goscript 0.0.26 → 0.0.29

package/dist/gs/unsafe/unsafe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unsafe.js","sourceRoot":"","sources":["../../../gs/unsafe/unsafe.ts"],"names":[],"mappings":"AAAA,oFAAoF;AACpF,2FAA2F;AAC3F,mCAAmC;AAYnC,uEAAuE;AACvE,4DAA4D;AAC5D,MAAM,UAAU,OAAO,CAAC,QAAuB;IAC7C,MAAM,IAAI,KAAK,CACb,sHAAsH,CACvH,CAAA;AACH,CAAC;AAED,8EAA8E;AAC9E,4DAA4D;AAC5D,MAAM,UAAU,QAAQ,CAAC,QAAuB;IAC9C,MAAM,IAAI,KAAK,CACb,sIAAsI,CACvI,CAAA;AACH,CAAC;AAED,iEAAiE;AACjE,4DAA4D;AAC5D,MAAM,UAAU,MAAM,CAAC,QAAuB;IAC5C,MAAM,IAAI,KAAK,CACb,gHAAgH,CACjH,CAAA;AACH,CAAC;AAED,sDAAsD;AACtD,+DAA+D;AAC/D,MAAM,UAAU,GAAG,CAAC,GAAY,EAAE,GAAgB;IAChD,MAAM,IAAI,KAAK,CACb,yGAAyG,CAC1G,CAAA;AACH,CAAC;AAED,6DAA6D;AAC7D,4DAA4D;AAC5D,MAAM,UAAU,KAAK,CAAC,GAAY,EAAE,GAAgB;IAClD,MAAM,IAAI,KAAK,CACb,6GAA6G,CAC9G,CAAA;AACH,CAAC;AAED,mEAAmE;AACnE,4DAA4D;AAC5D,MAAM,UAAU,SAAS,CAAC,KAAY;IACpC,MAAM,IAAI,KAAK,CACb,iHAAiH,CAClH,CAAA;AACH,CAAC;AAED,oEAAoE;AACpE,4DAA4D;AAC5D,MAAM,UAAU,MAAM,CAAC,GAAY,EAAE,GAAgB;IACnD,MAAM,IAAI,KAAK,CACb,8GAA8G,CAC/G,CAAA;AACH,CAAC;AAED,kEAAkE;AAClE,4DAA4D;AAC5D,MAAM,UAAU,UAAU,CAAC,GAAW;IACpC,MAAM,IAAI,KAAK,CACb,kHAAkH,CACnH,CAAA;AACH,CAAC"}

package/go.mod

@@ -4,6 +4,7 @@ go 1.24.3
 
 require (
 	github.com/aperturerobotics/cli v1.0.0
+	github.com/aperturerobotics/protobuf-go-lite v0.9.1
 	github.com/aperturerobotics/util v1.30.0
 	github.com/pkg/errors v0.9.1
 	github.com/sirupsen/logrus v1.9.3
@@ -12,7 +13,7 @@ require (
 
 require (
 	github.com/aperturerobotics/common v0.22.1 // indirect
-	github.com/stretchr/testify v1.10.0 // indirect
+	github.com/aperturerobotics/json-iterator-lite v1.0.1-0.20240713111131-be6bf89c3008 // indirect
 	github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 // indirect
 	golang.org/x/mod v0.24.0 // indirect
 	golang.org/x/sync v0.14.0 // indirect

package/go.sum

@@ -2,13 +2,17 @@ github.com/aperturerobotics/cli v1.0.0 h1:s3xT2h7eBih4/4yZKTn/HQ6P+qpk6ygWZl2416
 github.com/aperturerobotics/cli v1.0.0/go.mod h1:wtlINjMcKuwyV1x4ftReuA6hHZcPB8kPMXHyQqGFCSc=
 github.com/aperturerobotics/common v0.22.1 h1:wxTV9wSgfAM9jYUuSzNFzUeC28DQMBgDO3iGahlHeaY=
 github.com/aperturerobotics/common v0.22.1/go.mod h1:wsPfDVCTNpGHddg/MSfm84rKoO4GAvb+TQtATXz+pKY=
+github.com/aperturerobotics/json-iterator-lite v1.0.1-0.20240713111131-be6bf89c3008 h1:So9JeziaWKx2Fw8sK4AUN/szqKtJ0jEMhS6bU4sHbxs=
+github.com/aperturerobotics/json-iterator-lite v1.0.1-0.20240713111131-be6bf89c3008/go.mod h1:snaApCEDtrHHP6UWSLKiYNOZU9A5NyzccKenx9oZEzg=
+github.com/aperturerobotics/protobuf-go-lite v0.9.1 h1:P1knXKnwLJpVE8fmeXYGckKu79IhqUvKRdCfJNR0MwQ=
+github.com/aperturerobotics/protobuf-go-lite v0.9.1/go.mod h1:fULrxQxEBWKQm7vvju9AfjTp9yfHoLgwMQWTiZQ2tg0=
 github.com/aperturerobotics/util v1.30.0 h1:OKhFVPnAfR8/dfVNV27EtMr27C0kzwPiStoCwKiint0=
 github.com/aperturerobotics/util v1.30.0/go.mod h1:T97YTP+FVLegYo5rylOVaPuTLyZyiDqYxD5zVLI9YAc=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
-github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=

package/gs/README.md

@@ -0,0 +1,6 @@
+# Hand-written Go Packages
+
+This directory contains hand-written .gs.ts files corresponding to select
+packages from the standard library. These packages are hard or impossible to
+transpile correctly, so we hand-write the TypeScript equivalents here.
+

package/gs/builtin/builtin.ts

@@ -0,0 +1,171 @@
+export * from './varRef.js'
+export * from './channel.js'
+export * from './defer.js'
+export * from './io.js'
+export * from './map.js'
+export * from './slice.js'
+export * from './type.js'
+
+// 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 {
+  // 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
+  // they get interpreted as signed 32-bit integers.
+  
+  // For Go's int type on 64-bit systems, we should preserve the full value
+  // since JavaScript numbers can safely represent integers up to Number.MAX_SAFE_INTEGER
+  return Math.trunc(value)
+}
+
+// Copy is the Go builtin function that copies the contents of one slice to another.
+// It returns the number of elements copied.
+export function copy<T>(
+  dst: T[] | Uint8Array,
+  src: T[] | Uint8Array | string,
+): number {
+  // Handle string to Uint8Array copy (common in Go)
+  if (typeof src === 'string' && dst instanceof Uint8Array) {
+    const encoder = new TextEncoder()
+    const srcBytes = encoder.encode(src)
+    const n = Math.min(dst.length, srcBytes.length)
+    for (let i = 0; i < n; i++) {
+      dst[i] = srcBytes[i]
+    }
+    return n
+  }
+
+  // Handle Uint8Array to Uint8Array copy
+  if (dst instanceof Uint8Array && src instanceof Uint8Array) {
+    const n = Math.min(dst.length, src.length)
+    for (let i = 0; i < n; i++) {
+      dst[i] = src[i]
+    }
+    return n
+  }
+
+  // Handle array to array copy (original implementation)
+  if (Array.isArray(dst) && Array.isArray(src)) {
+    const n = Math.min(dst.length, src.length)
+    for (let i = 0; i < n; i++) {
+      dst[i] = src[i]
+    }
+    return n
+  }
+
+  // Handle mixed types - convert to compatible format
+  if (dst instanceof Uint8Array && Array.isArray(src)) {
+    const n = Math.min(dst.length, src.length)
+    for (let i = 0; i < n; i++) {
+      dst[i] = src[i] as number
+    }
+    return n
+  }
+
+  if (Array.isArray(dst) && src instanceof Uint8Array) {
+    const n = Math.min(dst.length, src.length)
+    for (let i = 0; i < n; i++) {
+      dst[i] = src[i] as T
+    }
+    return n
+  }
+
+  throw new Error(
+    `Unsupported copy operation between ${typeof dst} and ${typeof src}`,
+  )
+}
+
+// Duration multiplication helper for time package operations
+// Handles expressions like time.Hour * 24
+export function multiplyDuration(duration: any, multiplier: number): any {
+  // Check if duration has a multiply method (like our Duration class)
+  if (duration && typeof duration.multiply === 'function') {
+    return duration.multiply(multiplier)
+  }
+
+  // Check if duration has a valueOf method for numeric operations
+  if (duration && typeof duration.valueOf === 'function') {
+    const numValue = duration.valueOf()
+    // Return an object with the same structure but multiplied value
+    if (typeof numValue === 'number') {
+      // Try to create a new instance of the same type
+      if (duration.constructor) {
+        return new duration.constructor(numValue * multiplier)
+      }
+      // Fallback: return a simple object with valueOf
+      return {
+        valueOf: () => numValue * multiplier,
+        toString: () => (numValue * multiplier).toString() + 'ns',
+      }
+    }
+  }
+
+  // Fallback for simple numeric values
+  if (typeof duration === 'number') {
+    return duration * multiplier
+  }
+
+  throw new Error(`Cannot multiply duration of type ${typeof duration}`)
+}
+
+/**
+ * Normalizes various byte representations into a `Uint8Array` for protobuf compatibility.
+ *
+ * @param {Uint8Array | number[] | null | undefined | { data: number[] } | { valueOf(): number[] }} bytes
+ *   The input to normalize. Accepted types:
+ *   - `Uint8Array`: Returned as-is.
+ *   - `number[]`: Converted to a `Uint8Array`.
+ *   - `null` or `undefined`: Returns an empty `Uint8Array`.
+ *   - `{ data: number[] }`: An object with a `data` property (e.g., `$.Slice<number>`), where `data` is a `number[]`.
+ *   - `{ valueOf(): number[] }`: An object with a `valueOf` method that returns a `number[]`.
+ * @returns {Uint8Array} A normalized `Uint8Array` representation of the input.
+ * @throws {Error} If the input type is unsupported or cannot be normalized.
+ */
+export function normalizeBytes(
+  bytes:
+    | Uint8Array
+    | number[]
+    | null
+    | undefined
+    | { data: number[] }
+    | { valueOf(): number[] },
+): Uint8Array {
+  if (bytes === null || bytes === undefined) {
+    return new Uint8Array(0)
+  }
+
+  if (bytes instanceof Uint8Array) {
+    return bytes
+  }
+
+  // Handle $.Slice<number> (which has a .data property that's a number[])
+  if (
+    bytes &&
+    typeof bytes === 'object' &&
+    'data' in bytes &&
+    Array.isArray(bytes.data)
+  ) {
+    return new Uint8Array(bytes.data)
+  }
+
+  // Handle plain number arrays
+  if (Array.isArray(bytes)) {
+    return new Uint8Array(bytes)
+  }
+
+  // Handle objects with valueOf() method that returns a number array
+  if (
+    bytes &&
+    typeof bytes === 'object' &&
+    'valueOf' in bytes &&
+    typeof bytes.valueOf === 'function'
+  ) {
+    const value = bytes.valueOf()
+    if (Array.isArray(value)) {
+      return new Uint8Array(value)
+    }
+  }
+
+  throw new Error(`Cannot normalize bytes of type ${typeof bytes}: ${bytes}`)
+}