case OpLiteral:
		for _, r := range re.Rune {
			escape(b, r, false)
		}
	case OpCharClass:
		if len(re.Rune)%2 != 0 {
			b.WriteString(`[invalid char class]`)
			break
		}
		b.WriteRune('[')
		if len(re.Rune) == 0 {
			b.WriteString(`^\x00-\x{10FFFF}`)
		} else if re.Rune[0] == 0 && re.Rune[len(re.Rune)-1] == unicode.MaxRune && len(re.Rune) > 2 {
			// Contains 0 and MaxRune. Probably a negated class.

	return c
}

// IsBracket reports whether the rune is a bracket.
func (p Properties) IsBracket() bool { return p.entry&0xF0 != 0 }

// IsOpeningBracket reports whether the rune is an opening bracket.
// IsBracket must return true.
func (p Properties) IsOpeningBracket() bool { return p.entry&openMask != 0 }

// TODO: find a better API and expose.
func (p Properties) reverseBracket(r rune) rune {
	return xorMasks[p.entry>>xorMaskShift] ^ r
}

// license that can be found in the LICENSE file.

// Test case where a slice of a user-defined byte type (not uint8 or byte) is
// converted to a string.  Same for slice of runes.

package main

type MyByte byte

type MyRune rune

func f[T []MyByte](x T) string {
	return string(x)
}

func g[T []MyRune](x T) string {
	return string(x)
}

func main() {
	var y []MyByte
	_ = f(y)

//
//	q := strconv.Quote("Hello, 世界")
//	q := strconv.QuoteToASCII("Hello, 世界")
//
// [QuoteRune] and [QuoteRuneToASCII] are similar but accept runes and
// return quoted Go rune literals.
//
// [Unquote] and [UnquoteChar] unquote Go string and rune literals.

// license that can be found in the LICENSE file.

// Test case where a slice of a user-defined byte type (not uint8 or byte) is
// converted to a string.  Same for slice of runes.

package main

type MyByte byte

type MyRune rune

func main() {
	var y []MyByte
	_ = string(y)

	var z []MyRune
	_ = string(z)

	r = -1
	s = string(r)
	assert(s, "\xef\xbf\xbd", "negative rune")

	// the large rune tests again, this time using constants instead of a variable.
	// these conversions will be done at compile time.
	s = string(0x10ffff) // largest rune value
	assert(s, "\xf4\x8f\xbf\xbf", "largest rune constant")
	s = string(0x10ffff + 1)
	assert(s, "\xef\xbf\xbd", "too-large rune constant")
	s = string(0xD800)

	hicb = 0xBF // 1011 1111
)

// countrunes returns the number of runes in s.
func countrunes(s string) int {
	n := 0
	for range s {
		n++
	}
	return n
}

// decoderune returns the non-ASCII rune at the start of
// s[k:] and the index after the rune in s.
//
// decoderune assumes that caller has checked that
// the to be decoded rune is a non-ASCII rune.
//
// If the string appears to be incomplete or decoding problems

Jonh Wendell <******@****.***> 1715709579 -0400

Jonh Wendell <******@****.***> 1715709579 -0400

func Decode(s []uint16) []rune {
	// Preallocate capacity to hold up to 64 runes.
	// Decode inlines, so the allocation can live on the stack.
	buf := make([]rune, 0, 64)
	return decode(s, buf)
}

// decode appends to buf the Unicode code point sequence represented
// by the UTF-16 encoding s and return the extended buffer.
func decode(s []uint16, buf []rune) []rune {
	for i := 0; i < len(s); i++ {