@mionjs/run-types 0.8.10 → 0.13.2

package/.dist/cjs/src/constants.functions.cjs

@@ -1,181 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const core = require("@mionjs/core");
-const __ΩRecord = ["K", "T", "Record", `l'e#"Rb!b"Pde"!N#!w#y`];
-function __assignType(fn, args) {
-  fn.__type = args;
-  return fn;
-}
-const CodeTypes = {
-  expression: "E",
-  // single expression, that could be concatenated using js operators like + - * && || etc...
-  statement: "S",
-  // one or multiple statements, that could be concatenated using ; to ensure correct syntax
-  returnBlock: "RB"
-  // code block, it can not be concatenated with other code, it has an explicit return statement and needs to be wrapped in a function
-};
-const __ΩCodeType = [() => CodeTypes, () => CodeTypes, "CodeType", 'i!i"gfw#y'];
-const __ΩJitFnSettings = ["id", "name", "args", "", "import", "JitFnArgs", "jitArgs", "jitDefaultArgs", "returnName", true, "noInitialVλl", () => __ΩRecord, "keyName", "boolean", "number", "string", "type", "defaultValue", "runTimeOptions", true, "formatShouldReplaceJitCode", "JitFnSettings", 'P&4!&4"PP"@2#"/$`/$4%8"w&4\'"w&4(&4).*4+8&P&4-P.../.0J41"42Mo,#438.4458Mw6y'];
-const jitArgs = { vλl: "v" };
-const jitDefaultArgs = { vλl: "" };
-const jitErrorArgs = { vλl: "v", pλth: "pth", εrr: "er" };
-const jitDefaultErrorArgs = { vλl: "", pλth: "[]", εrr: "[]" };
-const jitArgsWithOptions = { vλl: "v", θpts: "opts" };
-const jitDefaultArgsWithOptions = { vλl: "", θpts: "{}" };
-const jitBinarySerializerArgs = { vλl: "v", sεr: "Ser" };
-const jitBinaryDeserializerArgs = { vλl: "ret", dεs: "Des" };
-const jitDefaultBinarySerializerArgs = { vλl: "", sεr: "" };
-const jitDefaultBinaryDeserializerArgs = { vλl: "", dεs: "" };
-const jitValidationFunctions = {
-  isType: {
-    id: core.JIT_FUNCTION_IDS.isType,
-    name: "isType",
-    jitArgs,
-    jitDefaultArgs,
-    returnName: jitArgs.vλl
-  },
-  typeErrors: {
-    id: core.JIT_FUNCTION_IDS.typeErrors,
-    name: "typeErrors",
-    jitArgs: jitErrorArgs,
-    jitDefaultArgs: jitDefaultErrorArgs,
-    returnName: jitErrorArgs.εrr
-  }
-};
-const jitSerializationFunctions = {
-  prepareForJson: {
-    id: core.JIT_FUNCTION_IDS.prepareForJson,
-    name: "prepareForJson",
-    jitArgs,
-    jitDefaultArgs,
-    returnName: jitArgs.vλl
-  },
-  restoreFromJson: {
-    id: core.JIT_FUNCTION_IDS.restoreFromJson,
-    name: "restoreFromJson",
-    jitArgs,
-    jitDefaultArgs,
-    returnName: jitArgs.vλl
-  },
-  stringifyJson: {
-    id: core.JIT_FUNCTION_IDS.stringifyJson,
-    name: "stringifyJson",
-    jitArgs,
-    jitDefaultArgs,
-    returnName: jitArgs.vλl
-  },
-  // similar to json stringify but outputs js code, including pure functions, already imported as size is quite small
-  toJSCode: {
-    id: core.JIT_FUNCTION_IDS.toJSCode,
-    name: "toJSCode",
-    jitArgs,
-    jitDefaultArgs,
-    returnName: jitArgs.vλl
-  },
-  // Binary serialization functions
-  toBinary: {
-    id: core.JIT_FUNCTION_IDS.toBinary,
-    name: "toBinary",
-    jitArgs: jitBinarySerializerArgs,
-    jitDefaultArgs: jitDefaultBinarySerializerArgs,
-    // returns the serializer buffer
-    returnName: jitBinarySerializerArgs.sεr,
-    formatShouldReplaceJitCode: true
-  },
-  fromBinary: {
-    id: core.JIT_FUNCTION_IDS.fromBinary,
-    name: "fromBinary",
-    jitArgs: jitBinaryDeserializerArgs,
-    jitDefaultArgs: jitDefaultBinaryDeserializerArgs,
-    // deserialized value is stored in vλl that is initially undefined
-    returnName: jitBinaryDeserializerArgs.vλl,
-    noInitialVλl: true,
-    formatShouldReplaceJitCode: true
-  },
-  // apply type formatters, ie: lowercase, uppercase, trim, etc
-  format: {
-    id: core.JIT_FUNCTION_IDS.format,
-    name: "format",
-    jitArgs,
-    jitDefaultArgs,
-    returnName: jitArgs.vλl
-  }
-};
-const JitFunctions = {
-  ...jitValidationFunctions,
-  ...jitSerializationFunctions,
-  unknownKeyErrors: {
-    id: core.JIT_FUNCTION_IDS.unknownKeyErrors,
-    name: "unknownKeyErrors",
-    jitArgs: jitErrorArgs,
-    jitDefaultArgs: jitDefaultErrorArgs,
-    returnName: jitErrorArgs.εrr
-  },
-  hasUnknownKeys: {
-    id: core.JIT_FUNCTION_IDS.hasUnknownKeys,
-    name: "hasUnknownKeys",
-    jitArgs: jitArgsWithOptions,
-    jitDefaultArgs: jitDefaultArgsWithOptions,
-    runTimeOptions: { checkNonJitProps: { keyName: "checkNonJitProps", type: "boolean", defaultValue: false } },
-    returnName: jitArgsWithOptions.vλl
-  },
-  stripUnknownKeys: {
-    id: core.JIT_FUNCTION_IDS.stripUnknownKeys,
-    name: "stripUnknownKeys",
-    jitArgs,
-    jitDefaultArgs,
-    returnName: jitArgs.vλl
-  },
-  unknownKeysToUndefined: {
-    id: core.JIT_FUNCTION_IDS.unknownKeysToUndefined,
-    name: "unknownKeysToUndefined",
-    jitArgs,
-    jitDefaultArgs,
-    returnName: jitArgs.vλl
-  },
-  aux: {
-    id: core.JIT_FUNCTION_IDS.aux,
-    name: "aux",
-    jitArgs,
-    jitDefaultArgs,
-    returnName: jitArgs.vλl
-  },
-  // mock is not really a jit function but is used in a similar way, main difference is that it is not compiled
-  mock: {
-    id: core.JIT_FUNCTION_IDS.mock,
-    name: "mockType",
-    import: () => Promise.resolve().then(() => require("./mocking/mockType.cjs")).then(__assignType((m) => m.mockType, ["m", "", 'P"2!"/"'])),
-    jitArgs,
-    jitDefaultArgs,
-    returnName: jitArgs.vλl
-  },
-  // pure function are not jit compiled but we ensure we reserve a prefix to avoid collisions
-  pureFunction: {
-    id: core.JIT_FUNCTION_IDS.pureFunction,
-    name: "pureFunction",
-    jitArgs,
-    jitDefaultArgs,
-    returnName: jitArgs.vλl
-  }
-};
-const jitFunctionList = Object.values(JitFunctions);
-const jitFunctionsById = Object.fromEntries(jitFunctionList.map(__assignType((f) => [f.id, f], ["f", "", 'P"2!"/"'])));
-exports.CodeTypes = CodeTypes;
-exports.JitFunctions = JitFunctions;
-exports.__ΩCodeType = __ΩCodeType;
-exports.__ΩJitFnSettings = __ΩJitFnSettings;
-exports.jitArgs = jitArgs;
-exports.jitArgsWithOptions = jitArgsWithOptions;
-exports.jitBinaryDeserializerArgs = jitBinaryDeserializerArgs;
-exports.jitBinarySerializerArgs = jitBinarySerializerArgs;
-exports.jitDefaultArgs = jitDefaultArgs;
-exports.jitDefaultArgsWithOptions = jitDefaultArgsWithOptions;
-exports.jitDefaultBinaryDeserializerArgs = jitDefaultBinaryDeserializerArgs;
-exports.jitDefaultBinarySerializerArgs = jitDefaultBinarySerializerArgs;
-exports.jitDefaultErrorArgs = jitDefaultErrorArgs;
-exports.jitErrorArgs = jitErrorArgs;
-exports.jitFunctionList = jitFunctionList;
-exports.jitFunctionsById = jitFunctionsById;
-exports.jitSerializationFunctions = jitSerializationFunctions;
-exports.jitValidationFunctions = jitValidationFunctions;
-//# sourceMappingURL=constants.functions.cjs.map

package/.dist/cjs/src/constants.functions.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.functions.cjs","sources":["../../../src/constants.functions.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 {type JitFnArgs, JIT_FUNCTION_IDS} from '@mionjs/core';\n\n/** Javascript code types */\nexport const CodeTypes = {\n    expression: 'E', // single expression, that could be concatenated using js operators like + - * && || etc...\n    statement: 'S', // one or multiple statements, that could be concatenated using ; to ensure correct syntax\n    returnBlock: 'RB', // code block, it can not be concatenated with other code, it has an explicit return statement and needs to be wrapped in a function\n} as const;\nexport type CodeType = (typeof CodeTypes)[keyof typeof CodeTypes];\n\nexport interface JitFnSettings {\n    id: string;\n    name: string;\n    /** dynamically imports a single compiler function that is capable of compiling any node\n     * @see {@link ./jitCompilers/stringifyJson.ts#visitJsonStringify} as example of compiler function\n     */\n    import?: () => Promise<(...args: any[]) => any>;\n    jitArgs: JitFnArgs;\n    jitDefaultArgs: JitFnArgs;\n    returnName: string;\n    /**\n     * When no initial vλl is required by the function.\n     * This is typically used by deserializers, that do not transform the input value but create a new one from other params.\n     * an the initial vλl is used as a variable initialization for the returned values.\n     * ie binary deserialization\n     */\n    noInitialVλl?: true;\n    runTimeOptions?: Record<string, {keyName: string; type: 'boolean' | 'number' | 'string'; defaultValue: any}>;\n    /**\n     * When set to true, the format code should replace the jit code for the function.\n     * This is used when the format code is more efficient than the default code.\n     */\n    formatShouldReplaceJitCode?: true;\n} // list of available jit functions\n\n// variable names used in jit functions\n// JitUtils is passed with the name 'utl'. it is hardcoded in all jit code to avoid string interpolation\nexport const jitArgs = {vλl: 'v'} as const;\nexport const jitDefaultArgs = {vλl: ''} as const;\nexport const jitErrorArgs = {vλl: 'v', pλth: 'pth', εrr: 'er'} as const;\nexport const jitDefaultErrorArgs = {vλl: '', pλth: '[]', εrr: '[]'} as const;\nexport const jitArgsWithOptions = {vλl: 'v', θpts: 'opts'} as const;\nexport const jitDefaultArgsWithOptions = {vλl: '', θpts: '{}'} as const;\nexport const jitBinarySerializerArgs = {vλl: 'v', sεr: 'Ser'} as const; // vλl = js value to serialize ser = serializer,\nexport const jitBinaryDeserializerArgs = {vλl: 'ret', dεs: 'Des'} as const; // vλl is used as return variable ans is assigned the deserialized value, des = deserializer\nexport const jitDefaultBinarySerializerArgs = {vλl: '', sεr: ''} as const;\nexport const jitDefaultBinaryDeserializerArgs = {vλl: '', dεs: ''} as const;\n\n// ######## !IMPORTANT: ALL JIT FUNCTIONS IDs MUST BE UNIQUE and short ########\n\ntype JitFunctionsGroup = {[key: string]: JitFnSettings};\n\nexport const jitValidationFunctions = {\n    isType: {\n        id: JIT_FUNCTION_IDS.isType,\n        name: 'isType',\n        jitArgs,\n        jitDefaultArgs,\n        returnName: jitArgs.vλl,\n    },\n    typeErrors: {\n        id: JIT_FUNCTION_IDS.typeErrors,\n        name: 'typeErrors',\n        jitArgs: jitErrorArgs,\n        jitDefaultArgs: jitDefaultErrorArgs,\n        returnName: jitErrorArgs.εrr,\n    },\n} as const satisfies JitFunctionsGroup;\n\nexport const jitSerializationFunctions = {\n    prepareForJson: {\n        id: JIT_FUNCTION_IDS.prepareForJson,\n        name: 'prepareForJson',\n        jitArgs,\n        jitDefaultArgs,\n        returnName: jitArgs.vλl,\n    },\n    restoreFromJson: {\n        id: JIT_FUNCTION_IDS.restoreFromJson,\n        name: 'restoreFromJson',\n        jitArgs,\n        jitDefaultArgs,\n        returnName: jitArgs.vλl,\n    },\n    stringifyJson: {\n        id: JIT_FUNCTION_IDS.stringifyJson,\n        name: 'stringifyJson',\n        jitArgs,\n        jitDefaultArgs,\n        returnName: jitArgs.vλl,\n    },\n    // similar to json stringify but outputs js code, including pure functions, already imported as size is quite small\n    toJSCode: {\n        id: JIT_FUNCTION_IDS.toJSCode,\n        name: 'toJSCode',\n        jitArgs,\n        jitDefaultArgs,\n        returnName: jitArgs.vλl,\n    },\n    // Binary serialization functions\n    toBinary: {\n        id: JIT_FUNCTION_IDS.toBinary,\n        name: 'toBinary',\n        jitArgs: jitBinarySerializerArgs,\n        jitDefaultArgs: jitDefaultBinarySerializerArgs,\n        // returns the serializer buffer\n        returnName: jitBinarySerializerArgs.sεr,\n        formatShouldReplaceJitCode: true,\n    },\n    fromBinary: {\n        id: JIT_FUNCTION_IDS.fromBinary,\n        name: 'fromBinary',\n        jitArgs: jitBinaryDeserializerArgs,\n        jitDefaultArgs: jitDefaultBinaryDeserializerArgs,\n        // deserialized value is stored in vλl that is initially undefined\n        returnName: jitBinaryDeserializerArgs.vλl,\n        noInitialVλl: true,\n        formatShouldReplaceJitCode: true,\n    },\n    // apply type formatters, ie: lowercase, uppercase, trim, etc\n    format: {\n        id: JIT_FUNCTION_IDS.format,\n        name: 'format',\n        jitArgs,\n        jitDefaultArgs,\n        returnName: jitArgs.vλl,\n    },\n} as const satisfies JitFunctionsGroup;\n\nexport const JitFunctions = {\n    ...jitValidationFunctions,\n    ...jitSerializationFunctions,\n    unknownKeyErrors: {\n        id: JIT_FUNCTION_IDS.unknownKeyErrors,\n        name: 'unknownKeyErrors',\n        jitArgs: jitErrorArgs,\n        jitDefaultArgs: jitDefaultErrorArgs,\n        returnName: jitErrorArgs.εrr,\n    },\n    hasUnknownKeys: {\n        id: JIT_FUNCTION_IDS.hasUnknownKeys,\n        name: 'hasUnknownKeys',\n        jitArgs: jitArgsWithOptions,\n        jitDefaultArgs: jitDefaultArgsWithOptions,\n        runTimeOptions: {checkNonJitProps: {keyName: 'checkNonJitProps', type: 'boolean', defaultValue: false}},\n        returnName: jitArgsWithOptions.vλl,\n    },\n    stripUnknownKeys: {\n        id: JIT_FUNCTION_IDS.stripUnknownKeys,\n        name: 'stripUnknownKeys',\n        jitArgs,\n        jitDefaultArgs,\n        returnName: jitArgs.vλl,\n    },\n    unknownKeysToUndefined: {\n        id: JIT_FUNCTION_IDS.unknownKeysToUndefined,\n        name: 'unknownKeysToUndefined',\n        jitArgs,\n        jitDefaultArgs,\n        returnName: jitArgs.vλl,\n    },\n    aux: {\n        id: JIT_FUNCTION_IDS.aux,\n        name: 'aux',\n        jitArgs,\n        jitDefaultArgs,\n        returnName: jitArgs.vλl,\n    },\n    // mock is not really a jit function but is used in a similar way, main difference is that it is not compiled\n    mock: {\n        id: JIT_FUNCTION_IDS.mock,\n        name: 'mockType',\n        import: () => import('./mocking/mockType.ts').then((m) => m.mockType),\n        jitArgs,\n        jitDefaultArgs,\n        returnName: jitArgs.vλl,\n    },\n    // pure function are not jit compiled but we ensure we reserve a prefix to avoid collisions\n    pureFunction: {\n        id: JIT_FUNCTION_IDS.pureFunction,\n        name: 'pureFunction',\n        jitArgs,\n        jitDefaultArgs,\n        returnName: jitArgs.vλl,\n    },\n} as const satisfies JitFunctionsGroup;\n\nexport const jitFunctionList: JitFnSettings[] = Object.values(JitFunctions);\nexport const jitFunctionsById = Object.fromEntries(jitFunctionList.map((f) => [f.id, f]));\n"],"names":["JIT_FUNCTION_IDS"],"mappings":"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"}

package/.dist/cjs/src/constants.functions.d.ts

@@ -1,386 +0,0 @@
-import { JitFnArgs } from '@mionjs/core';
-export declare const CodeTypes: {
-    readonly expression: "E";
-    readonly statement: "S";
-    readonly returnBlock: "RB";
-};
-export type CodeType = (typeof CodeTypes)[keyof typeof CodeTypes];
-export interface JitFnSettings {
-    id: string;
-    name: string;
-    import?: () => Promise<(...args: any[]) => any>;
-    jitArgs: JitFnArgs;
-    jitDefaultArgs: JitFnArgs;
-    returnName: string;
-    noInitialVλl?: true;
-    runTimeOptions?: Record<string, {
-        keyName: string;
-        type: 'boolean' | 'number' | 'string';
-        defaultValue: any;
-    }>;
-    formatShouldReplaceJitCode?: true;
-}
-export declare const jitArgs: {
-    readonly vλl: "v";
-};
-export declare const jitDefaultArgs: {
-    readonly vλl: "";
-};
-export declare const jitErrorArgs: {
-    readonly vλl: "v";
-    readonly pλth: "pth";
-    readonly εrr: "er";
-};
-export declare const jitDefaultErrorArgs: {
-    readonly vλl: "";
-    readonly pλth: "[]";
-    readonly εrr: "[]";
-};
-export declare const jitArgsWithOptions: {
-    readonly vλl: "v";
-    readonly θpts: "opts";
-};
-export declare const jitDefaultArgsWithOptions: {
-    readonly vλl: "";
-    readonly θpts: "{}";
-};
-export declare const jitBinarySerializerArgs: {
-    readonly vλl: "v";
-    readonly sεr: "Ser";
-};
-export declare const jitBinaryDeserializerArgs: {
-    readonly vλl: "ret";
-    readonly dεs: "Des";
-};
-export declare const jitDefaultBinarySerializerArgs: {
-    readonly vλl: "";
-    readonly sεr: "";
-};
-export declare const jitDefaultBinaryDeserializerArgs: {
-    readonly vλl: "";
-    readonly dεs: "";
-};
-export declare const jitValidationFunctions: {
-    readonly isType: {
-        readonly id: "is";
-        readonly name: "isType";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly typeErrors: {
-        readonly id: "te";
-        readonly name: "typeErrors";
-        readonly jitArgs: {
-            readonly vλl: "v";
-            readonly pλth: "pth";
-            readonly εrr: "er";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-            readonly pλth: "[]";
-            readonly εrr: "[]";
-        };
-        readonly returnName: "er";
-    };
-};
-export declare const jitSerializationFunctions: {
-    readonly prepareForJson: {
-        readonly id: "tj";
-        readonly name: "prepareForJson";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly restoreFromJson: {
-        readonly id: "fj";
-        readonly name: "restoreFromJson";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly stringifyJson: {
-        readonly id: "sj";
-        readonly name: "stringifyJson";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly toJSCode: {
-        readonly id: "tc";
-        readonly name: "toJSCode";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly toBinary: {
-        readonly id: "tBi";
-        readonly name: "toBinary";
-        readonly jitArgs: {
-            readonly vλl: "v";
-            readonly sεr: "Ser";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-            readonly sεr: "";
-        };
-        readonly returnName: "Ser";
-        readonly formatShouldReplaceJitCode: true;
-    };
-    readonly fromBinary: {
-        readonly id: "fBi";
-        readonly name: "fromBinary";
-        readonly jitArgs: {
-            readonly vλl: "ret";
-            readonly dεs: "Des";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-            readonly dεs: "";
-        };
-        readonly returnName: "ret";
-        readonly noInitialVλl: true;
-        readonly formatShouldReplaceJitCode: true;
-    };
-    readonly format: {
-        readonly id: "fmt";
-        readonly name: "format";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-};
-export declare const JitFunctions: {
-    readonly unknownKeyErrors: {
-        readonly id: "uk";
-        readonly name: "unknownKeyErrors";
-        readonly jitArgs: {
-            readonly vλl: "v";
-            readonly pλth: "pth";
-            readonly εrr: "er";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-            readonly pλth: "[]";
-            readonly εrr: "[]";
-        };
-        readonly returnName: "er";
-    };
-    readonly hasUnknownKeys: {
-        readonly id: "hk";
-        readonly name: "hasUnknownKeys";
-        readonly jitArgs: {
-            readonly vλl: "v";
-            readonly θpts: "opts";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-            readonly θpts: "{}";
-        };
-        readonly runTimeOptions: {
-            readonly checkNonJitProps: {
-                readonly keyName: "checkNonJitProps";
-                readonly type: "boolean";
-                readonly defaultValue: false;
-            };
-        };
-        readonly returnName: "v";
-    };
-    readonly stripUnknownKeys: {
-        readonly id: "sk";
-        readonly name: "stripUnknownKeys";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly unknownKeysToUndefined: {
-        readonly id: "ku";
-        readonly name: "unknownKeysToUndefined";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly aux: {
-        readonly id: "aux";
-        readonly name: "aux";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly mock: {
-        readonly id: "mock";
-        readonly name: "mockType";
-        readonly import: () => Promise<((...args: any[]) => any) | typeof import('./mocking/mockType.ts').mockType>;
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly pureFunction: {
-        readonly id: "pf";
-        readonly name: "pureFunction";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly prepareForJson: {
-        readonly id: "tj";
-        readonly name: "prepareForJson";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly restoreFromJson: {
-        readonly id: "fj";
-        readonly name: "restoreFromJson";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly stringifyJson: {
-        readonly id: "sj";
-        readonly name: "stringifyJson";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly toJSCode: {
-        readonly id: "tc";
-        readonly name: "toJSCode";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly toBinary: {
-        readonly id: "tBi";
-        readonly name: "toBinary";
-        readonly jitArgs: {
-            readonly vλl: "v";
-            readonly sεr: "Ser";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-            readonly sεr: "";
-        };
-        readonly returnName: "Ser";
-        readonly formatShouldReplaceJitCode: true;
-    };
-    readonly fromBinary: {
-        readonly id: "fBi";
-        readonly name: "fromBinary";
-        readonly jitArgs: {
-            readonly vλl: "ret";
-            readonly dεs: "Des";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-            readonly dεs: "";
-        };
-        readonly returnName: "ret";
-        readonly noInitialVλl: true;
-        readonly formatShouldReplaceJitCode: true;
-    };
-    readonly format: {
-        readonly id: "fmt";
-        readonly name: "format";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly isType: {
-        readonly id: "is";
-        readonly name: "isType";
-        readonly jitArgs: {
-            readonly vλl: "v";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-        };
-        readonly returnName: "v";
-    };
-    readonly typeErrors: {
-        readonly id: "te";
-        readonly name: "typeErrors";
-        readonly jitArgs: {
-            readonly vλl: "v";
-            readonly pλth: "pth";
-            readonly εrr: "er";
-        };
-        readonly jitDefaultArgs: {
-            readonly vλl: "";
-            readonly pλth: "[]";
-            readonly εrr: "[]";
-        };
-        readonly returnName: "er";
-    };
-};
-export declare const jitFunctionList: JitFnSettings[];
-export declare const jitFunctionsById: {
-    [k: string]: JitFnSettings;
-};
-export declare type __ΩCodeType = any[];
-export declare type __ΩJitFnSettings = any[];
-//# sourceMappingURL=constants.functions.d.ts.map

package/.dist/cjs/src/constants.functions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.functions.d.ts","sourceRoot":"","sources":["../../../src/constants.functions.ts"],"names":[],"mappings":"AAOA,OAAO,EAAC,KAAK,SAAS,EAAmB,MAAM,cAAc,CAAC;AAG9D,eAAO,MAAM,SAAS;;;;CAIZ,CAAC;AACX,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC;AAElE,MAAM,WAAW,aAAa;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IAIb,MAAM,CAAC,EAAE,MAAM,OAAO,CAAC,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC,CAAC;IAChD,OAAO,EAAE,SAAS,CAAC;IACnB,cAAc,EAAE,SAAS,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;IAOnB,YAAY,CAAC,EAAE,IAAI,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,SAAS,GAAG,QAAQ,GAAG,QAAQ,CAAC;QAAC,YAAY,EAAE,GAAG,CAAA;KAAC,CAAC,CAAC;IAK7G,0BAA0B,CAAC,EAAE,IAAI,CAAC;CACrC;AAID,eAAO,MAAM,OAAO;;CAAsB,CAAC;AAC3C,eAAO,MAAM,cAAc;;CAAqB,CAAC;AACjD,eAAO,MAAM,YAAY;;;;CAA8C,CAAC;AACxE,eAAO,MAAM,mBAAmB;;;;CAA4C,CAAC;AAC7E,eAAO,MAAM,kBAAkB;;;CAAoC,CAAC;AACpE,eAAO,MAAM,yBAAyB;;;CAAiC,CAAC;AACxE,eAAO,MAAM,uBAAuB;;;CAAkC,CAAC;AACvE,eAAO,MAAM,yBAAyB;;;CAAoC,CAAC;AAC3E,eAAO,MAAM,8BAA8B;;;CAA8B,CAAC;AAC1E,eAAO,MAAM,gCAAgC;;;CAA8B,CAAC;AAM5E,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAeG,CAAC;AAEvC,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DA,CAAC;AAEvC,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAjHY,GAAG,EAAE,KAAK,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyKZ,CAAC;AAEvC,eAAO,MAAM,eAAe,EAAE,aAAa,EAAgC,CAAC;AAC5E,eAAO,MAAM,gBAAgB;;CAA4D,CAAC"}

package/.dist/cjs/src/constants.kind.cjs

@@ -1,74 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const type = require("@deepkit/type");
-const src_types = require("./types.cjs");
-const ReflectionKindName = {
-  0: "never",
-  1: "any",
-  2: "unknown",
-  3: "void",
-  4: "objectLiteral",
-  // name was changed from deepkit's 'object' to 'objectLiteral'
-  5: "string",
-  6: "number",
-  7: "boolean",
-  8: "symbol",
-  9: "bigint",
-  10: "null",
-  11: "undefined",
-  12: "regexp",
-  13: "literal",
-  14: "templateLiteral",
-  15: "property",
-  16: "method",
-  17: "function",
-  18: "parameter",
-  19: "promise",
-  20: "class",
-  21: "typeParameter",
-  22: "enum",
-  23: "union",
-  24: "intersection",
-  25: "array",
-  26: "tuple",
-  27: "tupleMember",
-  28: "enumMember",
-  29: "rest",
-  30: "object",
-  // name was changed from deepkit's 'objectLiteral' to 'object' for better error messages
-  31: "indexSignature",
-  32: "propertySignature",
-  33: "methodSignature",
-  34: "infer",
-  35: "callSignature"
-};
-const ReflectionSubKind = {
-  // group of sub-kinds that extends ReflectionKind.class
-  date: 2001,
-  map: 2002,
-  set: 2003,
-  nonSerializable: 2004,
-  params: 1701,
-  mapKey: 1801,
-  mapValue: 1802,
-  setItem: 1803
-};
-const ReflectionSubNames = {
-  2001: "date",
-  2002: "map",
-  2003: "set",
-  1701: "params"
-};
-const __ΩAnyKindName = [() => type.ReflectionKind, () => ReflectionSubKind, "AnyKindName", 'Pi!gi"gJw#y'];
-function getReflectionName(rt) {
-  if (rt.src.subKind)
-    return ReflectionSubNames[rt.src.subKind];
-  return ReflectionKindName[rt.src.kind];
-}
-getReflectionName.__type = [() => src_types.__ΩRunType, "rt", () => __ΩAnyKindName, "getReflectionName", 'Pn!2"n#/$'];
-exports.ReflectionKindName = ReflectionKindName;
-exports.ReflectionSubKind = ReflectionSubKind;
-exports.ReflectionSubNames = ReflectionSubNames;
-exports.__ΩAnyKindName = __ΩAnyKindName;
-exports.getReflectionName = getReflectionName;
-//# sourceMappingURL=constants.kind.cjs.map

package/.dist/cjs/src/constants.kind.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.kind.cjs","sources":["../../../src/constants.kind.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} from '@deepkit/type';\nimport {RunType} from './types.ts';\n\nexport const ReflectionKindName: {[key: number]: keyof typeof ReflectionKind} = {\n    0: 'never',\n    1: 'any',\n    2: 'unknown',\n    3: 'void',\n    4: 'objectLiteral', // name was changed from deepkit's 'object' to 'objectLiteral'\n    5: 'string',\n    6: 'number',\n    7: 'boolean',\n    8: 'symbol',\n    9: 'bigint',\n    10: 'null',\n    11: 'undefined',\n    12: 'regexp',\n    13: 'literal',\n    14: 'templateLiteral',\n    15: 'property',\n    16: 'method',\n    17: 'function',\n    18: 'parameter',\n    19: 'promise',\n    20: 'class',\n    21: 'typeParameter',\n    22: 'enum',\n    23: 'union',\n    24: 'intersection',\n    25: 'array',\n    26: 'tuple',\n    27: 'tupleMember',\n    28: 'enumMember',\n    29: 'rest',\n    30: 'object', // name was changed from deepkit's 'objectLiteral' to 'object' for better error messages\n    31: 'indexSignature',\n    32: 'propertySignature',\n    33: 'methodSignature',\n    34: 'infer',\n    35: 'callSignature',\n};\n\n// ReflectionKind from deepkit is extended with the following sub kinds\nexport const ReflectionSubKind = {\n    // group of sub-kinds that extends ReflectionKind.class\n    date: 20_01,\n    map: 20_02,\n    set: 20_03,\n    nonSerializable: 20_04,\n\n    params: 17_01,\n    mapKey: 18_01,\n    mapValue: 18_02,\n    setItem: 18_03,\n} as const;\n\nexport const ReflectionSubNames: {[key: number]: keyof typeof ReflectionSubKind} = {\n    20_01: 'date',\n    20_02: 'map',\n    20_03: 'set',\n    17_01: 'params',\n} as const;\n\nexport type AnyKindName = keyof typeof ReflectionKind | keyof typeof ReflectionSubKind;\n\nexport function getReflectionName(rt: RunType): AnyKindName {\n    if (rt.src.subKind) return ReflectionSubNames[rt.src.subKind];\n    return ReflectionKindName[rt.src.kind];\n}\n"],"names":[],"mappings":";;;;AAUO,MAAM,qBAAmE;AAAA,EAC5E,GAAG;AAAA,EACH,GAAG;AAAA,EACH,GAAG;AAAA,EACH,GAAG;AAAA,EACH,GAAG;AAAA;AAAA,EACH,GAAG;AAAA,EACH,GAAG;AAAA,EACH,GAAG;AAAA,EACH,GAAG;AAAA,EACH,GAAG;AAAA,EACH,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;AAAA;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;;AAID,MAAM,oBAAoB;AAAA;AAAA,EAE7B,MAAM;AAAA,EACN,KAAK;AAAA,EACL,KAAK;AAAA,EACL,iBAAiB;AAAA,EAEjB,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,SAAS;;AAGN,MAAM,qBAAsE;AAAA,EAC/E,MAAO;AAAA,EACP,MAAO;AAAA,EACP,MAAO;AAAA,EACP,MAAO;;;AAKL,SAAU,kBAAkB,IAAW;AACzC,MAAI,GAAG,IAAI;AAAS,WAAO,mBAAmB,GAAG,IAAI,OAAO;AAC5D,SAAO,mBAAmB,GAAG,IAAI,IAAI;AACzC;;;;;;;"}