goscript 0.0.34 → 0.0.36

package/gs/builtin/builtin.ts

@@ -5,10 +5,12 @@ export * from './io.js'
 export * from './map.js'
 export * from './slice.js'
 export * from './type.js'
+import type { Slice, SliceProxy } from './slice.js'
+import { isSliceProxy } from './slice.js'
 
 // Bytes represents all valid []byte representations in TypeScript
 // This includes Uint8Array (the preferred representation) and $.Slice<number> (which includes null)
-export type Bytes = Uint8Array | import('./slice.js').Slice<number>
+export type Bytes = Uint8Array | Slice<number>
 
 // int converts a value to a Go int type, handling proper signed integer conversion
 // This ensures that values like 2147483648 (2^31) are properly handled according to Go semantics
@@ -179,24 +181,24 @@ export function normalizeBytes(
  * Handles all slice types including null, arrays, Uint8Array, and SliceProxy.
  * @param s The slice to sort in place
  */
-export function sortSlice<T extends string | number>(s: import('./slice.js').Slice<T>): void {
+export function sortSlice<T extends string | number>(s: Slice<T>): void {
   if (s === null || s === undefined) {
     return // Nothing to sort for nil slice
   }
-  
+
   if (Array.isArray(s)) {
     s.sort()
     return
   }
-  
+
   if (s instanceof Uint8Array) {
     s.sort()
     return
   }
-  
+
   // Handle SliceProxy case - sort the backing array in-place within the slice bounds
-  if (s && typeof s === 'object' && '__meta__' in s) {
-    const proxy = s as import('./slice.js').SliceProxy<T>
+  if (isSliceProxy(s)) {
+    const proxy = s as SliceProxy<T>
     const meta = proxy.__meta__
     const section = meta.backing.slice(meta.offset, meta.offset + meta.length)
     section.sort()

package/gs/builtin/map.ts

@@ -12,7 +12,11 @@ export const makeMap = <K, V>(): Map<K, V> => {
  * @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 function mapGet<K, V, D>(map: Map<K, V>, key: K, defaultValue: D): [V, true] | [D, false] {
+export function mapGet<K, V, D>(
+  map: Map<K, V>,
+  key: K,
+  defaultValue: D,
+): [V, true] | [D, false] {
   const exists = map.has(key)
   if (exists) {
     return [map.get(key)!, true]

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
 }
 
 /**
@@ -1020,12 +1151,9 @@ export function indexStringOrBytes(
  * @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 | import('./builtin.js').Bytes>(
-  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

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"