@jsenv/core 33.0.2 → 34.0.1

package/src/test/logs_file_execution.js

@@ -1,3 +1,4 @@
+import wrapAnsi from "wrap-ansi"
 import {
   ANSI,
   UNICODE,
@@ -41,29 +42,48 @@ export const createExecutionLog = (
     timeEllapsed,
     memoryHeap,
   })
+  let log
   if (completedExecutionLogAbbreviation && status === "completed") {
-    return `${description}${summary}`
+    log = `${description}${summary}`
+  } else {
+    const { consoleCalls = [], errors = [] } = executionResult
+    const consoleOutput = formatConsoleCalls(consoleCalls)
+    const errorsOutput = formatErrors(errors)
+    log = formatExecution({
+      label: `${description}${summary}`,
+      details: {
+        file: fileRelativeUrl,
+        ...(logRuntime ? { runtime: `${runtimeName}/${runtimeVersion}` } : {}),
+        ...(logEachDuration
+          ? {
+              duration:
+                status === "executing"
+                  ? msAsEllapsedTime(Date.now() - startMs)
+                  : msAsDuration(endMs - startMs),
+            }
+          : {}),
+      },
+      consoleOutput,
+      errorsOutput,
+    })
   }
-  const { consoleCalls = [], errors = [] } = executionResult
-  const consoleOutput = formatConsoleCalls(consoleCalls)
-  const errorsOutput = formatErrors(errors)
-  return formatExecution({
-    label: `${description}${summary}`,
-    details: {
-      file: fileRelativeUrl,
-      ...(logRuntime ? { runtime: `${runtimeName}/${runtimeVersion}` } : {}),
-      ...(logEachDuration
-        ? {
-            duration:
-              status === "executing"
-                ? msAsEllapsedTime(Date.now() - startMs)
-                : msAsDuration(endMs - startMs),
-          }
-        : {}),
-    },
-    consoleOutput,
-    errorsOutput,
+
+  const { columns = 80 } = process.stdout
+  log = wrapAnsi(log, columns, {
+    trim: false,
+    hard: true,
+    wordWrap: false,
   })
+  if (endMs) {
+    if (completedExecutionLogAbbreviation) {
+      return `${log}\n`
+    }
+    if (executionIndex === counters.total - 1) {
+      return `${log}\n`
+    }
+    return `${log}\n\n`
+  }
+  return log
 }
 
 const formatErrors = (errors) => {
@@ -203,44 +223,70 @@ const createMixedDetails = ({ counters }) => {
 const descriptionFormatters = {
   executing: ({ index, total }) => {
     return ANSI.color(
-      `executing ${index + 1} of ${total}`,
+      `executing ${padNumber(index, total)} of ${total}`,
       EXECUTION_COLORS.executing,
     )
   },
   aborted: ({ index, total }) => {
     return ANSI.color(
-      `${UNICODE.FAILURE_RAW} execution ${index + 1} of ${total} aborted`,
+      `${UNICODE.FAILURE_RAW} execution ${padNumber(
+        index,
+        total,
+      )} of ${total} aborted`,
       EXECUTION_COLORS.aborted,
     )
   },
   timedout: ({ index, total, executionParams }) => {
     return ANSI.color(
-      `${UNICODE.FAILURE_RAW} execution ${
-        index + 1
-      } of ${total} timeout after ${executionParams.allocatedMs}ms`,
+      `${UNICODE.FAILURE_RAW} execution ${padNumber(
+        index,
+        total,
+      )} of ${total} timeout after ${executionParams.allocatedMs}ms`,
       EXECUTION_COLORS.timedout,
     )
   },
   failed: ({ index, total }) => {
     return ANSI.color(
-      `${UNICODE.FAILURE_RAW} execution ${index + 1} of ${total} failed`,
+      `${UNICODE.FAILURE_RAW} execution ${padNumber(
+        index,
+        total,
+      )} of ${total} failed`,
       EXECUTION_COLORS.failed,
     )
   },
   completed: ({ index, total }) => {
     return ANSI.color(
-      `${UNICODE.OK_RAW} execution ${index + 1} of ${total} completed`,
+      `${UNICODE.OK_RAW} execution ${padNumber(
+        index,
+        total,
+      )} of ${total} completed`,
       EXECUTION_COLORS.completed,
     )
   },
   cancelled: ({ index, total }) => {
     return ANSI.color(
-      `${UNICODE.FAILURE_RAW} execution ${index + 1} of ${total} cancelled`,
+      `${UNICODE.FAILURE_RAW} execution ${padNumber(
+        index,
+        total,
+      )} of ${total} cancelled`,
       EXECUTION_COLORS.cancelled,
     )
   },
 }
 
+const padNumber = (index, total) => {
+  const number = index + 1
+  const numberWidth = String(number).length
+  const totalWith = String(total).length
+  let missingWidth = totalWith - numberWidth
+  let padded = ""
+  while (missingWidth--) {
+    padded += "0"
+  }
+  padded += number
+  return padded
+}
+
 const formatConsoleCalls = (consoleCalls) => {
   if (consoleCalls.length === 0) {
     return ""

package/dist/js/babel_plugin_transform_modules_systemjs.cjs

@@ -1,392 +0,0 @@
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-exports.getExportSpecifierName = getExportSpecifierName;
-var _helperPluginUtils = require("@babel/helper-plugin-utils");
-var _helperHoistVariables = require("@babel/helper-hoist-variables");
-var _core = require("@babel/core");
-var _helperModuleTransforms = require("@babel/helper-module-transforms");
-var _helperValidatorIdentifier = require("@babel/helper-validator-identifier");
-const buildTemplate = _core.template.statement(`
-  SYSTEM_REGISTER(MODULE_NAME, SOURCES, function (EXPORT_IDENTIFIER, CONTEXT_IDENTIFIER) {
-    "use strict";
-    BEFORE_BODY;
-    return {
-      setters: SETTERS,
-      execute: EXECUTE,
-    };
-  });
-`);
-const buildExportAll = _core.template.statement(`
-  for (var KEY in TARGET) {
-    if (KEY !== "default" && KEY !== "__esModule") EXPORT_OBJ[KEY] = TARGET[KEY];
-  }
-`);
-const MISSING_PLUGIN_WARNING = `\
-WARNING: Dynamic import() transformation must be enabled using the
-         @babel/plugin-proposal-dynamic-import plugin. Babel 8 will
-         no longer transform import() without using that plugin.
-`;
-function getExportSpecifierName(node, stringSpecifiers) {
-  if (node.type === "Identifier") {
-    return node.name;
-  } else if (node.type === "StringLiteral") {
-    const stringValue = node.value;
-    if (!(0, _helperValidatorIdentifier.isIdentifierName)(stringValue)) {
-      stringSpecifiers.add(stringValue);
-    }
-    return stringValue;
-  } else {
-    throw new Error(`Expected export specifier to be either Identifier or StringLiteral, got ${node.type}`);
-  }
-}
-function constructExportCall(path, exportIdent, exportNames, exportValues, exportStarTarget, stringSpecifiers) {
-  const statements = [];
-  if (!exportStarTarget) {
-    if (exportNames.length === 1) {
-      statements.push(_core.types.expressionStatement(_core.types.callExpression(exportIdent, [_core.types.stringLiteral(exportNames[0]), exportValues[0]])));
-    } else {
-      const objectProperties = [];
-      for (let i = 0; i < exportNames.length; i++) {
-        const exportName = exportNames[i];
-        const exportValue = exportValues[i];
-        objectProperties.push(_core.types.objectProperty(stringSpecifiers.has(exportName) ? _core.types.stringLiteral(exportName) : _core.types.identifier(exportName), exportValue));
-      }
-      statements.push(_core.types.expressionStatement(_core.types.callExpression(exportIdent, [_core.types.objectExpression(objectProperties)])));
-    }
-  } else {
-    const exportObj = path.scope.generateUid("exportObj");
-    statements.push(_core.types.variableDeclaration("var", [_core.types.variableDeclarator(_core.types.identifier(exportObj), _core.types.objectExpression([]))]));
-    statements.push(buildExportAll({
-      KEY: path.scope.generateUidIdentifier("key"),
-      EXPORT_OBJ: _core.types.identifier(exportObj),
-      TARGET: exportStarTarget
-    }));
-    for (let i = 0; i < exportNames.length; i++) {
-      const exportName = exportNames[i];
-      const exportValue = exportValues[i];
-      statements.push(_core.types.expressionStatement(_core.types.assignmentExpression("=", _core.types.memberExpression(_core.types.identifier(exportObj), _core.types.identifier(exportName)), exportValue)));
-    }
-    statements.push(_core.types.expressionStatement(_core.types.callExpression(exportIdent, [_core.types.identifier(exportObj)])));
-  }
-  return statements;
-}
-var _default = (0, _helperPluginUtils.declare)((api, options) => {
-  api.assertVersion(7);
-  const {
-    systemGlobal = "System",
-    allowTopLevelThis = false
-  } = options;
-  const reassignmentVisited = new WeakSet();
-  const reassignmentVisitor = {
-    "AssignmentExpression|UpdateExpression"(path) {
-      if (reassignmentVisited.has(path.node)) return;
-      reassignmentVisited.add(path.node);
-      const arg = path.isAssignmentExpression() ? path.get("left") : path.get("argument");
-      if (arg.isObjectPattern() || arg.isArrayPattern()) {
-        const exprs = [path.node];
-        for (const name of Object.keys(arg.getBindingIdentifiers())) {
-          if (this.scope.getBinding(name) !== path.scope.getBinding(name)) {
-            return;
-          }
-          const exportedNames = this.exports[name];
-          if (!exportedNames) continue;
-          for (const exportedName of exportedNames) {
-            exprs.push(this.buildCall(exportedName, _core.types.identifier(name)).expression);
-          }
-        }
-        path.replaceWith(_core.types.sequenceExpression(exprs));
-        return;
-      }
-      if (!arg.isIdentifier()) return;
-      const name = arg.node.name;
-      if (this.scope.getBinding(name) !== path.scope.getBinding(name)) return;
-      const exportedNames = this.exports[name];
-      if (!exportedNames) return;
-      let node = path.node;
-      const isPostUpdateExpression = _core.types.isUpdateExpression(node, {
-        prefix: false
-      });
-      if (isPostUpdateExpression) {
-        node = _core.types.binaryExpression(node.operator[0], _core.types.unaryExpression("+", _core.types.cloneNode(node.argument)), _core.types.numericLiteral(1));
-      }
-      for (const exportedName of exportedNames) {
-        node = this.buildCall(exportedName, node).expression;
-      }
-      if (isPostUpdateExpression) {
-        node = _core.types.sequenceExpression([node, path.node]);
-      }
-      path.replaceWith(node);
-    }
-  };
-  return {
-    name: "transform-modules-systemjs",
-    pre() {
-      this.file.set("@babel/plugin-transform-modules-*", "systemjs");
-    },
-    visitor: {
-      CallExpression(path, state) {
-        if (_core.types.isImport(path.node.callee)) {
-          if (!this.file.has("@babel/plugin-proposal-dynamic-import")) {
-            {
-              console.warn(MISSING_PLUGIN_WARNING);
-            }
-          }
-          path.replaceWith((0, _helperModuleTransforms.buildDynamicImport)(path.node, false, true, specifier => _core.types.callExpression(_core.types.memberExpression(_core.types.identifier(state.contextIdent), _core.types.identifier("import")), [specifier])));
-        }
-      },
-      MetaProperty(path, state) {
-        if (path.node.meta.name === "import" && path.node.property.name === "meta") {
-          path.replaceWith(_core.types.memberExpression(_core.types.identifier(state.contextIdent), _core.types.identifier("meta")));
-        }
-      },
-      ReferencedIdentifier(path, state) {
-        if (path.node.name === "__moduleName" && !path.scope.hasBinding("__moduleName")) {
-          path.replaceWith(_core.types.memberExpression(_core.types.identifier(state.contextIdent), _core.types.identifier("id")));
-        }
-      },
-      Program: {
-        enter(path, state) {
-          state.contextIdent = path.scope.generateUid("context");
-          state.stringSpecifiers = new Set();
-          if (!allowTopLevelThis) {
-            (0, _helperModuleTransforms.rewriteThis)(path);
-          }
-        },
-        exit(path, state) {
-          const scope = path.scope;
-          const exportIdent = scope.generateUid("export");
-          const {
-            contextIdent,
-            stringSpecifiers
-          } = state;
-          const exportMap = Object.create(null);
-          const modules = [];
-          const beforeBody = [];
-          const setters = [];
-          const sources = [];
-          const variableIds = [];
-          const removedPaths = [];
-          function addExportName(key, val) {
-            exportMap[key] = exportMap[key] || [];
-            exportMap[key].push(val);
-          }
-          function pushModule(source, key, specifiers) {
-            let module;
-            modules.forEach(function (m) {
-              if (m.key === source) {
-                module = m;
-              }
-            });
-            if (!module) {
-              modules.push(module = {
-                key: source,
-                imports: [],
-                exports: []
-              });
-            }
-            module[key] = module[key].concat(specifiers);
-          }
-          function buildExportCall(name, val) {
-            return _core.types.expressionStatement(_core.types.callExpression(_core.types.identifier(exportIdent), [_core.types.stringLiteral(name), val]));
-          }
-          const exportNames = [];
-          const exportValues = [];
-          const body = path.get("body");
-          for (const path of body) {
-            if (path.isFunctionDeclaration()) {
-              beforeBody.push(path.node);
-              removedPaths.push(path);
-            } else if (path.isClassDeclaration()) {
-              variableIds.push(_core.types.cloneNode(path.node.id));
-              path.replaceWith(_core.types.expressionStatement(_core.types.assignmentExpression("=", _core.types.cloneNode(path.node.id), _core.types.toExpression(path.node))));
-            } else if (path.isVariableDeclaration()) {
-              path.node.kind = "var";
-            } else if (path.isImportDeclaration()) {
-              const source = path.node.source.value;
-              pushModule(source, "imports", path.node.specifiers);
-              for (const name of Object.keys(path.getBindingIdentifiers())) {
-                scope.removeBinding(name);
-                variableIds.push(_core.types.identifier(name));
-              }
-              path.remove();
-            } else if (path.isExportAllDeclaration()) {
-              pushModule(path.node.source.value, "exports", path.node);
-              path.remove();
-            } else if (path.isExportDefaultDeclaration()) {
-              const declar = path.node.declaration;
-              if (_core.types.isClassDeclaration(declar)) {
-                const id = declar.id;
-                if (id) {
-                  exportNames.push("default");
-                  exportValues.push(scope.buildUndefinedNode());
-                  variableIds.push(_core.types.cloneNode(id));
-                  addExportName(id.name, "default");
-                  path.replaceWith(_core.types.expressionStatement(_core.types.assignmentExpression("=", _core.types.cloneNode(id), _core.types.toExpression(declar))));
-                } else {
-                  exportNames.push("default");
-                  exportValues.push(_core.types.toExpression(declar));
-                  removedPaths.push(path);
-                }
-              } else if (_core.types.isFunctionDeclaration(declar)) {
-                const id = declar.id;
-                if (id) {
-                  beforeBody.push(declar);
-                  exportNames.push("default");
-                  exportValues.push(_core.types.cloneNode(id));
-                  addExportName(id.name, "default");
-                } else {
-                  exportNames.push("default");
-                  exportValues.push(_core.types.toExpression(declar));
-                }
-                removedPaths.push(path);
-              } else {
-                path.replaceWith(buildExportCall("default", declar));
-              }
-            } else if (path.isExportNamedDeclaration()) {
-              const declar = path.node.declaration;
-              if (declar) {
-                path.replaceWith(declar);
-                if (_core.types.isFunction(declar)) {
-                  const name = declar.id.name;
-                  addExportName(name, name);
-                  beforeBody.push(declar);
-                  exportNames.push(name);
-                  exportValues.push(_core.types.cloneNode(declar.id));
-                  removedPaths.push(path);
-                } else if (_core.types.isClass(declar)) {
-                  const name = declar.id.name;
-                  exportNames.push(name);
-                  exportValues.push(scope.buildUndefinedNode());
-                  variableIds.push(_core.types.cloneNode(declar.id));
-                  path.replaceWith(_core.types.expressionStatement(_core.types.assignmentExpression("=", _core.types.cloneNode(declar.id), _core.types.toExpression(declar))));
-                  addExportName(name, name);
-                } else {
-                  if (_core.types.isVariableDeclaration(declar)) {
-                    declar.kind = "var";
-                  }
-                  for (const name of Object.keys(_core.types.getBindingIdentifiers(declar))) {
-                    addExportName(name, name);
-                  }
-                }
-              } else {
-                const specifiers = path.node.specifiers;
-                if (specifiers != null && specifiers.length) {
-                  if (path.node.source) {
-                    pushModule(path.node.source.value, "exports", specifiers);
-                    path.remove();
-                  } else {
-                    const nodes = [];
-                    for (const specifier of specifiers) {
-                      const {
-                        local,
-                        exported
-                      } = specifier;
-                      const binding = scope.getBinding(local.name);
-                      const exportedName = getExportSpecifierName(exported, stringSpecifiers);
-                      if (binding && _core.types.isFunctionDeclaration(binding.path.node)) {
-                        exportNames.push(exportedName);
-                        exportValues.push(_core.types.cloneNode(local));
-                      } else if (!binding) {
-                        nodes.push(buildExportCall(exportedName, local));
-                      }
-                      addExportName(local.name, exportedName);
-                    }
-                    path.replaceWithMultiple(nodes);
-                  }
-                } else {
-                  path.remove();
-                }
-              }
-            }
-          }
-          modules.forEach(function (specifiers) {
-            const setterBody = [];
-            // --- START FORK CHANGES ---
-            const targetHint = state.opts.generateIdentifierHint ? state.opts.generateIdentifierHint(specifiers.key) : specifiers.key;
-            const target = scope.generateUid(targetHint);
-            // --- END FORK CHANGES ---
-            for (let specifier of specifiers.imports) {
-              if (_core.types.isImportNamespaceSpecifier(specifier)) {
-                setterBody.push(_core.types.expressionStatement(_core.types.assignmentExpression("=", specifier.local, _core.types.identifier(target))));
-              } else if (_core.types.isImportDefaultSpecifier(specifier)) {
-                specifier = _core.types.importSpecifier(specifier.local, _core.types.identifier("default"));
-              }
-              if (_core.types.isImportSpecifier(specifier)) {
-                const {
-                  imported
-                } = specifier;
-                setterBody.push(_core.types.expressionStatement(_core.types.assignmentExpression("=", specifier.local, _core.types.memberExpression(_core.types.identifier(target), specifier.imported, imported.type === "StringLiteral"))));
-              }
-            }
-            if (specifiers.exports.length) {
-              const exportNames = [];
-              const exportValues = [];
-              let hasExportStar = false;
-              for (const node of specifiers.exports) {
-                if (_core.types.isExportAllDeclaration(node)) {
-                  hasExportStar = true;
-                } else if (_core.types.isExportSpecifier(node)) {
-                  const exportedName = getExportSpecifierName(node.exported, stringSpecifiers);
-                  exportNames.push(exportedName);
-                  exportValues.push(_core.types.memberExpression(_core.types.identifier(target), node.local, _core.types.isStringLiteral(node.local)));
-                } else ;
-              }
-              setterBody.push(...constructExportCall(path, _core.types.identifier(exportIdent), exportNames, exportValues, hasExportStar ? _core.types.identifier(target) : null, stringSpecifiers));
-            }
-            sources.push(_core.types.stringLiteral(specifiers.key));
-            setters.push(_core.types.functionExpression(null, [_core.types.identifier(target)], _core.types.blockStatement(setterBody)));
-          });
-          let moduleName = (0, _helperModuleTransforms.getModuleName)(this.file.opts, options);
-          if (moduleName) moduleName = _core.types.stringLiteral(moduleName);
-          (0, _helperHoistVariables.default)(path, (id, name, hasInit) => {
-            variableIds.push(id);
-            if (!hasInit && name in exportMap) {
-              for (const exported of exportMap[name]) {
-                exportNames.push(exported);
-                exportValues.push(scope.buildUndefinedNode());
-              }
-            }
-          });
-          if (variableIds.length) {
-            beforeBody.unshift(_core.types.variableDeclaration("var", variableIds.map(id => _core.types.variableDeclarator(id))));
-          }
-          if (exportNames.length) {
-            beforeBody.push(...constructExportCall(path, _core.types.identifier(exportIdent), exportNames, exportValues, null, stringSpecifiers));
-          }
-          path.traverse(reassignmentVisitor, {
-            exports: exportMap,
-            buildCall: buildExportCall,
-            scope
-          });
-          for (const path of removedPaths) {
-            path.remove();
-          }
-          let hasTLA = false;
-          path.traverse({
-            AwaitExpression(path) {
-              hasTLA = true;
-              path.stop();
-            },
-            Function(path) {
-              path.skip();
-            },
-            noScope: true
-          });
-          path.node.body = [buildTemplate({
-            SYSTEM_REGISTER: _core.types.memberExpression(_core.types.identifier(systemGlobal), _core.types.identifier("register")),
-            BEFORE_BODY: beforeBody,
-            MODULE_NAME: moduleName,
-            SETTERS: _core.types.arrayExpression(setters),
-            EXECUTE: _core.types.functionExpression(null, [], _core.types.blockStatement(path.node.body), false, hasTLA),
-            SOURCES: _core.types.arrayExpression(sources),
-            EXPORT_IDENTIFIER: _core.types.identifier(exportIdent),
-            CONTEXT_IDENTIFIER: _core.types.identifier(contextIdent)
-          })];
-        }
-      }
-    }
-  };
-});
-exports.default = _default;

package/dist/js/script_type_module_supervisor.js

@@ -1,109 +0,0 @@
-// https://twitter.com/damienmaillard/status/1554752482273787906
-const isWebkitOrSafari = typeof window.webkitConvertPointFromNodeToPage === "function";
-const superviseScriptTypeModule = async ({
-  src,
-  async
-}) => {
-  const currentScript = document.querySelector(`script[type="module"][inlined-from-src="${src}"]`);
-  const execute = isWebkitOrSafari ? createExecuteWithDynamicImport({
-    src
-  }) : createExecuteWithScript({
-    currentScript,
-    src
-  });
-  return window.__supervisor__.addExecution({
-    src,
-    async,
-    type: "js_module",
-    execute
-  });
-};
-const createExecuteWithScript = ({
-  currentScript,
-  src
-}) => {
-  const parentNode = currentScript.parentNode;
-  let nodeToReplace;
-  let currentScriptClone;
-  return async ({
-    isReload
-  }) => {
-    const urlObject = new URL(src, window.location);
-    const loadPromise = new Promise((resolve, reject) => {
-      currentScriptClone = document.createElement("script");
-      // browsers set async by default when creating script(s)
-      // we want an exact copy to preserves how code is executed
-      currentScriptClone.async = false;
-      Array.from(currentScript.attributes).forEach(attribute => {
-        currentScriptClone.setAttribute(attribute.nodeName, attribute.nodeValue);
-      });
-      if (isReload) {
-        urlObject.searchParams.set("hmr", Date.now());
-        nodeToReplace = currentScriptClone;
-        currentScriptClone.src = urlObject.href;
-      } else {
-        currentScriptClone.removeAttribute("jsenv-cooked-by");
-        currentScriptClone.removeAttribute("jsenv-inlined-by");
-        currentScriptClone.removeAttribute("jsenv-injected-by");
-        currentScriptClone.removeAttribute("inlined-from-src");
-        currentScriptClone.removeAttribute("original-position");
-        currentScriptClone.removeAttribute("original-src-position");
-        nodeToReplace = currentScript;
-        currentScriptClone.src = src;
-      }
-      currentScriptClone.addEventListener("error", reject);
-      currentScriptClone.addEventListener("load", resolve);
-      parentNode.replaceChild(currentScriptClone, nodeToReplace);
-    });
-    try {
-      await loadPromise;
-    } catch (e) {
-      // eslint-disable-next-line no-throw-literal
-      throw {
-        message: `Failed to fetch module: ${urlObject.href}`,
-        reportedBy: "script_error_event",
-        url: urlObject.href,
-        // window.error won't be dispatched for this error
-        needsReport: true
-      };
-    }
-    try {
-      return {
-        executionPromise: import(urlObject.href)
-      };
-    } catch (e) {
-      e.reportedBy = "dynamic_import";
-      throw e;
-    }
-  };
-};
-const createExecuteWithDynamicImport = ({
-  src
-}) => {
-  return async ({
-    isReload
-  }) => {
-    const urlObject = new URL(src, window.location);
-    if (isReload) {
-      urlObject.searchParams.set("hmr", Date.now());
-    }
-    try {
-      const namespace = await import(urlObject.href);
-      return {
-        executionPromise: Promise.resolve(namespace)
-      };
-    } catch (e) {
-      e.reportedBy = "dynamic_import";
-      // dynamic import would hide the error to the browser
-      // so it must be re-reported using window.reportError
-      if (typeof window.reportError === "function") {
-        window.reportError(e);
-      } else {
-        console.error(e);
-      }
-      throw e;
-    }
-  };
-};
-
-export { superviseScriptTypeModule };