goscript 0.2.6 → 0.2.7

package/dist/gs/builtin/slice.d.ts

@@ -118,6 +118,15 @@ export declare function copy<T>(dst: Slice<T>, src: string): number;
  * @throws Error if index is out of bounds or type is unsupported.
  */
 export declare function index<T>(collection: GoStringValue | Slice<T> | T[], index: number): T | number;
+/**
+ * arrayIndex reads collection[index] with Go bounds-check semantics, panicking
+ * with the Go runtime message when index is out of range. Strings and maps are
+ * lowered through their own helpers, so this covers Go arrays and slices. The
+ * overloads reproduce the element type of a direct collection[index]: a byte
+ * collection yields number, an element slice yields its element type.
+ */
+export declare function arrayIndex(collection: Uint8Array, index: number): number;
+export declare function arrayIndex<T>(collection: Slice<T> | T[], index: number): T;
 /**
  * indexRef returns an addressable reference to a slice or array element.
  */
@@ -169,6 +178,7 @@ export declare const stringToRune: (str: string) => number;
  * @returns The resulting string.
  */
 export declare const runesToString: (runes: Slice<number>) => string;
+export declare function runeToString(r: number): string;
 /**
  * Converts a number to a byte (uint8) by truncating to the range 0-255.
  * Equivalent to Go's byte() conversion.

package/dist/gs/builtin/slice.js

@@ -1,3 +1,4 @@
+import { runtimePanic } from './panic.js';
 import { isOwnedPointerHandle, isVarRef, varRef, } from './varRef.js';
 export class GoBinaryString extends String {
     bytes;
@@ -63,6 +64,15 @@ function sliceIndexProperty(prop) {
     }
     return index;
 }
+// outOfRangeIndex panics with Go's index-out-of-range runtime message. Go omits
+// the "with length" suffix for negative indices and includes it otherwise, so
+// callers route every element bounds failure through here to stay byte-faithful.
+function outOfRangeIndex(index, length) {
+    if (index < 0) {
+        runtimePanic(`runtime error: index out of range [${index}]`);
+    }
+    runtimePanic(`runtime error: index out of range [${index}] with length ${length}`);
+}
 /**
  * wrapSliceProxy wraps a SliceProxy in a Proxy to intercept index access
  * and route it through the backing array.
@@ -77,7 +87,7 @@ function wrapSliceProxy(proxy) {
                 if (index < meta.length) {
                     return meta.backing[meta.offset + index];
                 }
-                throw new Error(`Slice index out of range: ${index} >= ${meta.length}`);
+                outOfRangeIndex(index, meta.length);
             }
             if (prop === 'length') {
                 return meta.length;
@@ -95,7 +105,7 @@ function wrapSliceProxy(proxy) {
                     target[index] = value; // Also update the proxy target for consistency
                     return true;
                 }
-                throw new Error(`Slice index out of range: ${index} >= ${meta.length}`);
+                outOfRangeIndex(index, meta.length);
             }
             if (prop === 'length' || prop === '__meta__') {
                 return false;
@@ -138,7 +148,7 @@ export function asArray(slice) {
 }
 export function sliceToArray(slice, length, typeHint) {
     if (len(slice) < length) {
-        throw new Error(`runtime error: cannot convert slice with length ${len(slice)} to array with length ${length}`);
+        runtimePanic(`runtime error: cannot convert slice with length ${len(slice)} to array or pointer to array with length ${length}`);
     }
     if (typeHint === 'byte') {
         return new Uint8Array(asArray(slice).slice(0, length));
@@ -147,7 +157,7 @@ export function sliceToArray(slice, length, typeHint) {
 }
 export function sliceToArrayPointer(slice, length, typeHint) {
     if (len(slice) < length) {
-        throw new Error(`runtime error: cannot convert slice with length ${len(slice)} to array pointer with length ${length}`);
+        runtimePanic(`runtime error: cannot convert slice with length ${len(slice)} to array or pointer to array with length ${length}`);
     }
     if (typeHint === 'byte') {
         if (slice instanceof Uint8Array) {
@@ -208,7 +218,9 @@ export const makeSlice = (length, capacity, typeHint, zeroFactory) => {
     if (typeHint === 'byte') {
         const actualCapacity = capacity === undefined ? length : capacity;
         if (length < 0 || actualCapacity < 0 || length > actualCapacity) {
-            throw new Error(`Invalid slice length (${length}) or capacity (${actualCapacity})`);
+            runtimePanic(actualCapacity < 0 ?
+                'runtime error: makeslice: cap out of range'
+                : 'runtime error: makeslice: len out of range');
         }
         // If capacity equals length, use Uint8Array directly for efficiency
         if (actualCapacity === length) {
@@ -218,7 +230,9 @@ export const makeSlice = (length, capacity, typeHint, zeroFactory) => {
     }
     const actualCapacity = capacity === undefined ? length : capacity;
     if (length < 0 || actualCapacity < 0 || length > actualCapacity) {
-        throw new Error(`Invalid slice length (${length}) or capacity (${actualCapacity})`);
+        runtimePanic(actualCapacity < 0 ?
+            'runtime error: makeslice: cap out of range'
+            : 'runtime error: makeslice: len out of range');
     }
     const zeroValue = () => {
         if (zeroFactory !== undefined) {
@@ -266,7 +280,7 @@ export const makeSlice = (length, capacity, typeHint, zeroFactory) => {
                 if (index < target.__meta__.length) {
                     return target.__meta__.backing[target.__meta__.offset + index];
                 }
-                throw new Error(`Slice index out of range: ${index} >= ${target.__meta__.length}`);
+                runtimePanic(`Slice index out of range: ${index} >= ${target.__meta__.length}`);
             }
             if (prop === 'length') {
                 return target.__meta__.length;
@@ -284,7 +298,7 @@ export const makeSlice = (length, capacity, typeHint, zeroFactory) => {
                     target[index] = value; // Also update the proxy target for consistency
                     return true;
                 }
-                throw new Error(`Slice index out of range: ${index} >= ${target.__meta__.length}`);
+                runtimePanic(`Slice index out of range: ${index} >= ${target.__meta__.length}`);
             }
             if (prop === 'length' || prop === '__meta__') {
                 return false;
@@ -307,7 +321,7 @@ s, low, high, max) {
                 if (index < target.__meta__.length) {
                     return target.__meta__.backing[target.__meta__.offset + index];
                 }
-                throw new Error(`Slice index out of range: ${index} >= ${target.__meta__.length}`);
+                runtimePanic(`Slice index out of range: ${index} >= ${target.__meta__.length}`);
             }
             if (prop === 'length') {
                 return target.__meta__.length;
@@ -341,7 +355,7 @@ s, low, high, max) {
                     target.__meta__.length++;
                     return true;
                 }
-                throw new Error(`Slice index out of range: ${index} >= ${target.__meta__.length}`);
+                runtimePanic(`Slice index out of range: ${index} >= ${target.__meta__.length}`);
             }
             if (prop === 'length' || prop === '__meta__') {
                 return false;
@@ -361,13 +375,13 @@ s, low, high, max) {
             actualHigh < actualLow ||
             actualLow > baseCapacity ||
             actualHigh > baseCapacity) {
-            throw new Error(`Invalid slice indices: low ${actualLow}, high ${actualHigh} for Uint8Array with capacity ${baseCapacity}`);
+            runtimePanic(`runtime error: slice bounds out of range [${actualLow}:${actualHigh}] with capacity ${baseCapacity}`);
         }
         const newLength = actualHigh - actualLow;
         if (max !== undefined) {
             if (max < actualHigh || max > baseCapacity) {
                 // max is relative to the original s.length (capacity)
-                throw new Error(`Invalid max index: ${max}. Constraints: low ${actualLow} <= high ${actualHigh} <= max <= capacity ${baseCapacity}`);
+                runtimePanic(`runtime error: slice bounds out of range [:${actualHigh}:${max}] with capacity ${baseCapacity}`);
             }
             const newCap = max - actualLow; // Capacity of the new slice view
             return byteSliceView(backing, baseOffset + actualLow, newLength, newCap);
@@ -379,13 +393,13 @@ s, low, high, max) {
         low = low ?? 0;
         high = high ?? 0;
         if (low < 0 || high < low) {
-            throw new Error(`Invalid slice indices: ${low}:${high}`);
+            runtimePanic(`runtime error: slice bounds out of range [${low}:${high}]`);
         }
         if (low !== 0 || high !== 0) {
-            throw new Error(`runtime error: slice bounds out of range [:${high}] with capacity 0`);
+            runtimePanic(`runtime error: slice bounds out of range [:${high}] with capacity 0`);
         }
         if (max !== undefined && max !== 0) {
-            throw new Error(`runtime error: slice bounds out of range [::${max}] with capacity 0`);
+            runtimePanic(`runtime error: slice bounds out of range [::${max}] with capacity 0`);
         }
         return null;
     }
@@ -393,12 +407,12 @@ s, low, high, max) {
     low = low ?? 0;
     high = high ?? slen;
     if (low < 0 || high < low) {
-        throw new Error(`Invalid slice indices: ${low}:${high}`);
+        runtimePanic(`runtime error: slice bounds out of range [${low}:${high}]`);
     }
     // In Go, high can be up to capacity, not just length
     const scap = cap(s);
     if (high > scap) {
-        throw new Error(`Slice index out of range: ${high} > ${scap}`);
+        runtimePanic(`Slice index out of range: ${high} > ${scap}`);
     }
     if (Array.isArray(s) &&
         !isComplexSlice(s) &&
@@ -422,13 +436,13 @@ s, low, high, max) {
     let newCap;
     if (max !== undefined) {
         if (max < high) {
-            throw new Error(`Invalid slice indices: ${low}:${high}:${max}`);
+            runtimePanic(`runtime error: slice bounds out of range [:${high}:${max}]`);
         }
         if (isComplexSlice(s) && max > oldOffset + oldCap) {
-            throw new Error(`Slice index out of range: ${max} > ${oldOffset + oldCap}`);
+            runtimePanic(`Slice index out of range: ${max} > ${oldOffset + oldCap}`);
         }
         if (!isComplexSlice(s) && max > s.length) {
-            throw new Error(`Slice index out of range: ${max} > ${s.length}`);
+            runtimePanic(`Slice index out of range: ${max} > ${s.length}`);
         }
         newCap = max - low;
     }
@@ -493,7 +507,7 @@ export const arrayToSlice = (arr, depth = 1) => {
                 if (index < target.__meta__.length) {
                     return target.__meta__.backing[target.__meta__.offset + index];
                 }
-                throw new Error(`Slice index out of range: ${index} >= ${target.__meta__.length}`);
+                runtimePanic(`Slice index out of range: ${index} >= ${target.__meta__.length}`);
             }
             if (prop === 'length') {
                 return target.__meta__.length;
@@ -525,7 +539,7 @@ export const arrayToSlice = (arr, depth = 1) => {
                     target.__meta__.length++;
                     return true;
                 }
-                throw new Error(`Slice index out of range: ${index} >= ${target.__meta__.length}`);
+                runtimePanic(`Slice index out of range: ${index} >= ${target.__meta__.length}`);
             }
             if (prop === 'length' || prop === '__meta__') {
                 return false;
@@ -931,41 +945,66 @@ function copySliceValues(src, count) {
  */
 export function index(collection, index) {
     if (collection === null || collection === undefined) {
-        throw new Error('runtime error: index on nil or undefined collection');
+        runtimePanic('runtime error: index on nil or undefined collection');
     }
     if (isGoStringValue(collection)) {
         return indexString(collection, index); // Use the existing indexString for byte access
     }
     else if (collection instanceof Uint8Array) {
         if (index < 0 || index >= collection.length) {
-            throw new Error(`runtime error: index out of range [${index}] with length ${collection.length}`);
+            outOfRangeIndex(index, collection.length);
         }
         return collection[index];
     }
     else if (isComplexSlice(collection)) {
         if (index < 0 || index >= collection.__meta__.length) {
-            throw new Error(`runtime error: index out of range [${index}] with length ${collection.__meta__.length}`);
+            outOfRangeIndex(index, collection.__meta__.length);
         }
         return collection.__meta__.backing[collection.__meta__.offset + index];
     }
     else if (Array.isArray(collection)) {
         if (index < 0 || index >= collection.length) {
-            throw new Error(`runtime error: index out of range [${index}] with length ${collection.length}`);
+            outOfRangeIndex(index, collection.length);
         }
         return collection[index];
     }
-    throw new Error('runtime error: index on unsupported type');
+    runtimePanic('runtime error: index on unsupported type');
+}
+export function arrayIndex(collection, index) {
+    if (collection === null || collection === undefined) {
+        outOfRangeIndex(index, 0);
+    }
+    if (collection instanceof Uint8Array) {
+        if (index < 0 || index >= collection.length) {
+            outOfRangeIndex(index, collection.length);
+        }
+        return collection[index];
+    }
+    if (isComplexSlice(collection)) {
+        const length = collection.__meta__.length;
+        if (index < 0 || index >= length) {
+            outOfRangeIndex(index, length);
+        }
+        return collection.__meta__.backing[collection.__meta__.offset + index];
+    }
+    if (Array.isArray(collection)) {
+        if (index < 0 || index >= collection.length) {
+            outOfRangeIndex(index, collection.length);
+        }
+        return collection[index];
+    }
+    runtimePanic('runtime error: index on unsupported type');
 }
 /**
  * indexRef returns an addressable reference to a slice or array element.
  */
 export function indexRef(collection, index) {
     if (collection === null || collection === undefined) {
-        throw new Error('runtime error: index on nil or undefined collection');
+        runtimePanic('runtime error: index on nil or undefined collection');
     }
     if (collection instanceof Uint8Array) {
         if (index < 0 || index >= collection.length) {
-            throw new Error(`runtime error: index out of range [${index}] with length ${collection.length}`);
+            outOfRangeIndex(index, collection.length);
         }
         const ref = {
             get value() {
@@ -984,7 +1023,7 @@ export function indexRef(collection, index) {
     }
     if (isComplexSlice(collection)) {
         if (index < 0 || index >= collection.__meta__.length) {
-            throw new Error(`runtime error: index out of range [${index}] with length ${collection.__meta__.length}`);
+            outOfRangeIndex(index, collection.__meta__.length);
         }
         const backingIndex = collection.__meta__.offset + index;
         const ref = {
@@ -1004,7 +1043,7 @@ export function indexRef(collection, index) {
     }
     if (Array.isArray(collection)) {
         if (index < 0 || index >= collection.length) {
-            throw new Error(`runtime error: index out of range [${index}] with length ${collection.length}`);
+            outOfRangeIndex(index, collection.length);
         }
         const ref = {
             get value() {
@@ -1021,7 +1060,7 @@ export function indexRef(collection, index) {
         ref.__goPointer = collectionPointer(ref, collection, index);
         return ref;
     }
-    throw new Error('runtime error: index on unsupported type');
+    runtimePanic('runtime error: index on unsupported type');
 }
 function collectionPointer(ref, collection, index) {
     return {
@@ -1030,7 +1069,7 @@ function collectionPointer(ref, collection, index) {
         __goRef: () => ref,
         __goSlice: (length) => {
             if (length < 0) {
-                throw new Error('runtime error: unsafe slice length out of range');
+                runtimePanic('runtime error: unsafe slice length out of range');
             }
             return goSlice(collection, index, index + length, index + length);
         },
@@ -1072,7 +1111,7 @@ export function arrayPointerFromIndexRef(ref, length, sourceElementByteSize = 1,
  */
 export function indexAddress(collection, index) {
     if (collection === null || collection === undefined) {
-        throw new Error('runtime error: index on nil or undefined collection');
+        runtimePanic('runtime error: index on nil or undefined collection');
     }
     let backing;
     let backingIndex;
@@ -1093,10 +1132,10 @@ export function indexAddress(collection, index) {
         length = collection.length;
     }
     else {
-        throw new Error('runtime error: index on unsupported type');
+        runtimePanic('runtime error: index on unsupported type');
     }
     if (index < 0 || index >= length) {
-        throw new Error(`runtime error: index out of range [${index}] with length ${length}`);
+        outOfRangeIndex(index, length);
     }
     let base = addressBases.get(backing);
     if (base === undefined) {
@@ -1160,11 +1199,11 @@ function numericByteSource(backing, elementByteSize) {
  */
 export function indexByteAddress(collection, index, elementByteSize) {
     if (collection === null || collection === undefined) {
-        throw new Error('runtime error: index on nil or undefined collection');
+        runtimePanic('runtime error: index on nil or undefined collection');
     }
     if (collection instanceof Uint8Array) {
         if (index < 0 || index >= collection.length) {
-            throw new Error(`runtime error: index out of range [${index}] with length ${collection.length}`);
+            outOfRangeIndex(index, collection.length);
         }
         const view = new Uint8Array(collection.buffer);
         const base = byteAddressBase(collection.buffer, {
@@ -1180,7 +1219,7 @@ export function indexByteAddress(collection, index, elementByteSize) {
     }
     if (isComplexSlice(collection)) {
         if (index < 0 || index >= collection.__meta__.length) {
-            throw new Error(`runtime error: index out of range [${index}] with length ${collection.__meta__.length}`);
+            outOfRangeIndex(index, collection.__meta__.length);
         }
         const backing = collection.__meta__.backing;
         const byteSize = Math.max(1, Math.trunc(elementByteSize));
@@ -1189,13 +1228,13 @@ export function indexByteAddress(collection, index, elementByteSize) {
     }
     if (Array.isArray(collection)) {
         if (index < 0 || index >= collection.length) {
-            throw new Error(`runtime error: index out of range [${index}] with length ${collection.length}`);
+            outOfRangeIndex(index, collection.length);
         }
         const byteSize = Math.max(1, Math.trunc(elementByteSize));
         const base = byteAddressBase(collection, numericByteSource(collection, byteSize));
         return base + index * byteSize;
     }
-    throw new Error('runtime error: index on unsupported type');
+    runtimePanic('runtime error: index on unsupported type');
 }
 /**
  * unsafePointerRef resolves a byte-addressed synthetic unsafe pointer created
@@ -1210,7 +1249,7 @@ export function unsafePointerRef(address) {
     }
     const offset = numericAddress - base;
     if (offset < 0 || offset >= source.byteLength) {
-        throw new Error('runtime error: unsafe pointer address out of range');
+        runtimePanic('runtime error: unsafe pointer address out of range');
     }
     return {
         get value() {
@@ -1230,7 +1269,7 @@ function byteArrayFromAddress(address, length) {
             const index = sliceIndexProperty(prop);
             if (index >= 0) {
                 if (index >= length) {
-                    throw new Error(`Slice index out of range: ${index} >= ${length}`);
+                    runtimePanic(`Slice index out of range: ${index} >= ${length}`);
                 }
                 return unsafePointerRef(start + index).value;
             }
@@ -1240,7 +1279,7 @@ function byteArrayFromAddress(address, length) {
             const index = sliceIndexProperty(prop);
             if (index >= 0) {
                 if (index >= length) {
-                    throw new Error(`Slice index out of range: ${index} >= ${length}`);
+                    runtimePanic(`Slice index out of range: ${index} >= ${length}`);
                 }
                 unsafePointerRef(start + index).value = value;
                 return true;
@@ -1290,8 +1329,26 @@ export const stringToRune = (str) => {
  * @returns The resulting string.
  */
 export const runesToString = (runes) => {
-    return runes?.length ? String.fromCharCode(...runes) : '';
+    if (!runes?.length) {
+        return '';
+    }
+    let out = '';
+    for (const r of runes) {
+        out += runeToString(r);
+    }
+    return out;
 };
+// runeToString encodes one rune as Go's string(rune) does: a valid Unicode
+// scalar value becomes its character including code points above U+FFFF (astral
+// planes), and a negative, out-of-range, or surrogate rune becomes U+FFFD
+// (utf8.RuneError), never a throw. String.fromCharCode truncated astral runes to
+// a single broken UTF-16 unit; String.fromCodePoint preserves the full rune.
+export function runeToString(r) {
+    if (r < 0 || r > 0x10ffff || (r >= 0xd800 && r <= 0xdfff)) {
+        return '�';
+    }
+    return String.fromCodePoint(r);
+}
 /**
  * Converts a number to a byte (uint8) by truncating to the range 0-255.
  * Equivalent to Go's byte() conversion.
@@ -1314,22 +1371,22 @@ export const indexString = (str, index) => {
         // Bytes - access directly
         if (str instanceof Uint8Array) {
             if (index < 0 || index >= str.length) {
-                throw new Error(`runtime error: index out of range [${index}] with length ${str.length}`);
+                outOfRangeIndex(index, str.length);
             }
             return str[index];
         }
         // Array or null
         if (str === null || str === undefined) {
-            throw new Error(`runtime error: index out of range [${index}] with length 0`);
+            outOfRangeIndex(index, 0);
         }
         if (index < 0 || index >= str.length) {
-            throw new Error(`runtime error: index out of range [${index}] with length ${str.length}`);
+            outOfRangeIndex(index, str.length);
         }
         return str[index];
     }
     const bytes = goStringBytes(str);
     if (index < 0 || index >= bytes.length) {
-        throw new Error(`runtime error: index out of range [${index}] with length ${bytes.length}`);
+        outOfRangeIndex(index, bytes.length);
     }
     return bytes[index];
 };
@@ -1366,7 +1423,7 @@ export const sliceString = (str, low, high) => {
             actualLow <= bytes.length) {
             return '';
         }
-        throw new Error(`runtime error: slice bounds out of range [${actualLow}:${actualHigh}] with length ${bytes.length}`);
+        runtimePanic(`runtime error: slice bounds out of range [${actualLow}:${actualHigh}] with length ${bytes.length}`);
     }
     return goStringFromBytes(bytes.subarray(actualLow, actualHigh));
 };
@@ -1586,18 +1643,18 @@ export function indexStringOrBytes(value, index) {
     else if (value instanceof Uint8Array) {
         // For Uint8Array, direct access returns the byte value
         if (index < 0 || index >= value.length) {
-            throw new Error(`runtime error: index out of range [${index}] with length ${value.length}`);
+            outOfRangeIndex(index, value.length);
         }
         return value[index];
     }
     else if (value === null) {
-        throw new Error(`runtime error: index out of range [${index}] with length 0`);
+        outOfRangeIndex(index, 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}`);
+            outOfRangeIndex(index, length);
         }
         return value[index];
     }