rollup 2.60.1 → 2.62.0

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.60.1
-	Mon, 22 Nov 2021 07:50:11 GMT - commit 649074e14131b490ff9dfe26e94632ff458c4970
+	Rollup.js v2.62.0
+	Fri, 24 Dec 2021 06:27:02 GMT - commit 81ce56f87de5fae51c00c4a0a977830ee93c5987
 
 
 	https://github.com/rollup/rollup
@@ -26,7 +26,7 @@ function _interopNamespaceDefault(e) {
   return n;
 }
 
-var version$1 = "2.60.1";
+var version$1 = "2.62.0";
 
 function ensureArray$1(items) {
     if (Array.isArray(items)) {
@@ -582,15 +582,14 @@ const getHashFromObjectOption = (optionName) => optionName.split('.').join('').t
 
 let fsEvents;
 let fsEventsImportError;
-function loadFsEvents() {
+async function loadFsEvents() {
     const moduleName = 'fsevents';
-    return Promise.resolve().then(() => /*#__PURE__*/_interopNamespaceDefault(require(moduleName)))
-        .then(namespace => {
-        fsEvents = namespace.default;
-    })
-        .catch(err => {
+    try {
+        ({ default: fsEvents } = await Promise.resolve().then(() => /*#__PURE__*/_interopNamespaceDefault(require(moduleName))));
+    }
+    catch (err) {
         fsEventsImportError = err;
-    });
+    }
 }
 // A call to this function will be injected into the chokidar code
 function getFsEvents() {
@@ -2252,20 +2251,70 @@ const BLANK = Object.freeze(Object.create(null));
 const EMPTY_OBJECT = Object.freeze({});
 const EMPTY_ARRAY = Object.freeze([]);
 
-const reservedWords$2 = 'break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public'.split(' ');
-const builtins$2 = 'Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl'.split(' ');
-const blacklisted = new Set(reservedWords$2.concat(builtins$2));
+const RESERVED_NAMES = new Set([
+    'await',
+    'break',
+    'case',
+    'catch',
+    'class',
+    'const',
+    'continue',
+    'debugger',
+    'default',
+    'delete',
+    'do',
+    'else',
+    'enum',
+    'eval',
+    'export',
+    'extends',
+    'false',
+    'finally',
+    'for',
+    'function',
+    'if',
+    'implements',
+    'import',
+    'in',
+    'instanceof',
+    'interface',
+    'let',
+    'NaN',
+    'new',
+    'null',
+    'package',
+    'private',
+    'protected',
+    'public',
+    'return',
+    'static',
+    'super',
+    'switch',
+    'this',
+    'throw',
+    'true',
+    'try',
+    'typeof',
+    'undefined',
+    'var',
+    'void',
+    'while',
+    'with',
+    'yield'
+]);
+const RESERVED_NAMES$1 = RESERVED_NAMES;
+
 const illegalCharacters = /[^$_a-zA-Z0-9]/g;
 const startsWithDigit = (str) => /\d/.test(str[0]);
 function isLegal(str) {
-    if (startsWithDigit(str) || blacklisted.has(str)) {
+    if (startsWithDigit(str) || RESERVED_NAMES$1.has(str)) {
         return false;
     }
     return !illegalCharacters.test(str);
 }
 function makeLegal(str) {
     str = str.replace(/-(\w)/g, (_, letter) => letter.toUpperCase()).replace(illegalCharacters, '_');
-    if (startsWithDigit(str) || blacklisted.has(str))
+    if (startsWithDigit(str) || RESERVED_NAMES$1.has(str))
         str = `_${str}`;
     return str || '_';
 }
@@ -2307,6 +2356,7 @@ class ExternalModule {
             },
             isEntry: false,
             isExternal: true,
+            isIncluded: null,
             meta,
             syntheticNamedExports: false
         };
@@ -5549,8 +5599,6 @@ const knownGlobals = {
         __proto__: null,
         [ValueProperties]: PURE,
         create: PF,
-        getNotifier: PF,
-        getOwn: PF,
         getOwnPropertyDescriptor: PF,
         getOwnPropertyNames: PF,
         getOwnPropertySymbols: PF,
@@ -6592,62 +6640,10 @@ function toBase64(num) {
     return outStr;
 }
 
-const RESERVED_NAMES = {
-    __proto__: null,
-    await: true,
-    break: true,
-    case: true,
-    catch: true,
-    class: true,
-    const: true,
-    continue: true,
-    debugger: true,
-    default: true,
-    delete: true,
-    do: true,
-    else: true,
-    enum: true,
-    eval: true,
-    export: true,
-    extends: true,
-    false: true,
-    finally: true,
-    for: true,
-    function: true,
-    if: true,
-    implements: true,
-    import: true,
-    in: true,
-    instanceof: true,
-    interface: true,
-    let: true,
-    new: true,
-    null: true,
-    package: true,
-    private: true,
-    protected: true,
-    public: true,
-    return: true,
-    static: true,
-    super: true,
-    switch: true,
-    this: true,
-    throw: true,
-    true: true,
-    try: true,
-    typeof: true,
-    undefined: true,
-    var: true,
-    void: true,
-    while: true,
-    with: true,
-    yield: true
-};
-
 function getSafeName(baseName, usedNames) {
     let safeName = baseName;
     let count = 1;
-    while (usedNames.has(safeName) || RESERVED_NAMES[safeName]) {
+    while (usedNames.has(safeName) || RESERVED_NAMES$1.has(safeName)) {
         safeName = `${baseName}$${toBase64(count++)}`;
     }
     usedNames.add(safeName);
@@ -6758,16 +6754,27 @@ const literalNumberMembers = assembleMemberDescriptions({
     valueOf: returnsNumber
 }, objectMembers);
 const literalStringMembers = assembleMemberDescriptions({
+    anchor: returnsString,
+    at: returnsUnknown,
+    big: returnsString,
+    blink: returnsString,
+    bold: returnsString,
     charAt: returnsString,
     charCodeAt: returnsNumber,
-    codePointAt: returnsNumber,
+    codePointAt: returnsUnknown,
     concat: returnsString,
     endsWith: returnsBoolean,
+    fixed: returnsString,
+    fontcolor: returnsString,
+    fontsize: returnsString,
     includes: returnsBoolean,
     indexOf: returnsNumber,
+    italics: returnsString,
     lastIndexOf: returnsNumber,
+    link: returnsString,
     localeCompare: returnsNumber,
-    match: returnsBoolean,
+    match: returnsUnknown,
+    matchAll: returnsUnknown,
     normalize: returnsString,
     padEnd: returnsString,
     padStart: returnsString,
@@ -6778,17 +6785,32 @@ const literalStringMembers = assembleMemberDescriptions({
             returns: UNKNOWN_LITERAL_STRING
         }
     },
+    replaceAll: {
+        value: {
+            callsArgs: [1],
+            returns: UNKNOWN_LITERAL_STRING
+        }
+    },
     search: returnsNumber,
     slice: returnsString,
+    small: returnsString,
     split: returnsUnknown,
     startsWith: returnsBoolean,
+    strike: returnsString,
+    sub: returnsString,
     substr: returnsString,
     substring: returnsString,
+    sup: returnsString,
     toLocaleLowerCase: returnsString,
     toLocaleUpperCase: returnsString,
     toLowerCase: returnsString,
+    toString: returnsString,
     toUpperCase: returnsString,
     trim: returnsString,
+    trimEnd: returnsString,
+    trimLeft: returnsString,
+    trimRight: returnsString,
+    trimStart: returnsString,
     valueOf: returnsString
 }, objectMembers);
 function getLiteralMembersForValue(value) {
@@ -8604,6 +8626,8 @@ const ARRAY_PROTOTYPE = new ObjectEntity({
     filter: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NEW_ARRAY,
     find: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN,
     findIndex: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NUMBER,
+    flat: METHOD_DEOPTS_SELF_RETURNS_NEW_ARRAY,
+    flatMap: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NEW_ARRAY,
     forEach: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN,
     includes: METHOD_RETURNS_BOOLEAN,
     indexOf: METHOD_RETURNS_NUMBER,
@@ -8621,6 +8645,8 @@ const ARRAY_PROTOTYPE = new ObjectEntity({
     some: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_BOOLEAN,
     sort: METHOD_CALLS_ARG_MUTATES_SELF_RETURNS_SELF,
     splice: METHOD_MUTATES_SELF_RETURNS_NEW_ARRAY,
+    toLocaleString: METHOD_RETURNS_STRING,
+    toString: METHOD_RETURNS_STRING,
     unshift: METHOD_MUTATES_SELF_RETURNS_NUMBER,
     values: METHOD_DEOPTS_SELF_RETURNS_UNKNOWN
 }, OBJECT_PROTOTYPE, true);
@@ -12073,13 +12099,19 @@ class SyntheticNamedExportVariable extends Variable {
     }
 }
 
+var BuildPhase;
+(function (BuildPhase) {
+    BuildPhase[BuildPhase["LOAD_AND_PARSE"] = 0] = "LOAD_AND_PARSE";
+    BuildPhase[BuildPhase["ANALYSE"] = 1] = "ANALYSE";
+    BuildPhase[BuildPhase["GENERATE"] = 2] = "GENERATE";
+})(BuildPhase || (BuildPhase = {}));
+
 function getId(m) {
     return m.id;
 }
 
 function getOriginalLocation(sourcemapChain, location) {
-    // This cast is guaranteed. If it were a missing Map, it wouldn't have a mappings.
-    const filteredSourcemapChain = sourcemapChain.filter(sourcemap => sourcemap.mappings);
+    const filteredSourcemapChain = sourcemapChain.filter((sourcemap) => !!sourcemap.mappings);
     while (filteredSourcemapChain.length > 0) {
         const sourcemap = filteredSourcemapChain.pop();
         const line = sourcemap.mappings[location.line - 1];
@@ -12352,10 +12384,10 @@ class Module {
             hasModuleSideEffects,
             id,
             get implicitlyLoadedAfterOneOf() {
-                return Array.from(module.implicitlyLoadedAfter, getId);
+                return Array.from(module.implicitlyLoadedAfter, getId).sort();
             },
             get implicitlyLoadedBefore() {
-                return Array.from(module.implicitlyLoadedBefore, getId);
+                return Array.from(module.implicitlyLoadedBefore, getId).sort();
             },
             get importedIds() {
                 return Array.from(module.sources, source => { var _a; return (_a = module.resolvedIds[source]) === null || _a === void 0 ? void 0 : _a.id; }).filter(Boolean);
@@ -12365,6 +12397,12 @@ class Module {
             },
             isEntry,
             isExternal: false,
+            get isIncluded() {
+                if (module.graph.phase !== BuildPhase.GENERATE) {
+                    return null;
+                }
+                return module.isIncluded();
+            },
             meta,
             syntheticNamedExports
         };
@@ -14155,7 +14193,7 @@ function escapeId(id) {
 function assignExportsToMangledNames(exports, exportsByName, exportNamesByVariable) {
     let nameIndex = 0;
     for (const variable of exports) {
-        let exportName = variable.name[0];
+        let [exportName] = variable.name;
         if (exportsByName[exportName]) {
             do {
                 exportName = toBase64(++nameIndex);
@@ -14164,7 +14202,7 @@ function assignExportsToMangledNames(exports, exportsByName, exportNamesByVariab
                     nameIndex += 9 * 64 ** (exportName.length - 1);
                     exportName = toBase64(nameIndex);
                 }
-            } while (RESERVED_NAMES[exportName] || exportsByName[exportName]);
+            } while (RESERVED_NAMES$1.has(exportName) || exportsByName[exportName]);
         }
         exportsByName[exportName] = variable;
         exportNamesByVariable.set(variable, [exportName]);
@@ -14979,11 +15017,11 @@ class Chunk {
                     continue;
                 }
                 const renderedResolution = resolution instanceof Module
-                    ? `'${this.getRelativePath((facadeChunk || chunk).id, stripKnownJsExtensions)}'`
+                    ? `'${escapeId(this.getRelativePath((facadeChunk || chunk).id, stripKnownJsExtensions))}'`
                     : resolution instanceof ExternalModule
-                        ? `'${resolution.renormalizeRenderPath
+                        ? `'${escapeId(resolution.renormalizeRenderPath
                             ? this.getRelativePath(resolution.renderPath, stripKnownJsExtensions)
-                            : resolution.renderPath}'`
+                            : resolution.renderPath)}'`
                         : resolution;
                 node.renderFinalResolution(code, renderedResolution, resolution instanceof Module &&
                     !(facadeChunk === null || facadeChunk === void 0 ? void 0 : facadeChunk.strictFacade) &&
@@ -15382,13 +15420,6 @@ function getChunkNameFromModule(module) {
     return module.chunkName || getAliasName(module.id);
 }
 
-var BuildPhase;
-(function (BuildPhase) {
-    BuildPhase[BuildPhase["LOAD_AND_PARSE"] = 0] = "LOAD_AND_PARSE";
-    BuildPhase[BuildPhase["ANALYSE"] = 1] = "ANALYSE";
-    BuildPhase[BuildPhase["GENERATE"] = 2] = "GENERATE";
-})(BuildPhase || (BuildPhase = {}));
-
 function generateAssetFileName(name, source, outputOptions, bundle) {
     const emittedName = outputOptions.sanitizeFileName(name || 'asset');
     return makeUnique(renderNamePattern(typeof outputOptions.assetFileNames === 'function'
@@ -15899,7 +15930,7 @@ function getGenerateCodeSnippets({ compact, generatedCode: { arrowFunctions, con
     ];
     const isValidPropName = reservedNamesAsProps
         ? (name) => validPropName.test(name)
-        : (name) => !RESERVED_NAMES[name] && validPropName.test(name);
+        : (name) => !RESERVED_NAMES$1.has(name) && validPropName.test(name);
     return {
         _,
         cnst,
@@ -16124,7 +16155,7 @@ function validateOptionsForMultiChunkOutput(outputOptions, onWarn) {
         onWarn(errInvalidOption('output.amd.id', 'outputamd', 'this option is only properly supported for single-file builds. Use "output.amd.autoId" and "output.amd.basePath" instead'));
 }
 function getIncludedModules(modulesById) {
-    return [...modulesById.values()].filter(module => module instanceof Module &&
+    return [...modulesById.values()].filter((module) => module instanceof Module &&
         (module.isIncluded() || module.info.isEntry || module.includedDynamicImporters.length > 0));
 }
 function addModuleToManualChunk(alias, module, manualChunkAliasByEntry) {
@@ -16149,7 +16180,7 @@ var reservedWords = {
 
 var ecma5AndLessKeywords = "break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this";
 
-var keywords = {
+var keywords$1 = {
   5: ecma5AndLessKeywords,
   "5module": ecma5AndLessKeywords + " export import",
   6: ecma5AndLessKeywords + " const class extends export import super"
@@ -16268,17 +16299,17 @@ var beforeExpr = {beforeExpr: true}, startsExpr = {startsExpr: true};
 
 // Map keyword names to token types.
 
-var keywords$1 = {};
+var keywords = {};
 
 // Succinct definitions of keyword token types
 function kw(name, options) {
   if ( options === void 0 ) options = {};
 
   options.keyword = name;
-  return keywords$1[name] = new TokenType(name, options)
+  return keywords[name] = new TokenType(name, options)
 }
 
-var types = {
+var types$1 = {
   num: new TokenType("num", startsExpr),
   regexp: new TokenType("regexp", startsExpr),
   string: new TokenType("string", startsExpr),
@@ -16620,7 +16651,7 @@ var
 var Parser = function Parser(options, input, startPos) {
   this.options = options = getOptions(options);
   this.sourceFile = options.sourceFile;
-  this.keywords = wordsRegexp(keywords[options.ecmaVersion >= 6 ? 6 : options.sourceType === "module" ? "5module" : 5]);
+  this.keywords = wordsRegexp(keywords$1[options.ecmaVersion >= 6 ? 6 : options.sourceType === "module" ? "5module" : 5]);
   var reserved = "";
   if (options.allowReserved !== true) {
     reserved = reservedWords[options.ecmaVersion >= 6 ? 6 : options.ecmaVersion === 5 ? 5 : 3];
@@ -16651,7 +16682,7 @@ var Parser = function Parser(options, input, startPos) {
 
   // Properties of the current token:
   // Its type
-  this.type = types.eof;
+  this.type = types$1.eof;
   // For tokens that include more information than their type, the value
   this.value = null;
   // Its start and end offset
@@ -16711,8 +16742,11 @@ Parser.prototype.parse = function parse () {
 };
 
 prototypeAccessors.inFunction.get = function () { return (this.currentVarScope().flags & SCOPE_FUNCTION) > 0 };
+
 prototypeAccessors.inGenerator.get = function () { return (this.currentVarScope().flags & SCOPE_GENERATOR) > 0 && !this.currentVarScope().inClassFieldInit };
+
 prototypeAccessors.inAsync.get = function () { return (this.currentVarScope().flags & SCOPE_ASYNC) > 0 && !this.currentVarScope().inClassFieldInit };
+
 prototypeAccessors.canAwait.get = function () {
   for (var i = this.scopeStack.length - 1; i >= 0; i--) {
     var scope = this.scopeStack[i];
@@ -16721,20 +16755,25 @@ prototypeAccessors.canAwait.get = function () {
   }
   return (this.inModule && this.options.ecmaVersion >= 13) || this.options.allowAwaitOutsideFunction
 };
+
 prototypeAccessors.allowSuper.get = function () {
   var ref = this.currentThisScope();
     var flags = ref.flags;
     var inClassFieldInit = ref.inClassFieldInit;
   return (flags & SCOPE_SUPER) > 0 || inClassFieldInit || this.options.allowSuperOutsideMethod
 };
+
 prototypeAccessors.allowDirectSuper.get = function () { return (this.currentThisScope().flags & SCOPE_DIRECT_SUPER) > 0 };
+
 prototypeAccessors.treatFunctionsAsVar.get = function () { return this.treatFunctionsAsVarInScope(this.currentScope()) };
+
 prototypeAccessors.allowNewDotTarget.get = function () {
   var ref = this.currentThisScope();
     var flags = ref.flags;
     var inClassFieldInit = ref.inClassFieldInit;
   return (flags & (SCOPE_FUNCTION | SCOPE_CLASS_STATIC_BLOCK)) > 0 || inClassFieldInit
 };
+
 prototypeAccessors.inClassStaticBlock.get = function () {
   return (this.currentVarScope().flags & SCOPE_CLASS_STATIC_BLOCK) > 0
 };
@@ -16764,12 +16803,12 @@ Parser.tokenizer = function tokenizer (input, options) {
 
 Object.defineProperties( Parser.prototype, prototypeAccessors );
 
-var pp = Parser.prototype;
+var pp$9 = Parser.prototype;
 
 // ## Parser utilities
 
 var literal = /^(?:'((?:\\.|[^'\\])*?)'|"((?:\\.|[^"\\])*?)")/;
-pp.strictDirective = function(start) {
+pp$9.strictDirective = function(start) {
   for (;;) {
     // Try to find string literal.
     skipWhiteSpace.lastIndex = start;
@@ -16797,7 +16836,7 @@ pp.strictDirective = function(start) {
 // Predicate that tests whether the next token is of the given
 // type, and if yes, consumes it as a side effect.
 
-pp.eat = function(type) {
+pp$9.eat = function(type) {
   if (this.type === type) {
     this.next();
     return true
@@ -16808,13 +16847,13 @@ pp.eat = function(type) {
 
 // Tests whether parsed token is a contextual keyword.
 
-pp.isContextual = function(name) {
-  return this.type === types.name && this.value === name && !this.containsEsc
+pp$9.isContextual = function(name) {
+  return this.type === types$1.name && this.value === name && !this.containsEsc
 };
 
 // Consumes contextual keyword if possible.
 
-pp.eatContextual = function(name) {
+pp$9.eatContextual = function(name) {
   if (!this.isContextual(name)) { return false }
   this.next();
   return true
@@ -16822,19 +16861,19 @@ pp.eatContextual = function(name) {
 
 // Asserts that following token is given contextual keyword.
 
-pp.expectContextual = function(name) {
+pp$9.expectContextual = function(name) {
   if (!this.eatContextual(name)) { this.unexpected(); }
 };
 
 // Test whether a semicolon can be inserted at the current position.
 
-pp.canInsertSemicolon = function() {
-  return this.type === types.eof ||
-    this.type === types.braceR ||
+pp$9.canInsertSemicolon = function() {
+  return this.type === types$1.eof ||
+    this.type === types$1.braceR ||
     lineBreak.test(this.input.slice(this.lastTokEnd, this.start))
 };
 
-pp.insertSemicolon = function() {
+pp$9.insertSemicolon = function() {
   if (this.canInsertSemicolon()) {
     if (this.options.onInsertedSemicolon)
       { this.options.onInsertedSemicolon(this.lastTokEnd, this.lastTokEndLoc); }
@@ -16845,11 +16884,11 @@ pp.insertSemicolon = function() {
 // Consume a semicolon, or, failing that, see if we are allowed to
 // pretend that there is a semicolon at this position.
 
-pp.semicolon = function() {
-  if (!this.eat(types.semi) && !this.insertSemicolon()) { this.unexpected(); }
+pp$9.semicolon = function() {
+  if (!this.eat(types$1.semi) && !this.insertSemicolon()) { this.unexpected(); }
 };
 
-pp.afterTrailingComma = function(tokType, notNext) {
+pp$9.afterTrailingComma = function(tokType, notNext) {
   if (this.type === tokType) {
     if (this.options.onTrailingComma)
       { this.options.onTrailingComma(this.lastTokStart, this.lastTokStartLoc); }
@@ -16862,13 +16901,13 @@ pp.afterTrailingComma = function(tokType, notNext) {
 // Expect a token of a given type. If found, consume it, otherwise,
 // raise an unexpected token error.
 
-pp.expect = function(type) {
+pp$9.expect = function(type) {
   this.eat(type) || this.unexpected();
 };
 
 // Raise an unexpected token error.
 
-pp.unexpected = function(pos) {
+pp$9.unexpected = function(pos) {
   this.raise(pos != null ? pos : this.start, "Unexpected token");
 };
 
@@ -16881,7 +16920,7 @@ function DestructuringErrors() {
     -1;
 }
 
-pp.checkPatternErrors = function(refDestructuringErrors, isAssign) {
+pp$9.checkPatternErrors = function(refDestructuringErrors, isAssign) {
   if (!refDestructuringErrors) { return }
   if (refDestructuringErrors.trailingComma > -1)
     { this.raiseRecoverable(refDestructuringErrors.trailingComma, "Comma is not permitted after the rest element"); }
@@ -16889,7 +16928,7 @@ pp.checkPatternErrors = function(refDestructuringErrors, isAssign) {
   if (parens > -1) { this.raiseRecoverable(parens, "Parenthesized pattern"); }
 };
 
-pp.checkExpressionErrors = function(refDestructuringErrors, andThrow) {
+pp$9.checkExpressionErrors = function(refDestructuringErrors, andThrow) {
   if (!refDestructuringErrors) { return false }
   var shorthandAssign = refDestructuringErrors.shorthandAssign;
   var doubleProto = refDestructuringErrors.doubleProto;
@@ -16900,20 +16939,20 @@ pp.checkExpressionErrors = function(refDestructuringErrors, andThrow) {
     { this.raiseRecoverable(doubleProto, "Redefinition of __proto__ property"); }
 };
 
-pp.checkYieldAwaitInDefaultParams = function() {
+pp$9.checkYieldAwaitInDefaultParams = function() {
   if (this.yieldPos && (!this.awaitPos || this.yieldPos < this.awaitPos))
     { this.raise(this.yieldPos, "Yield expression cannot be a default value"); }
   if (this.awaitPos)
     { this.raise(this.awaitPos, "Await expression cannot be a default value"); }
 };
 
-pp.isSimpleAssignTarget = function(expr) {
+pp$9.isSimpleAssignTarget = function(expr) {
   if (expr.type === "ParenthesizedExpression")
     { return this.isSimpleAssignTarget(expr.expression) }
   return expr.type === "Identifier" || expr.type === "MemberExpression"
 };
 
-var pp$1 = Parser.prototype;
+var pp$8 = Parser.prototype;
 
 // ### Statement parsing
 
@@ -16922,10 +16961,10 @@ var pp$1 = Parser.prototype;
 // `program` argument.  If present, the statements will be appended
 // to its body instead of creating a new node.
 
-pp$1.parseTopLevel = function(node) {
+pp$8.parseTopLevel = function(node) {
   var exports = Object.create(null);
   if (!node.body) { node.body = []; }
-  while (this.type !== types.eof) {
+  while (this.type !== types$1.eof) {
     var stmt = this.parseStatement(null, true, exports);
     node.body.push(stmt);
   }
@@ -16944,7 +16983,7 @@ pp$1.parseTopLevel = function(node) {
 
 var loopLabel = {kind: "loop"}, switchLabel = {kind: "switch"};
 
-pp$1.isLet = function(context) {
+pp$8.isLet = function(context) {
   if (this.options.ecmaVersion < 6 || !this.isContextual("let")) { return false }
   skipWhiteSpace.lastIndex = this.pos;
   var skip = skipWhiteSpace.exec(this.input);
@@ -16970,7 +17009,7 @@ pp$1.isLet = function(context) {
 // check 'async [no LineTerminator here] function'
 // - 'async /*foo*/ function' is OK.
 // - 'async /*\n*/ function' is invalid.
-pp$1.isAsyncFunction = function() {
+pp$8.isAsyncFunction = function() {
   if (this.options.ecmaVersion < 8 || !this.isContextual("async"))
     { return false }
 
@@ -16990,11 +17029,11 @@ pp$1.isAsyncFunction = function() {
 // `if (foo) /blah/.exec(foo)`, where looking at the previous token
 // does not help.
 
-pp$1.parseStatement = function(context, topLevel, exports) {
+pp$8.parseStatement = function(context, topLevel, exports) {
   var starttype = this.type, node = this.startNode(), kind;
 
   if (this.isLet(context)) {
-    starttype = types._var;
+    starttype = types$1._var;
     kind = "let";
   }
 
@@ -17003,35 +17042,35 @@ pp$1.parseStatement = function(context, topLevel, exports) {
   // complexity.
 
   switch (starttype) {
-  case types._break: case types._continue: return this.parseBreakContinueStatement(node, starttype.keyword)
-  case types._debugger: return this.parseDebuggerStatement(node)
-  case types._do: return this.parseDoStatement(node)
-  case types._for: return this.parseForStatement(node)
-  case types._function:
+  case types$1._break: case types$1._continue: return this.parseBreakContinueStatement(node, starttype.keyword)
+  case types$1._debugger: return this.parseDebuggerStatement(node)
+  case types$1._do: return this.parseDoStatement(node)
+  case types$1._for: return this.parseForStatement(node)
+  case types$1._function:
     // Function as sole body of either an if statement or a labeled statement
     // works, but not when it is part of a labeled statement that is the sole
     // body of an if statement.
     if ((context && (this.strict || context !== "if" && context !== "label")) && this.options.ecmaVersion >= 6) { this.unexpected(); }
     return this.parseFunctionStatement(node, false, !context)
-  case types._class:
+  case types$1._class:
     if (context) { this.unexpected(); }
     return this.parseClass(node, true)
-  case types._if: return this.parseIfStatement(node)
-  case types._return: return this.parseReturnStatement(node)
-  case types._switch: return this.parseSwitchStatement(node)
-  case types._throw: return this.parseThrowStatement(node)
-  case types._try: return this.parseTryStatement(node)
-  case types._const: case types._var:
+  case types$1._if: return this.parseIfStatement(node)
+  case types$1._return: return this.parseReturnStatement(node)
+  case types$1._switch: return this.parseSwitchStatement(node)
+  case types$1._throw: return this.parseThrowStatement(node)
+  case types$1._try: return this.parseTryStatement(node)
+  case types$1._const: case types$1._var:
     kind = kind || this.value;
     if (context && kind !== "var") { this.unexpected(); }
     return this.parseVarStatement(node, kind)
-  case types._while: return this.parseWhileStatement(node)
-  case types._with: return this.parseWithStatement(node)
-  case types.braceL: return this.parseBlock(true, node)
-  case types.semi: return this.parseEmptyStatement(node)
-  case types._export:
-  case types._import:
-    if (this.options.ecmaVersion > 10 && starttype === types._import) {
+  case types$1._while: return this.parseWhileStatement(node)
+  case types$1._with: return this.parseWithStatement(node)
+  case types$1.braceL: return this.parseBlock(true, node)
+  case types$1.semi: return this.parseEmptyStatement(node)
+  case types$1._export:
+  case types$1._import:
+    if (this.options.ecmaVersion > 10 && starttype === types$1._import) {
       skipWhiteSpace.lastIndex = this.pos;
       var skip = skipWhiteSpace.exec(this.input);
       var next = this.pos + skip[0].length, nextCh = this.input.charCodeAt(next);
@@ -17045,7 +17084,7 @@ pp$1.parseStatement = function(context, topLevel, exports) {
       if (!this.inModule)
         { this.raise(this.start, "'import' and 'export' may appear only with 'sourceType: module'"); }
     }
-    return starttype === types._import ? this.parseImport(node) : this.parseExport(node, exports)
+    return starttype === types$1._import ? this.parseImport(node) : this.parseExport(node, exports)
 
     // If the statement does not start with a statement keyword or a
     // brace, it's an ExpressionStatement or LabeledStatement. We
@@ -17060,17 +17099,17 @@ pp$1.parseStatement = function(context, topLevel, exports) {
     }
 
     var maybeName = this.value, expr = this.parseExpression();
-    if (starttype === types.name && expr.type === "Identifier" && this.eat(types.colon))
+    if (starttype === types$1.name && expr.type === "Identifier" && this.eat(types$1.colon))
       { return this.parseLabeledStatement(node, maybeName, expr, context) }
     else { return this.parseExpressionStatement(node, expr) }
   }
 };
 
-pp$1.parseBreakContinueStatement = function(node, keyword) {
+pp$8.parseBreakContinueStatement = function(node, keyword) {
   var isBreak = keyword === "break";
   this.next();
-  if (this.eat(types.semi) || this.insertSemicolon()) { node.label = null; }
-  else if (this.type !== types.name) { this.unexpected(); }
+  if (this.eat(types$1.semi) || this.insertSemicolon()) { node.label = null; }
+  else if (this.type !== types$1.name) { this.unexpected(); }
   else {
     node.label = this.parseIdent();
     this.semicolon();
@@ -17090,21 +17129,21 @@ pp$1.parseBreakContinueStatement = function(node, keyword) {
   return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement")
 };
 
-pp$1.parseDebuggerStatement = function(node) {
+pp$8.parseDebuggerStatement = function(node) {
   this.next();
   this.semicolon();
   return this.finishNode(node, "DebuggerStatement")
 };
 
-pp$1.parseDoStatement = function(node) {
+pp$8.parseDoStatement = function(node) {
   this.next();
   this.labels.push(loopLabel);
   node.body = this.parseStatement("do");
   this.labels.pop();
-  this.expect(types._while);
+  this.expect(types$1._while);
   node.test = this.parseParenExpression();
   if (this.options.ecmaVersion >= 6)
-    { this.eat(types.semi); }
+    { this.eat(types$1.semi); }
   else
     { this.semicolon(); }
   return this.finishNode(node, "DoWhileStatement")
@@ -17118,25 +17157,25 @@ pp$1.parseDoStatement = function(node) {
 // part (semicolon immediately after the opening parenthesis), it
 // is a regular `for` loop.
 
-pp$1.parseForStatement = function(node) {
+pp$8.parseForStatement = function(node) {
   this.next();
   var awaitAt = (this.options.ecmaVersion >= 9 && this.canAwait && this.eatContextual("await")) ? this.lastTokStart : -1;
   this.labels.push(loopLabel);
   this.enterScope(0);
-  this.expect(types.parenL);
-  if (this.type === types.semi) {
+  this.expect(types$1.parenL);
+  if (this.type === types$1.semi) {
     if (awaitAt > -1) { this.unexpected(awaitAt); }
     return this.parseFor(node, null)
   }
   var isLet = this.isLet();
-  if (this.type === types._var || this.type === types._const || isLet) {
+  if (this.type === types$1._var || this.type === types$1._const || isLet) {
     var init$1 = this.startNode(), kind = isLet ? "let" : this.value;
     this.next();
     this.parseVar(init$1, true, kind);
     this.finishNode(init$1, "VariableDeclaration");
-    if ((this.type === types._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) && init$1.declarations.length === 1) {
+    if ((this.type === types$1._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) && init$1.declarations.length === 1) {
       if (this.options.ecmaVersion >= 9) {
-        if (this.type === types._in) {
+        if (this.type === types$1._in) {
           if (awaitAt > -1) { this.unexpected(awaitAt); }
         } else { node.await = awaitAt > -1; }
       }
@@ -17148,9 +17187,9 @@ pp$1.parseForStatement = function(node) {
   var startsWithLet = this.isContextual("let"), isForOf = false;
   var refDestructuringErrors = new DestructuringErrors;
   var init = this.parseExpression(awaitAt > -1 ? "await" : true, refDestructuringErrors);
-  if (this.type === types._in || (isForOf = this.options.ecmaVersion >= 6 && this.isContextual("of"))) {
+  if (this.type === types$1._in || (isForOf = this.options.ecmaVersion >= 6 && this.isContextual("of"))) {
     if (this.options.ecmaVersion >= 9) {
-      if (this.type === types._in) {
+      if (this.type === types$1._in) {
         if (awaitAt > -1) { this.unexpected(awaitAt); }
       } else { node.await = awaitAt > -1; }
     }
@@ -17165,21 +17204,21 @@ pp$1.parseForStatement = function(node) {
   return this.parseFor(node, init)
 };
 
-pp$1.parseFunctionStatement = function(node, isAsync, declarationPosition) {
+pp$8.parseFunctionStatement = function(node, isAsync, declarationPosition) {
   this.next();
   return this.parseFunction(node, FUNC_STATEMENT | (declarationPosition ? 0 : FUNC_HANGING_STATEMENT), false, isAsync)
 };
 
-pp$1.parseIfStatement = function(node) {
+pp$8.parseIfStatement = function(node) {
   this.next();
   node.test = this.parseParenExpression();
   // allow function declarations in branches, but only in non-strict mode
   node.consequent = this.parseStatement("if");
-  node.alternate = this.eat(types._else) ? this.parseStatement("if") : null;
+  node.alternate = this.eat(types$1._else) ? this.parseStatement("if") : null;
   return this.finishNode(node, "IfStatement")
 };
 
-pp$1.parseReturnStatement = function(node) {
+pp$8.parseReturnStatement = function(node) {
   if (!this.inFunction && !this.options.allowReturnOutsideFunction)
     { this.raise(this.start, "'return' outside of function"); }
   this.next();
@@ -17188,16 +17227,16 @@ pp$1.parseReturnStatement = function(node) {
   // optional arguments, we eagerly look for a semicolon or the
   // possibility to insert one.
 
-  if (this.eat(types.semi) || this.insertSemicolon()) { node.argument = null; }
+  if (this.eat(types$1.semi) || this.insertSemicolon()) { node.argument = null; }
   else { node.argument = this.parseExpression(); this.semicolon(); }
   return this.finishNode(node, "ReturnStatement")
 };
 
-pp$1.parseSwitchStatement = function(node) {
+pp$8.parseSwitchStatement = function(node) {
   this.next();
   node.discriminant = this.parseParenExpression();
   node.cases = [];
-  this.expect(types.braceL);
+  this.expect(types$1.braceL);
   this.labels.push(switchLabel);
   this.enterScope(0);
 
@@ -17206,9 +17245,9 @@ pp$1.parseSwitchStatement = function(node) {
   // adding statements to.
 
   var cur;
-  for (var sawDefault = false; this.type !== types.braceR;) {
-    if (this.type === types._case || this.type === types._default) {
-      var isCase = this.type === types._case;
+  for (var sawDefault = false; this.type !== types$1.braceR;) {
+    if (this.type === types$1._case || this.type === types$1._default) {
+      var isCase = this.type === types$1._case;
       if (cur) { this.finishNode(cur, "SwitchCase"); }
       node.cases.push(cur = this.startNode());
       cur.consequent = [];
@@ -17220,7 +17259,7 @@ pp$1.parseSwitchStatement = function(node) {
         sawDefault = true;
         cur.test = null;
       }
-      this.expect(types.colon);
+      this.expect(types$1.colon);
     } else {
       if (!cur) { this.unexpected(); }
       cur.consequent.push(this.parseStatement(null));
@@ -17233,7 +17272,7 @@ pp$1.parseSwitchStatement = function(node) {
   return this.finishNode(node, "SwitchStatement")
 };
 
-pp$1.parseThrowStatement = function(node) {
+pp$8.parseThrowStatement = function(node) {
   this.next();
   if (lineBreak.test(this.input.slice(this.lastTokEnd, this.start)))
     { this.raise(this.lastTokEnd, "Illegal newline after throw"); }
@@ -17244,21 +17283,21 @@ pp$1.parseThrowStatement = function(node) {
 
 // Reused empty array added for node fields that are always empty.
 
-var empty = [];
+var empty$1 = [];
 
-pp$1.parseTryStatement = function(node) {
+pp$8.parseTryStatement = function(node) {
   this.next();
   node.block = this.parseBlock();
   node.handler = null;
-  if (this.type === types._catch) {
+  if (this.type === types$1._catch) {
     var clause = this.startNode();
     this.next();
-    if (this.eat(types.parenL)) {
+    if (this.eat(types$1.parenL)) {
       clause.param = this.parseBindingAtom();
       var simple = clause.param.type === "Identifier";
       this.enterScope(simple ? SCOPE_SIMPLE_CATCH : 0);
       this.checkLValPattern(clause.param, simple ? BIND_SIMPLE_CATCH : BIND_LEXICAL);
-      this.expect(types.parenR);
+      this.expect(types$1.parenR);
     } else {
       if (this.options.ecmaVersion < 10) { this.unexpected(); }
       clause.param = null;
@@ -17268,20 +17307,20 @@ pp$1.parseTryStatement = function(node) {
     this.exitScope();
     node.handler = this.finishNode(clause, "CatchClause");
   }
-  node.finalizer = this.eat(types._finally) ? this.parseBlock() : null;
+  node.finalizer = this.eat(types$1._finally) ? this.parseBlock() : null;
   if (!node.handler && !node.finalizer)
     { this.raise(node.start, "Missing catch or finally clause"); }
   return this.finishNode(node, "TryStatement")
 };
 
-pp$1.parseVarStatement = function(node, kind) {
+pp$8.parseVarStatement = function(node, kind) {
   this.next();
   this.parseVar(node, false, kind);
   this.semicolon();
   return this.finishNode(node, "VariableDeclaration")
 };
 
-pp$1.parseWhileStatement = function(node) {
+pp$8.parseWhileStatement = function(node) {
   this.next();
   node.test = this.parseParenExpression();
   this.labels.push(loopLabel);
@@ -17290,7 +17329,7 @@ pp$1.parseWhileStatement = function(node) {
   return this.finishNode(node, "WhileStatement")
 };
 
-pp$1.parseWithStatement = function(node) {
+pp$8.parseWithStatement = function(node) {
   if (this.strict) { this.raise(this.start, "'with' in strict mode"); }
   this.next();
   node.object = this.parseParenExpression();
@@ -17298,12 +17337,12 @@ pp$1.parseWithStatement = function(node) {
   return this.finishNode(node, "WithStatement")
 };
 
-pp$1.parseEmptyStatement = function(node) {
+pp$8.parseEmptyStatement = function(node) {
   this.next();
   return this.finishNode(node, "EmptyStatement")
 };
 
-pp$1.parseLabeledStatement = function(node, maybeName, expr, context) {
+pp$8.parseLabeledStatement = function(node, maybeName, expr, context) {
   for (var i$1 = 0, list = this.labels; i$1 < list.length; i$1 += 1)
     {
     var label = list[i$1];
@@ -17311,7 +17350,7 @@ pp$1.parseLabeledStatement = function(node, maybeName, expr, context) {
     if (label.name === maybeName)
       { this.raise(expr.start, "Label '" + maybeName + "' is already declared");
   } }
-  var kind = this.type.isLoop ? "loop" : this.type === types._switch ? "switch" : null;
+  var kind = this.type.isLoop ? "loop" : this.type === types$1._switch ? "switch" : null;
   for (var i = this.labels.length - 1; i >= 0; i--) {
     var label$1 = this.labels[i];
     if (label$1.statementStart === node.start) {
@@ -17327,7 +17366,7 @@ pp$1.parseLabeledStatement = function(node, maybeName, expr, context) {
   return this.finishNode(node, "LabeledStatement")
 };
 
-pp$1.parseExpressionStatement = function(node, expr) {
+pp$8.parseExpressionStatement = function(node, expr) {
   node.expression = expr;
   this.semicolon();
   return this.finishNode(node, "ExpressionStatement")
@@ -17337,14 +17376,14 @@ pp$1.parseExpressionStatement = function(node, expr) {
 // strict"` declarations when `allowStrict` is true (used for
 // function bodies).
 
-pp$1.parseBlock = function(createNewLexicalScope, node, exitStrict) {
+pp$8.parseBlock = function(createNewLexicalScope, node, exitStrict) {
   if ( createNewLexicalScope === void 0 ) createNewLexicalScope = true;
   if ( node === void 0 ) node = this.startNode();
 
   node.body = [];
-  this.expect(types.braceL);
+  this.expect(types$1.braceL);
   if (createNewLexicalScope) { this.enterScope(0); }
-  while (this.type !== types.braceR) {
+  while (this.type !== types$1.braceR) {
     var stmt = this.parseStatement(null);
     node.body.push(stmt);
   }
@@ -17358,13 +17397,13 @@ pp$1.parseBlock = function(createNewLexicalScope, node, exitStrict) {
 // `parseStatement` will already have parsed the init statement or
 // expression.
 
-pp$1.parseFor = function(node, init) {
+pp$8.parseFor = function(node, init) {
   node.init = init;
-  this.expect(types.semi);
-  node.test = this.type === types.semi ? null : this.parseExpression();
-  this.expect(types.semi);
-  node.update = this.type === types.parenR ? null : this.parseExpression();
-  this.expect(types.parenR);
+  this.expect(types$1.semi);
+  node.test = this.type === types$1.semi ? null : this.parseExpression();
+  this.expect(types$1.semi);
+  node.update = this.type === types$1.parenR ? null : this.parseExpression();
+  this.expect(types$1.parenR);
   node.body = this.parseStatement("for");
   this.exitScope();
   this.labels.pop();
@@ -17374,8 +17413,8 @@ pp$1.parseFor = function(node, init) {
 // Parse a `for`/`in` and `for`/`of` loop, which are almost
 // same from parser's perspective.
 
-pp$1.parseForIn = function(node, init) {
-  var isForIn = this.type === types._in;
+pp$8.parseForIn = function(node, init) {
+  var isForIn = this.type === types$1._in;
   this.next();
 
   if (
@@ -17396,7 +17435,7 @@ pp$1.parseForIn = function(node, init) {
   }
   node.left = init;
   node.right = isForIn ? this.parseExpression() : this.parseMaybeAssign();
-  this.expect(types.parenR);
+  this.expect(types$1.parenR);
   node.body = this.parseStatement("for");
   this.exitScope();
   this.labels.pop();
@@ -17405,28 +17444,28 @@ pp$1.parseForIn = function(node, init) {
 
 // Parse a list of variable declarations.
 
-pp$1.parseVar = function(node, isFor, kind) {
+pp$8.parseVar = function(node, isFor, kind) {
   node.declarations = [];
   node.kind = kind;
   for (;;) {
     var decl = this.startNode();
     this.parseVarId(decl, kind);
-    if (this.eat(types.eq)) {
+    if (this.eat(types$1.eq)) {
       decl.init = this.parseMaybeAssign(isFor);
-    } else if (kind === "const" && !(this.type === types._in || (this.options.ecmaVersion >= 6 && this.isContextual("of")))) {
+    } else if (kind === "const" && !(this.type === types$1._in || (this.options.ecmaVersion >= 6 && this.isContextual("of")))) {
       this.unexpected();
-    } else if (decl.id.type !== "Identifier" && !(isFor && (this.type === types._in || this.isContextual("of")))) {
+    } else if (decl.id.type !== "Identifier" && !(isFor && (this.type === types$1._in || this.isContextual("of")))) {
       this.raise(this.lastTokEnd, "Complex binding patterns require an initialization value");
     } else {
       decl.init = null;
     }
     node.declarations.push(this.finishNode(decl, "VariableDeclarator"));
-    if (!this.eat(types.comma)) { break }
+    if (!this.eat(types$1.comma)) { break }
   }
   return node
 };
 
-pp$1.parseVarId = function(decl, kind) {
+pp$8.parseVarId = function(decl, kind) {
   decl.id = this.parseBindingAtom();
   this.checkLValPattern(decl.id, kind === "var" ? BIND_VAR : BIND_LEXICAL, false);
 };
@@ -17437,18 +17476,18 @@ var FUNC_STATEMENT = 1, FUNC_HANGING_STATEMENT = 2, FUNC_NULLABLE_ID = 4;
 // `statement & FUNC_STATEMENT`).
 
 // Remove `allowExpressionBody` for 7.0.0, as it is only called with false
-pp$1.parseFunction = function(node, statement, allowExpressionBody, isAsync, forInit) {
+pp$8.parseFunction = function(node, statement, allowExpressionBody, isAsync, forInit) {
   this.initFunction(node);
   if (this.options.ecmaVersion >= 9 || this.options.ecmaVersion >= 6 && !isAsync) {
-    if (this.type === types.star && (statement & FUNC_HANGING_STATEMENT))
+    if (this.type === types$1.star && (statement & FUNC_HANGING_STATEMENT))
       { this.unexpected(); }
-    node.generator = this.eat(types.star);
+    node.generator = this.eat(types$1.star);
   }
   if (this.options.ecmaVersion >= 8)
     { node.async = !!isAsync; }
 
   if (statement & FUNC_STATEMENT) {
-    node.id = (statement & FUNC_NULLABLE_ID) && this.type !== types.name ? null : this.parseIdent();
+    node.id = (statement & FUNC_NULLABLE_ID) && this.type !== types$1.name ? null : this.parseIdent();
     if (node.id && !(statement & FUNC_HANGING_STATEMENT))
       // If it is a regular function declaration in sloppy mode, then it is
       // subject to Annex B semantics (BIND_FUNCTION). Otherwise, the binding
@@ -17464,7 +17503,7 @@ pp$1.parseFunction = function(node, statement, allowExpressionBody, isAsync, for
   this.enterScope(functionFlags(node.async, node.generator));
 
   if (!(statement & FUNC_STATEMENT))
-    { node.id = this.type === types.name ? this.parseIdent() : null; }
+    { node.id = this.type === types$1.name ? this.parseIdent() : null; }
 
   this.parseFunctionParams(node);
   this.parseFunctionBody(node, allowExpressionBody, false, forInit);
@@ -17475,16 +17514,16 @@ pp$1.parseFunction = function(node, statement, allowExpressionBody, isAsync, for
   return this.finishNode(node, (statement & FUNC_STATEMENT) ? "FunctionDeclaration" : "FunctionExpression")
 };
 
-pp$1.parseFunctionParams = function(node) {
-  this.expect(types.parenL);
-  node.params = this.parseBindingList(types.parenR, false, this.options.ecmaVersion >= 8);
+pp$8.parseFunctionParams = function(node) {
+  this.expect(types$1.parenL);
+  node.params = this.parseBindingList(types$1.parenR, false, this.options.ecmaVersion >= 8);
   this.checkYieldAwaitInDefaultParams();
 };
 
 // Parse a class declaration or literal (depending on the
 // `isStatement` parameter).
 
-pp$1.parseClass = function(node, isStatement) {
+pp$8.parseClass = function(node, isStatement) {
   this.next();
 
   // ecma-262 14.6 Class Definitions
@@ -17498,8 +17537,8 @@ pp$1.parseClass = function(node, isStatement) {
   var classBody = this.startNode();
   var hadConstructor = false;
   classBody.body = [];
-  this.expect(types.braceL);
-  while (this.type !== types.braceR) {
+  this.expect(types$1.braceL);
+  while (this.type !== types$1.braceR) {
     var element = this.parseClassElement(node.superClass !== null);
     if (element) {
       classBody.body.push(element);
@@ -17518,8 +17557,8 @@ pp$1.parseClass = function(node, isStatement) {
   return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression")
 };
 
-pp$1.parseClassElement = function(constructorAllowsSuper) {
-  if (this.eat(types.semi)) { return null }
+pp$8.parseClassElement = function(constructorAllowsSuper) {
+  if (this.eat(types$1.semi)) { return null }
 
   var ecmaVersion = this.options.ecmaVersion;
   var node = this.startNode();
@@ -17531,11 +17570,11 @@ pp$1.parseClassElement = function(constructorAllowsSuper) {
 
   if (this.eatContextual("static")) {
     // Parse static init block
-    if (ecmaVersion >= 13 && this.eat(types.braceL)) {
+    if (ecmaVersion >= 13 && this.eat(types$1.braceL)) {
       this.parseClassStaticBlock(node);
       return node
     }
-    if (this.isClassElementNameStart() || this.type === types.star) {
+    if (this.isClassElementNameStart() || this.type === types$1.star) {
       isStatic = true;
     } else {
       keyName = "static";
@@ -17543,13 +17582,13 @@ pp$1.parseClassElement = function(constructorAllowsSuper) {
   }
   node.static = isStatic;
   if (!keyName && ecmaVersion >= 8 && this.eatContextual("async")) {
-    if ((this.isClassElementNameStart() || this.type === types.star) && !this.canInsertSemicolon()) {
+    if ((this.isClassElementNameStart() || this.type === types$1.star) && !this.canInsertSemicolon()) {
       isAsync = true;
     } else {
       keyName = "async";
     }
   }
-  if (!keyName && (ecmaVersion >= 9 || !isAsync) && this.eat(types.star)) {
+  if (!keyName && (ecmaVersion >= 9 || !isAsync) && this.eat(types$1.star)) {
     isGenerator = true;
   }
   if (!keyName && !isAsync && !isGenerator) {
@@ -17576,7 +17615,7 @@ pp$1.parseClassElement = function(constructorAllowsSuper) {
   }
 
   // Parse element value
-  if (ecmaVersion < 13 || this.type === types.parenL || kind !== "method" || isGenerator || isAsync) {
+  if (ecmaVersion < 13 || this.type === types$1.parenL || kind !== "method" || isGenerator || isAsync) {
     var isConstructor = !node.static && checkKeyName(node, "constructor");
     var allowsDirectSuper = isConstructor && constructorAllowsSuper;
     // Couldn't move this check into the 'parseClassMethod' method for backward compatibility.
@@ -17590,19 +17629,19 @@ pp$1.parseClassElement = function(constructorAllowsSuper) {
   return node
 };
 
-pp$1.isClassElementNameStart = function() {
+pp$8.isClassElementNameStart = function() {
   return (
-    this.type === types.name ||
-    this.type === types.privateId ||
-    this.type === types.num ||
-    this.type === types.string ||
-    this.type === types.bracketL ||
+    this.type === types$1.name ||
+    this.type === types$1.privateId ||
+    this.type === types$1.num ||
+    this.type === types$1.string ||
+    this.type === types$1.bracketL ||
     this.type.keyword
   )
 };
 
-pp$1.parseClassElementName = function(element) {
-  if (this.type === types.privateId) {
+pp$8.parseClassElementName = function(element) {
+  if (this.type === types$1.privateId) {
     if (this.value === "constructor") {
       this.raise(this.start, "Classes can't have an element named '#constructor'");
     }
@@ -17613,7 +17652,7 @@ pp$1.parseClassElementName = function(element) {
   }
 };
 
-pp$1.parseClassMethod = function(method, isGenerator, isAsync, allowsDirectSuper) {
+pp$8.parseClassMethod = function(method, isGenerator, isAsync, allowsDirectSuper) {
   // Check key and flags
   var key = method.key;
   if (method.kind === "constructor") {
@@ -17637,14 +17676,14 @@ pp$1.parseClassMethod = function(method, isGenerator, isAsync, allowsDirectSuper
   return this.finishNode(method, "MethodDefinition")
 };
 
-pp$1.parseClassField = function(field) {
+pp$8.parseClassField = function(field) {
   if (checkKeyName(field, "constructor")) {
     this.raise(field.key.start, "Classes can't have a field named 'constructor'");
   } else if (field.static && checkKeyName(field, "prototype")) {
     this.raise(field.key.start, "Classes can't have a static field named 'prototype'");
   }
 
-  if (this.eat(types.eq)) {
+  if (this.eat(types$1.eq)) {
     // To raise SyntaxError if 'arguments' exists in the initializer.
     var scope = this.currentThisScope();
     var inClassFieldInit = scope.inClassFieldInit;
@@ -17659,13 +17698,13 @@ pp$1.parseClassField = function(field) {
   return this.finishNode(field, "PropertyDefinition")
 };
 
-pp$1.parseClassStaticBlock = function(node) {
+pp$8.parseClassStaticBlock = function(node) {
   node.body = [];
 
   var oldLabels = this.labels;
   this.labels = [];
   this.enterScope(SCOPE_CLASS_STATIC_BLOCK | SCOPE_SUPER);
-  while (this.type !== types.braceR) {
+  while (this.type !== types$1.braceR) {
     var stmt = this.parseStatement(null);
     node.body.push(stmt);
   }
@@ -17676,8 +17715,8 @@ pp$1.parseClassStaticBlock = function(node) {
   return this.finishNode(node, "StaticBlock")
 };
 
-pp$1.parseClassId = function(node, isStatement) {
-  if (this.type === types.name) {
+pp$8.parseClassId = function(node, isStatement) {
+  if (this.type === types$1.name) {
     node.id = this.parseIdent();
     if (isStatement)
       { this.checkLValSimple(node.id, BIND_LEXICAL, false); }
@@ -17688,17 +17727,17 @@ pp$1.parseClassId = function(node, isStatement) {
   }
 };
 
-pp$1.parseClassSuper = function(node) {
-  node.superClass = this.eat(types._extends) ? this.parseExprSubscripts(false) : null;
+pp$8.parseClassSuper = function(node) {
+  node.superClass = this.eat(types$1._extends) ? this.parseExprSubscripts(false) : null;
 };
 
-pp$1.enterClassBody = function() {
+pp$8.enterClassBody = function() {
   var element = {declared: Object.create(null), used: []};
   this.privateNameStack.push(element);
   return element.declared
 };
 
-pp$1.exitClassBody = function() {
+pp$8.exitClassBody = function() {
   var ref = this.privateNameStack.pop();
   var declared = ref.declared;
   var used = ref.used;
@@ -17753,10 +17792,10 @@ function checkKeyName(node, name) {
 
 // Parses module export declaration.
 
-pp$1.parseExport = function(node, exports) {
+pp$8.parseExport = function(node, exports) {
   this.next();
   // export * from '...'
-  if (this.eat(types.star)) {
+  if (this.eat(types$1.star)) {
     if (this.options.ecmaVersion >= 11) {
       if (this.eatContextual("as")) {
         node.exported = this.parseIdent(true);
@@ -17766,20 +17805,20 @@ pp$1.parseExport = function(node, exports) {
       }
     }
     this.expectContextual("from");
-    if (this.type !== types.string) { this.unexpected(); }
+    if (this.type !== types$1.string) { this.unexpected(); }
     node.source = this.parseExprAtom();
     this.semicolon();
     return this.finishNode(node, "ExportAllDeclaration")
   }
-  if (this.eat(types._default)) { // export default ...
+  if (this.eat(types$1._default)) { // export default ...
     this.checkExport(exports, "default", this.lastTokStart);
     var isAsync;
-    if (this.type === types._function || (isAsync = this.isAsyncFunction())) {
+    if (this.type === types$1._function || (isAsync = this.isAsyncFunction())) {
       var fNode = this.startNode();
       this.next();
       if (isAsync) { this.next(); }
       node.declaration = this.parseFunction(fNode, FUNC_STATEMENT | FUNC_NULLABLE_ID, false, isAsync);
-    } else if (this.type === types._class) {
+    } else if (this.type === types$1._class) {
       var cNode = this.startNode();
       node.declaration = this.parseClass(cNode, "nullableID");
     } else {
@@ -17801,7 +17840,7 @@ pp$1.parseExport = function(node, exports) {
     node.declaration = null;
     node.specifiers = this.parseExportSpecifiers(exports);
     if (this.eatContextual("from")) {
-      if (this.type !== types.string) { this.unexpected(); }
+      if (this.type !== types$1.string) { this.unexpected(); }
       node.source = this.parseExprAtom();
     } else {
       for (var i = 0, list = node.specifiers; i < list.length; i += 1) {
@@ -17820,14 +17859,14 @@ pp$1.parseExport = function(node, exports) {
   return this.finishNode(node, "ExportNamedDeclaration")
 };
 
-pp$1.checkExport = function(exports, name, pos) {
+pp$8.checkExport = function(exports, name, pos) {
   if (!exports) { return }
   if (has(exports, name))
     { this.raiseRecoverable(pos, "Duplicate export '" + name + "'"); }
   exports[name] = true;
 };
 
-pp$1.checkPatternExport = function(exports, pat) {
+pp$8.checkPatternExport = function(exports, pat) {
   var type = pat.type;
   if (type === "Identifier")
     { this.checkExport(exports, pat.name, pat.start); }
@@ -17854,7 +17893,7 @@ pp$1.checkPatternExport = function(exports, pat) {
     { this.checkPatternExport(exports, pat.expression); }
 };
 
-pp$1.checkVariableExport = function(exports, decls) {
+pp$8.checkVariableExport = function(exports, decls) {
   if (!exports) { return }
   for (var i = 0, list = decls; i < list.length; i += 1)
     {
@@ -17864,7 +17903,7 @@ pp$1.checkVariableExport = function(exports, decls) {
   }
 };
 
-pp$1.shouldParseExportStatement = function() {
+pp$8.shouldParseExportStatement = function() {
   return this.type.keyword === "var" ||
     this.type.keyword === "const" ||
     this.type.keyword === "class" ||
@@ -17875,14 +17914,14 @@ pp$1.shouldParseExportStatement = function() {
 
 // Parses a comma-separated list of module exports.
 
-pp$1.parseExportSpecifiers = function(exports) {
+pp$8.parseExportSpecifiers = function(exports) {
   var nodes = [], first = true;
   // export { x, y as z } [from '...']
-  this.expect(types.braceL);
-  while (!this.eat(types.braceR)) {
+  this.expect(types$1.braceL);
+  while (!this.eat(types$1.braceR)) {
     if (!first) {
-      this.expect(types.comma);
-      if (this.afterTrailingComma(types.braceR)) { break }
+      this.expect(types$1.comma);
+      if (this.afterTrailingComma(types$1.braceR)) { break }
     } else { first = false; }
 
     var node = this.startNode();
@@ -17896,16 +17935,16 @@ pp$1.parseExportSpecifiers = function(exports) {
 
 // Parses import declaration.
 
-pp$1.parseImport = function(node) {
+pp$8.parseImport = function(node) {
   this.next();
   // import '...'
-  if (this.type === types.string) {
-    node.specifiers = empty;
+  if (this.type === types$1.string) {
+    node.specifiers = empty$1;
     node.source = this.parseExprAtom();
   } else {
     node.specifiers = this.parseImportSpecifiers();
     this.expectContextual("from");
-    node.source = this.type === types.string ? this.parseExprAtom() : this.unexpected();
+    node.source = this.type === types$1.string ? this.parseExprAtom() : this.unexpected();
   }
   this.semicolon();
   return this.finishNode(node, "ImportDeclaration")
@@ -17913,17 +17952,17 @@ pp$1.parseImport = function(node) {
 
 // Parses a comma-separated list of module imports.
 
-pp$1.parseImportSpecifiers = function() {
+pp$8.parseImportSpecifiers = function() {
   var nodes = [], first = true;
-  if (this.type === types.name) {
+  if (this.type === types$1.name) {
     // import defaultObj, { x, y as z } from '...'
     var node = this.startNode();
     node.local = this.parseIdent();
     this.checkLValSimple(node.local, BIND_LEXICAL);
     nodes.push(this.finishNode(node, "ImportDefaultSpecifier"));
-    if (!this.eat(types.comma)) { return nodes }
+    if (!this.eat(types$1.comma)) { return nodes }
   }
-  if (this.type === types.star) {
+  if (this.type === types$1.star) {
     var node$1 = this.startNode();
     this.next();
     this.expectContextual("as");
@@ -17932,11 +17971,11 @@ pp$1.parseImportSpecifiers = function() {
     nodes.push(this.finishNode(node$1, "ImportNamespaceSpecifier"));
     return nodes
   }
-  this.expect(types.braceL);
-  while (!this.eat(types.braceR)) {
+  this.expect(types$1.braceL);
+  while (!this.eat(types$1.braceR)) {
     if (!first) {
-      this.expect(types.comma);
-      if (this.afterTrailingComma(types.braceR)) { break }
+      this.expect(types$1.comma);
+      if (this.afterTrailingComma(types$1.braceR)) { break }
     } else { first = false; }
 
     var node$2 = this.startNode();
@@ -17954,12 +17993,12 @@ pp$1.parseImportSpecifiers = function() {
 };
 
 // Set `ExpressionStatement#directive` property for directive prologues.
-pp$1.adaptDirectivePrologue = function(statements) {
+pp$8.adaptDirectivePrologue = function(statements) {
   for (var i = 0; i < statements.length && this.isDirectiveCandidate(statements[i]); ++i) {
     statements[i].directive = statements[i].expression.raw.slice(1, -1);
   }
 };
-pp$1.isDirectiveCandidate = function(statement) {
+pp$8.isDirectiveCandidate = function(statement) {
   return (
     statement.type === "ExpressionStatement" &&
     statement.expression.type === "Literal" &&
@@ -17969,12 +18008,12 @@ pp$1.isDirectiveCandidate = function(statement) {
   )
 };
 
-var pp$2 = Parser.prototype;
+var pp$7 = Parser.prototype;
 
 // Convert existing expression atom to assignable pattern
 // if possible.
 
-pp$2.toAssignable = function(node, isBinding, refDestructuringErrors) {
+pp$7.toAssignable = function(node, isBinding, refDestructuringErrors) {
   if (this.options.ecmaVersion >= 6 && node) {
     switch (node.type) {
     case "Identifier":
@@ -18055,7 +18094,7 @@ pp$2.toAssignable = function(node, isBinding, refDestructuringErrors) {
 
 // Convert list of expression atoms to binding list.
 
-pp$2.toAssignableList = function(exprList, isBinding) {
+pp$7.toAssignableList = function(exprList, isBinding) {
   var end = exprList.length;
   for (var i = 0; i < end; i++) {
     var elt = exprList[i];
@@ -18071,19 +18110,19 @@ pp$2.toAssignableList = function(exprList, isBinding) {
 
 // Parses spread element.
 
-pp$2.parseSpread = function(refDestructuringErrors) {
+pp$7.parseSpread = function(refDestructuringErrors) {
   var node = this.startNode();
   this.next();
   node.argument = this.parseMaybeAssign(false, refDestructuringErrors);
   return this.finishNode(node, "SpreadElement")
 };
 
-pp$2.parseRestBinding = function() {
+pp$7.parseRestBinding = function() {
   var node = this.startNode();
   this.next();
 
   // RestElement inside of a function parameter must be an identifier
-  if (this.options.ecmaVersion === 6 && this.type !== types.name)
+  if (this.options.ecmaVersion === 6 && this.type !== types$1.name)
     { this.unexpected(); }
 
   node.argument = this.parseBindingAtom();
@@ -18093,36 +18132,36 @@ pp$2.parseRestBinding = function() {
 
 // Parses lvalue (assignable) atom.
 
-pp$2.parseBindingAtom = function() {
+pp$7.parseBindingAtom = function() {
   if (this.options.ecmaVersion >= 6) {
     switch (this.type) {
-    case types.bracketL:
+    case types$1.bracketL:
       var node = this.startNode();
       this.next();
-      node.elements = this.parseBindingList(types.bracketR, true, true);
+      node.elements = this.parseBindingList(types$1.bracketR, true, true);
       return this.finishNode(node, "ArrayPattern")
 
-    case types.braceL:
+    case types$1.braceL:
       return this.parseObj(true)
     }
   }
   return this.parseIdent()
 };
 
-pp$2.parseBindingList = function(close, allowEmpty, allowTrailingComma) {
+pp$7.parseBindingList = function(close, allowEmpty, allowTrailingComma) {
   var elts = [], first = true;
   while (!this.eat(close)) {
     if (first) { first = false; }
-    else { this.expect(types.comma); }
-    if (allowEmpty && this.type === types.comma) {
+    else { this.expect(types$1.comma); }
+    if (allowEmpty && this.type === types$1.comma) {
       elts.push(null);
     } else if (allowTrailingComma && this.afterTrailingComma(close)) {
       break
-    } else if (this.type === types.ellipsis) {
+    } else if (this.type === types$1.ellipsis) {
       var rest = this.parseRestBinding();
       this.parseBindingListItem(rest);
       elts.push(rest);
-      if (this.type === types.comma) { this.raise(this.start, "Comma is not permitted after the rest element"); }
+      if (this.type === types$1.comma) { this.raise(this.start, "Comma is not permitted after the rest element"); }
       this.expect(close);
       break
     } else {
@@ -18134,15 +18173,15 @@ pp$2.parseBindingList = function(close, allowEmpty, allowTrailingComma) {
   return elts
 };
 
-pp$2.parseBindingListItem = function(param) {
+pp$7.parseBindingListItem = function(param) {
   return param
 };
 
 // Parses assignment pattern around given atom if possible.
 
-pp$2.parseMaybeDefault = function(startPos, startLoc, left) {
+pp$7.parseMaybeDefault = function(startPos, startLoc, left) {
   left = left || this.parseBindingAtom();
-  if (this.options.ecmaVersion < 6 || !this.eat(types.eq)) { return left }
+  if (this.options.ecmaVersion < 6 || !this.eat(types$1.eq)) { return left }
   var node = this.startNodeAt(startPos, startLoc);
   node.left = left;
   node.right = this.parseMaybeAssign();
@@ -18213,7 +18252,7 @@ pp$2.parseMaybeDefault = function(startPos, startLoc, left) {
 // duplicate argument names. checkClashes is ignored if the provided construct
 // is an assignment (i.e., bindingType is BIND_NONE).
 
-pp$2.checkLValSimple = function(expr, bindingType, checkClashes) {
+pp$7.checkLValSimple = function(expr, bindingType, checkClashes) {
   if ( bindingType === void 0 ) bindingType = BIND_NONE;
 
   var isBind = bindingType !== BIND_NONE;
@@ -18251,7 +18290,7 @@ pp$2.checkLValSimple = function(expr, bindingType, checkClashes) {
   }
 };
 
-pp$2.checkLValPattern = function(expr, bindingType, checkClashes) {
+pp$7.checkLValPattern = function(expr, bindingType, checkClashes) {
   if ( bindingType === void 0 ) bindingType = BIND_NONE;
 
   switch (expr.type) {
@@ -18276,7 +18315,7 @@ pp$2.checkLValPattern = function(expr, bindingType, checkClashes) {
   }
 };
 
-pp$2.checkLValInnerPattern = function(expr, bindingType, checkClashes) {
+pp$7.checkLValInnerPattern = function(expr, bindingType, checkClashes) {
   if ( bindingType === void 0 ) bindingType = BIND_NONE;
 
   switch (expr.type) {
@@ -18308,7 +18347,7 @@ var TokContext = function TokContext(token, isExpr, preserveSpace, override, gen
   this.generator = !!generator;
 };
 
-var types$1 = {
+var types = {
   b_stat: new TokContext("{", false),
   b_expr: new TokContext("{", true),
   b_tmpl: new TokContext("${", false),
@@ -18321,38 +18360,38 @@ var types$1 = {
   f_gen: new TokContext("function", false, false, null, true)
 };
 
-var pp$3 = Parser.prototype;
+var pp$6 = Parser.prototype;
 
-pp$3.initialContext = function() {
-  return [types$1.b_stat]
+pp$6.initialContext = function() {
+  return [types.b_stat]
 };
 
-pp$3.curContext = function() {
+pp$6.curContext = function() {
   return this.context[this.context.length - 1]
 };
 
-pp$3.braceIsBlock = function(prevType) {
+pp$6.braceIsBlock = function(prevType) {
   var parent = this.curContext();
-  if (parent === types$1.f_expr || parent === types$1.f_stat)
+  if (parent === types.f_expr || parent === types.f_stat)
     { return true }
-  if (prevType === types.colon && (parent === types$1.b_stat || parent === types$1.b_expr))
+  if (prevType === types$1.colon && (parent === types.b_stat || parent === types.b_expr))
     { return !parent.isExpr }
 
   // The check for `tt.name && exprAllowed` detects whether we are
   // after a `yield` or `of` construct. See the `updateContext` for
   // `tt.name`.
-  if (prevType === types._return || prevType === types.name && this.exprAllowed)
+  if (prevType === types$1._return || prevType === types$1.name && this.exprAllowed)
     { return lineBreak.test(this.input.slice(this.lastTokEnd, this.start)) }
-  if (prevType === types._else || prevType === types.semi || prevType === types.eof || prevType === types.parenR || prevType === types.arrow)
+  if (prevType === types$1._else || prevType === types$1.semi || prevType === types$1.eof || prevType === types$1.parenR || prevType === types$1.arrow)
     { return true }
-  if (prevType === types.braceL)
-    { return parent === types$1.b_stat }
-  if (prevType === types._var || prevType === types._const || prevType === types.name)
+  if (prevType === types$1.braceL)
+    { return parent === types.b_stat }
+  if (prevType === types$1._var || prevType === types$1._const || prevType === types$1.name)
     { return false }
   return !this.exprAllowed
 };
 
-pp$3.inGeneratorContext = function() {
+pp$6.inGeneratorContext = function() {
   for (var i = this.context.length - 1; i >= 1; i--) {
     var context = this.context[i];
     if (context.token === "function")
@@ -18361,9 +18400,9 @@ pp$3.inGeneratorContext = function() {
   return false
 };
 
-pp$3.updateContext = function(prevType) {
+pp$6.updateContext = function(prevType) {
   var update, type = this.type;
-  if (type.keyword && prevType === types.dot)
+  if (type.keyword && prevType === types$1.dot)
     { this.exprAllowed = false; }
   else if (update = type.updateContext)
     { update.call(this, prevType); }
@@ -18372,7 +18411,7 @@ pp$3.updateContext = function(prevType) {
 };
 
 // Used to handle egde case when token context could not be inferred correctly in tokenize phase
-pp$3.overrideContext = function(tokenCtx) {
+pp$6.overrideContext = function(tokenCtx) {
   if (this.curContext() !== tokenCtx) {
     this.context[this.context.length - 1] = tokenCtx;
   }
@@ -18380,71 +18419,71 @@ pp$3.overrideContext = function(tokenCtx) {
 
 // Token-specific context update code
 
-types.parenR.updateContext = types.braceR.updateContext = function() {
+types$1.parenR.updateContext = types$1.braceR.updateContext = function() {
   if (this.context.length === 1) {
     this.exprAllowed = true;
     return
   }
   var out = this.context.pop();
-  if (out === types$1.b_stat && this.curContext().token === "function") {
+  if (out === types.b_stat && this.curContext().token === "function") {
     out = this.context.pop();
   }
   this.exprAllowed = !out.isExpr;
 };
 
-types.braceL.updateContext = function(prevType) {
-  this.context.push(this.braceIsBlock(prevType) ? types$1.b_stat : types$1.b_expr);
+types$1.braceL.updateContext = function(prevType) {
+  this.context.push(this.braceIsBlock(prevType) ? types.b_stat : types.b_expr);
   this.exprAllowed = true;
 };
 
-types.dollarBraceL.updateContext = function() {
-  this.context.push(types$1.b_tmpl);
+types$1.dollarBraceL.updateContext = function() {
+  this.context.push(types.b_tmpl);
   this.exprAllowed = true;
 };
 
-types.parenL.updateContext = function(prevType) {
-  var statementParens = prevType === types._if || prevType === types._for || prevType === types._with || prevType === types._while;
-  this.context.push(statementParens ? types$1.p_stat : types$1.p_expr);
+types$1.parenL.updateContext = function(prevType) {
+  var statementParens = prevType === types$1._if || prevType === types$1._for || prevType === types$1._with || prevType === types$1._while;
+  this.context.push(statementParens ? types.p_stat : types.p_expr);
   this.exprAllowed = true;
 };
 
-types.incDec.updateContext = function() {
+types$1.incDec.updateContext = function() {
   // tokExprAllowed stays unchanged
 };
 
-types._function.updateContext = types._class.updateContext = function(prevType) {
-  if (prevType.beforeExpr && prevType !== types._else &&
-      !(prevType === types.semi && this.curContext() !== types$1.p_stat) &&
-      !(prevType === types._return && lineBreak.test(this.input.slice(this.lastTokEnd, this.start))) &&
-      !((prevType === types.colon || prevType === types.braceL) && this.curContext() === types$1.b_stat))
-    { this.context.push(types$1.f_expr); }
+types$1._function.updateContext = types$1._class.updateContext = function(prevType) {
+  if (prevType.beforeExpr && prevType !== types$1._else &&
+      !(prevType === types$1.semi && this.curContext() !== types.p_stat) &&
+      !(prevType === types$1._return && lineBreak.test(this.input.slice(this.lastTokEnd, this.start))) &&
+      !((prevType === types$1.colon || prevType === types$1.braceL) && this.curContext() === types.b_stat))
+    { this.context.push(types.f_expr); }
   else
-    { this.context.push(types$1.f_stat); }
+    { this.context.push(types.f_stat); }
   this.exprAllowed = false;
 };
 
-types.backQuote.updateContext = function() {
-  if (this.curContext() === types$1.q_tmpl)
+types$1.backQuote.updateContext = function() {
+  if (this.curContext() === types.q_tmpl)
     { this.context.pop(); }
   else
-    { this.context.push(types$1.q_tmpl); }
+    { this.context.push(types.q_tmpl); }
   this.exprAllowed = false;
 };
 
-types.star.updateContext = function(prevType) {
-  if (prevType === types._function) {
+types$1.star.updateContext = function(prevType) {
+  if (prevType === types$1._function) {
     var index = this.context.length - 1;
-    if (this.context[index] === types$1.f_expr)
-      { this.context[index] = types$1.f_expr_gen; }
+    if (this.context[index] === types.f_expr)
+      { this.context[index] = types.f_expr_gen; }
     else
-      { this.context[index] = types$1.f_gen; }
+      { this.context[index] = types.f_gen; }
   }
   this.exprAllowed = true;
 };
 
-types.name.updateContext = function(prevType) {
+types$1.name.updateContext = function(prevType) {
   var allowed = false;
-  if (this.options.ecmaVersion >= 6 && prevType !== types.dot) {
+  if (this.options.ecmaVersion >= 6 && prevType !== types$1.dot) {
     if (this.value === "of" && !this.exprAllowed ||
         this.value === "yield" && this.inGeneratorContext())
       { allowed = true; }
@@ -18454,14 +18493,14 @@ types.name.updateContext = function(prevType) {
 
 // A recursive descent parser operates by defining functions for all
 
-var pp$4 = Parser.prototype;
+var pp$5 = Parser.prototype;
 
 // Check if property name clashes with already added.
 // Object/class getters and setters are not allowed to clash —
 // either with each other or with an init property — and in
 // strict mode, init properties are also not allowed to be repeated.
 
-pp$4.checkPropClash = function(prop, propHash, refDestructuringErrors) {
+pp$5.checkPropClash = function(prop, propHash, refDestructuringErrors) {
   if (this.options.ecmaVersion >= 9 && prop.type === "SpreadElement")
     { return }
   if (this.options.ecmaVersion >= 6 && (prop.computed || prop.method || prop.shorthand))
@@ -18478,10 +18517,12 @@ pp$4.checkPropClash = function(prop, propHash, refDestructuringErrors) {
     if (name === "__proto__" && kind === "init") {
       if (propHash.proto) {
         if (refDestructuringErrors) {
-          if (refDestructuringErrors.doubleProto < 0)
-            { refDestructuringErrors.doubleProto = key.start; }
-          // Backwards-compat kludge. Can be removed in version 6.0
-        } else { this.raiseRecoverable(key.start, "Redefinition of __proto__ property"); }
+          if (refDestructuringErrors.doubleProto < 0) {
+            refDestructuringErrors.doubleProto = key.start;
+          }
+        } else {
+          this.raiseRecoverable(key.start, "Redefinition of __proto__ property");
+        }
       }
       propHash.proto = true;
     }
@@ -18523,13 +18564,13 @@ pp$4.checkPropClash = function(prop, propHash, refDestructuringErrors) {
 // and object pattern might appear (so it's possible to raise
 // delayed syntax error at correct position).
 
-pp$4.parseExpression = function(forInit, refDestructuringErrors) {
+pp$5.parseExpression = function(forInit, refDestructuringErrors) {
   var startPos = this.start, startLoc = this.startLoc;
   var expr = this.parseMaybeAssign(forInit, refDestructuringErrors);
-  if (this.type === types.comma) {
+  if (this.type === types$1.comma) {
     var node = this.startNodeAt(startPos, startLoc);
     node.expressions = [expr];
-    while (this.eat(types.comma)) { node.expressions.push(this.parseMaybeAssign(forInit, refDestructuringErrors)); }
+    while (this.eat(types$1.comma)) { node.expressions.push(this.parseMaybeAssign(forInit, refDestructuringErrors)); }
     return this.finishNode(node, "SequenceExpression")
   }
   return expr
@@ -18538,7 +18579,7 @@ pp$4.parseExpression = function(forInit, refDestructuringErrors) {
 // Parse an assignment expression. This includes applications of
 // operators like `+=`.
 
-pp$4.parseMaybeAssign = function(forInit, refDestructuringErrors, afterLeftParse) {
+pp$5.parseMaybeAssign = function(forInit, refDestructuringErrors, afterLeftParse) {
   if (this.isContextual("yield")) {
     if (this.inGenerator) { return this.parseYield(forInit) }
     // The tokenizer will assume an expression is allowed after
@@ -18546,10 +18587,11 @@ pp$4.parseMaybeAssign = function(forInit, refDestructuringErrors, afterLeftParse
     else { this.exprAllowed = false; }
   }
 
-  var ownDestructuringErrors = false, oldParenAssign = -1, oldTrailingComma = -1;
+  var ownDestructuringErrors = false, oldParenAssign = -1, oldTrailingComma = -1, oldDoubleProto = -1;
   if (refDestructuringErrors) {
     oldParenAssign = refDestructuringErrors.parenthesizedAssign;
     oldTrailingComma = refDestructuringErrors.trailingComma;
+    oldDoubleProto = refDestructuringErrors.doubleProto;
     refDestructuringErrors.parenthesizedAssign = refDestructuringErrors.trailingComma = -1;
   } else {
     refDestructuringErrors = new DestructuringErrors;
@@ -18557,7 +18599,7 @@ pp$4.parseMaybeAssign = function(forInit, refDestructuringErrors, afterLeftParse
   }
 
   var startPos = this.start, startLoc = this.startLoc;
-  if (this.type === types.parenL || this.type === types.name) {
+  if (this.type === types$1.parenL || this.type === types$1.name) {
     this.potentialArrowAt = this.start;
     this.potentialArrowInForAwait = forInit === "await";
   }
@@ -18566,20 +18608,21 @@ pp$4.parseMaybeAssign = function(forInit, refDestructuringErrors, afterLeftParse
   if (this.type.isAssign) {
     var node = this.startNodeAt(startPos, startLoc);
     node.operator = this.value;
-    if (this.type === types.eq)
+    if (this.type === types$1.eq)
       { left = this.toAssignable(left, false, refDestructuringErrors); }
     if (!ownDestructuringErrors) {
       refDestructuringErrors.parenthesizedAssign = refDestructuringErrors.trailingComma = refDestructuringErrors.doubleProto = -1;
     }
     if (refDestructuringErrors.shorthandAssign >= left.start)
       { refDestructuringErrors.shorthandAssign = -1; } // reset because shorthand default was used correctly
-    if (this.type === types.eq)
+    if (this.type === types$1.eq)
       { this.checkLValPattern(left); }
     else
       { this.checkLValSimple(left); }
     node.left = left;
     this.next();
     node.right = this.parseMaybeAssign(forInit);
+    if (oldDoubleProto > -1) { refDestructuringErrors.doubleProto = oldDoubleProto; }
     return this.finishNode(node, "AssignmentExpression")
   } else {
     if (ownDestructuringErrors) { this.checkExpressionErrors(refDestructuringErrors, true); }
@@ -18591,15 +18634,15 @@ pp$4.parseMaybeAssign = function(forInit, refDestructuringErrors, afterLeftParse
 
 // Parse a ternary conditional (`?:`) operator.
 
-pp$4.parseMaybeConditional = function(forInit, refDestructuringErrors) {
+pp$5.parseMaybeConditional = function(forInit, refDestructuringErrors) {
   var startPos = this.start, startLoc = this.startLoc;
   var expr = this.parseExprOps(forInit, refDestructuringErrors);
   if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }
-  if (this.eat(types.question)) {
+  if (this.eat(types$1.question)) {
     var node = this.startNodeAt(startPos, startLoc);
     node.test = expr;
     node.consequent = this.parseMaybeAssign();
-    this.expect(types.colon);
+    this.expect(types$1.colon);
     node.alternate = this.parseMaybeAssign(forInit);
     return this.finishNode(node, "ConditionalExpression")
   }
@@ -18608,7 +18651,7 @@ pp$4.parseMaybeConditional = function(forInit, refDestructuringErrors) {
 
 // Start the precedence parser.
 
-pp$4.parseExprOps = function(forInit, refDestructuringErrors) {
+pp$5.parseExprOps = function(forInit, refDestructuringErrors) {
   var startPos = this.start, startLoc = this.startLoc;
   var expr = this.parseMaybeUnary(refDestructuringErrors, false, false, forInit);
   if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }
@@ -18621,23 +18664,23 @@ pp$4.parseExprOps = function(forInit, refDestructuringErrors) {
 // defer further parser to one of its callers when it encounters an
 // operator that has a lower precedence than the set it is parsing.
 
-pp$4.parseExprOp = function(left, leftStartPos, leftStartLoc, minPrec, forInit) {
+pp$5.parseExprOp = function(left, leftStartPos, leftStartLoc, minPrec, forInit) {
   var prec = this.type.binop;
-  if (prec != null && (!forInit || this.type !== types._in)) {
+  if (prec != null && (!forInit || this.type !== types$1._in)) {
     if (prec > minPrec) {
-      var logical = this.type === types.logicalOR || this.type === types.logicalAND;
-      var coalesce = this.type === types.coalesce;
+      var logical = this.type === types$1.logicalOR || this.type === types$1.logicalAND;
+      var coalesce = this.type === types$1.coalesce;
       if (coalesce) {
         // Handle the precedence of `tt.coalesce` as equal to the range of logical expressions.
         // In other words, `node.right` shouldn't contain logical expressions in order to check the mixed error.
-        prec = types.logicalAND.binop;
+        prec = types$1.logicalAND.binop;
       }
       var op = this.value;
       this.next();
       var startPos = this.start, startLoc = this.startLoc;
       var right = this.parseExprOp(this.parseMaybeUnary(null, false, false, forInit), startPos, startLoc, prec, forInit);
       var node = this.buildBinary(leftStartPos, leftStartLoc, left, right, op, logical || coalesce);
-      if ((logical && this.type === types.coalesce) || (coalesce && (this.type === types.logicalOR || this.type === types.logicalAND))) {
+      if ((logical && this.type === types$1.coalesce) || (coalesce && (this.type === types$1.logicalOR || this.type === types$1.logicalAND))) {
         this.raiseRecoverable(this.start, "Logical expressions and coalesce expressions cannot be mixed. Wrap either by parentheses");
       }
       return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec, forInit)
@@ -18646,7 +18689,8 @@ pp$4.parseExprOp = function(left, leftStartPos, leftStartLoc, minPrec, forInit)
   return left
 };
 
-pp$4.buildBinary = function(startPos, startLoc, left, right, op, logical) {
+pp$5.buildBinary = function(startPos, startLoc, left, right, op, logical) {
+  if (right.type === "PrivateIdentifier") { this.raise(right.start, "Private identifier can only be left side of binary expression"); }
   var node = this.startNodeAt(startPos, startLoc);
   node.left = left;
   node.operator = op;
@@ -18656,13 +18700,13 @@ pp$4.buildBinary = function(startPos, startLoc, left, right, op, logical) {
 
 // Parse unary operators, both prefix and postfix.
 
-pp$4.parseMaybeUnary = function(refDestructuringErrors, sawUnary, incDec, forInit) {
+pp$5.parseMaybeUnary = function(refDestructuringErrors, sawUnary, incDec, forInit) {
   var startPos = this.start, startLoc = this.startLoc, expr;
   if (this.isContextual("await") && this.canAwait) {
     expr = this.parseAwait(forInit);
     sawUnary = true;
   } else if (this.type.prefix) {
-    var node = this.startNode(), update = this.type === types.incDec;
+    var node = this.startNode(), update = this.type === types$1.incDec;
     node.operator = this.value;
     node.prefix = true;
     this.next();
@@ -18676,6 +18720,11 @@ pp$4.parseMaybeUnary = function(refDestructuringErrors, sawUnary, incDec, forIni
       { this.raiseRecoverable(node.start, "Private fields can not be deleted"); }
     else { sawUnary = true; }
     expr = this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
+  } else if (!sawUnary && this.type === types$1.privateId) {
+    if (forInit || this.privateNameStack.length === 0) { this.unexpected(); }
+    expr = this.parsePrivateIdent();
+    // only could be private fields in 'in', such as #x in obj
+    if (this.type !== types$1._in) { this.unexpected(); }
   } else {
     expr = this.parseExprSubscripts(refDestructuringErrors, forInit);
     if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }
@@ -18690,7 +18739,7 @@ pp$4.parseMaybeUnary = function(refDestructuringErrors, sawUnary, incDec, forIni
     }
   }
 
-  if (!incDec && this.eat(types.starstar)) {
+  if (!incDec && this.eat(types$1.starstar)) {
     if (sawUnary)
       { this.unexpected(this.lastTokStart); }
     else
@@ -18709,7 +18758,7 @@ function isPrivateFieldAccess(node) {
 
 // Parse call, dot, and `[]`-subscript expressions.
 
-pp$4.parseExprSubscripts = function(refDestructuringErrors, forInit) {
+pp$5.parseExprSubscripts = function(refDestructuringErrors, forInit) {
   var startPos = this.start, startLoc = this.startLoc;
   var expr = this.parseExprAtom(refDestructuringErrors, forInit);
   if (expr.type === "ArrowFunctionExpression" && this.input.slice(this.lastTokStart, this.lastTokEnd) !== ")")
@@ -18723,7 +18772,7 @@ pp$4.parseExprSubscripts = function(refDestructuringErrors, forInit) {
   return result
 };
 
-pp$4.parseSubscripts = function(base, startPos, startLoc, noCalls, forInit) {
+pp$5.parseSubscripts = function(base, startPos, startLoc, noCalls, forInit) {
   var maybeAsyncArrow = this.options.ecmaVersion >= 8 && base.type === "Identifier" && base.name === "async" &&
       this.lastTokEnd === base.end && !this.canInsertSemicolon() && base.end - base.start === 5 &&
       this.potentialArrowAt === base.start;
@@ -18746,19 +18795,19 @@ pp$4.parseSubscripts = function(base, startPos, startLoc, noCalls, forInit) {
   }
 };
 
-pp$4.parseSubscript = function(base, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained, forInit) {
+pp$5.parseSubscript = function(base, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained, forInit) {
   var optionalSupported = this.options.ecmaVersion >= 11;
-  var optional = optionalSupported && this.eat(types.questionDot);
+  var optional = optionalSupported && this.eat(types$1.questionDot);
   if (noCalls && optional) { this.raise(this.lastTokStart, "Optional chaining cannot appear in the callee of new expressions"); }
 
-  var computed = this.eat(types.bracketL);
-  if (computed || (optional && this.type !== types.parenL && this.type !== types.backQuote) || this.eat(types.dot)) {
+  var computed = this.eat(types$1.bracketL);
+  if (computed || (optional && this.type !== types$1.parenL && this.type !== types$1.backQuote) || this.eat(types$1.dot)) {
     var node = this.startNodeAt(startPos, startLoc);
     node.object = base;
     if (computed) {
       node.property = this.parseExpression();
-      this.expect(types.bracketR);
-    } else if (this.type === types.privateId && base.type !== "Super") {
+      this.expect(types$1.bracketR);
+    } else if (this.type === types$1.privateId && base.type !== "Super") {
       node.property = this.parsePrivateIdent();
     } else {
       node.property = this.parseIdent(this.options.allowReserved !== "never");
@@ -18768,13 +18817,13 @@ pp$4.parseSubscript = function(base, startPos, startLoc, noCalls, maybeAsyncArro
       node.optional = optional;
     }
     base = this.finishNode(node, "MemberExpression");
-  } else if (!noCalls && this.eat(types.parenL)) {
+  } else if (!noCalls && this.eat(types$1.parenL)) {
     var refDestructuringErrors = new DestructuringErrors, oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;
     this.yieldPos = 0;
     this.awaitPos = 0;
     this.awaitIdentPos = 0;
-    var exprList = this.parseExprList(types.parenR, this.options.ecmaVersion >= 8, false, refDestructuringErrors);
-    if (maybeAsyncArrow && !optional && !this.canInsertSemicolon() && this.eat(types.arrow)) {
+    var exprList = this.parseExprList(types$1.parenR, this.options.ecmaVersion >= 8, false, refDestructuringErrors);
+    if (maybeAsyncArrow && !optional && !this.canInsertSemicolon() && this.eat(types$1.arrow)) {
       this.checkPatternErrors(refDestructuringErrors, false);
       this.checkYieldAwaitInDefaultParams();
       if (this.awaitIdentPos > 0)
@@ -18795,7 +18844,7 @@ pp$4.parseSubscript = function(base, startPos, startLoc, noCalls, maybeAsyncArro
       node$1.optional = optional;
     }
     base = this.finishNode(node$1, "CallExpression");
-  } else if (this.type === types.backQuote) {
+  } else if (this.type === types$1.backQuote) {
     if (optional || optionalChained) {
       this.raise(this.start, "Optional chaining cannot appear in the tag of tagged template expressions");
     }
@@ -18812,19 +18861,19 @@ pp$4.parseSubscript = function(base, startPos, startLoc, noCalls, maybeAsyncArro
 // `new`, or an expression wrapped in punctuation like `()`, `[]`,
 // or `{}`.
 
-pp$4.parseExprAtom = function(refDestructuringErrors, forInit) {
+pp$5.parseExprAtom = function(refDestructuringErrors, forInit) {
   // If a division operator appears in an expression position, the
   // tokenizer got confused, and we force it to read a regexp instead.
-  if (this.type === types.slash) { this.readRegexp(); }
+  if (this.type === types$1.slash) { this.readRegexp(); }
 
   var node, canBeArrow = this.potentialArrowAt === this.start;
   switch (this.type) {
-  case types._super:
+  case types$1._super:
     if (!this.allowSuper)
       { this.raise(this.start, "'super' keyword outside a method"); }
     node = this.startNode();
     this.next();
-    if (this.type === types.parenL && !this.allowDirectSuper)
+    if (this.type === types$1.parenL && !this.allowDirectSuper)
       { this.raise(node.start, "super() call outside constructor of a subclass"); }
     // The `super` keyword can appear at below:
     // SuperProperty:
@@ -18832,52 +18881,52 @@ pp$4.parseExprAtom = function(refDestructuringErrors, forInit) {
     //     super . IdentifierName
     // SuperCall:
     //     super ( Arguments )
-    if (this.type !== types.dot && this.type !== types.bracketL && this.type !== types.parenL)
+    if (this.type !== types$1.dot && this.type !== types$1.bracketL && this.type !== types$1.parenL)
       { this.unexpected(); }
     return this.finishNode(node, "Super")
 
-  case types._this:
+  case types$1._this:
     node = this.startNode();
     this.next();
     return this.finishNode(node, "ThisExpression")
 
-  case types.name:
+  case types$1.name:
     var startPos = this.start, startLoc = this.startLoc, containsEsc = this.containsEsc;
     var id = this.parseIdent(false);
-    if (this.options.ecmaVersion >= 8 && !containsEsc && id.name === "async" && !this.canInsertSemicolon() && this.eat(types._function)) {
-      this.overrideContext(types$1.f_expr);
+    if (this.options.ecmaVersion >= 8 && !containsEsc && id.name === "async" && !this.canInsertSemicolon() && this.eat(types$1._function)) {
+      this.overrideContext(types.f_expr);
       return this.parseFunction(this.startNodeAt(startPos, startLoc), 0, false, true, forInit)
     }
     if (canBeArrow && !this.canInsertSemicolon()) {
-      if (this.eat(types.arrow))
+      if (this.eat(types$1.arrow))
         { return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], false, forInit) }
-      if (this.options.ecmaVersion >= 8 && id.name === "async" && this.type === types.name && !containsEsc &&
+      if (this.options.ecmaVersion >= 8 && id.name === "async" && this.type === types$1.name && !containsEsc &&
           (!this.potentialArrowInForAwait || this.value !== "of" || this.containsEsc)) {
         id = this.parseIdent(false);
-        if (this.canInsertSemicolon() || !this.eat(types.arrow))
+        if (this.canInsertSemicolon() || !this.eat(types$1.arrow))
           { this.unexpected(); }
         return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], true, forInit)
       }
     }
     return id
 
-  case types.regexp:
+  case types$1.regexp:
     var value = this.value;
     node = this.parseLiteral(value.value);
     node.regex = {pattern: value.pattern, flags: value.flags};
     return node
 
-  case types.num: case types.string:
+  case types$1.num: case types$1.string:
     return this.parseLiteral(this.value)
 
-  case types._null: case types._true: case types._false:
+  case types$1._null: case types$1._true: case types$1._false:
     node = this.startNode();
-    node.value = this.type === types._null ? null : this.type === types._true;
+    node.value = this.type === types$1._null ? null : this.type === types$1._true;
     node.raw = this.type.keyword;
     this.next();
     return this.finishNode(node, "Literal")
 
-  case types.parenL:
+  case types$1.parenL:
     var start = this.start, expr = this.parseParenAndDistinguishExpression(canBeArrow, forInit);
     if (refDestructuringErrors) {
       if (refDestructuringErrors.parenthesizedAssign < 0 && !this.isSimpleAssignTarget(expr))
@@ -18887,31 +18936,31 @@ pp$4.parseExprAtom = function(refDestructuringErrors, forInit) {
     }
     return expr
 
-  case types.bracketL:
+  case types$1.bracketL:
     node = this.startNode();
     this.next();
-    node.elements = this.parseExprList(types.bracketR, true, true, refDestructuringErrors);
+    node.elements = this.parseExprList(types$1.bracketR, true, true, refDestructuringErrors);
     return this.finishNode(node, "ArrayExpression")
 
-  case types.braceL:
-    this.overrideContext(types$1.b_expr);
+  case types$1.braceL:
+    this.overrideContext(types.b_expr);
     return this.parseObj(false, refDestructuringErrors)
 
-  case types._function:
+  case types$1._function:
     node = this.startNode();
     this.next();
     return this.parseFunction(node, 0)
 
-  case types._class:
+  case types$1._class:
     return this.parseClass(this.startNode(), false)
 
-  case types._new:
+  case types$1._new:
     return this.parseNew()
 
-  case types.backQuote:
+  case types$1.backQuote:
     return this.parseTemplate()
 
-  case types._import:
+  case types$1._import:
     if (this.options.ecmaVersion >= 11) {
       return this.parseExprImport()
     } else {
@@ -18923,7 +18972,7 @@ pp$4.parseExprAtom = function(refDestructuringErrors, forInit) {
   }
 };
 
-pp$4.parseExprImport = function() {
+pp$5.parseExprImport = function() {
   var node = this.startNode();
 
   // Consume `import` as an identifier for `import.meta`.
@@ -18932,9 +18981,9 @@ pp$4.parseExprImport = function() {
   var meta = this.parseIdent(true);
 
   switch (this.type) {
-  case types.parenL:
+  case types$1.parenL:
     return this.parseDynamicImport(node)
-  case types.dot:
+  case types$1.dot:
     node.meta = meta;
     return this.parseImportMeta(node)
   default:
@@ -18942,16 +18991,16 @@ pp$4.parseExprImport = function() {
   }
 };
 
-pp$4.parseDynamicImport = function(node) {
+pp$5.parseDynamicImport = function(node) {
   this.next(); // skip `(`
 
   // Parse node.source.
   node.source = this.parseMaybeAssign();
 
   // Verify ending.
-  if (!this.eat(types.parenR)) {
+  if (!this.eat(types$1.parenR)) {
     var errorPos = this.start;
-    if (this.eat(types.comma) && this.eat(types.parenR)) {
+    if (this.eat(types$1.comma) && this.eat(types$1.parenR)) {
       this.raiseRecoverable(errorPos, "Trailing comma is not allowed in import()");
     } else {
       this.unexpected(errorPos);
@@ -18961,7 +19010,7 @@ pp$4.parseDynamicImport = function(node) {
   return this.finishNode(node, "ImportExpression")
 };
 
-pp$4.parseImportMeta = function(node) {
+pp$5.parseImportMeta = function(node) {
   this.next(); // skip `.`
 
   var containsEsc = this.containsEsc;
@@ -18977,7 +19026,7 @@ pp$4.parseImportMeta = function(node) {
   return this.finishNode(node, "MetaProperty")
 };
 
-pp$4.parseLiteral = function(value) {
+pp$5.parseLiteral = function(value) {
   var node = this.startNode();
   node.value = value;
   node.raw = this.input.slice(this.start, this.end);
@@ -18986,14 +19035,14 @@ pp$4.parseLiteral = function(value) {
   return this.finishNode(node, "Literal")
 };
 
-pp$4.parseParenExpression = function() {
-  this.expect(types.parenL);
+pp$5.parseParenExpression = function() {
+  this.expect(types$1.parenL);
   var val = this.parseExpression();
-  this.expect(types.parenR);
+  this.expect(types$1.parenR);
   return val
 };
 
-pp$4.parseParenAndDistinguishExpression = function(canBeArrow, forInit) {
+pp$5.parseParenAndDistinguishExpression = function(canBeArrow, forInit) {
   var startPos = this.start, startLoc = this.startLoc, val, allowTrailingComma = this.options.ecmaVersion >= 8;
   if (this.options.ecmaVersion >= 6) {
     this.next();
@@ -19004,24 +19053,24 @@ pp$4.parseParenAndDistinguishExpression = function(canBeArrow, forInit) {
     this.yieldPos = 0;
     this.awaitPos = 0;
     // Do not save awaitIdentPos to allow checking awaits nested in parameters
-    while (this.type !== types.parenR) {
-      first ? first = false : this.expect(types.comma);
-      if (allowTrailingComma && this.afterTrailingComma(types.parenR, true)) {
+    while (this.type !== types$1.parenR) {
+      first ? first = false : this.expect(types$1.comma);
+      if (allowTrailingComma && this.afterTrailingComma(types$1.parenR, true)) {
         lastIsComma = true;
         break
-      } else if (this.type === types.ellipsis) {
+      } else if (this.type === types$1.ellipsis) {
         spreadStart = this.start;
         exprList.push(this.parseParenItem(this.parseRestBinding()));
-        if (this.type === types.comma) { this.raise(this.start, "Comma is not permitted after the rest element"); }
+        if (this.type === types$1.comma) { this.raise(this.start, "Comma is not permitted after the rest element"); }
         break
       } else {
         exprList.push(this.parseMaybeAssign(false, refDestructuringErrors, this.parseParenItem));
       }
     }
     var innerEndPos = this.lastTokEnd, innerEndLoc = this.lastTokEndLoc;
-    this.expect(types.parenR);
+    this.expect(types$1.parenR);
 
-    if (canBeArrow && !this.canInsertSemicolon() && this.eat(types.arrow)) {
+    if (canBeArrow && !this.canInsertSemicolon() && this.eat(types$1.arrow)) {
       this.checkPatternErrors(refDestructuringErrors, false);
       this.checkYieldAwaitInDefaultParams();
       this.yieldPos = oldYieldPos;
@@ -19055,12 +19104,12 @@ pp$4.parseParenAndDistinguishExpression = function(canBeArrow, forInit) {
   }
 };
 
-pp$4.parseParenItem = function(item) {
+pp$5.parseParenItem = function(item) {
   return item
 };
 
-pp$4.parseParenArrowList = function(startPos, startLoc, exprList, forInit) {
-  return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), exprList, forInit)
+pp$5.parseParenArrowList = function(startPos, startLoc, exprList, forInit) {
+  return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), exprList, false, forInit)
 };
 
 // New's precedence is slightly tricky. It must allow its argument to
@@ -19069,13 +19118,13 @@ pp$4.parseParenArrowList = function(startPos, startLoc, exprList, forInit) {
 // argument to parseSubscripts to prevent it from consuming the
 // argument list.
 
-var empty$1 = [];
+var empty = [];
 
-pp$4.parseNew = function() {
+pp$5.parseNew = function() {
   if (this.containsEsc) { this.raiseRecoverable(this.start, "Escape sequence in keyword new"); }
   var node = this.startNode();
   var meta = this.parseIdent(true);
-  if (this.options.ecmaVersion >= 6 && this.eat(types.dot)) {
+  if (this.options.ecmaVersion >= 6 && this.eat(types$1.dot)) {
     node.meta = meta;
     var containsEsc = this.containsEsc;
     node.property = this.parseIdent(true);
@@ -19087,23 +19136,23 @@ pp$4.parseNew = function() {
       { this.raiseRecoverable(node.start, "'new.target' can only be used in functions and class static block"); }
     return this.finishNode(node, "MetaProperty")
   }
-  var startPos = this.start, startLoc = this.startLoc, isImport = this.type === types._import;
+  var startPos = this.start, startLoc = this.startLoc, isImport = this.type === types$1._import;
   node.callee = this.parseSubscripts(this.parseExprAtom(), startPos, startLoc, true, false);
   if (isImport && node.callee.type === "ImportExpression") {
     this.raise(startPos, "Cannot use new with import()");
   }
-  if (this.eat(types.parenL)) { node.arguments = this.parseExprList(types.parenR, this.options.ecmaVersion >= 8, false); }
-  else { node.arguments = empty$1; }
+  if (this.eat(types$1.parenL)) { node.arguments = this.parseExprList(types$1.parenR, this.options.ecmaVersion >= 8, false); }
+  else { node.arguments = empty; }
   return this.finishNode(node, "NewExpression")
 };
 
 // Parse template expression.
 
-pp$4.parseTemplateElement = function(ref) {
+pp$5.parseTemplateElement = function(ref) {
   var isTagged = ref.isTagged;
 
   var elem = this.startNode();
-  if (this.type === types.invalidTemplate) {
+  if (this.type === types$1.invalidTemplate) {
     if (!isTagged) {
       this.raiseRecoverable(this.start, "Bad escape sequence in untagged template literal");
     }
@@ -19118,11 +19167,11 @@ pp$4.parseTemplateElement = function(ref) {
     };
   }
   this.next();
-  elem.tail = this.type === types.backQuote;
+  elem.tail = this.type === types$1.backQuote;
   return this.finishNode(elem, "TemplateElement")
 };
 
-pp$4.parseTemplate = function(ref) {
+pp$5.parseTemplate = function(ref) {
   if ( ref === void 0 ) ref = {};
   var isTagged = ref.isTagged; if ( isTagged === void 0 ) isTagged = false;
 
@@ -19132,32 +19181,32 @@ pp$4.parseTemplate = function(ref) {
   var curElt = this.parseTemplateElement({isTagged: isTagged});
   node.quasis = [curElt];
   while (!curElt.tail) {
-    if (this.type === types.eof) { this.raise(this.pos, "Unterminated template literal"); }
-    this.expect(types.dollarBraceL);
+    if (this.type === types$1.eof) { this.raise(this.pos, "Unterminated template literal"); }
+    this.expect(types$1.dollarBraceL);
     node.expressions.push(this.parseExpression());
-    this.expect(types.braceR);
+    this.expect(types$1.braceR);
     node.quasis.push(curElt = this.parseTemplateElement({isTagged: isTagged}));
   }
   this.next();
   return this.finishNode(node, "TemplateLiteral")
 };
 
-pp$4.isAsyncProp = function(prop) {
+pp$5.isAsyncProp = function(prop) {
   return !prop.computed && prop.key.type === "Identifier" && prop.key.name === "async" &&
-    (this.type === types.name || this.type === types.num || this.type === types.string || this.type === types.bracketL || this.type.keyword || (this.options.ecmaVersion >= 9 && this.type === types.star)) &&
+    (this.type === types$1.name || this.type === types$1.num || this.type === types$1.string || this.type === types$1.bracketL || this.type.keyword || (this.options.ecmaVersion >= 9 && this.type === types$1.star)) &&
     !lineBreak.test(this.input.slice(this.lastTokEnd, this.start))
 };
 
 // Parse an object literal or binding pattern.
 
-pp$4.parseObj = function(isPattern, refDestructuringErrors) {
+pp$5.parseObj = function(isPattern, refDestructuringErrors) {
   var node = this.startNode(), first = true, propHash = {};
   node.properties = [];
   this.next();
-  while (!this.eat(types.braceR)) {
+  while (!this.eat(types$1.braceR)) {
     if (!first) {
-      this.expect(types.comma);
-      if (this.options.ecmaVersion >= 5 && this.afterTrailingComma(types.braceR)) { break }
+      this.expect(types$1.comma);
+      if (this.options.ecmaVersion >= 5 && this.afterTrailingComma(types$1.braceR)) { break }
     } else { first = false; }
 
     var prop = this.parseProperty(isPattern, refDestructuringErrors);
@@ -19167,18 +19216,18 @@ pp$4.parseObj = function(isPattern, refDestructuringErrors) {
   return this.finishNode(node, isPattern ? "ObjectPattern" : "ObjectExpression")
 };
 
-pp$4.parseProperty = function(isPattern, refDestructuringErrors) {
+pp$5.parseProperty = function(isPattern, refDestructuringErrors) {
   var prop = this.startNode(), isGenerator, isAsync, startPos, startLoc;
-  if (this.options.ecmaVersion >= 9 && this.eat(types.ellipsis)) {
+  if (this.options.ecmaVersion >= 9 && this.eat(types$1.ellipsis)) {
     if (isPattern) {
       prop.argument = this.parseIdent(false);
-      if (this.type === types.comma) {
+      if (this.type === types$1.comma) {
         this.raise(this.start, "Comma is not permitted after the rest element");
       }
       return this.finishNode(prop, "RestElement")
     }
     // To disallow parenthesized identifier via `this.toAssignable()`.
-    if (this.type === types.parenL && refDestructuringErrors) {
+    if (this.type === types$1.parenL && refDestructuringErrors) {
       if (refDestructuringErrors.parenthesizedAssign < 0) {
         refDestructuringErrors.parenthesizedAssign = this.start;
       }
@@ -19189,7 +19238,7 @@ pp$4.parseProperty = function(isPattern, refDestructuringErrors) {
     // Parse argument.
     prop.argument = this.parseMaybeAssign(false, refDestructuringErrors);
     // To disallow trailing comma via `this.toAssignable()`.
-    if (this.type === types.comma && refDestructuringErrors && refDestructuringErrors.trailingComma < 0) {
+    if (this.type === types$1.comma && refDestructuringErrors && refDestructuringErrors.trailingComma < 0) {
       refDestructuringErrors.trailingComma = this.start;
     }
     // Finish
@@ -19203,13 +19252,13 @@ pp$4.parseProperty = function(isPattern, refDestructuringErrors) {
       startLoc = this.startLoc;
     }
     if (!isPattern)
-      { isGenerator = this.eat(types.star); }
+      { isGenerator = this.eat(types$1.star); }
   }
   var containsEsc = this.containsEsc;
   this.parsePropertyName(prop);
   if (!isPattern && !containsEsc && this.options.ecmaVersion >= 8 && !isGenerator && this.isAsyncProp(prop)) {
     isAsync = true;
-    isGenerator = this.options.ecmaVersion >= 9 && this.eat(types.star);
+    isGenerator = this.options.ecmaVersion >= 9 && this.eat(types$1.star);
     this.parsePropertyName(prop, refDestructuringErrors);
   } else {
     isAsync = false;
@@ -19218,14 +19267,14 @@ pp$4.parseProperty = function(isPattern, refDestructuringErrors) {
   return this.finishNode(prop, "Property")
 };
 
-pp$4.parsePropertyValue = function(prop, isPattern, isGenerator, isAsync, startPos, startLoc, refDestructuringErrors, containsEsc) {
-  if ((isGenerator || isAsync) && this.type === types.colon)
+pp$5.parsePropertyValue = function(prop, isPattern, isGenerator, isAsync, startPos, startLoc, refDestructuringErrors, containsEsc) {
+  if ((isGenerator || isAsync) && this.type === types$1.colon)
     { this.unexpected(); }
 
-  if (this.eat(types.colon)) {
+  if (this.eat(types$1.colon)) {
     prop.value = isPattern ? this.parseMaybeDefault(this.start, this.startLoc) : this.parseMaybeAssign(false, refDestructuringErrors);
     prop.kind = "init";
-  } else if (this.options.ecmaVersion >= 6 && this.type === types.parenL) {
+  } else if (this.options.ecmaVersion >= 6 && this.type === types$1.parenL) {
     if (isPattern) { this.unexpected(); }
     prop.kind = "init";
     prop.method = true;
@@ -19233,7 +19282,7 @@ pp$4.parsePropertyValue = function(prop, isPattern, isGenerator, isAsync, startP
   } else if (!isPattern && !containsEsc &&
              this.options.ecmaVersion >= 5 && !prop.computed && prop.key.type === "Identifier" &&
              (prop.key.name === "get" || prop.key.name === "set") &&
-             (this.type !== types.comma && this.type !== types.braceR && this.type !== types.eq)) {
+             (this.type !== types$1.comma && this.type !== types$1.braceR && this.type !== types$1.eq)) {
     if (isGenerator || isAsync) { this.unexpected(); }
     prop.kind = prop.key.name;
     this.parsePropertyName(prop);
@@ -19257,7 +19306,7 @@ pp$4.parsePropertyValue = function(prop, isPattern, isGenerator, isAsync, startP
     prop.kind = "init";
     if (isPattern) {
       prop.value = this.parseMaybeDefault(startPos, startLoc, this.copyNode(prop.key));
-    } else if (this.type === types.eq && refDestructuringErrors) {
+    } else if (this.type === types$1.eq && refDestructuringErrors) {
       if (refDestructuringErrors.shorthandAssign < 0)
         { refDestructuringErrors.shorthandAssign = this.start; }
       prop.value = this.parseMaybeDefault(startPos, startLoc, this.copyNode(prop.key));
@@ -19268,23 +19317,23 @@ pp$4.parsePropertyValue = function(prop, isPattern, isGenerator, isAsync, startP
   } else { this.unexpected(); }
 };
 
-pp$4.parsePropertyName = function(prop) {
+pp$5.parsePropertyName = function(prop) {
   if (this.options.ecmaVersion >= 6) {
-    if (this.eat(types.bracketL)) {
+    if (this.eat(types$1.bracketL)) {
       prop.computed = true;
       prop.key = this.parseMaybeAssign();
-      this.expect(types.bracketR);
+      this.expect(types$1.bracketR);
       return prop.key
     } else {
       prop.computed = false;
     }
   }
-  return prop.key = this.type === types.num || this.type === types.string ? this.parseExprAtom() : this.parseIdent(this.options.allowReserved !== "never")
+  return prop.key = this.type === types$1.num || this.type === types$1.string ? this.parseExprAtom() : this.parseIdent(this.options.allowReserved !== "never")
 };
 
 // Initialize empty function node.
 
-pp$4.initFunction = function(node) {
+pp$5.initFunction = function(node) {
   node.id = null;
   if (this.options.ecmaVersion >= 6) { node.generator = node.expression = false; }
   if (this.options.ecmaVersion >= 8) { node.async = false; }
@@ -19292,7 +19341,7 @@ pp$4.initFunction = function(node) {
 
 // Parse object or class method.
 
-pp$4.parseMethod = function(isGenerator, isAsync, allowDirectSuper) {
+pp$5.parseMethod = function(isGenerator, isAsync, allowDirectSuper) {
   var node = this.startNode(), oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;
 
   this.initFunction(node);
@@ -19306,8 +19355,8 @@ pp$4.parseMethod = function(isGenerator, isAsync, allowDirectSuper) {
   this.awaitIdentPos = 0;
   this.enterScope(functionFlags(isAsync, node.generator) | SCOPE_SUPER | (allowDirectSuper ? SCOPE_DIRECT_SUPER : 0));
 
-  this.expect(types.parenL);
-  node.params = this.parseBindingList(types.parenR, false, this.options.ecmaVersion >= 8);
+  this.expect(types$1.parenL);
+  node.params = this.parseBindingList(types$1.parenR, false, this.options.ecmaVersion >= 8);
   this.checkYieldAwaitInDefaultParams();
   this.parseFunctionBody(node, false, true, false);
 
@@ -19319,7 +19368,7 @@ pp$4.parseMethod = function(isGenerator, isAsync, allowDirectSuper) {
 
 // Parse arrow function expression with given parameters.
 
-pp$4.parseArrowExpression = function(node, params, isAsync, forInit) {
+pp$5.parseArrowExpression = function(node, params, isAsync, forInit) {
   var oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;
 
   this.enterScope(functionFlags(isAsync, false) | SCOPE_ARROW);
@@ -19341,8 +19390,8 @@ pp$4.parseArrowExpression = function(node, params, isAsync, forInit) {
 
 // Parse function body and check parameters.
 
-pp$4.parseFunctionBody = function(node, isArrowFunction, isMethod, forInit) {
-  var isExpression = isArrowFunction && this.type !== types.braceL;
+pp$5.parseFunctionBody = function(node, isArrowFunction, isMethod, forInit) {
+  var isExpression = isArrowFunction && this.type !== types$1.braceL;
   var oldStrict = this.strict, useStrict = false;
 
   if (isExpression) {
@@ -19378,7 +19427,7 @@ pp$4.parseFunctionBody = function(node, isArrowFunction, isMethod, forInit) {
   this.exitScope();
 };
 
-pp$4.isSimpleParamList = function(params) {
+pp$5.isSimpleParamList = function(params) {
   for (var i = 0, list = params; i < list.length; i += 1)
     {
     var param = list[i];
@@ -19391,7 +19440,7 @@ pp$4.isSimpleParamList = function(params) {
 // Checks function params for various disallowed patterns such as using "eval"
 // or "arguments" and duplicate parameters.
 
-pp$4.checkParams = function(node, allowDuplicates) {
+pp$5.checkParams = function(node, allowDuplicates) {
   var nameHash = Object.create(null);
   for (var i = 0, list = node.params; i < list.length; i += 1)
     {
@@ -19407,20 +19456,20 @@ pp$4.checkParams = function(node, allowDuplicates) {
 // nothing in between them to be parsed as `null` (which is needed
 // for array literals).
 
-pp$4.parseExprList = function(close, allowTrailingComma, allowEmpty, refDestructuringErrors) {
+pp$5.parseExprList = function(close, allowTrailingComma, allowEmpty, refDestructuringErrors) {
   var elts = [], first = true;
   while (!this.eat(close)) {
     if (!first) {
-      this.expect(types.comma);
+      this.expect(types$1.comma);
       if (allowTrailingComma && this.afterTrailingComma(close)) { break }
     } else { first = false; }
 
     var elt = (void 0);
-    if (allowEmpty && this.type === types.comma)
+    if (allowEmpty && this.type === types$1.comma)
       { elt = null; }
-    else if (this.type === types.ellipsis) {
+    else if (this.type === types$1.ellipsis) {
       elt = this.parseSpread(refDestructuringErrors);
-      if (refDestructuringErrors && this.type === types.comma && refDestructuringErrors.trailingComma < 0)
+      if (refDestructuringErrors && this.type === types$1.comma && refDestructuringErrors.trailingComma < 0)
         { refDestructuringErrors.trailingComma = this.start; }
     } else {
       elt = this.parseMaybeAssign(false, refDestructuringErrors);
@@ -19430,7 +19479,7 @@ pp$4.parseExprList = function(close, allowTrailingComma, allowEmpty, refDestruct
   return elts
 };
 
-pp$4.checkUnreserved = function(ref) {
+pp$5.checkUnreserved = function(ref) {
   var start = ref.start;
   var end = ref.end;
   var name = ref.name;
@@ -19459,9 +19508,9 @@ pp$4.checkUnreserved = function(ref) {
 // when parsing properties), it will also convert keywords into
 // identifiers.
 
-pp$4.parseIdent = function(liberal, isBinding) {
+pp$5.parseIdent = function(liberal, isBinding) {
   var node = this.startNode();
-  if (this.type === types.name) {
+  if (this.type === types$1.name) {
     node.name = this.value;
   } else if (this.type.keyword) {
     node.name = this.type.keyword;
@@ -19487,9 +19536,9 @@ pp$4.parseIdent = function(liberal, isBinding) {
   return node
 };
 
-pp$4.parsePrivateIdent = function() {
+pp$5.parsePrivateIdent = function() {
   var node = this.startNode();
-  if (this.type === types.privateId) {
+  if (this.type === types$1.privateId) {
     node.name = this.value;
   } else {
     this.unexpected();
@@ -19509,22 +19558,22 @@ pp$4.parsePrivateIdent = function() {
 
 // Parses yield expression inside generator.
 
-pp$4.parseYield = function(forInit) {
+pp$5.parseYield = function(forInit) {
   if (!this.yieldPos) { this.yieldPos = this.start; }
 
   var node = this.startNode();
   this.next();
-  if (this.type === types.semi || this.canInsertSemicolon() || (this.type !== types.star && !this.type.startsExpr)) {
+  if (this.type === types$1.semi || this.canInsertSemicolon() || (this.type !== types$1.star && !this.type.startsExpr)) {
     node.delegate = false;
     node.argument = null;
   } else {
-    node.delegate = this.eat(types.star);
+    node.delegate = this.eat(types$1.star);
     node.argument = this.parseMaybeAssign(forInit);
   }
   return this.finishNode(node, "YieldExpression")
 };
 
-pp$4.parseAwait = function(forInit) {
+pp$5.parseAwait = function(forInit) {
   if (!this.awaitPos) { this.awaitPos = this.start; }
 
   var node = this.startNode();
@@ -19533,7 +19582,7 @@ pp$4.parseAwait = function(forInit) {
   return this.finishNode(node, "AwaitExpression")
 };
 
-var pp$5 = Parser.prototype;
+var pp$4 = Parser.prototype;
 
 // This function is used to raise exceptions on parse errors. It
 // takes an offset integer (into the current `input`) to indicate
@@ -19541,7 +19590,7 @@ var pp$5 = Parser.prototype;
 // of the error message, and then raises a `SyntaxError` with that
 // message.
 
-pp$5.raise = function(pos, message) {
+pp$4.raise = function(pos, message) {
   var loc = getLineInfo(this.input, pos);
   message += " (" + loc.line + ":" + loc.column + ")";
   var err = new SyntaxError(message);
@@ -19549,15 +19598,15 @@ pp$5.raise = function(pos, message) {
   throw err
 };
 
-pp$5.raiseRecoverable = pp$5.raise;
+pp$4.raiseRecoverable = pp$4.raise;
 
-pp$5.curPosition = function() {
+pp$4.curPosition = function() {
   if (this.options.locations) {
     return new Position(this.curLine, this.pos - this.lineStart)
   }
 };
 
-var pp$6 = Parser.prototype;
+var pp$3 = Parser.prototype;
 
 var Scope = function Scope(flags) {
   this.flags = flags;
@@ -19573,22 +19622,22 @@ var Scope = function Scope(flags) {
 
 // The functions in this module keep track of declared variables in the current scope in order to detect duplicate variable names.
 
-pp$6.enterScope = function(flags) {
+pp$3.enterScope = function(flags) {
   this.scopeStack.push(new Scope(flags));
 };
 
-pp$6.exitScope = function() {
+pp$3.exitScope = function() {
   this.scopeStack.pop();
 };
 
 // The spec says:
 // > At the top level of a function, or script, function declarations are
 // > treated like var declarations rather than like lexical declarations.
-pp$6.treatFunctionsAsVarInScope = function(scope) {
+pp$3.treatFunctionsAsVarInScope = function(scope) {
   return (scope.flags & SCOPE_FUNCTION) || !this.inModule && (scope.flags & SCOPE_TOP)
 };
 
-pp$6.declareName = function(name, bindingType, pos) {
+pp$3.declareName = function(name, bindingType, pos) {
   var redeclared = false;
   if (bindingType === BIND_LEXICAL) {
     var scope = this.currentScope();
@@ -19623,7 +19672,7 @@ pp$6.declareName = function(name, bindingType, pos) {
   if (redeclared) { this.raiseRecoverable(pos, ("Identifier '" + name + "' has already been declared")); }
 };
 
-pp$6.checkLocalExport = function(id) {
+pp$3.checkLocalExport = function(id) {
   // scope.functions must be empty as Module code is always strict.
   if (this.scopeStack[0].lexical.indexOf(id.name) === -1 &&
       this.scopeStack[0].var.indexOf(id.name) === -1) {
@@ -19631,11 +19680,11 @@ pp$6.checkLocalExport = function(id) {
   }
 };
 
-pp$6.currentScope = function() {
+pp$3.currentScope = function() {
   return this.scopeStack[this.scopeStack.length - 1]
 };
 
-pp$6.currentVarScope = function() {
+pp$3.currentVarScope = function() {
   for (var i = this.scopeStack.length - 1;; i--) {
     var scope = this.scopeStack[i];
     if (scope.flags & SCOPE_VAR) { return scope }
@@ -19643,7 +19692,7 @@ pp$6.currentVarScope = function() {
 };
 
 // Could be useful for `this`, `new.target`, `super()`, `super.property`, and `super[property]`.
-pp$6.currentThisScope = function() {
+pp$3.currentThisScope = function() {
   for (var i = this.scopeStack.length - 1;; i--) {
     var scope = this.scopeStack[i];
     if (scope.flags & SCOPE_VAR && !(scope.flags & SCOPE_ARROW)) { return scope }
@@ -19664,13 +19713,13 @@ var Node = function Node(parser, pos, loc) {
 
 // Start an AST node, attaching a start offset.
 
-var pp$7 = Parser.prototype;
+var pp$2 = Parser.prototype;
 
-pp$7.startNode = function() {
+pp$2.startNode = function() {
   return new Node(this, this.start, this.startLoc)
 };
 
-pp$7.startNodeAt = function(pos, loc) {
+pp$2.startNodeAt = function(pos, loc) {
   return new Node(this, pos, loc)
 };
 
@@ -19686,17 +19735,17 @@ function finishNodeAt(node, type, pos, loc) {
   return node
 }
 
-pp$7.finishNode = function(node, type) {
+pp$2.finishNode = function(node, type) {
   return finishNodeAt.call(this, node, type, this.lastTokEnd, this.lastTokEndLoc)
 };
 
 // Finish node at given position
 
-pp$7.finishNodeAt = function(node, type, pos, loc) {
+pp$2.finishNodeAt = function(node, type, pos, loc) {
   return finishNodeAt.call(this, node, type, pos, loc)
 };
 
-pp$7.copyNode = function(node) {
+pp$2.copyNode = function(node) {
   var newNode = new Node(this, node.start, this.startLoc);
   for (var prop in node) { newNode[prop] = node[prop]; }
   return newNode
@@ -19753,7 +19802,7 @@ buildUnicodeData(10);
 buildUnicodeData(11);
 buildUnicodeData(12);
 
-var pp$8 = Parser.prototype;
+var pp$1 = Parser.prototype;
 
 var RegExpValidationState = function RegExpValidationState(parser) {
   this.parser = parser;
@@ -19849,7 +19898,7 @@ RegExpValidationState.prototype.eat = function eat (ch, forceU) {
   return false
 };
 
-function codePointToString(ch) {
+function codePointToString$1(ch) {
   if (ch <= 0xFFFF) { return String.fromCharCode(ch) }
   ch -= 0x10000;
   return String.fromCharCode((ch >> 10) + 0xD800, (ch & 0x03FF) + 0xDC00)
@@ -19861,7 +19910,7 @@ function codePointToString(ch) {
  * @param {RegExpValidationState} state The state to validate RegExp.
  * @returns {void}
  */
-pp$8.validateRegExpFlags = function(state) {
+pp$1.validateRegExpFlags = function(state) {
   var validFlags = state.validFlags;
   var flags = state.flags;
 
@@ -19882,7 +19931,7 @@ pp$8.validateRegExpFlags = function(state) {
  * @param {RegExpValidationState} state The state to validate RegExp.
  * @returns {void}
  */
-pp$8.validateRegExpPattern = function(state) {
+pp$1.validateRegExpPattern = function(state) {
   this.regexp_pattern(state);
 
   // The goal symbol for the parse is |Pattern[~U, ~N]|. If the result of
@@ -19897,7 +19946,7 @@ pp$8.validateRegExpPattern = function(state) {
 };
 
 // https://www.ecma-international.org/ecma-262/8.0/#prod-Pattern
-pp$8.regexp_pattern = function(state) {
+pp$1.regexp_pattern = function(state) {
   state.pos = 0;
   state.lastIntValue = 0;
   state.lastStringValue = "";
@@ -19931,7 +19980,7 @@ pp$8.regexp_pattern = function(state) {
 };
 
 // https://www.ecma-international.org/ecma-262/8.0/#prod-Disjunction
-pp$8.regexp_disjunction = function(state) {
+pp$1.regexp_disjunction = function(state) {
   this.regexp_alternative(state);
   while (state.eat(0x7C /* | */)) {
     this.regexp_alternative(state);
@@ -19947,13 +19996,13 @@ pp$8.regexp_disjunction = function(state) {
 };
 
 // https://www.ecma-international.org/ecma-262/8.0/#prod-Alternative
-pp$8.regexp_alternative = function(state) {
+pp$1.regexp_alternative = function(state) {
   while (state.pos < state.source.length && this.regexp_eatTerm(state))
     { }
 };
 
 // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-Term
-pp$8.regexp_eatTerm = function(state) {
+pp$1.regexp_eatTerm = function(state) {
   if (this.regexp_eatAssertion(state)) {
     // Handle `QuantifiableAssertion Quantifier` alternative.
     // `state.lastAssertionIsQuantifiable` is true if the last eaten Assertion
@@ -19976,7 +20025,7 @@ pp$8.regexp_eatTerm = function(state) {
 };
 
 // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-Assertion
-pp$8.regexp_eatAssertion = function(state) {
+pp$1.regexp_eatAssertion = function(state) {
   var start = state.pos;
   state.lastAssertionIsQuantifiable = false;
 
@@ -20014,7 +20063,7 @@ pp$8.regexp_eatAssertion = function(state) {
 };
 
 // https://www.ecma-international.org/ecma-262/8.0/#prod-Quantifier
-pp$8.regexp_eatQuantifier = function(state, noError) {
+pp$1.regexp_eatQuantifier = function(state, noError) {
   if ( noError === void 0 ) noError = false;
 
   if (this.regexp_eatQuantifierPrefix(state, noError)) {
@@ -20025,7 +20074,7 @@ pp$8.regexp_eatQuantifier = function(state, noError) {
 };
 
 // https://www.ecma-international.org/ecma-262/8.0/#prod-QuantifierPrefix
-pp$8.regexp_eatQuantifierPrefix = function(state, noError) {
+pp$1.regexp_eatQuantifierPrefix = function(state, noError) {
   return (
     state.eat(0x2A /* * */) ||
     state.eat(0x2B /* + */) ||
@@ -20033,7 +20082,7 @@ pp$8.regexp_eatQuantifierPrefix = function(state, noError) {
     this.regexp_eatBracedQuantifier(state, noError)
   )
 };
-pp$8.regexp_eatBracedQuantifier = function(state, noError) {
+pp$1.regexp_eatBracedQuantifier = function(state, noError) {
   var start = state.pos;
   if (state.eat(0x7B /* { */)) {
     var min = 0, max = -1;
@@ -20059,7 +20108,7 @@ pp$8.regexp_eatBracedQuantifier = function(state, noError) {
 };
 
 // https://www.ecma-international.org/ecma-262/8.0/#prod-Atom
-pp$8.regexp_eatAtom = function(state) {
+pp$1.regexp_eatAtom = function(state) {
   return (
     this.regexp_eatPatternCharacters(state) ||
     state.eat(0x2E /* . */) ||
@@ -20069,7 +20118,7 @@ pp$8.regexp_eatAtom = function(state) {
     this.regexp_eatCapturingGroup(state)
   )
 };
-pp$8.regexp_eatReverseSolidusAtomEscape = function(state) {
+pp$1.regexp_eatReverseSolidusAtomEscape = function(state) {
   var start = state.pos;
   if (state.eat(0x5C /* \ */)) {
     if (this.regexp_eatAtomEscape(state)) {
@@ -20079,7 +20128,7 @@ pp$8.regexp_eatReverseSolidusAtomEscape = function(state) {
   }
   return false
 };
-pp$8.regexp_eatUncapturingGroup = function(state) {
+pp$1.regexp_eatUncapturingGroup = function(state) {
   var start = state.pos;
   if (state.eat(0x28 /* ( */)) {
     if (state.eat(0x3F /* ? */) && state.eat(0x3A /* : */)) {
@@ -20093,7 +20142,7 @@ pp$8.regexp_eatUncapturingGroup = function(state) {
   }
   return false
 };
-pp$8.regexp_eatCapturingGroup = function(state) {
+pp$1.regexp_eatCapturingGroup = function(state) {
   if (state.eat(0x28 /* ( */)) {
     if (this.options.ecmaVersion >= 9) {
       this.regexp_groupSpecifier(state);
@@ -20111,7 +20160,7 @@ pp$8.regexp_eatCapturingGroup = function(state) {
 };
 
 // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ExtendedAtom
-pp$8.regexp_eatExtendedAtom = function(state) {
+pp$1.regexp_eatExtendedAtom = function(state) {
   return (
     state.eat(0x2E /* . */) ||
     this.regexp_eatReverseSolidusAtomEscape(state) ||
@@ -20124,7 +20173,7 @@ pp$8.regexp_eatExtendedAtom = function(state) {
 };
 
 // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-InvalidBracedQuantifier
-pp$8.regexp_eatInvalidBracedQuantifier = function(state) {
+pp$1.regexp_eatInvalidBracedQuantifier = function(state) {
   if (this.regexp_eatBracedQuantifier(state, true)) {
     state.raise("Nothing to repeat");
   }
@@ -20132,7 +20181,7 @@ pp$8.regexp_eatInvalidBracedQuantifier = function(state) {
 };
 
 // https://www.ecma-international.org/ecma-262/8.0/#prod-SyntaxCharacter
-pp$8.regexp_eatSyntaxCharacter = function(state) {
+pp$1.regexp_eatSyntaxCharacter = function(state) {
   var ch = state.current();
   if (isSyntaxCharacter(ch)) {
     state.lastIntValue = ch;
@@ -20154,7 +20203,7 @@ function isSyntaxCharacter(ch) {
 
 // https://www.ecma-international.org/ecma-262/8.0/#prod-PatternCharacter
 // But eat eager.
-pp$8.regexp_eatPatternCharacters = function(state) {
+pp$1.regexp_eatPatternCharacters = function(state) {
   var start = state.pos;
   var ch = 0;
   while ((ch = state.current()) !== -1 && !isSyntaxCharacter(ch)) {
@@ -20164,7 +20213,7 @@ pp$8.regexp_eatPatternCharacters = function(state) {
 };
 
 // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ExtendedPatternCharacter
-pp$8.regexp_eatExtendedPatternCharacter = function(state) {
+pp$1.regexp_eatExtendedPatternCharacter = function(state) {
   var ch = state.current();
   if (
     ch !== -1 &&
@@ -20185,7 +20234,7 @@ pp$8.regexp_eatExtendedPatternCharacter = function(state) {
 // GroupSpecifier ::
 //   [empty]
 //   `?` GroupName
-pp$8.regexp_groupSpecifier = function(state) {
+pp$1.regexp_groupSpecifier = function(state) {
   if (state.eat(0x3F /* ? */)) {
     if (this.regexp_eatGroupName(state)) {
       if (state.groupNames.indexOf(state.lastStringValue) !== -1) {
@@ -20201,7 +20250,7 @@ pp$8.regexp_groupSpecifier = function(state) {
 // GroupName ::
 //   `<` RegExpIdentifierName `>`
 // Note: this updates `state.lastStringValue` property with the eaten name.
-pp$8.regexp_eatGroupName = function(state) {
+pp$1.regexp_eatGroupName = function(state) {
   state.lastStringValue = "";
   if (state.eat(0x3C /* < */)) {
     if (this.regexp_eatRegExpIdentifierName(state) && state.eat(0x3E /* > */)) {
@@ -20216,12 +20265,12 @@ pp$8.regexp_eatGroupName = function(state) {
 //   RegExpIdentifierStart
 //   RegExpIdentifierName RegExpIdentifierPart
 // Note: this updates `state.lastStringValue` property with the eaten name.
-pp$8.regexp_eatRegExpIdentifierName = function(state) {
+pp$1.regexp_eatRegExpIdentifierName = function(state) {
   state.lastStringValue = "";
   if (this.regexp_eatRegExpIdentifierStart(state)) {
-    state.lastStringValue += codePointToString(state.lastIntValue);
+    state.lastStringValue += codePointToString$1(state.lastIntValue);
     while (this.regexp_eatRegExpIdentifierPart(state)) {
-      state.lastStringValue += codePointToString(state.lastIntValue);
+      state.lastStringValue += codePointToString$1(state.lastIntValue);
     }
     return true
   }
@@ -20233,7 +20282,7 @@ pp$8.regexp_eatRegExpIdentifierName = function(state) {
 //   `$`
 //   `_`
 //   `\` RegExpUnicodeEscapeSequence[+U]
-pp$8.regexp_eatRegExpIdentifierStart = function(state) {
+pp$1.regexp_eatRegExpIdentifierStart = function(state) {
   var start = state.pos;
   var forceU = this.options.ecmaVersion >= 11;
   var ch = state.current(forceU);
@@ -20261,7 +20310,7 @@ function isRegExpIdentifierStart(ch) {
 //   `\` RegExpUnicodeEscapeSequence[+U]
 //   <ZWNJ>
 //   <ZWJ>
-pp$8.regexp_eatRegExpIdentifierPart = function(state) {
+pp$1.regexp_eatRegExpIdentifierPart = function(state) {
   var start = state.pos;
   var forceU = this.options.ecmaVersion >= 11;
   var ch = state.current(forceU);
@@ -20283,7 +20332,7 @@ function isRegExpIdentifierPart(ch) {
 }
 
 // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-AtomEscape
-pp$8.regexp_eatAtomEscape = function(state) {
+pp$1.regexp_eatAtomEscape = function(state) {
   if (
     this.regexp_eatBackReference(state) ||
     this.regexp_eatCharacterClassEscape(state) ||
@@ -20301,7 +20350,7 @@ pp$8.regexp_eatAtomEscape = function(state) {
   }
   return false
 };
-pp$8.regexp_eatBackReference = function(state) {
+pp$1.regexp_eatBackReference = function(state) {
   var start = state.pos;
   if (this.regexp_eatDecimalEscape(state)) {
     var n = state.lastIntValue;
@@ -20319,7 +20368,7 @@ pp$8.regexp_eatBackReference = function(state) {
   }
   return false
 };
-pp$8.regexp_eatKGroupName = function(state) {
+pp$1.regexp_eatKGroupName = function(state) {
   if (state.eat(0x6B /* k */)) {
     if (this.regexp_eatGroupName(state)) {
       state.backReferenceNames.push(state.lastStringValue);
@@ -20331,7 +20380,7 @@ pp$8.regexp_eatKGroupName = function(state) {
 };
 
 // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-CharacterEscape
-pp$8.regexp_eatCharacterEscape = function(state) {
+pp$1.regexp_eatCharacterEscape = function(state) {
   return (
     this.regexp_eatControlEscape(state) ||
     this.regexp_eatCControlLetter(state) ||
@@ -20342,7 +20391,7 @@ pp$8.regexp_eatCharacterEscape = function(state) {
     this.regexp_eatIdentityEscape(state)
   )
 };
-pp$8.regexp_eatCControlLetter = function(state) {
+pp$1.regexp_eatCControlLetter = function(state) {
   var start = state.pos;
   if (state.eat(0x63 /* c */)) {
     if (this.regexp_eatControlLetter(state)) {
@@ -20352,7 +20401,7 @@ pp$8.regexp_eatCControlLetter = function(state) {
   }
   return false
 };
-pp$8.regexp_eatZero = function(state) {
+pp$1.regexp_eatZero = function(state) {
   if (state.current() === 0x30 /* 0 */ && !isDecimalDigit(state.lookahead())) {
     state.lastIntValue = 0;
     state.advance();
@@ -20362,7 +20411,7 @@ pp$8.regexp_eatZero = function(state) {
 };
 
 // https://www.ecma-international.org/ecma-262/8.0/#prod-ControlEscape
-pp$8.regexp_eatControlEscape = function(state) {
+pp$1.regexp_eatControlEscape = function(state) {
   var ch = state.current();
   if (ch === 0x74 /* t */) {
     state.lastIntValue = 0x09; /* \t */
@@ -20393,7 +20442,7 @@ pp$8.regexp_eatControlEscape = function(state) {
 };
 
 // https://www.ecma-international.org/ecma-262/8.0/#prod-ControlLetter
-pp$8.regexp_eatControlLetter = function(state) {
+pp$1.regexp_eatControlLetter = function(state) {
   var ch = state.current();
   if (isControlLetter(ch)) {
     state.lastIntValue = ch % 0x20;
@@ -20410,7 +20459,7 @@ function isControlLetter(ch) {
 }
 
 // https://www.ecma-international.org/ecma-262/8.0/#prod-RegExpUnicodeEscapeSequence
-pp$8.regexp_eatRegExpUnicodeEscapeSequence = function(state, forceU) {
+pp$1.regexp_eatRegExpUnicodeEscapeSequence = function(state, forceU) {
   if ( forceU === void 0 ) forceU = false;
 
   var start = state.pos;
@@ -20455,7 +20504,7 @@ function isValidUnicode(ch) {
 }
 
 // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-IdentityEscape
-pp$8.regexp_eatIdentityEscape = function(state) {
+pp$1.regexp_eatIdentityEscape = function(state) {
   if (state.switchU) {
     if (this.regexp_eatSyntaxCharacter(state)) {
       return true
@@ -20478,7 +20527,7 @@ pp$8.regexp_eatIdentityEscape = function(state) {
 };
 
 // https://www.ecma-international.org/ecma-262/8.0/#prod-DecimalEscape
-pp$8.regexp_eatDecimalEscape = function(state) {
+pp$1.regexp_eatDecimalEscape = function(state) {
   state.lastIntValue = 0;
   var ch = state.current();
   if (ch >= 0x31 /* 1 */ && ch <= 0x39 /* 9 */) {
@@ -20492,7 +20541,7 @@ pp$8.regexp_eatDecimalEscape = function(state) {
 };
 
 // https://www.ecma-international.org/ecma-262/8.0/#prod-CharacterClassEscape
-pp$8.regexp_eatCharacterClassEscape = function(state) {
+pp$1.regexp_eatCharacterClassEscape = function(state) {
   var ch = state.current();
 
   if (isCharacterClassEscape(ch)) {
@@ -20534,7 +20583,7 @@ function isCharacterClassEscape(ch) {
 // UnicodePropertyValueExpression ::
 //   UnicodePropertyName `=` UnicodePropertyValue
 //   LoneUnicodePropertyNameOrValue
-pp$8.regexp_eatUnicodePropertyValueExpression = function(state) {
+pp$1.regexp_eatUnicodePropertyValueExpression = function(state) {
   var start = state.pos;
 
   // UnicodePropertyName `=` UnicodePropertyValue
@@ -20556,24 +20605,24 @@ pp$8.regexp_eatUnicodePropertyValueExpression = function(state) {
   }
   return false
 };
-pp$8.regexp_validateUnicodePropertyNameAndValue = function(state, name, value) {
+pp$1.regexp_validateUnicodePropertyNameAndValue = function(state, name, value) {
   if (!has(state.unicodeProperties.nonBinary, name))
     { state.raise("Invalid property name"); }
   if (!state.unicodeProperties.nonBinary[name].test(value))
     { state.raise("Invalid property value"); }
 };
-pp$8.regexp_validateUnicodePropertyNameOrValue = function(state, nameOrValue) {
+pp$1.regexp_validateUnicodePropertyNameOrValue = function(state, nameOrValue) {
   if (!state.unicodeProperties.binary.test(nameOrValue))
     { state.raise("Invalid property name"); }
 };
 
 // UnicodePropertyName ::
 //   UnicodePropertyNameCharacters
-pp$8.regexp_eatUnicodePropertyName = function(state) {
+pp$1.regexp_eatUnicodePropertyName = function(state) {
   var ch = 0;
   state.lastStringValue = "";
   while (isUnicodePropertyNameCharacter(ch = state.current())) {
-    state.lastStringValue += codePointToString(ch);
+    state.lastStringValue += codePointToString$1(ch);
     state.advance();
   }
   return state.lastStringValue !== ""
@@ -20584,11 +20633,11 @@ function isUnicodePropertyNameCharacter(ch) {
 
 // UnicodePropertyValue ::
 //   UnicodePropertyValueCharacters
-pp$8.regexp_eatUnicodePropertyValue = function(state) {
+pp$1.regexp_eatUnicodePropertyValue = function(state) {
   var ch = 0;
   state.lastStringValue = "";
   while (isUnicodePropertyValueCharacter(ch = state.current())) {
-    state.lastStringValue += codePointToString(ch);
+    state.lastStringValue += codePointToString$1(ch);
     state.advance();
   }
   return state.lastStringValue !== ""
@@ -20599,12 +20648,12 @@ function isUnicodePropertyValueCharacter(ch) {
 
 // LoneUnicodePropertyNameOrValue ::
 //   UnicodePropertyValueCharacters
-pp$8.regexp_eatLoneUnicodePropertyNameOrValue = function(state) {
+pp$1.regexp_eatLoneUnicodePropertyNameOrValue = function(state) {
   return this.regexp_eatUnicodePropertyValue(state)
 };
 
 // https://www.ecma-international.org/ecma-262/8.0/#prod-CharacterClass
-pp$8.regexp_eatCharacterClass = function(state) {
+pp$1.regexp_eatCharacterClass = function(state) {
   if (state.eat(0x5B /* [ */)) {
     state.eat(0x5E /* ^ */);
     this.regexp_classRanges(state);
@@ -20620,7 +20669,7 @@ pp$8.regexp_eatCharacterClass = function(state) {
 // https://www.ecma-international.org/ecma-262/8.0/#prod-ClassRanges
 // https://www.ecma-international.org/ecma-262/8.0/#prod-NonemptyClassRanges
 // https://www.ecma-international.org/ecma-262/8.0/#prod-NonemptyClassRangesNoDash
-pp$8.regexp_classRanges = function(state) {
+pp$1.regexp_classRanges = function(state) {
   while (this.regexp_eatClassAtom(state)) {
     var left = state.lastIntValue;
     if (state.eat(0x2D /* - */) && this.regexp_eatClassAtom(state)) {
@@ -20637,7 +20686,7 @@ pp$8.regexp_classRanges = function(state) {
 
 // https://www.ecma-international.org/ecma-262/8.0/#prod-ClassAtom
 // https://www.ecma-international.org/ecma-262/8.0/#prod-ClassAtomNoDash
-pp$8.regexp_eatClassAtom = function(state) {
+pp$1.regexp_eatClassAtom = function(state) {
   var start = state.pos;
 
   if (state.eat(0x5C /* \ */)) {
@@ -20666,7 +20715,7 @@ pp$8.regexp_eatClassAtom = function(state) {
 };
 
 // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ClassEscape
-pp$8.regexp_eatClassEscape = function(state) {
+pp$1.regexp_eatClassEscape = function(state) {
   var start = state.pos;
 
   if (state.eat(0x62 /* b */)) {
@@ -20693,7 +20742,7 @@ pp$8.regexp_eatClassEscape = function(state) {
 };
 
 // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ClassControlLetter
-pp$8.regexp_eatClassControlLetter = function(state) {
+pp$1.regexp_eatClassControlLetter = function(state) {
   var ch = state.current();
   if (isDecimalDigit(ch) || ch === 0x5F /* _ */) {
     state.lastIntValue = ch % 0x20;
@@ -20704,7 +20753,7 @@ pp$8.regexp_eatClassControlLetter = function(state) {
 };
 
 // https://www.ecma-international.org/ecma-262/8.0/#prod-HexEscapeSequence
-pp$8.regexp_eatHexEscapeSequence = function(state) {
+pp$1.regexp_eatHexEscapeSequence = function(state) {
   var start = state.pos;
   if (state.eat(0x78 /* x */)) {
     if (this.regexp_eatFixedHexDigits(state, 2)) {
@@ -20719,7 +20768,7 @@ pp$8.regexp_eatHexEscapeSequence = function(state) {
 };
 
 // https://www.ecma-international.org/ecma-262/8.0/#prod-DecimalDigits
-pp$8.regexp_eatDecimalDigits = function(state) {
+pp$1.regexp_eatDecimalDigits = function(state) {
   var start = state.pos;
   var ch = 0;
   state.lastIntValue = 0;
@@ -20734,7 +20783,7 @@ function isDecimalDigit(ch) {
 }
 
 // https://www.ecma-international.org/ecma-262/8.0/#prod-HexDigits
-pp$8.regexp_eatHexDigits = function(state) {
+pp$1.regexp_eatHexDigits = function(state) {
   var start = state.pos;
   var ch = 0;
   state.lastIntValue = 0;
@@ -20763,7 +20812,7 @@ function hexToInt(ch) {
 
 // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-LegacyOctalEscapeSequence
 // Allows only 0-377(octal) i.e. 0-255(decimal).
-pp$8.regexp_eatLegacyOctalEscapeSequence = function(state) {
+pp$1.regexp_eatLegacyOctalEscapeSequence = function(state) {
   if (this.regexp_eatOctalDigit(state)) {
     var n1 = state.lastIntValue;
     if (this.regexp_eatOctalDigit(state)) {
@@ -20782,7 +20831,7 @@ pp$8.regexp_eatLegacyOctalEscapeSequence = function(state) {
 };
 
 // https://www.ecma-international.org/ecma-262/8.0/#prod-OctalDigit
-pp$8.regexp_eatOctalDigit = function(state) {
+pp$1.regexp_eatOctalDigit = function(state) {
   var ch = state.current();
   if (isOctalDigit(ch)) {
     state.lastIntValue = ch - 0x30; /* 0 */
@@ -20799,7 +20848,7 @@ function isOctalDigit(ch) {
 // https://www.ecma-international.org/ecma-262/8.0/#prod-Hex4Digits
 // https://www.ecma-international.org/ecma-262/8.0/#prod-HexDigit
 // And HexDigit HexDigit in https://www.ecma-international.org/ecma-262/8.0/#prod-HexEscapeSequence
-pp$8.regexp_eatFixedHexDigits = function(state, length) {
+pp$1.regexp_eatFixedHexDigits = function(state, length) {
   var start = state.pos;
   state.lastIntValue = 0;
   for (var i = 0; i < length; ++i) {
@@ -20831,11 +20880,11 @@ var Token = function Token(p) {
 
 // ## Tokenizer
 
-var pp$9 = Parser.prototype;
+var pp = Parser.prototype;
 
 // Move to the next token
 
-pp$9.next = function(ignoreEscapeSequenceInKeyword) {
+pp.next = function(ignoreEscapeSequenceInKeyword) {
   if (!ignoreEscapeSequenceInKeyword && this.type.keyword && this.containsEsc)
     { this.raiseRecoverable(this.start, "Escape sequence in keyword " + this.type.keyword); }
   if (this.options.onToken)
@@ -20848,21 +20897,21 @@ pp$9.next = function(ignoreEscapeSequenceInKeyword) {
   this.nextToken();
 };
 
-pp$9.getToken = function() {
+pp.getToken = function() {
   this.next();
   return new Token(this)
 };
 
 // If we're in an ES6 environment, make parsers iterable
 if (typeof Symbol !== "undefined")
-  { pp$9[Symbol.iterator] = function() {
+  { pp[Symbol.iterator] = function() {
     var this$1$1 = this;
 
     return {
       next: function () {
         var token = this$1$1.getToken();
         return {
-          done: token.type === types.eof,
+          done: token.type === types$1.eof,
           value: token
         }
       }
@@ -20875,19 +20924,19 @@ if (typeof Symbol !== "undefined")
 // Read a single token, updating the parser object's token-related
 // properties.
 
-pp$9.nextToken = function() {
+pp.nextToken = function() {
   var curContext = this.curContext();
   if (!curContext || !curContext.preserveSpace) { this.skipSpace(); }
 
   this.start = this.pos;
   if (this.options.locations) { this.startLoc = this.curPosition(); }
-  if (this.pos >= this.input.length) { return this.finishToken(types.eof) }
+  if (this.pos >= this.input.length) { return this.finishToken(types$1.eof) }
 
   if (curContext.override) { return curContext.override(this) }
   else { this.readToken(this.fullCharCodeAtPos()); }
 };
 
-pp$9.readToken = function(code) {
+pp.readToken = function(code) {
   // Identifier or keyword. '\uXXXX' sequences are allowed in
   // identifiers, so '\' also dispatches to that.
   if (isIdentifierStart(code, this.options.ecmaVersion >= 6) || code === 92 /* '\' */)
@@ -20896,14 +20945,14 @@ pp$9.readToken = function(code) {
   return this.getTokenFromCode(code)
 };
 
-pp$9.fullCharCodeAtPos = function() {
+pp.fullCharCodeAtPos = function() {
   var code = this.input.charCodeAt(this.pos);
   if (code <= 0xd7ff || code >= 0xdc00) { return code }
   var next = this.input.charCodeAt(this.pos + 1);
   return next <= 0xdbff || next >= 0xe000 ? code : (code << 10) + next - 0x35fdc00
 };
 
-pp$9.skipBlockComment = function() {
+pp.skipBlockComment = function() {
   var startLoc = this.options.onComment && this.curPosition();
   var start = this.pos, end = this.input.indexOf("*/", this.pos += 2);
   if (end === -1) { this.raise(this.pos - 2, "Unterminated comment"); }
@@ -20921,7 +20970,7 @@ pp$9.skipBlockComment = function() {
                            startLoc, this.curPosition()); }
 };
 
-pp$9.skipLineComment = function(startSkip) {
+pp.skipLineComment = function(startSkip) {
   var start = this.pos;
   var startLoc = this.options.onComment && this.curPosition();
   var ch = this.input.charCodeAt(this.pos += startSkip);
@@ -20936,7 +20985,7 @@ pp$9.skipLineComment = function(startSkip) {
 // Called at the start of the parse and after every token. Skips
 // whitespace and comments, and.
 
-pp$9.skipSpace = function() {
+pp.skipSpace = function() {
   loop: while (this.pos < this.input.length) {
     var ch = this.input.charCodeAt(this.pos);
     switch (ch) {
@@ -20981,7 +21030,7 @@ pp$9.skipSpace = function() {
 // the token, so that the next one's `start` will point at the
 // right position.
 
-pp$9.finishToken = function(type, val) {
+pp.finishToken = function(type, val) {
   this.end = this.pos;
   if (this.options.locations) { this.endLoc = this.curPosition(); }
   var prevType = this.type;
@@ -21000,62 +21049,62 @@ pp$9.finishToken = function(type, val) {
 //
 // All in the name of speed.
 //
-pp$9.readToken_dot = function() {
+pp.readToken_dot = function() {
   var next = this.input.charCodeAt(this.pos + 1);
   if (next >= 48 && next <= 57) { return this.readNumber(true) }
   var next2 = this.input.charCodeAt(this.pos + 2);
   if (this.options.ecmaVersion >= 6 && next === 46 && next2 === 46) { // 46 = dot '.'
     this.pos += 3;
-    return this.finishToken(types.ellipsis)
+    return this.finishToken(types$1.ellipsis)
   } else {
     ++this.pos;
-    return this.finishToken(types.dot)
+    return this.finishToken(types$1.dot)
   }
 };
 
-pp$9.readToken_slash = function() { // '/'
+pp.readToken_slash = function() { // '/'
   var next = this.input.charCodeAt(this.pos + 1);
   if (this.exprAllowed) { ++this.pos; return this.readRegexp() }
-  if (next === 61) { return this.finishOp(types.assign, 2) }
-  return this.finishOp(types.slash, 1)
+  if (next === 61) { return this.finishOp(types$1.assign, 2) }
+  return this.finishOp(types$1.slash, 1)
 };
 
-pp$9.readToken_mult_modulo_exp = function(code) { // '%*'
+pp.readToken_mult_modulo_exp = function(code) { // '%*'
   var next = this.input.charCodeAt(this.pos + 1);
   var size = 1;
-  var tokentype = code === 42 ? types.star : types.modulo;
+  var tokentype = code === 42 ? types$1.star : types$1.modulo;
 
   // exponentiation operator ** and **=
   if (this.options.ecmaVersion >= 7 && code === 42 && next === 42) {
     ++size;
-    tokentype = types.starstar;
+    tokentype = types$1.starstar;
     next = this.input.charCodeAt(this.pos + 2);
   }
 
-  if (next === 61) { return this.finishOp(types.assign, size + 1) }
+  if (next === 61) { return this.finishOp(types$1.assign, size + 1) }
   return this.finishOp(tokentype, size)
 };
 
-pp$9.readToken_pipe_amp = function(code) { // '|&'
+pp.readToken_pipe_amp = function(code) { // '|&'
   var next = this.input.charCodeAt(this.pos + 1);
   if (next === code) {
     if (this.options.ecmaVersion >= 12) {
       var next2 = this.input.charCodeAt(this.pos + 2);
-      if (next2 === 61) { return this.finishOp(types.assign, 3) }
+      if (next2 === 61) { return this.finishOp(types$1.assign, 3) }
     }
-    return this.finishOp(code === 124 ? types.logicalOR : types.logicalAND, 2)
+    return this.finishOp(code === 124 ? types$1.logicalOR : types$1.logicalAND, 2)
   }
-  if (next === 61) { return this.finishOp(types.assign, 2) }
-  return this.finishOp(code === 124 ? types.bitwiseOR : types.bitwiseAND, 1)
+  if (next === 61) { return this.finishOp(types$1.assign, 2) }
+  return this.finishOp(code === 124 ? types$1.bitwiseOR : types$1.bitwiseAND, 1)
 };
 
-pp$9.readToken_caret = function() { // '^'
+pp.readToken_caret = function() { // '^'
   var next = this.input.charCodeAt(this.pos + 1);
-  if (next === 61) { return this.finishOp(types.assign, 2) }
-  return this.finishOp(types.bitwiseXOR, 1)
+  if (next === 61) { return this.finishOp(types$1.assign, 2) }
+  return this.finishOp(types$1.bitwiseXOR, 1)
 };
 
-pp$9.readToken_plus_min = function(code) { // '+-'
+pp.readToken_plus_min = function(code) { // '+-'
   var next = this.input.charCodeAt(this.pos + 1);
   if (next === code) {
     if (next === 45 && !this.inModule && this.input.charCodeAt(this.pos + 2) === 62 &&
@@ -21065,19 +21114,19 @@ pp$9.readToken_plus_min = function(code) { // '+-'
       this.skipSpace();
       return this.nextToken()
     }
-    return this.finishOp(types.incDec, 2)
+    return this.finishOp(types$1.incDec, 2)
   }
-  if (next === 61) { return this.finishOp(types.assign, 2) }
-  return this.finishOp(types.plusMin, 1)
+  if (next === 61) { return this.finishOp(types$1.assign, 2) }
+  return this.finishOp(types$1.plusMin, 1)
 };
 
-pp$9.readToken_lt_gt = function(code) { // '<>'
+pp.readToken_lt_gt = function(code) { // '<>'
   var next = this.input.charCodeAt(this.pos + 1);
   var size = 1;
   if (next === code) {
     size = code === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2;
-    if (this.input.charCodeAt(this.pos + size) === 61) { return this.finishOp(types.assign, size + 1) }
-    return this.finishOp(types.bitShift, size)
+    if (this.input.charCodeAt(this.pos + size) === 61) { return this.finishOp(types$1.assign, size + 1) }
+    return this.finishOp(types$1.bitShift, size)
   }
   if (next === 33 && code === 60 && !this.inModule && this.input.charCodeAt(this.pos + 2) === 45 &&
       this.input.charCodeAt(this.pos + 3) === 45) {
@@ -21087,53 +21136,53 @@ pp$9.readToken_lt_gt = function(code) { // '<>'
     return this.nextToken()
   }
   if (next === 61) { size = 2; }
-  return this.finishOp(types.relational, size)
+  return this.finishOp(types$1.relational, size)
 };
 
-pp$9.readToken_eq_excl = function(code) { // '=!'
+pp.readToken_eq_excl = function(code) { // '=!'
   var next = this.input.charCodeAt(this.pos + 1);
-  if (next === 61) { return this.finishOp(types.equality, this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2) }
+  if (next === 61) { return this.finishOp(types$1.equality, this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2) }
   if (code === 61 && next === 62 && this.options.ecmaVersion >= 6) { // '=>'
     this.pos += 2;
-    return this.finishToken(types.arrow)
+    return this.finishToken(types$1.arrow)
   }
-  return this.finishOp(code === 61 ? types.eq : types.prefix, 1)
+  return this.finishOp(code === 61 ? types$1.eq : types$1.prefix, 1)
 };
 
-pp$9.readToken_question = function() { // '?'
+pp.readToken_question = function() { // '?'
   var ecmaVersion = this.options.ecmaVersion;
   if (ecmaVersion >= 11) {
     var next = this.input.charCodeAt(this.pos + 1);
     if (next === 46) {
       var next2 = this.input.charCodeAt(this.pos + 2);
-      if (next2 < 48 || next2 > 57) { return this.finishOp(types.questionDot, 2) }
+      if (next2 < 48 || next2 > 57) { return this.finishOp(types$1.questionDot, 2) }
     }
     if (next === 63) {
       if (ecmaVersion >= 12) {
         var next2$1 = this.input.charCodeAt(this.pos + 2);
-        if (next2$1 === 61) { return this.finishOp(types.assign, 3) }
+        if (next2$1 === 61) { return this.finishOp(types$1.assign, 3) }
       }
-      return this.finishOp(types.coalesce, 2)
+      return this.finishOp(types$1.coalesce, 2)
     }
   }
-  return this.finishOp(types.question, 1)
+  return this.finishOp(types$1.question, 1)
 };
 
-pp$9.readToken_numberSign = function() { // '#'
+pp.readToken_numberSign = function() { // '#'
   var ecmaVersion = this.options.ecmaVersion;
   var code = 35; // '#'
   if (ecmaVersion >= 13) {
     ++this.pos;
     code = this.fullCharCodeAtPos();
     if (isIdentifierStart(code, true) || code === 92 /* '\' */) {
-      return this.finishToken(types.privateId, this.readWord1())
+      return this.finishToken(types$1.privateId, this.readWord1())
     }
   }
 
-  this.raise(this.pos, "Unexpected character '" + codePointToString$1(code) + "'");
+  this.raise(this.pos, "Unexpected character '" + codePointToString(code) + "'");
 };
 
-pp$9.getTokenFromCode = function(code) {
+pp.getTokenFromCode = function(code) {
   switch (code) {
   // The interpretation of a dot depends on whether it is followed
   // by a digit or another two dots.
@@ -21141,20 +21190,20 @@ pp$9.getTokenFromCode = function(code) {
     return this.readToken_dot()
 
   // Punctuation tokens.
-  case 40: ++this.pos; return this.finishToken(types.parenL)
-  case 41: ++this.pos; return this.finishToken(types.parenR)
-  case 59: ++this.pos; return this.finishToken(types.semi)
-  case 44: ++this.pos; return this.finishToken(types.comma)
-  case 91: ++this.pos; return this.finishToken(types.bracketL)
-  case 93: ++this.pos; return this.finishToken(types.bracketR)
-  case 123: ++this.pos; return this.finishToken(types.braceL)
-  case 125: ++this.pos; return this.finishToken(types.braceR)
-  case 58: ++this.pos; return this.finishToken(types.colon)
+  case 40: ++this.pos; return this.finishToken(types$1.parenL)
+  case 41: ++this.pos; return this.finishToken(types$1.parenR)
+  case 59: ++this.pos; return this.finishToken(types$1.semi)
+  case 44: ++this.pos; return this.finishToken(types$1.comma)
+  case 91: ++this.pos; return this.finishToken(types$1.bracketL)
+  case 93: ++this.pos; return this.finishToken(types$1.bracketR)
+  case 123: ++this.pos; return this.finishToken(types$1.braceL)
+  case 125: ++this.pos; return this.finishToken(types$1.braceR)
+  case 58: ++this.pos; return this.finishToken(types$1.colon)
 
   case 96: // '`'
     if (this.options.ecmaVersion < 6) { break }
     ++this.pos;
-    return this.finishToken(types.backQuote)
+    return this.finishToken(types$1.backQuote)
 
   case 48: // '0'
     var next = this.input.charCodeAt(this.pos + 1);
@@ -21177,7 +21226,6 @@ pp$9.getTokenFromCode = function(code) {
   // often referred to. `finishOp` simply skips the amount of
   // characters it is given as second argument, and returns a token
   // of the type given by its first argument.
-
   case 47: // '/'
     return this.readToken_slash()
 
@@ -21203,22 +21251,22 @@ pp$9.getTokenFromCode = function(code) {
     return this.readToken_question()
 
   case 126: // '~'
-    return this.finishOp(types.prefix, 1)
+    return this.finishOp(types$1.prefix, 1)
 
   case 35: // '#'
     return this.readToken_numberSign()
   }
 
-  this.raise(this.pos, "Unexpected character '" + codePointToString$1(code) + "'");
+  this.raise(this.pos, "Unexpected character '" + codePointToString(code) + "'");
 };
 
-pp$9.finishOp = function(type, size) {
+pp.finishOp = function(type, size) {
   var str = this.input.slice(this.pos, this.pos + size);
   this.pos += size;
   return this.finishToken(type, str)
 };
 
-pp$9.readRegexp = function() {
+pp.readRegexp = function() {
   var escaped, inClass, start = this.pos;
   for (;;) {
     if (this.pos >= this.input.length) { this.raise(start, "Unterminated regular expression"); }
@@ -21253,14 +21301,14 @@ pp$9.readRegexp = function() {
     // https://github.com/estree/estree/blob/a27003adf4fd7bfad44de9cef372a2eacd527b1c/es5.md#regexpliteral
   }
 
-  return this.finishToken(types.regexp, {pattern: pattern, flags: flags, value: value})
+  return this.finishToken(types$1.regexp, {pattern: pattern, flags: flags, value: value})
 };
 
 // Read an integer in the given radix. Return null if zero digits
 // were read, the integer value otherwise. When `len` is given, this
 // will return `null` unless the integer has exactly `len` digits.
 
-pp$9.readInt = function(radix, len, maybeLegacyOctalNumericLiteral) {
+pp.readInt = function(radix, len, maybeLegacyOctalNumericLiteral) {
   // `len` is used for character escape sequences. In that case, disallow separators.
   var allowSeparators = this.options.ecmaVersion >= 12 && len === undefined;
 
@@ -21314,7 +21362,7 @@ function stringToBigInt(str) {
   return BigInt(str.replace(/_/g, ""))
 }
 
-pp$9.readRadixNumber = function(radix) {
+pp.readRadixNumber = function(radix) {
   var start = this.pos;
   this.pos += 2; // 0x
   var val = this.readInt(radix);
@@ -21323,12 +21371,12 @@ pp$9.readRadixNumber = function(radix) {
     val = stringToBigInt(this.input.slice(start, this.pos));
     ++this.pos;
   } else if (isIdentifierStart(this.fullCharCodeAtPos())) { this.raise(this.pos, "Identifier directly after number"); }
-  return this.finishToken(types.num, val)
+  return this.finishToken(types$1.num, val)
 };
 
 // Read an integer, octal integer, or floating-point number.
 
-pp$9.readNumber = function(startsWithDot) {
+pp.readNumber = function(startsWithDot) {
   var start = this.pos;
   if (!startsWithDot && this.readInt(10, undefined, true) === null) { this.raise(start, "Invalid number"); }
   var octal = this.pos - start >= 2 && this.input.charCodeAt(start) === 48;
@@ -21338,7 +21386,7 @@ pp$9.readNumber = function(startsWithDot) {
     var val$1 = stringToBigInt(this.input.slice(start, this.pos));
     ++this.pos;
     if (isIdentifierStart(this.fullCharCodeAtPos())) { this.raise(this.pos, "Identifier directly after number"); }
-    return this.finishToken(types.num, val$1)
+    return this.finishToken(types$1.num, val$1)
   }
   if (octal && /[89]/.test(this.input.slice(start, this.pos))) { octal = false; }
   if (next === 46 && !octal) { // '.'
@@ -21354,12 +21402,12 @@ pp$9.readNumber = function(startsWithDot) {
   if (isIdentifierStart(this.fullCharCodeAtPos())) { this.raise(this.pos, "Identifier directly after number"); }
 
   var val = stringToNumber(this.input.slice(start, this.pos), octal);
-  return this.finishToken(types.num, val)
+  return this.finishToken(types$1.num, val)
 };
 
 // Read a string value, interpreting backslash-escapes.
 
-pp$9.readCodePoint = function() {
+pp.readCodePoint = function() {
   var ch = this.input.charCodeAt(this.pos), code;
 
   if (ch === 123) { // '{'
@@ -21374,14 +21422,14 @@ pp$9.readCodePoint = function() {
   return code
 };
 
-function codePointToString$1(code) {
+function codePointToString(code) {
   // UTF-16 Decoding
   if (code <= 0xFFFF) { return String.fromCharCode(code) }
   code -= 0x10000;
   return String.fromCharCode((code >> 10) + 0xD800, (code & 1023) + 0xDC00)
 }
 
-pp$9.readString = function(quote) {
+pp.readString = function(quote) {
   var out = "", chunkStart = ++this.pos;
   for (;;) {
     if (this.pos >= this.input.length) { this.raise(this.start, "Unterminated string constant"); }
@@ -21404,14 +21452,14 @@ pp$9.readString = function(quote) {
     }
   }
   out += this.input.slice(chunkStart, this.pos++);
-  return this.finishToken(types.string, out)
+  return this.finishToken(types$1.string, out)
 };
 
 // Reads template string tokens.
 
 var INVALID_TEMPLATE_ESCAPE_ERROR = {};
 
-pp$9.tryReadTemplateToken = function() {
+pp.tryReadTemplateToken = function() {
   this.inTemplateElement = true;
   try {
     this.readTmplToken();
@@ -21426,7 +21474,7 @@ pp$9.tryReadTemplateToken = function() {
   this.inTemplateElement = false;
 };
 
-pp$9.invalidStringToken = function(position, message) {
+pp.invalidStringToken = function(position, message) {
   if (this.inTemplateElement && this.options.ecmaVersion >= 9) {
     throw INVALID_TEMPLATE_ESCAPE_ERROR
   } else {
@@ -21434,23 +21482,23 @@ pp$9.invalidStringToken = function(position, message) {
   }
 };
 
-pp$9.readTmplToken = function() {
+pp.readTmplToken = function() {
   var out = "", chunkStart = this.pos;
   for (;;) {
     if (this.pos >= this.input.length) { this.raise(this.start, "Unterminated template"); }
     var ch = this.input.charCodeAt(this.pos);
     if (ch === 96 || ch === 36 && this.input.charCodeAt(this.pos + 1) === 123) { // '`', '${'
-      if (this.pos === this.start && (this.type === types.template || this.type === types.invalidTemplate)) {
+      if (this.pos === this.start && (this.type === types$1.template || this.type === types$1.invalidTemplate)) {
         if (ch === 36) {
           this.pos += 2;
-          return this.finishToken(types.dollarBraceL)
+          return this.finishToken(types$1.dollarBraceL)
         } else {
           ++this.pos;
-          return this.finishToken(types.backQuote)
+          return this.finishToken(types$1.backQuote)
         }
       }
       out += this.input.slice(chunkStart, this.pos);
-      return this.finishToken(types.template, out)
+      return this.finishToken(types$1.template, out)
     }
     if (ch === 92) { // '\'
       out += this.input.slice(chunkStart, this.pos);
@@ -21481,7 +21529,7 @@ pp$9.readTmplToken = function() {
 };
 
 // Reads a template token to search for the end, without validating any escape sequences
-pp$9.readInvalidTemplateToken = function() {
+pp.readInvalidTemplateToken = function() {
   for (; this.pos < this.input.length; this.pos++) {
     switch (this.input[this.pos]) {
     case "\\":
@@ -21492,10 +21540,10 @@ pp$9.readInvalidTemplateToken = function() {
       if (this.input[this.pos + 1] !== "{") {
         break
       }
-    // falls through
 
+    // falls through
     case "`":
-      return this.finishToken(types.invalidTemplate, this.input.slice(this.start, this.pos))
+      return this.finishToken(types$1.invalidTemplate, this.input.slice(this.start, this.pos))
 
     // no default
     }
@@ -21505,14 +21553,14 @@ pp$9.readInvalidTemplateToken = function() {
 
 // Used to read escaped characters
 
-pp$9.readEscapedChar = function(inTemplate) {
+pp.readEscapedChar = function(inTemplate) {
   var ch = this.input.charCodeAt(++this.pos);
   ++this.pos;
   switch (ch) {
   case 110: return "\n" // 'n' -> '\n'
   case 114: return "\r" // 'r' -> '\r'
   case 120: return String.fromCharCode(this.readHexChar(2)) // 'x'
-  case 117: return codePointToString$1(this.readCodePoint()) // 'u'
+  case 117: return codePointToString(this.readCodePoint()) // 'u'
   case 116: return "\t" // 't' -> '\t'
   case 98: return "\b" // 'b' -> '\b'
   case 118: return "\u000b" // 'v' -> '\u000b'
@@ -21570,7 +21618,7 @@ pp$9.readEscapedChar = function(inTemplate) {
 
 // Used to read character escape sequences ('\x', '\u', '\U').
 
-pp$9.readHexChar = function(len) {
+pp.readHexChar = function(len) {
   var codePos = this.pos;
   var n = this.readInt(16, len);
   if (n === null) { this.invalidStringToken(codePos, "Bad character escape sequence"); }
@@ -21583,7 +21631,7 @@ pp$9.readHexChar = function(len) {
 // Incrementally adds only escaped chars, adding other chunks as-is
 // as a micro-optimization.
 
-pp$9.readWord1 = function() {
+pp.readWord1 = function() {
   this.containsEsc = false;
   var word = "", first = true, chunkStart = this.pos;
   var astral = this.options.ecmaVersion >= 6;
@@ -21601,7 +21649,7 @@ pp$9.readWord1 = function() {
       var esc = this.readCodePoint();
       if (!(first ? isIdentifierStart : isIdentifierChar)(esc, astral))
         { this.invalidStringToken(escStart, "Invalid Unicode escape"); }
-      word += codePointToString$1(esc);
+      word += codePointToString(esc);
       chunkStart = this.pos;
     } else {
       break
@@ -21614,18 +21662,18 @@ pp$9.readWord1 = function() {
 // Read an identifier or keyword token. Will check for reserved
 // words when necessary.
 
-pp$9.readWord = function() {
+pp.readWord = function() {
   var word = this.readWord1();
-  var type = types.name;
+  var type = types$1.name;
   if (this.keywords.test(word)) {
-    type = keywords$1[word];
+    type = keywords[word];
   }
   return this.finishToken(type, word)
 };
 
 // Acorn is a tiny, fast JavaScript parser written in JavaScript.
 
-var version = "8.5.0";
+var version = "8.6.0";
 
 Parser.acorn = {
   Parser: Parser,
@@ -21636,10 +21684,10 @@ Parser.acorn = {
   getLineInfo: getLineInfo,
   Node: Node,
   TokenType: TokenType,
-  tokTypes: types,
-  keywordTypes: keywords$1,
+  tokTypes: types$1,
+  keywordTypes: keywords,
   TokContext: TokContext,
-  tokContexts: types$1,
+  tokContexts: types,
   isIdentifierChar: isIdentifierChar,
   isIdentifierStart: isIdentifierStart,
   Token: Token,
@@ -21652,20 +21700,7 @@ Parser.acorn = {
 const readFile = (file) => new Promise((fulfil, reject) => fs.readFile(file, 'utf-8', (err, contents) => (err ? reject(err) : fulfil(contents))));
 function mkdirpath(path) {
     const dir = path$2.dirname(path);
-    try {
-        fs.readdirSync(dir);
-    }
-    catch (_a) {
-        mkdirpath(dir);
-        try {
-            fs.mkdirSync(dir);
-        }
-        catch (err) {
-            if (err.code !== 'EEXIST') {
-                throw err;
-            }
-        }
-    }
+    fs.mkdirSync(dir, { recursive: true });
 }
 function writeFile(dest, data) {
     return new Promise((fulfil, reject) => {
@@ -22031,6 +22066,7 @@ class ModuleLoader {
         this.indexedEntryModules = [];
         this.latestLoadModulesPromise = Promise.resolve();
         this.moduleLoadPromises = new Map();
+        this.modulesWithLoadedDependencies = new Set();
         this.nextEntryModuleIndex = 0;
         this.readQueue = new Queue();
         this.resolveId = async (source, importer, customOptions, isEntry, skip = null) => {
@@ -22209,7 +22245,8 @@ class ModuleLoader {
         this.graph.watchFiles[id] = true;
         const loadPromise = this.addModuleSource(id, importer, module).then(() => [
             this.getResolveStaticDependencyPromises(module),
-            this.getResolveDynamicImportPromises(module)
+            this.getResolveDynamicImportPromises(module),
+            loadAndResolveDependenciesPromise
         ]);
         const loadAndResolveDependenciesPromise = loadPromise
             .then(([resolveStaticDependencyPromises, resolveDynamicImportPromises]) => Promise.all([...resolveStaticDependencyPromises, ...resolveDynamicImportPromises]))
@@ -22217,23 +22254,25 @@ class ModuleLoader {
         loadAndResolveDependenciesPromise.catch(() => {
             /* avoid unhandled promise rejections */
         });
-        if (isPreload) {
-            this.moduleLoadPromises.set(module, loadPromise);
-            await loadPromise;
-        }
-        else {
-            await this.fetchModuleDependencies(module, ...(await loadPromise));
-            // To handle errors when resolving dependencies or in moduleParsed
-            await loadAndResolveDependenciesPromise;
+        this.moduleLoadPromises.set(module, loadPromise);
+        const resolveDependencyPromises = await loadPromise;
+        if (!isPreload) {
+            await this.fetchModuleDependencies(module, ...resolveDependencyPromises);
         }
         return module;
     }
-    async fetchModuleDependencies(module, resolveStaticDependencyPromises, resolveDynamicDependencyPromises) {
+    async fetchModuleDependencies(module, resolveStaticDependencyPromises, resolveDynamicDependencyPromises, loadAndResolveDependenciesPromise) {
+        if (this.modulesWithLoadedDependencies.has(module)) {
+            return;
+        }
+        this.modulesWithLoadedDependencies.add(module);
         await Promise.all([
             this.fetchStaticDependencies(module, resolveStaticDependencyPromises),
             this.fetchDynamicDependencies(module, resolveDynamicDependencyPromises)
         ]);
         module.linkImports();
+        // To handle errors when resolving dependencies or in moduleParsed
+        await loadAndResolveDependenciesPromise;
     }
     fetchResolvedDependency(source, importer, resolvedId) {
         if (resolvedId.external) {
@@ -22322,8 +22361,7 @@ class ModuleLoader {
     async handleExistingModule(module, isEntry, isPreload) {
         const loadPromise = this.moduleLoadPromises.get(module);
         if (isPreload) {
-            await loadPromise;
-            return;
+            return loadPromise;
         }
         if (isEntry) {
             module.info.isEntry = true;
@@ -22333,11 +22371,7 @@ class ModuleLoader {
             }
             module.implicitlyLoadedAfter.clear();
         }
-        if (loadPromise) {
-            this.moduleLoadPromises.delete(module);
-            await this.fetchModuleDependencies(module, ...(await loadPromise));
-        }
-        return;
+        return this.fetchModuleDependencies(module, ...(await loadPromise));
     }
     handleResolveId(resolvedId, source, importer) {
         if (resolvedId === null) {