goscript 0.0.14 → 0.0.16

package/dist/builtin/builtin.js

@@ -1,32 +1,165 @@
+export function asArray(slice) {
+    return slice;
+}
 /**
- * Creates a new slice (TypeScript array) with the specified length and capacity.
- * @param len The length of the slice.
- * @param cap The capacity of the slice (optional).
- * @returns A new TypeScript array representing the slice.
+ * isComplexSlice checks if a slice is a complex slice (has __meta__ property)
  */
-export const makeSlice = (len, cap) => {
-    const slice = new Array(len);
-    slice.__capacity = cap !== undefined ? cap : len;
-    return slice;
+function isComplexSlice(slice) {
+    return (slice !== null &&
+        slice !== undefined &&
+        '__meta__' in slice &&
+        slice.__meta__ !== undefined);
+}
+/**
+ * Creates a new slice with the specified length and capacity.
+ * @param length The length of the slice.
+ * @param capacity The capacity of the slice (optional).
+ * @returns A new slice.
+ */
+export const makeSlice = (length, capacity) => {
+    if (capacity === undefined) {
+        capacity = length;
+    }
+    if (length < 0 || capacity < 0 || length > capacity) {
+        throw new Error(`Invalid slice length (${length}) or capacity (${capacity})`);
+    }
+    const arr = new Array(length);
+    // Always create a complex slice with metadata to preserve capacity information
+    const proxy = arr;
+    proxy.__meta__ = {
+        backing: new Array(capacity),
+        offset: 0,
+        length: length,
+        capacity: capacity,
+    };
+    for (let i = 0; i < length; i++) {
+        proxy.__meta__.backing[i] = arr[i];
+    }
+    return proxy;
 };
 /**
- * Creates a new slice header that shares the backing array.
+ * goSlice creates a slice from s[low:high:max]
  * Arguments mirror Go semantics; omitted indices are undefined.
  *
- * @param arr  The original slice/array produced by makeSlice or another slice
- * @param low  Starting index (defaults to 0)
- * @param high Ending index (defaults to arr.length)
- * @param max  Capacity limit (defaults to original capacity)
- */
-export const slice = (arr, low, high, max) => {
-    const start = low ?? 0;
-    const origLen = arr.length;
-    const origCap = arr.__capacity !== undefined ? arr.__capacity : origLen;
-    const end = high !== undefined ? high : origLen;
-    const newCap = max !== undefined ? max - start : origCap - start;
-    const newArr = arr.slice(start, end);
-    newArr.__capacity = newCap;
-    return newArr;
+ * @param s The original slice
+ * @param low Starting index (defaults to 0)
+ * @param high Ending index (defaults to s.length)
+ * @param max Capacity limit (defaults to original capacity)
+ */
+export const goSlice = (s, low, high, max) => {
+    if (s === null || s === undefined) {
+        throw new Error('Cannot slice nil');
+    }
+    const slen = len(s);
+    low = low ?? 0;
+    high = high ?? slen;
+    if (low < 0 || high < low) {
+        throw new Error(`Invalid slice indices: ${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}`);
+    }
+    if (Array.isArray(s) &&
+        !isComplexSlice(s) &&
+        low === 0 &&
+        high === s.length &&
+        max === undefined) {
+        return s;
+    }
+    let backing;
+    let oldOffset = 0;
+    let oldCap = scap;
+    // Get the backing array and offset
+    if (isComplexSlice(s)) {
+        backing = s.__meta__.backing;
+        oldOffset = s.__meta__.offset;
+        oldCap = s.__meta__.capacity;
+    }
+    else {
+        backing = s;
+    }
+    let newCap;
+    if (max !== undefined) {
+        if (max < high) {
+            throw new Error(`Invalid slice indices: ${low}:${high}:${max}`);
+        }
+        if (isComplexSlice(s) && max > oldOffset + oldCap) {
+            throw new Error(`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}`);
+        }
+        newCap = max - low;
+    }
+    else {
+        // For slices of slices, capacity should be the capacity of the original slice minus the low index
+        if (isComplexSlice(s)) {
+            newCap = oldCap - low;
+        }
+        else {
+            newCap = s.length - low;
+        }
+    }
+    const newLength = high - low;
+    const newOffset = oldOffset + low;
+    const target = {
+        __meta__: {
+            backing: backing,
+            offset: newOffset,
+            length: newLength,
+            capacity: newCap,
+        },
+    };
+    const handler = {
+        get(target, prop) {
+            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__;
+            }
+            if (prop === 'slice' ||
+                prop === 'map' ||
+                prop === 'filter' ||
+                prop === 'reduce' ||
+                prop === 'forEach' ||
+                prop === Symbol.iterator) {
+                const backingSlice = target.__meta__.backing.slice(target.__meta__.offset, target.__meta__.offset + target.__meta__.length);
+                return backingSlice[prop].bind(backingSlice);
+            }
+            return Reflect.get(target, prop);
+        },
+        set(target, prop, value) {
+            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;
+                    return true;
+                }
+                if (index === target.__meta__.length &&
+                    target.__meta__.length < target.__meta__.capacity) {
+                    target.__meta__.backing[target.__meta__.offset + index] = value;
+                    target.__meta__.length++;
+                    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(target, handler);
 };
 /**
  * Creates a new map (TypeScript Map).
@@ -36,26 +169,293 @@ export const makeMap = () => {
     return new Map();
 };
 /**
- * Returns the length of a collection (string, array, or map).
- * @param collection The collection to get the length of.
+ * Converts a JavaScript array to a Go slice.
+ * For multi-dimensional arrays, recursively converts nested arrays to slices.
+ * @param arr The JavaScript array to convert
+ * @param depth How many levels of nesting to convert (default: 1, use Infinity for all levels)
+ * @returns A Go slice containing the same elements
+ */
+export const arrayToSlice = (arr, depth = 1) => {
+    if (arr == null)
+        return [];
+    if (arr.length === 0)
+        return arr;
+    const target = {
+        __meta__: {
+            backing: arr,
+            offset: 0,
+            length: arr.length,
+            capacity: arr.length,
+        },
+    };
+    const handler = {
+        get(target, prop) {
+            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__;
+            }
+            if (prop === 'slice' ||
+                prop === 'map' ||
+                prop === 'filter' ||
+                prop === 'reduce' ||
+                prop === 'forEach' ||
+                prop === Symbol.iterator) {
+                const backingSlice = target.__meta__.backing.slice(target.__meta__.offset, target.__meta__.offset + target.__meta__.length);
+                return backingSlice[prop].bind(backingSlice);
+            }
+            return Reflect.get(target, prop);
+        },
+        set(target, prop, value) {
+            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;
+                    return true;
+                }
+                if (index === target.__meta__.length &&
+                    target.__meta__.length < target.__meta__.capacity) {
+                    target.__meta__.backing[target.__meta__.offset + index] = value;
+                    target.__meta__.length++;
+                    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);
+        },
+    };
+    // Recursively convert nested arrays if depth > 1
+    if (depth > 1 && arr.length > 0) {
+        for (let i = 0; i < arr.length; i++) {
+            const item = arr[i];
+            if (isComplexSlice(item)) {
+            }
+            else if (Array.isArray(item)) {
+                arr[i] = arrayToSlice(item, depth - 1);
+            }
+            else if (item &&
+                typeof item === 'object' &&
+                isComplexSlice(item)) {
+                // Preserve capacity information for complex slices
+            }
+        }
+    }
+    return new Proxy(target, handler);
+};
+/**
+ * Returns the length of a collection (string, array, slice, map, or set).
+ * @param obj The collection to get the length of.
  * @returns The length of the collection.
  */
-export const len = (collection) => {
-    if (typeof collection === 'string' || Array.isArray(collection)) {
-        return collection.length;
+export const len = (obj) => {
+    if (obj === null || obj === undefined) {
+        return 0;
     }
-    else if (collection instanceof Map) {
-        return collection.size;
+    if (typeof obj === 'string') {
+        return obj.length;
+    }
+    if (obj instanceof Map || obj instanceof Set) {
+        return obj.size;
+    }
+    if (isComplexSlice(obj)) {
+        return obj.__meta__.length;
+    }
+    if (Array.isArray(obj)) {
+        return obj.length;
     }
     return 0; // Default fallback
 };
 /**
- * Returns the capacity of a slice (TypeScript array).
- * @param slice The slice (TypeScript array).
+ * Returns the capacity of a slice.
+ * @param obj The slice.
  * @returns The capacity of the slice.
  */
-export const cap = (slice) => {
-    return slice.__capacity !== undefined ? slice.__capacity : slice.length;
+export const cap = (obj) => {
+    if (obj === null || obj === undefined) {
+        return 0;
+    }
+    if (isComplexSlice(obj)) {
+        return obj.__meta__.capacity;
+    }
+    if (Array.isArray(obj)) {
+        return obj.length;
+    }
+    return 0;
+};
+/**
+ * Appends elements to a slice.
+ * Note: In Go, append can return a new slice if the underlying array is reallocated.
+ * This helper emulates that by returning the modified or new slice.
+ * @param slice The slice to append to.
+ * @param elements The elements to append.
+ * @returns The modified or new slice.
+ */
+export const append = (slice, ...elements) => {
+    if (slice === null || slice === undefined) {
+        if (elements.length === 0) {
+            return [];
+        }
+        else {
+            return elements.slice(0);
+        }
+    }
+    if (elements.length === 0) {
+        return slice;
+    }
+    const oldLen = len(slice);
+    const oldCap = cap(slice);
+    const newLen = oldLen + elements.length;
+    if (newLen <= oldCap) {
+        if (isComplexSlice(slice)) {
+            const offset = slice.__meta__.offset;
+            const backing = slice.__meta__.backing;
+            for (let i = 0; i < elements.length; i++) {
+                backing[offset + oldLen + i] = elements[i];
+            }
+            const result = new Array(newLen);
+            for (let i = 0; i < oldLen; i++) {
+                result[i] = backing[offset + i];
+            }
+            for (let i = 0; i < elements.length; i++) {
+                result[oldLen + i] = elements[i];
+            }
+            result.__meta__ = {
+                backing: backing,
+                offset: offset,
+                length: newLen,
+                capacity: oldCap,
+            };
+            return result;
+        }
+        else {
+            const result = new Array(newLen);
+            for (let i = 0; i < oldLen; i++) {
+                result[i] = slice[i];
+            }
+            for (let i = 0; i < elements.length; i++) {
+                result[i + oldLen] = elements[i];
+                if (i + oldLen < oldCap && Array.isArray(slice)) {
+                    slice[i + oldLen] = elements[i];
+                }
+            }
+            result.__meta__ = {
+                backing: slice,
+                offset: 0,
+                length: newLen,
+                capacity: oldCap,
+            };
+            return result;
+        }
+    }
+    else {
+        let newCap = oldCap;
+        if (newCap == 0) {
+            newCap = elements.length;
+        }
+        else {
+            if (newCap < 1024) {
+                newCap *= 2;
+            }
+            else {
+                newCap += newCap / 4;
+            }
+            // Ensure the new capacity fits all the elements
+            if (newCap < newLen) {
+                newCap = newLen;
+            }
+        }
+        const newBacking = new Array(newCap);
+        if (isComplexSlice(slice)) {
+            const offset = slice.__meta__.offset;
+            const backing = slice.__meta__.backing;
+            for (let i = 0; i < oldLen; i++) {
+                newBacking[i] = backing[offset + i];
+            }
+        }
+        else {
+            for (let i = 0; i < oldLen; i++) {
+                newBacking[i] = slice[i];
+            }
+        }
+        for (let i = 0; i < elements.length; i++) {
+            newBacking[oldLen + i] = elements[i];
+        }
+        if (newLen === newCap) {
+            return newBacking.slice(0, newLen);
+        }
+        const result = new Array(newLen);
+        for (let i = 0; i < newLen; i++) {
+            result[i] = newBacking[i];
+        }
+        result.__meta__ = {
+            backing: newBacking,
+            offset: 0,
+            length: newLen,
+            capacity: newCap,
+        };
+        return result;
+    }
+};
+/**
+ * Copies elements from src to dst.
+ * @param dst The destination slice.
+ * @param src The source slice.
+ * @returns The number of elements copied.
+ */
+export const copy = (dst, src) => {
+    if (dst === null || src === null) {
+        return 0;
+    }
+    const dstLen = len(dst);
+    const srcLen = len(src);
+    const count = Math.min(dstLen, srcLen);
+    if (count === 0) {
+        return 0;
+    }
+    if (isComplexSlice(dst)) {
+        const dstOffset = dst.__meta__.offset;
+        const dstBacking = dst.__meta__.backing;
+        if (isComplexSlice(src)) {
+            const srcOffset = src.__meta__.offset;
+            const srcBacking = src.__meta__.backing;
+            for (let i = 0; i < count; i++) {
+                dstBacking[dstOffset + i] = srcBacking[srcOffset + i];
+                dst[i] = srcBacking[srcOffset + i]; // Update the proxy array
+            }
+        }
+        else {
+            for (let i = 0; i < count; i++) {
+                dstBacking[dstOffset + i] = src[i];
+                dst[i] = src[i]; // Update the proxy array
+            }
+        }
+    }
+    else {
+        if (isComplexSlice(src)) {
+            const srcOffset = src.__meta__.offset;
+            const srcBacking = src.__meta__.backing;
+            for (let i = 0; i < count; i++) {
+                dst[i] = srcBacking[srcOffset + i];
+            }
+        }
+        else {
+            for (let i = 0; i < count; i++) {
+                dst[i] = src[i];
+            }
+        }
+    }
+    return count;
 };
 /**
  * Converts a string to an array of Unicode code points (runes).
@@ -71,8 +471,30 @@ export const stringToRunes = (str) => {
  * @returns The resulting string.
  */
 export const runesToString = (runes) => {
-    return String.fromCharCode(...runes);
+    return runes?.length ? String.fromCharCode(...runes) : '';
 };
+/**
+ * Converts a number to a byte (uint8) by truncating to the range 0-255.
+ * Equivalent to Go's byte() conversion.
+ * @param n The number to convert to a byte.
+ * @returns The byte value (0-255).
+ */
+export const byte = (n) => {
+    return n & 0xff; // Bitwise AND with 255 ensures we get a value in the range 0-255
+};
+/** Wrap a non-null T in a pointer‐box. */
+export function box(v) {
+    // We create a new object wrapper for every box call to ensure
+    // distinct pointer identity, crucial for pointer comparisons (p1 == p2).
+    return { value: v };
+}
+/** Dereference a pointer‐box, throws on null → simulates Go panic. */
+export function unbox(b) {
+    if (b === null) {
+        throw new Error('runtime error: invalid memory address or nil pointer dereference');
+    }
+    return b.value;
+}
 /**
  * Gets a value from a map, with a default value if the key doesn't exist.
  * @param map The map to get from.
@@ -109,147 +531,417 @@ export const deleteMapEntry = (map, key) => {
 export const mapHas = (map, key) => {
     return map.has(key);
 };
-/**
- * Appends elements to a slice (TypeScript array).
- * Note: In Go, append can return a new slice if the underlying array is reallocated.
- * This helper emulates that by returning the modified array.
- * @param slice The slice (TypeScript array) to append to.
- * @param elements The elements to append.
- * @returns The modified slice (TypeScript array).
- */
-export const append = (slice, ...elements) => {
-    slice.push(...elements);
-    if (slice.__capacity !== undefined && slice.length > slice.__capacity) {
-        slice.__capacity = slice.length;
-    }
-    return slice;
-};
 /**
  * Represents the kinds of Go types that can be registered at runtime.
  */
 export var TypeKind;
 (function (TypeKind) {
-    TypeKind["Struct"] = "struct";
-    TypeKind["Interface"] = "interface";
     TypeKind["Basic"] = "basic";
-    TypeKind["Pointer"] = "pointer";
-    TypeKind["Slice"] = "slice";
+    TypeKind["Interface"] = "interface";
+    TypeKind["Struct"] = "struct";
     TypeKind["Map"] = "map";
-    TypeKind["Channel"] = "channel";
+    TypeKind["Slice"] = "slice";
+    TypeKind["Array"] = "array";
+    TypeKind["Pointer"] = "pointer";
     TypeKind["Function"] = "function";
+    TypeKind["Channel"] = "channel";
 })(TypeKind || (TypeKind = {}));
+// Type guard functions for TypeInfo variants
+export function isStructTypeInfo(info) {
+    return info.kind === TypeKind.Struct;
+}
+export function isInterfaceTypeInfo(info) {
+    return info.kind === TypeKind.Interface;
+}
+export function isBasicTypeInfo(info) {
+    return info.kind === TypeKind.Basic;
+}
+export function isMapTypeInfo(info) {
+    return info.kind === TypeKind.Map;
+}
+export function isSliceTypeInfo(info) {
+    return info.kind === TypeKind.Slice;
+}
+export function isArrayTypeInfo(info) {
+    return info.kind === TypeKind.Array;
+}
+export function isPointerTypeInfo(info) {
+    return info.kind === TypeKind.Pointer;
+}
+export function isFunctionTypeInfo(info) {
+    return info.kind === TypeKind.Function;
+}
+export function isChannelTypeInfo(info) {
+    return info.kind === TypeKind.Channel;
+}
 // Registry to store runtime type information
 const typeRegistry = new Map();
 /**
- * Registers a type with the runtime type system.
+ * Registers a struct type with the runtime type system.
  *
  * @param name The name of the type.
- * @param kind The kind of the type.
  * @param zeroValue The zero value for the type.
- * @param methods Optional set of method names for interfaces.
- * @param constructor Optional constructor for structs.
- * @returns The type information object for chaining.
+ * @param methods Set of method names for the struct.
+ * @param ctor Constructor for the struct.
+ * @returns The struct type information object.
  */
-export const registerType = (name, kind, zeroValue, methods, constructor) => {
+export const registerStructType = (name, zeroValue, methods, ctor) => {
     const typeInfo = {
         name,
-        kind,
+        kind: TypeKind.Struct,
         zeroValue,
         methods,
-        constructor,
+        ctor: ctor,
     };
     typeRegistry.set(name, typeInfo);
     return typeInfo;
 };
 /**
- * Performs a type assertion at runtime.
+ * Registers an interface type with the runtime type system.
  *
- * @param value The value to assert.
- * @param typeName The name of the target type.
- * @returns An object with the asserted value and whether the assertion succeeded.
- */
-export function typeAssert(value, typeName) {
-    // Get the type information from the registry
-    const typeInfo = typeRegistry.get(typeName);
-    if (!typeInfo) {
-        console.warn(`Type information for '${typeName}' not found in registry.`);
-        return { value: null, ok: false };
-    }
-    // If value is null or undefined, assertion fails
-    if (value === null || value === undefined) {
-        return { value: typeInfo.zeroValue, ok: false };
+ * @param name The name of the type.
+ * @param zeroValue The zero value for the type (usually null).
+ * @param methods Set of method names the interface requires.
+ * @returns The interface type information object.
+ */
+export const registerInterfaceType = (name, zeroValue, methods) => {
+    const typeInfo = {
+        name,
+        kind: TypeKind.Interface,
+        zeroValue,
+        methods,
+    };
+    typeRegistry.set(name, typeInfo);
+    return typeInfo;
+};
+/**
+ * Normalizes a type info to a structured TypeInfo object.
+ *
+ * @param info The type info or name.
+ * @returns A normalized TypeInfo object.
+ */
+function normalizeTypeInfo(info) {
+    if (typeof info === 'string') {
+        const typeInfo = typeRegistry.get(info);
+        if (typeInfo) {
+            return typeInfo;
+        }
+        return {
+            kind: TypeKind.Basic,
+            name: info,
+        };
     }
-    // Check based on the kind of the target type
-    switch (typeInfo.kind) {
-        case TypeKind.Struct:
-            // For structs, use instanceof with the constructor
-            if (typeInfo.constructor && value instanceof typeInfo.constructor) {
-                return { value: value, ok: true };
+    return info;
+}
+/**
+ * Validates that a map key matches the expected type info.
+ *
+ * @param key The key to validate
+ * @param keyTypeInfo The normalized type info for the key
+ * @returns True if the key matches the type info, false otherwise
+ */
+function validateMapKey(key, keyTypeInfo) {
+    if (keyTypeInfo.kind === TypeKind.Basic) {
+        // For string keys
+        if (keyTypeInfo.name === 'string') {
+            return typeof key === 'string';
+        }
+        else if (keyTypeInfo.name === 'int' ||
+            keyTypeInfo.name === 'float64' ||
+            keyTypeInfo.name === 'number') {
+            if (typeof key === 'string') {
+                return /^-?\d+(\.\d+)?$/.test(key);
             }
-            break;
-        case TypeKind.Interface:
-            // For interfaces, check if the value has all the required methods
-            if (typeInfo.methods && typeof value === 'object') {
-                const allMethodsPresent = Array.from(typeInfo.methods).every((method) => typeof value[method] === 'function');
-                if (allMethodsPresent) {
-                    return { value: value, ok: true };
+            else {
+                return typeof key === 'number';
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Checks if a value matches a basic type info.
+ *
+ * @param value The value to check.
+ * @param info The basic type info to match against.
+ * @returns True if the value matches the basic type, false otherwise.
+ */
+function matchesBasicType(value, info) {
+    if (info.name === 'string')
+        return typeof value === 'string';
+    if (info.name === 'number' || info.name === 'int' || info.name === 'float64')
+        return typeof value === 'number';
+    if (info.name === 'boolean' || info.name === 'bool')
+        return typeof value === 'boolean';
+    return false;
+}
+/**
+ * Checks if a value matches a struct type info.
+ *
+ * @param value The value to check.
+ * @param info The struct type info to match against.
+ * @returns True if the value matches the struct type, false otherwise.
+ */
+function matchesStructType(value, info) {
+    if (!isStructTypeInfo(info))
+        return false;
+    // For structs, use instanceof with the constructor
+    if (info.ctor && value instanceof info.ctor) {
+        return true;
+    }
+    if (info.fields && typeof value === 'object') {
+        // For struct type assertions, we need to check that the value has exactly
+        const descFields = Array.from(info.fields);
+        const valueFields = Object.keys(value);
+        const condition1 = descFields.every((field) => field in value);
+        const condition2 = valueFields.length === descFields.length;
+        const condition3 = valueFields.every((field) => descFields.includes(field));
+        console.log('Struct field matching debug:', {
+            descFields,
+            valueFields,
+            allDescFieldsInValue: condition1,
+            sameFieldCount: condition2,
+            allValueFieldsInDesc: condition3,
+        });
+        return condition1 && condition2 && condition3;
+    }
+    return false;
+}
+/**
+ * Checks if a value matches an interface type info.
+ *
+ * @param value The value to check.
+ * @param info The interface type info to match against.
+ * @returns True if the value matches the interface type, false otherwise.
+ */
+function matchesInterfaceType(value, info) {
+    // For interfaces, check if the value has all the required methods
+    if (isInterfaceTypeInfo(info) &&
+        info.methods &&
+        typeof value === 'object' &&
+        value !== null) {
+        return Array.from(info.methods).every((method) => typeof value[method] === 'function');
+    }
+    return false;
+}
+/**
+ * Checks if a value matches a map type info.
+ *
+ * @param value The value to check.
+ * @param info The map type info to match against.
+ * @returns True if the value matches the map type, false otherwise.
+ */
+function matchesMapType(value, info) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    if (!isMapTypeInfo(info))
+        return false;
+    if (info.keyType || info.elemType) {
+        let entries = [];
+        if (value instanceof Map) {
+            entries = Array.from(value.entries());
+        }
+        else {
+            entries = Object.entries(value);
+        }
+        if (entries.length === 0)
+            return true; // Empty map matches any map type
+        const sampleSize = Math.min(5, entries.length);
+        for (let i = 0; i < sampleSize; i++) {
+            const [k, v] = entries[i];
+            if (info.keyType) {
+                if (!validateMapKey(k, normalizeTypeInfo(info.keyType))) {
+                    return false;
                 }
             }
-            break;
-        case TypeKind.Basic: {
-            // For basic types, check if the value matches the expected JavaScript type
-            // This is a simple check for common basic types
-            const basicType = typeof value;
-            if (basicType === 'string' ||
-                basicType === 'number' ||
-                basicType === 'boolean') {
-                return { value: value, ok: true };
+            if (info.elemType &&
+                !matchesType(v, normalizeTypeInfo(info.elemType))) {
+                return false;
             }
-            break;
         }
-        case TypeKind.Pointer:
-            // For pointers, check if value is not null or undefined
-            // In Go, pointers can be nil which we represent as null/undefined in TS
-            if (value !== null && value !== undefined) {
-                return { value: value, ok: true };
-            }
-            break;
-        case TypeKind.Slice:
-            // For slices, check if the value is an array
-            if (Array.isArray(value)) {
-                return { value: value, ok: true };
+    }
+    return true;
+}
+/**
+ * Checks if a value matches an array or slice type info.
+ *
+ * @param value The value to check.
+ * @param info The array or slice type info to match against.
+ * @returns True if the value matches the array or slice type, false otherwise.
+ */
+function matchesArrayOrSliceType(value, info) {
+    // For slices and arrays, check if the value is an array and sample element types
+    if (!Array.isArray(value))
+        return false;
+    if (!isArrayTypeInfo(info) && !isSliceTypeInfo(info))
+        return false;
+    if (info.elemType) {
+        const arr = value;
+        if (arr.length === 0)
+            return true; // Empty array matches any array type
+        const sampleSize = Math.min(5, arr.length);
+        for (let i = 0; i < sampleSize; i++) {
+            if (!matchesType(arr[i], normalizeTypeInfo(info.elemType))) {
+                return false;
             }
-            break;
+        }
+    }
+    return true;
+}
+/**
+ * Checks if a value matches a pointer type info.
+ *
+ * @param value The value to check.
+ * @param info The pointer type info to match against.
+ * @returns True if the value matches the pointer type, false otherwise.
+ */
+function matchesPointerType(value, info) {
+    // For pointers, check if value is a Box (has a 'value' property)
+    if (value === null || value === undefined) {
+        return false;
+    }
+    // Check if the value is a Box (has a 'value' property)
+    if (typeof value !== 'object' || !('value' in value)) {
+        return false;
+    }
+    if (!isPointerTypeInfo(info))
+        return false;
+    if (info.elemType) {
+        const elemTypeInfo = normalizeTypeInfo(info.elemType);
+        return matchesType(value.value, elemTypeInfo);
+    }
+    return true;
+}
+/**
+ * Checks if a value matches a function type info.
+ *
+ * @param value The value to check.
+ * @param info The function type info to match against.
+ * @returns True if the value matches the function type, false otherwise.
+ */
+function matchesFunctionType(value, info) {
+    // For functions, check if the value is a function
+    return typeof value === 'function';
+}
+/**
+ * Checks if a value matches a channel type info.
+ *
+ * @param value The value to check.
+ * @param info The channel type info to match against.
+ * @returns True if the value matches the channel type, false otherwise.
+ */
+function matchesChannelType(value, info) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'send' in value &&
+        'receive' in value &&
+        'close' in value &&
+        typeof value.send === 'function' &&
+        typeof value.receive === 'function' &&
+        typeof value.close === 'function');
+}
+/**
+ * Checks if a value matches a type info.
+ *
+ * @param value The value to check.
+ * @param info The type info to match against.
+ * @returns True if the value matches the type info, false otherwise.
+ */
+function matchesType(value, info) {
+    if (value === null || value === undefined) {
+        return false;
+    }
+    switch (info.kind) {
+        case TypeKind.Basic:
+            return matchesBasicType(value, info);
+        case TypeKind.Struct:
+            return matchesStructType(value, info);
+        case TypeKind.Interface:
+            return matchesInterfaceType(value, info);
         case TypeKind.Map:
-            // For maps, check if the value is a Map
+            return matchesMapType(value, info);
+        case TypeKind.Slice:
+        case TypeKind.Array:
+            return matchesArrayOrSliceType(value, info);
+        case TypeKind.Pointer:
+            return matchesPointerType(value, info);
+        case TypeKind.Function:
+            return matchesFunctionType(value, info);
+        case TypeKind.Channel:
+            return matchesChannelType(value, info);
+        default:
+            console.warn(`Type matching for kind '${info.kind}' not implemented.`);
+            return false;
+    }
+}
+export function typeAssert(value, typeInfo) {
+    const normalizedType = normalizeTypeInfo(typeInfo);
+    if (isStructTypeInfo(normalizedType) &&
+        normalizedType.fields &&
+        typeof value === 'object' &&
+        value !== null) {
+        const descFields = Array.from(normalizedType.fields);
+        const valueFields = Object.keys(value);
+        // For struct type assertions, we need exact field matching
+        const structMatch = descFields.length === valueFields.length &&
+            descFields.every((field) => field in value) &&
+            valueFields.every((field) => descFields.includes(field));
+        if (structMatch) {
+            return { value: value, ok: true };
+        }
+        else {
+            return { value: null, ok: false };
+        }
+    }
+    if (isMapTypeInfo(normalizedType) &&
+        typeof value === 'object' &&
+        value !== null) {
+        if (normalizedType.keyType || normalizedType.elemType) {
+            let entries = [];
             if (value instanceof Map) {
-                return { value: value, ok: true };
+                entries = Array.from(value.entries());
             }
-            break;
-        case TypeKind.Channel:
-            // For channels, check if the value has the required Channel interface methods
-            if (typeof value === 'object' &&
-                value !== null &&
-                'send' in value &&
-                'receive' in value &&
-                'close' in value &&
-                typeof value.send === 'function' &&
-                typeof value.receive === 'function' &&
-                typeof value.close === 'function') {
-                return { value: value, ok: true };
+            else {
+                entries = Object.entries(value);
             }
-            break;
-        case TypeKind.Function:
-            // For functions, check if the value is a function
-            if (typeof value === 'function') {
+            if (entries.length === 0) {
                 return { value: value, ok: true };
             }
-            break;
-        default:
-            console.warn(`Type assertion for kind '${typeInfo.kind}' not implemented.`);
+            const sampleSize = Math.min(5, entries.length);
+            for (let i = 0; i < sampleSize; i++) {
+                const [k, v] = entries[i];
+                if (normalizedType.keyType) {
+                    if (!validateMapKey(k, normalizeTypeInfo(normalizedType.keyType))) {
+                        return { value: null, ok: false };
+                    }
+                }
+                if (normalizedType.elemType) {
+                    const elemTypeInfo = normalizeTypeInfo(normalizedType.elemType);
+                    if (!matchesType(v, elemTypeInfo)) {
+                        return { value: null, ok: false };
+                    }
+                }
+            }
+            // If we get here, the map type assertion passes
+            return { value: value, ok: true };
+        }
+    }
+    const matches = matchesType(value, normalizedType);
+    if (matches) {
+        return { value: value, ok: true };
     }
-    // Assertion failed
-    return { value: typeInfo.zeroValue, ok: false };
+    // If we get here, the assertion failed
+    // For registered types, use the zero value from the registry
+    if (typeof typeInfo === 'string') {
+        const registeredType = typeRegistry.get(typeInfo);
+        if (registeredType && registeredType.zeroValue !== undefined) {
+            return { value: registeredType.zeroValue, ok: false };
+        }
+    }
+    else if (normalizedType.zeroValue !== undefined) {
+        return { value: normalizedType.zeroValue, ok: false };
+    }
+    return { value: null, ok: false };
 }
 // A simple implementation of buffered channels
 class BufferedChannel {
@@ -543,12 +1235,14 @@ export const makeChannel = (bufferSize, zeroValue) => {
  * Implements the `Disposable` interface for use with `using` declarations.
  */
 export class DisposableStack {
-    #stack = [];
+    stack = [];
     /**
      * Adds a function to be executed when the stack is disposed.
      * @param fn The function to defer.
      */
-    defer(fn) { this.#stack.push(fn); }
+    defer(fn) {
+        this.stack.push(fn);
+    }
     /**
      * Disposes of the resources in the stack by executing the deferred functions
      * in Last-In, First-Out (LIFO) order.
@@ -557,8 +1251,8 @@ export class DisposableStack {
      */
     [Symbol.dispose]() {
         // Emulate Go: if a deferred throws, stop and rethrow
-        while (this.#stack.length) {
-            const fn = this.#stack.pop();
+        while (this.stack.length) {
+            const fn = this.stack.pop();
             fn();
         }
     }
@@ -569,13 +1263,13 @@ export class DisposableStack {
  * Implements the `AsyncDisposable` interface for use with `await using` declarations.
  */
 export class AsyncDisposableStack {
-    #stack = [];
+    stack = [];
     /**
      * Adds a synchronous or asynchronous function to be executed when the stack is disposed.
      * @param fn The function to defer. Can return void or a Promise<void>.
      */
     defer(fn) {
-        this.#stack.push(fn);
+        this.stack.push(fn);
     }
     /**
      * Asynchronously disposes of the resources in the stack by executing the deferred functions
@@ -583,9 +1277,16 @@ export class AsyncDisposableStack {
      */
     async [Symbol.asyncDispose]() {
         // Execute in LIFO order, awaiting each potentially async function
-        for (let i = this.#stack.length - 1; i >= 0; --i) {
-            await this.#stack[i]();
+        for (let i = this.stack.length - 1; i >= 0; --i) {
+            await this.stack[i]();
         }
     }
 }
+/**
+ * Implementation of Go's built-in println function
+ * @param args Arguments to print
+ */
+export function println(...args) {
+    console.log(...args);
+}
 //# sourceMappingURL=builtin.js.map