gofront 1.8.0 → 1.9.0

package/stdlib/path/path.go

@@ -0,0 +1,394 @@
+//go:build gofront
+
+//gofront:target both
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package path implements utility routines for manipulating slash-separated
+// paths.
+//
+// The path package should only be used for paths separated by forward
+// slashes, such as the paths in URLs. This package does not deal with
+// Windows paths with drive letters or backslashes; to manipulate
+// operating system paths, use the [path/filepath] package.
+package path
+
+import (
+	"errors"
+	"unicode/utf8"
+)
+
+// Clean returns the shortest path name equivalent to path
+// by purely lexical processing. It applies the following rules
+// iteratively until no further processing can be done:
+//
+//  1. Replace multiple slashes with a single slash.
+//  2. Eliminate each . path name element (the current directory).
+//  3. Eliminate each inner .. path name element (the parent directory)
+//     along with the non-.. element that precedes it.
+//  4. Eliminate .. elements that begin a rooted path:
+//     that is, replace "/.." by "/" at the beginning of a path.
+//
+// The returned path ends in a slash only if it is the root "/".
+//
+// If the result of this process is an empty string, Clean
+// returns the string ".".
+//
+// See also Rob Pike, “Lexical File Names in Plan 9 or
+// Getting Dot-Dot Right,”
+// https://9p.io/sys/doc/lexnames.html
+func Clean(path string) string {
+	if path == "" {
+		return "."
+	}
+	rooted := path[0] == '/'
+	// Elements are collected rather than edited in place: GoFront strings are
+	// indexed by UTF-16 code unit, so a byte buffer cannot hold their text.
+	var out []string
+	for i := 0; i < len(path); {
+		j := i
+		for j < len(path) && path[j] != '/' {
+			j++
+		}
+		elem := path[i:j]
+		i = j + 1
+		switch elem {
+		case "", ".":
+		case "..":
+			if len(out) > 0 && out[len(out)-1] != ".." {
+				out = out[:len(out)-1]
+			} else if !rooted {
+				out = append(out, "..")
+			}
+		default:
+			out = append(out, elem)
+		}
+	}
+	res := ""
+	for i, elem := range out {
+		if i > 0 {
+			res += "/"
+		}
+		res += elem
+	}
+	if rooted {
+		res = "/" + res
+	}
+	if res == "" {
+		return "."
+	}
+	return res
+}
+
+// Split splits path immediately following the final slash,
+// separating it into a directory and file name component.
+// If there is no slash in path, Split returns an empty dir and
+// file set to path.
+// The returned values have the property that path = dir+file.
+func Split(path string) (dir, file string) {
+	i := lastSlash(path)
+	return path[:i+1], path[i+1:]
+}
+
+// Join joins any number of path elements into a single path,
+// separating them with slashes. Empty elements are ignored.
+// The result is Cleaned. However, if the argument list is
+// empty or all its elements are empty, Join returns
+// an empty string.
+func Join(elem ...string) string {
+	joined := ""
+	for _, e := range elem {
+		if joined != "" || e != "" {
+			if joined != "" {
+				joined += "/"
+			}
+			joined += e
+		}
+	}
+	if joined == "" {
+		return ""
+	}
+	return Clean(joined)
+}
+
+// Ext returns the file name extension used by path.
+// The extension is the suffix beginning at the final dot
+// in the final slash-separated element of path;
+// it is empty if there is no dot.
+func Ext(path string) string {
+	for i := len(path) - 1; i >= 0 && path[i] != '/'; i-- {
+		if path[i] == '.' {
+			return path[i:]
+		}
+	}
+	return ""
+}
+
+// Base returns the last element of path.
+// Trailing slashes are removed before extracting the last element.
+// If the path is empty, Base returns ".".
+// If the path consists entirely of slashes, Base returns "/".
+func Base(path string) string {
+	if path == "" {
+		return "."
+	}
+	// Strip trailing slashes.
+	for len(path) > 0 && path[len(path)-1] == '/' {
+		path = path[0 : len(path)-1]
+	}
+	// Find the last element
+	if i := lastSlash(path); i >= 0 {
+		path = path[i+1:]
+	}
+	// If empty now, it had only slashes.
+	if path == "" {
+		return "/"
+	}
+	return path
+}
+
+// IsAbs reports whether the path is absolute.
+func IsAbs(path string) bool {
+	return len(path) > 0 && path[0] == '/'
+}
+
+// Dir returns all but the last element of path, typically the path's directory.
+// After dropping the final element using [Split], the path is Cleaned and trailing
+// slashes are removed.
+// If the path is empty, Dir returns ".".
+// If the path consists entirely of slashes followed by non-slash bytes, Dir
+// returns a single slash. In any other case, the returned path does not end in a
+// slash.
+func Dir(path string) string {
+	dir, _ := Split(path)
+	return Clean(dir)
+}
+
+// lastSlash returns the index of the last '/' in s, or -1.
+func lastSlash(s string) int {
+	for i := len(s) - 1; i >= 0; i-- {
+		if s[i] == '/' {
+			return i
+		}
+	}
+	return -1
+}
+
+// ErrBadPattern indicates a pattern was malformed.
+var ErrBadPattern = errors.New("syntax error in pattern")
+
+// Match reports whether name matches the shell pattern.
+// The pattern syntax is:
+//
+//	pattern:
+//		{ term }
+//	term:
+//		'*'         matches any sequence of non-/ characters
+//		'?'         matches any single non-/ character
+//		'[' [ '^' ] { character-range } ']'
+//		            character class (must be non-empty)
+//		c           matches character c (c != '*', '?', '\\', '[')
+//		'\\' c      matches character c
+//
+//	character-range:
+//		c           matches character c (c != '\\', '-', ']')
+//		'\\' c      matches character c
+//		lo '-' hi   matches character c for lo <= c <= hi
+//
+// Match requires pattern to match all of name, not just a substring.
+// The only possible returned error is [ErrBadPattern], when pattern
+// is malformed.
+func Match(pattern, name string) (matched bool, err error) {
+Pattern:
+	for len(pattern) > 0 {
+		var star bool
+		var chunk string
+		star, chunk, pattern = scanChunk(pattern)
+		if star && chunk == "" {
+			// Trailing * matches rest of string unless it has a /.
+			return indexSlash(name) < 0, nil
+		}
+		// Look for match at current position.
+		t, ok, cerr := matchChunk(chunk, name)
+		// if we're the last chunk, make sure we've exhausted the name
+		// otherwise we'll give a false result even if we could still match
+		// using the star
+		if ok && (len(t) == 0 || len(pattern) > 0) {
+			name = t
+			continue
+		}
+		if cerr != nil {
+			return false, cerr
+		}
+		if star {
+			// Look for match skipping i+1 bytes.
+			// Cannot skip /.
+			for i := 0; i < len(name) && name[i] != '/'; i++ {
+				t, ok, cerr := matchChunk(chunk, name[i+1:])
+				if ok {
+					// if we're the last chunk, make sure we exhausted the name
+					if len(pattern) == 0 && len(t) > 0 {
+						continue
+					}
+					name = t
+					continue Pattern
+				}
+				if cerr != nil {
+					return false, cerr
+				}
+			}
+		}
+		// Before returning false with no error,
+		// check that the remainder of the pattern is syntactically valid.
+		for len(pattern) > 0 {
+			_, chunk, pattern = scanChunk(pattern)
+			if _, _, cerr := matchChunk(chunk, ""); cerr != nil {
+				return false, cerr
+			}
+		}
+		return false, nil
+	}
+	return len(name) == 0, nil
+}
+
+// scanChunk gets the next segment of pattern, which is a non-star string
+// possibly preceded by a star.
+func scanChunk(pattern string) (star bool, chunk, rest string) {
+	for len(pattern) > 0 && pattern[0] == '*' {
+		pattern = pattern[1:]
+		star = true
+	}
+	inrange := false
+	for i := 0; i < len(pattern); i++ {
+		switch pattern[i] {
+		case '\\':
+			// error check handled in matchChunk: bad pattern.
+			if i+1 < len(pattern) {
+				i++
+			}
+		case '[':
+			inrange = true
+		case ']':
+			inrange = false
+		case '*':
+			if !inrange {
+				return star, pattern[:i], pattern[i:]
+			}
+		}
+	}
+	return star, pattern, ""
+}
+
+// matchChunk checks whether chunk matches the beginning of s.
+// If so, it returns the remainder of s (after the match).
+// Chunk is all single-character operators: literals, char classes, and ?.
+func matchChunk(chunk, s string) (rest string, ok bool, err error) {
+	// failed records whether the match has failed.
+	// After the match fails, the loop continues on processing chunk,
+	// checking that the pattern is well-formed but no longer reading s.
+	failed := false
+	for len(chunk) > 0 {
+		failed = failed || len(s) == 0
+		switch chunk[0] {
+		case '[':
+			// character class
+			var r rune
+			if !failed {
+				var n int
+				r, n = utf8.DecodeRuneInString(s)
+				s = s[n:]
+			}
+			chunk = chunk[1:]
+			// possibly negated
+			negated := false
+			if len(chunk) > 0 && chunk[0] == '^' {
+				negated = true
+				chunk = chunk[1:]
+			}
+			// parse all ranges
+			match := false
+			nrange := 0
+			for {
+				if len(chunk) > 0 && chunk[0] == ']' && nrange > 0 {
+					chunk = chunk[1:]
+					break
+				}
+				var lo, hi rune
+				if lo, chunk, err = getEsc(chunk); err != nil {
+					return "", false, err
+				}
+				hi = lo
+				if chunk[0] == '-' {
+					if hi, chunk, err = getEsc(chunk[1:]); err != nil {
+						return "", false, err
+					}
+				}
+				match = match || lo <= r && r <= hi
+				nrange++
+			}
+			failed = failed || match == negated
+
+		case '?':
+			if !failed {
+				failed = s[0] == '/'
+				_, n := utf8.DecodeRuneInString(s)
+				s = s[n:]
+			}
+			chunk = chunk[1:]
+
+		case '\\':
+			chunk = chunk[1:]
+			if len(chunk) == 0 {
+				return "", false, ErrBadPattern
+			}
+			fallthrough
+
+		default:
+			if !failed {
+				failed = chunk[0] != s[0]
+				s = s[1:]
+			}
+			chunk = chunk[1:]
+		}
+	}
+	if failed {
+		return "", false, nil
+	}
+	return s, true, nil
+}
+
+// getEsc gets a possibly-escaped character from chunk, for a character class.
+func getEsc(chunk string) (r rune, nchunk string, err error) {
+	if len(chunk) == 0 || chunk[0] == '-' || chunk[0] == ']' {
+		err = ErrBadPattern
+		return
+	}
+	if chunk[0] == '\\' {
+		chunk = chunk[1:]
+		if len(chunk) == 0 {
+			err = ErrBadPattern
+			return
+		}
+	}
+	r, n := utf8.DecodeRuneInString(chunk)
+	if r == utf8.RuneError && n == 1 {
+		err = ErrBadPattern
+	}
+	nchunk = chunk[n:]
+	if len(nchunk) == 0 {
+		err = ErrBadPattern
+	}
+	return
+}
+
+// indexSlash returns the index of the first '/' in s, or -1.
+func indexSlash(s string) int {
+	for i := 0; i < len(s); i++ {
+		if s[i] == '/' {
+			return i
+		}
+	}
+	return -1
+}

package/stdlib/regexp/regexp.go

@@ -0,0 +1,231 @@
+//go:build gofront
+
+//gofront:target js
+
+// Package regexp is backed by the host's RegExp engine, so patterns use
+// JavaScript syntax and indexes count UTF-16 units. A pattern may start with
+// inline flags such as (?i). It is only available in js packages.
+package regexp
+
+import "errors"
+
+// Regexp is the representation of a compiled regular expression.
+type Regexp struct {
+	src string
+	re  any
+}
+
+// inlineFlags splits a leading "(?flags)" group (flags from "gimsuy") off the
+// pattern.
+func inlineFlags(expr string) (pattern, flags string) {
+	if len(expr) < 4 || expr[0] != '(' || expr[1] != '?' {
+		return expr, ""
+	}
+	for i := 2; i < len(expr); i++ {
+		switch expr[i] {
+		case 'g', 'i', 'm', 's', 'u', 'y':
+		case ')':
+			if i == 2 {
+				return expr, ""
+			}
+			return expr[i+1:], expr[2:i]
+		default:
+			return expr, ""
+		}
+	}
+	return expr, ""
+}
+
+// Compile parses a regular expression and returns, if successful, a Regexp
+// object that can be used to match against text.
+func Compile(expr string) (re *Regexp, err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			re = nil
+			err = errors.New("error parsing regexp: " + errorText(r))
+		}
+	}()
+	pattern, flags := inlineFlags(expr)
+	return &Regexp{src: expr, re: RegExp(pattern, flags)}, nil
+}
+
+func errorText(r any) string {
+	if s, ok := r.(string); ok {
+		return s
+	}
+	if e, ok := r.(error); ok {
+		return e.Error()
+	}
+	return String(r.message).(string)
+}
+
+// MustCompile is like Compile but panics if the expression cannot be parsed.
+func MustCompile(expr string) *Regexp {
+	re, err := Compile(expr)
+	if err != nil {
+		panic("regexp: Compile(`" + expr + "`): " + err.Error())
+	}
+	return re
+}
+
+// MatchString reports whether the string s contains any match of the regular
+// expression pattern.
+func MatchString(pattern string, s string) (matched bool, err error) {
+	re, err := Compile(pattern)
+	if err != nil {
+		return false, err
+	}
+	return re.MatchString(s), nil
+}
+
+// QuoteMeta returns a string that escapes all regular expression
+// metacharacters inside the argument text.
+func QuoteMeta(s string) string {
+	var b []byte
+	for i := 0; i < len(s); i++ {
+		switch s[i] {
+		case '\\', '.', '+', '*', '?', '(', ')', '|', '[', ']', '{', '}', '^', '$':
+			b = append(b, '\\')
+		}
+		b = append(b, s[i])
+	}
+	return string(b)
+}
+
+// String returns the source text used to compile the regular expression.
+func (re *Regexp) String() string {
+	return re.src
+}
+
+// global returns a copy of the expression that matches every occurrence.
+func (re *Regexp) global() any {
+	flags := re.re.flags.(string)
+	if !re.re.flags.includes("g").(bool) {
+		flags += "g"
+	}
+	return RegExp(re.re.source, flags)
+}
+
+func text(v any) string {
+	if v == nil {
+		return ""
+	}
+	return v.(string)
+}
+
+func groups(m any) []string {
+	items := m.([]any)
+	out := make([]string, len(items))
+	for i, v := range items {
+		out[i] = text(v)
+	}
+	return out
+}
+
+// matches returns the match arrays of up to n occurrences (all when n < 0).
+func (re *Regexp) matches(s string, n int) []any {
+	var out []any
+	if n == 0 {
+		return out
+	}
+	all := Array.from(any(s).matchAll(re.global())).([]any)
+	for _, m := range all {
+		out = append(out, m)
+		if n > 0 && len(out) >= n {
+			break
+		}
+	}
+	return out
+}
+
+// MatchString reports whether the string s contains any match of the regular
+// expression re.
+func (re *Regexp) MatchString(s string) bool {
+	return re.re.test(s).(bool)
+}
+
+// FindString returns a string holding the text of the leftmost match in s of
+// the regular expression, or "" if there is no match.
+func (re *Regexp) FindString(s string) string {
+	m := re.re.exec(s)
+	if m == nil {
+		return ""
+	}
+	return text(m.([]any)[0])
+}
+
+// FindStringIndex returns a two-element slice of integers defining the
+// location of the leftmost match in s of the regular expression, or nil if
+// there is no match.
+func (re *Regexp) FindStringIndex(s string) []int {
+	m := re.re.exec(s)
+	if m == nil {
+		return nil
+	}
+	start := m.index.(int)
+	return []int{start, start + m.([]any)[0].length.(int)}
+}
+
+// FindAllString returns a slice of all successive matches of the expression;
+// a negative n means all matches.
+func (re *Regexp) FindAllString(s string, n int) []string {
+	var out []string
+	for _, m := range re.matches(s, n) {
+		out = append(out, text(m.([]any)[0]))
+	}
+	return out
+}
+
+// FindStringSubmatch returns a slice of strings holding the text of the
+// leftmost match and of its subexpressions.
+func (re *Regexp) FindStringSubmatch(s string) []string {
+	m := re.re.exec(s)
+	if m == nil {
+		return nil
+	}
+	return groups(m)
+}
+
+// FindAllStringSubmatch is the 'All' version of FindStringSubmatch.
+func (re *Regexp) FindAllStringSubmatch(s string, n int) [][]string {
+	var out [][]string
+	for _, m := range re.matches(s, n) {
+		out = append(out, groups(m))
+	}
+	return out
+}
+
+// ReplaceAllString returns a copy of src, replacing matches of the Regexp
+// with the replacement string repl. Inside repl, $1 and $& refer to the
+// match as in JavaScript.
+func (re *Regexp) ReplaceAllString(src, repl string) string {
+	return any(src).replaceAll(re.global(), repl).(string)
+}
+
+// ReplaceAllLiteralString returns a copy of src, replacing matches of the
+// Regexp with the replacement string repl, without expanding $.
+func (re *Regexp) ReplaceAllLiteralString(src, repl string) string {
+	return re.ReplaceAllStringFunc(src, func(string) string { return repl })
+}
+
+// ReplaceAllStringFunc returns a copy of src in which all matches of the
+// Regexp have been replaced by the return value of function repl applied to
+// the matched substring.
+func (re *Regexp) ReplaceAllStringFunc(src string, repl func(string) string) string {
+	return any(src).replaceAll(re.global(), func(m string) string { return repl(m) }).(string)
+}
+
+// Split slices s into substrings separated by the expression. Text captured
+// by groups is included, as in JavaScript. A non-negative n keeps at most n
+// substrings.
+func (re *Regexp) Split(s string, n int) []string {
+	parts := Array.from(any(s).split(re.re)).([]any)
+	out := make([]string, 0, len(parts))
+	for _, p := range parts {
+		if n >= 0 && len(out) >= n {
+			break
+		}
+		out = append(out, text(p))
+	}
+	return out
+}