@mionjs/run-types 0.8.0-alpha.0

package/.dist/esm/src/nodes/native/Iterable.d.ts

@@ -0,0 +1,18 @@
+import { JitCode } from '../../types.ts';
+import { ClassRunType } from '../collection/class.ts';
+import { JitFnCompiler, JitErrorsFnCompiler } from '../../lib/jitFnCompiler.ts';
+import { BaseRunType } from '../../lib/baseRunTypes.ts';
+export declare abstract class IterableRunType extends ClassRunType {
+    abstract children: BaseRunType[];
+    abstract constructorName: string;
+    getIndexVarName(comp: JitFnCompiler): string;
+    getChildRunTypes: () => BaseRunType[];
+    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;
+}

package/.dist/esm/src/nodes/native/Iterable.js

@@ -0,0 +1,135 @@
+import { ClassRunType } from "../collection/class.js";
+import { JitFnCompiler, JitErrorsFnCompiler } from "../../lib/jitFnCompiler.js";
+import { BaseRunType } from "../../lib/baseRunTypes.js";
+function __assignType(fn, args) {
+  fn.__type = args;
+  return fn;
+}
+class IterableRunType extends ClassRunType {
+  getIndexVarName(comp) {
+    return comp.getLocalVarName("e", this);
+  }
+  getChildRunTypes = __assignType(() => {
+    return this.children;
+  }, [() => BaseRunType, "", 'PP7!F/"']);
+  emitIsType(comp) {
+    const entry = this.getCustomVλl(comp)?.vλl || comp.vλl;
+    const childrenCode = this.getJitChildren(comp).map(__assignType((c) => `if (!(${comp.compileIsType(c, "E").code})) return false`, ["c", "", 'P"2!"/"'])).join(";");
+    return {
+      code: `
+            if (!(${comp.vλl} instanceof ${this.constructorName})) return false;
+            for (const ${entry} of ${comp.vλl}) {${childrenCode}} return true;
+        `,
+      type: "RB"
+    };
+  }
+  emitTypeErrors(comp) {
+    const entry = this.getCustomVλl(comp)?.vλl || comp.vλl;
+    const childrenCode = this.getJitChildren(comp).map(__assignType((c) => comp.compileTypeErrors(c, "S").code, ["c", "", 'P"2!"/"'])).join(";");
+    const index = this.getIndexVarName(comp);
+    return {
+      code: `
+            if (!(${comp.vλl} instanceof ${this.constructorName})){${comp.callJitErr(this)}}
+            else {let ${index} = 0;for (const ${entry} of ${comp.vλl}) {${childrenCode}; ${index}++}}
+        `,
+      type: "S"
+    };
+  }
+  emitPrepareForJson(comp) {
+    const entry = this.getCustomVλl(comp)?.vλl || comp.vλl;
+    const resName = comp.getLocalVarName("ml", this);
+    const childrenCode = this.getJitChildren(comp).map(__assignType((c) => comp.compilePrepareForJson(c, "S").code, ["c", "", 'P"2!"/"'])).filter(Boolean).join(";");
+    if (!childrenCode)
+      return { code: `${comp.vλl} = Array.from(${comp.vλl})`, type: "S" };
+    return {
+      code: `
+            const ${resName} = [];
+            for (let ${entry} of ${comp.vλl}) {${childrenCode} ${resName}.push(${entry})}
+            ${comp.vλl} = ${resName};
+        `,
+      type: "S"
+    };
+  }
+  emitRestoreFromJson(comp) {
+    const children = this.getJitChildren(comp);
+    if (!children.length)
+      return { code: `${comp.vλl} = new Map(${comp.vλl})`, type: "S" };
+    const index = this.getCustomVλl(comp)?.vλl || comp.vλl;
+    const childrenCode = children.map(__assignType((c) => comp.compileRestoreFromJson(c, "S").code, ["c", "", 'P"2!"/"'])).filter(Boolean).join(";");
+    if (!childrenCode)
+      return { code: `${comp.vλl} = new ${this.constructorName}(${comp.vλl})`, type: "S" };
+    return {
+      code: `
+            for (let ${index} = 0; ${index} < ${comp.vλl}.length; ${index}++) {${childrenCode}}
+            ${comp.vλl} = new ${this.constructorName}(${comp.vλl})
+        `,
+      type: "S"
+    };
+  }
+  // TODO: Implement the following methods, should just call same compile method for children, look into to array run type
+  emitHasUnknownKeys(comp) {
+    const childrenCode = this.getJitChildren(comp).map(__assignType((child) => {
+      const itemJit = comp.compileHasUnknownKeys(child, "E");
+      return itemJit?.code ? `if (${itemJit.code}) return true;` : "";
+    }, ["child", "", 'P"2!"/"'])).filter(Boolean).join("");
+    if (!childrenCode)
+      return { code: "return false", type: "RB" };
+    const entry = this.getCustomVλl(comp)?.vλl || comp.vλl;
+    return {
+      code: `
+            if (!(${comp.vλl} instanceof ${this.constructorName})) return false;
+            for (const ${entry} of ${comp.vλl}) {${childrenCode}} return false;
+        `,
+      type: "RB"
+    };
+  }
+  emitUnknownKeyErrors(comp) {
+    const childrenCode = this.getJitChildren(comp).map(__assignType((child) => comp.compileUnknownKeyErrors(child, "S").code, ["child", "", 'P"2!"/"'])).filter(Boolean).join(";");
+    if (!childrenCode)
+      return { code: void 0, type: "S" };
+    const entry = this.getCustomVλl(comp)?.vλl || comp.vλl;
+    const index = this.getIndexVarName(comp);
+    return {
+      code: `
+            if (!(${comp.vλl} instanceof ${this.constructorName})) return;
+            let ${index} = 0; for (const ${entry} of ${comp.vλl}) {${childrenCode}; ${index}++}
+        `,
+      type: "S"
+    };
+  }
+  emitStripUnknownKeys(comp) {
+    const childrenCode = this.getJitChildren(comp).map(__assignType((child) => comp.compileStripUnknownKeys(child, "S").code, ["child", "", 'P"2!"/"'])).filter(Boolean).join(";");
+    if (!childrenCode)
+      return { code: void 0, type: "S" };
+    const entry = this.getCustomVλl(comp)?.vλl || comp.vλl;
+    return {
+      code: `
+            if (!(${comp.vλl} instanceof ${this.constructorName})) return;
+            for (const ${entry} of ${comp.vλl}) {${childrenCode}}
+        `,
+      type: "S"
+    };
+  }
+  emitUnknownKeysToUndefined(comp) {
+    const childrenCode = this.getJitChildren(comp).map(__assignType((child) => comp.compileUnknownKeysToUndefined(child, "S").code, ["child", "", 'P"2!"/"'])).filter(Boolean).join(";");
+    if (!childrenCode)
+      return { code: void 0, type: "S" };
+    const entry = this.getCustomVλl(comp)?.vλl || comp.vλl;
+    return {
+      code: `
+            if (!(${comp.vλl} instanceof ${this.constructorName})) return;
+            for (const ${entry} of ${comp.vλl}) {${childrenCode}}
+        `,
+      type: "S"
+    };
+  }
+  static __type = [() => ClassRunType, () => BaseRunType, "children", "constructorName", () => JitFnCompiler, "comp", "getIndexVarName", "getChildRunTypes", function() {
+    return __assignType(() => {
+      return this.children;
+    }, [() => BaseRunType, "", 'PP7!F/"']);
+  }, () => JitFnCompiler, "JitCode", "emitIsType", () => JitErrorsFnCompiler, "emitTypeErrors", () => JitFnCompiler, "emitPrepareForJson", () => JitFnCompiler, "emitRestoreFromJson", () => JitFnCompiler, "emitHasUnknownKeys", () => JitErrorsFnCompiler, "emitUnknownKeyErrors", () => JitFnCompiler, "emitStripUnknownKeys", () => JitFnCompiler, "emitUnknownKeysToUndefined", "IterableRunType", `P7!P7"F3#=&3$=PP7%2&&0'!3(>)PP7*2&"w+0,PP7-2&"w+0.PP7/2&"w+00PP712&"w+02PP732&"w+04PP752&"w+06PP772&"w+08PP792&"w+0:5w;`];
+}
+export {
+  IterableRunType
+};
+//# sourceMappingURL=Iterable.js.map

package/.dist/esm/src/nodes/native/Iterable.js.map

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

package/.dist/esm/src/nodes/native/map.d.ts

@@ -0,0 +1,42 @@
+import { SrcType } from '../../types.ts';
+import { GenericMemberRunType } from '../member/genericMember.ts';
+import { TypeClass } from '@deepkit/type';
+import { IterableRunType } from './Iterable.ts';
+import { JitFnCompiler } from '../../lib/jitFnCompiler.ts';
+export declare class MapRunType extends IterableRunType {
+    keyRT: MapKeyRunType;
+    valueRT: MapValueRunType;
+    children: (MapKeyRunType | MapValueRunType)[];
+    constructorName: string;
+    onCreated(src: SrcType<TypeClass>): void;
+    getCustomVλl(comp: JitFnCompiler): {
+        vλl: string;
+        isStandalone: boolean;
+        useArrayAccessor: boolean;
+    } | {
+        vλl: string;
+        isStandalone: boolean;
+        useArrayAccessor?: undefined;
+    };
+    getMapKeyVλl(comp: JitFnCompiler): string;
+    getMapValueVλl(comp: JitFnCompiler): string;
+}
+declare class MapKeyRunType extends GenericMemberRunType<any> {
+    index: number;
+    getStaticPathLiteral(comp: JitFnCompiler): string | number;
+    getCustomVλl(comp: JitFnCompiler): {
+        vλl: string;
+        isStandalone: boolean;
+        useArrayAccessor: boolean;
+    } | undefined;
+}
+declare class MapValueRunType extends GenericMemberRunType<any> {
+    index: number;
+    getStaticPathLiteral(comp: JitFnCompiler): string | number;
+    getCustomVλl(comp: JitFnCompiler): {
+        vλl: string;
+        isStandalone: boolean;
+        useArrayAccessor: boolean;
+    } | undefined;
+}
+export {};

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

@@ -0,0 +1,96 @@
+import { GenericMemberRunType } from "../member/genericMember.js";
+import { ReflectionSubKind } from "../../constants.kind.js";
+import { ReflectionKind } from "@deepkit/type";
+import { IterableRunType } from "./Iterable.js";
+import { JitFunctions } from "../../constants.functions.js";
+import { cpf_safeIterableKey } from "../../run-types-pure-fns.js";
+class MapRunType extends IterableRunType {
+  keyRT = new MapKeyRunType();
+  valueRT = new MapValueRunType();
+  children = [this.keyRT, this.valueRT];
+  constructorName = "Map";
+  onCreated(src) {
+    const types = src.arguments;
+    if (!types || types.length !== 2)
+      throw new Error(`Map expects 2 type arguments: ie: Map<string, number>`);
+    super.onCreated(src);
+    this.keyRT.onCreated({
+      kind: ReflectionKind.parameter,
+      parent: src,
+      type: types[0],
+      subKind: ReflectionSubKind.mapKey
+    });
+    this.valueRT.onCreated({
+      kind: ReflectionKind.parameter,
+      parent: src,
+      type: types[1],
+      subKind: ReflectionSubKind.mapValue
+    });
+  }
+  getCustomVλl(comp) {
+    if (comp.fnID === JitFunctions.restoreFromJson.id)
+      return { vλl: comp.getLocalVarName("it", this), isStandalone: false, useArrayAccessor: true };
+    return { vλl: comp.getLocalVarName("it", this), isStandalone: true };
+  }
+  getMapKeyVλl(comp) {
+    return comp.getLocalVarName("mpk", this);
+  }
+  getMapValueVλl(comp) {
+    return comp.getLocalVarName("mpV", this);
+  }
+  static __type = [() => IterableRunType, "keyRT", function() {
+    return new MapKeyRunType();
+  }, "valueRT", function() {
+    return new MapValueRunType();
+  }, "children", function() {
+    return [this.keyRT, this.valueRT];
+  }, "constructorName", function() {
+    return "Map";
+  }, "SrcType", "src", "onCreated", "JitFnCompiler", "comp", "getCustomVλl", "getMapKeyVλl", "getMapValueVλl", "MapRunType", `P7!!3">#!3$>%!3&>'&3(>)P"w*2+$0,P"w-2."0/P"w-2."00P"w-2."015w2`];
+}
+class MapKeyRunType extends GenericMemberRunType {
+  index = 0;
+  getStaticPathLiteral(comp) {
+    const parent = this.getParent();
+    const custom = parent.getCustomVλl(comp);
+    const safeKeyFn = comp.addPureFunction(cpf_safeIterableKey);
+    return `{key:${safeKeyFn}(${custom.vλl}[0]),index:${parent.getIndexVarName(comp)},failed:'mapKey'}`;
+  }
+  getCustomVλl(comp) {
+    if (comp.fnID === JitFunctions.fromBinary.id)
+      return {
+        vλl: this.getParent().getMapKeyVλl(comp),
+        isStandalone: true,
+        useArrayAccessor: false
+      };
+    return void 0;
+  }
+  static __type = [() => GenericMemberRunType, "index", function() {
+    return 0;
+  }, "JitFnCompiler", "comp", "getStaticPathLiteral", "getCustomVλl", "MapKeyRunType", `P"7!'3">#P"w$2%P&'J0&P"w$2%"0'5"6"w(`];
+}
+class MapValueRunType extends GenericMemberRunType {
+  index = 1;
+  getStaticPathLiteral(comp) {
+    const parent = this.getParent();
+    const custom = parent.getCustomVλl(comp);
+    const safeKeyFn = comp.addPureFunction(cpf_safeIterableKey);
+    return `{key:${safeKeyFn}(${custom.vλl}[0]),index:${parent.getIndexVarName(comp)},failed:'mapVal'}`;
+  }
+  getCustomVλl(comp) {
+    if (comp.fnID === JitFunctions.fromBinary.id)
+      return {
+        vλl: this.getParent().getMapValueVλl(comp),
+        isStandalone: true,
+        useArrayAccessor: false
+      };
+    return void 0;
+  }
+  static __type = [() => GenericMemberRunType, "index", function() {
+    return 1;
+  }, "JitFnCompiler", "comp", "getStaticPathLiteral", "getCustomVλl", "MapValueRunType", `P"7!'3">#P"w$2%P&'J0&P"w$2%"0'5"6"w(`];
+}
+export {
+  MapRunType
+};
+//# sourceMappingURL=map.js.map

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

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

package/.dist/esm/src/nodes/native/nonSerializable.d.ts

@@ -0,0 +1,14 @@
+import { TypeClass, TypeObjectLiteral } from '@deepkit/type';
+import { JitCode } from '../../types.ts';
+import { InterfaceRunType } from '../collection/interface.ts';
+export declare class NonSerializableRunType extends InterfaceRunType<TypeObjectLiteral | TypeClass> {
+    skipJit(): boolean;
+    emitIsType(): JitCode;
+    emitTypeErrors(): JitCode;
+    emitPrepareForJson(): JitCode;
+    emitRestoreFromJson(): JitCode;
+    emitHasUnknownKeys(): JitCode;
+    emitUnknownKeyErrors(): JitCode;
+    emitStripUnknownKeys(): JitCode;
+    emitUnknownKeysToUndefined(): JitCode;
+}

package/.dist/esm/src/nodes/native/nonSerializable.js

@@ -0,0 +1,36 @@
+import { __ΩJitCode as ___JitCode } from "../../types.js";
+import { InterfaceRunType } from "../collection/interface.js";
+class NonSerializableRunType extends InterfaceRunType {
+  skipJit() {
+    return false;
+  }
+  emitIsType() {
+    throw new Error(`Jit compilation disabled for Non Serializable types.`);
+  }
+  emitTypeErrors() {
+    throw new Error(`Jit compilation disabled for Non Serializable types.`);
+  }
+  emitPrepareForJson() {
+    throw new Error(`Jit compilation disabled for Non Serializable types.`);
+  }
+  emitRestoreFromJson() {
+    throw new Error(`Jit compilation disabled for Non Serializable types.`);
+  }
+  emitHasUnknownKeys() {
+    throw new Error(`Jit compilation disabled for Non Serializable types.`);
+  }
+  emitUnknownKeyErrors() {
+    throw new Error(`Jit compilation disabled for Non Serializable types.`);
+  }
+  emitStripUnknownKeys() {
+    throw new Error(`Jit compilation disabled for Non Serializable types.`);
+  }
+  emitUnknownKeysToUndefined() {
+    throw new Error(`Jit compilation disabled for Non Serializable types.`);
+  }
+  static __type = ["TypeObjectLiteral", "TypeClass", () => InterfaceRunType, "skipJit", () => ___JitCode, "emitIsType", () => ___JitCode, "emitTypeErrors", () => ___JitCode, "emitPrepareForJson", () => ___JitCode, "emitRestoreFromJson", () => ___JitCode, "emitHasUnknownKeys", () => ___JitCode, "emitUnknownKeyErrors", () => ___JitCode, "emitStripUnknownKeys", () => ___JitCode, "emitUnknownKeysToUndefined", "NonSerializableRunType", `PP"w!"w"J7#P"0$Pn%0&Pn'0(Pn)0*Pn+0,Pn-0.Pn/00Pn102Pn3045P"w!"w"J6"w5`];
+}
+export {
+  NonSerializableRunType
+};
+//# sourceMappingURL=nonSerializable.js.map

package/.dist/esm/src/nodes/native/nonSerializable.js.map

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

package/.dist/esm/src/nodes/native/promise.d.ts

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

package/.dist/esm/src/nodes/native/promise.js

@@ -0,0 +1,38 @@
+import { MemberRunType } from "../../lib/baseRunTypes.js";
+import { JitFunctions } from "../../constants.functions.js";
+class PromiseRunType extends MemberRunType {
+  skipJit(comp) {
+    return comp?.fnID !== JitFunctions.toJSCode.id;
+  }
+  emitIsType() {
+    throw new Error(`Jit compilation disabled for Non Serializable types.`);
+  }
+  emitTypeErrors() {
+    throw new Error(`Jit compilation disabled for Non Serializable types.`);
+  }
+  emitPrepareForJson() {
+    throw new Error(`Jit compilation disabled for Non Serializable types.`);
+  }
+  emitRestoreFromJson() {
+    throw new Error(`Jit compilation disabled for Non Serializable types.`);
+  }
+  isOptional() {
+    return false;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getChildVarName(comp) {
+    return comp.getLocalVarName("p", this);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getChildLiteral(comp) {
+    return this.getChildVarName(comp);
+  }
+  useArrayAccessor() {
+    return false;
+  }
+  static __type = ["TypePromise", () => MemberRunType, "JitFnCompiler", "comp", "skipJit", "JitCode", "emitIsType", "emitTypeErrors", "emitPrepareForJson", "emitRestoreFromJson", "isOptional", "getChildVarName", "getChildLiteral", "useArrayAccessor", "PromiseRunType", `P"w!7"P"w#2$)0%P"w&0'P"w&0(P"w&0)P"w&0*P)0+P"w#2$P&'J0,P"w#2$P&'J0-P)0.5"w!6"w/`];
+}
+export {
+  PromiseRunType
+};
+//# sourceMappingURL=promise.js.map

package/.dist/esm/src/nodes/native/promise.js.map

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

package/.dist/esm/src/nodes/native/set.d.ts

@@ -0,0 +1,30 @@
+import { SrcType } from '../../types.ts';
+import { TypeClass } from '@deepkit/type';
+import { GenericMemberRunType } from '../member/genericMember.ts';
+import { IterableRunType } from './Iterable.ts';
+import { JitFnCompiler } from '../../lib/jitFnCompiler.ts';
+export declare class SetRunType extends IterableRunType {
+    keyRT: SetKeyRunType;
+    children: SetKeyRunType[];
+    constructorName: string;
+    onCreated(src: SrcType<TypeClass>): void;
+    getCustomVλl(comp: JitFnCompiler): {
+        vλl: string;
+        isStandalone: boolean;
+        useArrayAccessor: boolean;
+    } | {
+        vλl: string;
+        isStandalone: boolean;
+        useArrayAccessor?: undefined;
+    };
+}
+export declare class SetKeyRunType extends GenericMemberRunType<any> {
+    index: number;
+    skipSettingAccessor(): boolean;
+    getStaticPathLiteral(comp: JitFnCompiler): string;
+    getCustomVλl(comp: JitFnCompiler): {
+        vλl: string;
+        isStandalone: boolean;
+        useArrayAccessor: boolean;
+    } | undefined;
+}

package/.dist/esm/src/nodes/native/set.js

@@ -0,0 +1,60 @@
+import { ReflectionSubKind } from "../../constants.kind.js";
+import { ReflectionKind } from "@deepkit/type";
+import { GenericMemberRunType } from "../member/genericMember.js";
+import { IterableRunType } from "./Iterable.js";
+import { JitFunctions } from "../../constants.functions.js";
+import { cpf_safeIterableKey } from "../../run-types-pure-fns.js";
+class SetRunType extends IterableRunType {
+  keyRT = new SetKeyRunType();
+  children = [this.keyRT];
+  constructorName = "Set";
+  onCreated(src) {
+    const types = src.arguments;
+    if (!types || types.length !== 1)
+      throw new Error(`Set expects 1 type argument: ie: Set<number>`);
+    super.onCreated(src);
+    this.keyRT.onCreated({
+      kind: ReflectionKind.parameter,
+      parent: src,
+      type: types[0],
+      subKind: ReflectionSubKind.setItem
+    });
+  }
+  getCustomVλl(comp) {
+    if (comp.fnID === JitFunctions.restoreFromJson.id)
+      return { vλl: comp.getLocalVarName("it", this), isStandalone: false, useArrayAccessor: true };
+    return { vλl: comp.getLocalVarName("it", this), isStandalone: true };
+  }
+  static __type = [() => IterableRunType, "keyRT", function() {
+    return new SetKeyRunType();
+  }, "children", function() {
+    return [this.keyRT];
+  }, "constructorName", function() {
+    return "Set";
+  }, "SrcType", "src", "onCreated", "JitFnCompiler", "comp", "getCustomVλl", "SetRunType", `P7!!3">#!3$>%&3&>'P"w(2)$0*P"w+2,"0-5w.`];
+}
+class SetKeyRunType extends GenericMemberRunType {
+  index = 0;
+  skipSettingAccessor() {
+    return true;
+  }
+  getStaticPathLiteral(comp) {
+    const parent = this.getParent();
+    const custom = parent.getCustomVλl(comp);
+    const safeKeyFn = comp.addPureFunction(cpf_safeIterableKey);
+    return `{key:${safeKeyFn}(${custom.vλl}),index:${parent.getIndexVarName(comp)}}`;
+  }
+  getCustomVλl(comp) {
+    if (comp.fnID === JitFunctions.fromBinary.id)
+      return { vλl: comp.getLocalVarName("sK", this), isStandalone: true, useArrayAccessor: false };
+    return void 0;
+  }
+  static __type = [() => GenericMemberRunType, "index", function() {
+    return 0;
+  }, "skipSettingAccessor", "JitFnCompiler", "comp", "getStaticPathLiteral", "getCustomVλl", "SetKeyRunType", `P"7!'3">#P"0$P"w%2&&0'P"w%2&"0(5"6"w)`];
+}
+export {
+  SetKeyRunType,
+  SetRunType
+};
+//# sourceMappingURL=set.js.map

package/.dist/esm/src/nodes/native/set.js.map

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

package/.dist/esm/src/run-types-pure-fns.d.ts

@@ -0,0 +1,7 @@
+export declare const cpf_asJSONString: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_getUnknownKeysFromArray: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_hasUnknownKeysFromArray: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_newRunTypeErr: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_formatErr: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_safeIterableKey: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_sanitizeCompiledFn: import('@mionjs/core').CompiledPureFunction;

package/.dist/esm/src/run-types-pure-fns.js

@@ -0,0 +1,112 @@
+import { registerPureFnFactory } from "@mionjs/core";
+const __ΩRecord = ["K", "T", "Record", `l'e#"Rb!b"Pde"!N#!w#y`];
+function __assignType(fn, args) {
+  fn.__type = args;
+  return fn;
+}
+const cpf_asJSONString = registerPureFnFactory("mion", "asJSONString", function() {
+  if (typeof Bun !== "undefined")
+    return JSON.stringify;
+  const STR_ESCAPE = /[\u0000-\u001f\u0022\u005c\ud800-\udfff]/;
+  const MAX_SCAPE_TEST_LENGTH = 1e3;
+  return __assignType(function _asJSONStringRegexOnly(str) {
+    if (str.length < MAX_SCAPE_TEST_LENGTH && STR_ESCAPE.test(str) === false) {
+      return '"' + str + '"';
+    } else {
+      return JSON.stringify(str);
+    }
+  }, ["str", "_asJSONStringRegexOnly", 'P"2!"/"']);
+}, { bodyHash: "4WYkR03dXOzAUe", paramNames: [], code: `if (typeof Bun !== "undefined") return JSON.stringify;
+  const STR_ESCAPE = /[\\u0000-\\u001f\\u0022\\u005c\\ud800-\\udfff]/;
+  const MAX_SCAPE_TEST_LENGTH = 1e3;
+  return function _asJSONStringRegexOnly(str) {
+    if (str.length < MAX_SCAPE_TEST_LENGTH && STR_ESCAPE.test(str) === false) {
+      return '"' + str + '"';
+    } else {
+      return JSON.stringify(str);
+    }
+  };` });
+const cpf_getUnknownKeysFromArray = registerPureFnFactory("mion", "getUnknownKeysFromArray", function() {
+  const MAX_UNKNOWN_KEYS = 10;
+  return __assignType(function _getUnknownKeysFromArray(obj, keys) {
+    const unknownKeys = [];
+    for (const prop in obj) {
+      let found = false;
+      for (let j = 0; j < keys.length; j++) {
+        if (keys[j] === prop) {
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        unknownKeys.push(prop);
+        if (unknownKeys.length >= MAX_UNKNOWN_KEYS)
+          throw new Error("Too many unknown keys");
+      }
+    }
+    return unknownKeys;
+  }, [() => __ΩRecord, "StrNumber", "obj", "keys", "_getUnknownKeysFromArray", 'P"w""o!#2#"w"F2$"w"F/%']);
+}, { bodyHash: "D2CDXI8OoGLGyW", paramNames: [], code: 'const MAX_UNKNOWN_KEYS = 10;\n  return function _getUnknownKeysFromArray(obj, keys) {\n    const unknownKeys = [];\n    for (const prop in obj) {\n      let found = false;\n      for (let j = 0; j < keys.length; j++) {\n        if (keys[j] === prop) {\n          found = true;\n          break;\n        }\n      }\n      if (!found) {\n        unknownKeys.push(prop);\n        if (unknownKeys.length >= MAX_UNKNOWN_KEYS) throw new Error("Too many unknown keys");\n      }\n    }\n    return unknownKeys;\n  };' });
+const cpf_hasUnknownKeysFromArray = registerPureFnFactory("mion", "hasUnknownKeysFromArray", function() {
+  return __assignType(function _hasUnknownKeysFromArray(obj, keys) {
+    for (const prop in obj) {
+      let found = false;
+      for (let j = 0; j < keys.length; j++) {
+        if (keys[j] === prop) {
+          found = true;
+          break;
+        }
+      }
+      if (!found)
+        return true;
+    }
+    return false;
+  }, [() => __ΩRecord, "StrNumber", "obj", "keys", "_hasUnknownKeysFromArray", 'P"w""o!#2#"w"F2$)/%']);
+}, { bodyHash: "K7uzDGNnPwcqQ9", paramNames: [], code: "return function _hasUnknownKeysFromArray(obj, keys) {\n    for (const prop in obj) {\n      let found = false;\n      for (let j = 0; j < keys.length; j++) {\n        if (keys[j] === prop) {\n          found = true;\n          break;\n        }\n      }\n      if (!found) return true;\n    }\n    return false;\n  };" });
+const cpf_newRunTypeErr = registerPureFnFactory("mion", "newRunTypeErr", function() {
+  return __assignType(function _err(pλth, εrr, expected, accessPath) {
+    const path = accessPath?.length ? [...pλth, ...accessPath] : [...pλth];
+    const runTypeErr = { expected, path };
+    εrr.push(runTypeErr);
+  }, ["StrNumber", "pλth", "RunTypeError", "εrr", "expected", "accessPath", "_err", `P"w!F92""w#F2$&2%"w!F92&8$/'`]);
+}, { bodyHash: "eCwDrS1nuSv7ge", paramNames: [], code: "return function _err(p\\u03BBth, \\u03B5rr, expected, accessPath) {\n    const path = accessPath?.length ? [...p\\u03BBth, ...accessPath] : [...p\\u03BBth];\n    const runTypeErr = { expected, path };\n    \\u03B5rr.push(runTypeErr);\n  };" });
+const cpf_formatErr = registerPureFnFactory("mion", "formatErr", function() {
+  return __assignType(function _formatErr(pλth, εrr, expected, fmtName, paramName, paramVal, fmtPath, accessPath, fmtAccessPath) {
+    const path = accessPath?.length ? [...pλth, ...accessPath] : [...pλth];
+    const formatPath = fmtAccessPath?.length ? [...fmtPath, ...fmtAccessPath, paramName] : [...fmtPath, paramName];
+    const format = { name: fmtName, formatPath, val: paramVal };
+    const runTypeErr = { expected, path, format };
+    εrr.push(runTypeErr);
+  }, ["StrNumber", "pλth", "RunTypeError", "εrr", "expected", "fmtName", "paramName", "paramVal", "fmtPath", "accessPath", "fmtAccessPath", "_formatErr", `P"w!F2""w#F2$&2%&2&&2'P&')*J2("w!F2)"w!F2*8"w!F2+8$/,`]);
+}, { bodyHash: "2isPiuLWPtohVR", paramNames: [], code: "return function _formatErr(p\\u03BBth, \\u03B5rr, expected, fmtName, paramName, paramVal, fmtPath, accessPath, fmtAccessPath) {\n    const path = accessPath?.length ? [...p\\u03BBth, ...accessPath] : [...p\\u03BBth];\n    const formatPath = fmtAccessPath?.length ? [...fmtPath, ...fmtAccessPath, paramName] : [...fmtPath, paramName];\n    const format = { name: fmtName, formatPath, val: paramVal };\n    const runTypeErr = { expected, path, format };\n    \\u03B5rr.push(runTypeErr);\n  };" });
+const cpf_safeIterableKey = registerPureFnFactory("mion", "safeIterableKey", function() {
+  return __assignType(function _safeKey(value) {
+    if (value === void 0)
+      return null;
+    if (value === null)
+      return null;
+    const type = typeof value;
+    if (type === "number" || type === "string" || type === "boolean")
+      return value;
+    return null;
+  }, ["value", "_safeKey", 'P"2!"/"']);
+}, { bodyHash: "BrjL47E-GRjUpQ", paramNames: [], code: 'return function _safeKey(value) {\n    if (value === void 0) return null;\n    if (value === null) return null;\n    const type = typeof value;\n    if (type === "number" || type === "string" || type === "boolean") return value;\n    return null;\n  };' });
+const cpf_sanitizeCompiledFn = registerPureFnFactory("mion", "sanitizeCompiledFn", function() {
+  const anonymousRegex = /^\s*function\s+anonymous\s*\(/;
+  return function sanitizeCompiled(fnCode) {
+    if (anonymousRegex.test(fnCode)) {
+      return fnCode.replace(anonymousRegex, "function (");
+    }
+    return fnCode;
+  };
+}, { bodyHash: "UjTRflEOSgqLPC", paramNames: [], code: 'const anonymousRegex = /^\\s*function\\s+anonymous\\s*\\(/;\n  return function sanitizeCompiled(fnCode) {\n    if (anonymousRegex.test(fnCode)) {\n      return fnCode.replace(anonymousRegex, "function (");\n    }\n    return fnCode;\n  };' });
+export {
+  cpf_asJSONString,
+  cpf_formatErr,
+  cpf_getUnknownKeysFromArray,
+  cpf_hasUnknownKeysFromArray,
+  cpf_newRunTypeErr,
+  cpf_safeIterableKey,
+  cpf_sanitizeCompiledFn
+};
+//# sourceMappingURL=run-types-pure-fns.js.map

package/.dist/esm/src/run-types-pure-fns.js.map

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