immosquare-cleaner 0.1.64 → 0.1.66

data/node_modules/@babel/parser/lib/index.js

@@ -7,7 +7,7 @@ function _objectWithoutPropertiesLoose(r, e) {
   if (null == r) return {};
   var t = {};
   for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
-    if (e.includes(n)) continue;
+    if (-1 !== e.indexOf(n)) continue;
     t[n] = r[n];
   }
   return t;
@@ -307,7 +307,7 @@ var StrictModeErrors = {
   StrictWith: "'with' in strict mode."
 };
 const UnparenthesizedPipeBodyDescriptions = new Set(["ArrowFunctionExpression", "AssignmentExpression", "ConditionalExpression", "YieldExpression"]);
-var PipelineOperatorErrors = {
+var PipelineOperatorErrors = Object.assign({
   PipeBodyIsTighter: "Unexpected yield after pipeline body; any yield expression acting as Hack-style pipe body must be parenthesized due to its loose operator precedence.",
   PipeTopicRequiresHackPipes: 'Topic reference is used, but the pipelineOperator plugin was not passed a "proposal": "hack" or "smart" option.',
   PipeTopicUnbound: "Topic reference is unbound; it must be inside a pipe body.",
@@ -319,14 +319,15 @@ var PipelineOperatorErrors = {
     type
   }) => `Hack-style pipe body cannot be an unparenthesized ${toNodeDescription({
     type
-  })}; please wrap it in parentheses.`,
+  })}; please wrap it in parentheses.`
+}, {
   PipelineBodyNoArrow: 'Unexpected arrow "=>" after pipeline body; arrow function in pipeline body must be parenthesized.',
   PipelineBodySequenceExpression: "Pipeline body may not be a comma-separated sequence expression.",
   PipelineHeadSequenceExpression: "Pipeline head should not be a comma-separated sequence expression.",
   PipelineTopicUnused: "Pipeline is in topic style but does not use topic reference.",
   PrimaryTopicNotAllowed: "Topic reference was used in a lexical context without topic binding.",
   PrimaryTopicRequiresSmartPipeline: 'Topic reference is used, but the pipelineOperator plugin was not passed a "proposal": "hack" or "smart" option.'
-};
+});
 const _excluded = ["message"];
 function defineHidden(obj, key, value) {
   Object.defineProperty(obj, key, {
@@ -420,6 +421,54 @@ function ParseErrorEnum(argument, syntaxPlugin) {
   return ParseErrorConstructors;
 }
 const Errors = Object.assign({}, ParseErrorEnum(ModuleErrors), ParseErrorEnum(StandardErrors), ParseErrorEnum(StrictModeErrors), ParseErrorEnum`pipelineOperator`(PipelineOperatorErrors));
+function createDefaultOptions() {
+  return {
+    sourceType: "script",
+    sourceFilename: undefined,
+    startIndex: 0,
+    startColumn: 0,
+    startLine: 1,
+    allowAwaitOutsideFunction: false,
+    allowReturnOutsideFunction: false,
+    allowNewTargetOutsideFunction: false,
+    allowImportExportEverywhere: false,
+    allowSuperOutsideMethod: false,
+    allowUndeclaredExports: false,
+    plugins: [],
+    strictMode: null,
+    ranges: false,
+    tokens: false,
+    createImportExpressions: false,
+    createParenthesizedExpressions: false,
+    errorRecovery: false,
+    attachComment: true,
+    annexB: true
+  };
+}
+function getOptions(opts) {
+  const options = createDefaultOptions();
+  if (opts == null) {
+    return options;
+  }
+  if (opts.annexB != null && opts.annexB !== false) {
+    throw new Error("The `annexB` option can only be set to `false`.");
+  }
+  for (const key of Object.keys(options)) {
+    if (opts[key] != null) options[key] = opts[key];
+  }
+  if (options.startLine === 1) {
+    if (opts.startIndex == null && options.startColumn > 0) {
+      options.startIndex = options.startColumn;
+    } else if (opts.startColumn == null && options.startIndex > 0) {
+      options.startColumn = options.startIndex;
+    }
+  } else if (opts.startColumn == null || opts.startIndex == null) {
+    if (opts.startIndex != null) {
+      throw new Error("With a `startLine > 1` you must also specify `startIndex` and `startColumn`.");
+    }
+  }
+  return options;
+}
 const {
   defineProperty
 } = Object;
@@ -439,7 +488,7 @@ function toESTreeLocation(node) {
 var estree = superClass => class ESTreeParserMixin extends superClass {
   parse() {
     const file = toESTreeLocation(super.parse());
-    if (this.options.tokens) {
+    if (this.optionFlags & 128) {
       file.tokens = file.tokens.map(toESTreeLocation);
     }
     return file;
@@ -528,14 +577,6 @@ var estree = superClass => class ESTreeParserMixin extends superClass {
     node.body = directiveStatements.concat(node.body);
     delete node.directives;
   }
-  pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
-    this.parseMethod(method, isGenerator, isAsync, isConstructor, allowsDirectSuper, "ClassMethod", true);
-    if (method.typeParameters) {
-      method.value.typeParameters = method.typeParameters;
-      delete method.typeParameters;
-    }
-    classBody.body.push(method);
-  }
   parsePrivateName() {
     const node = super.parsePrivateName();
     {
@@ -586,6 +627,14 @@ var estree = superClass => class ESTreeParserMixin extends superClass {
     funcNode.type = "FunctionExpression";
     delete funcNode.kind;
     node.value = funcNode;
+    const {
+      typeParameters
+    } = node;
+    if (typeParameters) {
+      delete node.typeParameters;
+      funcNode.typeParameters = typeParameters;
+      this.resetStartLocationFromNode(funcNode, typeParameters);
+    }
     if (type === "ClassPrivateMethod") {
       node.computed = false;
     }
@@ -602,7 +651,9 @@ var estree = superClass => class ESTreeParserMixin extends superClass {
         return propertyNode;
       }
     }
-    propertyNode.type = "PropertyDefinition";
+    {
+      propertyNode.type = "PropertyDefinition";
+    }
     return propertyNode;
   }
   parseClassPrivateProperty(...args) {
@@ -612,7 +663,9 @@ var estree = superClass => class ESTreeParserMixin extends superClass {
         return propertyNode;
       }
     }
-    propertyNode.type = "PropertyDefinition";
+    {
+      propertyNode.type = "PropertyDefinition";
+    }
     propertyNode.computed = false;
     return propertyNode;
   }
@@ -1734,6 +1787,14 @@ class CommentsParser extends BaseParser {
           case "ImportDeclaration":
             adjustInnerComments(node, node.specifiers, commentWS);
             break;
+          case "TSEnumDeclaration":
+            {
+              adjustInnerComments(node, node.members, commentWS);
+            }
+            break;
+          case "TSEnumBody":
+            adjustInnerComments(node, node.members, commentWS);
+            break;
           default:
             {
               setInnerComments(node, comments);
@@ -2313,7 +2374,7 @@ class Tokenizer extends CommentsParser {
     this.tokens = [];
     this.errorHandlers_readInt = {
       invalidDigit: (pos, lineStart, curLine, radix) => {
-        if (!this.options.errorRecovery) return false;
+        if (!(this.optionFlags & 1024)) return false;
         this.raise(Errors.InvalidDigit, buildPosition(pos, lineStart, curLine), {
           radix
         });
@@ -2354,7 +2415,7 @@ class Tokenizer extends CommentsParser {
   }
   next() {
     this.checkKeywordEscapes();
-    if (this.options.tokens) {
+    if (this.optionFlags & 128) {
       this.pushToken(new Token(this.state));
     }
     this.state.lastTokEndLoc = this.state.endLoc;
@@ -2470,7 +2531,7 @@ class Tokenizer extends CommentsParser {
       end: this.sourceToOffsetPos(end + commentEnd.length),
       loc: new SourceLocation(startLoc, this.state.curPosition())
     };
-    if (this.options.tokens) this.pushToken(comment);
+    if (this.optionFlags & 128) this.pushToken(comment);
     return comment;
   }
   skipLineComment(startSkip) {
@@ -2493,12 +2554,12 @@ class Tokenizer extends CommentsParser {
       end: this.sourceToOffsetPos(end),
       loc: new SourceLocation(startLoc, this.state.curPosition())
     };
-    if (this.options.tokens) this.pushToken(comment);
+    if (this.optionFlags & 128) this.pushToken(comment);
     return comment;
   }
   skipSpace() {
     const spaceStart = this.state.pos;
-    const comments = [];
+    const comments = this.optionFlags & 2048 ? [] : null;
     loop: while (this.state.pos < this.length) {
       const ch = this.input.charCodeAt(this.state.pos);
       switch (ch) {
@@ -2525,7 +2586,7 @@ class Tokenizer extends CommentsParser {
                 const comment = this.skipBlockComment("*/");
                 if (comment !== undefined) {
                   this.addComment(comment);
-                  if (this.options.attachComment) comments.push(comment);
+                  comments == null || comments.push(comment);
                 }
                 break;
               }
@@ -2534,7 +2595,7 @@ class Tokenizer extends CommentsParser {
                 const comment = this.skipLineComment(2);
                 if (comment !== undefined) {
                   this.addComment(comment);
-                  if (this.options.attachComment) comments.push(comment);
+                  comments == null || comments.push(comment);
                 }
                 break;
               }
@@ -2545,24 +2606,24 @@ class Tokenizer extends CommentsParser {
         default:
           if (isWhitespace(ch)) {
             ++this.state.pos;
-          } else if (ch === 45 && !this.inModule && this.options.annexB) {
+          } else if (ch === 45 && !this.inModule && this.optionFlags & 4096) {
             const pos = this.state.pos;
             if (this.input.charCodeAt(pos + 1) === 45 && this.input.charCodeAt(pos + 2) === 62 && (spaceStart === 0 || this.state.lineStart > spaceStart)) {
               const comment = this.skipLineComment(3);
               if (comment !== undefined) {
                 this.addComment(comment);
-                if (this.options.attachComment) comments.push(comment);
+                comments == null || comments.push(comment);
               }
             } else {
               break loop;
             }
-          } else if (ch === 60 && !this.inModule && this.options.annexB) {
+          } else if (ch === 60 && !this.inModule && this.optionFlags & 4096) {
             const pos = this.state.pos;
             if (this.input.charCodeAt(pos + 1) === 33 && this.input.charCodeAt(pos + 2) === 45 && this.input.charCodeAt(pos + 3) === 45) {
               const comment = this.skipLineComment(4);
               if (comment !== undefined) {
                 this.addComment(comment);
-                if (this.options.attachComment) comments.push(comment);
+                comments == null || comments.push(comment);
               }
             } else {
               break loop;
@@ -2572,7 +2633,7 @@ class Tokenizer extends CommentsParser {
           }
       }
     }
-    if (comments.length > 0) {
+    if ((comments == null ? void 0 : comments.length) > 0) {
       const end = this.state.pos;
       const commentWhitespace = {
         start: this.sourceToOffsetPos(spaceStart),
@@ -3264,7 +3325,7 @@ class Tokenizer extends CommentsParser {
   raise(toParseError, at, details = {}) {
     const loc = at instanceof Position ? at : at.loc.start;
     const error = toParseError(loc, details);
-    if (!this.options.errorRecovery) throw error;
+    if (!(this.optionFlags & 1024)) throw error;
     if (!this.isLookahead) this.state.errors.push(error);
     return error;
   }
@@ -3748,7 +3809,7 @@ class Node {
     this.start = pos;
     this.end = 0;
     this.loc = new SourceLocation(loc);
-    if (parser != null && parser.options.ranges) this.range = [pos, 0];
+    if ((parser == null ? void 0 : parser.optionFlags) & 64) this.range = [pos, 0];
     if (parser != null && parser.filename) this.loc.filename = parser.filename;
   }
 }
@@ -3836,19 +3897,21 @@ class NodeUtils extends UtilParser {
     node.type = type;
     node.end = endLoc.index;
     node.loc.end = endLoc;
-    if (this.options.ranges) node.range[1] = endLoc.index;
-    if (this.options.attachComment) this.processComment(node);
+    if (this.optionFlags & 64) node.range[1] = endLoc.index;
+    if (this.optionFlags & 2048) {
+      this.processComment(node);
+    }
     return node;
   }
   resetStartLocation(node, startLoc) {
     node.start = startLoc.index;
     node.loc.start = startLoc;
-    if (this.options.ranges) node.range[0] = startLoc.index;
+    if (this.optionFlags & 64) node.range[0] = startLoc.index;
   }
   resetEndLocation(node, endLoc = this.state.lastTokEndLoc) {
     node.end = endLoc.index;
     node.loc.end = endLoc;
-    if (this.options.ranges) node.range[1] = endLoc.index;
+    if (this.optionFlags & 64) node.range[1] = endLoc.index;
   }
   resetStartLocationFromNode(node, locationNode) {
     this.resetStartLocation(node, locationNode.loc.start);
@@ -4356,26 +4419,49 @@ var flow = superClass => class FlowParserMixin extends superClass {
     this.state.inType = oldInType;
     return this.finishNode(node, "TypeParameterDeclaration");
   }
+  flowInTopLevelContext(cb) {
+    if (this.curContext() !== types.brace) {
+      const oldContext = this.state.context;
+      this.state.context = [oldContext[0]];
+      try {
+        return cb();
+      } finally {
+        this.state.context = oldContext;
+      }
+    } else {
+      return cb();
+    }
+  }
+  flowParseTypeParameterInstantiationInExpression() {
+    if (this.reScan_lt() !== 47) return;
+    return this.flowParseTypeParameterInstantiation();
+  }
   flowParseTypeParameterInstantiation() {
     const node = this.startNode();
     const oldInType = this.state.inType;
-    node.params = [];
     this.state.inType = true;
-    this.expect(47);
-    const oldNoAnonFunctionType = this.state.noAnonFunctionType;
-    this.state.noAnonFunctionType = false;
-    while (!this.match(48)) {
-      node.params.push(this.flowParseType());
-      if (!this.match(48)) {
-        this.expect(12);
+    node.params = [];
+    this.flowInTopLevelContext(() => {
+      this.expect(47);
+      const oldNoAnonFunctionType = this.state.noAnonFunctionType;
+      this.state.noAnonFunctionType = false;
+      while (!this.match(48)) {
+        node.params.push(this.flowParseType());
+        if (!this.match(48)) {
+          this.expect(12);
+        }
       }
+      this.state.noAnonFunctionType = oldNoAnonFunctionType;
+    });
+    this.state.inType = oldInType;
+    if (!this.state.inType && this.curContext() === types.brace) {
+      this.reScan_lt_gt();
     }
-    this.state.noAnonFunctionType = oldNoAnonFunctionType;
     this.expect(48);
-    this.state.inType = oldInType;
     return this.finishNode(node, "TypeParameterInstantiation");
   }
   flowParseTypeParameterInstantiationCallOrNew() {
+    if (this.reScan_lt() !== 47) return;
     const node = this.startNode();
     const oldInType = this.state.inType;
     node.params = [];
@@ -4655,8 +4741,7 @@ var flow = superClass => class FlowParserMixin extends superClass {
     }
   }
   flowParseQualifiedTypeIdentifier(startLoc, id) {
-    var _startLoc;
-    (_startLoc = startLoc) != null ? _startLoc : startLoc = this.state.startLoc;
+    startLoc != null ? startLoc : startLoc = this.state.startLoc;
     let node = id || this.flowParseRestrictedIdentifier(true);
     while (this.eat(16)) {
       const node2 = this.startNodeAt(startLoc);
@@ -5429,8 +5514,10 @@ var flow = superClass => class FlowParserMixin extends superClass {
   }
   parseClassSuper(node) {
     super.parseClassSuper(node);
-    if (node.superClass && this.match(47)) {
-      node.superTypeParameters = this.flowParseTypeParameterInstantiation();
+    if (node.superClass && (this.match(47) || this.match(51))) {
+      {
+        node.superTypeParameters = this.flowParseTypeParameterInstantiationInExpression();
+      }
     }
     if (this.isContextual(113)) {
       this.next();
@@ -5761,12 +5848,12 @@ var flow = superClass => class FlowParserMixin extends superClass {
       this.next();
       const node = this.startNodeAt(startLoc);
       node.callee = base;
-      node.typeArguments = this.flowParseTypeParameterInstantiation();
+      node.typeArguments = this.flowParseTypeParameterInstantiationInExpression();
       this.expect(10);
       node.arguments = this.parseCallExpressionArguments(11);
       node.optional = true;
       return this.finishCallExpression(node, true);
-    } else if (!noCalls && this.shouldParseTypes() && this.match(47)) {
+    } else if (!noCalls && this.shouldParseTypes() && (this.match(47) || this.match(51))) {
       const node = this.startNodeAt(startLoc);
       node.callee = base;
       const result = this.tryParse(() => {
@@ -6195,6 +6282,14 @@ var flow = superClass => class FlowParserMixin extends superClass {
     node.body = this.flowEnumBody(this.startNode(), id);
     return this.finishNode(node, "EnumDeclaration");
   }
+  jsxParseOpeningElementAfterName(node) {
+    if (this.shouldParseTypes()) {
+      if (this.match(47) || this.match(51)) {
+        node.typeArguments = this.flowParseTypeParameterInstantiationInExpression();
+      }
+    }
+    return super.jsxParseOpeningElementAfterName(node);
+  }
   isLookaheadToken_lt() {
     const next = this.nextTokenStart();
     if (this.input.charCodeAt(next) === 60) {
@@ -6203,6 +6298,29 @@ var flow = superClass => class FlowParserMixin extends superClass {
     }
     return false;
   }
+  reScan_lt_gt() {
+    const {
+      type
+    } = this.state;
+    if (type === 47) {
+      this.state.pos -= 1;
+      this.readToken_lt();
+    } else if (type === 48) {
+      this.state.pos -= 1;
+      this.readToken_gt();
+    }
+  }
+  reScan_lt() {
+    const {
+      type
+    } = this.state;
+    if (type === 51) {
+      this.state.pos -= 2;
+      this.finishOp(47, 1);
+      return 47;
+    }
+    return type;
+  }
   maybeUnwrapTypeCastExpression(node) {
     return node.type === "TypeCastExpression" ? node.expression : node;
   }
@@ -7079,14 +7197,7 @@ class LValParser extends NodeUtils {
     for (let i = 0; i <= end; i++) {
       const elt = exprList[i];
       if (!elt) continue;
-      if (elt.type === "SpreadElement") {
-        elt.type = "RestElement";
-        const arg = elt.argument;
-        this.checkToRestConversion(arg, true);
-        this.toAssignable(arg, isLHS);
-      } else {
-        this.toAssignable(elt, isLHS);
-      }
+      this.toAssignableListItem(exprList, i, isLHS);
       if (elt.type === "RestElement") {
         if (i < end) {
           this.raise(Errors.RestTrailingComma, elt);
@@ -7096,6 +7207,17 @@ class LValParser extends NodeUtils {
       }
     }
   }
+  toAssignableListItem(exprList, index, isLHS) {
+    const node = exprList[index];
+    if (node.type === "SpreadElement") {
+      node.type = "RestElement";
+      const arg = node.argument;
+      this.checkToRestConversion(arg, true);
+      this.toAssignable(arg, isLHS);
+    } else {
+      this.toAssignable(node, isLHS);
+    }
+  }
   isAssignable(node, isBinding) {
     switch (node.type) {
       case "Identifier":
@@ -7191,13 +7313,15 @@ class LValParser extends NodeUtils {
         }
       } else {
         const decorators = [];
-        if (this.match(26) && this.hasPlugin("decorators")) {
-          this.raise(Errors.UnsupportedParameterDecorator, this.state.startLoc);
-        }
-        while (this.match(26)) {
-          decorators.push(this.parseDecorator());
+        if (flags & 2) {
+          if (this.match(26) && this.hasPlugin("decorators")) {
+            this.raise(Errors.UnsupportedParameterDecorator, this.state.startLoc);
+          }
+          while (this.match(26)) {
+            decorators.push(this.parseDecorator());
+          }
         }
-        elts.push(this.parseAssignableListItem(flags, decorators));
+        elts.push(this.parseBindingElement(flags, decorators));
       }
     }
     return elts;
@@ -7227,7 +7351,7 @@ class LValParser extends NodeUtils {
     prop.method = false;
     return this.parseObjPropValue(prop, startLoc, false, false, true, false);
   }
-  parseAssignableListItem(flags, decorators) {
+  parseBindingElement(flags, decorators) {
     const left = this.parseMaybeDefault();
     if (this.hasPlugin("flow") || flags & 2) {
       this.parseFunctionParamType(left);
@@ -7242,9 +7366,8 @@ class LValParser extends NodeUtils {
     return param;
   }
   parseMaybeDefault(startLoc, left) {
-    var _startLoc, _left;
-    (_startLoc = startLoc) != null ? _startLoc : startLoc = this.state.startLoc;
-    left = (_left = left) != null ? _left : this.parseBindingAtom();
+    startLoc != null ? startLoc : startLoc = this.state.startLoc;
+    left = left != null ? left : this.parseBindingAtom();
     if (!this.eat(29)) return left;
     const node = this.startNodeAt(startLoc);
     node.left = left;
@@ -7434,6 +7557,9 @@ const TSErrors = ParseErrorEnum`typescript`({
   IndexSignatureHasOverride: "'override' modifier cannot appear on an index signature.",
   IndexSignatureHasStatic: "Index signatures cannot have the 'static' modifier.",
   InitializerNotAllowedInAmbientContext: "Initializers are not allowed in ambient contexts.",
+  InvalidHeritageClauseType: ({
+    token
+  }) => `'${token}' list can only include identifiers or qualified-names with optional type arguments.`,
   InvalidModifierOnTypeMember: ({
     modifier
   }) => `'${modifier}' modifier cannot appear on a type member.`,
@@ -7714,8 +7840,14 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     this.expect(10);
     if (!this.match(134)) {
       this.raise(TSErrors.UnsupportedImportTypeArgument, this.state.startLoc);
+      {
+        node.argument = super.parseExprAtom();
+      }
+    } else {
+      {
+        node.argument = this.parseStringLiteral(this.state.value);
+      }
     }
-    node.argument = super.parseExprAtom();
     if (this.eat(12) && !this.match(11)) {
       node.options = super.parseMaybeAssignAllowIn();
       this.eat(12);
@@ -7724,28 +7856,43 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     }
     this.expect(11);
     if (this.eat(16)) {
-      node.qualifier = this.tsParseEntityName();
+      node.qualifier = this.tsParseEntityName(1 | 2);
     }
     if (this.match(47)) {
-      node.typeParameters = this.tsParseTypeArguments();
+      {
+        node.typeParameters = this.tsParseTypeArguments();
+      }
     }
     return this.finishNode(node, "TSImportType");
   }
-  tsParseEntityName(allowReservedWords = true) {
-    let entity = this.parseIdentifier(allowReservedWords);
+  tsParseEntityName(flags) {
+    let entity;
+    if (flags & 1 && this.match(78)) {
+      if (flags & 2) {
+        entity = this.parseIdentifier(true);
+      } else {
+        const node = this.startNode();
+        this.next();
+        entity = this.finishNode(node, "ThisExpression");
+      }
+    } else {
+      entity = this.parseIdentifier(!!(flags & 1));
+    }
     while (this.eat(16)) {
       const node = this.startNodeAtNode(entity);
       node.left = entity;
-      node.right = this.parseIdentifier(allowReservedWords);
+      node.right = this.parseIdentifier(!!(flags & 1));
       entity = this.finishNode(node, "TSQualifiedName");
     }
     return entity;
   }
   tsParseTypeReference() {
     const node = this.startNode();
-    node.typeName = this.tsParseEntityName();
+    node.typeName = this.tsParseEntityName(1);
     if (!this.hasPrecedingLineBreak() && this.match(47)) {
-      node.typeParameters = this.tsParseTypeArguments();
+      {
+        node.typeParameters = this.tsParseTypeArguments();
+      }
     }
     return this.finishNode(node, "TSTypeReference");
   }
@@ -7768,10 +7915,14 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     if (this.match(83)) {
       node.exprName = this.tsParseImportType();
     } else {
-      node.exprName = this.tsParseEntityName();
+      {
+        node.exprName = this.tsParseEntityName(1 | 2);
+      }
     }
     if (!this.hasPrecedingLineBreak() && this.match(47)) {
-      node.typeParameters = this.tsParseTypeArguments();
+      {
+        node.typeParameters = this.tsParseTypeArguments();
+      }
     }
     return this.finishNode(node, "TSTypeQuery");
   }
@@ -8026,10 +8177,11 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     return this.finishNode(node, "TSTupleType");
   }
   tsParseTupleElementType() {
+    const restStartLoc = this.state.startLoc;
+    const rest = this.eat(21);
     const {
       startLoc
     } = this.state;
-    const rest = this.eat(21);
     let labeled;
     let label;
     let optional;
@@ -8044,7 +8196,6 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
       type = this.tsParseType();
     } else if (chAfterWord === 63) {
       optional = true;
-      const startLoc = this.state.startLoc;
       const wordName = this.state.value;
       const typeOrLabel = this.tsParseNonArrayType();
       if (this.lookaheadCharCode() === 58) {
@@ -8066,7 +8217,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     if (labeled) {
       let labeledNode;
       if (label) {
-        labeledNode = this.startNodeAtNode(label);
+        labeledNode = this.startNodeAt(startLoc);
         labeledNode.optional = optional;
         labeledNode.label = label;
         labeledNode.elementType = type;
@@ -8075,7 +8226,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
           this.raise(TSErrors.TupleOptionalAfterType, this.state.lastTokStartLoc);
         }
       } else {
-        labeledNode = this.startNodeAtNode(type);
+        labeledNode = this.startNodeAt(startLoc);
         labeledNode.optional = optional;
         this.raise(TSErrors.InvalidTupleMemberLabel, type);
         labeledNode.label = type;
@@ -8083,12 +8234,12 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
       }
       type = this.finishNode(labeledNode, "TSNamedTupleMember");
     } else if (optional) {
-      const optionalTypeNode = this.startNodeAtNode(type);
+      const optionalTypeNode = this.startNodeAt(startLoc);
       optionalTypeNode.typeAnnotation = type;
       type = this.finishNode(optionalTypeNode, "TSOptionalType");
     }
     if (rest) {
-      const restNode = this.startNodeAt(startLoc);
+      const restNode = this.startNodeAt(restStartLoc);
       restNode.typeAnnotation = type;
       type = this.finishNode(restNode, "TSRestType");
     }
@@ -8127,9 +8278,11 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     return this.finishNode(node, "TSLiteralType");
   }
   tsParseTemplateLiteralType() {
-    const node = this.startNode();
-    node.literal = super.parseTemplate(false);
-    return this.finishNode(node, "TSLiteralType");
+    {
+      const node = this.startNode();
+      node.literal = super.parseTemplate(false);
+      return this.finishNode(node, "TSLiteralType");
+    }
   }
   parseTemplateSubstitution() {
     if (this.state.inType) return this.tsParseType();
@@ -8196,15 +8349,18 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     this.unexpected();
   }
   tsParseArrayTypeOrHigher() {
+    const {
+      startLoc
+    } = this.state;
     let type = this.tsParseNonArrayType();
     while (!this.hasPrecedingLineBreak() && this.eat(0)) {
       if (this.match(3)) {
-        const node = this.startNodeAtNode(type);
+        const node = this.startNodeAt(startLoc);
         node.elementType = type;
         this.expect(3);
         type = this.finishNode(node, "TSArrayType");
       } else {
-        const node = this.startNodeAtNode(type);
+        const node = this.startNodeAt(startLoc);
         node.objectType = type;
         node.indexType = this.tsParseType();
         this.expect(3);
@@ -8456,12 +8612,14 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
   tsParseHeritageClause(token) {
     const originalStartLoc = this.state.startLoc;
     const delimitedList = this.tsParseDelimitedList("HeritageClauseElement", () => {
-      const node = this.startNode();
-      node.expression = this.tsParseEntityName();
-      if (this.match(47)) {
-        node.typeParameters = this.tsParseTypeArguments();
+      {
+        const node = this.startNode();
+        node.expression = this.tsParseEntityName(1 | 2);
+        if (this.match(47)) {
+          node.typeParameters = this.tsParseTypeArguments();
+        }
+        return this.finishNode(node, "TSExpressionWithTypeArguments");
       }
-      return this.finishNode(node, "TSExpressionWithTypeArguments");
     });
     if (!delimitedList.length) {
       this.raise(TSErrors.EmptyHeritageClauseType, originalStartLoc, {
@@ -8506,13 +8664,17 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     this.semicolon();
     return this.finishNode(node, "TSTypeAliasDeclaration");
   }
-  tsInNoContext(cb) {
-    const oldContext = this.state.context;
-    this.state.context = [oldContext[0]];
-    try {
+  tsInTopLevelContext(cb) {
+    if (this.curContext() !== types.brace) {
+      const oldContext = this.state.context;
+      this.state.context = [oldContext[0]];
+      try {
+        return cb();
+      } finally {
+        this.state.context = oldContext;
+      }
+    } else {
       return cb();
-    } finally {
-      this.state.context = oldContext;
     }
   }
   tsInType(cb) {
@@ -8573,10 +8735,19 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     this.expectContextual(126);
     node.id = this.parseIdentifier();
     this.checkIdentifier(node.id, node.const ? 8971 : 8459);
+    {
+      this.expect(5);
+      node.members = this.tsParseDelimitedList("EnumMembers", this.tsParseEnumMember.bind(this));
+      this.expect(8);
+    }
+    return this.finishNode(node, "TSEnumDeclaration");
+  }
+  tsParseEnumBody() {
+    const node = this.startNode();
     this.expect(5);
     node.members = this.tsParseDelimitedList("EnumMembers", this.tsParseEnumMember.bind(this));
     this.expect(8);
-    return this.finishNode(node, "TSEnumDeclaration");
+    return this.finishNode(node, "TSEnumBody");
   }
   tsParseModuleBlock() {
     const node = this.startNode();
@@ -8629,7 +8800,9 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     return this.finishNode(node, "TSModuleDeclaration");
   }
   tsParseImportEqualsDeclaration(node, maybeDefaultIdentifier, isExport) {
-    node.isExport = isExport || false;
+    {
+      node.isExport = isExport || false;
+    }
     node.id = maybeDefaultIdentifier || this.parseIdentifier();
     this.checkIdentifier(node.id, 4096);
     this.expect(29);
@@ -8645,7 +8818,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     return this.isContextual(119) && this.lookaheadCharCode() === 40;
   }
   tsParseModuleReference() {
-    return this.tsIsExternalModuleReference() ? this.tsParseExternalModuleReference() : this.tsParseEntityName(false);
+    return this.tsIsExternalModuleReference() ? this.tsParseExternalModuleReference() : this.tsParseEntityName(0);
   }
   tsParseExternalModuleReference() {
     const node = this.startNode();
@@ -8821,7 +8994,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
   }
   tsParseTypeArguments() {
     const node = this.startNode();
-    node.params = this.tsInType(() => this.tsInNoContext(() => {
+    node.params = this.tsInType(() => this.tsInTopLevelContext(() => {
       this.expect(47);
       return this.tsParseDelimitedList("TypeParametersOrArguments", this.tsParseType.bind(this));
     }));
@@ -8840,7 +9013,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     if (this.tsIsDeclarationStart()) return false;
     return super.isExportDefaultSpecifier();
   }
-  parseAssignableListItem(flags, decorators) {
+  parseBindingElement(flags, decorators) {
     const startLoc = this.state.startLoc;
     const modified = {};
     this.tsParseModifiers({
@@ -8966,7 +9139,9 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
         }
         if (tokenIsTemplate(this.state.type)) {
           const result = super.parseTaggedTemplateExpression(base, startLoc, state);
-          result.typeParameters = typeArguments;
+          {
+            result.typeParameters = typeArguments;
+          }
           return result;
         }
         if (!noCalls && this.eat(10)) {
@@ -8974,7 +9149,9 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
           node.callee = base;
           node.arguments = this.parseCallExpressionArguments(11);
           this.tsCheckForInvalidTypeCasts(node.arguments);
-          node.typeParameters = typeArguments;
+          {
+            node.typeParameters = typeArguments;
+          }
           if (state.optionalChainMember) {
             node.optional = isOptionalCall;
           }
@@ -8986,7 +9163,9 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
         }
         const node = this.startNodeAt(startLoc);
         node.expression = base;
-        node.typeParameters = typeArguments;
+        {
+          node.typeParameters = typeArguments;
+        }
         return this.finishNode(node, "TSInstantiationExpression");
       });
       if (missingParenErrorLoc) {
@@ -9008,7 +9187,9 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
       callee
     } = node;
     if (callee.type === "TSInstantiationExpression" && !((_callee$extra = callee.extra) != null && _callee$extra.parenthesized)) {
-      node.typeParameters = callee.typeParameters;
+      {
+        node.typeParameters = callee.typeParameters;
+      }
       node.callee = callee.expression;
     }
   }
@@ -9089,15 +9270,18 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
   }
   parseExport(node, decorators) {
     if (this.match(83)) {
-      this.next();
       const nodeImportEquals = node;
+      this.next();
       let maybeDefaultIdentifier = null;
       if (this.isContextual(130) && this.isPotentialImportPhase(false)) {
         maybeDefaultIdentifier = this.parseMaybeImportPhase(nodeImportEquals, false);
       } else {
         nodeImportEquals.importKind = "value";
       }
-      return this.tsParseImportEqualsDeclaration(nodeImportEquals, maybeDefaultIdentifier, true);
+      const declaration = this.tsParseImportEqualsDeclaration(nodeImportEquals, maybeDefaultIdentifier, true);
+      {
+        return declaration;
+      }
     } else if (this.eat(29)) {
       const assign = node;
       assign.expression = super.parseExpression();
@@ -9255,18 +9439,15 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     return super.shouldParseExportDeclaration();
   }
   parseConditional(expr, startLoc, refExpressionErrors) {
-    if (!this.state.maybeInArrowParameters || !this.match(17)) {
-      return super.parseConditional(expr, startLoc, refExpressionErrors);
-    }
-    const result = this.tryParse(() => super.parseConditional(expr, startLoc));
-    if (!result.node) {
-      if (result.error) {
-        super.setOptionalParametersError(refExpressionErrors, result.error);
+    if (!this.match(17)) return expr;
+    if (this.state.maybeInArrowParameters) {
+      const nextCh = this.lookaheadCharCode();
+      if (nextCh === 44 || nextCh === 61 || nextCh === 58 || nextCh === 41) {
+        this.setOptionalParametersError(refExpressionErrors);
+        return expr;
       }
-      return expr;
     }
-    if (result.error) this.state = result.failState;
-    return result.node;
+    return super.parseConditional(expr, startLoc, refExpressionErrors);
   }
   parseParenItem(node, startLoc) {
     const newNode = super.parseParenItem(node, startLoc);
@@ -9297,7 +9478,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     if (declaration.type === "TSInterfaceDeclaration" || declaration.type === "TSTypeAliasDeclaration" || isDeclare) {
       node.exportKind = "type";
     }
-    if (isDeclare) {
+    if (isDeclare && declaration.type !== "TSImportEqualsDeclaration") {
       this.resetStartLocation(declaration, startLoc);
       declaration.declare = true;
     }
@@ -9388,7 +9569,9 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
   parseClassSuper(node) {
     super.parseClassSuper(node);
     if (node.superClass && (this.match(47) || this.match(51))) {
-      node.superTypeParameters = this.tsParseTypeArgumentsInExpression();
+      {
+        node.superTypeParameters = this.tsParseTypeArgumentsInExpression();
+      }
     }
     if (this.eatContextual(113)) {
       node.implements = this.tsParseHeritageClause("implements");
@@ -9481,8 +9664,8 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     throw ((_jsx3 = jsx) == null ? void 0 : _jsx3.error) || arrow.error || ((_typeCast2 = typeCast) == null ? void 0 : _typeCast2.error);
   }
   reportReservedArrowTypeParam(node) {
-    var _node$extra;
-    if (node.params.length === 1 && !node.params[0].constraint && !((_node$extra = node.extra) != null && _node$extra.trailingComma) && this.getPluginOption("typescript", "disallowAmbiguousJSXLike")) {
+    var _node$extra2;
+    if (node.params.length === 1 && !node.params[0].constraint && !((_node$extra2 = node.extra) != null && _node$extra2.trailingComma) && this.getPluginOption("typescript", "disallowAmbiguousJSXLike")) {
       this.raise(TSErrors.ReservedArrowTypeParam, node);
     }
   }
@@ -9582,7 +9765,6 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
       case "TSParameterProperty":
         return "parameter";
       case "TSNonNullExpression":
-      case "TSInstantiationExpression":
         return "expression";
       case "TSAsExpression":
       case "TSSatisfiesExpression":
@@ -9598,17 +9780,19 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     }
     return super.parseBindingAtom();
   }
-  parseMaybeDecoratorArguments(expr) {
+  parseMaybeDecoratorArguments(expr, startLoc) {
     if (this.match(47) || this.match(51)) {
       const typeArguments = this.tsParseTypeArgumentsInExpression();
       if (this.match(10)) {
-        const call = super.parseMaybeDecoratorArguments(expr);
-        call.typeParameters = typeArguments;
+        const call = super.parseMaybeDecoratorArguments(expr, startLoc);
+        {
+          call.typeParameters = typeArguments;
+        }
         return call;
       }
       this.unexpected(null, 10);
     }
-    return super.parseMaybeDecoratorArguments(expr);
+    return super.parseMaybeDecoratorArguments(expr, startLoc);
   }
   checkCommaAfterRest(close) {
     if (this.state.isAmbientContext && this.match(12) && this.lookaheadCharCode() === close) {
@@ -9666,14 +9850,12 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     }
     return type;
   }
-  toAssignableList(exprList, trailingCommaLoc, isLHS) {
-    for (let i = 0; i < exprList.length; i++) {
-      const expr = exprList[i];
-      if ((expr == null ? void 0 : expr.type) === "TSTypeCastExpression") {
-        exprList[i] = this.typeCastToParameter(expr);
-      }
+  toAssignableListItem(exprList, index, isLHS) {
+    const node = exprList[index];
+    if (node.type === "TSTypeCastExpression") {
+      exprList[index] = this.typeCastToParameter(node);
     }
-    super.toAssignableList(exprList, trailingCommaLoc, isLHS);
+    super.toAssignableListItem(exprList, index, isLHS);
   }
   typeCastToParameter(node) {
     node.expression.typeAnnotation = node.typeAnnotation;
@@ -9695,7 +9877,11 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
   jsxParseOpeningElementAfterName(node) {
     if (this.match(47) || this.match(51)) {
       const typeArguments = this.tsTryParseAndCatch(() => this.tsParseTypeArgumentsInExpression());
-      if (typeArguments) node.typeParameters = typeArguments;
+      if (typeArguments) {
+        {
+          node.typeParameters = typeArguments;
+        }
+      }
     }
     return super.jsxParseOpeningElementAfterName(node);
   }
@@ -9755,8 +9941,9 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
   parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope) {
     const method = super.parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope);
     if (method.abstract) {
-      const hasBody = this.hasPlugin("estree") ? !!method.value.body : !!method.body;
-      if (hasBody) {
+      const hasEstreePlugin = this.hasPlugin("estree");
+      const methodFn = hasEstreePlugin ? method.value : method;
+      if (methodFn.body) {
         const {
           key
         } = method;
@@ -10236,67 +10423,19 @@ const mixinPlugins = {
   placeholders
 };
 const mixinPluginNames = Object.keys(mixinPlugins);
-function createDefaultOptions() {
-  return {
-    sourceType: "script",
-    sourceFilename: undefined,
-    startIndex: 0,
-    startColumn: 0,
-    startLine: 1,
-    allowAwaitOutsideFunction: false,
-    allowReturnOutsideFunction: false,
-    allowNewTargetOutsideFunction: false,
-    allowImportExportEverywhere: false,
-    allowSuperOutsideMethod: false,
-    allowUndeclaredExports: false,
-    plugins: [],
-    strictMode: null,
-    ranges: false,
-    tokens: false,
-    createImportExpressions: false,
-    createParenthesizedExpressions: false,
-    errorRecovery: false,
-    attachComment: true,
-    annexB: true
-  };
-}
-function getOptions(opts) {
-  const options = createDefaultOptions();
-  if (opts == null) {
-    return options;
-  }
-  if (opts.annexB != null && opts.annexB !== false) {
-    throw new Error("The `annexB` option can only be set to `false`.");
-  }
-  for (const key of Object.keys(options)) {
-    if (opts[key] != null) options[key] = opts[key];
-  }
-  if (options.startLine === 1) {
-    if (opts.startIndex == null && options.startColumn > 0) {
-      options.startIndex = options.startColumn;
-    } else if (opts.startColumn == null && options.startIndex > 0) {
-      options.startColumn = options.startIndex;
-    }
-  } else if (opts.startColumn == null || opts.startIndex == null) {
-    if (opts.startIndex != null) {
-      throw new Error("With a `startLine > 1` you must also specify `startIndex` and `startColumn`.");
-    }
-  }
-  return options;
-}
 class ExpressionParser extends LValParser {
-  checkProto(prop, isRecord, protoRef, refExpressionErrors) {
+  checkProto(prop, isRecord, sawProto, refExpressionErrors) {
     if (prop.type === "SpreadElement" || this.isObjectMethod(prop) || prop.computed || prop.shorthand) {
-      return;
+      return sawProto;
     }
     const key = prop.key;
     const name = key.type === "Identifier" ? key.name : key.value;
     if (name === "__proto__") {
       if (isRecord) {
         this.raise(Errors.RecordNoProto, key);
-        return;
+        return true;
       }
-      if (protoRef.used) {
+      if (sawProto) {
         if (refExpressionErrors) {
           if (refExpressionErrors.doubleProtoLoc === null) {
             refExpressionErrors.doubleProtoLoc = key.loc.start;
@@ -10305,8 +10444,9 @@ class ExpressionParser extends LValParser {
           this.raise(Errors.DuplicateProto, key);
         }
       }
-      protoRef.used = true;
+      return true;
     }
+    return sawProto;
   }
   shouldExitDescending(expr, potentialArrowAt) {
     return expr.type === "ArrowFunctionExpression" && this.offsetToSourcePos(expr.start) === potentialArrowAt;
@@ -10321,7 +10461,7 @@ class ExpressionParser extends LValParser {
     this.finalizeRemainingComments();
     expr.comments = this.comments;
     expr.errors = this.state.errors;
-    if (this.options.tokens) {
+    if (this.optionFlags & 128) {
       expr.tokens = this.tokens;
     }
     return expr;
@@ -10352,9 +10492,8 @@ class ExpressionParser extends LValParser {
   parseMaybeAssignAllowIn(refExpressionErrors, afterLeftParse) {
     return this.allowInAnd(() => this.parseMaybeAssign(refExpressionErrors, afterLeftParse));
   }
-  setOptionalParametersError(refExpressionErrors, resultError) {
-    var _resultError$loc;
-    refExpressionErrors.optionalParametersLoc = (_resultError$loc = resultError == null ? void 0 : resultError.loc) != null ? _resultError$loc : this.state.startLoc;
+  setOptionalParametersError(refExpressionErrors) {
+    refExpressionErrors.optionalParametersLoc = this.state.startLoc;
   }
   parseMaybeAssign(refExpressionErrors, afterLeftParse) {
     const startLoc = this.state.startLoc;
@@ -10503,18 +10642,19 @@ class ExpressionParser extends LValParser {
             return this.withTopicBindingContext(() => {
               return this.parseHackPipeBody();
             });
-          case "smart":
-            return this.withTopicBindingContext(() => {
-              if (this.prodParam.hasYield && this.isContextual(108)) {
-                throw this.raise(Errors.PipeBodyIsTighter, this.state.startLoc);
-              }
-              return this.parseSmartPipelineBodyInStyle(this.parseExprOpBaseRightExpr(op, prec), startLoc);
-            });
           case "fsharp":
             return this.withSoloAwaitPermittingContext(() => {
               return this.parseFSharpPipelineBody(prec);
             });
         }
+        if (this.getPluginOption("pipelineOperator", "proposal") === "smart") {
+          return this.withTopicBindingContext(() => {
+            if (this.prodParam.hasYield && this.isContextual(108)) {
+              throw this.raise(Errors.PipeBodyIsTighter, this.state.startLoc);
+            }
+            return this.parseSmartPipelineBodyInStyle(this.parseExprOpBaseRightExpr(op, prec), startLoc);
+          });
+        }
       default:
         return this.parseExprOpBaseRightExpr(op, prec);
     }
@@ -10826,7 +10966,7 @@ class ExpressionParser extends LValParser {
           return this.parseImportMetaProperty(node);
         }
         if (this.match(10)) {
-          if (this.options.createImportExpressions) {
+          if (this.optionFlags & 256) {
             return this.parseImportCall(node);
           } else {
             return this.finishNode(node, "Import");
@@ -11010,12 +11150,19 @@ class ExpressionParser extends LValParser {
   }
   finishTopicReference(node, startLoc, pipeProposal, tokenType) {
     if (this.testTopicReferenceConfiguration(pipeProposal, startLoc, tokenType)) {
-      const nodeType = pipeProposal === "smart" ? "PipelinePrimaryTopicReference" : "TopicReference";
-      if (!this.topicReferenceIsAllowedInCurrentContext()) {
-        this.raise(pipeProposal === "smart" ? Errors.PrimaryTopicNotAllowed : Errors.PipeTopicUnbound, startLoc);
+      if (pipeProposal === "hack") {
+        if (!this.topicReferenceIsAllowedInCurrentContext()) {
+          this.raise(Errors.PipeTopicUnbound, startLoc);
+        }
+        this.registerTopicReference();
+        return this.finishNode(node, "TopicReference");
+      } else {
+        if (!this.topicReferenceIsAllowedInCurrentContext()) {
+          this.raise(Errors.PrimaryTopicNotAllowed, startLoc);
+        }
+        this.registerTopicReference();
+        return this.finishNode(node, "PipelinePrimaryTopicReference");
       }
-      this.registerTopicReference();
-      return this.finishNode(node, nodeType);
     } else {
       throw this.raise(Errors.PipeTopicUnconfiguredToken, startLoc, {
         token: tokenLabelName(tokenType)
@@ -11068,9 +11215,9 @@ class ExpressionParser extends LValParser {
   parseSuper() {
     const node = this.startNode();
     this.next();
-    if (this.match(10) && !this.scope.allowDirectSuper && !this.options.allowSuperOutsideMethod) {
+    if (this.match(10) && !this.scope.allowDirectSuper && !(this.optionFlags & 16)) {
       this.raise(Errors.SuperNotAllowed, node);
-    } else if (!this.scope.allowSuper && !this.options.allowSuperOutsideMethod) {
+    } else if (!this.scope.allowSuper && !(this.optionFlags & 16)) {
       this.raise(Errors.UnexpectedSuper, node);
     }
     if (!this.match(10) && !this.match(0) && !this.match(16)) {
@@ -11123,9 +11270,8 @@ class ExpressionParser extends LValParser {
       this.sawUnambiguousESM = true;
     } else if (this.isContextual(105) || this.isContextual(97)) {
       const isSource = this.isContextual(105);
-      if (!isSource) this.unexpected();
       this.expectPlugin(isSource ? "sourcePhaseImports" : "deferredImportEvaluation");
-      if (!this.options.createImportExpressions) {
+      if (!(this.optionFlags & 256)) {
         throw this.raise(Errors.DynamicImportPhaseRequiresImportExpressions, this.state.startLoc, {
           phase: this.state.value
         });
@@ -11245,7 +11391,7 @@ class ExpressionParser extends LValParser {
     return this.wrapParenthesis(startLoc, val);
   }
   wrapParenthesis(startLoc, expression) {
-    if (!this.options.createParenthesizedExpressions) {
+    if (!(this.optionFlags & 512)) {
       this.addExtra(expression, "parenthesized", true);
       this.addExtra(expression, "parenStart", startLoc.index);
       this.takeSurroundingComments(expression, startLoc.index, this.state.lastTokEndLoc.index);
@@ -11273,7 +11419,7 @@ class ExpressionParser extends LValParser {
       const meta = this.createIdentifier(this.startNodeAtNode(node), "new");
       this.next();
       const metaProp = this.parseMetaProperty(node, meta, "target");
-      if (!this.scope.inNonArrowFunction && !this.scope.inClass && !this.options.allowNewTargetOutsideFunction) {
+      if (!this.scope.inNonArrowFunction && !this.scope.inClass && !(this.optionFlags & 4)) {
         this.raise(Errors.UnexpectedNewTarget, metaProp);
       }
       return metaProp;
@@ -11349,7 +11495,7 @@ class ExpressionParser extends LValParser {
     }
     const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
     this.state.inFSharpPipelineDirectBody = false;
-    const propHash = Object.create(null);
+    let sawProto = false;
     let first = true;
     const node = this.startNode();
     node.properties = [];
@@ -11369,7 +11515,7 @@ class ExpressionParser extends LValParser {
         prop = this.parseBindingProperty();
       } else {
         prop = this.parsePropertyDefinition(refExpressionErrors);
-        this.checkProto(prop, isRecord, propHash, refExpressionErrors);
+        sawProto = this.checkProto(prop, isRecord, sawProto, refExpressionErrors);
       }
       if (isRecord && !this.isObjectProperty(prop) && prop.type !== "SpreadElement") {
         this.raise(Errors.InvalidRecordProperty, prop);
@@ -11788,7 +11934,7 @@ class ExpressionParser extends LValParser {
     }
   }
   recordAwaitIfAllowed() {
-    const isAwaitAllowed = this.prodParam.hasAwait || this.options.allowAwaitOutsideFunction && !this.scope.inFunction;
+    const isAwaitAllowed = this.prodParam.hasAwait || this.optionFlags & 1 && !this.scope.inFunction;
     if (isAwaitAllowed && !this.scope.inFunction) {
       this.state.hasTopLevelAwait = true;
     }
@@ -11800,7 +11946,7 @@ class ExpressionParser extends LValParser {
     if (this.eat(55)) {
       this.raise(Errors.ObsoleteAwaitStar, node);
     }
-    if (!this.scope.inFunction && !this.options.allowAwaitOutsideFunction) {
+    if (!this.scope.inFunction && !(this.optionFlags & 1)) {
       if (this.isAmbiguousAwait()) {
         this.ambiguousScriptDifferentAst = true;
       } else {
@@ -12124,7 +12270,7 @@ class StatementParser extends ExpressionParser {
   parseTopLevel(file, program) {
     file.program = this.parseProgram(program);
     file.comments = this.comments;
-    if (this.options.tokens) {
+    if (this.optionFlags & 128) {
       file.tokens = babel7CompatTokens(this.tokens, this.input, this.startIndex);
     }
     return this.finishNode(file, "File");
@@ -12134,7 +12280,7 @@ class StatementParser extends ExpressionParser {
     program.interpreter = this.parseInterpreterDirective();
     this.parseBlockBody(program, true, true, end);
     if (this.inModule) {
-      if (!this.options.allowUndeclaredExports && this.scope.undefinedExports.size > 0) {
+      if (!(this.optionFlags & 32) && this.scope.undefinedExports.size > 0) {
         for (const [localName, at] of Array.from(this.scope.undefinedExports)) {
           this.raise(Errors.ModuleExportUndefined, at, {
             localName
@@ -12360,21 +12506,15 @@ class StatementParser extends ExpressionParser {
         }
       case 82:
         {
-          if (!this.options.allowImportExportEverywhere && !topLevel) {
+          if (!(this.optionFlags & 8) && !topLevel) {
             this.raise(Errors.UnexpectedImportExport, this.state.startLoc);
           }
           this.next();
           let result;
           if (startType === 83) {
             result = this.parseImport(node);
-            if (result.type === "ImportDeclaration" && (!result.importKind || result.importKind === "value")) {
-              this.sawUnambiguousESM = true;
-            }
           } else {
             result = this.parseExport(node, decorators);
-            if (result.type === "ExportNamedDeclaration" && (!result.exportKind || result.exportKind === "value") || result.type === "ExportAllDeclaration" && (!result.exportKind || result.exportKind === "value") || result.type === "ExportDefaultDeclaration") {
-              this.sawUnambiguousESM = true;
-            }
           }
           this.assertModuleNodeAllowed(result);
           return result;
@@ -12399,7 +12539,7 @@ class StatementParser extends ExpressionParser {
     }
   }
   assertModuleNodeAllowed(node) {
-    if (!this.options.allowImportExportEverywhere && !this.inModule) {
+    if (!(this.optionFlags & 8) && !this.inModule) {
       this.raise(Errors.ImportOutsideModule, node);
     }
   }
@@ -12409,7 +12549,8 @@ class StatementParser extends ExpressionParser {
   }
   maybeTakeDecorators(maybeDecorators, classNode, exportNode) {
     if (maybeDecorators) {
-      if (classNode.decorators && classNode.decorators.length > 0) {
+      var _classNode$decorators;
+      if ((_classNode$decorators = classNode.decorators) != null && _classNode$decorators.length) {
         if (typeof this.getPluginOption("decorators", "decoratorsBeforeExport") !== "boolean") {
           this.raise(Errors.DecoratorsBeforeAfterExport, classNode.decorators[0]);
         }
@@ -12456,7 +12597,7 @@ class StatementParser extends ExpressionParser {
         this.expect(11);
         expr = this.wrapParenthesis(startLoc, expr);
         const paramsStartLoc = this.state.startLoc;
-        node.expression = this.parseMaybeDecoratorArguments(expr);
+        node.expression = this.parseMaybeDecoratorArguments(expr, startLoc);
         if (this.getPluginOption("decorators", "allowCallParenthesized") === false && node.expression !== expr) {
           this.raise(Errors.DecoratorArgumentsOutsideParentheses, paramsStartLoc);
         }
@@ -12474,16 +12615,16 @@ class StatementParser extends ExpressionParser {
           node.computed = false;
           expr = this.finishNode(node, "MemberExpression");
         }
-        node.expression = this.parseMaybeDecoratorArguments(expr);
+        node.expression = this.parseMaybeDecoratorArguments(expr, startLoc);
       }
     } else {
       node.expression = this.parseExprSubscripts();
     }
     return this.finishNode(node, "Decorator");
   }
-  parseMaybeDecoratorArguments(expr) {
+  parseMaybeDecoratorArguments(expr, startLoc) {
     if (this.eat(10)) {
-      const node = this.startNodeAtNode(expr);
+      const node = this.startNodeAt(startLoc);
       node.callee = expr;
       node.arguments = this.parseCallExpressionArguments(11);
       this.toReferencedList(node.arguments);
@@ -12630,7 +12771,7 @@ class StatementParser extends ExpressionParser {
     return this.finishNode(node, "IfStatement");
   }
   parseReturnStatement(node) {
-    if (!this.prodParam.hasReturn && !this.options.allowReturnOutsideFunction) {
+    if (!this.prodParam.hasReturn && !(this.optionFlags & 2)) {
       this.raise(Errors.IllegalReturn, this.state.startLoc);
     }
     this.next();
@@ -13284,6 +13425,7 @@ class StatementParser extends ExpressionParser {
         throw this.raise(Errors.UnsupportedDecoratorExport, node);
       }
       this.parseExportFrom(node, true);
+      this.sawUnambiguousESM = true;
       return this.finishNode(node, "ExportAllDeclaration");
     }
     const hasSpecifiers = this.maybeParseExportNamedSpecifiers(node);
@@ -13312,6 +13454,7 @@ class StatementParser extends ExpressionParser {
       } else if (decorators) {
         throw this.raise(Errors.UnsupportedDecoratorExport, node);
       }
+      this.sawUnambiguousESM = true;
       return this.finishNode(node2, "ExportNamedDeclaration");
     }
     if (this.eat(65)) {
@@ -13324,6 +13467,7 @@ class StatementParser extends ExpressionParser {
         throw this.raise(Errors.UnsupportedDecoratorExport, node);
       }
       this.checkExport(node2, true, true);
+      this.sawUnambiguousESM = true;
       return this.finishNode(node2, "ExportDefaultDeclaration");
     }
     this.unexpected(null, 5);
@@ -13361,10 +13505,12 @@ class StatementParser extends ExpressionParser {
       const isTypeExport = node2.exportKind === "type";
       node2.specifiers.push(...this.parseExportSpecifiers(isTypeExport));
       node2.source = null;
-      node2.declaration = null;
       if (this.hasPlugin("importAssertions")) {
         node2.assertions = [];
+      } else {
+        node2.attributes = [];
       }
+      node2.declaration = null;
       return true;
     }
     return false;
@@ -13375,6 +13521,8 @@ class StatementParser extends ExpressionParser {
       node.source = null;
       if (this.hasPlugin("importAssertions")) {
         node.assertions = [];
+      } else {
+        node.attributes = [];
       }
       node.declaration = this.parseExportDeclaration(node);
       return true;
@@ -13738,6 +13886,7 @@ class StatementParser extends ExpressionParser {
     this.checkImportReflection(node);
     this.checkJSONModuleImport(node);
     this.semicolon();
+    this.sawUnambiguousESM = true;
     return this.finishNode(node, "ImportDeclaration");
   }
   parseImportSource() {
@@ -13920,6 +14069,47 @@ class Parser extends StatementParser {
     this.plugins = pluginsMap;
     this.filename = options.sourceFilename;
     this.startIndex = options.startIndex;
+    let optionFlags = 0;
+    if (options.allowAwaitOutsideFunction) {
+      optionFlags |= 1;
+    }
+    if (options.allowReturnOutsideFunction) {
+      optionFlags |= 2;
+    }
+    if (options.allowImportExportEverywhere) {
+      optionFlags |= 8;
+    }
+    if (options.allowSuperOutsideMethod) {
+      optionFlags |= 16;
+    }
+    if (options.allowUndeclaredExports) {
+      optionFlags |= 32;
+    }
+    if (options.allowNewTargetOutsideFunction) {
+      optionFlags |= 4;
+    }
+    if (options.ranges) {
+      optionFlags |= 64;
+    }
+    if (options.tokens) {
+      optionFlags |= 128;
+    }
+    if (options.createImportExpressions) {
+      optionFlags |= 256;
+    }
+    if (options.createParenthesizedExpressions) {
+      optionFlags |= 512;
+    }
+    if (options.errorRecovery) {
+      optionFlags |= 1024;
+    }
+    if (options.attachComment) {
+      optionFlags |= 2048;
+    }
+    if (options.annexB) {
+      optionFlags |= 4096;
+    }
+    this.optionFlags = optionFlags;
   }
   getScopeHandler() {
     return ScopeHandler;