@mionjs/run-types 0.8.0-alpha.0

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

@@ -0,0 +1,198 @@
+import { getTotalComplexity, sortRunTypeByComplexity } from "../../lib/utils.js";
+import { isAnyRunType, isUnknownRunType } from "../../lib/guards.js";
+function __assignType(fn, args) {
+  fn.__type = args;
+  return fn;
+}
+const __ΩFlattenedProp = ["CollectionRunType", "unionItem", "unionIndex", "PropertyRunType", "prop", "typeID", "compiledName", "FlattenedProp", `P"w!4"P&'J4#"w$4%P&'J4&&4'Mw(y`];
+const __ΩSplitUnionResult = ["BaseRunType", "simpleItems", "CollectionRunType", "objectTypes", "anyItem", "SplitUnionResult", 'P"w!F4""w#F4$"w!4%8Mw&y'];
+function splitUnionItems(comp, urt, unionChildren) {
+  const unionItems = unionChildren || urt.getJitChildren(comp);
+  const objectTypes = [];
+  const simpleItems = [];
+  let anyItem;
+  unionItems.forEach(__assignType((unionItem) => {
+    if (isAnyRunType(unionItem) || isUnknownRunType(unionItem)) {
+      if (!anyItem)
+        anyItem = unionItem;
+      return;
+    }
+    const isObj = urt.isTypeWithProperties(unionItem);
+    if (!isObj)
+      return simpleItems.push(unionItem);
+    return objectTypes.push(unionItem);
+  }, ["unionItem", "", 'P"2!"/"']));
+  const sortedObjectTypes = sortUnreachableTypes(comp, objectTypes);
+  return { simpleItems, objectTypes: sortedObjectTypes, anyItem };
+}
+splitUnionItems.__type = ["JitFnCompiler", "comp", "UnionRunType", "urt", "BaseRunType", "unionChildren", () => __ΩSplitUnionResult, "splitUnionItems", `P"w!2""w#2$"w%F2&8n'/(`];
+function sortUnreachableTypes(comp, objectTypes) {
+  if (objectTypes.length <= 1)
+    return objectTypes;
+  const typePropsMap = (Map.Ω = [["CollectionRunType", '"w!'], ["P&'JD"]], /* @__PURE__ */ new Map());
+  objectTypes.forEach(__assignType((objType) => {
+    const props = objType.getJitChildren(comp);
+    const propTypeIDs = (Set.Ω = [["P&'J"]], /* @__PURE__ */ new Set());
+    props.forEach(__assignType((prop) => propTypeIDs.add(prop.getTypeID()), ["prop", "", 'P"2!"/"']));
+    typePropsMap.set(objType, propTypeIDs);
+  }, ["objType", "", 'P"2!"/"']));
+  const isSubsetOf = __assignType((smaller, larger) => {
+    const smallerProps = typePropsMap.get(smaller);
+    const largerProps = typePropsMap.get(larger);
+    if (smallerProps.size >= largerProps.size)
+      return false;
+    for (const typeID of smallerProps) {
+      if (!largerProps.has(typeID))
+        return false;
+    }
+    return true;
+  }, ["CollectionRunType", "smaller", "larger", "", 'P"w!2""w!2#)/$']);
+  const processed = (Set.Ω = [["CollectionRunType", '"w!']], /* @__PURE__ */ new Set());
+  const result = [];
+  for (let i = 0; i < objectTypes.length; i++) {
+    const current = objectTypes[i];
+    if (processed.has(current))
+      continue;
+    const relatedGroup = [current];
+    processed.add(current);
+    for (let j = 0; j < objectTypes.length; j++) {
+      if (i === j)
+        continue;
+      const other = objectTypes[j];
+      if (processed.has(other))
+        continue;
+      if (isSubsetOf(current, other) || isSubsetOf(other, current)) {
+        relatedGroup.push(other);
+        processed.add(other);
+      }
+    }
+    if (relatedGroup.length > 1) {
+      relatedGroup.sort(__assignType((a, b) => {
+        const aSize = typePropsMap.get(a).size;
+        const bSize = typePropsMap.get(b).size;
+        return bSize - aSize;
+      }, ["a", "b", "", 'P"2!"2""/#']));
+    }
+    result.push(...relatedGroup);
+  }
+  return result;
+}
+sortUnreachableTypes.__type = ["JitFnCompiler", "comp", "CollectionRunType", "objectTypes", "sortUnreachableTypes", 'P"w!2""w#F2$"w#F/%'];
+function markDiscriminators(comp, urt, unionItems) {
+  if (urt.hasDiscriminators !== void 0 && urt.hasObjectTypes !== void 0)
+    return;
+  const objectTypes = unionItems.filter(__assignType((item) => urt.isTypeWithProperties(item), ["item", "", 'P"2!"/"']));
+  const namedDiscriminators = getDiscriminatorProperties(comp, urt, objectTypes, initGetCompiledName());
+  const uniqueDiscriminators = getUniqueDiscriminatorProperties(comp, urt, objectTypes, initGetCompiledName());
+  urt.hasObjectTypes = !!objectTypes.length;
+  urt.hasDiscriminators = !!namedDiscriminators.length || !!uniqueDiscriminators.length;
+}
+markDiscriminators.__type = ["JitFnCompiler", "comp", "UnionRunType", "urt", "BaseRunType", "unionItems", "markDiscriminators", `P"w!2""w#2$"w%F2&"/'`];
+const __ΩPropUnionItemPair = ["PropertyRunType", "prop", "CollectionRunType", "unionItem", "PropUnionItemPair", 'P"w!4""w#4$Mw%y'];
+function getDiscriminatorProperties(comp, urt, unionTypes, getCompiledName) {
+  if (!unionTypes.length)
+    return [];
+  const propByName = (Map.Ω = [["P&'J"], [() => __ΩPropUnionItemPair, "n!F"]], /* @__PURE__ */ new Map());
+  unionTypes.forEach(__assignType((unionItem) => {
+    const props = unionItem.getJitChildren(comp);
+    props.forEach(__assignType((prop) => {
+      const name = prop.getChildVarName(comp);
+      const existing = propByName.get(name) || [];
+      propByName.set(name, [...existing, { prop, unionItem }]);
+    }, ["prop", "", 'P"2!"/"']));
+  }, ["unionItem", "", 'P"2!"/"']));
+  const propsOnAllTypes = Array.from(propByName.entries()).filter(__assignType(([, props]) => props.length === unionTypes.length, ["param0", "", 'P"2!"/"'])).map(__assignType(([key, props]) => ({
+    name: key,
+    props,
+    complexity: props.reduce(__assignType((acc, item) => acc + getTotalComplexity(comp, item.prop), ["acc", "item", "", 'P"2!"2""/#']), 0),
+    isUniqueType: props.every(__assignType((item) => {
+      const child = item;
+      const typeID = child.prop.getTypeID();
+      const isDiff = props.every(__assignType((otherItem) => child.prop === otherItem.prop || otherItem.prop.getTypeID() !== typeID, ["otherItem", "", 'P"2!"/"']));
+      return isDiff;
+    }, ["item", "", 'P"2!"/"']))
+  }), ["param0", "", 'P"2!"/"'])).filter(__assignType((item) => item.isUniqueType, ["item", "", 'P"2!"/"']));
+  const lessComplexProps = propsOnAllTypes.toSorted(__assignType((a, b) => a.complexity - b.complexity, ["a", "b", "", 'P"2!"2""/#']));
+  const lessComplex = lessComplexProps[0];
+  if (!lessComplex)
+    return [];
+  return lessComplex.props.map(__assignType((item) => {
+    item.prop.isUnionDiscriminator = true;
+    const unionIndex = urt.getUnionItemIndex(comp, item.unionItem);
+    const typeID = item.prop.getTypeID();
+    return {
+      unionItem: item.unionItem,
+      unionIndex,
+      prop: item.prop,
+      typeID,
+      compiledName: getCompiledName(comp, urt, typeID)
+    };
+  }, ["item", "", 'P"2!"/"']));
+}
+getDiscriminatorProperties.__type = ["JitFnCompiler", "comp", "UnionRunType", "urt", "CollectionRunType", "unionTypes", "propTypeID", "", "getCompiledName", () => __ΩFlattenedProp, "getDiscriminatorProperties", `P"w!2""w#2$"w%F2&P"w!2""w#2$P&'J2'&/(2)n*F/+`];
+function getUniqueDiscriminatorProperties(comp, urt, unionTypes, getCompiledName) {
+  if (!unionTypes.length)
+    return [];
+  const uniquePropByUnionItem = (Map.Ω = [["CollectionRunType", '"w!'], [() => __ΩPropUnionItemPair, "n!"]], /* @__PURE__ */ new Map());
+  unionTypes.forEach(__assignType((unionItem) => {
+    const props = unionItem.getJitChildren(comp);
+    props.forEach(__assignType((prop) => {
+      const typeID = prop.getTypeID();
+      const isUnique = unionTypes.every(__assignType((otherUnionItem) => {
+        if (otherUnionItem === unionItem)
+          return true;
+        const otherProps = otherUnionItem.getJitChildren(comp);
+        return otherProps.every(__assignType((otherProp) => otherProp.getTypeID() !== typeID, ["otherProp", "", 'P"2!"/"']));
+      }, ["otherUnionItem", "", 'P"2!"/"']));
+      if (isUnique) {
+        const existing = uniquePropByUnionItem.get(unionItem);
+        if (!existing) {
+          uniquePropByUnionItem.set(unionItem, {
+            prop,
+            unionItem
+          });
+          return;
+        }
+        const newItem = { prop, unionItem };
+        const lessComplex = [newItem, existing].toSorted(__assignType((a, b) => sortRunTypeByComplexity(comp, a.prop, b.prop), ["a", "b", "", 'P"2!"2""/#']))[0];
+        uniquePropByUnionItem.set(unionItem, lessComplex);
+      }
+    }, ["prop", "", 'P"2!"/"']));
+  }, ["unionItem", "", 'P"2!"/"']));
+  if (!uniquePropByUnionItem.size)
+    return [];
+  const uniqueProps = Array.from(uniquePropByUnionItem.values());
+  return uniqueProps.map(__assignType((item) => {
+    item.prop.isUnionDiscriminator = true;
+    const unionIndex = urt.getUnionItemIndex(comp, item.unionItem);
+    const typeID = item.prop.getTypeID();
+    return {
+      unionItem: item.unionItem,
+      unionIndex,
+      prop: item.prop,
+      typeID,
+      compiledName: getCompiledName(comp, urt, typeID)
+    };
+  }, ["item", "", 'P"2!"/"']));
+}
+getUniqueDiscriminatorProperties.__type = ["JitFnCompiler", "comp", "UnionRunType", "urt", "CollectionRunType", "unionTypes", "propTypeID", "", "getCompiledName", () => __ΩFlattenedProp, "getUniqueDiscriminatorProperties", `P"w!2""w#2$"w%F2&P"w!2""w#2$P&'J2'&/(2)n*F/+`];
+function initGetCompiledName() {
+  const typeIDs = (Map.Ω = [["P&'J"], ["'"]], /* @__PURE__ */ new Map());
+  return __assignType(function getCompiledName(comp, urt, typeID) {
+    const existingIndex = typeIDs.get(typeID);
+    if (existingIndex)
+      return comp.getLocalVarName("prop", urt) + `_${existingIndex}`;
+    const newIndex = typeIDs.size;
+    typeIDs.set(typeID, newIndex);
+    return comp.getLocalVarName("prop", urt) + `_${newIndex}`;
+  }, ["JitFnCompiler", "comp", "UnionRunType", "urt", "typeID", "getCompiledName", `P"w!2""w#2$P&'J2%&/&`]);
+}
+initGetCompiledName.__type = ["initGetCompiledName", 'P"/!'];
+export {
+  __ΩFlattenedProp,
+  __ΩSplitUnionResult,
+  markDiscriminators,
+  sortUnreachableTypes,
+  splitUnionItems
+};
+//# sourceMappingURL=unionDiscriminator.js.map

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

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

package/.dist/esm/src/nodes/function/function.d.ts

@@ -0,0 +1,33 @@
+import { AnyFunction, SrcType, JitFn, JitCode, RunTypeOptions } from '../../types.ts';
+import { TypeFunction } from '@deepkit/type';
+import { BaseRunType } from '../../lib/baseRunTypes.ts';
+import { JitFnCompiler, JitErrorsFnCompiler } from '../../lib/jitFnCompiler.ts';
+import { FunctionParamsRunType } from '../collection/functionParams.ts';
+import { JitCompiledFn } from '@mionjs/core';
+export declare class FunctionRunType<CallType extends AnyFunction = TypeFunction> extends BaseRunType<CallType> {
+    parameterRunTypes: FunctionParamsRunType;
+    skipJit(comp: JitFnCompiler): boolean;
+    onCreated(deepkitType: SrcType): void;
+    getFamily(): 'F';
+    getFnName(): string | number;
+    createJitParamsFunction(jitFn: JitFn, opts?: RunTypeOptions): (...args: any[]) => any;
+    createJitCompiledParamsFunction(jitFn: JitFn, opts?: RunTypeOptions): JitCompiledFn;
+    createJitReturnFunction(jitFn: JitFn): (...args: any[]) => any;
+    createJitCompiledReturnFunction(jitFn: JitFn, opts?: RunTypeOptions): JitCompiledFn;
+    emitIsType(comp: JitFnCompiler): JitCode;
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode;
+    emitPrepareForJson(): JitCode;
+    emitRestoreFromJson(): JitCode;
+    emitHasUnknownKeys(): JitCode;
+    emitUnknownKeyErrors(): JitCode;
+    emitStripUnknownKeys(): JitCode;
+    emitUnknownKeysToUndefined(): JitCode;
+    getReturnType(): BaseRunType;
+    getParameters(): FunctionParamsRunType;
+    getParameterNames(opts?: RunTypeOptions): string[];
+    hasReturnData(): boolean;
+    isAsync(): boolean;
+    returnIsPromise(): boolean;
+    mockReturn(ctx?: RunTypeOptions): Promise<any>;
+    mockParams(ctx?: RunTypeOptions): Promise<any[]>;
+}

package/.dist/esm/src/nodes/function/function.js

@@ -0,0 +1,155 @@
+import { ReflectionKind, __ΩTypeFunction as ___TypeFunction } from "@deepkit/type";
+import { BaseRunType } from "../../lib/baseRunTypes.js";
+import { isAnyFunctionRunType, isPromiseRunType, isFunctionRunType } from "../../lib/guards.js";
+import { JitFnCompiler, JitErrorsFnCompiler } from "../../lib/jitFnCompiler.js";
+import { ReflectionSubKind } from "../../constants.kind.js";
+import { FunctionParamsRunType } from "../collection/functionParams.js";
+import { __ΩJitCompiledFn as ___JitCompiledFn } from "@mionjs/core";
+import { registerJitFunctionCompiler } from "../../lib/jitFnsRegistry.js";
+import { JitFunctions } from "../../constants.functions.js";
+function __assignType(fn, args) {
+  fn.__type = args;
+  return fn;
+}
+class FunctionRunType extends BaseRunType {
+  // parameterRunTypes.src must be set after FunctionRunType creation
+  parameterRunTypes = new FunctionParamsRunType();
+  skipJit(comp) {
+    if (!comp)
+      return true;
+    return comp.fnID !== JitFunctions.toJSCode.id;
+  }
+  onCreated(deepkitType) {
+    super.onCreated(deepkitType);
+    const paramsType = { ...deepkitType, subKind: ReflectionSubKind.params };
+    delete paramsType._typeId;
+    delete paramsType._formatId;
+    this.parameterRunTypes.onCreated(paramsType);
+  }
+  getFamily() {
+    return "F";
+  }
+  getFnName() {
+    const name = this.src.name;
+    if (!name)
+      return "";
+    if (typeof name === "symbol")
+      return name.toString();
+    return name;
+  }
+  createJitParamsFunction(jitFn, opts) {
+    return this.createJitCompiledParamsFunction(jitFn, opts).fn;
+  }
+  createJitCompiledParamsFunction(jitFn, opts) {
+    const start = opts?.paramsSlice?.start;
+    const end = opts?.paramsSlice?.end;
+    if (start && end) {
+      if (start < 0 || end > this.parameterRunTypes.getChildRunTypes().length)
+        throw new Error(`Invalid paramsSlice, start: ${start}, end: ${end}.`);
+      if (end <= start)
+        throw new Error(`Invalid paramsSlice, start: ${start}, end: ${end}`);
+    }
+    return this.parameterRunTypes.createJitCompiledFunction(jitFn.id, void 0, opts);
+  }
+  createJitReturnFunction(jitFn) {
+    return this.createJitCompiledReturnFunction(jitFn).fn;
+  }
+  createJitCompiledReturnFunction(jitFn, opts) {
+    let currentType = this;
+    while (true) {
+      if (isAnyFunctionRunType(currentType)) {
+        const returnType = currentType.getReturnType();
+        if (isPromiseRunType(returnType) || isFunctionRunType(returnType)) {
+          currentType = returnType;
+          continue;
+        }
+        return returnType.createJitCompiledFunction(jitFn.id, void 0, opts);
+      }
+      const memberType = currentType.getMemberType();
+      if (isPromiseRunType(memberType) || isFunctionRunType(memberType)) {
+        currentType = memberType;
+        continue;
+      }
+      return memberType.createJitCompiledFunction(jitFn.id, void 0, opts);
+    }
+  }
+  // ######## JIT functions (all throw error) ########
+  // can't know the types of the run type function parameters, neither the return type, so only compare function name and length
+  emitIsType(comp) {
+    const minLength = this.parameterRunTypes.totalRequiredParams(comp);
+    const totalParams = this.parameterRunTypes.getParamRunTypes(comp).length;
+    const hasOptional = totalParams > minLength;
+    const maxLength = this.parameterRunTypes.hasRestParameter(comp) || !hasOptional ? "" : ` && ${comp.vλl}.length <= ${totalParams}`;
+    return { code: `(typeof ${comp.vλl} === 'function' && ${comp.vλl}.length >= ${minLength} ${maxLength})`, type: "E" };
+  }
+  emitTypeErrors(comp) {
+    return { code: `if (!(${this.emitIsType(comp).code})) ${comp.callJitErr(this)};`, type: "S" };
+  }
+  /**
+   * json encode a function
+   */
+  emitPrepareForJson() {
+    throw new Error(`Compile function PrepareForJson not supported, call compileParams or compileReturn instead.`);
+  }
+  emitRestoreFromJson() {
+    throw new Error(`Compile function RestoreFromJson not supported, call compileParams or compileReturn instead.`);
+  }
+  emitHasUnknownKeys() {
+    return { code: "", type: "E" };
+  }
+  emitUnknownKeyErrors() {
+    return { code: "", type: "S" };
+  }
+  emitStripUnknownKeys() {
+    return { code: "", type: "S" };
+  }
+  emitUnknownKeysToUndefined() {
+    return { code: "", type: "S" };
+  }
+  // TODO: paramsSlice has been removed as options are not jet passed when building the run type. maybe we can pass it to the JitCompileOperation instead
+  // constructor() {
+  //     const start = opts?.paramsSlice?.start;
+  //     const end = opts?.paramsSlice?.end;
+  //     parameterRunTypes = src.parameters.slice(start, end).map((p) => visitor(p, parents, opts)) as ParameterRunType[];
+  // }
+  getReturnType() {
+    return this.src.return._rt;
+  }
+  getParameters() {
+    return this.parameterRunTypes;
+  }
+  getParameterNames(opts) {
+    const start = opts?.paramsSlice?.start;
+    const end = opts?.paramsSlice?.end;
+    if (start || end) {
+      return this.src.parameters.slice(start, end).map(__assignType((p) => p.name, ["p", "", 'P"2!"/"']));
+    }
+    return this.src.parameters.map(__assignType((p) => p.name, ["p", "", 'P"2!"/"']));
+  }
+  hasReturnData() {
+    const returnKind = this.getReturnType().src.kind;
+    return returnKind !== ReflectionKind.void && returnKind !== ReflectionKind.never && returnKind !== ReflectionKind.undefined;
+  }
+  isAsync() {
+    const returnKind = this.getReturnType().src.kind;
+    return returnKind === ReflectionKind.promise || returnKind === ReflectionKind.any || returnKind === ReflectionKind.unknown;
+  }
+  returnIsPromise() {
+    return isPromiseRunType(this.getReturnType());
+  }
+  async mockReturn(ctx) {
+    await registerJitFunctionCompiler(JitFunctions.mock);
+    return this.getReturnType().mockType(ctx);
+  }
+  async mockParams(ctx) {
+    await registerJitFunctionCompiler(JitFunctions.mock);
+    return this.parameterRunTypes.mockType(ctx);
+  }
+  static __type = [() => ___TypeFunction, "CallType", () => BaseRunType, () => FunctionParamsRunType, "parameterRunTypes", function() {
+    return new FunctionParamsRunType();
+  }, () => JitFnCompiler, "comp", "skipJit", "SrcType", "deepkitType", "onCreated", "F", "getFamily", "getFnName", "JitFn", "jitFn", "RunTypeOptions", "opts", "args", "", "createJitParamsFunction", () => ___JitCompiledFn, "createJitCompiledParamsFunction", "createJitReturnFunction", () => ___JitCompiledFn, "createJitCompiledReturnFunction", () => JitFnCompiler, "JitCode", "emitIsType", () => JitErrorsFnCompiler, "emitTypeErrors", "emitPrepareForJson", "emitRestoreFromJson", "emitHasUnknownKeys", "emitUnknownKeyErrors", "emitStripUnknownKeys", "emitUnknownKeysToUndefined", () => BaseRunType, "getReturnType", () => FunctionParamsRunType, "getParameters", "getParameterNames", "hasReturnData", "isAsync", "returnIsPromise", "ctx", "mockReturn", "mockParams", "FunctionRunType", 'n!c"Pe"!7#P7$3%>&PP7\'2()0)P"w*2+$0,P.-0.PP&\'J0/P"w021"w2238P"@24"/506P"w021"w2238n708P"w021P"@24"/509P"w021"w2238n:0;PP7<2("w=0>PP7?2("w=0@P"w=0AP"w=0BP"w=0CP"w=0DP"w=0EP"w=0FPP7G0HPP7I0JP"w2238&F0KP)0LP)0MP)0NP"w22O8"`0PP"w22O8"F`0Q5e!!6"wR'];
+}
+export {
+  FunctionRunType
+};
+//# sourceMappingURL=function.js.map

package/.dist/esm/src/nodes/function/function.js.map

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

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

@@ -0,0 +1,24 @@
+import { Type, TypeArray } from '@deepkit/type';
+import { JitCode } from '../../types.ts';
+import { JitFnCompiler, JitErrorsFnCompiler } from '../../lib/jitFnCompiler.ts';
+import { MemberRunType } from '../../lib/baseRunTypes.ts';
+export declare class ArrayRunType<T extends Type = TypeArray> extends MemberRunType<T> {
+    startIndex(comp: JitFnCompiler): number;
+    getChildVarName(comp: JitFnCompiler): string;
+    getChildLiteral(comp: JitFnCompiler): string;
+    useArrayAccessor(): true;
+    isOptional(): 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): {
+        code: string | undefined;
+        type: 'S';
+    };
+    checkNonSkipTypes(comp: JitFnCompiler): void;
+}

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

@@ -0,0 +1,154 @@
+import { MemberRunType } from "../../lib/baseRunTypes.js";
+import { childIsExpression } from "../../lib/utils.js";
+class ArrayRunType extends MemberRunType {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  startIndex(comp) {
+    return 0;
+  }
+  getChildVarName(comp) {
+    return comp.getLocalVarName("i", this);
+  }
+  getChildLiteral(comp) {
+    return this.getChildVarName(comp);
+  }
+  useArrayAccessor() {
+    return true;
+  }
+  isOptional() {
+    return false;
+  }
+  // #### jit code ####
+  emitIsType(comp) {
+    this.checkNonSkipTypes(comp);
+    const resultVal = comp.getLocalVarName("res", this);
+    const index = this.getChildVarName(comp);
+    const child = this.getJitChild(comp);
+    const childJit = comp.compileIsType(child, "E");
+    if (!childJit?.code && comp.opts.noIsArrayCheck)
+      return { code: void 0, type: "E" };
+    if (!childJit?.code)
+      return { code: `Array.isArray(${comp.vλl})`, type: "E" };
+    const isArrayCheckCode = comp.opts.noIsArrayCheck ? "" : `if (!Array.isArray(${comp.vλl})) return false;`;
+    return {
+      code: `
+            ${isArrayCheckCode}
+            for (let ${index} = ${this.startIndex(comp)}; ${index} < ${comp.vλl}.length; ${index}++) {
+                const ${resultVal} = ${childJit.code};
+                if (!(${resultVal})) return false;
+            }
+            return true;
+        `,
+      type: "RB"
+    };
+  }
+  emitTypeErrors(comp) {
+    this.checkNonSkipTypes(comp);
+    const index = this.getChildVarName(comp);
+    const child = this.getJitChild(comp);
+    const childJit = comp.compileTypeErrors(child, "S");
+    if (!childJit?.code && comp.opts.noIsArrayCheck)
+      return { code: void 0, type: "E" };
+    if (!childJit?.code)
+      return { code: `if (!Array.isArray(${comp.vλl})) ${comp.callJitErr(this)};`, type: "S" };
+    const itemsCode = `for (let ${index} = ${this.startIndex(comp)}; ${index} < ${comp.vλl}.length; ${index}++) {${childJit.code}}`;
+    if (comp.opts.noIsArrayCheck)
+      return { code: itemsCode, type: "S" };
+    return {
+      code: `if (!Array.isArray(${comp.vλl})) {${comp.callJitErr(this)}} else {${itemsCode}}`,
+      type: "S"
+    };
+  }
+  emitPrepareForJson(comp) {
+    this.checkNonSkipTypes(comp);
+    const index = this.getChildVarName(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 || "";
+    return {
+      code: `for (let ${index} = ${this.startIndex(comp)}; ${index} < ${comp.vλl}.length; ${index}++) {${code}}`,
+      type: "S"
+    };
+  }
+  emitRestoreFromJson(comp) {
+    this.checkNonSkipTypes(comp);
+    const index = this.getChildVarName(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 || "";
+    return {
+      code: `for (let ${index} = ${this.startIndex(comp)}; ${index} < ${comp.vλl}.length; ${index}++) {${code}}`,
+      type: "S"
+    };
+  }
+  emitHasUnknownKeys(comp) {
+    this.checkNonSkipTypes(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: void 0, type: "E" };
+    const resultVal = comp.getLocalVarName("res", this);
+    const index = this.getChildVarName(comp);
+    return {
+      code: `
+            if (!Array.isArray(${comp.vλl})) return false;
+            for (let ${index} = ${this.startIndex(comp)}; ${index} < ${comp.vλl}.length; ${index}++) {
+                const ${resultVal} = ${childJit.code};
+                if (${resultVal}) return true;
+            }
+            return false;
+        `,
+      type: "RB"
+    };
+  }
+  emitUnknownKeyErrors(comp) {
+    this.checkNonSkipTypes(comp);
+    if (this.getMemberType().getFamily() === "A")
+      return { code: "", type: "E" };
+    const child = this.getJitChild(comp);
+    const childJit = comp.compileUnknownKeyErrors(child, "S");
+    return this.traverseCode(comp, childJit);
+  }
+  emitStripUnknownKeys(comp) {
+    this.checkNonSkipTypes(comp);
+    if (this.getMemberType().getFamily() === "A")
+      return { code: "", type: "E" };
+    const child = this.getJitChild(comp);
+    const childJit = comp.compileStripUnknownKeys(child, "S");
+    return this.traverseCode(comp, childJit);
+  }
+  emitUnknownKeysToUndefined(comp) {
+    this.checkNonSkipTypes(comp);
+    if (this.getMemberType().getFamily() === "A")
+      return { code: "", type: "E" };
+    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 index = this.getChildVarName(comp);
+    return {
+      code: `for (let ${index} = ${this.startIndex(comp)}; ${index} < ${comp.vλl}.length; ${index}++) {${childJit.code}}`,
+      type: "S"
+    };
+  }
+  checkNonSkipTypes(comp) {
+    const child = this.getMemberType();
+    if (child.skipJit(comp))
+      throw new Error(`Arrays can not have non serializable types, ie: Symbol[], Function[], etc.`);
+  }
+  static __type = ["TypeArray", "T", () => MemberRunType, "JitFnCompiler", "comp", "startIndex", "getChildVarName", "getChildLiteral", true, "useArrayAccessor", "isOptional", "JitCode", "emitIsType", "JitErrorsFnCompiler", "emitTypeErrors", "emitPrepareForJson", "emitRestoreFromJson", "emitHasUnknownKeys", "emitUnknownKeyErrors", "emitStripUnknownKeys", "emitUnknownKeysToUndefined", "childJit", "code", "S", "type", "traverseCode", "checkNonSkipTypes", "ArrayRunType", `"w!c"Pe"!7#P"w$2%'0&P"w$2%&0'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,01P"w$2%"w,02P"w.2%"w,03P"w$2%"w,04P"w$2%"w,05P"w$2%P"w,-J26PP&-J47.849M0:P"w$2%"0;5e!!6"w<`];
+}
+export {
+  ArrayRunType
+};
+//# sourceMappingURL=array.js.map

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

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

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

@@ -0,0 +1,40 @@
+import { __ΩTypeCallSignature as ___TypeCallSignature } from "@deepkit/type";
+import { __ΩRunTypeChildAccessor as ___RunTypeChildAccessor } from "../../types.js";
+import { getPropIndex } from "../../lib/utils.js";
+import { FunctionRunType } from "../function/function.js";
+function __assignType(fn, args) {
+  fn.__type = args;
+  return fn;
+}
+class CallSignatureRunType 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""/#']);
+  getChildVarName = () => "";
+  getChildLiteral = () => '""';
+  useArrayAccessor = () => false;
+  isOptional = () => false;
+  static __type = [() => ___TypeCallSignature, () => 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""/#']);
+  }, "getChildVarName", function() {
+    return () => "";
+  }, "getChildLiteral", function() {
+    return () => '""';
+  }, "useArrayAccessor", function() {
+    return () => false;
+  }, "isOptional", function() {
+    return () => false;
+  }, () => ___TypeCallSignature, () => ___RunTypeChildAccessor, "CallSignatureRunType", `Pn!7"!3#>$!3%>&!3'>(!3)>*!3+>,5n-6"n.x"w/`];
+}
+export {
+  CallSignatureRunType
+};
+//# sourceMappingURL=callSignature.js.map

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

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

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