gofront 1.8.0 → 1.9.1

package/stdlib/bytes/iter.go

@@ -1,192 +0,0 @@
-//go:build gofront
-
-//gofront:target both
-
-// Overlay on the emitter-backed bytes package: the sequence members of
-// Go 1.24 are written in Go over iter.Seq and merged into the bytes
-// namespace.  Like Go's, the slices they yield alias the input and have their
-// capacity clipped, so appending to one does not write into the original.
-package bytes
-
-import (
-	"iter"
-	"unicode"
-)
-
-const (
-	runeError = 0xFFFD
-	runeSelf  = 0x80
-)
-
-// decodeRune unpacks the first UTF-8 encoding in p and returns the rune and
-// its width in bytes, as utf8.DecodeRune does: an invalid or incomplete
-// encoding is (RuneError, 1) and p must not be empty.
-func decodeRune(p []byte) (rune, int) {
-	b0 := int(p[0])
-	if b0 < runeSelf {
-		return rune(b0), 1
-	}
-	n, lo, mask := 0, 0, 0
-	if b0 >= 0xC2 && b0 <= 0xDF {
-		n, lo, mask = 2, 0x80, 0x1F
-	} else if b0 >= 0xE0 && b0 <= 0xEF {
-		n, lo, mask = 3, 0x800, 0x0F
-	} else if b0 >= 0xF0 && b0 <= 0xF4 {
-		n, lo, mask = 4, 0x10000, 0x07
-	} else {
-		return runeError, 1
-	}
-	if len(p) < n {
-		return runeError, 1
-	}
-	r := b0 & mask
-	for i := 1; i < n; i++ {
-		b := int(p[i])
-		if b&0xC0 != 0x80 {
-			return runeError, 1
-		}
-		r = r<<6 | b&0x3F
-	}
-	if r < lo || r > 0x10FFFF || (r >= 0xD800 && r <= 0xDFFF) {
-		return runeError, 1
-	}
-	return rune(r), n
-}
-
-// index returns the byte offset of the first instance of sep in s, or -1.
-// It compares bytes: the emitter's bytes.Index goes through a decoded JS
-// string on the JS backend and so counts characters, not bytes, once s holds
-// multi-byte text.  sep must not be empty.
-func index(s, sep []byte) int {
-	first := sep[0]
-	for i := 0; i+len(sep) <= len(s); i++ {
-		if s[i] != first {
-			continue
-		}
-		j := 1
-		for j < len(sep) && s[i+j] == sep[j] {
-			j++
-		}
-		if j == len(sep) {
-			return i
-		}
-	}
-	return -1
-}
-
-// 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))
-}
-
-// Lines returns an iterator over the newline-terminated lines in the byte slice 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.
-// The iterator yields slices of the original slice s.
-func Lines(s []byte) iter.Seq[[]byte] {
-	return func(yield func([]byte) bool) {
-		for len(s) > 0 {
-			var line []byte
-			if i := IndexByte(s, '\n'); i >= 0 {
-				line, s = s[:i+1:i+1], s[i+1:]
-			} else {
-				line, s = s[:len(s):len(s)], nil
-			}
-			if !yield(line) {
-				return
-			}
-		}
-	}
-}
-
-// explodeSeq returns an iterator over the UTF-8 encodings of the runes in s.
-func explodeSeq(s []byte) iter.Seq[[]byte] {
-	return func(yield func([]byte) bool) {
-		for len(s) > 0 {
-			_, size := decodeRune(s)
-			if !yield(s[:size:size]) {
-				return
-			}
-			s = s[size:]
-		}
-	}
-}
-
-// splitSeq is SplitSeq or SplitAfterSeq, configured by how many
-// bytes of sep to include in the results (none or all).
-func splitSeq(s, sep []byte, sepSave int) iter.Seq[[]byte] {
-	if len(sep) == 0 {
-		return explodeSeq(s)
-	}
-	return func(yield func([]byte) bool) {
-		for {
-			i := index(s, sep)
-			if i < 0 {
-				break
-			}
-			frag := s[:i+sepSave]
-			if !yield(frag[:len(frag):len(frag)]) {
-				return
-			}
-			s = s[i+len(sep):]
-		}
-		yield(s[:len(s):len(s)])
-	}
-}
-
-// SplitSeq returns an iterator over subslices of s split around sep.
-// The iterator yields the same subslices that would be returned by Split(s, sep),
-// but without constructing the slice.
-// It returns a single-use iterator.
-func SplitSeq(s, sep []byte) iter.Seq[[]byte] {
-	return splitSeq(s, sep, 0)
-}
-
-// SplitAfterSeq returns an iterator over subslices of s split after each instance of sep.
-// The iterator yields the same subslices that would be returned by SplitAfter(s, sep),
-// but without constructing the slice.
-// It returns a single-use iterator.
-func SplitAfterSeq(s, sep []byte) iter.Seq[[]byte] {
-	return splitSeq(s, sep, len(sep))
-}
-
-// FieldsSeq returns an iterator over subslices of s split around runs of
-// whitespace characters, as defined by unicode.IsSpace.
-// The iterator yields the same subslices that would be returned by Fields(s),
-// but without constructing the slice.
-func FieldsSeq(s []byte) iter.Seq[[]byte] {
-	return FieldsFuncSeq(s, isSpace)
-}
-
-// FieldsFuncSeq returns an iterator over subslices of s split around runs of
-// Unicode code points satisfying f(c).
-// The iterator yields the same subslices that would be returned by FieldsFunc(s),
-// but without constructing the slice.
-func FieldsFuncSeq(s []byte, f func(rune) bool) iter.Seq[[]byte] {
-	return func(yield func([]byte) bool) {
-		start := -1
-		for i := 0; i < len(s); {
-			size := 1
-			r := rune(s[i])
-			if r >= runeSelf {
-				r, size = decodeRune(s[i:])
-			}
-			if f(r) {
-				if start >= 0 {
-					if !yield(s[start:i:i]) {
-						return
-					}
-					start = -1
-				}
-			} else if start < 0 {
-				start = i
-			}
-			i += size
-		}
-		if start >= 0 {
-			yield(s[start:len(s):len(s)])
-		}
-	}
-}

package/stdlib/bytes/search.go

@@ -1,240 +0,0 @@
-//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

@@ -1,218 +0,0 @@
-//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/errors/overlay.go

@@ -1,12 +0,0 @@
-//go:build gofront
-
-//gofront:target both
-
-// Overlay on the emitter-backed errors package: these members are written
-// in Go and merged into the errors namespace. Unqualified references to
-// emitter members (New) resolve to the emitter implementation.
-package errors
-
-// ErrUnsupported indicates that a requested operation cannot be performed,
-// because it is unsupported.
-var ErrUnsupported = New("unsupported operation")