@jsenv/test 1.6.9 → 1.7.0

package/dist/js/execute_using_dynamic_import.js

@@ -2,795 +2,142 @@ import { writeFileSync } from "node:fs";
 import { Session } from "node:inspector";
 import { PerformanceObserver, performance } from "node:perf_hooks";
 
-// https://developer.mozilla.org/en-US/docs/Glossary/Primitive
-
-const isComposite = (value) => {
-  if (value === null) {
-    return false
-  }
-
-  const type = typeof value;
-  if (type === "object") {
-    return true
-  }
-
-  if (type === "function") {
-    return true
-  }
-
-  return false
-};
-
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap
-const compositeWellKnownMap = new WeakMap();
-const primitiveWellKnownMap = new Map();
-
-const getCompositeGlobalPath = (value) => compositeWellKnownMap.get(value);
-
-const getPrimitiveGlobalPath = (value) => primitiveWellKnownMap.get(value);
-
-const visitGlobalObject = (value) => {
-  const visitValue = (value, path) => {
-    if (isComposite(value)) {
-      // prevent infinite recursion
-      if (compositeWellKnownMap.has(value)) {
-        return
-      }
-      compositeWellKnownMap.set(value, path);
-
-      const visitProperty = (property) => {
-        let descriptor;
-        try {
-          descriptor = Object.getOwnPropertyDescriptor(value, property);
-        } catch (e) {
-          if (e.name === "SecurityError") {
-            return
-          }
-          throw e
-        }
-
-        if (!descriptor) {
-          // it's apparently possible to have getOwnPropertyNames returning
-          // a property that later returns a null descriptor
-          // for instance window.showModalDialog in webkit 13.0
-          return
-        }
-
-        // do not trigger getter/setter
-        if ("value" in descriptor) {
-          const propertyValue = descriptor.value;
-          visitValue(propertyValue, [...path, property]);
-        }
-      };
-
-      Object.getOwnPropertyNames(value).forEach((name) => visitProperty(name));
-      Object.getOwnPropertySymbols(value).forEach((symbol) => visitProperty(symbol));
-    }
-
-    primitiveWellKnownMap.set(value, path);
-    return
-  };
-
-  visitValue(value, []);
-};
-
-if (typeof window === "object") visitGlobalObject(window);
-
-if (typeof global === "object") visitGlobalObject(global);
-
-/**
- * transforms a javascript value into an object describing it.
+/*
+ * Exception are objects used to wrap a value that is thrown
+ * Usually they wrap error but the value can be anything as
+ * throw "toto" can be used in JS
  *
+ * - provide a common API to interact with value that can be thrown
+ * - enrich usual errors with a bit more information (line, column)
+ * - normalize error properties
+ *   - exception.stackTrace: only the stack trace as string (no error.name or error.message)
+ *   - error.stack: error.name + error.message + error.stackTrace
+ *
+ * It is used mostly internally by jsenv but can also be found
+ * value returned by "executeTestPlan" public export (for failed executions)
+ * and value returned by "execute" public export (when execution fails)
+ *
+ * This file is responsible to wrap error hapenning in Node.js runtime
+ * The browser part can be found in "supervisor.js"
  */
 
-
-const decompose = (mainValue, { functionAllowed, prototypeStrict, ignoreSymbols }) => {
-  const valueMap = {};
-  const recipeArray = [];
-
-  const valueToIdentifier = (value, path = []) => {
-    if (!isComposite(value)) {
-      const existingIdentifier = identifierForPrimitive(value);
-      if (existingIdentifier !== undefined) {
-        return existingIdentifier
-      }
-      const identifier = identifierForNewValue(value);
-      recipeArray[identifier] = primitiveToRecipe(value);
-      return identifier
-    }
-
-    if (typeof Promise === "function" && value instanceof Promise) {
-      throw new Error(createPromiseAreNotSupportedMessage({ path }))
-    }
-    if (typeof WeakSet === "function" && value instanceof WeakSet) {
-      throw new Error(createWeakSetAreNotSupportedMessage({ path }))
-    }
-    if (typeof WeakMap === "function" && value instanceof WeakMap) {
-      throw new Error(createWeakMapAreNotSupportedMessage({ path }))
-    }
-    if (typeof value === "function" && !functionAllowed) {
-      throw new Error(createForbiddenFunctionMessage({ path }))
-    }
-
-    const existingIdentifier = identifierForComposite(value);
-    if (existingIdentifier !== undefined) {
-      return existingIdentifier
-    }
-    const identifier = identifierForNewValue(value);
-
-    const compositeGlobalPath = getCompositeGlobalPath(value);
-    if (compositeGlobalPath) {
-      recipeArray[identifier] = createGlobalReferenceRecipe(compositeGlobalPath);
-      return identifier
-    }
-
-    const propertyDescriptionArray = [];
-    Object.getOwnPropertyNames(value).forEach((propertyName) => {
-      const propertyDescriptor = Object.getOwnPropertyDescriptor(value, propertyName);
-      const propertyNameIdentifier = valueToIdentifier(propertyName, [...path, propertyName]);
-      const propertyDescription = computePropertyDescription(propertyDescriptor, propertyName, path);
-      propertyDescriptionArray.push({ propertyNameIdentifier, propertyDescription });
-    });
-
-    const symbolDescriptionArray = [];
-    if (!ignoreSymbols) {
-      Object.getOwnPropertySymbols(value).forEach((symbol) => {
-        const propertyDescriptor = Object.getOwnPropertyDescriptor(value, symbol);
-        const symbolIdentifier = valueToIdentifier(symbol, [...path, `[${symbol.toString()}]`]);
-        const propertyDescription = computePropertyDescription(propertyDescriptor, symbol, path);
-        symbolDescriptionArray.push({ symbolIdentifier, propertyDescription });
-      });
-    }
-
-    const methodDescriptionArray = computeMethodDescriptionArray(value, path);
-
-    const extensible = Object.isExtensible(value);
-
-    recipeArray[identifier] = createCompositeRecipe({
-      propertyDescriptionArray,
-      symbolDescriptionArray,
-      methodDescriptionArray,
-      extensible,
-    });
-    return identifier
-  };
-
-  const computePropertyDescription = (propertyDescriptor, propertyNameOrSymbol, path) => {
-    if (propertyDescriptor.set && !functionAllowed) {
-      throw new Error(createForbiddenPropertySetterMessage({ path, propertyNameOrSymbol }))
-    }
-    if (propertyDescriptor.get && !functionAllowed) {
-      throw new Error(createForbiddenPropertyGetterMessage({ path, propertyNameOrSymbol }))
-    }
-
-    return {
-      configurable: propertyDescriptor.configurable,
-      writable: propertyDescriptor.writable,
-      enumerable: propertyDescriptor.enumerable,
-      getIdentifier:
-        "get" in propertyDescriptor
-          ? valueToIdentifier(propertyDescriptor.get, [
-              ...path,
-              String(propertyNameOrSymbol),
-              "[[descriptor:get]]",
-            ])
-          : undefined,
-      setIdentifier:
-        "set" in propertyDescriptor
-          ? valueToIdentifier(propertyDescriptor.set, [
-              ...path,
-              String(propertyNameOrSymbol),
-              "[[descriptor:set]]",
-            ])
-          : undefined,
-      valueIdentifier:
-        "value" in propertyDescriptor
-          ? valueToIdentifier(propertyDescriptor.value, [
-              ...path,
-              String(propertyNameOrSymbol),
-              "[[descriptor:value]]",
-            ])
-          : undefined,
-    }
+const createException = (reason) => {
+  const exception = {
+    isException: true,
+    isError: false,
+    name: "",
+    message: "",
+    stack: "",
+    stackTrace: "",
+    site: null,
   };
 
-  const computeMethodDescriptionArray = (value, path) => {
-    const methodDescriptionArray = [];
-
-    if (typeof Set === "function" && value instanceof Set) {
-      const callArray = [];
-      value.forEach((entryValue, index) => {
-        const entryValueIdentifier = valueToIdentifier(entryValue, [
-          ...path,
-          `[[SetEntryValue]]`,
-          index,
-        ]);
-        callArray.push([entryValueIdentifier]);
-      });
-      methodDescriptionArray.push({ methodNameIdentifier: valueToIdentifier("add"), callArray });
-    }
-
-    if (typeof Map === "function" && value instanceof Map) {
-      const callArray = [];
-      value.forEach((entryValue, entryKey) => {
-        const entryKeyIdentifier = valueToIdentifier(entryKey, [
-          ...path,
-          "[[MapEntryKey]]",
-          entryKey,
-        ]);
-        const entryValueIdentifier = valueToIdentifier(entryValue, [
-          ...path,
-          "[[MapEntryValue]]",
-          entryValue,
-        ]);
-        callArray.push([entryKeyIdentifier, entryValueIdentifier]);
-      });
-      methodDescriptionArray.push({ methodNameIdentifier: valueToIdentifier("set"), callArray });
-    }
-
-    return methodDescriptionArray
-  };
-
-  const identifierForPrimitive = (value) => {
-    return Object.keys(valueMap).find((existingIdentifier) => {
-      const existingValue = valueMap[existingIdentifier];
-      if (Object.is(value, existingValue)) return true
-      return value === existingValue
-    })
-  };
-
-  const identifierForComposite = (value) => {
-    return Object.keys(valueMap).find((existingIdentifier) => {
-      const existingValue = valueMap[existingIdentifier];
-      return value === existingValue
-    })
-  };
-
-  const identifierForNewValue = (value) => {
-    const identifier = nextIdentifier();
-    valueMap[identifier] = value;
-    return identifier
-  };
-
-  let currentIdentifier = -1;
-  const nextIdentifier = () => {
-    const identifier = String(parseInt(currentIdentifier) + 1);
-    currentIdentifier = identifier;
-    return identifier
-  };
-
-  const mainIdentifier = valueToIdentifier(mainValue);
-
-  // prototype, important to keep after the whole structure was visited
-  // so that we discover if any prototype is part of the value
-  const prototypeValueToIdentifier = (prototypeValue) => {
-    // prototype is null
-    if (prototypeValue === null) {
-      return valueToIdentifier(prototypeValue)
-    }
-
-    // prototype found somewhere already
-    const prototypeExistingIdentifier = identifierForComposite(prototypeValue);
-    if (prototypeExistingIdentifier !== undefined) {
-      return prototypeExistingIdentifier
-    }
-
-    // mark prototype as visited
-    const prototypeIdentifier = identifierForNewValue(prototypeValue);
-
-    // prototype is a global reference ?
-    const prototypeGlobalPath = getCompositeGlobalPath(prototypeValue);
-    if (prototypeGlobalPath) {
-      recipeArray[prototypeIdentifier] = createGlobalReferenceRecipe(prototypeGlobalPath);
-      return prototypeIdentifier
-    }
-
-    // otherwise prototype is unknown
-    if (prototypeStrict) {
-      throw new Error(createUnknownPrototypeMessage({ prototypeValue }))
-    }
-
-    return prototypeValueToIdentifier(Object.getPrototypeOf(prototypeValue))
-  };
-  const identifierForValueOf = (value, path = []) => {
-    if (value instanceof Array) {
-      return valueToIdentifier(value.length, [...path, "length"])
-    }
-
-    if ("valueOf" in value === false) {
-      return undefined
-    }
-
-    if (typeof value.valueOf !== "function") {
-      return undefined
-    }
-
-    const valueOfReturnValue = value.valueOf();
-    if (!isComposite(valueOfReturnValue)) {
-      return valueToIdentifier(valueOfReturnValue, [...path, "valueOf()"])
-    }
-
-    if (valueOfReturnValue === value) {
-      return undefined
-    }
-
-    throw new Error(createUnexpectedValueOfReturnValueMessage())
-  };
-
-  recipeArray.slice().forEach((recipe, index) => {
-    if (recipe.type === "composite") {
-      const value = valueMap[index];
-
-      if (typeof value === "function") {
-        const valueOfIdentifier = nextIdentifier();
-        recipeArray[valueOfIdentifier] = {
-          type: "primitive",
-          value,
-        };
-        recipe.valueOfIdentifier = valueOfIdentifier;
-        return
-      }
-
-      if (value instanceof RegExp) {
-        const valueOfIdentifier = nextIdentifier();
-        recipeArray[valueOfIdentifier] = {
-          type: "primitive",
-          value,
-        };
-        recipe.valueOfIdentifier = valueOfIdentifier;
-        return
-      }
-
-      // valueOf, mandatory to uneval new Date(10) for instance.
-      recipe.valueOfIdentifier = identifierForValueOf(value);
-      const prototypeValue = Object.getPrototypeOf(value);
-      recipe.prototypeIdentifier = prototypeValueToIdentifier(prototypeValue);
-    }
-  });
-
-  return {
-    recipeArray,
-    mainIdentifier,
-    valueMap,
-  }
-};
-
-const primitiveToRecipe = (value) => {
-  if (typeof value === "symbol") {
-    return symbolToRecipe(value)
-  }
-
-  return createPimitiveRecipe(value)
-};
-
-const symbolToRecipe = (symbol) => {
-  const globalSymbolKey = Symbol.keyFor(symbol);
-  if (globalSymbolKey !== undefined) {
-    return createGlobalSymbolRecipe(globalSymbolKey)
+  if (reason === undefined) {
+    exception.message = "undefined";
+    return exception;
   }
-
-  const symbolGlobalPath = getPrimitiveGlobalPath(symbol);
-  if (!symbolGlobalPath) {
-    throw new Error(createUnknownSymbolMessage({ symbol }))
+  if (reason === undefined) {
+    exception.message = "undefined";
+    return exception;
   }
-
-  return createGlobalReferenceRecipe(symbolGlobalPath)
-};
-
-const createPimitiveRecipe = (value) => {
-  return {
-    type: "primitive",
-    value,
+  if (typeof reason === "string") {
+    exception.message = reason;
+    return exception;
   }
-};
-
-const createGlobalReferenceRecipe = (path) => {
-  const recipe = {
-    type: "global-reference",
-    path,
-  };
-  return recipe
-};
-
-const createGlobalSymbolRecipe = (key) => {
-  return {
-    type: "global-symbol",
-    key,
+  if (reason instanceof Error) {
+    exception.isError = true;
+    exception.name = reason.name;
+    exception.message = reason.message;
+    const stackInfo = getStackInfo(reason);
+    if (stackInfo) {
+      const { stackTrace, stackObject } = stackInfo;
+      exception.stackTrace = stackTrace;
+      const [firstCallSite] = stackObject;
+      writePropertiesFromCallSite(exception, firstCallSite);
+    }
+    exception.stack = reason.stack;
+    return exception;
   }
-};
-
-const createCompositeRecipe = ({
-  prototypeIdentifier,
-  valueOfIdentifier,
-  propertyDescriptionArray,
-  symbolDescriptionArray,
-  methodDescriptionArray,
-  extensible,
-}) => {
-  return {
-    type: "composite",
-    prototypeIdentifier,
-    valueOfIdentifier,
-    propertyDescriptionArray,
-    symbolDescriptionArray,
-    methodDescriptionArray,
-    extensible,
+  if (typeof reason === "object") {
+    exception.code = reason.code;
+    exception.message = reason.message;
+    exception.stack = reason.stack;
+    return exception;
   }
+  exception.message = JSON.stringify(reason);
+  return exception;
 };
 
-const createPromiseAreNotSupportedMessage = ({ path }) => {
-  if (path.length === 0) {
-    return `promise are not supported.`
+const getStackInfo = (reason) => {
+  if (reason instanceof Error) {
+    const { prepareStackTrace } = Error;
+    let stackTrace;
+    let stackObject;
+    Error.prepareStackTrace = (e, secondArg) => {
+      Error.prepareStackTrace = prepareStackTrace;
+      stackObject = secondArg;
+      stackTrace = secondArg.map((callSite) => `  at ${callSite}`).join("\n");
+      const name = e.name || "Error";
+      const message = e.message || "";
+      let stack = `${name}: ${message}`;
+      if (stackTrace) {
+        stack += `\n${stackTrace}`;
+      }
+      return stack;
+    };
+    // eslint-disable-next-line no-unused-expressions
+    reason.stack;
+    if (stackTrace === undefined) {
+      return null;
+    }
+    return {
+      stackTrace,
+      stackObject,
+    };
   }
-
-  return `promise are not supported.
-promise found at: ${path.join("")}`
+  return null;
 };
-
-const createWeakSetAreNotSupportedMessage = ({ path }) => {
-  if (path.length === 0) {
-    return `weakSet are not supported.`
+const writePropertiesFromCallSite = (exception, callSite) => {
+  const source = callSite.getFileName() || callSite.getScriptNameOrSourceURL();
+  if (source) {
+    const line = callSite.getLineNumber();
+    const column = callSite.getColumnNumber() - 1;
+    exception.site = {
+      url: source,
+      line,
+      column,
+    };
+    return;
   }
-
-  return `weakSet are not supported.
-weakSet found at: ${path.join("")}`
-};
-
-const createWeakMapAreNotSupportedMessage = ({ path }) => {
-  if (path.length === 0) {
-    return `weakMap are not supported.`
+  // Code called using eval() needs special handling
+  if (callSite.isEval()) {
+    const origin = callSite.getEvalOrigin();
+    if (origin) {
+      writePropertiesFromEvalOrigin(exception, origin);
+    }
   }
-
-  return `weakMap are not supported.
-weakMap found at: ${path.join("")}`
 };
-
-const createForbiddenFunctionMessage = ({ path }) => {
-  if (path.length === 0) {
-    return `function are not allowed.`
+const writePropertiesFromEvalOrigin = (exception, origin) => {
+  // Most eval() calls are in this format
+  const topLevelEvalMatch = /^eval at ([^(]+) \((.+):(\d+):(\d+)\)$/.exec(
+    origin,
+  );
+  if (topLevelEvalMatch) {
+    const source = topLevelEvalMatch[2];
+    const line = Number(topLevelEvalMatch[3]);
+    const column = topLevelEvalMatch[4] - 1;
+    exception.site = {
+      url: source,
+      line,
+      column,
+    };
+    return;
   }
-
-  return `function are not allowed.
-function found at: ${path.join("")}`
-};
-
-const createForbiddenPropertyGetterMessage = ({
-  path,
-  propertyNameOrSymbol,
-}) => `property getter are not allowed.
-getter found on property: ${String(propertyNameOrSymbol)}
-at: ${path.join("")}`;
-
-const createForbiddenPropertySetterMessage = ({
-  path,
-  propertyNameOrSymbol,
-}) => `property setter are not allowed.
-setter found on property: ${String(propertyNameOrSymbol)}
-at: ${path.join("")}`;
-
-const createUnexpectedValueOfReturnValueMessage = () =>
-  `valueOf() must return a primitive of the object itself.`;
-
-const createUnknownSymbolMessage = ({
-  symbol,
-}) => `symbol must be global, like Symbol.iterator, or created using Symbol.for().
-symbol: ${symbol.toString()}`;
-
-const createUnknownPrototypeMessage = ({ prototypeValue }) =>
-  `prototype must be global, like Object.prototype, or somewhere in the value.
-prototype constructor name: ${prototypeValue.constructor.name}`;
-
-// be carefull because this function is mutating recipe objects inside the recipeArray.
-// this is not an issue because each recipe object is not accessible from the outside
-// when used internally by uneval
-const sortRecipe = (recipeArray) => {
-  const findInRecipePrototypeChain = (recipe, callback) => {
-    let currentRecipe = recipe;
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-      if (currentRecipe.type !== "composite") {
-        break
-      }
-
-      const prototypeIdentifier = currentRecipe.prototypeIdentifier;
-      if (prototypeIdentifier === undefined) {
-        break
-      }
-
-      currentRecipe = recipeArray[prototypeIdentifier];
-
-      if (callback(currentRecipe, prototypeIdentifier)) {
-        return prototypeIdentifier
-      }
-    }
-    return undefined
-  };
-
-  const recipeArrayOrdered = recipeArray.slice();
-  recipeArrayOrdered.sort((leftRecipe, rightRecipe) => {
-    const leftType = leftRecipe.type;
-    const rightType = rightRecipe.type;
-
-    if (leftType === "composite" && rightType === "composite") {
-      const rightRecipeIsInLeftRecipePrototypeChain = findInRecipePrototypeChain(
-        leftRecipe,
-        (recipeCandidate) => recipeCandidate === rightRecipe,
-      );
-      // if left recipe requires right recipe, left must be after right
-      if (rightRecipeIsInLeftRecipePrototypeChain) {
-        return 1
-      }
-
-      const leftRecipeIsInRightRecipePrototypeChain = findInRecipePrototypeChain(
-        rightRecipe,
-        (recipeCandidate) => recipeCandidate === leftRecipe,
-      );
-      // if right recipe requires left recipe, right must be after left
-      if (leftRecipeIsInRightRecipePrototypeChain) {
-        return -1
-      }
-    }
-
-    if (leftType !== rightType) {
-      // if left is a composite, left must be after right
-      if (leftType === "composite") {
-        return 1
-      }
-
-      // if right is a composite, right must be after left
-      if (rightType === "composite") {
-        return -1
-      }
-    }
-
-    const leftIndex = recipeArray.indexOf(leftRecipe);
-    const rightIndex = recipeArray.indexOf(rightRecipe);
-    // left was before right, don't change that
-    if (leftIndex < rightIndex) {
-      return -1
-    }
-
-    // right was after left, don't change that
-    return 1
-  });
-
-  return recipeArrayOrdered
-};
-
-// https://github.com/joliss/js-string-escape/blob/master/index.js
-// http://javascript.crockford.com/remedial.html
-const escapeString = (value) => {
-  const string = String(value);
-  let i = 0;
-  const j = string.length;
-  var escapedString = "";
-  while (i < j) {
-    const char = string[i];
-    let escapedChar;
-    if (char === '"' || char === "'" || char === "\\") {
-      escapedChar = `\\${char}`;
-    } else if (char === "\n") {
-      escapedChar = "\\n";
-    } else if (char === "\r") {
-      escapedChar = "\\r";
-    } else if (char === "\u2028") {
-      escapedChar = "\\u2028";
-    } else if (char === "\u2029") {
-      escapedChar = "\\u2029";
-    } else {
-      escapedChar = char;
-    }
-    escapedString += escapedChar;
-    i++;
+  // Parse nested eval() calls using recursion
+  const nestedEvalMatch = /^eval at ([^(]+) \((.+)\)$/.exec(origin);
+  if (nestedEvalMatch) {
+    writePropertiesFromEvalOrigin(exception, nestedEvalMatch[2]);
   }
-  return escapedString
-};
-
-const uneval = (
-  value,
-  { functionAllowed = false, prototypeStrict = false, ignoreSymbols = false } = {},
-) => {
-  const { recipeArray, mainIdentifier, valueMap } = decompose(value, {
-    functionAllowed,
-    prototypeStrict,
-    ignoreSymbols,
-  });
-  const recipeArraySorted = sortRecipe(recipeArray);
-
-  let source = `(function () {
-var globalObject
-try {
-  globalObject = Function('return this')() || (42, eval)('this');
-} catch(e) {
-  globalObject = window;
-}
-
-function safeDefineProperty(object, propertyNameOrSymbol, descriptor) {
-  var currentDescriptor = Object.getOwnPropertyDescriptor(object, propertyNameOrSymbol);
-  if (currentDescriptor && !currentDescriptor.configurable) return
-  Object.defineProperty(object, propertyNameOrSymbol, descriptor)
-};
-`;
-
-  const variableNameMap = {};
-  recipeArray.forEach((recipe, index) => {
-    const indexSorted = recipeArraySorted.indexOf(recipe);
-    variableNameMap[index] = `_${indexSorted}`;
-  });
-
-  const identifierToVariableName = (identifier) => variableNameMap[identifier];
-
-  const recipeToSetupSource = (recipe) => {
-    if (recipe.type === "primitive") return primitiveRecipeToSetupSource(recipe)
-    if (recipe.type === "global-symbol") return globalSymbolRecipeToSetupSource(recipe)
-    if (recipe.type === "global-reference") return globalReferenceRecipeToSetupSource(recipe)
-    return compositeRecipeToSetupSource(recipe)
-  };
-
-  const primitiveRecipeToSetupSource = ({ value }) => {
-    const type = typeof value;
-
-    if (type === "string") {
-      return `"${escapeString(value)}";`
-    }
-
-    if (type === "bigint") {
-      return `${value.toString()}n`
-    }
-
-    if (Object.is(value, -0)) {
-      return "-0;"
-    }
-
-    return `${String(value)};`
-  };
-
-  const globalSymbolRecipeToSetupSource = (recipe) => {
-    return `Symbol.for("${escapeString(recipe.key)}");`
-  };
-
-  const globalReferenceRecipeToSetupSource = (recipe) => {
-    const pathSource = recipe.path.map((part) => `["${escapeString(part)}"]`).join("");
-    return `globalObject${pathSource};`
-  };
-
-  const compositeRecipeToSetupSource = ({ prototypeIdentifier, valueOfIdentifier }) => {
-    if (prototypeIdentifier === undefined) {
-      return identifierToVariableName(valueOfIdentifier)
-    }
-
-    const prototypeValue = valueMap[prototypeIdentifier];
-    if (prototypeValue === null) {
-      return `Object.create(null);`
-    }
-
-    const prototypeConstructor = prototypeValue.constructor;
-    if (prototypeConstructor === Object) {
-      return `Object.create(${identifierToVariableName(prototypeIdentifier)});`
-    }
-
-    if (valueOfIdentifier === undefined) {
-      return `new ${prototypeConstructor.name}();`
-    }
-
-    if (prototypeConstructor.name === "BigInt") {
-      return `Object(${identifierToVariableName(valueOfIdentifier)})`
-    }
-
-    return `new ${prototypeConstructor.name}(${identifierToVariableName(valueOfIdentifier)});`
-  };
-
-  recipeArraySorted.forEach((recipe) => {
-    const recipeVariableName = identifierToVariableName(recipeArray.indexOf(recipe));
-    source += `var ${recipeVariableName} = ${recipeToSetupSource(recipe)}
-`;
-  });
-
-  const recipeToMutateSource = (recipe, recipeVariableName) => {
-    if (recipe.type === "composite") {
-      return compositeRecipeToMutateSource(recipe, recipeVariableName)
-    }
-    return ``
-  };
-
-  const compositeRecipeToMutateSource = (
-    { propertyDescriptionArray, symbolDescriptionArray, methodDescriptionArray, extensible },
-    recipeVariableName,
-  ) => {
-    let mutateSource = ``;
-
-    propertyDescriptionArray.forEach(({ propertyNameIdentifier, propertyDescription }) => {
-      mutateSource += generateDefinePropertySource(
-        recipeVariableName,
-        propertyNameIdentifier,
-        propertyDescription,
-      );
-    });
-
-    symbolDescriptionArray.forEach(({ symbolIdentifier, propertyDescription }) => {
-      mutateSource += generateDefinePropertySource(
-        recipeVariableName,
-        symbolIdentifier,
-        propertyDescription,
-      );
-    });
-
-    methodDescriptionArray.forEach(({ methodNameIdentifier, callArray }) => {
-      mutateSource += generateMethodCallSource(recipeVariableName, methodNameIdentifier, callArray);
-    });
-
-    if (!extensible) {
-      mutateSource += generatePreventExtensionSource(recipeVariableName);
-    }
-
-    return mutateSource
-  };
-
-  const generateDefinePropertySource = (
-    recipeVariableName,
-    propertyNameOrSymbolIdentifier,
-    propertyDescription,
-  ) => {
-    const propertyOrSymbolVariableName = identifierToVariableName(propertyNameOrSymbolIdentifier);
-
-    const propertyDescriptorSource = generatePropertyDescriptorSource(propertyDescription);
-    return `safeDefineProperty(${recipeVariableName}, ${propertyOrSymbolVariableName}, ${propertyDescriptorSource});`
-  };
-
-  const generatePropertyDescriptorSource = ({
-    configurable,
-    writable,
-    enumerable,
-    getIdentifier,
-    setIdentifier,
-    valueIdentifier,
-  }) => {
-    if (valueIdentifier === undefined) {
-      return `{
-  configurable: ${configurable},
-  enumerable: ${enumerable},
-  get: ${getIdentifier === undefined ? undefined : identifierToVariableName(getIdentifier)},
-  set: ${setIdentifier === undefined ? undefined : identifierToVariableName(setIdentifier)},
-}`
-    }
-
-    return `{
-  configurable: ${configurable},
-  writable: ${writable},
-  enumerable: ${enumerable},
-  value: ${valueIdentifier === undefined ? undefined : identifierToVariableName(valueIdentifier)}
-}`
-  };
-
-  const generateMethodCallSource = (recipeVariableName, methodNameIdentifier, callArray) => {
-    let methodCallSource = ``;
-
-    const methodVariableName = identifierToVariableName(methodNameIdentifier);
-    callArray.forEach((argumentIdentifiers) => {
-      const argumentVariableNames = argumentIdentifiers.map((argumentIdentifier) =>
-        identifierToVariableName(argumentIdentifier),
-      );
-
-      methodCallSource += `${recipeVariableName}[${methodVariableName}](${argumentVariableNames.join(
-        ",",
-      )});`;
-    });
-
-    return methodCallSource
-  };
-
-  const generatePreventExtensionSource = (recipeVariableName) => {
-    return `Object.preventExtensions(${recipeVariableName});`
-  };
-
-  recipeArraySorted.forEach((recipe) => {
-    const recipeVariableName = identifierToVariableName(recipeArray.indexOf(recipe));
-    source += `${recipeToMutateSource(recipe, recipeVariableName)}`;
-  });
-
-  source += `return ${identifierToVariableName(mainIdentifier)}; })()`;
-
-  return source
 };
 
 /*
@@ -964,4 +311,4 @@ const executeUsingDynamicImport = async ({
   return result;
 };
 
-export { executeUsingDynamicImport, uneval };
+export { createException, executeUsingDynamicImport };