goscript 0.0.22 → 0.0.24

package/dist/gs/builtin/type.js

@@ -0,0 +1,745 @@
+export { TypeKind };
+/**
+ * Represents the kinds of Go types that can be registered at runtime.
+ */
+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 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 VarRef (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;
+    }
+}
+/**
+ * Performs a type assertion on a value against a specified type.
+ * Returns an object containing the value (cast to type T) and a boolean indicating success.
+ * This is used to implement Go's type assertion with comma-ok idiom: value, ok := x.(Type)
+ *
+ * @param value The value to check against the type
+ * @param typeInfo The type information to check against (can be a string name or TypeInfo object)
+ * @returns An object with the asserted value and a boolean indicating if the assertion succeeded
+ */
+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;
+                    }
+                }
+            }
+            // If the function exists and there's no type info, assume it matches.
+            // TODO check this
+            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 };
+}
+/**
+ * Performs a type assertion on a value against a specified type.
+ * Returns the value (cast to type T) if the assertion is successful,
+ * otherwise throws a runtime error.
+ * This is used to implement Go's single-value type assertion: value := x.(Type)
+ *
+ * @param value The value to check against the type
+ * @param typeInfo The type information to check against (can be a string name or TypeInfo object)
+ * @returns The asserted value if the assertion succeeded
+ * @throws Error if the type assertion fails
+ */
+export function mustTypeAssert(value, typeInfo) {
+    const { value: assertedValue, ok } = typeAssert(value, typeInfo);
+    if (!ok) {
+        const targetTypeName = typeof typeInfo === 'string' ? typeInfo : (typeInfo.name || JSON.stringify(typeInfo));
+        let valueTypeName = typeof value;
+        if (value && value.constructor && value.constructor.name) {
+            valueTypeName = value.constructor.name;
+        }
+        if (value === null) {
+            valueTypeName = 'nil';
+        }
+        throw new Error(`inline type conversion panic: value is ${valueTypeName}, not ${targetTypeName}`);
+    }
+    return assertedValue;
+}
+/**
+ * Checks if a value is of a specific type.
+ * Similar to typeAssert but only returns a boolean without extracting the value.
+ *
+ * @param value The value to check
+ * @param typeInfo The type information to check against
+ * @returns True if the value matches the type, false otherwise
+ */
+export function is(value, typeInfo) {
+    return matchesType(value, normalizeTypeInfo(typeInfo));
+}
+/**
+ * Helper for Go's type switch statement.
+ * Executes the body of the first case whose type matches the value.
+ *
+ * @param value The value being switched upon.
+ * @param cases An array of TypeSwitchCase objects.
+ * @param defaultCase Optional function for the default case.
+ */
+export function typeSwitch(value, cases, defaultCase) {
+    for (const caseObj of cases) {
+        // For cases with multiple types (case T1, T2:), use $.is
+        if (caseObj.types.length > 1) {
+            const matchesAny = caseObj.types.some((typeInfo) => is(value, typeInfo));
+            if (matchesAny) {
+                // For multi-type cases, the case variable (if any) gets the original value
+                caseObj.body(value);
+                return; // Found a match, exit switch
+            }
+        }
+        else if (caseObj.types.length === 1) {
+            // For single-type cases (case T:), use $.typeAssert to get the typed value and ok status
+            const typeInfo = caseObj.types[0];
+            const { value: assertedValue, ok } = typeAssert(value, typeInfo);
+            if (ok) {
+                // Pass the asserted value to the case body function
+                caseObj.body(assertedValue);
+                return; // Found a match, exit switch
+            }
+        }
+        // Note: Cases with 0 types are not valid in Go type switches
+    }
+    // If no case matched and a default case exists, execute it
+    if (defaultCase) {
+        defaultCase();
+    }
+}
+//# sourceMappingURL=type.js.map