@mionjs/run-types 0.8.0-alpha.0

package/.dist/esm/src/nodes/member/genericMember.js

@@ -0,0 +1,68 @@
+import { MemberRunType } from "../../lib/baseRunTypes.js";
+import { childIsExpression } from "../../lib/utils.js";
+class GenericMemberRunType extends 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 = 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 = 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", () => 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`];
+}
+export {
+  GenericMemberRunType
+};
+//# sourceMappingURL=genericMember.js.map

package/.dist/esm/src/nodes/member/genericMember.js.map

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

package/.dist/esm/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/esm/src/nodes/member/indexProperty.js

@@ -0,0 +1,130 @@
+import { ReflectionKind, __ΩTypeIndexSignature as ___TypeIndexSignature } from "@deepkit/type";
+import { MemberRunType } from "../../lib/baseRunTypes.js";
+import { JitFunctions } from "../../constants.functions.js";
+import { childIsExpression } from "../../lib/utils.js";
+function __assignType(fn, args) {
+  fn.__type = args;
+  return fn;
+}
+class IndexSignatureRunType extends 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 === ReflectionKind.symbol) {
+      return comp?.fnID !== 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 = 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 = 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 = [() => ___TypeIndexSignature, () => MemberRunType, "isOptional", "JitFnCompiler", "comp", "getChildVarName", "getChildLiteral", true, "useArrayAccessor", "skipJit", "JitCode", "emitIsType", "JitErrorsFnCompiler", "emitTypeErrors", "emitPrepareForJson", "emitRestoreFromJson", "emitHasUnknownKeys", "emitUnknownKeyErrors", "emitStripUnknownKeys", "emitUnknownKeysToUndefined", "childJit", "traverseCode", "prop", "getSkipCode", () => ___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:`];
+}
+export {
+  IndexSignatureRunType
+};
+//# sourceMappingURL=indexProperty.js.map

package/.dist/esm/src/nodes/member/indexProperty.js.map

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

package/.dist/esm/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/esm/src/nodes/member/method.js

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

package/.dist/esm/src/nodes/member/method.js.map

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

package/.dist/esm/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/esm/src/nodes/member/methodSignature.js

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

package/.dist/esm/src/nodes/member/methodSignature.js.map

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

package/.dist/esm/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/esm/src/nodes/member/param.js

@@ -0,0 +1,17 @@
+import { TupleMemberRunType } from "./tupleMember.js";
+class ParameterRunType extends TupleMemberRunType {
+  getParamName() {
+    return this.src.name;
+  }
+  getChildVarName(comp) {
+    return this.getChildIndex(comp);
+  }
+  getChildLiteral(comp) {
+    return this.getChildIndex(comp);
+  }
+  static __type = ["TypeParameter", "T", () => TupleMemberRunType, "getParamName", "JitFnCompiler", "comp", "getChildVarName", "getChildLiteral", "ParameterRunType", `"w!c"Pe"!7#P"0$P"w%2&'0'P"w%2&'0(5e!!6"w)`];
+}
+export {
+  ParameterRunType
+};
+//# sourceMappingURL=param.js.map

package/.dist/esm/src/nodes/member/param.js.map

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

package/.dist/esm/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/esm/src/nodes/member/property.js

@@ -0,0 +1,85 @@
+import { getPropVarName, getPropLiteral, useArrayAccessorForProp, childIsExpression } from "../../lib/utils.js";
+import { MemberRunType } from "../../lib/baseRunTypes.js";
+import { JitFunctions } from "../../constants.functions.js";
+function __assignType(fn, args) {
+  fn.__type = args;
+  return fn;
+}
+class PropertyRunType extends 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 getPropVarName(this.src.name);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getChildVarName(comp) {
+    return getPropVarName(this.src.name);
+  }
+  getChildLiteral(comp) {
+    return getPropLiteral(this.getChildVarName(comp));
+  }
+  useArrayAccessor() {
+    return 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 !== 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 = 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 = 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", () => 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`];
+}
+export {
+  PropertyRunType
+};
+//# sourceMappingURL=property.js.map

package/.dist/esm/src/nodes/member/property.js.map

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

package/.dist/esm/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/esm/src/nodes/member/restParams.js

@@ -0,0 +1,15 @@
+import { ArrayRunType } from "./array.js";
+class RestParamsRunType extends ArrayRunType {
+  getChildIndex(comp) {
+    const parent = this.getParent();
+    return parent.getChildIndex(comp);
+  }
+  startIndex(comp) {
+    return this.getChildIndex(comp);
+  }
+  static __type = ["TypeRest", () => ArrayRunType, "JitFnCompiler", "comp", "getChildIndex", "startIndex", "RestParamsRunType", `P"w!7"P"w#2$'0%P"w#2$'0&5"w!6"w'`];
+}
+export {
+  RestParamsRunType
+};
+//# sourceMappingURL=restParams.js.map

package/.dist/esm/src/nodes/member/restParams.js.map

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

package/.dist/esm/src/nodes/member/tupleMember.d.ts

@@ -0,0 +1,20 @@
+import { TypeTupleMember, TypeParameter } from '@deepkit/type';
+import { JitFnCompiler, JitErrorsFnCompiler } from '../../lib/jitFnCompiler.ts';
+import { MemberRunType } from '../../lib/baseRunTypes.ts';
+import { JitCode } from '../../types.ts';
+type TupleMemberT = TypeParameter | TypeTupleMember;
+export declare class TupleMemberRunType<T extends TupleMemberT = TypeTupleMember> extends MemberRunType<T> {
+    isOptional(): boolean;
+    getChildIndex(comp: JitFnCompiler): number;
+    getChildVarName(comp: JitFnCompiler): number;
+    getChildLiteral(comp: JitFnCompiler): number;
+    useArrayAccessor(): true;
+    isRest(): boolean;
+    skipSettingAccessor(): boolean;
+    hasDefaultValue(): boolean;
+    emitIsType(comp: JitFnCompiler): JitCode;
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode;
+    emitPrepareForJson(comp: JitFnCompiler): JitCode;
+    emitRestoreFromJson(comp: JitFnCompiler): JitCode;
+}
+export {};

package/.dist/esm/src/nodes/member/tupleMember.js

@@ -0,0 +1,93 @@
+import { ReflectionKind, __ΩTypeTupleMember as ___TypeTupleMember } from "@deepkit/type";
+import { MemberRunType } from "../../lib/baseRunTypes.js";
+import { __ΩJitCode as ___JitCode } from "../../types.js";
+import { getParamIndex, childIsExpression } from "../../lib/utils.js";
+class TupleMemberRunType extends MemberRunType {
+  isOptional() {
+    return !!this.src.optional || this.isRest() || this.hasDefaultValue();
+  }
+  getChildIndex(comp) {
+    const start = comp?.opts?.paramsSlice?.start;
+    if (start)
+      return getParamIndex(this.src) - start;
+    return 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 === 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 = 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 = 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 = [() => ___TypeTupleMember, "T", () => MemberRunType, "isOptional", "JitFnCompiler", "comp", "getChildIndex", "getChildVarName", "getChildLiteral", true, "useArrayAccessor", "isRest", "skipSettingAccessor", "hasDefaultValue", () => ___JitCode, "emitIsType", "JitErrorsFnCompiler", () => ___JitCode, "emitTypeErrors", () => ___JitCode, "emitPrepareForJson", () => ___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`];
+}
+export {
+  TupleMemberRunType
+};
+//# sourceMappingURL=tupleMember.js.map

package/.dist/esm/src/nodes/member/tupleMember.js.map

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