@mionjs/run-types 0.8.0-alpha.0

package/.dist/cjs/src/nodes/atomic/enum.d.ts

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

package/.dist/cjs/src/nodes/atomic/enumMember.cjs

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_lib_baseRunTypes = require("../../lib/baseRunTypes.cjs");
+const src_types = require("../../types.cjs");
+class EnumMemberRunType extends src_lib_baseRunTypes.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", () => src_lib_baseRunTypes.AtomicRunType, "skipJit", () => src_types.__ΩJitCode, "emitIsType", () => src_types.__ΩJitCode, "emitTypeErrors", () => src_types.__ΩJitCode, "emitPrepareForJson", () => src_types.__ΩJitCode, "emitRestoreFromJson", "EnumMemberRunType", `P"w!7"P"0#Pn$0%Pn&0'Pn(0)Pn*0+5"w!6"w,`];
+}
+exports.EnumMemberRunType = EnumMemberRunType;
+//# sourceMappingURL=enumMember.cjs.map

package/.dist/cjs/src/nodes/atomic/enumMember.cjs.map

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

package/.dist/cjs/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/cjs/src/nodes/atomic/literal.cjs

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const type = require("@deepkit/type");
+const src_lib_utils = require("../../lib/utils.cjs");
+const src_lib_baseRunTypes = require("../../lib/baseRunTypes.cjs");
+const src_nodes_atomic_bigInt = require("./bigInt.cjs");
+const src_nodes_atomic_regexp = require("./regexp.cjs");
+const src_nodes_atomic_symbol = require("./symbol.cjs");
+const src_constants_kind = require("../../constants.kind.cjs");
+const src_nodes_atomic_string = require("./string.cjs");
+const src_nodes_atomic_number = require("./number.cjs");
+const src_nodes_atomic_boolean = require("./boolean.cjs");
+const stringRt = new src_nodes_atomic_string.StringRunType();
+const numberRt = new src_nodes_atomic_number.NumberRunType();
+const booleanRt = new src_nodes_atomic_boolean.BooleanRunType();
+const symbolRt = new src_nodes_atomic_symbol.SymbolRunType();
+const regexpRt = new src_nodes_atomic_regexp.RegexpRunType();
+const bigIntRt = new src_nodes_atomic_bigInt.BigIntRunType();
+const __ΩAnyLiteralRunType = [() => src_nodes_atomic_string.StringRunType, () => src_nodes_atomic_number.NumberRunType, () => src_nodes_atomic_boolean.BooleanRunType, () => src_nodes_atomic_symbol.SymbolRunType, () => src_nodes_atomic_regexp.RegexpRunType, () => src_nodes_atomic_bigInt.BigIntRunType, "AnyLiteralRunType", `PP7!P7"P7#P7$P7%P7&Jw'y`];
+class LiteralRunType extends src_lib_baseRunTypes.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 = type.ReflectionKind.regexp;
+      return rt;
+    }
+    switch (typeof lit) {
+      case "string":
+        rt = stringRt;
+        if (noLiterals)
+          this.src.kind = type.ReflectionKind.string;
+        break;
+      case "number":
+        rt = numberRt;
+        if (noLiterals)
+          this.src.kind = type.ReflectionKind.number;
+        break;
+      case "boolean":
+        rt = booleanRt;
+        if (noLiterals)
+          this.src.kind = type.ReflectionKind.boolean;
+        break;
+      case "bigint":
+        rt = bigIntRt;
+        if (noLiterals)
+          this.src.kind = type.ReflectionKind.bigint;
+        break;
+      case "symbol":
+        rt = symbolRt;
+        if (noLiterals)
+          this.src.kind = type.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", () => src_lib_baseRunTypes.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} === ${src_lib_utils.toLiteral(lit)}`;
+    case "number":
+      return `${comp.vλl} === ${src_lib_utils.toLiteral(lit)}`;
+    case "boolean":
+      return `${comp.vλl} === ${src_lib_utils.toLiteral(lit)}`;
+    case "bigint":
+      return `${comp.vλl} === ${src_lib_utils.toLiteral(lit)}`;
+    case "symbol":
+      return `typeof ${comp.vλl} === 'symbol' && ${comp.vλl}.description === ${src_lib_utils.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} !== ${src_lib_utils.toLiteral(lit)}) ${comp.callJitErr(name)}`;
+    case "number":
+      return `if (${comp.vλl} !== ${src_lib_utils.toLiteral(lit)}) ${comp.callJitErr(name)}`;
+    case "boolean":
+      return `if (${comp.vλl} !== ${src_lib_utils.toLiteral(lit)}) ${comp.callJitErr(name)}`;
+    case "bigint":
+      return `if (${comp.vλl} !== ${src_lib_utils.toLiteral(lit)}) ${comp.callJitErr(name)}`;
+    case "symbol":
+      return `if (typeof ${comp.vλl} !== 'symbol' || ${comp.vλl}.description !== ${src_lib_utils.toLiteral(lit.description)}) {${comp.callJitErr(name)}}`;
+    default:
+      throw new Error(`Unsupported literal type ${literalType}`);
+  }
+}
+compileTypeErrorsLiteral.__type = ["JitErrorsFnCompiler", "comp", "TypeLiteral", "literal", "lit", () => src_constants_kind.__ΩAnyKindName, "name", "compileTypeErrorsLiteral", `P"w!2""w#.$f2%n&2'&/(`];
+exports.LiteralRunType = LiteralRunType;
+//# sourceMappingURL=literal.cjs.map

package/.dist/cjs/src/nodes/atomic/literal.cjs.map

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

package/.dist/cjs/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/cjs/src/nodes/atomic/never.cjs

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_lib_baseRunTypes = require("../../lib/baseRunTypes.cjs");
+const src_lib_jitFnCompiler = require("../../lib/jitFnCompiler.cjs");
+const src_types = require("../../types.cjs");
+class NeverRunType extends src_lib_baseRunTypes.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", () => src_lib_baseRunTypes.AtomicRunType, () => src_types.__ΩJitCode, "emitIsType", () => src_lib_jitFnCompiler.JitErrorsFnCompiler, "comp", () => src_types.__ΩJitCode, "emitTypeErrors", () => src_types.__ΩJitCode, "emitPrepareForJson", () => src_types.__ΩJitCode, "emitRestoreFromJson", "NeverRunType", `P"w!7"Pn#0$PP7%2&n'0(Pn)0*Pn+0,5"w!6"w-`];
+}
+exports.NeverRunType = NeverRunType;
+//# sourceMappingURL=never.cjs.map

package/.dist/cjs/src/nodes/atomic/never.cjs.map

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

package/.dist/cjs/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/cjs/src/nodes/atomic/null.cjs

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_lib_baseRunTypes = require("../../lib/baseRunTypes.cjs");
+class NullRunType extends src_lib_baseRunTypes.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", () => src_lib_baseRunTypes.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+`];
+}
+exports.NullRunType = NullRunType;
+//# sourceMappingURL=null.cjs.map

package/.dist/cjs/src/nodes/atomic/null.cjs.map

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

package/.dist/cjs/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/cjs/src/nodes/atomic/number.cjs

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_lib_baseRunTypes = require("../../lib/baseRunTypes.cjs");
+class NumberRunType extends src_lib_baseRunTypes.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", () => src_lib_baseRunTypes.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+`];
+}
+exports.NumberRunType = NumberRunType;
+//# sourceMappingURL=number.cjs.map

package/.dist/cjs/src/nodes/atomic/number.cjs.map

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

package/.dist/cjs/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/cjs/src/nodes/atomic/object.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_lib_baseRunTypes = require("../../lib/baseRunTypes.cjs");
+class ObjectRunType extends src_lib_baseRunTypes.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", () => src_lib_baseRunTypes.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*`];
+}
+exports.ObjectRunType = ObjectRunType;
+//# sourceMappingURL=object.cjs.map

package/.dist/cjs/src/nodes/atomic/object.cjs.map

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

package/.dist/cjs/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/cjs/src/nodes/atomic/regexp.cjs

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_lib_baseRunTypes = require("../../lib/baseRunTypes.cjs");
+class RegexpRunType extends src_lib_baseRunTypes.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", () => src_lib_baseRunTypes.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+`];
+}
+exports.RegexpRunType = RegexpRunType;
+//# sourceMappingURL=regexp.cjs.map

package/.dist/cjs/src/nodes/atomic/regexp.cjs.map

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

package/.dist/cjs/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/cjs/src/nodes/atomic/string.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_lib_baseRunTypes = require("../../lib/baseRunTypes.cjs");
+class StringRunType extends src_lib_baseRunTypes.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", () => src_lib_baseRunTypes.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)`];
+}
+exports.StringRunType = StringRunType;
+//# sourceMappingURL=string.cjs.map

package/.dist/cjs/src/nodes/atomic/string.cjs.map

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

package/.dist/cjs/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/cjs/src/nodes/atomic/symbol.cjs

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_lib_baseRunTypes = require("../../lib/baseRunTypes.cjs");
+const src_constants_functions = require("../../constants.functions.cjs");
+class SymbolRunType extends src_lib_baseRunTypes.AtomicRunType {
+  skipJit(comp) {
+    if (!comp)
+      return true;
+    return comp.fnID !== src_constants_functions.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", () => src_lib_baseRunTypes.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,`];
+}
+exports.SymbolRunType = SymbolRunType;
+//# sourceMappingURL=symbol.cjs.map

package/.dist/cjs/src/nodes/atomic/symbol.cjs.map

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

package/.dist/cjs/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/cjs/src/nodes/atomic/undefined.cjs

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_lib_baseRunTypes = require("../../lib/baseRunTypes.cjs");
+class UndefinedRunType extends src_lib_baseRunTypes.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", () => src_lib_baseRunTypes.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*`];
+}
+exports.UndefinedRunType = UndefinedRunType;
+//# sourceMappingURL=undefined.cjs.map

package/.dist/cjs/src/nodes/atomic/undefined.cjs.map

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

package/.dist/cjs/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/cjs/src/nodes/atomic/unknown.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_nodes_atomic_any = require("./any.cjs");
+class UnknownRunType extends src_nodes_atomic_any.AnyRunType {
+  static __type = [() => src_nodes_atomic_any.AnyRunType, "UnknownRunType", 'P7!5w"'];
+}
+exports.UnknownRunType = UnknownRunType;
+//# sourceMappingURL=unknown.cjs.map

package/.dist/cjs/src/nodes/atomic/unknown.cjs.map

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

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

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

package/.dist/cjs/src/nodes/atomic/void.cjs

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_lib_baseRunTypes = require("../../lib/baseRunTypes.cjs");
+class VoidRunType extends src_lib_baseRunTypes.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", () => src_lib_baseRunTypes.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+`];
+}
+exports.VoidRunType = VoidRunType;
+//# sourceMappingURL=void.cjs.map

package/.dist/cjs/src/nodes/atomic/void.cjs.map

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

package/.dist/cjs/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/cjs/src/nodes/collection/class.cjs

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const type = require("@deepkit/type");
+const src_nodes_collection_interface = require("./interface.cjs");
+const src_lib_jitFnCompiler = require("../../lib/jitFnCompiler.cjs");
+const core = require("@mionjs/core");
+const src_lib_utils = require("../../lib/utils.cjs");
+const src_lib_guards = require("../../lib/guards.cjs");
+const src_types = require("../../types.cjs");
+function __assignType(fn, args) {
+  fn.__type = args;
+  return fn;
+}
+class ClassRunType extends src_nodes_collection_interface.InterfaceRunType {
+  getClassName() {
+    return this.src.classType.name;
+  }
+  isClassWithEmptyConstructor() {
+    const children = this.getChildRunTypes();
+    const isEmpty = children.every(__assignType((prop) => !src_lib_guards.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 = src_lib_utils.toLiteral(this.getClassName());
+    const code = `
+            ${objJit.code};
+            let ${desFnVarName} = utl.${core.getJitUtils().getDeserializeFn.name}(${classLiteral});
+            if (${desFnVarName}) {${comp.vλl} = ${desFnVarName}(${comp.vλl})}
+            else if (${desFnVarName} = utl.${core.getJitUtils().getSerializeClass.name}(${classLiteral})) {${comp.vλl} = new ${desFnVarName}(${comp.vλl})}
+        `;
+    return { code, type: "S" };
+  }
+  static __type = [() => type.__ΩTypeClass, () => src_nodes_collection_interface.InterfaceRunType, "getClassName", "isClassWithEmptyConstructor", () => src_lib_jitFnCompiler.JitFnCompiler, "comp", () => src_types.__ΩJitCode, "emitRestoreFromJson", () => type.__ΩTypeClass, "ClassRunType", `Pn!7"P&0#P)0$PP7%2&n'0(5n)6"w*`];
+}
+exports.ClassRunType = ClassRunType;
+//# sourceMappingURL=class.cjs.map

package/.dist/cjs/src/nodes/collection/class.cjs.map

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

package/.dist/cjs/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;
+}