@mionjs/run-types 0.8.8 → 0.13.0

package/.dist/cjs/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/cjs/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/cjs/src/createRunType.cjs

@@ -1,284 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const type = require("@deepkit/type");
-const src_lib_guards = require("./lib/guards.cjs");
-const src_nodes_atomic_string = require("./nodes/atomic/string.cjs");
-const src_nodes_atomic_date = require("./nodes/atomic/date.cjs");
-const src_nodes_atomic_number = require("./nodes/atomic/number.cjs");
-const src_nodes_atomic_boolean = require("./nodes/atomic/boolean.cjs");
-const src_nodes_atomic_null = require("./nodes/atomic/null.cjs");
-const src_nodes_atomic_bigInt = require("./nodes/atomic/bigInt.cjs");
-const src_nodes_atomic_any = require("./nodes/atomic/any.cjs");
-const src_nodes_atomic_undefined = require("./nodes/atomic/undefined.cjs");
-const src_nodes_atomic_unknown = require("./nodes/atomic/unknown.cjs");
-const src_nodes_atomic_void = require("./nodes/atomic/void.cjs");
-const src_nodes_member_array = require("./nodes/member/array.cjs");
-const src_nodes_atomic_literal = require("./nodes/atomic/literal.cjs");
-const src_nodes_atomic_regexp = require("./nodes/atomic/regexp.cjs");
-const src_nodes_atomic_never = require("./nodes/atomic/never.cjs");
-const src_nodes_atomic_enum = require("./nodes/atomic/enum.cjs");
-const src_nodes_atomic_enumMember = require("./nodes/atomic/enumMember.cjs");
-const src_nodes_collection_union = require("./nodes/collection/union.cjs");
-const src_nodes_collection_tuple = require("./nodes/collection/tuple.cjs");
-const src_nodes_collection_functionParams = require("./nodes/collection/functionParams.cjs");
-const src_nodes_member_tupleMember = require("./nodes/member/tupleMember.cjs");
-const src_nodes_collection_interface = require("./nodes/collection/interface.cjs");
-const src_nodes_member_property = require("./nodes/member/property.cjs");
-const src_nodes_member_indexProperty = require("./nodes/member/indexProperty.cjs");
-const src_nodes_member_methodSignature = require("./nodes/member/methodSignature.cjs");
-const src_nodes_member_callSignature = require("./nodes/member/callSignature.cjs");
-const src_nodes_function_function = require("./nodes/function/function.cjs");
-const src_nodes_native_promise = require("./nodes/native/promise.cjs");
-const src_nodes_atomic_object = require("./nodes/atomic/object.cjs");
-const src_nodes_collection_intersection = require("./nodes/collection/intersection.cjs");
-const src_nodes_member_param = require("./nodes/member/param.cjs");
-const src_nodes_member_method = require("./nodes/member/method.cjs");
-const src_nodes_member_restParams = require("./nodes/member/restParams.cjs");
-const src_nodes_collection_class = require("./nodes/collection/class.cjs");
-const src_nodes_native_map = require("./nodes/native/map.cjs");
-const src_constants_kind = require("./constants.kind.cjs");
-const src_nodes_native_set = require("./nodes/native/set.cjs");
-const src_nodes_atomic_symbol = require("./nodes/atomic/symbol.cjs");
-const src_nodes_native_nonSerializable = require("./nodes/native/nonSerializable.cjs");
-const core = require("@mionjs/core");
-function __assignType(fn, args) {
-  fn.__type = args;
-  return fn;
-}
-function runType(type$1 = runType.Ω?.[0]) {
-  runType.Ω = void 0;
-  const start = Date.now();
-  const src = type.resolveReceiveType(type$1);
-  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 ${type.stringifyType(src)}`);
-  return src._rt;
-}
-runType.__type = [() => type.__ΩReceiveType, "type", "RunType", "runType", 'P"o!"2"8"w#/$'];
-function reflectFunction(fn) {
-  const src = type.reflect(fn);
-  runType(src);
-  return src._rt;
-}
-reflectFunction.__type = ["fn", () => src_nodes_function_function.FunctionRunType, "reflectFunction", 'P"2!P7"/#'];
-function createRunTypes(src) {
-  core.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 (src_lib_guards.hasType(current))
-      stack.push(current.type);
-    if (src_lib_guards.hasReturn(current))
-      stack.push(current.return);
-    if (src_lib_guards.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 (src_lib_guards.hasTypes(current))
-      pushToStack(current.types, stack);
-    if (src_lib_guards.hasParameters(current))
-      pushToStack(current.parameters, stack);
-    if (src_lib_guards.hasArguments(current))
-      pushToStack(current.arguments, stack);
-    if (src_lib_guards.hasExtendsArguments(current))
-      pushToStack(current.extendsArguments, stack);
-    if (src_lib_guards.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 = type.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 type.ReflectionKind.any:
-      rt = new src_nodes_atomic_any.AnyRunType();
-      break;
-    case type.ReflectionKind.bigint:
-      rt = new src_nodes_atomic_bigInt.BigIntRunType();
-      break;
-    case type.ReflectionKind.boolean:
-      rt = new src_nodes_atomic_boolean.BooleanRunType();
-      break;
-    case type.ReflectionKind.enum:
-      rt = new src_nodes_atomic_enum.EnumRunType();
-      break;
-    case type.ReflectionKind.enumMember:
-      rt = new src_nodes_atomic_enumMember.EnumMemberRunType();
-      break;
-    case type.ReflectionKind.literal:
-      rt = new src_nodes_atomic_literal.LiteralRunType();
-      break;
-    case type.ReflectionKind.never:
-      rt = src_lib_guards.isNativeUtilityStringTypes(deepkitType) ? new src_nodes_atomic_string.StringRunType() : new src_nodes_atomic_never.NeverRunType();
-      break;
-    case type.ReflectionKind.null:
-      rt = new src_nodes_atomic_null.NullRunType();
-      break;
-    case type.ReflectionKind.number:
-      rt = new src_nodes_atomic_number.NumberRunType();
-      break;
-    case type.ReflectionKind.object:
-      rt = new src_nodes_atomic_object.ObjectRunType();
-      break;
-    case type.ReflectionKind.regexp:
-      rt = new src_nodes_atomic_regexp.RegexpRunType();
-      break;
-    case type.ReflectionKind.string:
-      rt = new src_nodes_atomic_string.StringRunType();
-      break;
-    case type.ReflectionKind.symbol:
-      rt = new src_nodes_atomic_symbol.SymbolRunType();
-      break;
-    case type.ReflectionKind.templateLiteral:
-      throw new Error("Template Literals are resolved by the compiler to Literals ie: const tl = `${string}World`. Template literal types are not supported. ie type TL = `${string}World`");
-    case type.ReflectionKind.undefined:
-      rt = new src_nodes_atomic_undefined.UndefinedRunType();
-      break;
-    case type.ReflectionKind.unknown:
-      rt = new src_nodes_atomic_unknown.UnknownRunType();
-      break;
-    case type.ReflectionKind.void:
-      rt = new src_nodes_atomic_void.VoidRunType();
-      break;
-    // ###################### MEMBER RUNTYPES ######################
-    // Types that represent members of collections or other structures
-    case type.ReflectionKind.array:
-      rt = new src_nodes_member_array.ArrayRunType();
-      break;
-    case type.ReflectionKind.callSignature:
-      rt = new src_nodes_member_callSignature.CallSignatureRunType();
-      break;
-    case type.ReflectionKind.function:
-      if (deepkitType.subKind === src_constants_kind.ReflectionSubKind.params) {
-        rt = new src_nodes_collection_functionParams.FunctionParamsRunType();
-      } else {
-        const frt = new src_nodes_function_function.FunctionRunType();
-        frt.parameterRunTypes.src = deepkitType;
-        rt = frt;
-      }
-      break;
-    case type.ReflectionKind.indexSignature:
-      rt = new src_nodes_member_indexProperty.IndexSignatureRunType();
-      break;
-    case type.ReflectionKind.method:
-      rt = new src_nodes_member_method.MethodRunType();
-      break;
-    case type.ReflectionKind.methodSignature:
-      rt = new src_nodes_member_methodSignature.MethodSignatureRunType();
-      break;
-    case type.ReflectionKind.parameter:
-      rt = new src_nodes_member_param.ParameterRunType();
-      break;
-    case type.ReflectionKind.property:
-    case type.ReflectionKind.propertySignature:
-      rt = new src_nodes_member_property.PropertyRunType();
-      break;
-    case type.ReflectionKind.rest:
-      rt = new src_nodes_member_restParams.RestParamsRunType();
-      break;
-    case type.ReflectionKind.tupleMember:
-      rt = new src_nodes_member_tupleMember.TupleMemberRunType();
-      break;
-    case type.ReflectionKind.promise:
-      rt = new src_nodes_native_promise.PromiseRunType();
-      break;
-    // ###################### COLLECTION RUNTYPES ######################
-    case type.ReflectionKind.objectLiteral:
-      if (src_lib_guards.isNonSerializableObject(deepkitType)) {
-        rt = new src_nodes_native_nonSerializable.NonSerializableRunType();
-      } else {
-        rt = new src_nodes_collection_interface.InterfaceRunType();
-      }
-      break;
-    case type.ReflectionKind.class:
-      rt = initClassRunType(deepkitType);
-      break;
-    // Types that contain other types as members
-    case type.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 type.ReflectionKind.intersection:
-      rt = new src_nodes_collection_intersection.IntersectionRunType();
-      break;
-    case type.ReflectionKind.tuple:
-      rt = new src_nodes_collection_tuple.TupleRunType();
-      break;
-    case type.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 type.ReflectionKind.union:
-      rt = new src_nodes_collection_union.UnionRunType();
-      break;
-    default:
-      rt = new src_nodes_atomic_any.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 = src_constants_kind.ReflectionSubKind.date;
-      return new src_nodes_atomic_date.DateRunType();
-    case Map:
-      src.subKind = src_constants_kind.ReflectionSubKind.map;
-      return new src_nodes_native_map.MapRunType();
-    case Set:
-      src.subKind = src_constants_kind.ReflectionSubKind.set;
-      return new src_nodes_native_set.SetRunType();
-    default:
-      if (src_lib_guards.isNonSerializableClass(src)) {
-        src.subKind = src_constants_kind.ReflectionSubKind.nonSerializable;
-        return new src_nodes_native_nonSerializable.NonSerializableRunType();
-      }
-      return new src_nodes_collection_class.ClassRunType();
-  }
-}
-initClassRunType.__type = ["TypeClass", "subKind", "src", "BaseRunType", "initClassRunType", `PP"w!P'4"8MK2#"w$/%`];
-exports.reflectFunction = reflectFunction;
-exports.runType = runType;
-//# sourceMappingURL=createRunType.cjs.map

package/.dist/cjs/src/createRunType.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createRunType.cjs","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 {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 automatically resolves template literals unions to literals\n            // this is only called when you define the type of a template literal i.e: type T = `foo${string}`;\n            // this is not supported at the moment but would be useful for type safe urls etc\n            throw new Error(\n                'Template Literals are resolved by the compiler to Literals ie: const tl = `${string}World`. Template literal types are not supported. ie type TL = `${string}World`'\n            );\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":["type","resolveReceiveType","stringifyType","reflect","registerErrorDeserializers","hasType","hasReturn","hasIndexType","hasTypes","hasParameters","hasArguments","hasExtendsArguments","hasImplements","typeAnnotation","ReflectionKind","AnyRunType","BigIntRunType","BooleanRunType","EnumRunType","EnumMemberRunType","LiteralRunType","isNativeUtilityStringTypes","StringRunType","NeverRunType","NullRunType","NumberRunType","ObjectRunType","RegexpRunType","SymbolRunType","UndefinedRunType","UnknownRunType","VoidRunType","ArrayRunType","CallSignatureRunType","ReflectionSubKind","FunctionParamsRunType","FunctionRunType","IndexSignatureRunType","MethodRunType","MethodSignatureRunType","ParameterRunType","PropertyRunType","RestParamsRunType","TupleMemberRunType","PromiseRunType","isNonSerializableObject","NonSerializableRunType","InterfaceRunType","IntersectionRunType","TupleRunType","UnionRunType","DateRunType","MapRunType","SetRunType","isNonSerializableClass","ClassRunType"],"mappings":"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"}

package/.dist/cjs/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/cjs/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;AAe7D,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/cjs/src/createRunTypeFunctions.cjs

@@ -1,78 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const src_constants_functions = require("./constants.functions.cjs");
-const type = require("@deepkit/type");
-const src_createRunType = require("./createRunType.cjs");
-const src_types = require("./types.cjs");
-const core = require("@mionjs/core");
-const src_lib_jitFnsRegistry = require("./lib/jitFnsRegistry.cjs");
-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, type2 = createIsTypeFn.Ω?.[0]) {
-  createIsTypeFn.Ω = void 0;
-  const rt = src_createRunType.runType(type2);
-  return rt.createJitFunction(src_constants_functions.JitFunctions.isType, opts);
-}
-createIsTypeFn.__type = [() => src_types.__ΩRunTypeOptions, "opts", () => type.__ΩReceiveType, "type", () => core.__ΩIsTypeFn, "createIsTypeFn", 'Pn!2"8"o#"2$8n%`/&'];
-async function createTypeErrorsFn(opts, type2 = createTypeErrorsFn.Ω?.[0]) {
-  createTypeErrorsFn.Ω = void 0;
-  const rt = src_createRunType.runType(type2);
-  return rt.createJitFunction(src_constants_functions.JitFunctions.typeErrors, opts);
-}
-createTypeErrorsFn.__type = [() => src_types.__ΩRunTypeOptions, "opts", () => type.__ΩReceiveType, "type", () => core.__ΩTypeErrorsFn, "createTypeErrorsFn", 'Pn!2"8"o#"2$8n%`/&'];
-async function createPrepareForJsonFn(opts, type2 = createPrepareForJsonFn.Ω?.[0]) {
-  createPrepareForJsonFn.Ω = void 0;
-  const rt = src_createRunType.runType(type2);
-  return rt.createJitFunction(src_constants_functions.JitFunctions.prepareForJson, opts);
-}
-createPrepareForJsonFn.__type = [() => src_types.__ΩRunTypeOptions, "opts", () => type.__ΩReceiveType, "type", () => core.__ΩPrepareForJsonFn, "createPrepareForJsonFn", 'Pn!2"8"o#"2$8n%`/&'];
-async function createRestoreFromJsonFn(opts, type2 = createRestoreFromJsonFn.Ω?.[0]) {
-  createRestoreFromJsonFn.Ω = void 0;
-  const rt = src_createRunType.runType(type2);
-  return rt.createJitFunction(src_constants_functions.JitFunctions.restoreFromJson, opts);
-}
-createRestoreFromJsonFn.__type = [() => src_types.__ΩRunTypeOptions, "opts", () => type.__ΩReceiveType, "type", () => core.__ΩRestoreFromJsonFn, "createRestoreFromJsonFn", 'Pn!2"8"o#"2$8n%`/&'];
-async function createStringifyJsonFn(opts, type2 = createStringifyJsonFn.Ω?.[0]) {
-  createStringifyJsonFn.Ω = void 0;
-  const rt = src_createRunType.runType(type2);
-  return rt.createJitFunction(src_constants_functions.JitFunctions.stringifyJson, opts);
-}
-createStringifyJsonFn.__type = [() => src_types.__ΩRunTypeOptions, "opts", () => type.__ΩReceiveType, "type", () => core.__ΩJsonStringifyFn, "createStringifyJsonFn", 'Pn!2"8"o#"2$8n%`/&'];
-async function createToBinaryFn(opts, type2 = createToBinaryFn.Ω?.[0]) {
-  createToBinaryFn.Ω = void 0;
-  const rt = src_createRunType.runType(type2);
-  return rt.createJitFunction(src_constants_functions.JitFunctions.toBinary, opts);
-}
-createToBinaryFn.__type = [() => src_types.__ΩRunTypeOptions, "opts", () => type.__ΩReceiveType, "type", () => core.__ΩToBinaryFn, "createToBinaryFn", 'Pn!2"8"o#"2$8n%`/&'];
-async function createFromBinaryFn(opts, type2 = createFromBinaryFn.Ω?.[0]) {
-  createFromBinaryFn.Ω = void 0;
-  const rt = src_createRunType.runType(type2);
-  return rt.createJitFunction(src_constants_functions.JitFunctions.fromBinary, opts);
-}
-createFromBinaryFn.__type = [() => src_types.__ΩRunTypeOptions, "opts", () => type.__ΩReceiveType, "type", () => core.__ΩFromBinaryFn, "createFromBinaryFn", 'Pn!2"8"o#"2$8n%`/&'];
-function createToJavascriptFn(opts, type2 = createToJavascriptFn.Ω?.[0]) {
-  createToJavascriptFn.Ω = void 0;
-  const rt = src_createRunType.runType(type2);
-  return rt.createJitFunction(src_constants_functions.JitFunctions.toJSCode, opts);
-}
-createToJavascriptFn.__type = [() => src_types.__ΩRunTypeOptions, "opts", () => type.__ΩReceiveType, "type", () => core.__ΩToCodeFn, "createToJavascriptFn", 'Pn!2"8"o#"2$8n%/&'];
-async function createMockTypeFn(type2 = createMockTypeFn.Ω?.[0]) {
-  createMockTypeFn.Ω = void 0;
-  const rt = src_createRunType.runType(type2);
-  await src_lib_jitFnsRegistry.registerJitFunctionCompiler(src_constants_functions.JitFunctions.mock);
-  return __assignType((opts) => rt.mockType(opts), [() => __ΩPartial, () => src_types.__ΩRunTypeOptions, "opts", "", 'Pn"o!"2#8"/$']);
-}
-createMockTypeFn.__type = [() => type.__ΩReceiveType, "type", () => __ΩPartial, () => src_types.__ΩRunTypeOptions, "opts", "", "createMockTypeFn", 'P"o!"2"8Pn$o#"2%8"/&`/\''];
-exports.createFromBinaryFn = createFromBinaryFn;
-exports.createIsTypeFn = createIsTypeFn;
-exports.createMockTypeFn = createMockTypeFn;
-exports.createPrepareForJsonFn = createPrepareForJsonFn;
-exports.createRestoreFromJsonFn = createRestoreFromJsonFn;
-exports.createStringifyJsonFn = createStringifyJsonFn;
-exports.createToBinaryFn = createToBinaryFn;
-exports.createToJavascriptFn = createToJavascriptFn;
-exports.createTypeErrorsFn = createTypeErrorsFn;
-//# sourceMappingURL=createRunTypeFunctions.cjs.map

package/.dist/cjs/src/createRunTypeFunctions.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createRunTypeFunctions.cjs","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":["type","runType","JitFunctions","registerJitFunctionCompiler","__ΩRunTypeOptions"],"mappings":";;;;;;;;;;;;;AA8BA,eAAsB,eAAkB,MAAuBA,QAAzC,eAAc,IAAA,CAAA,GAAgD;AAA9D,iBAAc,IAAA;AAChC,QAAM,KAAKC,kBAAAA,QAAQD,KAAI;AACvB,SAAO,GAAG,kBAAkBE,qCAAa,QAAQ,IAAI;AACxD;;AAGD,eAAsB,mBAAsB,MAAuBF,QAA7C,mBAAkB,IAAA,CAAA,GAAgD;AAAlE,qBAAkB,IAAA;AACpC,QAAM,KAAKC,kBAAAA,QAAQD,KAAI;AACvB,SAAO,GAAG,kBAAkBE,qCAAa,YAAY,IAAI;AAC5D;;AAMD,eAAsB,uBAA0B,MAAuBF,QAAjD,uBAAsB,IAAA,CAAA,GAAgD;AAAtE,yBAAsB,IAAA;AACxC,QAAM,KAAKC,kBAAAA,QAAQD,KAAI;AACvB,SAAO,GAAG,kBAAkBE,qCAAa,gBAAgB,IAAI;AAChE;;AAMD,eAAsB,wBAA2B,MAAuBF,QAAlD,wBAAuB,IAAA,CAAA,GAAgD;AAAvE,0BAAuB,IAAA;AACzC,QAAM,KAAKC,kBAAAA,QAAQD,KAAI;AACvB,SAAO,GAAG,kBAAkBE,qCAAa,iBAAiB,IAAI;AACjE;;AAOD,eAAsB,sBAAyB,MAAuBF,QAAhD,sBAAqB,IAAA,CAAA,GAAgD;AAArE,wBAAqB,IAAA;AACvC,QAAM,KAAKC,kBAAAA,QAAQD,KAAI;AACvB,SAAO,GAAG,kBAAkBE,qCAAa,eAAe,IAAI;AAC/D;;AAGD,eAAsB,iBAAoB,MAAuBF,QAA3C,iBAAgB,IAAA,CAAA,GAAgD;AAAhE,mBAAgB,IAAA;AAClC,QAAM,KAAKC,kBAAAA,QAAQD,KAAI;AACvB,SAAO,GAAG,kBAAkBE,qCAAa,UAAU,IAAI;AAC1D;;AAGD,eAAsB,mBAAsB,MAAuBF,QAA7C,mBAAkB,IAAA,CAAA,GAAgD;AAAlE,qBAAkB,IAAA;AACpC,QAAM,KAAKC,kBAAAA,QAAQD,KAAI;AACvB,SAAO,GAAG,kBAAkBE,qCAAa,YAAY,IAAI;AAC5D;;SAGe,qBAAwB,MAAuBF,QAA/C,qBAAoB,IAAA,CAAA,GAAgD;AAApE,uBAAoB,IAAA;AAChC,QAAM,KAAKC,kBAAAA,QAAQD,KAAI;AACvB,SAAO,GAAG,kBAAkBE,qCAAa,UAAU,IAAI;AAC1D;;AAGD,eAAsB,iBAAoBF,QAApB,iBAAgB,IAAA,CAAA,GAAyB;AAAzC,mBAAgB,IAAA;AAClC,QAAM,KAAKC,kBAAAA,QAAQD,KAAI;AACvB,QAAMG,uBAAAA,4BAA4BD,wBAAAA,aAAa,IAAI;AACnD,SAAA,aAAO,CAAC,SAAmC,GAAG,SAAS,IAAI,GAAM,CAAA,MAAA,YAAA,MAAAE,UAAAA,mBAAA,QAAA,IAAA,cAAA,CAAA;AACpE;;;;;;;;;;;"}

package/.dist/cjs/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/cjs/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/cjs/src/formats.runtype.cjs

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const core = require("@deepkit/core");
-const core$1 = require("@mionjs/core");
-const __ΩTypeFormat = ["BaseType", "Name", "P", "BrandName", () => core.__ΩTypeAnnotation, () => core$1.__ΩBrand, () => core.__ΩTypeAnnotation, "brand", "TypeFormat", `lPPe$!e$"e$#o%#KRPe$!e$$o&#e$"Pe%#Pe&$4(MKo'#KRb!b"b#!c$PPe#$GP!Gqk#2Qw)y`];
-exports.__ΩTypeFormat = __ΩTypeFormat;
-//# sourceMappingURL=formats.runtype.cjs.map

package/.dist/cjs/src/formats.runtype.cjs.map

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

package/.dist/cjs/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/cjs/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/cjs/src/jitCompilers/binary/binarySpec/binaryHelpers.cjs

@@ -1,109 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const src_constants_functions = require("../../../constants.functions.cjs");
-const core = require("@mionjs/core");
-const vitest = require("vitest");
-const DEBUG = core.getENV("DEBUG_JIT") === "print";
-const toJsonSerializers = /* @__PURE__ */ new Map();
-core.setSerializationOptions({ bufferSize: 1024 });
-const serContext = core.createDataViewSerializer("test");
-const desContext = core.createDataViewDeserializer("test", new ArrayBuffer(0));
-const SERIALIZE_FN = src_constants_functions.JitFunctions.toBinary;
-const DESERIALIZE_FN = src_constants_functions.JitFunctions.fromBinary;
-function createSerializationFns(rt) {
-  const toBinary = rt.createJitFunction(SERIALIZE_FN);
-  const fromBinary = rt.createJitFunction(DESERIALIZE_FN);
-  const serialize = (v) => (toBinary(v, serContext), serContext.getBuffer());
-  const deserialize = (data) => (desContext.setBuffer(data), fromBinary(void 0, desContext));
-  if (DEBUG) {
-    const toJson = rt.createJitFunction(src_constants_functions.JitFunctions.prepareForJson);
-    const stringify = (v) => JSON.stringify(toJson(v));
-    toJsonSerializers.set(serialize, stringify);
-  }
-  return { serialize, deserialize };
-}
-function createSerializationParamsFn(rt, sliceStart) {
-  const params = typeof sliceStart === "number" ? { paramsSlice: { start: sliceStart } } : void 0;
-  const toBinary = rt.createJitParamsFunction(SERIALIZE_FN, params);
-  const fromBinary = rt.createJitParamsFunction(DESERIALIZE_FN, params);
-  const serialize = (v) => (toBinary(v, serContext), serContext.getBuffer());
-  const deserialize = (data) => (desContext.setBuffer(data), fromBinary(void 0, desContext));
-  if (DEBUG) {
-    const toJson = rt.createJitParamsFunction(src_constants_functions.JitFunctions.prepareForJson, params);
-    const stringify = (v) => JSON.stringify(toJson(v));
-    toJsonSerializers.set(serialize, stringify);
-  }
-  return { serialize, deserialize };
-}
-function createSerializationReturnFn(rt) {
-  const toBinary = rt.createJitReturnFunction(SERIALIZE_FN);
-  const fromBinary = rt.createJitReturnFunction(DESERIALIZE_FN);
-  const serialize = (v) => (toBinary(v, serContext), serContext.getBuffer());
-  const deserialize = (data) => (desContext.setBuffer(data), fromBinary(void 0, desContext));
-  if (DEBUG) {
-    const toJson = rt.createJitReturnFunction(src_constants_functions.JitFunctions.prepareForJson);
-    const stringify = (v) => JSON.stringify(toJson(v));
-    toJsonSerializers.set(serialize, stringify);
-  }
-  return { serialize, deserialize };
-}
-function createSerializationCallSignatureParamsFn(rt) {
-  const callSignature = rt.getCallSignature();
-  const toBinary = callSignature.createJitParamsFunction(SERIALIZE_FN);
-  const fromBinary = callSignature.createJitParamsFunction(DESERIALIZE_FN);
-  const serialize = (v) => (toBinary(v, serContext), serContext.getBuffer());
-  const deserialize = (data) => (desContext.setBuffer(data), fromBinary(void 0, desContext));
-  if (DEBUG) {
-    const toJson = callSignature.createJitParamsFunction(src_constants_functions.JitFunctions.prepareForJson);
-    const stringify = (v) => JSON.stringify(toJson(v));
-    toJsonSerializers.set(serialize, stringify);
-  }
-  return { serialize, deserialize };
-}
-function createSerializationCallSignatureReturnFn(rt) {
-  const callSignature = rt.getCallSignature();
-  const toBinary = callSignature.createJitReturnFunction(SERIALIZE_FN);
-  const fromBinary = callSignature.createJitReturnFunction(DESERIALIZE_FN);
-  const serialize = (v) => (toBinary(v, serContext), serContext.getBuffer());
-  const deserialize = (data) => (desContext.setBuffer(data), fromBinary(void 0, desContext));
-  if (DEBUG) {
-    const toJson = callSignature.createJitReturnFunction(src_constants_functions.JitFunctions.prepareForJson);
-    const stringify = (v) => JSON.stringify(toJson(v));
-    toJsonSerializers.set(serialize, stringify);
-  }
-  return { serialize, deserialize };
-}
-const sizesEntries = [];
-const valuesEntries = [];
-function roundTrip(serialize, deserialize, value) {
-  serContext.reset();
-  const serialized = serialize(value);
-  const deserialized = deserialize(serialized);
-  if (DEBUG) {
-    const stringify = toJsonSerializers.get(serialize);
-    let json = "";
-    try {
-      json = new Blob([stringify(value)]).size;
-    } catch (e) {
-      json = "-";
-    }
-    const sizes = { name: vitest.expect.getState().currentTestName, json, binary: serialized.byteLength };
-    sizesEntries.push(sizes);
-    valuesEntries.push({ value, deserialized });
-  }
-  const result = { serialized, deserialized };
-  return result;
-}
-vitest.afterAll(() => {
-  if (sizesEntries.length) console.table(sizesEntries);
-  if (valuesEntries.length) console.table(valuesEntries);
-});
-exports.createSerializationCallSignatureParamsFn = createSerializationCallSignatureParamsFn;
-exports.createSerializationCallSignatureReturnFn = createSerializationCallSignatureReturnFn;
-exports.createSerializationFns = createSerializationFns;
-exports.createSerializationParamsFn = createSerializationParamsFn;
-exports.createSerializationReturnFn = createSerializationReturnFn;
-exports.desContext = desContext;
-exports.roundTrip = roundTrip;
-exports.serContext = serContext;
-//# sourceMappingURL=binaryHelpers.cjs.map