@mionjs/run-types 0.8.0-alpha.0

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

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

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

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

@@ -0,0 +1,5 @@
+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;

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

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

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

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

@@ -0,0 +1,12 @@
+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>;

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

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

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

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

@@ -0,0 +1,6 @@
+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[];

package/.dist/cjs/src/jitCompilers/binary/binarySpec/binaryHelpers.cjs

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

package/.dist/cjs/src/jitCompilers/binary/binarySpec/binaryHelpers.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"binaryHelpers.cjs","sources":["../../../../../../src/jitCompilers/binary/binarySpec/binaryHelpers.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 {FunctionRunType} from '../../../nodes/function/function.ts';\nimport type {DataViewDeserializer, DataViewSerializer, StrictArrayBuffer} from '@mionjs/core';\nimport type {InterfaceRunType} from '../../../nodes/collection/interface.ts';\nimport type {RunType} from '../../../types.ts';\nimport {createDataViewDeserializer, createDataViewSerializer, setSerializationOptions, getENV} from '@mionjs/core';\nimport {afterAll, expect} from 'vitest';\n\nconst DEBUG = getENV('DEBUG_JIT') === 'print';\n/** maps a binary serializer to json serializer */\nconst toJsonSerializers: Map<(v: any) => any, (v: any) => string> = new Map();\n\nsetSerializationOptions({bufferSize: 1024});\nexport const serContext: DataViewSerializer = createDataViewSerializer('test');\nexport const desContext: DataViewDeserializer = createDataViewDeserializer('test', new ArrayBuffer(0));\n\nconst SERIALIZE_FN = JitFunctions.toBinary;\nconst DESERIALIZE_FN = JitFunctions.fromBinary;\n\nexport function createSerializationFns(rt: RunType) {\n    const toBinary = rt.createJitFunction(SERIALIZE_FN);\n    const fromBinary = rt.createJitFunction(DESERIALIZE_FN);\n    const serialize = (v: any) => (toBinary(v, serContext), serContext.getBuffer());\n    const deserialize = (data: StrictArrayBuffer) => (desContext.setBuffer(data), fromBinary(undefined, desContext));\n    if (DEBUG) {\n        const toJson = rt.createJitFunction(JitFunctions.prepareForJson);\n        const stringify = (v: any) => JSON.stringify(toJson(v));\n        toJsonSerializers.set(serialize, stringify);\n    }\n    return {serialize, deserialize};\n}\n\nexport function createSerializationParamsFn(rt: FunctionRunType, sliceStart?: number) {\n    const params = typeof sliceStart === 'number' ? {paramsSlice: {start: sliceStart}} : undefined;\n    const toBinary = rt.createJitParamsFunction(SERIALIZE_FN, params);\n    const fromBinary = rt.createJitParamsFunction(DESERIALIZE_FN, params);\n    const serialize = (v: any) => (toBinary(v, serContext), serContext.getBuffer());\n    const deserialize = (data: StrictArrayBuffer) => (desContext.setBuffer(data), fromBinary(undefined, desContext));\n    if (DEBUG) {\n        const toJson = rt.createJitParamsFunction(JitFunctions.prepareForJson, params);\n        const stringify = (v: any) => JSON.stringify(toJson(v));\n        toJsonSerializers.set(serialize, stringify);\n    }\n    return {serialize, deserialize};\n}\n\nexport function createSerializationReturnFn(rt: FunctionRunType) {\n    const toBinary = rt.createJitReturnFunction(SERIALIZE_FN);\n    const fromBinary = rt.createJitReturnFunction(DESERIALIZE_FN);\n    const serialize = (v: any) => (toBinary(v, serContext), serContext.getBuffer());\n    const deserialize = (data: StrictArrayBuffer) => (desContext.setBuffer(data), fromBinary(undefined, desContext));\n    if (DEBUG) {\n        const toJson = rt.createJitReturnFunction(JitFunctions.prepareForJson);\n        const stringify = (v: any) => JSON.stringify(toJson(v));\n        toJsonSerializers.set(serialize, stringify);\n    }\n    return {serialize, deserialize};\n}\n\nexport function createSerializationCallSignatureParamsFn(rt: InterfaceRunType) {\n    const callSignature = rt.getCallSignature()!;\n    const toBinary = callSignature.createJitParamsFunction(SERIALIZE_FN);\n    const fromBinary = callSignature.createJitParamsFunction(DESERIALIZE_FN);\n    const serialize = (v: any) => (toBinary(v, serContext), serContext.getBuffer());\n    const deserialize = (data: StrictArrayBuffer) => (desContext.setBuffer(data), fromBinary(undefined, desContext));\n    if (DEBUG) {\n        const toJson = callSignature.createJitParamsFunction(JitFunctions.prepareForJson);\n        const stringify = (v: any) => JSON.stringify(toJson(v));\n        toJsonSerializers.set(serialize, stringify);\n    }\n    return {serialize, deserialize};\n}\n\nexport function createSerializationCallSignatureReturnFn(rt: InterfaceRunType) {\n    const callSignature = rt.getCallSignature()!;\n    const toBinary = callSignature.createJitReturnFunction(SERIALIZE_FN);\n    const fromBinary = callSignature.createJitReturnFunction(DESERIALIZE_FN);\n    const serialize = (v: any) => (toBinary(v, serContext), serContext.getBuffer());\n    const deserialize = (data: StrictArrayBuffer) => (desContext.setBuffer(data), fromBinary(undefined, desContext));\n    if (DEBUG) {\n        const toJson = callSignature.createJitReturnFunction(JitFunctions.prepareForJson);\n        const stringify = (v: any) => JSON.stringify(toJson(v));\n        toJsonSerializers.set(serialize, stringify);\n    }\n    return {serialize, deserialize};\n}\n\nconst sizesEntries: any[] = [];\nconst valuesEntries: any[] = [];\n\nexport function roundTrip(serialize: (v: any) => StrictArrayBuffer, deserialize: (v: StrictArrayBuffer) => any, value: any) {\n    serContext.reset();\n    const serialized = serialize(value);\n    const deserialized = deserialize(serialized);\n    if (DEBUG) {\n        const stringify = toJsonSerializers.get(serialize)!;\n        let json: number | string = '';\n        // eslint-disable-next-line\n        try { json = new Blob([stringify(value)]).size; } catch (e) { json = '-'; } // prettier-ignore\n        const sizes = {name: expect.getState().currentTestName, json, binary: serialized.byteLength};\n        sizesEntries.push(sizes);\n        valuesEntries.push({value, deserialized});\n    }\n    const result = {serialized, deserialized};\n    return result;\n}\n\nafterAll(() => {\n    if (sizesEntries.length) console.table(sizesEntries);\n    if (valuesEntries.length) console.table(valuesEntries);\n});\n"],"names":["getENV","setSerializationOptions","createDataViewSerializer","createDataViewDeserializer","JitFunctions","expect","afterAll"],"mappings":"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"}

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

@@ -0,0 +1,30 @@
+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;
+};