@mionjs/run-types 0.8.8 → 0.13.0

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

@@ -1,650 +0,0 @@
-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;
-    if (!this.jitDependencies) this.jitDependencies = [];
-    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;
-    if (!this.pureFnDependencies) this.pureFnDependencies = [];
-    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