@mionjs/run-types 0.8.3-alpha.0 → 0.8.4

package/.dist/cjs/src/lib/jitFnCompiler.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"jitFnCompiler.cjs","sources":["../../../../src/lib/jitFnCompiler.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {JitCompiledFn, JitCompiledFnData, JitFnArgs, JITUtils, CompiledPureFunction} from '@mionjs/core';\nimport {MAX_STACK_DEPTH, getJitUtils, quickHash} from '@mionjs/core';\nimport type {TypeFunction} from '@deepkit/type';\nimport type {Mutable, JitFnID, StrNumber, JitCode, RunTypeOptions, JitCompilerOpts, RunTypeChildAccessor} from '../types.ts';\nimport type {BaseRunType} from './baseRunTypes.ts';\nimport type {BaseRunTypeFormat} from './baseRunTypeFormat.ts';\nimport {getReflectionName, type AnyKindName} from '../constants.kind.ts';\nimport {maxStackErrorMessage, JIT_STACK_TRACE_MESSAGE} from '../constants.ts';\nimport {type CodeType, CodeTypes, jitErrorArgs, type JitFnSettings} from '../constants.functions.ts';\nimport {getJITFnName, getJitFnSettings} from './jitFnsRegistry.ts';\nimport {JitFunctions} from '../constants.functions.ts';\nimport {isChildAccessorType, isFunctionParamsRunType, isJitErrorsCompiler} from './guards.ts';\nimport {addFullStop, getJitFnArgCallVarName, toLiteral, toLiteralInContext} from './utils.ts';\nimport {getRunTypeFormat} from './formats.ts';\nimport {emitJsonStringify} from '../jitCompilers/json/stringifyJson.ts';\nimport {emitToBinary} from '../jitCompilers/binary/toBinary.ts';\nimport {emitFromBinary} from '../jitCompilers/binary/fromBinary.ts';\nimport {emitToCode} from '../jitCompilers/json/toJsCode.ts';\nimport {createJitFunction, getJITFnHash} from './createJitFunction.ts';\nimport {cpf_newRunTypeErr, cpf_formatErr} from '../run-types-pure-fns.ts';\n\nconst RB = CodeTypes.returnBlock;\nconst S = CodeTypes.statement;\nconst E = CodeTypes.expression;\n\nexport type StackItem = {\n    /** current compile stack full variable accessor */\n    vλl: string;\n    /** current compile stack variable accessor */\n    rt: BaseRunType;\n    /** if should call a dependency instead inline code, then this would contain the id of the dependency to call */\n    dependencyId?: string;\n    staticPath?: StrNumber[];\n};\n\nexport type JitCompilerLike = BaseFnCompiler | JitCompiledFnData;\n\n/**\n * Program to compile a Jit function to be used at runtime.\n * These jit functions are used to validate, serialize, deserialize, etc... based on runTypes.\n */\nexport class BaseFnCompiler<FnArgsNames extends JitFnArgs = JitFnArgs, ID extends JitFnID = any>\n    implements JitCompiledFnData, JitCompilerOpts\n{\n    // !!! DO NOT MODIFY METHOD WITHOUT REVIEWING JIT CODE INVOCATIONS!!!\n    /** The Jit Generated function once the compilation is finished */\n    readonly fn: ((...args: any[]) => any) | undefined;\n    readonly createJitFn: ((utl: JITUtils) => (...args: any[]) => any) | undefined;\n    private isCompiled = false;\n\n    constructor(\n        public readonly rootType: BaseRunType,\n        // the id of the function to be compiled (isType, typeErrors, prepareForJson, restoreFromJson, etc)\n        public readonly fnID: ID,\n        jitFnSettings: JitFnSettings,\n        public readonly parentCompiler?: BaseFnCompiler,\n        jitFnHash?: string,\n        typeID?: StrNumber,\n        public readonly opts: RunTypeOptions = {}\n    ) {\n        this.typeName = this.rootType.getTypeName();\n        this.jitFnHash = jitFnHash || getJITFnHash(this.fnID, this.rootType, opts);\n        this.typeID = typeID || this.rootType.getTypeID();\n        this.args = {...jitFnSettings.jitArgs} as FnArgsNames;\n        this.defaultParamValues = {...jitFnSettings.jitDefaultArgs} as FnArgsNames;\n        this.returnName = jitFnSettings.returnName;\n        if (this.args.vλl) this.vλl = this.args.vλl;\n        // At the time of adding this compiler to the jit cache, the fn is undefined which is technically not allowed\n        // but this prevents issues with circular types and loading order of jit dependencies\n        getJitUtils().addToJitCache(this as JitCompiledFn);\n        validateCompilerOptions(opts);\n    }\n    readonly typeName: string;\n    readonly typeID: StrNumber;\n    readonly jitFnHash: string;\n    readonly args: FnArgsNames;\n    readonly defaultParamValues: FnArgsNames;\n    readonly returnName: string;\n\n    /** Alternative arguments to use when calling a child function */\n    readonly childrenCallArgs: Partial<Record<JitFnID, Partial<JitFnArgs>>> = {};\n\n    /** Code for the jit function. after the operation has been compiled */\n    readonly code: string = '';\n    /** Code for the context function enclosing the jit function.\n     * This can be used to initialize constant or some other things that will be required across all invocation.\n     * By default this contains constants for the direct dependencies of the jit function.\n     * */\n    readonly contextCodeItems = new Map<string, string>();\n    /**\n     * This flag is set to true when the result of a jit compilation is a no operation (empty function).\n     * Some jit compiled functions could execute no operations (ie: string, boolean and numbers does not require prepareForJson/restoreFromJson)\n     */\n    readonly isNoop?: boolean = false;\n    /** The list of all jit functions that are used by this function and it's children. */\n    readonly jitDependencies: Array<string> = [];\n    readonly pureFnDependencies: Array<string> = [];\n    /** The list of types being compiled.*/\n    readonly stack: StackItem[] = [];\n    popItem: StackItem | undefined;\n    /** shorthand for  this.length */\n    get length() {\n        return this.stack.length;\n    }\n    get totalLength() {\n        if (this.parentCompiler) return this.stack.length + this.parentCompiler.totalLength;\n        return this.stack.length;\n    }\n    /** The variable name for the current item in the stack. */\n    vλl: string = '';\n    getNestLevel(rt: BaseRunType<any>): number {\n        let index = -1;\n        this.stack.forEach((item, i) => {\n            if (item.rt === rt) index = i;\n            if (item.rt.src.id && item.rt.src.id === rt.src.id) index = i;\n        });\n        if (index !== -1) return index;\n        const fromParent = this.parentCompiler?.getNestLevel(rt);\n        if (fromParent && fromParent !== -1) return fromParent;\n        return -1; // not found\n    }\n    private varNameindex: Map<BaseRunType<any> | number, number> = new Map();\n    getLocalVarName(prefix: string, rt: BaseRunType<any>): string {\n        const key = rt.src.id || rt; // duplicated elements might have same index (that means they are the same deepkit type)\n        const index = this.varNameindex.get(key);\n        if (index !== undefined) return `${prefix}${index}`;\n        const newIndex = this.varNameindex.size;\n        this.varNameindex.set(key, newIndex);\n        return `${prefix}${newIndex}`;\n    }\n    /**\n     * The path to the current item in the stack,\n     * This path can contain prop names array indexes or event literal variable values, ie: if parsing an array the path item would be the name if the index variable.\n     * This is used to generate the correct code to access the value at runtime of the current item in the stack.\n     * ie: if parsing the tuple ['A','B','C'] and the current item is 'B', the path would [1] as is the index of the item in the stack.\n     * ie: if parsing the object {a: {b: {c: 'C'}}} and the current item is 'b', the path would ['a','b'] as is the path to the item in the stack.\n     * At runtime this path gets combined with the runtime pλth variable to generate the correct path to access the value\n     * */\n    private _accessPathLiterals: StrNumber[] = [];\n    /** push new item to the stack, returns true if new child is already in the stack (is circular type) */\n    pushStack(newChild: BaseRunType): void {\n        const totalLength = this.stack.length + this.totalLength;\n        if (totalLength > MAX_STACK_DEPTH) throw new Error(maxStackErrorMessage);\n        if (this.stack.length === 0) {\n            if (newChild !== this.rootType) throw new Error('rootType should be the first item in the stack');\n            newChild.getTypeID(); // ensures the constants are generated in correct order\n        }\n        this.vλl = getStackVλl(this);\n        // static path must be called before pushing the new item\n        if (isJitErrorsCompiler(this)) this._accessPathLiterals = getAccessPath(this);\n        const newStackItem: StackItem = {vλl: this.vλl, rt: newChild, staticPath: this._accessPathLiterals};\n        this.stack.push(newStackItem);\n    }\n    popStack(resultCode: JitCode): void | ((...args: any[]) => any) {\n        if (resultCode?.code) (this as Mutable<BaseFnCompiler>).code = resultCode.code;\n        this.popItem = this.stack.pop();\n        const item = this.stack[this.stack.length - 1];\n        this.vλl = item?.vλl || this.args.vλl;\n        if (isJitErrorsCompiler(this)) this._accessPathLiterals = item?.staticPath || [];\n    }\n    siplePushStack(newChild: BaseRunType): void {\n        const newStackItem: StackItem = {vλl: this.vλl, rt: newChild, staticPath: this._accessPathLiterals};\n        this.stack.push(newStackItem);\n    }\n    simplePopStack(): void {\n        this.popItem = this.stack.pop();\n    }\n    createJitFunction(overrideCode?: string): (...args: any[]) => any {\n        try {\n            if (overrideCode) {\n                (this as Mutable<BaseFnCompiler>).code = overrideCode;\n                this.isCompiled = false;\n            }\n            this.handleFunctionReturn();\n            return createJitFunction(this); // add the compiled function to jit cache\n        } catch (e: any) {\n            const fnName = getJITFnName(this.fnID);\n            const fnCode = ` Code:\\nfunction ${fnName}(){${this.code}}`;\n            const name = `(${this.rootType.getTypeName()}:${this.rootType.getTypeID()})`;\n            const typeString = `Type: ${this.rootType.stringify()}`;\n            throw new Error(`Error building ${fnName} JIT function for type ${name}: ${e?.message} \\n${typeString} \\n${fnCode}`);\n        }\n    }\n    /** Returns a copy of the access pat for current stack item */\n    getAccessPath(): StrNumber[] {\n        return [...this._accessPathLiterals];\n    }\n\n    getAccessPathArgs(): string {\n        return this._accessPathLiterals.join(',');\n    }\n    getAccessPathLength(): number {\n        return this._accessPathLiterals.length;\n    }\n    getAccessPathArgsForFnCall(): {args: string; length: number} {\n        return {args: this.getAccessPathArgs(), length: this.getAccessPathLength()};\n    }\n    getCurrentStackItem(): StackItem {\n        const item = this.stack[this.stack.length - 1];\n        if (!item) throw new Error('Compiler stack is empty, no current item');\n        return item;\n    }\n    getChildVλl(): string {\n        const parent = this.getCurrentStackItem();\n        if (!parent) return this.args.vλl;\n        const rt = parent.rt;\n        if (!isChildAccessorType(rt)) throw new Error(`cant get child var name from ${rt.getKindName()}`);\n        if (rt.skipSettingAccessor?.()) return parent.vλl;\n        return parent.vλl + (rt.useArrayAccessor() ? `[${rt.getChildLiteral(this)}]` : `.${rt.getChildVarName(this)}`);\n    }\n    shouldCallDependency(): boolean {\n        const stackItem = this.getCurrentStackItem();\n        return !stackItem.rt.isJitInlined() && this.stack.length > 1;\n    }\n    updateDependencies(childComp: JitCompiledFnData): void {\n        if (childComp.isNoop) return; // noop functions are not added to dependencies as shouldn't be used inside jit code neither\n        if (this.jitDependencies.includes(childComp.jitFnHash)) return;\n        this.jitDependencies.push(childComp.jitFnHash);\n    }\n    removeFromJitCache(): void {\n        getJitUtils().removeFromJitCache(this as JitCompiledFn);\n    }\n    getStackTrace(): string {\n        const separator = '.';\n        const parentTrace = this.parentCompiler ? this.parentCompiler.getStackTrace() + separator : JIT_STACK_TRACE_MESSAGE;\n        const lastParentItem = this.parentCompiler?.getCurrentStackItem();\n        const filteredStack = lastParentItem ? this.stack.filter((item) => item.rt !== lastParentItem?.rt) : this.stack;\n        return parentTrace + filteredStack.map((item) => this.getTypeTraceInfo(item.rt)).join(separator);\n    }\n    hasStackTrace(errorMessage: string) {\n        return errorMessage.includes(JIT_STACK_TRACE_MESSAGE);\n    }\n\n    /** Set a context code item */\n    setContextItem(key: string, value: string): void {\n        this.contextCodeItems.set(key, value);\n    }\n\n    /** Get a context code item */\n    getContextItem(key: string): string | undefined {\n        return this.contextCodeItems.get(key);\n    }\n\n    /** Check if a context code item exists */\n    hasContextItem(key: string): boolean {\n        return this.contextCodeItems.has(key);\n    }\n\n    /** Get all context code items values */\n    getContextItemValues(): string[] {\n        return Array.from(this.contextCodeItems.values());\n    }\n\n    setChildrenCallArgs(fnID: string, args: Partial<JitFnArgs>): void {\n        this.childrenCallArgs[fnID] = args;\n    }\n\n    getChildrenCallArgs(fnID: string): Partial<JitFnArgs> | undefined {\n        return this.childrenCallArgs[fnID];\n    }\n\n    /**\n     * Compiles the current function.\n     * This function handles the logic to determine if the operation should be compiled and code should be inlined, or called as a dependency.\n     * Note current JitCompiler operation might be different from the passed operation id.\n     * ie: typeErrors might want to compile isType to generate the part of the code that checks for the type.\n     * @param comp current jit compiler operation\n     * @param fnID operation id\n     * @returns\n     */\n    compile(rt: BaseRunType | undefined, expectedCType: CodeType, fnID: JitFnID): JitCode {\n        if (!rt) return {code: undefined, type: expectedCType};\n        let jCode: JitCode;\n        this.pushStack(rt);\n        if (this.shouldCallDependency()) {\n            const compiledOp = rt.createJitCompiledFunction(fnID, this, this.opts);\n            jCode = this.callDependency(rt, compiledOp);\n            this.updateDependencies(compiledOp);\n        } else {\n            // prettier-ignore\n            switch (fnID) {\n                    case JitFunctions.isType.id:\n                        jCode = this.compileFormatter(rt, fnID, rt.emitIsType(this, expectedCType), expectedCType, '&&'); break;\n                    case JitFunctions.typeErrors.id:\n                        jCode = this.compileFormatter(rt, fnID, rt.emitTypeErrors(this as any, expectedCType), expectedCType, ';'); break;\n                    case JitFunctions.prepareForJson.id:\n                        jCode = this.compileFormatter(rt, fnID,rt.emitPrepareForJson(this, expectedCType), expectedCType, ';'); break;\n                    case JitFunctions.restoreFromJson.id:\n                        jCode = this.compileFormatter(rt, fnID,rt.emitRestoreFromJson(this, expectedCType), expectedCType, ';'); break;\n                    case JitFunctions.stringifyJson.id:\n                        jCode = this.compileFormatter(rt, fnID,emitJsonStringify(rt, this), expectedCType, ';'); break;\n                    case JitFunctions.toBinary.id:\n                        jCode = this.compileFormatter(rt, fnID,emitToBinary(rt, this as any), expectedCType, ';'); break;\n                    case JitFunctions.fromBinary.id:\n                        jCode = this.compileFormatter(rt, fnID,emitFromBinary(rt, this as any), expectedCType, ';'); break;\n                    case JitFunctions.toJSCode.id:\n                        jCode =this.compileFormatter(rt, fnID, emitToCode(rt, this), expectedCType, ';'); break;\n                    case JitFunctions.unknownKeyErrors.id:\n                        jCode = rt.emitUnknownKeyErrors(this as any, expectedCType); break;\n                    case JitFunctions.hasUnknownKeys.id:\n                        jCode = rt.emitHasUnknownKeys(this, expectedCType); break;\n                    case JitFunctions.stripUnknownKeys.id:\n                        jCode = rt.emitStripUnknownKeys(this, expectedCType); break;\n                    case JitFunctions.unknownKeysToUndefined.id:\n                        jCode = rt.emitUnknownKeysToUndefined(this, expectedCType); break;\n                    case JitFunctions.format.id:\n                        jCode = {code: undefined, type: E}; break;\n                    default:\n                        throw new Error(`Unknown compile operation: ${fnID}`);\n                }\n            if (jCode?.code) {\n                // endure the child code type is compatible with the parent code type.\n                // ie: a code statement can not be interpolated within an expression\n                const compatibleCode = this.handleCodeInterpolation(rt, jCode, expectedCType);\n                jCode = {code: compatibleCode, type: jCode.type};\n            }\n        }\n        this.popStack(jCode);\n        return jCode;\n    }\n\n    private compileFormatter(\n        rt: BaseRunType,\n        fnID: JitFnID,\n        childJCode: JitCode,\n        expectedCType: CodeType,\n        separator: ';' | '&&'\n    ): JitCode {\n        const expectedCT = childJCode.code ? childJCode.type : expectedCType;\n        const typeFormatter = getRunTypeFormat(rt);\n        if (!typeFormatter) return childJCode;\n        let jitCode: JitCode | undefined = undefined;\n        const formatterCode = typeFormatter.compileFormat(fnID, this, rt);\n        // Check if the formatter code can be embedded AND is compatible with the function ID\n        const canEmbed = typeFormatter.canEmbedFormatterCode(fnID, rt);\n        const codeHasReturn = formatterCode.type === RB;\n\n        // For isType and similar functions that are expressions, we need to ensure\n        // the formatter code is also an expression or has a return statement\n        const isCompatible = formatterCode.type === expectedCT;\n        if (canEmbed && isCompatible && !codeHasReturn) {\n            jitCode = formatterCode;\n        } else {\n            // Otherwise, create a separate function\n            const compiled = typeFormatter.createJitCompiledFormatter(fnID, rt, this, undefined, undefined, undefined, this.opts);\n            if (!compiled.isNoop) {\n                this.updateDependencies(compiled);\n                jitCode = this.callDependency(rt, compiled);\n            }\n        }\n        if (!jitCode?.code) return childJCode;\n        const shouldReplace = getJitFnSettings(fnID).formatShouldReplaceJitCode;\n        const joiner = separator === '&&' ? ' && ' : '; ';\n        if (shouldReplace) {\n            return jitCode;\n        }\n        const finalCode = childJCode?.code ? childJCode.code + joiner + jitCode.code : jitCode.code;\n        return {code: finalCode, type: expectedCT};\n    }\n\n    private callDependency(rt: BaseRunType, dependencyComp: JitCompiledFn): JitCode {\n        if (dependencyComp.isNoop) return {code: '', type: E}; // we don't need to call noop functions\n        const isErrorCall =\n            dependencyComp.fnID === JitFunctions.typeErrors.id || dependencyComp.fnID === JitFunctions.unknownKeyErrors.id;\n\n        // Use the dependency's args, not the current compiler's args\n        const depArgs = getJitFnSettings(dependencyComp.fnID as JitFnID).jitArgs;\n        const callArgsCode = Object.keys(depArgs)\n            .map((key) => getJitFnArgCallVarName(this, rt, dependencyComp.fnID as JitFnID, key))\n            .join(',');\n        const isSelf = this.jitFnHash === dependencyComp.jitFnHash;\n        const varName = dependencyComp.jitFnHash;\n        // call local variable instead directly calling jitUtils to avoid lookups.\n        // ie function context (local variable created when compiling the function): const abc = jitUtils.getJIT('abc);\n        // ie calling context variable: abc.fn();\n        // if operation is the same as the current operation we can call the function directly\n\n        const callCode = isSelf ? `${varName}(${callArgsCode})` : `${varName}.fn(${callArgsCode})`;\n        if (!isSelf) this.setContextItem(varName, `const ${varName} = utl.getJIT(${toLiteral(varName)})`);\n        if (isErrorCall) {\n            const pathArgs = this.getAccessPathArgs();\n            const pathLength = this.getAccessPathLength();\n            if (!pathLength) return {code: callCode, type: 'E'};\n            // increase and decrease the static path before and after calling the dependency function\n            // TODO, maybe we can improve performance by using something else than push and splice\n            return {\n                code: `${jitErrorArgs.pλth}.push(${pathArgs}); ${callCode}; ${jitErrorArgs.pλth}.splice(-${pathLength});`,\n                type: 'S',\n            };\n        }\n        return {code: callCode, type: 'E'};\n    }\n\n    /** Check if root type is a FunctionParamsRunType with no children (empty params) */\n    private isEmptyFunctionParams(): boolean {\n        if (!isFunctionParamsRunType(this.rootType)) return false;\n        return this.rootType.getChildRunTypes().length === 0;\n    }\n\n    /**\n     * Set the isNoop flag based on the code of the operation.\n     * must be called before function gets compiled.\n     * The isNoop flag is used to avoid calling the function when the result of compilation is an empty function.\n     */\n    private handleFunctionReturn(): void {\n        if (this.isCompiled) return;\n        let isNoop = false;\n        // trims code and transforms multiple whitespaces into a single one, does not affect new lines as those can be significant\n        let code = this.code.replace(/[ \\t]+/g, ' ').replace(/;+/g, ';');\n        // For functions with no params, all validation/serialization functions are noop\n        const isEmptyParams = this.isEmptyFunctionParams();\n        switch (this.fnID) {\n            case JitFunctions.isType.id:\n                isNoop = isEmptyParams || !this.code || this.code === 'true' || this.code === 'return true';\n                if (isNoop) code = `return true`; // if code is a noop, we still need to return true\n                break;\n            case JitFunctions.hasUnknownKeys.id:\n                isNoop = !this.code || this.code === 'false' || this.code === 'return false';\n                if (isNoop) code = `return false`; // if code is a noop, we still need return false\n                break;\n            case JitFunctions.prepareForJson.id:\n            case JitFunctions.restoreFromJson.id:\n            case JitFunctions.stripUnknownKeys.id:\n            case JitFunctions.unknownKeysToUndefined.id:\n                isNoop = isEmptyParams || !this.code || this.code === this.args.vλl || this.code === `return ${this.args.vλl}`;\n                if (isNoop) code = `return ${this.args.vλl}`; // if code is a noop, we need to return the value\n                break;\n            case JitFunctions.typeErrors.id:\n            case JitFunctions.unknownKeyErrors.id:\n                isNoop = isEmptyParams || !this.code || this.code === this.args.εrr || this.code === `return ${this.args.εrr}`;\n                if (isNoop) code = `return ${this.args.εrr}`; // if code is a noop, we need to return the error array\n                break;\n            case JitFunctions.format.id:\n                isNoop = !this.code || this.code === this.args.vλl || this.code === `return ${this.args.vλl}`;\n                if (isNoop) code = `return ${this.args.vλl}`; // if code is a noop, we need to return the value\n                break;\n        }\n        (this as Mutable<BaseFnCompiler>).isNoop = isNoop;\n        (this as Mutable<BaseFnCompiler>).code = code;\n        this.isCompiled = true;\n    }\n\n    /** Ensures the child code type is compatible with the parent code type */\n    private handleCodeInterpolation(rt: BaseRunType, childJCode: JitCode, parentCodeType: CodeType): string {\n        const code = childJCode.code || '';\n        const childCodeType = childJCode.type;\n        const isRoot = this.length === 1;\n        // root code must ensure values are returned\n        if (isRoot) {\n            // prettier-ignore\n            switch (childCodeType) {\n                case E: return `return ${code}`;\n                case S: return  `${addFullStop(code)} return ${this.returnName}`;\n                case RB: return code;\n            }\n        }\n        switch (true) {\n            case parentCodeType === E && childCodeType === E:\n                return code;\n            case parentCodeType === E && childCodeType === S:\n                return this.callSelfInvokingFunction(childJCode);\n            case parentCodeType === E && childCodeType === RB:\n                return this.callSelfInvokingFunction(childJCode);\n            case parentCodeType === S && childCodeType === E:\n                return code; // no need for full stop, parent should handle it\n            case parentCodeType === S && childCodeType === S:\n                return addFullStop(code);\n            case parentCodeType === S && childCodeType === RB:\n                return this.callSelfInvokingFunction(childJCode);\n            case parentCodeType === RB && childCodeType === E:\n                throw new Error('Expected an block code but got an expression, rt should not happen as would be useless code.');\n            case parentCodeType === RB && childCodeType === S:\n                return addFullStop(code);\n            case parentCodeType === RB && childCodeType === RB:\n                return `${addFullStop(code)} return ${this.returnName}`;\n            default:\n                throw new Error(`Unexpected code type (expected: ${parentCodeType}, got: ${childCodeType})`);\n        }\n    }\n\n    /**\n     * If code should be an expression, but code has return a statement, we need to wrap it in a self invoking function to avoid syntax errors\n     * IMPORTANT TODO, WE CAN IMPROVE PERF QUITE A BIT BY CREATING A NEW FUNCTION IN CONTEXT INSTEAD SELF INVOkING\n     * TODO: we could create a new function and cache instead a self invoking function a performance is same but code is not repeated\n     * IE: this.selfInvoke(code), rt will create a new function in context and call that function instead of self invoking\n     * rt is specially for atomic types as we can be sure there are no references to children types inside the code block\n     */\n    private callSelfInvokingFunction(jCode: JitCode): string {\n        if (jCode.type === E) throw new Error('Javascript expressions never need to be wrapped in a self invoking function.');\n        if (!jCode.code) return '';\n        const code = jCode.code.trim();\n        const isSelfInvoking = code.startsWith('(function()') && code.endsWith(')()');\n        if (isSelfInvoking) return code;\n        const addReturn = jCode.type !== RB;\n        const returnCode = addReturn ? `return ` : '';\n        return `(function(){${returnCode}${jCode.code}})()`;\n    }\n\n    getTypeTraceInfo(rt: BaseRunType): string {\n        if (rt.getFamily() === 'C') return rt.src.typeName || getReflectionName(rt);\n        if (rt.getFamily() === 'F') return String((rt.src as TypeFunction).name) || getReflectionName(rt);\n        if (rt.getFamily() === 'M') {\n            const rtChild = rt as any as RunTypeChildAccessor;\n            const isRunTypeChildAccessor = !!rtChild.getChildVarName;\n            if (!isRunTypeChildAccessor) return getReflectionName(rt);\n            return String(rtChild.getChildVarName(this));\n        }\n        return getReflectionName(rt);\n    }\n\n    // ########## Compile Methods shorthands ##########\n\n    compileIsType(rt: BaseRunType | undefined, expectedCType: CodeType): JitCode {\n        return this.compile(rt, expectedCType, JitFunctions.isType.id);\n    }\n    compileTypeErrors(rt: BaseRunType | undefined, expectedCType: CodeType): JitCode {\n        return this.compile(rt, expectedCType, JitFunctions.typeErrors.id);\n    }\n    compilePrepareForJson(rt: BaseRunType | undefined, expectedCType: CodeType): JitCode {\n        return this.compile(rt, expectedCType, JitFunctions.prepareForJson.id);\n    }\n    compileRestoreFromJson(rt: BaseRunType | undefined, expectedCType: CodeType): JitCode {\n        return this.compile(rt, expectedCType, JitFunctions.restoreFromJson.id);\n    }\n    compileJsonStringify(rt: BaseRunType | undefined, expectedCType: CodeType): JitCode {\n        return this.compile(rt, expectedCType, JitFunctions.stringifyJson.id);\n    }\n    compileToBinary(rt: BaseRunType | undefined, expectedCType: CodeType): JitCode {\n        return this.compile(rt, expectedCType, JitFunctions.toBinary.id);\n    }\n    compileFromBinary(rt: BaseRunType | undefined, expectedCType: CodeType): JitCode {\n        return this.compile(rt, expectedCType, JitFunctions.fromBinary.id);\n    }\n    compileUnknownKeyErrors(rt: BaseRunType | undefined, expectedCType: CodeType): JitCode {\n        return this.compile(rt, expectedCType, JitFunctions.unknownKeyErrors.id);\n    }\n    compileHasUnknownKeys(rt: BaseRunType | undefined, expectedCType: CodeType): JitCode {\n        return this.compile(rt, expectedCType, JitFunctions.hasUnknownKeys.id);\n    }\n    compileStripUnknownKeys(rt: BaseRunType | undefined, expectedCType: CodeType): JitCode {\n        return this.compile(rt, expectedCType, JitFunctions.stripUnknownKeys.id);\n    }\n    compileUnknownKeysToUndefined(rt: BaseRunType | undefined, expectedCType: CodeType): JitCode {\n        return this.compile(rt, expectedCType, JitFunctions.unknownKeysToUndefined.id);\n    }\n\n    // ################### Pure Functions Operations ###################\n\n    addPureFunction(compiledPureFn: CompiledPureFunction): string {\n        const {namespace, fnName} = compiledPureFn;\n        const varName = quickHash(fnName, 8);\n        if (this.hasContextItem(varName)) return varName;\n        this.addPureFnDependency(compiledPureFn);\n        // Add context code for the pure function and params\n        const pureFunctionCode = `const ${varName} = utl.getPureFn(${toLiteral(namespace)}, ${toLiteral(fnName)})`;\n        this.setContextItem(varName, pureFunctionCode);\n        return varName;\n    }\n\n    addPureFnDependency(compiledPureFn: CompiledPureFunction): void {\n        const {namespace, fnName} = compiledPureFn;\n        if (!getJitUtils().hasPureFn(namespace, fnName))\n            throw new Error(\n                `Pure function with name ${fnName} can not be added as jit dependency in namespace ${namespace}, be sure to register the pure function first by calling getJitUtils().addPureFn()`\n            );\n        // Store as \"namespace::fnName\" format (using :: to avoid conflicts with : in names)\n        const key = `${namespace}::${fnName}`;\n        if (this.pureFnDependencies.includes(key)) return;\n        this.pureFnDependencies.push(key);\n    }\n}\n\n// ################### Compile Operations ###################\n\nexport class JitFnCompiler<ID extends JitFnID = any> extends BaseFnCompiler<JitFnArgs, ID> {\n    constructor(\n        rt: BaseRunType,\n        fnID: ID,\n        parentCompiler?: BaseFnCompiler,\n        jitFnHash?: string,\n        typeID?: StrNumber,\n        opts: RunTypeOptions = {}\n    ) {\n        const fnSettings = getJitFnSettings(fnID);\n        super(rt, fnID, fnSettings, parentCompiler, jitFnHash, typeID, opts);\n    }\n}\n\nexport class JitErrorsFnCompiler<ID extends JitFnID = any> extends BaseFnCompiler<typeof jitErrorArgs, ID> {\n    constructor(\n        rt: BaseRunType,\n        fnID: ID,\n        parentCompiler?: BaseFnCompiler,\n        jitFnHash?: string,\n        typeID?: StrNumber,\n        opts: RunTypeOptions = {}\n    ) {\n        const fnSettings = getJitFnSettings(fnID);\n        super(rt, fnID, fnSettings, parentCompiler, jitFnHash, typeID, opts);\n    }\n    callJitErr(expected: AnyKindName | BaseRunType<any>): string {\n        // TODO: most of the time jit path is an empty array, so a new array is created every time\n        // this can be optimized by adding it to the compiler context, or maybe make the param optional in jitUtils.err\n        return this.callJitErrWithPath(expected);\n    }\n    /**\n     * This is used when we add an extra item to the path,\n     * for extra info, ie union items, maps keys, etc...\n     * This is because we don't want the item int the real path as it is not part of the runtime path of an object.\n     * but we still want to add that info to process the error.\n     * ie: type  AorBList = ({a: string} | {b: string})[];\n     * we want the error to contain the info if it is union item a or b, but the path to the the doesn't have that info is just list[index]\n     * */\n    callJitErrWithPath(exp: AnyKindName | BaseRunType<any>, extraPathLiteral?: StrNumber): string {\n        const args = this._getJitErrorArgs(exp);\n        const accessPath = this.getAccessPathLiteral(extraPathLiteral);\n        if (accessPath) args.push(accessPath);\n        const errFn = this.addPureFunction(cpf_newRunTypeErr);\n        return `${errFn}(${args.join(',')})`;\n    }\n    callJitFormatErr(\n        expected: AnyKindName | BaseRunType<any>,\n        formatter: BaseRunTypeFormat<any>,\n        paramName: string,\n        paramValue: string | number | boolean | bigint,\n        extraPathLiteral?: StrNumber\n    ): string {\n        // jitUtil.formatErr function arguments =>\n\n        // pλth: StrNumber[],\n        // εrr: RunTypeError[],\n        // expected: string,\n\n        // fmtName: string,\n        // paramName: string,\n        // paramVal: StrNumber,\n        // fmtPath: StrNumber[],\n        // accessPath?: StrNumber[],\n        // fmtAccessPath?: StrNumber[]\n\n        const typeErrArgs = this._getJitErrorArgs(expected);\n        const fmtName = toLiteralInContext(this, formatter.getFormatName());\n        const pName = toLiteralInContext(this, paramName);\n        const pVal = toLiteralInContext(this, paramValue);\n        const fmtPath = toLiteralInContext(this, formatter.getFormatPath());\n        const formatArgs = [fmtName, pName, pVal, fmtPath];\n        const optionalArgs: string[] = [];\n        const accessPath = this.getAccessPathLiteral(extraPathLiteral);\n        const formatAccessPath = this.getFormatAccessPathLiteral(formatter);\n        if (!accessPath && formatAccessPath) optionalArgs.push('undefined');\n        if (accessPath) optionalArgs.push(accessPath);\n        if (formatAccessPath) optionalArgs.push(formatAccessPath);\n        const formatErrFn = this.addPureFunction(cpf_formatErr);\n        return `${formatErrFn}(${[...typeErrArgs, ...formatArgs, ...optionalArgs].join(',')})`;\n    }\n\n    private _getJitErrorArgs(exp: AnyKindName | BaseRunType<any>): string[] {\n        // jitUtil.err function arguments =>\n        // pλth: StrNumber[],\n        // εrr: RunTypeError[],\n        // expected: string,\n        const path = this.args.pλth;\n        const err = this.args.εrr;\n        const expected = typeof exp === 'string' ? toLiteral(exp) : toLiteral(exp.getKindName());\n        return [path, err, expected];\n    }\n\n    getAccessPathLiteral(extraPathLiteral?: StrNumber): string {\n        const accessPath = this.getAccessPath();\n        if (extraPathLiteral) accessPath.push(extraPathLiteral);\n        return accessPath.length ? `[${accessPath.join(',')}]` : '';\n    }\n\n    getFormatAccessPathLiteral(formatter: BaseRunTypeFormat<any>): string {\n        const formatExtraPathLiteral = formatter.getFormatExtraPathLiteral();\n        return formatExtraPathLiteral ? `[${formatExtraPathLiteral}]` : '';\n    }\n}\n\n/**\n * This is an special compiler for mock Function as mock is not technically a jit compiled function\n * but still needs to be created to reuse all jit functionality.\n */\nexport class MockJitCompiler extends BaseFnCompiler<JitFnArgs, 'mock'> {\n    constructor(rt: BaseRunType, opts: RunTypeOptions, parentCompiler?: BaseFnCompiler, jitFnHash?: string, typeID?: StrNumber) {\n        super(rt, JitFunctions.mock.id, JitFunctions.mock, parentCompiler, jitFnHash, typeID, opts);\n    }\n}\n\n// ################### Compiler Creation ###################\n\nexport function createJitCompiler(\n    rt: BaseRunType,\n    fnID: JitFnID,\n    parent?: BaseFnCompiler,\n    jitFnHash?: string,\n    typeID?: StrNumber,\n    opts: RunTypeOptions = {}\n): BaseFnCompiler {\n    switch (fnID) {\n        case JitFunctions.isType.id:\n        case JitFunctions.prepareForJson.id:\n        case JitFunctions.restoreFromJson.id:\n        case JitFunctions.stringifyJson.id:\n        case JitFunctions.hasUnknownKeys.id:\n        case JitFunctions.stripUnknownKeys.id:\n        case JitFunctions.unknownKeysToUndefined.id:\n        case JitFunctions.format.id:\n        case JitFunctions.toJSCode.id:\n        case JitFunctions.toBinary.id:\n        case JitFunctions.fromBinary.id:\n            return new JitFnCompiler(rt, fnID, parent, jitFnHash, typeID, opts);\n        case JitFunctions.typeErrors.id:\n        case JitFunctions.unknownKeyErrors.id:\n            return new JitErrorsFnCompiler(rt, fnID, parent, jitFnHash, typeID, opts);\n        case JitFunctions.mock.id:\n            return new MockJitCompiler(rt, opts, parent, jitFnHash, typeID);\n        default:\n            throw new Error(`Unknown compile operation: ${fnID}`);\n    }\n}\n\nexport function printClosure(fnWithContext: string, functionName: string): string {\n    return `function get_${functionName}(utl){${fnWithContext}}`;\n}\n\n// ################### utils ###################\n\nfunction getStackVλl(comp: BaseFnCompiler): string {\n    let vλl: string = comp.args.vλl;\n    for (let i = 0; i < comp.stack.length; i++) {\n        const rt = comp.stack[i].rt;\n        const custom = rt.getCustomVλl(comp);\n        if (custom && custom.isStandalone) {\n            vλl = custom.vλl;\n        } else if (custom) {\n            vλl += custom.useArrayAccessor ? `[${custom.vλl}]` : `.${custom.vλl}`;\n        } else if (isChildAccessorType(rt) && !rt.skipSettingAccessor?.()) {\n            vλl += rt.useArrayAccessor() ? `[${rt.getChildLiteral(comp)}]` : `.${rt.getChildVarName(comp)}`;\n        }\n    }\n    return vλl;\n}\nfunction getAccessPath(comp: BaseFnCompiler): StrNumber[] {\n    const path: StrNumber[] = [];\n    const rtName: any = [];\n    for (let i = 0; i < comp.stack.length; i++) {\n        const rt = comp.stack[i].rt;\n        const pathItem = rt.getStaticPathLiteral(comp);\n        if (pathItem) {\n            path.push(pathItem);\n        } else if (isChildAccessorType(rt) && !rt.skipSettingAccessor?.()) {\n            path.push(rt.getChildLiteral(comp));\n        }\n        rtName.push({path: [...path], name: rt.constructor.name});\n    }\n    return path;\n}\n\nfunction validateCompilerOptions(opts: RunTypeOptions): void {\n    if (opts.paramsSlice) {\n        const start = opts.paramsSlice?.start;\n        const end = opts.paramsSlice?.end;\n        if (start && start < 0) {\n            throw new Error(`paramsSlice.start must be greater than 0`);\n        }\n        if (end && end < 0) {\n            throw new Error(`paramsSlice.end must be greater than 0`);\n        }\n        if (end && start && end <= start) {\n            throw new Error(`paramsSlice.end must be greater than paramsSlice.start`);\n        }\n    }\n}\n"],"names":["CodeTypes","getJITFnHash","getJitUtils","MAX_STACK_DEPTH","maxStackErrorMessage","isJitErrorsCompiler","createJitFunction","getJITFnName","isChildAccessorType","JIT_STACK_TRACE_MESSAGE","JitFunctions","emitJsonStringify","emitToBinary","emitFromBinary","emitToCode","getRunTypeFormat","getJitFnSettings","getJitFnArgCallVarName","toLiteral","jitErrorArgs","isFunctionParamsRunType","addFullStop","getReflectionName","quickHash","cpf_newRunTypeErr","toLiteralInContext","cpf_formatErr"],"mappings":"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"}
+{"version":3,"file":"jitFnCompiler.cjs","sources":["../../../../src/lib/jitFnCompiler.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {JitCompiledFn, JitCompiledFnData, JitFnArgs, JITUtils, CompiledPureFunction} from '@mionjs/core';\nimport {MAX_STACK_DEPTH, getJitUtils, quickHash} from '@mionjs/core';\nimport type {TypeFunction} from '@deepkit/type';\nimport type {Mutable, JitFnID, StrNumber, JitCode, RunTypeOptions, JitCompilerOpts, RunTypeChildAccessor} from '../types.ts';\nimport type {BaseRunType} from './baseRunTypes.ts';\nimport type {BaseRunTypeFormat} from './baseRunTypeFormat.ts';\nimport {getReflectionName, type AnyKindName} from '../constants.kind.ts';\nimport {maxStackErrorMessage, JIT_STACK_TRACE_MESSAGE} from '../constants.ts';\nimport {type CodeType, CodeTypes, jitErrorArgs, type JitFnSettings} from '../constants.functions.ts';\nimport {getJITFnName, getJitFnSettings} from './jitFnsRegistry.ts';\nimport {JitFunctions} from '../constants.functions.ts';\nimport {isChildAccessorType, isFunctionParamsRunType, isJitErrorsCompiler} from './guards.ts';\nimport {addFullStop, getJitFnArgCallVarName, toLiteral, toLiteralInContext} from './utils.ts';\nimport {getRunTypeFormat} from './formats.ts';\nimport {emitJsonStringify} from '../jitCompilers/json/stringifyJson.ts';\nimport {emitToBinary} from '../jitCompilers/binary/toBinary.ts';\nimport {emitFromBinary} from '../jitCompilers/binary/fromBinary.ts';\nimport {emitToCode} from '../jitCompilers/json/toJsCode.ts';\nimport {createJitFunction, getJITFnHash} from './createJitFunction.ts';\nimport {cpf_newRunTypeErr, cpf_formatErr} from '../run-types-pure-fns.ts';\n\nconst RB = CodeTypes.returnBlock;\nconst S = CodeTypes.statement;\nconst E = CodeTypes.expression;\n\nexport type StackItem = {\n    /** current compile stack full variable accessor */\n    vλl: string;\n    /** current compile stack variable accessor */\n    rt: BaseRunType;\n    /** if should call a dependency instead inline code, then this would contain the id of the dependency to call */\n    dependencyId?: string;\n    staticPath?: StrNumber[];\n};\n\nexport type JitCompilerLike = BaseFnCompiler | JitCompiledFnData;\n\n/**\n * Program to compile a Jit function to be used at runtime.\n * These jit functions are used to validate, serialize, deserialize, etc... based on runTypes.\n */\nexport class BaseFnCompiler<FnArgsNames extends JitFnArgs = JitFnArgs, ID extends JitFnID = any>\n    implements JitCompiledFnData, JitCompilerOpts\n{\n    // !!! DO NOT MODIFY METHOD WITHOUT REVIEWING JIT CODE INVOCATIONS!!!\n    /** The Jit Generated function once the compilation is finished */\n    readonly fn: ((...args: any[]) => any) | undefined;\n    readonly createJitFn: ((utl: JITUtils) => (...args: any[]) => any) | undefined;\n    private isCompiled = false;\n\n    constructor(\n        public readonly rootType: BaseRunType,\n        // the id of the function to be compiled (isType, typeErrors, prepareForJson, restoreFromJson, etc)\n        public readonly fnID: ID,\n        jitFnSettings: JitFnSettings,\n        public readonly parentCompiler?: BaseFnCompiler,\n        jitFnHash?: string,\n        typeID?: StrNumber,\n        public readonly opts: RunTypeOptions = {}\n    ) {\n        this.typeName = this.rootType.getTypeName();\n        this.jitFnHash = jitFnHash || getJITFnHash(this.fnID, this.rootType, opts);\n        this.typeID = typeID || this.rootType.getTypeID();\n        this.args = {...jitFnSettings.jitArgs} as FnArgsNames;\n        this.defaultParamValues = {...jitFnSettings.jitDefaultArgs} as FnArgsNames;\n        this.returnName = jitFnSettings.returnName;\n        if (this.args.vλl) this.vλl = this.args.vλl;\n        // At the time of adding this compiler to the jit cache, the fn is undefined which is technically not allowed\n        // but this prevents issues with circular types and loading order of jit dependencies\n        getJitUtils().addToJitCache(this as JitCompiledFn);\n        validateCompilerOptions(opts);\n    }\n    readonly typeName: string;\n    readonly typeID: StrNumber;\n    readonly jitFnHash: string;\n    readonly args: FnArgsNames;\n    readonly defaultParamValues: FnArgsNames;\n    readonly returnName: string;\n\n    /** Alternative arguments to use when calling a child function */\n    readonly childrenCallArgs: Partial<Record<JitFnID, Partial<JitFnArgs>>> = {};\n\n    /** Code for the jit function. after the operation has been compiled */\n    readonly code: string = '';\n    /** Code for the context function enclosing the jit function.\n     * This can be used to initialize constant or some other things that will be required across all invocation.\n     * By default this contains constants for the direct dependencies of the jit function.\n     * */\n    readonly contextCodeItems = new Map<string, string>();\n    /**\n     * This flag is set to true when the result of a jit compilation is a no operation (empty function).\n     * Some jit compiled functions could execute no operations (ie: string, boolean and numbers does not require prepareForJson/restoreFromJson)\n     */\n    readonly isNoop?: boolean = false;\n    /** The list of all jit functions that are used by this function and it's children. */\n    readonly jitDependencies: Array<string> | undefined;\n    readonly pureFnDependencies: Array<string> | undefined;\n    /** The list of types being compiled.*/\n    readonly stack: StackItem[] = [];\n    popItem: StackItem | undefined;\n    /** shorthand for  this.length */\n    get length() {\n        return this.stack.length;\n    }\n    get totalLength() {\n        if (this.parentCompiler) return this.stack.length + this.parentCompiler.totalLength;\n        return this.stack.length;\n    }\n    /** The variable name for the current item in the stack. */\n    vλl: string = '';\n    getNestLevel(rt: BaseRunType<any>): number {\n        let index = -1;\n        this.stack.forEach((item, i) => {\n            if (item.rt === rt) index = i;\n            if (item.rt.src.id && item.rt.src.id === rt.src.id) index = i;\n        });\n        if (index !== -1) return index;\n        const fromParent = this.parentCompiler?.getNestLevel(rt);\n        if (fromParent && fromParent !== -1) return fromParent;\n        return -1; // not found\n    }\n    private varNameindex: Map<BaseRunType<any> | number, number> = new Map();\n    getLocalVarName(prefix: string, rt: BaseRunType<any>): string {\n        const key = rt.src.id || rt; // duplicated elements might have same index (that means they are the same deepkit type)\n        const index = this.varNameindex.get(key);\n        if (index !== undefined) return `${prefix}${index}`;\n        const newIndex = this.varNameindex.size;\n        this.varNameindex.set(key, newIndex);\n        return `${prefix}${newIndex}`;\n    }\n    /**\n     * The path to the current item in the stack,\n     * This path can contain prop names array indexes or event literal variable values, ie: if parsing an array the path item would be the name if the index variable.\n     * This is used to generate the correct code to access the value at runtime of the current item in the stack.\n     * ie: if parsing the tuple ['A','B','C'] and the current item is 'B', the path would [1] as is the index of the item in the stack.\n     * ie: if parsing the object {a: {b: {c: 'C'}}} and the current item is 'b', the path would ['a','b'] as is the path to the item in the stack.\n     * At runtime this path gets combined with the runtime pλth variable to generate the correct path to access the value\n     * */\n    private _accessPathLiterals: StrNumber[] = [];\n    /** push new item to the stack, returns true if new child is already in the stack (is circular type) */\n    pushStack(newChild: BaseRunType): void {\n        const totalLength = this.stack.length + this.totalLength;\n        if (totalLength > MAX_STACK_DEPTH) throw new Error(maxStackErrorMessage);\n        if (this.stack.length === 0) {\n            if (newChild !== this.rootType) throw new Error('rootType should be the first item in the stack');\n            newChild.getTypeID(); // ensures the constants are generated in correct order\n        }\n        this.vλl = getStackVλl(this);\n        // static path must be called before pushing the new item\n        if (isJitErrorsCompiler(this)) this._accessPathLiterals = getAccessPath(this);\n        const newStackItem: StackItem = {vλl: this.vλl, rt: newChild, staticPath: this._accessPathLiterals};\n        this.stack.push(newStackItem);\n    }\n    popStack(resultCode: JitCode): void | ((...args: any[]) => any) {\n        if (resultCode?.code) (this as Mutable<BaseFnCompiler>).code = resultCode.code;\n        this.popItem = this.stack.pop();\n        const item = this.stack[this.stack.length - 1];\n        this.vλl = item?.vλl || this.args.vλl;\n        if (isJitErrorsCompiler(this)) this._accessPathLiterals = item?.staticPath || [];\n    }\n    siplePushStack(newChild: BaseRunType): void {\n        const newStackItem: StackItem = {vλl: this.vλl, rt: newChild, staticPath: this._accessPathLiterals};\n        this.stack.push(newStackItem);\n    }\n    simplePopStack(): void {\n        this.popItem = this.stack.pop();\n    }\n    createJitFunction(overrideCode?: string): (...args: any[]) => any {\n        try {\n            if (overrideCode) {\n                (this as Mutable<BaseFnCompiler>).code = overrideCode;\n                this.isCompiled = false;\n            }\n            this.handleFunctionReturn();\n            return createJitFunction(this); // add the compiled function to jit cache\n        } catch (e: any) {\n            const fnName = getJITFnName(this.fnID);\n            const fnCode = ` Code:\\nfunction ${fnName}(){${this.code}}`;\n            const name = `(${this.rootType.getTypeName()}:${this.rootType.getTypeID()})`;\n            const typeString = `Type: ${this.rootType.stringify()}`;\n            throw new Error(`Error building ${fnName} JIT function for type ${name}: ${e?.message} \\n${typeString} \\n${fnCode}`);\n        }\n    }\n    /** Returns a copy of the access pat for current stack item */\n    getAccessPath(): StrNumber[] {\n        return [...this._accessPathLiterals];\n    }\n\n    getAccessPathArgs(): string {\n        return this._accessPathLiterals.join(',');\n    }\n    getAccessPathLength(): number {\n        return this._accessPathLiterals.length;\n    }\n    getAccessPathArgsForFnCall(): {args: string; length: number} {\n        return {args: this.getAccessPathArgs(), length: this.getAccessPathLength()};\n    }\n    getCurrentStackItem(): StackItem {\n        const item = this.stack[this.stack.length - 1];\n        if (!item) throw new Error('Compiler stack is empty, no current item');\n        return item;\n    }\n    getChildVλl(): string {\n        const parent = this.getCurrentStackItem();\n        if (!parent) return this.args.vλl;\n        const rt = parent.rt;\n        if (!isChildAccessorType(rt)) throw new Error(`cant get child var name from ${rt.getKindName()}`);\n        if (rt.skipSettingAccessor?.()) return parent.vλl;\n        return parent.vλl + (rt.useArrayAccessor() ? `[${rt.getChildLiteral(this)}]` : `.${rt.getChildVarName(this)}`);\n    }\n    shouldCallDependency(): boolean {\n        const stackItem = this.getCurrentStackItem();\n        return !stackItem.rt.isJitInlined() && this.stack.length > 1;\n    }\n    updateDependencies(childComp: JitCompiledFnData): void {\n        if (childComp.isNoop) return; // noop functions are not added to dependencies as shouldn't be used inside jit code neither\n        if (this.jitDependencies?.includes(childComp.jitFnHash)) return;\n        if (!this.jitDependencies) (this as Mutable<this>).jitDependencies = [];\n        this.jitDependencies!.push(childComp.jitFnHash);\n    }\n    removeFromJitCache(): void {\n        getJitUtils().removeFromJitCache(this as JitCompiledFn);\n    }\n    getStackTrace(): string {\n        const separator = '.';\n        const parentTrace = this.parentCompiler ? this.parentCompiler.getStackTrace() + separator : JIT_STACK_TRACE_MESSAGE;\n        const lastParentItem = this.parentCompiler?.getCurrentStackItem();\n        const filteredStack = lastParentItem ? this.stack.filter((item) => item.rt !== lastParentItem?.rt) : this.stack;\n        return parentTrace + filteredStack.map((item) => this.getTypeTraceInfo(item.rt)).join(separator);\n    }\n    hasStackTrace(errorMessage: string) {\n        return errorMessage.includes(JIT_STACK_TRACE_MESSAGE);\n    }\n\n    /** Set a context code item */\n    setContextItem(key: string, value: string): void {\n        this.contextCodeItems.set(key, value);\n    }\n\n    /** Get a context code item */\n    getContextItem(key: string): string | undefined {\n        return this.contextCodeItems.get(key);\n    }\n\n    /** Check if a context code item exists */\n    hasContextItem(key: string): boolean {\n        return this.contextCodeItems.has(key);\n    }\n\n    /** Get all context code items values */\n    getContextItemValues(): string[] {\n        return Array.from(this.contextCodeItems.values());\n    }\n\n    setChildrenCallArgs(fnID: string, args: Partial<JitFnArgs>): void {\n        this.childrenCallArgs[fnID] = args;\n    }\n\n    getChildrenCallArgs(fnID: string): Partial<JitFnArgs> | undefined {\n        return this.childrenCallArgs[fnID];\n    }\n\n    /**\n     * Compiles the current function.\n     * This function handles the logic to determine if the operation should be compiled and code should be inlined, or called as a dependency.\n     * Note current JitCompiler operation might be different from the passed operation id.\n     * ie: typeErrors might want to compile isType to generate the part of the code that checks for the type.\n     * @param comp current jit compiler operation\n     * @param fnID operation id\n     * @returns\n     */\n    compile(rt: BaseRunType | undefined, expectedCType: CodeType, fnID: JitFnID): JitCode {\n        if (!rt) return {code: undefined, type: expectedCType};\n        let jCode: JitCode;\n        this.pushStack(rt);\n        if (this.shouldCallDependency()) {\n            const compiledOp = rt.createJitCompiledFunction(fnID, this, this.opts);\n            jCode = this.callDependency(rt, compiledOp);\n            this.updateDependencies(compiledOp);\n        } else {\n            // prettier-ignore\n            switch (fnID) {\n                    case JitFunctions.isType.id:\n                        jCode = this.compileFormatter(rt, fnID, rt.emitIsType(this, expectedCType), expectedCType, '&&'); break;\n                    case JitFunctions.typeErrors.id:\n                        jCode = this.compileFormatter(rt, fnID, rt.emitTypeErrors(this as any, expectedCType), expectedCType, ';'); break;\n                    case JitFunctions.prepareForJson.id:\n                        jCode = this.compileFormatter(rt, fnID,rt.emitPrepareForJson(this, expectedCType), expectedCType, ';'); break;\n                    case JitFunctions.restoreFromJson.id:\n                        jCode = this.compileFormatter(rt, fnID,rt.emitRestoreFromJson(this, expectedCType), expectedCType, ';'); break;\n                    case JitFunctions.stringifyJson.id:\n                        jCode = this.compileFormatter(rt, fnID,emitJsonStringify(rt, this), expectedCType, ';'); break;\n                    case JitFunctions.toBinary.id:\n                        jCode = this.compileFormatter(rt, fnID,emitToBinary(rt, this as any), expectedCType, ';'); break;\n                    case JitFunctions.fromBinary.id:\n                        jCode = this.compileFormatter(rt, fnID,emitFromBinary(rt, this as any), expectedCType, ';'); break;\n                    case JitFunctions.toJSCode.id:\n                        jCode =this.compileFormatter(rt, fnID, emitToCode(rt, this), expectedCType, ';'); break;\n                    case JitFunctions.unknownKeyErrors.id:\n                        jCode = rt.emitUnknownKeyErrors(this as any, expectedCType); break;\n                    case JitFunctions.hasUnknownKeys.id:\n                        jCode = rt.emitHasUnknownKeys(this, expectedCType); break;\n                    case JitFunctions.stripUnknownKeys.id:\n                        jCode = rt.emitStripUnknownKeys(this, expectedCType); break;\n                    case JitFunctions.unknownKeysToUndefined.id:\n                        jCode = rt.emitUnknownKeysToUndefined(this, expectedCType); break;\n                    case JitFunctions.format.id:\n                        jCode = {code: undefined, type: E}; break;\n                    default:\n                        throw new Error(`Unknown compile operation: ${fnID}`);\n                }\n            if (jCode?.code) {\n                // endure the child code type is compatible with the parent code type.\n                // ie: a code statement can not be interpolated within an expression\n                const compatibleCode = this.handleCodeInterpolation(rt, jCode, expectedCType);\n                jCode = {code: compatibleCode, type: jCode.type};\n            }\n        }\n        this.popStack(jCode);\n        return jCode;\n    }\n\n    private compileFormatter(\n        rt: BaseRunType,\n        fnID: JitFnID,\n        childJCode: JitCode,\n        expectedCType: CodeType,\n        separator: ';' | '&&'\n    ): JitCode {\n        const expectedCT = childJCode.code ? childJCode.type : expectedCType;\n        const typeFormatter = getRunTypeFormat(rt);\n        if (!typeFormatter) return childJCode;\n        let jitCode: JitCode | undefined = undefined;\n        const formatterCode = typeFormatter.compileFormat(fnID, this, rt);\n        // Check if the formatter code can be embedded AND is compatible with the function ID\n        const canEmbed = typeFormatter.canEmbedFormatterCode(fnID, rt);\n        const codeHasReturn = formatterCode.type === RB;\n\n        // For isType and similar functions that are expressions, we need to ensure\n        // the formatter code is also an expression or has a return statement\n        const isCompatible = formatterCode.type === expectedCT;\n        if (canEmbed && isCompatible && !codeHasReturn) {\n            jitCode = formatterCode;\n        } else {\n            // Otherwise, create a separate function\n            const compiled = typeFormatter.createJitCompiledFormatter(fnID, rt, this, undefined, undefined, undefined, this.opts);\n            if (!compiled.isNoop) {\n                this.updateDependencies(compiled);\n                jitCode = this.callDependency(rt, compiled);\n            }\n        }\n        if (!jitCode?.code) return childJCode;\n        const shouldReplace = getJitFnSettings(fnID).formatShouldReplaceJitCode;\n        const joiner = separator === '&&' ? ' && ' : '; ';\n        if (shouldReplace) {\n            return jitCode;\n        }\n        const finalCode = childJCode?.code ? childJCode.code + joiner + jitCode.code : jitCode.code;\n        return {code: finalCode, type: expectedCT};\n    }\n\n    private callDependency(rt: BaseRunType, dependencyComp: JitCompiledFn): JitCode {\n        if (dependencyComp.isNoop) return {code: '', type: E}; // we don't need to call noop functions\n        const isErrorCall =\n            dependencyComp.fnID === JitFunctions.typeErrors.id || dependencyComp.fnID === JitFunctions.unknownKeyErrors.id;\n\n        // Use the dependency's args, not the current compiler's args\n        const depArgs = getJitFnSettings(dependencyComp.fnID as JitFnID).jitArgs;\n        const callArgsCode = Object.keys(depArgs)\n            .map((key) => getJitFnArgCallVarName(this, rt, dependencyComp.fnID as JitFnID, key))\n            .join(',');\n        const isSelf = this.jitFnHash === dependencyComp.jitFnHash;\n        const varName = dependencyComp.jitFnHash;\n        // call local variable instead directly calling jitUtils to avoid lookups.\n        // ie function context (local variable created when compiling the function): const abc = jitUtils.getJIT('abc);\n        // ie calling context variable: abc.fn();\n        // if operation is the same as the current operation we can call the function directly\n\n        const callCode = isSelf ? `${varName}(${callArgsCode})` : `${varName}.fn(${callArgsCode})`;\n        if (!isSelf) this.setContextItem(varName, `const ${varName} = utl.getJIT(${toLiteral(varName)})`);\n        if (isErrorCall) {\n            const pathArgs = this.getAccessPathArgs();\n            const pathLength = this.getAccessPathLength();\n            if (!pathLength) return {code: callCode, type: 'E'};\n            // increase and decrease the static path before and after calling the dependency function\n            // TODO, maybe we can improve performance by using something else than push and splice\n            return {\n                code: `${jitErrorArgs.pλth}.push(${pathArgs}); ${callCode}; ${jitErrorArgs.pλth}.splice(-${pathLength});`,\n                type: 'S',\n            };\n        }\n        return {code: callCode, type: 'E'};\n    }\n\n    /** Check if root type is a FunctionParamsRunType with no children (empty params) */\n    private isEmptyFunctionParams(): boolean {\n        if (!isFunctionParamsRunType(this.rootType)) return false;\n        return this.rootType.getChildRunTypes().length === 0;\n    }\n\n    /**\n     * Set the isNoop flag based on the code of the operation.\n     * must be called before function gets compiled.\n     * The isNoop flag is used to avoid calling the function when the result of compilation is an empty function.\n     */\n    private handleFunctionReturn(): void {\n        if (this.isCompiled) return;\n        let isNoop = false;\n        // trims code and transforms multiple whitespaces into a single one, does not affect new lines as those can be significant\n        let code = this.code.replace(/[ \\t]+/g, ' ').replace(/;+/g, ';');\n        // For functions with no params, all validation/serialization functions are noop\n        const isEmptyParams = this.isEmptyFunctionParams();\n        switch (this.fnID) {\n            case JitFunctions.isType.id:\n                isNoop = isEmptyParams || !this.code || this.code === 'true' || this.code === 'return true';\n                if (isNoop) code = `return true`; // if code is a noop, we still need to return true\n                break;\n            case JitFunctions.hasUnknownKeys.id:\n                isNoop = !this.code || this.code === 'false' || this.code === 'return false';\n                if (isNoop) code = `return false`; // if code is a noop, we still need return false\n                break;\n            case JitFunctions.prepareForJson.id:\n            case JitFunctions.restoreFromJson.id:\n            case JitFunctions.stripUnknownKeys.id:\n            case JitFunctions.unknownKeysToUndefined.id:\n                isNoop = isEmptyParams || !this.code || this.code === this.args.vλl || this.code === `return ${this.args.vλl}`;\n                if (isNoop) code = `return ${this.args.vλl}`; // if code is a noop, we need to return the value\n                break;\n            case JitFunctions.typeErrors.id:\n            case JitFunctions.unknownKeyErrors.id:\n                isNoop = isEmptyParams || !this.code || this.code === this.args.εrr || this.code === `return ${this.args.εrr}`;\n                if (isNoop) code = `return ${this.args.εrr}`; // if code is a noop, we need to return the error array\n                break;\n            case JitFunctions.format.id:\n                isNoop = !this.code || this.code === this.args.vλl || this.code === `return ${this.args.vλl}`;\n                if (isNoop) code = `return ${this.args.vλl}`; // if code is a noop, we need to return the value\n                break;\n        }\n        (this as Mutable<BaseFnCompiler>).isNoop = isNoop;\n        (this as Mutable<BaseFnCompiler>).code = code;\n        this.isCompiled = true;\n    }\n\n    /** Ensures the child code type is compatible with the parent code type */\n    private handleCodeInterpolation(rt: BaseRunType, childJCode: JitCode, parentCodeType: CodeType): string {\n        const code = childJCode.code || '';\n        const childCodeType = childJCode.type;\n        const isRoot = this.length === 1;\n        // root code must ensure values are returned\n        if (isRoot) {\n            // prettier-ignore\n            switch (childCodeType) {\n                case E: return `return ${code}`;\n                case S: return  `${addFullStop(code)} return ${this.returnName}`;\n                case RB: return code;\n            }\n        }\n        switch (true) {\n            case parentCodeType === E && childCodeType === E:\n                return code;\n            case parentCodeType === E && childCodeType === S:\n                return this.callSelfInvokingFunction(childJCode);\n            case parentCodeType === E && childCodeType === RB:\n                return this.callSelfInvokingFunction(childJCode);\n            case parentCodeType === S && childCodeType === E:\n                return code; // no need for full stop, parent should handle it\n            case parentCodeType === S && childCodeType === S:\n                return addFullStop(code);\n            case parentCodeType === S && childCodeType === RB:\n                return this.callSelfInvokingFunction(childJCode);\n            case parentCodeType === RB && childCodeType === E:\n                throw new Error('Expected an block code but got an expression, rt should not happen as would be useless code.');\n            case parentCodeType === RB && childCodeType === S:\n                return addFullStop(code);\n            case parentCodeType === RB && childCodeType === RB:\n                return `${addFullStop(code)} return ${this.returnName}`;\n            default:\n                throw new Error(`Unexpected code type (expected: ${parentCodeType}, got: ${childCodeType})`);\n        }\n    }\n\n    /**\n     * If code should be an expression, but code has return a statement, we need to wrap it in a self invoking function to avoid syntax errors\n     * IMPORTANT TODO, WE CAN IMPROVE PERF QUITE A BIT BY CREATING A NEW FUNCTION IN CONTEXT INSTEAD SELF INVOkING\n     * TODO: we could create a new function and cache instead a self invoking function a performance is same but code is not repeated\n     * IE: this.selfInvoke(code), rt will create a new function in context and call that function instead of self invoking\n     * rt is specially for atomic types as we can be sure there are no references to children types inside the code block\n     */\n    private callSelfInvokingFunction(jCode: JitCode): string {\n        if (jCode.type === E) throw new Error('Javascript expressions never need to be wrapped in a self invoking function.');\n        if (!jCode.code) return '';\n        const code = jCode.code.trim();\n        const isSelfInvoking = code.startsWith('(function()') && code.endsWith(')()');\n        if (isSelfInvoking) return code;\n        const addReturn = jCode.type !== RB;\n        const returnCode = addReturn ? `return ` : '';\n        return `(function(){${returnCode}${jCode.code}})()`;\n    }\n\n    getTypeTraceInfo(rt: BaseRunType): string {\n        if (rt.getFamily() === 'C') return rt.src.typeName || getReflectionName(rt);\n        if (rt.getFamily() === 'F') return String((rt.src as TypeFunction).name) || getReflectionName(rt);\n        if (rt.getFamily() === 'M') {\n            const rtChild = rt as any as RunTypeChildAccessor;\n            const isRunTypeChildAccessor = !!rtChild.getChildVarName;\n            if (!isRunTypeChildAccessor) return getReflectionName(rt);\n            return String(rtChild.getChildVarName(this));\n        }\n        return getReflectionName(rt);\n    }\n\n    // ########## Compile Methods shorthands ##########\n\n    compileIsType(rt: BaseRunType | undefined, expectedCType: CodeType): JitCode {\n        return this.compile(rt, expectedCType, JitFunctions.isType.id);\n    }\n    compileTypeErrors(rt: BaseRunType | undefined, expectedCType: CodeType): JitCode {\n        return this.compile(rt, expectedCType, JitFunctions.typeErrors.id);\n    }\n    compilePrepareForJson(rt: BaseRunType | undefined, expectedCType: CodeType): JitCode {\n        return this.compile(rt, expectedCType, JitFunctions.prepareForJson.id);\n    }\n    compileRestoreFromJson(rt: BaseRunType | undefined, expectedCType: CodeType): JitCode {\n        return this.compile(rt, expectedCType, JitFunctions.restoreFromJson.id);\n    }\n    compileJsonStringify(rt: BaseRunType | undefined, expectedCType: CodeType): JitCode {\n        return this.compile(rt, expectedCType, JitFunctions.stringifyJson.id);\n    }\n    compileToBinary(rt: BaseRunType | undefined, expectedCType: CodeType): JitCode {\n        return this.compile(rt, expectedCType, JitFunctions.toBinary.id);\n    }\n    compileFromBinary(rt: BaseRunType | undefined, expectedCType: CodeType): JitCode {\n        return this.compile(rt, expectedCType, JitFunctions.fromBinary.id);\n    }\n    compileUnknownKeyErrors(rt: BaseRunType | undefined, expectedCType: CodeType): JitCode {\n        return this.compile(rt, expectedCType, JitFunctions.unknownKeyErrors.id);\n    }\n    compileHasUnknownKeys(rt: BaseRunType | undefined, expectedCType: CodeType): JitCode {\n        return this.compile(rt, expectedCType, JitFunctions.hasUnknownKeys.id);\n    }\n    compileStripUnknownKeys(rt: BaseRunType | undefined, expectedCType: CodeType): JitCode {\n        return this.compile(rt, expectedCType, JitFunctions.stripUnknownKeys.id);\n    }\n    compileUnknownKeysToUndefined(rt: BaseRunType | undefined, expectedCType: CodeType): JitCode {\n        return this.compile(rt, expectedCType, JitFunctions.unknownKeysToUndefined.id);\n    }\n\n    // ################### Pure Functions Operations ###################\n\n    addPureFunction(compiledPureFn: CompiledPureFunction): string {\n        const {namespace, fnName} = compiledPureFn;\n        const varName = quickHash(fnName, 8);\n        if (this.hasContextItem(varName)) return varName;\n        this.addPureFnDependency(compiledPureFn);\n        // Add context code for the pure function and params\n        const pureFunctionCode = `const ${varName} = utl.getPureFn(${toLiteral(namespace)}, ${toLiteral(fnName)})`;\n        this.setContextItem(varName, pureFunctionCode);\n        return varName;\n    }\n\n    addPureFnDependency(compiledPureFn: CompiledPureFunction): void {\n        const {namespace, fnName} = compiledPureFn;\n        if (!getJitUtils().hasPureFn(namespace, fnName))\n            throw new Error(\n                `Pure function with name ${fnName} can not be added as jit dependency in namespace ${namespace}, be sure to register the pure function first by calling getJitUtils().addPureFn()`\n            );\n        // Store as \"namespace::fnName\" format (using :: to avoid conflicts with : in names)\n        const key = `${namespace}::${fnName}`;\n        if (this.pureFnDependencies?.includes(key)) return;\n        if (!this.pureFnDependencies) (this as Mutable<this>).pureFnDependencies = [];\n        this.pureFnDependencies!.push(key);\n    }\n}\n\n// ################### Compile Operations ###################\n\nexport class JitFnCompiler<ID extends JitFnID = any> extends BaseFnCompiler<JitFnArgs, ID> {\n    constructor(\n        rt: BaseRunType,\n        fnID: ID,\n        parentCompiler?: BaseFnCompiler,\n        jitFnHash?: string,\n        typeID?: StrNumber,\n        opts: RunTypeOptions = {}\n    ) {\n        const fnSettings = getJitFnSettings(fnID);\n        super(rt, fnID, fnSettings, parentCompiler, jitFnHash, typeID, opts);\n    }\n}\n\nexport class JitErrorsFnCompiler<ID extends JitFnID = any> extends BaseFnCompiler<typeof jitErrorArgs, ID> {\n    constructor(\n        rt: BaseRunType,\n        fnID: ID,\n        parentCompiler?: BaseFnCompiler,\n        jitFnHash?: string,\n        typeID?: StrNumber,\n        opts: RunTypeOptions = {}\n    ) {\n        const fnSettings = getJitFnSettings(fnID);\n        super(rt, fnID, fnSettings, parentCompiler, jitFnHash, typeID, opts);\n    }\n    callJitErr(expected: AnyKindName | BaseRunType<any>): string {\n        // TODO: most of the time jit path is an empty array, so a new array is created every time\n        // this can be optimized by adding it to the compiler context, or maybe make the param optional in jitUtils.err\n        return this.callJitErrWithPath(expected);\n    }\n    /**\n     * This is used when we add an extra item to the path,\n     * for extra info, ie union items, maps keys, etc...\n     * This is because we don't want the item int the real path as it is not part of the runtime path of an object.\n     * but we still want to add that info to process the error.\n     * ie: type  AorBList = ({a: string} | {b: string})[];\n     * we want the error to contain the info if it is union item a or b, but the path to the the doesn't have that info is just list[index]\n     * */\n    callJitErrWithPath(exp: AnyKindName | BaseRunType<any>, extraPathLiteral?: StrNumber): string {\n        const args = this._getJitErrorArgs(exp);\n        const accessPath = this.getAccessPathLiteral(extraPathLiteral);\n        if (accessPath) args.push(accessPath);\n        const errFn = this.addPureFunction(cpf_newRunTypeErr);\n        return `${errFn}(${args.join(',')})`;\n    }\n    callJitFormatErr(\n        expected: AnyKindName | BaseRunType<any>,\n        formatter: BaseRunTypeFormat<any>,\n        paramName: string,\n        paramValue: string | number | boolean | bigint,\n        extraPathLiteral?: StrNumber\n    ): string {\n        // jitUtil.formatErr function arguments =>\n\n        // pλth: StrNumber[],\n        // εrr: RunTypeError[],\n        // expected: string,\n\n        // fmtName: string,\n        // paramName: string,\n        // paramVal: StrNumber,\n        // fmtPath: StrNumber[],\n        // accessPath?: StrNumber[],\n        // fmtAccessPath?: StrNumber[]\n\n        const typeErrArgs = this._getJitErrorArgs(expected);\n        const fmtName = toLiteralInContext(this, formatter.getFormatName());\n        const pName = toLiteralInContext(this, paramName);\n        const pVal = toLiteralInContext(this, paramValue);\n        const fmtPath = toLiteralInContext(this, formatter.getFormatPath());\n        const formatArgs = [fmtName, pName, pVal, fmtPath];\n        const optionalArgs: string[] = [];\n        const accessPath = this.getAccessPathLiteral(extraPathLiteral);\n        const formatAccessPath = this.getFormatAccessPathLiteral(formatter);\n        if (!accessPath && formatAccessPath) optionalArgs.push('undefined');\n        if (accessPath) optionalArgs.push(accessPath);\n        if (formatAccessPath) optionalArgs.push(formatAccessPath);\n        const formatErrFn = this.addPureFunction(cpf_formatErr);\n        return `${formatErrFn}(${[...typeErrArgs, ...formatArgs, ...optionalArgs].join(',')})`;\n    }\n\n    private _getJitErrorArgs(exp: AnyKindName | BaseRunType<any>): string[] {\n        // jitUtil.err function arguments =>\n        // pλth: StrNumber[],\n        // εrr: RunTypeError[],\n        // expected: string,\n        const path = this.args.pλth;\n        const err = this.args.εrr;\n        const expected = typeof exp === 'string' ? toLiteral(exp) : toLiteral(exp.getKindName());\n        return [path, err, expected];\n    }\n\n    getAccessPathLiteral(extraPathLiteral?: StrNumber): string {\n        const accessPath = this.getAccessPath();\n        if (extraPathLiteral) accessPath.push(extraPathLiteral);\n        return accessPath.length ? `[${accessPath.join(',')}]` : '';\n    }\n\n    getFormatAccessPathLiteral(formatter: BaseRunTypeFormat<any>): string {\n        const formatExtraPathLiteral = formatter.getFormatExtraPathLiteral();\n        return formatExtraPathLiteral ? `[${formatExtraPathLiteral}]` : '';\n    }\n}\n\n/**\n * This is an special compiler for mock Function as mock is not technically a jit compiled function\n * but still needs to be created to reuse all jit functionality.\n */\nexport class MockJitCompiler extends BaseFnCompiler<JitFnArgs, 'mock'> {\n    constructor(rt: BaseRunType, opts: RunTypeOptions, parentCompiler?: BaseFnCompiler, jitFnHash?: string, typeID?: StrNumber) {\n        super(rt, JitFunctions.mock.id, JitFunctions.mock, parentCompiler, jitFnHash, typeID, opts);\n    }\n}\n\n// ################### Compiler Creation ###################\n\nexport function createJitCompiler(\n    rt: BaseRunType,\n    fnID: JitFnID,\n    parent?: BaseFnCompiler,\n    jitFnHash?: string,\n    typeID?: StrNumber,\n    opts: RunTypeOptions = {}\n): BaseFnCompiler {\n    switch (fnID) {\n        case JitFunctions.isType.id:\n        case JitFunctions.prepareForJson.id:\n        case JitFunctions.restoreFromJson.id:\n        case JitFunctions.stringifyJson.id:\n        case JitFunctions.hasUnknownKeys.id:\n        case JitFunctions.stripUnknownKeys.id:\n        case JitFunctions.unknownKeysToUndefined.id:\n        case JitFunctions.format.id:\n        case JitFunctions.toJSCode.id:\n        case JitFunctions.toBinary.id:\n        case JitFunctions.fromBinary.id:\n            return new JitFnCompiler(rt, fnID, parent, jitFnHash, typeID, opts);\n        case JitFunctions.typeErrors.id:\n        case JitFunctions.unknownKeyErrors.id:\n            return new JitErrorsFnCompiler(rt, fnID, parent, jitFnHash, typeID, opts);\n        case JitFunctions.mock.id:\n            return new MockJitCompiler(rt, opts, parent, jitFnHash, typeID);\n        default:\n            throw new Error(`Unknown compile operation: ${fnID}`);\n    }\n}\n\nexport function printClosure(fnWithContext: string, functionName: string): string {\n    return `function get_${functionName}(utl){${fnWithContext}}`;\n}\n\n// ################### utils ###################\n\nfunction getStackVλl(comp: BaseFnCompiler): string {\n    let vλl: string = comp.args.vλl;\n    for (let i = 0; i < comp.stack.length; i++) {\n        const rt = comp.stack[i].rt;\n        const custom = rt.getCustomVλl(comp);\n        if (custom && custom.isStandalone) {\n            vλl = custom.vλl;\n        } else if (custom) {\n            vλl += custom.useArrayAccessor ? `[${custom.vλl}]` : `.${custom.vλl}`;\n        } else if (isChildAccessorType(rt) && !rt.skipSettingAccessor?.()) {\n            vλl += rt.useArrayAccessor() ? `[${rt.getChildLiteral(comp)}]` : `.${rt.getChildVarName(comp)}`;\n        }\n    }\n    return vλl;\n}\nfunction getAccessPath(comp: BaseFnCompiler): StrNumber[] {\n    const path: StrNumber[] = [];\n    const rtName: any = [];\n    for (let i = 0; i < comp.stack.length; i++) {\n        const rt = comp.stack[i].rt;\n        const pathItem = rt.getStaticPathLiteral(comp);\n        if (pathItem) {\n            path.push(pathItem);\n        } else if (isChildAccessorType(rt) && !rt.skipSettingAccessor?.()) {\n            path.push(rt.getChildLiteral(comp));\n        }\n        rtName.push({path: [...path], name: rt.constructor.name});\n    }\n    return path;\n}\n\nfunction validateCompilerOptions(opts: RunTypeOptions): void {\n    if (opts.paramsSlice) {\n        const start = opts.paramsSlice?.start;\n        const end = opts.paramsSlice?.end;\n        if (start && start < 0) {\n            throw new Error(`paramsSlice.start must be greater than 0`);\n        }\n        if (end && end < 0) {\n            throw new Error(`paramsSlice.end must be greater than 0`);\n        }\n        if (end && start && end <= start) {\n            throw new Error(`paramsSlice.end must be greater than paramsSlice.start`);\n        }\n    }\n}\n"],"names":["CodeTypes","getJITFnHash","getJitUtils","MAX_STACK_DEPTH","maxStackErrorMessage","isJitErrorsCompiler","createJitFunction","getJITFnName","isChildAccessorType","JIT_STACK_TRACE_MESSAGE","JitFunctions","emitJsonStringify","emitToBinary","emitFromBinary","emitToCode","getRunTypeFormat","getJitFnSettings","getJitFnArgCallVarName","toLiteral","jitErrorArgs","isFunctionParamsRunType","addFullStop","getReflectionName","quickHash","cpf_newRunTypeErr","toLiteralInContext","cpf_formatErr"],"mappings":";;;;;;;;;;;;;;;;AA4BA,MAAM,KAAKA,wBAAAA,UAAU;AACrB,MAAM,IAAIA,wBAAAA,UAAU;AACpB,MAAM,IAAIA,wBAAAA,UAAU;AAkBb,MAAM,eAEb;AAAA,EAOI,YACoB,UAEA,MAChB,eACgB,gBAChB,WACA,QACgB,OAAuB,IACzC;AARkB,SAAA,WAAA;AAEA,SAAA,OAAA;AAEA,SAAA,iBAAA;AAGA,SAAA,OAAA;AAEhB,SAAK,WAAW,KAAK,SAAS,YAAA;AAC9B,SAAK,YAAY,aAAaC,0BAAAA,aAAa,KAAK,MAAM,KAAK,UAAU,IAAI;AACzE,SAAK,SAAS,UAAU,KAAK,SAAS,UAAA;AACtC,SAAK,OAAO,EAAC,GAAG,cAAc,QAAA;AAC9B,SAAK,qBAAqB,EAAC,GAAG,cAAc,eAAA;AAC5C,SAAK,aAAa,cAAc;AAChC,QAAI,KAAK,KAAK,IAAK,MAAK,MAAM,KAAK,KAAK;AAGxCC,qBAAA,EAAc,cAAc,IAAqB;AACjD,4BAAwB,IAAI;AAAA,EAChC;AAAA;AAAA;AAAA,EAzBS;AAAA,EACA;AAAA,EACD,aAAa;AAAA,EAwBZ;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EAGA,mBAAiE,CAAA;AAAA;AAAA,EAGjE,OAAe;AAAA;AAAA;AAAA;AAAA;AAAA,EAKf,uCAAuB,IAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAKvB,SAAmB;AAAA;AAAA,EAEnB;AAAA,EACA;AAAA;AAAA,EAEA,QAAqB,CAAA;AAAA,EAC9B;AAAA;AAAA,EAEA,IAAI,SAAS;AACT,WAAO,KAAK,MAAM;AAAA,EACtB;AAAA,EACA,IAAI,cAAc;AACd,QAAI,KAAK,eAAgB,QAAO,KAAK,MAAM,SAAS,KAAK,eAAe;AACxE,WAAO,KAAK,MAAM;AAAA,EACtB;AAAA;AAAA,EAEA,MAAc;AAAA,EACd,aAAa,IAA8B;AACvC,QAAI,QAAQ;AACZ,SAAK,MAAM,QAAQ,CAAC,MAAM,MAAM;AAC5B,UAAI,KAAK,OAAO,GAAI,SAAQ;AAC5B,UAAI,KAAK,GAAG,IAAI,MAAM,KAAK,GAAG,IAAI,OAAO,GAAG,IAAI,GAAI,SAAQ;AAAA,IAChE,CAAC;AACD,QAAI,UAAU,GAAI,QAAO;AACzB,UAAM,aAAa,KAAK,gBAAgB,aAAa,EAAE;AACvD,QAAI,cAAc,eAAe,GAAI,QAAO;AAC5C,WAAO;AAAA,EACX;AAAA,EACQ,mCAA2D,IAAA;AAAA,EACnE,gBAAgB,QAAgB,IAA8B;AAC1D,UAAM,MAAM,GAAG,IAAI,MAAM;AACzB,UAAM,QAAQ,KAAK,aAAa,IAAI,GAAG;AACvC,QAAI,UAAU,OAAW,QAAO,GAAG,MAAM,GAAG,KAAK;AACjD,UAAM,WAAW,KAAK,aAAa;AACnC,SAAK,aAAa,IAAI,KAAK,QAAQ;AACnC,WAAO,GAAG,MAAM,GAAG,QAAQ;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASQ,sBAAmC,CAAA;AAAA;AAAA,EAE3C,UAAU,UAA6B;AACnC,UAAM,cAAc,KAAK,MAAM,SAAS,KAAK;AAC7C,QAAI,cAAcC,KAAAA,gBAAiB,OAAM,IAAI,MAAMC,cAAAA,oBAAoB;AACvE,QAAI,KAAK,MAAM,WAAW,GAAG;AACzB,UAAI,aAAa,KAAK,SAAU,OAAM,IAAI,MAAM,gDAAgD;AAChG,eAAS,UAAA;AAAA,IACb;AACA,SAAK,MAAM,YAAY,IAAI;AAE3B,QAAIC,eAAAA,oBAAoB,IAAI,EAAG,MAAK,sBAAsB,cAAc,IAAI;AAC5E,UAAM,eAA0B,EAAC,KAAK,KAAK,KAAK,IAAI,UAAU,YAAY,KAAK,oBAAA;AAC/E,SAAK,MAAM,KAAK,YAAY;AAAA,EAChC;AAAA,EACA,SAAS,YAAuD;AAC5D,QAAI,YAAY,KAAO,MAAiC,OAAO,WAAW;AAC1E,SAAK,UAAU,KAAK,MAAM,IAAA;AAC1B,UAAM,OAAO,KAAK,MAAM,KAAK,MAAM,SAAS,CAAC;AAC7C,SAAK,MAAM,MAAM,OAAO,KAAK,KAAK;AAClC,QAAIA,eAAAA,oBAAoB,IAAI,QAAQ,sBAAsB,MAAM,cAAc,CAAA;AAAA,EAClF;AAAA,EACA,eAAe,UAA6B;AACxC,UAAM,eAA0B,EAAC,KAAK,KAAK,KAAK,IAAI,UAAU,YAAY,KAAK,oBAAA;AAC/E,SAAK,MAAM,KAAK,YAAY;AAAA,EAChC;AAAA,EACA,iBAAuB;AACnB,SAAK,UAAU,KAAK,MAAM,IAAA;AAAA,EAC9B;AAAA,EACA,kBAAkB,cAAgD;AAC9D,QAAI;AACA,UAAI,cAAc;AACb,aAAiC,OAAO;AACzC,aAAK,aAAa;AAAA,MACtB;AACA,WAAK,qBAAA;AACL,aAAOC,0BAAAA,kBAAkB,IAAI;AAAA,IACjC,SAAS,GAAQ;AACb,YAAM,SAASC,uBAAAA,aAAa,KAAK,IAAI;AACrC,YAAM,SAAS;AAAA,WAAoB,MAAM,MAAM,KAAK,IAAI;AACxD,YAAM,OAAO,IAAI,KAAK,SAAS,aAAa,IAAI,KAAK,SAAS,UAAA,CAAW;AACzE,YAAM,aAAa,SAAS,KAAK,SAAS,WAAW;AACrD,YAAM,IAAI,MAAM,kBAAkB,MAAM,0BAA0B,IAAI,KAAK,GAAG,OAAO;AAAA,EAAM,UAAU;AAAA,EAAM,MAAM,EAAE;AAAA,IACvH;AAAA,EACJ;AAAA;AAAA,EAEA,gBAA6B;AACzB,WAAO,CAAC,GAAG,KAAK,mBAAmB;AAAA,EACvC;AAAA,EAEA,oBAA4B;AACxB,WAAO,KAAK,oBAAoB,KAAK,GAAG;AAAA,EAC5C;AAAA,EACA,sBAA8B;AAC1B,WAAO,KAAK,oBAAoB;AAAA,EACpC;AAAA,EACA,6BAA6D;AACzD,WAAO,EAAC,MAAM,KAAK,kBAAA,GAAqB,QAAQ,KAAK,sBAAoB;AAAA,EAC7E;AAAA,EACA,sBAAiC;AAC7B,UAAM,OAAO,KAAK,MAAM,KAAK,MAAM,SAAS,CAAC;AAC7C,QAAI,CAAC,KAAM,OAAM,IAAI,MAAM,0CAA0C;AACrE,WAAO;AAAA,EACX;AAAA,EACA,cAAsB;AAClB,UAAM,SAAS,KAAK,oBAAA;AACpB,QAAI,CAAC,OAAQ,QAAO,KAAK,KAAK;AAC9B,UAAM,KAAK,OAAO;AAClB,QAAI,CAACC,eAAAA,oBAAoB,EAAE,EAAG,OAAM,IAAI,MAAM,gCAAgC,GAAG,YAAA,CAAa,EAAE;AAChG,QAAI,GAAG,wBAAyB,QAAO,OAAO;AAC9C,WAAO,OAAO,OAAO,GAAG,iBAAA,IAAqB,IAAI,GAAG,gBAAgB,IAAI,CAAC,MAAM,IAAI,GAAG,gBAAgB,IAAI,CAAC;AAAA,EAC/G;AAAA,EACA,uBAAgC;AAC5B,UAAM,YAAY,KAAK,oBAAA;AACvB,WAAO,CAAC,UAAU,GAAG,kBAAkB,KAAK,MAAM,SAAS;AAAA,EAC/D;AAAA,EACA,mBAAmB,WAAoC;AACnD,QAAI,UAAU,OAAQ;AACtB,QAAI,KAAK,iBAAiB,SAAS,UAAU,SAAS,EAAG;AACzD,QAAI,CAAC,KAAK,gBAAkB,MAAuB,kBAAkB,CAAA;AACrE,SAAK,gBAAiB,KAAK,UAAU,SAAS;AAAA,EAClD;AAAA,EACA,qBAA2B;AACvBN,qBAAA,EAAc,mBAAmB,IAAqB;AAAA,EAC1D;AAAA,EACA,gBAAwB;AACpB,UAAM,YAAY;AAClB,UAAM,cAAc,KAAK,iBAAiB,KAAK,eAAe,cAAA,IAAkB,YAAYO,cAAAA;AAC5F,UAAM,iBAAiB,KAAK,gBAAgB,oBAAA;AAC5C,UAAM,gBAAgB,iBAAiB,KAAK,MAAM,OAAO,CAAC,SAAS,KAAK,OAAO,gBAAgB,EAAE,IAAI,KAAK;AAC1G,WAAO,cAAc,cAAc,IAAI,CAAC,SAAS,KAAK,iBAAiB,KAAK,EAAE,CAAC,EAAE,KAAK,SAAS;AAAA,EACnG;AAAA,EACA,cAAc,cAAsB;AAChC,WAAO,aAAa,SAASA,qCAAuB;AAAA,EACxD;AAAA;AAAA,EAGA,eAAe,KAAa,OAAqB;AAC7C,SAAK,iBAAiB,IAAI,KAAK,KAAK;AAAA,EACxC;AAAA;AAAA,EAGA,eAAe,KAAiC;AAC5C,WAAO,KAAK,iBAAiB,IAAI,GAAG;AAAA,EACxC;AAAA;AAAA,EAGA,eAAe,KAAsB;AACjC,WAAO,KAAK,iBAAiB,IAAI,GAAG;AAAA,EACxC;AAAA;AAAA,EAGA,uBAAiC;AAC7B,WAAO,MAAM,KAAK,KAAK,iBAAiB,QAAQ;AAAA,EACpD;AAAA,EAEA,oBAAoB,MAAc,MAAgC;AAC9D,SAAK,iBAAiB,IAAI,IAAI;AAAA,EAClC;AAAA,EAEA,oBAAoB,MAA8C;AAC9D,WAAO,KAAK,iBAAiB,IAAI;AAAA,EACrC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,QAAQ,IAA6B,eAAyB,MAAwB;AAClF,QAAI,CAAC,GAAI,QAAO,EAAC,MAAM,QAAW,MAAM,cAAA;AACxC,QAAI;AACJ,SAAK,UAAU,EAAE;AACjB,QAAI,KAAK,wBAAwB;AAC7B,YAAM,aAAa,GAAG,0BAA0B,MAAM,MAAM,KAAK,IAAI;AACrE,cAAQ,KAAK,eAAe,IAAI,UAAU;AAC1C,WAAK,mBAAmB,UAAU;AAAA,IACtC,OAAO;AAEH,cAAQ,MAAA;AAAA,QACA,KAAKC,wBAAAA,aAAa,OAAO;AACrB,kBAAQ,KAAK,iBAAiB,IAAI,MAAM,GAAG,WAAW,MAAM,aAAa,GAAG,eAAe,IAAI;AAAG;AAAA,QACtG,KAAKA,wBAAAA,aAAa,WAAW;AACzB,kBAAQ,KAAK,iBAAiB,IAAI,MAAM,GAAG,eAAe,MAAa,aAAa,GAAG,eAAe,GAAG;AAAG;AAAA,QAChH,KAAKA,wBAAAA,aAAa,eAAe;AAC7B,kBAAQ,KAAK,iBAAiB,IAAI,MAAK,GAAG,mBAAmB,MAAM,aAAa,GAAG,eAAe,GAAG;AAAG;AAAA,QAC5G,KAAKA,wBAAAA,aAAa,gBAAgB;AAC9B,kBAAQ,KAAK,iBAAiB,IAAI,MAAK,GAAG,oBAAoB,MAAM,aAAa,GAAG,eAAe,GAAG;AAAG;AAAA,QAC7G,KAAKA,wBAAAA,aAAa,cAAc;AAC5B,kBAAQ,KAAK,iBAAiB,IAAI,MAAKC,sDAAkB,IAAI,IAAI,GAAG,eAAe,GAAG;AAAG;AAAA,QAC7F,KAAKD,wBAAAA,aAAa,SAAS;AACvB,kBAAQ,KAAK,iBAAiB,IAAI,MAAKE,8CAAa,IAAI,IAAW,GAAG,eAAe,GAAG;AAAG;AAAA,QAC/F,KAAKF,wBAAAA,aAAa,WAAW;AACzB,kBAAQ,KAAK,iBAAiB,IAAI,MAAKG,kDAAe,IAAI,IAAW,GAAG,eAAe,GAAG;AAAG;AAAA,QACjG,KAAKH,wBAAAA,aAAa,SAAS;AACvB,kBAAO,KAAK,iBAAiB,IAAI,MAAMI,0CAAW,IAAI,IAAI,GAAG,eAAe,GAAG;AAAG;AAAA,QACtF,KAAKJ,wBAAAA,aAAa,iBAAiB;AAC/B,kBAAQ,GAAG,qBAAqB,MAAa,aAAa;AAAG;AAAA,QACjE,KAAKA,wBAAAA,aAAa,eAAe;AAC7B,kBAAQ,GAAG,mBAAmB,MAAM,aAAa;AAAG;AAAA,QACxD,KAAKA,wBAAAA,aAAa,iBAAiB;AAC/B,kBAAQ,GAAG,qBAAqB,MAAM,aAAa;AAAG;AAAA,QAC1D,KAAKA,wBAAAA,aAAa,uBAAuB;AACrC,kBAAQ,GAAG,2BAA2B,MAAM,aAAa;AAAG;AAAA,QAChE,KAAKA,wBAAAA,aAAa,OAAO;AACrB,kBAAQ,EAAC,MAAM,QAAW,MAAM,EAAA;AAAI;AAAA,QACxC;AACI,gBAAM,IAAI,MAAM,8BAA8B,IAAI,EAAE;AAAA,MAAA;AAEhE,UAAI,OAAO,MAAM;AAGb,cAAM,iBAAiB,KAAK,wBAAwB,IAAI,OAAO,aAAa;AAC5E,gBAAQ,EAAC,MAAM,gBAAgB,MAAM,MAAM,KAAA;AAAA,MAC/C;AAAA,IACJ;AACA,SAAK,SAAS,KAAK;AACnB,WAAO;AAAA,EACX;AAAA,EAEQ,iBACJ,IACA,MACA,YACA,eACA,WACO;AACP,UAAM,aAAa,WAAW,OAAO,WAAW,OAAO;AACvD,UAAM,gBAAgBK,gBAAAA,iBAAiB,EAAE;AACzC,QAAI,CAAC,cAAe,QAAO;AAC3B,QAAI,UAA+B;AACnC,UAAM,gBAAgB,cAAc,cAAc,MAAM,MAAM,EAAE;AAEhE,UAAM,WAAW,cAAc,sBAAsB,MAAM,EAAE;AAC7D,UAAM,gBAAgB,cAAc,SAAS;AAI7C,UAAM,eAAe,cAAc,SAAS;AAC5C,QAAI,YAAY,gBAAgB,CAAC,eAAe;AAC5C,gBAAU;AAAA,IACd,OAAO;AAEH,YAAM,WAAW,cAAc,2BAA2B,MAAM,IAAI,MAAM,QAAW,QAAW,QAAW,KAAK,IAAI;AACpH,UAAI,CAAC,SAAS,QAAQ;AAClB,aAAK,mBAAmB,QAAQ;AAChC,kBAAU,KAAK,eAAe,IAAI,QAAQ;AAAA,MAC9C;AAAA,IACJ;AACA,QAAI,CAAC,SAAS,KAAM,QAAO;AAC3B,UAAM,gBAAgBC,uBAAAA,iBAAiB,IAAI,EAAE;AAC7C,UAAM,SAAS,cAAc,OAAO,SAAS;AAC7C,QAAI,eAAe;AACf,aAAO;AAAA,IACX;AACA,UAAM,YAAY,YAAY,OAAO,WAAW,OAAO,SAAS,QAAQ,OAAO,QAAQ;AACvF,WAAO,EAAC,MAAM,WAAW,MAAM,WAAA;AAAA,EACnC;AAAA,EAEQ,eAAe,IAAiB,gBAAwC;AAC5E,QAAI,eAAe,OAAQ,QAAO,EAAC,MAAM,IAAI,MAAM,EAAA;AACnD,UAAM,cACF,eAAe,SAASN,qCAAa,WAAW,MAAM,eAAe,SAASA,wBAAAA,aAAa,iBAAiB;AAGhH,UAAM,UAAUM,uBAAAA,iBAAiB,eAAe,IAAe,EAAE;AACjE,UAAM,eAAe,OAAO,KAAK,OAAO,EACnC,IAAI,CAAC,QAAQC,cAAAA,uBAAuB,MAAM,IAAI,eAAe,MAAiB,GAAG,CAAC,EAClF,KAAK,GAAG;AACb,UAAM,SAAS,KAAK,cAAc,eAAe;AACjD,UAAM,UAAU,eAAe;AAM/B,UAAM,WAAW,SAAS,GAAG,OAAO,IAAI,YAAY,MAAM,GAAG,OAAO,OAAO,YAAY;AACvF,QAAI,CAAC,OAAQ,MAAK,eAAe,SAAS,SAAS,OAAO,iBAAiBC,cAAAA,UAAU,OAAO,CAAC,GAAG;AAChG,QAAI,aAAa;AACb,YAAM,WAAW,KAAK,kBAAA;AACtB,YAAM,aAAa,KAAK,oBAAA;AACxB,UAAI,CAAC,WAAY,QAAO,EAAC,MAAM,UAAU,MAAM,IAAA;AAG/C,aAAO;AAAA,QACH,MAAM,GAAGC,wBAAAA,aAAa,IAAI,SAAS,QAAQ,MAAM,QAAQ,KAAKA,wBAAAA,aAAa,IAAI,YAAY,UAAU;AAAA,QACrG,MAAM;AAAA,MAAA;AAAA,IAEd;AACA,WAAO,EAAC,MAAM,UAAU,MAAM,IAAA;AAAA,EAClC;AAAA;AAAA,EAGQ,wBAAiC;AACrC,QAAI,CAACC,eAAAA,wBAAwB,KAAK,QAAQ,EAAG,QAAO;AACpD,WAAO,KAAK,SAAS,iBAAA,EAAmB,WAAW;AAAA,EACvD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOQ,uBAA6B;AACjC,QAAI,KAAK,WAAY;AACrB,QAAI,SAAS;AAEb,QAAI,OAAO,KAAK,KAAK,QAAQ,WAAW,GAAG,EAAE,QAAQ,OAAO,GAAG;AAE/D,UAAM,gBAAgB,KAAK,sBAAA;AAC3B,YAAQ,KAAK,MAAA;AAAA,MACT,KAAKV,wBAAAA,aAAa,OAAO;AACrB,iBAAS,iBAAiB,CAAC,KAAK,QAAQ,KAAK,SAAS,UAAU,KAAK,SAAS;AAC9E,YAAI,OAAQ,QAAO;AACnB;AAAA,MACJ,KAAKA,wBAAAA,aAAa,eAAe;AAC7B,iBAAS,CAAC,KAAK,QAAQ,KAAK,SAAS,WAAW,KAAK,SAAS;AAC9D,YAAI,OAAQ,QAAO;AACnB;AAAA,MACJ,KAAKA,wBAAAA,aAAa,eAAe;AAAA,MACjC,KAAKA,wBAAAA,aAAa,gBAAgB;AAAA,MAClC,KAAKA,wBAAAA,aAAa,iBAAiB;AAAA,MACnC,KAAKA,wBAAAA,aAAa,uBAAuB;AACrC,iBAAS,iBAAiB,CAAC,KAAK,QAAQ,KAAK,SAAS,KAAK,KAAK,OAAO,KAAK,SAAS,UAAU,KAAK,KAAK,GAAG;AAC5G,YAAI,OAAQ,QAAO,UAAU,KAAK,KAAK,GAAG;AAC1C;AAAA,MACJ,KAAKA,wBAAAA,aAAa,WAAW;AAAA,MAC7B,KAAKA,wBAAAA,aAAa,iBAAiB;AAC/B,iBAAS,iBAAiB,CAAC,KAAK,QAAQ,KAAK,SAAS,KAAK,KAAK,OAAO,KAAK,SAAS,UAAU,KAAK,KAAK,GAAG;AAC5G,YAAI,OAAQ,QAAO,UAAU,KAAK,KAAK,GAAG;AAC1C;AAAA,MACJ,KAAKA,wBAAAA,aAAa,OAAO;AACrB,iBAAS,CAAC,KAAK,QAAQ,KAAK,SAAS,KAAK,KAAK,OAAO,KAAK,SAAS,UAAU,KAAK,KAAK,GAAG;AAC3F,YAAI,OAAQ,QAAO,UAAU,KAAK,KAAK,GAAG;AAC1C;AAAA,IAAA;AAEP,SAAiC,SAAS;AAC1C,SAAiC,OAAO;AACzC,SAAK,aAAa;AAAA,EACtB;AAAA;AAAA,EAGQ,wBAAwB,IAAiB,YAAqB,gBAAkC;AACpG,UAAM,OAAO,WAAW,QAAQ;AAChC,UAAM,gBAAgB,WAAW;AACjC,UAAM,SAAS,KAAK,WAAW;AAE/B,QAAI,QAAQ;AAER,cAAQ,eAAA;AAAA,QACJ,KAAK;AAAG,iBAAO,UAAU,IAAI;AAAA,QAC7B,KAAK;AAAG,iBAAQ,GAAGW,cAAAA,YAAY,IAAI,CAAC,WAAW,KAAK,UAAU;AAAA,QAC9D,KAAK;AAAI,iBAAO;AAAA,MAAA;AAAA,IAExB;AACA,YAAQ,MAAA;AAAA,MACJ,MAAK,mBAAmB,KAAK,kBAAkB;AAC3C,eAAO;AAAA,MACX,MAAK,mBAAmB,KAAK,kBAAkB;AAC3C,eAAO,KAAK,yBAAyB,UAAU;AAAA,MACnD,MAAK,mBAAmB,KAAK,kBAAkB;AAC3C,eAAO,KAAK,yBAAyB,UAAU;AAAA,MACnD,MAAK,mBAAmB,KAAK,kBAAkB;AAC3C,eAAO;AAAA;AAAA,MACX,MAAK,mBAAmB,KAAK,kBAAkB;AAC3C,eAAOA,cAAAA,YAAY,IAAI;AAAA,MAC3B,MAAK,mBAAmB,KAAK,kBAAkB;AAC3C,eAAO,KAAK,yBAAyB,UAAU;AAAA,MACnD,MAAK,mBAAmB,MAAM,kBAAkB;AAC5C,cAAM,IAAI,MAAM,8FAA8F;AAAA,MAClH,MAAK,mBAAmB,MAAM,kBAAkB;AAC5C,eAAOA,cAAAA,YAAY,IAAI;AAAA,MAC3B,MAAK,mBAAmB,MAAM,kBAAkB;AAC5C,eAAO,GAAGA,cAAAA,YAAY,IAAI,CAAC,WAAW,KAAK,UAAU;AAAA,MACzD;AACI,cAAM,IAAI,MAAM,mCAAmC,cAAc,UAAU,aAAa,GAAG;AAAA,IAAA;AAAA,EAEvG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASQ,yBAAyB,OAAwB;AACrD,QAAI,MAAM,SAAS,EAAG,OAAM,IAAI,MAAM,8EAA8E;AACpH,QAAI,CAAC,MAAM,KAAM,QAAO;AACxB,UAAM,OAAO,MAAM,KAAK,KAAA;AACxB,UAAM,iBAAiB,KAAK,WAAW,aAAa,KAAK,KAAK,SAAS,KAAK;AAC5E,QAAI,eAAgB,QAAO;AAC3B,UAAM,YAAY,MAAM,SAAS;AACjC,UAAM,aAAa,YAAY,YAAY;AAC3C,WAAO,eAAe,UAAU,GAAG,MAAM,IAAI;AAAA,EACjD;AAAA,EAEA,iBAAiB,IAAyB;AACtC,QAAI,GAAG,gBAAgB,YAAY,GAAG,IAAI,YAAYC,mBAAAA,kBAAkB,EAAE;AAC1E,QAAI,GAAG,gBAAgB,IAAK,QAAO,OAAQ,GAAG,IAAqB,IAAI,KAAKA,mBAAAA,kBAAkB,EAAE;AAChG,QAAI,GAAG,UAAA,MAAgB,KAAK;AACxB,YAAM,UAAU;AAChB,YAAM,yBAAyB,CAAC,CAAC,QAAQ;AACzC,UAAI,CAAC,uBAAwB,QAAOA,mBAAAA,kBAAkB,EAAE;AACxD,aAAO,OAAO,QAAQ,gBAAgB,IAAI,CAAC;AAAA,IAC/C;AACA,WAAOA,mBAAAA,kBAAkB,EAAE;AAAA,EAC/B;AAAA;AAAA,EAIA,cAAc,IAA6B,eAAkC;AACzE,WAAO,KAAK,QAAQ,IAAI,eAAeZ,wBAAAA,aAAa,OAAO,EAAE;AAAA,EACjE;AAAA,EACA,kBAAkB,IAA6B,eAAkC;AAC7E,WAAO,KAAK,QAAQ,IAAI,eAAeA,wBAAAA,aAAa,WAAW,EAAE;AAAA,EACrE;AAAA,EACA,sBAAsB,IAA6B,eAAkC;AACjF,WAAO,KAAK,QAAQ,IAAI,eAAeA,wBAAAA,aAAa,eAAe,EAAE;AAAA,EACzE;AAAA,EACA,uBAAuB,IAA6B,eAAkC;AAClF,WAAO,KAAK,QAAQ,IAAI,eAAeA,wBAAAA,aAAa,gBAAgB,EAAE;AAAA,EAC1E;AAAA,EACA,qBAAqB,IAA6B,eAAkC;AAChF,WAAO,KAAK,QAAQ,IAAI,eAAeA,wBAAAA,aAAa,cAAc,EAAE;AAAA,EACxE;AAAA,EACA,gBAAgB,IAA6B,eAAkC;AAC3E,WAAO,KAAK,QAAQ,IAAI,eAAeA,wBAAAA,aAAa,SAAS,EAAE;AAAA,EACnE;AAAA,EACA,kBAAkB,IAA6B,eAAkC;AAC7E,WAAO,KAAK,QAAQ,IAAI,eAAeA,wBAAAA,aAAa,WAAW,EAAE;AAAA,EACrE;AAAA,EACA,wBAAwB,IAA6B,eAAkC;AACnF,WAAO,KAAK,QAAQ,IAAI,eAAeA,wBAAAA,aAAa,iBAAiB,EAAE;AAAA,EAC3E;AAAA,EACA,sBAAsB,IAA6B,eAAkC;AACjF,WAAO,KAAK,QAAQ,IAAI,eAAeA,wBAAAA,aAAa,eAAe,EAAE;AAAA,EACzE;AAAA,EACA,wBAAwB,IAA6B,eAAkC;AACnF,WAAO,KAAK,QAAQ,IAAI,eAAeA,wBAAAA,aAAa,iBAAiB,EAAE;AAAA,EAC3E;AAAA,EACA,8BAA8B,IAA6B,eAAkC;AACzF,WAAO,KAAK,QAAQ,IAAI,eAAeA,wBAAAA,aAAa,uBAAuB,EAAE;AAAA,EACjF;AAAA;AAAA,EAIA,gBAAgB,gBAA8C;AAC1D,UAAM,EAAC,WAAW,OAAA,IAAU;AAC5B,UAAM,UAAUa,KAAAA,UAAU,QAAQ,CAAC;AACnC,QAAI,KAAK,eAAe,OAAO,EAAG,QAAO;AACzC,SAAK,oBAAoB,cAAc;AAEvC,UAAM,mBAAmB,SAAS,OAAO,oBAAoBL,cAAAA,UAAU,SAAS,CAAC,KAAKA,cAAAA,UAAU,MAAM,CAAC;AACvG,SAAK,eAAe,SAAS,gBAAgB;AAC7C,WAAO;AAAA,EACX;AAAA,EAEA,oBAAoB,gBAA4C;AAC5D,UAAM,EAAC,WAAW,OAAA,IAAU;AAC5B,QAAI,CAAChB,KAAAA,YAAA,EAAc,UAAU,WAAW,MAAM;AAC1C,YAAM,IAAI;AAAA,QACN,2BAA2B,MAAM,oDAAoD,SAAS;AAAA,MAAA;AAGtG,UAAM,MAAM,GAAG,SAAS,KAAK,MAAM;AACnC,QAAI,KAAK,oBAAoB,SAAS,GAAG,EAAG;AAC5C,QAAI,CAAC,KAAK,mBAAqB,MAAuB,qBAAqB,CAAA;AAC3E,SAAK,mBAAoB,KAAK,GAAG;AAAA,EACrC;AACJ;AAIO,MAAM,sBAAgD,eAA8B;AAAA,EACvF,YACI,IACA,MACA,gBACA,WACA,QACA,OAAuB,IACzB;AACE,UAAM,aAAac,uBAAAA,iBAAiB,IAAI;AACxC,UAAM,IAAI,MAAM,YAAY,gBAAgB,WAAW,QAAQ,IAAI;AAAA,EACvE;AACJ;AAEO,MAAM,4BAAsD,eAAwC;AAAA,EACvG,YACI,IACA,MACA,gBACA,WACA,QACA,OAAuB,IACzB;AACE,UAAM,aAAaA,uBAAAA,iBAAiB,IAAI;AACxC,UAAM,IAAI,MAAM,YAAY,gBAAgB,WAAW,QAAQ,IAAI;AAAA,EACvE;AAAA,EACA,WAAW,UAAkD;AAGzD,WAAO,KAAK,mBAAmB,QAAQ;AAAA,EAC3C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,mBAAmB,KAAqC,kBAAsC;AAC1F,UAAM,OAAO,KAAK,iBAAiB,GAAG;AACtC,UAAM,aAAa,KAAK,qBAAqB,gBAAgB;AAC7D,QAAI,WAAY,MAAK,KAAK,UAAU;AACpC,UAAM,QAAQ,KAAK,gBAAgBQ,qCAAiB;AACpD,WAAO,GAAG,KAAK,IAAI,KAAK,KAAK,GAAG,CAAC;AAAA,EACrC;AAAA,EACA,iBACI,UACA,WACA,WACA,YACA,kBACM;AAcN,UAAM,cAAc,KAAK,iBAAiB,QAAQ;AAClD,UAAM,UAAUC,cAAAA,mBAAmB,MAAM,UAAU,eAAe;AAClE,UAAM,QAAQA,cAAAA,mBAAmB,MAAM,SAAS;AAChD,UAAM,OAAOA,cAAAA,mBAAmB,MAAM,UAAU;AAChD,UAAM,UAAUA,cAAAA,mBAAmB,MAAM,UAAU,eAAe;AAClE,UAAM,aAAa,CAAC,SAAS,OAAO,MAAM,OAAO;AACjD,UAAM,eAAyB,CAAA;AAC/B,UAAM,aAAa,KAAK,qBAAqB,gBAAgB;AAC7D,UAAM,mBAAmB,KAAK,2BAA2B,SAAS;AAClE,QAAI,CAAC,cAAc,iBAAkB,cAAa,KAAK,WAAW;AAClE,QAAI,WAAY,cAAa,KAAK,UAAU;AAC5C,QAAI,iBAAkB,cAAa,KAAK,gBAAgB;AACxD,UAAM,cAAc,KAAK,gBAAgBC,iCAAa;AACtD,WAAO,GAAG,WAAW,IAAI,CAAC,GAAG,aAAa,GAAG,YAAY,GAAG,YAAY,EAAE,KAAK,GAAG,CAAC;AAAA,EACvF;AAAA,EAEQ,iBAAiB,KAA+C;AAKpE,UAAM,OAAO,KAAK,KAAK;AACvB,UAAM,MAAM,KAAK,KAAK;AACtB,UAAM,WAAW,OAAO,QAAQ,WAAWR,cAAAA,UAAU,GAAG,IAAIA,cAAAA,UAAU,IAAI,aAAa;AACvF,WAAO,CAAC,MAAM,KAAK,QAAQ;AAAA,EAC/B;AAAA,EAEA,qBAAqB,kBAAsC;AACvD,UAAM,aAAa,KAAK,cAAA;AACxB,QAAI,iBAAkB,YAAW,KAAK,gBAAgB;AACtD,WAAO,WAAW,SAAS,IAAI,WAAW,KAAK,GAAG,CAAC,MAAM;AAAA,EAC7D;AAAA,EAEA,2BAA2B,WAA2C;AAClE,UAAM,yBAAyB,UAAU,0BAAA;AACzC,WAAO,yBAAyB,IAAI,sBAAsB,MAAM;AAAA,EACpE;AACJ;AAMO,MAAM,wBAAwB,eAAkC;AAAA,EACnE,YAAY,IAAiB,MAAsB,gBAAiC,WAAoB,QAAoB;AACxH,UAAM,IAAIR,qCAAa,KAAK,IAAIA,qCAAa,MAAM,gBAAgB,WAAW,QAAQ,IAAI;AAAA,EAC9F;AACJ;AAIO,SAAS,kBACZ,IACA,MACA,QACA,WACA,QACA,OAAuB,IACT;AACd,UAAQ,MAAA;AAAA,IACJ,KAAKA,wBAAAA,aAAa,OAAO;AAAA,IACzB,KAAKA,wBAAAA,aAAa,eAAe;AAAA,IACjC,KAAKA,wBAAAA,aAAa,gBAAgB;AAAA,IAClC,KAAKA,wBAAAA,aAAa,cAAc;AAAA,IAChC,KAAKA,wBAAAA,aAAa,eAAe;AAAA,IACjC,KAAKA,wBAAAA,aAAa,iBAAiB;AAAA,IACnC,KAAKA,wBAAAA,aAAa,uBAAuB;AAAA,IACzC,KAAKA,wBAAAA,aAAa,OAAO;AAAA,IACzB,KAAKA,wBAAAA,aAAa,SAAS;AAAA,IAC3B,KAAKA,wBAAAA,aAAa,SAAS;AAAA,IAC3B,KAAKA,wBAAAA,aAAa,WAAW;AACzB,aAAO,IAAI,cAAc,IAAI,MAAM,QAAQ,WAAW,QAAQ,IAAI;AAAA,IACtE,KAAKA,wBAAAA,aAAa,WAAW;AAAA,IAC7B,KAAKA,wBAAAA,aAAa,iBAAiB;AAC/B,aAAO,IAAI,oBAAoB,IAAI,MAAM,QAAQ,WAAW,QAAQ,IAAI;AAAA,IAC5E,KAAKA,wBAAAA,aAAa,KAAK;AACnB,aAAO,IAAI,gBAAgB,IAAI,MAAM,QAAQ,WAAW,MAAM;AAAA,IAClE;AACI,YAAM,IAAI,MAAM,8BAA8B,IAAI,EAAE;AAAA,EAAA;AAEhE;AAEO,SAAS,aAAa,eAAuB,cAA8B;AAC9E,SAAO,gBAAgB,YAAY,SAAS,aAAa;AAC7D;AAIA,SAAS,YAAY,MAA8B;AAC/C,MAAI,MAAc,KAAK,KAAK;AAC5B,WAAS,IAAI,GAAG,IAAI,KAAK,MAAM,QAAQ,KAAK;AACxC,UAAM,KAAK,KAAK,MAAM,CAAC,EAAE;AACzB,UAAM,SAAS,GAAG,aAAa,IAAI;AACnC,QAAI,UAAU,OAAO,cAAc;AAC/B,YAAM,OAAO;AAAA,IACjB,WAAW,QAAQ;AACf,aAAO,OAAO,mBAAmB,IAAI,OAAO,GAAG,MAAM,IAAI,OAAO,GAAG;AAAA,IACvE,WAAWF,eAAAA,oBAAoB,EAAE,KAAK,CAAC,GAAG,yBAAyB;AAC/D,aAAO,GAAG,iBAAA,IAAqB,IAAI,GAAG,gBAAgB,IAAI,CAAC,MAAM,IAAI,GAAG,gBAAgB,IAAI,CAAC;AAAA,IACjG;AAAA,EACJ;AACA,SAAO;AACX;AACA,SAAS,cAAc,MAAmC;AACtD,QAAM,OAAoB,CAAA;AAC1B,QAAM,SAAc,CAAA;AACpB,WAAS,IAAI,GAAG,IAAI,KAAK,MAAM,QAAQ,KAAK;AACxC,UAAM,KAAK,KAAK,MAAM,CAAC,EAAE;AACzB,UAAM,WAAW,GAAG,qBAAqB,IAAI;AAC7C,QAAI,UAAU;AACV,WAAK,KAAK,QAAQ;AAAA,IACtB,WAAWA,eAAAA,oBAAoB,EAAE,KAAK,CAAC,GAAG,yBAAyB;AAC/D,WAAK,KAAK,GAAG,gBAAgB,IAAI,CAAC;AAAA,IACtC;AACA,WAAO,KAAK,EAAC,MAAM,CAAC,GAAG,IAAI,GAAG,MAAM,GAAG,YAAY,MAAK;AAAA,EAC5D;AACA,SAAO;AACX;AAEA,SAAS,wBAAwB,MAA4B;AACzD,MAAI,KAAK,aAAa;AAClB,UAAM,QAAQ,KAAK,aAAa;AAChC,UAAM,MAAM,KAAK,aAAa;AAC9B,QAAI,SAAS,QAAQ,GAAG;AACpB,YAAM,IAAI,MAAM,0CAA0C;AAAA,IAC9D;AACA,QAAI,OAAO,MAAM,GAAG;AAChB,YAAM,IAAI,MAAM,wCAAwC;AAAA,IAC5D;AACA,QAAI,OAAO,SAAS,OAAO,OAAO;AAC9B,YAAM,IAAI,MAAM,wDAAwD;AAAA,IAC5E;AAAA,EACJ;AACJ;;;;;;;"}

package/.dist/cjs/src/lib/jitFnCompiler.d.ts

@@ -30,8 +30,8 @@ export declare class BaseFnCompiler<FnArgsNames extends JitFnArgs = JitFnArgs, I
     readonly code: string;
     readonly contextCodeItems: Map<string, string>;
     readonly isNoop?: boolean;
-    readonly jitDependencies: Array<string>;
-    readonly pureFnDependencies: Array<string>;
+    readonly jitDependencies: Array<string> | undefined;
+    readonly pureFnDependencies: Array<string> | undefined;
     readonly stack: StackItem[];
     popItem: StackItem | undefined;
     get length(): number;

package/.dist/cjs/src/nodes/atomic/any.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"any.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"any.cjs","sources":["../../../../../src/nodes/atomic/any.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {type TypeAny, type TypeUnknown} from '@deepkit/type';\nimport {AtomicRunType} from '../../lib/baseRunTypes.ts';\nimport type {JitCode} from '../../types.ts';\nimport {JitFnCompiler} from '../../lib/jitFnCompiler.ts';\n\nexport class AnyRunType extends AtomicRunType<TypeAny | TypeUnknown> {\n    emitIsType(comp: JitFnCompiler): JitCode {\n        const isRoot = comp.getNestLevel(this) === 0;\n        if (isRoot) return {code: undefined, type: 'E'};\n        return {code: 'true', type: 'E'};\n    }\n    emitTypeErrors(): JitCode {\n        return {code: undefined, type: 'S'};\n    }\n}\n"],"names":["AtomicRunType"],"mappings":";;;;AAYM,MAAO,mBAAmBA,qBAAAA,cAAoC;AAAA,EAChE,WAAW,MAAmB;AAC1B,UAAM,SAAS,KAAK,aAAa,IAAI,MAAM;AAC3C,QAAI;AAAQ,aAAO,EAAC,MAAM,QAAW,MAAM,IAAA;AAC3C,WAAO,EAAC,MAAM,QAAQ,MAAM,IAAA;AAAA,EAChC;AAAA,EACA,iBAAc;AACV,WAAO,EAAC,MAAM,QAAW,MAAM,IAAA;AAAA,EACnC;AAAA;;;"}

package/.dist/cjs/src/nodes/atomic/bigInt.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"bigInt.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"bigInt.cjs","sources":["../../../../../src/nodes/atomic/bigInt.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {TypeBigInt} from '@deepkit/type';\nimport type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';\nimport type {JitCode} from '../../types.ts';\nimport {AtomicRunType} from '../../lib/baseRunTypes.ts';\n\nexport class BigIntRunType extends AtomicRunType<TypeBigInt> {\n    emitIsType(comp: JitFnCompiler): JitCode {\n        return {code: `typeof ${comp.vλl} === 'bigint'`, type: 'E'};\n    }\n    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {\n        return {code: `if (typeof ${comp.vλl} !== 'bigint') ${comp.callJitErr(this)}`, type: 'S'};\n    }\n    emitPrepareForJson(comp: JitFnCompiler): JitCode {\n        return {code: `${comp.vλl}.toString()`, type: 'E'};\n    }\n    emitRestoreFromJson(comp: JitFnCompiler): JitCode {\n        return {code: `BigInt(${comp.vλl})`, type: 'E'};\n    }\n}\n"],"names":["AtomicRunType"],"mappings":";;;AAYM,MAAO,sBAAsBA,qBAAAA,cAAyB;AAAA,EACxD,WAAW,MAAmB;AAC1B,WAAO,EAAC,MAAM,UAAU,KAAK,GAAG,iBAAiB,MAAM,IAAA;AAAA,EAC3D;AAAA,EACA,eAAe,MAAyB;AACpC,WAAO,EAAC,MAAM,cAAc,KAAK,GAAG,kBAAkB,KAAK,WAAW,IAAI,CAAC,IAAI,MAAM,IAAA;AAAA,EACzF;AAAA,EACA,mBAAmB,MAAmB;AAClC,WAAO,EAAC,MAAM,GAAG,KAAK,GAAG,eAAe,MAAM,IAAA;AAAA,EAClD;AAAA,EACA,oBAAoB,MAAmB;AACnC,WAAO,EAAC,MAAM,UAAU,KAAK,GAAG,KAAK,MAAM,IAAA;AAAA,EAC/C;AAAA;;;"}

package/.dist/cjs/src/nodes/atomic/boolean.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"boolean.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"boolean.cjs","sources":["../../../../../src/nodes/atomic/boolean.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {TypeBoolean} from '@deepkit/type';\nimport type {JitCode} from '../../types.ts';\nimport type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';\nimport {AtomicRunType} from '../../lib/baseRunTypes.ts';\n\nexport class BooleanRunType extends AtomicRunType<TypeBoolean> {\n    emitIsType(comp: JitFnCompiler): JitCode {\n        return {code: `typeof ${comp.vλl} === 'boolean'`, type: 'E'};\n    }\n    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {\n        return {code: `if (typeof ${comp.vλl} !== 'boolean') ${comp.callJitErr(this)}`, type: 'S'};\n    }\n    emitPrepareForJson(): JitCode {\n        return {code: undefined, type: 'S'};\n    }\n    emitRestoreFromJson(): JitCode {\n        return {code: undefined, type: 'S'};\n    }\n}\n"],"names":["AtomicRunType"],"mappings":";;;AAYM,MAAO,uBAAuBA,qBAAAA,cAA0B;AAAA,EAC1D,WAAW,MAAmB;AAC1B,WAAO,EAAC,MAAM,UAAU,KAAK,GAAG,kBAAkB,MAAM,IAAA;AAAA,EAC5D;AAAA,EACA,eAAe,MAAyB;AACpC,WAAO,EAAC,MAAM,cAAc,KAAK,GAAG,mBAAmB,KAAK,WAAW,IAAI,CAAC,IAAI,MAAM,IAAA;AAAA,EAC1F;AAAA,EACA,qBAAkB;AACd,WAAO,EAAC,MAAM,QAAW,MAAM,IAAA;AAAA,EACnC;AAAA,EACA,sBAAmB;AACf,WAAO,EAAC,MAAM,QAAW,MAAM,IAAA;AAAA,EACnC;AAAA;;;"}

package/.dist/cjs/src/nodes/atomic/date.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"date.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"date.cjs","sources":["../../../../../src/nodes/atomic/date.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {type TypeClass} from '@deepkit/type';\nimport type {JitCode} from '../../types.ts';\nimport type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';\nimport {AtomicRunType} from '../../lib/baseRunTypes.ts';\n\nexport class DateRunType extends AtomicRunType<TypeClass> {\n    emitIsType(comp: JitFnCompiler): JitCode {\n        return {code: `(${comp.vλl} instanceof Date && !isNaN(${comp.vλl}.getTime()))`, type: 'E'};\n    }\n    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {\n        return {code: `if (!(${comp.vλl} instanceof Date && !isNaN(${comp.vλl}.getTime()))) ${comp.callJitErr(this)}`, type: 'S'};\n    }\n    emitPrepareForJson(): JitCode {\n        return {code: undefined, type: 'S'};\n    }\n    emitRestoreFromJson(comp: JitFnCompiler): JitCode {\n        return {code: `new Date(${comp.vλl})`, type: 'E'};\n    }\n}\n"],"names":["AtomicRunType"],"mappings":";;;AAYM,MAAO,oBAAoBA,qBAAAA,cAAwB;AAAA,EACrD,WAAW,MAAmB;AAC1B,WAAO,EAAC,MAAM,IAAI,KAAK,GAAG,8BAA8B,KAAK,GAAG,gBAAgB,MAAM,IAAA;AAAA,EAC1F;AAAA,EACA,eAAe,MAAyB;AACpC,WAAO,EAAC,MAAM,SAAS,KAAK,GAAG,8BAA8B,KAAK,GAAG,iBAAiB,KAAK,WAAW,IAAI,CAAC,IAAI,MAAM,IAAA;AAAA,EACzH;AAAA,EACA,qBAAkB;AACd,WAAO,EAAC,MAAM,QAAW,MAAM,IAAA;AAAA,EACnC;AAAA,EACA,oBAAoB,MAAmB;AACnC,WAAO,EAAC,MAAM,YAAY,KAAK,GAAG,KAAK,MAAM,IAAA;AAAA,EACjD;AAAA;;;"}

package/.dist/cjs/src/nodes/atomic/enum.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"enum.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"enum.cjs","sources":["../../../../../src/nodes/atomic/enum.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {TypeEnum} from '@deepkit/type';\nimport type {JitCode} from '../../types.ts';\nimport {toLiteral} from '../../lib/utils.ts';\nimport {AtomicRunType} from '../../lib/baseRunTypes.ts';\nimport type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';\n\nexport class EnumRunType extends AtomicRunType<TypeEnum> {\n    emitIsType(comp: JitFnCompiler): JitCode {\n        const items = this.src.values.map((v) => `${comp.vλl} === ${toLiteral(v)}`);\n        return {code: `(${items.join(' || ')})`, type: 'E'};\n    }\n    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {\n        const items = this.src.values.map((v) => `${comp.vλl} === ${toLiteral(v)}`);\n        return {code: `if (!(${items.join(' || ')})) ${comp.callJitErr(this)}`, type: 'S'};\n    }\n}\n"],"names":["AtomicRunType","toLiteral"],"mappings":";;;;;;;;;AAaM,MAAO,oBAAoBA,qBAAAA,cAAuB;AAAA,EACpD,WAAW,MAAmB;AAC1B,UAAM,QAAQ,KAAK,IAAI,OAAO,IAAG,aAAC,CAAC,MAAM,GAAG,KAAK,GAAG,QAAQC,wBAAU,CAAC,CAAC,IAAE,CAAA,KAAA,IAAA,SAAA,CAAA,CAAA;AAC1E,WAAO,EAAC,MAAM,IAAI,MAAM,KAAK,MAAM,CAAC,KAAK,MAAM,IAAA;AAAA,EACnD;AAAA,EACA,eAAe,MAAyB;AACpC,UAAM,QAAQ,KAAK,IAAI,OAAO,IAAG,aAAC,CAAC,MAAM,GAAG,KAAK,GAAG,QAAQA,wBAAU,CAAC,CAAC,IAAE,CAAA,KAAA,IAAA,SAAA,CAAA,CAAA;AAC1E,WAAO,EAAC,MAAM,SAAS,MAAM,KAAK,MAAM,CAAC,MAAM,KAAK,WAAW,IAAI,CAAC,IAAI,MAAM,IAAA;AAAA,EAClF;AAAA;;;"}

package/.dist/cjs/src/nodes/atomic/enumMember.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"enumMember.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"enumMember.cjs","sources":["../../../../../src/nodes/atomic/enumMember.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {type TypeEnum} from '@deepkit/type';\nimport {AtomicRunType} from '../../lib/baseRunTypes.ts';\nimport {JitCode} from '../../types.ts';\n\n// TODO: not sure when run type will be generated but doesn't seem to be used when using reflection on enums\nexport class EnumMemberRunType extends AtomicRunType<TypeEnum> {\n    skipJit() {\n        return true;\n    }\n    emitIsType(): JitCode {\n        throw new Error('Enum member operations are not supported');\n    }\n    emitTypeErrors(): JitCode {\n        throw new Error('Enum member operations are not supported');\n    }\n    emitPrepareForJson(): JitCode {\n        throw new Error('Enum member operations are not supported');\n    }\n    emitRestoreFromJson(): JitCode {\n        throw new Error('Enum member operations are not supported');\n    }\n}\n"],"names":["AtomicRunType"],"mappings":";;;;AAYM,MAAO,0BAA0BA,qBAAAA,cAAuB;AAAA,EAC1D,UAAO;AACH,WAAO;AAAA,EACX;AAAA,EACA,aAAU;AACN,UAAM,IAAI,MAAM,0CAA0C;AAAA,EAC9D;AAAA,EACA,iBAAc;AACV,UAAM,IAAI,MAAM,0CAA0C;AAAA,EAC9D;AAAA,EACA,qBAAkB;AACd,UAAM,IAAI,MAAM,0CAA0C;AAAA,EAC9D;AAAA,EACA,sBAAmB;AACf,UAAM,IAAI,MAAM,0CAA0C;AAAA,EAC9D;AAAA;;;"}

package/.dist/cjs/src/nodes/atomic/literal.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"literal.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"literal.cjs","sources":["../../../../../src/nodes/atomic/literal.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {ReflectionKind, type TypeLiteral} from '@deepkit/type';\nimport type {JitCode, RunType} from '../../types.ts';\nimport type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';\nimport type {Mutable} from '@mionjs/core';\nimport {toLiteral} from '../../lib/utils.ts';\nimport {AtomicRunType} from '../../lib/baseRunTypes.ts';\nimport {BigIntRunType} from './bigInt.ts';\nimport {RegexpRunType} from './regexp.ts';\nimport {SymbolRunType} from './symbol.ts';\nimport {AnyKindName} from '../../constants.kind.ts';\nimport {StringRunType} from './string.ts';\nimport {NumberRunType} from './number.ts';\nimport {BooleanRunType} from './boolean.ts';\n\nconst stringRt = new StringRunType();\nconst numberRt = new NumberRunType();\nconst booleanRt = new BooleanRunType();\nconst symbolRt = new SymbolRunType();\nconst regexpRt = new RegexpRunType();\nconst bigIntRt = new BigIntRunType();\n\ntype AnyLiteralRunType = StringRunType | NumberRunType | BooleanRunType | SymbolRunType | RegexpRunType | BigIntRunType;\n\nexport class LiteralRunType extends AtomicRunType<TypeLiteral> {\n    getRunTypeForLiteral(comp: JitFnCompiler): AnyLiteralRunType {\n        const noLiterals = comp.opts.noLiterals;\n        const lit = this.src.literal;\n        let rt: AnyLiteralRunType;\n        if (lit instanceof RegExp) {\n            rt = regexpRt;\n            (rt as Mutable<RunType>).src = this.src;\n            if (noLiterals) (this.src as any).kind = ReflectionKind.regexp;\n            return rt;\n        }\n        switch (typeof lit) {\n            case 'string':\n                rt = stringRt;\n                if (noLiterals) (this.src as any).kind = ReflectionKind.string;\n                break;\n            case 'number':\n                rt = numberRt;\n                if (noLiterals) (this.src as any).kind = ReflectionKind.number;\n                break;\n            case 'boolean':\n                rt = booleanRt;\n                if (noLiterals) (this.src as any).kind = ReflectionKind.boolean;\n                break;\n            case 'bigint':\n                rt = bigIntRt;\n                if (noLiterals) (this.src as any).kind = ReflectionKind.bigint;\n                break;\n            case 'symbol':\n                rt = symbolRt;\n                if (noLiterals) (this.src as any).kind = ReflectionKind.symbol;\n                break;\n            default:\n                throw new Error(`Unsupported literal type ${typeof lit}`);\n        }\n        (rt as Mutable<RunType>).src = this.src;\n        return rt;\n    }\n    emitIsType(comp: JitFnCompiler): JitCode {\n        if (comp.opts.noLiterals) return this.getRunTypeForLiteral(comp).emitIsType(comp);\n        return {code: compileIsLiteral(comp, this.src.literal), type: 'E'};\n    }\n    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {\n        if (comp.opts.noLiterals) return this.getRunTypeForLiteral(comp).emitTypeErrors(comp);\n        return {code: compileTypeErrorsLiteral(comp, this.src.literal, this.getKindName()), type: 'S'};\n    }\n    emitPrepareForJson(comp: JitFnCompiler): JitCode {\n        return this.getRunTypeForLiteral(comp).emitPrepareForJson(comp);\n    }\n    emitRestoreFromJson(comp: JitFnCompiler): JitCode {\n        return this.getRunTypeForLiteral(comp).emitRestoreFromJson(comp);\n    }\n    getLiteralValue() {\n        return this.src.literal;\n    }\n}\n\nfunction compileIsLiteral(comp: JitFnCompiler, lit: TypeLiteral['literal']): string {\n    const literalType = typeof lit;\n    if (lit instanceof RegExp) return `${comp.vλl} instanceof RegExp && String(${comp.vλl}) === String(${lit})`;\n    switch (literalType) {\n        case 'string':\n            return `${comp.vλl} === ${toLiteral(lit)}`;\n        case 'number':\n            return `${comp.vλl} === ${toLiteral(lit)}`;\n        case 'boolean':\n            return `${comp.vλl} === ${toLiteral(lit)}`;\n        case 'bigint':\n            return `${comp.vλl} === ${toLiteral(lit)}`;\n        case 'symbol':\n            return `typeof ${comp.vλl} === 'symbol' && ${comp.vλl}.description === ${toLiteral((lit as symbol).description)}`;\n        default:\n            throw new Error(`Unsupported literal type ${literalType}`);\n    }\n}\n\nfunction compileTypeErrorsLiteral(comp: JitErrorsFnCompiler, lit: TypeLiteral['literal'], name: AnyKindName): string {\n    const literalType = typeof lit;\n    if (lit instanceof RegExp)\n        return `if (!(${comp.vλl} instanceof RegExp) || String(${comp.vλl}) !== String(${lit})) ${comp.callJitErr(name)}`;\n    switch (literalType) {\n        case 'string':\n            return `if (${comp.vλl} !== ${toLiteral(lit)}) ${comp.callJitErr(name)}`;\n        case 'number':\n            return `if (${comp.vλl} !== ${toLiteral(lit)}) ${comp.callJitErr(name)}`;\n        case 'boolean':\n            return `if (${comp.vλl} !== ${toLiteral(lit)}) ${comp.callJitErr(name)}`;\n        case 'bigint':\n            return `if (${comp.vλl} !== ${toLiteral(lit)}) ${comp.callJitErr(name)}`;\n        case 'symbol':\n            return `if (typeof ${comp.vλl} !== 'symbol' || ${comp.vλl}.description !== ${toLiteral((lit as symbol).description)}) {${comp.callJitErr(name)}}`;\n        default:\n            throw new Error(`Unsupported literal type ${literalType}`);\n    }\n}\n"],"names":["StringRunType","NumberRunType","BooleanRunType","SymbolRunType","RegexpRunType","BigIntRunType","AtomicRunType","ReflectionKind","toLiteral"],"mappings":"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"}

package/.dist/cjs/src/nodes/atomic/never.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"never.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"never.cjs","sources":["../../../../../src/nodes/atomic/never.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {TypeNever} from '@deepkit/type';\nimport {AtomicRunType} from '../../lib/baseRunTypes.ts';\nimport {JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';\nimport {JitCode} from '../../types.ts';\n\nexport class NeverRunType extends AtomicRunType<TypeNever> {\n    emitIsType(): JitCode {\n        return {code: 'false', type: 'E'};\n    }\n    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {\n        return {code: `${comp.callJitErr(this)}`, type: 'S'};\n    }\n    emitPrepareForJson(): JitCode {\n        throw new Error('Never type cannot be encoded to JSON.');\n    }\n    emitRestoreFromJson(): JitCode {\n        throw new Error('Never type cannot be decoded from JSON.');\n    }\n}\n"],"names":["AtomicRunType"],"mappings":";;;;;AAYM,MAAO,qBAAqBA,qBAAAA,cAAwB;AAAA,EACtD,aAAU;AACN,WAAO,EAAC,MAAM,SAAS,MAAM,IAAA;AAAA,EACjC;AAAA,EACA,eAAe,MAAyB;AACpC,WAAO,EAAC,MAAM,GAAG,KAAK,WAAW,IAAI,CAAC,IAAI,MAAM,IAAA;AAAA,EACpD;AAAA,EACA,qBAAkB;AACd,UAAM,IAAI,MAAM,uCAAuC;AAAA,EAC3D;AAAA,EACA,sBAAmB;AACf,UAAM,IAAI,MAAM,yCAAyC;AAAA,EAC7D;AAAA;;;"}

package/.dist/cjs/src/nodes/atomic/null.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"null.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"null.cjs","sources":["../../../../../src/nodes/atomic/null.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {TypeNull} from '@deepkit/type';\nimport type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';\nimport type {JitCode} from '../../types.ts';\nimport {AtomicRunType} from '../../lib/baseRunTypes.ts';\n\nexport class NullRunType extends AtomicRunType<TypeNull> {\n    emitIsType(comp: JitFnCompiler): JitCode {\n        return {code: `${comp.vλl} === null`, type: 'E'};\n    }\n    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {\n        return {code: `if (${comp.vλl} !== null) ${comp.callJitErr(this)}`, type: 'S'};\n    }\n    emitPrepareForJson(): JitCode {\n        return {code: undefined, type: 'S'};\n    }\n    emitRestoreFromJson(): JitCode {\n        return {code: undefined, type: 'S'};\n    }\n}\n"],"names":["AtomicRunType"],"mappings":";;;AAYM,MAAO,oBAAoBA,qBAAAA,cAAuB;AAAA,EACpD,WAAW,MAAmB;AAC1B,WAAO,EAAC,MAAM,GAAG,KAAK,GAAG,aAAa,MAAM,IAAA;AAAA,EAChD;AAAA,EACA,eAAe,MAAyB;AACpC,WAAO,EAAC,MAAM,OAAO,KAAK,GAAG,cAAc,KAAK,WAAW,IAAI,CAAC,IAAI,MAAM,IAAA;AAAA,EAC9E;AAAA,EACA,qBAAkB;AACd,WAAO,EAAC,MAAM,QAAW,MAAM,IAAA;AAAA,EACnC;AAAA,EACA,sBAAmB;AACf,WAAO,EAAC,MAAM,QAAW,MAAM,IAAA;AAAA,EACnC;AAAA;;;"}

package/.dist/cjs/src/nodes/atomic/number.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"number.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"number.cjs","sources":["../../../../../src/nodes/atomic/number.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {TypeNumber} from '@deepkit/type';\nimport type {JitCode} from '../../types.ts';\nimport type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';\nimport {AtomicRunType} from '../../lib/baseRunTypes.ts';\n\nexport class NumberRunType extends AtomicRunType<TypeNumber> {\n    emitIsType(comp: JitFnCompiler): JitCode {\n        return {code: `Number.isFinite(${comp.vλl})`, type: 'E'};\n    }\n    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {\n        return {code: `if(!(Number.isFinite(${comp.vλl}))) ${comp.callJitErr(this)}`, type: 'S'};\n    }\n    emitPrepareForJson(): JitCode {\n        return {code: undefined, type: 'S'};\n    }\n    emitRestoreFromJson(): JitCode {\n        return {code: undefined, type: 'S'};\n    }\n}\n"],"names":["AtomicRunType"],"mappings":";;;AAYM,MAAO,sBAAsBA,qBAAAA,cAAyB;AAAA,EACxD,WAAW,MAAmB;AAC1B,WAAO,EAAC,MAAM,mBAAmB,KAAK,GAAG,KAAK,MAAM,IAAA;AAAA,EACxD;AAAA,EACA,eAAe,MAAyB;AACpC,WAAO,EAAC,MAAM,wBAAwB,KAAK,GAAG,OAAO,KAAK,WAAW,IAAI,CAAC,IAAI,MAAM,IAAA;AAAA,EACxF;AAAA,EACA,qBAAkB;AACd,WAAO,EAAC,MAAM,QAAW,MAAM,IAAA;AAAA,EACnC;AAAA,EACA,sBAAmB;AACf,WAAO,EAAC,MAAM,QAAW,MAAM,IAAA;AAAA,EACnC;AAAA;;;"}

package/.dist/cjs/src/nodes/atomic/object.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"object.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;"}
+{"version":3,"file":"object.cjs","sources":["../../../../../src/nodes/atomic/object.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {TypeAny, TypeUnknown} from '@deepkit/type';\nimport type {JitCode} from '../../types.ts';\nimport {AtomicRunType} from '../../lib/baseRunTypes.ts';\nimport type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';\n\nexport class ObjectRunType extends AtomicRunType<TypeAny | TypeUnknown> {\n    emitIsType(comp: JitFnCompiler): JitCode {\n        return {code: `(typeof ${comp.vλl} === 'object' && ${comp.vλl} !== null)`, type: 'E'};\n    }\n    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {\n        return {code: `if (!(typeof ${comp.vλl} === 'object' && ${comp.vλl} !== null)) ${comp.callJitErr(this)}`, type: 'S'};\n    }\n}\n"],"names":["AtomicRunType"],"mappings":";;;AAYM,MAAO,sBAAsBA,qBAAAA,cAAoC;AAAA,EACnE,WAAW,MAAmB;AAC1B,WAAO,EAAC,MAAM,WAAW,KAAK,GAAG,oBAAoB,KAAK,GAAG,cAAc,MAAM,IAAA;AAAA,EACrF;AAAA,EACA,eAAe,MAAyB;AACpC,WAAO,EAAC,MAAM,gBAAgB,KAAK,GAAG,oBAAoB,KAAK,GAAG,eAAe,KAAK,WAAW,IAAI,CAAC,IAAI,MAAM,IAAA;AAAA,EACpH;AAAA;;;"}

package/.dist/cjs/src/nodes/atomic/regexp.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"regexp.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"regexp.cjs","sources":["../../../../../src/nodes/atomic/regexp.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {TypeRegexp} from '@deepkit/type';\nimport type {JitCode} from '../../types.ts';\nimport type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';\nimport {AtomicRunType} from '../../lib/baseRunTypes.ts';\n\nexport class RegexpRunType extends AtomicRunType<TypeRegexp> {\n    emitIsType(comp: JitFnCompiler): JitCode {\n        return {code: `(${comp.vλl} instanceof RegExp)`, type: 'E'};\n    }\n    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {\n        return {code: `if (!(${comp.vλl} instanceof RegExp)) ${comp.callJitErr(this)}`, type: 'S'};\n    }\n    emitPrepareForJson(comp: JitFnCompiler): JitCode {\n        return {code: `${comp.vλl}.toString()`, type: 'E'};\n    }\n    emitRestoreFromJson(comp: JitFnCompiler): JitCode {\n        return {\n            code: `(function(){const parts = ${comp.vλl}.match(/\\\\/(.*)\\\\/(.*)?/) ;return new RegExp(parts[1], parts[2] || '')})()`,\n            type: 'E',\n        };\n    }\n}\n"],"names":["AtomicRunType"],"mappings":";;;AAYM,MAAO,sBAAsBA,qBAAAA,cAAyB;AAAA,EACxD,WAAW,MAAmB;AAC1B,WAAO,EAAC,MAAM,IAAI,KAAK,GAAG,uBAAuB,MAAM,IAAA;AAAA,EAC3D;AAAA,EACA,eAAe,MAAyB;AACpC,WAAO,EAAC,MAAM,SAAS,KAAK,GAAG,wBAAwB,KAAK,WAAW,IAAI,CAAC,IAAI,MAAM,IAAA;AAAA,EAC1F;AAAA,EACA,mBAAmB,MAAmB;AAClC,WAAO,EAAC,MAAM,GAAG,KAAK,GAAG,eAAe,MAAM,IAAA;AAAA,EAClD;AAAA,EACA,oBAAoB,MAAmB;AACnC,WAAO;AAAA,MACH,MAAM,6BAA6B,KAAK,GAAG;AAAA,MAC3C,MAAM;AAAA,IAAA;AAAA,EAEd;AAAA;;;"}

package/.dist/cjs/src/nodes/atomic/string.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"string.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;"}
+{"version":3,"file":"string.cjs","sources":["../../../../../src/nodes/atomic/string.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {TypeString} from '@deepkit/type';\nimport type {JitCode} from '../../types.ts';\nimport {AtomicRunType} from '../../lib/baseRunTypes.ts';\nimport type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';\n\nexport class StringRunType extends AtomicRunType<TypeString> {\n    emitIsType(comp: JitFnCompiler): JitCode {\n        return {code: `typeof ${comp.vλl} === 'string'`, type: 'E'};\n    }\n    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {\n        return {code: `if (typeof ${comp.vλl} !== 'string') ${comp.callJitErr(this)}`, type: 'S'};\n    }\n}\n"],"names":["AtomicRunType"],"mappings":";;;AAYM,MAAO,sBAAsBA,qBAAAA,cAAyB;AAAA,EACxD,WAAW,MAAmB;AAC1B,WAAO,EAAC,MAAM,UAAU,KAAK,GAAG,iBAAiB,MAAM,IAAA;AAAA,EAC3D;AAAA,EACA,eAAe,MAAyB;AACpC,WAAO,EAAC,MAAM,cAAc,KAAK,GAAG,kBAAkB,KAAK,WAAW,IAAI,CAAC,IAAI,MAAM,IAAA;AAAA,EACzF;AAAA;;;"}

package/.dist/cjs/src/nodes/atomic/symbol.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"symbol.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"symbol.cjs","sources":["../../../../../src/nodes/atomic/symbol.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {TypeSymbol} from '@deepkit/type';\nimport type {JitCode} from '../../types.ts';\nimport type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';\nimport {AtomicRunType} from '../../lib/baseRunTypes.ts';\nimport {JitFunctions} from '../../constants.functions.ts';\n\nexport class SymbolRunType extends AtomicRunType<TypeSymbol> {\n    skipJit(comp: JitFnCompiler): boolean {\n        if (!comp) return true;\n        return comp.fnID !== JitFunctions.toJSCode.id;\n    }\n    emitIsType(comp: JitFnCompiler): JitCode {\n        return {code: `typeof ${comp.vλl} === 'symbol'`, type: 'E'};\n    }\n    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {\n        return {code: `if (typeof ${comp.vλl} !== 'symbol') ${comp.callJitErr(this)}`, type: 'S'};\n    }\n    emitPrepareForJson(comp: JitFnCompiler): JitCode {\n        return {code: `'Symbol:' + (${comp.vλl}.description || '')`, type: 'E'};\n    }\n    emitRestoreFromJson(comp: JitFnCompiler): JitCode {\n        return {code: `Symbol(${comp.vλl}.substring(7))`, type: 'E'};\n    }\n}\n"],"names":["AtomicRunType","JitFunctions"],"mappings":";;;;AAaM,MAAO,sBAAsBA,qBAAAA,cAAyB;AAAA,EACxD,QAAQ,MAAmB;AACvB,QAAI,CAAC;AAAM,aAAO;AAClB,WAAO,KAAK,SAASC,wBAAAA,aAAa,SAAS;AAAA,EAC/C;AAAA,EACA,WAAW,MAAmB;AAC1B,WAAO,EAAC,MAAM,UAAU,KAAK,GAAG,iBAAiB,MAAM,IAAA;AAAA,EAC3D;AAAA,EACA,eAAe,MAAyB;AACpC,WAAO,EAAC,MAAM,cAAc,KAAK,GAAG,kBAAkB,KAAK,WAAW,IAAI,CAAC,IAAI,MAAM,IAAA;AAAA,EACzF;AAAA,EACA,mBAAmB,MAAmB;AAClC,WAAO,EAAC,MAAM,gBAAgB,KAAK,GAAG,uBAAuB,MAAM,IAAA;AAAA,EACvE;AAAA,EACA,oBAAoB,MAAmB;AACnC,WAAO,EAAC,MAAM,UAAU,KAAK,GAAG,kBAAkB,MAAM,IAAA;AAAA,EAC5D;AAAA;;;"}

package/.dist/cjs/src/nodes/atomic/undefined.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"undefined.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;"}
+{"version":3,"file":"undefined.cjs","sources":["../../../../../src/nodes/atomic/undefined.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {TypeUndefined} from '@deepkit/type';\nimport type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';\nimport type {JitCode} from '../../types.ts';\nimport {AtomicRunType} from '../../lib/baseRunTypes.ts';\n\nexport class UndefinedRunType extends AtomicRunType<TypeUndefined> {\n    emitIsType(comp: JitFnCompiler): JitCode {\n        return {code: `typeof ${comp.vλl} === 'undefined'`, type: 'E'};\n    }\n    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {\n        return {code: `if (typeof ${comp.vλl} !== 'undefined') ${comp.callJitErr(this)}`, type: 'S'};\n    }\n    emitRestoreFromJson(): JitCode {\n        return {code: `undefined`, type: 'E'};\n    }\n}\n"],"names":["AtomicRunType"],"mappings":";;;AAYM,MAAO,yBAAyBA,qBAAAA,cAA4B;AAAA,EAC9D,WAAW,MAAmB;AAC1B,WAAO,EAAC,MAAM,UAAU,KAAK,GAAG,oBAAoB,MAAM,IAAA;AAAA,EAC9D;AAAA,EACA,eAAe,MAAyB;AACpC,WAAO,EAAC,MAAM,cAAc,KAAK,GAAG,qBAAqB,KAAK,WAAW,IAAI,CAAC,IAAI,MAAM,IAAA;AAAA,EAC5F;AAAA,EACA,sBAAmB;AACf,WAAO,EAAC,MAAM,aAAa,MAAM,IAAA;AAAA,EACrC;AAAA;;;"}

package/.dist/cjs/src/nodes/atomic/unknown.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"unknown.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;"}
+{"version":3,"file":"unknown.cjs","sources":["../../../../../src/nodes/atomic/unknown.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {AnyRunType} from './any.ts';\n\nexport class UnknownRunType extends AnyRunType {}\n"],"names":["AnyRunType"],"mappings":";;;AASM,MAAO,uBAAuBA,qBAAAA,WAAU;AAAA;;;"}

package/.dist/cjs/src/nodes/atomic/void.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"void.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"void.cjs","sources":["../../../../../src/nodes/atomic/void.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {TypeVoid} from '@deepkit/type';\nimport type {JitCode} from '../../types.ts';\nimport {AtomicRunType} from '../../lib/baseRunTypes.ts';\nimport type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';\n\nexport class VoidRunType extends AtomicRunType<TypeVoid> {\n    emitIsType(comp: JitFnCompiler): JitCode {\n        return {code: `${comp.vλl} === undefined`, type: 'E'};\n    }\n    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {\n        return {code: `if (${comp.vλl} !== undefined) ${comp.callJitErr(this)}`, type: 'S'};\n    }\n    emitPrepareForJson(comp: JitFnCompiler): JitCode {\n        return {code: `${comp.vλl} = undefined`, type: 'E'};\n    }\n    emitRestoreFromJson(comp: JitFnCompiler): JitCode {\n        return {code: `${comp.vλl} = undefined`, type: 'E'};\n    }\n}\n"],"names":["AtomicRunType"],"mappings":";;;AAYM,MAAO,oBAAoBA,qBAAAA,cAAuB;AAAA,EACpD,WAAW,MAAmB;AAC1B,WAAO,EAAC,MAAM,GAAG,KAAK,GAAG,kBAAkB,MAAM,IAAA;AAAA,EACrD;AAAA,EACA,eAAe,MAAyB;AACpC,WAAO,EAAC,MAAM,OAAO,KAAK,GAAG,mBAAmB,KAAK,WAAW,IAAI,CAAC,IAAI,MAAM,IAAA;AAAA,EACnF;AAAA,EACA,mBAAmB,MAAmB;AAClC,WAAO,EAAC,MAAM,GAAG,KAAK,GAAG,gBAAgB,MAAM,IAAA;AAAA,EACnD;AAAA,EACA,oBAAoB,MAAmB;AACnC,WAAO,EAAC,MAAM,GAAG,KAAK,GAAG,gBAAgB,MAAM,IAAA;AAAA,EACnD;AAAA;;;"}

package/.dist/cjs/src/nodes/collection/class.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"class.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"class.cjs","sources":["../../../../../src/nodes/collection/class.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\nimport {TypeClass} from '@deepkit/type';\nimport {InterfaceMember, InterfaceRunType} from './interface.ts';\nimport {JitFnCompiler} from '../../lib/jitFnCompiler.ts';\nimport {getJitUtils} from '@mionjs/core';\nimport {toLiteral} from '../../lib/utils.ts';\nimport {isConstructor} from '../../lib/guards.ts';\nimport {JitCode} from '../../types.ts';\n\nexport class ClassRunType extends InterfaceRunType<TypeClass> {\n    getClassName(): string {\n        return this.src.classType.name;\n    }\n    isClassWithEmptyConstructor(): boolean {\n        const children = this.getChildRunTypes() as InterfaceMember[];\n        const isEmpty = children.every((prop) => !isConstructor(prop) || prop.getParameters().getChildRunTypes().length === 0);\n        return isEmpty;\n    }\n    emitRestoreFromJson(comp: JitFnCompiler): JitCode {\n        const objJit = super.emitRestoreFromJson(comp);\n        const desFnVarName = comp.getLocalVarName('desFn', this);\n        const classLiteral = toLiteral(this.getClassName());\n        const code = `\n            ${objJit.code};\n            let ${desFnVarName} = utl.${getJitUtils().getDeserializeFn.name}(${classLiteral});\n            if (${desFnVarName}) {${comp.vλl} = ${desFnVarName}(${comp.vλl})}\n            else if (${desFnVarName} = utl.${getJitUtils().getSerializeClass.name}(${classLiteral})) {${comp.vλl} = new ${desFnVarName}(${comp.vλl})}\n        `;\n        return {code, type: 'S'};\n    }\n}\n"],"names":["InterfaceRunType","isConstructor","toLiteral","getJitUtils"],"mappings":";;;;;;;;;;;;;AAcM,MAAO,qBAAqBA,+BAAAA,iBAA2B;AAAA,EACzD,eAAY;AACR,WAAO,KAAK,IAAI,UAAU;AAAA,EAC9B;AAAA,EACA,8BAA2B;AACvB,UAAM,WAAW,KAAK,iBAAA;AACtB,UAAM,UAAU,SAAS,MAAK,aAAC,CAAC,SAAS,CAACC,6BAAc,IAAI,KAAK,KAAK,gBAAgB,iBAAA,EAAmB,WAAW;AACpH,WAAO;AAAA,EACX;AAAA,EACA,oBAAoB,MAAmB;AACnC,UAAM,SAAS,MAAM,oBAAoB,IAAI;AAC7C,UAAM,eAAe,KAAK,gBAAgB,SAAS,IAAI;AACvD,UAAM,eAAeC,cAAAA,UAAU,KAAK,aAAA,CAAc;AAClD,UAAM,OAAO;AAAA,cACP,OAAO,IAAI;AAAA,kBACP,YAAY,UAAUC,KAAAA,YAAA,EAAc,iBAAiB,IAAI,IAAI,YAAY;AAAA,kBACzE,YAAY,MAAM,KAAK,GAAG,MAAM,YAAY,IAAI,KAAK,GAAG;AAAA,uBACnD,YAAY,UAAUA,KAAAA,YAAA,EAAc,kBAAkB,IAAI,IAAI,YAAY,OAAO,KAAK,GAAG,UAAU,YAAY,IAAI,KAAK,GAAG;AAAA;AAE1I,WAAO,EAAC,MAAM,MAAM,IAAA;AAAA,EACxB;AAAA;;;"}

package/.dist/cjs/src/nodes/collection/functionParams.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"functionParams.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"functionParams.cjs","sources":["../../../../../src/nodes/collection/functionParams.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {TypeFunction} from '@deepkit/type';\nimport type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';\nimport type {AnyParameterListRunType, JitCode} from '../../types.ts';\nimport {TupleRunType} from './tuple.ts';\nimport {ParameterRunType} from '../member/param.ts';\n\nexport class FunctionParamsRunType<ParamList extends AnyParameterListRunType = TypeFunction> extends TupleRunType<\n    ParamList,\n    ParameterRunType\n> {\n    emitIsType(comp: JitFnCompiler): JitCode {\n        const children = this.getParamRunTypes(comp);\n        if (children.length === 0) return {code: `${comp.vλl}.length === 0`, type: 'E'};\n        const lengthCode = this.hasRestParameter(comp) ? '' : `${comp.vλl}.length <= ${children.length}`;\n        // Only include parameters that require validation\n        const paramsCode = children.map((p) => comp.compileIsType(p, 'E').code).filter(Boolean);\n        if (paramsCode.length === 0) return lengthCode ? {code: `(${lengthCode})`, type: 'E'} : {code: undefined, type: 'E'};\n        return lengthCode\n            ? {code: `(${lengthCode} && ${paramsCode.join(' && ')})`, type: 'E'}\n            : {code: `(${paramsCode.join(' && ')})`, type: 'E'};\n    }\n    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {\n        const children = this.getParamRunTypes(comp);\n        if (children.length === 0) return {code: `if (${comp.vλl}.length !== 0) ${comp.callJitErr(this)}`, type: 'S'};\n        const lengthCode = this.hasRestParameter(comp) ? '' : `${comp.vλl}.length > ${children.length}`;\n\n        // Only include parameters that require validation\n        const paramsCode = children.map((p) => comp.compileTypeErrors(p, 'S').code).filter(Boolean);\n        if (paramsCode.length === 0)\n            return lengthCode ? {code: `if (${lengthCode}) ${comp.callJitErr(this)}`, type: 'S'} : {code: undefined, type: 'S'};\n        return lengthCode\n            ? {code: `if (${lengthCode}) ${comp.callJitErr(this)}; else {${paramsCode.join(';')}}`, type: 'S'}\n            : {code: paramsCode.join(';'), type: 'S'};\n    }\n}\n"],"names":["TupleRunType"],"mappings":";;;;;;;;AAaM,MAAO,8BAAwFA,2BAAAA,aAGpG;AAAA,EACG,WAAW,MAAmB;AAC1B,UAAM,WAAW,KAAK,iBAAiB,IAAI;AAC3C,QAAI,SAAS,WAAW;AAAG,aAAO,EAAC,MAAM,GAAG,KAAK,GAAG,iBAAiB,MAAM,IAAA;AAC3E,UAAM,aAAa,KAAK,iBAAiB,IAAI,IAAI,KAAK,GAAG,KAAK,GAAG,cAAc,SAAS,MAAM;AAE9F,UAAM,aAAa,SAAS,IAAG,aAAC,CAAC,MAAM,KAAK,cAAc,GAAG,GAAG,EAAE,MAAI,CAAA,KAAA,IAAA,SAAA,CAAA,CAAA,EAAE,OAAO,OAAO;AACtF,QAAI,WAAW,WAAW;AAAG,aAAO,aAAa,EAAC,MAAM,IAAI,UAAU,KAAK,MAAM,IAAA,IAAO,EAAC,MAAM,QAAW,MAAM,IAAA;AAChH,WAAO,aACD,EAAC,MAAM,IAAI,UAAU,OAAO,WAAW,KAAK,MAAM,CAAC,KAAK,MAAM,QAC9D,EAAC,MAAM,IAAI,WAAW,KAAK,MAAM,CAAC,KAAK,MAAM,IAAA;AAAA,EACvD;AAAA,EACA,eAAe,MAAyB;AACpC,UAAM,WAAW,KAAK,iBAAiB,IAAI;AAC3C,QAAI,SAAS,WAAW;AAAG,aAAO,EAAC,MAAM,OAAO,KAAK,GAAG,kBAAkB,KAAK,WAAW,IAAI,CAAC,IAAI,MAAM,IAAA;AACzG,UAAM,aAAa,KAAK,iBAAiB,IAAI,IAAI,KAAK,GAAG,KAAK,GAAG,aAAa,SAAS,MAAM;AAG7F,UAAM,aAAa,SAAS,IAAG,aAAC,CAAC,MAAM,KAAK,kBAAkB,GAAG,GAAG,EAAE,MAAI,CAAA,KAAA,IAAA,SAAA,CAAA,CAAA,EAAE,OAAO,OAAO;AAC1F,QAAI,WAAW,WAAW;AACtB,aAAO,aAAa,EAAC,MAAM,OAAO,UAAU,KAAK,KAAK,WAAW,IAAI,CAAC,IAAI,MAAM,IAAA,IAAO,EAAC,MAAM,QAAW,MAAM,IAAA;AACnH,WAAO,aACD,EAAC,MAAM,OAAO,UAAU,KAAK,KAAK,WAAW,IAAI,CAAC,WAAW,WAAW,KAAK,GAAG,CAAC,KAAK,MAAM,IAAA,IAC5F,EAAC,MAAM,WAAW,KAAK,GAAG,GAAG,MAAM,IAAA;AAAA,EAC7C;AAAA;;;"}

package/.dist/cjs/src/nodes/collection/interface.cjs

@@ -54,8 +54,14 @@ class InterfaceRunType extends src_lib_baseRunTypes.CollectionRunType {
         code: [this.getCallSignature().emitIsType(comp).code, childrenCode].filter(Boolean).join(" && "),
         type: "E"
       };
+    let propsCode = "";
+    if (comp.opts.strictTypes && !this.hasIndexSignature(comp)) {
+      const unknownCheck = callCheckUnknownProperties(this, comp, children, false, false);
+      if (unknownCheck)
+        propsCode = `!${unknownCheck}`;
+    }
     const objectCheck = this.isPartOfUnion() ? "" : `typeof ${varName} === 'object' && ${varName} !== null`;
-    const itemsCode = [objectCheck, this.allOptionalCode(comp), childrenCode].filter(Boolean).join(" && ");
+    const itemsCode = [objectCheck, this.allOptionalCode(comp), childrenCode, propsCode].filter(Boolean).join(" && ");
     return { code: `(${itemsCode})`, type: "E" };
   }
   emitTypeErrors(comp) {
@@ -65,6 +71,18 @@ class InterfaceRunType extends src_lib_baseRunTypes.CollectionRunType {
     if (this.isCallable()) {
       return { code: `${this.getCallSignature().emitTypeErrors(comp).code} else {${childrenCode}}`, type: "S" };
     }
+    let propsCode = "";
+    if (comp.opts.strictTypes && !this.hasIndexSignature(comp)) {
+      const unknownVar = comp.getLocalVarName("unk", this);
+      const keyVar = comp.getLocalVarName("ky", this);
+      const unknownValue = callCheckUnknownProperties(this, comp, children, true, false);
+      if (unknownValue) {
+        propsCode = `
+                    const ${unknownVar} = ${unknownValue};
+                    if (${unknownVar}) {for (const ${keyVar} of ${unknownVar}) {${comp.callJitErrWithPath("never", keyVar)}}}
+                `;
+      }
+    }
     const objectCheck = this.isPartOfUnion() ? "" : `typeof ${varName} === 'object' && ${varName} !== null`;
     const isObjectCode = [objectCheck, this.allOptionalCode(comp)].filter(Boolean).join(" && ");
     return {
@@ -73,6 +91,7 @@ class InterfaceRunType extends src_lib_baseRunTypes.CollectionRunType {
                 ${comp.callJitErr(this)};
             } else {
                 ${childrenCode}
+                ${propsCode}
             }
         `,
       type: "S"
@@ -204,10 +223,11 @@ function callCheckUnknownProperties(rt, comp, jitChildrenRunTypes, returnKeys, c
   const checkPropName = src_constants_functions.JitFunctions.hasUnknownKeys.runTimeOptions.checkNonJitProps.keyName;
   const optsVarName = src_lib_utils.getJitFnArgCallVarName(comp, rt, src_constants_functions.JitFunctions.hasUnknownKeys.id, "θpts");
   const conditional = allChildrenRuntypes?.length && result.hasNonJitChildren ? `${optsVarName}.${checkPropName} ? ${result.allKeysName} : ${result.keysName}` : result.keysName;
-  const getUnknownKeysFn = comp.addPureFunction(src_runTypesPureFns.cpf_getUnknownKeysFromArray);
-  const hasUnknownKeysFn = comp.addPureFunction(src_runTypesPureFns.cpf_hasUnknownKeysFromArray);
-  if (returnKeys)
+  if (returnKeys) {
+    const getUnknownKeysFn = comp.addPureFunction(src_runTypesPureFns.cpf_getUnknownKeysFromArray);
     return `${getUnknownKeysFn}(${comp.vλl}, ${conditional})`;
+  }
+  const hasUnknownKeysFn = comp.addPureFunction(src_runTypesPureFns.cpf_hasUnknownKeysFromArray);
   objectCheckCode.push(`${hasUnknownKeysFn}(${comp.vλl}, ${conditional})`);
   const filtered = objectCheckCode.filter(Boolean);
   if (filtered.length > 1)

package/.dist/cjs/src/nodes/collection/interface.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"interface.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"interface.cjs","sources":["../../../../../src/nodes/collection/interface.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\nimport {TypeObjectLiteral, TypeClass, TypeIntersection, ReflectionKind} from '@deepkit/type';\nimport type {JitCode} from '../../types.ts';\nimport type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';\nimport {arrayToLiteral, getJitFnArgCallVarName, memorize, sortDiscriminatorsFirst} from '../../lib/utils.ts';\nimport {PropertyRunType} from '../member/property.ts';\nimport {BaseRunType, CollectionRunType, MemberRunType} from '../../lib/baseRunTypes.ts';\nimport {MethodSignatureRunType} from '../member/methodSignature.ts';\nimport {IndexSignatureRunType} from '../member/indexProperty.ts';\nimport {MethodRunType} from '../member/method.ts';\nimport {CallSignatureRunType} from '../member/callSignature.ts';\nimport {JitFunctions} from '../../constants.functions.ts';\nimport {isIndexSignatureRunType} from '../../lib/guards.ts';\nimport {cpf_getUnknownKeysFromArray, cpf_hasUnknownKeysFromArray} from '../../run-types-pure-fns.ts';\n\nexport type InterfaceMember =\n    | PropertyRunType\n    | MethodSignatureRunType\n    | IndexSignatureRunType\n    | MethodRunType\n    | CallSignatureRunType;\n\nexport class InterfaceRunType<\n    T extends TypeObjectLiteral | TypeClass | TypeIntersection = TypeObjectLiteral,\n> extends CollectionRunType<T> {\n    getNamedChildren(comp: JitFnCompiler): InterfaceMember[] {\n        return this.getJitChildren(comp).filter((prop) => !!(prop.src as any).name) as InterfaceMember[];\n    }\n\n    isCallable(): boolean {\n        return this.getCallSignature() !== undefined;\n    }\n\n    getCallSignature = memorize((): CallSignatureRunType | undefined => {\n        return this.getChildRunTypes().find((prop) => prop.src.kind === ReflectionKind.callSignature) as CallSignatureRunType;\n    });\n\n    getJitChildren(comp: JitFnCompiler): InterfaceMember[] {\n        const children = super.getJitChildren(comp) as InterfaceMember[];\n        return children.toSorted((a, b) => sortDiscriminatorsFirst(a, b)) as InterfaceMember[];\n    }\n    /** Split children in two groups: required and optional */\n    splitJitSplitChildren(comp: JitFnCompiler): {\n        /** all required properties */\n        required: PropertyRunType[];\n        /** all optional properties */\n        optional: PropertyRunType[];\n        /** all index signatures */\n        indexSignatures: IndexSignatureRunType[];\n    } {\n        const children = super.getJitChildren(comp) as InterfaceMember[];\n        const required = children.filter((prop) => !prop.isOptional()) as PropertyRunType[];\n        const optional = children.filter((prop) => prop.isOptional() && !isIndexSignatureRunType(prop)) as PropertyRunType[];\n        const indexSignatures = children.filter((prop) => isIndexSignatureRunType(prop)) as IndexSignatureRunType[];\n        return {required, optional, indexSignatures};\n    }\n    isPartOfUnion(): boolean {\n        return this.getParent()?.src.kind === ReflectionKind.union;\n    }\n    hasIndexSignature(comp: JitFnCompiler): boolean {\n        return this.getJitChildren(comp).some((prop) => isIndexSignatureRunType(prop));\n    }\n\n    // #### collection's jit code ####\n\n    emitIsType(comp: JitFnCompiler): JitCode {\n        const varName = comp.vλl;\n        const children = this.getJitChildren(comp);\n        const childrenCode = children\n            .map((prop) => comp.compileIsType(prop, 'E').code)\n            .filter(Boolean)\n            .join(' && ');\n        if (this.isCallable())\n            return {\n                code: [this.getCallSignature()!.emitIsType(comp).code, childrenCode].filter(Boolean).join(' && '),\n                type: 'E',\n            };\n        let propsCode = '';\n        if (comp.opts.strictTypes && !this.hasIndexSignature(comp)) {\n            const unknownCheck = callCheckUnknownProperties(this, comp, children, false, false);\n            if (unknownCheck) propsCode = `!${unknownCheck}`;\n        }\n        const objectCheck = this.isPartOfUnion() ? '' : `typeof ${varName} === 'object' && ${varName} !== null`;\n        const itemsCode = [objectCheck, this.allOptionalCode(comp), childrenCode, propsCode].filter(Boolean).join(' && ');\n        return {code: `(${itemsCode})`, type: 'E'};\n    }\n\n    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {\n        const varName = comp.vλl;\n        const children = this.getJitChildren(comp);\n        const childrenCode = children\n            .map((prop) => comp.compileTypeErrors(prop, 'S').code)\n            .filter(Boolean)\n            .join(';');\n        if (this.isCallable()) {\n            return {code: `${this.getCallSignature()!.emitTypeErrors(comp).code} else {${childrenCode}}`, type: 'S'};\n        }\n        let propsCode = '';\n        if (comp.opts.strictTypes && !this.hasIndexSignature(comp)) {\n            const unknownVar = comp.getLocalVarName('unk', this);\n            const keyVar = comp.getLocalVarName('ky', this);\n            const unknownValue = callCheckUnknownProperties(this, comp, children, true, false);\n            if (unknownValue) {\n                propsCode = `\n                    const ${unknownVar} = ${unknownValue};\n                    if (${unknownVar}) {for (const ${keyVar} of ${unknownVar}) {${comp.callJitErrWithPath('never', keyVar)}}}\n                `;\n            }\n        }\n        const objectCheck = this.isPartOfUnion() ? '' : `typeof ${varName} === 'object' && ${varName} !== null`;\n        const isObjectCode = [objectCheck, this.allOptionalCode(comp)].filter(Boolean).join(' && ');\n        return {\n            code: `\n            if (!(${isObjectCode})) {\n                ${comp.callJitErr(this)};\n            } else {\n                ${childrenCode}\n                ${propsCode}\n            }\n        `,\n            type: 'S',\n        };\n    }\n    emitPrepareForJson(comp: JitFnCompiler): JitCode {\n        if (this.isCallable()) return this.getCallSignature()!.emitPrepareForJson();\n        const children = this.getJitChildren(comp);\n        const childrenCode = children\n            .map((prop) => comp.compilePrepareForJson(prop, 'S').code)\n            .filter(Boolean)\n            .join(';');\n        return {code: childrenCode, type: 'S'};\n    }\n    emitRestoreFromJson(comp: JitFnCompiler): JitCode {\n        if (this.isCallable()) return this.getCallSignature()!.emitRestoreFromJson();\n        const children = this.getJitChildren(comp);\n        const childrenCode = children\n            .map((prop) => comp.compileRestoreFromJson(prop, 'S').code)\n            .filter(Boolean)\n            .join(';');\n        return {code: childrenCode, type: 'S'};\n    }\n    emitHasUnknownKeys(comp: JitFnCompiler): JitCode {\n        const children = this.getJitChildren(comp);\n        const allChildren = this.getChildRunTypes().filter((prop) => !isIndexSignatureRunType(prop));\n        const hasIndexProp = children.some((prop) => isIndexSignatureRunType(prop));\n        const parentCode = hasIndexProp\n            ? ''\n            : callCheckUnknownProperties(this, comp, children, false, !this.isPartOfUnion(), allChildren);\n        const childrenCode = super.emitHasUnknownKeys(comp).code;\n        return {code: [parentCode, childrenCode].filter(Boolean).join(' || '), type: 'E'};\n    }\n    emitUnknownKeyErrors(comp: JitErrorsFnCompiler): JitCode {\n        const children = this.getJitChildren(comp);\n        const allChildren = this.getChildRunTypes().filter((prop) => !isIndexSignatureRunType(prop));\n        const hasIndexProp = children.some((prop) => isIndexSignatureRunType(prop));\n        const unknownVar = comp.getLocalVarName('unk', this);\n        const keyVar = comp.getLocalVarName('ky', this);\n        const unknownValue = hasIndexProp\n            ? undefined\n            : callCheckUnknownProperties(this, comp, children, true, !this.isPartOfUnion(), allChildren);\n        const parentCode = `\n            const ${unknownVar} = ${unknownValue};\n            if (${unknownVar}) {for (const ${keyVar} of ${unknownVar}) {${comp.callJitErrWithPath('never', keyVar)}}}\n        `;\n        const childrenCode = super.emitUnknownKeyErrors(comp).code;\n        return {code: [unknownValue ? parentCode : '', childrenCode].filter(Boolean).join('\\n'), type: 'S'};\n    }\n    emitStripUnknownKeys(comp: JitFnCompiler): JitCode {\n        const children = this.getJitChildren(comp);\n        const unknownVar = comp.getLocalVarName('unk', this);\n        const keyVar = comp.getLocalVarName('ky', this);\n        const hasIndexProp = children.some((prop) => isIndexSignatureRunType(prop));\n        const unknownValue = hasIndexProp\n            ? undefined\n            : callCheckUnknownProperties(this, comp, children, true, !this.isPartOfUnion());\n        const parentCode = `\n            const ${unknownVar} = ${unknownValue};\n            if (${unknownVar}) {for (const ${keyVar} of ${unknownVar}){delete ${comp.vλl}[${keyVar}]}}\n        `;\n        const childrenCode = super.emitStripUnknownKeys(comp).code;\n        return {code: [unknownValue ? parentCode : '', childrenCode].filter(Boolean).join('\\n'), type: 'S'};\n    }\n    emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode {\n        const children = this.getJitChildren(comp);\n        const unknownVar = comp.getLocalVarName('unk', this);\n        const keyVar = comp.getLocalVarName('ky', this);\n        const hasIndexProp = children.some((prop) => isIndexSignatureRunType(prop));\n        const unknownValue = hasIndexProp\n            ? undefined\n            : callCheckUnknownProperties(this, comp, children, true, !this.isPartOfUnion());\n        const parentCode = `\n            const ${unknownVar} = ${unknownValue};\n            if (${unknownVar}) {for (const ${keyVar} of ${unknownVar}){${comp.vλl}[${keyVar}] = undefined}}\n        `;\n        const childrenCode = super.emitUnknownKeysToUndefined(comp).code;\n        return {code: [unknownValue ? parentCode : '', childrenCode].filter(Boolean).join('\\n'), type: 'S'};\n    }\n\n    // In order to json stringify to work properly optional properties must come first\n    getJsonStringifySortedChildren(comp: JitFnCompiler): MemberRunType<any>[] {\n        return this.getJitChildren(comp).toSorted((a, b) => {\n            const aOptional = a instanceof MemberRunType && a.isOptional();\n            const bOptional = b instanceof MemberRunType && b.isOptional();\n            if (aOptional && !bOptional) return -1;\n            if (!aOptional && bOptional) return 1;\n            return 0;\n        }) as MemberRunType<any>[];\n    }\n\n    // extra check to prevent empty array passing as object where all properties are optional\n    // when this check is disabled empty array will pass as object but fail when checking for properties\n    allOptionalCode(comp: JitFnCompiler): string {\n        const children = this.getJitChildren(comp);\n        if (children.length !== 0 && !this.areAllChildrenOptional(children)) return '';\n        const isNotArray = `!Array.isArray(${comp.vλl})`;\n        const ifNoNative = `Object.prototype.toString.call(${comp.vλl}) === '[object Object]'`;\n        return `(${isNotArray} && ${ifNoNative})`;\n    }\n\n    addObjectPropsToContext(comp: JitFnCompiler, jitChildrenRunTypes?: BaseRunType[], allChildrenRuntypes?: BaseRunType[]) {\n        const children = jitChildrenRunTypes || this.getJitChildren(comp);\n        const allChildren = allChildrenRuntypes || this.getChildRunTypes();\n        return addObjectPropsToContext(this, comp, children, allChildren);\n    }\n}\n\nexport interface ObjectPropsContextResult {\n    keysName: string;\n    allKeysName: string;\n    hasNonJitChildren: boolean;\n    jitChildrenNames: string[];\n    allChildrenNames: string[];\n}\n\n/**\n * Extracts object property names and adds them to the JIT compiler context.\n */\nfunction addObjectPropsToContext(\n    rt: InterfaceRunType<any>,\n    comp: JitFnCompiler,\n    jitChildrenRunTypes: BaseRunType[],\n    allChildrenRuntypes?: BaseRunType[]\n): ObjectPropsContextResult {\n    const jitArrNames = jitChildrenRunTypes.filter((prop) => !!(prop.src as any).name).map((prop) => (prop.src as any).name);\n    const AllArrNames = allChildrenRuntypes?.filter((prop) => !!(prop.src as any).name).map((prop) => (prop.src as any).name);\n    const jitChildrenNames = Array.from(new Set(jitArrNames));\n    const allChildrenNames = Array.from(new Set(AllArrNames));\n    const isSameLength = jitChildrenNames.length === allChildrenNames.length;\n    const isSameSet = isSameLength && jitChildrenNames.every((v) => allChildrenNames.includes(v));\n    const hasNonJitChildren = !(isSameLength && isSameSet);\n    const keysName = `k_${rt.getJitHash(comp.opts)}`;\n    const allKeysName = `kA_${rt.getJitHash(comp.opts)}`;\n\n    comp.setContextItem(keysName, `const ${keysName} = ${arrayToLiteral(jitChildrenNames)}`);\n    if (hasNonJitChildren) comp.setContextItem(allKeysName, `const ${allKeysName} = ${arrayToLiteral(allChildrenNames)}`);\n\n    return {\n        keysName,\n        allKeysName,\n        hasNonJitChildren,\n        jitChildrenNames,\n        allChildrenNames,\n    };\n}\n\n// TODO: look like some of this logic should be moved to index prop ? Also the runtime\nfunction callCheckUnknownProperties(\n    rt: InterfaceRunType<any>,\n    comp: JitFnCompiler,\n    jitChildrenRunTypes: BaseRunType[],\n    returnKeys: boolean,\n    checkObject = true,\n    allChildrenRuntypes?: BaseRunType[]\n): string {\n    const result = addObjectPropsToContext(rt, comp, jitChildrenRunTypes, allChildrenRuntypes);\n\n    if (result.jitChildrenNames.length === 0 && result.allChildrenNames.length === 0) return '';\n\n    const objectCheckCode = checkObject ? [`typeof ${comp.vλl} === 'object'`, `${comp.vλl} !== null`] : [];\n    const checkPropName = JitFunctions.hasUnknownKeys.runTimeOptions.checkNonJitProps.keyName;\n    const optsVarName = getJitFnArgCallVarName(comp, rt, JitFunctions.hasUnknownKeys.id, 'θpts');\n    const conditional =\n        allChildrenRuntypes?.length && result.hasNonJitChildren\n            ? `${optsVarName}.${checkPropName} ? ${result.allKeysName} : ${result.keysName}`\n            : result.keysName;\n    if (returnKeys) {\n        const getUnknownKeysFn = comp.addPureFunction(cpf_getUnknownKeysFromArray);\n        return `${getUnknownKeysFn}(${comp.vλl}, ${conditional})`;\n    }\n    const hasUnknownKeysFn = comp.addPureFunction(cpf_hasUnknownKeysFromArray);\n    objectCheckCode.push(`${hasUnknownKeysFn}(${comp.vλl}, ${conditional})`);\n    const filtered = objectCheckCode.filter(Boolean);\n    if (filtered.length > 1) return `(${filtered.join(' && ')})`;\n    return filtered[0];\n}\n"],"names":["CollectionRunType","memorize","ReflectionKind","sortDiscriminatorsFirst","isIndexSignatureRunType","MemberRunType","CallSignatureRunType","PropertyRunType","IndexSignatureRunType","BaseRunType","arrayToLiteral","JitFunctions","getJitFnArgCallVarName","cpf_getUnknownKeysFromArray","cpf_hasUnknownKeysFromArray"],"mappings":"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"}