@mionjs/run-types 0.8.0-alpha.0

package/.dist/esm/src/lib/jitFnCompiler.js

@@ -0,0 +1,648 @@
+import { getJitUtils, MAX_STACK_DEPTH, quickHash } from "@mionjs/core";
+import { getReflectionName } from "../constants.kind.js";
+import { maxStackErrorMessage, JIT_STACK_TRACE_MESSAGE } from "../constants.js";
+import { JitFunctions, CodeTypes, jitErrorArgs } from "../constants.functions.js";
+import { getJITFnName, getJitFnSettings } from "./jitFnsRegistry.js";
+import { isJitErrorsCompiler, isChildAccessorType, isFunctionParamsRunType } from "./guards.js";
+import { getJitFnArgCallVarName, toLiteral, addFullStop, toLiteralInContext } from "./utils.js";
+import { getRunTypeFormat } from "./formats.js";
+import { emitJsonStringify } from "../jitCompilers/json/stringifyJson.js";
+import { emitToBinary } from "../jitCompilers/binary/toBinary.js";
+import { emitFromBinary } from "../jitCompilers/binary/fromBinary.js";
+import { emitToCode } from "../jitCompilers/json/toJsCode.js";
+import { getJITFnHash, createJitFunction } from "./createJitFunction.js";
+import { cpf_newRunTypeErr, cpf_formatErr } from "../run-types-pure-fns.js";
+const RB = CodeTypes.returnBlock;
+const S = CodeTypes.statement;
+const E = CodeTypes.expression;
+class BaseFnCompiler {
+  constructor(rootType, fnID, jitFnSettings, parentCompiler, jitFnHash, typeID, opts = {}) {
+    this.rootType = rootType;
+    this.fnID = fnID;
+    this.parentCompiler = parentCompiler;
+    this.opts = opts;
+    this.typeName = this.rootType.getTypeName();
+    this.jitFnHash = jitFnHash || getJITFnHash(this.fnID, this.rootType, opts);
+    this.typeID = typeID || this.rootType.getTypeID();
+    this.args = { ...jitFnSettings.jitArgs };
+    this.defaultParamValues = { ...jitFnSettings.jitDefaultArgs };
+    this.returnName = jitFnSettings.returnName;
+    if (this.args.vλl) this.vλl = this.args.vλl;
+    getJitUtils().addToJitCache(this);
+    validateCompilerOptions(opts);
+  }
+  // !!! DO NOT MODIFY METHOD WITHOUT REVIEWING JIT CODE INVOCATIONS!!!
+  /** The Jit Generated function once the compilation is finished */
+  fn;
+  createJitFn;
+  isCompiled = false;
+  typeName;
+  typeID;
+  jitFnHash;
+  args;
+  defaultParamValues;
+  returnName;
+  /** Alternative arguments to use when calling a child function */
+  childrenCallArgs = {};
+  /** Code for the jit function. after the operation has been compiled */
+  code = "";
+  /** Code for the context function enclosing the jit function.
+   * This can be used to initialize constant or some other things that will be required across all invocation.
+   * By default this contains constants for the direct dependencies of the jit function.
+   * */
+  contextCodeItems = /* @__PURE__ */ new Map();
+  /**
+   * This flag is set to true when the result of a jit compilation is a no operation (empty function).
+   * Some jit compiled functions could execute no operations (ie: string, boolean and numbers does not require prepareForJson/restoreFromJson)
+   */
+  isNoop = false;
+  /** The list of all jit functions that are used by this function and it's children. */
+  jitDependencies = [];
+  pureFnDependencies = [];
+  /** The list of types being compiled.*/
+  stack = [];
+  popItem;
+  /** shorthand for  this.length */
+  get length() {
+    return this.stack.length;
+  }
+  get totalLength() {
+    if (this.parentCompiler) return this.stack.length + this.parentCompiler.totalLength;
+    return this.stack.length;
+  }
+  /** The variable name for the current item in the stack. */
+  vλl = "";
+  getNestLevel(rt) {
+    let index = -1;
+    this.stack.forEach((item, i) => {
+      if (item.rt === rt) index = i;
+      if (item.rt.src.id && item.rt.src.id === rt.src.id) index = i;
+    });
+    if (index !== -1) return index;
+    const fromParent = this.parentCompiler?.getNestLevel(rt);
+    if (fromParent && fromParent !== -1) return fromParent;
+    return -1;
+  }
+  varNameindex = /* @__PURE__ */ new Map();
+  getLocalVarName(prefix, rt) {
+    const key = rt.src.id || rt;
+    const index = this.varNameindex.get(key);
+    if (index !== void 0) return `${prefix}${index}`;
+    const newIndex = this.varNameindex.size;
+    this.varNameindex.set(key, newIndex);
+    return `${prefix}${newIndex}`;
+  }
+  /**
+   * The path to the current item in the stack,
+   * This path can contain prop names array indexes or event literal variable values, ie: if parsing an array the path item would be the name if the index variable.
+   * This is used to generate the correct code to access the value at runtime of the current item in the stack.
+   * ie: if parsing the tuple ['A','B','C'] and the current item is 'B', the path would [1] as is the index of the item in the stack.
+   * ie: if parsing the object {a: {b: {c: 'C'}}} and the current item is 'b', the path would ['a','b'] as is the path to the item in the stack.
+   * At runtime this path gets combined with the runtime pλth variable to generate the correct path to access the value
+   * */
+  _accessPathLiterals = [];
+  /** push new item to the stack, returns true if new child is already in the stack (is circular type) */
+  pushStack(newChild) {
+    const totalLength = this.stack.length + this.totalLength;
+    if (totalLength > MAX_STACK_DEPTH) throw new Error(maxStackErrorMessage);
+    if (this.stack.length === 0) {
+      if (newChild !== this.rootType) throw new Error("rootType should be the first item in the stack");
+      newChild.getTypeID();
+    }
+    this.vλl = getStackVλl(this);
+    if (isJitErrorsCompiler(this)) this._accessPathLiterals = getAccessPath(this);
+    const newStackItem = { vλl: this.vλl, rt: newChild, staticPath: this._accessPathLiterals };
+    this.stack.push(newStackItem);
+  }
+  popStack(resultCode) {
+    if (resultCode?.code) this.code = resultCode.code;
+    this.popItem = this.stack.pop();
+    const item = this.stack[this.stack.length - 1];
+    this.vλl = item?.vλl || this.args.vλl;
+    if (isJitErrorsCompiler(this)) this._accessPathLiterals = item?.staticPath || [];
+  }
+  siplePushStack(newChild) {
+    const newStackItem = { vλl: this.vλl, rt: newChild, staticPath: this._accessPathLiterals };
+    this.stack.push(newStackItem);
+  }
+  simplePopStack() {
+    this.popItem = this.stack.pop();
+  }
+  createJitFunction(overrideCode) {
+    try {
+      if (overrideCode) {
+        this.code = overrideCode;
+        this.isCompiled = false;
+      }
+      this.handleFunctionReturn();
+      return createJitFunction(this);
+    } catch (e) {
+      const fnName = getJITFnName(this.fnID);
+      const fnCode = ` Code:
+function ${fnName}(){${this.code}}`;
+      const name = `(${this.rootType.getTypeName()}:${this.rootType.getTypeID()})`;
+      const typeString = `Type: ${this.rootType.stringify()}`;
+      throw new Error(`Error building ${fnName} JIT function for type ${name}: ${e?.message} 
+${typeString} 
+${fnCode}`);
+    }
+  }
+  /** Returns a copy of the access pat for current stack item */
+  getAccessPath() {
+    return [...this._accessPathLiterals];
+  }
+  getAccessPathArgs() {
+    return this._accessPathLiterals.join(",");
+  }
+  getAccessPathLength() {
+    return this._accessPathLiterals.length;
+  }
+  getAccessPathArgsForFnCall() {
+    return { args: this.getAccessPathArgs(), length: this.getAccessPathLength() };
+  }
+  getCurrentStackItem() {
+    const item = this.stack[this.stack.length - 1];
+    if (!item) throw new Error("Compiler stack is empty, no current item");
+    return item;
+  }
+  getChildVλl() {
+    const parent = this.getCurrentStackItem();
+    if (!parent) return this.args.vλl;
+    const rt = parent.rt;
+    if (!isChildAccessorType(rt)) throw new Error(`cant get child var name from ${rt.getKindName()}`);
+    if (rt.skipSettingAccessor?.()) return parent.vλl;
+    return parent.vλl + (rt.useArrayAccessor() ? `[${rt.getChildLiteral(this)}]` : `.${rt.getChildVarName(this)}`);
+  }
+  shouldCallDependency() {
+    const stackItem = this.getCurrentStackItem();
+    return !stackItem.rt.isJitInlined() && this.stack.length > 1;
+  }
+  updateDependencies(childComp) {
+    if (childComp.isNoop) return;
+    if (this.jitDependencies.includes(childComp.jitFnHash)) return;
+    this.jitDependencies.push(childComp.jitFnHash);
+  }
+  removeFromJitCache() {
+    getJitUtils().removeFromJitCache(this);
+  }
+  getStackTrace() {
+    const separator = ".";
+    const parentTrace = this.parentCompiler ? this.parentCompiler.getStackTrace() + separator : JIT_STACK_TRACE_MESSAGE;
+    const lastParentItem = this.parentCompiler?.getCurrentStackItem();
+    const filteredStack = lastParentItem ? this.stack.filter((item) => item.rt !== lastParentItem?.rt) : this.stack;
+    return parentTrace + filteredStack.map((item) => this.getTypeTraceInfo(item.rt)).join(separator);
+  }
+  hasStackTrace(errorMessage) {
+    return errorMessage.includes(JIT_STACK_TRACE_MESSAGE);
+  }
+  /** Set a context code item */
+  setContextItem(key, value) {
+    this.contextCodeItems.set(key, value);
+  }
+  /** Get a context code item */
+  getContextItem(key) {
+    return this.contextCodeItems.get(key);
+  }
+  /** Check if a context code item exists */
+  hasContextItem(key) {
+    return this.contextCodeItems.has(key);
+  }
+  /** Get all context code items values */
+  getContextItemValues() {
+    return Array.from(this.contextCodeItems.values());
+  }
+  setChildrenCallArgs(fnID, args) {
+    this.childrenCallArgs[fnID] = args;
+  }
+  getChildrenCallArgs(fnID) {
+    return this.childrenCallArgs[fnID];
+  }
+  /**
+   * Compiles the current function.
+   * This function handles the logic to determine if the operation should be compiled and code should be inlined, or called as a dependency.
+   * Note current JitCompiler operation might be different from the passed operation id.
+   * ie: typeErrors might want to compile isType to generate the part of the code that checks for the type.
+   * @param comp current jit compiler operation
+   * @param fnID operation id
+   * @returns
+   */
+  compile(rt, expectedCType, fnID) {
+    if (!rt) return { code: void 0, type: expectedCType };
+    let jCode;
+    this.pushStack(rt);
+    if (this.shouldCallDependency()) {
+      const compiledOp = rt.createJitCompiledFunction(fnID, this, this.opts);
+      jCode = this.callDependency(rt, compiledOp);
+      this.updateDependencies(compiledOp);
+    } else {
+      switch (fnID) {
+        case JitFunctions.isType.id:
+          jCode = this.compileFormatter(rt, fnID, rt.emitIsType(this, expectedCType), expectedCType, "&&");
+          break;
+        case JitFunctions.typeErrors.id:
+          jCode = this.compileFormatter(rt, fnID, rt.emitTypeErrors(this, expectedCType), expectedCType, ";");
+          break;
+        case JitFunctions.prepareForJson.id:
+          jCode = this.compileFormatter(rt, fnID, rt.emitPrepareForJson(this, expectedCType), expectedCType, ";");
+          break;
+        case JitFunctions.restoreFromJson.id:
+          jCode = this.compileFormatter(rt, fnID, rt.emitRestoreFromJson(this, expectedCType), expectedCType, ";");
+          break;
+        case JitFunctions.stringifyJson.id:
+          jCode = this.compileFormatter(rt, fnID, emitJsonStringify(rt, this), expectedCType, ";");
+          break;
+        case JitFunctions.toBinary.id:
+          jCode = this.compileFormatter(rt, fnID, emitToBinary(rt, this), expectedCType, ";");
+          break;
+        case JitFunctions.fromBinary.id:
+          jCode = this.compileFormatter(rt, fnID, emitFromBinary(rt, this), expectedCType, ";");
+          break;
+        case JitFunctions.toJSCode.id:
+          jCode = this.compileFormatter(rt, fnID, emitToCode(rt, this), expectedCType, ";");
+          break;
+        case JitFunctions.unknownKeyErrors.id:
+          jCode = rt.emitUnknownKeyErrors(this, expectedCType);
+          break;
+        case JitFunctions.hasUnknownKeys.id:
+          jCode = rt.emitHasUnknownKeys(this, expectedCType);
+          break;
+        case JitFunctions.stripUnknownKeys.id:
+          jCode = rt.emitStripUnknownKeys(this, expectedCType);
+          break;
+        case JitFunctions.unknownKeysToUndefined.id:
+          jCode = rt.emitUnknownKeysToUndefined(this, expectedCType);
+          break;
+        case JitFunctions.format.id:
+          jCode = { code: void 0, type: E };
+          break;
+        default:
+          throw new Error(`Unknown compile operation: ${fnID}`);
+      }
+      if (jCode?.code) {
+        const compatibleCode = this.handleCodeInterpolation(rt, jCode, expectedCType);
+        jCode = { code: compatibleCode, type: jCode.type };
+      }
+    }
+    this.popStack(jCode);
+    return jCode;
+  }
+  compileFormatter(rt, fnID, childJCode, expectedCType, separator) {
+    const expectedCT = childJCode.code ? childJCode.type : expectedCType;
+    const typeFormatter = getRunTypeFormat(rt);
+    if (!typeFormatter) return childJCode;
+    let jitCode = void 0;
+    const formatterCode = typeFormatter.compileFormat(fnID, this, rt);
+    const canEmbed = typeFormatter.canEmbedFormatterCode(fnID, rt);
+    const codeHasReturn = formatterCode.type === RB;
+    const isCompatible = formatterCode.type === expectedCT;
+    if (canEmbed && isCompatible && !codeHasReturn) {
+      jitCode = formatterCode;
+    } else {
+      const compiled = typeFormatter.createJitCompiledFormatter(fnID, rt, this, void 0, void 0, void 0, this.opts);
+      if (!compiled.isNoop) {
+        this.updateDependencies(compiled);
+        jitCode = this.callDependency(rt, compiled);
+      }
+    }
+    if (!jitCode?.code) return childJCode;
+    const shouldReplace = getJitFnSettings(fnID).formatShouldReplaceJitCode;
+    const joiner = separator === "&&" ? " && " : "; ";
+    if (shouldReplace) {
+      return jitCode;
+    }
+    const finalCode = childJCode?.code ? childJCode.code + joiner + jitCode.code : jitCode.code;
+    return { code: finalCode, type: expectedCT };
+  }
+  callDependency(rt, dependencyComp) {
+    if (dependencyComp.isNoop) return { code: "", type: E };
+    const isErrorCall = dependencyComp.fnID === JitFunctions.typeErrors.id || dependencyComp.fnID === JitFunctions.unknownKeyErrors.id;
+    const depArgs = getJitFnSettings(dependencyComp.fnID).jitArgs;
+    const callArgsCode = Object.keys(depArgs).map((key) => getJitFnArgCallVarName(this, rt, dependencyComp.fnID, key)).join(",");
+    const isSelf = this.jitFnHash === dependencyComp.jitFnHash;
+    const varName = dependencyComp.jitFnHash;
+    const callCode = isSelf ? `${varName}(${callArgsCode})` : `${varName}.fn(${callArgsCode})`;
+    if (!isSelf) this.setContextItem(varName, `const ${varName} = utl.getJIT(${toLiteral(varName)})`);
+    if (isErrorCall) {
+      const pathArgs = this.getAccessPathArgs();
+      const pathLength = this.getAccessPathLength();
+      if (!pathLength) return { code: callCode, type: "E" };
+      return {
+        code: `${jitErrorArgs.pλth}.push(${pathArgs}); ${callCode}; ${jitErrorArgs.pλth}.splice(-${pathLength});`,
+        type: "S"
+      };
+    }
+    return { code: callCode, type: "E" };
+  }
+  /** Check if root type is a FunctionParamsRunType with no children (empty params) */
+  isEmptyFunctionParams() {
+    if (!isFunctionParamsRunType(this.rootType)) return false;
+    return this.rootType.getChildRunTypes().length === 0;
+  }
+  /**
+   * Set the isNoop flag based on the code of the operation.
+   * must be called before function gets compiled.
+   * The isNoop flag is used to avoid calling the function when the result of compilation is an empty function.
+   */
+  handleFunctionReturn() {
+    if (this.isCompiled) return;
+    let isNoop = false;
+    let code = this.code.replace(/[ \t]+/g, " ").replace(/;+/g, ";");
+    const isEmptyParams = this.isEmptyFunctionParams();
+    switch (this.fnID) {
+      case JitFunctions.isType.id:
+        isNoop = isEmptyParams || !this.code || this.code === "true" || this.code === "return true";
+        if (isNoop) code = `return true`;
+        break;
+      case JitFunctions.hasUnknownKeys.id:
+        isNoop = !this.code || this.code === "false" || this.code === "return false";
+        if (isNoop) code = `return false`;
+        break;
+      case JitFunctions.prepareForJson.id:
+      case JitFunctions.restoreFromJson.id:
+      case JitFunctions.stripUnknownKeys.id:
+      case JitFunctions.unknownKeysToUndefined.id:
+        isNoop = isEmptyParams || !this.code || this.code === this.args.vλl || this.code === `return ${this.args.vλl}`;
+        if (isNoop) code = `return ${this.args.vλl}`;
+        break;
+      case JitFunctions.typeErrors.id:
+      case JitFunctions.unknownKeyErrors.id:
+        isNoop = isEmptyParams || !this.code || this.code === this.args.εrr || this.code === `return ${this.args.εrr}`;
+        if (isNoop) code = `return ${this.args.εrr}`;
+        break;
+      case JitFunctions.format.id:
+        isNoop = !this.code || this.code === this.args.vλl || this.code === `return ${this.args.vλl}`;
+        if (isNoop) code = `return ${this.args.vλl}`;
+        break;
+    }
+    this.isNoop = isNoop;
+    this.code = code;
+    this.isCompiled = true;
+  }
+  /** Ensures the child code type is compatible with the parent code type */
+  handleCodeInterpolation(rt, childJCode, parentCodeType) {
+    const code = childJCode.code || "";
+    const childCodeType = childJCode.type;
+    const isRoot = this.length === 1;
+    if (isRoot) {
+      switch (childCodeType) {
+        case E:
+          return `return ${code}`;
+        case S:
+          return `${addFullStop(code)} return ${this.returnName}`;
+        case RB:
+          return code;
+      }
+    }
+    switch (true) {
+      case (parentCodeType === E && childCodeType === E):
+        return code;
+      case (parentCodeType === E && childCodeType === S):
+        return this.callSelfInvokingFunction(childJCode);
+      case (parentCodeType === E && childCodeType === RB):
+        return this.callSelfInvokingFunction(childJCode);
+      case (parentCodeType === S && childCodeType === E):
+        return code;
+      // no need for full stop, parent should handle it
+      case (parentCodeType === S && childCodeType === S):
+        return addFullStop(code);
+      case (parentCodeType === S && childCodeType === RB):
+        return this.callSelfInvokingFunction(childJCode);
+      case (parentCodeType === RB && childCodeType === E):
+        throw new Error("Expected an block code but got an expression, rt should not happen as would be useless code.");
+      case (parentCodeType === RB && childCodeType === S):
+        return addFullStop(code);
+      case (parentCodeType === RB && childCodeType === RB):
+        return `${addFullStop(code)} return ${this.returnName}`;
+      default:
+        throw new Error(`Unexpected code type (expected: ${parentCodeType}, got: ${childCodeType})`);
+    }
+  }
+  /**
+   * If code should be an expression, but code has return a statement, we need to wrap it in a self invoking function to avoid syntax errors
+   * IMPORTANT TODO, WE CAN IMPROVE PERF QUITE A BIT BY CREATING A NEW FUNCTION IN CONTEXT INSTEAD SELF INVOkING
+   * TODO: we could create a new function and cache instead a self invoking function a performance is same but code is not repeated
+   * IE: this.selfInvoke(code), rt will create a new function in context and call that function instead of self invoking
+   * rt is specially for atomic types as we can be sure there are no references to children types inside the code block
+   */
+  callSelfInvokingFunction(jCode) {
+    if (jCode.type === E) throw new Error("Javascript expressions never need to be wrapped in a self invoking function.");
+    if (!jCode.code) return "";
+    const code = jCode.code.trim();
+    const isSelfInvoking = code.startsWith("(function()") && code.endsWith(")()");
+    if (isSelfInvoking) return code;
+    const addReturn = jCode.type !== RB;
+    const returnCode = addReturn ? `return ` : "";
+    return `(function(){${returnCode}${jCode.code}})()`;
+  }
+  getTypeTraceInfo(rt) {
+    if (rt.getFamily() === "C") return rt.src.typeName || getReflectionName(rt);
+    if (rt.getFamily() === "F") return String(rt.src.name) || getReflectionName(rt);
+    if (rt.getFamily() === "M") {
+      const rtChild = rt;
+      const isRunTypeChildAccessor = !!rtChild.getChildVarName;
+      if (!isRunTypeChildAccessor) return getReflectionName(rt);
+      return String(rtChild.getChildVarName(this));
+    }
+    return getReflectionName(rt);
+  }
+  // ########## Compile Methods shorthands ##########
+  compileIsType(rt, expectedCType) {
+    return this.compile(rt, expectedCType, JitFunctions.isType.id);
+  }
+  compileTypeErrors(rt, expectedCType) {
+    return this.compile(rt, expectedCType, JitFunctions.typeErrors.id);
+  }
+  compilePrepareForJson(rt, expectedCType) {
+    return this.compile(rt, expectedCType, JitFunctions.prepareForJson.id);
+  }
+  compileRestoreFromJson(rt, expectedCType) {
+    return this.compile(rt, expectedCType, JitFunctions.restoreFromJson.id);
+  }
+  compileJsonStringify(rt, expectedCType) {
+    return this.compile(rt, expectedCType, JitFunctions.stringifyJson.id);
+  }
+  compileToBinary(rt, expectedCType) {
+    return this.compile(rt, expectedCType, JitFunctions.toBinary.id);
+  }
+  compileFromBinary(rt, expectedCType) {
+    return this.compile(rt, expectedCType, JitFunctions.fromBinary.id);
+  }
+  compileUnknownKeyErrors(rt, expectedCType) {
+    return this.compile(rt, expectedCType, JitFunctions.unknownKeyErrors.id);
+  }
+  compileHasUnknownKeys(rt, expectedCType) {
+    return this.compile(rt, expectedCType, JitFunctions.hasUnknownKeys.id);
+  }
+  compileStripUnknownKeys(rt, expectedCType) {
+    return this.compile(rt, expectedCType, JitFunctions.stripUnknownKeys.id);
+  }
+  compileUnknownKeysToUndefined(rt, expectedCType) {
+    return this.compile(rt, expectedCType, JitFunctions.unknownKeysToUndefined.id);
+  }
+  // ################### Pure Functions Operations ###################
+  addPureFunction(compiledPureFn) {
+    const { namespace, fnName } = compiledPureFn;
+    const varName = quickHash(fnName, 8);
+    if (this.hasContextItem(varName)) return varName;
+    this.addPureFnDependency(compiledPureFn);
+    const pureFunctionCode = `const ${varName} = utl.getPureFn(${toLiteral(namespace)}, ${toLiteral(fnName)})`;
+    this.setContextItem(varName, pureFunctionCode);
+    return varName;
+  }
+  addPureFnDependency(compiledPureFn) {
+    const { namespace, fnName } = compiledPureFn;
+    if (!getJitUtils().hasPureFn(namespace, fnName))
+      throw new Error(
+        `Pure function with name ${fnName} can not be added as jit dependency in namespace ${namespace}, be sure to register the pure function first by calling getJitUtils().addPureFn()`
+      );
+    const key = `${namespace}::${fnName}`;
+    if (this.pureFnDependencies.includes(key)) return;
+    this.pureFnDependencies.push(key);
+  }
+}
+class JitFnCompiler extends BaseFnCompiler {
+  constructor(rt, fnID, parentCompiler, jitFnHash, typeID, opts = {}) {
+    const fnSettings = getJitFnSettings(fnID);
+    super(rt, fnID, fnSettings, parentCompiler, jitFnHash, typeID, opts);
+  }
+}
+class JitErrorsFnCompiler extends BaseFnCompiler {
+  constructor(rt, fnID, parentCompiler, jitFnHash, typeID, opts = {}) {
+    const fnSettings = getJitFnSettings(fnID);
+    super(rt, fnID, fnSettings, parentCompiler, jitFnHash, typeID, opts);
+  }
+  callJitErr(expected) {
+    return this.callJitErrWithPath(expected);
+  }
+  /**
+   * This is used when we add an extra item to the path,
+   * for extra info, ie union items, maps keys, etc...
+   * This is because we don't want the item int the real path as it is not part of the runtime path of an object.
+   * but we still want to add that info to process the error.
+   * ie: type  AorBList = ({a: string} | {b: string})[];
+   * we want the error to contain the info if it is union item a or b, but the path to the the doesn't have that info is just list[index]
+   * */
+  callJitErrWithPath(exp, extraPathLiteral) {
+    const args = this._getJitErrorArgs(exp);
+    const accessPath = this.getAccessPathLiteral(extraPathLiteral);
+    if (accessPath) args.push(accessPath);
+    const errFn = this.addPureFunction(cpf_newRunTypeErr);
+    return `${errFn}(${args.join(",")})`;
+  }
+  callJitFormatErr(expected, formatter, paramName, paramValue, extraPathLiteral) {
+    const typeErrArgs = this._getJitErrorArgs(expected);
+    const fmtName = toLiteralInContext(this, formatter.getFormatName());
+    const pName = toLiteralInContext(this, paramName);
+    const pVal = toLiteralInContext(this, paramValue);
+    const fmtPath = toLiteralInContext(this, formatter.getFormatPath());
+    const formatArgs = [fmtName, pName, pVal, fmtPath];
+    const optionalArgs = [];
+    const accessPath = this.getAccessPathLiteral(extraPathLiteral);
+    const formatAccessPath = this.getFormatAccessPathLiteral(formatter);
+    if (!accessPath && formatAccessPath) optionalArgs.push("undefined");
+    if (accessPath) optionalArgs.push(accessPath);
+    if (formatAccessPath) optionalArgs.push(formatAccessPath);
+    const formatErrFn = this.addPureFunction(cpf_formatErr);
+    return `${formatErrFn}(${[...typeErrArgs, ...formatArgs, ...optionalArgs].join(",")})`;
+  }
+  _getJitErrorArgs(exp) {
+    const path = this.args.pλth;
+    const err = this.args.εrr;
+    const expected = typeof exp === "string" ? toLiteral(exp) : toLiteral(exp.getKindName());
+    return [path, err, expected];
+  }
+  getAccessPathLiteral(extraPathLiteral) {
+    const accessPath = this.getAccessPath();
+    if (extraPathLiteral) accessPath.push(extraPathLiteral);
+    return accessPath.length ? `[${accessPath.join(",")}]` : "";
+  }
+  getFormatAccessPathLiteral(formatter) {
+    const formatExtraPathLiteral = formatter.getFormatExtraPathLiteral();
+    return formatExtraPathLiteral ? `[${formatExtraPathLiteral}]` : "";
+  }
+}
+class MockJitCompiler extends BaseFnCompiler {
+  constructor(rt, opts, parentCompiler, jitFnHash, typeID) {
+    super(rt, JitFunctions.mock.id, JitFunctions.mock, parentCompiler, jitFnHash, typeID, opts);
+  }
+}
+function createJitCompiler(rt, fnID, parent, jitFnHash, typeID, opts = {}) {
+  switch (fnID) {
+    case JitFunctions.isType.id:
+    case JitFunctions.prepareForJson.id:
+    case JitFunctions.restoreFromJson.id:
+    case JitFunctions.stringifyJson.id:
+    case JitFunctions.hasUnknownKeys.id:
+    case JitFunctions.stripUnknownKeys.id:
+    case JitFunctions.unknownKeysToUndefined.id:
+    case JitFunctions.format.id:
+    case JitFunctions.toJSCode.id:
+    case JitFunctions.toBinary.id:
+    case JitFunctions.fromBinary.id:
+      return new JitFnCompiler(rt, fnID, parent, jitFnHash, typeID, opts);
+    case JitFunctions.typeErrors.id:
+    case JitFunctions.unknownKeyErrors.id:
+      return new JitErrorsFnCompiler(rt, fnID, parent, jitFnHash, typeID, opts);
+    case JitFunctions.mock.id:
+      return new MockJitCompiler(rt, opts, parent, jitFnHash, typeID);
+    default:
+      throw new Error(`Unknown compile operation: ${fnID}`);
+  }
+}
+function printClosure(fnWithContext, functionName) {
+  return `function get_${functionName}(utl){${fnWithContext}}`;
+}
+function getStackVλl(comp) {
+  let vλl = comp.args.vλl;
+  for (let i = 0; i < comp.stack.length; i++) {
+    const rt = comp.stack[i].rt;
+    const custom = rt.getCustomVλl(comp);
+    if (custom && custom.isStandalone) {
+      vλl = custom.vλl;
+    } else if (custom) {
+      vλl += custom.useArrayAccessor ? `[${custom.vλl}]` : `.${custom.vλl}`;
+    } else if (isChildAccessorType(rt) && !rt.skipSettingAccessor?.()) {
+      vλl += rt.useArrayAccessor() ? `[${rt.getChildLiteral(comp)}]` : `.${rt.getChildVarName(comp)}`;
+    }
+  }
+  return vλl;
+}
+function getAccessPath(comp) {
+  const path = [];
+  const rtName = [];
+  for (let i = 0; i < comp.stack.length; i++) {
+    const rt = comp.stack[i].rt;
+    const pathItem = rt.getStaticPathLiteral(comp);
+    if (pathItem) {
+      path.push(pathItem);
+    } else if (isChildAccessorType(rt) && !rt.skipSettingAccessor?.()) {
+      path.push(rt.getChildLiteral(comp));
+    }
+    rtName.push({ path: [...path], name: rt.constructor.name });
+  }
+  return path;
+}
+function validateCompilerOptions(opts) {
+  if (opts.paramsSlice) {
+    const start = opts.paramsSlice?.start;
+    const end = opts.paramsSlice?.end;
+    if (start && start < 0) {
+      throw new Error(`paramsSlice.start must be greater than 0`);
+    }
+    if (end && end < 0) {
+      throw new Error(`paramsSlice.end must be greater than 0`);
+    }
+    if (end && start && end <= start) {
+      throw new Error(`paramsSlice.end must be greater than paramsSlice.start`);
+    }
+  }
+}
+export {
+  BaseFnCompiler,
+  JitErrorsFnCompiler,
+  JitFnCompiler,
+  MockJitCompiler,
+  createJitCompiler,
+  printClosure
+};
+//# sourceMappingURL=jitFnCompiler.js.map