@mionjs/run-types 0.8.0-alpha.0

package/.dist/cjs/src/nodes/member/callSignature.cjs.map

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

package/.dist/cjs/src/nodes/member/callSignature.d.ts

@@ -0,0 +1,11 @@
+import { TypeCallSignature } from '@deepkit/type';
+import { RunTypeChildAccessor } from '../../types.ts';
+import { FunctionRunType } from '../function/function.ts';
+import { JitFnCompiler } from '../../lib/jitFnCompiler.ts';
+export declare class CallSignatureRunType extends FunctionRunType<TypeCallSignature> implements RunTypeChildAccessor {
+    getChildIndex: (comp: JitFnCompiler) => number;
+    getChildVarName: () => string;
+    getChildLiteral: () => string;
+    useArrayAccessor: () => boolean;
+    isOptional: () => boolean;
+}

package/.dist/cjs/src/nodes/member/genericMember.cjs

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_lib_baseRunTypes = require("../../lib/baseRunTypes.cjs");
+const src_lib_utils = require("../../lib/utils.cjs");
+class GenericMemberRunType extends src_lib_baseRunTypes.MemberRunType {
+  index = 0;
+  getChildIndex() {
+    return this.index;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getChildVarName(comp) {
+    return this.index;
+  }
+  getChildLiteral(comp) {
+    return this.getChildVarName(comp);
+  }
+  useArrayAccessor() {
+    return true;
+  }
+  isOptional() {
+    return false;
+  }
+  emitIsType(comp) {
+    const child = this.getJitChild(comp);
+    const childJit = comp.compileIsType(child, "E");
+    if (!childJit?.code)
+      return { code: void 0, type: "E" };
+    if (this.isOptional())
+      return { code: `${comp.getChildVλl()} === undefined || (${childJit.code})`, type: "E" };
+    return childJit;
+  }
+  emitTypeErrors(comp) {
+    const child = this.getJitChild(comp);
+    const childJit = comp.compileTypeErrors(child, "S");
+    if (!childJit?.code)
+      return { code: void 0, type: "S" };
+    if (this.isOptional())
+      return { code: `if (${comp.getChildVλl()} !== undefined) {${childJit.code}}`, type: "S" };
+    return childJit;
+  }
+  emitPrepareForJson(comp) {
+    const child = this.getJitChild(comp);
+    const childJit = comp.compilePrepareForJson(child, "S");
+    if (!childJit?.code || !child)
+      return { code: void 0, type: "S" };
+    const isExpression = src_lib_utils.childIsExpression(childJit, child);
+    const code = isExpression ? `${comp.getChildVλl()} = ${childJit.code}` : childJit.code || "";
+    if (this.isOptional())
+      return { code: `if (${comp.getChildVλl()} !== undefined) {${code}}`, type: "S" };
+    return { code, type: "S" };
+  }
+  emitRestoreFromJson(comp) {
+    const child = this.getJitChild(comp);
+    const childJit = comp.compileRestoreFromJson(child, "S");
+    if (!childJit?.code || !child)
+      return { code: void 0, type: "S" };
+    const isExpression = src_lib_utils.childIsExpression(childJit, child);
+    const code = isExpression ? `${comp.getChildVλl()} = ${childJit.code};` : childJit.code || "";
+    if (this.isOptional())
+      return { code: `if (${comp.getChildVλl()} !== undefined) {${code}}`, type: "S" };
+    return { code, type: "S" };
+  }
+  static __type = ["T", () => src_lib_baseRunTypes.MemberRunType, "index", function() {
+    return 0;
+  }, "getChildIndex", "JitFnCompiler", "comp", "getChildVarName", "getChildLiteral", "useArrayAccessor", "isOptional", "JitCode", "emitIsType", "JitErrorsFnCompiler", "emitTypeErrors", "emitPrepareForJson", "emitRestoreFromJson", "GenericMemberRunType", `b!Pe"!7"'3#>$P"0%P"w&2'P&'J0(P"w&2'"0)P"0*P"0+P"w&2'"w,0-P"w.2'"w,0/P"w&2'"w,00P"w&2'"w,015e!!6"w2`];
+}
+exports.GenericMemberRunType = GenericMemberRunType;
+//# sourceMappingURL=genericMember.cjs.map

package/.dist/cjs/src/nodes/member/genericMember.cjs.map

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

package/.dist/cjs/src/nodes/member/genericMember.d.ts

@@ -0,0 +1,15 @@
+import { JitFnCompiler, JitErrorsFnCompiler } from '../../lib/jitFnCompiler.ts';
+import { MemberRunType } from '../../lib/baseRunTypes.ts';
+import { JitCode, SrcMember } from '../../types.ts';
+export declare class GenericMemberRunType<T extends SrcMember> extends MemberRunType<T> {
+    index: number;
+    getChildIndex(): number;
+    getChildVarName(comp: JitFnCompiler): string | number;
+    getChildLiteral(comp: JitFnCompiler): string | number;
+    useArrayAccessor(): boolean;
+    isOptional(): boolean;
+    emitIsType(comp: JitFnCompiler): JitCode;
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode;
+    emitPrepareForJson(comp: JitFnCompiler): JitCode;
+    emitRestoreFromJson(comp: JitFnCompiler): JitCode;
+}

package/.dist/cjs/src/nodes/member/indexProperty.cjs

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const type = require("@deepkit/type");
+const src_lib_baseRunTypes = require("../../lib/baseRunTypes.cjs");
+const src_constants_functions = require("../../constants.functions.cjs");
+const src_lib_utils = require("../../lib/utils.cjs");
+function __assignType(fn, args) {
+  fn.__type = args;
+  return fn;
+}
+class IndexSignatureRunType extends src_lib_baseRunTypes.MemberRunType {
+  isOptional() {
+    return true;
+  }
+  getChildVarName(comp) {
+    return comp.getLocalVarName("p", this);
+  }
+  getChildLiteral(comp) {
+    return this.getChildVarName(comp);
+  }
+  useArrayAccessor() {
+    return true;
+  }
+  skipJit(comp) {
+    const index = this.src.index?.kind;
+    if (index === type.ReflectionKind.symbol) {
+      return comp?.fnID !== src_constants_functions.JitFunctions.toJSCode.id;
+    }
+    return false;
+  }
+  // #### jit code ####
+  emitIsType(comp) {
+    const child = this.getJitChild(comp);
+    const childJit = comp.compileIsType(child, "E");
+    if (!childJit?.code)
+      return { code: void 0, type: "E" };
+    return {
+      code: `for (const ${this.getChildVarName(comp)} in ${comp.vλl}){if (!(${childJit.code})) return false;} return true;`,
+      type: "RB"
+    };
+  }
+  emitTypeErrors(comp) {
+    const child = this.getJitChild(comp);
+    const childJit = comp.compileTypeErrors(child, "S");
+    if (!childJit?.code)
+      return { code: void 0, type: "S" };
+    return { code: `for (const ${this.getChildVarName(comp)} in ${comp.vλl}) {${childJit.code}}`, type: "S" };
+  }
+  emitPrepareForJson(comp) {
+    const child = this.getJitChild(comp);
+    const childJit = comp.compilePrepareForJson(child, "S");
+    if (!child || !childJit?.code)
+      return { code: void 0, type: "S" };
+    const varName = comp.vλl;
+    const prop = this.getChildVarName(comp);
+    const skipCode = this.getSkipCode(comp, prop);
+    const isExpression = src_lib_utils.childIsExpression(childJit, child);
+    const code = isExpression ? `${comp.getChildVλl()} = ${childJit.code};` : childJit.code || "";
+    return { code: `for (const ${prop} in ${varName}){${skipCode} ${code}}`, type: "S" };
+  }
+  emitRestoreFromJson(comp) {
+    const child = this.getJitChild(comp);
+    const childJit = comp.compileRestoreFromJson(child, "S");
+    if (!child || !childJit?.code)
+      return { code: void 0, type: "S" };
+    const varName = comp.vλl;
+    const prop = this.getChildVarName(comp);
+    const skipCode = this.getSkipCode(comp, prop);
+    const isExpression = src_lib_utils.childIsExpression(childJit, child);
+    const code = isExpression ? `${comp.getChildVλl()} = ${childJit.code};` : childJit.code || "";
+    return { code: `for (const ${prop} in ${varName}){${skipCode} ${code}}`, type: "S" };
+  }
+  emitHasUnknownKeys(comp) {
+    if (this.getMemberType().getFamily() === "A")
+      return { code: void 0, type: "E" };
+    const child = this.getJitChild(comp);
+    const childJit = comp.compileHasUnknownKeys(child, "E");
+    if (!childJit?.code)
+      return { code: "", type: "E" };
+    const varName = comp.vλl;
+    const prop = this.getChildVarName(comp);
+    const resultVal = comp.getLocalVarName("res", this);
+    return {
+      code: `for (const ${prop} in ${varName}) {const ${resultVal} = ${childJit.code};if (${resultVal}) return true;}return false;`,
+      type: "RB"
+    };
+  }
+  emitUnknownKeyErrors(comp) {
+    if (this.getMemberType().getFamily() === "A")
+      return { code: void 0, type: "S" };
+    const child = this.getJitChild(comp);
+    const childJit = comp.compileUnknownKeyErrors(child, "S");
+    return this.traverseCode(comp, childJit);
+  }
+  emitStripUnknownKeys(comp) {
+    if (this.getMemberType().getFamily() === "A")
+      return { code: void 0, type: "S" };
+    const child = this.getJitChild(comp);
+    const childJit = comp.compileStripUnknownKeys(child, "S");
+    return this.traverseCode(comp, childJit);
+  }
+  emitUnknownKeysToUndefined(comp) {
+    if (this.getMemberType().getFamily() === "A")
+      return { code: void 0, type: "S" };
+    const child = this.getJitChild(comp);
+    const childJit = comp.compileUnknownKeysToUndefined(child, "S");
+    return this.traverseCode(comp, childJit);
+  }
+  traverseCode(comp, childJit) {
+    if (!childJit?.code)
+      return { code: void 0, type: "S" };
+    const prop = this.getChildVarName(comp);
+    return { code: `for (const ${prop} in ${comp.vλl}) {${childJit.code}}`, type: "S" };
+  }
+  /**
+   * if index property should be skipped then it output some code to skip it,
+   * this happen when an object/interface has an index property but also has named properties
+   * that might collide with the index property. ie {[key: string]: string, a: string}
+   * when executing the logic for the index property we need to skip the named properties.
+   */
+  getSkipCode(comp, prop) {
+    const parent = this.getParent();
+    const namedChildren = parent.getNamedChildren(comp);
+    const skipNames = namedChildren.length ? namedChildren.map(__assignType((child) => `${child.getChildLiteral(comp)} === ${prop}`, ["child", "", 'P"2!"/"'])).join(" || ") : "";
+    return namedChildren.length ? `if (${skipNames}) continue;` : "";
+  }
+  static __type = [() => type.__ΩTypeIndexSignature, () => src_lib_baseRunTypes.MemberRunType, "isOptional", "JitFnCompiler", "comp", "getChildVarName", "getChildLiteral", true, "useArrayAccessor", "skipJit", "JitCode", "emitIsType", "JitErrorsFnCompiler", "emitTypeErrors", "emitPrepareForJson", "emitRestoreFromJson", "emitHasUnknownKeys", "emitUnknownKeyErrors", "emitStripUnknownKeys", "emitUnknownKeysToUndefined", "childJit", "traverseCode", "prop", "getSkipCode", () => type.__ΩTypeIndexSignature, "IndexSignatureRunType", `Pn!7"P)0#P"w$2%&0&P"w$2%&0'P.(0)P"w$2%)0*P"w$2%"w+0,P"w-2%"w+0.P"w$2%"w+0/P"w$2%"w+00P"w$2%"w+01P"w-2%"w+02P"w$2%"w+03P"w$2%"w+04P"w$2%P"w+-J25"w+06P"w$2%&27&085n96"w:`];
+}
+exports.IndexSignatureRunType = IndexSignatureRunType;
+//# sourceMappingURL=indexProperty.cjs.map

package/.dist/cjs/src/nodes/member/indexProperty.cjs.map

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

package/.dist/cjs/src/nodes/member/indexProperty.d.ts

@@ -0,0 +1,21 @@
+import { TypeIndexSignature } from '@deepkit/type';
+import { MemberRunType } from '../../lib/baseRunTypes.ts';
+import { JitCode } from '../../types.ts';
+import { JitFnCompiler, JitErrorsFnCompiler } from '../../lib/jitFnCompiler.ts';
+export declare class IndexSignatureRunType extends MemberRunType<TypeIndexSignature> {
+    isOptional(): boolean;
+    getChildVarName(comp: JitFnCompiler): string;
+    getChildLiteral(comp: JitFnCompiler): string;
+    useArrayAccessor(): true;
+    skipJit(comp: JitFnCompiler): boolean;
+    emitIsType(comp: JitFnCompiler): JitCode;
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode;
+    emitPrepareForJson(comp: JitFnCompiler): JitCode;
+    emitRestoreFromJson(comp: JitFnCompiler): JitCode;
+    emitHasUnknownKeys(comp: JitFnCompiler): JitCode;
+    emitUnknownKeyErrors(comp: JitErrorsFnCompiler): JitCode;
+    emitStripUnknownKeys(comp: JitFnCompiler): JitCode;
+    emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode;
+    traverseCode(comp: JitFnCompiler, childJit: JitCode | undefined): JitCode;
+    getSkipCode(comp: JitFnCompiler, prop: string): string;
+}

package/.dist/cjs/src/nodes/member/method.cjs

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const type = require("@deepkit/type");
+const src_nodes_function_function = require("../function/function.cjs");
+const src_types = require("../../types.cjs");
+const src_lib_utils = require("../../lib/utils.cjs");
+function __assignType(fn, args) {
+  fn.__type = args;
+  return fn;
+}
+class MethodRunType extends src_nodes_function_function.FunctionRunType {
+  getChildIndex = __assignType((comp) => {
+    const start = comp?.opts?.paramsSlice?.start;
+    if (start)
+      return src_lib_utils.getPropIndex(this.src) - start;
+    return src_lib_utils.getPropIndex(this.src);
+  }, ["JitFnCompiler", "comp", "", 'P"w!2""/#']);
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getChildVarName(comp) {
+    return src_lib_utils.getPropVarName(this.src.name);
+  }
+  getChildLiteral(comp) {
+    return src_lib_utils.getPropLiteral(this.getChildVarName(comp));
+  }
+  useArrayAccessor() {
+    return src_lib_utils.useArrayAccessorForProp(this.src.name);
+  }
+  isOptional = () => !!this.src.optional;
+  static __type = [() => type.__ΩTypeMethod, () => src_nodes_function_function.FunctionRunType, "getChildIndex", function() {
+    return __assignType((comp) => {
+      const start = comp?.opts?.paramsSlice?.start;
+      if (start)
+        return src_lib_utils.getPropIndex(this.src) - start;
+      return src_lib_utils.getPropIndex(this.src);
+    }, ["JitFnCompiler", "comp", "", 'P"w!2""/#']);
+  }, "JitFnCompiler", "comp", "getChildVarName", "getChildLiteral", "useArrayAccessor", "isOptional", function() {
+    return () => !!this.src.optional;
+  }, () => type.__ΩTypeMethod, () => src_types.__ΩRunTypeChildAccessor, "MethodRunType", `Pn!7"!3#>$P"w%2&"0'P"w%2&"0(P"0)!3*>+5n,6"n-x"w.`];
+}
+exports.MethodRunType = MethodRunType;
+//# sourceMappingURL=method.cjs.map

package/.dist/cjs/src/nodes/member/method.cjs.map

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

package/.dist/cjs/src/nodes/member/method.d.ts

@@ -0,0 +1,11 @@
+import { TypeMethod } from '@deepkit/type';
+import { FunctionRunType } from '../function/function.ts';
+import { RunTypeChildAccessor } from '../../types.ts';
+import { JitFnCompiler } from '../../lib/jitFnCompiler.ts';
+export declare class MethodRunType extends FunctionRunType<TypeMethod> implements RunTypeChildAccessor {
+    getChildIndex: (comp: JitFnCompiler) => number;
+    getChildVarName(comp: JitFnCompiler): string | number;
+    getChildLiteral(comp: JitFnCompiler): string | number;
+    useArrayAccessor(): boolean;
+    isOptional: () => boolean;
+}

package/.dist/cjs/src/nodes/member/methodSignature.cjs

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const type = require("@deepkit/type");
+const src_types = require("../../types.cjs");
+const src_nodes_function_function = require("../function/function.cjs");
+const src_lib_utils = require("../../lib/utils.cjs");
+function __assignType(fn, args) {
+  fn.__type = args;
+  return fn;
+}
+class MethodSignatureRunType extends src_nodes_function_function.FunctionRunType {
+  getChildIndex = __assignType((comp) => {
+    const start = comp?.opts?.paramsSlice?.start;
+    if (start)
+      return src_lib_utils.getPropIndex(this.src) - start;
+    return src_lib_utils.getPropIndex(this.src);
+  }, ["JitFnCompiler", "comp", "", 'P"w!2""/#']);
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getChildVarName(comp) {
+    return src_lib_utils.getPropVarName(this.src.name);
+  }
+  getChildLiteral(comp) {
+    return src_lib_utils.getPropLiteral(this.getChildVarName(comp));
+  }
+  useArrayAccessor() {
+    return src_lib_utils.useArrayAccessorForProp(this.src.name);
+  }
+  isOptional = () => !!this.src.optional;
+  skipCommas = false;
+  static __type = [() => type.__ΩTypeMethodSignature, () => src_nodes_function_function.FunctionRunType, "getChildIndex", function() {
+    return __assignType((comp) => {
+      const start = comp?.opts?.paramsSlice?.start;
+      if (start)
+        return src_lib_utils.getPropIndex(this.src) - start;
+      return src_lib_utils.getPropIndex(this.src);
+    }, ["JitFnCompiler", "comp", "", 'P"w!2""/#']);
+  }, "JitFnCompiler", "comp", "getChildVarName", "getChildLiteral", "useArrayAccessor", "isOptional", function() {
+    return () => !!this.src.optional;
+  }, "skipCommas", function() {
+    return false;
+  }, () => type.__ΩTypeMethodSignature, () => src_types.__ΩRunTypeChildAccessor, "MethodSignatureRunType", `Pn!7"!3#>$P"w%2&"0'P"w%2&"0(P"0)!3*>+)3,>-5n.6"n/x"w0`];
+}
+exports.MethodSignatureRunType = MethodSignatureRunType;
+//# sourceMappingURL=methodSignature.cjs.map

package/.dist/cjs/src/nodes/member/methodSignature.cjs.map

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

package/.dist/cjs/src/nodes/member/methodSignature.d.ts

@@ -0,0 +1,12 @@
+import { TypeMethodSignature } from '@deepkit/type';
+import { RunTypeChildAccessor } from '../../types.ts';
+import { FunctionRunType } from '../function/function.ts';
+import { JitFnCompiler } from '../../lib/jitFnCompiler.ts';
+export declare class MethodSignatureRunType extends FunctionRunType<TypeMethodSignature> implements RunTypeChildAccessor {
+    getChildIndex: (comp: JitFnCompiler) => number;
+    getChildVarName(comp: JitFnCompiler): string | number;
+    getChildLiteral(comp: JitFnCompiler): string | number;
+    useArrayAccessor(): boolean;
+    isOptional: () => boolean;
+    skipCommas: boolean;
+}

package/.dist/cjs/src/nodes/member/param.cjs

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_nodes_member_tupleMember = require("./tupleMember.cjs");
+class ParameterRunType extends src_nodes_member_tupleMember.TupleMemberRunType {
+  getParamName() {
+    return this.src.name;
+  }
+  getChildVarName(comp) {
+    return this.getChildIndex(comp);
+  }
+  getChildLiteral(comp) {
+    return this.getChildIndex(comp);
+  }
+  static __type = ["TypeParameter", "T", () => src_nodes_member_tupleMember.TupleMemberRunType, "getParamName", "JitFnCompiler", "comp", "getChildVarName", "getChildLiteral", "ParameterRunType", `"w!c"Pe"!7#P"0$P"w%2&'0'P"w%2&'0(5e!!6"w)`];
+}
+exports.ParameterRunType = ParameterRunType;
+//# sourceMappingURL=param.cjs.map

package/.dist/cjs/src/nodes/member/param.cjs.map

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

package/.dist/cjs/src/nodes/member/param.d.ts

@@ -0,0 +1,8 @@
+import { TypeParameter } from '@deepkit/type';
+import { JitFnCompiler } from '../../lib/jitFnCompiler.ts';
+import { TupleMemberRunType } from './tupleMember.ts';
+export declare class ParameterRunType<T extends TypeParameter = TypeParameter> extends TupleMemberRunType<T> {
+    getParamName(): string;
+    getChildVarName(comp: JitFnCompiler): number;
+    getChildLiteral(comp: JitFnCompiler): number;
+}

package/.dist/cjs/src/nodes/member/property.cjs

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_lib_utils = require("../../lib/utils.cjs");
+const src_lib_baseRunTypes = require("../../lib/baseRunTypes.cjs");
+const src_constants_functions = require("../../constants.functions.cjs");
+function __assignType(fn, args) {
+  fn.__type = args;
+  return fn;
+}
+class PropertyRunType extends src_lib_baseRunTypes.MemberRunType {
+  isUnionDiscriminator = false;
+  /** this is set by the parent interface if prop is optional, when optional properties are sorted */
+  optionalIndex = -1;
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getPropertyName() {
+    return src_lib_utils.getPropVarName(this.src.name);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getChildVarName(comp) {
+    return src_lib_utils.getPropVarName(this.src.name);
+  }
+  getChildLiteral(comp) {
+    return src_lib_utils.getPropLiteral(this.getChildVarName(comp));
+  }
+  useArrayAccessor() {
+    return src_lib_utils.useArrayAccessorForProp(this.src.name);
+  }
+  getJitChildIndex = __assignType((comp) => this.getParent().getJitChildren(comp).indexOf(this), ["JitFnCompiler", "comp", "", 'P"w!2""/#']);
+  isOptional = () => !!this.src.optional;
+  skipJit(comp) {
+    const name = this.src.name;
+    if (typeof name === "symbol") {
+      return comp?.fnID !== src_constants_functions.JitFunctions.toJSCode.id;
+    }
+    return false;
+  }
+  // #### jit code ####
+  emitIsType(comp) {
+    const child = this.getJitChild(comp);
+    const childJit = comp.compileIsType(child, "E");
+    if (!childJit?.code)
+      return { code: void 0, type: "E" };
+    return this.src.optional ? { code: `(${comp.getChildVλl()} === undefined || ${childJit.code})`, type: "E" } : childJit;
+  }
+  emitTypeErrors(comp) {
+    const child = this.getJitChild(comp);
+    const childJit = comp.compileTypeErrors(child, "S");
+    if (!childJit?.code)
+      return { code: void 0, type: "S" };
+    return this.src.optional ? { code: `if (${comp.getChildVλl()} !== undefined) {${childJit.code}}`, type: "S" } : childJit;
+  }
+  emitPrepareForJson(comp) {
+    const child = this.getJitChild(comp);
+    const childJit = comp.compilePrepareForJson(child, "S");
+    if (!child || !childJit?.code)
+      return { code: void 0, type: "S" };
+    const isExpression = src_lib_utils.childIsExpression(childJit, child);
+    const code = isExpression ? `${comp.getChildVλl()} = ${childJit.code};` : childJit.code || "";
+    if (this.src.optional)
+      return { code: `if (${comp.getChildVλl()} !== undefined) {${code}}`, type: "S" };
+    return { code, type: "S" };
+  }
+  emitRestoreFromJson(comp) {
+    const child = this.getJitChild(comp);
+    const childJit = comp.compileRestoreFromJson(child, "S");
+    if (!child || !childJit?.code)
+      return { code: void 0, type: "S" };
+    const isExpression = src_lib_utils.childIsExpression(childJit, child);
+    const code = isExpression ? `${comp.getChildVλl()} = ${childJit.code};` : childJit.code || "";
+    if (this.src.optional)
+      return { code: `if (${comp.getChildVλl()} !== undefined) {${code}}`, type: "S" };
+    return { code, type: "S" };
+  }
+  static __type = ["TypePropertySignature", "TypeProperty", () => src_lib_baseRunTypes.MemberRunType, "isUnionDiscriminator", function() {
+    return false;
+  }, "optionalIndex", function() {
+    return -1;
+  }, "getPropertyName", "JitFnCompiler", "comp", "getChildVarName", "getChildLiteral", "useArrayAccessor", "getJitChildIndex", function() {
+    return __assignType((comp) => this.getParent().getJitChildren(comp).indexOf(this), ["JitFnCompiler", "comp", "", 'P"w!2""/#']);
+  }, "isOptional", function() {
+    return () => !!this.src.optional;
+  }, "skipJit", "JitCode", "emitIsType", "JitErrorsFnCompiler", "emitTypeErrors", "emitPrepareForJson", "emitRestoreFromJson", "PropertyRunType", `PP"w!"w"J7#)3$>%!3&>'P"0(P"w)2*"0+P"w)2*"0,P"0-!3.>/!30>1P"w)2*)02P"w)2*"w304P"w52*"w306P"w)2*"w307P"w)2*"w3085P"w!"w"J6"w9`];
+}
+exports.PropertyRunType = PropertyRunType;
+//# sourceMappingURL=property.cjs.map

package/.dist/cjs/src/nodes/member/property.cjs.map

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

package/.dist/cjs/src/nodes/member/property.d.ts

@@ -0,0 +1,19 @@
+import { TypeProperty, TypePropertySignature } from '@deepkit/type';
+import { JitFnCompiler, JitErrorsFnCompiler } from '../../lib/jitFnCompiler.ts';
+import { JitCode } from '../../types.ts';
+import { MemberRunType } from '../../lib/baseRunTypes.ts';
+export declare class PropertyRunType extends MemberRunType<TypePropertySignature | TypeProperty> {
+    isUnionDiscriminator: boolean;
+    optionalIndex: number;
+    getPropertyName(): string | number;
+    getChildVarName(comp: JitFnCompiler): string | number;
+    getChildLiteral(comp: JitFnCompiler): string | number;
+    useArrayAccessor(): boolean;
+    getJitChildIndex: (comp: JitFnCompiler) => number;
+    isOptional: () => boolean;
+    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/member/restParams.cjs

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_nodes_member_array = require("./array.cjs");
+class RestParamsRunType extends src_nodes_member_array.ArrayRunType {
+  getChildIndex(comp) {
+    const parent = this.getParent();
+    return parent.getChildIndex(comp);
+  }
+  startIndex(comp) {
+    return this.getChildIndex(comp);
+  }
+  static __type = ["TypeRest", () => src_nodes_member_array.ArrayRunType, "JitFnCompiler", "comp", "getChildIndex", "startIndex", "RestParamsRunType", `P"w!7"P"w#2$'0%P"w#2$'0&5"w!6"w'`];
+}
+exports.RestParamsRunType = RestParamsRunType;
+//# sourceMappingURL=restParams.cjs.map

package/.dist/cjs/src/nodes/member/restParams.cjs.map

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

package/.dist/cjs/src/nodes/member/restParams.d.ts

@@ -0,0 +1,7 @@
+import { TypeRest } from '@deepkit/type';
+import { ArrayRunType } from './array.ts';
+import { JitFnCompiler } from '../../lib/jitFnCompiler.ts';
+export declare class RestParamsRunType extends ArrayRunType<TypeRest> {
+    getChildIndex(comp: JitFnCompiler): number;
+    startIndex(comp: JitFnCompiler): number;
+}

package/.dist/cjs/src/nodes/member/tupleMember.cjs

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const type = require("@deepkit/type");
+const src_lib_baseRunTypes = require("../../lib/baseRunTypes.cjs");
+const src_types = require("../../types.cjs");
+const src_lib_utils = require("../../lib/utils.cjs");
+class TupleMemberRunType extends src_lib_baseRunTypes.MemberRunType {
+  isOptional() {
+    return !!this.src.optional || this.isRest() || this.hasDefaultValue();
+  }
+  getChildIndex(comp) {
+    const start = comp?.opts?.paramsSlice?.start;
+    if (start)
+      return src_lib_utils.getParamIndex(this.src) - start;
+    return src_lib_utils.getParamIndex(this.src);
+  }
+  getChildVarName(comp) {
+    const src = this.src;
+    if (src.parent?.types) {
+      return src.parent.types.indexOf(this.src);
+    }
+    return this.getChildIndex(comp);
+  }
+  getChildLiteral(comp) {
+    return this.getChildVarName(comp);
+  }
+  useArrayAccessor() {
+    return true;
+  }
+  isRest() {
+    return this.getMemberType().src.kind === type.ReflectionKind.rest;
+  }
+  skipSettingAccessor() {
+    return this.isRest();
+  }
+  hasDefaultValue() {
+    return !!this.src.default;
+  }
+  emitIsType(comp) {
+    const child = this.getJitChild(comp);
+    const skipChild = child?.skipJit(comp);
+    const childJit = comp.compileIsType(child, "E");
+    const isNonSerializable = skipChild || !childJit?.code && !child;
+    if (isNonSerializable)
+      return { code: `${comp.getChildVλl()} === undefined`, type: "E" };
+    if (!childJit?.code)
+      return { code: void 0, type: "E" };
+    if (this.isRest())
+      return childJit;
+    return this.isOptional() ? { code: `(${comp.getChildVλl()} === undefined || (${childJit.code}))`, type: "E" } : childJit;
+  }
+  emitTypeErrors(comp) {
+    const child = this.getJitChild(comp);
+    const skipChild = child?.skipJit(comp);
+    const childJit = comp.compileTypeErrors(child, "S");
+    const isNonSerializable = skipChild || !childJit?.code && !child;
+    if (isNonSerializable)
+      return {
+        code: `if (${comp.getChildVλl()} !== undefined) ${comp.callJitErrWithPath("undefined", this.getChildIndex(comp))}`,
+        type: "S"
+      };
+    if (!childJit?.code)
+      return { code: void 0, type: "S" };
+    if (this.isRest())
+      return childJit;
+    return this.isOptional() ? { code: `if (${comp.getChildVλl()} !== undefined) {${childJit.code}}`, type: "S" } : childJit;
+  }
+  emitPrepareForJson(comp) {
+    const child = this.getJitChild(comp);
+    const childJit = comp.compilePrepareForJson(child, "S");
+    const optionalCode = `if (${comp.getChildVλl()} === undefined ) {if (${comp.vλl}.length > ${this.getChildIndex(comp)}) ${comp.getChildVλl()} = null}`;
+    if (!child || !childJit?.code)
+      return this.isOptional() ? { code: optionalCode, type: "S" } : { code: void 0, type: "S" };
+    const isExpression = src_lib_utils.childIsExpression(childJit, child);
+    const code = isExpression ? `${comp.getChildVλl()} = ${childJit.code};` : childJit.code || "";
+    return this.isOptional() ? { code: `${optionalCode} else {${code}}`, type: "S" } : { code, type: "S" };
+  }
+  emitRestoreFromJson(comp) {
+    if (!this.getJitChild(comp))
+      return { code: `${comp.getChildVλl()} = undefined;`, type: "S" };
+    const child = this.getJitChild(comp);
+    const childJit = comp.compileRestoreFromJson(child, "S");
+    const optionalCOde = `if (${comp.getChildVλl()} === null ) {${comp.getChildVλl()} = undefined}`;
+    if (!child || !childJit?.code)
+      return this.isOptional() ? { code: optionalCOde, type: "S" } : { code: void 0, type: "S" };
+    const isExpression = src_lib_utils.childIsExpression(childJit, child);
+    const code = isExpression ? `${comp.getChildVλl()} = ${childJit.code};` : childJit.code || "";
+    return this.isOptional() ? { code: `${optionalCOde} else if (${comp.getChildVλl()} !== undefined) {${code}}`, type: "S" } : { code, type: "S" };
+  }
+  static __type = [() => type.__ΩTypeTupleMember, "T", () => src_lib_baseRunTypes.MemberRunType, "isOptional", "JitFnCompiler", "comp", "getChildIndex", "getChildVarName", "getChildLiteral", true, "useArrayAccessor", "isRest", "skipSettingAccessor", "hasDefaultValue", () => src_types.__ΩJitCode, "emitIsType", "JitErrorsFnCompiler", () => src_types.__ΩJitCode, "emitTypeErrors", () => src_types.__ΩJitCode, "emitPrepareForJson", () => src_types.__ΩJitCode, "emitRestoreFromJson", "TupleMemberRunType", `n!c"Pe"!7#P)0$P"w%2&'0'P"w%2&'0(P"w%2&'0)P.*0+P)0,P"0-P)0.P"w%2&n/00P"w12&n203P"w%2&n405P"w%2&n6075e!!6"w8`];
+}
+exports.TupleMemberRunType = TupleMemberRunType;
+//# sourceMappingURL=tupleMember.cjs.map

package/.dist/cjs/src/nodes/member/tupleMember.cjs.map

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