goscript 0.0.22 → 0.0.24

package/dist/builtin/builtin.js

@@ -1,1686 +0,0 @@
-export function asArray(slice) {
-    return slice;
-}
-/**
- * isComplexSlice checks if a slice is a complex slice (has __meta__ property)
- */
-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;
-};
-/**
- * goSlice creates a slice from s[low:high:max]
- * Arguments mirror Go semantics; omitted indices are undefined.
- *
- * @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).
- * @returns A new TypeScript Map.
- */
-export const makeMap = () => {
-    return new Map();
-};
-/**
- * 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 = (obj) => {
-    if (obj === null || obj === undefined) {
-        return 0;
-    }
-    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.
- * @param obj The slice.
- * @returns The capacity of the slice.
- */
-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).
- * @param str The input string.
- * @returns An array of numbers representing the Unicode code points.
- */
-export const stringToRunes = (str) => {
-    return Array.from(str).map((c) => c.codePointAt(0) || 0);
-};
-/**
- * Converts an array of Unicode code points (runes) to a string.
- * @param runes The input array of numbers representing Unicode code points.
- * @returns The resulting string.
- */
-export const runesToString = (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.
- * @param key The key to get.
- * @param defaultValue The default value to return if the key doesn't exist (defaults to 0).
- * @returns The value for the key, or the default value if the key doesn't exist.
- */
-export const mapGet = (map, key, defaultValue = null) => {
-    return map.has(key) ? map.get(key) : defaultValue;
-};
-/**
- * Sets a value in a map.
- * @param map The map to set in.
- * @param key The key to set.
- * @param value The value to set.
- */
-export const mapSet = (map, key, value) => {
-    map.set(key, value);
-};
-/**
- * Deletes a key from a map.
- * @param map The map to delete from.
- * @param key The key to delete.
- */
-export const deleteMapEntry = (map, key) => {
-    map.delete(key);
-};
-/**
- * Checks if a key exists in a map.
- * @param map The map to check in.
- * @param key The key to check.
- * @returns True if the key exists, false otherwise.
- */
-export const mapHas = (map, key) => {
-    return map.has(key);
-};
-/**
- * Represents the kinds of Go types that can be registered at runtime.
- */
-export var TypeKind;
-(function (TypeKind) {
-    TypeKind["Basic"] = "basic";
-    TypeKind["Interface"] = "interface";
-    TypeKind["Struct"] = "struct";
-    TypeKind["Map"] = "map";
-    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 struct type with the runtime type system.
- *
- * @param name The name of the type.
- * @param zeroValue The zero value for the type.
- * @param methods Array of method signatures for the struct.
- * @param ctor Constructor for the struct.
- * @param fields Record of field names and their types.
- * @returns The struct type information object.
- */
-export const registerStructType = (name, zeroValue, methods, ctor, fields = {}) => {
-    const typeInfo = {
-        name,
-        kind: TypeKind.Struct,
-        zeroValue,
-        methods,
-        ctor,
-        fields,
-    };
-    typeRegistry.set(name, typeInfo);
-    return typeInfo;
-};
-/**
- * Registers an interface type with the runtime type system.
- *
- * @param name The name of the type.
- * @param zeroValue The zero value for the type (usually null).
- * @param methods Array of method signatures for the interface.
- * @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,
-        };
-    }
-    return info;
-}
-function compareOptionalTypeInfo(type1, type2) {
-    if (type1 === undefined && type2 === undefined)
-        return true;
-    if (type1 === undefined || type2 === undefined)
-        return false;
-    // Assuming areTypeInfosIdentical will handle normalization if needed, 
-    // but type1 and type2 here are expected to be direct fields from TypeInfo objects.
-    return areTypeInfosIdentical(type1, type2);
-}
-function areFuncParamOrResultArraysIdentical(arr1, arr2) {
-    if (arr1 === undefined && arr2 === undefined)
-        return true;
-    if (arr1 === undefined || arr2 === undefined)
-        return false;
-    if (arr1.length !== arr2.length)
-        return false;
-    for (let i = 0; i < arr1.length; i++) {
-        if (!areTypeInfosIdentical(arr1[i], arr2[i])) {
-            return false;
-        }
-    }
-    return true;
-}
-function areFuncSignaturesIdentical(func1, func2) {
-    if ((func1.isVariadic || false) !== (func2.isVariadic || false)) {
-        return false;
-    }
-    return (areFuncParamOrResultArraysIdentical(func1.params, func2.params) &&
-        areFuncParamOrResultArraysIdentical(func1.results, func2.results));
-}
-function areMethodArgsArraysIdentical(args1, args2) {
-    if (args1 === undefined && args2 === undefined)
-        return true;
-    if (args1 === undefined || args2 === undefined)
-        return false;
-    if (args1.length !== args2.length)
-        return false;
-    for (let i = 0; i < args1.length; i++) {
-        // Compare based on type only, names of args/results don't affect signature identity here.
-        if (!areTypeInfosIdentical(args1[i].type, args2[i].type)) {
-            return false;
-        }
-    }
-    return true;
-}
-export function areTypeInfosIdentical(type1InfoOrName, type2InfoOrName) {
-    const t1Norm = normalizeTypeInfo(type1InfoOrName);
-    const t2Norm = normalizeTypeInfo(type2InfoOrName);
-    if (t1Norm === t2Norm)
-        return true; // Object identity
-    if (t1Norm.kind !== t2Norm.kind)
-        return false;
-    // If types have names, the names must match for identity.
-    // If one has a name and the other doesn't, they are not identical.
-    if (t1Norm.name !== t2Norm.name)
-        return false;
-    // If both are named and names match, for Basic, Struct, Interface, this is sufficient for identity.
-    if (t1Norm.name !== undefined /* && t2Norm.name is also defined and equal */) {
-        if (t1Norm.kind === TypeKind.Basic ||
-            t1Norm.kind === TypeKind.Struct ||
-            t1Norm.kind === TypeKind.Interface) {
-            return true;
-        }
-    }
-    // For other types (Pointer, Slice, etc.), or if both are anonymous (name is undefined),
-    // structural comparison is needed.
-    switch (t1Norm.kind) {
-        case TypeKind.Basic:
-            // Names matched if they were defined, or both undefined (which means true by t1Norm.name !== t2Norm.name being false)
-            return true;
-        case TypeKind.Pointer:
-            return compareOptionalTypeInfo(t1Norm.elemType, t2Norm.elemType);
-        case TypeKind.Slice:
-            return compareOptionalTypeInfo(t1Norm.elemType, t2Norm.elemType);
-        case TypeKind.Array:
-            return (t1Norm.length === t2Norm.length &&
-                compareOptionalTypeInfo(t1Norm.elemType, t2Norm.elemType));
-        case TypeKind.Map:
-            return (compareOptionalTypeInfo(t1Norm.keyType, t2Norm.keyType) &&
-                compareOptionalTypeInfo(t1Norm.elemType, t2Norm.elemType));
-        case TypeKind.Channel:
-            return (
-            // Ensure direction property exists before comparing, or handle undefined if it can be
-            (t1Norm.direction || 'both') === (t2Norm.direction || 'both') &&
-                compareOptionalTypeInfo(t1Norm.elemType, t2Norm.elemType));
-        case TypeKind.Function:
-            return areFuncSignaturesIdentical(t1Norm, t2Norm);
-        case TypeKind.Struct:
-        case TypeKind.Interface:
-            // If we reach here, names were undefined (both anonymous) or names matched but was not Basic/Struct/Interface.
-            // For anonymous Struct/Interface, strict identity means full structural comparison.
-            // For now, we consider anonymous types not identical unless they are the same object (caught above).
-            // If they were named and matched, 'return true' was hit earlier for these kinds.
-            return false;
-        default:
-            return false;
-    }
-}
-/**
- * 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);
-            }
-            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;
-    }
-    // Check if the value has all methods defined in the struct's TypeInfo
-    // This is a structural check, not a signature check here.
-    // Signature checks are more relevant for interface satisfaction.
-    if (info.methods && typeof value === 'object' && value !== null) {
-        const allMethodsExist = info.methods.every((methodSig) => typeof value[methodSig.name] === 'function');
-        if (!allMethodsExist) {
-            return false;
-        }
-        // Further signature checking could be added here if needed for struct-to-struct assignability
-    }
-    if (typeof value === 'object' && value !== null && info.fields) {
-        const fieldNames = Object.keys(info.fields || {});
-        const valueFields = Object.keys(value);
-        const fieldsExist = fieldNames.every((field) => field in value);
-        const sameFieldCount = valueFields.length === fieldNames.length;
-        const allFieldsInStruct = valueFields.every((field) => fieldNames.includes(field));
-        if (fieldsExist && sameFieldCount && allFieldsInStruct) {
-            return Object.entries(info.fields).every(([fieldName, fieldType]) => {
-                return matchesType(value[fieldName], normalizeTypeInfo(fieldType));
-            });
-        }
-        return false;
-    }
-    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.
- */
-/**
- * Checks if a value matches an interface type info by verifying it implements
- * all required methods with compatible signatures.
- *
- * @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) {
-    // Check basic conditions first
-    if (!isInterfaceTypeInfo(info) || typeof value !== 'object' || value === null) {
-        return false;
-    }
-    // For interfaces, check if the value has all the required methods with compatible signatures
-    return info.methods.every((requiredMethodSig) => {
-        const actualMethod = value[requiredMethodSig.name];
-        // Method must exist and be a function
-        if (typeof actualMethod !== 'function') {
-            return false;
-        }
-        // Check parameter count (basic arity check)
-        // Note: This is a simplified check as JavaScript functions can have optional/rest parameters
-        const declaredParamCount = actualMethod.length;
-        const requiredParamCount = requiredMethodSig.args.length;
-        // Strict arity checking can be problematic in JS, so we'll be lenient
-        // A method with fewer params than required is definitely incompatible
-        if (declaredParamCount < requiredParamCount) {
-            return false;
-        }
-        // Check return types if we can determine them
-        // This is challenging in JavaScript without runtime type information
-        // If the value has a __goTypeName property, it might be a registered type
-        // with more type information available
-        if (value.__goTypeName) {
-            const valueTypeInfo = typeRegistry.get(value.__goTypeName);
-            if (valueTypeInfo && isStructTypeInfo(valueTypeInfo)) {
-                // Find the matching method in the value's type info
-                const valueMethodSig = valueTypeInfo.methods.find(m => m.name === requiredMethodSig.name);
-                if (valueMethodSig) {
-                    // Compare return types
-                    if (valueMethodSig.returns.length !== requiredMethodSig.returns.length) {
-                        return false;
-                    }
-                    // Compare each return type for compatibility
-                    for (let i = 0; i < requiredMethodSig.returns.length; i++) {
-                        const requiredReturnType = normalizeTypeInfo(requiredMethodSig.returns[i].type);
-                        const valueReturnType = normalizeTypeInfo(valueMethodSig.returns[i].type);
-                        // For interface return types, we need to check if the value's return type
-                        // implements the required interface
-                        if (isInterfaceTypeInfo(requiredReturnType)) {
-                            // This would be a recursive check, but we'll simplify for now
-                            // by just checking if the types are the same or if the value type
-                            // is registered as implementing the interface
-                            if (requiredReturnType.name !== valueReturnType.name) {
-                                // Check if valueReturnType implements requiredReturnType
-                                // This would require additional implementation tracking
-                                return false;
-                            }
-                        }
-                        // For non-interface types, check direct type compatibility
-                        else if (requiredReturnType.name !== valueReturnType.name) {
-                            return false;
-                        }
-                    }
-                    // Similarly, we could check parameter types for compatibility
-                    // but we'll skip that for brevity
-                }
-            }
-        }
-        // If we can't determine detailed type information, we'll accept the method
-        // as long as it exists with a compatible arity
-        return true;
-    });
-}
-/**
- * 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;
-                }
-            }
-            if (info.elemType &&
-                !matchesType(v, normalizeTypeInfo(info.elemType))) {
-                return false;
-            }
-        }
-    }
-    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;
-            }
-        }
-    }
-    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) {
-    // Allow null/undefined values to match pointer types to support nil pointer assertions
-    // This enables Go's nil pointer type assertions like `ptr, ok := i.(*SomeType)` to work correctly
-    if (value === null || value === undefined) {
-        return true;
-    }
-    // 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) {
-    // First check if the value is a function
-    if (typeof value !== 'function') {
-        return false;
-    }
-    // This is important for named function types
-    if (info.name && value.__goTypeName) {
-        return info.name === value.__goTypeName;
-    }
-    return true;
-}
-/**
- * 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) {
-    // First check if it's a channel or channel reference
-    if (typeof value !== 'object' || value === null) {
-        return false;
-    }
-    // If it's a ChannelRef, get the underlying channel
-    let channel = value;
-    let valueDirection = 'both';
-    if ('channel' in value && 'direction' in value) {
-        channel = value.channel;
-        valueDirection = value.direction;
-    }
-    // Check if it has channel methods
-    if (!('send' in channel) ||
-        !('receive' in channel) ||
-        !('close' in channel) ||
-        typeof channel.send !== 'function' ||
-        typeof channel.receive !== 'function' ||
-        typeof channel.close !== 'function') {
-        return false;
-    }
-    if (info.elemType) {
-        if (info.elemType === 'string' &&
-            'zeroValue' in channel &&
-            channel.zeroValue !== '') {
-            return false;
-        }
-        if (info.elemType === 'number' &&
-            'zeroValue' in channel &&
-            typeof channel.zeroValue !== 'number') {
-            return false;
-        }
-    }
-    if (info.direction) {
-        return valueDirection === info.direction;
-    }
-    return true;
-}
-/**
- * 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:
-            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 (isPointerTypeInfo(normalizedType) && value === null) {
-        return { value: null, ok: true };
-    }
-    if (isStructTypeInfo(normalizedType) &&
-        normalizedType.methods && normalizedType.methods.length > 0 &&
-        typeof value === 'object' &&
-        value !== null) {
-        // Check if the value implements all methods of the struct type with compatible signatures.
-        // This is more for interface satisfaction by a struct.
-        // For struct-to-struct assertion, usually instanceof or field checks are primary.
-        const allMethodsMatch = normalizedType.methods.every((requiredMethodSig) => {
-            const actualMethod = value[requiredMethodSig.name];
-            if (typeof actualMethod !== 'function') {
-                return false;
-            }
-            const valueTypeInfoVal = value.$typeInfo;
-            if (valueTypeInfoVal) {
-                const normalizedValueType = normalizeTypeInfo(valueTypeInfoVal);
-                if (isStructTypeInfo(normalizedValueType) || isInterfaceTypeInfo(normalizedValueType)) {
-                    const actualValueMethodSig = normalizedValueType.methods.find(m => m.name === requiredMethodSig.name);
-                    if (actualValueMethodSig) {
-                        // Perform full signature comparison using MethodSignatures
-                        const paramsMatch = areMethodArgsArraysIdentical(requiredMethodSig.args, actualValueMethodSig.args);
-                        const resultsMatch = areMethodArgsArraysIdentical(requiredMethodSig.returns, actualValueMethodSig.returns);
-                        return paramsMatch && resultsMatch;
-                    }
-                    else {
-                        // Value has TypeInfo listing methods, but this specific method isn't listed.
-                        // This implies a mismatch for strict signature check based on TypeInfo.
-                        return false;
-                    }
-                }
-            }
-            // Fallback: Original behavior if value has no TypeInfo that lists methods,
-            // or if the method wasn't found in its TypeInfo (covered by 'else' returning false above).
-            // The original comment was: "For now, presence and function type is checked by matchesStructType/matchesInterfaceType"
-            // This 'return true' implies that if we couldn't do a full signature check via TypeInfo,
-            // we still consider it a match if the function simply exists on the object.
-            return true;
-        });
-        if (allMethodsMatch) {
-            return { value: value, ok: true };
-        }
-    }
-    if (isStructTypeInfo(normalizedType) &&
-        normalizedType.fields &&
-        typeof value === 'object' &&
-        value !== null) {
-        const fieldNames = Object.keys(normalizedType.fields);
-        const valueFields = Object.keys(value);
-        // For struct type assertions, we need exact field matching
-        const structFieldsMatch = fieldNames.length === valueFields.length &&
-            fieldNames.every((field) => field in value) &&
-            valueFields.every((field) => fieldNames.includes(field));
-        if (structFieldsMatch) {
-            const typesMatch = Object.entries(normalizedType.fields).every(([fieldName, fieldType]) => {
-                return matchesType(value[fieldName], normalizeTypeInfo(fieldType));
-            });
-            return { value: value, ok: typesMatch };
-        }
-        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) {
-                entries = Array.from(value.entries());
-            }
-            else {
-                entries = Object.entries(value);
-            }
-            if (entries.length === 0) {
-                return { value: value, ok: true };
-            }
-            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 };
-    }
-    // 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 {
-    buffer = [];
-    closed = false;
-    capacity;
-    zeroValue; // Made public for access by ChannelRef or for type inference
-    // Senders queue: stores { value, resolve for send, reject for send }
-    senders = [];
-    // Receivers queue for receive(): stores { resolve for receive, reject for receive }
-    receivers = [];
-    // Receivers queue for receiveWithOk(): stores { resolve for receiveWithOk }
-    receiversWithOk = [];
-    constructor(capacity, zeroValue) {
-        if (capacity < 0) {
-            throw new Error('Channel capacity cannot be negative');
-        }
-        this.capacity = capacity;
-        this.zeroValue = zeroValue;
-    }
-    async send(value) {
-        if (this.closed) {
-            throw new Error('send on closed channel');
-        }
-        // Attempt to hand off to a waiting receiver (rendezvous)
-        if (this.receivers.length > 0) {
-            const receiverTask = this.receivers.shift();
-            queueMicrotask(() => receiverTask.resolveReceive(value));
-            return;
-        }
-        if (this.receiversWithOk.length > 0) {
-            const receiverTask = this.receiversWithOk.shift();
-            queueMicrotask(() => receiverTask.resolveReceive({ value, ok: true }));
-            return;
-        }
-        // If no waiting receivers, try to buffer if space is available
-        if (this.buffer.length < this.capacity) {
-            this.buffer.push(value);
-            return;
-        }
-        // Buffer is full (or capacity is 0 and no receivers are waiting). Sender must block.
-        return new Promise((resolve, reject) => {
-            this.senders.push({ value, resolveSend: resolve, rejectSend: reject });
-        });
-    }
-    async receive() {
-        // Attempt to get from buffer first
-        if (this.buffer.length > 0) {
-            const value = this.buffer.shift();
-            // If a sender was waiting because the buffer was full, unblock it.
-            if (this.senders.length > 0) {
-                const senderTask = this.senders.shift();
-                this.buffer.push(senderTask.value); // Sender's value now goes into buffer
-                queueMicrotask(() => senderTask.resolveSend()); // Unblock sender
-            }
-            return value;
-        }
-        // Buffer is empty.
-        // If channel is closed (and buffer is empty), subsequent receives panic.
-        if (this.closed) {
-            throw new Error('receive on closed channel');
-        }
-        // Buffer is empty, channel is open.
-        // Attempt to rendezvous with a waiting sender.
-        if (this.senders.length > 0) {
-            const senderTask = this.senders.shift();
-            queueMicrotask(() => senderTask.resolveSend()); // Unblock the sender
-            return senderTask.value; // Return the value from sender
-        }
-        // Buffer is empty, channel is open, no waiting senders. Receiver must block.
-        return new Promise((resolve, reject) => {
-            this.receivers.push({ resolveReceive: resolve, rejectReceive: reject });
-        });
-    }
-    async receiveWithOk() {
-        // Attempt to get from buffer first
-        if (this.buffer.length > 0) {
-            const value = this.buffer.shift();
-            if (this.senders.length > 0) {
-                const senderTask = this.senders.shift();
-                this.buffer.push(senderTask.value);
-                queueMicrotask(() => senderTask.resolveSend());
-            }
-            return { value, ok: true };
-        }
-        // Buffer is empty.
-        // Attempt to rendezvous with a waiting sender.
-        if (this.senders.length > 0) {
-            const senderTask = this.senders.shift();
-            queueMicrotask(() => senderTask.resolveSend());
-            return { value: senderTask.value, ok: true };
-        }
-        // Buffer is empty, no waiting senders.
-        // If channel is closed, return zero value with ok: false.
-        if (this.closed) {
-            return { value: this.zeroValue, ok: false };
-        }
-        // Buffer is empty, channel is open, no waiting senders. Receiver must block.
-        return new Promise((resolve) => {
-            this.receiversWithOk.push({ resolveReceive: resolve });
-        });
-    }
-    async selectReceive(id) {
-        if (this.buffer.length > 0) {
-            const value = this.buffer.shift();
-            if (this.senders.length > 0) {
-                const senderTask = this.senders.shift();
-                this.buffer.push(senderTask.value);
-                queueMicrotask(() => senderTask.resolveSend());
-            }
-            return { value, ok: true, id };
-        }
-        if (this.senders.length > 0) {
-            const senderTask = this.senders.shift();
-            queueMicrotask(() => senderTask.resolveSend());
-            return { value: senderTask.value, ok: true, id };
-        }
-        if (this.closed) {
-            return { value: this.zeroValue, ok: false, id };
-        }
-        return new Promise((resolve) => {
-            this.receiversWithOk.push({
-                resolveReceive: (result) => {
-                    resolve({ ...result, id });
-                },
-            });
-        });
-    }
-    async selectSend(value, id) {
-        if (this.closed) {
-            // A select case sending on a closed channel panics in Go.
-            // This will cause Promise.race in selectStatement to reject.
-            throw new Error('send on closed channel');
-        }
-        if (this.receivers.length > 0) {
-            const receiverTask = this.receivers.shift();
-            queueMicrotask(() => receiverTask.resolveReceive(value));
-            return { value: true, ok: true, id };
-        }
-        if (this.receiversWithOk.length > 0) {
-            const receiverTask = this.receiversWithOk.shift();
-            queueMicrotask(() => receiverTask.resolveReceive({ value, ok: true }));
-            return { value: true, ok: true, id };
-        }
-        if (this.buffer.length < this.capacity) {
-            this.buffer.push(value);
-            return { value: true, ok: true, id };
-        }
-        return new Promise((resolve, reject) => {
-            this.senders.push({
-                value,
-                resolveSend: () => resolve({ value: true, ok: true, id }),
-                rejectSend: (e) => reject(e), // Propagate error if channel closes
-            });
-        });
-    }
-    close() {
-        if (this.closed) {
-            throw new Error('close of closed channel');
-        }
-        this.closed = true;
-        const sendersToNotify = [...this.senders]; // Shallow copy for iteration
-        this.senders = [];
-        for (const senderTask of sendersToNotify) {
-            queueMicrotask(() => senderTask.rejectSend(new Error('send on closed channel')));
-        }
-        const receiversToNotify = [...this.receivers];
-        this.receivers = [];
-        for (const receiverTask of receiversToNotify) {
-            queueMicrotask(() => receiverTask.rejectReceive(new Error('receive on closed channel')));
-        }
-        const receiversWithOkToNotify = [...this.receiversWithOk];
-        this.receiversWithOk = [];
-        for (const receiverTask of receiversWithOkToNotify) {
-            queueMicrotask(() => receiverTask.resolveReceive({ value: this.zeroValue, ok: false }));
-        }
-    }
-    canReceiveNonBlocking() {
-        return this.buffer.length > 0 || this.senders.length > 0 || this.closed;
-    }
-    canSendNonBlocking() {
-        if (this.closed) {
-            return true; // Ready to panic
-        }
-        return (this.buffer.length < this.capacity ||
-            this.receivers.length > 0 ||
-            this.receiversWithOk.length > 0);
-    }
-}
-/**
- * A bidirectional channel reference.
- */
-export class BidirectionalChannelRef {
-    channel;
-    direction = 'both';
-    constructor(channel) {
-        this.channel = channel;
-    }
-    // Delegate all methods to the underlying channel
-    send(value) {
-        return this.channel.send(value);
-    }
-    receive() {
-        return this.channel.receive();
-    }
-    receiveWithOk() {
-        return this.channel.receiveWithOk();
-    }
-    close() {
-        this.channel.close();
-    }
-    canSendNonBlocking() {
-        return this.channel.canSendNonBlocking();
-    }
-    canReceiveNonBlocking() {
-        return this.channel.canReceiveNonBlocking();
-    }
-    selectSend(value, id) {
-        return this.channel.selectSend(value, id);
-    }
-    selectReceive(id) {
-        return this.channel.selectReceive(id);
-    }
-}
-/**
- * A send-only channel reference.
- */
-export class SendOnlyChannelRef {
-    channel;
-    direction = 'send';
-    constructor(channel) {
-        this.channel = channel;
-    }
-    // Allow send operations
-    send(value) {
-        return this.channel.send(value);
-    }
-    // Allow close operations
-    close() {
-        this.channel.close();
-    }
-    canSendNonBlocking() {
-        return this.channel.canSendNonBlocking();
-    }
-    selectSend(value, id) {
-        return this.channel.selectSend(value, id);
-    }
-    // Disallow receive operations
-    receive() {
-        throw new Error('Cannot receive from send-only channel');
-    }
-    receiveWithOk() {
-        throw new Error('Cannot receive from send-only channel');
-    }
-    canReceiveNonBlocking() {
-        return false;
-    }
-    selectReceive(id) {
-        throw new Error('Cannot receive from send-only channel');
-    }
-}
-/**
- * A receive-only channel reference.
- */
-export class ReceiveOnlyChannelRef {
-    channel;
-    direction = 'receive';
-    constructor(channel) {
-        this.channel = channel;
-    }
-    // Allow receive operations
-    receive() {
-        return this.channel.receive();
-    }
-    receiveWithOk() {
-        return this.channel.receiveWithOk();
-    }
-    canReceiveNonBlocking() {
-        return this.channel.canReceiveNonBlocking();
-    }
-    selectReceive(id) {
-        return this.channel.selectReceive(id);
-    }
-    // Disallow send operations
-    send(value) {
-        throw new Error('Cannot send to receive-only channel');
-    }
-    // Disallow close operations
-    close() {
-        throw new Error('Cannot close receive-only channel');
-    }
-    canSendNonBlocking() {
-        return false;
-    }
-    selectSend(value, id) {
-        throw new Error('Cannot send to receive-only channel');
-    }
-}
-/**
- * Creates a new channel reference with the specified direction.
- */
-export function makeChannelRef(channel, direction) {
-    switch (direction) {
-        case 'send':
-            return new SendOnlyChannelRef(channel);
-        case 'receive':
-            return new ReceiveOnlyChannelRef(channel);
-        default: // 'both'
-            return new BidirectionalChannelRef(channel);
-    }
-}
-/**
- * Helper for 'select' statements. Takes an array of select cases
- * and resolves when one of them completes, following Go's select rules.
- *
- * @param cases Array of SelectCase objects
- * @param hasDefault Whether there is a default case
- * @returns A promise that resolves with the result of the selected case
- */
-export async function selectStatement(cases, hasDefault = false) {
-    if (cases.length === 0 && !hasDefault) {
-        // Go spec: If there are no cases, the select statement blocks forever.
-        // Emulate blocking forever with a promise that never resolves.
-        return new Promise(() => { }); // Promise never resolves
-    }
-    // 1. Check for ready (non-blocking) operations
-    const readyCases = [];
-    for (const caseObj of cases) {
-        if (caseObj.id === -1) {
-            // Skip default case in this check
-            continue;
-        }
-        // Add check for channel existence
-        if (caseObj.channel) {
-            if (caseObj.isSend && caseObj.channel.canSendNonBlocking()) {
-                readyCases.push(caseObj);
-            }
-            else if (!caseObj.isSend && caseObj.channel.canReceiveNonBlocking()) {
-                readyCases.push(caseObj);
-            }
-        }
-    }
-    if (readyCases.length > 0) {
-        // If one or more cases are ready, choose one pseudo-randomly
-        const selectedCase = readyCases[Math.floor(Math.random() * readyCases.length)];
-        // Execute the selected operation and its onSelected handler
-        // Add check for channel existence
-        if (selectedCase.channel) {
-            if (selectedCase.isSend) {
-                const result = await selectedCase.channel.selectSend(selectedCase.value, selectedCase.id);
-                if (selectedCase.onSelected) {
-                    await selectedCase.onSelected(result); // Await the handler
-                }
-            }
-            else {
-                const result = await selectedCase.channel.selectReceive(selectedCase.id);
-                if (selectedCase.onSelected) {
-                    await selectedCase.onSelected(result); // Await the handler
-                }
-            }
-        }
-        else {
-            // This case should ideally not happen if channel is required for non-default cases
-            console.error('Selected case without a channel:', selectedCase);
-        }
-        return; // Return after executing a ready case
-    }
-    // 2. If no operations are ready and there's a default case, select default
-    if (hasDefault) {
-        // Find the default case (it will have id -1)
-        const defaultCase = cases.find((c) => c.id === -1);
-        if (defaultCase && defaultCase.onSelected) {
-            // Execute the onSelected handler for the default case
-            await defaultCase.onSelected({
-                value: undefined,
-                ok: false,
-                id: -1,
-            }); // Await the handler
-        }
-        return; // Return after executing the default case
-    }
-    // 3. If no operations are ready and no default case, block until one is ready
-    // Use Promise.race on the blocking promises
-    const blockingPromises = cases
-        .filter((c) => c.id !== -1)
-        .map((caseObj) => {
-        // Exclude default case
-        // Add check for channel existence (though it should always exist here)
-        if (caseObj.channel) {
-            if (caseObj.isSend) {
-                return caseObj.channel.selectSend(caseObj.value, caseObj.id);
-            }
-            else {
-                return caseObj.channel.selectReceive(caseObj.id);
-            }
-        }
-        // Return a promise that never resolves if channel is somehow missing
-        return new Promise(() => { });
-    });
-    const result = await Promise.race(blockingPromises);
-    // Execute onSelected handler for the selected case
-    const selectedCase = cases.find((c) => c.id === result.id);
-    if (selectedCase && selectedCase.onSelected) {
-        await selectedCase.onSelected(result); // Await the handler
-    }
-    // No explicit return needed here, as the function will implicitly return after the await
-}
-/**
- * Creates a new channel with the specified buffer size and zero value.
- * @param bufferSize The size of the channel buffer. If 0, creates an unbuffered channel.
- * @param zeroValue The zero value for the channel's element type.
- * @param direction Optional direction for the channel. Default is 'both' (bidirectional).
- * @returns A new channel instance or channel reference.
- */
-export const makeChannel = (bufferSize, zeroValue, direction = 'both') => {
-    const channel = new BufferedChannel(bufferSize, zeroValue);
-    // Wrap the channel with the appropriate ChannelRef based on direction
-    if (direction === 'send') {
-        return new SendOnlyChannelRef(channel);
-    }
-    else if (direction === 'receive') {
-        return new ReceiveOnlyChannelRef(channel);
-    }
-    else {
-        return channel;
-    }
-};
-/**
- * DisposableStack manages synchronous disposable resources, mimicking Go's defer behavior.
- * Functions added via `defer` are executed in LIFO order when the stack is disposed.
- * Implements the `Disposable` interface for use with `using` declarations.
- */
-export class DisposableStack {
-    stack = [];
-    /**
-     * Adds a function to be executed when the stack is disposed.
-     * @param fn The function to defer.
-     */
-    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.
-     * If a deferred function throws an error, disposal stops, and the error is rethrown,
-     * similar to Go's panic behavior during defer execution.
-     */
-    [Symbol.dispose]() {
-        // Emulate Go: if a deferred throws, stop and rethrow
-        while (this.stack.length) {
-            const fn = this.stack.pop();
-            fn();
-        }
-    }
-}
-/**
- * AsyncDisposableStack manages asynchronous disposable resources, mimicking Go's defer behavior.
- * Functions added via `defer` are executed sequentially in LIFO order when the stack is disposed.
- * Implements the `AsyncDisposable` interface for use with `await using` declarations.
- */
-export class AsyncDisposableStack {
-    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);
-    }
-    /**
-     * Asynchronously disposes of the resources in the stack by executing the deferred functions
-     * sequentially in Last-In, First-Out (LIFO) order. It awaits each function if it returns a promise.
-     */
-    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]();
-        }
-    }
-}
-/**
- * Implementation of Go's built-in println function
- * @param args Arguments to print
- */
-export function println(...args) {
-    console.log(...args);
-}
-//# sourceMappingURL=builtin.js.map