@mionjs/run-types 0.8.10 → 0.13.0

package/.dist/esm/src/constants.kind.d.ts

@@ -1,22 +0,0 @@
-import { ReflectionKind } from '@deepkit/type';
-import { RunType } from './types.ts';
-export declare const ReflectionKindName: {
-    [key: number]: keyof typeof ReflectionKind;
-};
-export declare const ReflectionSubKind: {
-    readonly date: 2001;
-    readonly map: 2002;
-    readonly set: 2003;
-    readonly nonSerializable: 2004;
-    readonly params: 1701;
-    readonly mapKey: 1801;
-    readonly mapValue: 1802;
-    readonly setItem: 1803;
-};
-export declare const ReflectionSubNames: {
-    [key: number]: keyof typeof ReflectionSubKind;
-};
-export type AnyKindName = keyof typeof ReflectionKind | keyof typeof ReflectionSubKind;
-export declare function getReflectionName(rt: RunType): AnyKindName;
-export declare type __ΩAnyKindName = any[];
-//# sourceMappingURL=constants.kind.d.ts.map

package/.dist/esm/src/constants.kind.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.kind.d.ts","sourceRoot":"","sources":["../../../src/constants.kind.ts"],"names":[],"mappings":"AAOA,OAAO,EAAC,cAAc,EAAC,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAC,OAAO,EAAC,MAAM,YAAY,CAAC;AAEnC,eAAO,MAAM,kBAAkB,EAAE;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,OAAO,cAAc,CAAA;CAqC3E,CAAC;AAGF,eAAO,MAAM,iBAAiB;;;;;;;;;CAWpB,CAAC;AAEX,eAAO,MAAM,kBAAkB,EAAE;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,OAAO,iBAAiB,CAAA;CAKrE,CAAC;AAEX,MAAM,MAAM,WAAW,GAAG,MAAM,OAAO,cAAc,GAAG,MAAM,OAAO,iBAAiB,CAAC;AAEvF,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,OAAO,GAAG,WAAW,CAG1D"}

package/.dist/esm/src/constants.kind.js

@@ -1,74 +0,0 @@
-import { ReflectionKind } from "@deepkit/type";
-import { __ΩRunType as ___RunType } from "./types.js";
-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 = [() => 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 = [() => ___RunType, "rt", () => __ΩAnyKindName, "getReflectionName", 'Pn!2"n#/$'];
-export {
-  ReflectionKindName,
-  ReflectionSubKind,
-  ReflectionSubNames,
-  __ΩAnyKindName,
-  getReflectionName
-};
-//# sourceMappingURL=constants.kind.js.map

package/.dist/esm/src/constants.kind.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.kind.js","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;;"}

package/.dist/esm/src/createRunType.d.ts

@@ -1,6 +0,0 @@
-import { RunType } from './types.ts';
-import { ReceiveType } from '@deepkit/type';
-import { FunctionRunType } from './nodes/function/function.ts';
-export declare function runType<T>(type?: ReceiveType<T>): RunType;
-export declare function reflectFunction<Fn extends (...args: any[]) => any>(fn: Fn): FunctionRunType;
-//# sourceMappingURL=createRunType.d.ts.map

package/.dist/esm/src/createRunType.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createRunType.d.ts","sourceRoot":"","sources":["../../../src/createRunType.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAC,OAAO,EAAmB,MAAM,YAAY,CAAC;AAG1D,OAAO,EAAqC,WAAW,EAAyC,MAAM,eAAe,CAAC;AAuCtH,OAAO,EAAC,eAAe,EAAC,MAAM,8BAA8B,CAAC;AAgB7D,wBAAgB,OAAO,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,OAAO,CAUzD;AAED,wBAAgB,eAAe,CAAC,EAAE,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAAE,EAAE,EAAE,EAAE,GAAG,eAAe,CAI3F"}

package/.dist/esm/src/createRunType.js

@@ -1,286 +0,0 @@
-import { reflect, resolveReceiveType, stringifyType, typeAnnotation, ReflectionKind, __ΩReceiveType as ___ReceiveType } from "@deepkit/type";
-import { hasType, hasReturn, hasIndexType, hasTypes, hasParameters, hasArguments, hasExtendsArguments, hasImplements, isNonSerializableObject, isNativeUtilityStringTypes, isNonSerializableClass } from "./lib/guards.js";
-import { StringRunType } from "./nodes/atomic/string.js";
-import { DateRunType } from "./nodes/atomic/date.js";
-import { NumberRunType } from "./nodes/atomic/number.js";
-import { BooleanRunType } from "./nodes/atomic/boolean.js";
-import { NullRunType } from "./nodes/atomic/null.js";
-import { BigIntRunType } from "./nodes/atomic/bigInt.js";
-import { AnyRunType } from "./nodes/atomic/any.js";
-import { UndefinedRunType } from "./nodes/atomic/undefined.js";
-import { UnknownRunType } from "./nodes/atomic/unknown.js";
-import { VoidRunType } from "./nodes/atomic/void.js";
-import { ArrayRunType } from "./nodes/member/array.js";
-import { LiteralRunType } from "./nodes/atomic/literal.js";
-import { RegexpRunType } from "./nodes/atomic/regexp.js";
-import { NeverRunType } from "./nodes/atomic/never.js";
-import { EnumRunType } from "./nodes/atomic/enum.js";
-import { EnumMemberRunType } from "./nodes/atomic/enumMember.js";
-import { UnionRunType } from "./nodes/collection/union.js";
-import { TupleRunType } from "./nodes/collection/tuple.js";
-import { FunctionParamsRunType } from "./nodes/collection/functionParams.js";
-import { TupleMemberRunType } from "./nodes/member/tupleMember.js";
-import { InterfaceRunType } from "./nodes/collection/interface.js";
-import { PropertyRunType } from "./nodes/member/property.js";
-import { IndexSignatureRunType } from "./nodes/member/indexProperty.js";
-import { MethodSignatureRunType } from "./nodes/member/methodSignature.js";
-import { CallSignatureRunType } from "./nodes/member/callSignature.js";
-import { FunctionRunType } from "./nodes/function/function.js";
-import { PromiseRunType } from "./nodes/native/promise.js";
-import { ObjectRunType } from "./nodes/atomic/object.js";
-import { IntersectionRunType } from "./nodes/collection/intersection.js";
-import { TemplateLiteralRunType } from "./nodes/collection/templateLiteral.js";
-import { ParameterRunType } from "./nodes/member/param.js";
-import { MethodRunType } from "./nodes/member/method.js";
-import { RestParamsRunType } from "./nodes/member/restParams.js";
-import { ClassRunType } from "./nodes/collection/class.js";
-import { MapRunType } from "./nodes/native/map.js";
-import { ReflectionSubKind } from "./constants.kind.js";
-import { SetRunType } from "./nodes/native/set.js";
-import { SymbolRunType } from "./nodes/atomic/symbol.js";
-import { NonSerializableRunType } from "./nodes/native/nonSerializable.js";
-import { registerErrorDeserializers } from "@mionjs/core";
-function __assignType(fn, args) {
-  fn.__type = args;
-  return fn;
-}
-function runType(type = runType.Ω?.[0]) {
-  runType.Ω = void 0;
-  const start = Date.now();
-  const src = resolveReceiveType(type);
-  const took0 = Date.now() - start;
-  createRunTypes(src);
-  const took1 = Date.now() - start;
-  const diff = took1 - took0;
-  if (diff > 60)
-    console.warn(`RunType overhead is very long: ${diff}ms for ${stringifyType(src)}`);
-  return src._rt;
-}
-runType.__type = [() => ___ReceiveType, "type", "RunType", "runType", 'P"o!"2"8"w#/$'];
-function reflectFunction(fn) {
-  const src = reflect(fn);
-  runType(src);
-  return src._rt;
-}
-reflectFunction.__type = ["fn", () => FunctionRunType, "reflectFunction", 'P"2!P7"/#'];
-function createRunTypes(src) {
-  registerErrorDeserializers();
-  const stack = [src];
-  while (stack.length > 0) {
-    const current = stack.pop();
-    if (!current || current._rt)
-      continue;
-    try {
-      createRunType(current);
-    } catch (error) {
-      const typesStackMessage = "\nTypes Stack: " + stack.map(__assignType((t) => t.typeName || t.kind, ["t", "", 'P"2!"/"'])).join(", ");
-      error.message += typesStackMessage;
-      throw error;
-    }
-    if (hasType(current))
-      stack.push(current.type);
-    if (hasReturn(current))
-      stack.push(current.return);
-    if (hasIndexType(current))
-      stack.push(current.indexType);
-    if (current.origin)
-      stack.push(current.origin);
-    if (current.indexAccessOrigin?.index)
-      stack.push(current.indexAccessOrigin?.index);
-    if (current.indexAccessOrigin?.container)
-      stack.push(current.indexAccessOrigin?.container);
-    if (hasTypes(current))
-      pushToStack(current.types, stack);
-    if (hasParameters(current))
-      pushToStack(current.parameters, stack);
-    if (hasArguments(current))
-      pushToStack(current.arguments, stack);
-    if (hasExtendsArguments(current))
-      pushToStack(current.extendsArguments, stack);
-    if (hasImplements(current))
-      pushToStack(current.implements, stack);
-    if (current.typeArguments)
-      pushToStack(current.typeArguments, stack);
-    if (current.decorators)
-      pushToStack(current.decorators, stack);
-    if (current.scheduleDecorators)
-      pushToStack(current.scheduleDecorators, stack);
-    if (current.annotations) {
-      const annotations = typeAnnotation.getAnnotations(current);
-      for (const annotation of annotations)
-        stack.push(annotation.options);
-    }
-    current.originTypes?.forEach(__assignType((ot) => {
-      if (ot.typeArguments)
-        pushToStack(ot.typeArguments, stack);
-    }, ["ot", "", 'P"2!"/"']));
-    if (current.parent && !current.parent?._rt)
-      stack.push(current.parent);
-  }
-}
-createRunTypes.__type = ["SrcType", "src", "createRunTypes", 'P"w!2"$/#'];
-function pushToStack(subTypes, stack) {
-  if (Array.isArray(subTypes))
-    stack.push(...subTypes);
-}
-pushToStack.__type = ["Type", "subTypes", "stack", "pushToStack", 'P"w!F2""w!F2#"/$'];
-function createRunType(deepkitType) {
-  const existingType = deepkitType._rt;
-  if (existingType)
-    return existingType;
-  let rt;
-  switch (deepkitType.kind) {
-    // ###################### ATOMIC RUNTYPES ######################
-    // Primitive types and other atomic types that don't contain other types
-    case ReflectionKind.any:
-      rt = new AnyRunType();
-      break;
-    case ReflectionKind.bigint:
-      rt = new BigIntRunType();
-      break;
-    case ReflectionKind.boolean:
-      rt = new BooleanRunType();
-      break;
-    case ReflectionKind.enum:
-      rt = new EnumRunType();
-      break;
-    case ReflectionKind.enumMember:
-      rt = new EnumMemberRunType();
-      break;
-    case ReflectionKind.literal:
-      rt = new LiteralRunType();
-      break;
-    case ReflectionKind.never:
-      rt = isNativeUtilityStringTypes(deepkitType) ? new StringRunType() : new NeverRunType();
-      break;
-    case ReflectionKind.null:
-      rt = new NullRunType();
-      break;
-    case ReflectionKind.number:
-      rt = new NumberRunType();
-      break;
-    case ReflectionKind.object:
-      rt = new ObjectRunType();
-      break;
-    case ReflectionKind.regexp:
-      rt = new RegexpRunType();
-      break;
-    case ReflectionKind.string:
-      rt = new StringRunType();
-      break;
-    case ReflectionKind.symbol:
-      rt = new SymbolRunType();
-      break;
-    case ReflectionKind.templateLiteral:
-      rt = new TemplateLiteralRunType();
-      break;
-    case ReflectionKind.undefined:
-      rt = new UndefinedRunType();
-      break;
-    case ReflectionKind.unknown:
-      rt = new UnknownRunType();
-      break;
-    case ReflectionKind.void:
-      rt = new VoidRunType();
-      break;
-    // ###################### MEMBER RUNTYPES ######################
-    // Types that represent members of collections or other structures
-    case ReflectionKind.array:
-      rt = new ArrayRunType();
-      break;
-    case ReflectionKind.callSignature:
-      rt = new CallSignatureRunType();
-      break;
-    case ReflectionKind.function:
-      if (deepkitType.subKind === ReflectionSubKind.params) {
-        rt = new FunctionParamsRunType();
-      } else {
-        const frt = new FunctionRunType();
-        frt.parameterRunTypes.src = deepkitType;
-        rt = frt;
-      }
-      break;
-    case ReflectionKind.indexSignature:
-      rt = new IndexSignatureRunType();
-      break;
-    case ReflectionKind.method:
-      rt = new MethodRunType();
-      break;
-    case ReflectionKind.methodSignature:
-      rt = new MethodSignatureRunType();
-      break;
-    case ReflectionKind.parameter:
-      rt = new ParameterRunType();
-      break;
-    case ReflectionKind.property:
-    case ReflectionKind.propertySignature:
-      rt = new PropertyRunType();
-      break;
-    case ReflectionKind.rest:
-      rt = new RestParamsRunType();
-      break;
-    case ReflectionKind.tupleMember:
-      rt = new TupleMemberRunType();
-      break;
-    case ReflectionKind.promise:
-      rt = new PromiseRunType();
-      break;
-    // ###################### COLLECTION RUNTYPES ######################
-    case ReflectionKind.objectLiteral:
-      if (isNonSerializableObject(deepkitType)) {
-        rt = new NonSerializableRunType();
-      } else {
-        rt = new InterfaceRunType();
-      }
-      break;
-    case ReflectionKind.class:
-      rt = initClassRunType(deepkitType);
-      break;
-    // Types that contain other types as members
-    case ReflectionKind.infer:
-      throw new Error("Infer type not supported, ie: type MyType =Type<T> = T extends (...args: any[]) => infer R ? R : any; https://www.typescriptlang.org/docs/handbook/2/conditional-types.html");
-    case ReflectionKind.intersection:
-      rt = new IntersectionRunType();
-      break;
-    case ReflectionKind.tuple:
-      rt = new TupleRunType();
-      break;
-    case ReflectionKind.typeParameter:
-      throw new Error('TypeParameter not implemented. Type parameters are the generic placeholders in type definitions (e.g., T in Array<T>, ErrType in TypedError<ErrType>). Type parameters are typically resolved during type instantiation and should not appear in runtime type checking.This error is typically caused by a generic type missing type arguments, e.g.: TypedError instead of TypedError<"my-error">.');
-    // rType = resolveTypeParameter(deepkitType, opts, mapper);
-    case ReflectionKind.union:
-      rt = new UnionRunType();
-      break;
-    default:
-      rt = new AnyRunType();
-      break;
-  }
-  rt.onCreated(deepkitType);
-  return rt;
-}
-createRunType.__type = ["Mutable", "deepkitType", "RunType", "createRunType", 'P"w!2""w#/$'];
-function initClassRunType(src) {
-  switch (src.classType) {
-    case Date:
-      src.subKind = ReflectionSubKind.date;
-      return new DateRunType();
-    case Map:
-      src.subKind = ReflectionSubKind.map;
-      return new MapRunType();
-    case Set:
-      src.subKind = ReflectionSubKind.set;
-      return new SetRunType();
-    default:
-      if (isNonSerializableClass(src)) {
-        src.subKind = ReflectionSubKind.nonSerializable;
-        return new NonSerializableRunType();
-      }
-      return new ClassRunType();
-  }
-}
-initClassRunType.__type = ["TypeClass", "subKind", "src", "BaseRunType", "initClassRunType", `PP"w!P'4"8MK2#"w$/%`];
-export {
-  reflectFunction,
-  runType
-};
-//# sourceMappingURL=createRunType.js.map

package/.dist/esm/src/createRunType.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createRunType.js","sources":["../../../src/createRunType.ts"],"sourcesContent":["/* eslint-disable no-case-declarations */\n/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {RunType, Mutable, SrcType} from './types.ts';\nimport type {BaseRunType} from './lib/baseRunTypes.ts';\nimport type {TypeClass, Type} from '@deepkit/type';\nimport {ReflectionKind, resolveReceiveType, ReceiveType, reflect, typeAnnotation, stringifyType} from '@deepkit/type';\nimport {\n    hasArguments,\n    hasExtendsArguments,\n    hasImplements,\n    hasIndexType,\n    hasParameters,\n    hasReturn,\n    hasType,\n    hasTypes,\n    isNativeUtilityStringTypes,\n    isNonSerializableClass,\n    isNonSerializableObject,\n} from './lib/guards.ts';\nimport {StringRunType} from './nodes/atomic/string.ts';\nimport {DateRunType} from './nodes/atomic/date.ts';\nimport {NumberRunType} from './nodes/atomic/number.ts';\nimport {BooleanRunType} from './nodes/atomic/boolean.ts';\nimport {NullRunType} from './nodes/atomic/null.ts';\nimport {BigIntRunType} from './nodes/atomic/bigInt.ts';\nimport {AnyRunType} from './nodes/atomic/any.ts';\nimport {UndefinedRunType} from './nodes/atomic/undefined.ts';\nimport {UnknownRunType} from './nodes/atomic/unknown.ts';\nimport {VoidRunType} from './nodes/atomic/void.ts';\nimport {ArrayRunType} from './nodes/member/array.ts';\nimport {LiteralRunType} from './nodes/atomic/literal.ts';\nimport {RegexpRunType} from './nodes/atomic/regexp.ts';\nimport {NeverRunType} from './nodes/atomic/never.ts';\nimport {EnumRunType} from './nodes/atomic/enum.ts';\nimport {EnumMemberRunType} from './nodes/atomic/enumMember.ts';\nimport {UnionRunType} from './nodes/collection/union.ts';\nimport {TupleRunType} from './nodes/collection/tuple.ts';\nimport {FunctionParamsRunType} from './nodes/collection/functionParams.ts';\nimport {TupleMemberRunType} from './nodes/member/tupleMember.ts';\nimport {InterfaceRunType} from './nodes/collection/interface.ts';\nimport {PropertyRunType} from './nodes/member/property.ts';\nimport {IndexSignatureRunType} from './nodes/member/indexProperty.ts';\nimport {MethodSignatureRunType} from './nodes/member/methodSignature.ts';\nimport {CallSignatureRunType} from './nodes/member/callSignature.ts';\nimport {FunctionRunType} from './nodes/function/function.ts';\nimport {PromiseRunType} from './nodes/native/promise.ts';\nimport {ObjectRunType} from './nodes/atomic/object.ts';\nimport {IntersectionRunType} from './nodes/collection/intersection.ts';\nimport {TemplateLiteralRunType} from './nodes/collection/templateLiteral.ts';\nimport {ParameterRunType} from './nodes/member/param.ts';\nimport {MethodRunType} from './nodes/member/method.ts';\nimport {RestParamsRunType} from './nodes/member/restParams.ts';\nimport {ClassRunType} from './nodes/collection/class.ts';\nimport {MapRunType} from './nodes/native/map.ts';\nimport {ReflectionSubKind} from './constants.kind.ts';\nimport {SetRunType} from './nodes/native/set.ts';\nimport {SymbolRunType} from './nodes/atomic/symbol.ts';\nimport {NonSerializableRunType} from './nodes/native/nonSerializable.ts';\nimport {registerErrorDeserializers} from '@mionjs/core';\n\nexport function runType<T>(type?: ReceiveType<T>): RunType {\n    const start = Date.now();\n    const src = resolveReceiveType(type) as SrcType;\n    const took0 = Date.now() - start;\n    createRunTypes(src);\n    const took1 = Date.now() - start;\n    const diff = took1 - took0;\n    // max RunType overhead 60 ms\n    if (diff > 60) console.warn(`RunType overhead is very long: ${diff}ms for ${stringifyType(src)}`);\n    return src._rt;\n}\n\nexport function reflectFunction<Fn extends (...args: any[]) => any>(fn: Fn): FunctionRunType {\n    const src = reflect(fn) as SrcType;\n    runType(src);\n    return src._rt as FunctionRunType;\n}\n\n// We need to traverse all possible associated nodes to create all the runTypes\nfunction createRunTypes(src: SrcType): void {\n    registerErrorDeserializers();\n    const stack: Type[] = [src];\n\n    while (stack.length > 0) {\n        const current = stack.pop();\n        if (!current || (current as SrcType)._rt) continue;\n\n        try {\n            createRunType(current as Mutable<SrcType>);\n        } catch (error) {\n            const typesStackMessage = '\\nTypes Stack: ' + stack.map((t) => t.typeName || t.kind).join(', ');\n            (error as Error).message += typesStackMessage;\n            throw error;\n        }\n\n        // single child type nodes\n        if (hasType(current)) stack.push(current.type);\n        if (hasReturn(current)) stack.push(current.return);\n        if (hasIndexType(current)) stack.push(current.indexType);\n        if (current.origin) stack.push(current.origin);\n        if (current.indexAccessOrigin?.index) stack.push(current.indexAccessOrigin?.index);\n        if (current.indexAccessOrigin?.container) stack.push(current.indexAccessOrigin?.container);\n\n        // multiple child type nodes\n        if (hasTypes(current)) pushToStack(current.types, stack);\n        if (hasParameters(current)) pushToStack(current.parameters, stack);\n        if (hasArguments(current)) pushToStack(current.arguments, stack);\n        if (hasExtendsArguments(current)) pushToStack(current.extendsArguments, stack);\n        if (hasImplements(current)) pushToStack(current.implements, stack);\n        if (current.typeArguments) pushToStack(current.typeArguments, stack);\n        if (current.decorators) pushToStack(current.decorators, stack);\n        if (current.scheduleDecorators) pushToStack(current.scheduleDecorators, stack);\n\n        // annotations\n        if (current.annotations) {\n            const annotations = typeAnnotation.getAnnotations(current);\n            for (const annotation of annotations) stack.push(annotation.options);\n        }\n\n        // originTypes\n        current.originTypes?.forEach((ot) => {\n            if (ot.typeArguments) pushToStack(ot.typeArguments, stack);\n        });\n\n        // sometimes parent is an orphan so we need to explicitly add it to the stack\n        if (current.parent && !(current.parent as SrcType)?._rt) stack.push(current.parent);\n    }\n}\n\nfunction pushToStack(subTypes: Type[], stack: Type[]) {\n    if (Array.isArray(subTypes)) stack.push(...subTypes);\n}\n\nfunction createRunType(deepkitType: Mutable<SrcType>): RunType {\n    // console.log('deepkitType', deepkitType);\n\n    /*\n     RunType reference is stored in the deepkitType._runType so we can access both the deepkitType and the mion RunType,\n     basically every runType stores a reference to a deepkit type and vice versa.\n     This also relies on deepkit handling circular types to prevent infinite loop when we are generating RunTypes.\n    */\n    const existingType: RunType | undefined = deepkitType._rt;\n    // TODO: IMPORTANT: seems like deepkit can generate multiple types objects for the same type, so we need to handle this\n    // we are attaching the runType to the deepkit type (deepkitType._runType), to link the two types together\n    // but as deepkit can generate multiple types that means existingType will be null and the markAsCircular function is not working as expected\n    if (existingType) return existingType;\n\n    let rt: BaseRunType;\n\n    switch (deepkitType.kind) {\n        // ###################### ATOMIC RUNTYPES ######################\n        // Primitive types and other atomic types that don't contain other types\n        case ReflectionKind.any:\n            rt = new AnyRunType();\n            break;\n        case ReflectionKind.bigint:\n            rt = new BigIntRunType();\n            break;\n        case ReflectionKind.boolean:\n            rt = new BooleanRunType();\n            break;\n        case ReflectionKind.enum:\n            rt = new EnumRunType();\n            break;\n        case ReflectionKind.enumMember:\n            // enum members are resolved by the enum type, so this is not expected to be called\n            rt = new EnumMemberRunType();\n            break;\n        case ReflectionKind.literal:\n            rt = new LiteralRunType();\n            break;\n        case ReflectionKind.never:\n            // TODO add the string format feature\n            rt = isNativeUtilityStringTypes(deepkitType) ? new StringRunType() : new NeverRunType();\n            break;\n        case ReflectionKind.null:\n            rt = new NullRunType();\n            break;\n        case ReflectionKind.number:\n            rt = new NumberRunType();\n            break;\n        case ReflectionKind.object:\n            rt = new ObjectRunType();\n            break;\n        case ReflectionKind.regexp:\n            rt = new RegexpRunType();\n            break;\n        case ReflectionKind.string:\n            rt = new StringRunType();\n            break;\n        case ReflectionKind.symbol:\n            rt = new SymbolRunType();\n            break;\n        case ReflectionKind.templateLiteral:\n            // deepkit resolves finite template literal unions to literal-string unions before reaching here.\n            // this branch handles the open form ie: type T = `api/user/${number}` (children: literal/string/number/any/infer)\n            rt = new TemplateLiteralRunType();\n            break;\n        case ReflectionKind.undefined:\n            rt = new UndefinedRunType();\n            break;\n        case ReflectionKind.unknown:\n            rt = new UnknownRunType();\n            break;\n        case ReflectionKind.void:\n            rt = new VoidRunType();\n            break;\n\n        // ###################### MEMBER RUNTYPES ######################\n        // Types that represent members of collections or other structures\n        case ReflectionKind.array:\n            rt = new ArrayRunType();\n            break;\n        case ReflectionKind.callSignature:\n            rt = new CallSignatureRunType();\n            break;\n        case ReflectionKind.function:\n            if (deepkitType.subKind === ReflectionSubKind.params) {\n                rt = new FunctionParamsRunType();\n            } else {\n                const frt = new FunctionRunType();\n                // TODO review an change how we compile function parameters and return type\n                // those should also be jit functions, no need to check for array\n                // and maybe add option to target individual parameters\n                (frt.parameterRunTypes as Mutable<RunType>).src = deepkitType;\n                rt = frt;\n            }\n            break;\n        case ReflectionKind.indexSignature:\n            rt = new IndexSignatureRunType();\n            break;\n        case ReflectionKind.method:\n            rt = new MethodRunType();\n            break;\n        case ReflectionKind.methodSignature:\n            rt = new MethodSignatureRunType();\n            break;\n        case ReflectionKind.parameter:\n            rt = new ParameterRunType();\n            break;\n        case ReflectionKind.property:\n        case ReflectionKind.propertySignature:\n            rt = new PropertyRunType();\n            break;\n        case ReflectionKind.rest:\n            rt = new RestParamsRunType();\n            break;\n        case ReflectionKind.tupleMember:\n            rt = new TupleMemberRunType();\n            break;\n        case ReflectionKind.promise:\n            rt = new PromiseRunType();\n            break;\n\n        // ###################### COLLECTION RUNTYPES ######################\n        case ReflectionKind.objectLiteral:\n            if (isNonSerializableObject(deepkitType)) {\n                rt = new NonSerializableRunType();\n            } else {\n                rt = new InterfaceRunType();\n            }\n            break;\n        case ReflectionKind.class:\n            rt = initClassRunType(deepkitType);\n            break;\n        // Types that contain other types as members\n        case ReflectionKind.infer:\n            throw new Error(\n                'Infer type not supported, ie: type MyType =Type<T> = T extends (...args: any[]) => infer R ? R : any; https://www.typescriptlang.org/docs/handbook/2/conditional-types.html'\n            );\n\n        case ReflectionKind.intersection:\n            rt = new IntersectionRunType();\n            break;\n\n        case ReflectionKind.tuple:\n            rt = new TupleRunType();\n            break;\n        case ReflectionKind.typeParameter:\n            throw new Error(\n                'TypeParameter not implemented. Type parameters are the generic placeholders in type definitions (e.g., T in Array<T>, ErrType in TypedError<ErrType>). ' +\n                    'Type parameters are typically resolved during type instantiation and should not appear in runtime type checking.' +\n                    'This error is typically caused by a generic type missing type arguments, e.g.: TypedError instead of TypedError<\"my-error\">.'\n            );\n        // rType = resolveTypeParameter(deepkitType, opts, mapper);\n        case ReflectionKind.union:\n            rt = new UnionRunType();\n            break;\n        default:\n            rt = new AnyRunType();\n            break;\n    }\n    rt.onCreated(deepkitType);\n    // console.log('rt', rt);\n    return rt;\n}\n\nfunction initClassRunType(src: TypeClass & {subKind?: number}): BaseRunType {\n    switch (src.classType) {\n        case Date:\n            src.subKind = ReflectionSubKind.date;\n            return new DateRunType();\n        case Map:\n            src.subKind = ReflectionSubKind.map;\n            return new MapRunType();\n        case Set:\n            src.subKind = ReflectionSubKind.set;\n            return new SetRunType();\n        default:\n            if (isNonSerializableClass(src)) {\n                src.subKind = ReflectionSubKind.nonSerializable;\n                return new NonSerializableRunType();\n            }\n            return new ClassRunType();\n    }\n}\n"],"names":[],"mappings":"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"}

package/.dist/esm/src/createRunTypeFunctions.d.ts

@@ -1,13 +0,0 @@
-import { ReceiveType } from '@deepkit/type';
-import { RunTypeOptions } from './types.ts';
-import { FromBinaryFn, IsTypeFn, JsonStringifyFn, PrepareForJsonFn, RestoreFromJsonFn, ToBinaryFn, ToCodeFn, TypeErrorsFn } from '@mionjs/core';
-export declare function createIsTypeFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<IsTypeFn>;
-export declare function createTypeErrorsFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<TypeErrorsFn>;
-export declare function createPrepareForJsonFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<PrepareForJsonFn>;
-export declare function createRestoreFromJsonFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<RestoreFromJsonFn>;
-export declare function createStringifyJsonFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<JsonStringifyFn>;
-export declare function createToBinaryFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<ToBinaryFn>;
-export declare function createFromBinaryFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<FromBinaryFn>;
-export declare function createToJavascriptFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): ToCodeFn;
-export declare function createMockTypeFn<T>(type?: ReceiveType<T>): Promise<(opts?: Partial<RunTypeOptions>) => T>;
-//# sourceMappingURL=createRunTypeFunctions.d.ts.map

package/.dist/esm/src/createRunTypeFunctions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createRunTypeFunctions.d.ts","sourceRoot":"","sources":["../../../src/createRunTypeFunctions.ts"],"names":[],"mappings":"AAQA,OAAO,EAAC,WAAW,EAAC,MAAM,eAAe,CAAC;AAE1C,OAAO,EAAC,cAAc,EAAC,MAAM,YAAY,CAAC;AAC1C,OAAO,EACH,YAAY,EACZ,QAAQ,EACR,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,UAAU,EACV,QAAQ,EACR,YAAY,EACf,MAAM,cAAc,CAAC;AAUtB,wBAAsB,cAAc,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,cAAc,EAAE,IAAI,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,QAAQ,CAAC,CAGvG;AAGD,wBAAsB,kBAAkB,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,cAAc,EAAE,IAAI,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAG/G;AAMD,wBAAsB,sBAAsB,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,cAAc,EAAE,IAAI,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAGvH;AAMD,wBAAsB,uBAAuB,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,cAAc,EAAE,IAAI,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAGzH;AAOD,wBAAsB,qBAAqB,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,cAAc,EAAE,IAAI,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,eAAe,CAAC,CAGrH;AAGD,wBAAsB,gBAAgB,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,cAAc,EAAE,IAAI,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC,CAG3G;AAGD,wBAAsB,kBAAkB,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,cAAc,EAAE,IAAI,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAG/G;AAGD,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,cAAc,EAAE,IAAI,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,QAAQ,CAG9F;AAGD,wBAAsB,gBAAgB,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,CAI/G"}

package/.dist/esm/src/createRunTypeFunctions.js

@@ -1,78 +0,0 @@
-import { JitFunctions } from "./constants.functions.js";
-import { __ΩReceiveType as ___ReceiveType } from "@deepkit/type";
-import { runType } from "./createRunType.js";
-import { __ΩRunTypeOptions as ___RunTypeOptions } from "./types.js";
-import { __ΩIsTypeFn as ___IsTypeFn, __ΩTypeErrorsFn as ___TypeErrorsFn, __ΩPrepareForJsonFn as ___PrepareForJsonFn, __ΩRestoreFromJsonFn as ___RestoreFromJsonFn, __ΩJsonStringifyFn as ___JsonStringifyFn, __ΩToBinaryFn as ___ToBinaryFn, __ΩFromBinaryFn as ___FromBinaryFn, __ΩToCodeFn as ___ToCodeFn } from "@mionjs/core";
-import { registerJitFunctionCompiler } from "./lib/jitFnsRegistry.js";
-const __ΩPartial = ["T", "Partial", 'l+e#!e"!fRb!Pde"!gN#"w"y'];
-function __assignType(fn, args) {
-  fn.__type = args;
-  return fn;
-}
-async function createIsTypeFn(opts, type = createIsTypeFn.Ω?.[0]) {
-  createIsTypeFn.Ω = void 0;
-  const rt = runType(type);
-  return rt.createJitFunction(JitFunctions.isType, opts);
-}
-createIsTypeFn.__type = [() => ___RunTypeOptions, "opts", () => ___ReceiveType, "type", () => ___IsTypeFn, "createIsTypeFn", 'Pn!2"8"o#"2$8n%`/&'];
-async function createTypeErrorsFn(opts, type = createTypeErrorsFn.Ω?.[0]) {
-  createTypeErrorsFn.Ω = void 0;
-  const rt = runType(type);
-  return rt.createJitFunction(JitFunctions.typeErrors, opts);
-}
-createTypeErrorsFn.__type = [() => ___RunTypeOptions, "opts", () => ___ReceiveType, "type", () => ___TypeErrorsFn, "createTypeErrorsFn", 'Pn!2"8"o#"2$8n%`/&'];
-async function createPrepareForJsonFn(opts, type = createPrepareForJsonFn.Ω?.[0]) {
-  createPrepareForJsonFn.Ω = void 0;
-  const rt = runType(type);
-  return rt.createJitFunction(JitFunctions.prepareForJson, opts);
-}
-createPrepareForJsonFn.__type = [() => ___RunTypeOptions, "opts", () => ___ReceiveType, "type", () => ___PrepareForJsonFn, "createPrepareForJsonFn", 'Pn!2"8"o#"2$8n%`/&'];
-async function createRestoreFromJsonFn(opts, type = createRestoreFromJsonFn.Ω?.[0]) {
-  createRestoreFromJsonFn.Ω = void 0;
-  const rt = runType(type);
-  return rt.createJitFunction(JitFunctions.restoreFromJson, opts);
-}
-createRestoreFromJsonFn.__type = [() => ___RunTypeOptions, "opts", () => ___ReceiveType, "type", () => ___RestoreFromJsonFn, "createRestoreFromJsonFn", 'Pn!2"8"o#"2$8n%`/&'];
-async function createStringifyJsonFn(opts, type = createStringifyJsonFn.Ω?.[0]) {
-  createStringifyJsonFn.Ω = void 0;
-  const rt = runType(type);
-  return rt.createJitFunction(JitFunctions.stringifyJson, opts);
-}
-createStringifyJsonFn.__type = [() => ___RunTypeOptions, "opts", () => ___ReceiveType, "type", () => ___JsonStringifyFn, "createStringifyJsonFn", 'Pn!2"8"o#"2$8n%`/&'];
-async function createToBinaryFn(opts, type = createToBinaryFn.Ω?.[0]) {
-  createToBinaryFn.Ω = void 0;
-  const rt = runType(type);
-  return rt.createJitFunction(JitFunctions.toBinary, opts);
-}
-createToBinaryFn.__type = [() => ___RunTypeOptions, "opts", () => ___ReceiveType, "type", () => ___ToBinaryFn, "createToBinaryFn", 'Pn!2"8"o#"2$8n%`/&'];
-async function createFromBinaryFn(opts, type = createFromBinaryFn.Ω?.[0]) {
-  createFromBinaryFn.Ω = void 0;
-  const rt = runType(type);
-  return rt.createJitFunction(JitFunctions.fromBinary, opts);
-}
-createFromBinaryFn.__type = [() => ___RunTypeOptions, "opts", () => ___ReceiveType, "type", () => ___FromBinaryFn, "createFromBinaryFn", 'Pn!2"8"o#"2$8n%`/&'];
-function createToJavascriptFn(opts, type = createToJavascriptFn.Ω?.[0]) {
-  createToJavascriptFn.Ω = void 0;
-  const rt = runType(type);
-  return rt.createJitFunction(JitFunctions.toJSCode, opts);
-}
-createToJavascriptFn.__type = [() => ___RunTypeOptions, "opts", () => ___ReceiveType, "type", () => ___ToCodeFn, "createToJavascriptFn", 'Pn!2"8"o#"2$8n%/&'];
-async function createMockTypeFn(type = createMockTypeFn.Ω?.[0]) {
-  createMockTypeFn.Ω = void 0;
-  const rt = runType(type);
-  await registerJitFunctionCompiler(JitFunctions.mock);
-  return __assignType((opts) => rt.mockType(opts), [() => __ΩPartial, () => ___RunTypeOptions, "opts", "", 'Pn"o!"2#8"/$']);
-}
-createMockTypeFn.__type = [() => ___ReceiveType, "type", () => __ΩPartial, () => ___RunTypeOptions, "opts", "", "createMockTypeFn", 'P"o!"2"8Pn$o#"2%8"/&`/\''];
-export {
-  createFromBinaryFn,
-  createIsTypeFn,
-  createMockTypeFn,
-  createPrepareForJsonFn,
-  createRestoreFromJsonFn,
-  createStringifyJsonFn,
-  createToBinaryFn,
-  createToJavascriptFn,
-  createTypeErrorsFn
-};
-//# sourceMappingURL=createRunTypeFunctions.js.map

package/.dist/esm/src/createRunTypeFunctions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createRunTypeFunctions.js","sources":["../../../src/createRunTypeFunctions.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 {JitFunctions} from './constants.functions.ts';\nimport {ReceiveType} from '@deepkit/type';\nimport {runType} from './createRunType.ts';\nimport {RunTypeOptions} from './types.ts';\nimport {\n    FromBinaryFn,\n    IsTypeFn,\n    JsonStringifyFn,\n    PrepareForJsonFn,\n    RestoreFromJsonFn,\n    ToBinaryFn,\n    ToCodeFn,\n    TypeErrorsFn,\n} from '@mionjs/core';\nimport {BaseRunType} from './lib/baseRunTypes.ts';\nimport {registerJitFunctionCompiler} from './lib/jitFnsRegistry.ts';\n\n// All these functions are async because they might need to compile the jit function first\n// At the moment they are compiled synchronously, but in the future they might be async\n// Also some the src code to compile or functionality of the JIT functions might be loaded dynamically\n// ie: mocking functionality is loaded only when mockTypeFn is called\n\n/** Returns a function that checks if the given value is of the specified type. */\nexport async function createIsTypeFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<IsTypeFn> {\n    const rt = runType(type);\n    return rt.createJitFunction(JitFunctions.isType, opts);\n}\n\n/** Returns a function that get Type error data. */\nexport async function createTypeErrorsFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<TypeErrorsFn> {\n    const rt = runType(type);\n    return rt.createJitFunction(JitFunctions.typeErrors, opts);\n}\n\n/**\n * Returns a function that prepares a javascript type to be compatible with json.stringify.\n * Allows json.stringify special types like dates, bigints, maps, set, etc... that are not supported by json.stringify\n */\nexport async function createPrepareForJsonFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<PrepareForJsonFn> {\n    const rt = runType(type);\n    return rt.createJitFunction(JitFunctions.prepareForJson, opts);\n}\n\n/**\n * Returns a function that restores a javascript type from json.parse.\n * Allows restoring special types like dates, bigints, maps, set, etc... that are not supported by json.parse\n * */\nexport async function createRestoreFromJsonFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<RestoreFromJsonFn> {\n    const rt = runType(type);\n    return rt.createJitFunction(JitFunctions.restoreFromJson, opts);\n}\n\n/**\n * Returns a function that stringifies a javascript value to a json string.\n * Stringifies special types like dates, bigints, maps, set, etc...\n * Is equivalent to calling prepareForJson and then json.stringify but more efficient.\n */\nexport async function createStringifyJsonFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<JsonStringifyFn> {\n    const rt = runType(type);\n    return rt.createJitFunction(JitFunctions.stringifyJson, opts);\n}\n\n/** Returns a function that serializes any type value to a binary format. */\nexport async function createToBinaryFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<ToBinaryFn> {\n    const rt = runType(type);\n    return rt.createJitFunction(JitFunctions.toBinary, opts);\n}\n\n/** Returns a function that deserializes a binary value to the specified type. */\nexport async function createFromBinaryFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<FromBinaryFn> {\n    const rt = runType(type);\n    return rt.createJitFunction(JitFunctions.fromBinary, opts);\n}\n\n/** Returns a function that converts a value to javascript code, including set etc */\nexport function createToJavascriptFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): ToCodeFn {\n    const rt = runType(type);\n    return rt.createJitFunction(JitFunctions.toJSCode, opts);\n}\n\n/** Returns a function that mocks a value of the specified type. */\nexport async function createMockTypeFn<T>(type?: ReceiveType<T>): Promise<(opts?: Partial<RunTypeOptions>) => T> {\n    const rt = runType(type) as BaseRunType;\n    await registerJitFunctionCompiler(JitFunctions.mock);\n    return (opts?: Partial<RunTypeOptions>) => rt.mockType(opts) as T;\n}\n"],"names":["__ΩRunTypeOptions"],"mappings":";;;;;;;;;;;AA8BA,eAAsB,eAAkB,MAAuB,OAAzC,eAAc,IAAA,CAAA,GAAgD;AAA9D,iBAAc,IAAA;AAChC,QAAM,KAAK,QAAQ,IAAI;AACvB,SAAO,GAAG,kBAAkB,aAAa,QAAQ,IAAI;AACxD;;AAGD,eAAsB,mBAAsB,MAAuB,OAA7C,mBAAkB,IAAA,CAAA,GAAgD;AAAlE,qBAAkB,IAAA;AACpC,QAAM,KAAK,QAAQ,IAAI;AACvB,SAAO,GAAG,kBAAkB,aAAa,YAAY,IAAI;AAC5D;;AAMD,eAAsB,uBAA0B,MAAuB,OAAjD,uBAAsB,IAAA,CAAA,GAAgD;AAAtE,yBAAsB,IAAA;AACxC,QAAM,KAAK,QAAQ,IAAI;AACvB,SAAO,GAAG,kBAAkB,aAAa,gBAAgB,IAAI;AAChE;;AAMD,eAAsB,wBAA2B,MAAuB,OAAlD,wBAAuB,IAAA,CAAA,GAAgD;AAAvE,0BAAuB,IAAA;AACzC,QAAM,KAAK,QAAQ,IAAI;AACvB,SAAO,GAAG,kBAAkB,aAAa,iBAAiB,IAAI;AACjE;;AAOD,eAAsB,sBAAyB,MAAuB,OAAhD,sBAAqB,IAAA,CAAA,GAAgD;AAArE,wBAAqB,IAAA;AACvC,QAAM,KAAK,QAAQ,IAAI;AACvB,SAAO,GAAG,kBAAkB,aAAa,eAAe,IAAI;AAC/D;;AAGD,eAAsB,iBAAoB,MAAuB,OAA3C,iBAAgB,IAAA,CAAA,GAAgD;AAAhE,mBAAgB,IAAA;AAClC,QAAM,KAAK,QAAQ,IAAI;AACvB,SAAO,GAAG,kBAAkB,aAAa,UAAU,IAAI;AAC1D;;AAGD,eAAsB,mBAAsB,MAAuB,OAA7C,mBAAkB,IAAA,CAAA,GAAgD;AAAlE,qBAAkB,IAAA;AACpC,QAAM,KAAK,QAAQ,IAAI;AACvB,SAAO,GAAG,kBAAkB,aAAa,YAAY,IAAI;AAC5D;;SAGe,qBAAwB,MAAuB,OAA/C,qBAAoB,IAAA,CAAA,GAAgD;AAApE,uBAAoB,IAAA;AAChC,QAAM,KAAK,QAAQ,IAAI;AACvB,SAAO,GAAG,kBAAkB,aAAa,UAAU,IAAI;AAC1D;;AAGD,eAAsB,iBAAoB,OAApB,iBAAgB,IAAA,CAAA,GAAyB;AAAzC,mBAAgB,IAAA;AAClC,QAAM,KAAK,QAAQ,IAAI;AACvB,QAAM,4BAA4B,aAAa,IAAI;AACnD,SAAA,aAAO,CAAC,SAAmC,GAAG,SAAS,IAAI,GAAM,CAAA,MAAA,YAAA,MAAAA,mBAAA,QAAA,IAAA,cAAA,CAAA;AACpE;;"}

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

@@ -1,7 +0,0 @@
-import { TypeAnnotation } from '@deepkit/core';
-import { TypeFormatParams, Brand, TypeFormatPrimitives } from '@mionjs/core';
-export type TypeFormat<BaseType extends TypeFormatPrimitives, Name extends string, P extends TypeFormatParams, BrandName extends string = never> = [BrandName] extends [never] ? BaseType & TypeAnnotation<Name, P> : Brand<BaseType, BrandName> & TypeAnnotation<Name, P & {
-    brand: BrandName;
-}>;
-export declare type __ΩTypeFormat = any[];
-//# sourceMappingURL=formats.runtype.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"formats.runtype.d.ts","sourceRoot":"","sources":["../../../src/formats.runtype.ts"],"names":[],"mappings":"AAQA,OAAO,EAAC,cAAc,EAAC,MAAM,eAAe,CAAC;AAE7C,OAAO,EAAC,gBAAgB,EAAE,KAAK,EAAE,oBAAoB,EAAC,MAAM,cAAc,CAAC;AAiB3E,MAAM,MAAM,UAAU,CAClB,QAAQ,SAAS,oBAAoB,EACrC,IAAI,SAAS,MAAM,EACnB,CAAC,SAAS,gBAAgB,EAC1B,SAAS,SAAS,MAAM,GAAG,KAAK,IAChC,CAAC,SAAS,CAAC,SAAS,CAAC,KAAK,CAAC,GACzB,QAAQ,GAAG,cAAc,CAAC,IAAI,EAAE,CAAC,CAAC,GAClC,KAAK,CAAC,QAAQ,EAAE,SAAS,CAAC,GAAG,cAAc,CAAC,IAAI,EAAE,CAAC,GAAG;IAAC,KAAK,EAAE,SAAS,CAAA;CAAC,CAAC,CAAC"}

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

@@ -1,7 +0,0 @@
-import { __ΩTypeAnnotation as ___TypeAnnotation } from "@deepkit/core";
-import { __ΩBrand as ___Brand } from "@mionjs/core";
-const __ΩTypeFormat = ["BaseType", "Name", "P", "BrandName", () => ___TypeAnnotation, () => ___Brand, () => ___TypeAnnotation, "brand", "TypeFormat", `lPPe$!e$"e$#o%#KRPe$!e$$o&#e$"Pe%#Pe&$4(MKo'#KRb!b"b#!c$PPe#$GP!Gqk#2Qw)y`];
-export {
-  __ΩTypeFormat
-};
-//# sourceMappingURL=formats.runtype.js.map

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

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

package/.dist/esm/src/jitCompilers/binary/binarySpec/binaryHelpers.d.ts

@@ -1,31 +0,0 @@
-import { FunctionRunType } from '../../../nodes/function/function.ts';
-import { DataViewDeserializer, DataViewSerializer, StrictArrayBuffer } from '@mionjs/core';
-import { InterfaceRunType } from '../../../nodes/collection/interface.ts';
-import { RunType } from '../../../types.ts';
-export declare const serContext: DataViewSerializer;
-export declare const desContext: DataViewDeserializer;
-export declare function createSerializationFns(rt: RunType): {
-    serialize: (v: any) => StrictArrayBuffer;
-    deserialize: (data: StrictArrayBuffer) => any;
-};
-export declare function createSerializationParamsFn(rt: FunctionRunType, sliceStart?: number): {
-    serialize: (v: any) => StrictArrayBuffer;
-    deserialize: (data: StrictArrayBuffer) => any;
-};
-export declare function createSerializationReturnFn(rt: FunctionRunType): {
-    serialize: (v: any) => StrictArrayBuffer;
-    deserialize: (data: StrictArrayBuffer) => any;
-};
-export declare function createSerializationCallSignatureParamsFn(rt: InterfaceRunType): {
-    serialize: (v: any) => StrictArrayBuffer;
-    deserialize: (data: StrictArrayBuffer) => any;
-};
-export declare function createSerializationCallSignatureReturnFn(rt: InterfaceRunType): {
-    serialize: (v: any) => StrictArrayBuffer;
-    deserialize: (data: StrictArrayBuffer) => any;
-};
-export declare function roundTrip(serialize: (v: any) => StrictArrayBuffer, deserialize: (v: StrictArrayBuffer) => any, value: any): {
-    serialized: StrictArrayBuffer;
-    deserialized: any;
-};
-//# sourceMappingURL=binaryHelpers.d.ts.map

package/.dist/esm/src/jitCompilers/binary/binarySpec/binaryHelpers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"binaryHelpers.d.ts","sourceRoot":"","sources":["../../../../../../src/jitCompilers/binary/binarySpec/binaryHelpers.ts"],"names":[],"mappings":"AAQA,OAAO,EAAC,eAAe,EAAC,MAAM,qCAAqC,CAAC;AACpE,OAAO,KAAK,EAAC,oBAAoB,EAAE,kBAAkB,EAAE,iBAAiB,EAAC,MAAM,cAAc,CAAC;AAC9F,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,wCAAwC,CAAC;AAC7E,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,mBAAmB,CAAC;AAS/C,eAAO,MAAM,UAAU,EAAE,kBAAqD,CAAC;AAC/E,eAAO,MAAM,UAAU,EAAE,oBAA6E,CAAC;AAKvG,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,OAAO;mBAGxB,GAAG;wBACE,iBAAiB;EAO/C;AAED,wBAAgB,2BAA2B,CAAC,EAAE,EAAE,eAAe,EAAE,UAAU,CAAC,EAAE,MAAM;mBAI1D,GAAG;wBACE,iBAAiB;EAO/C;AAED,wBAAgB,2BAA2B,CAAC,EAAE,EAAE,eAAe;mBAGrC,GAAG;wBACE,iBAAiB;EAO/C;AAED,wBAAgB,wCAAwC,CAAC,EAAE,EAAE,gBAAgB;mBAInD,GAAG;wBACE,iBAAiB;EAO/C;AAED,wBAAgB,wCAAwC,CAAC,EAAE,EAAE,gBAAgB;mBAInD,GAAG;wBACE,iBAAiB;EAO/C;AAKD,wBAAgB,SAAS,CAAC,SAAS,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,iBAAiB,EAAE,WAAW,EAAE,CAAC,CAAC,EAAE,iBAAiB,KAAK,GAAG,EAAE,KAAK,EAAE,GAAG;;;EAezH"}