@mionjs/run-types 0.8.0-alpha.0

package/.dist/cjs/src/run-types-pure-fns.d.ts

@@ -0,0 +1,7 @@
+export declare const cpf_asJSONString: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_getUnknownKeysFromArray: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_hasUnknownKeysFromArray: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_newRunTypeErr: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_formatErr: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_safeIterableKey: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_sanitizeCompiledFn: import('@mionjs/core').CompiledPureFunction;

package/.dist/cjs/src/types.cjs

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const __ΩError = ["name", "message", "stack", "Error", 'P&4!&4"&4#8Mw$y'];
+const __ΩRecord = ["K", "T", "Record", `l'e#"Rb!b"Pde"!N#!w#y`];
+const __ΩStrNumber = ["StrNumber", "P&'Jw!y"];
+const __ΩJitCode = ["code", "CodeType", "type", "JitCode", 'PP&-J4!"w"4#Mw$y'];
+const __ΩSrcType = ["Type", "T", () => __ΩRunType, "_rt", () => __ΩStrNumber, "_typeId", "_formatId", () => __ΩSubKind, "subKind", "SrcType", `"w!c"Pe"!Pn#4$9n%4&89&4'89n(4)89MKw*y`];
+const __ΩRunTypeFamily = ["A", "C", "M", "F", "RunTypeFamily", 'P.!.".#.$Jw%y'];
+const __ΩRunType = [() => __ΩSrcType, "src", "getKindName", () => __ΩRunTypeFamily, "getFamily", () => __ΩDeepPartial, () => __ΩRunTypeOptions, "options", "", "mock", () => __ΩStrNumber, "getTypeID", () => __ΩRunTypeOptions, "opts", "getJitHash", () => __ΩJitFn, "jitFn", () => __ΩRunTypeOptions, "args", "createJitFunction", "RunType", 'P"o!"4"9P&1#Pn$1%Pn\'o&"2(8"`/)4*Pn+1,Pn-2.&1/Pn021n22.8P"@23"/)14Mw5y'];
+const __ΩSubKind = [() => ReflectionSubKind, () => ReflectionSubKind, "SubKind", 'i!i"gfw#y'];
+const __ΩRunTypeVisitor = ["Type", "deepkitType", () => __ΩRunType, "parents", () => __ΩRunTypeOptions, "opts", () => __ΩRunType, "", "RunTypeVisitor", `P"w!2"n#F2$n%2&n'/(w)y`];
+const __ΩSrcCollection = ["Type", "types", "SrcCollection", 'P"w!P"w!F4"MKw#y'];
+const __ΩSrcMember = ["Type", "type", "SrcMember", 'P"w!P"w!4"MKw#y'];
+const __ΩJitCompilerOpts = ["fnID", () => __ΩStrNumber, "typeID", "jitFnHash", () => __ΩRunTypeOptions, "opts", "JitCompilerOpts", `P&4!9n"4#9&4$9n%4&9Mw'y`];
+const __ΩRunTypeChildAccessor = [() => __ΩRunType, "JitFnCompiler", "comp", "getChildIndex", () => __ΩStrNumber, "getChildVarName", () => __ΩStrNumber, "getChildLiteral", "useArrayAccessor", "isOptional", "skipSettingAccessor", "skipCommas", "RunTypeChildAccessor", `Pn!P"w"2#'1$P"w"2#n%1&P"w"2#n'1(P)1)P)1*P)1+8)4,8Mw-y`];
+const __ΩCustomVλl = ["vλl", "isStandalone", "useArrayAccessor", "CustomVλl", 'P&4!)4"8)4#8Mw$y'];
+const __ΩRunTypeOptions = ["start", "end", "paramsSlice", () => __ΩMockOptions, "mock", "noLiterals", "noIsArrayCheck", "RunTypeOptions", `PP'4!8'4"8M4#8n$4%8)4&8)4'8Mw(y`];
+const __ΩPartialRunTypeOptions = [() => __ΩDeepPartial, () => __ΩRunTypeOptions, "PartialRunTypeOptions", 'n"o!"w#y'];
+const __ΩJitFn = [() => JitFunctions, () => JitFunctions, "JitFn", 'i!i"gfw#y'];
+const __ΩJitFnID = [() => __ΩJitFn, "id", "JitFnID", 'n!."fw#y'];
+const __ΩAnyFunction = ["TypeMethodSignature", "TypeCallSignature", "TypeFunction", "TypeMethod", "AnyFunction", 'P"w!"w""w#"w$Jw%y'];
+const __ΩAnyParameterListRunType = [() => __ΩAnyFunction, "TypeTuple", "AnyParameterListRunType", 'Pn!"w"Jw#y'];
+const __ΩMockOptions = ["anyValuesList", "minNumber", "maxNumber", "minDate", "maxDate", "enumIndex", "objectList", "promiseTimeOut", () => __ΩError, "promiseReject", "regexpList", "maxRandomStringLength", "stringLength", "stringCharSet", "symbolLength", "symbolCharSet", "symbolName", "maxRandomItemsLength", "arrayLength", "optionalProbability", () => __ΩRecord, () => __ΩStrNumber, "optionalPropertyProbability", () => __ΩRecord, () => __ΩStrNumber, "parentObj", "unionIndex", 0, "tupleOptions", 0, "paramsOptions", "maxStackDepth", "maxMockRecursion", "MockOptions", `P"F4!'4"8'4#8'4$8'4%8'4&8%F4''4(P&n)"J4*8AF4+'4,'4-8&4.'4/8&408&418'42'438'44n6'o5#478Pn9+J"o8#4:8'4;8n<F4=8n>F4?8'4@'4AMwBy`];
+const __ΩMockOperation = [() => __ΩMockOptions, () => __ΩRunType, "stack", () => __ΩJitFnID, "fnID", "MockOperation", 'Pn!n"F4#n$4%Mw&y'];
+const __ΩDKAnnotation = ["name", () => __ΩSrcType, "options", "DKAnnotation", 'P&4!n"4#Mw$y'];
+const __ΩFormatAnnotation = [() => __ΩDKAnnotation, "TypeFormatParams", "params", "BaseRunTypeFormat", "formatter", "FormatAnnotation", 'Pn!P"w"4#8"w$4%MKw&y'];
+const __ΩRunTypeAnnotation = ["name", () => __ΩRunType, "options", "RunTypeAnnotation", 'P&4!n"4#Mw$y'];
+const __ΩAnyClass = ["T", "args", "new", "AnyClass", '"c!PP"@2"e#!1#Mw$y'];
+const __ΩMutable = ["T", "Mutable", 'l+e#!e"!fRb!Pde"!gN#)w"y'];
+const __ΩDeepRequired = ["T", 0, "DeepRequired", 'lGe&!e"!fo""RPde%!gN#"Re$!RPe#!%qk.8QRb!Pde"!p<w#y'];
+const __ΩDeepPartial = ["T", 0, "DeepPartial", 'lGe&!e"!fo""RPde%!gN#"Re$!RPe#!%qk.8QRb!Pde"!p<w#y'];
+exports.__ΩAnyClass = __ΩAnyClass;
+exports.__ΩAnyFunction = __ΩAnyFunction;
+exports.__ΩAnyParameterListRunType = __ΩAnyParameterListRunType;
+exports.__ΩCustomVλl = __ΩCustomVλl;
+exports.__ΩDKAnnotation = __ΩDKAnnotation;
+exports.__ΩDeepPartial = __ΩDeepPartial;
+exports.__ΩDeepRequired = __ΩDeepRequired;
+exports.__ΩFormatAnnotation = __ΩFormatAnnotation;
+exports.__ΩJitCode = __ΩJitCode;
+exports.__ΩJitCompilerOpts = __ΩJitCompilerOpts;
+exports.__ΩJitFn = __ΩJitFn;
+exports.__ΩJitFnID = __ΩJitFnID;
+exports.__ΩMockOperation = __ΩMockOperation;
+exports.__ΩMockOptions = __ΩMockOptions;
+exports.__ΩMutable = __ΩMutable;
+exports.__ΩPartialRunTypeOptions = __ΩPartialRunTypeOptions;
+exports.__ΩRunType = __ΩRunType;
+exports.__ΩRunTypeAnnotation = __ΩRunTypeAnnotation;
+exports.__ΩRunTypeChildAccessor = __ΩRunTypeChildAccessor;
+exports.__ΩRunTypeFamily = __ΩRunTypeFamily;
+exports.__ΩRunTypeOptions = __ΩRunTypeOptions;
+exports.__ΩRunTypeVisitor = __ΩRunTypeVisitor;
+exports.__ΩSrcCollection = __ΩSrcCollection;
+exports.__ΩSrcMember = __ΩSrcMember;
+exports.__ΩSrcType = __ΩSrcType;
+exports.__ΩStrNumber = __ΩStrNumber;
+exports.__ΩSubKind = __ΩSubKind;
+//# sourceMappingURL=types.cjs.map

package/.dist/cjs/src/types.cjs.map

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

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

@@ -0,0 +1,152 @@
+import { Type, TypeCallSignature, TypeFunction, TypeMethod, TypeMethodSignature, TypeTuple } from '@deepkit/type';
+import { TypeFormatParams } from '@mionjs/core';
+import { JitFunctions, CodeType } from './constants.functions.ts';
+import { ReflectionSubKind } from './constants.kind.ts';
+import { BaseRunTypeFormat } from './lib/baseRunTypeFormat.ts';
+import { JitFnCompiler } from './lib/jitFnCompiler.ts';
+export type StrNumber = string | number;
+export type JitCode = {
+    code: string | undefined;
+    type: CodeType;
+};
+export type SrcType<T extends Type = Type> = T & {
+    readonly _rt: RunType;
+    readonly _typeId?: StrNumber;
+    readonly _formatId?: string;
+    readonly subKind?: SubKind;
+};
+export type RunTypeFamily = 'A' | 'C' | 'M' | 'F';
+export interface RunType {
+    readonly src: SrcType<any>;
+    getKindName(): string;
+    getFamily(): RunTypeFamily;
+    mock: (options?: DeepPartial<RunTypeOptions>) => Promise<any>;
+    getTypeID(): StrNumber;
+    getJitHash(opts: RunTypeOptions): string;
+    createJitFunction(jitFn: JitFn, opts?: RunTypeOptions): (...args: any[]) => any;
+}
+export type SubKind = (typeof ReflectionSubKind)[keyof typeof ReflectionSubKind];
+export type RunTypeVisitor = (deepkitType: Type, parents: RunType[], opts: RunTypeOptions) => RunType;
+export type SrcCollection = Type & {
+    types: Type[];
+};
+export type SrcMember = Type & {
+    type: Type;
+};
+export interface JitCompilerOpts {
+    readonly fnID: string;
+    readonly typeID: StrNumber;
+    readonly jitFnHash: string;
+    readonly opts: RunTypeOptions;
+}
+export interface RunTypeChildAccessor extends RunType {
+    getChildIndex(comp: JitFnCompiler): number;
+    getChildVarName(comp: JitFnCompiler): StrNumber;
+    getChildLiteral(comp: JitFnCompiler): StrNumber;
+    useArrayAccessor(): boolean;
+    isOptional(): boolean;
+    skipSettingAccessor?(): boolean;
+    skipCommas?: boolean;
+}
+export interface CustomVλl {
+    vλl: string;
+    isStandalone?: boolean;
+    useArrayAccessor?: boolean;
+}
+export interface RunTypeOptions {
+    paramsSlice?: {
+        start?: number;
+        end?: number;
+    };
+    mock?: MockOptions;
+    noLiterals?: boolean;
+    noIsArrayCheck?: boolean;
+}
+export type PartialRunTypeOptions = DeepPartial<RunTypeOptions>;
+export type JitFn = (typeof JitFunctions)[keyof typeof JitFunctions];
+export type JitFnID = JitFn['id'];
+export type AnyFunction = TypeMethodSignature | TypeCallSignature | TypeFunction | TypeMethod;
+export type AnyParameterListRunType = AnyFunction | TypeTuple;
+export interface MockOptions {
+    anyValuesList: any[];
+    minNumber?: number;
+    maxNumber?: number;
+    minDate?: number;
+    maxDate?: number;
+    enumIndex?: number;
+    objectList: object[];
+    promiseTimeOut: number;
+    promiseReject?: string | Error | any;
+    regexpList: RegExp[];
+    maxRandomStringLength: number;
+    stringLength?: number;
+    stringCharSet: string;
+    symbolLength?: number;
+    symbolCharSet?: string;
+    symbolName?: string;
+    maxRandomItemsLength: number;
+    arrayLength?: number;
+    optionalProbability: number;
+    optionalPropertyProbability?: Record<StrNumber, number>;
+    parentObj?: Record<StrNumber | symbol, any>;
+    unionIndex?: number;
+    tupleOptions?: MockOptions[];
+    paramsOptions?: MockOptions[];
+    maxStackDepth: number;
+    maxMockRecursion: number;
+}
+export interface MockOperation extends MockOptions {
+    stack: RunType[];
+    fnID: JitFnID;
+}
+export type DKAnnotation = {
+    name: string;
+    options: SrcType;
+};
+export type FormatAnnotation = DKAnnotation & {
+    params?: TypeFormatParams;
+    formatter: BaseRunTypeFormat;
+};
+export type RunTypeAnnotation = {
+    name: string;
+    options: RunType;
+};
+export interface AnyClass<T = any> {
+    new (...args: any[]): T;
+}
+export type Mutable<T> = {
+    -readonly [K in keyof T]: T[K];
+};
+export type DeepRequired<T> = T extends object ? {
+    [P in keyof T]?: DeepRequired<T[P]>;
+} : T;
+export type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+export declare type __ΩStrNumber = any[];
+export declare type __ΩJitCode = any[];
+export declare type __ΩSrcType = any[];
+export declare type __ΩRunTypeFamily = any[];
+export declare type __ΩRunType = any[];
+export declare type __ΩSubKind = any[];
+export declare type __ΩRunTypeVisitor = any[];
+export declare type __ΩSrcCollection = any[];
+export declare type __ΩSrcMember = any[];
+export declare type __ΩJitCompilerOpts = any[];
+export declare type __ΩRunTypeChildAccessor = any[];
+export declare type __ΩCustomVλl = any[];
+export declare type __ΩRunTypeOptions = any[];
+export declare type __ΩPartialRunTypeOptions = any[];
+export declare type __ΩJitFn = any[];
+export declare type __ΩJitFnID = any[];
+export declare type __ΩAnyFunction = any[];
+export declare type __ΩAnyParameterListRunType = any[];
+export declare type __ΩMockOptions = any[];
+export declare type __ΩMockOperation = any[];
+export declare type __ΩDKAnnotation = any[];
+export declare type __ΩFormatAnnotation = any[];
+export declare type __ΩRunTypeAnnotation = any[];
+export declare type __ΩAnyClass = any[];
+export declare type __ΩMutable = any[];
+export declare type __ΩDeepRequired = any[];
+export declare type __ΩDeepPartial = any[];

package/.dist/esm/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/esm/index.js

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

package/.dist/esm/index.js.map

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

package/.dist/esm/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;