rollup 2.47.0 → 2.48.0

package/dist/es/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.47.0
-	Tue, 04 May 2021 05:02:40 GMT - commit 6cc9d6b5137dd80fef9618e97471f89f8fbc54ad
+	Rollup.js v2.48.0
+	Sat, 15 May 2021 04:50:11 GMT - commit 07b3a02069594147665daa95d3fa3e041a82b2d0
 
 
 	https://github.com/rollup/rollup
@@ -14,7 +14,7 @@ import * as fs from 'fs';
 import { lstatSync, realpathSync, readdirSync } from 'fs';
 import { EventEmitter } from 'events';
 
-var version$1 = "2.47.0";
+var version$1 = "2.48.0";
 
 var charToInteger = {};
 var chars$1 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
@@ -4352,17 +4352,18 @@ class NamespaceVariable extends Variable {
         this.name = identifier.name;
     }
     deoptimizePath(path) {
+        var _a;
         const memberVariables = this.getMemberVariables();
         const memberPath = path.length <= 1 ? UNKNOWN_PATH : path.slice(1);
         const key = path[0];
-        if (typeof key !== 'string') {
+        if (typeof key === 'string') {
+            (_a = memberVariables[key]) === null || _a === void 0 ? void 0 : _a.deoptimizePath(memberPath);
+        }
+        else {
             for (const key of Object.keys(memberVariables)) {
                 memberVariables[key].deoptimizePath(memberPath);
             }
         }
-        else {
-            memberVariables[key].deoptimizePath(memberPath);
-        }
     }
     getMemberVariables() {
         if (this.memberVariables) {
@@ -6779,7 +6780,8 @@ class CallExpression extends NodeBase {
             if (argument.hasEffects(context))
                 return true;
         }
-        if (this.context.options.treeshake.annotations && ((_a = this.annotations) === null || _a === void 0 ? void 0 : _a.some((a) => a.pure)))
+        if (this.context.options.treeshake.annotations &&
+            ((_a = this.annotations) === null || _a === void 0 ? void 0 : _a.some((a) => a.pure)))
             return false;
         return (this.callee.hasEffects(context) ||
             this.callee.hasEffectsWhenCalledAtPath(EMPTY_PATH, this.callOptions, context));
@@ -8072,7 +8074,8 @@ class NewExpression extends NodeBase {
             if (argument.hasEffects(context))
                 return true;
         }
-        if (this.context.options.treeshake.annotations && ((_a = this.annotations) === null || _a === void 0 ? void 0 : _a.some((a) => a.pure)))
+        if (this.context.options.treeshake.annotations &&
+            ((_a = this.annotations) === null || _a === void 0 ? void 0 : _a.some((a) => a.pure)))
             return false;
         return (this.callee.hasEffects(context) ||
             this.callee.hasEffectsWhenCalledAtPath(EMPTY_PATH, this.callOptions, context));
@@ -11099,12 +11102,11 @@ class Chunk {
         if (isAbsolute(id)) {
             const extension = extname(id);
             const pattern = unsetOptions.has('entryFileNames')
-                ? NON_ASSET_EXTENSIONS.includes(extension)
-                    ? '[name].js'
-                    : '[name][extname].js'
+                ? '[name][assetExtname].js'
                 : options.entryFileNames;
             const currentDir = dirname(sanitizedId);
             const fileName = renderNamePattern(typeof pattern === 'function' ? pattern(this.getChunkInfo()) : pattern, 'output.entryFileNames', {
+                assetExtname: () => NON_ASSET_EXTENSIONS.includes(extension) ? '' : extension,
                 ext: () => extension.substr(1),
                 extname: () => extension,
                 format: () => options.format,
@@ -12740,6 +12742,7 @@ var types = {
   regexp: new TokenType("regexp", startsExpr),
   string: new TokenType("string", startsExpr),
   name: new TokenType("name", startsExpr),
+  privateId: new TokenType("privateId", startsExpr),
   eof: new TokenType("eof"),
 
   // Punctuation token types.
@@ -12934,7 +12937,8 @@ var defaultOptions = {
   // error.
   allowReturnOutsideFunction: false,
   // When enabled, import/export statements are not constrained to
-  // appearing at the top of the program.
+  // appearing at the top of the program, and an import.meta expression
+  // in a script isn't considered an error.
   allowImportExportEverywhere: false,
   // When enabled, await identifiers are allowed to appear at the top-level scope,
   // but they are still not allowed in non-async functions.
@@ -13125,6 +13129,7 @@ var Parser = function Parser(options, input, startPos) {
 
   // Used to signify the start of a potential arrow function
   this.potentialArrowAt = -1;
+  this.potentialArrowInForAwait = false;
 
   // Positions to delayed-check that yield/await does not exist in default parameters.
   this.yieldPos = this.awaitPos = this.awaitIdentPos = 0;
@@ -13143,6 +13148,11 @@ var Parser = function Parser(options, input, startPos) {
 
   // For RegExp validation
   this.regexpState = null;
+
+  // The stack of private names.
+  // Each element has two properties: 'declared' and 'used'.
+  // When it exited from the outermost class definition, all used private names must be declared.
+  this.privateNameStack = [];
 };
 
 var prototypeAccessors = { inFunction: { configurable: true },inGenerator: { configurable: true },inAsync: { configurable: true },allowSuper: { configurable: true },allowDirectSuper: { configurable: true },treatFunctionsAsVar: { configurable: true },inNonArrowFunction: { configurable: true } };
@@ -13154,12 +13164,22 @@ 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 };
-prototypeAccessors.inAsync.get = function () { return (this.currentVarScope().flags & SCOPE_ASYNC) > 0 };
-prototypeAccessors.allowSuper.get = function () { return (this.currentThisScope().flags & SCOPE_SUPER) > 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.allowSuper.get = function () {
+  var ref = this.currentThisScope();
+    var flags = ref.flags;
+    var inClassFieldInit = ref.inClassFieldInit;
+  return (flags & SCOPE_SUPER) > 0 || inClassFieldInit
+};
 prototypeAccessors.allowDirectSuper.get = function () { return (this.currentThisScope().flags & SCOPE_DIRECT_SUPER) > 0 };
 prototypeAccessors.treatFunctionsAsVar.get = function () { return this.treatFunctionsAsVarInScope(this.currentScope()) };
-prototypeAccessors.inNonArrowFunction.get = function () { return (this.currentThisScope().flags & SCOPE_FUNCTION) > 0 };
+prototypeAccessors.inNonArrowFunction.get = function () {
+  var ref = this.currentThisScope();
+    var flags = ref.flags;
+    var inClassFieldInit = ref.inClassFieldInit;
+  return (flags & SCOPE_FUNCTION) > 0 || inClassFieldInit
+};
 
 Parser.extend = function extend () {
     var plugins = [], len = arguments.length;
@@ -13566,7 +13586,7 @@ pp$1.parseForStatement = function(node) {
     return this.parseFor(node, init$1)
   }
   var refDestructuringErrors = new DestructuringErrors;
-  var init = this.parseExpression(true, refDestructuringErrors);
+  var init = this.parseExpression(awaitAt > -1 ? "await" : true, refDestructuringErrors);
   if (this.type === types._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) {
     if (this.options.ecmaVersion >= 9) {
       if (this.type === types._in) {
@@ -13912,6 +13932,7 @@ pp$1.parseClass = function(node, isStatement) {
 
   this.parseClassId(node, isStatement);
   this.parseClassSuper(node);
+  var privateNameMap = this.enterClassBody();
   var classBody = this.startNode();
   var hadConstructor = false;
   classBody.body = [];
@@ -13923,77 +13944,154 @@ pp$1.parseClass = function(node, isStatement) {
       if (element.type === "MethodDefinition" && element.kind === "constructor") {
         if (hadConstructor) { this.raise(element.start, "Duplicate constructor in the same class"); }
         hadConstructor = true;
+      } else if (element.key.type === "PrivateIdentifier" && isPrivateNameConflicted(privateNameMap, element)) {
+        this.raiseRecoverable(element.key.start, ("Identifier '#" + (element.key.name) + "' has already been declared"));
       }
     }
   }
   this.strict = oldStrict;
   this.next();
   node.body = this.finishNode(classBody, "ClassBody");
+  this.exitClassBody();
   return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression")
 };
 
 pp$1.parseClassElement = function(constructorAllowsSuper) {
-  var this$1 = this;
-
   if (this.eat(types.semi)) { return null }
 
-  var method = this.startNode();
-  var tryContextual = function (k, noLineBreak) {
-    if ( noLineBreak === void 0 ) noLineBreak = false;
-
-    var start = this$1.start, startLoc = this$1.startLoc;
-    if (!this$1.eatContextual(k)) { return false }
-    if (this$1.type !== types.parenL && (!noLineBreak || !this$1.canInsertSemicolon())) { return true }
-    if (method.key) { this$1.unexpected(); }
-    method.computed = false;
-    method.key = this$1.startNodeAt(start, startLoc);
-    method.key.name = k;
-    this$1.finishNode(method.key, "Identifier");
-    return false
-  };
-
-  method.kind = "method";
-  method.static = tryContextual("static");
-  var isGenerator = this.eat(types.star);
+  var ecmaVersion = this.options.ecmaVersion;
+  var node = this.startNode();
+  var keyName = "";
+  var isGenerator = false;
   var isAsync = false;
-  if (!isGenerator) {
-    if (this.options.ecmaVersion >= 8 && tryContextual("async", true)) {
+  var kind = "method";
+
+  // Parse modifiers
+  node.static = false;
+  if (this.eatContextual("static")) {
+    if (this.isClassElementNameStart() || this.type === types.star) {
+      node.static = true;
+    } else {
+      keyName = "static";
+    }
+  }
+  if (!keyName && ecmaVersion >= 8 && this.eatContextual("async")) {
+    if ((this.isClassElementNameStart() || this.type === types.star) && !this.canInsertSemicolon()) {
       isAsync = true;
-      isGenerator = this.options.ecmaVersion >= 9 && this.eat(types.star);
-    } else if (tryContextual("get")) {
-      method.kind = "get";
-    } else if (tryContextual("set")) {
-      method.kind = "set";
+    } else {
+      keyName = "async";
+    }
+  }
+  if (!keyName && (ecmaVersion >= 9 || !isAsync) && this.eat(types.star)) {
+    isGenerator = true;
+  }
+  if (!keyName && !isAsync && !isGenerator) {
+    var lastValue = this.value;
+    if (this.eatContextual("get") || this.eatContextual("set")) {
+      if (this.isClassElementNameStart()) {
+        kind = lastValue;
+      } else {
+        keyName = lastValue;
+      }
+    }
+  }
+
+  // Parse element name
+  if (keyName) {
+    // 'async', 'get', 'set', or 'static' were not a keyword contextually.
+    // The last token is any of those. Make it the element name.
+    node.computed = false;
+    node.key = this.startNodeAt(this.lastTokStart, this.lastTokStartLoc);
+    node.key.name = keyName;
+    this.finishNode(node.key, "Identifier");
+  } else {
+    this.parseClassElementName(node);
+  }
+
+  // Parse element value
+  if (ecmaVersion < 13 || this.type === types.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.
+    if (isConstructor && kind !== "method") { this.raise(node.key.start, "Constructor can't have get/set modifier"); }
+    node.kind = isConstructor ? "constructor" : kind;
+    this.parseClassMethod(node, isGenerator, isAsync, allowsDirectSuper);
+  } else {
+    this.parseClassField(node);
+  }
+
+  return node
+};
+
+pp$1.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.keyword
+  )
+};
+
+pp$1.parseClassElementName = function(element) {
+  if (this.type === types.privateId) {
+    if (this.value === "constructor") {
+      this.raise(this.start, "Classes can't have an element named '#constructor'");
     }
+    element.computed = false;
+    element.key = this.parsePrivateIdent();
+  } else {
+    this.parsePropertyName(element);
   }
-  if (!method.key) { this.parsePropertyName(method); }
+};
+
+pp$1.parseClassMethod = function(method, isGenerator, isAsync, allowsDirectSuper) {
+  // Check key and flags
   var key = method.key;
-  var allowsDirectSuper = false;
-  if (!method.computed && !method.static && (key.type === "Identifier" && key.name === "constructor" ||
-      key.type === "Literal" && key.value === "constructor")) {
-    if (method.kind !== "method") { this.raise(key.start, "Constructor can't have get/set modifier"); }
+  if (method.kind === "constructor") {
     if (isGenerator) { this.raise(key.start, "Constructor can't be a generator"); }
     if (isAsync) { this.raise(key.start, "Constructor can't be an async method"); }
-    method.kind = "constructor";
-    allowsDirectSuper = constructorAllowsSuper;
-  } else if (method.static && key.type === "Identifier" && key.name === "prototype") {
+  } else if (method.static && checkKeyName(method, "prototype")) {
     this.raise(key.start, "Classes may not have a static property named prototype");
   }
-  this.parseClassMethod(method, isGenerator, isAsync, allowsDirectSuper);
-  if (method.kind === "get" && method.value.params.length !== 0)
-    { this.raiseRecoverable(method.value.start, "getter should have no params"); }
-  if (method.kind === "set" && method.value.params.length !== 1)
-    { this.raiseRecoverable(method.value.start, "setter should have exactly one param"); }
-  if (method.kind === "set" && method.value.params[0].type === "RestElement")
-    { this.raiseRecoverable(method.value.params[0].start, "Setter cannot use rest params"); }
-  return method
-};
 
-pp$1.parseClassMethod = function(method, isGenerator, isAsync, allowsDirectSuper) {
-  method.value = this.parseMethod(isGenerator, isAsync, allowsDirectSuper);
+  // Parse value
+  var value = method.value = this.parseMethod(isGenerator, isAsync, allowsDirectSuper);
+
+  // Check value
+  if (method.kind === "get" && value.params.length !== 0)
+    { this.raiseRecoverable(value.start, "getter should have no params"); }
+  if (method.kind === "set" && value.params.length !== 1)
+    { this.raiseRecoverable(value.start, "setter should have exactly one param"); }
+  if (method.kind === "set" && value.params[0].type === "RestElement")
+    { this.raiseRecoverable(value.params[0].start, "Setter cannot use rest params"); }
+
   return this.finishNode(method, "MethodDefinition")
 };
 
+pp$1.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)) {
+    // To raise SyntaxError if 'arguments' exists in the initializer.
+    var scope = this.currentThisScope();
+    var inClassFieldInit = scope.inClassFieldInit;
+    scope.inClassFieldInit = true;
+    field.value = this.parseMaybeAssign();
+    scope.inClassFieldInit = inClassFieldInit;
+  } else {
+    field.value = null;
+  }
+  this.semicolon();
+
+  return this.finishNode(field, "PropertyDefinition")
+};
+
 pp$1.parseClassId = function(node, isStatement) {
   if (this.type === types.name) {
     node.id = this.parseIdent();
@@ -14010,6 +14108,65 @@ pp$1.parseClassSuper = function(node) {
   node.superClass = this.eat(types._extends) ? this.parseExprSubscripts() : null;
 };
 
+pp$1.enterClassBody = function() {
+  var element = {declared: Object.create(null), used: []};
+  this.privateNameStack.push(element);
+  return element.declared
+};
+
+pp$1.exitClassBody = function() {
+  var ref = this.privateNameStack.pop();
+  var declared = ref.declared;
+  var used = ref.used;
+  var len = this.privateNameStack.length;
+  var parent = len === 0 ? null : this.privateNameStack[len - 1];
+  for (var i = 0; i < used.length; ++i) {
+    var id = used[i];
+    if (!has(declared, id.name)) {
+      if (parent) {
+        parent.used.push(id);
+      } else {
+        this.raiseRecoverable(id.start, ("Private field '#" + (id.name) + "' must be declared in an enclosing class"));
+      }
+    }
+  }
+};
+
+function isPrivateNameConflicted(privateNameMap, element) {
+  var name = element.key.name;
+  var curr = privateNameMap[name];
+
+  var next = "true";
+  if (element.type === "MethodDefinition" && (element.kind === "get" || element.kind === "set")) {
+    next = (element.static ? "s" : "i") + element.kind;
+  }
+
+  // `class { get #a(){}; static set #a(_){} }` is also conflict.
+  if (
+    curr === "iget" && next === "iset" ||
+    curr === "iset" && next === "iget" ||
+    curr === "sget" && next === "sset" ||
+    curr === "sset" && next === "sget"
+  ) {
+    privateNameMap[name] = "true";
+    return false
+  } else if (!curr) {
+    privateNameMap[name] = next;
+    return false
+  } else {
+    return true
+  }
+}
+
+function checkKeyName(node, name) {
+  var computed = node.computed;
+  var key = node.key;
+  return !computed && (
+    key.type === "Identifier" && key.name === name ||
+    key.type === "Literal" && key.value === name
+  )
+}
+
 // Parses module export declaration.
 
 pp$1.parseExport = function(node, exports) {
@@ -14628,13 +14785,13 @@ pp$3.checkPropClash = function(prop, propHash, refDestructuringErrors) {
 // and object pattern might appear (so it's possible to raise
 // delayed syntax error at correct position).
 
-pp$3.parseExpression = function(noIn, refDestructuringErrors) {
+pp$3.parseExpression = function(forInit, refDestructuringErrors) {
   var startPos = this.start, startLoc = this.startLoc;
-  var expr = this.parseMaybeAssign(noIn, refDestructuringErrors);
+  var expr = this.parseMaybeAssign(forInit, refDestructuringErrors);
   if (this.type === types.comma) {
     var node = this.startNodeAt(startPos, startLoc);
     node.expressions = [expr];
-    while (this.eat(types.comma)) { node.expressions.push(this.parseMaybeAssign(noIn, refDestructuringErrors)); }
+    while (this.eat(types.comma)) { node.expressions.push(this.parseMaybeAssign(forInit, refDestructuringErrors)); }
     return this.finishNode(node, "SequenceExpression")
   }
   return expr
@@ -14643,9 +14800,9 @@ pp$3.parseExpression = function(noIn, refDestructuringErrors) {
 // Parse an assignment expression. This includes applications of
 // operators like `+=`.
 
-pp$3.parseMaybeAssign = function(noIn, refDestructuringErrors, afterLeftParse) {
+pp$3.parseMaybeAssign = function(forInit, refDestructuringErrors, afterLeftParse) {
   if (this.isContextual("yield")) {
-    if (this.inGenerator) { return this.parseYield(noIn) }
+    if (this.inGenerator) { return this.parseYield(forInit) }
     // The tokenizer will assume an expression is allowed after
     // `yield`, but this isn't that kind of yield
     else { this.exprAllowed = false; }
@@ -14662,9 +14819,11 @@ pp$3.parseMaybeAssign = function(noIn, refDestructuringErrors, afterLeftParse) {
   }
 
   var startPos = this.start, startLoc = this.startLoc;
-  if (this.type === types.parenL || this.type === types.name)
-    { this.potentialArrowAt = this.start; }
-  var left = this.parseMaybeConditional(noIn, refDestructuringErrors);
+  if (this.type === types.parenL || this.type === types.name) {
+    this.potentialArrowAt = this.start;
+    this.potentialArrowInForAwait = forInit === "await";
+  }
+  var left = this.parseMaybeConditional(forInit, refDestructuringErrors);
   if (afterLeftParse) { left = afterLeftParse.call(this, left, startPos, startLoc); }
   if (this.type.isAssign) {
     var node = this.startNodeAt(startPos, startLoc);
@@ -14682,7 +14841,7 @@ pp$3.parseMaybeAssign = function(noIn, refDestructuringErrors, afterLeftParse) {
       { this.checkLValSimple(left); }
     node.left = left;
     this.next();
-    node.right = this.parseMaybeAssign(noIn);
+    node.right = this.parseMaybeAssign(forInit);
     return this.finishNode(node, "AssignmentExpression")
   } else {
     if (ownDestructuringErrors) { this.checkExpressionErrors(refDestructuringErrors, true); }
@@ -14694,16 +14853,16 @@ pp$3.parseMaybeAssign = function(noIn, refDestructuringErrors, afterLeftParse) {
 
 // Parse a ternary conditional (`?:`) operator.
 
-pp$3.parseMaybeConditional = function(noIn, refDestructuringErrors) {
+pp$3.parseMaybeConditional = function(forInit, refDestructuringErrors) {
   var startPos = this.start, startLoc = this.startLoc;
-  var expr = this.parseExprOps(noIn, refDestructuringErrors);
+  var expr = this.parseExprOps(forInit, refDestructuringErrors);
   if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }
   if (this.eat(types.question)) {
     var node = this.startNodeAt(startPos, startLoc);
     node.test = expr;
     node.consequent = this.parseMaybeAssign();
     this.expect(types.colon);
-    node.alternate = this.parseMaybeAssign(noIn);
+    node.alternate = this.parseMaybeAssign(forInit);
     return this.finishNode(node, "ConditionalExpression")
   }
   return expr
@@ -14711,11 +14870,11 @@ pp$3.parseMaybeConditional = function(noIn, refDestructuringErrors) {
 
 // Start the precedence parser.
 
-pp$3.parseExprOps = function(noIn, refDestructuringErrors) {
+pp$3.parseExprOps = function(forInit, refDestructuringErrors) {
   var startPos = this.start, startLoc = this.startLoc;
   var expr = this.parseMaybeUnary(refDestructuringErrors, false);
   if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }
-  return expr.start === startPos && expr.type === "ArrowFunctionExpression" ? expr : this.parseExprOp(expr, startPos, startLoc, -1, noIn)
+  return expr.start === startPos && expr.type === "ArrowFunctionExpression" ? expr : this.parseExprOp(expr, startPos, startLoc, -1, forInit)
 };
 
 // Parse binary operators with the operator precedence parsing
@@ -14724,9 +14883,9 @@ pp$3.parseExprOps = function(noIn, 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$3.parseExprOp = function(left, leftStartPos, leftStartLoc, minPrec, noIn) {
+pp$3.parseExprOp = function(left, leftStartPos, leftStartLoc, minPrec, forInit) {
   var prec = this.type.binop;
-  if (prec != null && (!noIn || this.type !== types._in)) {
+  if (prec != null && (!forInit || this.type !== types._in)) {
     if (prec > minPrec) {
       var logical = this.type === types.logicalOR || this.type === types.logicalAND;
       var coalesce = this.type === types.coalesce;
@@ -14738,12 +14897,12 @@ pp$3.parseExprOp = function(left, leftStartPos, leftStartLoc, minPrec, noIn) {
       var op = this.value;
       this.next();
       var startPos = this.start, startLoc = this.startLoc;
-      var right = this.parseExprOp(this.parseMaybeUnary(null, false), startPos, startLoc, prec, noIn);
+      var right = this.parseExprOp(this.parseMaybeUnary(null, false), 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))) {
         this.raiseRecoverable(this.start, "Logical expressions and coalesce expressions cannot be mixed. Wrap either by parentheses");
       }
-      return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec, noIn)
+      return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec, forInit)
     }
   }
   return left
@@ -14759,7 +14918,7 @@ pp$3.buildBinary = function(startPos, startLoc, left, right, op, logical) {
 
 // Parse unary operators, both prefix and postfix.
 
-pp$3.parseMaybeUnary = function(refDestructuringErrors, sawUnary) {
+pp$3.parseMaybeUnary = function(refDestructuringErrors, sawUnary, incDec) {
   var startPos = this.start, startLoc = this.startLoc, expr;
   if (this.isContextual("await") && (this.inAsync || (!this.inFunction && this.options.allowAwaitOutsideFunction))) {
     expr = this.parseAwait();
@@ -14769,12 +14928,14 @@ pp$3.parseMaybeUnary = function(refDestructuringErrors, sawUnary) {
     node.operator = this.value;
     node.prefix = true;
     this.next();
-    node.argument = this.parseMaybeUnary(null, true);
+    node.argument = this.parseMaybeUnary(null, true, update);
     this.checkExpressionErrors(refDestructuringErrors, true);
     if (update) { this.checkLValSimple(node.argument); }
     else if (this.strict && node.operator === "delete" &&
              node.argument.type === "Identifier")
       { this.raiseRecoverable(node.start, "Deleting local variable in strict mode"); }
+    else if (node.operator === "delete" && isPrivateFieldAccess(node.argument))
+      { this.raiseRecoverable(node.start, "Private fields can not be deleted"); }
     else { sawUnary = true; }
     expr = this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
   } else {
@@ -14791,12 +14952,23 @@ pp$3.parseMaybeUnary = function(refDestructuringErrors, sawUnary) {
     }
   }
 
-  if (!sawUnary && this.eat(types.starstar))
-    { return this.buildBinary(startPos, startLoc, expr, this.parseMaybeUnary(null, false), "**", false) }
-  else
-    { return expr }
+  if (!incDec && this.eat(types.starstar)) {
+    if (sawUnary)
+      { this.unexpected(this.lastTokStart); }
+    else
+      { return this.buildBinary(startPos, startLoc, expr, this.parseMaybeUnary(null, false), "**", false) }
+  } else {
+    return expr
+  }
 };
 
+function isPrivateFieldAccess(node) {
+  return (
+    node.type === "MemberExpression" && node.property.type === "PrivateIdentifier" ||
+    node.type === "ChainExpression" && isPrivateFieldAccess(node.expression)
+  )
+}
+
 // Parse call, dot, and `[]`-subscript expressions.
 
 pp$3.parseExprSubscripts = function(refDestructuringErrors) {
@@ -14808,6 +14980,7 @@ pp$3.parseExprSubscripts = function(refDestructuringErrors) {
   if (refDestructuringErrors && result.type === "MemberExpression") {
     if (refDestructuringErrors.parenthesizedAssign >= result.start) { refDestructuringErrors.parenthesizedAssign = -1; }
     if (refDestructuringErrors.parenthesizedBind >= result.start) { refDestructuringErrors.parenthesizedBind = -1; }
+    if (refDestructuringErrors.trailingComma >= result.start) { refDestructuringErrors.trailingComma = -1; }
   }
   return result
 };
@@ -14844,9 +15017,15 @@ pp$3.parseSubscript = function(base, startPos, startLoc, noCalls, maybeAsyncArro
   if (computed || (optional && this.type !== types.parenL && this.type !== types.backQuote) || this.eat(types.dot)) {
     var node = this.startNodeAt(startPos, startLoc);
     node.object = base;
-    node.property = computed ? this.parseExpression() : this.parseIdent(this.options.allowReserved !== "never");
+    if (computed) {
+      node.property = this.parseExpression();
+      this.expect(types.bracketR);
+    } else if (this.type === types.privateId && base.type !== "Super") {
+      node.property = this.parsePrivateIdent();
+    } else {
+      node.property = this.parseIdent(this.options.allowReserved !== "never");
+    }
     node.computed = !!computed;
-    if (computed) { this.expect(types.bracketR); }
     if (optionalSupported) {
       node.optional = optional;
     }
@@ -14932,7 +15111,8 @@ pp$3.parseExprAtom = function(refDestructuringErrors) {
     if (canBeArrow && !this.canInsertSemicolon()) {
       if (this.eat(types.arrow))
         { return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], false) }
-      if (this.options.ecmaVersion >= 8 && id.name === "async" && this.type === types.name && !containsEsc) {
+      if (this.options.ecmaVersion >= 8 && id.name === "async" && this.type === types.name && !containsEsc &&
+          (!this.potentialArrowInForAwait || this.value !== "of" || this.containsEsc)) {
         id = this.parseIdent(false);
         if (this.canInsertSemicolon() || !this.eat(types.arrow))
           { this.unexpected(); }
@@ -15050,7 +15230,7 @@ pp$3.parseImportMeta = function(node) {
     { this.raiseRecoverable(node.property.start, "The only valid meta property for import is 'import.meta'"); }
   if (containsEsc)
     { this.raiseRecoverable(node.start, "'import.meta' must not contain escaped characters"); }
-  if (this.options.sourceType !== "module")
+  if (this.options.sourceType !== "module" && !this.options.allowImportExportEverywhere)
     { this.raiseRecoverable(node.start, "Cannot use 'import.meta' outside a module"); }
 
   return this.finishNode(node, "MetaProperty")
@@ -15518,6 +15698,8 @@ pp$3.checkUnreserved = function(ref) {
     { this.raiseRecoverable(start, "Cannot use 'yield' as identifier inside a generator"); }
   if (this.inAsync && name === "await")
     { this.raiseRecoverable(start, "Cannot use 'await' as identifier inside an async function"); }
+  if (this.currentThisScope().inClassFieldInit && name === "arguments")
+    { this.raiseRecoverable(start, "Cannot use 'arguments' in class field initializer"); }
   if (this.keywords.test(name))
     { this.raise(start, ("Unexpected keyword '" + name + "'")); }
   if (this.options.ecmaVersion < 6 &&
@@ -15562,9 +15744,29 @@ pp$3.parseIdent = function(liberal, isBinding) {
   return node
 };
 
+pp$3.parsePrivateIdent = function() {
+  var node = this.startNode();
+  if (this.type === types.privateId) {
+    node.name = this.value;
+  } else {
+    this.unexpected();
+  }
+  this.next();
+  this.finishNode(node, "PrivateIdentifier");
+
+  // For validating existence
+  if (this.privateNameStack.length === 0) {
+    this.raise(node.start, ("Private field '#" + (node.name) + "' must be declared in an enclosing class"));
+  } else {
+    this.privateNameStack[this.privateNameStack.length - 1].used.push(node);
+  }
+
+  return node
+};
+
 // Parses yield expression inside generator.
 
-pp$3.parseYield = function(noIn) {
+pp$3.parseYield = function(forInit) {
   if (!this.yieldPos) { this.yieldPos = this.start; }
 
   var node = this.startNode();
@@ -15574,7 +15776,7 @@ pp$3.parseYield = function(noIn) {
     node.argument = null;
   } else {
     node.delegate = this.eat(types.star);
-    node.argument = this.parseMaybeAssign(noIn);
+    node.argument = this.parseMaybeAssign(forInit);
   }
   return this.finishNode(node, "YieldExpression")
 };
@@ -15622,6 +15824,8 @@ var Scope = function Scope(flags) {
   this.lexical = [];
   // A list of lexically-declared FunctionDeclaration names in the current lexical scope
   this.functions = [];
+  // A switch to disallow the identifier reference 'arguments'
+  this.inClassFieldInit = false;
 };
 
 // The functions in this module keep track of declared variables in the current scope in order to detect duplicate variable names.
@@ -17098,9 +17302,9 @@ pp$9.readToken = function(code) {
 
 pp$9.fullCharCodeAtPos = function() {
   var code = this.input.charCodeAt(this.pos);
-  if (code <= 0xd7ff || code >= 0xe000) { return code }
+  if (code <= 0xd7ff || code >= 0xdc00) { return code }
   var next = this.input.charCodeAt(this.pos + 1);
-  return (code << 10) + next - 0x35fdc00
+  return next <= 0xdbff || next >= 0xe000 ? code : (code << 10) + next - 0x35fdc00
 };
 
 pp$9.skipBlockComment = function() {
@@ -17319,6 +17523,20 @@ pp$9.readToken_question = function() { // '?'
   return this.finishOp(types.question, 1)
 };
 
+pp$9.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())
+    }
+  }
+
+  this.raise(this.pos, "Unexpected character '" + codePointToString$1(code) + "'");
+};
+
 pp$9.getTokenFromCode = function(code) {
   switch (code) {
   // The interpretation of a dot depends on whether it is followed
@@ -17390,6 +17608,9 @@ pp$9.getTokenFromCode = function(code) {
 
   case 126: // '~'
     return this.finishOp(types.prefix, 1)
+
+  case 35: // '#'
+    return this.readToken_numberSign()
   }
 
   this.raise(this.pos, "Unexpected character '" + codePointToString$1(code) + "'");
@@ -17801,7 +18022,7 @@ pp$9.readWord = function() {
 
 // Acorn is a tiny, fast JavaScript parser written in JavaScript.
 
-var version = "8.0.5";
+var version = "8.2.4";
 
 Parser.acorn = {
   Parser: Parser,
@@ -17836,47 +18057,6 @@ function parse(input, options) {
   return Parser.parse(input, options)
 }
 
-// This function tries to parse a single expression at a given
-// offset in a string. Useful for parsing mixed-language formats
-// that embed JavaScript expressions.
-
-function parseExpressionAt(input, pos, options) {
-  return Parser.parseExpressionAt(input, pos, options)
-}
-
-// Acorn is organized as a tokenizer and a recursive-descent parser.
-// The `tokenizer` export provides an interface to the tokenizer.
-
-function tokenizer(input, options) {
-  return Parser.tokenizer(input, options)
-}
-
-var acorn = {
-  __proto__: null,
-  Node: Node,
-  Parser: Parser,
-  Position: Position,
-  SourceLocation: SourceLocation,
-  TokContext: TokContext,
-  Token: Token,
-  TokenType: TokenType,
-  defaultOptions: defaultOptions,
-  getLineInfo: getLineInfo,
-  isIdentifierChar: isIdentifierChar,
-  isIdentifierStart: isIdentifierStart,
-  isNewLine: isNewLine,
-  keywordTypes: keywords$1,
-  lineBreak: lineBreak,
-  lineBreakG: lineBreakG,
-  nonASCIIwhitespace: nonASCIIwhitespace,
-  parse: parse,
-  parseExpressionAt: parseExpressionAt,
-  tokContexts: types$1,
-  tokTypes: types,
-  tokenizer: tokenizer,
-  version: version
-};
-
 class GlobalScope extends Scope$1 {
     constructor() {
         super();
@@ -19104,7 +19284,7 @@ base.ImportDeclaration = function (node, st, c) {
 base.ImportExpression = function (node, st, c) {
   c(node.source, st, "Expression");
 };
-base.ImportSpecifier = base.ImportDefaultSpecifier = base.ImportNamespaceSpecifier = base.Identifier = base.Literal = ignore;
+base.ImportSpecifier = base.ImportDefaultSpecifier = base.ImportNamespaceSpecifier = base.Identifier = base.PrivateIdentifier = base.Literal = ignore;
 
 base.TaggedTemplateExpression = function (node, st, c) {
   c(node.tag, st, "Expression");
@@ -19124,9 +19304,9 @@ base.ClassBody = function (node, st, c) {
     c(elt, st);
   }
 };
-base.MethodDefinition = base.Property = function (node, st, c) {
+base.MethodDefinition = base.PropertyDefinition = base.Property = function (node, st, c) {
   if (node.computed) { c(node.key, st, "Expression"); }
-  c(node.value, st, "Expression");
+  if (node.value) { c(node.value, st, "Expression"); }
 };
 
 // patch up acorn-walk until class-fields are officially supported
@@ -19138,10 +19318,30 @@ base.PropertyDefinition = function (node, st, c) {
         c(node.value, st, 'Expression');
     }
 };
+function isOnlyWhitespaceOrComments(code) {
+    // streamline the typical case
+    if (/^\s*$/.test(code))
+        return true;
+    try {
+        // successful only if it's a valid Program without statements
+        const ast = parse(code, { ecmaVersion: 'latest' });
+        return ast.body && ast.body.length === 0;
+    }
+    catch (_a) {
+        // should only be reached by invalid annotations like:
+        //
+        //   foo() /*@__PURE__*/ /* other */, bar();
+        //
+        // where `code` is " /* other */, "
+    }
+    return false;
+}
 function handlePureAnnotationsOfNode(node, state, type = node.type) {
     let commentNode = state.commentNodes[state.commentIndex];
     while (commentNode && node.start >= commentNode.end) {
-        markPureNode(node, commentNode);
+        const between = state.code.substring(commentNode.end, node.start);
+        if (isOnlyWhitespaceOrComments(between))
+            markPureNode(node, commentNode);
         commentNode = state.commentNodes[++state.commentIndex];
     }
     if (commentNode && commentNode.end <= node.end) {
@@ -19169,8 +19369,9 @@ function markPureNode(node, comment) {
 }
 const pureCommentRegex = /[@#]__PURE__/;
 const isPureComment = (comment) => pureCommentRegex.test(comment.value);
-function markPureCallExpressions(comments, esTreeAst) {
+function markPureCallExpressions(comments, esTreeAst, code) {
     handlePureAnnotationsOfNode(esTreeAst, {
+        code,
         commentIndex: 0,
         commentNodes: comments.filter(isPureComment)
     });
@@ -19277,7 +19478,7 @@ class Graph {
             onCommentOrig.push(...comments);
         }
         options.onComment = onCommentOrig;
-        markPureCallExpressions(comments, ast);
+        markPureCallExpressions(comments, ast, code);
         return ast;
     }
     getCache() {
@@ -19401,363 +19602,6 @@ function ensureArray(items) {
     return [];
 }
 
-function getAugmentedNamespace(n) {
-	if (n.__esModule) return n;
-	var a = Object.defineProperty({}, '__esModule', {value: true});
-	Object.keys(n).forEach(function (k) {
-		var d = Object.getOwnPropertyDescriptor(n, k);
-		Object.defineProperty(a, k, d.get ? d : {
-			enumerable: true,
-			get: function () {
-				return n[k];
-			}
-		});
-	});
-	return a;
-}
-
-var require$$1 = /*@__PURE__*/getAugmentedNamespace(acorn);
-
-const getPrototype = Object.getPrototypeOf || (o => o.__proto__);
-
-const getAcorn$1 = Parser => {
-  if (Parser.acorn) return Parser.acorn
-
-  const acorn = require$$1;
-
-  if (acorn.version.indexOf("6.") != 0 && acorn.version.indexOf("6.0.") == 0 && acorn.version.indexOf("7.") != 0) {
-    throw new Error(`acorn-private-class-elements requires acorn@^6.1.0 or acorn@7.0.0, not ${acorn.version}`)
-  }
-
-  // Make sure `Parser` comes from the same acorn as we `require`d,
-  // otherwise the comparisons fail.
-  for (let cur = Parser; cur && cur !== acorn.Parser; cur = getPrototype(cur)) {
-    if (cur !== acorn.Parser) {
-      throw new Error("acorn-private-class-elements does not support mixing different acorn copies")
-    }
-  }
-  return acorn
-};
-
-var acornPrivateClassElements = function(Parser) {
-  // Only load this plugin once.
-  if (Parser.prototype.parsePrivateName) {
-    return Parser
-  }
-
-  const acorn = getAcorn$1(Parser);
-
-  Parser = class extends Parser {
-    _branch() {
-      this.__branch = this.__branch || new Parser({ecmaVersion: this.options.ecmaVersion}, this.input);
-      this.__branch.end = this.end;
-      this.__branch.pos = this.pos;
-      this.__branch.type = this.type;
-      this.__branch.value = this.value;
-      this.__branch.containsEsc = this.containsEsc;
-      return this.__branch
-    }
-
-    parsePrivateClassElementName(element) {
-      element.computed = false;
-      element.key = this.parsePrivateName();
-      if (element.key.name == "constructor") this.raise(element.key.start, "Classes may not have a private element named constructor");
-      const accept = {get: "set", set: "get"}[element.kind];
-      const privateBoundNames = this._privateBoundNames;
-      if (Object.prototype.hasOwnProperty.call(privateBoundNames, element.key.name) && privateBoundNames[element.key.name] !== accept) {
-        this.raise(element.start, "Duplicate private element");
-      }
-      privateBoundNames[element.key.name] = element.kind || true;
-      delete this._unresolvedPrivateNames[element.key.name];
-      return element.key
-    }
-
-    parsePrivateName() {
-      const node = this.startNode();
-      node.name = this.value;
-      this.next();
-      this.finishNode(node, "PrivateIdentifier");
-      if (this.options.allowReserved == "never") this.checkUnreserved(node);
-      return node
-    }
-
-    // Parse # token
-    getTokenFromCode(code) {
-      if (code === 35) {
-        ++this.pos;
-        const word = this.readWord1();
-        return this.finishToken(this.privateIdentifierToken, word)
-      }
-      return super.getTokenFromCode(code)
-    }
-
-    // Manage stacks and check for undeclared private names
-    parseClass(node, isStatement) {
-      const oldOuterPrivateBoundNames = this._outerPrivateBoundNames;
-      this._outerPrivateBoundNames = this._privateBoundNames;
-      this._privateBoundNames = Object.create(this._privateBoundNames || null);
-      const oldOuterUnresolvedPrivateNames = this._outerUnresolvedPrivateNames;
-      this._outerUnresolvedPrivateNames = this._unresolvedPrivateNames;
-      this._unresolvedPrivateNames = Object.create(null);
-
-      const _return = super.parseClass(node, isStatement);
-
-      const unresolvedPrivateNames = this._unresolvedPrivateNames;
-      this._privateBoundNames = this._outerPrivateBoundNames;
-      this._outerPrivateBoundNames = oldOuterPrivateBoundNames;
-      this._unresolvedPrivateNames = this._outerUnresolvedPrivateNames;
-      this._outerUnresolvedPrivateNames = oldOuterUnresolvedPrivateNames;
-      if (!this._unresolvedPrivateNames) {
-        const names = Object.keys(unresolvedPrivateNames);
-        if (names.length) {
-          names.sort((n1, n2) => unresolvedPrivateNames[n1] - unresolvedPrivateNames[n2]);
-          this.raise(unresolvedPrivateNames[names[0]], "Usage of undeclared private name");
-        }
-      } else Object.assign(this._unresolvedPrivateNames, unresolvedPrivateNames);
-      return _return
-    }
-
-    // Class heritage is evaluated with outer private environment
-    parseClassSuper(node) {
-      const privateBoundNames = this._privateBoundNames;
-      this._privateBoundNames = this._outerPrivateBoundNames;
-      const unresolvedPrivateNames = this._unresolvedPrivateNames;
-      this._unresolvedPrivateNames = this._outerUnresolvedPrivateNames;
-      const _return = super.parseClassSuper(node);
-      this._privateBoundNames = privateBoundNames;
-      this._unresolvedPrivateNames = unresolvedPrivateNames;
-      return _return
-    }
-
-    // Parse private element access
-    parseSubscript(base, startPos, startLoc, _noCalls, _maybeAsyncArrow, _optionalChained) {
-      const optionalSupported = this.options.ecmaVersion >= 11 && acorn.tokTypes.questionDot;
-      const branch = this._branch();
-      if (!(
-        (branch.eat(acorn.tokTypes.dot) || (optionalSupported && branch.eat(acorn.tokTypes.questionDot))) &&
-        branch.type == this.privateIdentifierToken
-      )) {
-        return super.parseSubscript.apply(this, arguments)
-      }
-      let optional = false;
-      if (!this.eat(acorn.tokTypes.dot)) {
-        this.expect(acorn.tokTypes.questionDot);
-        optional = true;
-      }
-      let node = this.startNodeAt(startPos, startLoc);
-      node.object = base;
-      node.computed = false;
-      if (optionalSupported) {
-        node.optional = optional;
-      }
-      if (this.type == this.privateIdentifierToken) {
-        if (base.type == "Super") {
-          this.raise(this.start, "Cannot access private element on super");
-        }
-        node.property = this.parsePrivateName();
-        if (!this._privateBoundNames || !this._privateBoundNames[node.property.name]) {
-          if (!this._unresolvedPrivateNames) {
-            this.raise(node.property.start, "Usage of undeclared private name");
-          }
-          this._unresolvedPrivateNames[node.property.name] = node.property.start;
-        }
-      } else {
-        node.property = this.parseIdent(true);
-      }
-      return this.finishNode(node, "MemberExpression")
-    }
-
-    // Prohibit delete of private class elements
-    parseMaybeUnary(refDestructuringErrors, sawUnary) {
-      const _return = super.parseMaybeUnary(refDestructuringErrors, sawUnary);
-      if (_return.operator == "delete") {
-        if (_return.argument.type == "MemberExpression" && _return.argument.property.type == "PrivateIdentifier") {
-          this.raise(_return.start, "Private elements may not be deleted");
-        }
-      }
-      return _return
-    }
-  };
-  Parser.prototype.privateIdentifierToken = new acorn.TokenType("privateIdentifier");
-  return Parser
-};
-
-const privateClassElements$1 = acornPrivateClassElements;
-
-var acornClassFields = function(Parser) {
-  const acorn = Parser.acorn || require$$1;
-  const tt = acorn.tokTypes;
-
-  Parser = privateClassElements$1(Parser);
-  return class extends Parser {
-    _maybeParseFieldValue(field) {
-      if (this.eat(tt.eq)) {
-        const oldInFieldValue = this._inFieldValue;
-        this._inFieldValue = true;
-        if (this.type === tt.name && this.value === "await" && (this.inAsync || this.options.allowAwaitOutsideFunction)) {
-          field.value = this.parseAwait();
-        } else field.value = this.parseExpression();
-        this._inFieldValue = oldInFieldValue;
-      } else field.value = null;
-    }
-
-    // Parse fields
-    parseClassElement(_constructorAllowsSuper) {
-      if (this.options.ecmaVersion >= 8 && (this.type == tt.name || this.type.keyword || this.type == this.privateIdentifierToken || this.type == tt.bracketL || this.type == tt.string || this.type == tt.num)) {
-        const branch = this._branch();
-        if (branch.type == tt.bracketL) {
-          let count = 0;
-          do {
-            if (branch.eat(tt.bracketL)) ++count;
-            else if (branch.eat(tt.bracketR)) --count;
-            else branch.next();
-          } while (count > 0)
-        } else branch.next(true);
-        let isField = branch.type == tt.eq || branch.type == tt.semi;
-        if (!isField && branch.canInsertSemicolon()) {
-          isField = branch.type != tt.parenL;
-        }
-        if (isField) {
-          const node = this.startNode();
-          if (this.type == this.privateIdentifierToken) {
-            this.parsePrivateClassElementName(node);
-          } else {
-            this.parsePropertyName(node);
-          }
-          if ((node.key.type === "Identifier" && node.key.name === "constructor") ||
-              (node.key.type === "Literal" && node.key.value === "constructor")) {
-            this.raise(node.key.start, "Classes may not have a field called constructor");
-          }
-          this.enterScope(64 | 2 | 1); // See acorn's scopeflags.js
-          this._maybeParseFieldValue(node);
-          this.exitScope();
-          this.finishNode(node, "PropertyDefinition");
-          this.semicolon();
-          return node
-        }
-      }
-
-      return super.parseClassElement.apply(this, arguments)
-    }
-
-    // Prohibit arguments in class field initializers
-    parseIdent(liberal, isBinding) {
-      const ident = super.parseIdent(liberal, isBinding);
-      if (this._inFieldValue && ident.name == "arguments") this.raise(ident.start, "A class field initializer may not contain arguments");
-      return ident
-    }
-  }
-};
-
-// eslint-disable-next-line node/no-unsupported-features/es-syntax
-
-// eslint-disable-next-line node/no-unsupported-features/es-syntax
-function privateMethods(Parser) {
-  const ExtendedParser = acornPrivateClassElements(Parser);
-
-  return class extends ExtendedParser {
-    // Parse private methods
-    parseClassElement(_constructorAllowsSuper) {
-      const oldInClassMemberName = this._inClassMemberName;
-      this._inClassMemberName = true;
-      const result = super.parseClassElement.apply(this, arguments);
-      this._inClassMemberName = oldInClassMemberName;
-      return result
-    }
-
-    parsePropertyName(prop) {
-      const isPrivate = this.options.ecmaVersion >= 8 && this._inClassMemberName && this.type == this.privateIdentifierToken && !prop.static;
-      this._inClassMemberName = false;
-      if (!isPrivate) return super.parsePropertyName(prop)
-      return this.parsePrivateClassElementName(prop)
-    }
-  }
-}
-
-const privateClassElements = acornPrivateClassElements;
-
-var acornStaticClassFeatures = function(Parser) {
-  const ExtendedParser = privateClassElements(Parser);
-
-  const acorn = Parser.acorn || require$$1;
-  const tt = acorn.tokTypes;
-
-  return class extends ExtendedParser {
-    _maybeParseFieldValue(field) {
-      if (this.eat(tt.eq)) {
-        const oldInFieldValue = this._inStaticFieldScope;
-        this._inStaticFieldScope = this.currentThisScope();
-        field.value = this.parseExpression();
-        this._inStaticFieldScope = oldInFieldValue;
-      } else field.value = null;
-    }
-
-    // Parse fields
-    parseClassElement(_constructorAllowsSuper) {
-      if (this.options.ecmaVersion < 8 || !this.isContextual("static")) {
-        return super.parseClassElement.apply(this, arguments)
-      }
-
-      const branch = this._branch();
-      branch.next();
-      if ([tt.name, tt.bracketL, tt.string, tt.num, this.privateIdentifierToken].indexOf(branch.type) == -1 && !branch.type.keyword) {
-        return super.parseClassElement.apply(this, arguments)
-      }
-      if (branch.type == tt.bracketL) {
-        let count = 0;
-        do {
-          if (branch.eat(tt.bracketL)) ++count;
-          else if (branch.eat(tt.bracketR)) --count;
-          else branch.next();
-        } while (count > 0)
-      } else branch.next();
-      if (branch.type != tt.eq && !branch.canInsertSemicolon() && branch.type != tt.semi) {
-        return super.parseClassElement.apply(this, arguments)
-      }
-
-      const node = this.startNode();
-      node.static = this.eatContextual("static");
-      if (this.type == this.privateIdentifierToken) {
-        this.parsePrivateClassElementName(node);
-      } else {
-        this.parsePropertyName(node);
-      }
-      if ((node.key.type === "Identifier" && node.key.name === "constructor") ||
-          (node.key.type === "Literal" && !node.computed && node.key.value === "constructor")) {
-        this.raise(node.key.start, "Classes may not have a field called constructor");
-      }
-      if ((node.key.name || node.key.value) === "prototype" && !node.computed) {
-        this.raise(node.key.start, "Classes may not have a static property named prototype");
-      }
-
-      this.enterScope(64 | 2 | 1); // See acorn's scopeflags.js
-      this._maybeParseFieldValue(node);
-      this.exitScope();
-      this.finishNode(node, "PropertyDefinition");
-      this.semicolon();
-      return node
-    }
-
-    // Parse private static methods
-    parsePropertyName(prop) {
-      if (prop.static && this.type == this.privateIdentifierToken) {
-        this.parsePrivateClassElementName(prop);
-      } else {
-        super.parsePropertyName(prop);
-      }
-    }
-
-    // Prohibit arguments in class field initializers
-    parseIdent(liberal, isBinding) {
-      const ident = super.parseIdent(liberal, isBinding);
-      if (this._inStaticFieldScope && this.currentThisScope() === this._inStaticFieldScope && ident.name == "arguments") {
-        this.raise(ident.start, "A static class field initializer may not contain arguments");
-      }
-      return ident
-    }
-  }
-};
-
 const defaultOnWarn = warning => console.warn(warning.message || warning);
 function warnUnknownOptions(passedOptions, validOptions, optionType, warn, ignoredKeys = /$./) {
     const validOptionSet = new Set(validOptions);
@@ -19830,12 +19674,7 @@ const getAcorn = (config) => ({
     sourceType: 'module',
     ...config.acorn
 });
-const getAcornInjectPlugins = (config) => [
-    acornClassFields,
-    privateMethods,
-    acornStaticClassFeatures,
-    ...ensureArray(config.acornInjectPlugins)
-];
+const getAcornInjectPlugins = (config) => ensureArray(config.acornInjectPlugins);
 const getCache = (config) => {
     var _a;
     return ((_a = config.cache) === null || _a === void 0 ? void 0 : _a.cache) || config.cache;
@@ -20236,7 +20075,10 @@ const getManualChunks = (config, inlineDynamicImports, preserveModules, inputOpt
     }
     return configManualChunks || {};
 };
-const getMinifyInternalExports = (config, format, compact) => { var _a; return (_a = config.minifyInternalExports) !== null && _a !== void 0 ? _a : (compact || format === 'es' || format === 'system'); };
+const getMinifyInternalExports = (config, format, compact) => {
+    var _a;
+    return (_a = config.minifyInternalExports) !== null && _a !== void 0 ? _a : (compact || format === 'es' || format === 'system');
+};
 
 function rollup(rawInputOptions) {
     return rollupInternal(rawInputOptions, null);
@@ -20453,4 +20295,4 @@ function watch(configs) {
     return emitter;
 }
 
-export { defaultOnWarn, ensureArray, fseventsImporter, getAugmentedNamespace, rollup, rollupInternal, version$1 as version, warnUnknownOptions, watch };
+export { defaultOnWarn, ensureArray, fseventsImporter, rollup, rollupInternal, version$1 as version, warnUnknownOptions, watch };