goscript 0.0.26 → 0.0.29

package/gs/runtime/godoc.txt

@@ -0,0 +1,331 @@
+package runtime // import "runtime"
+
+Package runtime contains operations that interact with Go's runtime system,
+such as functions to control goroutines. It also includes the low-level type
+information used by the reflect package; see reflect's documentation for the
+programmable interface to the run-time type system.
+
+# Environment Variables
+
+The following environment variables ($name or %name%, depending on the host
+operating system) control the run-time behavior of Go programs. The meanings and
+use may change from release to release.
+
+The GOGC variable sets the initial garbage collection target percentage.
+A collection is triggered when the ratio of freshly allocated data to live
+data remaining after the previous collection reaches this percentage. The
+default is GOGC=100. Setting GOGC=off disables the garbage collector entirely.
+runtime/debug.SetGCPercent allows changing this percentage at run time.
+
+The GOMEMLIMIT variable sets a soft memory limit for the runtime. This memory
+limit includes the Go heap and all other memory managed by the runtime, and
+excludes external memory sources such as mappings of the binary itself, memory
+managed in other languages, and memory held by the operating system on behalf
+of the Go program. GOMEMLIMIT is a numeric value in bytes with an optional unit
+suffix. The supported suffixes include B, KiB, MiB, GiB, and TiB. These suffixes
+represent quantities of bytes as defined by the IEC 80000-13 standard. That is,
+they are based on powers of two: KiB means 2^10 bytes, MiB means 2^20 bytes,
+and so on. The default setting is math.MaxInt64, which effectively disables the
+memory limit. runtime/debug.SetMemoryLimit allows changing this limit at run
+time.
+
+The GODEBUG variable controls debugging variables within the runtime. It is a
+comma-separated list of name=val pairs setting these named variables:
+
+    clobberfree: setting clobberfree=1 causes the garbage collector to
+    clobber the memory content of an object with bad content when it frees
+    the object.
+
+    cpu.*: cpu.all=off disables the use of all optional instruction set extensions.
+    cpu.extension=off disables use of instructions from the specified instruction set extension.
+    extension is the lower case name for the instruction set extension such as sse41 or avx
+    as listed in internal/cpu package. As an example cpu.avx=off disables runtime detection
+    and thereby use of AVX instructions.
+
+    cgocheck: setting cgocheck=0 disables all checks for packages
+    using cgo to incorrectly pass Go pointers to non-Go code.
+    Setting cgocheck=1 (the default) enables relatively cheap
+    checks that may miss some errors. A more complete, but slow,
+    cgocheck mode can be enabled using GOEXPERIMENT (which
+    requires a rebuild), see https://pkg.go.dev/internal/goexperiment for details.
+
+    disablethp: setting disablethp=1 on Linux disables transparent huge pages for the heap.
+    It has no effect on other platforms. disablethp is meant for compatibility with versions
+    of Go before 1.21, which stopped working around a Linux kernel default that can result
+    in significant memory overuse. See https://go.dev/issue/64332. This setting will be
+    removed in a future release, so operators should tweak their Linux configuration to suit
+    their needs before then. See https://go.dev/doc/gc-guide#Linux_transparent_huge_pages.
+
+    dontfreezetheworld: by default, the start of a fatal panic or throw
+    "freezes the world", preempting all threads to stop all running
+    goroutines, which makes it possible to traceback all goroutines, and
+    keeps their state close to the point of panic. Setting
+    dontfreezetheworld=1 disables this preemption, allowing goroutines to
+    continue executing during panic processing. Note that goroutines that
+    naturally enter the scheduler will still stop. This can be useful when
+    debugging the runtime scheduler, as freezetheworld perturbs scheduler
+    state and thus may hide problems.
+
+    efence: setting efence=1 causes the allocator to run in a mode
+    where each object is allocated on a unique page and addresses are
+    never recycled.
+
+    gccheckmark: setting gccheckmark=1 enables verification of the
+    garbage collector's concurrent mark phase by performing a
+    second mark pass while the world is stopped.  If the second
+    pass finds a reachable object that was not found by concurrent
+    mark, the garbage collector will panic.
+
+    gcpacertrace: setting gcpacertrace=1 causes the garbage collector to
+    print information about the internal state of the concurrent pacer.
+
+    gcshrinkstackoff: setting gcshrinkstackoff=1 disables moving goroutines
+    onto smaller stacks. In this mode, a goroutine's stack can only grow.
+
+    gcstoptheworld: setting gcstoptheworld=1 disables concurrent garbage collection,
+    making every garbage collection a stop-the-world event. Setting gcstoptheworld=2
+    also disables concurrent sweeping after the garbage collection finishes.
+
+    gctrace: setting gctrace=1 causes the garbage collector to emit a single line to standard
+    error at each collection, summarizing the amount of memory collected and the
+    length of the pause. The format of this line is subject to change. Included in
+    the explanation below is also the relevant runtime/metrics metric for each field.
+    Currently, it is:
+    	gc # @#s #%: #+#+# ms clock, #+#/#/#+# ms cpu, #->#-># MB, # MB goal, # MB stacks, #MB globals, # P
+    where the fields are as follows:
+    	gc #         the GC number, incremented at each GC
+    	@#s          time in seconds since program start
+    	#%           percentage of time spent in GC since program start
+    	#+...+#      wall-clock/CPU times for the phases of the GC
+    	#->#-># MB   heap size at GC start, at GC end, and live heap, or /gc/scan/heap:bytes
+    	# MB goal    goal heap size, or /gc/heap/goal:bytes
+    	# MB stacks  estimated scannable stack size, or /gc/scan/stack:bytes
+    	# MB globals scannable global size, or /gc/scan/globals:bytes
+    	# P          number of processors used, or /sched/gomaxprocs:threads
+    The phases are stop-the-world (STW) sweep termination, concurrent
+    mark and scan, and STW mark termination. The CPU times
+    for mark/scan are broken down in to assist time (GC performed in
+    line with allocation), background GC time, and idle GC time.
+    If the line ends with "(forced)", this GC was forced by a
+    runtime.GC() call.
+
+    harddecommit: setting harddecommit=1 causes memory that is returned to the OS to
+    also have protections removed on it. This is the only mode of operation on Windows,
+    but is helpful in debugging scavenger-related issues on other platforms. Currently,
+    only supported on Linux.
+
+    inittrace: setting inittrace=1 causes the runtime to emit a single line to standard
+    error for each package with init work, summarizing the execution time and memory
+    allocation. No information is printed for inits executed as part of plugin loading
+    and for packages without both user defined and compiler generated init work.
+    The format of this line is subject to change. Currently, it is:
+    	init # @#ms, # ms clock, # bytes, # allocs
+    where the fields are as follows:
+    	init #      the package name
+    	@# ms       time in milliseconds when the init started since program start
+    	# clock     wall-clock time for package initialization work
+    	# bytes     memory allocated on the heap
+    	# allocs    number of heap allocations
+
+    madvdontneed: setting madvdontneed=0 will use MADV_FREE
+    instead of MADV_DONTNEED on Linux when returning memory to the
+    kernel. This is more efficient, but means RSS numbers will
+    drop only when the OS is under memory pressure. On the BSDs and
+    Illumos/Solaris, setting madvdontneed=1 will use MADV_DONTNEED instead
+    of MADV_FREE. This is less efficient, but causes RSS numbers to drop
+    more quickly.
+
+    memprofilerate: setting memprofilerate=X will update the value of runtime.MemProfileRate.
+    When set to 0 memory profiling is disabled.  Refer to the description of
+    MemProfileRate for the default value.
+
+    profstackdepth: profstackdepth=128 (the default) will set the maximum stack
+    depth used by all pprof profilers except for the CPU profiler to 128 frames.
+    Stack traces that exceed this limit will be truncated to the limit starting
+    from the leaf frame. Setting profstackdepth to any value above 1024 will
+    silently default to 1024. Future versions of Go may remove this limitation
+    and extend profstackdepth to apply to the CPU profiler and execution tracer.
+
+    pagetrace: setting pagetrace=/path/to/file will write out a trace of page events
+    that can be viewed, analyzed, and visualized using the x/debug/cmd/pagetrace tool.
+    Build your program with GOEXPERIMENT=pagetrace to enable this functionality. Do not
+    enable this functionality if your program is a setuid binary as it introduces a security
+    risk in that scenario. Currently not supported on Windows, plan9 or js/wasm. Setting this
+    option for some applications can produce large traces, so use with care.
+
+    panicnil: setting panicnil=1 disables the runtime error when calling panic with nil
+    interface value or an untyped nil.
+
+    runtimecontentionstacks: setting runtimecontentionstacks=1 enables inclusion of call stacks
+    related to contention on runtime-internal locks in the "mutex" profile, subject to the
+    MutexProfileFraction setting. When runtimecontentionstacks=0, contention on
+    runtime-internal locks will report as "runtime._LostContendedRuntimeLock". When
+    runtimecontentionstacks=1, the call stacks will correspond to the unlock call that released
+    the lock. But instead of the value corresponding to the amount of contention that call
+    stack caused, it corresponds to the amount of time the caller of unlock had to wait in its
+    original call to lock. A future release is expected to align those and remove this setting.
+
+    invalidptr: invalidptr=1 (the default) causes the garbage collector and stack
+    copier to crash the program if an invalid pointer value (for example, 1)
+    is found in a pointer-typed location. Setting invalidptr=0 disables this check.
+    This should only be used as a temporary workaround to diagnose buggy code.
+    The real fix is to not store integers in pointer-typed locations.
+
+    sbrk: setting sbrk=1 replaces the memory allocator and garbage collector
+    with a trivial allocator that obtains memory from the operating system and
+    never reclaims any memory.
+
+    scavtrace: setting scavtrace=1 causes the runtime to emit a single line to standard
+    error, roughly once per GC cycle, summarizing the amount of work done by the
+    scavenger as well as the total amount of memory returned to the operating system
+    and an estimate of physical memory utilization. The format of this line is subject
+    to change, but currently it is:
+    	scav # KiB work (bg), # KiB work (eager), # KiB total, #% util
+    where the fields are as follows:
+    	# KiB work (bg)    the amount of memory returned to the OS in the background since
+    	                   the last line
+    	# KiB work (eager) the amount of memory returned to the OS eagerly since the last line
+    	# KiB now          the amount of address space currently returned to the OS
+    	#% util            the fraction of all unscavenged heap memory which is in-use
+    If the line ends with "(forced)", then scavenging was forced by a
+    debug.FreeOSMemory() call.
+
+    scheddetail: setting schedtrace=X and scheddetail=1 causes the scheduler to emit
+    detailed multiline info every X milliseconds, describing state of the scheduler,
+    processors, threads and goroutines.
+
+    schedtrace: setting schedtrace=X causes the scheduler to emit a single line to standard
+    error every X milliseconds, summarizing the scheduler state.
+
+    tracebackancestors: setting tracebackancestors=N extends tracebacks with the stacks at
+    which goroutines were created, where N limits the number of ancestor goroutines to
+    report. This also extends the information returned by runtime.Stack.
+    Setting N to 0 will report no ancestry information.
+
+    tracefpunwindoff: setting tracefpunwindoff=1 forces the execution tracer to
+    use the runtime's default stack unwinder instead of frame pointer unwinding.
+    This increases tracer overhead, but could be helpful as a workaround or for
+    debugging unexpected regressions caused by frame pointer unwinding.
+
+    traceadvanceperiod: the approximate period in nanoseconds between trace generations. Only
+    applies if a program is built with GOEXPERIMENT=exectracer2. Used primarily for testing
+    and debugging the execution tracer.
+
+    tracecheckstackownership: setting tracecheckstackownership=1 enables a debug check in the
+    execution tracer to double-check stack ownership before taking a stack trace.
+
+    asyncpreemptoff: asyncpreemptoff=1 disables signal-based
+    asynchronous goroutine preemption. This makes some loops
+    non-preemptible for long periods, which may delay GC and
+    goroutine scheduling. This is useful for debugging GC issues
+    because it also disables the conservative stack scanning used
+    for asynchronously preempted goroutines.
+
+The net and net/http packages also refer to debugging variables in GODEBUG.
+See the documentation for those packages for details.
+
+The GOMAXPROCS variable limits the number of operating system threads that can
+execute user-level Go code simultaneously. There is no limit to the number of
+threads that can be blocked in system calls on behalf of Go code; those do not
+count against the GOMAXPROCS limit. This package's GOMAXPROCS function queries
+and changes the limit.
+
+The GORACE variable configures the race detector, for programs built using
+-race. See the Race Detector article for details.
+
+The GOTRACEBACK variable controls the amount of output generated when a Go
+program fails due to an unrecovered panic or an unexpected runtime condition.
+By default, a failure prints a stack trace for the current goroutine, eliding
+functions internal to the run-time system, and then exits with exit code 2.
+The failure prints stack traces for all goroutines if there is no current
+goroutine or the failure is internal to the run-time. GOTRACEBACK=none omits
+the goroutine stack traces entirely. GOTRACEBACK=single (the default) behaves
+as described above. GOTRACEBACK=all adds stack traces for all user-created
+goroutines. GOTRACEBACK=system is like “all” but adds stack frames for
+run-time functions and shows goroutines created internally by the run-time.
+GOTRACEBACK=crash is like “system” but crashes in an operating system-specific
+manner instead of exiting. For example, on Unix systems, the crash raises
+SIGABRT to trigger a core dump. GOTRACEBACK=wer is like “crash” but doesn't
+disable Windows Error Reporting (WER). For historical reasons, the GOTRACEBACK
+settings 0, 1, and 2 are synonyms for none, all, and system, respectively.
+The runtime/debug.SetTraceback function allows increasing the amount of output
+at run time, but it cannot reduce the amount below that specified by the
+environment variable.
+
+The GOARCH, GOOS, GOPATH, and GOROOT environment variables complete the set of
+Go environment variables. They influence the building of Go programs (see cmd/go
+and go/build). GOARCH, GOOS, and GOROOT are recorded at compile time and made
+available by constants or functions in this package, but they do not influence
+the execution of the run-time system.
+
+# Security
+
+On Unix platforms, Go's runtime system behaves slightly differently when
+a binary is setuid/setgid or executed with setuid/setgid-like properties,
+in order to prevent dangerous behaviors. On Linux this is determined by checking
+for the AT_SECURE flag in the auxiliary vector, on the BSDs and Solaris/Illumos
+it is determined by checking the issetugid syscall, and on AIX it is determined
+by checking if the uid/gid match the effective uid/gid.
+
+When the runtime determines the binary is setuid/setgid-like, it does three main
+things:
+  - The standard input/output file descriptors (0, 1, 2) are checked to be open.
+    If any of them are closed, they are opened pointing at /dev/null.
+  - The value of the GOTRACEBACK environment variable is set to 'none'.
+  - When a signal is received that terminates the program, or the program
+    encounters an unrecoverable panic that would otherwise override the value
+    of GOTRACEBACK, the goroutine stack, registers, and other memory related
+    information are omitted.
+
+[Race Detector article]: https://go.dev/doc/articles/race_detector
+
+const Compiler = "gc"
+const GOARCH string = goarch.GOARCH
+const GOOS string = goos.GOOS
+var MemProfileRate int = 512 * 1024
+func BlockProfile(p []BlockProfileRecord) (n int, ok bool)
+func Breakpoint()
+func CPUProfile() []byte
+func Caller(skip int) (pc uintptr, file string, line int, ok bool)
+func Callers(skip int, pc []uintptr) int
+func GC()
+func GOMAXPROCS(n int) int
+func GOROOT() string
+func Goexit()
+func GoroutineProfile(p []StackRecord) (n int, ok bool)
+func Gosched()
+func KeepAlive(x any)
+func LockOSThread()
+func MemProfile(p []MemProfileRecord, inuseZero bool) (n int, ok bool)
+func MutexProfile(p []BlockProfileRecord) (n int, ok bool)
+func NumCPU() int
+func NumCgoCall() int64
+func NumGoroutine() int
+func ReadMemStats(m *MemStats)
+func ReadTrace() []byte
+func SetBlockProfileRate(rate int)
+func SetCPUProfileRate(hz int)
+func SetCgoTraceback(version int, traceback, context, symbolizer unsafe.Pointer)
+func SetFinalizer(obj any, finalizer any)
+func SetMutexProfileFraction(rate int) int
+func Stack(buf []byte, all bool) int
+func StartTrace() error
+func StopTrace()
+func ThreadCreateProfile(p []StackRecord) (n int, ok bool)
+func UnlockOSThread()
+func Version() string
+type BlockProfileRecord struct{ ... }
+type Cleanup struct{ ... }
+    func AddCleanup[T, S any](ptr *T, cleanup func(S), arg S) Cleanup
+type Error interface{ ... }
+type Frame struct{ ... }
+type Frames struct{ ... }
+    func CallersFrames(callers []uintptr) *Frames
+type Func struct{ ... }
+    func FuncForPC(pc uintptr) *Func
+type MemProfileRecord struct{ ... }
+type MemStats struct{ ... }
+type PanicNilError struct{ ... }
+type Pinner struct{ ... }
+type StackRecord struct{ ... }
+type TypeAssertionError struct{ ... }

package/gs/runtime/index.ts

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

package/gs/runtime/runtime.ts

@@ -0,0 +1,178 @@
+// Runtime constants for the JavaScript/WebAssembly target
+export const GOOS = 'js'
+export const GOARCH = 'wasm'
+
+// Version returns the Go version as a string
+export const GOVERSION = 'go1.24.3'
+export function Version(): string {
+  return GOVERSION
+}
+
+// GOMAXPROCS sets the maximum number of operating system threads
+//
+// JavaScript is single threaded so this always returns 1.
+export function GOMAXPROCS(n: number): number {
+  // In a full implementation, we would set the max procs
+  // Since JavaScript only supports 1, just return 1.
+  return 1
+}
+
+// NumCPU returns the number of logical CPUs on the system.
+export function NumCPU(): number {
+  // In browser environment, use navigator.hardwareConcurrency if available
+  if (typeof navigator !== 'undefined' && navigator.hardwareConcurrency) {
+    return navigator.hardwareConcurrency
+  }
+
+  // Default to 1 if we can't determine
+  return 1
+}
+
+// GC runs a garbage collection and blocks the caller until the
+// garbage collection is complete. In JavaScript, we can suggest GC but not force it.
+export function GC(): void {
+  // In JavaScript, we can't force garbage collection
+  // Some engines have gc() function in development, but it's not standard
+  if (typeof globalThis.gc === 'function') {
+    ;(globalThis as any).gc()
+  }
+  // Otherwise, this is a no-op
+}
+
+// Gosched yields the processor, allowing other goroutines to run.
+// In JavaScript, we can use setTimeout(0) or queueMicrotask for similar effect
+export function Gosched(): Promise<void> {
+  return new Promise((resolve) => {
+    queueMicrotask(resolve)
+  })
+}
+
+// NumGoroutine returns the number of goroutines that currently exist.
+// In goscript, this is informational only
+let goroutineCount = 1 // Start with main goroutine
+
+export function NumGoroutine(): number {
+  return goroutineCount
+}
+
+// Internal function to track goroutine creation (called by goscript runtime)
+export function _incrementGoroutineCount(): void {
+  goroutineCount++
+}
+
+// Internal function to track goroutine completion (called by goscript runtime)
+export function _decrementGoroutineCount(): void {
+  if (goroutineCount > 0) {
+    goroutineCount--
+  }
+}
+
+// Caller returns details about the calling goroutine's stack.
+// This is a simplified version for goscript
+export function Caller(skip: number): [number, string, number, boolean] {
+  // In JavaScript, we can use Error stack trace, but it's limited
+  // Return dummy values for goscript compatibility
+  const pc = 0 // program counter (not meaningful in JS)
+  const file = 'unknown'
+  const line = 0
+  const ok = false // indicate we don't have real stack info
+  return [pc, file, line, ok]
+}
+
+// Stack returns a formatted stack trace of the calling goroutine.
+// In JavaScript, we use Error.stack
+export function Stack(): Uint8Array {
+  const stack = new Error().stack || 'stack trace unavailable'
+  const encoder = new TextEncoder()
+  return encoder.encode(stack)
+}
+
+// MemStats represents memory allocation statistics
+export class MemStats {
+  // Simplified memory stats for goscript
+  public Alloc: number = 0 // bytes allocated and not yet freed
+  public TotalAlloc: number = 0 // bytes allocated (even if freed)
+  public Sys: number = 0 // bytes obtained from system
+  public Lookups: number = 0 // number of pointer lookups
+  public Mallocs: number = 0 // number of mallocs
+  public Frees: number = 0 // number of frees
+
+  constructor() {
+    // Initialize with some default values
+    // In a real environment, these would be obtained from the JS runtime
+    this.updateMemoryStats()
+  }
+
+  private updateMemoryStats(): void {
+    // Use performance.memory if available (Chrome/Edge)
+    if (typeof performance !== 'undefined' && (performance as any).memory) {
+      const mem = (performance as any).memory
+      this.Alloc = mem.usedJSHeapSize || 0
+      this.Sys = mem.totalJSHeapSize || 0
+      this.TotalAlloc = this.Alloc // Simplified
+    }
+  }
+}
+
+// ReadMemStats populates m with memory allocator statistics
+export function ReadMemStats(m: MemStats): void {
+  // Update the provided MemStats object with current values
+  if (typeof performance !== 'undefined' && (performance as any).memory) {
+    const mem = (performance as any).memory
+    m.Alloc = mem.usedJSHeapSize || 0
+    m.Sys = mem.totalJSHeapSize || 0
+    m.TotalAlloc = m.Alloc // Simplified
+  }
+}
+
+// Error interface for runtime errors
+export interface Error {
+  Error(): string
+}
+
+// TypeAssertionError represents a failed type assertion
+export class TypeAssertionError implements Error {
+  constructor(
+    public readonly interfaceType: string,
+    public readonly concrete: string,
+    public readonly assertedType: string,
+    public readonly missingMethod?: string,
+  ) {}
+
+  Error(): string {
+    if (this.missingMethod) {
+      return `interface conversion: ${this.interfaceType} is ${this.concrete}, not ${this.assertedType} (missing ${this.missingMethod} method)`
+    }
+    return `interface conversion: ${this.interfaceType} is ${this.concrete}, not ${this.assertedType}`
+  }
+}
+
+// PanicError represents a panic
+export class PanicError implements Error {
+  constructor(public readonly value: any) {}
+
+  Error(): string {
+    return `panic: ${this.value}`
+  }
+}
+
+// SetFinalizer sets the finalizer associated with obj to the provided finalizer function.
+// In goscript/TypeScript environment, finalizers are not supported, so this throws an error.
+export function SetFinalizer(
+  obj: object,
+  finalizer: ((obj: object) => void) | null,
+): void {
+  throw new Error(
+    'runtime.SetFinalizer is not supported in goscript TypeScript environment',
+  )
+}
+
+// KeepAlive keeps obj reachable until the point where KeepAlive is called
+export function KeepAlive(obj: any): void {
+  // In JavaScript, just accessing the object keeps it alive for this call
+  // This is mostly a no-op but we touch the object to ensure it's not optimized away
+  if (obj !== null && obj !== undefined) {
+    // Touch the object to keep it alive
+    void obj
+  }
+}

package/gs/slices/godoc.txt

@@ -0,0 +1,44 @@
+package slices // import "slices"
+
+Package slices defines various functions useful with slices of any type.
+
+func All[Slice ~[]E, E any](s Slice) iter.Seq2[int, E]
+func AppendSeq[Slice ~[]E, E any](s Slice, seq iter.Seq[E]) Slice
+func Backward[Slice ~[]E, E any](s Slice) iter.Seq2[int, E]
+func BinarySearch[S ~[]E, E cmp.Ordered](x S, target E) (int, bool)
+func BinarySearchFunc[S ~[]E, E, T any](x S, target T, cmp func(E, T) int) (int, bool)
+func Chunk[Slice ~[]E, E any](s Slice, n int) iter.Seq[Slice]
+func Clip[S ~[]E, E any](s S) S
+func Clone[S ~[]E, E any](s S) S
+func Collect[E any](seq iter.Seq[E]) []E
+func Compact[S ~[]E, E comparable](s S) S
+func CompactFunc[S ~[]E, E any](s S, eq func(E, E) bool) S
+func Compare[S ~[]E, E cmp.Ordered](s1, s2 S) int
+func CompareFunc[S1 ~[]E1, S2 ~[]E2, E1, E2 any](s1 S1, s2 S2, cmp func(E1, E2) int) int
+func Concat[S ~[]E, E any](slices ...S) S
+func Contains[S ~[]E, E comparable](s S, v E) bool
+func ContainsFunc[S ~[]E, E any](s S, f func(E) bool) bool
+func Delete[S ~[]E, E any](s S, i, j int) S
+func DeleteFunc[S ~[]E, E any](s S, del func(E) bool) S
+func Equal[S ~[]E, E comparable](s1, s2 S) bool
+func EqualFunc[S1 ~[]E1, S2 ~[]E2, E1, E2 any](s1 S1, s2 S2, eq func(E1, E2) bool) bool
+func Grow[S ~[]E, E any](s S, n int) S
+func Index[S ~[]E, E comparable](s S, v E) int
+func IndexFunc[S ~[]E, E any](s S, f func(E) bool) int
+func Insert[S ~[]E, E any](s S, i int, v ...E) S
+func IsSorted[S ~[]E, E cmp.Ordered](x S) bool
+func IsSortedFunc[S ~[]E, E any](x S, cmp func(a, b E) int) bool
+func Max[S ~[]E, E cmp.Ordered](x S) E
+func MaxFunc[S ~[]E, E any](x S, cmp func(a, b E) int) E
+func Min[S ~[]E, E cmp.Ordered](x S) E
+func MinFunc[S ~[]E, E any](x S, cmp func(a, b E) int) E
+func Repeat[S ~[]E, E any](x S, count int) S
+func Replace[S ~[]E, E any](s S, i, j int, v ...E) S
+func Reverse[S ~[]E, E any](s S)
+func Sort[S ~[]E, E cmp.Ordered](x S)
+func SortFunc[S ~[]E, E any](x S, cmp func(a, b E) int)
+func SortStableFunc[S ~[]E, E any](x S, cmp func(a, b E) int)
+func Sorted[E cmp.Ordered](seq iter.Seq[E]) []E
+func SortedFunc[E any](seq iter.Seq[E], cmp func(E, E) int) []E
+func SortedStableFunc[E any](seq iter.Seq[E], cmp func(E, E) int) []E
+func Values[Slice ~[]E, E any](s Slice) iter.Seq[E]

package/gs/slices/index.ts

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

package/gs/slices/slices.ts

@@ -0,0 +1,22 @@
+// TypeScript implementation of Go's slices package
+import * as $ from '@goscript/builtin/builtin.js'
+
+/**
+ * All returns an iterator over index-value pairs in the slice.
+ * This is equivalent to Go's slices.All function.
+ * @param s The slice to iterate over
+ * @returns An iterator function that yields index-value pairs
+ */
+export function All<T>(
+  s: $.Slice<T>,
+): (yieldFunc: (index: number, value: T) => boolean) => void {
+  return function (_yield: (index: number, value: T) => boolean): void {
+    const length = $.len(s)
+    for (let i = 0; i < length; i++) {
+      const value = (s as any)[i] as T // Use proper indexing to avoid type issues
+      if (!_yield(i, value)) {
+        break
+      }
+    }
+  }
+}