@mionjs/run-types 0.8.0-alpha.0

package/.dist/cjs/index.cjs

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_types = require("./src/types.cjs");
+const src_constants_functions = require("./src/constants.functions.cjs");
+const src_constants_kind = require("./src/constants.kind.cjs");
+const src_constants = require("./src/constants.cjs");
+const src_createRunType = require("./src/createRunType.cjs");
+const src_createRunTypeFunctions = require("./src/createRunTypeFunctions.cjs");
+const src_formats_runtype = require("./src/formats.runtype.cjs");
+const src_lib_typeId = require("./src/lib/typeId.cjs");
+const src_lib_dkProxy = require("./src/lib/dkProxy.cjs");
+const src_lib_baseRunTypeFormat = require("./src/lib/baseRunTypeFormat.cjs");
+const src_lib_baseRunTypes = require("./src/lib/baseRunTypes.cjs");
+const src_lib_formats = require("./src/lib/formats.cjs");
+const src_lib_guards = require("./src/lib/guards.cjs");
+const src_lib_jitFnCompiler = require("./src/lib/jitFnCompiler.cjs");
+const src_lib_jitFnsRegistry = require("./src/lib/jitFnsRegistry.cjs");
+const src_mocking_constants_mock = require("./src/mocking/constants.mock.cjs");
+const src_mocking_mockRegistry = require("./src/mocking/mockRegistry.cjs");
+const src_mocking_mockType = require("./src/mocking/mockType.cjs");
+const src_mocking_mockUtils = require("./src/mocking/mockUtils.cjs");
+const src_runTypesPureFns = require("./src/run-types-pure-fns.cjs");
+exports.__ΩAnyClass = src_types.__ΩAnyClass;
+exports.__ΩAnyFunction = src_types.__ΩAnyFunction;
+exports.__ΩAnyParameterListRunType = src_types.__ΩAnyParameterListRunType;
+exports.__ΩCustomVλl = src_types.__ΩCustomVλl;
+exports.__ΩDKAnnotation = src_types.__ΩDKAnnotation;
+exports.__ΩDeepPartial = src_types.__ΩDeepPartial;
+exports.__ΩDeepRequired = src_types.__ΩDeepRequired;
+exports.__ΩFormatAnnotation = src_types.__ΩFormatAnnotation;
+exports.__ΩJitCode = src_types.__ΩJitCode;
+exports.__ΩJitCompilerOpts = src_types.__ΩJitCompilerOpts;
+exports.__ΩJitFn = src_types.__ΩJitFn;
+exports.__ΩJitFnID = src_types.__ΩJitFnID;
+exports.__ΩMockOperation = src_types.__ΩMockOperation;
+exports.__ΩMockOptions = src_types.__ΩMockOptions;
+exports.__ΩMutable = src_types.__ΩMutable;
+exports.__ΩPartialRunTypeOptions = src_types.__ΩPartialRunTypeOptions;
+exports.__ΩRunType = src_types.__ΩRunType;
+exports.__ΩRunTypeAnnotation = src_types.__ΩRunTypeAnnotation;
+exports.__ΩRunTypeChildAccessor = src_types.__ΩRunTypeChildAccessor;
+exports.__ΩRunTypeFamily = src_types.__ΩRunTypeFamily;
+exports.__ΩRunTypeOptions = src_types.__ΩRunTypeOptions;
+exports.__ΩRunTypeVisitor = src_types.__ΩRunTypeVisitor;
+exports.__ΩSrcCollection = src_types.__ΩSrcCollection;
+exports.__ΩSrcMember = src_types.__ΩSrcMember;
+exports.__ΩSrcType = src_types.__ΩSrcType;
+exports.__ΩStrNumber = src_types.__ΩStrNumber;
+exports.__ΩSubKind = src_types.__ΩSubKind;
+exports.CodeTypes = src_constants_functions.CodeTypes;
+exports.JitFunctions = src_constants_functions.JitFunctions;
+exports.__ΩCodeType = src_constants_functions.__ΩCodeType;
+exports.__ΩJitFnSettings = src_constants_functions.__ΩJitFnSettings;
+exports.jitArgs = src_constants_functions.jitArgs;
+exports.jitArgsWithOptions = src_constants_functions.jitArgsWithOptions;
+exports.jitBinaryDeserializerArgs = src_constants_functions.jitBinaryDeserializerArgs;
+exports.jitBinarySerializerArgs = src_constants_functions.jitBinarySerializerArgs;
+exports.jitDefaultArgs = src_constants_functions.jitDefaultArgs;
+exports.jitDefaultArgsWithOptions = src_constants_functions.jitDefaultArgsWithOptions;
+exports.jitDefaultBinaryDeserializerArgs = src_constants_functions.jitDefaultBinaryDeserializerArgs;
+exports.jitDefaultBinarySerializerArgs = src_constants_functions.jitDefaultBinarySerializerArgs;
+exports.jitDefaultErrorArgs = src_constants_functions.jitDefaultErrorArgs;
+exports.jitErrorArgs = src_constants_functions.jitErrorArgs;
+exports.jitFunctionList = src_constants_functions.jitFunctionList;
+exports.jitFunctionsById = src_constants_functions.jitFunctionsById;
+exports.jitSerializationFunctions = src_constants_functions.jitSerializationFunctions;
+exports.jitValidationFunctions = src_constants_functions.jitValidationFunctions;
+exports.ReflectionKindName = src_constants_kind.ReflectionKindName;
+exports.ReflectionSubKind = src_constants_kind.ReflectionSubKind;
+exports.ReflectionSubNames = src_constants_kind.ReflectionSubNames;
+exports.__ΩAnyKindName = src_constants_kind.__ΩAnyKindName;
+exports.getReflectionName = src_constants_kind.getReflectionName;
+exports.JIT_STACK_TRACE_MESSAGE = src_constants.JIT_STACK_TRACE_MESSAGE;
+exports.MAX_UNION_ITEMS = src_constants.MAX_UNION_ITEMS;
+exports.maxStackErrorMessage = src_constants.maxStackErrorMessage;
+exports.nativeUtilityStringTypes = src_constants.nativeUtilityStringTypes;
+exports.nonSerializableClasses = src_constants.nonSerializableClasses;
+exports.nonSerializableGlobals = src_constants.nonSerializableGlobals;
+exports.validPropertyNameRegExp = src_constants.validPropertyNameRegExp;
+exports.reflectFunction = src_createRunType.reflectFunction;
+exports.runType = src_createRunType.runType;
+exports.createFromBinaryFn = src_createRunTypeFunctions.createFromBinaryFn;
+exports.createIsTypeFn = src_createRunTypeFunctions.createIsTypeFn;
+exports.createMockTypeFn = src_createRunTypeFunctions.createMockTypeFn;
+exports.createPrepareForJsonFn = src_createRunTypeFunctions.createPrepareForJsonFn;
+exports.createRestoreFromJsonFn = src_createRunTypeFunctions.createRestoreFromJsonFn;
+exports.createStringifyJsonFn = src_createRunTypeFunctions.createStringifyJsonFn;
+exports.createToBinaryFn = src_createRunTypeFunctions.createToBinaryFn;
+exports.createToJavascriptFn = src_createRunTypeFunctions.createToJavascriptFn;
+exports.createTypeErrorsFn = src_createRunTypeFunctions.createTypeErrorsFn;
+exports.__ΩTypeFormat = src_formats_runtype.__ΩTypeFormat;
+exports.computeDeepkitFormatID = src_lib_typeId.computeDeepkitFormatID;
+exports.createTypeId = src_lib_typeId.createTypeId;
+exports.getParsedAnnotationOptions = src_lib_dkProxy.getParsedAnnotationOptions;
+exports.getRunTypeAnnotations = src_lib_dkProxy.getRunTypeAnnotations;
+exports.getTypeToObject = src_lib_dkProxy.getTypeToObject;
+exports.BaseRunTypeFormat = src_lib_baseRunTypeFormat.BaseRunTypeFormat;
+exports.AtomicRunType = src_lib_baseRunTypes.AtomicRunType;
+exports.BaseRunType = src_lib_baseRunTypes.BaseRunType;
+exports.CollectionRunType = src_lib_baseRunTypes.CollectionRunType;
+exports.MemberRunType = src_lib_baseRunTypes.MemberRunType;
+exports.defaultIgnoreFormatProps = src_lib_formats.defaultIgnoreFormatProps;
+exports.dependenciesToLiteral = src_lib_formats.dependenciesToLiteral;
+exports.getFormatAnnotation = src_lib_formats.getFormatAnnotation;
+exports.getFormatterFromCache = src_lib_formats.getFormatterFromCache;
+exports.getFormatterKey = src_lib_formats.getFormatterKey;
+exports.getFormatterParams = src_lib_formats.getFormatterParams;
+exports.getRunTypeFormat = src_lib_formats.getRunTypeFormat;
+exports.getRunTypeTransformer = src_lib_formats.getRunTypeTransformer;
+exports.getToLiteralFn = src_lib_formats.getToLiteralFn;
+exports.initFormatAnnotations = src_lib_formats.initFormatAnnotations;
+exports.paramsToLiteral = src_lib_formats.paramsToLiteral;
+exports.registerFormatter = src_lib_formats.registerFormatter;
+exports.hasArguments = src_lib_guards.hasArguments;
+exports.hasExtends = src_lib_guards.hasExtends;
+exports.hasExtendsArguments = src_lib_guards.hasExtendsArguments;
+exports.hasImplements = src_lib_guards.hasImplements;
+exports.hasIndexType = src_lib_guards.hasIndexType;
+exports.hasMembers = src_lib_guards.hasMembers;
+exports.hasParameters = src_lib_guards.hasParameters;
+exports.hasReturn = src_lib_guards.hasReturn;
+exports.hasType = src_lib_guards.hasType;
+exports.hasTypeArguments = src_lib_guards.hasTypeArguments;
+exports.hasTypeParameters = src_lib_guards.hasTypeParameters;
+exports.hasTypes = src_lib_guards.hasTypes;
+exports.isAnyFunctionRunType = src_lib_guards.isAnyFunctionRunType;
+exports.isAnyRunType = src_lib_guards.isAnyRunType;
+exports.isArrayRunType = src_lib_guards.isArrayRunType;
+exports.isAtomicRunType = src_lib_guards.isAtomicRunType;
+exports.isBigIntRunType = src_lib_guards.isBigIntRunType;
+exports.isBooleanRunType = src_lib_guards.isBooleanRunType;
+exports.isCallSignatureRunType = src_lib_guards.isCallSignatureRunType;
+exports.isChildAccessorType = src_lib_guards.isChildAccessorType;
+exports.isClassRunType = src_lib_guards.isClassRunType;
+exports.isCollectionRunType = src_lib_guards.isCollectionRunType;
+exports.isConstructor = src_lib_guards.isConstructor;
+exports.isDateRunType = src_lib_guards.isDateRunType;
+exports.isEnumMemberRunType = src_lib_guards.isEnumMemberRunType;
+exports.isEnumRunType = src_lib_guards.isEnumRunType;
+exports.isFormatParamMeta = src_lib_guards.isFormatParamMeta;
+exports.isFunctionParamsRunType = src_lib_guards.isFunctionParamsRunType;
+exports.isFunctionRunType = src_lib_guards.isFunctionRunType;
+exports.isIndexSignatureRunType = src_lib_guards.isIndexSignatureRunType;
+exports.isInterfaceRunType = src_lib_guards.isInterfaceRunType;
+exports.isIntersectionRunType = src_lib_guards.isIntersectionRunType;
+exports.isJitErrorsCompiler = src_lib_guards.isJitErrorsCompiler;
+exports.isLiteralRunType = src_lib_guards.isLiteralRunType;
+exports.isMemberRunType = src_lib_guards.isMemberRunType;
+exports.isMethodSignatureRunType = src_lib_guards.isMethodSignatureRunType;
+exports.isNativeUtilityStringTypes = src_lib_guards.isNativeUtilityStringTypes;
+exports.isNeverRunType = src_lib_guards.isNeverRunType;
+exports.isNonSerializableClass = src_lib_guards.isNonSerializableClass;
+exports.isNonSerializableObject = src_lib_guards.isNonSerializableObject;
+exports.isNullRunType = src_lib_guards.isNullRunType;
+exports.isNumberRunType = src_lib_guards.isNumberRunType;
+exports.isObjectLiteralRunType = src_lib_guards.isObjectLiteralRunType;
+exports.isObjectRunType = src_lib_guards.isObjectRunType;
+exports.isParameterRunType = src_lib_guards.isParameterRunType;
+exports.isPromiseRunType = src_lib_guards.isPromiseRunType;
+exports.isPropertyRunType = src_lib_guards.isPropertyRunType;
+exports.isPropertySignatureRunType = src_lib_guards.isPropertySignatureRunType;
+exports.isRegexpRunType = src_lib_guards.isRegexpRunType;
+exports.isRunType = src_lib_guards.isRunType;
+exports.isStringRunType = src_lib_guards.isStringRunType;
+exports.isSymbolRunType = src_lib_guards.isSymbolRunType;
+exports.isTupleMemberRunType = src_lib_guards.isTupleMemberRunType;
+exports.isTupleRunType = src_lib_guards.isTupleRunType;
+exports.isUndefinedRunType = src_lib_guards.isUndefinedRunType;
+exports.isUnionRunType = src_lib_guards.isUnionRunType;
+exports.isUnknownRunType = src_lib_guards.isUnknownRunType;
+exports.isVoidRunType = src_lib_guards.isVoidRunType;
+exports.BaseFnCompiler = src_lib_jitFnCompiler.BaseFnCompiler;
+exports.JitErrorsFnCompiler = src_lib_jitFnCompiler.JitErrorsFnCompiler;
+exports.JitFnCompiler = src_lib_jitFnCompiler.JitFnCompiler;
+exports.MockJitCompiler = src_lib_jitFnCompiler.MockJitCompiler;
+exports.createJitCompiler = src_lib_jitFnCompiler.createJitCompiler;
+exports.printClosure = src_lib_jitFnCompiler.printClosure;
+exports.getJITFnName = src_lib_jitFnsRegistry.getJITFnName;
+exports.getJitFnSettings = src_lib_jitFnsRegistry.getJitFnSettings;
+exports.getJitFunctionCompiler = src_lib_jitFnsRegistry.getJitFunctionCompiler;
+exports.registerJitFunctionCompiler = src_lib_jitFnsRegistry.registerJitFunctionCompiler;
+exports.anyValuesList = src_mocking_constants_mock.anyValuesList;
+exports.defaultMockOptions = src_mocking_constants_mock.defaultMockOptions;
+exports.emailLocalPartSymbols = src_mocking_constants_mock.emailLocalPartSymbols;
+exports.mockObjectList = src_mocking_constants_mock.mockObjectList;
+exports.mockRegExpsList = src_mocking_constants_mock.mockRegExpsList;
+exports.stringCharSet = src_mocking_constants_mock.stringCharSet;
+exports.getMockCompiler = src_mocking_mockRegistry.getMockCompiler;
+exports.setMockCompiler = src_mocking_mockRegistry.setMockCompiler;
+exports.mockType = src_mocking_mockType.mockType;
+exports.mockAny = src_mocking_mockUtils.mockAny;
+exports.mockBigInt = src_mocking_mockUtils.mockBigInt;
+exports.mockBoolean = src_mocking_mockUtils.mockBoolean;
+exports.mockDate = src_mocking_mockUtils.mockDate;
+exports.mockNumber = src_mocking_mockUtils.mockNumber;
+exports.mockRecursiveEmptyArray = src_mocking_mockUtils.mockRecursiveEmptyArray;
+exports.mockRegExp = src_mocking_mockUtils.mockRegExp;
+exports.mockString = src_mocking_mockUtils.mockString;
+exports.mockSymbol = src_mocking_mockUtils.mockSymbol;
+exports.random = src_mocking_mockUtils.random;
+exports.randomItem = src_mocking_mockUtils.randomItem;
+exports.cpf_asJSONString = src_runTypesPureFns.cpf_asJSONString;
+exports.cpf_formatErr = src_runTypesPureFns.cpf_formatErr;
+exports.cpf_getUnknownKeysFromArray = src_runTypesPureFns.cpf_getUnknownKeysFromArray;
+exports.cpf_hasUnknownKeysFromArray = src_runTypesPureFns.cpf_hasUnknownKeysFromArray;
+exports.cpf_newRunTypeErr = src_runTypesPureFns.cpf_newRunTypeErr;
+exports.cpf_safeIterableKey = src_runTypesPureFns.cpf_safeIterableKey;
+exports.cpf_sanitizeCompiledFn = src_runTypesPureFns.cpf_sanitizeCompiledFn;
+//# sourceMappingURL=index.cjs.map

package/.dist/cjs/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/.dist/cjs/index.d.ts

@@ -0,0 +1,60 @@
+export * from './src/types.ts';
+export * from './src/constants.functions.ts';
+export * from './src/constants.kind.ts';
+export * from './src/constants.ts';
+export * from './src/createRunType.ts';
+export * from './src/createRunTypeFunctions.ts';
+export * from './src/formats.runtype.ts';
+export * from './src/lib/typeId.ts';
+export * from './src/lib/dkProxy.ts';
+export * from './src/lib/baseRunTypeFormat.ts';
+export * from './src/lib/baseRunTypes.ts';
+export * from './src/lib/formats.ts';
+export * from './src/lib/guards.ts';
+export * from './src/lib/jitFnCompiler.ts';
+export * from './src/lib/jitFnsRegistry.ts';
+export * from './src/mocking/constants.mock.ts';
+export * from './src/mocking/mockRegistry.ts';
+export * from './src/mocking/mockType.ts';
+export * from './src/mocking/mockUtils.ts';
+export * from './src/run-types-pure-fns.ts';
+export type * from './src/nodes/atomic/any.ts';
+export type * from './src/nodes/atomic/bigInt.ts';
+export type * from './src/nodes/atomic/boolean.ts';
+export type * from './src/nodes/atomic/date.ts';
+export type * from './src/nodes/atomic/enum.ts';
+export type * from './src/nodes/atomic/enumMember.ts';
+export type * from './src/nodes/atomic/literal.ts';
+export type * from './src/nodes/atomic/never.ts';
+export type * from './src/nodes/atomic/null.ts';
+export type * from './src/nodes/atomic/number.ts';
+export type * from './src/nodes/atomic/object.ts';
+export type * from './src/nodes/atomic/regexp.ts';
+export type * from './src/nodes/atomic/string.ts';
+export type * from './src/nodes/atomic/symbol.ts';
+export type * from './src/nodes/atomic/undefined.ts';
+export type * from './src/nodes/atomic/unknown.ts';
+export type * from './src/nodes/atomic/void.ts';
+export type * from './src/nodes/collection/class.ts';
+export type * from './src/nodes/collection/functionParams.ts';
+export type * from './src/nodes/collection/interface.ts';
+export type * from './src/nodes/collection/intersection.ts';
+export type * from './src/nodes/collection/tuple.ts';
+export type * from './src/nodes/collection/union.ts';
+export type * from './src/nodes/collection/unionDiscriminator.ts';
+export type * from './src/nodes/function/function.ts';
+export type * from './src/nodes/member/array.ts';
+export type * from './src/nodes/member/callSignature.ts';
+export type * from './src/nodes/member/genericMember.ts';
+export type * from './src/nodes/member/indexProperty.ts';
+export type * from './src/nodes/member/method.ts';
+export type * from './src/nodes/member/methodSignature.ts';
+export type * from './src/nodes/member/param.ts';
+export type * from './src/nodes/member/property.ts';
+export type * from './src/nodes/member/restParams.ts';
+export type * from './src/nodes/member/tupleMember.ts';
+export type * from './src/nodes/native/Iterable.ts';
+export type * from './src/nodes/native/map.ts';
+export type * from './src/nodes/native/nonSerializable.ts';
+export type * from './src/nodes/native/promise.ts';
+export type * from './src/nodes/native/set.ts';

package/.dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

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

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const nonSerializableClasses = [
+  // TODO: decide what to do with native errors, they should be easily serializable
+  Error,
+  EvalError,
+  RangeError,
+  ReferenceError,
+  SyntaxError,
+  TypeError,
+  URIError,
+  AggregateError,
+  // Promise, // Promise has it's own RunType
+  // data types
+  WeakMap,
+  WeakSet,
+  DataView,
+  ArrayBuffer,
+  SharedArrayBuffer,
+  Float32Array,
+  Float64Array,
+  Int8Array,
+  Int16Array,
+  Int32Array,
+  Uint8Array,
+  Uint8ClampedArray,
+  Uint16Array,
+  Uint32Array,
+  BigInt64Array,
+  BigUint64Array
+];
+const nonSerializableGlobals = [
+  // TODO: decide what to do with native errors, they should be easily serializable
+  "Error",
+  "EvalError",
+  "RangeError",
+  "ReferenceError",
+  "SyntaxError",
+  "TypeError",
+  "URIError",
+  "AggregateError",
+  // data types
+  "WeakMap",
+  "WeakSet",
+  "DataView",
+  "ArrayBuffer",
+  "SharedArrayBuffer",
+  "Float32Array",
+  "Float64Array",
+  "Int8Array",
+  "Int16Array",
+  "Int32Array",
+  "Uint8Array",
+  "Uint8ClampedArray",
+  "Uint16Array",
+  "Uint32Array",
+  "BigInt64Array",
+  "BigUint64Array",
+  // bellow are common interface names from standard libraries, they added here but not tested
+  "Generator",
+  "GeneratorFunction",
+  "AsyncGenerator",
+  "Iterator",
+  "AsyncGeneratorFunction",
+  "AsyncIterator"
+];
+const nativeUtilityStringTypes = ["Uppercase", "Lowercase", "Capitalize", "Uncapitalize"];
+const validPropertyNameRegExp = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+const maxStackErrorMessage = "Max compilation nested level reached, either you have a very deeply nested type or there is an error related to circular references un the types.";
+const JIT_STACK_TRACE_MESSAGE = "\nJIT runType trace => ";
+const MAX_UNION_ITEMS = 2 ** 16 - 1;
+exports.JIT_STACK_TRACE_MESSAGE = JIT_STACK_TRACE_MESSAGE;
+exports.MAX_UNION_ITEMS = MAX_UNION_ITEMS;
+exports.maxStackErrorMessage = maxStackErrorMessage;
+exports.nativeUtilityStringTypes = nativeUtilityStringTypes;
+exports.nonSerializableClasses = nonSerializableClasses;
+exports.nonSerializableGlobals = nonSerializableGlobals;
+exports.validPropertyNameRegExp = validPropertyNameRegExp;
+//# sourceMappingURL=constants.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

@@ -0,0 +1,7 @@
+export declare const nonSerializableClasses: (ErrorConstructor | AggregateErrorConstructor | WeakMapConstructor | WeakSetConstructor | DataViewConstructor | ArrayBufferConstructor | SharedArrayBufferConstructor | Float32ArrayConstructor | Float64ArrayConstructor | Int8ArrayConstructor | Int16ArrayConstructor | Int32ArrayConstructor | Uint8ArrayConstructor | Uint8ClampedArrayConstructor | Uint16ArrayConstructor | Uint32ArrayConstructor | BigInt64ArrayConstructor | BigUint64ArrayConstructor)[];
+export declare const nonSerializableGlobals: string[];
+export declare const nativeUtilityStringTypes: string[];
+export declare const validPropertyNameRegExp: RegExp;
+export declare const maxStackErrorMessage = "Max compilation nested level reached, either you have a very deeply nested type or there is an error related to circular references un the types.";
+export declare const JIT_STACK_TRACE_MESSAGE = "\nJIT runType trace => ";
+export declare const MAX_UNION_ITEMS: number;

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

@@ -0,0 +1,181 @@
+"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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.functions.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}