@mionjs/run-types 0.8.0-alpha.0

package/.dist/esm/src/nodes/atomic/enumMember.d.ts

@@ -0,0 +1,10 @@
+import { TypeEnum } from '@deepkit/type';
+import { AtomicRunType } from '../../lib/baseRunTypes.ts';
+import { JitCode } from '../../types.ts';
+export declare class EnumMemberRunType extends AtomicRunType<TypeEnum> {
+    skipJit(): boolean;
+    emitIsType(): JitCode;
+    emitTypeErrors(): JitCode;
+    emitPrepareForJson(): JitCode;
+    emitRestoreFromJson(): JitCode;
+}

package/.dist/esm/src/nodes/atomic/enumMember.js

@@ -0,0 +1,24 @@
+import { AtomicRunType } from "../../lib/baseRunTypes.js";
+import { __ΩJitCode as ___JitCode } from "../../types.js";
+class EnumMemberRunType extends AtomicRunType {
+  skipJit() {
+    return true;
+  }
+  emitIsType() {
+    throw new Error("Enum member operations are not supported");
+  }
+  emitTypeErrors() {
+    throw new Error("Enum member operations are not supported");
+  }
+  emitPrepareForJson() {
+    throw new Error("Enum member operations are not supported");
+  }
+  emitRestoreFromJson() {
+    throw new Error("Enum member operations are not supported");
+  }
+  static __type = ["TypeEnum", () => AtomicRunType, "skipJit", () => ___JitCode, "emitIsType", () => ___JitCode, "emitTypeErrors", () => ___JitCode, "emitPrepareForJson", () => ___JitCode, "emitRestoreFromJson", "EnumMemberRunType", `P"w!7"P"0#Pn$0%Pn&0'Pn(0)Pn*0+5"w!6"w,`];
+}
+export {
+  EnumMemberRunType
+};
+//# sourceMappingURL=enumMember.js.map

package/.dist/esm/src/nodes/atomic/enumMember.js.map

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

package/.dist/esm/src/nodes/atomic/literal.d.ts

@@ -0,0 +1,20 @@
+import { TypeLiteral } from '@deepkit/type';
+import { JitCode } from '../../types.ts';
+import { JitFnCompiler, JitErrorsFnCompiler } from '../../lib/jitFnCompiler.ts';
+import { AtomicRunType } from '../../lib/baseRunTypes.ts';
+import { BigIntRunType } from './bigInt.ts';
+import { RegexpRunType } from './regexp.ts';
+import { SymbolRunType } from './symbol.ts';
+import { StringRunType } from './string.ts';
+import { NumberRunType } from './number.ts';
+import { BooleanRunType } from './boolean.ts';
+type AnyLiteralRunType = StringRunType | NumberRunType | BooleanRunType | SymbolRunType | RegexpRunType | BigIntRunType;
+export declare class LiteralRunType extends AtomicRunType<TypeLiteral> {
+    getRunTypeForLiteral(comp: JitFnCompiler): AnyLiteralRunType;
+    emitIsType(comp: JitFnCompiler): JitCode;
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode;
+    emitPrepareForJson(comp: JitFnCompiler): JitCode;
+    emitRestoreFromJson(comp: JitFnCompiler): JitCode;
+    getLiteralValue(): string | number | bigint | boolean | symbol | RegExp;
+}
+export {};

package/.dist/esm/src/nodes/atomic/literal.js

@@ -0,0 +1,126 @@
+import { ReflectionKind } from "@deepkit/type";
+import { toLiteral } from "../../lib/utils.js";
+import { AtomicRunType } from "../../lib/baseRunTypes.js";
+import { BigIntRunType } from "./bigInt.js";
+import { RegexpRunType } from "./regexp.js";
+import { SymbolRunType } from "./symbol.js";
+import { __ΩAnyKindName as ___AnyKindName } from "../../constants.kind.js";
+import { StringRunType } from "./string.js";
+import { NumberRunType } from "./number.js";
+import { BooleanRunType } from "./boolean.js";
+const stringRt = new StringRunType();
+const numberRt = new NumberRunType();
+const booleanRt = new BooleanRunType();
+const symbolRt = new SymbolRunType();
+const regexpRt = new RegexpRunType();
+const bigIntRt = new BigIntRunType();
+const __ΩAnyLiteralRunType = [() => StringRunType, () => NumberRunType, () => BooleanRunType, () => SymbolRunType, () => RegexpRunType, () => BigIntRunType, "AnyLiteralRunType", `PP7!P7"P7#P7$P7%P7&Jw'y`];
+class LiteralRunType extends AtomicRunType {
+  getRunTypeForLiteral(comp) {
+    const noLiterals = comp.opts.noLiterals;
+    const lit = this.src.literal;
+    let rt;
+    if (lit instanceof RegExp) {
+      rt = regexpRt;
+      rt.src = this.src;
+      if (noLiterals)
+        this.src.kind = ReflectionKind.regexp;
+      return rt;
+    }
+    switch (typeof lit) {
+      case "string":
+        rt = stringRt;
+        if (noLiterals)
+          this.src.kind = ReflectionKind.string;
+        break;
+      case "number":
+        rt = numberRt;
+        if (noLiterals)
+          this.src.kind = ReflectionKind.number;
+        break;
+      case "boolean":
+        rt = booleanRt;
+        if (noLiterals)
+          this.src.kind = ReflectionKind.boolean;
+        break;
+      case "bigint":
+        rt = bigIntRt;
+        if (noLiterals)
+          this.src.kind = ReflectionKind.bigint;
+        break;
+      case "symbol":
+        rt = symbolRt;
+        if (noLiterals)
+          this.src.kind = ReflectionKind.symbol;
+        break;
+      default:
+        throw new Error(`Unsupported literal type ${typeof lit}`);
+    }
+    rt.src = this.src;
+    return rt;
+  }
+  emitIsType(comp) {
+    if (comp.opts.noLiterals)
+      return this.getRunTypeForLiteral(comp).emitIsType(comp);
+    return { code: compileIsLiteral(comp, this.src.literal), type: "E" };
+  }
+  emitTypeErrors(comp) {
+    if (comp.opts.noLiterals)
+      return this.getRunTypeForLiteral(comp).emitTypeErrors(comp);
+    return { code: compileTypeErrorsLiteral(comp, this.src.literal, this.getKindName()), type: "S" };
+  }
+  emitPrepareForJson(comp) {
+    return this.getRunTypeForLiteral(comp).emitPrepareForJson(comp);
+  }
+  emitRestoreFromJson(comp) {
+    return this.getRunTypeForLiteral(comp).emitRestoreFromJson(comp);
+  }
+  getLiteralValue() {
+    return this.src.literal;
+  }
+  static __type = ["TypeLiteral", () => AtomicRunType, "JitFnCompiler", "comp", () => __ΩAnyLiteralRunType, "getRunTypeForLiteral", "JitCode", "emitIsType", "JitErrorsFnCompiler", "emitTypeErrors", "emitPrepareForJson", "emitRestoreFromJson", "getLiteralValue", "LiteralRunType", `P"w!7"P"w#2$n%0&P"w#2$"w'0(P"w)2$"w'0*P"w#2$"w'0+P"w#2$"w'0,P"0-5"w!6"w.`];
+}
+function compileIsLiteral(comp, lit) {
+  const literalType = typeof lit;
+  if (lit instanceof RegExp)
+    return `${comp.vλl} instanceof RegExp && String(${comp.vλl}) === String(${lit})`;
+  switch (literalType) {
+    case "string":
+      return `${comp.vλl} === ${toLiteral(lit)}`;
+    case "number":
+      return `${comp.vλl} === ${toLiteral(lit)}`;
+    case "boolean":
+      return `${comp.vλl} === ${toLiteral(lit)}`;
+    case "bigint":
+      return `${comp.vλl} === ${toLiteral(lit)}`;
+    case "symbol":
+      return `typeof ${comp.vλl} === 'symbol' && ${comp.vλl}.description === ${toLiteral(lit.description)}`;
+    default:
+      throw new Error(`Unsupported literal type ${literalType}`);
+  }
+}
+compileIsLiteral.__type = ["JitFnCompiler", "comp", "TypeLiteral", "literal", "lit", "compileIsLiteral", 'P"w!2""w#.$f2%&/&'];
+function compileTypeErrorsLiteral(comp, lit, name) {
+  const literalType = typeof lit;
+  if (lit instanceof RegExp)
+    return `if (!(${comp.vλl} instanceof RegExp) || String(${comp.vλl}) !== String(${lit})) ${comp.callJitErr(name)}`;
+  switch (literalType) {
+    case "string":
+      return `if (${comp.vλl} !== ${toLiteral(lit)}) ${comp.callJitErr(name)}`;
+    case "number":
+      return `if (${comp.vλl} !== ${toLiteral(lit)}) ${comp.callJitErr(name)}`;
+    case "boolean":
+      return `if (${comp.vλl} !== ${toLiteral(lit)}) ${comp.callJitErr(name)}`;
+    case "bigint":
+      return `if (${comp.vλl} !== ${toLiteral(lit)}) ${comp.callJitErr(name)}`;
+    case "symbol":
+      return `if (typeof ${comp.vλl} !== 'symbol' || ${comp.vλl}.description !== ${toLiteral(lit.description)}) {${comp.callJitErr(name)}}`;
+    default:
+      throw new Error(`Unsupported literal type ${literalType}`);
+  }
+}
+compileTypeErrorsLiteral.__type = ["JitErrorsFnCompiler", "comp", "TypeLiteral", "literal", "lit", () => ___AnyKindName, "name", "compileTypeErrorsLiteral", `P"w!2""w#.$f2%n&2'&/(`];
+export {
+  LiteralRunType
+};
+//# sourceMappingURL=literal.js.map

package/.dist/esm/src/nodes/atomic/literal.js.map

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

package/.dist/esm/src/nodes/atomic/never.d.ts

@@ -0,0 +1,10 @@
+import { TypeNever } from '@deepkit/type';
+import { AtomicRunType } from '../../lib/baseRunTypes.ts';
+import { JitErrorsFnCompiler } from '../../lib/jitFnCompiler.ts';
+import { JitCode } from '../../types.ts';
+export declare class NeverRunType extends AtomicRunType<TypeNever> {
+    emitIsType(): JitCode;
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode;
+    emitPrepareForJson(): JitCode;
+    emitRestoreFromJson(): JitCode;
+}

package/.dist/esm/src/nodes/atomic/never.js

@@ -0,0 +1,22 @@
+import { AtomicRunType } from "../../lib/baseRunTypes.js";
+import { JitErrorsFnCompiler } from "../../lib/jitFnCompiler.js";
+import { __ΩJitCode as ___JitCode } from "../../types.js";
+class NeverRunType extends AtomicRunType {
+  emitIsType() {
+    return { code: "false", type: "E" };
+  }
+  emitTypeErrors(comp) {
+    return { code: `${comp.callJitErr(this)}`, type: "S" };
+  }
+  emitPrepareForJson() {
+    throw new Error("Never type cannot be encoded to JSON.");
+  }
+  emitRestoreFromJson() {
+    throw new Error("Never type cannot be decoded from JSON.");
+  }
+  static __type = ["TypeNever", () => AtomicRunType, () => ___JitCode, "emitIsType", () => JitErrorsFnCompiler, "comp", () => ___JitCode, "emitTypeErrors", () => ___JitCode, "emitPrepareForJson", () => ___JitCode, "emitRestoreFromJson", "NeverRunType", `P"w!7"Pn#0$PP7%2&n'0(Pn)0*Pn+0,5"w!6"w-`];
+}
+export {
+  NeverRunType
+};
+//# sourceMappingURL=never.js.map

package/.dist/esm/src/nodes/atomic/never.js.map

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

package/.dist/esm/src/nodes/atomic/null.d.ts

@@ -0,0 +1,10 @@
+import { TypeNull } from '@deepkit/type';
+import { JitFnCompiler, JitErrorsFnCompiler } from '../../lib/jitFnCompiler.ts';
+import { JitCode } from '../../types.ts';
+import { AtomicRunType } from '../../lib/baseRunTypes.ts';
+export declare class NullRunType extends AtomicRunType<TypeNull> {
+    emitIsType(comp: JitFnCompiler): JitCode;
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode;
+    emitPrepareForJson(): JitCode;
+    emitRestoreFromJson(): JitCode;
+}

package/.dist/esm/src/nodes/atomic/null.js

@@ -0,0 +1,20 @@
+import { AtomicRunType } from "../../lib/baseRunTypes.js";
+class NullRunType extends AtomicRunType {
+  emitIsType(comp) {
+    return { code: `${comp.vλl} === null`, type: "E" };
+  }
+  emitTypeErrors(comp) {
+    return { code: `if (${comp.vλl} !== null) ${comp.callJitErr(this)}`, type: "S" };
+  }
+  emitPrepareForJson() {
+    return { code: void 0, type: "S" };
+  }
+  emitRestoreFromJson() {
+    return { code: void 0, type: "S" };
+  }
+  static __type = ["TypeNull", () => AtomicRunType, "JitFnCompiler", "comp", "JitCode", "emitIsType", "JitErrorsFnCompiler", "emitTypeErrors", "emitPrepareForJson", "emitRestoreFromJson", "NullRunType", `P"w!7"P"w#2$"w%0&P"w'2$"w%0(P"w%0)P"w%0*5"w!6"w+`];
+}
+export {
+  NullRunType
+};
+//# sourceMappingURL=null.js.map

package/.dist/esm/src/nodes/atomic/null.js.map

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

package/.dist/esm/src/nodes/atomic/number.d.ts

@@ -0,0 +1,10 @@
+import { TypeNumber } from '@deepkit/type';
+import { JitCode } from '../../types.ts';
+import { JitFnCompiler, JitErrorsFnCompiler } from '../../lib/jitFnCompiler.ts';
+import { AtomicRunType } from '../../lib/baseRunTypes.ts';
+export declare class NumberRunType extends AtomicRunType<TypeNumber> {
+    emitIsType(comp: JitFnCompiler): JitCode;
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode;
+    emitPrepareForJson(): JitCode;
+    emitRestoreFromJson(): JitCode;
+}

package/.dist/esm/src/nodes/atomic/number.js

@@ -0,0 +1,20 @@
+import { AtomicRunType } from "../../lib/baseRunTypes.js";
+class NumberRunType extends AtomicRunType {
+  emitIsType(comp) {
+    return { code: `Number.isFinite(${comp.vλl})`, type: "E" };
+  }
+  emitTypeErrors(comp) {
+    return { code: `if(!(Number.isFinite(${comp.vλl}))) ${comp.callJitErr(this)}`, type: "S" };
+  }
+  emitPrepareForJson() {
+    return { code: void 0, type: "S" };
+  }
+  emitRestoreFromJson() {
+    return { code: void 0, type: "S" };
+  }
+  static __type = ["TypeNumber", () => AtomicRunType, "JitFnCompiler", "comp", "JitCode", "emitIsType", "JitErrorsFnCompiler", "emitTypeErrors", "emitPrepareForJson", "emitRestoreFromJson", "NumberRunType", `P"w!7"P"w#2$"w%0&P"w'2$"w%0(P"w%0)P"w%0*5"w!6"w+`];
+}
+export {
+  NumberRunType
+};
+//# sourceMappingURL=number.js.map

package/.dist/esm/src/nodes/atomic/number.js.map

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

package/.dist/esm/src/nodes/atomic/object.d.ts

@@ -0,0 +1,8 @@
+import { TypeAny, TypeUnknown } from '@deepkit/type';
+import { JitCode } from '../../types.ts';
+import { AtomicRunType } from '../../lib/baseRunTypes.ts';
+import { JitFnCompiler, JitErrorsFnCompiler } from '../../lib/jitFnCompiler.ts';
+export declare class ObjectRunType extends AtomicRunType<TypeAny | TypeUnknown> {
+    emitIsType(comp: JitFnCompiler): JitCode;
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode;
+}

package/.dist/esm/src/nodes/atomic/object.js

@@ -0,0 +1,14 @@
+import { AtomicRunType } from "../../lib/baseRunTypes.js";
+class ObjectRunType extends AtomicRunType {
+  emitIsType(comp) {
+    return { code: `(typeof ${comp.vλl} === 'object' && ${comp.vλl} !== null)`, type: "E" };
+  }
+  emitTypeErrors(comp) {
+    return { code: `if (!(typeof ${comp.vλl} === 'object' && ${comp.vλl} !== null)) ${comp.callJitErr(this)}`, type: "S" };
+  }
+  static __type = ["TypeAny", "TypeUnknown", () => AtomicRunType, "JitFnCompiler", "comp", "JitCode", "emitIsType", "JitErrorsFnCompiler", "emitTypeErrors", "ObjectRunType", `PP"w!"w"J7#P"w$2%"w&0'P"w(2%"w&0)5P"w!"w"J6"w*`];
+}
+export {
+  ObjectRunType
+};
+//# sourceMappingURL=object.js.map

package/.dist/esm/src/nodes/atomic/object.js.map

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

package/.dist/esm/src/nodes/atomic/regexp.d.ts

@@ -0,0 +1,10 @@
+import { TypeRegexp } from '@deepkit/type';
+import { JitCode } from '../../types.ts';
+import { JitFnCompiler, JitErrorsFnCompiler } from '../../lib/jitFnCompiler.ts';
+import { AtomicRunType } from '../../lib/baseRunTypes.ts';
+export declare class RegexpRunType extends AtomicRunType<TypeRegexp> {
+    emitIsType(comp: JitFnCompiler): JitCode;
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode;
+    emitPrepareForJson(comp: JitFnCompiler): JitCode;
+    emitRestoreFromJson(comp: JitFnCompiler): JitCode;
+}

package/.dist/esm/src/nodes/atomic/regexp.js

@@ -0,0 +1,23 @@
+import { AtomicRunType } from "../../lib/baseRunTypes.js";
+class RegexpRunType extends AtomicRunType {
+  emitIsType(comp) {
+    return { code: `(${comp.vλl} instanceof RegExp)`, type: "E" };
+  }
+  emitTypeErrors(comp) {
+    return { code: `if (!(${comp.vλl} instanceof RegExp)) ${comp.callJitErr(this)}`, type: "S" };
+  }
+  emitPrepareForJson(comp) {
+    return { code: `${comp.vλl}.toString()`, type: "E" };
+  }
+  emitRestoreFromJson(comp) {
+    return {
+      code: `(function(){const parts = ${comp.vλl}.match(/\\/(.*)\\/(.*)?/) ;return new RegExp(parts[1], parts[2] || '')})()`,
+      type: "E"
+    };
+  }
+  static __type = ["TypeRegexp", () => AtomicRunType, "JitFnCompiler", "comp", "JitCode", "emitIsType", "JitErrorsFnCompiler", "emitTypeErrors", "emitPrepareForJson", "emitRestoreFromJson", "RegexpRunType", `P"w!7"P"w#2$"w%0&P"w'2$"w%0(P"w#2$"w%0)P"w#2$"w%0*5"w!6"w+`];
+}
+export {
+  RegexpRunType
+};
+//# sourceMappingURL=regexp.js.map

package/.dist/esm/src/nodes/atomic/regexp.js.map

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

package/.dist/esm/src/nodes/atomic/string.d.ts

@@ -0,0 +1,8 @@
+import { TypeString } from '@deepkit/type';
+import { JitCode } from '../../types.ts';
+import { AtomicRunType } from '../../lib/baseRunTypes.ts';
+import { JitFnCompiler, JitErrorsFnCompiler } from '../../lib/jitFnCompiler.ts';
+export declare class StringRunType extends AtomicRunType<TypeString> {
+    emitIsType(comp: JitFnCompiler): JitCode;
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode;
+}

package/.dist/esm/src/nodes/atomic/string.js

@@ -0,0 +1,14 @@
+import { AtomicRunType } from "../../lib/baseRunTypes.js";
+class StringRunType extends AtomicRunType {
+  emitIsType(comp) {
+    return { code: `typeof ${comp.vλl} === 'string'`, type: "E" };
+  }
+  emitTypeErrors(comp) {
+    return { code: `if (typeof ${comp.vλl} !== 'string') ${comp.callJitErr(this)}`, type: "S" };
+  }
+  static __type = ["TypeString", () => AtomicRunType, "JitFnCompiler", "comp", "JitCode", "emitIsType", "JitErrorsFnCompiler", "emitTypeErrors", "StringRunType", `P"w!7"P"w#2$"w%0&P"w'2$"w%0(5"w!6"w)`];
+}
+export {
+  StringRunType
+};
+//# sourceMappingURL=string.js.map

package/.dist/esm/src/nodes/atomic/string.js.map

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

package/.dist/esm/src/nodes/atomic/symbol.d.ts

@@ -0,0 +1,11 @@
+import { TypeSymbol } from '@deepkit/type';
+import { JitCode } from '../../types.ts';
+import { JitFnCompiler, JitErrorsFnCompiler } from '../../lib/jitFnCompiler.ts';
+import { AtomicRunType } from '../../lib/baseRunTypes.ts';
+export declare class SymbolRunType extends AtomicRunType<TypeSymbol> {
+    skipJit(comp: JitFnCompiler): boolean;
+    emitIsType(comp: JitFnCompiler): JitCode;
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode;
+    emitPrepareForJson(comp: JitFnCompiler): JitCode;
+    emitRestoreFromJson(comp: JitFnCompiler): JitCode;
+}

package/.dist/esm/src/nodes/atomic/symbol.js

@@ -0,0 +1,26 @@
+import { AtomicRunType } from "../../lib/baseRunTypes.js";
+import { JitFunctions } from "../../constants.functions.js";
+class SymbolRunType extends AtomicRunType {
+  skipJit(comp) {
+    if (!comp)
+      return true;
+    return comp.fnID !== JitFunctions.toJSCode.id;
+  }
+  emitIsType(comp) {
+    return { code: `typeof ${comp.vλl} === 'symbol'`, type: "E" };
+  }
+  emitTypeErrors(comp) {
+    return { code: `if (typeof ${comp.vλl} !== 'symbol') ${comp.callJitErr(this)}`, type: "S" };
+  }
+  emitPrepareForJson(comp) {
+    return { code: `'Symbol:' + (${comp.vλl}.description || '')`, type: "E" };
+  }
+  emitRestoreFromJson(comp) {
+    return { code: `Symbol(${comp.vλl}.substring(7))`, type: "E" };
+  }
+  static __type = ["TypeSymbol", () => AtomicRunType, "JitFnCompiler", "comp", "skipJit", "JitCode", "emitIsType", "JitErrorsFnCompiler", "emitTypeErrors", "emitPrepareForJson", "emitRestoreFromJson", "SymbolRunType", `P"w!7"P"w#2$)0%P"w#2$"w&0'P"w(2$"w&0)P"w#2$"w&0*P"w#2$"w&0+5"w!6"w,`];
+}
+export {
+  SymbolRunType
+};
+//# sourceMappingURL=symbol.js.map

package/.dist/esm/src/nodes/atomic/symbol.js.map

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

package/.dist/esm/src/nodes/atomic/undefined.d.ts

@@ -0,0 +1,9 @@
+import { TypeUndefined } from '@deepkit/type';
+import { JitFnCompiler, JitErrorsFnCompiler } from '../../lib/jitFnCompiler.ts';
+import { JitCode } from '../../types.ts';
+import { AtomicRunType } from '../../lib/baseRunTypes.ts';
+export declare class UndefinedRunType extends AtomicRunType<TypeUndefined> {
+    emitIsType(comp: JitFnCompiler): JitCode;
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode;
+    emitRestoreFromJson(): JitCode;
+}

package/.dist/esm/src/nodes/atomic/undefined.js

@@ -0,0 +1,17 @@
+import { AtomicRunType } from "../../lib/baseRunTypes.js";
+class UndefinedRunType extends AtomicRunType {
+  emitIsType(comp) {
+    return { code: `typeof ${comp.vλl} === 'undefined'`, type: "E" };
+  }
+  emitTypeErrors(comp) {
+    return { code: `if (typeof ${comp.vλl} !== 'undefined') ${comp.callJitErr(this)}`, type: "S" };
+  }
+  emitRestoreFromJson() {
+    return { code: `undefined`, type: "E" };
+  }
+  static __type = ["TypeUndefined", () => AtomicRunType, "JitFnCompiler", "comp", "JitCode", "emitIsType", "JitErrorsFnCompiler", "emitTypeErrors", "emitRestoreFromJson", "UndefinedRunType", `P"w!7"P"w#2$"w%0&P"w'2$"w%0(P"w%0)5"w!6"w*`];
+}
+export {
+  UndefinedRunType
+};
+//# sourceMappingURL=undefined.js.map

package/.dist/esm/src/nodes/atomic/undefined.js.map

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

package/.dist/esm/src/nodes/atomic/unknown.d.ts

@@ -0,0 +1,3 @@
+import { AnyRunType } from './any.ts';
+export declare class UnknownRunType extends AnyRunType {
+}

package/.dist/esm/src/nodes/atomic/unknown.js

@@ -0,0 +1,8 @@
+import { AnyRunType } from "./any.js";
+class UnknownRunType extends AnyRunType {
+  static __type = [() => AnyRunType, "UnknownRunType", 'P7!5w"'];
+}
+export {
+  UnknownRunType
+};
+//# sourceMappingURL=unknown.js.map

package/.dist/esm/src/nodes/atomic/unknown.js.map

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

package/.dist/esm/src/nodes/atomic/void.d.ts

@@ -0,0 +1,10 @@
+import { TypeVoid } from '@deepkit/type';
+import { JitCode } from '../../types.ts';
+import { AtomicRunType } from '../../lib/baseRunTypes.ts';
+import { JitFnCompiler, JitErrorsFnCompiler } from '../../lib/jitFnCompiler.ts';
+export declare class VoidRunType extends AtomicRunType<TypeVoid> {
+    emitIsType(comp: JitFnCompiler): JitCode;
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode;
+    emitPrepareForJson(comp: JitFnCompiler): JitCode;
+    emitRestoreFromJson(comp: JitFnCompiler): JitCode;
+}

package/.dist/esm/src/nodes/atomic/void.js

@@ -0,0 +1,20 @@
+import { AtomicRunType } from "../../lib/baseRunTypes.js";
+class VoidRunType extends AtomicRunType {
+  emitIsType(comp) {
+    return { code: `${comp.vλl} === undefined`, type: "E" };
+  }
+  emitTypeErrors(comp) {
+    return { code: `if (${comp.vλl} !== undefined) ${comp.callJitErr(this)}`, type: "S" };
+  }
+  emitPrepareForJson(comp) {
+    return { code: `${comp.vλl} = undefined`, type: "E" };
+  }
+  emitRestoreFromJson(comp) {
+    return { code: `${comp.vλl} = undefined`, type: "E" };
+  }
+  static __type = ["TypeVoid", () => AtomicRunType, "JitFnCompiler", "comp", "JitCode", "emitIsType", "JitErrorsFnCompiler", "emitTypeErrors", "emitPrepareForJson", "emitRestoreFromJson", "VoidRunType", `P"w!7"P"w#2$"w%0&P"w'2$"w%0(P"w#2$"w%0)P"w#2$"w%0*5"w!6"w+`];
+}
+export {
+  VoidRunType
+};
+//# sourceMappingURL=void.js.map

package/.dist/esm/src/nodes/atomic/void.js.map

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

package/.dist/esm/src/nodes/collection/class.d.ts

@@ -0,0 +1,9 @@
+import { TypeClass } from '@deepkit/type';
+import { InterfaceRunType } from './interface.ts';
+import { JitFnCompiler } from '../../lib/jitFnCompiler.ts';
+import { JitCode } from '../../types.ts';
+export declare class ClassRunType extends InterfaceRunType<TypeClass> {
+    getClassName(): string;
+    isClassWithEmptyConstructor(): boolean;
+    emitRestoreFromJson(comp: JitFnCompiler): JitCode;
+}

package/.dist/esm/src/nodes/collection/class.js

@@ -0,0 +1,38 @@
+import { __ΩTypeClass as ___TypeClass } from "@deepkit/type";
+import { InterfaceRunType } from "./interface.js";
+import { JitFnCompiler } from "../../lib/jitFnCompiler.js";
+import { getJitUtils } from "@mionjs/core";
+import { toLiteral } from "../../lib/utils.js";
+import { isConstructor } from "../../lib/guards.js";
+import { __ΩJitCode as ___JitCode } from "../../types.js";
+function __assignType(fn, args) {
+  fn.__type = args;
+  return fn;
+}
+class ClassRunType extends InterfaceRunType {
+  getClassName() {
+    return this.src.classType.name;
+  }
+  isClassWithEmptyConstructor() {
+    const children = this.getChildRunTypes();
+    const isEmpty = children.every(__assignType((prop) => !isConstructor(prop) || prop.getParameters().getChildRunTypes().length === 0, ["prop", "", 'P"2!"/"']));
+    return isEmpty;
+  }
+  emitRestoreFromJson(comp) {
+    const objJit = super.emitRestoreFromJson(comp);
+    const desFnVarName = comp.getLocalVarName("desFn", this);
+    const classLiteral = toLiteral(this.getClassName());
+    const code = `
+            ${objJit.code};
+            let ${desFnVarName} = utl.${getJitUtils().getDeserializeFn.name}(${classLiteral});
+            if (${desFnVarName}) {${comp.vλl} = ${desFnVarName}(${comp.vλl})}
+            else if (${desFnVarName} = utl.${getJitUtils().getSerializeClass.name}(${classLiteral})) {${comp.vλl} = new ${desFnVarName}(${comp.vλl})}
+        `;
+    return { code, type: "S" };
+  }
+  static __type = [() => ___TypeClass, () => InterfaceRunType, "getClassName", "isClassWithEmptyConstructor", () => JitFnCompiler, "comp", () => ___JitCode, "emitRestoreFromJson", () => ___TypeClass, "ClassRunType", `Pn!7"P&0#P)0$PP7%2&n'0(5n)6"w*`];
+}
+export {
+  ClassRunType
+};
+//# sourceMappingURL=class.js.map

package/.dist/esm/src/nodes/collection/class.js.map

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

package/.dist/esm/src/nodes/collection/functionParams.d.ts

@@ -0,0 +1,9 @@
+import { TypeFunction } from '@deepkit/type';
+import { JitFnCompiler, JitErrorsFnCompiler } from '../../lib/jitFnCompiler.ts';
+import { AnyParameterListRunType, JitCode } from '../../types.ts';
+import { TupleRunType } from './tuple.ts';
+import { ParameterRunType } from '../member/param.ts';
+export declare class FunctionParamsRunType<ParamList extends AnyParameterListRunType = TypeFunction> extends TupleRunType<ParamList, ParameterRunType> {
+    emitIsType(comp: JitFnCompiler): JitCode;
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode;
+}

package/.dist/esm/src/nodes/collection/functionParams.js

@@ -0,0 +1,33 @@
+import { TupleRunType } from "./tuple.js";
+import { ParameterRunType } from "../member/param.js";
+function __assignType(fn, args) {
+  fn.__type = args;
+  return fn;
+}
+class FunctionParamsRunType extends TupleRunType {
+  emitIsType(comp) {
+    const children = this.getParamRunTypes(comp);
+    if (children.length === 0)
+      return { code: `${comp.vλl}.length === 0`, type: "E" };
+    const lengthCode = this.hasRestParameter(comp) ? "" : `${comp.vλl}.length <= ${children.length}`;
+    const paramsCode = children.map(__assignType((p) => comp.compileIsType(p, "E").code, ["p", "", 'P"2!"/"'])).filter(Boolean);
+    if (paramsCode.length === 0)
+      return lengthCode ? { code: `(${lengthCode})`, type: "E" } : { code: void 0, type: "E" };
+    return lengthCode ? { code: `(${lengthCode} && ${paramsCode.join(" && ")})`, type: "E" } : { code: `(${paramsCode.join(" && ")})`, type: "E" };
+  }
+  emitTypeErrors(comp) {
+    const children = this.getParamRunTypes(comp);
+    if (children.length === 0)
+      return { code: `if (${comp.vλl}.length !== 0) ${comp.callJitErr(this)}`, type: "S" };
+    const lengthCode = this.hasRestParameter(comp) ? "" : `${comp.vλl}.length > ${children.length}`;
+    const paramsCode = children.map(__assignType((p) => comp.compileTypeErrors(p, "S").code, ["p", "", 'P"2!"/"'])).filter(Boolean);
+    if (paramsCode.length === 0)
+      return lengthCode ? { code: `if (${lengthCode}) ${comp.callJitErr(this)}`, type: "S" } : { code: void 0, type: "S" };
+    return lengthCode ? { code: `if (${lengthCode}) ${comp.callJitErr(this)}; else {${paramsCode.join(";")}}`, type: "S" } : { code: paramsCode.join(";"), type: "S" };
+  }
+  static __type = ["TypeFunction", "ParamList", () => ParameterRunType, () => TupleRunType, "JitFnCompiler", "comp", "JitCode", "emitIsType", "JitErrorsFnCompiler", "emitTypeErrors", () => ParameterRunType, "FunctionParamsRunType", `"w!c"Pe"!P7#7$P"w%2&"w'0(P"w)2&"w'0*5e!!P7+6#w,`];
+}
+export {
+  FunctionParamsRunType
+};
+//# sourceMappingURL=functionParams.js.map