@mionjs/run-types 0.8.8 → 0.13.0

package/.dist/cjs/src/jitCompilers/binary/toBinary.cjs

@@ -1,338 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const type = require("@deepkit/type");
-const src_constants_kind = require("../../constants.kind.cjs");
-const src_constants_functions = require("../../constants.functions.cjs");
-const src_lib_utils = require("../../lib/utils.cjs");
-const src_constants = require("../../constants.cjs");
-const fnID = src_constants_functions.JitFunctions.toBinary.id;
-function emitToBinary(runType, comp) {
-  const src = runType.src;
-  const kind = src.kind;
-  const sεr = comp.args.sεr;
-  switch (kind) {
-    // ###################### ATOMIC TYPES ######################
-    case type.ReflectionKind.unknown:
-    case type.ReflectionKind.any: {
-      return { code: `${sεr}.serString(JSON.stringify(${comp.vλl}))`, type: "S" };
-    }
-    case type.ReflectionKind.null:
-      return { code: `${sεr}.view.setUint8(${sεr}.index++, 0)`, type: "S" };
-    case type.ReflectionKind.boolean:
-      return { code: `${sεr}.view.setUint8(${sεr}.index++, !!${comp.vλl})`, type: "S" };
-    case type.ReflectionKind.number: {
-      return { code: `${sεr}.view.setFloat64(${sεr}.index,${comp.vλl}, 1, (${sεr}.index += 8))`, type: "S" };
-    }
-    case type.ReflectionKind.string: {
-      return { code: `${sεr}.serString(${comp.vλl})`, type: "S" };
-    }
-    case type.ReflectionKind.bigint: {
-      return { code: `${sεr}.serString(${comp.vλl}.toString(), true)`, type: "S" };
-    }
-    case type.ReflectionKind.undefined:
-    case type.ReflectionKind.void:
-      return { code: `${sεr}.view.setUint8(${sεr}.index++, 1)`, type: "S" };
-    case type.ReflectionKind.symbol: {
-      return { code: `${sεr}.serString(${comp.vλl}.description || '')`, type: "S" };
-    }
-    case type.ReflectionKind.regexp: {
-      return { code: `${sεr}.serString(${comp.vλl}.source);${sεr}.serString(${comp.vλl}.flags)`, type: "S" };
-    }
-    case type.ReflectionKind.object:
-      return { code: `${sεr}.serString(JSON.stringify(${comp.vλl}))`, type: "S" };
-    case type.ReflectionKind.enum: {
-      return { code: `${sεr}.serEnum(${comp.vλl})`, type: "S" };
-    }
-    case type.ReflectionKind.enumMember:
-      throw new Error("Binary serialization not supported for enum member types");
-    case type.ReflectionKind.never:
-      throw new Error("Never type cannot be serialized to Binary");
-    case type.ReflectionKind.templateLiteral:
-      throw new Error("Template literals are not supported in Binary serialization");
-    case type.ReflectionKind.literal: {
-      if (comp.opts.noLiterals) {
-        const lit = runType.src.literal;
-        if (lit instanceof RegExp) return emitToBinaryAs(runType, comp, type.ReflectionKind.regexp);
-        switch (typeof lit) {
-          case "string":
-            return emitToBinaryAs(runType, comp, type.ReflectionKind.string);
-          case "number":
-            return emitToBinaryAs(runType, comp, type.ReflectionKind.number);
-          case "boolean":
-            return emitToBinaryAs(runType, comp, type.ReflectionKind.boolean);
-          case "bigint":
-            return emitToBinaryAs(runType, comp, type.ReflectionKind.bigint);
-          case "symbol":
-            return emitToBinaryAs(runType, comp, type.ReflectionKind.symbol);
-          default:
-            throw new Error(`Unsupported literal type ${typeof lit}`);
-        }
-      }
-      return { code: "", type: "S" };
-    }
-    // ###################### MEMBER RUNTYPES ######################
-    // Types that represent members of collections or other structures
-    case type.ReflectionKind.rest:
-    // rest params are serialized as array but start at rest item index
-    case type.ReflectionKind.array: {
-      const rt = runType;
-      rt.checkNonSkipTypes(comp);
-      const child = rt.getMemberType();
-      const memberJit = comp.compile(child, "S", fnID);
-      if (!memberJit?.code) throw new Error(`Do not know how to serialize Array<${child.getTypeName()}> to Binary.`);
-      const index = rt.getChildVarName(comp);
-      return {
-        code: `
-                ${sεr}.view.setUint32(${sεr}.index, ${comp.vλl}.length, 1); ${sεr}.index += 4;
-                for (let ${index} = ${rt.startIndex(comp)}; ${index} < ${comp.vλl}.length; ${index}++) {${memberJit.code}}
-            `,
-        type: "S"
-      };
-    }
-    case type.ReflectionKind.indexSignature: {
-      const rt = runType;
-      const indexKind = rt.src.index?.kind;
-      const memberJit = comp.compile(rt.getJitChild(comp), "S", fnID);
-      if (!memberJit?.code) return { code: void 0, type: "S" };
-      const propVar = rt.getChildVarName(comp);
-      const lengthVar = comp.getLocalVarName("cnt", rt);
-      const indexVar = comp.getLocalVarName("piI", rt);
-      const varsInit = `let ${lengthVar} = 0; const ${indexVar} = ${sεr}.index; ${sεr}.index += 4;`;
-      let keySerializationCode;
-      if (indexKind === type.ReflectionKind.number) {
-        keySerializationCode = `${sεr}.view.setUint32(${sεr}.index , Number(${propVar}), 1); ${sεr}.index += 4;`;
-      } else {
-        keySerializationCode = `${sεr}.serString(${propVar});`;
-      }
-      return {
-        code: `
-                ${varsInit};
-                for (const ${propVar} in ${comp.vλl}) {${keySerializationCode} ${memberJit.code}; ${lengthVar}++;}
-                ${sεr}.view.setUint32(${indexVar}, ${lengthVar}, 1);
-            `,
-        type: "S"
-      };
-    }
-    case type.ReflectionKind.function:
-    case type.ReflectionKind.method:
-    case type.ReflectionKind.methodSignature:
-    case type.ReflectionKind.callSignature:
-      if (runType.src.subKind === src_constants_kind.ReflectionSubKind.params) {
-        return emitToBinaryAs(runType, comp, type.ReflectionKind.tuple);
-      } else {
-        throw new Error("Binary serialization not supported for functions, call compileParams or compileReturn instead.");
-      }
-    case type.ReflectionKind.parameter: {
-      const rt = runType;
-      switch (src.subKind) {
-        case src_constants_kind.ReflectionSubKind.mapKey:
-        case src_constants_kind.ReflectionSubKind.mapValue:
-        case src_constants_kind.ReflectionSubKind.setItem: {
-          const child = rt.getJitChild(comp);
-          const childJit = comp.compile(child, "S", fnID);
-          if (!childJit?.code) throw new Error(`Do not know how to serialize ${rt.getTypeName()} to Binary.`);
-          return childJit;
-        }
-        default: {
-          return emitToBinaryAs(runType, comp, type.ReflectionKind.tupleMember);
-        }
-      }
-    }
-    case type.ReflectionKind.property:
-    case type.ReflectionKind.propertySignature: {
-      const rt = runType;
-      const parent = rt.getParent();
-      if (parent.hasIndexSignature(comp)) return { code: void 0, type: "S" };
-      const memberCode = comp.compile(rt.getJitChild(comp), "S", fnID).code || "";
-      if (rt.isOptional()) {
-        const { bitMIndexVar, bitIndex } = getOptionalBitmapItems(parent, comp, 0, rt.optionalIndex, false);
-        const setBitMask = `${sεr}.setBitMask(${bitMIndexVar}, ${bitIndex})`;
-        return { code: `if (${comp.getChildVλl()} !== undefined) {${memberCode};${setBitMask}}`, type: "S" };
-      }
-      return { code: `${memberCode}`, type: "S" };
-    }
-    case type.ReflectionKind.tupleMember: {
-      const rt = runType;
-      const child = rt.getJitChild(comp);
-      const childJit = comp.compile(child, "S", fnID);
-      const nullJIt = emitToBinaryAs(rt, comp, type.ReflectionKind.undefined);
-      const itemJit = childJit?.code ? childJit : nullJIt;
-      if (rt.isRest()) return itemJit;
-      const optionalIndex = rt.optionalIndex;
-      const bitMIndexVar = rt._bitmapVar;
-      const isFnParam = rt._isFnParam;
-      const isOptional = rt.isOptional() || isFnParam;
-      if (isOptional && optionalIndex !== void 0 && bitMIndexVar) {
-        const bitIndex = optionalIndex & 7;
-        const setBitMask = `${sεr}.setBitMask(${bitMIndexVar}, ${bitIndex})`;
-        return { code: `if (${comp.getChildVλl()} !== undefined) {${itemJit.code};${setBitMask}}`, type: "S" };
-      }
-      return itemJit;
-    }
-    case type.ReflectionKind.promise:
-      throw new Error("Jit compilation disabled for Non Serializable types.");
-    // ###################### COLLECTION RUNTYPES ######################
-    // Types that contain other types as members
-    case type.ReflectionKind.objectLiteral:
-    case type.ReflectionKind.intersection: {
-      const rt = runType;
-      if (rt.isCallable()) return comp.compile(rt.getCallSignature(), "S", fnID);
-      if (runType.src.subKind === src_constants_kind.ReflectionSubKind.nonSerializable) {
-        throw new Error("Binary serialization is disabled for Non Serializable types");
-      } else {
-        const { required, optional, indexSignatures } = rt.splitJitSplitChildren(comp);
-        if (indexSignatures.length) {
-          return comp.compile(indexSignatures[0], "S", fnID);
-        }
-        const requiredProps = required.map((prop) => comp.compile(prop, "S", fnID).code);
-        const requiredPropsCode = requiredProps.join(";");
-        let optionalPropsCode = "";
-        if (optional.length) {
-          const { bitMapInit, bitMIndexVar } = getOptionalBitmapItems(rt, comp, optional.length, 0, false);
-          const propsCode = optional.map((prop, i) => {
-            prop.optionalIndex = i;
-            const modIndex = i + 1;
-            const shouldIncreaseBufferIndex = modIndex % 8 === 0;
-            const propCode = comp.compile(prop, "S", fnID).code;
-            if (!shouldIncreaseBufferIndex) return propCode;
-            return `${propCode} ${bitMIndexVar}++;`;
-          }).filter(Boolean).join("");
-          optionalPropsCode = `${bitMapInit}
-${propsCode}`;
-        }
-        return { code: `${requiredPropsCode}
-${optionalPropsCode}`, type: "S" };
-      }
-    }
-    case type.ReflectionKind.class:
-      switch (runType.src.subKind) {
-        case src_constants_kind.ReflectionSubKind.date:
-          return {
-            code: `${sεr}.view.setFloat64(${sεr}.index, ${comp.vλl}.getTime(), 1, (${sεr}.index += 8))`,
-            type: "S"
-          };
-        case src_constants_kind.ReflectionSubKind.map:
-        case src_constants_kind.ReflectionSubKind.set: {
-          const rt = runType;
-          const sεr2 = comp.args.sεr;
-          const entry = rt.getCustomVλl(comp)?.vλl || comp.vλl;
-          const jitChildren = rt.getJitChildren(comp);
-          const childrenCode = jitChildren.map((c) => comp.compile(c, "S", fnID).code).filter(Boolean).join(";");
-          const setLength = `${sεr2}.view.setUint32(${sεr2}.index, ${comp.vλl}.size, 1); ${sεr2}.index += 4;`;
-          return {
-            code: `${setLength} for (const ${entry} of ${comp.vλl}) {${childrenCode}}`,
-            type: "S"
-          };
-        }
-        case src_constants_kind.ReflectionSubKind.nonSerializable:
-          throw new Error("Binary serialization disabled for Non Serializable types");
-        default: {
-          const rt = runType;
-          if (rt.isCallable()) {
-            const callSignature = rt.getCallSignature();
-            if (callSignature) return comp.compile(callSignature, "S", fnID);
-          }
-          const originalKind = runType.src.kind;
-          runType.src.kind = type.ReflectionKind.objectLiteral;
-          const result = emitToBinary(runType, comp);
-          runType.src.kind = originalKind;
-          return result;
-        }
-      }
-      break;
-    case type.ReflectionKind.infer:
-      throw new Error("Infer is not supported in Binary serialization");
-    case type.ReflectionKind.tuple: {
-      const rt = runType;
-      const skip = rt.skipJit(comp);
-      if (skip) return { code: void 0, type: "S" };
-      const params = rt.getParamRunTypes(comp);
-      if (params.length === 0) return { code: void 0, type: "S" };
-      const isFnParams = runType.src.subKind === src_constants_kind.ReflectionSubKind.params;
-      const required = isFnParams ? [] : params.filter((p) => !p.isOptional() && !p.isRest());
-      const optional = isFnParams ? params.filter((p) => !p.isRest()) : params.filter((p) => p.isOptional() && !p.isRest());
-      const rest = params.filter((p) => p.isRest());
-      const requiredCode = required.map((p) => comp.compile(p, "S", fnID).code).join(";");
-      let optionalCode = "";
-      if (optional.length) {
-        const { bitMapInit, bitMIndexVar } = getOptionalBitmapItems(rt, comp, optional.length, 0, true);
-        const optionalParamsCode = optional.map((p, i) => {
-          p.optionalIndex = i;
-          p._bitmapVar = bitMIndexVar;
-          p._isFnParam = isFnParams;
-          const paramCode = comp.compile(p, "S", fnID).code || "";
-          const modIndex = i + 1;
-          const shouldIncreaseBufferIndex = modIndex % 8 === 0 && modIndex < optional.length;
-          const increaseIndex = shouldIncreaseBufferIndex ? `${bitMIndexVar}++;` : "";
-          return `${paramCode} ${increaseIndex}`;
-        }).join("");
-        optionalCode = `${bitMapInit}
-${optionalParamsCode}`;
-      }
-      const restCode = rest.map((p) => comp.compile(p, "S", fnID).code).join(";");
-      const allCode = [requiredCode, optionalCode, restCode].filter(Boolean).join(";");
-      return { code: allCode, type: "S" };
-    }
-    case type.ReflectionKind.typeParameter:
-      throw new Error("Type parameter not implemented in Binary serialization");
-    case type.ReflectionKind.union: {
-      const rt = runType;
-      rt.checkAllowedChildren(comp);
-      const { simpleItems, objectTypes, anyItem } = rt.getUnionChildren(comp);
-      const totalLength = simpleItems.length + objectTypes.length + (anyItem ? 1 : 0);
-      if (totalLength > src_constants.MAX_UNION_ITEMS) {
-        throw new Error(
-          `Binary serialization not supported for Union with more than ${src_constants.MAX_UNION_ITEMS} items. Found ${totalLength} in ${rt.getUnionTypeNames()}`
-        );
-      }
-      const errName = comp.getLocalVarName("uErr", rt);
-      const fail = `throw new Error(${errName});`;
-      comp.setContextItem(
-        errName,
-        `const ${errName} = "Can not encode union to binary: item does not belong to the union"`
-      );
-      const ifElse = src_lib_utils.createIfElseFn();
-      const getEncodeCode = (childRt) => {
-        const toJit = comp.compile(childRt, "S", fnID);
-        const encodeCode = toJit.code || "";
-        const index = rt.getUnionItemIndex(comp, childRt);
-        const isUint16 = index > 255;
-        const writeIndex = isUint16 ? `${sεr}.view.setUint16(${sεr}.index, ${index}, 1, (${sεr}.index += 2))` : `${sεr}.view.setUint8(${sεr}.index++, ${index})`;
-        return `${writeIndex};${encodeCode}`;
-      };
-      const simpleCode = simpleItems.map((childRt) => {
-        const isTypeCode = rt.getChildIsTypeWithLooseCheck(childRt, comp);
-        return `${ifElse()} (${isTypeCode}) {${getEncodeCode(childRt)}}`;
-      });
-      const objCode = objectTypes.length ? objectTypes.map((childRt) => {
-        const isTypeCode = rt.getChildIsTypeWithLooseCheck(childRt, comp);
-        return `${ifElse()} (typeof ${comp.vλl} === 'object' && ${comp.vλl} !== null && ${isTypeCode}) {${getEncodeCode(childRt)}}`;
-      }) : [];
-      const anyCode = anyItem ? `${ifElse(true)} {${getEncodeCode(anyItem)}}` : `${ifElse(true)} {${fail}}`;
-      return { code: [...simpleCode, ...objCode, anyCode].join(""), type: "S" };
-    }
-    default:
-      throw new Error(`Binary serialization not supported for ${type.ReflectionKind[kind]} types`);
-  }
-  return { code: void 0, type: "S" };
-}
-function getOptionalBitmapItems(rt, comp, optionalLength = 0, currentIndex = 0, isTuple = false) {
-  const sεr = comp.args.sεr;
-  const prefix = isTuple ? "t" : "";
-  const bitMIndexVar = comp.getLocalVarName(`${prefix}bmI`, rt);
-  const bitmapLength = Math.ceil(optionalLength / 8);
-  const bitIndex = `${currentIndex} & 7`;
-  const indexVar = comp.getLocalVarName(`${prefix}iBl`, rt);
-  const setBitmapToZero = bitmapLength > 1 ? `for (let ${indexVar} = 0; ${indexVar} < ${bitmapLength}; ${indexVar}++) {${sεr}.view.setUint8(${sεr}.index++, 0)}` : `${sεr}.view.setUint8(${sεr}.index++, 0)`;
-  const bitMapInit = `${bitmapLength > 1 ? "let " : "const"} ${bitMIndexVar} = ${sεr}.index; ${setBitmapToZero}`;
-  return { bitMIndexVar, bitmapLength, bitIndex, bitMapInit };
-}
-function emitToBinaryAs(rt, comp, kind) {
-  const originalKind = rt.src.kind;
-  rt.src.kind = kind;
-  const result = emitToBinary(rt, comp);
-  rt.src.kind = originalKind;
-  return result;
-}
-exports.emitToBinary = emitToBinary;
-//# sourceMappingURL=toBinary.cjs.map

package/.dist/cjs/src/jitCompilers/binary/toBinary.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"toBinary.cjs","sources":["../../../../../src/jitCompilers/binary/toBinary.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 {ReflectionKind} from '@deepkit/type';\nimport {ReflectionSubKind} from '../../constants.kind.ts';\nimport {jitBinarySerializerArgs, JitFunctions} from '../../constants.functions.ts';\nimport {createIfElseFn} from '../../lib/utils.ts';\nimport {MAX_UNION_ITEMS} from '../../constants.ts';\nimport type {JitCode} from '../../types.ts';\nimport type {BaseRunType} from '../../lib/baseRunTypes.ts';\nimport type {BaseFnCompiler} from '../../lib/jitFnCompiler.ts';\nimport type {ArrayRunType} from '../../nodes/member/array.ts';\nimport type {PropertyRunType} from '../../nodes/member/property.ts';\nimport type {InterfaceRunType} from '../../nodes/collection/interface.ts';\nimport type {IndexSignatureRunType} from '../../nodes/member/indexProperty.ts';\nimport type {ParameterRunType} from '../../nodes/member/param.ts';\nimport type {TupleRunType} from '../../nodes/collection/tuple.ts';\nimport type {UnionRunType} from '../../nodes/collection/union.ts';\nimport type {IterableRunType} from '../../nodes/native/Iterable.ts';\nimport type {LiteralRunType} from '../../nodes/atomic/literal.ts';\n\ntype BinaryCompiler = BaseFnCompiler<typeof jitBinarySerializerArgs, typeof JitFunctions.toBinary.id>;\nconst fnID = JitFunctions.toBinary.id;\n\n/**\n * Main Binary serialization compiler function\n * Generates JIT code to serialize values to Binary format following Binary 1.1 specification\n *\n * This function generates JavaScript expressions that return Uint8Array containing Binary bytes.\n */\nexport function emitToBinary(runType: BaseRunType, comp: BinaryCompiler): JitCode {\n    const src = runType.src;\n    const kind = src.kind;\n    const sεr = comp.args.sεr;\n\n    // hack is used in some case to increase the index passing an extra argument to view.set methods\n    // ie: view.setUint32(index, value, littleEndian, index += 4);\n    // setUint32 only accepts 3 arguments, but we use the 4rd one to increase the index on a single statement so code can be used as an expression\n\n    switch (kind) {\n        // ###################### ATOMIC TYPES ######################\n        case ReflectionKind.unknown:\n        case ReflectionKind.any: {\n            // any is serialized as json string\n            return {code: `${sεr}.serString(JSON.stringify(${comp.vλl}))`, type: 'S'};\n        }\n        case ReflectionKind.null:\n            return {code: `${sεr}.view.setUint8(${sεr}.index++, 0)`, type: 'S'};\n        case ReflectionKind.boolean:\n            return {code: `${sεr}.view.setUint8(${sεr}.index++, !!${comp.vλl})`, type: 'S'};\n        case ReflectionKind.number: {\n            return {code: `${sεr}.view.setFloat64(${sεr}.index,${comp.vλl}, 1, (${sεr}.index += 8))`, type: 'S'};\n        }\n        case ReflectionKind.string: {\n            return {code: `${sεr}.serString(${comp.vλl})`, type: 'S'};\n        }\n        case ReflectionKind.bigint: {\n            return {code: `${sεr}.serString(${comp.vλl}.toString(), true)`, type: 'S'};\n        }\n        case ReflectionKind.undefined:\n        case ReflectionKind.void:\n            return {code: `${sεr}.view.setUint8(${sεr}.index++, 1)`, type: 'S'};\n        case ReflectionKind.symbol: {\n            return {code: `${sεr}.serString(${comp.vλl}.description || '')`, type: 'S'};\n        }\n        case ReflectionKind.regexp: {\n            return {code: `${sεr}.serString(${comp.vλl}.source);${sεr}.serString(${comp.vλl}.flags)`, type: 'S'};\n        }\n        case ReflectionKind.object:\n            // similar to any, this is serialized as json string\n            return {code: `${sεr}.serString(JSON.stringify(${comp.vλl}))`, type: 'S'};\n        case ReflectionKind.enum: {\n            return {code: `${sεr}.serEnum(${comp.vλl})`, type: 'S'};\n        }\n        case ReflectionKind.enumMember:\n            throw new Error('Binary serialization not supported for enum member types');\n        case ReflectionKind.never:\n            throw new Error('Never type cannot be serialized to Binary');\n        case ReflectionKind.templateLiteral:\n            throw new Error('Template literals are not supported in Binary serialization');\n        case ReflectionKind.literal: {\n            if (comp.opts.noLiterals) {\n                const lit = (runType as LiteralRunType).src.literal;\n                if (lit instanceof RegExp) return emitToBinaryAs(runType, comp, ReflectionKind.regexp);\n                switch (typeof lit) {\n                    case 'string':\n                        return emitToBinaryAs(runType, comp, ReflectionKind.string);\n                    case 'number':\n                        return emitToBinaryAs(runType, comp, ReflectionKind.number);\n                    case 'boolean':\n                        return emitToBinaryAs(runType, comp, ReflectionKind.boolean);\n                    case 'bigint':\n                        return emitToBinaryAs(runType, comp, ReflectionKind.bigint);\n                    case 'symbol':\n                        return emitToBinaryAs(runType, comp, ReflectionKind.symbol);\n                    default:\n                        throw new Error(`Unsupported literal type ${typeof lit}`);\n                }\n            }\n            return {code: '', type: 'S'}; // literals can be skipped as we restore the value directly from runType in jit code\n        }\n\n        // ###################### MEMBER RUNTYPES ######################\n        // Types that represent members of collections or other structures\n        case ReflectionKind.rest: // rest params are serialized as array but start at rest item index\n        case ReflectionKind.array: {\n            const rt = runType as ArrayRunType;\n            rt.checkNonSkipTypes(comp);\n            const child = rt.getMemberType()!;\n            const memberJit = comp.compile(child, 'S', fnID);\n            if (!memberJit?.code) throw new Error(`Do not know how to serialize Array<${child.getTypeName()}> to Binary.`);\n            const index = rt.getChildVarName(comp);\n            // serialized as [length, items...]\n            return {\n                code: `\n                ${sεr}.view.setUint32(${sεr}.index, ${comp.vλl}.length, 1); ${sεr}.index += 4;\n                for (let ${index} = ${rt.startIndex(comp)}; ${index} < ${comp.vλl}.length; ${index}++) {${memberJit.code}}\n            `,\n                type: 'S',\n            };\n        }\n        case ReflectionKind.indexSignature: {\n            const rt = runType as IndexSignatureRunType;\n            const indexKind = (rt.src as any).index?.kind;\n            const memberJit = comp.compile(rt.getJitChild(comp), 'S', fnID);\n            if (!memberJit?.code) return {code: undefined, type: 'S'};\n\n            const propVar = rt.getChildVarName(comp);\n            const lengthVar = comp.getLocalVarName('cnt', rt);\n            const indexVar = comp.getLocalVarName('piI', rt);\n            const varsInit = `let ${lengthVar} = 0; const ${indexVar} = ${sεr}.index; ${sεr}.index += 4;`;\n\n            // Serialize entries\n            let keySerializationCode: string;\n            if (indexKind === ReflectionKind.number) {\n                keySerializationCode = `${sεr}.view.setUint32(${sεr}.index , Number(${propVar}), 1); ${sεr}.index += 4;`;\n            } else {\n                keySerializationCode = `${sεr}.serString(${propVar});`;\n            }\n\n            return {\n                code: `\n                ${varsInit};\n                for (const ${propVar} in ${comp.vλl}) {${keySerializationCode} ${memberJit.code}; ${lengthVar}++;}\n                ${sεr}.view.setUint32(${indexVar}, ${lengthVar}, 1);\n            `,\n                type: 'S',\n            };\n        }\n\n        case ReflectionKind.function:\n        case ReflectionKind.method:\n        case ReflectionKind.methodSignature:\n        case ReflectionKind.callSignature:\n            if (runType.src.subKind === ReflectionSubKind.params) {\n                return emitToBinaryAs(runType, comp, ReflectionKind.tuple);\n            } else {\n                throw new Error('Binary serialization not supported for functions, call compileParams or compileReturn instead.');\n            }\n        case ReflectionKind.parameter: {\n            const rt = runType as ParameterRunType;\n            switch (src.subKind) {\n                case ReflectionSubKind.mapKey:\n                case ReflectionSubKind.mapValue:\n                case ReflectionSubKind.setItem: {\n                    const child = rt.getJitChild(comp);\n                    const childJit = comp.compile(child, 'S', fnID);\n                    if (!childJit?.code) throw new Error(`Do not know how to serialize ${rt.getTypeName()} to Binary.`);\n                    return childJit;\n                }\n                default: {\n                    return emitToBinaryAs(runType, comp, ReflectionKind.tupleMember);\n                }\n            }\n        }\n        case ReflectionKind.property:\n        case ReflectionKind.propertySignature: {\n            const rt = runType as PropertyRunType;\n            const parent = rt.getParent() as InterfaceRunType;\n            if (parent.hasIndexSignature(comp)) return {code: undefined, type: 'S'}; // all serialization is done by index signature code\n\n            const memberCode = comp.compile(rt.getJitChild(comp), 'S', fnID).code || '';\n            if (rt.isOptional()) {\n                const {bitMIndexVar, bitIndex} = getOptionalBitmapItems(parent, comp, 0, rt.optionalIndex, false);\n                const setBitMask = `${sεr}.setBitMask(${bitMIndexVar}, ${bitIndex})`;\n                return {code: `if (${comp.getChildVλl()} !== undefined) {${memberCode};${setBitMask}}`, type: 'S'};\n            }\n            // non optional properties rely in the order they are defined in the type so no need to include the index\n            return {code: `${memberCode}`, type: 'S'};\n        }\n        case ReflectionKind.tupleMember: {\n            const rt = runType as ParameterRunType;\n            const child = rt.getJitChild(comp);\n            const childJit = comp.compile(child, 'S', fnID);\n            const nullJIt = emitToBinaryAs(rt, comp, ReflectionKind.undefined);\n            const itemJit = childJit?.code ? childJit : nullJIt; // if child is not serializable, we serialize null as need to fill the space in the tuple\n            if (rt.isRest()) return itemJit;\n            // Optional handling uses bitmap set at tuple level\n            const optionalIndex = (rt as any).optionalIndex;\n            const bitMIndexVar = (rt as any)._bitmapVar;\n            const isFnParam = (rt as any)._isFnParam;\n            // Treat as optional if either isOptional() is true OR it's a function param (all fn params are optional in binary)\n            const isOptional = rt.isOptional() || isFnParam;\n            if (isOptional && optionalIndex !== undefined && bitMIndexVar) {\n                const bitIndex = optionalIndex & 7; // equivalent to optionalIndex % 8\n                const setBitMask = `${sεr}.setBitMask(${bitMIndexVar}, ${bitIndex})`;\n                return {code: `if (${comp.getChildVλl()} !== undefined) {${itemJit.code};${setBitMask}}`, type: 'S'};\n            }\n            return itemJit;\n        }\n\n        case ReflectionKind.promise:\n            throw new Error('Jit compilation disabled for Non Serializable types.');\n\n        // ###################### COLLECTION RUNTYPES ######################\n        // Types that contain other types as members\n        case ReflectionKind.objectLiteral:\n        case ReflectionKind.intersection: {\n            const rt = runType as InterfaceRunType;\n            if (rt.isCallable()) return comp.compile(rt.getCallSignature(), 'S', fnID);\n            if (runType.src.subKind === ReflectionSubKind.nonSerializable) {\n                throw new Error('Binary serialization is disabled for Non Serializable types');\n            } else {\n                // we need to ensure non optional properties are serialized first so then we can restore the object correctly\n                // non optional properties are restored as: '{a: deserializeA, b: deserializeB, c: deserializeC};\n                // and must be serialized/deserialized in the same order they are declared in the type\n                const {required, optional, indexSignatures} = rt.splitJitSplitChildren(comp);\n\n                if (indexSignatures.length) {\n                    return comp.compile(indexSignatures[0], 'S', fnID); // index signature code already contains the loop\n                }\n\n                const requiredProps = required.map((prop) => comp.compile(prop, 'S', fnID).code);\n                const requiredPropsCode = requiredProps.join(';');\n\n                let optionalPropsCode = '';\n                if (optional.length) {\n                    const {bitMapInit, bitMIndexVar} = getOptionalBitmapItems(rt, comp, optional.length, 0, false);\n                    const propsCode = optional\n                        .map((prop, i) => {\n                            prop.optionalIndex = i;\n                            const modIndex = i + 1;\n                            const shouldIncreaseBufferIndex = modIndex % 8 === 0;\n                            const propCode = comp.compile(prop, 'S', fnID).code;\n                            if (!shouldIncreaseBufferIndex) return propCode;\n                            // every 8 props we need to increase the bitmap index\n                            return `${propCode} ${bitMIndexVar}++;`;\n                        })\n                        .filter(Boolean)\n                        .join('');\n                    optionalPropsCode = `${bitMapInit}\\n${propsCode}`;\n                }\n\n                return {code: `${requiredPropsCode}\\n${optionalPropsCode}`, type: 'S'};\n            }\n        }\n        case ReflectionKind.class:\n            switch (runType.src.subKind) {\n                case ReflectionSubKind.date:\n                    return {\n                        code: `${sεr}.view.setFloat64(${sεr}.index, ${comp.vλl}.getTime(), 1, (${sεr}.index += 8))`,\n                        type: 'S',\n                    };\n                case ReflectionSubKind.map:\n                case ReflectionSubKind.set: {\n                    const rt = runType as IterableRunType;\n                    const sεr = comp.args.sεr;\n                    const entry = rt.getCustomVλl(comp)?.vλl || comp.vλl;\n                    const jitChildren = rt.getJitChildren(comp);\n                    const childrenCode = jitChildren\n                        .map((c) => comp.compile(c, 'S', fnID).code)\n                        .filter(Boolean)\n                        .join(';');\n                    // Serialize length at the beginning, then iterate and serialize items\n                    const setLength = `${sεr}.view.setUint32(${sεr}.index, ${comp.vλl}.size, 1); ${sεr}.index += 4;`;\n                    return {\n                        code: `${setLength} for (const ${entry} of ${comp.vλl}) {${childrenCode}}`,\n                        type: 'S',\n                    };\n                }\n                case ReflectionSubKind.nonSerializable:\n                    throw new Error('Binary serialization disabled for Non Serializable types');\n                default: {\n                    const rt = runType as InterfaceRunType;\n                    if (rt.isCallable()) {\n                        const callSignature = rt.getCallSignature();\n                        if (callSignature) return comp.compile(callSignature, 'S', fnID);\n                    }\n                    const originalKind = runType.src.kind;\n                    (runType.src as any).kind = ReflectionKind.objectLiteral;\n                    const result = emitToBinary(runType, comp);\n                    (runType.src as any).kind = originalKind;\n                    return result;\n                }\n            }\n            break;\n\n        case ReflectionKind.infer:\n            throw new Error('Infer is not supported in Binary serialization');\n\n        case ReflectionKind.tuple: {\n            const rt = runType as TupleRunType;\n            const skip = rt.skipJit(comp);\n            if (skip) return {code: undefined, type: 'S'};\n            const params = rt.getParamRunTypes(comp);\n            if (params.length === 0) return {code: undefined, type: 'S'};\n\n            // For function params, all params are treated as optional in binary serialization\n            // This allows sending null/undefined values over the wire even if the type is not optional\n            const isFnParams = runType.src.subKind === ReflectionSubKind.params;\n\n            // Split params into required, optional, and rest\n            // For function params, all non-rest params are treated as optional\n            const required = isFnParams ? [] : params.filter((p) => !p.isOptional() && !p.isRest());\n            const optional = isFnParams ? params.filter((p) => !p.isRest()) : params.filter((p) => p.isOptional() && !p.isRest());\n            const rest = params.filter((p) => p.isRest());\n\n            // Serialize required params first\n            const requiredCode = required.map((p) => comp.compile(p, 'S', fnID).code).join(';');\n\n            // Serialize optional params with bitmap (groups of 8)\n            let optionalCode = '';\n            if (optional.length) {\n                const {bitMapInit, bitMIndexVar} = getOptionalBitmapItems(rt, comp, optional.length, 0, true);\n                const optionalParamsCode = optional\n                    .map((p, i) => {\n                        (p as any).optionalIndex = i; // set optionalIndex for use in tupleMember case\n                        (p as any)._bitmapVar = bitMIndexVar; // pass bitmap variable name to tupleMember case\n                        (p as any)._isFnParam = isFnParams; // flag to indicate this is a function param\n                        const paramCode = comp.compile(p, 'S', fnID).code || '';\n                        const modIndex = i + 1;\n                        const shouldIncreaseBufferIndex = modIndex % 8 === 0 && modIndex < optional.length;\n                        const increaseIndex = shouldIncreaseBufferIndex ? `${bitMIndexVar}++;` : '';\n                        return `${paramCode} ${increaseIndex}`;\n                    })\n                    .join('');\n                optionalCode = `${bitMapInit}\\n${optionalParamsCode}`;\n            }\n\n            // Serialize rest params (handled as array by the rest param itself)\n            const restCode = rest.map((p) => comp.compile(p, 'S', fnID).code).join(';');\n\n            const allCode = [requiredCode, optionalCode, restCode].filter(Boolean).join(';');\n            return {code: allCode, type: 'S'};\n        }\n        case ReflectionKind.typeParameter:\n            throw new Error('Type parameter not implemented in Binary serialization');\n\n        case ReflectionKind.union: {\n            const rt = runType as UnionRunType;\n            rt.checkAllowedChildren(comp);\n            const {simpleItems, objectTypes, anyItem} = rt.getUnionChildren(comp);\n            const totalLength = simpleItems.length + objectTypes.length + (anyItem ? 1 : 0);\n            if (totalLength > MAX_UNION_ITEMS) {\n                throw new Error(\n                    `Binary serialization not supported for Union with more than ${MAX_UNION_ITEMS} items.` +\n                        ` Found ${totalLength} in ${rt.getUnionTypeNames()}`\n                );\n            }\n            const errName = comp.getLocalVarName('uErr', rt);\n            const fail = `throw new Error(${errName});`;\n            comp.setContextItem(\n                errName,\n                `const ${errName} = \"Can not encode union to binary: item does not belong to the union\"`\n            );\n            const ifElse = createIfElseFn();\n            // Helper to generate encode code for a union item\n            const getEncodeCode = (childRt: BaseRunType) => {\n                const toJit = comp.compile(childRt, 'S', fnID);\n                const encodeCode = toJit.code || '';\n                const index = rt.getUnionItemIndex(comp, childRt);\n                const isUint16 = index > 255;\n                const writeIndex = isUint16\n                    ? `${sεr}.view.setUint16(${sεr}.index, ${index}, 1, (${sεr}.index += 2))`\n                    : `${sεr}.view.setUint8(${sεr}.index++, ${index})`;\n                return `${writeIndex};${encodeCode}`;\n            };\n            // Generate code for simple items (atomic types)\n            const simpleCode = simpleItems.map((childRt) => {\n                const isTypeCode = rt.getChildIsTypeWithLooseCheck(childRt, comp);\n                return `${ifElse()} (${isTypeCode}) {${getEncodeCode(childRt)}}`;\n            });\n            // Generate code for object types (need null guard)\n            const objCode = objectTypes.length\n                ? objectTypes.map((childRt) => {\n                      const isTypeCode = rt.getChildIsTypeWithLooseCheck(childRt, comp);\n                      return `${ifElse()} (typeof ${comp.vλl} === 'object' && ${comp.vλl} !== null && ${isTypeCode}) {${getEncodeCode(childRt)}}`;\n                  })\n                : [];\n            // Generate code for anyItem (always matches, checked last as fallback)\n            const anyCode = anyItem ? `${ifElse(true)} {${getEncodeCode(anyItem)}}` : `${ifElse(true)} {${fail}}`;\n            return {code: [...simpleCode, ...objCode, anyCode].join(''), type: 'S'};\n        }\n        default:\n            throw new Error(`Binary serialization not supported for ${ReflectionKind[kind]} types`);\n    }\n\n    // Default return for cases that break without returning\n    return {code: undefined, type: 'S'};\n}\n\n/** Generates bitmap initialization code for optional properties/params. Uses 1 bit per optional item (8 items per byte). */\nfunction getOptionalBitmapItems(\n    rt: InterfaceRunType | TupleRunType,\n    comp: BinaryCompiler,\n    optionalLength = 0,\n    currentIndex = 0,\n    isTuple = false\n) {\n    const sεr = comp.args.sεr;\n    const prefix = isTuple ? 't' : '';\n    const bitMIndexVar = comp.getLocalVarName(`${prefix}bmI`, rt); // index of the bitmap\n    const bitmapLength = Math.ceil(optionalLength / 8);\n    const bitIndex = `${currentIndex} & 7`; // equivalent to index % 8\n    // initialize bitmap to zero as there could be values left from previous serialization\n    const indexVar = comp.getLocalVarName(`${prefix}iBl`, rt);\n    const setBitmapToZero =\n        bitmapLength > 1\n            ? `for (let ${indexVar} = 0; ${indexVar} < ${bitmapLength}; ${indexVar}++) {${sεr}.view.setUint8(${sεr}.index++, 0)}`\n            : `${sεr}.view.setUint8(${sεr}.index++, 0)`;\n    const bitMapInit = `${bitmapLength > 1 ? 'let ' : 'const'} ${bitMIndexVar} = ${sεr}.index; ${setBitmapToZero}`;\n    return {bitMIndexVar, bitmapLength, bitIndex, bitMapInit};\n}\n\nfunction emitToBinaryAs(rt: BaseRunType, comp: BinaryCompiler, kind: ReflectionKind): JitCode {\n    const originalKind = rt.src.kind;\n    (rt.src as any).kind = kind;\n    const result = emitToBinary(rt, comp);\n    (rt.src as any).kind = originalKind;\n    return result;\n}\n"],"names":["JitFunctions","ReflectionKind","ReflectionSubKind","sεr","MAX_UNION_ITEMS","createIfElseFn"],"mappings":"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"}

package/.dist/cjs/src/jitCompilers/binary/toBinary.d.ts

@@ -1,8 +0,0 @@
-import { jitBinarySerializerArgs, JitFunctions } from '../../constants.functions.ts';
-import { JitCode } from '../../types.ts';
-import { BaseRunType } from '../../lib/baseRunTypes.ts';
-import { BaseFnCompiler } from '../../lib/jitFnCompiler.ts';
-type BinaryCompiler = BaseFnCompiler<typeof jitBinarySerializerArgs, typeof JitFunctions.toBinary.id>;
-export declare function emitToBinary(runType: BaseRunType, comp: BinaryCompiler): JitCode;
-export {};
-//# sourceMappingURL=toBinary.d.ts.map

package/.dist/cjs/src/jitCompilers/binary/toBinary.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"toBinary.d.ts","sourceRoot":"","sources":["../../../../../src/jitCompilers/binary/toBinary.ts"],"names":[],"mappings":"AASA,OAAO,EAAC,uBAAuB,EAAE,YAAY,EAAC,MAAM,8BAA8B,CAAC;AAGnF,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,2BAA2B,CAAC;AAC3D,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,4BAA4B,CAAC;AAW/D,KAAK,cAAc,GAAG,cAAc,CAAC,OAAO,uBAAuB,EAAE,OAAO,YAAY,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;AAStG,wBAAgB,YAAY,CAAC,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,cAAc,GAAG,OAAO,CAiXhF"}

package/.dist/cjs/src/jitCompilers/equalsHelpers.cjs

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-function normalizeForComparison(actual, expected) {
-  if (Array.isArray(actual) && Array.isArray(expected)) {
-    const maxLength = Math.max(actual.length, expected.length);
-    const normalizedActual = normalizeArrayForComparison(actual, maxLength);
-    const normalizedExpected = normalizeArrayForComparison(expected, maxLength);
-    const resultActual = [];
-    const resultExpected = [];
-    for (let i = 0; i < maxLength; i++) {
-      const normalized = normalizeForComparison(normalizedActual[i], normalizedExpected[i]);
-      resultActual.push(normalized.actual);
-      resultExpected.push(normalized.expected);
-    }
-    return { actual: resultActual, expected: resultExpected };
-  }
-  if (actual && expected && typeof actual === "object" && typeof expected === "object") {
-    const actualKeys = Object.keys(actual);
-    const expectedKeys = Object.keys(expected);
-    const allKeys = [.../* @__PURE__ */ new Set([...actualKeys, ...expectedKeys])];
-    const resultActual = {};
-    const resultExpected = {};
-    for (const key of allKeys) {
-      const normalized = normalizeForComparison(actual[key], expected[key]);
-      resultActual[key] = normalized.actual;
-      resultExpected[key] = normalized.expected;
-    }
-    return { actual: resultActual, expected: resultExpected };
-  }
-  return { actual, expected };
-}
-function normalizeArrayForComparison(arr, targetLength) {
-  if (arr.length >= targetLength) return arr;
-  return [...arr, ...Array(targetLength - arr.length).fill(void 0)];
-}
-exports.normalizeForComparison = normalizeForComparison;
-//# sourceMappingURL=equalsHelpers.cjs.map

package/.dist/cjs/src/jitCompilers/equalsHelpers.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"equalsHelpers.cjs","sources":["../../../../src/jitCompilers/equalsHelpers.ts"],"sourcesContent":["/* ###############\n * 2026 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ############### */\n\n/**\n * Recursively normalizes values for comparison, handling arrays with optional elements.\n * Returns an object with normalized actual and expected values for direct comparison.\n *\n * This is needed because Vitest's toEqual is stricter than Jest's when comparing arrays\n * with optional/undefined elements. For example:\n * - Jest: [446] equals [446, undefined, undefined, undefined] // true\n * - Vitest: [446] equals [446, undefined, undefined, undefined] // false\n *\n * This function pads shorter arrays with undefined to match the longer array's length,\n * then recursively normalizes nested values.\n */\nexport function normalizeForComparison(actual: any, expected: any): {actual: any; expected: any} {\n    // Handle arrays - normalize length to match expected\n    if (Array.isArray(actual) && Array.isArray(expected)) {\n        const maxLength = Math.max(actual.length, expected.length);\n        const normalizedActual = normalizeArrayForComparison(actual, maxLength);\n        const normalizedExpected = normalizeArrayForComparison(expected, maxLength);\n        const resultActual: any[] = [];\n        const resultExpected: any[] = [];\n        for (let i = 0; i < maxLength; i++) {\n            const normalized = normalizeForComparison(normalizedActual[i], normalizedExpected[i]);\n            resultActual.push(normalized.actual);\n            resultExpected.push(normalized.expected);\n        }\n        return {actual: resultActual, expected: resultExpected};\n    }\n    // Handle nested objects\n    if (actual && expected && typeof actual === 'object' && typeof expected === 'object') {\n        const actualKeys = Object.keys(actual);\n        const expectedKeys = Object.keys(expected);\n        const allKeys = [...new Set([...actualKeys, ...expectedKeys])];\n        const resultActual: any = {};\n        const resultExpected: any = {};\n        for (const key of allKeys) {\n            const normalized = normalizeForComparison(actual[key], expected[key]);\n            resultActual[key] = normalized.actual;\n            resultExpected[key] = normalized.expected;\n        }\n        return {actual: resultActual, expected: resultExpected};\n    }\n    // Primitive values - return as-is\n    return {actual, expected};\n}\n\n/**\n * Normalizes arrays for comparison by padding shorter arrays with undefined values.\n * This handles the difference between Jest and Vitest's toEqual behavior with optional tuple elements.\n * Jest considered [446] and [446, undefined, undefined, undefined] as equal,\n * but Vitest is stricter and requires explicit undefined values.\n */\nfunction normalizeArrayForComparison(arr: any[], targetLength: number): any[] {\n    if (arr.length >= targetLength) return arr;\n    return [...arr, ...Array(targetLength - arr.length).fill(undefined)];\n}\n"],"names":[],"mappings":";;AAmBO,SAAS,uBAAuB,QAAa,UAA6C;AAE7F,MAAI,MAAM,QAAQ,MAAM,KAAK,MAAM,QAAQ,QAAQ,GAAG;AAClD,UAAM,YAAY,KAAK,IAAI,OAAO,QAAQ,SAAS,MAAM;AACzD,UAAM,mBAAmB,4BAA4B,QAAQ,SAAS;AACtE,UAAM,qBAAqB,4BAA4B,UAAU,SAAS;AAC1E,UAAM,eAAsB,CAAA;AAC5B,UAAM,iBAAwB,CAAA;AAC9B,aAAS,IAAI,GAAG,IAAI,WAAW,KAAK;AAChC,YAAM,aAAa,uBAAuB,iBAAiB,CAAC,GAAG,mBAAmB,CAAC,CAAC;AACpF,mBAAa,KAAK,WAAW,MAAM;AACnC,qBAAe,KAAK,WAAW,QAAQ;AAAA,IAC3C;AACA,WAAO,EAAC,QAAQ,cAAc,UAAU,eAAA;AAAA,EAC5C;AAEA,MAAI,UAAU,YAAY,OAAO,WAAW,YAAY,OAAO,aAAa,UAAU;AAClF,UAAM,aAAa,OAAO,KAAK,MAAM;AACrC,UAAM,eAAe,OAAO,KAAK,QAAQ;AACzC,UAAM,UAAU,CAAC,GAAG,oBAAI,IAAI,CAAC,GAAG,YAAY,GAAG,YAAY,CAAC,CAAC;AAC7D,UAAM,eAAoB,CAAA;AAC1B,UAAM,iBAAsB,CAAA;AAC5B,eAAW,OAAO,SAAS;AACvB,YAAM,aAAa,uBAAuB,OAAO,GAAG,GAAG,SAAS,GAAG,CAAC;AACpE,mBAAa,GAAG,IAAI,WAAW;AAC/B,qBAAe,GAAG,IAAI,WAAW;AAAA,IACrC;AACA,WAAO,EAAC,QAAQ,cAAc,UAAU,eAAA;AAAA,EAC5C;AAEA,SAAO,EAAC,QAAQ,SAAA;AACpB;AAQA,SAAS,4BAA4B,KAAY,cAA6B;AAC1E,MAAI,IAAI,UAAU,aAAc,QAAO;AACvC,SAAO,CAAC,GAAG,KAAK,GAAG,MAAM,eAAe,IAAI,MAAM,EAAE,KAAK,MAAS,CAAC;AACvE;;"}

package/.dist/cjs/src/jitCompilers/equalsHelpers.d.ts

@@ -1,5 +0,0 @@
-export declare function normalizeForComparison(actual: any, expected: any): {
-    actual: any;
-    expected: any;
-};
-//# sourceMappingURL=equalsHelpers.d.ts.map

package/.dist/cjs/src/jitCompilers/equalsHelpers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"equalsHelpers.d.ts","sourceRoot":"","sources":["../../../../src/jitCompilers/equalsHelpers.ts"],"names":[],"mappings":"AAmBA,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,GAAG;IAAC,MAAM,EAAE,GAAG,CAAC;IAAC,QAAQ,EAAE,GAAG,CAAA;CAAC,CA+B/F"}

package/.dist/cjs/src/jitCompilers/json/jsonSpec/jsonHelpers.cjs

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const src_constants_functions = require("../../../constants.functions.cjs");
-const SERIALIZE_FN = src_constants_functions.JitFunctions.prepareForJson;
-const DESERIALIZE_FN = src_constants_functions.JitFunctions.restoreFromJson;
-function createSerializationFns(rt) {
-  const prepareForJson = rt.createJitFunction(SERIALIZE_FN);
-  const restoreFromJson = rt.createJitFunction(DESERIALIZE_FN);
-  const serialize = (v) => JSON.stringify(prepareForJson(v));
-  const deserialize = (data) => restoreFromJson(JSON.parse(data));
-  return { serialize, deserialize };
-}
-function createSerializationParamsFn(rt, sliceStart) {
-  const params = typeof sliceStart === "number" ? { paramsSlice: { start: sliceStart } } : void 0;
-  const prepareForJson = rt.createJitParamsFunction(SERIALIZE_FN, params);
-  const restoreFromJson = rt.createJitParamsFunction(DESERIALIZE_FN, params);
-  const serialize = (v) => JSON.stringify(prepareForJson(v));
-  const deserialize = (data) => restoreFromJson(JSON.parse(data));
-  return { serialize, deserialize };
-}
-function createSerializationReturnFn(rt) {
-  const prepareForJson = rt.createJitReturnFunction(SERIALIZE_FN);
-  const restoreFromJson = rt.createJitReturnFunction(DESERIALIZE_FN);
-  const serialize = (v) => JSON.stringify(prepareForJson(v));
-  const deserialize = (data) => restoreFromJson(JSON.parse(data));
-  return { serialize, deserialize };
-}
-function createSerializationCallSignatureParamsFn(rt) {
-  const callSignature = rt.getCallSignature();
-  const prepareForJson = callSignature.createJitParamsFunction(SERIALIZE_FN);
-  const restoreFromJson = callSignature.createJitParamsFunction(DESERIALIZE_FN);
-  const serialize = (v) => JSON.stringify(prepareForJson(v));
-  const deserialize = (data) => restoreFromJson(JSON.parse(data));
-  return { serialize, deserialize };
-}
-function createSerializationCallSignatureReturnFn(rt) {
-  const callSignature = rt.getCallSignature();
-  const prepareForJson = callSignature.createJitReturnFunction(SERIALIZE_FN);
-  const restoreFromJson = callSignature.createJitReturnFunction(DESERIALIZE_FN);
-  const serialize = (v) => JSON.stringify(prepareForJson(v));
-  const deserialize = (data) => restoreFromJson(JSON.parse(data));
-  return { serialize, deserialize };
-}
-function roundTrip(serialize, deserialize, value) {
-  const serialized = serialize(value);
-  const deserialized = deserialize(serialized);
-  const result = { serialized, deserialized };
-  return result;
-}
-exports.createSerializationCallSignatureParamsFn = createSerializationCallSignatureParamsFn;
-exports.createSerializationCallSignatureReturnFn = createSerializationCallSignatureReturnFn;
-exports.createSerializationFns = createSerializationFns;
-exports.createSerializationParamsFn = createSerializationParamsFn;
-exports.createSerializationReturnFn = createSerializationReturnFn;
-exports.roundTrip = roundTrip;
-//# sourceMappingURL=jsonHelpers.cjs.map

package/.dist/cjs/src/jitCompilers/json/jsonSpec/jsonHelpers.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"jsonHelpers.cjs","sources":["../../../../../../src/jitCompilers/json/jsonSpec/jsonHelpers.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 type {InterfaceRunType} from '../../../nodes/collection/interface.ts';\nimport type {FunctionRunType} from '../../../nodes/function/function.ts';\nimport type {RunType} from '../../../types.ts';\n\nconst SERIALIZE_FN = JitFunctions.prepareForJson;\nconst DESERIALIZE_FN = JitFunctions.restoreFromJson;\n\nexport function createSerializationFns(rt: RunType) {\n    const prepareForJson = rt.createJitFunction(SERIALIZE_FN);\n    const restoreFromJson = rt.createJitFunction(DESERIALIZE_FN);\n    const serialize = (v: any) => JSON.stringify(prepareForJson(v));\n    const deserialize = (data: any) => restoreFromJson(JSON.parse(data));\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 prepareForJson = rt.createJitParamsFunction(SERIALIZE_FN, params);\n    const restoreFromJson = rt.createJitParamsFunction(DESERIALIZE_FN, params);\n    const serialize = (v: any) => JSON.stringify(prepareForJson(v));\n    const deserialize = (data: any) => restoreFromJson(JSON.parse(data));\n    return {serialize, deserialize};\n}\n\nexport function createSerializationReturnFn(rt: FunctionRunType) {\n    const prepareForJson = rt.createJitReturnFunction(SERIALIZE_FN);\n    const restoreFromJson = rt.createJitReturnFunction(DESERIALIZE_FN);\n    const serialize = (v: any) => JSON.stringify(prepareForJson(v));\n    const deserialize = (data: any) => restoreFromJson(JSON.parse(data));\n    return {serialize, deserialize};\n}\n\nexport function createSerializationCallSignatureParamsFn(rt: InterfaceRunType) {\n    const callSignature = rt.getCallSignature()!;\n    const prepareForJson = callSignature.createJitParamsFunction(SERIALIZE_FN);\n    const restoreFromJson = callSignature.createJitParamsFunction(DESERIALIZE_FN);\n    const serialize = (v: any) => JSON.stringify(prepareForJson(v));\n    const deserialize = (data: any) => restoreFromJson(JSON.parse(data));\n    return {serialize, deserialize};\n}\n\nexport function createSerializationCallSignatureReturnFn(rt: InterfaceRunType) {\n    const callSignature = rt.getCallSignature()!;\n    const prepareForJson = callSignature.createJitReturnFunction(SERIALIZE_FN);\n    const restoreFromJson = callSignature.createJitReturnFunction(DESERIALIZE_FN);\n    const serialize = (v: any) => JSON.stringify(prepareForJson(v));\n    const deserialize = (data: any) => restoreFromJson(JSON.parse(data));\n    return {serialize, deserialize};\n}\n\nexport function roundTrip(serialize: (v: any) => string, deserialize: (v: string) => any, value: any) {\n    const serialized = serialize(value);\n    const deserialized = deserialize(serialized);\n    const result = {serialized, deserialized};\n    return result;\n}\n"],"names":["JitFunctions"],"mappings":";;;AAYA,MAAM,eAAeA,wBAAAA,aAAa;AAClC,MAAM,iBAAiBA,wBAAAA,aAAa;AAE7B,SAAS,uBAAuB,IAAa;AAChD,QAAM,iBAAiB,GAAG,kBAAkB,YAAY;AACxD,QAAM,kBAAkB,GAAG,kBAAkB,cAAc;AAC3D,QAAM,YAAY,CAAC,MAAW,KAAK,UAAU,eAAe,CAAC,CAAC;AAC9D,QAAM,cAAc,CAAC,SAAc,gBAAgB,KAAK,MAAM,IAAI,CAAC;AACnE,SAAO,EAAC,WAAW,YAAA;AACvB;AAEO,SAAS,4BAA4B,IAAqB,YAAqB;AAClF,QAAM,SAAS,OAAO,eAAe,WAAW,EAAC,aAAa,EAAC,OAAO,WAAA,EAAU,IAAK;AACrF,QAAM,iBAAiB,GAAG,wBAAwB,cAAc,MAAM;AACtE,QAAM,kBAAkB,GAAG,wBAAwB,gBAAgB,MAAM;AACzE,QAAM,YAAY,CAAC,MAAW,KAAK,UAAU,eAAe,CAAC,CAAC;AAC9D,QAAM,cAAc,CAAC,SAAc,gBAAgB,KAAK,MAAM,IAAI,CAAC;AACnE,SAAO,EAAC,WAAW,YAAA;AACvB;AAEO,SAAS,4BAA4B,IAAqB;AAC7D,QAAM,iBAAiB,GAAG,wBAAwB,YAAY;AAC9D,QAAM,kBAAkB,GAAG,wBAAwB,cAAc;AACjE,QAAM,YAAY,CAAC,MAAW,KAAK,UAAU,eAAe,CAAC,CAAC;AAC9D,QAAM,cAAc,CAAC,SAAc,gBAAgB,KAAK,MAAM,IAAI,CAAC;AACnE,SAAO,EAAC,WAAW,YAAA;AACvB;AAEO,SAAS,yCAAyC,IAAsB;AAC3E,QAAM,gBAAgB,GAAG,iBAAA;AACzB,QAAM,iBAAiB,cAAc,wBAAwB,YAAY;AACzE,QAAM,kBAAkB,cAAc,wBAAwB,cAAc;AAC5E,QAAM,YAAY,CAAC,MAAW,KAAK,UAAU,eAAe,CAAC,CAAC;AAC9D,QAAM,cAAc,CAAC,SAAc,gBAAgB,KAAK,MAAM,IAAI,CAAC;AACnE,SAAO,EAAC,WAAW,YAAA;AACvB;AAEO,SAAS,yCAAyC,IAAsB;AAC3E,QAAM,gBAAgB,GAAG,iBAAA;AACzB,QAAM,iBAAiB,cAAc,wBAAwB,YAAY;AACzE,QAAM,kBAAkB,cAAc,wBAAwB,cAAc;AAC5E,QAAM,YAAY,CAAC,MAAW,KAAK,UAAU,eAAe,CAAC,CAAC;AAC9D,QAAM,cAAc,CAAC,SAAc,gBAAgB,KAAK,MAAM,IAAI,CAAC;AACnE,SAAO,EAAC,WAAW,YAAA;AACvB;AAEO,SAAS,UAAU,WAA+B,aAAiC,OAAY;AAClG,QAAM,aAAa,UAAU,KAAK;AAClC,QAAM,eAAe,YAAY,UAAU;AAC3C,QAAM,SAAS,EAAC,YAAY,aAAA;AAC5B,SAAO;AACX;;;;;;;"}

package/.dist/cjs/src/jitCompilers/json/jsonSpec/jsonHelpers.d.ts

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

package/.dist/cjs/src/jitCompilers/json/jsonSpec/jsonHelpers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"jsonHelpers.d.ts","sourceRoot":"","sources":["../../../../../../src/jitCompilers/json/jsonSpec/jsonHelpers.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,wCAAwC,CAAC;AAC7E,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,qCAAqC,CAAC;AACzE,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,mBAAmB,CAAC;AAK/C,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,OAAO;mBAGxB,GAAG;wBACE,GAAG;EAEjC;AAED,wBAAgB,2BAA2B,CAAC,EAAE,EAAE,eAAe,EAAE,UAAU,CAAC,EAAE,MAAM;mBAI1D,GAAG;wBACE,GAAG;EAEjC;AAED,wBAAgB,2BAA2B,CAAC,EAAE,EAAE,eAAe;mBAGrC,GAAG;wBACE,GAAG;EAEjC;AAED,wBAAgB,wCAAwC,CAAC,EAAE,EAAE,gBAAgB;mBAInD,GAAG;wBACE,GAAG;EAEjC;AAED,wBAAgB,wCAAwC,CAAC,EAAE,EAAE,gBAAgB;mBAInD,GAAG;wBACE,GAAG;EAEjC;AAED,wBAAgB,SAAS,CAAC,SAAS,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,MAAM,EAAE,WAAW,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,GAAG,EAAE,KAAK,EAAE,GAAG;;;EAKnG"}