goscript 0.0.33 → 0.0.35

package/gs/builtin/map.ts

@@ -6,18 +6,23 @@ export const makeMap = <K, V>(): Map<K, V> => {
   return new Map<K, V>()
 }
 /**
- * Gets a value from a map, with a default value if the key doesn't exist.
+ * Gets a value from a map, returning a tuple [value, exists].
  * @param map The map to get from.
  * @param key The key to get.
- * @param defaultValue The default value to return if the key doesn't exist (defaults to 0).
- * @returns The value for the key, or the default value if the key doesn't exist.
+ * @param defaultValue The default value to return if the key doesn't exist.
+ * @returns A tuple [value, exists] where value is the map value or defaultValue, and exists is whether the key was found.
  */
-export const mapGet = <K, V>(
+export function mapGet<K, V, D>(
   map: Map<K, V>,
   key: K,
-  defaultValue: V | null = null,
-): V | null => {
-  return map.has(key) ? map.get(key)! : defaultValue
+  defaultValue: D,
+): [V, true] | [D, false] {
+  const exists = map.has(key)
+  if (exists) {
+    return [map.get(key)!, true]
+  } else {
+    return [defaultValue, false]
+  }
 }
 
 /**

package/gs/builtin/slice.ts

@@ -65,6 +65,14 @@ function isComplexSlice<T>(slice: Slice<T>): slice is SliceProxy<T> {
   )
 }
 
+/**
+ * isSliceProxy checks if a slice is a SliceProxy (has __meta__ property)
+ * This is an alias for isComplexSlice for better type hinting
+ */
+export function isSliceProxy<T>(slice: Slice<T>): slice is SliceProxy<T> {
+  return isComplexSlice(slice)
+}
+
 /**
  * Creates a new slice with the specified length and capacity.
  * @param length The length of the slice.
@@ -77,9 +85,81 @@ export const makeSlice = <T>(
   typeHint?: string,
 ): Slice<T> => {
   if (typeHint === 'byte') {
-    // Uint8Array is initialized to zeros by default.
-    // Capacity for Uint8Array is its length.
-    return new Uint8Array(length) as Slice<T>
+    const actualCapacity = capacity === undefined ? length : capacity
+    if (length < 0 || actualCapacity < 0 || length > actualCapacity) {
+      throw new Error(
+        `Invalid slice length (${length}) or capacity (${actualCapacity})`,
+      )
+    }
+
+    // If capacity equals length, use Uint8Array directly for efficiency
+    if (actualCapacity === length) {
+      return new Uint8Array(length) as Slice<T>
+    }
+
+    // If capacity > length, create a SliceProxy backed by a Uint8Array
+    const backingUint8 = new Uint8Array(actualCapacity)
+    const backingNumbers = Array.from(backingUint8) as T[] // Convert to number[] for backing
+
+    const proxyTargetArray = new Array<T>(length)
+    for (let i = 0; i < length; i++) {
+      proxyTargetArray[i] = 0 as T // Initialize with zeros
+    }
+
+    const proxy = proxyTargetArray as SliceProxy<T>
+    proxy.__meta__ = {
+      backing: backingNumbers,
+      offset: 0,
+      length: length,
+      capacity: actualCapacity,
+    }
+
+    // Create a proper Proxy with the handler for SliceProxy behavior
+    const handler = {
+      get(target: any, prop: string | symbol): any {
+        if (typeof prop === 'string' && /^\d+$/.test(prop)) {
+          const index = Number(prop)
+          if (index >= 0 && index < target.__meta__.length) {
+            return target.__meta__.backing[target.__meta__.offset + index]
+          }
+          throw new Error(
+            `Slice index out of range: ${index} >= ${target.__meta__.length}`,
+          )
+        }
+
+        if (prop === 'length') {
+          return target.__meta__.length
+        }
+
+        if (prop === '__meta__') {
+          return target.__meta__
+        }
+
+        return Reflect.get(target, prop)
+      },
+
+      set(target: any, prop: string | symbol, value: any): boolean {
+        if (typeof prop === 'string' && /^\d+$/.test(prop)) {
+          const index = Number(prop)
+          if (index >= 0 && index < target.__meta__.length) {
+            target.__meta__.backing[target.__meta__.offset + index] = value
+            target[index] = value // Also update the proxy target for consistency
+            return true
+          }
+          throw new Error(
+            `Slice index out of range: ${index} >= ${target.__meta__.length}`,
+          )
+        }
+
+        if (prop === 'length' || prop === '__meta__') {
+          return false
+        }
+
+        return Reflect.set(target, prop, value)
+      },
+    }
+
+    return new Proxy(proxy, handler) as Slice<T>
   }
 
   const actualCapacity = capacity === undefined ? length : capacity
@@ -127,7 +207,52 @@ export const makeSlice = <T>(
     capacity: actualCapacity,
   }
 
-  return proxy
+  // Create a proper Proxy with the handler for SliceProxy behavior
+  const handler = {
+    get(target: any, prop: string | symbol): any {
+      if (typeof prop === 'string' && /^\d+$/.test(prop)) {
+        const index = Number(prop)
+        if (index >= 0 && index < target.__meta__.length) {
+          return target.__meta__.backing[target.__meta__.offset + index]
+        }
+        throw new Error(
+          `Slice index out of range: ${index} >= ${target.__meta__.length}`,
+        )
+      }
+
+      if (prop === 'length') {
+        return target.__meta__.length
+      }
+
+      if (prop === '__meta__') {
+        return target.__meta__
+      }
+
+      return Reflect.get(target, prop)
+    },
+
+    set(target: any, prop: string | symbol, value: any): boolean {
+      if (typeof prop === 'string' && /^\d+$/.test(prop)) {
+        const index = Number(prop)
+        if (index >= 0 && index < target.__meta__.length) {
+          target.__meta__.backing[target.__meta__.offset + index] = value
+          target[index] = value // Also update the proxy target for consistency
+          return true
+        }
+        throw new Error(
+          `Slice index out of range: ${index} >= ${target.__meta__.length}`,
+        )
+      }
+
+      if (prop === 'length' || prop === '__meta__') {
+        return false
+      }
+
+      return Reflect.set(target, prop, value)
+    },
+  }
+
+  return new Proxy(proxy, handler) as Slice<T>
 }
 
 /**
@@ -329,18 +454,22 @@ export const goSlice = <T>( // T can be number for Uint8Array case
   const newLength = high - low
   const newOffset = oldOffset + low
 
-  const target = {
-    __meta__: {
-      backing: backing,
-      offset: newOffset,
-      length: newLength,
-      capacity: newCap,
-    },
+  // Create an array-like target with the correct length
+  const proxyTargetArray = new Array<T>(newLength)
+  // Note: We don't need to initialize the values here since the proxy handler
+  // will fetch them from the backing array when accessed
+
+  const proxy = proxyTargetArray as SliceProxy<T>
+  proxy.__meta__ = {
+    backing: backing,
+    offset: newOffset,
+    length: newLength,
+    capacity: newCap,
   }
 
   // const handler = { ... } // Handler is now defined at the top
 
-  return new Proxy(target, handler) as unknown as SliceProxy<T>
+  return new Proxy(proxy, handler) as unknown as SliceProxy<T>
 }
 
 /**
@@ -522,10 +651,12 @@ export const cap = <T>(obj: Slice<T> | Uint8Array): number => {
  * @param elements The elements to append.
  * @returns The modified or new slice.
  */
-export const append = <T>(
+export function append(slice: Uint8Array, ...elements: any[]): Uint8Array
+export function append<T>(slice: Slice<T>, ...elements: any[]): Slice<T>
+export function append<T>(
   slice: Slice<T> | Uint8Array,
   ...elements: any[]
-): Slice<T> => {
+): Slice<T> {
   // 1. Flatten all elements from the varargs `...elements` into `varargsElements`.
   // Determine if the result should be a Uint8Array.
   const inputIsUint8Array = slice instanceof Uint8Array
@@ -581,7 +712,7 @@ export const append = <T>(
     }
     const newArr = new Uint8Array(combinedBytes.length)
     newArr.set(combinedBytes)
-    return newArr as Slice<T>
+    return newArr as any
   }
 
   // Handle generic Slice<T> (non-Uint8Array result).
@@ -590,7 +721,7 @@ export const append = <T>(
   const numAdded = elements.length
 
   if (numAdded === 0) {
-    return slice
+    return slice as any
   }
 
   let originalElements: T[] = []
@@ -631,7 +762,7 @@ export const append = <T>(
       length: newLength,
       capacity: oldCapacity,
     }
-    return resultProxy
+    return resultProxy as any
   }
 
   // Case 2: Reallocation is needed.
@@ -663,7 +794,7 @@ export const append = <T>(
     length: newLength,
     capacity: newCapacity,
   }
-  return resultProxy
+  return resultProxy as any
 }
 
 /**
@@ -910,8 +1041,7 @@ export const sliceString = (
     // Attempt to decode with strict UTF-8 validation
     const result = new TextDecoder('utf-8', { fatal: true }).decode(slicedBytes)
     return result
-  } catch (_e) {
-    //eslint-disable-line @typescript-eslint/no-unused-vars
+  } catch (_e) { //eslint-disable-line @typescript-eslint/no-unused-vars
     // If we get here, the slice would create invalid UTF-8
     // This is a fundamental limitation of JavaScript string handling
     throw new Error(
@@ -975,20 +1105,20 @@ export function genericBytesOrStringToString(
 }
 
 /**
- * Indexes into a value that could be either a string or Uint8Array.
+ * Indexes into a value that could be either a string or bytes.
  * Used for generic type parameters with constraint string | []byte.
  * Both cases return a byte value (number).
- * @param value Value that is either a string or Uint8Array
+ * @param value Value that is either a string or bytes (Uint8Array or Slice<number>)
  * @param index The index to access
  * @returns The byte value at the specified index
  */
 export function indexStringOrBytes(
-  value: string | Uint8Array,
+  value: string | import('./builtin.js').Bytes,
   index: number,
 ): number {
   if (typeof value === 'string') {
     return indexString(value, index)
-  } else {
+  } else if (value instanceof Uint8Array) {
     // For Uint8Array, direct access returns the byte value
     if (index < 0 || index >= value.length) {
       throw new Error(
@@ -996,29 +1126,39 @@ export function indexStringOrBytes(
       )
     }
     return value[index]
+  } else if (value === null) {
+    throw new Error(
+      `runtime error: index out of range [${index}] with length 0`,
+    )
+  } else {
+    // For Slice<number> (including SliceProxy)
+    const length = len(value)
+    if (index < 0 || index >= length) {
+      throw new Error(
+        `runtime error: index out of range [${index}] with length ${length}`,
+      )
+    }
+    return (value as any)[index] as number
   }
 }
 
 /**
- * Slices a value that could be either a string or Uint8Array.
+ * Slices a value that could be either a string or bytes.
  * Used for generic type parameters with constraint string | []byte.
- * @param value Value that is either a string or Uint8Array
+ * @param value Value that is either a string or bytes (Uint8Array or Slice<number>)
  * @param low Starting index (inclusive). Defaults to 0.
  * @param high Ending index (exclusive). Defaults to length.
- * @param max Capacity limit (only used for Uint8Array, ignored for strings)
+ * @param max Capacity limit (only used for bytes, ignored for strings)
  * @returns The sliced value of the same type as input
  */
-export function sliceStringOrBytes<T extends string | Uint8Array>(
-  value: T,
-  low?: number,
-  high?: number,
-  max?: number,
-): T {
+export function sliceStringOrBytes<
+  T extends string | import('./builtin.js').Bytes,
+>(value: T, low?: number, high?: number, max?: number): T {
   if (typeof value === 'string') {
     // For strings, use sliceString and ignore max parameter
     return sliceString(value, low, high) as T
   } else {
-    // For Uint8Array, use goSlice
+    // For bytes (Uint8Array or Slice<number>), use goSlice
     return goSlice(value as Slice<number>, low, high, max) as T
   }
 }

package/gs/github.com/pkg/errors/errors.ts

@@ -0,0 +1,307 @@
+import * as $ from "../../../builtin/builtin.js";
+import { callers } from "./stack.js";
+
+// Type definitions
+export type Frame = any; // Simplified frame type
+export type StackTrace = Frame[] | null;
+export type stack = any; // Simplified stack type
+export type uintptr = number;
+
+// Simplified fmt functions for basic string formatting
+const fmt = {
+  Sprintf: (format: string, ...args: any[]): string => {
+    // Basic sprintf implementation for the errors package
+    let result = format;
+    let argIndex = 0;
+    result = result.replace(/%[sdqv%]/g, (match) => {
+      if (match === '%%') return '%';
+      if (argIndex >= args.length) return match;
+      const arg = args[argIndex++];
+      switch (match) {
+        case '%s': return String(arg);
+        case '%d': return String(Number(arg));
+        case '%q': return JSON.stringify(String(arg));
+        case '%v': return String(arg);
+        default: return match;
+      }
+    });
+    return result;
+  }
+};
+
+// New returns an error with the supplied message.
+// New also records the stack trace at the point it was called.
+export function New(message: string): $.GoError {
+	return new fundamental({msg: message, stack: callers()})
+}
+
+// Errorf formats according to a format specifier and returns the string
+// as a value that satisfies error.
+// Errorf also records the stack trace at the point it was called.
+export function Errorf(format: string, ...args: any[]): $.GoError {
+	return new fundamental({msg: fmt.Sprintf(format, ...args), stack: callers()})
+}
+
+class fundamental {
+	public get msg(): string {
+		return this._fields.msg.value
+	}
+	public set msg(value: string) {
+		this._fields.msg.value = value
+	}
+
+	public get stack(): $.VarRef<stack> | null {
+		return this._fields.stack.value
+	}
+	public set stack(value: $.VarRef<stack> | null) {
+		this._fields.stack.value = value
+	}
+
+	public _fields: {
+		msg: $.VarRef<string>;
+		stack: $.VarRef<$.VarRef<stack> | null>;
+	}
+
+	constructor(init?: Partial<{msg?: string, stack?: $.VarRef<stack> | null}>) {
+		this._fields = {
+			msg: $.varRef(init?.msg ?? ""),
+			stack: $.varRef(init?.stack ?? null)
+		}
+	}
+
+	public clone(): fundamental {
+		const cloned = new fundamental()
+		cloned._fields = {
+			msg: $.varRef(this._fields.msg.value),
+			stack: $.varRef(this._fields.stack.value)
+		}
+		return cloned
+	}
+
+	public Error(): string {
+		const f = this
+		return f!.msg
+	}
+
+	public StackTrace(): StackTrace {
+		return null; // Simplified - no stack trace for now
+	}
+
+	// Register this type with the runtime type system
+	static __typeInfo = $.registerStructType(
+	  'fundamental',
+	  new fundamental(),
+	  [{ name: "Error", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "string" } }] }],
+	  fundamental,
+	  {"msg": { kind: $.TypeKind.Basic, name: "string" }, "stack": { kind: $.TypeKind.Pointer, elemType: "stack" }}
+	);
+}
+
+// WithStack annotates err with a stack trace at the point WithStack was called.
+// If err is nil, WithStack returns nil.
+export function WithStack(err: $.GoError): $.GoError {
+	if (err == null) {
+		return null
+	}
+	return new withStack({error: err, stack: callers()})
+}
+
+class withStack {
+	public get error(): $.GoError {
+		return this._fields.error.value
+	}
+	public set error(value: $.GoError) {
+		this._fields.error.value = value
+	}
+
+	public get stack(): $.VarRef<stack> | null {
+		return this._fields.stack.value
+	}
+	public set stack(value: $.VarRef<stack> | null) {
+		this._fields.stack.value = value
+	}
+
+	public _fields: {
+		error: $.VarRef<$.GoError>;
+		stack: $.VarRef<$.VarRef<stack> | null>;
+	}
+
+	constructor(init?: Partial<{error?: $.GoError, stack?: $.VarRef<stack> | null}>) {
+		this._fields = {
+			error: $.varRef(init?.error ?? null),
+			stack: $.varRef(init?.stack ?? null)
+		}
+	}
+
+	public clone(): withStack {
+		const cloned = new withStack()
+		cloned._fields = {
+			error: $.varRef(this._fields.error.value),
+			stack: $.varRef(this._fields.stack.value)
+		}
+		return cloned
+	}
+
+	public Cause(): $.GoError {
+		const w = this
+		return w!.error
+	}
+
+	// Unwrap provides compatibility for Go 1.13 error chains.
+	public Unwrap(): $.GoError {
+		const w = this
+		return w!.error
+	}
+
+	public Error(): string {
+		return this.error?.Error() ?? ""
+	}
+
+	public StackTrace(): StackTrace {
+		return null; // Simplified - no stack trace for now
+	}
+
+	// Register this type with the runtime type system
+	static __typeInfo = $.registerStructType(
+	  'withStack',
+	  new withStack(),
+	  [{ name: "Cause", args: [], returns: [{ type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "Unwrap", args: [], returns: [{ type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }],
+	  withStack,
+	  {"error": { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] }, "stack": { kind: $.TypeKind.Pointer, elemType: "stack" }}
+	);
+}
+
+// Wrap returns an error annotating err with a stack trace
+// at the point Wrap is called, and the supplied message.
+// If err is nil, Wrap returns nil.
+export function Wrap(err: $.GoError, message: string): $.GoError {
+	if (err == null) {
+		return null
+	}
+	const wrappedErr = new withMessage({cause: err, msg: message})
+	return new withStack({error: wrappedErr, stack: callers()})
+}
+
+// Wrapf returns an error annotating err with a stack trace
+// at the point Wrapf is called, and the format specifier.
+// If err is nil, Wrapf returns nil.
+export function Wrapf(err: $.GoError, format: string, ...args: any[]): $.GoError {
+	if (err == null) {
+		return null
+	}
+	const wrappedErr = new withMessage({cause: err, msg: fmt.Sprintf(format, ...args)})
+	return new withStack({error: wrappedErr, stack: callers()})
+}
+
+// WithMessage annotates err with a new message.
+// If err is nil, WithMessage returns nil.
+export function WithMessage(err: $.GoError, message: string): $.GoError {
+	if (err == null) {
+		return null
+	}
+	return new withMessage({cause: err, msg: message})
+}
+
+// WithMessagef annotates err with the format specifier.
+// If err is nil, WithMessagef returns nil.
+export function WithMessagef(err: $.GoError, format: string, ...args: any[]): $.GoError {
+	if (err == null) {
+		return null
+	}
+	return new withMessage({cause: err, msg: fmt.Sprintf(format, ...args)})
+}
+
+class withMessage {
+	public get cause(): $.GoError {
+		return this._fields.cause.value
+	}
+	public set cause(value: $.GoError) {
+		this._fields.cause.value = value
+	}
+
+	public get msg(): string {
+		return this._fields.msg.value
+	}
+	public set msg(value: string) {
+		this._fields.msg.value = value
+	}
+
+	public _fields: {
+		cause: $.VarRef<$.GoError>;
+		msg: $.VarRef<string>;
+	}
+
+	constructor(init?: Partial<{cause?: $.GoError, msg?: string}>) {
+		this._fields = {
+			cause: $.varRef(init?.cause ?? null),
+			msg: $.varRef(init?.msg ?? "")
+		}
+	}
+
+	public clone(): withMessage {
+		const cloned = new withMessage()
+		cloned._fields = {
+			cause: $.varRef(this._fields.cause.value),
+			msg: $.varRef(this._fields.msg.value)
+		}
+		return cloned
+	}
+
+	public Error(): string {
+		const w = this
+		return w!.msg + ": " + w!.cause!.Error()
+	}
+
+	public Cause(): $.GoError {
+		const w = this
+		return w!.cause
+	}
+
+	// Unwrap provides compatibility for Go 1.13 error chains.
+	public Unwrap(): $.GoError {
+		const w = this
+		return w!.cause
+	}
+
+	// Register this type with the runtime type system
+	static __typeInfo = $.registerStructType(
+	  'withMessage',
+	  new withMessage(),
+	  [{ name: "Error", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "string" } }] }, { name: "Cause", args: [], returns: [{ type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "Unwrap", args: [], returns: [{ type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }],
+	  withMessage,
+	  {"cause": { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] }, "msg": { kind: $.TypeKind.Basic, name: "string" }}
+	);
+}
+
+// Cause returns the underlying cause of the error, if possible.
+// An error value has a cause if it implements the following
+// interface:
+//
+//     type causer interface {
+//            Cause() error
+//     }
+//
+// If the error does not implement Cause, the original error will
+// be returned. If the error is nil, nil will be returned without further
+// investigation.
+export function Cause(err: $.GoError): $.GoError {
+	type causer = null | {
+		Cause(): $.GoError
+	}
+
+	$.registerInterfaceType(
+	  'causer',
+	  null, // Zero value for interface is null
+	  [{ name: "Cause", args: [], returns: [{ type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }]
+	);
+
+	for (; err != null; ) {
+		let { value: cause, ok: ok } = $.typeAssert<causer>(err, 'causer')
+		if (!ok) {
+			break
+		}
+		err = cause!.Cause()
+	}
+	return err
+}
+

package/gs/github.com/pkg/errors/go113.ts

@@ -0,0 +1,39 @@
+import * as $ from "../../../builtin/builtin.js";
+
+import * as stderrors from "../../../errors/index.js"
+
+// Is reports whether any error in err's chain matches target.
+//
+// The chain consists of err itself followed by the sequence of errors obtained by
+// repeatedly calling Unwrap.
+//
+// An error is considered to match a target if it is equal to that target or if
+// it implements a method Is(error) bool such that Is(target) returns true.
+export function Is(err: $.GoError, target: $.GoError): boolean {
+	return stderrors.Is(err, target)
+}
+
+// As finds the first error in err's chain that matches target, and if so, sets
+// target to that error value and returns true.
+//
+// The chain consists of err itself followed by the sequence of errors obtained by
+// repeatedly calling Unwrap.
+//
+// An error matches target if the error's concrete value is assignable to the value
+// pointed to by target, or if the error has a method As(interface{}) bool such that
+// As(target) returns true. In the latter case, the As method is responsible for
+// setting target.
+//
+// As will panic if target is not a non-nil pointer to either a type that implements
+// error, or to any interface type. As returns false if err is nil.
+export function As(err: $.GoError, target: null | any): boolean {
+	return stderrors.As(err, target)
+}
+
+// Unwrap returns the result of calling the Unwrap method on err, if err's
+// type contains an Unwrap method returning error.
+// Otherwise, Unwrap returns nil.
+export function Unwrap(err: $.GoError): $.GoError {
+	return stderrors.Unwrap(err)
+}
+

package/gs/github.com/pkg/errors/index.ts

@@ -0,0 +1,3 @@
+export { Cause, Errorf, New, WithMessage, WithMessagef, WithStack, Wrap, Wrapf } from "./errors.js"
+export { As, Is, Unwrap } from "./go113.js"
+export { Frame, StackTrace } from "./stack.js"