goscript 0.0.26 → 0.0.29

package/gs/iter/godoc.txt

@@ -0,0 +1,203 @@
+package iter // import "iter"
+
+Package iter provides basic definitions and operations related to iterators over
+sequences.
+
+# Iterators
+
+An iterator is a function that passes successive elements of a sequence to a
+callback function, conventionally named yield. The function stops either when
+the sequence is finished or when yield returns false, indicating to stop the
+iteration early. This package defines Seq and Seq2 (pronounced like seek—the
+first syllable of sequence) as shorthands for iterators that pass 1 or 2 values
+per sequence element to yield:
+
+    type (
+    	Seq[V any]     func(yield func(V) bool)
+    	Seq2[K, V any] func(yield func(K, V) bool)
+    )
+
+Seq2 represents a sequence of paired values, conventionally key-value or
+index-value pairs.
+
+Yield returns true if the iterator should continue with the next element in the
+sequence, false if it should stop.
+
+For instance, maps.Keys returns an iterator that produces the sequence of keys
+of the map m, implemented as follows:
+
+    func Keys[Map ~map[K]V, K comparable, V any](m Map) iter.Seq[K] {
+    	return func(yield func(K) bool) {
+    		for k := range m {
+    			if !yield(k) {
+    				return
+    			}
+    		}
+    	}
+    }
+
+Further examples can be found in The Go Blog: Range Over Function Types.
+
+Iterator functions are most often called by a range loop, as in:
+
+    func PrintAll[V any](seq iter.Seq[V]) {
+    	for v := range seq {
+    		fmt.Println(v)
+    	}
+    }
+
+# Naming Conventions
+
+Iterator functions and methods are named for the sequence being walked:
+
+    // All returns an iterator over all elements in s.
+    func (s *Set[V]) All() iter.Seq[V]
+
+The iterator method on a collection type is conventionally named All, because it
+iterates a sequence of all the values in the collection.
+
+For a type containing multiple possible sequences, the iterator's name can
+indicate which sequence is being provided:
+
+    // Cities returns an iterator over the major cities in the country.
+    func (c *Country) Cities() iter.Seq[*City]
+
+    // Languages returns an iterator over the official spoken languages of the country.
+    func (c *Country) Languages() iter.Seq[string]
+
+If an iterator requires additional configuration, the constructor function can
+take additional configuration arguments:
+
+    // Scan returns an iterator over key-value pairs with min ≤ key ≤ max.
+    func (m *Map[K, V]) Scan(min, max K) iter.Seq2[K, V]
+
+    // Split returns an iterator over the (possibly-empty) substrings of s
+    // separated by sep.
+    func Split(s, sep string) iter.Seq[string]
+
+When there are multiple possible iteration orders, the method name may indicate
+that order:
+
+    // All returns an iterator over the list from head to tail.
+    func (l *List[V]) All() iter.Seq[V]
+
+    // Backward returns an iterator over the list from tail to head.
+    func (l *List[V]) Backward() iter.Seq[V]
+
+    // Preorder returns an iterator over all nodes of the syntax tree
+    // beneath (and including) the specified root, in depth-first preorder,
+    // visiting a parent node before its children.
+    func Preorder(root Node) iter.Seq[Node]
+
+# Single-Use Iterators
+
+Most iterators provide the ability to walk an entire sequence: when called,
+the iterator does any setup necessary to start the sequence, then calls yield
+on successive elements of the sequence, and then cleans up before returning.
+Calling the iterator again walks the sequence again.
+
+Some iterators break that convention, providing the ability to walk a sequence
+only once. These “single-use iterators” typically report values from a data
+stream that cannot be rewound to start over. Calling the iterator again after
+stopping early may continue the stream, but calling it again after the sequence
+is finished will yield no values at all. Doc comments for functions or methods
+that return single-use iterators should document this fact:
+
+    // Lines returns an iterator over lines read from r.
+    // It returns a single-use iterator.
+    func (r *Reader) Lines() iter.Seq[string]
+
+# Pulling Values
+
+Functions and methods that accept or return iterators should use the standard
+Seq or Seq2 types, to ensure compatibility with range loops and other iterator
+adapters. The standard iterators can be thought of as “push iterators”, which
+push values to the yield function.
+
+Sometimes a range loop is not the most natural way to consume values of the
+sequence. In this case, Pull converts a standard push iterator to a “pull
+iterator”, which can be called to pull one value at a time from the sequence.
+Pull starts an iterator and returns a pair of functions—next and stop—which
+return the next value from the iterator and stop it, respectively.
+
+For example:
+
+    // Pairs returns an iterator over successive pairs of values from seq.
+    func Pairs[V any](seq iter.Seq[V]) iter.Seq2[V, V] {
+    	return func(yield func(V, V) bool) {
+    		next, stop := iter.Pull(seq)
+    		defer stop()
+    		for {
+    			v1, ok1 := next()
+    			if !ok1 {
+    				return
+    			}
+    			v2, ok2 := next()
+    			// If ok2 is false, v2 should be the
+    			// zero value; yield one last pair.
+    			if !yield(v1, v2) {
+    				return
+    			}
+    			if !ok2 {
+    				return
+    			}
+    		}
+    	}
+    }
+
+If clients do not consume the sequence to completion, they must call stop, which
+allows the iterator function to finish and return. As shown in the example,
+the conventional way to ensure this is to use defer.
+
+# Standard Library Usage
+
+A few packages in the standard library provide iterator-based APIs, most notably
+the maps and slices packages. For example, maps.Keys returns an iterator over
+the keys of a map, while slices.Sorted collects the values of an iterator into a
+slice, sorts them, and returns the slice, so to iterate over the sorted keys of
+a map:
+
+    for _, key := range slices.Sorted(maps.Keys(m)) {
+    	...
+    }
+
+# Mutation
+
+Iterators provide only the values of the sequence, not any direct way to modify
+it. If an iterator wishes to provide a mechanism for modifying a sequence
+during iteration, the usual approach is to define a position type with the extra
+operations and then provide an iterator over positions.
+
+For example, a tree implementation might provide:
+
+    // Positions returns an iterator over positions in the sequence.
+    func (t *Tree[V]) Positions() iter.Seq[*Pos]
+
+    // A Pos represents a position in the sequence.
+    // It is only valid during the yield call it is passed to.
+    type Pos[V any] struct { ... }
+
+    // Pos returns the value at the cursor.
+    func (p *Pos[V]) Value() V
+
+    // Delete deletes the value at this point in the iteration.
+    func (p *Pos[V]) Delete()
+
+    // Set changes the value v at the cursor.
+    func (p *Pos[V]) Set(v V)
+
+And then a client could delete boring values from the tree using:
+
+    for p := range t.Positions() {
+    	if boring(p.Value()) {
+    		p.Delete()
+    	}
+    }
+
+[The Go Blog: Range Over Function Types]: https://go.dev/blog/range-functions
+[range loop]: https://go.dev/ref/spec#For_range
+
+func Pull[V any](seq Seq[V]) (next func() (V, bool), stop func())
+func Pull2[K, V any](seq Seq2[K, V]) (next func() (K, V, bool), stop func())
+type Seq[V any] func(yield func(V) bool)
+type Seq2[K, V any] func(yield func(K, V) bool)

package/gs/iter/index.ts

@@ -0,0 +1 @@
+export * from './iter.js'

package/gs/iter/iter.ts

@@ -0,0 +1,117 @@
+// TypeScript implementation of Go's iter package
+// This provides iterator types and functions
+
+// Seq is an iterator over sequences of individual values
+export type Seq<V> = (_yield: (value: V) => boolean) => void
+
+// Seq2 is an iterator over sequences of pairs of values
+export type Seq2<K, V> = (_yield: (key: K, value: V) => boolean) => void
+
+// Pull converts the "push-style" iterator sequence seq into a "pull-style" iterator
+// Returns a function that returns the next value and a boolean indicating if iteration should continue
+export function Pull<V>(
+  seq: Seq<V>,
+): [() => [V | undefined, boolean], () => void] {
+  let done = false
+  let nextValue: V | undefined
+  let hasNext = false
+
+  const iterator = seq(function (value: V): boolean {
+    nextValue = value
+    hasNext = true
+    return false // Stop iteration after getting one value
+  })
+
+  const next = (): [V | undefined, boolean] => {
+    if (done) {
+      return [undefined, false]
+    }
+
+    if (hasNext) {
+      const value = nextValue
+      hasNext = false
+      nextValue = undefined
+      return [value, true]
+    }
+
+    // Try to get next value
+    seq(function (value: V): boolean {
+      nextValue = value
+      hasNext = true
+      return false // Stop after getting one value
+    })
+
+    if (hasNext) {
+      const value = nextValue
+      hasNext = false
+      nextValue = undefined
+      return [value, true]
+    }
+
+    done = true
+    return [undefined, false]
+  }
+
+  const stop = (): void => {
+    done = true
+    hasNext = false
+    nextValue = undefined
+  }
+
+  return [next, stop]
+}
+
+// Pull2 converts the "push-style" iterator sequence seq into a "pull-style" iterator
+// Returns a function that returns the next key-value pair and a boolean indicating if iteration should continue
+export function Pull2<K, V>(
+  seq: Seq2<K, V>,
+): [() => [K | undefined, V | undefined, boolean], () => void] {
+  let done = false
+  let nextKey: K | undefined
+  let nextValue: V | undefined
+  let hasNext = false
+
+  const next = (): [K | undefined, V | undefined, boolean] => {
+    if (done) {
+      return [undefined, undefined, false]
+    }
+
+    if (hasNext) {
+      const key = nextKey
+      const value = nextValue
+      hasNext = false
+      nextKey = undefined
+      nextValue = undefined
+      return [key, value, true]
+    }
+
+    // Try to get next value
+    seq(function (key: K, value: V): boolean {
+      nextKey = key
+      nextValue = value
+      hasNext = true
+      return false // Stop after getting one value
+    })
+
+    if (hasNext) {
+      const key = nextKey
+      const value = nextValue
+      hasNext = false
+      nextKey = undefined
+      nextValue = undefined
+      return [key, value, true]
+    }
+
+    done = true
+    return [undefined, undefined, false]
+  }
+
+  const stop = (): void => {
+    done = true
+    hasNext = false
+    nextKey = undefined
+    nextValue = undefined
+  }
+
+  return [next, stop]
+}

package/gs/math/bits/index.ts

@@ -0,0 +1,356 @@
+// Minimal stub for math/bits package
+// This replaces the auto-generated version that has TypeScript syntax errors
+
+// UintSize is the size of a uint in bits
+export const UintSize = 32 // Assuming 32-bit for JavaScript numbers
+
+// --- Leading zeros ---
+export function LeadingZeros(x: number): number {
+  return Math.clz32(x >>> 0)
+}
+
+export function LeadingZeros8(x: number): number {
+  return Math.clz32((x & 0xff) << 24)
+}
+
+export function LeadingZeros16(x: number): number {
+  return Math.clz32((x & 0xffff) << 16)
+}
+
+export function LeadingZeros32(x: number): number {
+  return Math.clz32(x >>> 0)
+}
+
+export function LeadingZeros64(x: bigint): number {
+  // For 64-bit, we need to handle it differently
+  if (x === 0n) return 64
+  let count = 0
+  let mask = 1n << 63n
+  while ((x & mask) === 0n && count < 64) {
+    count++
+    mask >>= 1n
+  }
+  return count
+}
+
+// --- Trailing zeros ---
+export function TrailingZeros(x: number): number {
+  if (x === 0) return UintSize
+  return TrailingZeros32(x)
+}
+
+export function TrailingZeros8(x: number): number {
+  if (x === 0) return 8
+  return Math.min(8, TrailingZeros32(x))
+}
+
+export function TrailingZeros16(x: number): number {
+  if (x === 0) return 16
+  return Math.min(16, TrailingZeros32(x))
+}
+
+export function TrailingZeros32(x: number): number {
+  if (x === 0) return 32
+  let count = 0
+  while ((x & 1) === 0) {
+    count++
+    x >>>= 1
+  }
+  return count
+}
+
+export function TrailingZeros64(x: bigint): number {
+  if (x === 0n) return 64
+  let count = 0
+  while ((x & 1n) === 0n && count < 64) {
+    count++
+    x >>= 1n
+  }
+  return count
+}
+
+// --- Ones count ---
+export function OnesCount(x: number): number {
+  return OnesCount32(x)
+}
+
+export function OnesCount8(x: number): number {
+  return OnesCount32(x & 0xff)
+}
+
+export function OnesCount16(x: number): number {
+  return OnesCount32(x & 0xffff)
+}
+
+export function OnesCount32(x: number): number {
+  // Brian Kernighan's algorithm
+  let count = 0
+  x = x >>> 0 // Ensure unsigned
+  while (x) {
+    count++
+    x &= x - 1
+  }
+  return count
+}
+
+export function OnesCount64(x: bigint): number {
+  let count = 0
+  while (x > 0n) {
+    count++
+    x &= x - 1n
+  }
+  return count
+}
+
+// --- Rotate left ---
+export function RotateLeft(x: number, k: number): number {
+  return RotateLeft32(x, k)
+}
+
+export function RotateLeft8(x: number, k: number): number {
+  const n = 8
+  k = k % n
+  x = x & 0xff
+  return ((x << k) | (x >> (n - k))) & 0xff
+}
+
+export function RotateLeft16(x: number, k: number): number {
+  const n = 16
+  k = k % n
+  x = x & 0xffff
+  return ((x << k) | (x >> (n - k))) & 0xffff
+}
+
+export function RotateLeft32(x: number, k: number): number {
+  const n = 32
+  k = k % n
+  x = x >>> 0 // Ensure unsigned
+  return ((x << k) | (x >>> (n - k))) >>> 0
+}
+
+export function RotateLeft64(x: bigint, k: number): bigint {
+  const n = 64
+  k = k % n
+  const mask = (1n << 64n) - 1n
+  x = x & mask
+  return ((x << BigInt(k)) | (x >> BigInt(n - k))) & mask
+}
+
+// --- Reverse ---
+export function Reverse(x: number): number {
+  return Reverse32(x)
+}
+
+export function Reverse8(x: number): number {
+  x = x & 0xff
+  x = ((x & 0xf0) >> 4) | ((x & 0x0f) << 4)
+  x = ((x & 0xcc) >> 2) | ((x & 0x33) << 2)
+  x = ((x & 0xaa) >> 1) | ((x & 0x55) << 1)
+  return x
+}
+
+export function Reverse16(x: number): number {
+  x = x & 0xffff
+  x = ((x & 0xff00) >> 8) | ((x & 0x00ff) << 8)
+  x = ((x & 0xf0f0) >> 4) | ((x & 0x0f0f) << 4)
+  x = ((x & 0xcccc) >> 2) | ((x & 0x3333) << 2)
+  x = ((x & 0xaaaa) >> 1) | ((x & 0x5555) << 1)
+  return x
+}
+
+export function Reverse32(x: number): number {
+  x = x >>> 0 // Ensure unsigned
+  x = ((x & 0xffff0000) >>> 16) | ((x & 0x0000ffff) << 16)
+  x = ((x & 0xff00ff00) >>> 8) | ((x & 0x00ff00ff) << 8)
+  x = ((x & 0xf0f0f0f0) >>> 4) | ((x & 0x0f0f0f0f) << 4)
+  x = ((x & 0xcccccccc) >>> 2) | ((x & 0x33333333) << 2)
+  x = ((x & 0xaaaaaaaa) >>> 1) | ((x & 0x55555555) << 1)
+  return x >>> 0
+}
+
+export function Reverse64(x: bigint): bigint {
+  // Implement 64-bit reverse using similar bit manipulation
+  const mask = (1n << 64n) - 1n
+  x = x & mask
+
+  // Swap 32-bit halves
+  x = ((x & 0xffffffff00000000n) >> 32n) | ((x & 0x00000000ffffffffn) << 32n)
+  // Swap 16-bit chunks
+  x = ((x & 0xffff0000ffff0000n) >> 16n) | ((x & 0x0000ffff0000ffffn) << 16n)
+  // Swap 8-bit chunks
+  x = ((x & 0xff00ff00ff00ff00n) >> 8n) | ((x & 0x00ff00ff00ff00ffn) << 8n)
+  // Swap 4-bit chunks
+  x = ((x & 0xf0f0f0f0f0f0f0f0n) >> 4n) | ((x & 0x0f0f0f0f0f0f0f0fn) << 4n)
+  // Swap 2-bit chunks
+  x = ((x & 0xccccccccccccccccn) >> 2n) | ((x & 0x3333333333333333n) << 2n)
+  // Swap 1-bit chunks
+  x = ((x & 0xaaaaaaaaaaaaaaaan) >> 1n) | ((x & 0x5555555555555555n) << 1n)
+
+  return x & mask
+}
+
+// --- ReverseBytes ---
+export function ReverseBytes(x: number): number {
+  return ReverseBytes32(x)
+}
+
+export function ReverseBytes16(x: number): number {
+  return ((x & 0xff) << 8) | ((x & 0xff00) >> 8)
+}
+
+export function ReverseBytes32(x: number): number {
+  x = x >>> 0 // Ensure unsigned
+  return (
+    (((x & 0xff) << 24) |
+      ((x & 0xff00) << 8) |
+      ((x & 0xff0000) >> 8) |
+      ((x & 0xff000000) >>> 24)) >>>
+    0
+  )
+}
+
+export function ReverseBytes64(x: bigint): bigint {
+  const mask = (1n << 64n) - 1n
+  x = x & mask
+
+  return (
+    (((x & 0xffn) << 56n) |
+      ((x & 0xff00n) << 40n) |
+      ((x & 0xff0000n) << 24n) |
+      ((x & 0xff000000n) << 8n) |
+      ((x & 0xff00000000n) >> 8n) |
+      ((x & 0xff0000000000n) >> 24n) |
+      ((x & 0xff000000000000n) >> 40n) |
+      ((x & 0xff00000000000000n) >> 56n)) &
+    mask
+  )
+}
+
+// --- Len ---
+export function Len(x: number): number {
+  return Len32(x)
+}
+
+export function Len8(x: number): number {
+  return 8 - LeadingZeros8(x)
+}
+
+export function Len16(x: number): number {
+  return 16 - LeadingZeros16(x)
+}
+
+export function Len32(x: number): number {
+  return 32 - LeadingZeros32(x)
+}
+
+export function Len64(x: bigint): number {
+  return 64 - LeadingZeros64(x)
+}
+
+// --- Multiplication functions ---
+export function Mul(x: number, y: number): [number, number] {
+  return Mul32(x, y)
+}
+
+export function Mul32(x: number, y: number): [number, number] {
+  // For 32-bit multiplication, we can use JavaScript's number precision
+  const result = (x >>> 0) * (y >>> 0)
+  const hi = Math.floor(result / 0x100000000) >>> 0
+  const lo = result >>> 0
+  return [hi, lo]
+}
+
+export function Mul64(x: bigint, y: bigint): [bigint, bigint] {
+  const mask32 = 0xffffffffn
+
+  // Split into 32-bit parts
+  const x0 = x & mask32
+  const x1 = x >> 32n
+  const y0 = y & mask32
+  const y1 = y >> 32n
+
+  // Multiply parts
+  const p00 = x0 * y0
+  const p01 = x0 * y1
+  const p10 = x1 * y0
+  const p11 = x1 * y1
+
+  // Combine results
+  const lo = p00 + ((p01 + p10) << 32n)
+  const hi = p11 + ((p01 + p10) >> 32n) + (lo < p00 ? 1n : 0n)
+
+  return [hi, lo]
+}
+
+// --- Division functions ---
+export function Div(hi: number, lo: number, y: number): [number, number] {
+  return Div32(hi, lo, y)
+}
+
+export function Div32(hi: number, lo: number, y: number): [number, number] {
+  if (y === 0) {
+    throw new Error('division by zero')
+  }
+
+  // Combine hi and lo into a 64-bit value using BigInt for precision
+  const dividend = (BigInt(hi >>> 0) << 32n) | BigInt(lo >>> 0)
+  const divisor = BigInt(y >>> 0)
+
+  const quotient = dividend / divisor
+  const remainder = dividend % divisor
+
+  return [Number(quotient), Number(remainder)]
+}
+
+export function Div64(hi: bigint, lo: bigint, y: bigint): [bigint, bigint] {
+  if (y === 0n) {
+    throw new Error('division by zero')
+  }
+
+  // Combine hi and lo into a 128-bit value (simulated)
+  // For simplicity, we'll use a basic implementation
+  const dividend = (hi << 64n) | lo
+  const quotient = dividend / y
+  const remainder = dividend % y
+
+  return [quotient, remainder]
+}
+
+// --- Add and Sub with carry ---
+export function Add(x: number, y: number, carry: number): [number, number] {
+  return Add32(x, y, carry)
+}
+
+export function Add32(x: number, y: number, carry: number): [number, number] {
+  const sum = (x >>> 0) + (y >>> 0) + (carry >>> 0)
+  const result = sum >>> 0
+  const carryOut = sum > 0xffffffff ? 1 : 0
+  return [result, carryOut]
+}
+
+export function Add64(x: bigint, y: bigint, carry: bigint): [bigint, bigint] {
+  const mask = (1n << 64n) - 1n
+  const sum = (x & mask) + (y & mask) + (carry & mask)
+  const result = sum & mask
+  const carryOut = sum > mask ? 1n : 0n
+  return [result, carryOut]
+}
+
+export function Sub(x: number, y: number, borrow: number): [number, number] {
+  return Sub32(x, y, borrow)
+}
+
+export function Sub32(x: number, y: number, borrow: number): [number, number] {
+  const diff = (x >>> 0) - (y >>> 0) - (borrow >>> 0)
+  const result = diff >>> 0
+  const borrowOut = diff < 0 ? 1 : 0
+  return [result, borrowOut]
+}
+
+export function Sub64(x: bigint, y: bigint, borrow: bigint): [bigint, bigint] {
+  const mask = (1n << 64n) - 1n
+  const diff = (x & mask) - (y & mask) - (borrow & mask)
+  const result = diff & mask
+  const borrowOut = diff < 0n ? 1n : 0n
+  return [result, borrowOut]
+}