@mionjs/run-types 0.8.10 → 0.13.2

package/.dist/esm/src/lib/baseRunTypes.js

@@ -1,277 +0,0 @@
-import { getENV, createUniqueHash, getJitUtils } from "@mionjs/core";
-import { CodeTypes, JitFunctions } from "../constants.functions.js";
-import { ReflectionKind, stringifyType } from "@deepkit/type";
-import { getPropIndex, memorize } from "./utils.js";
-import { MockJitCompiler, createJitCompiler } from "./jitFnCompiler.js";
-import { getJITFnHash } from "./createJitFunction.js";
-import { getReflectionName } from "../constants.kind.js";
-import { initFormatAnnotations } from "./formats.js";
-import { createTypeId } from "./typeId.js";
-import { registerJitFunctionCompiler, getJitFunctionCompiler } from "./jitFnsRegistry.js";
-import { defaultMockOptions } from "../mocking/constants.mock.js";
-CodeTypes.returnBlock;
-const S = CodeTypes.statement;
-const E = CodeTypes.expression;
-class BaseRunType {
-  isCircular;
-  src = null;
-  // Atomic, Collection, Member, Function
-  /**
-   * This single functions controls whether or not the code for a type should be inlined into the parent function
-   * or should create a separate jit function for it, add as a dependency and call it.
-   * @returns
-   */
-  isJitInlined = () => {
-    if (this.isCircular) return false;
-    if (getENV("DEBUG_JIT") === "INLINED") return true;
-    if (this.src.kind === ReflectionKind.array) return false;
-    if (this.src.typeName && this.getFamily() === "C") return false;
-    return true;
-  };
-  getKindName = memorize(() => getReflectionName(this));
-  getTypeName = () => this.src.typeName || this.getKindName();
-  stringify = memorize(() => stringifyType(this.src));
-  skipJit(comp) {
-    return false;
-  }
-  /** Returns the format portion of the type ID (cached in src._formatId), or undefined if no format. */
-  getFormatTypeID() {
-    const formatId = this.src._formatId;
-    return formatId || void 0;
-  }
-  /** Returns the type ID which is cached in src._typeId by getDeepkitTypeId(). Format ID is already included. */
-  getTypeID() {
-    if (this.src._typeId === void 0) {
-      throw new Error(`Missing cached type ID for ${this.getTypeName()}. Ensure getDeepkitTypeId() has been called.`);
-    }
-    return this.src._typeId;
-  }
-  getJitHash(opts) {
-    const optsCopy = { ...opts };
-    if (optsCopy.mock) delete optsCopy.mock;
-    return createUniqueHash(this.getTypeID().toString() + JSON.stringify(optsCopy));
-  }
-  getParent = () => this.src.parent?._rt;
-  checkIsCircularAndGetRefId(stack = []) {
-    const inStackIndex = stack.findIndex((rt) => {
-      if (rt === this) return true;
-      return rt.src.id && this.src.id && rt.src.id === this.src.id;
-    });
-    stack.findIndex((rt) => rt.src.id && this.src.id && rt.src.id === this.src.id);
-    const isInStack = inStackIndex >= 0;
-    if (isInStack) {
-      this.isCircular = true;
-      const name = this.src.typeName || "";
-      const refId = "$" + this.src.kind + `_${inStackIndex}` + name;
-      return refId;
-    }
-    return void 0;
-  }
-  /**
-   * Method that should be called Immediately after the RunType gets created to link the SrcType and RunType.
-   * This is more flexible than passing params to the constructor helps to avoid circular dependencies, etc.
-   * */
-  onCreated(src) {
-    this.src = src;
-    src._rt = this;
-    initFormatAnnotations(this);
-    createTypeId(src);
-  }
-  /**
-   * Some elements might need a standalone name variable that ignores the vλl value of the parents.
-   * returns a variable that is being compiled, ignores the parents variable names */
-  getCustomVλl(comp) {
-    return void 0;
-  }
-  /**
-   * Some elements might need a custom static path to be able to reference the source of an error.
-   * ie: when validating a Map we need to differentiate if the value that failed is the  key or the value of a map's entry.
-   */
-  getStaticPathLiteral(comp) {
-    return void 0;
-  }
-  // ########## Mock ##########
-  async mock(opts) {
-    await registerJitFunctionCompiler(JitFunctions.mock);
-    return this.mockType(opts);
-  }
-  /** synchronous version of mock, throws an error if the mock function has not been loaded */
-  mockType(opts = {}) {
-    const mockFn = getJitFunctionCompiler(JitFunctions.mock);
-    if (!mockFn)
-      throw new Error(
-        `Function ${JitFunctions.mock.name} has not been loaded. make sure you have called loadJitCompilerFunction(JitFunctions.mock) before calling mockType.`
-      );
-    const fnID = JitFunctions.mock.id;
-    const mockingOpts = { ...opts, mock: { ...defaultMockOptions, ...opts.mock || {} } };
-    const hash = getJITFnHash(fnID, this, mockingOpts);
-    const comp = new MockJitCompiler(this, mockingOpts, void 0, hash, this.getTypeID());
-    return mockFn(this, comp);
-  }
-  // ########## Create Jit Functions ##########
-  createJitFunction = (jitFn, opts = {}) => {
-    return this.createJitCompiledFunction(jitFn.id, void 0, opts).fn;
-  };
-  createJitCompiledFunction(fnID, parentCop, opts = {}) {
-    const fnHash = getJITFnHash(fnID, this, opts);
-    const jitCompiled = getJitUtils().getJIT(fnHash);
-    if (jitCompiled) {
-      if (getENV("DEBUG_JIT") === "VERBOSE")
-        console.log(`\x1B[32m Using cached function: ${jitCompiled.jitFnHash} \x1B[0m`);
-      return jitCompiled;
-    }
-    const newJitCompiler = createJitCompiler(
-      this,
-      fnID,
-      parentCop,
-      void 0,
-      void 0,
-      opts
-    );
-    try {
-      const codeType = this.getFamily() === "A" ? E : S;
-      newJitCompiler.compile(this, codeType, fnID);
-      newJitCompiler.createJitFunction();
-    } catch (e) {
-      newJitCompiler.removeFromJitCache();
-      if (typeof e?.message === "string" && !newJitCompiler.hasStackTrace(e.message))
-        e.message += newJitCompiler.getStackTrace();
-      throw e;
-    }
-    return newJitCompiler;
-  }
-}
-class AtomicRunType extends BaseRunType {
-  getFamily() {
-    return "A";
-  }
-  emitPrepareForJson(comp) {
-    return { code: void 0, type: S };
-  }
-  emitRestoreFromJson(comp) {
-    return { code: void 0, type: S };
-  }
-  emitHasUnknownKeys(comp) {
-    return { code: void 0, type: E };
-  }
-  emitUnknownKeyErrors(comp) {
-    return { code: void 0, type: S };
-  }
-  emitStripUnknownKeys(comp) {
-    return { code: void 0, type: S };
-  }
-  emitUnknownKeysToUndefined(comp) {
-    return { code: void 0, type: S };
-  }
-}
-class CollectionRunType extends BaseRunType {
-  getFamily() {
-    return "C";
-  }
-  getChildRunTypes = () => {
-    const childTypes = this.src.types || [];
-    return childTypes.map((t) => t._rt);
-  };
-  getJitChildren(comp) {
-    let skipIndex = false;
-    return this.getChildRunTypes().filter((c) => {
-      if (c.skipJit(comp)) return false;
-      const isIndex = c.src.kind === ReflectionKind.indexSignature;
-      if (isIndex && skipIndex) return false;
-      if (isIndex) skipIndex = true;
-      return true;
-    });
-  }
-  areAllChildrenOptional(children) {
-    return children.every(
-      (prop) => prop?.isOptional() || prop.src?.optional || prop.src.kind === ReflectionKind.indexSignature
-    );
-  }
-  emitHasUnknownKeys(comp) {
-    const codes = this.getJitChildren(comp).map((c) => comp.compileHasUnknownKeys(c, E).code).filter((code) => !!code);
-    return { code: codes.join(" || "), type: E };
-  }
-  emitUnknownKeyErrors(comp) {
-    const codes = this.getJitChildren(comp).map((c) => comp.compileUnknownKeyErrors(c, S).code).filter((code) => !!code);
-    return { code: codes.join(";"), type: S };
-  }
-  emitStripUnknownKeys(comp) {
-    const codes = this.getJitChildren(comp).map((c) => comp.compileStripUnknownKeys(c, S).code).filter((code) => !!code);
-    return { code: codes.join(";"), type: S };
-  }
-  emitUnknownKeysToUndefined(comp) {
-    const codes = this.getJitChildren(comp).map((c) => comp.compileUnknownKeysToUndefined(c, S).code).filter((code) => !!code);
-    return { code: codes.join(";"), type: S };
-  }
-}
-class MemberRunType extends BaseRunType {
-  /** used to compile json stringify */
-  skipCommas;
-  /** used to compile json stringify */
-  tempChildVλl;
-  getFamily() {
-    return "M";
-  }
-  getMemberType() {
-    const memberType = this.src.type;
-    return memberType._rt;
-  }
-  getChildIndex(comp) {
-    const start = comp?.opts?.paramsSlice?.start;
-    if (start) return getPropIndex(this.src) - start;
-    return getPropIndex(this.src);
-  }
-  getJitChild(comp) {
-    const member = this.getMemberType();
-    if (member.skipJit(comp)) return void 0;
-    return member;
-  }
-  emitHasUnknownKeys(comp) {
-    const child = this.getJitChild(comp);
-    const codeResult = comp.compileHasUnknownKeys(child, E);
-    if (!codeResult?.code) return { code: void 0, type: E };
-    const childName = comp.getChildVλl();
-    const finalCode = this.isOptional() ? `(${childName} !== undefined && ${codeResult.code})` : codeResult.code;
-    return { code: finalCode, type: codeResult.type };
-  }
-  emitUnknownKeyErrors(comp) {
-    const child = this.getJitChild(comp);
-    const codeResult = comp.compileUnknownKeyErrors(child, S);
-    if (!codeResult?.code) return { code: void 0, type: S };
-    const finalCode = this.isOptional() ? `if (${comp.getChildVλl()} !== undefined) {${codeResult.code}}` : codeResult.code;
-    return { code: finalCode, type: codeResult.type };
-  }
-  emitStripUnknownKeys(comp) {
-    const child = this.getJitChild(comp);
-    const codeResult = comp.compileStripUnknownKeys(child, S);
-    if (!codeResult?.code) return { code: void 0, type: S };
-    const finalCode = this.isOptional() ? `if (${comp.getChildVλl()} !== undefined) {${codeResult.code}}` : codeResult.code;
-    return { code: finalCode, type: codeResult.type };
-  }
-  emitUnknownKeysToUndefined(comp) {
-    const child = this.getJitChild(comp);
-    const codeResult = comp.compileUnknownKeysToUndefined(child, S);
-    if (!codeResult?.code) return { code: void 0, type: S };
-    const finalCode = this.isOptional() ? `if (${comp.getChildVλl()} !== undefined) {${codeResult.code}}` : codeResult.code;
-    return { code: finalCode, type: codeResult.type };
-  }
-  visitToBinary(comp) {
-    const child = this.getJitChild(comp);
-    const code = comp.compileToBinary(child, S);
-    if (!code?.code) return { code: void 0, type: S };
-    return this.isOptional() ? { code: `(${comp.getChildVλl()} !== undefined ? ${code.code} : utl.writeBinaryNull())`, type: S } : code;
-  }
-  visitFromBinary(comp) {
-    const child = this.getJitChild(comp);
-    const code = comp.compileFromBinary(child, S);
-    if (!code?.code) return { code: void 0, type: S };
-    return code;
-  }
-}
-export {
-  AtomicRunType,
-  BaseRunType,
-  CollectionRunType,
-  MemberRunType
-};
-//# sourceMappingURL=baseRunTypes.js.map

package/.dist/esm/src/lib/baseRunTypes.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"baseRunTypes.js","sources":["../../../../src/lib/baseRunTypes.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-unused-vars */\n/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\nimport {MAX_STACK_DEPTH, JitCompiledFn, createUniqueHash, getJitUtils, getENV} from '@mionjs/core';\nimport type {\n    RunType,\n    Mutable,\n    RunTypeChildAccessor,\n    JitFnID,\n    SrcType,\n    SrcCollection,\n    CustomVλl,\n    JitFn,\n    JitCode,\n    RunTypeOptions,\n    StrNumber,\n    DeepPartial,\n    RunTypeFamily,\n} from '../types.ts';\nimport type {mockType} from '../mocking/mockType.ts';\nimport {maxStackErrorMessage} from '../constants.ts';\nimport {type CodeType, JitFunctions, CodeTypes} from '../constants.functions.ts';\nimport {ReflectionKind, stringifyType} from '@deepkit/type';\nimport type {TypeIndexSignature, TypeProperty, Type} from '@deepkit/type';\nimport {getPropIndex, memorize} from './utils.ts';\nimport {createJitCompiler, MockJitCompiler} from './jitFnCompiler.ts';\nimport {getJITFnHash} from './createJitFunction.ts';\nimport type {JitFnCompiler, JitErrorsFnCompiler} from './jitFnCompiler.ts';\nimport {type AnyKindName, getReflectionName} from '../constants.kind.ts';\nimport {initFormatAnnotations} from './formats.ts';\nimport {createTypeId} from './typeId.ts';\nimport {getJitFunctionCompiler, registerJitFunctionCompiler} from './jitFnsRegistry.ts';\nimport {defaultMockOptions} from '../mocking/constants.mock.ts';\n\nconst RB = CodeTypes.returnBlock;\nconst S = CodeTypes.statement;\nconst E = CodeTypes.expression;\n\nexport abstract class BaseRunType<T extends Type = Type> implements RunType {\n    isCircular?: boolean;\n    readonly src: SrcType<T> = null as any; // real value will be set after construction by the createRunType function\n    abstract getFamily(): RunTypeFamily; // Atomic, Collection, Member, Function\n    /**\n     * This single functions controls whether or not the code for a type should be inlined into the parent function\n     * or should create a separate jit function for it, add as a dependency and call it.\n     * @returns\n     */\n    isJitInlined = (): boolean => {\n        // if is circular, always create a separate jit function as need to self invoke\n        if (this.isCircular) return false;\n        if (getENV('DEBUG_JIT') === 'INLINED') return true;\n        // all array  are self invoked for isType and are usually repeated type like string[] or number[] so worth deduplicating\n        if (this.src.kind === ReflectionKind.array) return false;\n        // collection with name might be used in different places so worth deduplicating\n        if (this.src.typeName && this.getFamily() === 'C') return false;\n        return true;\n    };\n    getKindName = memorize((): AnyKindName => getReflectionName(this));\n    getTypeName = (): string => this.src.typeName || this.getKindName();\n    stringify = memorize((): string => stringifyType(this.src));\n    skipJit(comp: JitFnCompiler): boolean {\n        return false;\n    }\n    /** Returns the format portion of the type ID (cached in src._formatId), or undefined if no format. */\n    getFormatTypeID(): string | undefined {\n        // _formatId is cached by computeDeepkitFormatID during getDeepkitTypeId call\n        // Empty string means no format, undefined means not computed yet\n        const formatId = (this.src as any)._formatId;\n        return formatId || undefined;\n    }\n    /** Returns the type ID which is cached in src._typeId by getDeepkitTypeId(). Format ID is already included. */\n    getTypeID(): StrNumber {\n        if (this.src._typeId === undefined) {\n            throw new Error(`Missing cached type ID for ${this.getTypeName()}. Ensure getDeepkitTypeId() has been called.`);\n        }\n        return this.src._typeId;\n    }\n    getJitHash(opts: RunTypeOptions): string {\n        const optsCopy = {...opts};\n        // remove mock options as not relevant for jit functionality\n        if (optsCopy.mock) delete optsCopy.mock;\n        return createUniqueHash(this.getTypeID().toString() + JSON.stringify(optsCopy));\n    }\n    getParent = (): BaseRunType | undefined => (this.src.parent as SrcType)?._rt as BaseRunType;\n    checkIsCircularAndGetRefId(stack: RunType[] = []): StrNumber | undefined {\n        const inStackIndex = stack.findIndex((rt) => {\n            if (rt === this) return true;\n            // some nodes seems to be different objects in memory but are the same id, so we check by id as well\n            return rt.src.id && this.src.id && rt.src.id === this.src.id;\n        }); // cant use isSameJitType because it uses getTypeID and would loop forever\n        const inStackSrcId = stack.findIndex((rt) => rt.src.id && this.src.id && rt.src.id === this.src.id);\n        const isInStack = inStackIndex >= 0; // recursive reference\n        if (isInStack) {\n            this.isCircular = true;\n            const name = this.src.typeName || ''; // todo: not sure if all the circular references will have a name\n            const refId = '$' + this.src.kind + `_${inStackIndex}` + name; // ensures different circular types have different typeID\n            return refId;\n        }\n        return undefined;\n    }\n    /**\n     * Method that should be called Immediately after the RunType gets created to link the SrcType and RunType.\n     * This is more flexible than passing params to the constructor helps to avoid circular dependencies, etc.\n     * */\n    onCreated(src: SrcType<any>): void {\n        (this as Mutable<RunType>).src = src;\n        (src as Mutable<SrcType>)._rt = this;\n        initFormatAnnotations(this);\n        // Cache the type ID on the src object - this includes format information\n        createTypeId(src);\n    }\n    /**\n     * Some elements might need a standalone name variable that ignores the vλl value of the parents.\n     * returns a variable that is being compiled, ignores the parents variable names */\n    getCustomVλl(comp: JitFnCompiler): CustomVλl | undefined {\n        return undefined;\n    }\n    /**\n     * Some elements might need a custom static path to be able to reference the source of an error.\n     * ie: when validating a Map we need to differentiate if the value that failed is the  key or the value of a map's entry.\n     */\n    getStaticPathLiteral(comp: JitFnCompiler): string | number | undefined {\n        return undefined;\n    }\n\n    // ########## Mock ##########\n\n    async mock(opts?: DeepPartial<RunTypeOptions>): Promise<any> {\n        // although the mock function is not jit, it is also stored in the registry\n        // this is because we don't want to load mock related functionality if not needed\n        await registerJitFunctionCompiler(JitFunctions.mock);\n        return this.mockType(opts);\n    }\n\n    /** synchronous version of mock, throws an error if the mock function has not been loaded */\n    mockType(opts: DeepPartial<RunTypeOptions> = {}): any {\n        const mockFn = getJitFunctionCompiler(JitFunctions.mock) as typeof mockType;\n        if (!mockFn)\n            throw new Error(\n                `Function ${JitFunctions.mock.name} has not been loaded. make sure you have called loadJitCompilerFunction(JitFunctions.mock) before calling mockType.`\n            );\n        const fnID = JitFunctions.mock.id;\n        // options sent to the compiler will be set to empty as mock options are handled separately from the compiler\n        const mockingOpts = {...opts, mock: {...defaultMockOptions, ...(opts.mock || {})}} as RunTypeOptions;\n        const hash = getJITFnHash(fnID, this, mockingOpts);\n        const comp = new MockJitCompiler(this, mockingOpts, undefined, hash, this.getTypeID());\n        return mockFn(this, comp);\n    }\n\n    // ########## Create Jit Functions ##########\n\n    createJitFunction = (jitFn: JitFn, opts: RunTypeOptions = {}): ((...args: any[]) => any) => {\n        return this.createJitCompiledFunction(jitFn.id, undefined, opts).fn;\n    };\n\n    createJitCompiledFunction(fnID: JitFnID, parentCop?: JitFnCompiler, opts: RunTypeOptions = {}): JitCompiledFn {\n        const fnHash = getJITFnHash(fnID, this, opts);\n        const jitCompiled = getJitUtils().getJIT(fnHash);\n        if (jitCompiled) {\n            if (getENV('DEBUG_JIT') === 'VERBOSE')\n                console.log(`\\x1b[32m Using cached function: ${jitCompiled.jitFnHash} \\x1b[0m`);\n            return jitCompiled;\n        }\n        const newJitCompiler: JitFnCompiler = createJitCompiler(\n            this,\n            fnID,\n            parentCop,\n            undefined,\n            undefined,\n            opts\n        ) as JitFnCompiler;\n        try {\n            const codeType = this.getFamily() === 'A' ? E : S;\n            newJitCompiler.compile(this, codeType, fnID);\n            newJitCompiler.createJitFunction();\n        } catch (e: any) {\n            // if something goes wrong during compilation we want to remove the compiler from\n            // the cache as this is automatically added to jitUtils cache during compilation\n            newJitCompiler.removeFromJitCache();\n            // TODO: we need to print the full path to the type that is causing the error\n            // for this ideally we should add a parent Compiler and print the trace only from the root\n            if (typeof e?.message === 'string' && !newJitCompiler.hasStackTrace(e.message))\n                e.message += newJitCompiler.getStackTrace();\n            throw e;\n        }\n        return newJitCompiler as JitCompiledFn;\n    }\n\n    // ########## emit Methods that generates src code ##########\n\n    abstract emitIsType(comp: JitFnCompiler, expectedCType: CodeType): JitCode;\n    abstract emitTypeErrors(comp: JitErrorsFnCompiler, expectedCType: CodeType): JitCode;\n    abstract emitHasUnknownKeys(comp: JitFnCompiler, expectedCType: CodeType): JitCode;\n    abstract emitUnknownKeyErrors(comp: JitErrorsFnCompiler, expectedCType: CodeType): JitCode;\n    abstract emitStripUnknownKeys(comp: JitFnCompiler, expectedCType: CodeType): JitCode;\n    abstract emitUnknownKeysToUndefined(comp: JitFnCompiler, expectedCType: CodeType): JitCode;\n    // todo: maybe we should move these two into a single file like the rest of serializers\n    abstract emitPrepareForJson(comp: JitFnCompiler, expectedCType: CodeType): JitCode;\n    abstract emitRestoreFromJson(comp: JitFnCompiler, expectedCType: CodeType): JitCode;\n}\n\n/**\n * RunType that is atomic an does not contains any other child runTypes.\n * ie: string, number, boolean, any, null, undefined, void, never, bigint, etc.\n * */\nexport abstract class AtomicRunType<T extends Type> extends BaseRunType<T> {\n    getFamily(): 'A' {\n        return 'A';\n    }\n    emitPrepareForJson(comp: JitFnCompiler): JitCode {\n        return {code: undefined, type: S};\n    }\n    emitRestoreFromJson(comp: JitFnCompiler): JitCode {\n        return {code: undefined, type: S};\n    }\n    emitHasUnknownKeys(comp: JitFnCompiler): JitCode {\n        return {code: undefined, type: E};\n    }\n    emitUnknownKeyErrors(comp: JitFnCompiler): JitCode {\n        return {code: undefined, type: S};\n    }\n    emitStripUnknownKeys(comp: JitFnCompiler): JitCode {\n        return {code: undefined, type: S};\n    }\n    emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode {\n        return {code: undefined, type: S};\n    }\n}\n\n/**\n * RunType that contains a collection or child runTypes.\n * Collection RunTypes are the only ones that can have circular references. as a child of a collection RunType can be the parent of the collection RunType.\n * i.e: interface, child runTypes are it's properties\n * i.e: tuple, it's child runTypes are the tuple members\n */\nexport abstract class CollectionRunType<T extends Type> extends BaseRunType<T> {\n    getFamily(): 'C' {\n        return 'C';\n    }\n    getChildRunTypes = (): BaseRunType[] => {\n        const childTypes = ((this.src as SrcCollection).types as SrcType[]) || []; // deepkit stores child types in the types property\n        return childTypes.map((t) => t._rt as BaseRunType);\n    };\n    getJitChildren(comp: JitFnCompiler): BaseRunType[] {\n        let skipIndex = false; // if there are multiple index signatures, only the first one will be used as they must be same type just different keys\n        return this.getChildRunTypes().filter((c) => {\n            if (c.skipJit(comp)) return false;\n            const isIndex = c.src.kind === ReflectionKind.indexSignature;\n            if (isIndex && skipIndex) return false;\n            if (isIndex) skipIndex = true;\n            return true;\n        });\n    }\n    areAllChildrenOptional(children: BaseRunType[]) {\n        return children.every(\n            (prop) =>\n                (prop as MemberRunType<any>)?.isOptional() ||\n                (prop.src as TypeProperty)?.optional ||\n                prop.src.kind === ReflectionKind.indexSignature\n        );\n    }\n    emitHasUnknownKeys(comp: JitFnCompiler): JitCode {\n        const codes = this.getJitChildren(comp)\n            .map((c) => comp.compileHasUnknownKeys(c, E).code)\n            .filter((code) => !!code);\n        return {code: codes.join(' || '), type: E};\n    }\n    emitUnknownKeyErrors(comp: JitErrorsFnCompiler): JitCode {\n        const codes = this.getJitChildren(comp)\n            .map((c) => comp.compileUnknownKeyErrors(c, S).code)\n            .filter((code) => !!code);\n        return {code: codes.join(';'), type: S};\n    }\n    emitStripUnknownKeys(comp: JitFnCompiler): JitCode {\n        const codes = this.getJitChildren(comp)\n            .map((c) => comp.compileStripUnknownKeys(c, S).code)\n            .filter((code) => !!code);\n        return {code: codes.join(';'), type: S};\n    }\n    emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode {\n        const codes = this.getJitChildren(comp)\n            .map((c) => comp.compileUnknownKeysToUndefined(c, S).code)\n            .filter((code) => !!code);\n        return {code: codes.join(';'), type: S};\n    }\n}\n\n/**\n * RunType that contains a single member or child RunType. usually part of a collection RunType.\n * i.e object properties, {prop: memberType} where memberType is the child RunType\n */\nexport abstract class MemberRunType<T extends Type> extends BaseRunType<T> implements RunTypeChildAccessor {\n    abstract isOptional(): boolean;\n    abstract getChildVarName(comp: JitFnCompiler): string | number;\n    abstract getChildLiteral(comp: JitFnCompiler): string | number;\n    abstract useArrayAccessor(): boolean;\n    /** used to compile json stringify */\n    skipCommas?: boolean;\n    /** used to compile json stringify */\n    tempChildVλl?: string;\n    getFamily(): 'M' {\n        return 'M';\n    }\n    getMemberType(): BaseRunType {\n        const memberType = (this.src as any).type as SrcType; // deepkit stores member types in the type property\n        return memberType._rt as BaseRunType;\n    }\n    getChildIndex(comp: JitFnCompiler) {\n        const start = comp?.opts?.paramsSlice?.start;\n        if (start) return getPropIndex(this.src) - start;\n        return getPropIndex(this.src);\n    }\n    getJitChild(comp: JitFnCompiler): BaseRunType | undefined {\n        const member: BaseRunType = this.getMemberType();\n        if (member.skipJit(comp)) return undefined;\n        return member;\n    }\n    emitHasUnknownKeys(comp: JitFnCompiler): JitCode {\n        const child = this.getJitChild(comp);\n        const codeResult = comp.compileHasUnknownKeys(child, E);\n        if (!codeResult?.code) return {code: undefined, type: E};\n        const childName = comp.getChildVλl();\n        const finalCode = this.isOptional() ? `(${childName} !== undefined && ${codeResult.code})` : codeResult.code;\n        return {code: finalCode, type: codeResult.type};\n    }\n    emitUnknownKeyErrors(comp: JitErrorsFnCompiler): JitCode {\n        const child = this.getJitChild(comp);\n        const codeResult = comp.compileUnknownKeyErrors(child, S);\n        if (!codeResult?.code) return {code: undefined, type: S};\n        const finalCode = this.isOptional() ? `if (${comp.getChildVλl()} !== undefined) {${codeResult.code}}` : codeResult.code;\n        return {code: finalCode, type: codeResult.type};\n    }\n    emitStripUnknownKeys(comp: JitFnCompiler): JitCode {\n        const child = this.getJitChild(comp);\n        const codeResult = comp.compileStripUnknownKeys(child, S);\n        if (!codeResult?.code) return {code: undefined, type: S};\n        const finalCode = this.isOptional() ? `if (${comp.getChildVλl()} !== undefined) {${codeResult.code}}` : codeResult.code;\n        return {code: finalCode, type: codeResult.type};\n    }\n    emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode {\n        const child = this.getJitChild(comp);\n        const codeResult = comp.compileUnknownKeysToUndefined(child, S);\n        if (!codeResult?.code) return {code: undefined, type: S};\n        const finalCode = this.isOptional() ? `if (${comp.getChildVλl()} !== undefined) {${codeResult.code}}` : codeResult.code;\n        return {code: finalCode, type: codeResult.type};\n    }\n    visitToBinary(comp: JitFnCompiler): JitCode {\n        const child = this.getJitChild(comp);\n        const code = comp.compileToBinary(child, S);\n        if (!code?.code) return {code: undefined, type: S};\n        return this.isOptional()\n            ? {code: `(${comp.getChildVλl()} !== undefined ? ${code.code} : utl.writeBinaryNull())`, type: S}\n            : code;\n    }\n    visitFromBinary(comp: JitFnCompiler): JitCode {\n        const child = this.getJitChild(comp);\n        const code = comp.compileFromBinary(child, S);\n        if (!code?.code) return {code: undefined, type: S};\n        return code;\n    }\n}\n\n// ########## Load Composable Functions ##########\n"],"names":[],"mappings":";;;;;;;;;;;AAsCW,UAAU;AACrB,MAAM,IAAI,UAAU;AACpB,MAAM,IAAI,UAAU;AAEb,MAAe,YAAsD;AAAA,EACxE;AAAA,EACS,MAAkB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAO3B,eAAe,MAAe;AAE1B,QAAI,KAAK,WAAY,QAAO;AAC5B,QAAI,OAAO,WAAW,MAAM,UAAW,QAAO;AAE9C,QAAI,KAAK,IAAI,SAAS,eAAe,MAAO,QAAO;AAEnD,QAAI,KAAK,IAAI,YAAY,KAAK,UAAA,MAAgB,IAAK,QAAO;AAC1D,WAAO;AAAA,EACX;AAAA,EACA,cAAc,SAAS,MAAmB,kBAAkB,IAAI,CAAC;AAAA,EACjE,cAAc,MAAc,KAAK,IAAI,YAAY,KAAK,YAAA;AAAA,EACtD,YAAY,SAAS,MAAc,cAAc,KAAK,GAAG,CAAC;AAAA,EAC1D,QAAQ,MAA8B;AAClC,WAAO;AAAA,EACX;AAAA;AAAA,EAEA,kBAAsC;AAGlC,UAAM,WAAY,KAAK,IAAY;AACnC,WAAO,YAAY;AAAA,EACvB;AAAA;AAAA,EAEA,YAAuB;AACnB,QAAI,KAAK,IAAI,YAAY,QAAW;AAChC,YAAM,IAAI,MAAM,8BAA8B,KAAK,YAAA,CAAa,8CAA8C;AAAA,IAClH;AACA,WAAO,KAAK,IAAI;AAAA,EACpB;AAAA,EACA,WAAW,MAA8B;AACrC,UAAM,WAAW,EAAC,GAAG,KAAA;AAErB,QAAI,SAAS,KAAM,QAAO,SAAS;AACnC,WAAO,iBAAiB,KAAK,UAAA,EAAY,aAAa,KAAK,UAAU,QAAQ,CAAC;AAAA,EAClF;AAAA,EACA,YAAY,MAAgC,KAAK,IAAI,QAAoB;AAAA,EACzE,2BAA2B,QAAmB,IAA2B;AACrE,UAAM,eAAe,MAAM,UAAU,CAAC,OAAO;AACzC,UAAI,OAAO,KAAM,QAAO;AAExB,aAAO,GAAG,IAAI,MAAM,KAAK,IAAI,MAAM,GAAG,IAAI,OAAO,KAAK,IAAI;AAAA,IAC9D,CAAC;AACoB,UAAM,UAAU,CAAC,OAAO,GAAG,IAAI,MAAM,KAAK,IAAI,MAAM,GAAG,IAAI,OAAO,KAAK,IAAI,EAAE;AAClG,UAAM,YAAY,gBAAgB;AAClC,QAAI,WAAW;AACX,WAAK,aAAa;AAClB,YAAM,OAAO,KAAK,IAAI,YAAY;AAClC,YAAM,QAAQ,MAAM,KAAK,IAAI,OAAO,IAAI,YAAY,KAAK;AACzD,aAAO;AAAA,IACX;AACA,WAAO;AAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA,UAAU,KAAyB;AAC9B,SAA0B,MAAM;AAChC,QAAyB,MAAM;AAChC,0BAAsB,IAAI;AAE1B,iBAAa,GAAG;AAAA,EACpB;AAAA;AAAA;AAAA;AAAA,EAIA,aAAa,MAA4C;AACrD,WAAO;AAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA,qBAAqB,MAAkD;AACnE,WAAO;AAAA,EACX;AAAA;AAAA,EAIA,MAAM,KAAK,MAAkD;AAGzD,UAAM,4BAA4B,aAAa,IAAI;AACnD,WAAO,KAAK,SAAS,IAAI;AAAA,EAC7B;AAAA;AAAA,EAGA,SAAS,OAAoC,IAAS;AAClD,UAAM,SAAS,uBAAuB,aAAa,IAAI;AACvD,QAAI,CAAC;AACD,YAAM,IAAI;AAAA,QACN,YAAY,aAAa,KAAK,IAAI;AAAA,MAAA;AAE1C,UAAM,OAAO,aAAa,KAAK;AAE/B,UAAM,cAAc,EAAC,GAAG,MAAM,MAAM,EAAC,GAAG,oBAAoB,GAAI,KAAK,QAAQ,CAAA,IAAG;AAChF,UAAM,OAAO,aAAa,MAAM,MAAM,WAAW;AACjD,UAAM,OAAO,IAAI,gBAAgB,MAAM,aAAa,QAAW,MAAM,KAAK,WAAW;AACrF,WAAO,OAAO,MAAM,IAAI;AAAA,EAC5B;AAAA;AAAA,EAIA,oBAAoB,CAAC,OAAc,OAAuB,OAAkC;AACxF,WAAO,KAAK,0BAA0B,MAAM,IAAI,QAAW,IAAI,EAAE;AAAA,EACrE;AAAA,EAEA,0BAA0B,MAAe,WAA2B,OAAuB,CAAA,GAAmB;AAC1G,UAAM,SAAS,aAAa,MAAM,MAAM,IAAI;AAC5C,UAAM,cAAc,cAAc,OAAO,MAAM;AAC/C,QAAI,aAAa;AACb,UAAI,OAAO,WAAW,MAAM;AACxB,gBAAQ,IAAI,mCAAmC,YAAY,SAAS,UAAU;AAClF,aAAO;AAAA,IACX;AACA,UAAM,iBAAgC;AAAA,MAClC;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IAAA;AAEJ,QAAI;AACA,YAAM,WAAW,KAAK,UAAA,MAAgB,MAAM,IAAI;AAChD,qBAAe,QAAQ,MAAM,UAAU,IAAI;AAC3C,qBAAe,kBAAA;AAAA,IACnB,SAAS,GAAQ;AAGb,qBAAe,mBAAA;AAGf,UAAI,OAAO,GAAG,YAAY,YAAY,CAAC,eAAe,cAAc,EAAE,OAAO;AACzE,UAAE,WAAW,eAAe,cAAA;AAChC,YAAM;AAAA,IACV;AACA,WAAO;AAAA,EACX;AAaJ;AAMO,MAAe,sBAAsC,YAAe;AAAA,EACvE,YAAiB;AACb,WAAO;AAAA,EACX;AAAA,EACA,mBAAmB,MAA8B;AAC7C,WAAO,EAAC,MAAM,QAAW,MAAM,EAAA;AAAA,EACnC;AAAA,EACA,oBAAoB,MAA8B;AAC9C,WAAO,EAAC,MAAM,QAAW,MAAM,EAAA;AAAA,EACnC;AAAA,EACA,mBAAmB,MAA8B;AAC7C,WAAO,EAAC,MAAM,QAAW,MAAM,EAAA;AAAA,EACnC;AAAA,EACA,qBAAqB,MAA8B;AAC/C,WAAO,EAAC,MAAM,QAAW,MAAM,EAAA;AAAA,EACnC;AAAA,EACA,qBAAqB,MAA8B;AAC/C,WAAO,EAAC,MAAM,QAAW,MAAM,EAAA;AAAA,EACnC;AAAA,EACA,2BAA2B,MAA8B;AACrD,WAAO,EAAC,MAAM,QAAW,MAAM,EAAA;AAAA,EACnC;AACJ;AAQO,MAAe,0BAA0C,YAAe;AAAA,EAC3E,YAAiB;AACb,WAAO;AAAA,EACX;AAAA,EACA,mBAAmB,MAAqB;AACpC,UAAM,aAAe,KAAK,IAAsB,SAAuB,CAAA;AACvE,WAAO,WAAW,IAAI,CAAC,MAAM,EAAE,GAAkB;AAAA,EACrD;AAAA,EACA,eAAe,MAAoC;AAC/C,QAAI,YAAY;AAChB,WAAO,KAAK,iBAAA,EAAmB,OAAO,CAAC,MAAM;AACzC,UAAI,EAAE,QAAQ,IAAI,EAAG,QAAO;AAC5B,YAAM,UAAU,EAAE,IAAI,SAAS,eAAe;AAC9C,UAAI,WAAW,UAAW,QAAO;AACjC,UAAI,QAAS,aAAY;AACzB,aAAO;AAAA,IACX,CAAC;AAAA,EACL;AAAA,EACA,uBAAuB,UAAyB;AAC5C,WAAO,SAAS;AAAA,MACZ,CAAC,SACI,MAA6B,WAAA,KAC7B,KAAK,KAAsB,YAC5B,KAAK,IAAI,SAAS,eAAe;AAAA,IAAA;AAAA,EAE7C;AAAA,EACA,mBAAmB,MAA8B;AAC7C,UAAM,QAAQ,KAAK,eAAe,IAAI,EACjC,IAAI,CAAC,MAAM,KAAK,sBAAsB,GAAG,CAAC,EAAE,IAAI,EAChD,OAAO,CAAC,SAAS,CAAC,CAAC,IAAI;AAC5B,WAAO,EAAC,MAAM,MAAM,KAAK,MAAM,GAAG,MAAM,EAAA;AAAA,EAC5C;AAAA,EACA,qBAAqB,MAAoC;AACrD,UAAM,QAAQ,KAAK,eAAe,IAAI,EACjC,IAAI,CAAC,MAAM,KAAK,wBAAwB,GAAG,CAAC,EAAE,IAAI,EAClD,OAAO,CAAC,SAAS,CAAC,CAAC,IAAI;AAC5B,WAAO,EAAC,MAAM,MAAM,KAAK,GAAG,GAAG,MAAM,EAAA;AAAA,EACzC;AAAA,EACA,qBAAqB,MAA8B;AAC/C,UAAM,QAAQ,KAAK,eAAe,IAAI,EACjC,IAAI,CAAC,MAAM,KAAK,wBAAwB,GAAG,CAAC,EAAE,IAAI,EAClD,OAAO,CAAC,SAAS,CAAC,CAAC,IAAI;AAC5B,WAAO,EAAC,MAAM,MAAM,KAAK,GAAG,GAAG,MAAM,EAAA;AAAA,EACzC;AAAA,EACA,2BAA2B,MAA8B;AACrD,UAAM,QAAQ,KAAK,eAAe,IAAI,EACjC,IAAI,CAAC,MAAM,KAAK,8BAA8B,GAAG,CAAC,EAAE,IAAI,EACxD,OAAO,CAAC,SAAS,CAAC,CAAC,IAAI;AAC5B,WAAO,EAAC,MAAM,MAAM,KAAK,GAAG,GAAG,MAAM,EAAA;AAAA,EACzC;AACJ;AAMO,MAAe,sBAAsC,YAA+C;AAAA;AAAA,EAMvG;AAAA;AAAA,EAEA;AAAA,EACA,YAAiB;AACb,WAAO;AAAA,EACX;AAAA,EACA,gBAA6B;AACzB,UAAM,aAAc,KAAK,IAAY;AACrC,WAAO,WAAW;AAAA,EACtB;AAAA,EACA,cAAc,MAAqB;AAC/B,UAAM,QAAQ,MAAM,MAAM,aAAa;AACvC,QAAI,MAAO,QAAO,aAAa,KAAK,GAAG,IAAI;AAC3C,WAAO,aAAa,KAAK,GAAG;AAAA,EAChC;AAAA,EACA,YAAY,MAA8C;AACtD,UAAM,SAAsB,KAAK,cAAA;AACjC,QAAI,OAAO,QAAQ,IAAI,EAAG,QAAO;AACjC,WAAO;AAAA,EACX;AAAA,EACA,mBAAmB,MAA8B;AAC7C,UAAM,QAAQ,KAAK,YAAY,IAAI;AACnC,UAAM,aAAa,KAAK,sBAAsB,OAAO,CAAC;AACtD,QAAI,CAAC,YAAY,KAAM,QAAO,EAAC,MAAM,QAAW,MAAM,EAAA;AACtD,UAAM,YAAY,KAAK,YAAA;AACvB,UAAM,YAAY,KAAK,WAAA,IAAe,IAAI,SAAS,qBAAqB,WAAW,IAAI,MAAM,WAAW;AACxG,WAAO,EAAC,MAAM,WAAW,MAAM,WAAW,KAAA;AAAA,EAC9C;AAAA,EACA,qBAAqB,MAAoC;AACrD,UAAM,QAAQ,KAAK,YAAY,IAAI;AACnC,UAAM,aAAa,KAAK,wBAAwB,OAAO,CAAC;AACxD,QAAI,CAAC,YAAY,KAAM,QAAO,EAAC,MAAM,QAAW,MAAM,EAAA;AACtD,UAAM,YAAY,KAAK,WAAA,IAAe,OAAO,KAAK,YAAA,CAAa,oBAAoB,WAAW,IAAI,MAAM,WAAW;AACnH,WAAO,EAAC,MAAM,WAAW,MAAM,WAAW,KAAA;AAAA,EAC9C;AAAA,EACA,qBAAqB,MAA8B;AAC/C,UAAM,QAAQ,KAAK,YAAY,IAAI;AACnC,UAAM,aAAa,KAAK,wBAAwB,OAAO,CAAC;AACxD,QAAI,CAAC,YAAY,KAAM,QAAO,EAAC,MAAM,QAAW,MAAM,EAAA;AACtD,UAAM,YAAY,KAAK,WAAA,IAAe,OAAO,KAAK,YAAA,CAAa,oBAAoB,WAAW,IAAI,MAAM,WAAW;AACnH,WAAO,EAAC,MAAM,WAAW,MAAM,WAAW,KAAA;AAAA,EAC9C;AAAA,EACA,2BAA2B,MAA8B;AACrD,UAAM,QAAQ,KAAK,YAAY,IAAI;AACnC,UAAM,aAAa,KAAK,8BAA8B,OAAO,CAAC;AAC9D,QAAI,CAAC,YAAY,KAAM,QAAO,EAAC,MAAM,QAAW,MAAM,EAAA;AACtD,UAAM,YAAY,KAAK,WAAA,IAAe,OAAO,KAAK,YAAA,CAAa,oBAAoB,WAAW,IAAI,MAAM,WAAW;AACnH,WAAO,EAAC,MAAM,WAAW,MAAM,WAAW,KAAA;AAAA,EAC9C;AAAA,EACA,cAAc,MAA8B;AACxC,UAAM,QAAQ,KAAK,YAAY,IAAI;AACnC,UAAM,OAAO,KAAK,gBAAgB,OAAO,CAAC;AAC1C,QAAI,CAAC,MAAM,KAAM,QAAO,EAAC,MAAM,QAAW,MAAM,EAAA;AAChD,WAAO,KAAK,WAAA,IACN,EAAC,MAAM,IAAI,KAAK,YAAA,CAAa,oBAAoB,KAAK,IAAI,6BAA6B,MAAM,MAC7F;AAAA,EACV;AAAA,EACA,gBAAgB,MAA8B;AAC1C,UAAM,QAAQ,KAAK,YAAY,IAAI;AACnC,UAAM,OAAO,KAAK,kBAAkB,OAAO,CAAC;AAC5C,QAAI,CAAC,MAAM,KAAM,QAAO,EAAC,MAAM,QAAW,MAAM,EAAA;AAChD,WAAO;AAAA,EACX;AACJ;"}

package/.dist/esm/src/lib/createJitFunction.d.ts

@@ -1,6 +0,0 @@
-import { JitFnID, RunTypeOptions } from '../types.ts';
-import { BaseFnCompiler } from './jitFnCompiler.ts';
-import { BaseRunType } from './baseRunTypes.ts';
-export declare function getJITFnHash(id: JitFnID, rt: BaseRunType, opts?: RunTypeOptions): string;
-export declare function createJitFunction(comp: BaseFnCompiler): (...args: any[]) => any;
-//# sourceMappingURL=createJitFunction.d.ts.map

package/.dist/esm/src/lib/createJitFunction.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createJitFunction.d.ts","sourceRoot":"","sources":["../../../../src/lib/createJitFunction.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,OAAO,EAAW,cAAc,EAAC,MAAM,aAAa,CAAC;AAClE,OAAO,EAAC,cAAc,EAAgC,MAAM,oBAAoB,CAAC;AACjF,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,mBAAmB,CAAC;AAUnD,wBAAgB,YAAY,CAAC,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,WAAW,EAAE,IAAI,CAAC,EAAE,cAAc,GAAG,MAAM,CAGxF;AAQD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,cAAc,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAU/E"}

package/.dist/esm/src/lib/createJitFunction.js

@@ -1,60 +0,0 @@
-import { getJitUtils, getENV } from "@mionjs/core";
-import { printClosure } from "./jitFnCompiler.js";
-import { getJITFnName } from "./jitFnsRegistry.js";
-function getJITFnHash(id, rt, opts) {
-  if (opts) return `${id}_${rt.getJitHash(opts)}`;
-  return `${id}_${rt.getJitHash({})}`;
-}
-function createJitFunction(comp) {
-  if (comp.fn) return comp.fn;
-  if (comp.stack.length !== 0) throw new Error("Can not get compiled function before the compile operation is finished");
-  if (getJitUtils().hasJitFn(comp.jitFnHash)) return getJitUtils().getJitFn(comp.jitFnHash);
-  const { fnCode, fnName, contextCode } = getJitFnCode(comp);
-  const { createJitFn, fn, code } = createJitFnWithContext(comp, fnName, fnCode, contextCode);
-  comp.code = code;
-  comp.fn = fn;
-  comp.createJitFn = createJitFn;
-  return fn;
-}
-function createJitFnWithContext(comp, fnName, fnCode, contextCode) {
-  const context = contextCode ? `${contextCode};` : "";
-  let fnWithContext = `'use strict'; ${context} return ${fnCode}`;
-  if (getENV("DEBUG_RUN_TIME")) {
-    const fnArgs = getJitFnArgs(comp);
-    const argsCall = getJitFnArgs(comp, false);
-    const debugWrapper = `function debug_${fnName}(${fnArgs}){
-            const resp = ${fnName}(${argsCall});
-            console.log('${fnName} ${getJITFnName(comp.fnID)} ${comp.rootType.getTypeName()}', 'result:', resp, ' value:', ${argsCall});
-            return resp;
-        }`;
-    fnWithContext = `'use strict'; ${context} ${fnCode} ${debugWrapper} return debug_${fnName};`;
-  }
-  try {
-    const wrapperWithContext = new Function("utl", fnWithContext);
-    if (getENV("DEBUG_JIT")) console.log(printClosure(fnWithContext, fnName));
-    return { createJitFn: wrapperWithContext, fn: wrapperWithContext(getJitUtils()), code: fnWithContext };
-  } catch (e) {
-    if (getENV("DEBUG_JIT")) {
-      console.warn("Error creating jit function with context code:\n", printClosure(fnWithContext, fnName));
-    }
-    throw e;
-  }
-}
-function getJitFnCode(comp) {
-  const fnName = comp.jitFnHash;
-  const fnArgs = getJitFnArgs(comp);
-  const fnCode = `function ${fnName}(${fnArgs}){${comp.code}}`;
-  return { fnName, fnCode, contextCode: comp.getContextItemValues().join(";\n") };
-}
-function getJitFnArgs(comp, defaultValues = true) {
-  return Object.entries(comp.args).map(([key, name]) => {
-    if (!comp.defaultParamValues[key] || !defaultValues) return name;
-    const value = comp.defaultParamValues[key];
-    return `${name}=${value}`;
-  }).join(",");
-}
-export {
-  createJitFunction,
-  getJITFnHash
-};
-//# sourceMappingURL=createJitFunction.js.map

package/.dist/esm/src/lib/createJitFunction.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createJitFunction.js","sources":["../../../../src/lib/createJitFunction.ts"],"sourcesContent":["import {getENV, getJitUtils, type JITUtils} from '@mionjs/core';\nimport type {JitFnID, Mutable, RunTypeOptions} from '../types.ts';\nimport {BaseFnCompiler, JitCompilerLike, printClosure} from './jitFnCompiler.ts';\nimport type {BaseRunType} from './baseRunTypes.ts';\nimport {getJITFnName} from './jitFnsRegistry.ts';\n\n/**\n * Creates a function name/hash based on the jitHash of the runType and the id of the function.\n * it is a valid js variable name.\n * @param id\n * @param rt\n * @returns\n */\nexport function getJITFnHash(id: JitFnID, rt: BaseRunType, opts?: RunTypeOptions): string {\n    if (opts) return `${id}_${rt.getJitHash(opts)}`;\n    return `${id}_${rt.getJitHash({})}`;\n}\n\n/**\n * Creates a jit function from a compiler.\n * This function handles the logic to determine if the function should be created or retrieved from the cache.\n * @param comp\n * @returns\n */\nexport function createJitFunction(comp: BaseFnCompiler): (...args: any[]) => any {\n    if (comp.fn) return comp.fn;\n    if (comp.stack.length !== 0) throw new Error('Can not get compiled function before the compile operation is finished');\n    if (getJitUtils().hasJitFn(comp.jitFnHash)) return getJitUtils().getJitFn(comp.jitFnHash);\n    const {fnCode, fnName, contextCode} = getJitFnCode(comp);\n    const {createJitFn, fn, code} = createJitFnWithContext(comp, fnName, fnCode, contextCode);\n    (comp as Mutable<BaseFnCompiler>).code = code;\n    (comp as Mutable<BaseFnCompiler>).fn = fn;\n    (comp as Mutable<BaseFnCompiler>).createJitFn = createJitFn;\n    return fn;\n}\n\n/**\n * Create a JIT function that has jitUtils (and possibly other required variables) in the context,\n * This way jitUtils ca be used without passing them as arguments to every atomic jit function (kind of global variables).\n * @param varName\n * @param fnCode\n * @returns\n */\nfunction createJitFnWithContext(comp: BaseFnCompiler, fnName: string, fnCode: string, contextCode?: string) {\n    // this function will have jitUtils as context as is an argument of the enclosing function\n    const context = contextCode ? `${contextCode};` : '';\n    let fnWithContext = `'use strict'; ${context} return ${fnCode}`;\n    if (getENV('DEBUG_RUN_TIME')) {\n        const fnArgs = getJitFnArgs(comp);\n        const argsCall = getJitFnArgs(comp, false);\n        const debugWrapper = `function debug_${fnName}(${fnArgs}){\n            const resp = ${fnName}(${argsCall});\n            console.log('${fnName} ${getJITFnName(comp.fnID)} ${comp.rootType.getTypeName()}', 'result:', resp, ' value:', ${argsCall});\n            return resp;\n        }`;\n        fnWithContext = `'use strict'; ${context} ${fnCode} ${debugWrapper} return debug_${fnName};`;\n    }\n    try {\n        // wrapper functions that works as a factory and returns the actual jit function, context contains all constants and heavy to create objects\n        const wrapperWithContext = new Function('utl', fnWithContext) as (utl: JITUtils) => (...args: any[]) => any;\n        if (getENV('DEBUG_JIT')) console.log(printClosure(fnWithContext, fnName));\n        return {createJitFn: wrapperWithContext, fn: wrapperWithContext(getJitUtils()), code: fnWithContext}; // returns the jit internal function with the context\n    } catch (e: any) {\n        if (getENV('DEBUG_JIT')) {\n            console.warn('Error creating jit function with context code:\\n', printClosure(fnWithContext, fnName));\n        }\n        throw e;\n    }\n}\n\nfunction getJitFnCode(comp: BaseFnCompiler): {fnName: string; fnCode: string; contextCode: string} {\n    const fnName = comp.jitFnHash;\n    const fnArgs = getJitFnArgs(comp); // function arguments with default values ie: 'vλl, pλth=[], εrr=[]'\n    const fnCode = `function ${fnName}(${fnArgs}){${comp.code}}`;\n    return {fnName, fnCode, contextCode: comp.getContextItemValues().join(';\\n')};\n}\n\n/** Returns the arguments of the function with default values */\nfunction getJitFnArgs(comp: JitCompilerLike, defaultValues = true): string {\n    return Object.entries(comp.args)\n        .map(([key, name]) => {\n            if (!comp.defaultParamValues[key] || !defaultValues) return name;\n            const value = comp.defaultParamValues[key];\n            return `${name}=${value}`;\n        })\n        .join(',');\n}\n"],"names":[],"mappings":";;;AAaO,SAAS,aAAa,IAAa,IAAiB,MAA+B;AACtF,MAAI,aAAa,GAAG,EAAE,IAAI,GAAG,WAAW,IAAI,CAAC;AAC7C,SAAO,GAAG,EAAE,IAAI,GAAG,WAAW,CAAA,CAAE,CAAC;AACrC;AAQO,SAAS,kBAAkB,MAA+C;AAC7E,MAAI,KAAK,GAAI,QAAO,KAAK;AACzB,MAAI,KAAK,MAAM,WAAW,EAAG,OAAM,IAAI,MAAM,wEAAwE;AACrH,MAAI,YAAA,EAAc,SAAS,KAAK,SAAS,EAAG,QAAO,cAAc,SAAS,KAAK,SAAS;AACxF,QAAM,EAAC,QAAQ,QAAQ,YAAA,IAAe,aAAa,IAAI;AACvD,QAAM,EAAC,aAAa,IAAI,KAAA,IAAQ,uBAAuB,MAAM,QAAQ,QAAQ,WAAW;AACvF,OAAiC,OAAO;AACxC,OAAiC,KAAK;AACtC,OAAiC,cAAc;AAChD,SAAO;AACX;AASA,SAAS,uBAAuB,MAAsB,QAAgB,QAAgB,aAAsB;AAExG,QAAM,UAAU,cAAc,GAAG,WAAW,MAAM;AAClD,MAAI,gBAAgB,iBAAiB,OAAO,WAAW,MAAM;AAC7D,MAAI,OAAO,gBAAgB,GAAG;AAC1B,UAAM,SAAS,aAAa,IAAI;AAChC,UAAM,WAAW,aAAa,MAAM,KAAK;AACzC,UAAM,eAAe,kBAAkB,MAAM,IAAI,MAAM;AAAA,2BACpC,MAAM,IAAI,QAAQ;AAAA,2BAClB,MAAM,IAAI,aAAa,KAAK,IAAI,CAAC,IAAI,KAAK,SAAS,aAAa,kCAAkC,QAAQ;AAAA;AAAA;AAG7H,oBAAgB,iBAAiB,OAAO,IAAI,MAAM,IAAI,YAAY,iBAAiB,MAAM;AAAA,EAC7F;AACA,MAAI;AAEA,UAAM,qBAAqB,IAAI,SAAS,OAAO,aAAa;AAC5D,QAAI,OAAO,WAAW,EAAG,SAAQ,IAAI,aAAa,eAAe,MAAM,CAAC;AACxE,WAAO,EAAC,aAAa,oBAAoB,IAAI,mBAAmB,YAAA,CAAa,GAAG,MAAM,cAAA;AAAA,EAC1F,SAAS,GAAQ;AACb,QAAI,OAAO,WAAW,GAAG;AACrB,cAAQ,KAAK,oDAAoD,aAAa,eAAe,MAAM,CAAC;AAAA,IACxG;AACA,UAAM;AAAA,EACV;AACJ;AAEA,SAAS,aAAa,MAA6E;AAC/F,QAAM,SAAS,KAAK;AACpB,QAAM,SAAS,aAAa,IAAI;AAChC,QAAM,SAAS,YAAY,MAAM,IAAI,MAAM,KAAK,KAAK,IAAI;AACzD,SAAO,EAAC,QAAQ,QAAQ,aAAa,KAAK,qBAAA,EAAuB,KAAK,KAAK,EAAA;AAC/E;AAGA,SAAS,aAAa,MAAuB,gBAAgB,MAAc;AACvE,SAAO,OAAO,QAAQ,KAAK,IAAI,EAC1B,IAAI,CAAC,CAAC,KAAK,IAAI,MAAM;AAClB,QAAI,CAAC,KAAK,mBAAmB,GAAG,KAAK,CAAC,cAAe,QAAO;AAC5D,UAAM,QAAQ,KAAK,mBAAmB,GAAG;AACzC,WAAO,GAAG,IAAI,IAAI,KAAK;AAAA,EAC3B,CAAC,EACA,KAAK,GAAG;AACjB;"}

package/.dist/esm/src/lib/dkProxy.d.ts

@@ -1,5 +0,0 @@
-import { RunType, RunTypeAnnotation } from '../types.ts';
-export declare function getRunTypeAnnotations(rt: RunType): RunTypeAnnotation[];
-export declare function getParsedAnnotationOptions(rt: RunType): any[];
-export declare function getTypeToObject(rt: RunType): any;
-//# sourceMappingURL=dkProxy.d.ts.map

package/.dist/esm/src/lib/dkProxy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dkProxy.d.ts","sourceRoot":"","sources":["../../../../src/lib/dkProxy.ts"],"names":[],"mappings":"AAQA,OAAO,EAAC,OAAO,EAAE,iBAAiB,EAAU,MAAM,aAAa,CAAC;AAUhE,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,OAAO,GAAG,iBAAiB,EAAE,CAStE;AAUD,wBAAgB,0BAA0B,CAAC,EAAE,EAAE,OAAO,GAAG,GAAG,EAAE,CAE7D;AAKD,wBAAgB,eAAe,CAAC,EAAE,EAAE,OAAO,GAAG,GAAG,CAEhD"}

package/.dist/esm/src/lib/dkProxy.js

@@ -1,23 +0,0 @@
-import { typeAnnotation, typeToObject } from "@deepkit/type";
-function getRunTypeAnnotations(rt) {
-  const annotations = typeAnnotation.getAnnotations(rt.src);
-  return annotations.map((a) => {
-    const annotation = {
-      name: a.name,
-      options: a.options._rt
-    };
-    return annotation;
-  });
-}
-function getParsedAnnotationOptions(rt) {
-  return getRunTypeAnnotations(rt).map((a) => typeAnnotation.getOption(rt.src, a.name));
-}
-function getTypeToObject(rt) {
-  return typeToObject(rt.src);
-}
-export {
-  getParsedAnnotationOptions,
-  getRunTypeAnnotations,
-  getTypeToObject
-};
-//# sourceMappingURL=dkProxy.js.map

package/.dist/esm/src/lib/dkProxy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"dkProxy.js","sources":["../../../../src/lib/dkProxy.ts"],"sourcesContent":["/* ########\n * 2025 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {typeAnnotation, typeToObject} from '@deepkit/type';\nimport {RunType, RunTypeAnnotation, SrcType} from '../types.ts';\n\n/**\n * Returns RunType annotations, ie:\n *\n * type WithSuffix<Suffix extends string> = string & TypeAnnotation<'suffix', Suffix>;\n * const rt = runType<WithSuffix<'hello'>>();\n * const annotations = rt.getRunTypeAnnotations();\n * annotations = [{name: 'suffix', options: LiteralRunType<'hello'>}];\n */\nexport function getRunTypeAnnotations(rt: RunType): RunTypeAnnotation[] {\n    const annotations = typeAnnotation.getAnnotations(rt.src);\n    return annotations.map((a) => {\n        const annotation: RunTypeAnnotation = {\n            name: a.name,\n            options: (a.options as SrcType)._rt as RunType,\n        };\n        return annotation;\n    });\n}\n\n/**\n * Returns the options of the annotations parsed js data, ie:\n *\n * type WithSuffix<Suffix extends string> = string & TypeAnnotation<'suffix', Suffix>;\n * const rt = runType<WithSuffix<'hello'>>();\n * const parsedOptions = rt.getParsedAnnotationOptions();\n * parsedOptions = 'hello';\n */\nexport function getParsedAnnotationOptions(rt: RunType): any[] {\n    return getRunTypeAnnotations(rt).map((a) => typeAnnotation.getOption(rt.src, a.name));\n}\n\n/**\n * Returns the deepkit type as a js object, this is useful to extract metadata from the type.\n */\nexport function getTypeToObject(rt: RunType): any {\n    return typeToObject(rt.src);\n}\n"],"names":[],"mappings":";AAkBO,SAAS,sBAAsB,IAAkC;AACpE,QAAM,cAAc,eAAe,eAAe,GAAG,GAAG;AACxD,SAAO,YAAY,IAAI,CAAC,MAAM;AAC1B,UAAM,aAAgC;AAAA,MAClC,MAAM,EAAE;AAAA,MACR,SAAU,EAAE,QAAoB;AAAA,IAAA;AAEpC,WAAO;AAAA,EACX,CAAC;AACL;AAUO,SAAS,2BAA2B,IAAoB;AAC3D,SAAO,sBAAsB,EAAE,EAAE,IAAI,CAAC,MAAM,eAAe,UAAU,GAAG,KAAK,EAAE,IAAI,CAAC;AACxF;AAKO,SAAS,gBAAgB,IAAkB;AAC9C,SAAO,aAAa,GAAG,GAAG;AAC9B;"}

package/.dist/esm/src/lib/formats.d.ts

@@ -1,19 +0,0 @@
-import { CompiledPureFunction, TypeFormatParams, TypeFormatValue } from '@mionjs/core';
-import { FormatAnnotation } from '../types.ts';
-import { ReflectionKind } from '@deepkit/type';
-import { BaseRunType } from './baseRunTypes.ts';
-import { JitErrorsFnCompiler, JitFnCompiler } from './jitFnCompiler.ts';
-import { BaseRunTypeFormat } from './baseRunTypeFormat.ts';
-export declare function registerFormatter<T extends BaseRunTypeFormat>(operation: T, shouldThrow?: boolean): T;
-export declare function getFormatterFromCache(typeKind: ReflectionKind, name: string, shouldThrow?: boolean): BaseRunTypeFormat | undefined;
-export declare function getFormatterKey(prefix: string, kind: string | number, name: string | number): string;
-export declare function getRunTypeFormat(rt: BaseRunType): BaseRunTypeFormat | undefined;
-export declare function getRunTypeTransformer(rt: BaseRunType): BaseRunTypeFormat | undefined;
-export declare function initFormatAnnotations(rt: BaseRunType): FormatAnnotation | undefined;
-export declare function getFormatterParams<P extends TypeFormatParams>(rt: BaseRunType, fmtName: string): P;
-export declare function getFormatAnnotation(rt: BaseRunType): FormatAnnotation | undefined;
-export declare const defaultIgnoreFormatProps: string[];
-export declare function paramsToLiteral(comp: JitFnCompiler | JitErrorsFnCompiler, params: TypeFormatValue, ignoreProps?: string[]): string;
-export declare function getToLiteralFn(comp: JitFnCompiler | JitErrorsFnCompiler, ignoreProps?: string[]): (params: TypeFormatValue) => string;
-export declare function dependenciesToLiteral(comp: JitFnCompiler | JitErrorsFnCompiler, params: Record<string, string | CompiledPureFunction>, ignoreProps?: string[]): string;
-//# sourceMappingURL=formats.d.ts.map

package/.dist/esm/src/lib/formats.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"formats.d.ts","sourceRoot":"","sources":["../../../../src/lib/formats.ts"],"names":[],"mappings":"AAOA,OAAO,EAAC,oBAAoB,EAAE,gBAAgB,EAAE,eAAe,EAAC,MAAM,cAAc,CAAC;AAErF,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,aAAa,CAAC;AAClD,OAAO,EAAiB,cAAc,EAAC,MAAM,eAAe,CAAC;AAC7D,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAC,mBAAmB,EAAE,aAAa,EAAC,MAAM,oBAAoB,CAAC;AAC3E,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,wBAAwB,CAAC;AAS9D,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,iBAAiB,EAAE,SAAS,EAAE,CAAC,EAAE,WAAW,UAAQ,GAAG,CAAC,CAUnG;AAGD,wBAAgB,qBAAqB,CACjC,QAAQ,EAAE,cAAc,EACxB,IAAI,EAAE,MAAM,EACZ,WAAW,UAAQ,GACpB,iBAAiB,GAAG,SAAS,CAO/B;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAEpG;AAGD,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,WAAW,GAAG,iBAAiB,GAAG,SAAS,CAE/E;AAED,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,WAAW,GAAG,iBAAiB,GAAG,SAAS,CAIpF;AASD,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,WAAW,GAAG,gBAAgB,GAAG,SAAS,CAenF;AAGD,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,gBAAgB,EAAE,EAAE,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,GAAG,CAAC,CAQlG;AAED,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,WAAW,GAAG,gBAAgB,GAAG,SAAS,CAIjF;AAKD,eAAO,MAAM,wBAAwB,UAAkB,CAAC;AAYxD,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,mBAAmB,EAAE,MAAM,EAAE,eAAe,EAAE,WAAW,CAAC,EAAE,MAAM,EAAE,UAEzH;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,aAAa,GAAG,mBAAmB,EAAE,WAAW,CAAC,EAAE,MAAM,EAAE,IACpF,QAAQ,eAAe,YAClC;AAYD,wBAAgB,qBAAqB,CACjC,IAAI,EAAE,aAAa,GAAG,mBAAmB,EACzC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,oBAAoB,CAAC,EACrD,WAAW,GAAE,MAAM,EAAO,UAG7B"}

package/.dist/esm/src/lib/formats.js

@@ -1,89 +0,0 @@
-import { ReflectionKindName } from "../constants.kind.js";
-import { typeAnnotation, ReflectionKind } from "@deepkit/type";
-import { toLiteralInContext } from "./utils.js";
-const typeAnnotationsCache = /* @__PURE__ */ new Map();
-const formatterPrefix = "f";
-function registerFormatter(operation, shouldThrow = false) {
-  const id = getFormatterKey(formatterPrefix, operation.kind, operation.name);
-  const exiting = typeAnnotationsCache.get(id);
-  if (exiting && exiting !== operation) {
-    if (shouldThrow)
-      throw new Error(`Annotation type ${operation.name} already registered for ${ReflectionKindName[operation.kind]}`);
-    return operation;
-  }
-  typeAnnotationsCache.set(id, operation);
-  return operation;
-}
-function getFormatterFromCache(typeKind, name, shouldThrow = false) {
-  const formatter = typeAnnotationsCache.get(getFormatterKey(formatterPrefix, typeKind, name));
-  if (!formatter) {
-    if (shouldThrow) throw new Error(`Annotation type ${name} not found for ${ReflectionKindName[typeKind]}`);
-    return void 0;
-  }
-  return formatter;
-}
-function getFormatterKey(prefix, kind, name) {
-  return `${prefix}:${kind}:${name}`;
-}
-function getRunTypeFormat(rt) {
-  return getFormatAnnotation(rt)?.formatter;
-}
-function getRunTypeTransformer(rt) {
-  const rtFormat = getRunTypeFormat(rt);
-  if (rtFormat?.emitFormat) return rtFormat;
-  return void 0;
-}
-function initFormatAnnotations(rt) {
-  const annotations = typeAnnotation.getAnnotations(rt.src);
-  if (annotations.length === 0) return;
-  if (annotations.length > 1)
-    throw new Error(`Only one type annotation is allowed for runTypes and ${rt.getTypeName()} has ${annotations.length}`);
-  const annotation = annotations[0];
-  if (!annotation.name) throw new Error(`Type annotation must have a name for ${rt.getTypeName()}`);
-  const params = annotation.options;
-  const formatter = getFormatterFromCache(rt.src.kind, annotation.name);
-  if (formatter && params.kind === ReflectionKind.objectLiteral) {
-    annotation.formatter = formatter;
-    return annotation;
-  }
-  return annotation;
-}
-function getFormatterParams(rt, fmtName) {
-  const annotation = getFormatAnnotation(rt);
-  if (annotation?.name === fmtName) {
-    if (annotation.params) return annotation.params;
-    annotation.params = typeAnnotation.getOption(rt.src, annotation.name);
-    return annotation.params;
-  }
-  throw new Error(`Type Formatter ${fmtName} not found for ${rt.getTypeName()}`);
-}
-function getFormatAnnotation(rt) {
-  const parsedAnnotations = typeAnnotation.getAnnotations(rt.src);
-  const formatAnnotations = parsedAnnotations.filter((a) => a.formatter);
-  return formatAnnotations[0];
-}
-const defaultIgnoreFormatProps = ["mockSamples"];
-function paramsToLiteral(comp, params, ignoreProps) {
-  return toLiteralInContext(comp, params, ignoreProps, false);
-}
-function getToLiteralFn(comp, ignoreProps) {
-  return (params) => paramsToLiteral(comp, params, ignoreProps);
-}
-function dependenciesToLiteral(comp, params, ignoreProps = []) {
-  return toLiteralInContext(comp, params, ignoreProps, true);
-}
-export {
-  defaultIgnoreFormatProps,
-  dependenciesToLiteral,
-  getFormatAnnotation,
-  getFormatterFromCache,
-  getFormatterKey,
-  getFormatterParams,
-  getRunTypeFormat,
-  getRunTypeTransformer,
-  getToLiteralFn,
-  initFormatAnnotations,
-  paramsToLiteral,
-  registerFormatter
-};
-//# sourceMappingURL=formats.js.map

package/.dist/esm/src/lib/formats.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"formats.js","sources":["../../../../src/lib/formats.ts"],"sourcesContent":["/* ########\n * 2025 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {CompiledPureFunction, TypeFormatParams, TypeFormatValue} from '@mionjs/core';\nimport {ReflectionKindName} from '../constants.kind.ts';\nimport type {FormatAnnotation} from '../types.ts';\nimport {typeAnnotation, ReflectionKind} from '@deepkit/type';\nimport type {BaseRunType} from './baseRunTypes.ts';\nimport type {JitErrorsFnCompiler, JitFnCompiler} from './jitFnCompiler.ts';\nimport type {BaseRunTypeFormat} from './baseRunTypeFormat.ts';\nimport {toLiteralInContext} from './utils.ts';\n\n// ################# REGISTER FORMATTERS & PURE FUNCTIONS  #################\n\nconst typeAnnotationsCache = new Map<string, BaseRunTypeFormat>();\nconst formatterPrefix = 'f';\n\n/** Adds a TypeFormatter or TypeValidator to the formatters cache */\nexport function registerFormatter<T extends BaseRunTypeFormat>(operation: T, shouldThrow = false): T {\n    const id = getFormatterKey(formatterPrefix, operation.kind, operation.name);\n    const exiting = typeAnnotationsCache.get(id);\n    if (exiting && exiting !== operation) {\n        if (shouldThrow)\n            throw new Error(`Annotation type ${operation.name} already registered for ${ReflectionKindName[operation.kind]}`);\n        return operation;\n    }\n    typeAnnotationsCache.set(id, operation);\n    return operation;\n}\n\n/** Gets a TypeFormatter or TypeValidator to the formatters cache */\nexport function getFormatterFromCache(\n    typeKind: ReflectionKind,\n    name: string,\n    shouldThrow = false\n): BaseRunTypeFormat | undefined {\n    const formatter = typeAnnotationsCache.get(getFormatterKey(formatterPrefix, typeKind, name));\n    if (!formatter) {\n        if (shouldThrow) throw new Error(`Annotation type ${name} not found for ${ReflectionKindName[typeKind]}`);\n        return undefined;\n    }\n    return formatter;\n}\n\nexport function getFormatterKey(prefix: string, kind: string | number, name: string | number): string {\n    return `${prefix}:${kind}:${name}`;\n}\n\n/** Returns the validator for a given type. ATM only one validator is allowed for each type */\nexport function getRunTypeFormat(rt: BaseRunType): BaseRunTypeFormat | undefined {\n    return getFormatAnnotation(rt)?.formatter;\n}\n\nexport function getRunTypeTransformer(rt: BaseRunType): BaseRunTypeFormat | undefined {\n    const rtFormat = getRunTypeFormat(rt);\n    if (rtFormat?.emitFormat) return rtFormat;\n    return undefined;\n}\n\n// ################# ANNOTATIONS  #################\n\n/**\n * Reads deepkit annotations and augment them with the associated formatters.\n * @param rt\n * @returns\n */\nexport function initFormatAnnotations(rt: BaseRunType): FormatAnnotation | undefined {\n    const annotations = typeAnnotation.getAnnotations(rt.src);\n    if (annotations.length === 0) return;\n    if (annotations.length > 1)\n        throw new Error(`Only one type annotation is allowed for runTypes and ${rt.getTypeName()} has ${annotations.length}`);\n    const annotation = annotations[0] as FormatAnnotation;\n    if (!annotation.name) throw new Error(`Type annotation must have a name for ${rt.getTypeName()}`);\n    const params = annotation.options;\n    const formatter = getFormatterFromCache(rt.src.kind, annotation.name);\n    // formatter property is only added to registered formatters, this allows using other type annotations that are not formatters\n    if (formatter && params.kind === ReflectionKind.objectLiteral) {\n        annotation.formatter = formatter;\n        return annotation;\n    }\n    return annotation as FormatAnnotation;\n}\n\n/** Returns the params for a given type formatter */\nexport function getFormatterParams<P extends TypeFormatParams>(rt: BaseRunType, fmtName: string): P {\n    const annotation = getFormatAnnotation(rt);\n    if (annotation?.name === fmtName) {\n        if (annotation.params) return annotation.params as P;\n        annotation.params = typeAnnotation.getOption(rt.src, annotation.name) as P;\n        return annotation.params as P;\n    }\n    throw new Error(`Type Formatter ${fmtName} not found for ${rt.getTypeName()}`);\n}\n\nexport function getFormatAnnotation(rt: BaseRunType): FormatAnnotation | undefined {\n    const parsedAnnotations = typeAnnotation.getAnnotations(rt.src);\n    const formatAnnotations = parsedAnnotations.filter((a) => (a as FormatAnnotation).formatter);\n    return formatAnnotations[0] as FormatAnnotation | undefined;\n}\n\n// ################# COMPILING  #################\n\n// TODO, read ignoreProps from multiple formatters, rather than a constant here\nexport const defaultIgnoreFormatProps = ['mockSamples'];\n\n/**\n * Transforms a params object into a literal string to be used in JIT code.\n * ie: {total: 5, name: 'hello'} gets transformed into teh string '{total: 5, name: \"hello\"}' that can be used as JIT code.\n * Some literals are automatically added to the context to reduce code size. in this case the reference to the context variable is returned.\n *\n * @param comp\n * @param params\n * @param ignoreProps\n * @returns\n */\nexport function paramsToLiteral(comp: JitFnCompiler | JitErrorsFnCompiler, params: TypeFormatValue, ignoreProps?: string[]) {\n    return toLiteralInContext(comp, params, ignoreProps, false);\n}\n\nexport function getToLiteralFn(comp: JitFnCompiler | JitErrorsFnCompiler, ignoreProps?: string[]) {\n    return (params: TypeFormatValue) => paramsToLiteral(comp, params, ignoreProps);\n}\n\n/**\n * Transforms a dependencies object into a string literal that can be used as JIT code.\n * Dependencies object can contain pure functions or code.\n * Pure functions will be load as dependency using jitUtils.getPureFn, and code will be left as is.\n * ie: {helloFn: function hello(){}, code: 'v + 2'} gets transformed into the string '{helloFn: utl.getPureFn(\"hello\"), code: v + 2}'\n * @param comp\n * @param params\n * @param ignoreProps\n * @returns\n */\nexport function dependenciesToLiteral(\n    comp: JitFnCompiler | JitErrorsFnCompiler,\n    params: Record<string, string | CompiledPureFunction>,\n    ignoreProps: string[] = []\n) {\n    return toLiteralInContext(comp, params, ignoreProps, true);\n}\n"],"names":[],"mappings":";;;AAkBA,MAAM,2CAA2B,IAAA;AACjC,MAAM,kBAAkB;AAGjB,SAAS,kBAA+C,WAAc,cAAc,OAAU;AACjG,QAAM,KAAK,gBAAgB,iBAAiB,UAAU,MAAM,UAAU,IAAI;AAC1E,QAAM,UAAU,qBAAqB,IAAI,EAAE;AAC3C,MAAI,WAAW,YAAY,WAAW;AAClC,QAAI;AACA,YAAM,IAAI,MAAM,mBAAmB,UAAU,IAAI,2BAA2B,mBAAmB,UAAU,IAAI,CAAC,EAAE;AACpH,WAAO;AAAA,EACX;AACA,uBAAqB,IAAI,IAAI,SAAS;AACtC,SAAO;AACX;AAGO,SAAS,sBACZ,UACA,MACA,cAAc,OACe;AAC7B,QAAM,YAAY,qBAAqB,IAAI,gBAAgB,iBAAiB,UAAU,IAAI,CAAC;AAC3F,MAAI,CAAC,WAAW;AACZ,QAAI,YAAa,OAAM,IAAI,MAAM,mBAAmB,IAAI,kBAAkB,mBAAmB,QAAQ,CAAC,EAAE;AACxG,WAAO;AAAA,EACX;AACA,SAAO;AACX;AAEO,SAAS,gBAAgB,QAAgB,MAAuB,MAA+B;AAClG,SAAO,GAAG,MAAM,IAAI,IAAI,IAAI,IAAI;AACpC;AAGO,SAAS,iBAAiB,IAAgD;AAC7E,SAAO,oBAAoB,EAAE,GAAG;AACpC;AAEO,SAAS,sBAAsB,IAAgD;AAClF,QAAM,WAAW,iBAAiB,EAAE;AACpC,MAAI,UAAU,WAAY,QAAO;AACjC,SAAO;AACX;AASO,SAAS,sBAAsB,IAA+C;AACjF,QAAM,cAAc,eAAe,eAAe,GAAG,GAAG;AACxD,MAAI,YAAY,WAAW,EAAG;AAC9B,MAAI,YAAY,SAAS;AACrB,UAAM,IAAI,MAAM,wDAAwD,GAAG,aAAa,QAAQ,YAAY,MAAM,EAAE;AACxH,QAAM,aAAa,YAAY,CAAC;AAChC,MAAI,CAAC,WAAW,KAAM,OAAM,IAAI,MAAM,wCAAwC,GAAG,YAAA,CAAa,EAAE;AAChG,QAAM,SAAS,WAAW;AAC1B,QAAM,YAAY,sBAAsB,GAAG,IAAI,MAAM,WAAW,IAAI;AAEpE,MAAI,aAAa,OAAO,SAAS,eAAe,eAAe;AAC3D,eAAW,YAAY;AACvB,WAAO;AAAA,EACX;AACA,SAAO;AACX;AAGO,SAAS,mBAA+C,IAAiB,SAAoB;AAChG,QAAM,aAAa,oBAAoB,EAAE;AACzC,MAAI,YAAY,SAAS,SAAS;AAC9B,QAAI,WAAW,OAAQ,QAAO,WAAW;AACzC,eAAW,SAAS,eAAe,UAAU,GAAG,KAAK,WAAW,IAAI;AACpE,WAAO,WAAW;AAAA,EACtB;AACA,QAAM,IAAI,MAAM,kBAAkB,OAAO,kBAAkB,GAAG,YAAA,CAAa,EAAE;AACjF;AAEO,SAAS,oBAAoB,IAA+C;AAC/E,QAAM,oBAAoB,eAAe,eAAe,GAAG,GAAG;AAC9D,QAAM,oBAAoB,kBAAkB,OAAO,CAAC,MAAO,EAAuB,SAAS;AAC3F,SAAO,kBAAkB,CAAC;AAC9B;AAKO,MAAM,2BAA2B,CAAC,aAAa;AAY/C,SAAS,gBAAgB,MAA2C,QAAyB,aAAwB;AACxH,SAAO,mBAAmB,MAAM,QAAQ,aAAa,KAAK;AAC9D;AAEO,SAAS,eAAe,MAA2C,aAAwB;AAC9F,SAAO,CAAC,WAA4B,gBAAgB,MAAM,QAAQ,WAAW;AACjF;AAYO,SAAS,sBACZ,MACA,QACA,cAAwB,CAAA,GAC1B;AACE,SAAO,mBAAmB,MAAM,QAAQ,aAAa,IAAI;AAC7D;"}