@jsenv/core 36.1.1 → 36.1.3

package/dist/jsenv_core.js

@@ -1,5 +1,5 @@
 import { pathToFileURL, fileURLToPath } from "node:url";
-import { chmod, stat, lstat, readdir, promises, unlink, openSync, closeSync, rmdir, readFileSync as readFileSync$1, watch, readdirSync, statSync, writeFileSync as writeFileSync$1, mkdirSync, createReadStream, readFile, existsSync, realpathSync } from "node:fs";
+import { chmod, stat, lstat, readdir, promises, unlink, openSync, closeSync, rmdir, watch, readdirSync, statSync, writeFileSync as writeFileSync$1, mkdirSync, createReadStream, readFile, existsSync, readFileSync, realpathSync } from "node:fs";
 import crypto, { createHash } from "node:crypto";
 import { extname } from "node:path";
 import process$1 from "node:process";
@@ -14,10 +14,10 @@ import { Readable, Stream, Writable } from "node:stream";
 import { Http2ServerResponse } from "node:http2";
 import { lookup } from "node:dns";
 import { SOURCEMAP, generateSourcemapFileUrl, composeTwoSourcemaps, generateSourcemapDataUrl, createMagicSource } from "@jsenv/sourcemap";
-import { parseHtmlString, visitHtmlNodes, getHtmlNodeAttribute, analyzeScriptNode, stringifyHtmlAst, parseSrcSet, getHtmlNodeText, setHtmlNodeAttributes, getHtmlNodePosition, getHtmlNodeAttributePosition, removeHtmlNodeText, setHtmlNodeText, parseCssUrls, parseJsUrls, applyBabelPlugins, injectHtmlNodeAsEarlyAsPossible, createHtmlNode, findHtmlNode, removeHtmlNode, injectJsImport, analyzeLinkNode, injectHtmlNode, insertHtmlNodeAfter } from "@jsenv/ast";
-import { createRequire } from "node:module";
-import babelParser from "@babel/parser";
+import { parseHtmlString, visitHtmlNodes, getHtmlNodeAttribute, analyzeScriptNode, stringifyHtmlAst, parseSrcSet, getHtmlNodeText, setHtmlNodeAttributes, getHtmlNodePosition, getHtmlNodeAttributePosition, removeHtmlNodeText, setHtmlNodeText, parseCssUrls, parseJsUrls, injectHtmlNodeAsEarlyAsPossible, createHtmlNode, findHtmlNode, removeHtmlNode, applyBabelPlugins, injectJsImport, analyzeLinkNode, injectHtmlNode, insertHtmlNodeAfter } from "@jsenv/ast";
+import { convertJsModuleToJsClassic, systemJsClientFileUrlDefault } from "@jsenv/js-module-fallback";
 import { jsenvPluginSupervisor } from "@jsenv/plugin-supervisor";
+import { createRequire } from "node:module";
 
 /*
  * data:[<mediatype>][;base64],<data>
@@ -2214,23 +2214,6 @@ const extractDriveLetter = resource => {
 
 process.platform === "win32";
 
-const readFileSync = (value, {
-  as = "buffer"
-} = {}) => {
-  const fileUrl = assertAndNormalizeFileUrl(value);
-  const buffer = readFileSync$1(new URL(fileUrl));
-  if (as === "buffer") {
-    return buffer;
-  }
-  if (as === "string") {
-    return buffer.toString();
-  }
-  if (as === "json") {
-    return JSON.parse(buffer.toString());
-  }
-  throw new Error(`"as" must be one of "buffer","string","json" received "${as}"`);
-};
-
 const guardTooFastSecondCallPerFile = (callback, cooldownBetweenFileEvents = 40) => {
   const previousCallMsMap = new Map();
   return fileEvent => {
@@ -8787,10 +8770,16 @@ const createFetchUrlContentError = ({
     });
   }
   if (error.code === "ENOENT") {
-    return createFailedToFetchUrlContentError({
-      code: "NOT_FOUND",
-      reason: "no entry on filesystem"
-    });
+    const urlTried = pathToFileURL(error.path).href;
+    // ensure ENOENT is caused by trying to read the urlInfo.url
+    // any ENOENT trying to read an other file should display the error.stack
+    // because it means some side logic has failed
+    if (urlInfo.url.startsWith(urlTried)) {
+      return createFailedToFetchUrlContentError({
+        code: "NOT_FOUND",
+        reason: "no entry on filesystem"
+      });
+    }
   }
   if (error.code === "PARSE_ERROR") {
     return createFailedToFetchUrlContentError({
@@ -11395,3899 +11384,166 @@ const jsenvPluginInlining = () => {
   }, jsenvPluginInliningAsDataUrl(), jsenvPluginInliningIntoHtml()];
 };
 
-const requireFromJsenv = createRequire(import.meta.url);
-
-const babelPluginPackagePath = requireFromJsenv.resolve("@jsenv/babel-plugins");
-const babelPluginPackageUrl = pathToFileURL(babelPluginPackagePath);
-const requireBabelPlugin = createRequire(babelPluginPackageUrl);
+/*
+ * - propagate "?js_module_fallback" query string param on urls
+ * - perform conversion from js module to js classic when url uses "?js_module_fallback"
+ */
 
-const babelPluginTransformImportMetaUrl = babel => {
-  return {
-    name: "transform-import-meta-url",
-    visitor: {
-      Program: programPath => {
-        const currentUrlIdentifier = programPath.scope.generateUidIdentifier("currentUrl");
-        let used = false;
-        programPath.traverse({
-          MemberExpression: path => {
-            const node = path.node;
-            if (node.object.type === "MetaProperty" && node.object.property.name === "meta" && node.property.name === "url") {
-              // const node = babel.types.valueToNode(10)
-              const identifier = babel.types.identifier(currentUrlIdentifier.name);
-              const expressionStatement = babel.types.expressionStatement(identifier);
-              path.replaceWith(expressionStatement);
-              used = true;
-            }
-          }
-        });
-        if (used) {
-          const ast = generateExpressionAst(`document.currentScript.src`);
-          programPath.scope.push({
-            id: currentUrlIdentifier,
-            init: ast
-          });
-        }
+const jsenvPluginJsModuleConversion = ({
+  systemJsInjection,
+  systemJsClientFileUrl,
+  generateJsClassicFilename
+}) => {
+  const isReferencingJsModule = reference => {
+    if (reference.type === "js_import" || reference.subtype === "system_register_arg" || reference.subtype === "system_import_arg") {
+      return true;
+    }
+    if (reference.type === "js_url" && reference.expectedType === "js_module") {
+      return true;
+    }
+    return false;
+  };
+  const shouldPropagateJsModuleConversion = (reference, context) => {
+    if (isReferencingJsModule(reference)) {
+      const parentUrlInfo = context.urlGraph.getUrlInfo(reference.parentUrl);
+      if (!parentUrlInfo) {
+        return false;
       }
+      const parentGotAsJsClassic = new URL(parentUrlInfo.url).searchParams.has("js_module_fallback");
+      return parentGotAsJsClassic;
     }
+    return false;
+  };
+  const markAsJsClassicProxy = reference => {
+    reference.expectedType = "js_classic";
+    reference.filename = generateJsClassicFilename(reference.url);
+  };
+  const turnIntoJsClassicProxy = reference => {
+    const urlTransformed = injectQueryParams(reference.url, {
+      js_module_fallback: ""
+    });
+    markAsJsClassicProxy(reference);
+    return urlTransformed;
   };
-};
-const generateExpressionAst = (expression, options) => {
-  const {
-    parseExpression
-  } = babelParser;
-  const ast = parseExpression(expression, options);
-  return ast;
-};
-
-const babelPluginTransformImportMetaResolve = () => {
   return {
-    name: "transform-import-meta-resolve",
-    visitor: {
-      Program: programPath => {
-        programPath.traverse({
-          MemberExpression: path => {
-            const node = path.node;
-            if (node.object.type === "MetaProperty" && node.object.property.name === "meta" && node.property.name === "resolve") {
-              const firstArg = node.arguments[0];
-              if (firstArg && firstArg.type === "StringLiteral") {
-                path.replaceWithSourceString(`new URL(${firstArg.value}, document.currentScript.src).href`);
-              }
-            }
-          }
+    name: "jsenv:js_module_conversion",
+    appliesDuring: "*",
+    redirectReference: (reference, context) => {
+      if (reference.searchParams.has("js_module_fallback")) {
+        markAsJsClassicProxy(reference);
+        return null;
+      }
+      // We want to propagate transformation of js module to js classic to:
+      // - import specifier (static/dynamic import + re-export)
+      // - url specifier when inside System.register/_context.import()
+      //   (because it's the transpiled equivalent of static and dynamic imports)
+      // And not other references otherwise we could try to transform inline resources
+      // or specifiers inside new URL()...
+      if (shouldPropagateJsModuleConversion(reference, context)) {
+        return turnIntoJsClassicProxy(reference);
+      }
+      return null;
+    },
+    fetchUrlContent: async (urlInfo, context) => {
+      const [jsModuleReference, jsModuleUrlInfo] = context.getWithoutSearchParam({
+        urlInfo,
+        context,
+        searchParam: "js_module_fallback",
+        // override the expectedType to "js_module"
+        // because when there is ?js_module_fallback it means the underlying resource
+        // is a js_module
+        expectedType: "js_module"
+      });
+      if (!jsModuleReference) {
+        return null;
+      }
+      await context.fetchUrlContent(jsModuleUrlInfo, {
+        reference: jsModuleReference
+      });
+      if (context.dev) {
+        context.referenceUtils.found({
+          type: "js_import",
+          subtype: jsModuleReference.subtype,
+          specifier: jsModuleReference.url,
+          expectedType: "js_module"
         });
+      } else if (context.build && jsModuleUrlInfo.dependents.size === 0) {
+        context.urlGraph.deleteUrlInfo(jsModuleUrlInfo.url);
       }
+      const {
+        content,
+        sourcemap
+      } = await convertJsModuleToJsClassic({
+        rootDirectoryUrl: context.rootDirectoryUrl,
+        systemJsInjection,
+        systemJsClientFileUrl,
+        urlInfo,
+        jsModuleUrlInfo
+      });
+      return {
+        content,
+        contentType: "text/javascript",
+        type: "js_classic",
+        originalUrl: jsModuleUrlInfo.originalUrl,
+        originalContent: jsModuleUrlInfo.originalContent,
+        sourcemap,
+        data: jsModuleUrlInfo.data
+      };
     }
   };
 };
 
-// eslint-disable-next-line import/no-default-export
-const helpers_string_1 = '// A type of promise-like that resolves synchronously and supports only one observer\nexport const _Pact = /*#__PURE__*/(function() {\n\tfunction _Pact() {}\n\t_Pact.prototype.then = function(onFulfilled, onRejected) {\n\t\tconst result = new _Pact();\n\t\tconst state = this.s;\n\t\tif (state) {\n\t\t\tconst callback = state & 1 ? onFulfilled : onRejected;\n\t\t\tif (callback) {\n\t\t\t\ttry {\n\t\t\t\t\t_settle(result, 1, callback(this.v));\n\t\t\t\t} catch (e) {\n\t\t\t\t\t_settle(result, 2, e);\n\t\t\t\t}\n\t\t\t\treturn result;\n\t\t\t} else {\n\t\t\t\treturn this;\n\t\t\t}\n\t\t}\n\t\tthis.o = function(_this) {\n\t\t\ttry {\n\t\t\t\tconst value = _this.v;\n\t\t\t\tif (_this.s & 1) {\n\t\t\t\t\t_settle(result, 1, onFulfilled ? onFulfilled(value) : value);\n\t\t\t\t} else if (onRejected) {\n\t\t\t\t\t_settle(result, 1, onRejected(value));\n\t\t\t\t} else {\n\t\t\t\t\t_settle(result, 2, value);\n\t\t\t\t}\n\t\t\t} catch (e) {\n\t\t\t\t_settle(result, 2, e);\n\t\t\t}\n\t\t};\n\t\treturn result;\n\t}\n\treturn _Pact;\n})();\n\n// Settles a pact synchronously\nexport function _settle(pact, state, value) {\n\tif (!pact.s) {\n\t\tif (value instanceof _Pact) {\n\t\t\tif (value.s) {\n\t\t\t\tif (state & 1) {\n\t\t\t\t\tstate = value.s;\n\t\t\t\t}\n\t\t\t\tvalue = value.v;\n\t\t\t} else {\n\t\t\t\tvalue.o = _settle.bind(null, pact, state);\n\t\t\t\treturn;\n\t\t\t}\n\t\t}\n\t\tif (value && value.then) {\n\t\t\tvalue.then(_settle.bind(null, pact, state), _settle.bind(null, pact, 2));\n\t\t\treturn;\n\t\t}\n\t\tpact.s = state;\n\t\tpact.v = value;\n\t\tconst observer = pact.o;\n\t\tif (observer) {\n\t\t\tobserver(pact);\n\t\t}\n\t}\n}\n\nexport function _isSettledPact(thenable) {\n\treturn thenable instanceof _Pact && thenable.s & 1;\n}\n\n// Converts argument to a function that always returns a Promise\nexport function _async(f) {\n\treturn function() {\n\t\tfor (var args = [], i = 0; i < arguments.length; i++) {\n\t\t\targs[i] = arguments[i];\n\t\t}\n\t\ttry {\n\t\t\treturn Promise.resolve(f.apply(this, args));\n\t\t} catch(e) {\n\t\t\treturn Promise.reject(e);\n\t\t}\n\t}\n}\n\n// Awaits on a value that may or may not be a Promise (equivalent to the await keyword in ES2015, with continuations passed explicitly)\nexport function _await(value, then, direct) {\n\tif (direct) {\n\t\treturn then ? then(value) : value;\n\t}\n\tif (!value || !value.then) {\n\t\tvalue = Promise.resolve(value);\n\t}\n\treturn then ? value.then(then) : value;\n}\n\n// Awaits on a value that may or may not be a Promise, then ignores it\nexport function _awaitIgnored(value, direct) {\n\tif (!direct) {\n\t\treturn value && value.then ? value.then(_empty) : Promise.resolve();\n\t}\n}\n\n// Proceeds after a value has resolved, or proceeds immediately if the value is not thenable\nexport function _continue(value, then) {\n\treturn value && value.then ? value.then(then) : then(value);\n}\n\n// Proceeds after a value has resolved, or proceeds immediately if the value is not thenable\nexport function _continueIgnored(value) {\n\tif (value && value.then) {\n\t\treturn value.then(_empty);\n\t}\n}\n\n// Asynchronously iterate through an object that has a length property, passing the index as the first argument to the callback (even as the length property changes)\nexport function _forTo(array, body, check) {\n\tvar i = -1, pact, reject;\n\tfunction _cycle(result) {\n\t\ttry {\n\t\t\twhile (++i < array.length && (!check || !check())) {\n\t\t\t\tresult = body(i);\n\t\t\t\tif (result && result.then) {\n\t\t\t\t\tif (_isSettledPact(result)) {\n\t\t\t\t\t\tresult = result.v;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tresult.then(_cycle, reject || (reject = _settle.bind(null, pact = new _Pact(), 2)));\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (pact) {\n\t\t\t\t_settle(pact, 1, result);\n\t\t\t} else {\n\t\t\t\tpact = result;\n\t\t\t}\n\t\t} catch (e) {\n\t\t\t_settle(pact || (pact = new _Pact()), 2, e);\n\t\t}\n\t}\n\t_cycle();\n\treturn pact;\n}\n\n// Asynchronously iterate through an object\'s properties (including properties inherited from the prototype)\n// Uses a snapshot of the object\'s properties\nexport function _forIn(target, body, check) {\n\tvar keys = [];\n\tfor (var key in target) {\n\t\tkeys.push(key);\n\t}\n\treturn _forTo(keys, function(i) { return body(keys[i]); }, check);\n}\n\n// Asynchronously iterate through an object\'s own properties (excluding properties inherited from the prototype)\n// Uses a snapshot of the object\'s properties\nexport function _forOwn(target, body, check) {\n\tvar keys = [];\n\tfor (var key in target) {\n\t\tif (Object.prototype.hasOwnProperty.call(target, key)) {\n\t\t\tkeys.push(key);\n\t\t}\n\t}\n\treturn _forTo(keys, function(i) { return body(keys[i]); }, check);\n}\n\nexport const _iteratorSymbol = /*#__PURE__*/ typeof Symbol !== "undefined" ? (Symbol.iterator || (Symbol.iterator = Symbol("Symbol.iterator"))) : "@@iterator";\n\n// Asynchronously iterate through an object\'s values\n// Uses for...of if the runtime supports it, otherwise iterates until length on a copy\nexport function _forOf(target, body, check) {\n\tif (typeof target[_iteratorSymbol] === "function") {\n\t\tvar iterator = target[_iteratorSymbol](), step, pact, reject;\n\t\tfunction _cycle(result) {\n\t\t\ttry {\n\t\t\t\twhile (!(step = iterator.next()).done && (!check || !check())) {\n\t\t\t\t\tresult = body(step.value);\n\t\t\t\t\tif (result && result.then) {\n\t\t\t\t\t\tif (_isSettledPact(result)) {\n\t\t\t\t\t\t\tresult = result.v;\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tresult.then(_cycle, reject || (reject = _settle.bind(null, pact = new _Pact(), 2)));\n\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif (pact) {\n\t\t\t\t\t_settle(pact, 1, result);\n\t\t\t\t} else {\n\t\t\t\t\tpact = result;\n\t\t\t\t}\n\t\t\t} catch (e) {\n\t\t\t\t_settle(pact || (pact = new _Pact()), 2, e);\n\t\t\t}\n\t\t}\n\t\t_cycle();\n\t\tif (iterator.return) {\n\t\t\tvar _fixup = function(value) {\n\t\t\t\ttry {\n\t\t\t\t\tif (!step.done) {\n\t\t\t\t\t\titerator.return();\n\t\t\t\t\t}\n\t\t\t\t} catch(e) {\n\t\t\t\t}\n\t\t\t\treturn value;\n\t\t\t}\n\t\t\tif (pact && pact.then) {\n\t\t\t\treturn pact.then(_fixup, function(e) {\n\t\t\t\t\tthrow _fixup(e);\n\t\t\t\t});\n\t\t\t}\n\t\t\t_fixup();\n\t\t}\n\t\treturn pact;\n\t}\n\t// No support for Symbol.iterator\n\tif (!("length" in target)) {\n\t\tthrow new TypeError("Object is not iterable");\n\t}\n\t// Handle live collections properly\n\tvar values = [];\n\tfor (var i = 0; i < target.length; i++) {\n\t\tvalues.push(target[i]);\n\t}\n\treturn _forTo(values, function(i) { return body(values[i]); }, check);\n}\n\nexport const _asyncIteratorSymbol = /*#__PURE__*/ typeof Symbol !== "undefined" ? (Symbol.asyncIterator || (Symbol.asyncIterator = Symbol("Symbol.asyncIterator"))) : "@@asyncIterator";\n\n// Asynchronously iterate on a value using it\'s async iterator if present, or its synchronous iterator if missing\nexport function _forAwaitOf(target, body, check) {\n\tif (typeof target[_asyncIteratorSymbol] === "function") {\n\t\tvar pact = new _Pact();\n\t\tvar iterator = target[_asyncIteratorSymbol]();\n\t\titerator.next().then(_resumeAfterNext).then(void 0, _reject);\n\t\treturn pact;\n\t\tfunction _resumeAfterBody(result) {\n\t\t\tif (check && check()) {\n\t\t\t\treturn _settle(pact, 1, iterator.return ? iterator.return().then(function() { return result; }) : result);\n\t\t\t}\n\t\t\titerator.next().then(_resumeAfterNext).then(void 0, _reject);\n\t\t}\n\t\tfunction _resumeAfterNext(step) {\n\t\t\tif (step.done) {\n\t\t\t\t_settle(pact, 1);\n\t\t\t} else {\n\t\t\t\tPromise.resolve(body(step.value)).then(_resumeAfterBody).then(void 0, _reject);\n\t\t\t}\n\t\t}\n\t\tfunction _reject(error) {\n\t\t\t_settle(pact, 2, iterator.return ? iterator.return().then(function() { return error; }) : error);\n\t\t}\n\t}\n\treturn Promise.resolve(_forOf(target, function(value) { return Promise.resolve(value).then(body); }, check));\n}\n\n// Asynchronously implement a generic for loop\nexport function _for(test, update, body) {\n\tvar stage;\n\tfor (;;) {\n\t\tvar shouldContinue = test();\n\t\tif (_isSettledPact(shouldContinue)) {\n\t\t\tshouldContinue = shouldContinue.v;\n\t\t}\n\t\tif (!shouldContinue) {\n\t\t\treturn result;\n\t\t}\n\t\tif (shouldContinue.then) {\n\t\t\tstage = 0;\n\t\t\tbreak;\n\t\t}\n\t\tvar result = body();\n\t\tif (result && result.then) {\n\t\t\tif (_isSettledPact(result)) {\n\t\t\t\tresult = result.s;\n\t\t\t} else {\n\t\t\t\tstage = 1;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\tif (update) {\n\t\t\tvar updateValue = update();\n\t\t\tif (updateValue && updateValue.then && !_isSettledPact(updateValue)) {\n\t\t\t\tstage = 2;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\tvar pact = new _Pact();\n\tvar reject = _settle.bind(null, pact, 2);\n\t(stage === 0 ? shouldContinue.then(_resumeAfterTest) : stage === 1 ? result.then(_resumeAfterBody) : updateValue.then(_resumeAfterUpdate)).then(void 0, reject);\n\treturn pact;\n\tfunction _resumeAfterBody(value) {\n\t\tresult = value;\n\t\tdo {\n\t\t\tif (update) {\n\t\t\t\tupdateValue = update();\n\t\t\t\tif (updateValue && updateValue.then && !_isSettledPact(updateValue)) {\n\t\t\t\t\tupdateValue.then(_resumeAfterUpdate).then(void 0, reject);\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t}\n\t\t\tshouldContinue = test();\n\t\t\tif (!shouldContinue || (_isSettledPact(shouldContinue) && !shouldContinue.v)) {\n\t\t\t\t_settle(pact, 1, result);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif (shouldContinue.then) {\n\t\t\t\tshouldContinue.then(_resumeAfterTest).then(void 0, reject);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tresult = body();\n\t\t\tif (_isSettledPact(result)) {\n\t\t\t\tresult = result.v;\n\t\t\t}\n\t\t} while (!result || !result.then);\n\t\tresult.then(_resumeAfterBody).then(void 0, reject);\n\t}\n\tfunction _resumeAfterTest(shouldContinue) {\n\t\tif (shouldContinue) {\n\t\t\tresult = body();\n\t\t\tif (result && result.then) {\n\t\t\t\tresult.then(_resumeAfterBody).then(void 0, reject);\n\t\t\t} else {\n\t\t\t\t_resumeAfterBody(result);\n\t\t\t}\n\t\t} else {\n\t\t\t_settle(pact, 1, result);\n\t\t}\n\t}\n\tfunction _resumeAfterUpdate() {\n\t\tif (shouldContinue = test()) {\n\t\t\tif (shouldContinue.then) {\n\t\t\t\tshouldContinue.then(_resumeAfterTest).then(void 0, reject);\n\t\t\t} else {\n\t\t\t\t_resumeAfterTest(shouldContinue);\n\t\t\t}\n\t\t} else {\n\t\t\t_settle(pact, 1, result);\n\t\t}\n\t}\n}\n\n// Asynchronously implement a do ... while loop\nexport function _do(body, test) {\n\tvar awaitBody;\n\tdo {\n\t\tvar result = body();\n\t\tif (result && result.then) {\n\t\t\tif (_isSettledPact(result)) {\n\t\t\t\tresult = result.v;\n\t\t\t} else {\n\t\t\t\tawaitBody = true;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\tvar shouldContinue = test();\n\t\tif (_isSettledPact(shouldContinue)) {\n\t\t\tshouldContinue = shouldContinue.v;\n\t\t}\n\t\tif (!shouldContinue) {\n\t\t\treturn result;\n\t\t}\n\t} while (!shouldContinue.then);\n\tconst pact = new _Pact();\n\tconst reject = _settle.bind(null, pact, 2);\n\t(awaitBody ? result.then(_resumeAfterBody) : shouldContinue.then(_resumeAfterTest)).then(void 0, reject);\n\treturn pact;\n\tfunction _resumeAfterBody(value) {\n\t\tresult = value;\n\t\tfor (;;) {\n\t\t\tshouldContinue = test();\n\t\t\tif (_isSettledPact(shouldContinue)) {\n\t\t\t\tshouldContinue = shouldContinue.v;\n\t\t\t}\n\t\t\tif (!shouldContinue) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif (shouldContinue.then) {\n\t\t\t\tshouldContinue.then(_resumeAfterTest).then(void 0, reject);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tresult = body();\n\t\t\tif (result && result.then) {\n\t\t\t\tif (_isSettledPact(result)) {\n\t\t\t\t\tresult = result.v;\n\t\t\t\t} else {\n\t\t\t\t\tresult.then(_resumeAfterBody).then(void 0, reject);\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\t_settle(pact, 1, result);\n\t}\n\tfunction _resumeAfterTest(shouldContinue) {\n\t\tif (shouldContinue) {\n\t\t\tdo {\n\t\t\t\tresult = body();\n\t\t\t\tif (result && result.then) {\n\t\t\t\t\tif (_isSettledPact(result)) {\n\t\t\t\t\t\tresult = result.v;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tresult.then(_resumeAfterBody).then(void 0, reject);\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tshouldContinue = test();\n\t\t\t\tif (_isSettledPact(shouldContinue)) {\n\t\t\t\t\tshouldContinue = shouldContinue.v;\n\t\t\t\t}\n\t\t\t\tif (!shouldContinue) {\n\t\t\t\t\t_settle(pact, 1, result);\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t} while (!shouldContinue.then);\n\t\t\tshouldContinue.then(_resumeAfterTest).then(void 0, reject);\n\t\t} else {\n\t\t\t_settle(pact, 1, result);\n\t\t}\n\t}\n}\n\n// Asynchronously implement a switch statement\nexport function _switch(discriminant, cases) {\n\tvar dispatchIndex = -1;\n\tvar awaitBody;\n\touter: {\n\t\tfor (var i = 0; i < cases.length; i++) {\n\t\t\tvar test = cases[i][0];\n\t\t\tif (test) {\n\t\t\t\tvar testValue = test();\n\t\t\t\tif (testValue && testValue.then) {\n\t\t\t\t\tbreak outer;\n\t\t\t\t}\n\t\t\t\tif (testValue === discriminant) {\n\t\t\t\t\tdispatchIndex = i;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\t// Found the default case, set it as the pending dispatch case\n\t\t\t\tdispatchIndex = i;\n\t\t\t}\n\t\t}\n\t\tif (dispatchIndex !== -1) {\n\t\t\tdo {\n\t\t\t\tvar body = cases[dispatchIndex][1];\n\t\t\t\twhile (!body) {\n\t\t\t\t\tdispatchIndex++;\n\t\t\t\t\tbody = cases[dispatchIndex][1];\n\t\t\t\t}\n\t\t\t\tvar result = body();\n\t\t\t\tif (result && result.then) {\n\t\t\t\t\tawaitBody = true;\n\t\t\t\t\tbreak outer;\n\t\t\t\t}\n\t\t\t\tvar fallthroughCheck = cases[dispatchIndex][2];\n\t\t\t\tdispatchIndex++;\n\t\t\t} while (fallthroughCheck && !fallthroughCheck());\n\t\t\treturn result;\n\t\t}\n\t}\n\tconst pact = new _Pact();\n\tconst reject = _settle.bind(null, pact, 2);\n\t(awaitBody ? result.then(_resumeAfterBody) : testValue.then(_resumeAfterTest)).then(void 0, reject);\n\treturn pact;\n\tfunction _resumeAfterTest(value) {\n\t\tfor (;;) {\n\t\t\tif (value === discriminant) {\n\t\t\t\tdispatchIndex = i;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif (++i === cases.length) {\n\t\t\t\tif (dispatchIndex !== -1) {\n\t\t\t\t\tbreak;\n\t\t\t\t} else {\n\t\t\t\t\t_settle(pact, 1, result);\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t}\n\t\t\ttest = cases[i][0];\n\t\t\tif (test) {\n\t\t\t\tvalue = test();\n\t\t\t\tif (value && value.then) {\n\t\t\t\t\tvalue.then(_resumeAfterTest).then(void 0, reject);\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tdispatchIndex = i;\n\t\t\t}\n\t\t}\n\t\tdo {\n\t\t\tvar body = cases[dispatchIndex][1];\n\t\t\twhile (!body) {\n\t\t\t\tdispatchIndex++;\n\t\t\t\tbody = cases[dispatchIndex][1];\n\t\t\t}\n\t\t\tvar result = body();\n\t\t\tif (result && result.then) {\n\t\t\t\tresult.then(_resumeAfterBody).then(void 0, reject);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tvar fallthroughCheck = cases[dispatchIndex][2];\n\t\t\tdispatchIndex++;\n\t\t} while (fallthroughCheck && !fallthroughCheck());\n\t\t_settle(pact, 1, result);\n\t}\n\tfunction _resumeAfterBody(result) {\n\t\tfor (;;) {\n\t\t\tvar fallthroughCheck = cases[dispatchIndex][2];\n\t\t\tif (!fallthroughCheck || fallthroughCheck()) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tdispatchIndex++;\n\t\t\tvar body = cases[dispatchIndex][1];\n\t\t\twhile (!body) {\n\t\t\t\tdispatchIndex++;\n\t\t\t\tbody = cases[dispatchIndex][1];\n\t\t\t}\n\t\t\tresult = body();\n\t\t\tif (result && result.then) {\n\t\t\t\tresult.then(_resumeAfterBody).then(void 0, reject);\n\t\t\t\treturn;\n\t\t\t}\n\t\t}\n\t\t_settle(pact, 1, result);\n\t}\n}\n\n// Asynchronously call a function and pass the result to explicitly passed continuations\nexport function _call(body, then, direct) {\n\tif (direct) {\n\t\treturn then ? then(body()) : body();\n\t}\n\ttry {\n\t\tvar result = Promise.resolve(body());\n\t\treturn then ? result.then(then) : result;\n\t} catch (e) {\n\t\treturn Promise.reject(e);\n\t}\n}\n\n// Asynchronously call a function and swallow the result\nexport function _callIgnored(body, direct) {\n\treturn _call(body, _empty, direct);\n}\n\n// Asynchronously call a function and pass the result to explicitly passed continuations\nexport function _invoke(body, then) {\n\tvar result = body();\n\tif (result && result.then) {\n\t\treturn result.then(then);\n\t}\n\treturn then(result);\n}\n\n// Asynchronously call a function and swallow the result\nexport function _invokeIgnored(body) {\n\tvar result = body();\n\tif (result && result.then) {\n\t\treturn result.then(_empty);\n\t}\n}\n\n// Asynchronously call a function and send errors to recovery continuation\nexport function _catch(body, recover) {\n\ttry {\n\t\tvar result = body();\n\t} catch(e) {\n\t\treturn recover(e);\n\t}\n\tif (result && result.then) {\n\t\treturn result.then(void 0, recover);\n\t}\n\treturn result;\n}\n\n// Asynchronously await a promise and pass the result to a finally continuation\nexport function _finallyRethrows(body, finalizer) {\n\ttry {\n\t\tvar result = body();\n\t} catch (e) {\n\t\treturn finalizer(true, e);\n\t}\n\tif (result && result.then) {\n\t\treturn result.then(finalizer.bind(null, false), finalizer.bind(null, true));\n\t}\n\treturn finalizer(false, result);\n}\n\n// Asynchronously await a promise and invoke a finally continuation that always overrides the result\nexport function _finally(body, finalizer) {\n\ttry {\n\t\tvar result = body();\n\t} catch (e) {\n\t\treturn finalizer();\n\t}\n\tif (result && result.then) {\n\t\treturn result.then(finalizer, finalizer);\n\t}\n\treturn finalizer();\n}\n\n// Rethrow or return a value from a finally continuation\nexport function _rethrow(thrown, value) {\n\tif (thrown)\n\t\tthrow value;\n\treturn value;\n}\n\n// Empty function to implement break and other control flow that ignores asynchronous results\nexport function _empty() {\n}\n\n// Sentinel value for early returns in generators \nexport const _earlyReturn = /*#__PURE__*/ {};\n\n// Asynchronously call a function and send errors to recovery continuation, skipping early returns\nexport function _catchInGenerator(body, recover) {\n\treturn _catch(body, function(e) {\n\t\tif (e === _earlyReturn) {\n\t\t\tthrow e;\n\t\t}\n\t\treturn recover(e);\n\t});\n}\n\n// Asynchronous generator class; accepts the entrypoint of the generator, to which it passes itself when the generator should start\nexport const _AsyncGenerator = /*#__PURE__*/(function() {\n\tfunction _AsyncGenerator(entry) {\n\t\tthis._entry = entry;\n\t\tthis._pact = null;\n\t\tthis._resolve = null;\n\t\tthis._return = null;\n\t\tthis._promise = null;\n\t}\n\n\tfunction _wrapReturnedValue(value) {\n\t\treturn { value: value, done: true };\n\t}\n\tfunction _wrapYieldedValue(value) {\n\t\treturn { value: value, done: false };\n\t}\n\n\t_AsyncGenerator.prototype._yield = function(value) {\n\t\t// Yield the value to the pending next call\n\t\tthis._resolve(value && value.then ? value.then(_wrapYieldedValue) : _wrapYieldedValue(value));\n\t\t// Return a pact for an upcoming next/return/throw call\n\t\treturn this._pact = new _Pact();\n\t};\n\t_AsyncGenerator.prototype.next = function(value) {\n\t\t// Advance the generator, starting it if it has yet to be started\n\t\tconst _this = this;\n\t\treturn _this._promise = new Promise(function (resolve) {\n\t\t\tconst _pact = _this._pact;\n\t\t\tif (_pact === null) {\n\t\t\t\tconst _entry = _this._entry;\n\t\t\t\tif (_entry === null) {\n\t\t\t\t\t// Generator is started, but not awaiting a yield expression\n\t\t\t\t\t// Abandon the next call!\n\t\t\t\t\treturn resolve(_this._promise);\n\t\t\t\t}\n\t\t\t\t// Start the generator\n\t\t\t\t_this._entry = null;\n\t\t\t\t_this._resolve = resolve;\n\t\t\t\tfunction returnValue(value) {\n\t\t\t\t\t_this._resolve(value && value.then ? value.then(_wrapReturnedValue) : _wrapReturnedValue(value));\n\t\t\t\t\t_this._pact = null;\n\t\t\t\t\t_this._resolve = null;\n\t\t\t\t}\n\t\t\t\tvar result = _entry(_this);\n\t\t\t\tif (result && result.then) {\n\t\t\t\t\tresult.then(returnValue, function(error) {\n\t\t\t\t\t\tif (error === _earlyReturn) {\n\t\t\t\t\t\t\treturnValue(_this._return);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tconst pact = new _Pact();\n\t\t\t\t\t\t\t_this._resolve(pact);\n\t\t\t\t\t\t\t_this._pact = null;\n\t\t\t\t\t\t\t_this._resolve = null;\n\t\t\t\t\t\t\t_resolve(pact, 2, error);\n\t\t\t\t\t\t}\n\t\t\t\t\t});\n\t\t\t\t} else {\n\t\t\t\t\treturnValue(result);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\t// Generator is started and a yield expression is pending, settle it\n\t\t\t\t_this._pact = null;\n\t\t\t\t_this._resolve = resolve;\n\t\t\t\t_settle(_pact, 1, value);\n\t\t\t}\n\t\t});\n\t};\n\t_AsyncGenerator.prototype.return = function(value) {\n\t\t// Early return from the generator if started, otherwise abandons the generator\n\t\tconst _this = this;\n\t\treturn _this._promise = new Promise(function (resolve) {\n\t\t\tconst _pact = _this._pact;\n\t\t\tif (_pact === null) {\n\t\t\t\tif (_this._entry === null) {\n\t\t\t\t\t// Generator is started, but not awaiting a yield expression\n\t\t\t\t\t// Abandon the return call!\n\t\t\t\t\treturn resolve(_this._promise);\n\t\t\t\t}\n\t\t\t\t// Generator is not started, abandon it and return the specified value\n\t\t\t\t_this._entry = null;\n\t\t\t\treturn resolve(value && value.then ? value.then(_wrapReturnedValue) : _wrapReturnedValue(value));\n\t\t\t}\n\t\t\t// Settle the yield expression with a rejected "early return" value\n\t\t\t_this._return = value;\n\t\t\t_this._resolve = resolve;\n\t\t\t_this._pact = null;\n\t\t\t_settle(_pact, 2, _earlyReturn);\n\t\t});\n\t};\n\t_AsyncGenerator.prototype.throw = function(error) {\n\t\t// Inject an exception into the pending yield expression\n\t\tconst _this = this;\n\t\treturn _this._promise = new Promise(function (resolve, reject) {\n\t\t\tconst _pact = _this._pact;\n\t\t\tif (_pact === null) {\n\t\t\t\tif (_this._entry === null) {\n\t\t\t\t\t// Generator is started, but not awaiting a yield expression\n\t\t\t\t\t// Abandon the throw call!\n\t\t\t\t\treturn resolve(_this._promise);\n\t\t\t\t}\n\t\t\t\t// Generator is not started, abandon it and return a rejected Promise containing the error\n\t\t\t\t_this._entry = null;\n\t\t\t\treturn reject(error);\n\t\t\t}\n\t\t\t// Settle the yield expression with the value as a rejection\n\t\t\t_this._resolve = resolve;\n\t\t\t_this._pact = null;\n\t\t\t_settle(_pact, 2, error);\n\t\t});\n\t};\n\n\t_AsyncGenerator.prototype[_asyncIteratorSymbol] = function() {\n\t\treturn this;\n\t};\n\t\n\treturn _AsyncGenerator;\n})();\n';
+/*
+ * when <script type="module"> cannot be used:
+ * - ?js_module_fallback is injected into the src of <script type="module">
+ * - js inside <script type="module"> is transformed into classic js
+ * - <link rel="modulepreload"> are converted to <link rel="preload">
+ */
 
-const require = createRequire(import.meta.url);
-const defaultConfigValues = {
-  externalHelpers: false,
-  hoist: false,
-  inlineHelpers: false,
-  minify: false,
-  target: "es5",
-  topLevelAwait: "disabled",
-  asyncAwait: true
-};
-function readConfigKey(config, key) {
-  if (Object.hasOwnProperty.call(config, key)) {
-    const result = config[key];
-    if (typeof result !== "undefined") {
-      return result;
-    }
-  }
-  return defaultConfigValues[key];
-}
-function discardingIntrinsics(node) {
-  if (node.type == "V8IntrinsicIdentifier") {
-    throw new Error(`Expected either an expression or a statement, got a ${node.type}!`);
-  }
-  return node;
-}
-function clearDeclarationData(declaration) {
-  let path = declaration;
-  while (path) {
-    if (path.getData("declaration:var:2") == declaration) {
-      path.setData("declaration:var:2", null);
-    }
-    path = path.parentPath;
-  }
-}
-const constantFunctionMethods = {
-  "call": false,
-  "apply": false,
-  "bind": false
-};
-const constantStaticMethods = {
-  "Object": Object.assign({
-    "assign": true,
-    "create": true,
-    "defineProperty": true,
-    "defineProperties": true,
-    "entries": true,
-    "freeze": true,
-    "fromEntries": true,
-    "getOwnPropertyDescriptor": true,
-    "getOwnPropertyDescriptors": true,
-    "getOwnPropertyNames": true,
-    "getOwnPropertySymbols": true,
-    "getPrototypeOf": true,
-    "is": true,
-    "isExtensible": true,
-    "isFrozen": true,
-    "isSealed": true,
-    "keys": true,
-    "preventExtensions": true,
-    "seal": true,
-    "setPrototypeOf": true,
-    "values": true
-  }, constantFunctionMethods),
-  "Function": constantFunctionMethods,
-  "Boolean": constantFunctionMethods,
-  "Number": Object.assign({
-    "isNaN": true,
-    "isFinite": true,
-    "isInteger": true,
-    "isSafeInteger": true,
-    "parseFloat": true,
-    "parseInteger": true
-  }, constantFunctionMethods),
-  "Array": Object.assign({
-    "from": true,
-    "isArray": true,
-    "of": true
-  }, constantFunctionMethods),
-  "Date": Object.assign({
-    "now": true,
-    "parse": true,
-    "UTC": true
-  }, constantFunctionMethods),
-  "RegExp": constantFunctionMethods,
-  "Error": constantFunctionMethods,
-  "TypeError": constantFunctionMethods,
-  "Map": constantFunctionMethods,
-  "Set": constantFunctionMethods,
-  "WeakMap": constantFunctionMethods,
-  "WeakSet": constantFunctionMethods,
-  "Promise": Object.assign({
-    "all": true,
-    "race": true,
-    "resolve": true,
-    "reject": true
-  }, constantFunctionMethods),
-  "Math": {
-    "abs": true,
-    "acos": true,
-    "asin": true,
-    "atan": true,
-    "atan2": true,
-    "ceil": true,
-    "cos": true,
-    "exp": true,
-    "floor": true,
-    "log": true,
-    "max": true,
-    "min": true,
-    "pow": true,
-    "random": true,
-    "round": true,
-    "sin": true,
-    "sqrt": true,
-    "tan": true
-  },
-  "JSON": {
-    "parse": true,
-    "stringify": true
-  },
-  "URL": Object.assign({
-    "createObjectURL": true,
-    "revokeObjectURL": true
-  }, constantFunctionMethods),
-  "console": {
-    "assert": true,
-    "clear": true,
-    "count": true,
-    "error": true,
-    "info": true,
-    "log": true,
-    "warn": true
-  },
-  "document": {
-    "createComment": true,
-    "createElement": true,
-    "createTextNode": true,
-    "getElementsByClassName": true,
-    "getElementsByTagName": true,
-    "getElementsByName": true,
-    "getElementById": true,
-    "querySelector": true,
-    "querySelectorAll": true,
-    "write": true,
-    "writeln": true
-  },
-  "XMLHttpRequest": constantFunctionMethods,
-  "WebSocket": constantFunctionMethods,
-  "Image": constantFunctionMethods,
-  "alert": constantFunctionMethods,
-  "confirm": constantFunctionMethods,
-  "open": constantFunctionMethods,
-  "prompt": constantFunctionMethods,
-  "eval": constantFunctionMethods,
-  "isFinite": constantFunctionMethods,
-  "isNaN": constantFunctionMethods,
-  "parseInt": constantFunctionMethods,
-  "parseFloat": constantFunctionMethods,
-  "decodeURI": constantFunctionMethods,
-  "decodeURIComponent": constantFunctionMethods,
-  "encodeURI": constantFunctionMethods,
-  "encodeURIComponent": constantFunctionMethods,
-  "escape": constantFunctionMethods,
-  "unescape": constantFunctionMethods,
-  "$": constantFunctionMethods
-};
-const originalNodeMap = new WeakMap();
-const skipNodeSet = new WeakSet();
-const breakIdentifierMap = new WeakMap();
-const isHelperDefinitionSet = new WeakSet();
-const helperNameMap = new WeakMap();
-const nodeIsAsyncSet = new WeakSet();
-let helpers;
-const alwaysTruthy = Object.keys(constantStaticMethods);
-const numberNames = ["zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"];
-function default_1({
-  types,
-  traverse,
-  transformFromAst,
-  version
-}) {
-  const isNewBabel = !/^6\./.test(version);
-  function cloneNode(node) {
-    const result = types.cloneDeep(node);
-    if (types.isIdentifier(node) || types.isMemberExpression(node)) {
-      const helperName = helperNameMap.get(node);
-      if (helperName !== undefined) {
-        helperNameMap.set(result, helperName);
-      }
-    }
-    return result;
-  }
-  function wrapNodeInStatement(node) {
-    if (types.isStatement(node)) {
-      return types.blockStatement([node]);
-    }
-    if (types.isExpression(node)) {
-      return types.expressionStatement(node);
-    }
-    throw new Error(`Expected either an expression or a statement, got a ${node.type}!`);
-  }
-  function pathForNewNode(node, parentPath) {
-    let contextPath = parentPath;
-    while (contextPath != null) {
-      if (contextPath.context) {
-        const result = contextPath.context.create(parentPath.node, [node], 0, "dummy");
-        result.setContext(contextPath.context);
-        return result;
-      }
-      contextPath = contextPath.parentPath;
-    }
-    throw parentPath.buildCodeFrameError(`Unable to find a context upon which to traverse!`, TypeError);
-  }
-  function pathsPassTest(matchingNodeTest, referenceOriginalNodes) {
-    function visit(path, result, state) {
-      if (referenceOriginalNodes) {
-        const originalNode = originalNodeMap.get(path.node);
-        if (originalNode) {
-          traverse(wrapNodeInStatement(originalNode), visitor, path.scope, {
-            match: result,
-            state
-          }, path);
-          return false;
-        }
-      }
-      const doesMatch = matchingNodeTest(path);
-      if (doesMatch) {
-        result.any = true;
-        result.all = !(state.breakingLabels.length || state.unnamedBreak);
-      }
-      if (path.isBreakStatement()) {
-        const label = path.node.label;
-        if (!label) {
-          state.unnamedBreak = true;
-        } else if (state.breakingLabels.indexOf(label.name) === -1) {
-          state.breakingLabels.push(label.name);
-        }
-      }
-      if (path.isLabeledStatement()) {
-        const index = state.breakingLabels.indexOf(path.node.label.name);
-        if (index !== -1) {
-          state.breakingLabels.splice(index, 1);
-        }
-      }
-      if (path.isLoop()) {
-        state.unnamedBreak = false;
-      }
-      if (doesMatch) {
-        return false;
-      }
-      if (path.isConditional()) {
-        const test = match(path.get("test"), state);
-        const consequent = match(path.get("consequent"), state);
-        const alternate = match(path.get("alternate"), state);
-        result.any = result.any || test.any || consequent.any || alternate.any;
-        return result.all = (test.all || consequent.all && alternate.all) && !(state.breakingLabels.length || state.unnamedBreak);
-      }
-      if (path.isSwitchStatement()) {
-        const discriminant = match(path.get("discriminant"), state);
-        const cases = path.get("cases");
-        const caseMatches = cases.map((switchCase, i) => {
-          const newState = {
-            unnamedBreak: false,
-            breakingLabels: state.breakingLabels
-          };
-          const newResult = match(switchCase, newState);
-          for (i++; (!newResult.all || pathsBreakReturnOrThrow(switchCase).all) && i < cases.length; i++) {
-            const tailMatch = match(cases[i], newState);
-            newResult.all = (newResult.all || tailMatch.all) && !(state.breakingLabels.length || state.unnamedBreak);
-            newResult.any = newResult.any || tailMatch.any;
-          }
-          return newResult;
-        });
-        result.any = result.any || discriminant.any || caseMatches.some(caseMatch => caseMatch.any);
-        return result.all = (discriminant.all || cases.some(switchCase => !switchCase.node.test) && caseMatches.every(caseMatch => caseMatch.all)) && !(state.breakingLabels.length || state.unnamedBreak);
-      }
-      if (path.isDoWhileStatement()) {
-        const body = match(path.get("body"), {
-          unnamedBreak: false,
-          breakingLabels: state.breakingLabels
-        });
-        const test = match(path.get("test"), state);
-        result.any = result.any || body.any || test.any;
-        return result.all = (body.all || test.all) && !(state.breakingLabels.length || state.unnamedBreak);
-      }
-      if (path.isWhileStatement()) {
-        const testPath = path.get("test");
-        const test = match(testPath, state);
-        const body = match(path.get("body"), {
-          unnamedBreak: false,
-          breakingLabels: state.breakingLabels
-        });
-        result.any = result.any || test.any || body.any;
-        return result.all = (test.all || body.all && extractLooseBooleanValue(testPath.node) === true) && !(state.breakingLabels.length || state.unnamedBreak);
-      }
-      if (path.isForXStatement()) {
-        const right = match(path.get("right"), state);
-        const body = match(path.get("body"), {
-          unnamedBreak: false,
-          breakingLabels: state.breakingLabels
-        });
-        result.any = result.any || right.any || body.any;
-        return result.all = right.all && !(state.breakingLabels.length || state.unnamedBreak);
-      }
-      if (path.isForStatement()) {
-        const init = match(path.get("init"), state);
-        const test = match(path.get("test"), state);
-        const body = match(path.get("body"), {
-          unnamedBreak: false,
-          breakingLabels: state.breakingLabels
-        });
-        const update = match(path.get("update"), state);
-        result.any = result.any || init.any || test.any || body.any || update.any;
-        return result.all = (init.all || test.all) && !(state.breakingLabels.length || state.unnamedBreak);
-      }
-      if (path.isLogicalExpression()) {
-        const left = match(path.get("left"), state);
-        const right = match(path.get("right"), state);
-        result.any = result.any || left.any || right.any;
-        return result.all = left.all && !(state.breakingLabels.length || state.unnamedBreak);
-      }
-      if (path.isReturnStatement()) {
-        return true;
-      }
-      if (path.isBreakStatement()) {
-        return true;
-      }
-      if (path.isContinueStatement()) {
-        return true;
-      }
-      if (path.isThrowStatement()) {
-        return true;
-      }
-      if (path.isTryStatement()) {
-        const blockMatch = match(path.get("block"), state);
-        const finalizer = path.get("finalizer");
-        const finalizerMatch = match(finalizer, state);
-        const handler = path.get("handler");
-        const handlerMatch = match(handler, state);
-        result.any = result.any || blockMatch.any || handlerMatch.any || finalizerMatch.any;
-        if (finalizerMatch.all) {
-          return result.all = !(state.breakingLabels.length || state.unnamedBreak);
-        } else if (!finalizer.node) {
-          return result.all = handlerMatch.all && blockMatch.all && !(state.breakingLabels.length || state.unnamedBreak);
+const jsenvPluginJsModuleFallbackInsideHtml = ({
+  systemJsInjection,
+  systemJsClientFileUrl
+}) => {
+  const turnIntoJsClassicProxy = reference => {
+    return injectQueryParams(reference.url, {
+      js_module_fallback: ""
+    });
+  };
+  return {
+    name: "jsenv:js_module_fallback_inside_html",
+    appliesDuring: "*",
+    redirectReference: {
+      link_href: (reference, context) => {
+        if (context.systemJsTranspilation && reference.subtype === "modulepreload") {
+          return turnIntoJsClassicProxy(reference);
         }
-        return false;
-      }
-      if (path.isFunction()) {
-        return false;
-      }
-    }
-    const visitor = {
-      enter(path) {
-        switch (visit(path, this.match, this.state)) {
-          case true:
-            path.stop();
-            break;
-          case false:
-            path.skip();
-            break;
+        if (context.systemJsTranspilation && reference.subtype === "preload" && reference.expectedType === "js_module") {
+          return turnIntoJsClassicProxy(reference);
         }
-      }
-    };
-    function match(path, state) {
-      const match = {
-        all: false,
-        any: false
-      };
-      if (path && path.node) {
-        if (typeof visit(path, match, state) === "undefined") {
-          path.traverse(visitor, {
-            match,
-            state
-          });
+        return null;
+      },
+      script: (reference, context) => {
+        if (context.systemJsTranspilation && reference.expectedType === "js_module") {
+          return turnIntoJsClassicProxy(reference);
         }
-      }
-      return match;
-    }
-    return path => match(path, {
-      breakingLabels: [],
-      unnamedBreak: false
-    });
-  }
-  function pathsReachNodeTypes(matchingNodeTypes, referenceOriginalNodes) {
-    return pathsPassTest(path => path.type !== null && path.type !== undefined && matchingNodeTypes.indexOf(path.type) !== -1, referenceOriginalNodes);
-  }
-  const pathsReturn = pathsReachNodeTypes(["ReturnStatement"], true);
-  const pathsReturnOrThrow = pathsReachNodeTypes(["ReturnStatement", "ThrowStatement"], true);
-  const pathsReturnOrThrowCurrentNodes = pathsReachNodeTypes(["ReturnStatement", "ThrowStatement"], false);
-  const pathsBreak = pathsReachNodeTypes(["BreakStatement"], true);
-  const pathsBreakReturnOrThrow = pathsReachNodeTypes(["ReturnStatement", "ThrowStatement", "BreakStatement"], true);
-  function isNonEmptyStatement(statement) {
-    return !types.isEmptyStatement(statement);
-  }
-  function expressionInSingleReturnStatement(target) {
-    const body = target.body;
-    if (types.isBlockStatement(body)) {
-      const statements = body.body.filter(isNonEmptyStatement);
-      if (statements.length === 0) {
-        return voidExpression();
-      } else {
-        const firstStatement = statements[0];
-        if (types.isReturnStatement(firstStatement)) {
-          return firstStatement.argument || voidExpression();
+        return null;
+      },
+      js_url: (reference, context) => {
+        if (context.systemJsTranspilation && reference.expectedType === "js_module") {
+          return turnIntoJsClassicProxy(reference);
         }
+        return null;
       }
-    } else {
-      return body;
-    }
-  }
-  function propertyNameOfMemberExpression(node) {
-    const property = node.property;
-    if (node.computed) {
-      if (types.isStringLiteral(property)) {
-        return property.value;
-      }
-    } else {
-      if (types.isIdentifier(property)) {
-        return property.name;
-      }
-    }
-  }
-  function identifiersInForToLengthStatement(statement) {
-    const init = statement.get("init");
-    if (init.isVariableDeclaration() && init.node.declarations.length === 1) {
-      const declaration = init.get("declarations")[0];
-      if (types.isNumericLiteral(declaration.node.init) && declaration.node.init.value === 0) {
-        const i = declaration.node.id;
-        const test = statement.get("test");
-        if (types.isIdentifier(i) && test.isBinaryExpression() && test.node.operator === "<" && types.isIdentifier(test.node.left) && test.node.left.name === i.name) {
-          const right = test.get("right");
-          if (right.isMemberExpression()) {
-            const object = right.node.object;
-            if (types.isIdentifier(object) && propertyNameOfMemberExpression(right.node) === "length") {
-              const update = statement.get("update");
-              if (update.isUpdateExpression() && update.node.operator == "++" && types.isIdentifier(update.node.argument) && update.node.argument.name === i.name) {
-                const binding = statement.scope.getBinding(i.name);
-                if (binding) {
-                  const updateArgument = update.get("argument");
-                  if (!binding.constantViolations.some(cv => cv !== updateArgument && cv !== update)) {
-                    return {
-                      i,
-                      array: object
-                    };
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  function extractForOwnBodyPath(path) {
-    let left = path.get("left");
-    if (left.isVariableDeclaration()) {
-      left = left.get("declarations")[0].get("id");
-    }
-    const right = path.get("right");
-    if (left.isIdentifier() && right.isIdentifier()) {
-      const rightBinding = path.scope.getBinding(right.node.name);
-      if (rightBinding && rightBinding.constant) {
-        let body = path.get("body");
-        for (;;) {
-          let statements;
-          if (body.isBlockStatement()) {
-            statements = body.get("body");
-          } else if (body.isReturnStatement()) {
-            const argument = body.get("argument");
-            if (argument.isCallExpression() && invokeTypeOfExpression(argument) && argument.get("arguments").length === 1) {
-              const firstArgument = argument.get("arguments")[0];
-              if (firstArgument.isFunctionExpression()) {
-                statements = firstArgument.get("body").get("body");
-              } else {
-                break;
-              }
-            } else {
-              break;
-            }
-          } else {
-            break;
-          }
-          if (statements.length !== 1) {
-            return;
-          }
-          body = statements[0];
-        }
-        if (body.isIfStatement() && !body.node.alternate) {
-          const test = body.get("test");
-          if (test.isCallExpression() && test.node.arguments.length === 2) {
-            const args = test.get("arguments");
-            const firstArg = args[0];
-            const secondArg = args[1];
-            if (firstArg.isIdentifier() && firstArg.node.name === right.node.name && secondArg.isIdentifier() && secondArg.node.name === left.node.name) {
-              const callee = test.get("callee");
-              if (callee.isMemberExpression() && propertyNameOfMemberExpression(callee.node) === "call") {
-                let method = callee.get("object");
-                if (method.isMemberExpression() && propertyNameOfMemberExpression(method.node) === "hasOwnProperty") {
-                  let target = method.get("object");
-                  if (target.isObjectExpression() && target.node.properties.length === 0) {
-                    return body.get("consequent");
-                  }
-                  if (target.isMemberExpression() && propertyNameOfMemberExpression(target.node) === "prototype") {
-                    target = target.get("object");
-                  }
-                  if (target.isIdentifier() && target.node.name === "Object") {
-                    return body.get("consequent");
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  function isContinuation(possible) {
-    return types.isFunctionExpression(possible) && possible.id === null || types.isArrowFunctionExpression(possible);
-  }
-  function isPassthroughContinuation(continuation) {
-    if (continuation) {
-      if (isContinuation(continuation) && continuation.params.length === 1) {
-        const expression = expressionInSingleReturnStatement(continuation);
-        if (expression) {
-          const firstParam = continuation.params[0];
-          if (types.isIdentifier(firstParam)) {
-            const valueName = firstParam.name;
-            if (types.isIdentifier(expression) && expression.name === valueName) {
-              return true;
-            }
-            if (types.isConditionalExpression(expression) && types.isIdentifier(expression.test) && types.isIdentifier(expression.consequent) && expression.consequent.name === valueName && types.isIdentifier(expression.alternate) && expression.alternate.name === valueName) {
-              return true;
-            }
-          }
-        }
-      }
-    }
-    return false;
-  }
-  function isEmptyContinuation(continuation) {
-    if (types.isIdentifier(continuation)) {
-      return helperNameMap.get(continuation) === "_empty";
-    }
-    if (isContinuation(continuation)) {
-      const body = continuation.body;
-      if (types.isBlockStatement(body)) {
-        return body.body.length === 0;
-      }
-    }
-    return false;
-  }
-  function voidExpression(arg) {
-    return types.unaryExpression("void", arg || types.numericLiteral(0));
-  }
-  function simplifyWithIdentifier(expression, identifier, truthy) {
-    if (types.isCallExpression(expression)) {
-      switch (promiseCallExpressionType(expression)) {
-        case "all":
-        case "race":
-        case "reject":
-        case "resolve":
-          {
-            const firstArgument = expression.arguments[0];
-            if (types.isExpression(firstArgument)) {
-              const simplified = simplifyWithIdentifier(firstArgument, identifier, truthy);
-              return simplified === expression.arguments[0] ? expression : types.callExpression(expression.callee, [simplified]);
-            }
-          }
-        case "then":
-          {
-            const callee = expression.callee;
-            if (types.isMemberExpression(callee)) {
-              const thenArgument = expression.arguments[0];
-              const object = callee.object;
-              if (types.isCallExpression(object)) {
-                const valueArgument = object.arguments[0];
-                if (types.isExpression(valueArgument) && types.isExpression(thenArgument)) {
-                  const simplified = simplifyWithIdentifier(valueArgument, identifier, truthy);
-                  return simplified === valueArgument ? expression : callThenMethod(types.callExpression(object.callee, [simplified]), thenArgument);
-                }
-              }
-            }
-          }
-      }
-      if (expression.arguments.length === 1 && types.isIdentifier(expression.callee) || isContinuation(expression.callee)) {
-        const firstArgument = expression.arguments[0];
-        if (types.isExpression(firstArgument)) {
-          const simplified = simplifyWithIdentifier(firstArgument, identifier, truthy);
-          return simplified === expression.arguments[0] ? expression : types.callExpression(expression.callee, [simplified]);
-        }
-      }
-    }
-    if (types.isConditionalExpression(expression) && types.isIdentifier(expression.test) && expression.test.name === identifier.name) {
-      return truthy ? expression.consequent : expression.alternate;
-    }
-    if (types.isLogicalExpression(expression) && types.isIdentifier(expression.left) && expression.left.name === identifier.name) {
-      if (expression.operator === "&&") {
-        return truthy ? expression.right : expression.left;
-      }
-      if (expression.operator === "||") {
-        return truthy ? expression.left : expression.right;
-      }
-    }
-    return expression;
-  }
-  function isIdentifierOrLiteral(expression) {
-    return types.isIdentifier(expression) || types.isLiteral(expression);
-  }
-  function simpleExpressionForContinuation(continuation, value) {
-    if (isContinuation(continuation)) {
-      let expression = expressionInSingleReturnStatement(continuation);
-      if (expression) {
-        switch (continuation.params.length) {
-          case 0:
-            if (types.isConditionalExpression(expression) && isIdentifierOrLiteral(expression.test) && isIdentifierOrLiteral(expression.consequent) && isIdentifierOrLiteral(expression.alternate) || (types.isLogicalExpression(expression) || types.isBinaryExpression(expression)) && isIdentifierOrLiteral(expression.left) && isIdentifierOrLiteral(expression.right) || types.isUnaryExpression(expression) && isIdentifierOrLiteral(expression.argument) || types.isCallExpression(expression) && isIdentifierOrLiteral(expression.callee) && expression.arguments.length === 0 || isIdentifierOrLiteral(expression)) {
-              return expression;
-            }
-            break;
-          case 1:
-            {
-              if (!value) {
-                return;
-              }
-              const firstParam = continuation.params[0];
-              const replace = expr => types.isIdentifier(firstParam) && types.isIdentifier(expr) && expr.name === firstParam.name ? value : discardingIntrinsics(expr);
-              if (isIdentifierOrLiteral(expression)) {
-                return replace(expression);
-              }
-              if (types.isConditionalExpression(expression) && isIdentifierOrLiteral(expression.test) && isIdentifierOrLiteral(expression.consequent) && isIdentifierOrLiteral(expression.alternate)) {
-                return types.conditionalExpression(replace(expression.test), replace(expression.consequent), replace(expression.alternate));
-              }
-              if (types.isLogicalExpression(expression) && isIdentifierOrLiteral(expression.left) && isIdentifierOrLiteral(expression.right)) {
-                return types.logicalExpression(expression.operator, replace(expression.left), replace(expression.right));
-              }
-              if (types.isBinaryExpression(expression) && isIdentifierOrLiteral(expression.left) && isIdentifierOrLiteral(expression.right)) {
-                return types.binaryExpression(expression.operator, replace(expression.left), replace(expression.right));
-              }
-              if (types.isCallExpression(expression) && isIdentifierOrLiteral(expression.callee) && expression.arguments.length === 0) {
-                return types.callExpression(replace(expression.callee), expression.arguments);
-              }
-            }
-        }
-      }
-    }
-  }
-  function awaitAndContinue(state, path, value, continuation, directExpression) {
-    const declarators = [];
-    if (continuation) {
-      if (isPassthroughContinuation(continuation)) {
-        continuation = undefined;
-      } else {
-        continuation = unwrapReturnCallWithPassthroughArgument(continuation, path.scope);
-      }
-    }
-    if (!continuation && directExpression && extractLooseBooleanValue(directExpression) === true) {
-      return {
-        declarators,
-        expression: value
-      };
-    }
-    if (types.isCallExpression(value) && value.arguments.length === 0 && isContinuation(value.callee) && value.callee.params.length === 0) {
-      const newValue = expressionInSingleReturnStatement(value.callee);
-      if (newValue) {
-        value = newValue;
-      }
-    }
-    if (continuation && !directExpression && types.isCallExpression(value) && types.isMemberExpression(value.callee) && helperNameMap.get(value.callee) === "_yield") {
-      return {
-        declarators,
-        expression: callThenMethod(value, continuation)
-      };
-    }
-    if (readConfigKey(state.opts, "inlineHelpers")) {
-      if (directExpression) {
-        const resolvedValue = types.callExpression(promiseResolve(), [value]);
-        const direct = extractLooseBooleanValue(directExpression);
-        if (typeof direct === "undefined") {
-          let expression;
-          if (continuation) {
-            let simpleExpression;
-            if (!types.isIdentifier(continuation) && !(simpleExpression = simpleExpressionForContinuation(continuation, isIdentifierOrLiteral(value) ? value : undefined))) {
-              const id = path.scope.generateUidIdentifier("temp");
-              if (isContinuation(continuation)) {
-                if (!path.parentPath) {
-                  throw path.buildCodeFrameError(`Expected a parent path!`, Error);
-                }
-                insertFunctionIntoScope(continuation, id, path.parentPath.scope);
-              } else {
-                declarators.push(types.variableDeclarator(id, continuation));
-              }
-              continuation = id;
-            }
-            expression = conditionalExpression(directExpression, simpleExpression || types.callExpression(continuation, [value]), callThenMethod(resolvedValue, continuation));
-          } else {
-            expression = conditionalExpression(directExpression, value, resolvedValue);
-          }
-          return {
-            declarators,
-            expression
-          };
-        } else if (direct) {
-          return {
-            declarators,
-            expression: continuation ? types.callExpression(continuation, [value]) : value
-          };
-        } else {
-          return {
-            declarators,
-            expression: continuation ? callThenMethod(resolvedValue, continuation) : resolvedValue
-          };
-        }
-      } else if (continuation) {
-        if (!types.isIdentifier(value)) {
-          if (types.isCallExpression(value) && promiseCallExpressionType(value) !== undefined) {
-            return {
-              declarators,
-              expression: callThenMethod(value, continuation)
-            };
-          }
-          const id = path.scope.generateUidIdentifier("temp");
-          declarators.push(types.variableDeclarator(id, value));
-          value = id;
-        }
-        const isEmpty = isEmptyContinuation(continuation);
-        let simpleExpression;
-        if (!isEmpty && !types.isIdentifier(continuation) && !(simpleExpression = simpleExpressionForContinuation(continuation, value))) {
-          const id = path.scope.generateUidIdentifier("temp");
-          if (isContinuation(continuation)) {
-            if (!path.parentPath) {
-              throw path.buildCodeFrameError(`Expected a parent path!`, Error);
-            }
-            insertFunctionIntoScope(continuation, id, path.parentPath.scope);
-          } else {
-            declarators.push(types.variableDeclarator(id, continuation));
-          }
-          continuation = id;
-        }
-        return {
-          declarators,
-          expression: types.conditionalExpression(types.logicalExpression("&&", value, types.memberExpression(value, types.identifier("then"))), callThenMethod(value, continuation), simpleExpression ? simpleExpression : isEmpty ? voidExpression() : types.callExpression(continuation, [value]))
-        };
-      }
-    }
-    const callTarget = types.isCallExpression(value) && value.arguments.length === 0 && !types.isMemberExpression(value.callee) ? value.callee : undefined;
-    const args = [callTarget || value];
-    const ignoreResult = continuation && isEmptyContinuation(continuation);
-    if (!ignoreResult && continuation) {
-      args.push(continuation);
-    }
-    if (directExpression && extractLooseBooleanValue(directExpression) !== false) {
-      if (!ignoreResult && !continuation) {
-        args.push(voidExpression());
-      }
-      args.push(directExpression);
-    }
-    const baseHelper = directExpression ? callTarget ? "_call" : "_await" : callTarget ? "_invoke" : "_continue";
-    const helperName = ignoreResult ? baseHelper + "Ignored" : baseHelper;
-    if (args.length === 1) {
-      switch (helperName) {
-        case "_invoke":
-          return {
-            declarators,
-            expression: types.callExpression(args[0], [])
-          };
-        case "_continue":
-          return {
-            declarators,
-            expression: discardingIntrinsics(args[0])
-          };
-        case "_continueIgnored":
-          const firstArgument = args[0];
-          if (types.isCallExpression(firstArgument) && (types.isIdentifier(firstArgument.callee) || types.isMemberExpression(firstArgument.callee))) {
-            if (helperNameMap.get(firstArgument.callee) === "_continueIgnored") {
-              return {
-                declarators,
-                expression: firstArgument
-              };
-            }
-          }
-      }
-    }
-    return {
-      declarators,
-      expression: types.callExpression(helperReference(state, path, helperName), args.map(discardingIntrinsics))
-    };
-  }
-  function borrowTail(target) {
-    let current = target;
-    const dest = [];
-    while (current && current.node && current.inList && current.container) {
-      const siblings = current.getAllNextSiblings();
-      for (const sibling of siblings) {
-        sibling.assertStatement();
-        dest.push(sibling.node);
-      }
-      for (const sibling of siblings) {
-        sibling.remove();
-      }
-      current = current.parentPath;
-      if (!current || !current.isBlockStatement()) {
-        break;
-      }
-    }
-    return dest;
-  }
-  function exitsInTail(target) {
-    let current = target;
-    while (current && current.node && current.inList && current.container && !current.isFunction()) {
-      for (var i = current.key + 1; i < current.container.length; i++) {
-        if (pathsReturnOrThrow(current).any) {
-          return true;
-        }
-      }
-      current = current.parentPath;
-    }
-    return false;
-  }
-  function returnStatement(argument, originalNode) {
-    const result = types.returnStatement(argument);
-    skipNodeSet.add(result);
-    if (originalNode !== undefined) {
-      originalNodeMap.set(result, originalNode);
-    }
-    return result;
-  }
-  function removeUnnecessaryReturnStatements(blocks) {
-    while (blocks.length) {
-      const lastStatement = blocks[blocks.length - 1];
-      if (types.isReturnStatement(lastStatement)) {
-        if (lastStatement.argument === null || lastStatement.argument === undefined) {
-          blocks = blocks.slice(0, blocks.length - 1);
-        } else {
-          if (types.isConditionalExpression(lastStatement.argument) && types.isUnaryExpression(lastStatement.argument.alternate) && lastStatement.argument.alternate.operator === "void" && isValueLiteral(lastStatement.argument.alternate.argument)) {
-            blocks = blocks.slice(0, blocks.length - 1);
-            blocks.push(types.ifStatement(lastStatement.argument.test, types.returnStatement(lastStatement.argument.consequent)));
-          } else if (blocks.length > 1) {
-            const previousStatement = blocks[blocks.length - 2];
-            if (types.isIfStatement(previousStatement) && !previousStatement.alternate) {
-              let consequent = previousStatement.consequent;
-              while (types.isBlockStatement(consequent)) {
-                if (consequent.body.length !== 1) {
-                  return blocks;
-                }
-                consequent = consequent.body[0];
-              }
-              if (types.isReturnStatement(consequent) && consequent.argument) {
-                blocks = blocks.slice(0, blocks.length - 2);
-                blocks.push(types.returnStatement(conditionalExpression(previousStatement.test, consequent.argument, lastStatement.argument)));
-              }
-            }
-          }
-          break;
-        }
-      } else {
-        if (types.isIfStatement(lastStatement)) {
-          let consequent = lastStatement.consequent;
-          if (types.isBlockStatement(consequent)) {
-            consequent = blockStatement(removeUnnecessaryReturnStatements(consequent.body));
-          }
-          let alternate = lastStatement.alternate;
-          if (alternate) {
-            if (types.isBlockStatement(alternate)) {
-              const removedOfUnnecessary = removeUnnecessaryReturnStatements(alternate.body);
-              alternate = removedOfUnnecessary.length ? blockStatement(removedOfUnnecessary) : undefined;
-            } else if (removeUnnecessaryReturnStatements([alternate]).length === 0) {
-              alternate = undefined;
-            }
-          }
-          if (consequent !== lastStatement.consequent || alternate !== lastStatement.alternate) {
-            blocks = blocks.slice(0, blocks.length - 1);
-            blocks.push(types.ifStatement(lastStatement.test, consequent, alternate || undefined));
-          }
-        }
-        break;
-      }
-    }
-    return blocks;
-  }
-  function rewriteAsyncNode(state, parentPath, node, additionalConstantNames, exitIdentifier, unpromisify) {
-    const path = pathForNewNode(node, parentPath);
-    rewriteAsyncBlock(state, path, additionalConstantNames, exitIdentifier, unpromisify);
-    return path.node;
-  }
-  function allScopes(scope) {
-    const result = [];
-    while (scope) {
-      result.push(scope);
-      scope = scope.parent;
-    }
-    return result;
-  }
-  const hoistCallArgumentsInnerVisitor = {
-    Identifier(identifierPath) {
-      if (identifierSearchesScope(identifierPath)) {
-        const name = identifierPath.node.name;
-        if (this.argumentNames.indexOf(name) === -1) {
-          if (this.additionalConstantNames.indexOf(name) !== -1) {
-            this.scopes.push(this.path.scope.parent);
-          } else {
-            const binding = identifierPath.scope.getBinding(name) || this.path.scope.getBinding(name);
-            if (binding) {
-              const scope = binding.scope;
-              if (scope !== null) {
-                if (this.pathScopes.indexOf(scope) !== -1) {
-                  this.scopes.push(scope);
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  };
-  function isValueLiteral(node) {
-    return types.isStringLiteral(node) || types.isNumericLiteral(node) || types.isBooleanLiteral(node);
-  }
-  function keyFilter(key, value) {
-    return key === "start" || key === "end" || key === "loc" || key === "directives" || key === "leadingComments" || key === "trailingComments" || key === "innerComments" || key[0] === "_" ? undefined : value;
-  }
-  function nodesAreEquivalent(node) {
-    let cached;
-    return other => {
-      if (typeof cached === "undefined") {
-        cached = JSON.stringify(node, keyFilter);
-      }
-      return cached === JSON.stringify(other, keyFilter);
-    };
-  }
-  const reregisterVariableVisitor = {
-    VariableDeclaration(path) {
-      path.scope.registerDeclaration(path);
-    },
-    FunctionDeclaration(path) {
-      path.parentPath.scope.registerDeclaration(path);
-    },
-    ClassDeclaration(path) {
-      path.scope.registerDeclaration(path);
-    },
-    Function(path) {
-      path.skip();
-    }
-  };
-  function insertFunctionIntoScope(func, id, scope) {
-    scope.push({
-      kind: "const",
-      id,
-      init: func,
-      unique: true
-    });
-    const binding = scope.getBinding(id.name);
-    if (typeof binding === "undefined") {
-      throw scope.path.buildCodeFrameError(`Could not find newly created binding for ${id.name}!`, Error);
-    }
-    const targetPath = binding.path.parentPath;
-    if (!targetPath) {
-      throw scope.path.buildCodeFrameError(`Could not find newly created binding for ${id.name}!`, Error);
-    }
-    targetPath.replaceWith(types.functionDeclaration(id, func.params, types.isBlockStatement(func.body) ? func.body : types.blockStatement([types.returnStatement(func.body)]), func.generator, func.async));
-    reregisterDeclarations(targetPath);
-  }
-  function hoistFunctionExpressionHandler(path) {
-    path.skip();
-    const bodyPath = path.get("body");
-    if (bodyPath.isBlockStatement() && bodyPath.node.body.length === 0 && !readConfigKey(this.state.opts, "inlineHelpers")) {
-      path.replaceWith(emptyFunction(this.state, path));
-      return;
-    }
-    const argumentNames = [];
-    for (const param of path.node.params) {
-      if (types.isIdentifier(param) || types.isPattern(param) || types.isRestElement(param)) {
-        addConstantNames(argumentNames, param);
-      } else {
-        return;
-      }
-    }
-    const scopes = [];
-    const pathScopes = allScopes(path.scope.parent);
-    path.traverse(hoistCallArgumentsInnerVisitor, {
-      argumentNames,
-      scopes,
-      pathScopes,
-      path,
-      additionalConstantNames: this.additionalConstantNames
-    });
-    let scope = path.scope.getProgramParent();
-    let ancestry = [scope];
-    for (let otherScope of scopes) {
-      if (ancestry.indexOf(otherScope) === -1) {
-        scope = otherScope;
-        ancestry = ancestry.concat(allScopes(otherScope));
-      }
-    }
-    if (ancestry.indexOf(path.scope.parent) === -1) {
-      const bindings = scope.bindings;
-      const filter = nodesAreEquivalent([...path.node.params, path.node.body]);
-      for (const key of Object.getOwnPropertyNames(bindings)) {
-        const binding = bindings[key];
-        const bindingPath = binding.path;
-        if (bindingPath.isFunctionDeclaration()) {
-          if (filter([...bindingPath.node.params, bindingPath.node.body])) {
-            path.replaceWith(binding.identifier);
-            return;
-          }
-        } else if (bindingPath.isVariableDeclarator()) {
-          const init = bindingPath.get("init");
-          if (init.node && isContinuation(init.node)) {
-            if (filter([...init.node.params, init.node.body])) {
-              path.replaceWith(binding.identifier);
-              return;
-            }
-          }
-        }
-      }
-      let nameNode = path.node;
-      if (types.isExpression(nameNode) && isContinuation(nameNode)) {
-        nameNode = nameNode.body;
-      }
-      if (types.isBlockStatement(nameNode) && nameNode.body.length === 1) {
-        nameNode = nameNode.body[0];
-      }
-      if (types.isReturnStatement(nameNode) && nameNode.argument) {
-        nameNode = nameNode.argument;
-      }
-      if (types.isCallExpression(nameNode)) {
-        const callee = nameNode.callee;
-        if (types.isIdentifier(callee) && helperNameMap.has(callee)) {
-          nameNode = nameNode.arguments[0];
-        }
-      }
-      const id = isValueLiteral(nameNode) ? scope.generateUidIdentifier(nameNode.value.toString().replace(/\d/g, number => numberNames[number])) : path.scope.generateUidIdentifierBasedOnNode(nameNode, "temp");
-      const init = path.node;
-      path.replaceWith(id);
-      insertFunctionIntoScope(init, id, scope);
-    }
-  }
-  const hoistCallArgumentsVisitor = {
-    FunctionExpression: hoistFunctionExpressionHandler,
-    ArrowFunctionExpression: hoistFunctionExpressionHandler
-  };
-  function hoistCallArguments(state, path, additionalConstantNames) {
-    if (path.isCallExpression()) {
-      const callee = path.node.callee;
-      if ((types.isIdentifier(callee) || types.isMemberExpression(callee)) && helperNameMap.has(callee)) {
-        const functionParent = path.getFunctionParent();
-        if (functionParent) {
-          const scope = functionParent.scope;
-          if (scope.crawl) {
-            scope.crawl();
-          }
-        }
-        path.traverse(hoistCallArgumentsVisitor, {
-          state,
-          additionalConstantNames
-        });
-      }
-    }
-  }
-  function checkPathValidity(path) {
-    if (path.container === null) {
-      throw path.buildCodeFrameError(`Path was expected to have a container!`, TypeError);
-    }
-    if ("resync" in path && typeof path.resync === "function") {
-      path.resync();
-      if (path.container === null) {
-        throw path.buildCodeFrameError(`Path was expected to have a container, and lost its container upon resync!`, TypeError);
-      }
-    }
-  }
-  function relocateTail(generatorState, awaitExpression, statementNode, target, additionalConstantNames, temporary, exitCheck, directExpression, skipReturns) {
-    checkPathValidity(target);
-    const tail = borrowTail(target);
-    checkPathValidity(target);
-    let originalNode = types.isStatement(target.node) ? target.node : types.expressionStatement(target.node);
-    const rewrittenTail = statementNode || tail.length ? rewriteAsyncNode(generatorState, target, blockStatement((statementNode ? [statementNode] : []).concat(tail)), additionalConstantNames).body : [];
-    checkPathValidity(target);
-    let blocks = removeUnnecessaryReturnStatements(rewrittenTail.filter(isNonEmptyStatement));
-    checkPathValidity(target);
-    let replacement;
-    if (blocks.length) {
-      if (exitCheck) {
-        if (temporary && !types.isIdentifier(temporary)) {
-          const temporaryIdentifier = temporary = target.scope.generateUidIdentifier("temp");
-          const declaration = types.variableDeclaration("const", [types.variableDeclarator(temporary, temporaryIdentifier)]);
-          blocks = [declaration].concat(blocks);
-          temporary = temporaryIdentifier;
-        }
-        if (temporary !== undefined) {
-          blocks = removeUnnecessaryReturnStatements([types.ifStatement(exitCheck, returnStatement(temporary))].concat(blocks));
-        } else {
-          const minify = readConfigKey(generatorState.state.opts, "minify");
-          blocks = removeUnnecessaryReturnStatements([types.ifStatement(logicalNot(exitCheck, minify), blocks.length === 1 ? blocks[0] : blockStatement(blocks))]);
-        }
-      }
-      const fn = functionize(generatorState.state, temporary ? [temporary] : [], blockStatement(blocks), target);
-      replacement = awaitAndContinue(generatorState.state, target, awaitExpression, fn, directExpression);
-      originalNode = types.blockStatement([originalNode].concat(tail));
-    } else if (pathsReturnOrThrow(target).any || target.parentPath.isArrowFunctionExpression()) {
-      replacement = awaitAndContinue(generatorState.state, target, awaitExpression, undefined, directExpression);
-    } else {
-      replacement = awaitAndContinue(generatorState.state, target, awaitExpression, emptyFunction(generatorState.state, target), directExpression);
-    }
-    checkPathValidity(target);
-    if (target.isExpression() && target.parentPath.isArrowFunctionExpression()) {
-      target.replaceWith(replacement.expression);
-    } else if (skipReturns) {
-      target.replaceWith(replacement.expression);
-    } else if (target.isBlockStatement() && target.parentPath.isFunctionExpression()) {
-      target.replaceWith(types.blockStatement([returnStatement(replacement.expression, originalNode)]));
-    } else {
-      target.replaceWith(returnStatement(replacement.expression, originalNode));
-    }
-    if (replacement.declarators.length) {
-      reregisterDeclarations(target.insertBefore(types.variableDeclaration("const", replacement.declarators)));
-    }
-    if (readConfigKey(generatorState.state.opts, "hoist")) {
-      if (target.isExpression()) {
-        hoistCallArguments(generatorState.state, target, additionalConstantNames);
-      } else if (target.isReturnStatement()) {
-        const argument = target.get("argument");
-        if (argument.node) {
-          hoistCallArguments(generatorState.state, argument, additionalConstantNames);
-        }
-      }
-    }
-  }
-  function rewriteToNamedConstant(targetPath, callback) {
-    const declarators = Object.create(null);
-    return callback((name, path) => {
-      if (Object.hasOwnProperty.call(declarators, name)) {
-        const id = declarators[name].id;
-        const binding = targetPath.scope.getBinding(id.name);
-        if (!binding || binding.path.get("init") !== path) {
-          path.replaceWith(types.identifier(id.name));
-        }
-      } else {
-        const id = path.scope.generateUidIdentifier(name);
-        const init = path.node;
-        path.replaceWith(id);
-        const declarator = declarators[name] = {
-          kind: "const",
-          id,
-          init
-        };
-        let skip = false;
-        if (targetPath.isClassMethod() && targetPath.node.kind === "constructor") {
-          targetPath.traverse({
-            Super(path) {
-              if (!skip && path.parentPath.isCallExpression() && path.parentPath.get("callee") === path) {
-                path.stop();
-                path.getStatementParent().insertAfter(types.variableDeclaration("const", [types.variableDeclarator(id, init)]));
-                skip = true;
-              }
-            }
-          });
-        }
-        if (!skip) {
-          targetPath.scope.push(declarator);
-        }
-        const binding = targetPath.scope.getBinding(id.name);
-        if (binding) {
-          binding.path.skip();
-        }
-      }
-    });
-  }
-  const rewriteThisVisitor = {
-    Function(path) {
-      if (!path.isArrowFunctionExpression()) {
-        path.skip();
-      }
-    },
-    ThisExpression(path) {
-      this.rewrite("this", path);
-    }
-  };
-  function rewriteThisExpressions(rewritePath, targetPath) {
-    rewriteToNamedConstant(targetPath, rewrite => rewritePath.traverse(rewriteThisVisitor, {
-      rewrite
-    }));
-  }
-  function identifiersInLVal(id, result = []) {
-    switch (id.type) {
-      case "Identifier":
-        result.push(id);
-        break;
-      case "AssignmentPattern":
-        identifiersInLVal(id.left);
-        break;
-      case "ArrayPattern":
-        for (const element of id.elements) {
-          if (types.isLVal(element)) {
-            identifiersInLVal(element, result);
-          }
-        }
-        break;
-      case "RestElement":
-        identifiersInLVal(id.argument, result);
-        break;
-      case "ObjectPattern":
-        for (const property of id.properties) {
-          if (types.isRestElement(property)) {
-            identifiersInLVal(property.argument, result);
-          } else if (types.isPattern(property.value) || types.isIdentifier(property.value)) {
-            identifiersInLVal(property.value, result);
-          }
-        }
-        break;
-      default:
-        throw new Error(`Unexpected node is not an LVal: ${id}`);
-    }
-    return result;
-  }
-  function anyIdentifiersRequireHoisting(identifiers, path) {
-    const ancestry = path.getAncestry().reverse();
-    for (const id of identifiers) {
-      const binding = path.scope.getBinding(id.name);
-      if (!binding) {
-        return true;
-      }
-      const executingBeforePath = binding.referencePaths.find(referencePath => {
-        if (!referencePath.willIMaybeExecuteBefore(path)) {
-          return false;
-        }
-        const referenceAncestry = referencePath.getAncestry().reverse();
-        const length = ancestry.length < referenceAncestry.length ? ancestry.length : referenceAncestry.length;
-        for (let i = 1; i < length; i++) {
-          if (ancestry[i] !== referenceAncestry[i]) {
-            if (typeof ancestry[i].key === "number" && typeof referenceAncestry[i].key === "number" && ancestry[i].key < referenceAncestry[i].key) {
-              return false;
-            }
-            if ((ancestry[i - 1].isForOfStatement() || ancestry[i - 1].isForInStatement()) && ancestry[i].key === "left") {
-              return false;
-            }
-            if (ancestry[i - 1].isForStatement() && ancestry[i].key === "init") {
-              return false;
-            }
-          }
-        }
-        return true;
-      });
-      if (executingBeforePath) {
-        return true;
-      }
-      if (binding.referencePaths.length && path.getDeepestCommonAncestorFrom(binding.referencePaths.concat([path])) !== path.parentPath) {
-        return true;
-      }
-    }
-    return false;
-  }
-  const rewriteThisArgumentsAndHoistVisitor = {
-    Function(path) {
-      path.skip();
-      if (path.isArrowFunctionExpression()) {
-        path.traverse(rewriteThisVisitor, this);
-      }
-    },
-    Super(path) {
-      if (this.rewriteSuper) {
-        const parent = path.parentPath;
-        if (parent.isMemberExpression() && parent.get("object") === path) {
-          const property = parent.get("property");
-          if (parent.node.computed) {
-            if (!property.isStringLiteral()) {
-              throw path.buildCodeFrameError(`Expected a staticly resolvable super expression, got a computed expression of type ${property.node.type}`, TypeError);
-            }
-          }
-          const grandparent = parent.parentPath;
-          if (property.isIdentifier() && grandparent.isCallExpression() && grandparent.get("callee") === parent) {
-            this.rewrite("super$" + property.node.name, parent);
-            const args = grandparent.node.arguments.slice(0);
-            args.unshift(types.thisExpression());
-            grandparent.replaceWith(types.callExpression(types.memberExpression(parent.node, types.identifier("call")), args));
-            reregisterDeclarations(grandparent);
-          }
-        }
-      }
-    },
-    ThisExpression(path) {
-      this.rewrite("this", path);
-    },
-    Identifier(path) {
-      if (path.node.name === "arguments" && identifierSearchesScope(path)) {
-        this.rewrite("arguments", path);
-      }
-    },
-    VariableDeclaration(path) {
-      if (path.node.kind === "var") {
-        const declarations = path.get("declarations");
-        const mapped = declarations.map(declaration => ({
-          declaration,
-          identifiers: identifiersInLVal(declaration.node.id)
-        }));
-        if (mapped.some(({
-          identifiers
-        }) => anyIdentifiersRequireHoisting(identifiers, path))) {
-          if ((path.parentPath.isForInStatement() || path.parentPath.isForOfStatement()) && path.parentPath.get("left") === path && declarations.length === 1) {
-            path.replaceWith(declarations[0].node.id);
-          } else {
-            const expressions = [];
-            for (const {
-              declaration
-            } of mapped) {
-              if (declaration.node.init) {
-                expressions.push(types.assignmentExpression("=", declaration.node.id, declaration.node.init));
-              }
-            }
-            clearDeclarationData(path);
-            if (expressions.length === 0) {
-              path.remove();
-            } else if (expressions.length === 1) {
-              path.replaceWith(expressions[0]);
-            } else if (path.parentPath.isForStatement() && path.parentPath.get("init") === path) {
-              path.replaceWith(types.sequenceExpression(expressions));
-            } else {
-              path.replaceWithMultiple(expressions.map(expression => types.expressionStatement(expression)));
-            }
-          }
-          for (const {
-            identifiers
-          } of mapped) {
-            for (const id of identifiers) {
-              this.targetPath.scope.push({
-                id
-              });
-            }
-          }
-        }
-      }
-    },
-    FunctionDeclaration(path) {
-      let targetPath = path;
-      while (targetPath.parentPath.isBlockStatement()) {
-        targetPath = targetPath.parentPath;
-      }
-      for (const sibling of path.getAllPrevSiblings()) {
-        if (!sibling.isFunctionDeclaration()) {
-          const node = path.node;
-          path.remove();
-          reregisterDeclarations(sibling.insertBefore(node));
-          return;
-        }
-      }
-    }
-  };
-  function rewriteThisArgumentsAndHoistFunctions(rewritePath, targetPath, rewriteSuper) {
-    rewriteToNamedConstant(targetPath, rewrite => rewritePath.traverse(rewriteThisArgumentsAndHoistVisitor, {
-      targetPath,
-      rewrite,
-      rewriteSuper
-    }));
-  }
-  function translateTSParameterProperties(array) {
-    return array.map(n => n.type === "TSParameterProperty" ? n.parameter : n);
-  }
-  function functionize(state, params, expression, target, id) {
-    const translatedParams = translateTSParameterProperties(params);
-    if (!id && readConfigKey(state.opts, "target") === "es6") {
-      let newExpression = expression;
-      if (types.isBlockStatement(newExpression) && newExpression.body.length === 1) {
-        newExpression = newExpression.body[0];
-      }
-      if (types.isReturnStatement(newExpression) && newExpression.argument) {
-        newExpression = newExpression.argument;
-      }
-      const result = types.arrowFunctionExpression(translatedParams, types.isStatement(newExpression) && !types.isBlockStatement(newExpression) ? types.blockStatement([newExpression]) : newExpression);
-      let usesThisOrArguments = false;
-      pathForNewNode(result, target).traverse({
-        Function(path) {
-          path.skip();
-        },
-        ThisExpression(path) {
-          usesThisOrArguments = true;
-          path.stop();
-        },
-        Identifier(path) {
-          if (path.node.name === "arguments" && identifierSearchesScope(path)) {
-            usesThisOrArguments = true;
-            path.stop();
-          }
-        }
-      });
-      if (!usesThisOrArguments) {
-        return result;
-      }
-    }
-    if (types.isExpression(expression)) {
-      expression = returnStatement(expression);
-    }
-    if (!types.isBlockStatement(expression)) {
-      expression = blockStatement([expression]);
-    }
-    expression.body = removeUnnecessaryReturnStatements(expression.body);
-    return types.functionExpression(id, translatedParams, expression);
-  }
-  function blockStatement(statementOrStatements) {
-    if ("length" in statementOrStatements) {
-      return types.blockStatement(statementOrStatements.filter(statement => !types.isEmptyStatement(statement)));
-    } else if (!types.isBlockStatement(statementOrStatements)) {
-      return types.blockStatement([statementOrStatements]);
-    } else {
-      return statementOrStatements;
-    }
-  }
-  function unwrapReturnCallWithEmptyArguments(node, scope, additionalConstantNames) {
-    if (isContinuation(node)) {
-      const expression = expressionInSingleReturnStatement(node);
-      if (expression && types.isCallExpression(expression)) {
-        let callTarget;
-        switch (expression.arguments.length) {
-          case 0:
-            callTarget = expression.callee;
-            break;
-          case 1:
-            {
-              const callee = expression.callee;
-              const onlyArgument = expression.arguments[0];
-              if (types.isIdentifier(callee) && helperNameMap.get(callee) === "_call") {
-                callTarget = onlyArgument;
-              }
-              if (types.isIdentifier(callee) || types.isMemberExpression(callee)) {
-                switch (helperNameMap.get(callee)) {
-                  case "_await":
-                  case "_promiseResolve":
-                    if (types.isCallExpression(onlyArgument) && onlyArgument.arguments.length === 0) {
-                      callTarget = onlyArgument.callee;
-                    }
-                    break;
-                }
-              }
-              break;
-            }
-        }
-        if (callTarget && types.isExpression(callTarget)) {
-          if (types.isIdentifier(callTarget)) {
-            const binding = scope.getBinding(callTarget.name);
-            if (binding && binding.constant) {
-              return callTarget;
-            }
-            if (additionalConstantNames.indexOf(callTarget.name) !== -1) {
-              return callTarget;
-            }
-          } else if (isContinuation(callTarget)) {
-            return unwrapReturnCallWithEmptyArguments(callTarget, scope, additionalConstantNames);
-          }
-        }
-      }
-    }
-    return node;
-  }
-  function unwrapReturnCallWithPassthroughArgument(node, scope) {
-    if (isContinuation(node) && node.params.length >= 1) {
-      const expression = expressionInSingleReturnStatement(node);
-      if (expression && types.isCallExpression(expression) && expression.arguments.length === 1) {
-        const firstArgument = expression.arguments[0];
-        const firstParam = node.params[0];
-        if (types.isIdentifier(firstArgument) && types.isIdentifier(firstParam) && firstArgument.name === firstParam.name) {
-          if (types.isIdentifier(expression.callee)) {
-            const binding = scope.getBinding(expression.callee.name);
-            if (binding && binding.constant) {
-              return expression.callee;
-            }
-            if (Object.hasOwnProperty.call(constantStaticMethods, expression.callee.name)) {
-              return expression.callee;
-            }
-          } else if (types.isMemberExpression(expression.callee)) {
-            const propertyName = propertyNameOfMemberExpression(expression.callee);
-            if (propertyName !== undefined) {
-              const object = expression.callee.object;
-              if (types.isIdentifier(object) && Object.hasOwnProperty.call(constantStaticMethods, object.name) && !scope.getBinding(object.name)) {
-                const staticMethods = constantStaticMethods[object.name];
-                if (Object.hasOwnProperty.call(staticMethods, propertyName) && staticMethods[propertyName]) {
-                  return expression.callee;
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-    return node;
-  }
-  function isExpressionOfLiterals(path, literalNames) {
-    if (path.node === null || path.node === undefined) {
-      return true;
-    }
-    if (path.isIdentifier()) {
-      const name = path.node.name;
-      if (name === "undefined" && !path.scope.getBinding("undefined")) {
-        return true;
-      }
-      const binding = path.parentPath.scope.getBinding(name);
-      if (binding) {
-        return binding.constant;
-      }
-      if (literalNames.indexOf(name) !== -1) {
-        return true;
-      }
-      if (Object.hasOwnProperty.call(constantStaticMethods, name) && !path.scope.getBinding(name)) {
-        return true;
-      }
-      return false;
-    }
-    if (path.isMemberExpression()) {
-      const object = path.get("object");
-      if (object.isIdentifier()) {
-        const propertyName = propertyNameOfMemberExpression(path.node);
-        if (propertyName !== undefined && Object.hasOwnProperty.call(constantStaticMethods, object.node.name) && !path.scope.getBinding(object.node.name)) {
-          const staticMethods = constantStaticMethods[object.node.name];
-          if (Object.hasOwnProperty.call(staticMethods, propertyName) && staticMethods[propertyName]) {
-            return true;
-          }
-        }
-      }
-      return false;
-    }
-    if (path.isBooleanLiteral()) {
-      return true;
-    }
-    if (path.isNumericLiteral()) {
-      return true;
-    }
-    if (path.isStringLiteral()) {
-      return true;
-    }
-    if (path.isArrayExpression()) {
-      return path.get("elements").every(element => element === null || element.node === null ? true : isExpressionOfLiterals(element, literalNames));
-    }
-    if (path.isNullLiteral()) {
-      return true;
-    }
-    if (path.isObjectExpression()) {
-      return path.get("properties").every(property => {
-        if (property.isObjectProperty()) {
-          if (!property.node.computed || isExpressionOfLiterals(property.get("key"), literalNames)) {
-            return isExpressionOfLiterals(property.get("value"), literalNames);
-          }
-        } else {
-          return true;
-        }
-      });
-    }
-    if (path.isUnaryExpression()) {
-      return isExpressionOfLiterals(path.get("argument"), literalNames);
-    }
-    if (path.isLogicalExpression()) {
-      return isExpressionOfLiterals(path.get("left"), literalNames) && isExpressionOfLiterals(path.get("right"), literalNames);
-    }
-    if (path.isBinaryExpression()) {
-      return isExpressionOfLiterals(path.get("left"), literalNames) && isExpressionOfLiterals(path.get("right"), literalNames);
-    }
-    if (path.isConditionalExpression()) {
-      return isExpressionOfLiterals(path.get("test"), literalNames) && isExpressionOfLiterals(path.get("consequent"), literalNames) && isExpressionOfLiterals(path.get("alternate"), literalNames);
-    }
-    if (path.isExpression() && isContinuation(path.node)) {
-      return true;
-    }
-    return false;
-  }
-  function generateIdentifierForPath(path) {
-    const node = path.node;
-    if (node) {
-      const result = path.scope.generateUidIdentifierBasedOnNode(node, "temp");
-      if (!path.isIdentifier() || path.node.name !== result.name) {
-        return result;
-      }
-    }
-    return path.scope.generateUidIdentifier("temp");
-  }
-  function booleanLiteral(value, minify) {
-    return minify ? types.numericLiteral(value ? 1 : 0) : types.booleanLiteral(value);
-  }
-  function conditionalExpression(test, consequent, alternate) {
-    const looseValue = extractLooseBooleanValue(test);
-    if (typeof looseValue !== "undefined") {
-      return looseValue ? consequent : alternate;
-    }
-    while (types.isUnaryExpression(test) && test.operator === "!") {
-      test = test.argument;
-      const temp = consequent;
-      consequent = alternate;
-      alternate = temp;
-    }
-    if (isValueLiteral(consequent) && isValueLiteral(alternate) && consequent.value === alternate.value || types.isNullLiteral(consequent) && types.isNullLiteral(alternate) || types.isIdentifier(consequent) && types.isIdentifier(alternate) && consequent.name === alternate.name) {
-      if (types.isIdentifier(test)) {
-        return consequent;
-      }
-    }
-    if (types.isIdentifier(test)) {
-      consequent = simplifyWithIdentifier(consequent, test, true);
-      alternate = simplifyWithIdentifier(alternate, test, false);
-    }
-    return types.conditionalExpression(test, consequent, alternate);
-  }
-  function extractBooleanValue(node) {
-    if (types.isBooleanLiteral(node)) {
-      return node.value;
-    }
-    if (types.isUnaryExpression(node)) {
-      if (node.operator === "!") {
-        const result = extractLooseBooleanValue(node.argument);
-        return typeof result === "undefined" ? undefined : !result;
-      } else if (node.operator === "void") {
-        return typeof extractLooseBooleanValue(node.argument) !== "undefined" ? false : undefined;
-      }
-    }
-  }
-  function extractLooseBooleanValue(node) {
-    if (isValueLiteral(node)) {
-      return !!node.value;
-    }
-    if (types.isNullLiteral(node)) {
-      return false;
-    }
-    if (types.isIdentifier(node)) {
-      if (alwaysTruthy.indexOf(node.name) !== -1) {
-        return true;
-      }
-      if (node.name === "undefined") {
-        return false;
-      }
-    }
-    return extractBooleanValue(node);
-  }
-  function logicalOr(left, right) {
-    if (extractLooseBooleanValue(left) === true) {
-      return left;
-    } else if (extractBooleanValue(left) === false) {
-      return right;
-    } else {
-      return types.logicalExpression("||", left, right);
-    }
-  }
-  function logicalOrLoose(left, right, minify) {
-    switch (extractLooseBooleanValue(left)) {
-      case false:
-        return extractLooseBooleanValue(right) === false ? booleanLiteral(false, minify) : right;
-      case true:
-        return booleanLiteral(true, minify);
-      default:
-        switch (extractLooseBooleanValue(right)) {
-          case false:
-            return left;
-          case true:
-            return booleanLiteral(true, minify);
-          default:
-            return types.logicalExpression("||", left, right);
-        }
-    }
-  }
-  function logicalAnd(left, right, extract = extractBooleanValue) {
-    switch (extract(left)) {
-      case true:
-        return left;
-      case false:
-        return right;
-      default:
-        return types.logicalExpression("&&", left, right);
-    }
-  }
-  function logicalNot(node, minify) {
-    const literalValue = extractLooseBooleanValue(node);
-    if (typeof literalValue !== "undefined") {
-      return booleanLiteral(!literalValue, minify);
-    }
-    if (types.isUnaryExpression(node) && node.operator === "!" && types.isUnaryExpression(node.argument) && node.argument.operator === "!") {
-      return node.argument;
-    }
-    return types.unaryExpression("!", node);
-  }
-  function unwrapSpreadElement(path) {
-    if (path.node === null) {
-      return path;
-    }
-    if (path.node.type === "JSXNamespacedName") {
-      return path;
-    }
-    if (path.isExpression()) {
-      return path;
-    }
-    if (path.isSpreadElement()) {
-      return path.get("argument");
-    }
-    if (isArgumentPlaceholder(path)) {
-      return path;
-    }
-    throw path.buildCodeFrameError(`Expected either an expression or a spread element, got a ${path.type}!`, TypeError);
-  }
-  function findDeclarationToReuse(path) {
-    while (path) {
-      const parent = path.parentPath;
-      if (parent === null) {
-        break;
-      }
-      if (parent.isVariableDeclarator()) {
-        const id = parent.get("id");
-        if (id.isIdentifier() || id.isPattern()) {
-          return parent;
-        }
-      }
-      let other;
-      if (parent.isConditionalExpression()) {
-        const test = parent.get("test");
-        if (path === test) {
-          break;
-        }
-        const consequent = parent.get("consequent");
-        const alternate = parent.get("alternate");
-        other = consequent === path ? alternate : consequent;
-      } else if (parent.isLogicalExpression()) {
-        const left = parent.get("left");
-        const right = parent.get("right");
-        other = left === path ? right : left;
-      } else {
-        break;
-      }
-      const otherAwaitPath = findAwaitOrYieldPath(other);
-      if (otherAwaitPath === other || !otherAwaitPath) {
-        path = parent;
-      } else {
-        break;
-      }
-    }
-  }
-  function extractDeclarations(state, originalAwaitPath, awaitExpression, additionalConstantNames) {
-    let awaitPath = originalAwaitPath;
-    const reusingExisting = findDeclarationToReuse(awaitPath);
-    const reusingExistingId = reusingExisting ? reusingExisting.get("id") : undefined;
-    const existingIdentifier = reusingExistingId && (reusingExistingId.isIdentifier() || reusingExistingId.isPattern()) ? reusingExistingId.node : undefined;
-    let resultIdentifier;
-    if (!awaitPath.parentPath.isSequenceExpression() || !(awaitPath.key < awaitPath.container.length - 1)) {
-      const argument = originalAwaitPath.get("argument");
-      if (argument.isExpression()) {
-        resultIdentifier = existingIdentifier || generateIdentifierForPath(argument);
-      }
-    }
-    originalAwaitPath.replaceWith(types.isIdentifier(resultIdentifier) ? resultIdentifier : types.numericLiteral(0));
-    let declarations = [];
-    const isYield = originalAwaitPath.isYieldExpression();
-    let directExpression = booleanLiteral(false, readConfigKey(state.opts, "minify"));
-    for (;;) {
-      const parent = awaitPath.parentPath;
-      if (parent.isVariableDeclarator()) {
-        const beforeDeclarations = [];
-        let skipLiterals = true;
-        for (let key = parent.key - 1; key >= 0; --key) {
-          const sibling = parent.getSibling(key);
-          if (sibling.isVariableDeclarator()) {
-            const init = sibling.get("init");
-            if (!skipLiterals || init && !isExpressionOfLiterals(init, additionalConstantNames)) {
-              skipLiterals = false;
-              beforeDeclarations.unshift(sibling.node);
-              sibling.remove();
-            }
-          } else {
-            throw sibling.buildCodeFrameError(`Expected a variable declarator, got a ${sibling.type}!`, TypeError);
-          }
-        }
-        if (beforeDeclarations.length) {
-          declarations = declarations.concat(beforeDeclarations.concat(declarations));
-        }
-      } else if (parent.isLogicalExpression()) {
-        const left = parent.get("left");
-        if (awaitPath !== left) {
-          if (!isYield && !isExpressionOfLiterals(left, additionalConstantNames)) {
-            const leftIdentifier = generateIdentifierForPath(left);
-            declarations = declarations.map(declaration => declaration.init ? types.variableDeclarator(declaration.id, logicalAnd(parent.node.operator === "||" ? logicalNot(leftIdentifier) : leftIdentifier, declaration.init)) : declaration);
-            declarations.unshift(types.variableDeclarator(leftIdentifier, left.node));
-            left.replaceWith(leftIdentifier);
-          }
-          const isOr = parent.node.operator === "||";
-          awaitExpression = (isOr ? logicalOr : logicalAnd)(left.node, awaitExpression);
-          if (!isYield) {
-            directExpression = logicalOrLoose(isOr ? left.node : logicalNot(left.node), directExpression, readConfigKey(state.opts, "minify"));
-          }
-          if (awaitPath === originalAwaitPath) {
-            if (resultIdentifier) {
-              parent.replaceWith(resultIdentifier);
-            } else {
-              resultIdentifier = existingIdentifier || generateIdentifierForPath(originalAwaitPath.get("argument"));
-              parent.replaceWith(resultIdentifier);
-            }
-            awaitPath = parent;
-            continue;
-          }
-        }
-      } else if (parent.isBinaryExpression()) {
-        const left = parent.get("left");
-        if (awaitPath !== left) {
-          if (!isExpressionOfLiterals(left, additionalConstantNames) && left.node.type !== "PrivateName") {
-            const leftIdentifier = generateIdentifierForPath(left);
-            declarations.unshift(types.variableDeclarator(leftIdentifier, left.node));
-            left.replaceWith(leftIdentifier);
-          }
-        }
-      } else if (parent.isSequenceExpression()) {
-        const children = parent.get("expressions");
-        const position = children.indexOf(awaitPath);
-        for (var i = 0; i < position; i++) {
-          const expression = children[i];
-          if (!isExpressionOfLiterals(expression, additionalConstantNames)) {
-            const sequenceIdentifier = generateIdentifierForPath(expression);
-            declarations.unshift(types.variableDeclarator(sequenceIdentifier, expression.node));
-          }
-          expression.remove();
-        }
-        if (position === children.length - 1) {
-          parent.replaceWith(children[position]);
-        }
-      } else if (parent.isConditionalExpression()) {
-        const test = parent.get("test");
-        if (awaitPath !== test) {
-          let testNode = test.node;
-          const consequent = parent.get("consequent");
-          const alternate = parent.get("alternate");
-          const other = consequent === awaitPath ? alternate : consequent;
-          const otherAwaitPath = findAwaitOrYieldPath(other);
-          let testIdentifier;
-          const isBoth = consequent === awaitPath && otherAwaitPath === alternate;
-          if (!(isBoth && awaitPath === originalAwaitPath) && !isExpressionOfLiterals(test, additionalConstantNames)) {
-            testIdentifier = generateIdentifierForPath(test);
-          }
-          declarations = declarations.map(declaration => declaration.init ? types.variableDeclarator(declaration.id, (consequent === awaitPath ? logicalAnd : logicalOr)(testIdentifier || testNode, declaration.init)) : declaration);
-          if (testIdentifier) {
-            declarations.unshift(types.variableDeclarator(testIdentifier, testNode));
-            test.replaceWith(testIdentifier);
-            testNode = testIdentifier;
-          }
-          if (isBoth && otherAwaitPath) {
-            awaitExpression = conditionalExpression(testNode, awaitExpression, otherAwaitPath.node.argument || types.identifier("undefined"));
-            if (!resultIdentifier) {
-              resultIdentifier = existingIdentifier || generateIdentifierForPath(originalAwaitPath.get("argument"));
-            }
-            alternate.replaceWith(resultIdentifier);
-            parent.replaceWith(resultIdentifier);
-          } else {
-            if (!isYield) {
-              directExpression = logicalOrLoose(consequent !== awaitPath ? testNode : logicalNot(testNode), directExpression, readConfigKey(state.opts, "minify"));
-            }
-            if (otherAwaitPath) {
-              awaitExpression = consequent !== awaitPath ? conditionalExpression(testNode, types.numericLiteral(0), awaitExpression) : conditionalExpression(testNode, awaitExpression, types.numericLiteral(0));
-            } else {
-              awaitExpression = consequent !== awaitPath ? conditionalExpression(testNode, other.node, awaitExpression) : conditionalExpression(testNode, awaitExpression, other.node);
-              if (!resultIdentifier) {
-                resultIdentifier = existingIdentifier || generateIdentifierForPath(originalAwaitPath.get("argument"));
-              }
-              if (awaitPath === originalAwaitPath) {
-                parent.replaceWith(resultIdentifier);
-                awaitPath = parent;
-                continue;
-              }
-              other.replaceWith(resultIdentifier);
-            }
-          }
-        }
-      } else if (parent.isCallExpression()) {
-        const callee = parent.get("callee");
-        if (callee !== awaitPath) {
-          for (const arg of parent.get("arguments")) {
-            const spreadArg = unwrapSpreadElement(arg);
-            if (spreadArg === awaitPath || arg === awaitPath) {
-              break;
-            }
-            if (spreadArg.isExpression() && !isExpressionOfLiterals(spreadArg, additionalConstantNames)) {
-              const argIdentifier = generateIdentifierForPath(spreadArg);
-              declarations.unshift(types.variableDeclarator(argIdentifier, spreadArg.node));
-              spreadArg.replaceWith(argIdentifier);
-            }
-          }
-          if (!isExpressionOfLiterals(callee, additionalConstantNames) && typeof promiseCallExpressionType(parent.node) === "undefined") {
-            if (callee.isMemberExpression()) {
-              const object = callee.get("object");
-              const property = callee.get("property");
-              let objectDeclarator;
-              let staticMethods = {};
-              let constantObject = false;
-              if (object.isIdentifier() && Object.hasOwnProperty.call(constantStaticMethods, object.node.name) && !callee.scope.getBinding(object.node.name)) {
-                constantObject = true;
-                staticMethods = constantStaticMethods[object.node.name];
-              } else if (isExpressionOfLiterals(object, additionalConstantNames)) {
-                constantObject = true;
-              }
-              if (!constantObject) {
-                const objectIdentifier = generateIdentifierForPath(object);
-                objectDeclarator = types.variableDeclarator(objectIdentifier, object.node);
-                object.replaceWith(objectIdentifier);
-              }
-              if (!callee.node.computed && property.isIdentifier() && (property.node.name === "call" || Object.hasOwnProperty.call(staticMethods, property.node.name))) ; else {
-                const calleeIdentifier = generateIdentifierForPath(property);
-                const calleeNode = callee.node;
-                const newArguments = parent.node.arguments.slice();
-                newArguments.unshift(Object.assign({}, object.node));
-                parent.replaceWith(types.callExpression(types.memberExpression(calleeIdentifier, types.identifier("call")), newArguments));
-                declarations.unshift(types.variableDeclarator(calleeIdentifier, calleeNode));
-              }
-              if (typeof objectDeclarator !== "undefined") {
-                declarations.unshift(objectDeclarator);
-              }
-            } else if (!callee.isIdentifier() || !(helperNameMap.has(callee.node) || (awaitPath.scope.getBinding(callee.node.name) || {
-              constant: false
-            }).constant)) {
-              const calleeIdentifier = generateIdentifierForPath(callee);
-              const calleeNode = callee.node;
-              callee.replaceWith(calleeIdentifier);
-              declarations.unshift(types.variableDeclarator(calleeIdentifier, discardingIntrinsics(calleeNode)));
-            }
-          }
-        }
-      } else if (parent.isArrayExpression()) {
-        for (const element of parent.get("elements")) {
-          const spreadElement = unwrapSpreadElement(element);
-          if (element === awaitPath || spreadElement === awaitPath) {
-            break;
-          }
-          if (spreadElement.isExpression() && !isExpressionOfLiterals(spreadElement, additionalConstantNames)) {
-            const elementIdentifier = generateIdentifierForPath(spreadElement);
-            declarations.unshift(types.variableDeclarator(elementIdentifier, spreadElement.node));
-            spreadElement.replaceWith(elementIdentifier);
-          }
-        }
-      } else if (parent.isObjectExpression()) {
-        for (const prop of parent.get("properties")) {
-          if (prop === awaitPath) {
-            break;
-          }
-          if (prop.isObjectProperty()) {
-            if (prop.node.computed) {
-              const propKey = prop.get("key");
-              if (propKey === awaitPath) {
-                break;
-              }
-              if (propKey.isExpression() && !isExpressionOfLiterals(propKey, additionalConstantNames)) {
-                const keyIdentifier = generateIdentifierForPath(propKey);
-                declarations.unshift(types.variableDeclarator(keyIdentifier, propKey.node));
-                propKey.replaceWith(keyIdentifier);
-              }
-            }
-            const propValue = prop.get("value");
-            if (propValue === awaitPath) {
-              break;
-            }
-            if (propValue.isExpression() && !isExpressionOfLiterals(propValue, additionalConstantNames)) {
-              const propIdentifier = generateIdentifierForPath(propValue);
-              declarations.unshift(types.variableDeclarator(propIdentifier, propValue.node));
-              propValue.replaceWith(propIdentifier);
-            }
-          }
-        }
-      }
-      if (parent.isStatement()) {
-        return {
-          declarationKind: reusingExisting ? reusingExisting.parent.kind : "const",
-          declarations,
-          awaitExpression,
-          directExpression,
-          reusingExisting,
-          resultIdentifier
-        };
-      }
-      awaitPath = parent;
-    }
-  }
-  function skipNode(path) {
-    path.skip();
-  }
-  const awaitPathVisitor = {
-    Function: skipNode,
-    AwaitExpression(path) {
-      this.result = path;
-      path.stop();
-    },
-    YieldExpression(path) {
-      this.result = path;
-      path.stop();
-    }
-  };
-  function findAwaitOrYieldPath(path) {
-    if (path.isAwaitExpression() || path.isYieldExpression()) {
-      return path;
-    }
-    const state = Object.create(null);
-    path.traverse(awaitPathVisitor, state);
-    return state.result;
-  }
-  function buildBreakExitCheck(state, exitIdentifier, breakIdentifiers) {
-    if (breakIdentifiers !== undefined && breakIdentifiers.length > 0) {
-      const minify = readConfigKey(state.opts, "minify");
-      const first = breakIdentifiers[0].identifier;
-      const partial = breakIdentifiers.slice(1).reduce((accumulator, {
-        identifier
-      }) => logicalOrLoose(accumulator, identifier, minify), first);
-      return exitIdentifier ? logicalOrLoose(partial, exitIdentifier, minify) : partial;
-    } else {
-      return exitIdentifier;
-    }
-  }
-  function pushMissing(destination, source) {
-    for (var value of source) {
-      var index = destination.indexOf(value);
-      if (index < 0) {
-        destination.push(value);
-      }
-    }
-  }
-  function setBreakIdentifier(value, breakIdentifier) {
-    return types.assignmentExpression("=", breakIdentifier.identifier, value);
-  }
-  function setBreakIdentifiers(breakIdentifiers, pluginState) {
-    return breakIdentifiers.reduce(setBreakIdentifier, booleanLiteral(true, readConfigKey(pluginState.opts, "minify")));
-  }
-  function expressionNeverThrows(expression) {
-    return isValueLiteral(expression) || types.isIdentifier(expression) || types.isUnaryExpression(expression) && isValueLiteral(expression.argument);
-  }
-  const replaceReturnsAndBreaksVisitor = {
-    Function: skipNode,
-    ReturnStatement(path) {
-      if (!skipNodeSet.has(path.node) && this.exitIdentifier) {
-        const minify = readConfigKey(this.pluginState.opts, "minify");
-        if (path.node.argument) {
-          if (minify && extractLooseBooleanValue(path.node.argument) === true) {
-            path.replaceWith(returnStatement(types.assignmentExpression("=", this.exitIdentifier, path.node.argument), path.node));
-          } else if (expressionNeverThrows(path.node.argument)) {
-            path.replaceWithMultiple([types.expressionStatement(types.assignmentExpression("=", this.exitIdentifier, booleanLiteral(true, minify))), returnStatement(path.node.argument, path.node)]);
-          } else {
-            const tempIdentifier = path.scope.generateUidIdentifierBasedOnNode(path.node.argument, "temp");
-            path.replaceWithMultiple([types.variableDeclaration("const", [types.variableDeclarator(tempIdentifier, path.node.argument)]), types.expressionStatement(types.assignmentExpression("=", this.exitIdentifier, booleanLiteral(true, minify))), returnStatement(tempIdentifier, path.node)]);
-          }
-        } else {
-          path.replaceWithMultiple([types.expressionStatement(types.assignmentExpression("=", this.exitIdentifier, booleanLiteral(true, minify))), returnStatement(undefined, path.node)]);
-        }
-      }
-    },
-    SwitchStatement: {
-      enter() {
-        this.switchCount++;
-      },
-      exit() {
-        this.switchCount--;
-      }
-    },
-    Loop: {
-      enter(path) {
-        const parent = path.parentPath;
-        this.breakIdentifiers.unshift({
-          identifier: types.identifier("break"),
-          path,
-          name: parent.isLabeledStatement() ? parent.node.label.name : undefined,
-          isAsync: false
-        });
-      },
-      exit() {
-        this.breakIdentifiers.shift();
-      }
-    },
-    BreakStatement(path) {
-      const label = path.node.label;
-      if (label || this.switchCount === 0) {
-        const index = label ? this.breakIdentifiers.findIndex(breakIdentifier => breakIdentifier.name === label.name) : 0;
-        const replace = returnStatement(undefined, path.node);
-        if (index !== -1 && this.breakIdentifiers.length) {
-          if (!this.breakIdentifiers[index].isAsync) {
-            return;
-          }
-          const used = this.breakIdentifiers.slice(0, index + 1);
-          if (used.length) {
-            pushMissing(this.usedIdentifiers, used);
-            path.replaceWithMultiple([types.expressionStatement(setBreakIdentifiers(used, this.pluginState)), replace]);
-            return;
-          }
-        }
-        path.replaceWith(replace);
-      }
-    },
-    ContinueStatement(path) {
-      const label = path.node.label;
-      const index = label ? this.breakIdentifiers.findIndex(breakIdentifier => breakIdentifier.name === label.name) : 0;
-      const replace = returnStatement(undefined, path.node);
-      if (index !== -1 && this.breakIdentifiers.length) {
-        if (!this.breakIdentifiers[index].isAsync) {
-          return;
-        }
-        const used = this.breakIdentifiers.slice(0, index);
-        if (used.length) {
-          pushMissing(this.usedIdentifiers, used);
-          path.replaceWithMultiple([types.expressionStatement(setBreakIdentifiers(used, this.pluginState)), replace]);
-          return;
-        }
-      }
-      path.replaceWith(replace);
-    }
-  };
-  function replaceReturnsAndBreaks(pluginState, path, exitIdentifier, existingUsedIdentifiers) {
-    const usedIdentifiers = [];
-    if (existingUsedIdentifiers !== undefined) {
-      for (const item of existingUsedIdentifiers) {
-        if (path.parentPath === null || path.parentPath.scope.getBinding(item.identifier.name) === path.scope.getBinding(item.identifier.name)) {
-          usedIdentifiers.push(item);
-        }
-      }
-    }
-    const state = {
-      pluginState,
-      exitIdentifier,
-      breakIdentifiers: breakContinueStackForPath(path),
-      usedIdentifiers,
-      switchCount: 0
-    };
-    path.traverse(replaceReturnsAndBreaksVisitor, state);
-    for (const {
-      identifier,
-      path: identifierPath
-    } of usedIdentifiers) {
-      const parentScope = identifierPath.parentPath.scope;
-      if (!parentScope.getBinding(identifier.name)) {
-        parentScope.push({
-          kind: "let",
-          id: identifier,
-          init: readConfigKey(pluginState.opts, "minify") ? undefined : booleanLiteral(false, readConfigKey(pluginState.opts, "minify"))
-        });
-      }
-    }
-    return usedIdentifiers;
-  }
-  function breakIdentifierForPath(path) {
-    let result = breakIdentifierMap.get(path.node);
-    if (!result) {
-      result = path.scope.generateUidIdentifier(path.parentPath !== null && path.parentPath.isLabeledStatement() ? path.parentPath.node.label.name + "Interrupt" : "interrupt");
-      breakIdentifierMap.set(path.node, result);
-    }
-    return result;
-  }
-  const simpleBreakOrContinueReferencesVisitor = {
-    Function: skipNode,
-    Loop: skipNode,
-    SwitchStatement: skipNode,
-    BreakStatement(path) {
-      if (!path.node.label) {
-        this.references.push(path);
-      }
-    },
-    ReturnStatement(path) {
-      const originalNode = originalNodeMap.get(path.node);
-      if (originalNode) {
-        traverse(wrapNodeInStatement(originalNode), simpleBreakOrContinueReferencesVisitor, path.scope, this, path);
-        path.skip();
-      }
-    }
-  };
-  function simpleBreakOrContinueReferences(path) {
-    const state = {
-      references: []
-    };
-    path.traverse(simpleBreakOrContinueReferencesVisitor, state);
-    return state.references;
-  }
-  const namedLabelReferencesVisitor = {
-    Function: skipNode,
-    BreakStatement(path) {
-      if (path.node.label && path.node.label.name === this.name) {
-        this.breaks.push(path);
-      }
-    },
-    ContinueStatement(path) {
-      if (path.node.label && path.node.label.name === this.name) {
-        this.continues.push(path);
-      }
-    },
-    ReturnStatement(path) {
-      const originalNode = originalNodeMap.get(path.node);
-      if (originalNode) {
-        traverse(wrapNodeInStatement(originalNode), namedLabelReferencesVisitor, path.scope, this, path);
-        path.skip();
-      }
-    }
-  };
-  function namedLabelReferences(labelPath, targetPath) {
-    const state = {
-      name: labelPath.node.label.name,
-      breaks: [],
-      continues: []
-    };
-    targetPath.traverse(namedLabelReferencesVisitor, state);
-    return state;
-  }
-  function breakContinueStackForPath(path) {
-    let current = path;
-    const result = [];
-    while (current && !current.isFunction()) {
-      if (current.isLoop() || current.isSwitchStatement()) {
-        const breaks = pathsBreak(current);
-        if (breaks.any && (!current.isSwitchStatement() || !breaks.all)) {
-          const simpleReferences = simpleBreakOrContinueReferences(current);
-          if (current.parentPath.isLabeledStatement()) {
-            const refs = namedLabelReferences(current.parentPath, path);
-            if (simpleReferences.length || refs.breaks.length || refs.continues.length) {
-              result.push({
-                identifier: breakIdentifierForPath(current),
-                name: current.parentPath.node.label.name,
-                path: current.parentPath,
-                isAsync: true
-              });
-            }
-            current = current.parentPath;
-          } else if (simpleReferences.length) {
-            result.push({
-              identifier: breakIdentifierForPath(current),
-              path: current,
-              isAsync: true
-            });
-          }
-        }
-      } else if (current.isLabeledStatement()) {
-        const refs = namedLabelReferences(current, path);
-        if (refs.breaks.length || refs.continues.length) {
-          result.push({
-            identifier: breakIdentifierForPath(current.get("body")),
-            name: current.node.label.name,
-            path: current,
-            isAsync: true
-          });
-        }
-      }
-      current = current.parentPath;
-    }
-    return result;
-  }
-  function isForAwaitStatement(path) {
-    return path.isForAwaitStatement && path.node ? path.isForAwaitStatement() : false;
-  }
-  function isArgumentPlaceholder(path) {
-    return path.node.type === "ArgumentPlaceholder";
-  }
-  function getStatementOrArrowBodyParent(path) {
-    let parent = path;
-    while (parent) {
-      if (parent.isStatement()) {
-        return parent;
-      }
-      if (parent.isArrowFunctionExpression()) {
-        return parent.get("body");
-      }
-      parent = parent.parentPath;
-    }
-    throw path.buildCodeFrameError(`Expected a statement parent!`, TypeError);
-  }
-  function addConstantNames(additionalConstantNames, node) {
-    if (types.isIdentifier(node)) {
-      if (additionalConstantNames.indexOf(node.name) === -1) {
-        additionalConstantNames.push(node.name);
-      }
-    } else if (types.isArrayPattern(node)) {
-      for (const element of node.elements) {
-        if (types.isIdentifier(element) || types.isPattern(element) || types.isRestElement(element)) {
-          addConstantNames(additionalConstantNames, element);
-        }
-      }
-    } else if (types.isObjectPattern(node)) {
-      for (const property of node.properties) {
-        if (types.isObjectProperty(property)) {
-          addConstantNames(additionalConstantNames, property.key);
-        } else if (types.isRestElement(property)) {
-          addConstantNames(additionalConstantNames, property.argument);
-        }
-      }
-    } else if (types.isRestElement(node)) {
-      addConstantNames(additionalConstantNames, node.argument);
-    }
-  }
-  function yieldOnExpression(state, expression) {
-    const generatorIdentifier = state.generatorIdentifier;
-    if (typeof generatorIdentifier === "undefined") {
-      throw new Error("Encountered a yield expression outside a generator function!");
-    }
-    const callee = types.memberExpression(generatorIdentifier, types.identifier("_yield"));
-    helperNameMap.set(callee, "_yield");
-    return types.callExpression(callee, [expression]);
-  }
-  function rewriteAwaitOrYieldPath(rewritePath) {
-    const state = this;
-    const pluginState = state.generatorState.state;
-    const path = state.path;
-    const additionalConstantNames = state.additionalConstantNames;
-    let awaitPath;
-    let processExpressions;
-    const rewritePathCopy = rewritePath;
-    if (rewritePath.isAwaitExpression() || rewritePath.isYieldExpression()) {
-      awaitPath = rewritePath;
-      processExpressions = true;
-    } else if (rewritePath.isForOfStatement() || isForAwaitStatement(rewritePath)) {
-      const left = rewritePath.get("left");
-      if (left.isAwaitExpression()) {
-        awaitPath = left.get("argument");
-      } else if (left.isSpreadElement()) {
-        awaitPath = unwrapSpreadElement(left);
-      } else {
-        awaitPath = left;
-      }
-      processExpressions = false;
-    } else {
-      throw rewritePathCopy.buildCodeFrameError(`Expected either an await expression or a for await statement, got a ${rewritePathCopy.type}!`, TypeError);
-    }
-    const paths = [];
-    {
-      let targetPath = awaitPath;
-      let shouldPushExitIdentifier = false;
-      while (targetPath !== path) {
-        const parent = targetPath.parentPath;
-        if (parent == null) {
-          break;
-        }
-        if (!parent.isSwitchCase() && !parent.isBlockStatement()) {
-          let exitIdentifier;
-          const explicitExits = pathsReturnOrThrow(parent);
-          if (!explicitExits.all && explicitExits.any && (parent.isLoop() || exitsInTail(parent))) {
-            if (!state.exitIdentifier) {
-              state.exitIdentifier = targetPath.scope.generateUidIdentifier("exit");
-              shouldPushExitIdentifier = true;
-            }
-            exitIdentifier = state.exitIdentifier;
-          }
-          paths.push({
-            targetPath,
-            explicitExits,
-            parent,
-            exitIdentifier
-          });
-        }
-        targetPath = parent;
-      }
-      if (shouldPushExitIdentifier && state.exitIdentifier) {
-        path.scope.push({
-          kind: "let",
-          id: state.exitIdentifier,
-          init: readConfigKey(pluginState.opts, "minify") ? undefined : booleanLiteral(false, readConfigKey(pluginState.opts, "minify"))
-        });
-      }
-    }
-    let breakIdentifiers = [];
-    for (const item of paths) {
-      const parent = item.parent;
-      if (parent.isForStatement() || parent.isWhileStatement() || parent.isDoWhileStatement() || parent.isForInStatement() || parent.isForOfStatement() || isForAwaitStatement(parent) || parent.isLabeledStatement()) {
-        breakIdentifiers = item.breakIdentifiers = replaceReturnsAndBreaks(pluginState, parent.get("body"), item.exitIdentifier, breakIdentifiers);
-        if (parent.isForStatement()) {
-          if (item.forToIdentifiers = identifiersInForToLengthStatement(parent)) {
-            addConstantNames(additionalConstantNames, item.forToIdentifiers.i);
-          }
-        }
-      } else if (item.parent.isSwitchStatement()) {
-        breakIdentifiers = breakIdentifiers.slice();
-        item.cases = item.parent.get("cases").map(casePath => {
-          const caseExits = pathsReturnOrThrow(casePath);
-          const caseBreaks = pathsBreak(casePath);
-          const caseBreakIdentifiers = item.breakIdentifiers = replaceReturnsAndBreaks(pluginState, casePath, item.exitIdentifier, breakIdentifiers);
-          for (const breakItem of caseBreakIdentifiers) {
-            if (!breakIdentifiers.find(existing => existing.identifier.name === breakItem.identifier.name)) {
-              breakIdentifiers.push(breakItem);
-            }
-          }
-          return {
-            casePath,
-            caseExits,
-            caseBreaks,
-            breakIdentifiers: caseBreakIdentifiers,
-            test: casePath.node.test
-          };
-        });
-      } else {
-        breakIdentifiers = item.breakIdentifiers = replaceReturnsAndBreaks(pluginState, parent, item.exitIdentifier, breakIdentifiers);
-      }
-    }
-    for (const {
-      targetPath,
-      explicitExits,
-      breakIdentifiers,
-      parent,
-      exitIdentifier,
-      cases,
-      forToIdentifiers
-    } of paths) {
-      if (parent.isExpressionStatement() && (targetPath.isAwaitExpression() || targetPath.isYieldExpression()) && processExpressions) {
-        processExpressions = false;
-        relocateTail(state.generatorState, targetPath.isYieldExpression() ? yieldOnExpression(state.generatorState, targetPath.node.argument || types.identifier("undefined")) : targetPath.node.argument, undefined, parent, additionalConstantNames, undefined, undefined, targetPath.isYieldExpression() ? undefined : booleanLiteral(false, readConfigKey(pluginState.opts, "minify")), state.skipReturns);
-      } else if (parent.isIfStatement()) {
-        const test = parent.get("test");
-        if (targetPath !== test) {
-          let resultIdentifier;
-          if (!explicitExits.all && explicitExits.any) {
-            resultIdentifier = path.scope.generateUidIdentifier("result");
-            addConstantNames(additionalConstantNames, resultIdentifier);
-          }
-          if (!explicitExits.all) {
-            const consequent = parent.get("consequent");
-            rewriteAsyncBlock(state.generatorState, consequent, additionalConstantNames, exitIdentifier);
-            const alternate = parent.get("alternate");
-            if (alternate.isStatement()) {
-              rewriteAsyncBlock(state.generatorState, alternate, additionalConstantNames, exitIdentifier);
-            }
-            const fn = functionize(pluginState, [], blockStatement([parent.node]), targetPath);
-            relocateTail(state.generatorState, types.callExpression(fn, []), undefined, parent, additionalConstantNames, resultIdentifier, exitIdentifier, undefined, state.skipReturns);
-            processExpressions = false;
-          }
-        }
-      } else if (parent.isTryStatement()) {
-        const temporary = explicitExits.any && !explicitExits.all ? path.scope.generateUidIdentifier("result") : undefined;
-        const exitCheck = buildBreakExitCheck(pluginState, explicitExits.any && !explicitExits.all ? exitIdentifier : undefined, breakIdentifiers);
-        let expression = rewriteAsyncNode(state.generatorState, parent, parent.node.block, additionalConstantNames, exitIdentifier);
-        const catchClause = parent.node.handler;
-        if (catchClause) {
-          const param = catchClause.param;
-          const paramIsUsed = param !== null && param !== undefined && (param.type !== "Identifier" || parent.get("handler").scope.getBinding(param.name).referencePaths.length !== 0);
-          const fn = catchClause.body.body.length ? rewriteAsyncNode(state.generatorState, parent, functionize(pluginState, paramIsUsed && param != null ? [param] : [], catchClause.body, targetPath), additionalConstantNames, exitIdentifier) : emptyFunction(pluginState, parent);
-          expression = types.callExpression(helperReference(pluginState, path, state.generatorState.generatorIdentifier ? "_catchInGenerator" : "_catch"), [unwrapReturnCallWithEmptyArguments(functionize(pluginState, [], expression, targetPath), path.scope, additionalConstantNames), fn]);
-        }
-        if (parent.node.finalizer) {
-          let finallyName;
-          let finallyArgs;
-          let finallyBody = parent.node.finalizer.body;
-          if (!pathsReturnOrThrow(parent.get("finalizer")).all) {
-            const resultIdentifier = temporary || path.scope.generateUidIdentifier("result");
-            addConstantNames(additionalConstantNames, resultIdentifier);
-            const wasThrownIdentifier = path.scope.generateUidIdentifier("wasThrown");
-            addConstantNames(additionalConstantNames, wasThrownIdentifier);
-            finallyArgs = [wasThrownIdentifier, resultIdentifier];
-            if (readConfigKey(pluginState.opts, "inlineHelpers")) {
-              finallyBody = finallyBody.concat([types.ifStatement(wasThrownIdentifier, types.throwStatement(resultIdentifier)), types.returnStatement(resultIdentifier)]);
-            } else {
-              finallyBody = finallyBody.concat(returnStatement(types.callExpression(helperReference(pluginState, parent, "_rethrow"), [wasThrownIdentifier, resultIdentifier])));
-            }
-            finallyName = "_finallyRethrows";
-          } else {
-            finallyArgs = [];
-            finallyName = "_finally";
-          }
-          const fn = functionize(pluginState, finallyArgs, blockStatement(finallyBody), targetPath);
-          const rewritten = rewriteAsyncNode(state.generatorState, parent, fn, additionalConstantNames, exitIdentifier);
-          expression = types.callExpression(helperReference(pluginState, parent, finallyName), [unwrapReturnCallWithEmptyArguments(functionize(pluginState, [], expression, targetPath), path.scope, additionalConstantNames), rewritten]);
-        }
-        relocateTail(state.generatorState, types.isExpression(expression) ? expression : types.callExpression(functionize(pluginState, [], expression, targetPath), []), undefined, parent, additionalConstantNames, temporary, exitCheck, undefined, state.skipReturns);
-        processExpressions = false;
-      } else if (parent.isForStatement() || parent.isWhileStatement() || parent.isDoWhileStatement() || parent.isForInStatement() || parent.isForOfStatement() || isForAwaitStatement(parent)) {
-        const label = parent.parentPath.isLabeledStatement() ? parent.parentPath.node.label.name : undefined;
-        if (parent.isForInStatement() || parent.isForOfStatement() || isForAwaitStatement(parent)) {
-          const right = parent.get("right");
-          if (awaitPath !== right) {
-            const left = parent.get("left");
-            const loopIdentifier = left.isVariableDeclaration() ? left.get("declarations")[0].get("id") : left;
-            if (loopIdentifier.isIdentifier() || loopIdentifier.isPattern()) {
-              const forOwnBodyPath = parent.isForInStatement() && extractForOwnBodyPath(parent);
-              const bodyBlock = blockStatement((forOwnBodyPath || parent.get("body")).node);
-              const params = [right.node, rewriteAsyncNode(state.generatorState, parent, bodyBlock.body.length ? functionize(pluginState, [loopIdentifier.node], bodyBlock, targetPath) : emptyFunction(pluginState, parent), additionalConstantNames, exitIdentifier)];
-              const exitCheck = buildBreakExitCheck(pluginState, exitIdentifier, breakIdentifiers);
-              if (exitCheck) {
-                params.push(functionize(pluginState, [], types.blockStatement([returnStatement(exitCheck)]), targetPath));
-              }
-              const loopCall = types.callExpression(helperReference(pluginState, parent, parent.isForInStatement() ? forOwnBodyPath ? "_forOwn" : "_forIn" : isForAwaitStatement(parent) ? "_forAwaitOf" : "_forOf"), params);
-              let resultIdentifier = undefined;
-              if (explicitExits.any) {
-                resultIdentifier = path.scope.generateUidIdentifier("result");
-                addConstantNames(additionalConstantNames, resultIdentifier);
-              }
-              relocateTail(state.generatorState, loopCall, undefined, label && parent.parentPath.isStatement() ? parent.parentPath : parent, additionalConstantNames, resultIdentifier, exitIdentifier, undefined, state.skipReturns);
-              processExpressions = false;
-            } else {
-              throw loopIdentifier.buildCodeFrameError(`Expected an identifier or pattern, but got a ${loopIdentifier.type}!`, TypeError);
-            }
-          }
-        } else {
-          let testExpression = parent.node.test;
-          const breakExitCheck = buildBreakExitCheck(pluginState, exitIdentifier, breakIdentifiers);
-          if (breakExitCheck) {
-            const inverted = logicalNot(breakExitCheck, readConfigKey(pluginState.opts, "minify"));
-            testExpression = testExpression && (!types.isBooleanLiteral(testExpression) || !testExpression.value) ? logicalAnd(inverted, testExpression, extractLooseBooleanValue) : inverted;
-          }
-          if (testExpression) {
-            testExpression = rewriteAsyncNode(state.generatorState, parent, functionize(pluginState, [], testExpression, targetPath), additionalConstantNames, exitIdentifier, true);
-          }
-          const isDoWhile = parent.isDoWhileStatement();
-          let loopCall;
-          if (forToIdentifiers && !isDoWhile) {
-            const args = [forToIdentifiers.array, rewriteAsyncNode(state.generatorState, parent, functionize(pluginState, [forToIdentifiers.i], blockStatement(parent.node.body), targetPath), additionalConstantNames, exitIdentifier)];
-            if (breakExitCheck) {
-              args.push(functionize(pluginState, [], breakExitCheck, targetPath));
-            }
-            loopCall = types.callExpression(helperReference(pluginState, parent, "_forTo"), args);
-          } else {
-            let updateExpression = null;
-            if (parent.isForStatement()) {
-              updateExpression = parent.node.update;
-              if (updateExpression) {
-                updateExpression = rewriteAsyncNode(state.generatorState, parent, functionize(pluginState, [], updateExpression, targetPath), additionalConstantNames, exitIdentifier, true);
-              }
-              const init = parent.get("init");
-              if (init) {
-                const initNode = init.node;
-                if (initNode !== null && initNode !== undefined) {
-                  reregisterDeclarations(parent.insertBefore(types.isExpression(initNode) ? types.expressionStatement(initNode) : initNode));
-                }
-              }
-            }
-            const bodyFunction = rewriteAsyncNode(state.generatorState, parent, functionize(pluginState, [], blockStatement(parent.node.body || []), targetPath), additionalConstantNames, exitIdentifier);
-            const testFunction = unwrapReturnCallWithEmptyArguments(testExpression || voidExpression(), path.scope, additionalConstantNames);
-            const updateFunction = unwrapReturnCallWithEmptyArguments(updateExpression || voidExpression(), path.scope, additionalConstantNames);
-            loopCall = isDoWhile ? types.callExpression(helperReference(pluginState, parent, "_do"), [bodyFunction, testFunction]) : types.callExpression(helperReference(pluginState, parent, "_for"), [testFunction, updateFunction, bodyFunction]);
-          }
-          let resultIdentifier = undefined;
-          if (explicitExits.any) {
-            resultIdentifier = path.scope.generateUidIdentifier("result");
-            addConstantNames(additionalConstantNames, resultIdentifier);
-          }
-          relocateTail(state.generatorState, loopCall, undefined, parent, additionalConstantNames, resultIdentifier, exitIdentifier, undefined, state.skipReturns);
-          processExpressions = false;
-        }
-      } else if (parent.isSwitchStatement()) {
-        const label = parent.parentPath.isLabeledStatement() ? parent.parentPath.node.label.name : undefined;
-        const discriminant = parent.get("discriminant");
-        const testPaths = parent.get("cases").map(casePath => casePath.get("test"));
-        if (awaitPath !== discriminant && !(explicitExits.all && !testPaths.some(testPath => testPath.node ? findAwaitOrYieldPath(testPath) !== undefined : false))) {
-          let resultIdentifier;
-          if (!explicitExits.all && explicitExits.any) {
-            resultIdentifier = path.scope.generateUidIdentifier("result");
-            addConstantNames(additionalConstantNames, resultIdentifier);
-          }
-          const caseNodes = types.arrayExpression(cases ? cases.map(caseItem => {
-            const args = [];
-            let consequent;
-            if (caseItem.casePath.node.consequent) {
-              const rewritten = rewriteAsyncNode(state.generatorState, parent, blockStatement(removeUnnecessaryReturnStatements(caseItem.casePath.node.consequent)), additionalConstantNames, exitIdentifier);
-              if (rewritten.body.length) {
-                consequent = functionize(pluginState, [], rewritten, targetPath);
-              }
-            }
-            if (caseItem.casePath.node.test) {
-              args.push(rewriteAsyncNode(state.generatorState, parent, functionize(pluginState, [], caseItem.casePath.node.test, targetPath), additionalConstantNames));
-            } else if (consequent) {
-              args.push(voidExpression());
-            }
-            if (consequent) {
-              args.push(consequent);
-              if (!caseItem.caseExits.any && !caseItem.caseBreaks.any) {
-                args.push(emptyFunction(pluginState, parent));
-              } else if (!(caseItem.caseExits.all || caseItem.caseBreaks.all)) {
-                const breakCheck = buildBreakExitCheck(pluginState, caseItem.caseExits.any ? exitIdentifier : undefined, caseItem.breakIdentifiers);
-                if (breakCheck) {
-                  args.push(functionize(pluginState, [], types.blockStatement([returnStatement(breakCheck)]), targetPath));
-                }
-              }
-            }
-            return types.arrayExpression(args);
-          }) : []);
-          const switchCall = types.callExpression(helperReference(pluginState, parent, "_switch"), [discriminant.node, caseNodes]);
-          relocateTail(state.generatorState, switchCall, undefined, label && parent.parentPath.isStatement() ? parent.parentPath : parent, additionalConstantNames, resultIdentifier, exitIdentifier, undefined, state.skipReturns);
-          processExpressions = false;
-        }
-      } else if (parent.isLabeledStatement()) {
-        let resultIdentifier;
-        if (!explicitExits.all && explicitExits.any) {
-          resultIdentifier = path.scope.generateUidIdentifier("result");
-          addConstantNames(additionalConstantNames, resultIdentifier);
-        }
-        if (resultIdentifier || breakIdentifiers && breakIdentifiers.length) {
-          const filteredBreakIdentifiers = breakIdentifiers ? breakIdentifiers.filter(id => id.name !== parent.node.label.name) : [];
-          const fn = functionize(pluginState, [], blockStatement(parent.node.body), targetPath);
-          const rewritten = rewriteAsyncNode(state.generatorState, parent, fn, additionalConstantNames, exitIdentifier);
-          const exitCheck = buildBreakExitCheck(pluginState, explicitExits.any ? exitIdentifier : undefined, filteredBreakIdentifiers);
-          relocateTail(state.generatorState, types.callExpression(rewritten, []), undefined, parent, additionalConstantNames, resultIdentifier, exitCheck, undefined, state.skipReturns);
-          processExpressions = false;
-        }
-      }
-    }
-    if (processExpressions) {
-      if (awaitPath.isAwaitExpression() || awaitPath.isYieldExpression()) {
-        const originalArgument = awaitPath.node.argument;
-        let parent = getStatementOrArrowBodyParent(awaitPath);
-        const {
-          declarationKind,
-          declarations,
-          awaitExpression,
-          directExpression,
-          reusingExisting,
-          resultIdentifier
-        } = extractDeclarations(pluginState, awaitPath, originalArgument || types.identifier("undefined"), additionalConstantNames);
-        if (resultIdentifier) {
-          addConstantNames(additionalConstantNames, resultIdentifier);
-        }
-        if (declarations.length) {
-          for (const {
-            id
-          } of declarations) {
-            addConstantNames(additionalConstantNames, id);
-          }
-          if (parent.parentPath.isBlockStatement()) {
-            reregisterDeclarations(parent.insertBefore(types.variableDeclaration(declarationKind, declarations)));
-          } else {
-            parent.replaceWith(blockStatement([types.variableDeclaration(declarationKind, declarations), types.isStatement(parent.node) ? parent.node : returnStatement(parent.node)]));
-            const body = parent.get("body");
-            reregisterDeclarations(body[0]);
-            parent = body[1];
-          }
-        }
-        if (reusingExisting) {
-          if (types.isVariableDeclaration(reusingExisting.parent) && reusingExisting.parent.declarations.length === 1) {
-            reusingExisting.parentPath.replaceWith(types.emptyStatement());
-          } else {
-            reusingExisting.remove();
-          }
-        }
-        const parentNode = parent.node;
-        relocateTail(state.generatorState, awaitPath.isYieldExpression() ? yieldOnExpression(state.generatorState, awaitExpression) : awaitExpression, types.isStatement(parentNode) ? parentNode : types.returnStatement(parentNode), parent, additionalConstantNames, resultIdentifier, undefined, awaitPath.isYieldExpression() ? undefined : directExpression, state.skipReturns);
-      }
-    }
-  }
-  const rewriteAsyncBlockVisitor = {
-    Function: skipNode,
-    AwaitExpression: rewriteAwaitOrYieldPath,
-    YieldExpression: rewriteAwaitOrYieldPath,
-    ForAwaitStatement: rewriteAwaitOrYieldPath,
-    ForOfStatement(path) {
-      if (path.node.await) {
-        rewriteAwaitOrYieldPath.call(this, path);
-      }
-    },
-    CallExpression(path) {
-      const callee = path.get("callee");
-      if (callee.isIdentifier() && callee.node.name === "eval") {
-        throw path.buildCodeFrameError("Calling eval from inside an async function is not supported!", TypeError);
-      }
-    }
-  };
-  const unpromisifyVisitor = {
-    Function: skipNode,
-    ReturnStatement(path) {
-      const argument = path.get("argument");
-      if (argument.node) {
-        unpromisify(argument, this);
-      }
-    }
-  };
-  function unpromisify(path, pluginState) {
-    if (path.isNumericLiteral() || path.isBooleanLiteral() || path.isStringLiteral() || path.isNullLiteral() || path.isIdentifier() && path.node.name === "undefined" || path.isArrayExpression() || path.isObjectExpression() || path.isBinaryExpression() || path.isUnaryExpression() || path.isUpdateExpression()) {
-      return;
-    }
-    if (path.isCallExpression() && (types.isIdentifier(path.node.callee) || types.isMemberExpression(path.node.callee)) && helperNameMap.has(path.node.callee)) {
-      switch (helperNameMap.get(path.node.callee)) {
-        case "_await":
-          const args = path.get("arguments");
-          if (args.length > 0 && args[0].isExpression()) {
-            unpromisify(args[0], pluginState);
-          }
-        case "_call":
-          {
-            const args = path.get("arguments");
-            if (args.length > 2) {
-              const secondArg = args[1];
-              if (types.isExpression(secondArg.node) && isContinuation(secondArg.node)) {
-                secondArg.traverse(unpromisifyVisitor, pluginState);
-              } else if (secondArg.isIdentifier()) {
-                const binding = secondArg.scope.getBinding(secondArg.node.name);
-                if (binding && binding.path.isVariableDeclarator()) {
-                  binding.path.get("init").traverse(unpromisifyVisitor, pluginState);
-                }
-              }
-            }
-            break;
-          }
-        case "_promiseThen":
-          {
-            const args = path.get("arguments");
-            if (args.length > 2) {
-              const firstArg = args[1];
-              if (types.isExpression(firstArg.node) && isContinuation(firstArg.node)) {
-                firstArg.traverse(unpromisifyVisitor, pluginState);
-              } else if (firstArg.isIdentifier()) {
-                const binding = firstArg.scope.getBinding(firstArg.node.name);
-                if (binding && binding.path.isVariableDeclarator()) {
-                  binding.path.get("init").traverse(unpromisifyVisitor, pluginState);
-                }
-              }
-            }
-            break;
-          }
-      }
-      return;
-    }
-    if (path.isLogicalExpression()) {
-      unpromisify(path.get("left"), pluginState);
-      unpromisify(path.get("right"), pluginState);
-      return;
-    }
-    if (path.isConditionalExpression()) {
-      unpromisify(path.get("consequent"), pluginState);
-      unpromisify(path.get("alternate"), pluginState);
-      return;
-    }
-    if (path.isSequenceExpression()) {
-      const expressions = path.get("expressions");
-      if (expressions.length) {
-        unpromisify(expressions[expressions.length - 1], pluginState);
-      }
-      return;
-    }
-    const minify = readConfigKey(pluginState.opts, "minify");
-    path.replaceWith(logicalNot(logicalNot(path.node, minify), minify));
-  }
-  function rewriteAsyncBlock(generatorState, path, additionalConstantNames, exitIdentifier, shouldUnpromisify, skipReturns) {
-    path.traverse(rewriteAsyncBlockVisitor, {
-      generatorState,
-      path,
-      additionalConstantNames,
-      exitIdentifier,
-      skipReturns
-    });
-    if (shouldUnpromisify) {
-      if (path.isArrowFunctionExpression()) {
-        const body = path.get("body");
-        if (body.isExpression()) {
-          unpromisify(body, generatorState.state);
-        }
-      } else {
-        path.traverse(unpromisifyVisitor, generatorState.state);
-      }
-    }
-  }
-  function getFile(path) {
-    let hub = path.hub;
-    if ("file" in hub) {
-      return hub.file;
-    }
-    throw path.buildCodeFrameError("Expected the path's hub to contain a file!", TypeError);
-  }
-  const getHelperDependenciesVisitor = {
-    Identifier(path) {
-      if (identifierSearchesScope(path) && getFile(path).scope.getBinding(path.node.name) && this.dependencies.indexOf(path.node.name) === -1) {
-        this.dependencies.push(path.node.name);
-      }
-    }
-  };
-  function getHelperDependencies(path) {
-    const state = {
-      dependencies: []
-    };
-    path.traverse(getHelperDependenciesVisitor, state);
-    return state.dependencies;
-  }
-  const usesIdentifierVisitor = {
-    Identifier(path) {
-      if (path.node.name === this.name) {
-        this.found = true;
-        path.stop();
-      }
-    }
-  };
-  function usesIdentifier(path, name) {
-    const state = {
-      name,
-      found: false
-    };
-    path.traverse(usesIdentifierVisitor, state);
-    return state.found;
-  }
-  function insertHelper(programPath, value) {
-    const body = programPath.get("body");
-    const destinationPath = body.find(path => !isHelperDefinitionSet.has(path.node) && !path.isImportDeclaration()) || body.find(() => true);
-    if (destinationPath.isVariableDeclaration()) {
-      const before = destinationPath.get("declarations").filter(path => isHelperDefinitionSet.has(path.node));
-      const after = destinationPath.get("declarations").filter(path => !isHelperDefinitionSet.has(path.node));
-      if (types.isVariableDeclaration(value)) {
-        const declaration = value.declarations[0];
-        isHelperDefinitionSet.add(declaration);
-        if (before.length === 0) {
-          const target = after[0];
-          reregisterDeclarations(target.insertBefore(declaration));
-          return getPreviousSibling(target);
-        } else {
-          const target = before[before.length - 1];
-          reregisterDeclarations(target.insertAfter(declaration));
-          return getNextSibling(target);
-        }
-      } else {
-        isHelperDefinitionSet.add(value);
-        if (before.length === 0) {
-          isHelperDefinitionSet.add(destinationPath.node);
-          reregisterDeclarations(destinationPath.insertBefore(value));
-          return getPreviousSibling(destinationPath);
-        } else if (after.length === 0) {
-          isHelperDefinitionSet.add(destinationPath.node);
-          reregisterDeclarations(destinationPath.insertAfter(value));
-          return getNextSibling(destinationPath);
-        } else {
-          const beforeNode = types.variableDeclaration(destinationPath.node.kind, before.map(path => path.node));
-          isHelperDefinitionSet.add(beforeNode);
-          const afterNode = types.variableDeclaration(destinationPath.node.kind, after.map(path => path.node));
-          destinationPath.replaceWith(afterNode);
-          reregisterDeclarations(destinationPath);
-          reregisterDeclarations(destinationPath.insertBefore(beforeNode));
-          reregisterDeclarations(destinationPath.insertBefore(value));
-          return getPreviousSibling(destinationPath);
-        }
-      }
-    } else {
-      if (types.isVariableDeclaration(value)) {
-        isHelperDefinitionSet.add(value.declarations[0]);
-      } else {
-        isHelperDefinitionSet.add(value);
-      }
-      const oldNode = destinationPath.node;
-      destinationPath.replaceWith(value);
-      reregisterDeclarations(destinationPath);
-      reregisterDeclarations(destinationPath.insertAfter(oldNode));
-      return destinationPath;
-    }
-  }
-  function helperReference(state, path, name) {
-    const file = getFile(path);
-    let result = file.declarations[name];
-    if (result) {
-      result = cloneNode(result);
-    } else {
-      result = file.declarations[name] = usesIdentifier(file.path, name) ? file.path.scope.generateUidIdentifier(name) : types.identifier(name);
-      helperNameMap.set(result, name);
-      if (readConfigKey(state.opts, "externalHelpers")) {
-        file.path.unshiftContainer("body", types.importDeclaration([types.importSpecifier(result, types.identifier(name))], types.stringLiteral("babel-plugin-transform-async-to-promises/helpers")));
-      } else {
-        if (!helpers) {
-          const newHelpers = {};
-          const plugins = [{
-            visitor: {
-              ExportNamedDeclaration(path) {
-                const declaration = path.get("declaration");
-                if (declaration.isFunctionDeclaration()) {
-                  const id = declaration.node.id;
-                  if (!types.isIdentifier(id)) {
-                    throw declaration.buildCodeFrameError(`Expected a named declaration!`, TypeError);
-                  }
-                  newHelpers[id.name] = {
-                    value: declaration.node,
-                    dependencies: getHelperDependencies(declaration)
-                  };
-                  return;
-                }
-                if (declaration.isVariableDeclaration() && declaration.node.declarations.length === 1) {
-                  const declaratorId = declaration.node.declarations[0].id;
-                  if (types.isIdentifier(declaratorId)) {
-                    newHelpers[declaratorId.name] = {
-                      value: declaration.node,
-                      dependencies: getHelperDependencies(declaration)
-                    };
-                    return;
-                  }
-                }
-                throw path.buildCodeFrameError("Expected a named export from built-in helper!", TypeError);
-              }
-            }
-          }];
-          const helperAst = require(isNewBabel ? "@babel/core" : "babylon").parse(helpers_string_1, {
-            sourceType: "module",
-            filename: "helpers.js"
-          });
-          if (isNewBabel) {
-            transformFromAst(helperAst, helpers_string_1, {
-              babelrc: false,
-              configFile: false,
-              plugins
-            });
-          } else {
-            transformFromAst(helperAst, helpers_string_1, {
-              babelrc: false,
-              plugins
-            });
-          }
-          helpers = newHelpers;
-        }
-        const helper = helpers[name];
-        for (const dependency of helper.dependencies) {
-          helperReference(state, path, dependency);
-        }
-        const usedHelpers = state.usedHelpers || (state.usedHelpers = {});
-        usedHelpers[name] = true;
-      }
-    }
-    return result;
-  }
-  function emptyFunction(state, path) {
-    return readConfigKey(state.opts, "inlineHelpers") ? functionize(state, [], blockStatement([]), path) : helperReference(state, path, "_empty");
-  }
-  function promiseResolve() {
-    const result = types.memberExpression(types.identifier("Promise"), types.identifier("resolve"));
-    helperNameMap.set(result, "_promiseResolve");
-    return result;
-  }
-  function callThenMethod(value, continuation) {
-    const thenExpression = types.memberExpression(value, types.identifier("then"));
-    helperNameMap.set(thenExpression, "_promiseThen");
-    return types.callExpression(thenExpression, [continuation]);
-  }
-  function isAsyncCallExpression(path) {
-    if (types.isIdentifier(path.node.callee) || types.isMemberExpression(path.node.callee)) {
-      switch (helperNameMap.get(path.node.callee)) {
-        case "_await":
-        case "_call":
-        case "_promiseResolve":
-        case "_promiseThen":
-          return path.node.arguments.length < 3;
-      }
-    }
-    return false;
-  }
-  function invokeTypeOfExpression(path) {
-    if (path.isCallExpression() && types.isIdentifier(path.node.callee)) {
-      const helperName = helperNameMap.get(path.node.callee);
-      switch (helperName) {
-        case "_invoke":
-        case "_invokeIgnored":
-        case "_catch":
-        case "_catchInGenerator":
-        case "_finally":
-        case "_finallyRethrows":
-          return helperName;
-      }
-    }
-  }
-  function isAsyncFunctionExpression(path) {
-    if (path.isFunction() && (path.node.async || nodeIsAsyncSet.has(path.node))) {
-      return true;
-    }
-    if (path.isCallExpression() && types.isIdentifier(path.node.callee) && helperNameMap.get(path.node.callee) === "_async") {
-      return true;
-    }
-    return false;
-  }
-  function isAsyncFunctionIdentifier(path) {
-    if (path.isIdentifier()) {
-      const binding = path.scope.getBinding(path.node.name);
-      if (binding && binding.constant) {
-        const bindingPath = binding.path;
-        if (bindingPath.isVariableDeclarator()) {
-          const initPath = bindingPath.get("init");
-          if (initPath.node && isAsyncFunctionExpression(initPath)) {
-            return true;
-          }
-        } else if (bindingPath.isFunctionDeclaration()) {
-          if (isAsyncFunctionExpression(bindingPath)) {
-            return true;
-          }
-        }
-      }
-    }
-    return false;
-  }
-  function isEvalOrArguments(path) {
-    return path.isIdentifier() && (path.node.name === "arguments" || path.node.name === "eval");
-  }
-  function identifierSearchesScope(path) {
-    if (path.node.name === "undefined") {
-      return false;
-    }
-    if (helperNameMap.has(path.node)) {
-      return false;
-    }
-    const parent = path.parentPath;
-    if (parent.isVariableDeclarator() && parent.get("id") === path) {
-      return false;
-    }
-    if (parent.isMemberExpression() && !parent.node.computed && parent.get("property") === path) {
-      return false;
-    }
-    if (parent.isLabeledStatement() && parent.get("label") === path) {
-      return false;
-    }
-    if (parent.isFunction() && parent.get("params").indexOf(path) !== -1) {
-      return false;
-    }
-    return true;
-  }
-  function canThrow() {
-    this.canThrow = true;
-  }
-  function promiseCallExpressionType(expression) {
-    if (types.isMemberExpression(expression.callee)) {
-      if (types.isIdentifier(expression.callee.object) && expression.callee.object.name === "Promise" && types.isIdentifier(expression.callee.property)) {
-        switch (expression.callee.property.name) {
-          case "all":
-          case "race":
-          case "reject":
-          case "resolve":
-            return expression.callee.property.name;
-        }
-      } else if (types.isCallExpression(expression.callee.object) && types.isIdentifier(expression.callee.property)) {
-        switch (expression.callee.property.name) {
-          case "then":
-          case "catch":
-          case "finally":
-            if (typeof promiseCallExpressionType(expression.callee.object) !== "undefined") {
-              return expression.callee.property.name;
-            }
-            break;
-        }
-      }
-    }
-    return undefined;
-  }
-  const checkForErrorsAndRewriteReturnsVisitor = {
-    Function: skipNode,
-    ThrowStatement: canThrow,
-    ForInStatement: canThrow,
-    ForOfStatement: canThrow,
-    WithStatement: canThrow,
-    NewExpression: canThrow,
-    TryStatement(path) {
-      if (path.get("handler")) {
-        path.get("block").skip();
-      }
-    },
-    CallExpression(path) {
-      if (!isAsyncCallExpression(path)) {
-        const args = path.get("arguments");
-        switch (invokeTypeOfExpression(path)) {
-          default:
-            if (checkForErrorsAndRewriteReturns(args[0], this.plugin)) {
-              this.canThrow = true;
-            }
-          case "_catch":
-          case "_catchInGenerator":
-          case "_finally":
-          case "_finallyRethrows":
-            if (args[1]) {
-              if (checkForErrorsAndRewriteReturns(args[1], this.plugin)) {
-                this.canThrow = true;
-              }
-            }
-            break;
-          case undefined:
-            {
-              const callee = path.get("callee");
-              if (!isAsyncFunctionIdentifier(callee)) {
-                this.canThrow = true;
-              }
-            }
-        }
-      }
-    },
-    UpdateExpression(path) {
-      if (isEvalOrArguments(path.get("argument"))) {
-        this.canThrow = true;
-      }
-    },
-    UnaryExpression(path) {
-      switch (path.node.operator) {
-        case "delete":
-          this.canThrow = true;
-          break;
-      }
-    },
-    BinaryExpression(path) {
-      switch (path.node.operator) {
-        case "instanceof":
-        case "in":
-          this.canThrow = true;
-          break;
-      }
-    },
-    Identifier(path) {
-      if (identifierSearchesScope(path) && !path.scope.getBinding(path.node.name) && alwaysTruthy.indexOf(path.node.name) === -1) {
-        this.canThrow = true;
-      }
-    },
-    MemberExpression(path) {
-      if (helperNameMap.get(path.node) !== "_await" && !(path.parentPath.isCallExpression() && promiseCallExpressionType(path.parentPath.node) !== undefined && path.parentPath.get("callee") === path)) {
-        const propertyName = propertyNameOfMemberExpression(path.node);
-        if (propertyName !== undefined) {
-          const object = path.get("object");
-          if (object.isIdentifier() && Object.hasOwnProperty.call(constantStaticMethods, object.node.name) && Object.hasOwnProperty.call(constantStaticMethods[object.node.name], propertyName)) {
-            return;
-          }
-        }
-        this.canThrow = true;
-      }
-    },
-    AssignmentExpression(path) {
-      if (isEvalOrArguments(path.get("left"))) {
-        this.canThrow = true;
-      }
-    },
-    ReturnStatement(path) {
-      if (this.rewriteReturns) {
-        const argument = path.get("argument");
-        if (argument && argument.node) {
-          let arg = argument.node;
-          if (!(argument.isCallExpression() && (isAsyncCallExpression(argument) || typeof promiseCallExpressionType(argument.node) !== "undefined") || argument.isCallExpression() && isAsyncFunctionIdentifier(argument.get("callee")))) {
-            const target = readConfigKey(this.plugin.opts, "inlineHelpers") ? promiseResolve() : helperReference(this.plugin, path, "_await");
-            if (types.isConditionalExpression(arg) && types.isIdentifier(arg.test)) {
-              if (types.isCallExpression(arg.consequent) && promiseCallExpressionType(arg.consequent) === "resolve" && arg.consequent.arguments.length === 1 && nodesAreEquivalent(arg.consequent.arguments[0])(arg.alternate)) {
-                arg = arg.alternate;
-              } else if (types.isCallExpression(arg.alternate) && promiseCallExpressionType(arg.alternate) === "resolve" && arg.alternate.arguments.length === 1 && nodesAreEquivalent(arg.alternate.arguments[0])(arg.consequent)) {
-                arg = arg.consequent;
-              }
-            }
-            if (types.isConditionalExpression(arg) && types.isCallExpression(arg.consequent) && promiseCallExpressionType(arg.consequent) === "resolve") {
-              const consequent = arg.consequent.arguments[0];
-              if (consequent && types.isExpression(consequent)) {
-                arg = conditionalExpression(arg.test, consequent, arg.alternate);
-              }
-            }
-            if (types.isConditionalExpression(arg) && types.isCallExpression(arg.alternate) && promiseCallExpressionType(arg.alternate) === "resolve") {
-              const alternate = arg.alternate.arguments[0];
-              if (alternate && types.isExpression(alternate)) {
-                arg = conditionalExpression(arg.test, arg.consequent, alternate);
-              }
-            }
-            if (types.isConditionalExpression(arg) && types.isIdentifier(arg.test)) {
-              if (types.isIdentifier(arg.consequent) && arg.test.name === arg.consequent.name) {
-                if (types.isIdentifier(arg.alternate) && arg.test.name === arg.alternate.name) {
-                  arg = arg.test;
-                } else {
-                  arg = types.logicalExpression("||", arg.consequent, arg.alternate);
-                }
-              } else if (types.isIdentifier(arg.alternate) && arg.test.name === arg.alternate.name) {
-                arg = types.logicalExpression("&&", arg.alternate, arg.consequent);
-              }
-            }
-            argument.replaceWith(types.callExpression(target, [arg]));
-          }
-        } else {
-          const target = readConfigKey(this.plugin.opts, "inlineHelpers") ? promiseResolve() : helperReference(this.plugin, path, "_await");
-          argument.replaceWith(types.callExpression(target, []));
-        }
-      }
-    }
-  };
-  function checkForErrorsAndRewriteReturns(path, plugin, rewriteReturns = false) {
-    const state = {
-      rewriteReturns,
-      plugin,
-      canThrow: false
-    };
-    path.traverse(checkForErrorsAndRewriteReturnsVisitor, state);
-    return state.canThrow;
-  }
-  const rewriteTopLevelReturnsVisitor = {
-    Function: skipNode,
-    ReturnStatement(path) {
-      const argument = path.get("argument");
-      if (argument.isCallExpression()) {
-        const callArgs = argument.node.arguments;
-        switch (callArgs.length) {
-          case 3:
-          case 2:
-            {
-              const secondArgument = callArgs[1];
-              if (!types.isUnaryExpression(secondArgument) || secondArgument.operator !== "void") {
-                break;
-              }
-            }
-          case 1:
-            if (types.isIdentifier(argument.node.callee) || types.isMemberExpression(argument.node.callee)) {
-              const firstArgument = callArgs[0];
-              if (types.isExpression(firstArgument)) {
-                switch (helperNameMap.get(argument.node.callee)) {
-                  case "_promiseResolve":
-                  case "_await":
-                    argument.replaceWith(firstArgument);
-                    break;
-                  case "_call":
-                    argument.replaceWith(types.callExpression(firstArgument, []));
-                    break;
-                }
-              }
-            }
-            break;
-        }
-      }
-    }
-  };
-  function reorderPathBeforeSiblingStatements(targetPath) {
-    for (const sibling of targetPath.getAllPrevSiblings().reverse()) {
-      if (!sibling.isFunctionDeclaration() && !sibling.isImportDeclaration()) {
-        const newNode = targetPath.node;
-        targetPath.remove();
-        reregisterDeclarations(sibling.insertBefore(newNode));
-        return;
-      }
-    }
-  }
-  function reregisterDeclarations(pathOrPaths) {
-    if (Array.isArray(pathOrPaths)) {
-      for (const path of pathOrPaths) {
-        reregisterDeclarations(path);
-      }
-    } else if (pathOrPaths && pathOrPaths.isLabeledStatement) {
-      const scope = pathOrPaths.isFunction() ? pathOrPaths.parentPath.scope : pathOrPaths.scope;
-      if (pathOrPaths.isVariableDeclaration() || pathOrPaths.isFunctionDeclaration() || pathOrPaths.isClassDeclaration()) {
-        scope.registerDeclaration(pathOrPaths);
-      }
-      pathOrPaths.traverse(reregisterVariableVisitor, {
-        originalScope: pathOrPaths.scope
-      });
-    }
-  }
-  function getPreviousSibling(targetPath) {
-    const siblings = targetPath.getAllPrevSiblings();
-    return siblings.length !== 0 ? siblings[siblings.length - 1] : undefined;
-  }
-  function getNextSibling(targetPath) {
-    const siblings = targetPath.getAllNextSiblings();
-    return siblings.length !== 0 ? siblings[0] : undefined;
-  }
-  function rewriteDefaultArguments(targetPath) {
-    const statements = [];
-    const params = targetPath.get("params");
-    const literals = [];
-    for (let i = 0; i < params.length; i++) {
-      const param = params[i];
-      if (param.isAssignmentPattern()) {
-        const init = param.get("right");
-        if (!isExpressionOfLiterals(init, literals)) {
-          const left = param.get("left");
-          let id;
-          let after;
-          if (left.isIdentifier()) {
-            id = left.node;
-          } else {
-            id = left.scope.generateUidIdentifier(`arg${i}`);
-            after = types.variableDeclaration("let", [types.variableDeclarator(left.node, id)]);
-          }
-          const initNode = init.node;
-          param.replaceWith(id);
-          const isMissing = types.binaryExpression("===", id, types.identifier("undefined"));
-          const assignment = types.expressionStatement(types.assignmentExpression("=", id, initNode));
-          statements.push(types.ifStatement(isMissing, assignment));
-          if (after) {
-            statements.push(after);
-          }
-        }
-      } else if (param.isIdentifier()) {
-        literals.push(param.node.name);
-      }
-    }
-    if (statements.length) {
-      targetPath.node.body.body = statements.concat(targetPath.node.body.body);
-    }
-  }
-  const unwrapReturnPromiseVisitor = {
-    ReturnStatement(path) {
-      const argument = path.get("argument");
-      if (argument.isCallExpression()) {
-        switch (promiseCallExpressionType(argument.node)) {
-          case "all":
-          case "race":
-          case "resolve":
-            switch (argument.node.arguments.length) {
-              case 0:
-                path.replaceWith(types.returnStatement());
-                break;
-              case 1:
-                const arg0 = argument.node.arguments[0];
-                if (types.isExpression(arg0)) {
-                  path.replaceWith(types.returnStatement(arg0));
-                }
-                break;
-            }
-            break;
-        }
-      }
-    }
-  };
-  const findAwaitExpressionVisitor = {
-    AwaitExpression(path) {
-      this.awaitPath = path;
-      path.stop();
-    }
-  };
-  return {
-    name: "transform-async-to-promises",
-    manipulateOptions(_options, parserOptions) {
-      parserOptions.plugins.push("asyncGenerators");
-    },
-    visitor: {
-      AwaitExpression(path) {
-        if (!path.getFunctionParent() && !this.hasTopLevelAwait) {
-          this.hasTopLevelAwait = true;
-        }
-      },
-      ImportDeclaration: {
-        exit(path) {
-          if (this.hasTopLevelAwait && readConfigKey(this.opts, "topLevelAwait") === "simple") {
-            throw path.buildCodeFrameError(`Cannot import after a top-level await when using topLevelAwait: "simple"!`, TypeError);
-          }
-        }
-      },
-      ExportDeclaration: {
-        exit(path) {
-          if (this.hasTopLevelAwait && readConfigKey(this.opts, "topLevelAwait") === "simple") {
-            throw path.buildCodeFrameError(`Cannot export after a top-level await when using topLevelAwait: "simple"!`, TypeError);
-          }
-        }
-      },
-      Program: {
-        exit(path) {
-          if (this.hasTopLevelAwait) {
-            let rediscoverState = {};
-            path.traverse(findAwaitExpressionVisitor, rediscoverState);
-            if (rediscoverState.awaitPath !== undefined) {
-              const functionParent = rediscoverState.awaitPath.getFunctionParent();
-              const topLevelAwaitParent = functionParent ? functionParent.get("body") : path;
-              switch (readConfigKey(this.opts, "topLevelAwait")) {
-                case "simple":
-                  {
-                    rewriteAsyncBlock({
-                      state: this
-                    }, topLevelAwaitParent, [], undefined, false, true);
-                    break;
-                  }
-                case "return":
-                  {
-                    helperReference(this, path, '_async');
-                    rewriteAsyncBlock({
-                      state: this
-                    }, topLevelAwaitParent, [], undefined, false, false);
-                    break;
-                  }
-                case "ignore":
-                  break;
-                default:
-                  throw rediscoverState.awaitPath.buildCodeFrameError(`Top level await is not supported unless experimental topLevelAwait: "simple" or topLevelAwait: "return" options are specified!`, TypeError);
-              }
-            }
-          }
-          const usedHelpers = this.usedHelpers;
-          if (usedHelpers !== undefined) {
-            const file = getFile(path);
-            for (const helperName of Object.keys(usedHelpers)) {
-              const helper = helpers[helperName];
-              const value = cloneNode(helper.value);
-              const newPath = insertHelper(file.path, value);
-              newPath.traverse({
-                Identifier(identifierPath) {
-                  const name = identifierPath.node.name;
-                  if (Object.hasOwnProperty.call(helpers, name)) {
-                    identifierPath.replaceWith(file.declarations[name]);
-                  }
-                }
-              });
-            }
-          }
-        }
-      },
-      FunctionDeclaration(path) {
-        if (!readConfigKey(this.opts, 'asyncAwait')) {
-          return;
-        }
-        const node = path.node;
-        if (node.async) {
-          const expression = types.functionExpression(undefined, node.params, node.body, node.generator, node.async);
-          if (node.id === null || node.id === undefined) {
-            path.replaceWith(expression);
-            reregisterDeclarations(path);
-            return;
-          }
-          const declarators = [types.variableDeclarator(node.id, expression)];
-          if (path.parentPath.isExportDeclaration()) {
-            if (path.parentPath.isExportDefaultDeclaration()) {
-              const targetPath = path.parentPath;
-              targetPath.replaceWith(types.variableDeclaration("const", declarators));
-              reregisterDeclarations(targetPath);
-              reregisterDeclarations(targetPath.insertAfter(types.exportDefaultDeclaration(node.id)));
-              reorderPathBeforeSiblingStatements(targetPath);
-            } else {
-              path.replaceWith(types.variableDeclaration("const", declarators));
-              reregisterDeclarations(path);
-              reorderPathBeforeSiblingStatements(path.parentPath);
-            }
-          } else {
-            path.replaceWith(types.variableDeclaration("const", declarators));
-            reregisterDeclarations(path);
-            reorderPathBeforeSiblingStatements(path);
-          }
-        }
-      },
-      ArrowFunctionExpression(path) {
-        if (!readConfigKey(this.opts, 'asyncAwait')) {
-          return;
-        }
-        const node = path.node;
-        if (node.async) {
-          rewriteThisExpressions(path, path.getFunctionParent() || path.scope.getProgramParent().path);
-          const body = types.isBlockStatement(path.node.body) ? path.node.body : blockStatement([types.returnStatement(path.node.body)]);
-          path.replaceWith(types.functionExpression(undefined, node.params, body, false, node.async));
-          reregisterDeclarations(path);
-        }
-      },
-      FunctionExpression(path) {
-        if (!readConfigKey(this.opts, 'asyncAwait')) {
-          return;
-        }
-        if (path.node.async) {
-          const id = path.node.id;
-          if (path.parentPath.isExportDefaultDeclaration() && id !== null && id !== undefined) {
-            const targetPath = path.parentPath;
-            targetPath.replaceWith(types.variableDeclaration("const", [types.variableDeclarator(id, types.functionExpression(undefined, path.node.params, path.node.body, path.node.generator, path.node.async))]));
-            reregisterDeclarations(targetPath);
-            reregisterDeclarations(targetPath.insertAfter(types.exportDefaultDeclaration(id)));
-            reorderPathBeforeSiblingStatements(targetPath);
-            return;
-          }
-          rewriteDefaultArguments(path);
-          rewriteThisArgumentsAndHoistFunctions(path, path, false);
-          const bodyPath = path.get("body");
-          if (path.node.generator) {
-            const generatorIdentifier = path.scope.generateUidIdentifier("generator");
-            path.scope.push({
-              kind: "const",
-              id: generatorIdentifier,
-              unique: true
-            });
-            const generatorBinding = path.scope.getBinding(generatorIdentifier.name);
-            if (typeof generatorBinding === "undefined") {
-              throw path.buildCodeFrameError(`Could not find newly created binding for ${generatorIdentifier.name}!`, Error);
-            }
-            rewriteAsyncBlock({
-              state: this,
-              generatorIdentifier
-            }, bodyPath, []);
-            generatorBinding.path.remove();
-            path.replaceWith(functionize(this, path.node.params, types.newExpression(helperReference(this, path, "_AsyncGenerator"), [functionize(this, [generatorIdentifier], bodyPath.node, path)]), path, id));
-          } else {
-            rewriteAsyncBlock({
-              state: this
-            }, path, []);
-            const inlineHelpers = readConfigKey(this.opts, "inlineHelpers");
-            const canThrow = checkForErrorsAndRewriteReturns(bodyPath, this, inlineHelpers || id !== null && id !== undefined);
-            const parentPath = path.parentPath;
-            const skipReturn = parentPath.isCallExpression() && parentPath.node.callee === path.node && parentPath.parentPath.isExpressionStatement();
-            if (!skipReturn && !pathsReturnOrThrowCurrentNodes(bodyPath).all) {
-              const awaitHelper = inlineHelpers ? promiseResolve() : helperReference(this, path, "_await");
-              path.node.body.body.push(types.returnStatement(types.callExpression(awaitHelper, [])));
-            }
-            if (skipReturn) {
-              path.traverse(unwrapReturnPromiseVisitor);
-            }
-            if (canThrow) {
-              if (inlineHelpers || id) {
-                if (!id && skipReturn && parentPath.isCallExpression() && parentPath.node.arguments.length === 0 && !pathsReturn(bodyPath).any) {
-                  parentPath.parentPath.replaceWith(types.tryStatement(bodyPath.node, types.catchClause(types.identifier("e"), blockStatement([types.expressionStatement(types.callExpression(types.memberExpression(types.identifier("Promise"), types.identifier("reject")), [types.identifier("e")]))]))));
-                } else {
-                  path.replaceWith(functionize(this, path.node.params, blockStatement(types.tryStatement(bodyPath.node, types.catchClause(types.identifier("e"), blockStatement([(skipReturn ? types.expressionStatement : types.returnStatement)(types.callExpression(types.memberExpression(types.identifier("Promise"), types.identifier("reject")), [types.identifier("e")]))])))), path, id));
-                }
-              } else {
-                bodyPath.traverse(rewriteTopLevelReturnsVisitor);
-                path.replaceWith(types.callExpression(helperReference(this, path, "_async"), [functionize(this, path.node.params, bodyPath.node, path)]));
-              }
-            } else {
-              if (!inlineHelpers) {
-                checkForErrorsAndRewriteReturns(bodyPath, this, true);
-              }
-              path.replaceWith(functionize(this, path.node.params, bodyPath.node, path, id));
-            }
-          }
-          nodeIsAsyncSet.add(path.node);
-        }
-      },
-      ClassMethod(path) {
-        if (!readConfigKey(this.opts, 'asyncAwait')) {
-          return;
-        }
-        if (path.node.async) {
-          const body = path.get("body");
-          if (path.node.kind === "method") {
-            rewriteDefaultArguments(path);
-            body.replaceWith(types.blockStatement([body.node]));
-            const target = body.get("body")[0];
-            if (!target.isBlockStatement()) {
-              throw path.buildCodeFrameError(`Expected a BlockStatement, got a ${target.type}`, TypeError);
-            }
-            if (path.node.generator) {
-              const generatorIdentifier = target.scope.generateUidIdentifier("generator");
-              target.scope.push({
-                kind: "const",
-                id: generatorIdentifier,
-                init: generatorIdentifier,
-                unique: true
-              });
-              const generatorBinding = target.scope.getBinding(generatorIdentifier.name);
-              if (typeof generatorBinding === "undefined") {
-                throw path.buildCodeFrameError(`Could not find newly created binding for ${generatorIdentifier.name}!`, Error);
-              }
-              rewriteAsyncBlock({
-                state: this,
-                generatorIdentifier
-              }, target, []);
-              generatorBinding.path.remove();
-              target.replaceWith(types.returnStatement(types.newExpression(helperReference(this, path, "_AsyncGenerator"), [functionize(this, [generatorIdentifier], target.node, target)])));
-            } else {
-              const inlineHelpers = readConfigKey(this.opts, "inlineHelpers");
-              rewriteThisArgumentsAndHoistFunctions(target, inlineHelpers ? target : body, true);
-              rewriteAsyncBlock({
-                state: this
-              }, target, []);
-              const statements = target.get("body");
-              const lastStatement = statements[statements.length - 1];
-              if (!lastStatement || !lastStatement.isReturnStatement()) {
-                const awaitHelper = inlineHelpers ? promiseResolve() : helperReference(this, path, "_await");
-                target.node.body.push(types.returnStatement(types.callExpression(awaitHelper, [])));
-              }
-              const canThrow = checkForErrorsAndRewriteReturns(body, this, true);
-              if (!canThrow) {
-                target.replaceWithMultiple(target.node.body);
-              } else if (inlineHelpers) {
-                target.replaceWith(types.tryStatement(target.node, types.catchClause(types.identifier("e"), blockStatement([types.returnStatement(types.callExpression(types.memberExpression(types.identifier("Promise"), types.identifier("reject")), [types.identifier("e")]))]))));
-              } else {
-                target.replaceWith(types.returnStatement(types.callExpression(helperReference(this, path, "_call"), [functionize(this, [], target.node, path)])));
-              }
-            }
-          }
-          path.replaceWith(types.classMethod(path.node.kind, path.node.key, path.node.params, path.node.body, path.node.computed, path.node.static));
-        }
-      },
-      ObjectMethod(path) {
-        if (!readConfigKey(this.opts, 'asyncAwait')) {
-          return;
-        }
-        if (path.node.async) {
-          if (path.node.kind === "method") {
-            path.replaceWith(types.objectProperty(path.node.key, types.functionExpression(undefined, path.node.params, path.node.body, path.node.generator, path.node.async), path.node.computed, false, path.node.decorators));
-          }
-        }
-      }
-    }
-  };
-}
-
-const systemJsClientFileUrlDefault = new URL("./js/s.js", import.meta.url).href;
-const convertJsModuleToJsClassic = async ({
-  systemJsInjection,
-  systemJsClientFileUrl = systemJsClientFileUrlDefault,
-  urlInfo,
-  jsModuleUrlInfo
-}) => {
-  let jsClassicFormat;
-  if (urlInfo.isEntryPoint && !jsModuleUrlInfo.data.usesImport) {
-    // if it's an entry point without dependency (it does not use import)
-    // then we can use UMD
-    jsClassicFormat = "umd";
-  } else {
-    // otherwise we have to use system in case it's imported
-    // by an other file (for entry points)
-    // or to be able to import when it uses import
-    jsClassicFormat = "system";
-  }
-  urlInfo.data.jsClassicFormat = jsClassicFormat;
-  const {
-    code,
-    map
-  } = await applyBabelPlugins({
-    babelPlugins: [...(jsClassicFormat === "system" ? [
-    // proposal-dynamic-import required with systemjs for babel8:
-    // https://github.com/babel/babel/issues/10746
-    requireFromJsenv("@babel/plugin-proposal-dynamic-import"), requireFromJsenv("@babel/plugin-transform-modules-systemjs"), [babelPluginRelativeImports, {
-      rootUrl: jsModuleUrlInfo.url
-    }], [default_1, {
-      asyncAwait: false,
-      // already handled + we might not needs it at all
-      topLevelAwait: "return"
-    }]] : [[requireBabelPlugin("babel-plugin-transform-async-to-promises"), {
-      asyncAwait: false,
-      // already handled + we might not needs it at all
-      topLevelAwait: "simple"
-    }], babelPluginTransformImportMetaUrl, babelPluginTransformImportMetaResolve, requireFromJsenv("@babel/plugin-transform-modules-umd"), [babelPluginRelativeImports, {
-      rootUrl: jsModuleUrlInfo.url
-    }]])],
-    urlInfo: jsModuleUrlInfo
-  });
-  let sourcemap = jsModuleUrlInfo.sourcemap;
-  sourcemap = await composeTwoSourcemaps(sourcemap, map);
-  if (systemJsInjection && jsClassicFormat === "system" && urlInfo.isEntryPoint) {
-    const magicSource = createMagicSource(code);
-    let systemJsFileContent = readFileSync(systemJsClientFileUrl, {
-      as: "string"
-    });
-    const sourcemapFound = SOURCEMAP.readComment({
-      contentType: "text/javascript",
-      content: systemJsFileContent
-    });
-    if (sourcemapFound) {
-      // for now let's remove s.js sourcemap
-      // because it would likely mess the sourcemap of the entry point itself
-      systemJsFileContent = SOURCEMAP.writeComment({
-        contentType: "text/javascript",
-        content: systemJsFileContent,
-        specifier: ""
-      });
-    }
-    magicSource.prepend(`${systemJsFileContent}\n\n`);
-    const magicResult = magicSource.toContentAndSourcemap();
-    sourcemap = await composeTwoSourcemaps(sourcemap, magicResult.sourcemap);
-    return {
-      content: magicResult.content,
-      sourcemap
-    };
-  }
-  return {
-    content: code,
-    sourcemap
-  };
-};
-
-/*
- * When systemjs or umd format is used by babel, it will generated UID based on
- * the import specifier:
- * https://github.com/babel/babel/blob/97d1967826077f15e766778c0d64711399e9a72a/packages/babel-plugin-transform-modules-systemjs/src/index.ts#L498
- * But at this stage import specifier are absolute file urls
- * This can be mitigated by minification that will rename them.
- * But to fix this issue once and for all there is babelPluginRelativeImports below
- */
-const babelPluginRelativeImports = babel => {
-  const t = babel.types;
-  const replaceSpecifierAtPath = (path, state) => {
-    const specifier = path.node.value;
-    if (specifier.startsWith("file://")) {
-      const specifierRelative = urlToRelativeUrl(specifier, state.opts.rootUrl);
-      path.replaceWith(t.stringLiteral(specifierRelative));
-    }
-  };
-  return {
-    name: "relative-imports",
-    visitor: {
-      CallExpression: (path, state) => {
-        if (path.node.callee.type !== "Import") {
-          // Some other function call, not import();
-          return;
-        }
-        if (path.node.arguments[0].type !== "StringLiteral") {
-          // Non-string argument, probably a variable or expression, e.g.
-          // import(moduleId)
-          // import('./' + moduleName)
-          return;
-        }
-        const sourcePath = path.get("arguments")[0];
-        if (sourcePath.node.type === "StringLiteral") {
-          replaceSpecifierAtPath(sourcePath, state);
-        }
-      },
-      ImportDeclaration: (path, state) => {
-        const sourcePath = path.get("source");
-        replaceSpecifierAtPath(sourcePath, state);
-      },
-      ExportAllDeclaration: (path, state) => {
-        const sourcePath = path.get("source");
-        replaceSpecifierAtPath(sourcePath, state);
-      },
-      ExportNamedDeclaration: (path, state) => {
-        if (!path.node.source) {
-          // This export has no "source", so it's probably
-          // a local variable or function, e.g.
-          // export { varName }
-          // export const constName = ...
-          // export function funcName() {}
-          return;
-        }
-        const sourcePath = path.get("source");
-        if (sourcePath.node.type === "StringLiteral") {
-          replaceSpecifierAtPath(sourcePath, state);
-        }
-      }
-    }
-  };
-};
-
-/*
- * - propagate "?js_module_fallback" query string param on urls
- * - perform conversion from js module to js classic when url uses "?js_module_fallback"
- */
-
-const jsenvPluginJsModuleConversion = ({
-  systemJsInjection,
-  systemJsClientFileUrl,
-  generateJsClassicFilename
-}) => {
-  const isReferencingJsModule = reference => {
-    if (reference.type === "js_import" || reference.subtype === "system_register_arg" || reference.subtype === "system_import_arg") {
-      return true;
-    }
-    if (reference.type === "js_url" && reference.expectedType === "js_module") {
-      return true;
-    }
-    return false;
-  };
-  const shouldPropagateJsModuleConversion = (reference, context) => {
-    if (isReferencingJsModule(reference)) {
-      const parentUrlInfo = context.urlGraph.getUrlInfo(reference.parentUrl);
-      if (!parentUrlInfo) {
-        return false;
-      }
-      const parentGotAsJsClassic = new URL(parentUrlInfo.url).searchParams.has("js_module_fallback");
-      return parentGotAsJsClassic;
-    }
-    return false;
-  };
-  const markAsJsClassicProxy = reference => {
-    reference.expectedType = "js_classic";
-    reference.filename = generateJsClassicFilename(reference.url);
-  };
-  const turnIntoJsClassicProxy = reference => {
-    const urlTransformed = injectQueryParams(reference.url, {
-      js_module_fallback: ""
-    });
-    markAsJsClassicProxy(reference);
-    return urlTransformed;
-  };
-  return {
-    name: "jsenv:js_module_conversion",
-    appliesDuring: "*",
-    redirectReference: (reference, context) => {
-      if (reference.searchParams.has("js_module_fallback")) {
-        markAsJsClassicProxy(reference);
-        return null;
-      }
-      // We want to propagate transformation of js module to js classic to:
-      // - import specifier (static/dynamic import + re-export)
-      // - url specifier when inside System.register/_context.import()
-      //   (because it's the transpiled equivalent of static and dynamic imports)
-      // And not other references otherwise we could try to transform inline resources
-      // or specifiers inside new URL()...
-      if (shouldPropagateJsModuleConversion(reference, context)) {
-        return turnIntoJsClassicProxy(reference);
-      }
-      return null;
-    },
-    fetchUrlContent: async (urlInfo, context) => {
-      const [jsModuleReference, jsModuleUrlInfo] = context.getWithoutSearchParam({
-        urlInfo,
-        context,
-        searchParam: "js_module_fallback",
-        // override the expectedType to "js_module"
-        // because when there is ?js_module_fallback it means the underlying resource
-        // is a js_module
-        expectedType: "js_module"
-      });
-      if (!jsModuleReference) {
-        return null;
-      }
-      await context.fetchUrlContent(jsModuleUrlInfo, {
-        reference: jsModuleReference
-      });
-      if (context.dev) {
-        context.referenceUtils.found({
-          type: "js_import",
-          subtype: jsModuleReference.subtype,
-          specifier: jsModuleReference.url,
-          expectedType: "js_module"
-        });
-      } else if (context.build && jsModuleUrlInfo.dependents.size === 0) {
-        context.urlGraph.deleteUrlInfo(jsModuleUrlInfo.url);
-      }
-      const {
-        content,
-        sourcemap
-      } = await convertJsModuleToJsClassic({
-        rootDirectoryUrl: context.rootDirectoryUrl,
-        systemJsInjection,
-        systemJsClientFileUrl,
-        urlInfo,
-        jsModuleUrlInfo
-      });
-      return {
-        content,
-        contentType: "text/javascript",
-        type: "js_classic",
-        originalUrl: jsModuleUrlInfo.originalUrl,
-        originalContent: jsModuleUrlInfo.originalContent,
-        sourcemap,
-        data: jsModuleUrlInfo.data
-      };
-    }
-  };
-};
-
-/*
- * when <script type="module"> cannot be used:
- * - ?js_module_fallback is injected into the src of <script type="module">
- * - js inside <script type="module"> is transformed into classic js
- * - <link rel="modulepreload"> are converted to <link rel="preload">
- */
-
-const jsenvPluginJsModuleFallbackInsideHtml = ({
-  systemJsInjection,
-  systemJsClientFileUrl
-}) => {
-  const turnIntoJsClassicProxy = reference => {
-    return injectQueryParams(reference.url, {
-      js_module_fallback: ""
-    });
-  };
-  return {
-    name: "jsenv:js_module_fallback_inside_html",
-    appliesDuring: "*",
-    redirectReference: {
-      link_href: (reference, context) => {
-        if (context.systemJsTranspilation && reference.subtype === "modulepreload") {
-          return turnIntoJsClassicProxy(reference);
-        }
-        if (context.systemJsTranspilation && reference.subtype === "preload" && reference.expectedType === "js_module") {
-          return turnIntoJsClassicProxy(reference);
-        }
-        return null;
-      },
-      script: (reference, context) => {
-        if (context.systemJsTranspilation && reference.expectedType === "js_module") {
-          return turnIntoJsClassicProxy(reference);
-        }
-        return null;
-      },
-      js_url: (reference, context) => {
-        if (context.systemJsTranspilation && reference.expectedType === "js_module") {
-          return turnIntoJsClassicProxy(reference);
-        }
-        return null;
-      }
-    },
-    finalizeUrlContent: {
-      html: async (urlInfo, context) => {
-        const htmlAst = parseHtmlString(urlInfo.content);
-        const mutations = [];
-        visitHtmlNodes(htmlAst, {
-          link: node => {
-            const rel = getHtmlNodeAttribute(node, "rel");
-            if (rel !== "modulepreload" && rel !== "preload") {
-              return;
+    },
+    finalizeUrlContent: {
+      html: async (urlInfo, context) => {
+        const htmlAst = parseHtmlString(urlInfo.content);
+        const mutations = [];
+        visitHtmlNodes(htmlAst, {
+          link: node => {
+            const rel = getHtmlNodeAttribute(node, "rel");
+            if (rel !== "modulepreload" && rel !== "preload") {
+              return;
             }
             const href = getHtmlNodeAttribute(node, "href");
             if (!href) {
@@ -15378,7 +11634,7 @@ const jsenvPluginJsModuleFallbackInsideHtml = ({
           }
           if (needsSystemJs) {
             mutations.push(async () => {
-              let systemJsFileContent = readFileSync$1(new URL(systemJsClientFileUrl), {
+              let systemJsFileContent = readFileSync(new URL(systemJsClientFileUrl), {
                 encoding: "utf8"
               });
               const sourcemapFound = SOURCEMAP.readComment({
@@ -16407,7 +12663,7 @@ const defaultLookupPackageScope = url => {
 
 const defaultReadPackageJson = packageUrl => {
   const packageJsonUrl = new URL("package.json", packageUrl);
-  const buffer = readFileSync$1(packageJsonUrl);
+  const buffer = readFileSync(packageJsonUrl);
   const string = String(buffer);
   try {
     return JSON.parse(string);
@@ -17123,7 +13379,7 @@ const mainLegacyResolvers = {
       };
     }
     const browserMainUrlObject = new URL(browserMain, packageDirectoryUrl);
-    const content = readFileSync$1(browserMainUrlObject, "utf-8");
+    const content = readFileSync(browserMainUrlObject, "utf-8");
     if (/typeof exports\s*==/.test(content) && /typeof module\s*==/.test(content) || /module\.exports\s*=/.test(content)) {
       return {
         type: "field:module",
@@ -17375,7 +13631,7 @@ const addRelationshipWithPackageJson = ({
     hasVersioningEffect
   });
   if (packageJsonUrlInfo.type === undefined) {
-    const packageJsonContentAsBuffer = readFileSync$1(new URL(packageJsonUrl));
+    const packageJsonContentAsBuffer = readFileSync(new URL(packageJsonUrl));
     packageJsonUrlInfo.type = "json";
     packageJsonUrlInfo.content = String(packageJsonContentAsBuffer);
     packageJsonUrlInfo.originalContentEtag = packageJsonUrlInfo.contentEtag = bufferToEtag$1(packageJsonContentAsBuffer);
@@ -17659,7 +13915,7 @@ const jsenvPluginProtocolFile = ({
           filename
         };
       }
-      const fileBuffer = readFileSync$1(urlObject);
+      const fileBuffer = readFileSync(urlObject);
       const contentType = CONTENT_TYPE.fromUrlExtension(urlInfo.url);
       return {
         content: CONTENT_TYPE.isTextual(contentType) ? String(fileBuffer) : fileBuffer,
@@ -18428,6 +14684,12 @@ const babelHelperNameFromUrl = url => {
   return babelHelperName;
 };
 
+const requireFromJsenv = createRequire(import.meta.url);
+
+const babelPluginPackagePath = requireFromJsenv.resolve("@jsenv/babel-plugins");
+const babelPluginPackageUrl = pathToFileURL(babelPluginPackagePath);
+const requireBabelPlugin = createRequire(babelPluginPackageUrl);
+
 /* eslint-disable camelcase */
 // copied from
 // https://github.com/babel/babel/blob/e498bee10f0123bb208baa228ce6417542a2c3c4/packages/babel-compat-data/data/plugins.json#L1
@@ -20819,7 +17081,7 @@ ${ANSI.color(buildUrl, ANSI.MAGENTA)}
       }), ...(lineBreakNormalization ? [jsenvPluginLineBreakNormalization()] : []), jsenvPluginJsModuleFallback({
         systemJsInjection: true
       }), jsenvPluginInlining(), {
-        name: "jsenv:build",
+        name: "jsenv:build_shape",
         appliesDuring: "build",
         resolveReference: reference => {
           const getUrl = () => {
@@ -22247,7 +18509,7 @@ const createFileService = ({
           // file is not watched, check the filesystem
           let fileContentAsBuffer;
           try {
-            fileContentAsBuffer = readFileSync$1(new URL(urlInfo.url));
+            fileContentAsBuffer = readFileSync(new URL(urlInfo.url));
           } catch (e) {
             if (e.code === "ENOENT") {
               // we should consider calling urlGraph.deleteUrlInfo(urlInfo)
@@ -22502,12 +18764,7 @@ const inferParentFromRequest = (request, sourceDirectoryUrl, sourceMainFilePath)
     return null;
   }
   const refererUrlObject = new URL(referer);
-  refererUrlObject.searchParams.delete("hmr");
-  refererUrlObject.searchParams.delete("v");
-  let refererUrl = refererUrlObject.href;
-  if (refererUrl === `${request.origin}/`) {
-    refererUrl = new URL(sourceMainFilePath, request.origin).href;
-  }
+  const refererUrl = refererUrlObject.pathname === `/` ? new URL(sourceMainFilePath, request.origin).href : referer;
   return WEB_URL_CONVERTER.asFileUrl(refererUrl, {
     origin: request.origin,
     rootDirectoryUrl: sourceDirectoryUrl