goscript 0.0.37 → 0.0.39

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

@@ -1,6 +1,6 @@
-import * as $ from "../../../builtin/builtin.js";
+import * as $ from '../../../builtin/builtin.js'
 
-import * as stderrors from "../../../errors/index.js"
+import * as stderrors from '../../../errors/index.js'
 
 // Is reports whether any error in err's chain matches target.
 //
@@ -10,7 +10,7 @@ import * as stderrors from "../../../errors/index.js"
 // 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)
+  return stderrors.Is(err, target)
 }
 
 // As finds the first error in err's chain that matches target, and if so, sets
@@ -27,13 +27,12 @@ export function Is(err: $.GoError, target: $.GoError): boolean {
 // 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)
+  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)
+  return stderrors.Unwrap(err)
 }
-

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

@@ -1,3 +1,12 @@
-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"
+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'

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

@@ -1,127 +1,129 @@
-import * as $ from "../../../builtin/builtin.js";
+import * as $ from '../../../builtin/builtin.js'
 
 // Type definitions
-export type uintptr = number;
+export type uintptr = number
 
 export class Frame {
-	constructor(private _value: uintptr) {}
-
-	valueOf(): uintptr {
-		return this._value
-	}
-
-	toString(): string {
-		return String(this._value)
-	}
-
-	static from(value: uintptr): Frame {
-		return new Frame(value)
-	}
-
-	// pc returns the program counter for this frame;
-	// multiple frames may have the same PC value.
-	public pc(): uintptr {
-		return this._value - 1
-	}
-
-	// file returns the full path to the file that contains the
-	// function for this Frame's pc.
-	public file(): string {
-		return "unknown"
-	}
-
-	// line returns the line number of source code of the
-	// function for this Frame's pc.
-	public line(): number {
-		return 0
-	}
-
-	// name returns the name of this function, if known.
-	public name(): string {
-		return "unknown"
-	}
-
-	// MarshalText formats a stacktrace Frame as a text string.
-	public MarshalText(): [$.Bytes, $.GoError] {
-		const name = this.name()
-		if (name == "unknown") {
-			return [new TextEncoder().encode(name), null]
-		}
-		return [new TextEncoder().encode(`${name} ${this.file()}:${this.line()}`), null]
-	}
+  constructor(private _value: uintptr) {}
+
+  valueOf(): uintptr {
+    return this._value
+  }
+
+  toString(): string {
+    return String(this._value)
+  }
+
+  static from(value: uintptr): Frame {
+    return new Frame(value)
+  }
+
+  // pc returns the program counter for this frame;
+  // multiple frames may have the same PC value.
+  public pc(): uintptr {
+    return this._value - 1
+  }
+
+  // file returns the full path to the file that contains the
+  // function for this Frame's pc.
+  public file(): string {
+    return 'unknown'
+  }
+
+  // line returns the line number of source code of the
+  // function for this Frame's pc.
+  public line(): number {
+    return 0
+  }
+
+  // name returns the name of this function, if known.
+  public name(): string {
+    return 'unknown'
+  }
+
+  // MarshalText formats a stacktrace Frame as a text string.
+  public MarshalText(): [$.Bytes, $.GoError] {
+    const name = this.name()
+    if (name == 'unknown') {
+      return [new TextEncoder().encode(name), null]
+    }
+    return [
+      new TextEncoder().encode(`${name} ${this.file()}:${this.line()}`),
+      null,
+    ]
+  }
 }
 
 export class StackTrace {
-	constructor(private _value: Frame[] | null) {}
+  constructor(private _value: Frame[] | null) {}
 
-	valueOf(): Frame[] | null {
-		return this._value
-	}
+  valueOf(): Frame[] | null {
+    return this._value
+  }
 
-	toString(): string {
-		return String(this._value)
-	}
+  toString(): string {
+    return String(this._value)
+  }
 
-	static from(value: Frame[] | null): StackTrace {
-		return new StackTrace(value)
-	}
+  static from(value: Frame[] | null): StackTrace {
+    return new StackTrace(value)
+  }
 }
 
 class stack {
-	constructor(private _value: uintptr[]) {}
-
-	valueOf(): uintptr[] {
-		return this._value
-	}
-
-	toString(): string {
-		return String(this._value)
-	}
-
-	static from(value: uintptr[]): stack {
-		return new stack(value)
-	}
-
-	public StackTrace(): StackTrace {
-		const s = this._value
-		if (!s || s.length === 0) {
-			return new StackTrace(null)
-		}
-		
-		const frames: Frame[] = []
-		for (let i = 0; i < s.length; i++) {
-			frames.push(new Frame(s[i]))
-		}
-		return new StackTrace(frames)
-	}
+  constructor(private _value: uintptr[]) {}
+
+  valueOf(): uintptr[] {
+    return this._value
+  }
+
+  toString(): string {
+    return String(this._value)
+  }
+
+  static from(value: uintptr[]): stack {
+    return new stack(value)
+  }
+
+  public StackTrace(): StackTrace {
+    const s = this._value
+    if (!s || s.length === 0) {
+      return new StackTrace(null)
+    }
+
+    const frames: Frame[] = []
+    for (let i = 0; i < s.length; i++) {
+      frames.push(new Frame(s[i]))
+    }
+    return new StackTrace(frames)
+  }
 }
 
 // callers returns a simplified stack trace using JavaScript's native stack
 export function callers(): $.VarRef<stack> | null {
-	try {
-		// Get JavaScript stack trace
-		throw new Error();
-	} catch(e: any) {
-		// Parse the stack trace to get some basic frame information
-		const stackLines = e.stack ? e.stack.split('\n') : []
-		
-		// Create simplified frame data - just use line numbers as uintptr values
-		const pcs: uintptr[] = []
-		for (let i = 0; i < Math.min(stackLines.length, 8); i++) {
-			pcs.push(i + 1) // Simple frame counter
-		}
-		
-		const st = new stack(pcs)
-		return $.varRef(st)
-	}
+  try {
+    // Get JavaScript stack trace
+    throw new Error()
+  } catch (e: any) {
+    // Parse the stack trace to get some basic frame information
+    const stackLines = e.stack ? e.stack.split('\n') : []
+
+    // Create simplified frame data - just use line numbers as uintptr values
+    const pcs: uintptr[] = []
+    for (let i = 0; i < Math.min(stackLines.length, 8); i++) {
+      pcs.push(i + 1) // Simple frame counter
+    }
+
+    const st = new stack(pcs)
+    return $.varRef(st)
+  }
 }
 
 // funcname extracts the function name from a full function path
 export function funcname(name: string): string {
-	const lastDot = name.lastIndexOf('.')
-	if (lastDot >= 0) {
-		return name.substring(lastDot + 1)
-	}
-	return name
+  const lastDot = name.lastIndexOf('.')
+  if (lastDot >= 0) {
+    return name.substring(lastDot + 1)
+  }
+  return name
 }
-

package/gs/internal/abi/index.ts

@@ -0,0 +1,37 @@
+// Placeholder abi module for reflect package compatibility
+
+// Type represents the ABI type information
+export interface Type {
+  Size_: number
+  PtrBytes: number
+  Hash: number
+  TFlag: number
+  Align_: number
+  FieldAlign_: number
+  Kind_: number
+}
+
+// RegArgs represents register arguments
+export interface RegArgs {
+  Ptrs?: any[]
+  Ints?: any[]
+}
+
+// IntArgRegBitmap represents register usage for integer arguments
+export class IntArgRegBitmap {
+  constructor(public value: number = 0) {}
+
+  Get(index: number): boolean {
+    return (this.value & (1 << index)) !== 0
+  }
+}
+
+// FuncPCABI0 returns the entry PC of the function f for ABI0
+export function FuncPCABI0(_f: any): number {
+  return 0 // Placeholder
+}
+
+// FuncPCABIInternal returns the entry PC of the function f for the internal ABI
+export function FuncPCABIInternal(_f: any): number {
+  return 0 // Placeholder
+}

package/gs/internal/bytealg/index.ts

@@ -0,0 +1,149 @@
+// Placeholder bytealg module for reflect package compatibility
+
+// Helper function to normalize bytes input
+function normalizeBytes(b: any): any[] {
+  if (b === null || b === undefined) {
+    return []
+  }
+  if (Array.isArray(b)) {
+    return b
+  }
+  if (b instanceof Uint8Array) {
+    return Array.from(b)
+  }
+  if (b && typeof b === 'object' && 'data' in b && Array.isArray(b.data)) {
+    return b.data
+  }
+  return []
+}
+
+// Equal reports whether a and b are the same length and contain the same bytes.
+export function Equal(a: any, b: any): boolean {
+  const aNorm = normalizeBytes(a)
+  const bNorm = normalizeBytes(b)
+  if (aNorm.length !== bNorm.length) {
+    return false
+  }
+  for (let i = 0; i < aNorm.length; i++) {
+    if (aNorm[i] !== bNorm[i]) {
+      return false
+    }
+  }
+  return true
+}
+
+// Compare returns an integer comparing two byte slices lexicographically.
+export function Compare(a: any, b: any): number {
+  const aNorm = normalizeBytes(a)
+  const bNorm = normalizeBytes(b)
+  const minLen = Math.min(aNorm.length, bNorm.length)
+  for (let i = 0; i < minLen; i++) {
+    if (aNorm[i] < bNorm[i]) {
+      return -1
+    }
+    if (aNorm[i] > bNorm[i]) {
+      return 1
+    }
+  }
+  if (aNorm.length < bNorm.length) {
+    return -1
+  }
+  if (aNorm.length > bNorm.length) {
+    return 1
+  }
+  return 0
+}
+
+// Additional functions needed by bytes package
+export function Count(s: any, b: number): number {
+  const sNorm = normalizeBytes(s)
+  let count = 0
+  for (let i = 0; i < sNorm.length; i++) {
+    if (sNorm[i] === b) {
+      count++
+    }
+  }
+  return count
+}
+
+export function IndexByte(s: any, b: number): number {
+  const sNorm = normalizeBytes(s)
+  for (let i = 0; i < sNorm.length; i++) {
+    if (sNorm[i] === b) {
+      return i
+    }
+  }
+  return -1
+}
+
+export function LastIndexByte(s: any, b: number): number {
+  const sNorm = normalizeBytes(s)
+  for (let i = sNorm.length - 1; i >= 0; i--) {
+    if (sNorm[i] === b) {
+      return i
+    }
+  }
+  return -1
+}
+
+export function Index(s: any, sep: any): number {
+  const sNorm = normalizeBytes(s)
+  const sepNorm = normalizeBytes(sep)
+  if (sepNorm.length === 0) return 0
+  if (sepNorm.length > sNorm.length) return -1
+
+  for (let i = 0; i <= sNorm.length - sepNorm.length; i++) {
+    let found = true
+    for (let j = 0; j < sepNorm.length; j++) {
+      if (sNorm[i + j] !== sepNorm[j]) {
+        found = false
+        break
+      }
+    }
+    if (found) return i
+  }
+  return -1
+}
+
+export function LastIndexRabinKarp(s: any, sep: any): number {
+  const sNorm = normalizeBytes(s)
+  const sepNorm = normalizeBytes(sep)
+  // Simple implementation
+  for (let i = sNorm.length - sepNorm.length; i >= 0; i--) {
+    let found = true
+    for (let j = 0; j < sepNorm.length; j++) {
+      if (sNorm[i + j] !== sepNorm[j]) {
+        found = false
+        break
+      }
+    }
+    if (found) return i
+  }
+  return -1
+}
+
+export function IndexRabinKarp(s: any, sep: any): number {
+  return Index(s, sep)
+}
+
+export function IndexByteString(s: string, b: number): number {
+  const char = String.fromCharCode(b)
+  return s.indexOf(char)
+}
+
+export function IndexString(s: string, substr: string): number {
+  return s.indexOf(substr)
+}
+
+export function MakeNoZero(n: number): Uint8Array {
+  return new Uint8Array(n)
+}
+
+export function Cutover(_n: number): number {
+  // TODO: Implement Cutover function
+  return 10 // Simple threshold
+}
+
+// Constants needed by bytes package
+export const MaxBruteForce = 64
+export const MaxLen = 32

package/gs/internal/byteorder/index.ts

@@ -1,4 +1,4 @@
-import * as $ from "@goscript/builtin/builtin.js";
+import * as $ from '@goscript/builtin/builtin.js'
 
 // Stub implementations for internal/byteorder package
 export function LittleEndian(): boolean {
@@ -19,10 +19,10 @@ export function BEUint64(b: $.Bytes): number {
   // For our stub purposes, this should be sufficient
   let high = BEUint32(b)
   let low = BEUint32($.goSlice(b, 4, undefined))
-  return (high * 0x100000000) + low
+  return high * 0x100000000 + low
 }
 
-// Little Endian byte order functions  
+// Little Endian byte order functions
 export function LEUint16(b: $.Bytes): number {
   return b![0] | (b![1] << 8)
 }
@@ -36,5 +36,5 @@ export function LEUint64(b: $.Bytes): number {
   // For our stub purposes, this should be sufficient
   let low = LEUint32(b)
   let high = LEUint32($.goSlice(b, 4, undefined))
-  return low + (high * 0x100000000)
-} 
+  return low + high * 0x100000000
+}

package/gs/math/abs.gs.test.ts

@@ -26,4 +26,4 @@ describe('Abs', () => {
     expect(Abs(Number.MIN_VALUE)).toBe(Number.MIN_VALUE)
     expect(Abs(-Number.MIN_VALUE)).toBe(Number.MIN_VALUE)
   })
-}) 
+})

package/gs/math/acosh.gs.test.ts

@@ -34,6 +34,8 @@ describe('acosh', () => {
     expect(acosh(1)).toBe(Acosh(1))
     expect(acosh(2)).toBe(Acosh(2))
     expect(acosh(10)).toBe(Acosh(10))
-    expect(acosh(Number.POSITIVE_INFINITY)).toBe(Acosh(Number.POSITIVE_INFINITY))
+    expect(acosh(Number.POSITIVE_INFINITY)).toBe(
+      Acosh(Number.POSITIVE_INFINITY),
+    )
   })
-}) 
+})

package/gs/math/asin.gs.test.ts

@@ -63,4 +63,4 @@ describe('acos', () => {
     expect(acos(-1)).toBe(Acos(-1))
     expect(acos(0.5)).toBe(Acos(0.5))
   })
-}) 
+})

package/gs/math/asinh.gs.test.ts

@@ -22,7 +22,9 @@ describe('Asinh', () => {
     const resultPos = Asinh(Number.MAX_VALUE)
     expect(resultPos > 700 || resultPos === Number.POSITIVE_INFINITY).toBe(true)
     const resultNeg = Asinh(-Number.MAX_VALUE)
-    expect(resultNeg < -700 || resultNeg === Number.NEGATIVE_INFINITY).toBe(true)
+    expect(resultNeg < -700 || resultNeg === Number.NEGATIVE_INFINITY).toBe(
+      true,
+    )
     expect(Asinh(Number.MIN_VALUE)).toBeCloseTo(Number.MIN_VALUE, 14)
   })
 })
@@ -32,6 +34,8 @@ describe('asinh', () => {
     expect(asinh(0)).toBe(Asinh(0))
     expect(asinh(1)).toBe(Asinh(1))
     expect(asinh(-1)).toBe(Asinh(-1))
-    expect(asinh(Number.POSITIVE_INFINITY)).toBe(Asinh(Number.POSITIVE_INFINITY))
+    expect(asinh(Number.POSITIVE_INFINITY)).toBe(
+      Asinh(Number.POSITIVE_INFINITY),
+    )
   })
-}) 
+})

package/gs/math/atan.gs.test.ts

@@ -46,4 +46,4 @@ describe('satan', () => {
     expect(satan(1)).toBeCloseTo(Math.atan(1), 15)
     expect(satan(2)).toBeCloseTo(Math.atan(2), 15)
   })
-}) 
+})

package/gs/math/atan2.gs.test.ts

@@ -4,9 +4,9 @@ import { Atan2, atan2 } from './atan2.gs.js'
 describe('Atan2', () => {
   it('should return correct arctangent values for basic cases', () => {
     expect(Atan2(1, 1)).toBeCloseTo(Math.PI / 4, 15)
-    expect(Atan2(1, -1)).toBeCloseTo(3 * Math.PI / 4, 15)
+    expect(Atan2(1, -1)).toBeCloseTo((3 * Math.PI) / 4, 15)
     expect(Atan2(-1, 1)).toBeCloseTo(-Math.PI / 4, 15)
-    expect(Atan2(-1, -1)).toBeCloseTo(-3 * Math.PI / 4, 15)
+    expect(Atan2(-1, -1)).toBeCloseTo((-3 * Math.PI) / 4, 15)
   })
 
   it('should handle zero cases correctly', () => {
@@ -17,15 +17,23 @@ describe('Atan2', () => {
   })
 
   it('should handle infinity cases', () => {
-    expect(Atan2(Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY)).toBeCloseTo(Math.PI / 4, 15)
-    expect(Atan2(Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY)).toBeCloseTo(-Math.PI / 4, 15)
-    expect(Atan2(Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY)).toBeCloseTo(3 * Math.PI / 4, 15)
-    expect(Atan2(Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY)).toBeCloseTo(-3 * Math.PI / 4, 15)
-    
+    expect(
+      Atan2(Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY),
+    ).toBeCloseTo(Math.PI / 4, 15)
+    expect(
+      Atan2(Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY),
+    ).toBeCloseTo(-Math.PI / 4, 15)
+    expect(
+      Atan2(Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY),
+    ).toBeCloseTo((3 * Math.PI) / 4, 15)
+    expect(
+      Atan2(Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY),
+    ).toBeCloseTo((-3 * Math.PI) / 4, 15)
+
     expect(Atan2(1, Number.POSITIVE_INFINITY)).toBe(0)
     expect(Atan2(1, Number.NEGATIVE_INFINITY)).toBeCloseTo(Math.PI, 15)
     expect(Atan2(-1, Number.NEGATIVE_INFINITY)).toBeCloseTo(-Math.PI, 15)
-    
+
     expect(Atan2(Number.POSITIVE_INFINITY, 1)).toBeCloseTo(Math.PI / 2, 15)
     expect(Atan2(Number.NEGATIVE_INFINITY, 1)).toBeCloseTo(-Math.PI / 2, 15)
   })
@@ -52,4 +60,4 @@ describe('atan2', () => {
     expect(atan2(-1, -1)).toBe(Atan2(-1, -1))
     expect(atan2(0, 1)).toBe(Atan2(0, 1))
   })
-}) 
+})

package/gs/math/atanh.gs.test.ts

@@ -44,4 +44,4 @@ describe('atanh', () => {
     expect(atanh(1)).toBe(Atanh(1))
     expect(atanh(-1)).toBe(Atanh(-1))
   })
-}) 
+})

package/gs/math/bits.gs.test.ts

@@ -85,4 +85,4 @@ describe('normalize', () => {
     expect(y).toBe(0)
     expect(exp).toBe(-52)
   })
-}) 
+})

package/gs/math/cbrt.gs.test.ts

@@ -54,4 +54,4 @@ describe('cbrt', () => {
     expect(cbrt(Number.POSITIVE_INFINITY)).toBe(Cbrt(Number.POSITIVE_INFINITY))
     expect(cbrt(0.125)).toBe(Cbrt(0.125))
   })
-}) 
+})