gofront 1.7.0 → 1.8.0

package/stdlib/bytes/search.go

@@ -0,0 +1,240 @@
+//go:build gofront
+
+//gofront:target both
+
+// Overlay on the emitter-backed bytes package: search and comparison members
+// written in Go and merged into the bytes namespace.  They work on byte
+// offsets and decode UTF-8 as Go does, so an invalid sequence reads as
+// (RuneError, 1).
+package bytes
+
+import "unicode"
+
+// decodeLastRune unpacks the last UTF-8 encoding in p and returns the rune and
+// its width in bytes, as utf8.DecodeLastRune does: an invalid or incomplete
+// encoding is (RuneError, 1) and p must not be empty.
+func decodeLastRune(p []byte) (rune, int) {
+	end := len(p)
+	r := rune(p[end-1])
+	if r < runeSelf {
+		return r, 1
+	}
+	start := end - 1
+	lim := end - 4
+	if lim < 0 {
+		lim = 0
+	}
+	for start--; start >= lim; start-- {
+		if p[start]&0xC0 != 0x80 {
+			break
+		}
+	}
+	if start < 0 {
+		start = 0
+	}
+	r, size := decodeRune(p[start:end])
+	if start+size != end {
+		return runeError, 1
+	}
+	return r, size
+}
+
+// Compare returns an integer comparing two byte slices lexicographically.
+// The result will be 0 if a == b, -1 if a < b, and +1 if a > b.
+// A nil argument is equivalent to an empty slice.
+func Compare(a, b []byte) int {
+	n := len(a)
+	if len(b) < n {
+		n = len(b)
+	}
+	for i := 0; i < n; i++ {
+		if a[i] != b[i] {
+			if a[i] < b[i] {
+				return -1
+			}
+			return 1
+		}
+	}
+	if len(a) < len(b) {
+		return -1
+	}
+	if len(a) > len(b) {
+		return 1
+	}
+	return 0
+}
+
+// EqualFold reports whether s and t, interpreted as UTF-8 strings,
+// are equal under simple Unicode case-folding, which is a more general
+// form of case-insensitivity.
+func EqualFold(s, t []byte) bool {
+	for len(s) != 0 && len(t) != 0 {
+		var sr, tr rune
+		if s[0] < runeSelf {
+			sr, s = rune(s[0]), s[1:]
+		} else {
+			r, size := decodeRune(s)
+			sr, s = r, s[size:]
+		}
+		if t[0] < runeSelf {
+			tr, t = rune(t[0]), t[1:]
+		} else {
+			r, size := decodeRune(t)
+			tr, t = r, t[size:]
+		}
+		if tr == sr {
+			continue
+		}
+		if tr < sr {
+			tr, sr = sr, tr
+		}
+		if tr < runeSelf {
+			if 'A' <= sr && sr <= 'Z' && tr == sr+'a'-'A' {
+				continue
+			}
+			return false
+		}
+		r := unicode.SimpleFold(sr)
+		for r != sr && r < tr {
+			r = unicode.SimpleFold(r)
+		}
+		if r == tr {
+			continue
+		}
+		return false
+	}
+	return len(s) == len(t)
+}
+
+// IndexRune interprets s as a sequence of UTF-8-encoded code points.
+// It returns the byte index of the first occurrence in s of the given rune.
+// It returns -1 if rune is not present in s.
+// If r is utf8.RuneError, it returns the first instance of any
+// invalid UTF-8 byte sequence.
+func IndexRune(s []byte, r rune) int {
+	if r < 0 || r > 0x10FFFF || (r >= 0xD800 && r <= 0xDFFF) {
+		return -1
+	}
+	if r < runeSelf {
+		return IndexByte(s, int(r))
+	}
+	for i := 0; i < len(s); {
+		c, size := decodeRune(s[i:])
+		if c == r {
+			return i
+		}
+		i += size
+	}
+	return -1
+}
+
+// containsRuneIn reports whether chars contains r, treating an invalid sequence
+// in chars as utf8.RuneError.
+func containsRuneIn(chars string, r rune) bool {
+	for _, c := range chars {
+		if c == r {
+			return true
+		}
+	}
+	return false
+}
+
+// IndexAny interprets s as a sequence of UTF-8-encoded Unicode code points.
+// It returns the byte index of the first occurrence in s of any of the Unicode
+// code points in chars. It returns -1 if chars is empty or if there is no code
+// point in common.
+func IndexAny(s []byte, chars string) int {
+	if len(chars) == 0 {
+		return -1
+	}
+	for i := 0; i < len(s); {
+		r, size := decodeRune(s[i:])
+		if containsRuneIn(chars, r) {
+			return i
+		}
+		i += size
+	}
+	return -1
+}
+
+// LastIndexAny interprets s as a sequence of UTF-8-encoded Unicode code
+// points. It returns the byte index of the last occurrence in s of any of
+// the Unicode code points in chars. It returns -1 if chars is empty or if
+// there is no code point in common.
+func LastIndexAny(s []byte, chars string) int {
+	if len(chars) == 0 {
+		return -1
+	}
+	for i := len(s); i > 0; {
+		r, size := decodeLastRune(s[:i])
+		i -= size
+		if containsRuneIn(chars, r) {
+			return i
+		}
+	}
+	return -1
+}
+
+func indexFunc(s []byte, f func(rune) bool, truth bool) int {
+	for i := 0; i < len(s); {
+		r, size := decodeRune(s[i:])
+		if f(r) == truth {
+			return i
+		}
+		i += size
+	}
+	return -1
+}
+
+func lastIndexFunc(s []byte, f func(rune) bool, truth bool) int {
+	for i := len(s); i > 0; {
+		r, size := decodeLastRune(s[:i])
+		i -= size
+		if f(r) == truth {
+			return i
+		}
+	}
+	return -1
+}
+
+// IndexFunc interprets s as a sequence of UTF-8-encoded code points.
+// It returns the byte index in s of the first Unicode
+// code point satisfying f(c), or -1 if none do.
+func IndexFunc(s []byte, f func(r rune) bool) int {
+	return indexFunc(s, f, true)
+}
+
+// LastIndexFunc interprets s as a sequence of UTF-8-encoded code points.
+// It returns the byte index in s of the last Unicode
+// code point satisfying f(c), or -1 if none do.
+func LastIndexFunc(s []byte, f func(r rune) bool) int {
+	return lastIndexFunc(s, f, true)
+}
+
+// ContainsFunc reports whether any of the UTF-8-encoded code points
+// in b satisfy f(c).
+func ContainsFunc(b []byte, f func(rune) bool) bool {
+	return indexFunc(b, f, true) >= 0
+}
+
+// CutPrefix returns s without the provided leading prefix byte slice
+// and reports whether it found the prefix.
+// If s doesn't start with prefix, CutPrefix returns s, false.
+// If prefix is the empty byte slice, CutPrefix returns s, true.
+func CutPrefix(s, prefix []byte) (after []byte, found bool) {
+	if len(s) < len(prefix) || Compare(s[:len(prefix)], prefix) != 0 {
+		return s, false
+	}
+	return s[len(prefix):], true
+}
+
+// CutSuffix returns s without the provided ending suffix byte slice
+// and reports whether it found the suffix.
+// If s doesn't end with suffix, CutSuffix returns s, false.
+// If suffix is the empty byte slice, CutSuffix returns s, true.
+func CutSuffix(s, suffix []byte) (before []byte, found bool) {
+	if len(s) < len(suffix) || Compare(s[len(s)-len(suffix):], suffix) != 0 {
+		return s, false
+	}
+	return s[:len(s)-len(suffix)], true
+}

package/stdlib/bytes/split.go

@@ -0,0 +1,218 @@
+//go:build gofront
+
+//gofront:target both
+
+// Overlay on the emitter-backed bytes package: splitting, trimming and
+// case members written in Go and merged into the bytes namespace.  Like Go's,
+// the slices SplitAfter and SplitAfterN return alias the input and have their
+// capacity clipped.
+package bytes
+
+import (
+	"errors"
+	"unicode"
+)
+
+// MinRead is the minimum slice size passed to a Read call by
+// Buffer.ReadFrom. As long as the Buffer has at least MinRead bytes beyond
+// what is required to hold the contents of r, ReadFrom will not grow the
+// underlying buffer.
+const MinRead = 512
+
+// ErrTooLarge is passed to panic if memory cannot be allocated to store data in a buffer.
+var ErrTooLarge = errors.New("bytes.Buffer: too large")
+
+// runeCount returns the number of runes in p, counting each invalid byte as
+// one rune as utf8.RuneCount does.
+func runeCount(p []byte) int {
+	n := 0
+	for i := 0; i < len(p); n++ {
+		_, size := decodeRune(p[i:])
+		i += size
+	}
+	return n
+}
+
+// countSep counts the non-overlapping instances of sep in s; sep must not be
+// empty.
+func countSep(s, sep []byte) int {
+	n := 0
+	for {
+		i := index(s, sep)
+		if i < 0 {
+			return n
+		}
+		n++
+		s = s[i+len(sep):]
+	}
+}
+
+// explode splits s into a slice of UTF-8 sequences, one per Unicode code point
+// (still slices of bytes), up to a maximum of n byte slices. Invalid UTF-8
+// sequences are chopped into individual bytes.
+func explode(s []byte, n int) [][]byte {
+	l := runeCount(s)
+	if n < 0 || n > l {
+		n = l
+	}
+	a := make([][]byte, n)
+	for i := 0; i < n-1; i++ {
+		_, size := decodeRune(s)
+		a[i] = s[:size:size]
+		s = s[size:]
+	}
+	if n > 0 {
+		a[n-1] = s[:len(s):len(s)]
+	}
+	return a
+}
+
+// genSplit splits s around sep, including sepSave bytes of sep in each
+// subslice, into at most n subslices.
+func genSplit(s, sep []byte, sepSave, n int) [][]byte {
+	if n == 0 {
+		return nil
+	}
+	if len(sep) == 0 {
+		return explode(s, n)
+	}
+	if n < 0 {
+		n = countSep(s, sep) + 1
+	}
+	if n > len(s)+1 {
+		n = len(s) + 1
+	}
+	a := make([][]byte, n)
+	n--
+	i := 0
+	for i < n {
+		m := index(s, sep)
+		if m < 0 {
+			break
+		}
+		a[i] = s[: m+sepSave : m+sepSave]
+		s = s[m+len(sep):]
+		i++
+	}
+	a[i] = s[:len(s):len(s)]
+	return a[:i+1]
+}
+
+// SplitAfter slices s into all subslices after each instance of sep and
+// returns a slice of those subslices.
+// If sep is empty, SplitAfter splits after each UTF-8 sequence.
+// It is equivalent to SplitAfterN with a count of -1.
+func SplitAfter(s, sep []byte) [][]byte {
+	return genSplit(s, sep, len(sep), -1)
+}
+
+// SplitAfterN slices s into subslices after each instance of sep and
+// returns a slice of those subslices.
+// The count determines the number of subslices to return:
+//   - n > 0: at most n subslices; the last subslice will be the unsplit remainder;
+//   - n == 0: the result is nil (zero subslices);
+//   - n < 0: all subslices.
+func SplitAfterN(s, sep []byte, n int) [][]byte {
+	return genSplit(s, sep, len(sep), n)
+}
+
+// Runes interprets s as a sequence of UTF-8-encoded code points.
+// It returns a slice of runes (Unicode code points) equivalent to s.
+func Runes(s []byte) []rune {
+	t := make([]rune, runeCount(s))
+	i := 0
+	for len(s) > 0 {
+		r, l := decodeRune(s)
+		t[i] = r
+		i++
+		s = s[l:]
+	}
+	return t
+}
+
+// isSeparator reports whether the rune could mark a word boundary.
+func isSeparator(r rune) bool {
+	if r <= 0x7F {
+		switch {
+		case '0' <= r && r <= '9':
+			return false
+		case 'a' <= r && r <= 'z':
+			return false
+		case 'A' <= r && r <= 'Z':
+			return false
+		case r == '_':
+			return false
+		}
+		return true
+	}
+	if unicode.IsLetter(int(r)) || unicode.IsDigit(int(r)) {
+		return false
+	}
+	return unicode.IsSpace(int(r))
+}
+
+// appendRune appends the UTF-8 encoding of r to p, writing RuneError for a
+// value that is not a valid code point.
+// The continuation bytes mask a byte(r>>n) rather than r>>n: the JS backend
+// drops the parentheses around a wrapped int32 shift in `x | r>>n&m`.
+func appendRune(p []byte, r rune) []byte {
+	switch {
+	case r < 0 || r > 0x10FFFF || (r >= 0xD800 && r <= 0xDFFF):
+		r = runeError
+	case r < 0x80:
+		return append(p, byte(r))
+	}
+	switch {
+	case r < 0x800:
+		return append(p, byte(0xC0|r>>6), byte(0x80|r&0x3F))
+	case r < 0x10000:
+		return append(p, byte(0xE0|r>>12), 0x80|byte(r>>6)&0x3F, byte(0x80|r&0x3F))
+	}
+	return append(p, byte(0xF0|r>>18), 0x80|byte(r>>12)&0x3F, 0x80|byte(r>>6)&0x3F, byte(0x80|r&0x3F))
+}
+
+// Title treats s as UTF-8-encoded bytes and returns a copy with all Unicode
+// letters that begin words mapped to their title case.
+//
+// Deprecated: The rule Title uses for word boundaries does not handle Unicode
+// punctuation properly.
+func Title(s []byte) []byte {
+	prev := rune(' ')
+	out := make([]byte, 0, len(s))
+	for i := 0; i < len(s); {
+		r, size := decodeRune(s[i:])
+		i += size
+		c := r
+		if isSeparator(prev) {
+			c = unicode.ToTitle(r)
+		}
+		prev = r
+		if c >= 0 {
+			out = appendRune(out, c)
+		}
+	}
+	return out
+}
+
+// TrimLeftFunc treats s as UTF-8-encoded bytes and returns a subslice of s by slicing off
+// all leading UTF-8-encoded code points c that satisfy f(c).
+func TrimLeftFunc(s []byte, f func(r rune) bool) []byte {
+	i := indexFunc(s, f, false)
+	if i == -1 {
+		return nil
+	}
+	return s[i:]
+}
+
+// TrimRightFunc returns a subslice of s by slicing off all trailing
+// UTF-8-encoded code points c that satisfy f(c).
+func TrimRightFunc(s []byte, f func(r rune) bool) []byte {
+	i := lastIndexFunc(s, f, false)
+	if i >= 0 && s[i] >= runeSelf {
+		_, wid := decodeRune(s[i:])
+		i += wid
+	} else {
+		i++
+	}
+	return s[0:i]
+}

package/stdlib/cmp/cmp.go

@@ -0,0 +1,65 @@
+//go:build gofront
+
+//gofront:target both
+
+// Package cmp provides types and functions related to comparing ordered
+// values. Same API as Go's cmp package.
+package cmp
+
+// Ordered is a constraint that permits any ordered type: any type that
+// supports the operators < <= >= >.
+type Ordered interface {
+	~int | ~int8 | ~int16 | ~int32 | ~int64 |
+		~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
+		~float32 | ~float64 |
+		~string
+}
+
+// Less reports whether x is less than y. A NaN is less than any non-NaN,
+// and -0.0 is not less than 0.0.
+func Less[T Ordered](x, y T) bool {
+	return (isNaNValue(x) && !isNaNValue(y)) || x < y
+}
+
+// Compare returns -1 if x is less than y, 0 if x equals y, and +1 if x is
+// greater than y. A NaN is less than any non-NaN, a NaN equals a NaN, and
+// -0.0 equals 0.0.
+func Compare[T Ordered](x, y T) int {
+	xNaN := isNaNValue(x)
+	yNaN := isNaNValue(y)
+	if xNaN {
+		if yNaN {
+			return 0
+		}
+		return -1
+	}
+	if yNaN {
+		return +1
+	}
+	if x < y {
+		return -1
+	}
+	if x > y {
+		return +1
+	}
+	return 0
+}
+
+// isNaNValue reports whether x is a NaN without requiring the math package
+// (named so it does not collide with the browser global isNaN until Task 0.9).
+// This will always return false if T is not floating-point.
+func isNaNValue[T Ordered](x T) bool {
+	return x != x
+}
+
+// Or returns the first of its arguments that is not equal to the zero
+// value. If no argument is non-zero, it returns the zero value.
+func Or[T comparable](vals ...T) T {
+	var zero T
+	for _, v := range vals {
+		if v != zero {
+			return v
+		}
+	}
+	return zero
+}

package/stdlib/encoding/json/errors.go

@@ -0,0 +1,31 @@
+//go:build gofront
+
+//gofront:target both
+
+package json
+
+import (
+	"internal/jsonrt"
+)
+
+// A SyntaxError is a description of a JSON syntax error.
+// [Unmarshal] will return a SyntaxError if the JSON can't be parsed.
+type SyntaxError = jsonrt.SyntaxError
+
+// An UnmarshalTypeError describes a JSON value that was not appropriate for
+// a value of a specific Go type.
+type UnmarshalTypeError = jsonrt.UnmarshalTypeError
+
+// An InvalidUnmarshalError describes an invalid argument passed to Unmarshal.
+type InvalidUnmarshalError = jsonrt.InvalidUnmarshalError
+
+// An UnsupportedValueError is returned by Marshal when attempting to encode
+// an unsupported value.
+type UnsupportedValueError = jsonrt.UnsupportedValueError
+
+// UnsupportedTypeError is returned by Marshal when attempting to encode an
+// unsupported value type.
+type UnsupportedTypeError = jsonrt.UnsupportedTypeError
+
+// A MarshalerError represents an error from calling a MarshalJSON method.
+type MarshalerError = jsonrt.MarshalerError

package/stdlib/encoding/json/indent.go

@@ -0,0 +1,71 @@
+//go:build gofront
+
+//gofront:target both
+
+package json
+
+import (
+	"bytes"
+	"internal/jsonrt"
+)
+
+var hexDigits = []byte("0123456789abcdef")
+
+func escapeLen(src []byte, i int) int {
+	c := src[i]
+	if c == '<' || c == '>' || c == '&' {
+		return 1
+	}
+	if c == 0xE2 && i+2 < len(src) && src[i+1] == 0x80 && (src[i+2]&^1) == 0xA8 {
+		return 3
+	}
+	return 0
+}
+
+// HTMLEscape appends to dst the JSON-encoded src with <, >, &, U+2028 and U+2029
+// characters inside string literals changed to \u003c, \u003e, \u0026, \u2028, \u2029
+// so that the JSON will be safe to embed inside HTML <script> tags.
+func HTMLEscape(dst *bytes.Buffer, src []byte) {
+	start := 0
+	for i := 0; i < len(src); {
+		n := escapeLen(src, i)
+		if n == 0 {
+			i++
+			continue
+		}
+		if start < i {
+			dst.Write(src[start:i])
+		}
+		if n == 1 {
+			c := src[i]
+			dst.Write([]byte{'\\', 'u', '0', '0', hexDigits[c>>4], hexDigits[c&0xF]})
+			i++
+		} else {
+			dst.Write([]byte{'\\', 'u', '2', '0', '2', hexDigits[src[i+2]&0xF]})
+			i += 3
+		}
+		start = i
+	}
+	if start < len(src) {
+		dst.Write(src[start:])
+	}
+}
+
+// Compact appends to dst the JSON-encoded src with
+// insignificant space characters elided.
+func Compact(dst *bytes.Buffer, src []byte) error {
+	b, err := jsonrt.AppendCompact(nil, src, false)
+	if len(b) > 0 {
+		dst.Write(b)
+	}
+	return err
+}
+
+// Indent appends to dst an indented form of the JSON-encoded src.
+func Indent(dst *bytes.Buffer, src []byte, prefix, indent string) error {
+	b, err := jsonrt.AppendIndent(nil, src, prefix, indent)
+	if len(b) > 0 {
+		dst.Write(b)
+	}
+	return err
+}

package/stdlib/encoding/json/number.go

@@ -0,0 +1,12 @@
+//go:build gofront
+
+//gofront:target both
+
+package json
+
+import (
+	"internal/jsonrt"
+)
+
+// A Number represents a JSON number literal.
+type Number = jsonrt.Number