gofront 1.6.1 → 1.8.0

package/stdlib/strconv/quote.go

@@ -0,0 +1,341 @@
+//go:build gofront
+
+//gofront:target both
+
+package strconv
+
+import (
+	"unicode"
+	"unicode/utf8"
+)
+
+// IntSize is the size in bits of an int or uint value.
+const IntSize = 64
+
+const lowerhex = "0123456789abcdef"
+
+// A NumError records a failed conversion.
+type NumError struct {
+	Func string // the failing function (ParseBool, ParseInt, ParseUint, ParseFloat, ParseComplex)
+	Num  string // the input
+	Err  error  // the reason the conversion failed (e.g. ErrRange, ErrSyntax, etc.)
+}
+
+func (e *NumError) Error() string {
+	return "strconv." + e.Func + ": parsing " + Quote(e.Num) + ": " + e.Err.Error()
+}
+
+func (e *NumError) Unwrap() error { return e.Err }
+
+// IsPrint reports whether the rune is defined as printable by Go, with
+// the same definition as unicode.IsPrint: letters, numbers, punctuation,
+// symbols and ASCII space.
+func IsPrint(r rune) bool {
+	if 0x20 <= r && r <= 0x7E {
+		return true
+	}
+	return unicode.IsPrint(r)
+}
+
+// IsGraphic reports whether the rune is defined as a Graphic by Unicode.
+func IsGraphic(r rune) bool {
+	if 0x20 <= r && r <= 0x7E {
+		return true
+	}
+	return unicode.IsGraphic(r)
+}
+
+func quoteWith(s string, quote byte, ASCIIonly, graphicOnly bool) string {
+	return string(appendQuotedWith(make([]byte, 0, 3*len(s)/2), s, quote, ASCIIonly, graphicOnly))
+}
+
+func quoteRuneWith(r rune, quote byte, ASCIIonly, graphicOnly bool) string {
+	return string(appendQuotedRuneWith(nil, r, quote, ASCIIonly, graphicOnly))
+}
+
+func hexDigit(v int) byte {
+	return byte(lowerhex[v&0xF])
+}
+
+func appendQuotedWith(buf []byte, s string, quote byte, ASCIIonly, graphicOnly bool) []byte {
+	buf = append(buf, quote)
+	for len(s) > 0 {
+		r, width := utf8.DecodeRuneInString(s)
+		if width == 1 && r == utf8.RuneError {
+			b0 := int(byte(s[0]))
+			buf = append(buf, byte('\\'), byte('x'), hexDigit(b0>>4), hexDigit(b0))
+			s = s[1:]
+			continue
+		}
+		buf = appendEscapedRune(buf, r, quote, ASCIIonly, graphicOnly)
+		s = s[width:]
+	}
+	buf = append(buf, quote)
+	return buf
+}
+
+func appendQuotedRuneWith(buf []byte, r rune, quote byte, ASCIIonly, graphicOnly bool) []byte {
+	buf = append(buf, quote)
+	if !utf8.ValidRune(r) {
+		r = utf8.RuneError
+	}
+	buf = appendEscapedRune(buf, r, quote, ASCIIonly, graphicOnly)
+	buf = append(buf, quote)
+	return buf
+}
+
+func appendEscapedRune(buf []byte, r rune, quote byte, ASCIIonly, graphicOnly bool) []byte {
+	if r == rune(quote) || r == '\\' {
+		buf = append(buf, byte('\\'), byte(r))
+		return buf
+	}
+	if ASCIIonly {
+		if r < utf8.RuneSelf && IsPrint(r) {
+			buf = append(buf, byte(r))
+			return buf
+		}
+	} else if IsPrint(r) || (graphicOnly && IsGraphic(r)) {
+		return utf8.AppendRune(buf, r)
+	}
+	switch r {
+	case '\a':
+		buf = append(buf, byte('\\'), byte('a'))
+	case '\b':
+		buf = append(buf, byte('\\'), byte('b'))
+	case '\f':
+		buf = append(buf, byte('\\'), byte('f'))
+	case '\n':
+		buf = append(buf, byte('\\'), byte('n'))
+	case '\r':
+		buf = append(buf, byte('\\'), byte('r'))
+	case '\t':
+		buf = append(buf, byte('\\'), byte('t'))
+	case '\v':
+		buf = append(buf, byte('\\'), byte('v'))
+	default:
+		switch {
+		case r < ' ' || r == 0x7f:
+			br := int(r)
+			buf = append(buf, byte('\\'), byte('x'), hexDigit(br>>4), hexDigit(br))
+		case !utf8.ValidRune(r):
+			r = 0xFFFD
+			buf = append(buf, byte('\\'), byte('u'))
+			for s := 12; s >= 0; s -= 4 {
+				buf = append(buf, hexDigit(int(r>>uint(s))))
+			}
+		case r < 0x10000:
+			buf = append(buf, byte('\\'), byte('u'))
+			for s := 12; s >= 0; s -= 4 {
+				buf = append(buf, hexDigit(int(r>>uint(s))))
+			}
+		default:
+			buf = append(buf, byte('\\'), byte('U'))
+			for s := 28; s >= 0; s -= 4 {
+				buf = append(buf, hexDigit(int(r>>uint(s))))
+			}
+		}
+	}
+	return buf
+}
+
+// QuoteRune returns a single-quoted Go character literal representing the rune.
+func QuoteRune(r rune) string {
+	return quoteRuneWith(r, byte('\''), false, false)
+}
+
+// QuoteToASCII returns a double-quoted Go string literal representing s using ASCII escapes.
+func QuoteToASCII(s string) string {
+	return quoteWith(s, byte('"'), true, false)
+}
+
+// QuoteRuneToASCII returns a single-quoted Go character literal representing the rune using ASCII escapes.
+func QuoteRuneToASCII(r rune) string {
+	return quoteRuneWith(r, byte('\''), true, false)
+}
+
+// AppendQuote appends a double-quoted Go string literal representing s to dst.
+func AppendQuote(dst []byte, s string) []byte {
+	return appendQuotedWith(dst, s, byte('"'), false, false)
+}
+
+// AppendQuoteToASCII appends a double-quoted Go string literal representing s using ASCII escapes to dst.
+func AppendQuoteToASCII(dst []byte, s string) []byte {
+	return appendQuotedWith(dst, s, byte('"'), true, false)
+}
+
+// AppendQuoteRune appends a single-quoted Go character literal representing the rune to dst.
+func AppendQuoteRune(dst []byte, r rune) []byte {
+	return appendQuotedRuneWith(dst, r, byte('\''), false, false)
+}
+
+// AppendQuoteRuneToASCII appends a single-quoted Go character literal representing the rune using ASCII escapes to dst.
+func AppendQuoteRuneToASCII(dst []byte, r rune) []byte {
+	return appendQuotedRuneWith(dst, r, byte('\''), true, false)
+}
+
+// CanBackquote reports whether the string s can be represented unchanged as a single-line backquoted string.
+func CanBackquote(s string) bool {
+	for len(s) > 0 {
+		r, wid := utf8.DecodeRuneInString(s)
+		s = s[wid:]
+		if wid > 1 {
+			if r == '\ufeff' {
+				return false
+			}
+			continue
+		}
+		if r == utf8.RuneError {
+			return false
+		}
+		if (r < ' ' && r != '\t') || r == '`' || r == '\u007F' {
+			return false
+		}
+	}
+	return true
+}
+
+func unhex(b byte) (rune, bool) {
+	switch {
+	case byte('0') <= b && b <= byte('9'):
+		return rune(b - byte('0')), true
+	case byte('a') <= b && b <= byte('f'):
+		return rune(b - byte('a') + 10), true
+	case byte('A') <= b && b <= byte('F'):
+		return rune(b - byte('A') + 10), true
+	}
+	return 0, false
+}
+
+func unquoteHex(c byte, s string) (rune, bool, string, error) {
+	n := 0
+	switch c {
+	case byte('x'):
+		n = 2
+	case byte('u'):
+		n = 4
+	case byte('U'):
+		n = 8
+	}
+	if len(s) < n {
+		return 0, false, "", ErrSyntax
+	}
+	var v rune
+	for j := 0; j < n; j++ {
+		x, ok := unhex(byte(s[j]))
+		if !ok {
+			return 0, false, "", ErrSyntax
+		}
+		v = v<<4 | x
+	}
+	s = s[n:]
+	if c == byte('x') {
+		return v, false, s, nil
+	}
+	if !utf8.ValidRune(v) {
+		return 0, false, "", ErrSyntax
+	}
+	return v, true, s, nil
+}
+
+func unquoteOctal(c byte, s string) (rune, string, error) {
+	v := rune(c - byte('0'))
+	if len(s) < 2 {
+		return 0, "", ErrSyntax
+	}
+	for j := 0; j < 2; j++ {
+		b := byte(s[j])
+		if b < byte('0') || b > byte('7') {
+			return 0, "", ErrSyntax
+		}
+		v = (v << 3) | rune(b-byte('0'))
+	}
+	if v > 255 {
+		return 0, "", ErrSyntax
+	}
+	return v, s[2:], nil
+}
+
+// UnquoteChar decodes the first character or byte in the escaped string or character literal represented by s.
+func UnquoteChar(s string, quote byte) (value rune, multibyte bool, tail string, err error) {
+	if len(s) == 0 {
+		return 0, false, "", ErrSyntax
+	}
+	c := byte(s[0])
+	if c == quote && (quote == byte('\'') || quote == byte('"')) {
+		return 0, false, "", ErrSyntax
+	}
+	if rune(c) >= utf8.RuneSelf {
+		r, size := utf8.DecodeRuneInString(s)
+		return r, true, s[size:], nil
+	}
+	if c != byte('\\') {
+		return rune(c), false, s[1:], nil
+	}
+	if len(s) <= 1 {
+		return 0, false, "", ErrSyntax
+	}
+	esc := byte(s[1])
+	s = s[2:]
+	switch esc {
+	case byte('a'):
+		return '\a', false, s, nil
+	case byte('b'):
+		return '\b', false, s, nil
+	case byte('f'):
+		return '\f', false, s, nil
+	case byte('n'):
+		return '\n', false, s, nil
+	case byte('r'):
+		return '\r', false, s, nil
+	case byte('t'):
+		return '\t', false, s, nil
+	case byte('v'):
+		return '\v', false, s, nil
+	case byte('x'), byte('u'), byte('U'):
+		v, mb, rem, err := unquoteHex(esc, s)
+		return v, mb, rem, err
+	case byte('0'), byte('1'), byte('2'), byte('3'), byte('4'), byte('5'), byte('6'), byte('7'):
+		v, rem, err := unquoteOctal(esc, s)
+		return v, false, rem, err
+	case byte('\\'):
+		return '\\', false, s, nil
+	case byte('\''), byte('"'):
+		if esc != quote {
+			return 0, false, "", ErrSyntax
+		}
+		return rune(esc), false, s, nil
+	default:
+		return 0, false, "", ErrSyntax
+	}
+}
+
+// QuotedPrefix returns the quoted string at the prefix of s.
+func QuotedPrefix(s string) (string, error) {
+	if len(s) < 2 {
+		return "", ErrSyntax
+	}
+	quote := byte(s[0])
+	if quote != byte('"') && quote != byte('\'') && quote != byte('`') {
+		return "", ErrSyntax
+	}
+	if quote == byte('`') {
+		for i := 1; i < len(s); i++ {
+			if byte(s[i]) == byte('`') {
+				return s[:i+1], nil
+			}
+		}
+		return "", ErrSyntax
+	}
+	rem := s[1:]
+	for len(rem) > 0 {
+		if byte(rem[0]) == quote {
+			return s[:len(s)-len(rem)+1], nil
+		}
+		_, _, next, err := UnquoteChar(rem, quote)
+		if err != nil {
+			return "", err
+		}
+		rem = next
+	}
+	return "", ErrSyntax
+}

package/stdlib/strings/extra.go

@@ -0,0 +1,35 @@
+//go:build gofront
+
+//gofront:target both
+
+// Overlay on the emitter-backed strings package: small members written in Go
+// and merged into the strings namespace.
+package strings
+
+// Clone returns a fresh copy of s.  Strings are immutable values here, so
+// the copy is s itself.
+func Clone(s string) string {
+	return s
+}
+
+// Compare returns an integer comparing two strings lexicographically.
+// The result will be 0 if a == b, -1 if a < b, and +1 if a > b.
+func Compare(a, b string) int {
+	if a == b {
+		return 0
+	}
+	if a < b {
+		return -1
+	}
+	return +1
+}
+
+// ContainsFunc reports whether any Unicode code points in s satisfy f(c).
+func ContainsFunc(s string, f func(rune) bool) bool {
+	for _, r := range s {
+		if f(r) {
+			return true
+		}
+	}
+	return false
+}

package/stdlib/strings/iter.go

@@ -0,0 +1,122 @@
+//go:build gofront
+
+//gofront:target both
+
+// Overlay on the emitter-backed strings package: the sequence members of
+// Go 1.24 are written in Go over iter.Seq and merged into the strings
+// namespace.  Strings are JavaScript strings, so Index and slicing count the
+// same units and splitting at a substring is always consistent; the places
+// that need code points (an empty separator, Fields) go through []rune.
+package strings
+
+import (
+	"iter"
+	"unicode"
+)
+
+// Lines returns an iterator over the newline-terminated lines in the string s.
+// The lines yielded by the iterator include their terminating newlines.
+// If s is empty, the iterator yields no lines at all.
+// If s does not end in a newline, the final yielded line will not end in a newline.
+func Lines(s string) iter.Seq[string] {
+	return func(yield func(string) bool) {
+		for len(s) > 0 {
+			var line string
+			if i := IndexByte(s, '\n'); i >= 0 {
+				line, s = s[:i+1], s[i+1:]
+			} else {
+				line, s = s, ""
+			}
+			if !yield(line) {
+				return
+			}
+		}
+	}
+}
+
+// explodeSeq returns an iterator over the runes in s.
+func explodeSeq(s string) iter.Seq[string] {
+	return func(yield func(string) bool) {
+		for _, r := range []rune(s) {
+			if !yield(string(r)) {
+				return
+			}
+		}
+	}
+}
+
+// splitSeq is SplitSeq or SplitAfterSeq, configured by how many
+// bytes of sep to include in the results (none or all).
+func splitSeq(s, sep string, sepSave int) iter.Seq[string] {
+	if len(sep) == 0 {
+		return explodeSeq(s)
+	}
+	return func(yield func(string) bool) {
+		for {
+			i := Index(s, sep)
+			if i < 0 {
+				break
+			}
+			frag := s[:i+sepSave]
+			if !yield(frag) {
+				return
+			}
+			s = s[i+len(sep):]
+		}
+		yield(s)
+	}
+}
+
+// SplitSeq returns an iterator over substrings of s split by sep.
+// The iterator yields the same strings that would be returned by Split(s, sep),
+// but without constructing the slice.
+func SplitSeq(s, sep string) iter.Seq[string] {
+	return splitSeq(s, sep, 0)
+}
+
+// SplitAfterSeq returns an iterator over substrings of s split after each instance of sep.
+// The iterator yields the same strings that would be returned by SplitAfter(s, sep),
+// but without constructing the slice.
+func SplitAfterSeq(s, sep string) iter.Seq[string] {
+	return splitSeq(s, sep, len(sep))
+}
+
+// isSpace is unicode.IsSpace as a func(rune) bool (the checker types the
+// unicode predicates over int).
+func isSpace(r rune) bool {
+	return unicode.IsSpace(int(r))
+}
+
+// FieldsSeq returns an iterator over substrings of s split around runs of
+// whitespace characters, as defined by unicode.IsSpace.
+// The iterator yields the same strings that would be returned by Fields(s),
+// but without constructing the slice.
+func FieldsSeq(s string) iter.Seq[string] {
+	return FieldsFuncSeq(s, isSpace)
+}
+
+// FieldsFuncSeq returns an iterator over substrings of s split around runs of
+// Unicode code points satisfying f(c).
+// The iterator yields the same strings that would be returned by FieldsFunc(s),
+// but without constructing the slice.
+func FieldsFuncSeq(s string, f func(rune) bool) iter.Seq[string] {
+	return func(yield func(string) bool) {
+		runes := []rune(s)
+		start := -1
+		for i, r := range runes {
+			if f(r) {
+				if start >= 0 {
+					if !yield(string(runes[start:i])) {
+						return
+					}
+					start = -1
+				}
+			} else if start < 0 {
+				start = i
+			}
+		}
+		if start >= 0 {
+			yield(string(runes[start:]))
+		}
+	}
+}

package/stdlib/sync/extra.go

@@ -0,0 +1,105 @@
+//go:build gofront
+
+//gofront:target both
+
+// Overlay on the emitter-backed sync package: OnceFunc/OnceValue/OnceValues
+// and RWMutex.RLocker.
+package sync
+
+// OnceFunc returns a function that invokes f only once. The returned function
+// may be called concurrently.
+//
+// If f panics, the returned function will panic with the same value on every call.
+func OnceFunc(f func()) func() {
+	var (
+		once  Once
+		valid bool
+		p     any
+	)
+	return func() {
+		once.Do(func() {
+			defer func() {
+				p = recover()
+				if !valid {
+					panic(p)
+				}
+			}()
+			f()
+			valid = true
+		})
+		if !valid {
+			panic(p)
+		}
+	}
+}
+
+// OnceValue returns a function that invokes f only once and returns the value
+// returned by f. The returned function may be called concurrently.
+//
+// If f panics, the returned function will panic with the same value on every call.
+func OnceValue[T any](f func() T) func() T {
+	var (
+		once   Once
+		valid  bool
+		p      any
+		result T
+	)
+	return func() T {
+		once.Do(func() {
+			defer func() {
+				p = recover()
+				if !valid {
+					panic(p)
+				}
+			}()
+			result = f()
+			valid = true
+		})
+		if !valid {
+			panic(p)
+		}
+		return result
+	}
+}
+
+// OnceValues returns a function that invokes f only once and returns the values
+// returned by f. The returned function may be called concurrently.
+//
+// If f panics, the returned function will panic with the same value on every call.
+func OnceValues[T1, T2 any](f func() (T1, T2)) func() (T1, T2) {
+	var (
+		once  Once
+		valid bool
+		p     any
+		r1    T1
+		r2    T2
+	)
+	return func() (T1, T2) {
+		once.Do(func() {
+			defer func() {
+				p = recover()
+				if !valid {
+					panic(p)
+				}
+			}()
+			r1, r2 = f()
+			valid = true
+		})
+		if !valid {
+			panic(p)
+		}
+		return r1, r2
+	}
+}
+
+type rlocker struct {
+	rw *RWMutex
+}
+
+func (r *rlocker) Lock() {}
+
+func (r *rlocker) Unlock() {}
+
+func (rw *RWMutex) RLocker() Locker {
+	return &rlocker{rw: rw}
+}

package/stdlib/unicode/unicode.go

@@ -0,0 +1,112 @@
+//go:build gofront
+
+//gofront:target both
+
+package unicode
+
+const (
+	MaxRune         = '\U0010FFFF' // Maximum valid Unicode code point.
+	ReplacementChar = '\uFFFD'     // Represents invalid code points.
+	MaxASCII        = '\u007F'     // maximum ASCII value.
+	MaxLatin1       = '\u00FF'     // maximum Latin-1 value.
+	UpperLower      = MaxRune + 1
+	Version         = "15.0.0"
+)
+
+// ToTitle maps the rune to title case.
+func ToTitle(r rune) rune {
+	if r <= MaxASCII {
+		if 'a' <= r && r <= 'z' {
+			return r - ('a' - 'A')
+		}
+		return r
+	}
+	switch r {
+	case 0x1C4, 0x1C5, 0x1C6:
+		return 0x1C5
+	case 0x1C7, 0x1C8, 0x1C9:
+		return 0x1C8
+	case 0x1CA, 0x1CB, 0x1CC:
+		return 0x1CB
+	case 0x1F1, 0x1F2, 0x1F3:
+		return 0x1F2
+	}
+	if 0x10D0 <= r && r <= 0x10FF {
+		return r
+	}
+	return rune(ToUpper(int(r)))
+}
+
+type foldPair struct {
+	From uint16
+	To   uint16
+}
+
+var caseOrbit = []foldPair{
+	{0x004B, 0x006B}, {0x0053, 0x0073}, {0x006B, 0x212A}, {0x0073, 0x017F},
+	{0x00B5, 0x039C}, {0x00C5, 0x00E5}, {0x00DF, 0x1E9E}, {0x00E5, 0x212B},
+	{0x0130, 0x0130}, {0x0131, 0x0131}, {0x017F, 0x0053}, {0x01C4, 0x01C5},
+	{0x01C5, 0x01C6}, {0x01C6, 0x01C4}, {0x01C7, 0x01C8}, {0x01C8, 0x01C9},
+	{0x01C9, 0x01C7}, {0x01CA, 0x01CB}, {0x01CB, 0x01CC}, {0x01CC, 0x01CA},
+	{0x01F1, 0x01F2}, {0x01F2, 0x01F3}, {0x01F3, 0x01F1}, {0x0345, 0x0399},
+	{0x0392, 0x03B2}, {0x0395, 0x03B5}, {0x0398, 0x03B8}, {0x0399, 0x03B9},
+	{0x039A, 0x03BA}, {0x039C, 0x03BC}, {0x03A0, 0x03C0}, {0x03A1, 0x03C1},
+	{0x03A3, 0x03C2}, {0x03A6, 0x03C6}, {0x03A9, 0x03C9}, {0x03B2, 0x03D0},
+	{0x03B5, 0x03F5}, {0x03B8, 0x03D1}, {0x03B9, 0x1FBE}, {0x03BA, 0x03F0},
+	{0x03BC, 0x00B5}, {0x03C0, 0x03D6}, {0x03C1, 0x03F1}, {0x03C2, 0x03C3},
+	{0x03C3, 0x03A3}, {0x03C6, 0x03D5}, {0x03C9, 0x2126}, {0x03D0, 0x0392},
+	{0x03D1, 0x03F4}, {0x03D5, 0x03A6}, {0x03D6, 0x03A0}, {0x03F0, 0x039A},
+	{0x03F1, 0x03A1}, {0x03F4, 0x0398}, {0x03F5, 0x0395}, {0x0412, 0x0432},
+	{0x0414, 0x0434}, {0x041E, 0x043E}, {0x0421, 0x0441}, {0x0422, 0x0442},
+	{0x042A, 0x044A}, {0x0432, 0x1C80}, {0x0434, 0x1C81}, {0x043E, 0x1C82},
+	{0x0441, 0x1C83}, {0x0442, 0x1C84}, {0x044A, 0x1C86}, {0x0462, 0x0463},
+	{0x0463, 0x1C87}, {0x1C80, 0x0412}, {0x1C81, 0x0414}, {0x1C82, 0x041E},
+	{0x1C83, 0x0421}, {0x1C84, 0x1C85}, {0x1C85, 0x0422}, {0x1C86, 0x042A},
+	{0x1C87, 0x0462}, {0x1C88, 0xA64A}, {0x1E60, 0x1E61}, {0x1E61, 0x1E9B},
+	{0x1E9B, 0x1E60}, {0x1E9E, 0x00DF}, {0x1FBE, 0x0345}, {0x2126, 0x03A9},
+	{0x212A, 0x004B}, {0x212B, 0x00C5}, {0xA64A, 0xA64B}, {0xA64B, 0x1C88},
+}
+
+func foldASCII(r rune) (rune, bool) {
+	if 'a' <= r && r <= 'z' {
+		if r != 'k' && r != 's' {
+			return r - ('a' - 'A'), true
+		}
+	} else if 'A' <= r && r <= 'Z' {
+		if r != 'K' && r != 'S' {
+			return r + ('a' - 'A'), true
+		}
+	} else {
+		return r, true
+	}
+	return r, false
+}
+
+// SimpleFold iterates over Unicode code points equivalent under simple case folding.
+func SimpleFold(r rune) rune {
+	if r < 0 || r > MaxRune {
+		return r
+	}
+	if r < 128 {
+		if folded, ok := foldASCII(r); ok {
+			return folded
+		}
+	}
+	lo := 0
+	hi := len(caseOrbit)
+	for lo < hi {
+		m := int(uint(lo+hi) >> 1)
+		if rune(caseOrbit[m].From) < r {
+			lo = m + 1
+		} else {
+			hi = m
+		}
+	}
+	if lo < len(caseOrbit) && rune(caseOrbit[lo].From) == r {
+		return rune(caseOrbit[lo].To)
+	}
+	if l := rune(ToLower(int(r))); l != r {
+		return l
+	}
+	return rune(ToUpper(int(r)))
+}