goscript 0.1.0 → 0.1.2

package/gs/builtin/builtin.ts

@@ -21,12 +21,41 @@ export function println(...args: any[]): void {
   writeHostStdoutText(message)
 }
 
+export class GoPanic extends Error {
+  constructor(public readonly value: unknown) {
+    super(`panic: ${formatPanicValue(value)}`)
+  }
+}
+
 /**
  * Implementation of Go's built-in panic function
  * @param args Arguments passed to panic
  */
-export function panic(...args: any[]): never {
-  throw new Error(`panic: ${args.map((arg) => String(arg)).join(' ')}`)
+export function panic(...args: unknown[]): never {
+  const value = args.length === 1 ? args[0] : args
+  throw new GoPanic(value)
+}
+
+export function panicValue(value: unknown): unknown {
+  if (value instanceof GoPanic) {
+    return value.value
+  }
+  return value
+}
+
+function formatPanicValue(value: unknown): string {
+  if (value instanceof Error) {
+    return value.message
+  }
+  if (
+    value !== null &&
+    typeof value === 'object' &&
+    'Error' in value &&
+    typeof (value as { Error?: unknown }).Error === 'function'
+  ) {
+    return String((value as { Error(): string }).Error())
+  }
+  return String(value)
 }
 
 /**
@@ -35,7 +64,7 @@ export function panic(...args: any[]): never {
  * For maps, it deletes all entries.
  * @param v The slice or map to clear
  */
-export function clear<T>(v: T[] | Map<unknown, unknown> | null): void {
+export function clear<T>(v: Slice<T> | Map<unknown, unknown> | null): void {
   if (v === null || v === undefined) {
     return
   }
@@ -43,12 +72,40 @@ export function clear<T>(v: T[] | Map<unknown, unknown> | null): void {
     v.clear()
     return
   }
+  if (v instanceof Uint8Array) {
+    v.fill(0)
+    return
+  }
+  if (isSliceProxy(v)) {
+    const zero = clearZeroValue(v)
+    for (let i = 0; i < v.length; i++) {
+      v[i] = zero
+    }
+    return
+  }
   if (Array.isArray(v)) {
-    v.fill(null as T)
+    v.fill(clearZeroValue(v))
     return
   }
 }
 
+function clearZeroValue<T>(v: T[]): T {
+  for (const item of v) {
+    if (item !== null && item !== undefined) {
+      switch (typeof item) {
+        case 'number':
+          return 0 as T
+        case 'string':
+          return '' as T
+        case 'boolean':
+          return false as T
+      }
+      break
+    }
+  }
+  return null as T
+}
+
 /**
  * assignStruct copies all field values from source struct to target struct.
  * Used for pointer dereference assignment: *p = value
@@ -93,16 +150,229 @@ export function pointerValue<T>(value: T | VarRef<T> | null | undefined): T {
   if (isVarRef(value)) {
     return value.value as T
   }
+  const boxed =
+    typeof value === 'object' &&
+    value !== null &&
+    '__goValue' in value ?
+      (value as { __goType?: unknown; __goValue: T | VarRef<T> })
+    : null
+  if (
+    boxed !== null &&
+    typeof boxed.__goType === 'string' &&
+    boxed.__goType.startsWith('*') &&
+    !hasGoMethodSurface(value)
+  ) {
+    return pointerValue(boxed.__goValue)
+  }
+  return value
+}
+
+export function pointerValueOrNil<T>(
+  value: T | VarRef<T> | null | undefined,
+): T | null {
+  if (value === null || value === undefined) {
+    return null
+  }
+  if (isVarRef(value)) {
+    return value.value as T
+  }
+  const boxed =
+    typeof value === 'object' &&
+    value !== null &&
+    '__goValue' in value ?
+      (value as { __goType?: unknown; __goValue: T | VarRef<T> })
+    : null
+  if (
+    boxed !== null &&
+    typeof boxed.__goType === 'string' &&
+    boxed.__goType.startsWith('*') &&
+    !hasGoMethodSurface(value)
+  ) {
+    return pointerValueOrNil(boxed.__goValue)
+  }
   return value
 }
 
+export function arrayEqual(a: unknown, b: unknown): boolean {
+  return comparableEqual(a, b)
+}
+
+export function comparableEqual(a: unknown, b: unknown): boolean {
+  if (a === b) {
+    return true
+  }
+  if (a === null || a === undefined || b === null || b === undefined) {
+    return false
+  }
+  if (isArrayLike(a) && isArrayLike(b)) {
+    if (a.length !== b.length) {
+      return false
+    }
+    for (let i = 0; i < a.length; i++) {
+      if (!comparableEqual(a[i], b[i])) {
+        return false
+      }
+    }
+    return true
+  }
+  if (isComplexValue(a) || isComplexValue(b)) {
+    return (
+      isComplexValue(a) &&
+      isComplexValue(b) &&
+      a.real === b.real &&
+      a.imag === b.imag
+    )
+  }
+  if (hasGoType(a) || hasGoType(b)) {
+    if (!hasGoType(a) || !hasGoType(b) || a.__goType !== b.__goType) {
+      return false
+    }
+    if (a.__isTypedNil || b.__isTypedNil) {
+      return a.__isTypedNil === true && b.__isTypedNil === true
+    }
+    if (hasGoValue(a) || hasGoValue(b)) {
+      return hasGoValue(a) && hasGoValue(b) && comparableEqual(a.__goValue, b.__goValue)
+    }
+  }
+  if (isStructValue(a) && isStructValue(b)) {
+    return fieldsEqual(a._fields, b._fields)
+  }
+  return false
+}
+
+function isArrayLike(value: unknown): value is ArrayLike<unknown> {
+  return Array.isArray(value) || value instanceof Uint8Array
+}
+
+function hasGoType(value: unknown): value is {
+  __goType: string
+  __isTypedNil?: boolean
+} {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    typeof (value as { __goType?: unknown }).__goType === 'string'
+  )
+}
+
+function hasGoValue(value: unknown): value is {
+  __goValue: unknown
+} {
+  return typeof value === 'object' && value !== null && '__goValue' in value
+}
+
+function hasGoMethodSurface(value: unknown): boolean {
+  if (typeof value !== 'object' || value === null) {
+    return false
+  }
+  return Object.keys(value).some((key) => {
+    return (
+      key !== '__goType' &&
+      key !== '__goValue' &&
+      key !== 'valueOf' &&
+      key !== 'toString' &&
+      typeof (value as Record<string, unknown>)[key] === 'function'
+    )
+  })
+}
+
+function isStructValue(value: unknown): value is {
+  _fields: Record<string, VarRef<unknown>>
+} {
+  const fields =
+    typeof value === 'object' && value !== null ?
+      (value as { _fields?: unknown })._fields
+    : undefined
+  return (
+    typeof fields === 'object' &&
+    fields !== null &&
+    !Array.isArray(fields) &&
+    Object.values(fields).every(isVarRef)
+  )
+}
+
+function fieldsEqual(
+  a: Record<string, VarRef<unknown>>,
+  b: Record<string, VarRef<unknown>>,
+): boolean {
+  const aKeys = Object.keys(a)
+  const bKeys = Object.keys(b)
+  if (aKeys.length !== bKeys.length) {
+    return false
+  }
+  for (const key of aKeys) {
+    if (!(key in b) || !comparableEqual(a[key].value, b[key].value)) {
+      return false
+    }
+  }
+  return true
+}
+
+export interface Complex {
+  real: number
+  imag: number
+}
+
+function isComplexValue(value: unknown): value is Complex {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    typeof (value as { real?: unknown }).real === 'number' &&
+    typeof (value as { imag?: unknown }).imag === 'number'
+  )
+}
+
+export function complex(real: number, imag: number): Complex {
+  return { real, imag }
+}
+
+export function real(value: number | Complex | null | undefined): number {
+  if (typeof value === 'number') {
+    return value
+  }
+  return value?.real ?? 0
+}
+
+export function imag(value: number | Complex | null | undefined): number {
+  if (typeof value === 'number') {
+    return 0
+  }
+  return value?.imag ?? 0
+}
+
 // Bytes represents all valid []byte representations in TypeScript
 // This includes Uint8Array (the preferred representation) and $.Slice<number> (which includes null)
 export type Bytes = Uint8Array | Slice<number>
+type ByteData = Uint8Array | number[] | SliceProxy<number>
+
+const maxSafeBigInt = BigInt(Number.MAX_SAFE_INTEGER)
+const maxUint64BigInt = 0xffffffffffffffffn
 
 // 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
-export function int(value: number): number {
+export function int(value: number | bigint, bits = 0): number {
+  if (typeof value === 'bigint') {
+    if (bits > 0 && bits <= 64) {
+      return Number(BigInt.asIntN(bits, value))
+    }
+    return Number(value)
+  }
+  if (bits > 0 && bits < 64) {
+    const modulo = 2 ** bits
+    const sign = 2 ** (bits - 1)
+    let truncated = Math.trunc(value)
+    if (!Number.isFinite(truncated)) {
+      return truncated
+    }
+    truncated %= modulo
+    if (truncated < 0) {
+      truncated += modulo
+    }
+    if (truncated >= sign) {
+      truncated -= modulo
+    }
+    return truncated
+  }
   // In Go, int is typically 64-bit on 64-bit systems, but for compatibility with JavaScript
   // we need to handle the conversion properly. The issue is that JavaScript's number type
   // can represent values larger than 32-bit signed integers, but when cast in certain contexts
@@ -115,6 +385,260 @@ export function int(value: number): number {
   return Math.trunc(value)
 }
 
+// uint converts a value to an unsigned Go integer width.
+export function uint(value: number | bigint, bits = 64): number {
+  if (typeof value === 'bigint') {
+    const normalized = BigInt.asUintN(Math.min(bits, 64), value)
+    if (bits >= 64) {
+      return uint64Result(normalized)
+    }
+    return Number(normalized)
+  }
+  if (!Number.isFinite(value)) {
+    return value
+  }
+  if (bits === 8) {
+    return value & 0xff
+  }
+  if (bits === 16) {
+    return value & 0xffff
+  }
+  if (bits === 32) {
+    return value >>> 0
+  }
+  if (bits >= 64) {
+    const truncated = Math.trunc(value)
+    if (truncated >= 0 && truncated <= Number.MAX_SAFE_INTEGER) {
+      return truncated
+    }
+  }
+  const modulo = bits >= 64 ? 2 ** 64 : 2 ** bits
+  let truncated = Math.trunc(value)
+  truncated %= modulo
+  if (truncated < 0) {
+    truncated += modulo
+  }
+  return truncated
+}
+
+export function uint64Shl(
+  value: number | bigint,
+  shift: number | bigint,
+): number {
+  return uint64Result(uint64Value(value) << BigInt(Math.trunc(Number(shift))))
+}
+
+export function uint64Shr(
+  value: number | bigint,
+  shift: number | bigint,
+): number {
+  return uint64Result(uint64Value(value) >> BigInt(Math.trunc(Number(shift))))
+}
+
+export function int64Shl(
+  value: number | bigint,
+  shift: number | bigint,
+): number {
+  return int64Result(int64Value(value) << BigInt(Math.trunc(Number(shift))))
+}
+
+export function int64Shr(
+  value: number | bigint,
+  shift: number | bigint,
+): number {
+  return int64Result(int64Value(value) >> BigInt(Math.trunc(Number(shift))))
+}
+
+export function uintShr(
+  value: number | bigint,
+  shift: number | bigint,
+  bits = 32,
+): number {
+  const width = Math.min(bits, 32)
+  const amount = Math.trunc(Number(shift))
+  if (amount < 0) {
+    throw new Error('runtime error: negative shift amount')
+  }
+  if (amount >= width) {
+    return 0
+  }
+  return uint(value, width) >>> amount
+}
+
+export function uint64Mul(
+  left: number | bigint,
+  right: number | bigint,
+): number {
+  return uint64Result(uint64Value(left) * uint64Value(right))
+}
+
+export function int64Mul(
+  left: number | bigint,
+  right: number | bigint,
+): number {
+  return int64Result(int64Value(left) * int64Value(right))
+}
+
+export function uint64Div(
+  left: number | bigint,
+  right: number | bigint,
+): number {
+  const divisor = uint64Value(right)
+  if (divisor === 0n) {
+    throw new Error('runtime error: integer divide by zero')
+  }
+  return uint64Result(uint64Value(left) / divisor)
+}
+
+export function int64Div(
+  left: number | bigint,
+  right: number | bigint,
+): number {
+  const divisor = int64Value(right)
+  if (divisor === 0n) {
+    throw new Error('runtime error: integer divide by zero')
+  }
+  return int64Result(int64Value(left) / divisor)
+}
+
+export function uint64Mod(
+  left: number | bigint,
+  right: number | bigint,
+): number {
+  const divisor = uint64Value(right)
+  if (divisor === 0n) {
+    throw new Error('runtime error: integer divide by zero')
+  }
+  return uint64Result(uint64Value(left) % divisor)
+}
+
+export function int64Mod(
+  left: number | bigint,
+  right: number | bigint,
+): number {
+  const divisor = int64Value(right)
+  if (divisor === 0n) {
+    throw new Error('runtime error: integer divide by zero')
+  }
+  return int64Result(int64Value(left) % divisor)
+}
+
+export function uint64Add(
+  left: number | bigint,
+  right: number | bigint,
+): number {
+  return uint64Result(uint64Value(left) + uint64Value(right))
+}
+
+export function int64Add(
+  left: number | bigint,
+  right: number | bigint,
+): number {
+  return int64Result(int64Value(left) + int64Value(right))
+}
+
+export function uint64Sub(
+  left: number | bigint,
+  right: number | bigint,
+): number {
+  return uint64Result(uint64Value(left) - uint64Value(right))
+}
+
+export function int64Sub(
+  left: number | bigint,
+  right: number | bigint,
+): number {
+  return int64Result(int64Value(left) - int64Value(right))
+}
+
+export function uint64And(
+  left: number | bigint,
+  right: number | bigint,
+): number {
+  return uint64Result(uint64Value(left) & uint64Value(right))
+}
+
+export function int64And(
+  left: number | bigint,
+  right: number | bigint,
+): number {
+  return int64Result(int64Value(left) & int64Value(right))
+}
+
+export function uint64Or(
+  left: number | bigint,
+  right: number | bigint,
+): number {
+  return uint64Result(uint64Value(left) | uint64Value(right))
+}
+
+export function int64Or(
+  left: number | bigint,
+  right: number | bigint,
+): number {
+  return int64Result(int64Value(left) | int64Value(right))
+}
+
+export function uint64Xor(
+  left: number | bigint,
+  right: number | bigint,
+): number {
+  return uint64Result(uint64Value(left) ^ uint64Value(right))
+}
+
+export function int64Xor(
+  left: number | bigint,
+  right: number | bigint,
+): number {
+  return int64Result(int64Value(left) ^ int64Value(right))
+}
+
+function int64Value(value: number | bigint): bigint {
+  if (typeof value === 'bigint') {
+    return BigInt.asIntN(64, value)
+  }
+  if (Number.isFinite(value)) {
+    const truncated = Math.trunc(value)
+    if (
+      truncated >= Number.MIN_SAFE_INTEGER &&
+      truncated <= Number.MAX_SAFE_INTEGER
+    ) {
+      return BigInt(truncated)
+    }
+  }
+  return BigInt.asIntN(64, BigInt(Math.trunc(value)))
+}
+
+function int64Result(value: bigint): number {
+  const normalized =
+    value >= -0x8000000000000000n && value <= 0x7fffffffffffffffn
+      ? value
+      : BigInt.asIntN(64, value)
+  return Number(normalized)
+}
+
+function uint64Value(value: number | bigint): bigint {
+  if (typeof value === 'bigint') {
+    return BigInt.asUintN(64, value)
+  }
+  if (Number.isFinite(value)) {
+    const truncated = Math.trunc(value)
+    if (truncated >= 0 && truncated <= Number.MAX_SAFE_INTEGER) {
+      return BigInt(truncated)
+    }
+  }
+  return BigInt.asUintN(64, BigInt(Math.trunc(value)))
+}
+
+function uint64Result(value: bigint): number {
+  const normalized =
+    value >= 0n && value <= maxUint64BigInt ? value : BigInt.asUintN(64, value)
+  if (normalized <= maxSafeBigInt) {
+    return Number(normalized)
+  }
+  return normalized as unknown as number
+}
+
 /**
  * Normalizes various byte representations into a `Uint8Array` for protobuf compatibility.
  *
@@ -196,18 +720,15 @@ export function sortSlice<T extends string | number>(s: Slice<T>): void {
  * Optimized for different byte representations.
  */
 export function bytesEqual(a: Bytes | null, b: Bytes | null): boolean {
-  // Handle null cases
   if (a === null && b === null) return true
   if (a === null || b === null) return false
 
-  // Convert to arrays for comparison
-  const aArr = bytesToArray(a)
-  const bArr = bytesToArray(b)
-
-  if (aArr.length !== bArr.length) return false
+  const aLen = bytesLen(a)
+  const bLen = bytesLen(b)
+  if (aLen !== bLen) return false
 
-  for (let i = 0; i < aArr.length; i++) {
-    if (aArr[i] !== bArr[i]) return false
+  for (let i = 0; i < aLen; i++) {
+    if (byteAt(a, i) !== byteAt(b, i)) return false
   }
 
   return true
@@ -218,47 +739,65 @@ export function bytesEqual(a: Bytes | null, b: Bytes | null): boolean {
  * Returns -1 if a < b, 0 if a == b, +1 if a > b.
  */
 export function bytesCompare(a: Bytes | null, b: Bytes | null): number {
-  // Handle null cases
   if (a === null && b === null) return 0
   if (a === null) return -1
   if (b === null) return 1
 
-  const aArr = bytesToArray(a)
-  const bArr = bytesToArray(b)
-
-  const minLen = Math.min(aArr.length, bArr.length)
+  const aLen = bytesLen(a)
+  const bLen = bytesLen(b)
+  const minLen = Math.min(aLen, bLen)
 
   for (let i = 0; i < minLen; i++) {
-    if (aArr[i] < bArr[i]) return -1
-    if (aArr[i] > bArr[i]) return 1
+    const av = byteAt(a, i)
+    const bv = byteAt(b, i)
+    if (av < bv) return -1
+    if (av > bv) return 1
   }
 
-  if (aArr.length < bArr.length) return -1
-  if (aArr.length > bArr.length) return 1
+  if (aLen < bLen) return -1
+  if (aLen > bLen) return 1
   return 0
 }
 
+function bytesLen(bytes: ByteData): number {
+  if (bytes instanceof Uint8Array) {
+    return bytes.length
+  }
+  if (isSliceProxy(bytes)) {
+    return (bytes as SliceProxy<number>).__meta__.length
+  }
+  return bytes.length
+}
+
+function byteAt(bytes: ByteData, index: number): number {
+  if (bytes instanceof Uint8Array || Array.isArray(bytes)) {
+    return bytes[index] ?? 0
+  }
+  const meta = (bytes as SliceProxy<number>).__meta__
+  return meta.backing[meta.offset + index] ?? 0
+}
+
 /**
  * bytesToArray converts any Bytes representation to a number array.
  */
 export function bytesToArray(bytes: Bytes | null): number[] {
+  bytes = bytesValue(bytes) as Bytes | null
   if (bytes === null) return []
 
   if (bytes instanceof Uint8Array) {
     return Array.from(bytes)
   }
 
-  if (Array.isArray(bytes)) {
-    return bytes
-  }
-
-  // Handle SliceProxy
   if (isSliceProxy(bytes)) {
     const proxy = bytes as SliceProxy<number>
     const meta = proxy.__meta__
     return meta.backing.slice(meta.offset, meta.offset + meta.length)
   }
 
+  if (Array.isArray(bytes)) {
+    return bytes
+  }
+
   throw new Error(`Cannot convert bytes of type ${typeof bytes} to array`)
 }
 
@@ -266,15 +805,34 @@ export function bytesToArray(bytes: Bytes | null): number[] {
  * bytesToUint8Array converts any Bytes representation to a Uint8Array.
  */
 export function bytesToUint8Array(bytes: Bytes | null): Uint8Array {
+  bytes = bytesValue(bytes) as Bytes | null
   if (bytes === null) return new Uint8Array(0)
 
   if (bytes instanceof Uint8Array) {
+    if ((bytes as Uint8Array & { __meta__?: unknown }).__meta__ !== undefined) {
+      return bytes.subarray(0)
+    }
     return bytes
   }
 
   return new Uint8Array(bytesToArray(bytes))
 }
 
+function bytesValue(value: unknown): unknown {
+  if (isVarRef(value)) {
+    return bytesValue(value.value)
+  }
+  if (
+    typeof value === 'object' &&
+    value !== null &&
+    typeof (value as { __goType?: unknown }).__goType === 'string' &&
+    '__goValue' in value
+  ) {
+    return bytesValue((value as { __goValue: unknown }).__goValue)
+  }
+  return value
+}
+
 /**
  * bytesIndexOf finds the first occurrence of subslice in bytes.
  * Returns -1 if not found.