condenser 0.2 → 0.3

data/lib/condenser/processors/node_modules/.bin/acorn

@@ -1 +0,0 @@
-../acorn/bin/acorn

data/lib/condenser/processors/node_modules/@babel/helper-call-delegate/README.md

@@ -1,19 +0,0 @@
-# @babel/helper-call-delegate
-
-> Helper function to call delegate
-
-See our website [@babel/helper-call-delegate](https://babeljs.io/docs/en/next/babel-helper-call-delegate.html) for more information.
-
-## Install
-
-Using npm:
-
-```sh
-npm install --save-dev @babel/helper-call-delegate
-```
-
-or using yarn:
-
-```sh
-yarn add @babel/helper-call-delegate --dev
-```

data/lib/condenser/processors/node_modules/@babel/helper-call-delegate/lib/index.js

@@ -1,70 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = _default;
-
-var _helperHoistVariables = _interopRequireDefault(require("@babel/helper-hoist-variables"));
-
-var t = _interopRequireWildcard(require("@babel/types"));
-
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-const visitor = {
-  enter(path, state) {
-    if (path.isThisExpression()) {
-      state.foundThis = true;
-    }
-
-    if (path.isReferencedIdentifier({
-      name: "arguments"
-    })) {
-      state.foundArguments = true;
-    }
-  },
-
-  Function(path) {
-    path.skip();
-  }
-
-};
-
-function _default(path, scope = path.scope) {
-  const {
-    node
-  } = path;
-  const container = t.functionExpression(null, [], node.body, node.generator, node.async);
-  let callee = container;
-  let args = [];
-  (0, _helperHoistVariables.default)(path, id => scope.push({
-    id
-  }));
-  const state = {
-    foundThis: false,
-    foundArguments: false
-  };
-  path.traverse(visitor, state);
-
-  if (state.foundArguments || state.foundThis) {
-    callee = t.memberExpression(container, t.identifier("apply"));
-    args = [];
-
-    if (state.foundThis) {
-      args.push(t.thisExpression());
-    }
-
-    if (state.foundArguments) {
-      if (!state.foundThis) args.push(t.nullLiteral());
-      args.push(t.identifier("arguments"));
-    }
-  }
-
-  let call = t.callExpression(callee, args);
-  if (node.generator) call = t.yieldExpression(call, true);
-  return t.returnStatement(call);
-}

data/lib/condenser/processors/node_modules/@babel/helper-call-delegate/package.json

@@ -1,46 +0,0 @@
-{
-  "_from": "@babel/helper-call-delegate@^7.7.4",
-  "_id": "@babel/helper-call-delegate@7.7.4",
-  "_inBundle": false,
-  "_integrity": "sha512-8JH9/B7J7tCYJ2PpWVpw9JhPuEVHztagNVuQAFBVFYluRMlpG7F1CgKEgGeL6KFqcsIa92ZYVj6DSc0XwmN1ZA==",
-  "_location": "/@babel/helper-call-delegate",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "range",
-    "registry": true,
-    "raw": "@babel/helper-call-delegate@^7.7.4",
-    "name": "@babel/helper-call-delegate",
-    "escapedName": "@babel%2fhelper-call-delegate",
-    "scope": "@babel",
-    "rawSpec": "^7.7.4",
-    "saveSpec": null,
-    "fetchSpec": "^7.7.4"
-  },
-  "_requiredBy": [
-    "/@babel/plugin-transform-parameters"
-  ],
-  "_resolved": "https://registry.npmjs.org/@babel/helper-call-delegate/-/helper-call-delegate-7.7.4.tgz",
-  "_shasum": "621b83e596722b50c0066f9dc37d3232e461b801",
-  "_spec": "@babel/helper-call-delegate@^7.7.4",
-  "_where": "/Users/malomalo/Code/condenser/lib/condenser/processors/node_modules/@babel/plugin-transform-parameters",
-  "bundleDependencies": false,
-  "dependencies": {
-    "@babel/helper-hoist-variables": "^7.7.4",
-    "@babel/traverse": "^7.7.4",
-    "@babel/types": "^7.7.4"
-  },
-  "deprecated": false,
-  "description": "Helper function to call delegate",
-  "gitHead": "75767d87cb147709b9bd9b99bf44daa6688874a9",
-  "license": "MIT",
-  "main": "lib/index.js",
-  "name": "@babel/helper-call-delegate",
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/babel/babel/tree/master/packages/babel-helper-call-delegate"
-  },
-  "version": "7.7.4"
-}

data/lib/condenser/processors/node_modules/@babel/parser/lib/options.js

@@ -1,35 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getOptions = getOptions;
-exports.defaultOptions = void 0;
-const defaultOptions = {
-  sourceType: "script",
-  sourceFilename: undefined,
-  startLine: 1,
-  allowAwaitOutsideFunction: false,
-  allowReturnOutsideFunction: false,
-  allowImportExportEverywhere: false,
-  allowSuperOutsideMethod: false,
-  allowUndeclaredExports: false,
-  plugins: [],
-  strictMode: null,
-  ranges: false,
-  tokens: false,
-  createParenthesizedExpressions: false,
-  errorRecovery: false
-};
-exports.defaultOptions = defaultOptions;
-
-function getOptions(opts) {
-  const options = {};
-
-  for (let _i = 0, _Object$keys = Object.keys(defaultOptions); _i < _Object$keys.length; _i++) {
-    const key = _Object$keys[_i];
-    options[key] = opts && opts[key] != null ? opts[key] : defaultOptions[key];
-  }
-
-  return options;
-}

data/lib/condenser/processors/node_modules/@babel/parser/lib/parser/base.js

@@ -1,24 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-class BaseParser {
-  constructor() {
-    this.sawUnambiguousESM = false;
-    this.ambiguousScriptDifferentAst = false;
-  }
-
-  hasPlugin(name) {
-    return this.plugins.has(name);
-  }
-
-  getPluginOption(plugin, name) {
-    if (this.hasPlugin(plugin)) return this.plugins.get(plugin)[name];
-  }
-
-}
-
-exports.default = BaseParser;

data/lib/condenser/processors/node_modules/@babel/parser/lib/parser/comments.js

@@ -1,198 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _base = _interopRequireDefault(require("./base"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function last(stack) {
-  return stack[stack.length - 1];
-}
-
-class CommentsParser extends _base.default {
-  addComment(comment) {
-    if (this.filename) comment.loc.filename = this.filename;
-    this.state.trailingComments.push(comment);
-    this.state.leadingComments.push(comment);
-  }
-
-  adjustCommentsAfterTrailingComma(node, elements, takeAllComments) {
-    if (this.state.leadingComments.length === 0) {
-      return;
-    }
-
-    let lastElement = null;
-    let i = elements.length;
-
-    while (lastElement === null && i > 0) {
-      lastElement = elements[--i];
-    }
-
-    if (lastElement === null) {
-      return;
-    }
-
-    for (let j = 0; j < this.state.leadingComments.length; j++) {
-      if (this.state.leadingComments[j].end < this.state.commentPreviousNode.end) {
-        this.state.leadingComments.splice(j, 1);
-        j--;
-      }
-    }
-
-    const newTrailingComments = [];
-
-    for (let i = 0; i < this.state.leadingComments.length; i++) {
-      const leadingComment = this.state.leadingComments[i];
-
-      if (leadingComment.end < node.end) {
-        newTrailingComments.push(leadingComment);
-
-        if (!takeAllComments) {
-          this.state.leadingComments.splice(i, 1);
-          i--;
-        }
-      } else {
-        if (node.trailingComments === undefined) {
-          node.trailingComments = [];
-        }
-
-        node.trailingComments.push(leadingComment);
-      }
-    }
-
-    if (takeAllComments) this.state.leadingComments = [];
-
-    if (newTrailingComments.length > 0) {
-      lastElement.trailingComments = newTrailingComments;
-    } else if (lastElement.trailingComments !== undefined) {
-      lastElement.trailingComments = [];
-    }
-  }
-
-  processComment(node) {
-    if (node.type === "Program" && node.body.length > 0) return;
-    const stack = this.state.commentStack;
-    let firstChild, lastChild, trailingComments, i, j;
-
-    if (this.state.trailingComments.length > 0) {
-      if (this.state.trailingComments[0].start >= node.end) {
-        trailingComments = this.state.trailingComments;
-        this.state.trailingComments = [];
-      } else {
-        this.state.trailingComments.length = 0;
-      }
-    } else if (stack.length > 0) {
-      const lastInStack = last(stack);
-
-      if (lastInStack.trailingComments && lastInStack.trailingComments[0].start >= node.end) {
-        trailingComments = lastInStack.trailingComments;
-        delete lastInStack.trailingComments;
-      }
-    }
-
-    if (stack.length > 0 && last(stack).start >= node.start) {
-      firstChild = stack.pop();
-    }
-
-    while (stack.length > 0 && last(stack).start >= node.start) {
-      lastChild = stack.pop();
-    }
-
-    if (!lastChild && firstChild) lastChild = firstChild;
-
-    if (firstChild) {
-      switch (node.type) {
-        case "ObjectExpression":
-          this.adjustCommentsAfterTrailingComma(node, node.properties);
-          break;
-
-        case "ObjectPattern":
-          this.adjustCommentsAfterTrailingComma(node, node.properties, true);
-          break;
-
-        case "CallExpression":
-          this.adjustCommentsAfterTrailingComma(node, node.arguments);
-          break;
-
-        case "ArrayExpression":
-          this.adjustCommentsAfterTrailingComma(node, node.elements);
-          break;
-
-        case "ArrayPattern":
-          this.adjustCommentsAfterTrailingComma(node, node.elements, true);
-          break;
-      }
-    } else if (this.state.commentPreviousNode && (this.state.commentPreviousNode.type === "ImportSpecifier" && node.type !== "ImportSpecifier" || this.state.commentPreviousNode.type === "ExportSpecifier" && node.type !== "ExportSpecifier")) {
-      this.adjustCommentsAfterTrailingComma(node, [this.state.commentPreviousNode], true);
-    }
-
-    if (lastChild) {
-      if (lastChild.leadingComments) {
-        if (lastChild !== node && lastChild.leadingComments.length > 0 && last(lastChild.leadingComments).end <= node.start) {
-          node.leadingComments = lastChild.leadingComments;
-          delete lastChild.leadingComments;
-        } else {
-          for (i = lastChild.leadingComments.length - 2; i >= 0; --i) {
-            if (lastChild.leadingComments[i].end <= node.start) {
-              node.leadingComments = lastChild.leadingComments.splice(0, i + 1);
-              break;
-            }
-          }
-        }
-      }
-    } else if (this.state.leadingComments.length > 0) {
-      if (last(this.state.leadingComments).end <= node.start) {
-        if (this.state.commentPreviousNode) {
-          for (j = 0; j < this.state.leadingComments.length; j++) {
-            if (this.state.leadingComments[j].end < this.state.commentPreviousNode.end) {
-              this.state.leadingComments.splice(j, 1);
-              j--;
-            }
-          }
-        }
-
-        if (this.state.leadingComments.length > 0) {
-          node.leadingComments = this.state.leadingComments;
-          this.state.leadingComments = [];
-        }
-      } else {
-        for (i = 0; i < this.state.leadingComments.length; i++) {
-          if (this.state.leadingComments[i].end > node.start) {
-            break;
-          }
-        }
-
-        const leadingComments = this.state.leadingComments.slice(0, i);
-
-        if (leadingComments.length) {
-          node.leadingComments = leadingComments;
-        }
-
-        trailingComments = this.state.leadingComments.slice(i);
-
-        if (trailingComments.length === 0) {
-          trailingComments = null;
-        }
-      }
-    }
-
-    this.state.commentPreviousNode = node;
-
-    if (trailingComments) {
-      if (trailingComments.length && trailingComments[0].start >= node.start && last(trailingComments).end <= node.end) {
-        node.innerComments = trailingComments;
-      } else {
-        node.trailingComments = trailingComments;
-      }
-    }
-
-    stack.push(node);
-  }
-
-}
-
-exports.default = CommentsParser;

data/lib/condenser/processors/node_modules/@babel/parser/lib/parser/expression.js

@@ -1,1703 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _types = require("../tokenizer/types");
-
-var _context = require("../tokenizer/context");
-
-var N = _interopRequireWildcard(require("../types"));
-
-var _lval = _interopRequireDefault(require("./lval"));
-
-var _identifier = require("../util/identifier");
-
-var _scopeflags = require("../util/scopeflags");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-class ExpressionParser extends _lval.default {
-  checkDuplicatedProto(prop, protoRef) {
-    if (prop.type === "SpreadElement" || prop.computed || prop.kind || prop.shorthand) {
-      return;
-    }
-
-    const key = prop.key;
-    const name = key.type === "Identifier" ? key.name : String(key.value);
-
-    if (name === "__proto__") {
-      if (protoRef.used && !protoRef.start) {
-        protoRef.start = key.start;
-      }
-
-      protoRef.used = true;
-    }
-  }
-
-  getExpression() {
-    this.scope.enter(_scopeflags.SCOPE_PROGRAM);
-    this.nextToken();
-    const expr = this.parseExpression();
-
-    if (!this.match(_types.types.eof)) {
-      this.unexpected();
-    }
-
-    expr.comments = this.state.comments;
-    expr.errors = this.state.errors;
-    return expr;
-  }
-
-  parseExpression(noIn, refShorthandDefaultPos) {
-    const startPos = this.state.start;
-    const startLoc = this.state.startLoc;
-    const expr = this.parseMaybeAssign(noIn, refShorthandDefaultPos);
-
-    if (this.match(_types.types.comma)) {
-      const node = this.startNodeAt(startPos, startLoc);
-      node.expressions = [expr];
-
-      while (this.eat(_types.types.comma)) {
-        node.expressions.push(this.parseMaybeAssign(noIn, refShorthandDefaultPos));
-      }
-
-      this.toReferencedList(node.expressions);
-      return this.finishNode(node, "SequenceExpression");
-    }
-
-    return expr;
-  }
-
-  parseMaybeAssign(noIn, refShorthandDefaultPos, afterLeftParse, refNeedsArrowPos) {
-    const startPos = this.state.start;
-    const startLoc = this.state.startLoc;
-
-    if (this.isContextual("yield")) {
-      if (this.scope.inGenerator) {
-        let left = this.parseYield(noIn);
-
-        if (afterLeftParse) {
-          left = afterLeftParse.call(this, left, startPos, startLoc);
-        }
-
-        return left;
-      } else {
-        this.state.exprAllowed = false;
-      }
-    }
-
-    let failOnShorthandAssign;
-
-    if (refShorthandDefaultPos) {
-      failOnShorthandAssign = false;
-    } else {
-      refShorthandDefaultPos = {
-        start: 0
-      };
-      failOnShorthandAssign = true;
-    }
-
-    if (this.match(_types.types.parenL) || this.match(_types.types.name)) {
-      this.state.potentialArrowAt = this.state.start;
-    }
-
-    let left = this.parseMaybeConditional(noIn, refShorthandDefaultPos, refNeedsArrowPos);
-
-    if (afterLeftParse) {
-      left = afterLeftParse.call(this, left, startPos, startLoc);
-    }
-
-    if (this.state.type.isAssign) {
-      const node = this.startNodeAt(startPos, startLoc);
-      const operator = this.state.value;
-      node.operator = operator;
-
-      if (operator === "??=") {
-        this.expectPlugin("nullishCoalescingOperator");
-        this.expectPlugin("logicalAssignment");
-      }
-
-      if (operator === "||=" || operator === "&&=") {
-        this.expectPlugin("logicalAssignment");
-      }
-
-      node.left = this.match(_types.types.eq) ? this.toAssignable(left, undefined, "assignment expression") : left;
-
-      if (refShorthandDefaultPos.start >= node.left.start) {
-        refShorthandDefaultPos.start = 0;
-      }
-
-      this.checkLVal(left, undefined, undefined, "assignment expression");
-      this.next();
-      node.right = this.parseMaybeAssign(noIn);
-      return this.finishNode(node, "AssignmentExpression");
-    } else if (failOnShorthandAssign && refShorthandDefaultPos.start) {
-      this.unexpected(refShorthandDefaultPos.start);
-    }
-
-    return left;
-  }
-
-  parseMaybeConditional(noIn, refShorthandDefaultPos, refNeedsArrowPos) {
-    const startPos = this.state.start;
-    const startLoc = this.state.startLoc;
-    const potentialArrowAt = this.state.potentialArrowAt;
-    const expr = this.parseExprOps(noIn, refShorthandDefaultPos);
-
-    if (expr.type === "ArrowFunctionExpression" && expr.start === potentialArrowAt) {
-      return expr;
-    }
-
-    if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
-    return this.parseConditional(expr, noIn, startPos, startLoc, refNeedsArrowPos);
-  }
-
-  parseConditional(expr, noIn, startPos, startLoc, refNeedsArrowPos) {
-    if (this.eat(_types.types.question)) {
-      const node = this.startNodeAt(startPos, startLoc);
-      node.test = expr;
-      node.consequent = this.parseMaybeAssign();
-      this.expect(_types.types.colon);
-      node.alternate = this.parseMaybeAssign(noIn);
-      return this.finishNode(node, "ConditionalExpression");
-    }
-
-    return expr;
-  }
-
-  parseExprOps(noIn, refShorthandDefaultPos) {
-    const startPos = this.state.start;
-    const startLoc = this.state.startLoc;
-    const potentialArrowAt = this.state.potentialArrowAt;
-    const expr = this.parseMaybeUnary(refShorthandDefaultPos);
-
-    if (expr.type === "ArrowFunctionExpression" && expr.start === potentialArrowAt) {
-      return expr;
-    }
-
-    if (refShorthandDefaultPos && refShorthandDefaultPos.start) {
-      return expr;
-    }
-
-    return this.parseExprOp(expr, startPos, startLoc, -1, noIn);
-  }
-
-  parseExprOp(left, leftStartPos, leftStartLoc, minPrec, noIn) {
-    const prec = this.state.type.binop;
-
-    if (prec != null && (!noIn || !this.match(_types.types._in))) {
-      if (prec > minPrec) {
-        const operator = this.state.value;
-
-        if (operator === "|>" && this.state.inFSharpPipelineDirectBody) {
-          return left;
-        }
-
-        const node = this.startNodeAt(leftStartPos, leftStartLoc);
-        node.left = left;
-        node.operator = operator;
-
-        if (operator === "**" && left.type === "UnaryExpression" && (this.options.createParenthesizedExpressions || !(left.extra && left.extra.parenthesized))) {
-          this.raise(left.argument.start, "Illegal expression. Wrap left hand side or entire exponentiation in parentheses.");
-        }
-
-        const op = this.state.type;
-
-        if (op === _types.types.pipeline) {
-          this.expectPlugin("pipelineOperator");
-          this.state.inPipeline = true;
-          this.checkPipelineAtInfixOperator(left, leftStartPos);
-        } else if (op === _types.types.nullishCoalescing) {
-          this.expectPlugin("nullishCoalescingOperator");
-        }
-
-        this.next();
-
-        if (op === _types.types.pipeline && this.getPluginOption("pipelineOperator", "proposal") === "minimal") {
-          if (this.match(_types.types.name) && this.state.value === "await" && this.scope.inAsync) {
-            throw this.raise(this.state.start, `Unexpected "await" after pipeline body; await must have parentheses in minimal proposal`);
-          }
-        }
-
-        node.right = this.parseExprOpRightExpr(op, prec, noIn);
-
-        if (op === _types.types.nullishCoalescing) {
-          if (left.type === "LogicalExpression" && left.operator !== "??" && !(left.extra && left.extra.parenthesized)) {
-            throw this.raise(left.start, `Nullish coalescing operator(??) requires parens when mixing with logical operators`);
-          } else if (node.right.type === "LogicalExpression" && node.right.operator !== "??" && !(node.right.extra && node.right.extra.parenthesized)) {
-            throw this.raise(node.right.start, `Nullish coalescing operator(??) requires parens when mixing with logical operators`);
-          }
-        }
-
-        this.finishNode(node, op === _types.types.logicalOR || op === _types.types.logicalAND || op === _types.types.nullishCoalescing ? "LogicalExpression" : "BinaryExpression");
-        return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec, noIn);
-      }
-    }
-
-    return left;
-  }
-
-  parseExprOpRightExpr(op, prec, noIn) {
-    const startPos = this.state.start;
-    const startLoc = this.state.startLoc;
-
-    switch (op) {
-      case _types.types.pipeline:
-        switch (this.getPluginOption("pipelineOperator", "proposal")) {
-          case "smart":
-            return this.withTopicPermittingContext(() => {
-              return this.parseSmartPipelineBody(this.parseExprOpBaseRightExpr(op, prec, noIn), startPos, startLoc);
-            });
-
-          case "fsharp":
-            return this.withSoloAwaitPermittingContext(() => {
-              return this.parseFSharpPipelineBody(prec, noIn);
-            });
-        }
-
-      default:
-        return this.parseExprOpBaseRightExpr(op, prec, noIn);
-    }
-  }
-
-  parseExprOpBaseRightExpr(op, prec, noIn) {
-    const startPos = this.state.start;
-    const startLoc = this.state.startLoc;
-    return this.parseExprOp(this.parseMaybeUnary(), startPos, startLoc, op.rightAssociative ? prec - 1 : prec, noIn);
-  }
-
-  parseMaybeUnary(refShorthandDefaultPos) {
-    if (this.isContextual("await") && this.isAwaitAllowed()) {
-      return this.parseAwait();
-    } else if (this.state.type.prefix) {
-      const node = this.startNode();
-      const update = this.match(_types.types.incDec);
-      node.operator = this.state.value;
-      node.prefix = true;
-
-      if (node.operator === "throw") {
-        this.expectPlugin("throwExpressions");
-      }
-
-      this.next();
-      node.argument = this.parseMaybeUnary();
-
-      if (refShorthandDefaultPos && refShorthandDefaultPos.start) {
-        this.unexpected(refShorthandDefaultPos.start);
-      }
-
-      if (update) {
-        this.checkLVal(node.argument, undefined, undefined, "prefix operation");
-      } else if (this.state.strict && node.operator === "delete") {
-        const arg = node.argument;
-
-        if (arg.type === "Identifier") {
-          this.raise(node.start, "Deleting local variable in strict mode");
-        } else if (arg.type === "MemberExpression" && arg.property.type === "PrivateName") {
-          this.raise(node.start, "Deleting a private field is not allowed");
-        }
-      }
-
-      return this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
-    }
-
-    const startPos = this.state.start;
-    const startLoc = this.state.startLoc;
-    let expr = this.parseExprSubscripts(refShorthandDefaultPos);
-    if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
-
-    while (this.state.type.postfix && !this.canInsertSemicolon()) {
-      const node = this.startNodeAt(startPos, startLoc);
-      node.operator = this.state.value;
-      node.prefix = false;
-      node.argument = expr;
-      this.checkLVal(expr, undefined, undefined, "postfix operation");
-      this.next();
-      expr = this.finishNode(node, "UpdateExpression");
-    }
-
-    return expr;
-  }
-
-  parseExprSubscripts(refShorthandDefaultPos) {
-    const startPos = this.state.start;
-    const startLoc = this.state.startLoc;
-    const potentialArrowAt = this.state.potentialArrowAt;
-    const expr = this.parseExprAtom(refShorthandDefaultPos);
-
-    if (expr.type === "ArrowFunctionExpression" && expr.start === potentialArrowAt) {
-      return expr;
-    }
-
-    if (refShorthandDefaultPos && refShorthandDefaultPos.start) {
-      return expr;
-    }
-
-    return this.parseSubscripts(expr, startPos, startLoc);
-  }
-
-  parseSubscripts(base, startPos, startLoc, noCalls) {
-    const state = {
-      optionalChainMember: false,
-      maybeAsyncArrow: this.atPossibleAsync(base),
-      stop: false
-    };
-
-    do {
-      base = this.parseSubscript(base, startPos, startLoc, noCalls, state);
-      state.maybeAsyncArrow = false;
-    } while (!state.stop);
-
-    return base;
-  }
-
-  parseSubscript(base, startPos, startLoc, noCalls, state) {
-    if (!noCalls && this.eat(_types.types.doubleColon)) {
-      const node = this.startNodeAt(startPos, startLoc);
-      node.object = base;
-      node.callee = this.parseNoCallExpr();
-      state.stop = true;
-      return this.parseSubscripts(this.finishNode(node, "BindExpression"), startPos, startLoc, noCalls);
-    } else if (this.match(_types.types.questionDot)) {
-      this.expectPlugin("optionalChaining");
-      state.optionalChainMember = true;
-
-      if (noCalls && this.lookaheadCharCode() === 40) {
-        state.stop = true;
-        return base;
-      }
-
-      this.next();
-      const node = this.startNodeAt(startPos, startLoc);
-
-      if (this.eat(_types.types.bracketL)) {
-        node.object = base;
-        node.property = this.parseExpression();
-        node.computed = true;
-        node.optional = true;
-        this.expect(_types.types.bracketR);
-        return this.finishNode(node, "OptionalMemberExpression");
-      } else if (this.eat(_types.types.parenL)) {
-        node.callee = base;
-        node.arguments = this.parseCallExpressionArguments(_types.types.parenR, false);
-        node.optional = true;
-        return this.finishCallExpression(node, true);
-      } else {
-        node.object = base;
-        node.property = this.parseIdentifier(true);
-        node.computed = false;
-        node.optional = true;
-        return this.finishNode(node, "OptionalMemberExpression");
-      }
-    } else if (this.eat(_types.types.dot)) {
-      const node = this.startNodeAt(startPos, startLoc);
-      node.object = base;
-      node.property = this.parseMaybePrivateName();
-      node.computed = false;
-
-      if (node.property.type === "PrivateName" && node.object.type === "Super") {
-        this.raise(startPos, "Private fields can't be accessed on super");
-      }
-
-      if (state.optionalChainMember) {
-        node.optional = false;
-        return this.finishNode(node, "OptionalMemberExpression");
-      }
-
-      return this.finishNode(node, "MemberExpression");
-    } else if (this.eat(_types.types.bracketL)) {
-      const node = this.startNodeAt(startPos, startLoc);
-      node.object = base;
-      node.property = this.parseExpression();
-      node.computed = true;
-      this.expect(_types.types.bracketR);
-
-      if (state.optionalChainMember) {
-        node.optional = false;
-        return this.finishNode(node, "OptionalMemberExpression");
-      }
-
-      return this.finishNode(node, "MemberExpression");
-    } else if (!noCalls && this.match(_types.types.parenL)) {
-      const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
-      const oldYieldPos = this.state.yieldPos;
-      const oldAwaitPos = this.state.awaitPos;
-      this.state.maybeInArrowParameters = true;
-      this.state.yieldPos = -1;
-      this.state.awaitPos = -1;
-      this.next();
-      let node = this.startNodeAt(startPos, startLoc);
-      node.callee = base;
-      node.arguments = this.parseCallExpressionArguments(_types.types.parenR, state.maybeAsyncArrow, base.type === "Import", base.type !== "Super", node);
-      this.finishCallExpression(node, state.optionalChainMember);
-
-      if (state.maybeAsyncArrow && this.shouldParseAsyncArrow()) {
-        state.stop = true;
-        node = this.parseAsyncArrowFromCallExpression(this.startNodeAt(startPos, startLoc), node);
-        this.checkYieldAwaitInDefaultParams();
-        this.state.yieldPos = oldYieldPos;
-        this.state.awaitPos = oldAwaitPos;
-      } else {
-        this.toReferencedListDeep(node.arguments);
-        if (oldYieldPos !== -1) this.state.yieldPos = oldYieldPos;
-
-        if (!this.isAwaitAllowed() && !oldMaybeInArrowParameters || oldAwaitPos !== -1) {
-          this.state.awaitPos = oldAwaitPos;
-        }
-      }
-
-      this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
-      return node;
-    } else if (this.match(_types.types.backQuote)) {
-      return this.parseTaggedTemplateExpression(startPos, startLoc, base, state);
-    } else {
-      state.stop = true;
-      return base;
-    }
-  }
-
-  parseTaggedTemplateExpression(startPos, startLoc, base, state, typeArguments) {
-    const node = this.startNodeAt(startPos, startLoc);
-    node.tag = base;
-    node.quasi = this.parseTemplate(true);
-    if (typeArguments) node.typeParameters = typeArguments;
-
-    if (state.optionalChainMember) {
-      this.raise(startPos, "Tagged Template Literals are not allowed in optionalChain");
-    }
-
-    return this.finishNode(node, "TaggedTemplateExpression");
-  }
-
-  atPossibleAsync(base) {
-    return base.type === "Identifier" && base.name === "async" && this.state.lastTokEnd === base.end && !this.canInsertSemicolon() && this.input.slice(base.start, base.end) === "async";
-  }
-
-  finishCallExpression(node, optional) {
-    if (node.callee.type === "Import") {
-      if (node.arguments.length !== 1) {
-        this.raise(node.start, "import() requires exactly one argument");
-      } else {
-        const importArg = node.arguments[0];
-
-        if (importArg && importArg.type === "SpreadElement") {
-          this.raise(importArg.start, "... is not allowed in import()");
-        }
-      }
-    }
-
-    return this.finishNode(node, optional ? "OptionalCallExpression" : "CallExpression");
-  }
-
-  parseCallExpressionArguments(close, possibleAsyncArrow, dynamicImport, allowPlaceholder, nodeForExtra) {
-    const elts = [];
-    let innerParenStart;
-    let first = true;
-    const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
-    this.state.inFSharpPipelineDirectBody = false;
-
-    while (!this.eat(close)) {
-      if (first) {
-        first = false;
-      } else {
-        this.expect(_types.types.comma);
-
-        if (this.match(close)) {
-          if (dynamicImport) {
-            this.raise(this.state.lastTokStart, "Trailing comma is disallowed inside import(...) arguments");
-          }
-
-          if (nodeForExtra) {
-            this.addExtra(nodeForExtra, "trailingComma", this.state.lastTokStart);
-          }
-
-          this.next();
-          break;
-        }
-      }
-
-      if (this.match(_types.types.parenL) && !innerParenStart) {
-        innerParenStart = this.state.start;
-      }
-
-      elts.push(this.parseExprListItem(false, possibleAsyncArrow ? {
-        start: 0
-      } : undefined, possibleAsyncArrow ? {
-        start: 0
-      } : undefined, allowPlaceholder));
-    }
-
-    if (possibleAsyncArrow && innerParenStart && this.shouldParseAsyncArrow()) {
-      this.unexpected();
-    }
-
-    this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
-    return elts;
-  }
-
-  shouldParseAsyncArrow() {
-    return this.match(_types.types.arrow) && !this.canInsertSemicolon();
-  }
-
-  parseAsyncArrowFromCallExpression(node, call) {
-    var _call$extra;
-
-    this.expect(_types.types.arrow);
-    this.parseArrowExpression(node, call.arguments, true, (_call$extra = call.extra) == null ? void 0 : _call$extra.trailingComma);
-    return node;
-  }
-
-  parseNoCallExpr() {
-    const startPos = this.state.start;
-    const startLoc = this.state.startLoc;
-    return this.parseSubscripts(this.parseExprAtom(), startPos, startLoc, true);
-  }
-
-  parseExprAtom(refShorthandDefaultPos) {
-    if (this.state.type === _types.types.slash) this.readRegexp();
-    const canBeArrow = this.state.potentialArrowAt === this.state.start;
-    let node;
-
-    switch (this.state.type) {
-      case _types.types._super:
-        node = this.startNode();
-        this.next();
-
-        if (this.match(_types.types.parenL) && !this.scope.allowDirectSuper && !this.options.allowSuperOutsideMethod) {
-          this.raise(node.start, "super() is only valid inside a class constructor of a subclass. " + "Maybe a typo in the method name ('constructor') or not extending another class?");
-        } else if (!this.scope.allowSuper && !this.options.allowSuperOutsideMethod) {
-          this.raise(node.start, "super is only allowed in object methods and classes");
-        }
-
-        if (!this.match(_types.types.parenL) && !this.match(_types.types.bracketL) && !this.match(_types.types.dot)) {
-          this.raise(node.start, "super can only be used with function calls (i.e. super()) or " + "in property accesses (i.e. super.prop or super[prop])");
-        }
-
-        return this.finishNode(node, "Super");
-
-      case _types.types._import:
-        node = this.startNode();
-        this.next();
-
-        if (this.match(_types.types.dot)) {
-          return this.parseImportMetaProperty(node);
-        }
-
-        this.expectPlugin("dynamicImport", node.start);
-
-        if (!this.match(_types.types.parenL)) {
-          this.unexpected(null, _types.types.parenL);
-        }
-
-        return this.finishNode(node, "Import");
-
-      case _types.types._this:
-        node = this.startNode();
-        this.next();
-        return this.finishNode(node, "ThisExpression");
-
-      case _types.types.name:
-        {
-          node = this.startNode();
-          const containsEsc = this.state.containsEsc;
-          const id = this.parseIdentifier();
-
-          if (!containsEsc && id.name === "async" && this.match(_types.types._function) && !this.canInsertSemicolon()) {
-            const last = this.state.context.length - 1;
-
-            if (this.state.context[last] !== _context.types.functionStatement) {
-              throw new Error("Internal error");
-            }
-
-            this.state.context[last] = _context.types.functionExpression;
-            this.next();
-            return this.parseFunction(node, undefined, true);
-          } else if (canBeArrow && !containsEsc && id.name === "async" && this.match(_types.types.name) && !this.canInsertSemicolon()) {
-            const params = [this.parseIdentifier()];
-            this.expect(_types.types.arrow);
-            this.parseArrowExpression(node, params, true);
-            return node;
-          }
-
-          if (canBeArrow && this.match(_types.types.arrow) && !this.canInsertSemicolon()) {
-            this.next();
-            this.parseArrowExpression(node, [id], false);
-            return node;
-          }
-
-          return id;
-        }
-
-      case _types.types._do:
-        {
-          this.expectPlugin("doExpressions");
-          const node = this.startNode();
-          this.next();
-          const oldLabels = this.state.labels;
-          this.state.labels = [];
-          node.body = this.parseBlock();
-          this.state.labels = oldLabels;
-          return this.finishNode(node, "DoExpression");
-        }
-
-      case _types.types.regexp:
-        {
-          const value = this.state.value;
-          node = this.parseLiteral(value.value, "RegExpLiteral");
-          node.pattern = value.pattern;
-          node.flags = value.flags;
-          return node;
-        }
-
-      case _types.types.num:
-        return this.parseLiteral(this.state.value, "NumericLiteral");
-
-      case _types.types.bigint:
-        return this.parseLiteral(this.state.value, "BigIntLiteral");
-
-      case _types.types.string:
-        return this.parseLiteral(this.state.value, "StringLiteral");
-
-      case _types.types._null:
-        node = this.startNode();
-        this.next();
-        return this.finishNode(node, "NullLiteral");
-
-      case _types.types._true:
-      case _types.types._false:
-        return this.parseBooleanLiteral();
-
-      case _types.types.parenL:
-        return this.parseParenAndDistinguishExpression(canBeArrow);
-
-      case _types.types.bracketL:
-        {
-          const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
-          this.state.inFSharpPipelineDirectBody = false;
-          node = this.startNode();
-          this.next();
-          node.elements = this.parseExprList(_types.types.bracketR, true, refShorthandDefaultPos, node);
-
-          if (!this.state.maybeInArrowParameters) {
-            this.toReferencedList(node.elements);
-          }
-
-          this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
-          return this.finishNode(node, "ArrayExpression");
-        }
-
-      case _types.types.braceL:
-        {
-          const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
-          this.state.inFSharpPipelineDirectBody = false;
-          const ret = this.parseObj(false, refShorthandDefaultPos);
-          this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
-          return ret;
-        }
-
-      case _types.types._function:
-        return this.parseFunctionExpression();
-
-      case _types.types.at:
-        this.parseDecorators();
-
-      case _types.types._class:
-        node = this.startNode();
-        this.takeDecorators(node);
-        return this.parseClass(node, false);
-
-      case _types.types._new:
-        return this.parseNew();
-
-      case _types.types.backQuote:
-        return this.parseTemplate(false);
-
-      case _types.types.doubleColon:
-        {
-          node = this.startNode();
-          this.next();
-          node.object = null;
-          const callee = node.callee = this.parseNoCallExpr();
-
-          if (callee.type === "MemberExpression") {
-            return this.finishNode(node, "BindExpression");
-          } else {
-            throw this.raise(callee.start, "Binding should be performed on object property.");
-          }
-        }
-
-      case _types.types.hash:
-        {
-          if (this.state.inPipeline) {
-            node = this.startNode();
-
-            if (this.getPluginOption("pipelineOperator", "proposal") !== "smart") {
-              this.raise(node.start, "Primary Topic Reference found but pipelineOperator not passed 'smart' for 'proposal' option.");
-            }
-
-            this.next();
-
-            if (!this.primaryTopicReferenceIsAllowedInCurrentTopicContext()) {
-              this.raise(node.start, `Topic reference was used in a lexical context without topic binding`);
-            }
-
-            this.registerTopicReference();
-            return this.finishNode(node, "PipelinePrimaryTopicReference");
-          }
-        }
-
-      default:
-        throw this.unexpected();
-    }
-  }
-
-  parseBooleanLiteral() {
-    const node = this.startNode();
-    node.value = this.match(_types.types._true);
-    this.next();
-    return this.finishNode(node, "BooleanLiteral");
-  }
-
-  parseMaybePrivateName() {
-    const isPrivate = this.match(_types.types.hash);
-
-    if (isPrivate) {
-      this.expectOnePlugin(["classPrivateProperties", "classPrivateMethods"]);
-      const node = this.startNode();
-      this.next();
-      this.assertNoSpace("Unexpected space between # and identifier");
-      node.id = this.parseIdentifier(true);
-      return this.finishNode(node, "PrivateName");
-    } else {
-      return this.parseIdentifier(true);
-    }
-  }
-
-  parseFunctionExpression() {
-    const node = this.startNode();
-    let meta = this.startNode();
-    this.next();
-    meta = this.createIdentifier(meta, "function");
-
-    if (this.scope.inGenerator && this.eat(_types.types.dot)) {
-      return this.parseMetaProperty(node, meta, "sent");
-    }
-
-    return this.parseFunction(node);
-  }
-
-  parseMetaProperty(node, meta, propertyName) {
-    node.meta = meta;
-
-    if (meta.name === "function" && propertyName === "sent") {
-      if (this.isContextual(propertyName)) {
-        this.expectPlugin("functionSent");
-      } else if (!this.hasPlugin("functionSent")) {
-        this.unexpected();
-      }
-    }
-
-    const containsEsc = this.state.containsEsc;
-    node.property = this.parseIdentifier(true);
-
-    if (node.property.name !== propertyName || containsEsc) {
-      this.raise(node.property.start, `The only valid meta property for ${meta.name} is ${meta.name}.${propertyName}`);
-    }
-
-    return this.finishNode(node, "MetaProperty");
-  }
-
-  parseImportMetaProperty(node) {
-    const id = this.createIdentifier(this.startNodeAtNode(node), "import");
-    this.expect(_types.types.dot);
-
-    if (this.isContextual("meta")) {
-      this.expectPlugin("importMeta");
-
-      if (!this.inModule) {
-        this.raise(id.start, `import.meta may appear only with 'sourceType: "module"'`, {
-          code: "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED"
-        });
-      }
-
-      this.sawUnambiguousESM = true;
-    } else if (!this.hasPlugin("importMeta")) {
-      this.raise(id.start, `Dynamic imports require a parameter: import('a.js')`);
-    }
-
-    return this.parseMetaProperty(node, id, "meta");
-  }
-
-  parseLiteral(value, type, startPos, startLoc) {
-    startPos = startPos || this.state.start;
-    startLoc = startLoc || this.state.startLoc;
-    const node = this.startNodeAt(startPos, startLoc);
-    this.addExtra(node, "rawValue", value);
-    this.addExtra(node, "raw", this.input.slice(startPos, this.state.end));
-    node.value = value;
-    this.next();
-    return this.finishNode(node, type);
-  }
-
-  parseParenAndDistinguishExpression(canBeArrow) {
-    const startPos = this.state.start;
-    const startLoc = this.state.startLoc;
-    let val;
-    this.expect(_types.types.parenL);
-    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
-    const oldYieldPos = this.state.yieldPos;
-    const oldAwaitPos = this.state.awaitPos;
-    const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
-    this.state.maybeInArrowParameters = true;
-    this.state.yieldPos = -1;
-    this.state.awaitPos = -1;
-    this.state.inFSharpPipelineDirectBody = false;
-    const innerStartPos = this.state.start;
-    const innerStartLoc = this.state.startLoc;
-    const exprList = [];
-    const refShorthandDefaultPos = {
-      start: 0
-    };
-    const refNeedsArrowPos = {
-      start: 0
-    };
-    let first = true;
-    let spreadStart;
-    let optionalCommaStart;
-
-    while (!this.match(_types.types.parenR)) {
-      if (first) {
-        first = false;
-      } else {
-        this.expect(_types.types.comma, refNeedsArrowPos.start || null);
-
-        if (this.match(_types.types.parenR)) {
-          optionalCommaStart = this.state.start;
-          break;
-        }
-      }
-
-      if (this.match(_types.types.ellipsis)) {
-        const spreadNodeStartPos = this.state.start;
-        const spreadNodeStartLoc = this.state.startLoc;
-        spreadStart = this.state.start;
-        exprList.push(this.parseParenItem(this.parseRestBinding(), spreadNodeStartPos, spreadNodeStartLoc));
-        this.checkCommaAfterRest(41);
-        break;
-      } else {
-        exprList.push(this.parseMaybeAssign(false, refShorthandDefaultPos, this.parseParenItem, refNeedsArrowPos));
-      }
-    }
-
-    const innerEndPos = this.state.start;
-    const innerEndLoc = this.state.startLoc;
-    this.expect(_types.types.parenR);
-    this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
-    this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
-    let arrowNode = this.startNodeAt(startPos, startLoc);
-
-    if (canBeArrow && this.shouldParseArrow() && (arrowNode = this.parseArrow(arrowNode))) {
-      this.checkYieldAwaitInDefaultParams();
-      this.state.yieldPos = oldYieldPos;
-      this.state.awaitPos = oldAwaitPos;
-
-      for (let _i = 0; _i < exprList.length; _i++) {
-        const param = exprList[_i];
-
-        if (param.extra && param.extra.parenthesized) {
-          this.unexpected(param.extra.parenStart);
-        }
-      }
-
-      this.parseArrowExpression(arrowNode, exprList, false);
-      return arrowNode;
-    }
-
-    if (oldYieldPos !== -1) this.state.yieldPos = oldYieldPos;
-    if (oldAwaitPos !== -1) this.state.awaitPos = oldAwaitPos;
-
-    if (!exprList.length) {
-      this.unexpected(this.state.lastTokStart);
-    }
-
-    if (optionalCommaStart) this.unexpected(optionalCommaStart);
-    if (spreadStart) this.unexpected(spreadStart);
-
-    if (refShorthandDefaultPos.start) {
-      this.unexpected(refShorthandDefaultPos.start);
-    }
-
-    if (refNeedsArrowPos.start) this.unexpected(refNeedsArrowPos.start);
-    this.toReferencedListDeep(exprList, true);
-
-    if (exprList.length > 1) {
-      val = this.startNodeAt(innerStartPos, innerStartLoc);
-      val.expressions = exprList;
-      this.finishNodeAt(val, "SequenceExpression", innerEndPos, innerEndLoc);
-    } else {
-      val = exprList[0];
-    }
-
-    if (!this.options.createParenthesizedExpressions) {
-      this.addExtra(val, "parenthesized", true);
-      this.addExtra(val, "parenStart", startPos);
-      return val;
-    }
-
-    const parenExpression = this.startNodeAt(startPos, startLoc);
-    parenExpression.expression = val;
-    this.finishNode(parenExpression, "ParenthesizedExpression");
-    return parenExpression;
-  }
-
-  shouldParseArrow() {
-    return !this.canInsertSemicolon();
-  }
-
-  parseArrow(node) {
-    if (this.eat(_types.types.arrow)) {
-      return node;
-    }
-  }
-
-  parseParenItem(node, startPos, startLoc) {
-    return node;
-  }
-
-  parseNew() {
-    const node = this.startNode();
-    let meta = this.startNode();
-    this.next();
-    meta = this.createIdentifier(meta, "new");
-
-    if (this.eat(_types.types.dot)) {
-      const metaProp = this.parseMetaProperty(node, meta, "target");
-
-      if (!this.scope.inNonArrowFunction && !this.state.inClassProperty) {
-        let error = "new.target can only be used in functions";
-
-        if (this.hasPlugin("classProperties")) {
-          error += " or class properties";
-        }
-
-        this.raise(metaProp.start, error);
-      }
-
-      return metaProp;
-    }
-
-    node.callee = this.parseNoCallExpr();
-
-    if (node.callee.type === "Import") {
-      this.raise(node.callee.start, "Cannot use new with import(...)");
-    } else if (node.callee.type === "OptionalMemberExpression" || node.callee.type === "OptionalCallExpression") {
-      this.raise(this.state.lastTokEnd, "constructors in/after an Optional Chain are not allowed");
-    } else if (this.eat(_types.types.questionDot)) {
-      this.raise(this.state.start, "constructors in/after an Optional Chain are not allowed");
-    }
-
-    this.parseNewArguments(node);
-    return this.finishNode(node, "NewExpression");
-  }
-
-  parseNewArguments(node) {
-    if (this.eat(_types.types.parenL)) {
-      const args = this.parseExprList(_types.types.parenR);
-      this.toReferencedList(args);
-      node.arguments = args;
-    } else {
-      node.arguments = [];
-    }
-  }
-
-  parseTemplateElement(isTagged) {
-    const elem = this.startNode();
-
-    if (this.state.value === null) {
-      if (!isTagged) {
-        this.raise(this.state.invalidTemplateEscapePosition || 0, "Invalid escape sequence in template");
-      } else {
-        this.state.invalidTemplateEscapePosition = null;
-      }
-    }
-
-    elem.value = {
-      raw: this.input.slice(this.state.start, this.state.end).replace(/\r\n?/g, "\n"),
-      cooked: this.state.value
-    };
-    this.next();
-    elem.tail = this.match(_types.types.backQuote);
-    return this.finishNode(elem, "TemplateElement");
-  }
-
-  parseTemplate(isTagged) {
-    const node = this.startNode();
-    this.next();
-    node.expressions = [];
-    let curElt = this.parseTemplateElement(isTagged);
-    node.quasis = [curElt];
-
-    while (!curElt.tail) {
-      this.expect(_types.types.dollarBraceL);
-      node.expressions.push(this.parseExpression());
-      this.expect(_types.types.braceR);
-      node.quasis.push(curElt = this.parseTemplateElement(isTagged));
-    }
-
-    this.next();
-    return this.finishNode(node, "TemplateLiteral");
-  }
-
-  parseObj(isPattern, refShorthandDefaultPos) {
-    const propHash = Object.create(null);
-    let first = true;
-    const node = this.startNode();
-    node.properties = [];
-    this.next();
-
-    while (!this.eat(_types.types.braceR)) {
-      if (first) {
-        first = false;
-      } else {
-        this.expect(_types.types.comma);
-
-        if (this.match(_types.types.braceR)) {
-          this.addExtra(node, "trailingComma", this.state.lastTokStart);
-          this.next();
-          break;
-        }
-      }
-
-      const prop = this.parseObjectMember(isPattern, refShorthandDefaultPos);
-      if (!isPattern) this.checkDuplicatedProto(prop, propHash);
-
-      if (prop.shorthand) {
-        this.addExtra(prop, "shorthand", true);
-      }
-
-      node.properties.push(prop);
-    }
-
-    if (!this.match(_types.types.eq) && propHash.start !== undefined) {
-      this.raise(propHash.start, "Redefinition of __proto__ property");
-    }
-
-    return this.finishNode(node, isPattern ? "ObjectPattern" : "ObjectExpression");
-  }
-
-  isAsyncProp(prop) {
-    return !prop.computed && prop.key.type === "Identifier" && prop.key.name === "async" && (this.match(_types.types.name) || this.match(_types.types.num) || this.match(_types.types.string) || this.match(_types.types.bracketL) || this.state.type.keyword || this.match(_types.types.star)) && !this.hasPrecedingLineBreak();
-  }
-
-  parseObjectMember(isPattern, refShorthandDefaultPos) {
-    let decorators = [];
-
-    if (this.match(_types.types.at)) {
-      if (this.hasPlugin("decorators")) {
-        this.raise(this.state.start, "Stage 2 decorators disallow object literal property decorators");
-      }
-
-      while (this.match(_types.types.at)) {
-        decorators.push(this.parseDecorator());
-      }
-    }
-
-    const prop = this.startNode();
-    let isGenerator = false;
-    let isAsync = false;
-    let startPos;
-    let startLoc;
-
-    if (this.match(_types.types.ellipsis)) {
-      if (decorators.length) this.unexpected();
-
-      if (isPattern) {
-        this.next();
-        prop.argument = this.parseIdentifier();
-        this.checkCommaAfterRest(125);
-        return this.finishNode(prop, "RestElement");
-      }
-
-      return this.parseSpread();
-    }
-
-    if (decorators.length) {
-      prop.decorators = decorators;
-      decorators = [];
-    }
-
-    prop.method = false;
-
-    if (isPattern || refShorthandDefaultPos) {
-      startPos = this.state.start;
-      startLoc = this.state.startLoc;
-    }
-
-    if (!isPattern) {
-      isGenerator = this.eat(_types.types.star);
-    }
-
-    const containsEsc = this.state.containsEsc;
-    this.parsePropertyName(prop);
-
-    if (!isPattern && !containsEsc && !isGenerator && this.isAsyncProp(prop)) {
-      isAsync = true;
-      isGenerator = this.eat(_types.types.star);
-      this.parsePropertyName(prop);
-    } else {
-      isAsync = false;
-    }
-
-    this.parseObjPropValue(prop, startPos, startLoc, isGenerator, isAsync, isPattern, refShorthandDefaultPos, containsEsc);
-    return prop;
-  }
-
-  isGetterOrSetterMethod(prop, isPattern) {
-    return !isPattern && !prop.computed && prop.key.type === "Identifier" && (prop.key.name === "get" || prop.key.name === "set") && (this.match(_types.types.string) || this.match(_types.types.num) || this.match(_types.types.bracketL) || this.match(_types.types.name) || !!this.state.type.keyword);
-  }
-
-  getGetterSetterExpectedParamCount(method) {
-    return method.kind === "get" ? 0 : 1;
-  }
-
-  checkGetterSetterParams(method) {
-    const paramCount = this.getGetterSetterExpectedParamCount(method);
-    const start = method.start;
-
-    if (method.params.length !== paramCount) {
-      if (method.kind === "get") {
-        this.raise(start, "getter must not have any formal parameters");
-      } else {
-        this.raise(start, "setter must have exactly one formal parameter");
-      }
-    }
-
-    if (method.kind === "set" && method.params[method.params.length - 1].type === "RestElement") {
-      this.raise(start, "setter function argument must not be a rest parameter");
-    }
-  }
-
-  parseObjectMethod(prop, isGenerator, isAsync, isPattern, containsEsc) {
-    if (isAsync || isGenerator || this.match(_types.types.parenL)) {
-      if (isPattern) this.unexpected();
-      prop.kind = "method";
-      prop.method = true;
-      return this.parseMethod(prop, isGenerator, isAsync, false, false, "ObjectMethod");
-    }
-
-    if (!containsEsc && this.isGetterOrSetterMethod(prop, isPattern)) {
-      if (isGenerator || isAsync) this.unexpected();
-      prop.kind = prop.key.name;
-      this.parsePropertyName(prop);
-      this.parseMethod(prop, false, false, false, false, "ObjectMethod");
-      this.checkGetterSetterParams(prop);
-      return prop;
-    }
-  }
-
-  parseObjectProperty(prop, startPos, startLoc, isPattern, refShorthandDefaultPos) {
-    prop.shorthand = false;
-
-    if (this.eat(_types.types.colon)) {
-      prop.value = isPattern ? this.parseMaybeDefault(this.state.start, this.state.startLoc) : this.parseMaybeAssign(false, refShorthandDefaultPos);
-      return this.finishNode(prop, "ObjectProperty");
-    }
-
-    if (!prop.computed && prop.key.type === "Identifier") {
-      this.checkReservedWord(prop.key.name, prop.key.start, true, true);
-
-      if (isPattern) {
-        prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key.__clone());
-      } else if (this.match(_types.types.eq) && refShorthandDefaultPos) {
-        if (!refShorthandDefaultPos.start) {
-          refShorthandDefaultPos.start = this.state.start;
-        }
-
-        prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key.__clone());
-      } else {
-        prop.value = prop.key.__clone();
-      }
-
-      prop.shorthand = true;
-      return this.finishNode(prop, "ObjectProperty");
-    }
-  }
-
-  parseObjPropValue(prop, startPos, startLoc, isGenerator, isAsync, isPattern, refShorthandDefaultPos, containsEsc) {
-    const node = this.parseObjectMethod(prop, isGenerator, isAsync, isPattern, containsEsc) || this.parseObjectProperty(prop, startPos, startLoc, isPattern, refShorthandDefaultPos);
-    if (!node) this.unexpected();
-    return node;
-  }
-
-  parsePropertyName(prop) {
-    if (this.eat(_types.types.bracketL)) {
-      prop.computed = true;
-      prop.key = this.parseMaybeAssign();
-      this.expect(_types.types.bracketR);
-    } else {
-      const oldInPropertyName = this.state.inPropertyName;
-      this.state.inPropertyName = true;
-      prop.key = this.match(_types.types.num) || this.match(_types.types.string) ? this.parseExprAtom() : this.parseMaybePrivateName();
-
-      if (prop.key.type !== "PrivateName") {
-        prop.computed = false;
-      }
-
-      this.state.inPropertyName = oldInPropertyName;
-    }
-
-    return prop.key;
-  }
-
-  initFunction(node, isAsync) {
-    node.id = null;
-    node.generator = false;
-    node.async = !!isAsync;
-  }
-
-  parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope = false) {
-    const oldYieldPos = this.state.yieldPos;
-    const oldAwaitPos = this.state.awaitPos;
-    this.state.yieldPos = -1;
-    this.state.awaitPos = -1;
-    this.initFunction(node, isAsync);
-    node.generator = !!isGenerator;
-    const allowModifiers = isConstructor;
-    this.scope.enter((0, _scopeflags.functionFlags)(isAsync, node.generator) | _scopeflags.SCOPE_SUPER | (inClassScope ? _scopeflags.SCOPE_CLASS : 0) | (allowDirectSuper ? _scopeflags.SCOPE_DIRECT_SUPER : 0));
-    this.parseFunctionParams(node, allowModifiers);
-    this.checkYieldAwaitInDefaultParams();
-    this.parseFunctionBodyAndFinish(node, type, true);
-    this.scope.exit();
-    this.state.yieldPos = oldYieldPos;
-    this.state.awaitPos = oldAwaitPos;
-    return node;
-  }
-
-  parseArrowExpression(node, params, isAsync, trailingCommaPos) {
-    this.scope.enter((0, _scopeflags.functionFlags)(isAsync, false) | _scopeflags.SCOPE_ARROW);
-    this.initFunction(node, isAsync);
-    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
-    const oldYieldPos = this.state.yieldPos;
-    const oldAwaitPos = this.state.awaitPos;
-    this.state.maybeInArrowParameters = false;
-    this.state.yieldPos = -1;
-    this.state.awaitPos = -1;
-    if (params) this.setArrowFunctionParameters(node, params, trailingCommaPos);
-    this.parseFunctionBody(node, true);
-    this.scope.exit();
-    this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
-    this.state.yieldPos = oldYieldPos;
-    this.state.awaitPos = oldAwaitPos;
-    return this.finishNode(node, "ArrowFunctionExpression");
-  }
-
-  setArrowFunctionParameters(node, params, trailingCommaPos) {
-    node.params = this.toAssignableList(params, true, "arrow function parameters", trailingCommaPos);
-  }
-
-  isStrictBody(node) {
-    const isBlockStatement = node.body.type === "BlockStatement";
-
-    if (isBlockStatement && node.body.directives.length) {
-      for (let _i2 = 0, _node$body$directives = node.body.directives; _i2 < _node$body$directives.length; _i2++) {
-        const directive = _node$body$directives[_i2];
-
-        if (directive.value.value === "use strict") {
-          return true;
-        }
-      }
-    }
-
-    return false;
-  }
-
-  parseFunctionBodyAndFinish(node, type, isMethod = false) {
-    this.parseFunctionBody(node, false, isMethod);
-    this.finishNode(node, type);
-  }
-
-  parseFunctionBody(node, allowExpression, isMethod = false) {
-    const isExpression = allowExpression && !this.match(_types.types.braceL);
-    const oldStrict = this.state.strict;
-    let useStrict = false;
-    const oldInParameters = this.state.inParameters;
-    this.state.inParameters = false;
-
-    if (isExpression) {
-      node.body = this.parseMaybeAssign();
-      this.checkParams(node, false, allowExpression, false);
-    } else {
-      const nonSimple = !this.isSimpleParamList(node.params);
-
-      if (!oldStrict || nonSimple) {
-        useStrict = this.strictDirective(this.state.end);
-
-        if (useStrict && nonSimple) {
-          const errorPos = (node.kind === "method" || node.kind === "constructor") && !!node.key ? node.key.end : node.start;
-          this.raise(errorPos, "Illegal 'use strict' directive in function with non-simple parameter list");
-        }
-      }
-
-      const oldLabels = this.state.labels;
-      this.state.labels = [];
-      if (useStrict) this.state.strict = true;
-      this.checkParams(node, !oldStrict && !useStrict && !allowExpression && !isMethod && !nonSimple, allowExpression, !oldStrict && useStrict);
-      node.body = this.parseBlock(true, false);
-      this.state.labels = oldLabels;
-    }
-
-    this.state.inParameters = oldInParameters;
-
-    if (this.state.strict && node.id) {
-      this.checkLVal(node.id, _scopeflags.BIND_OUTSIDE, undefined, "function name", undefined, !oldStrict && useStrict);
-    }
-
-    this.state.strict = oldStrict;
-  }
-
-  isSimpleParamList(params) {
-    for (let i = 0, len = params.length; i < len; i++) {
-      if (params[i].type !== "Identifier") return false;
-    }
-
-    return true;
-  }
-
-  checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged = true) {
-    const nameHash = Object.create(null);
-
-    for (let i = 0; i < node.params.length; i++) {
-      this.checkLVal(node.params[i], _scopeflags.BIND_VAR, allowDuplicates ? null : nameHash, "function parameter list", undefined, strictModeChanged);
-    }
-  }
-
-  parseExprList(close, allowEmpty, refShorthandDefaultPos, nodeForExtra) {
-    const elts = [];
-    let first = true;
-
-    while (!this.eat(close)) {
-      if (first) {
-        first = false;
-      } else {
-        this.expect(_types.types.comma);
-
-        if (this.match(close)) {
-          if (nodeForExtra) {
-            this.addExtra(nodeForExtra, "trailingComma", this.state.lastTokStart);
-          }
-
-          this.next();
-          break;
-        }
-      }
-
-      elts.push(this.parseExprListItem(allowEmpty, refShorthandDefaultPos));
-    }
-
-    return elts;
-  }
-
-  parseExprListItem(allowEmpty, refShorthandDefaultPos, refNeedsArrowPos, allowPlaceholder) {
-    let elt;
-
-    if (allowEmpty && this.match(_types.types.comma)) {
-      elt = null;
-    } else if (this.match(_types.types.ellipsis)) {
-      const spreadNodeStartPos = this.state.start;
-      const spreadNodeStartLoc = this.state.startLoc;
-      elt = this.parseParenItem(this.parseSpread(refShorthandDefaultPos, refNeedsArrowPos), spreadNodeStartPos, spreadNodeStartLoc);
-    } else if (this.match(_types.types.question)) {
-      this.expectPlugin("partialApplication");
-
-      if (!allowPlaceholder) {
-        this.raise(this.state.start, "Unexpected argument placeholder");
-      }
-
-      const node = this.startNode();
-      this.next();
-      elt = this.finishNode(node, "ArgumentPlaceholder");
-    } else {
-      elt = this.parseMaybeAssign(false, refShorthandDefaultPos, this.parseParenItem, refNeedsArrowPos);
-    }
-
-    return elt;
-  }
-
-  parseIdentifier(liberal) {
-    const node = this.startNode();
-    const name = this.parseIdentifierName(node.start, liberal);
-    return this.createIdentifier(node, name);
-  }
-
-  createIdentifier(node, name) {
-    node.name = name;
-    node.loc.identifierName = name;
-    return this.finishNode(node, "Identifier");
-  }
-
-  parseIdentifierName(pos, liberal) {
-    let name;
-
-    if (this.match(_types.types.name)) {
-      name = this.state.value;
-    } else if (this.state.type.keyword) {
-      name = this.state.type.keyword;
-
-      if ((name === "class" || name === "function") && (this.state.lastTokEnd !== this.state.lastTokStart + 1 || this.input.charCodeAt(this.state.lastTokStart) !== 46)) {
-        this.state.context.pop();
-      }
-    } else {
-      throw this.unexpected();
-    }
-
-    if (liberal) {
-      this.state.type = _types.types.name;
-    } else {
-      this.checkReservedWord(name, this.state.start, !!this.state.type.keyword, false);
-    }
-
-    this.next();
-    return name;
-  }
-
-  checkReservedWord(word, startLoc, checkKeywords, isBinding) {
-    if (this.scope.inGenerator && word === "yield") {
-      this.raise(startLoc, "Can not use 'yield' as identifier inside a generator");
-      return;
-    }
-
-    if (word === "await") {
-      if (this.scope.inAsync) {
-        this.raise(startLoc, "Can not use 'await' as identifier inside an async function");
-        return;
-      }
-
-      if (this.state.awaitPos === -1 && (this.state.maybeInArrowParameters || this.isAwaitAllowed())) {
-        this.state.awaitPos = this.state.start;
-      }
-    }
-
-    if (this.scope.inClass && !this.scope.inNonArrowFunction && word === "arguments") {
-      this.raise(startLoc, "'arguments' is not allowed in class field initializer");
-      return;
-    }
-
-    if (checkKeywords && (0, _identifier.isKeyword)(word)) {
-      this.raise(startLoc, `Unexpected keyword '${word}'`);
-      return;
-    }
-
-    const reservedTest = !this.state.strict ? _identifier.isReservedWord : isBinding ? _identifier.isStrictBindReservedWord : _identifier.isStrictReservedWord;
-
-    if (reservedTest(word, this.inModule)) {
-      if (!this.scope.inAsync && word === "await") {
-        this.raise(startLoc, "Can not use keyword 'await' outside an async function");
-      } else {
-        this.raise(startLoc, `Unexpected reserved word '${word}'`);
-      }
-    }
-  }
-
-  isAwaitAllowed() {
-    if (this.scope.inFunction) return this.scope.inAsync;
-    if (this.options.allowAwaitOutsideFunction) return true;
-    if (this.hasPlugin("topLevelAwait")) return this.inModule;
-    return false;
-  }
-
-  parseAwait() {
-    const node = this.startNode();
-    this.next();
-
-    if (this.state.inParameters) {
-      this.raise(node.start, "await is not allowed in async function parameters");
-    } else if (this.state.awaitPos === -1) {
-      this.state.awaitPos = node.start;
-    }
-
-    if (this.eat(_types.types.star)) {
-      this.raise(node.start, "await* has been removed from the async functions proposal. Use Promise.all() instead.");
-    }
-
-    if (!this.scope.inFunction && !this.options.allowAwaitOutsideFunction) {
-      if (this.hasPrecedingLineBreak() || this.match(_types.types.plusMin) || this.match(_types.types.parenL) || this.match(_types.types.bracketL) || this.match(_types.types.backQuote) || this.match(_types.types.regexp) || this.match(_types.types.slash) || this.hasPlugin("v8intrinsic") && this.match(_types.types.modulo)) {
-        this.ambiguousScriptDifferentAst = true;
-      } else {
-        this.sawUnambiguousESM = true;
-      }
-    }
-
-    if (!this.state.soloAwait) {
-      node.argument = this.parseMaybeUnary();
-    }
-
-    return this.finishNode(node, "AwaitExpression");
-  }
-
-  parseYield(noIn) {
-    const node = this.startNode();
-
-    if (this.state.inParameters) {
-      this.raise(node.start, "yield is not allowed in generator parameters");
-    } else if (this.state.yieldPos === -1) {
-      this.state.yieldPos = node.start;
-    }
-
-    this.next();
-
-    if (this.match(_types.types.semi) || !this.match(_types.types.star) && !this.state.type.startsExpr || this.hasPrecedingLineBreak()) {
-      node.delegate = false;
-      node.argument = null;
-    } else {
-      node.delegate = this.eat(_types.types.star);
-      node.argument = this.parseMaybeAssign(noIn);
-    }
-
-    return this.finishNode(node, "YieldExpression");
-  }
-
-  checkPipelineAtInfixOperator(left, leftStartPos) {
-    if (this.getPluginOption("pipelineOperator", "proposal") === "smart") {
-      if (left.type === "SequenceExpression") {
-        this.raise(leftStartPos, `Pipeline head should not be a comma-separated sequence expression`);
-      }
-    }
-  }
-
-  parseSmartPipelineBody(childExpression, startPos, startLoc) {
-    const pipelineStyle = this.checkSmartPipelineBodyStyle(childExpression);
-    this.checkSmartPipelineBodyEarlyErrors(childExpression, pipelineStyle, startPos);
-    return this.parseSmartPipelineBodyInStyle(childExpression, pipelineStyle, startPos, startLoc);
-  }
-
-  checkSmartPipelineBodyEarlyErrors(childExpression, pipelineStyle, startPos) {
-    if (this.match(_types.types.arrow)) {
-      throw this.raise(this.state.start, `Unexpected arrow "=>" after pipeline body; arrow function in pipeline body must be parenthesized`);
-    } else if (pipelineStyle === "PipelineTopicExpression" && childExpression.type === "SequenceExpression") {
-      this.raise(startPos, `Pipeline body may not be a comma-separated sequence expression`);
-    }
-  }
-
-  parseSmartPipelineBodyInStyle(childExpression, pipelineStyle, startPos, startLoc) {
-    const bodyNode = this.startNodeAt(startPos, startLoc);
-
-    switch (pipelineStyle) {
-      case "PipelineBareFunction":
-        bodyNode.callee = childExpression;
-        break;
-
-      case "PipelineBareConstructor":
-        bodyNode.callee = childExpression.callee;
-        break;
-
-      case "PipelineBareAwaitedFunction":
-        bodyNode.callee = childExpression.argument;
-        break;
-
-      case "PipelineTopicExpression":
-        if (!this.topicReferenceWasUsedInCurrentTopicContext()) {
-          this.raise(startPos, `Pipeline is in topic style but does not use topic reference`);
-        }
-
-        bodyNode.expression = childExpression;
-        break;
-
-      default:
-        throw new Error(`Internal @babel/parser error: Unknown pipeline style (${pipelineStyle})`);
-    }
-
-    return this.finishNode(bodyNode, pipelineStyle);
-  }
-
-  checkSmartPipelineBodyStyle(expression) {
-    switch (expression.type) {
-      default:
-        return this.isSimpleReference(expression) ? "PipelineBareFunction" : "PipelineTopicExpression";
-    }
-  }
-
-  isSimpleReference(expression) {
-    switch (expression.type) {
-      case "MemberExpression":
-        return !expression.computed && this.isSimpleReference(expression.object);
-
-      case "Identifier":
-        return true;
-
-      default:
-        return false;
-    }
-  }
-
-  withTopicPermittingContext(callback) {
-    const outerContextTopicState = this.state.topicContext;
-    this.state.topicContext = {
-      maxNumOfResolvableTopics: 1,
-      maxTopicIndex: null
-    };
-
-    try {
-      return callback();
-    } finally {
-      this.state.topicContext = outerContextTopicState;
-    }
-  }
-
-  withTopicForbiddingContext(callback) {
-    const outerContextTopicState = this.state.topicContext;
-    this.state.topicContext = {
-      maxNumOfResolvableTopics: 0,
-      maxTopicIndex: null
-    };
-
-    try {
-      return callback();
-    } finally {
-      this.state.topicContext = outerContextTopicState;
-    }
-  }
-
-  withSoloAwaitPermittingContext(callback) {
-    const outerContextSoloAwaitState = this.state.soloAwait;
-    this.state.soloAwait = true;
-
-    try {
-      return callback();
-    } finally {
-      this.state.soloAwait = outerContextSoloAwaitState;
-    }
-  }
-
-  registerTopicReference() {
-    this.state.topicContext.maxTopicIndex = 0;
-  }
-
-  primaryTopicReferenceIsAllowedInCurrentTopicContext() {
-    return this.state.topicContext.maxNumOfResolvableTopics >= 1;
-  }
-
-  topicReferenceWasUsedInCurrentTopicContext() {
-    return this.state.topicContext.maxTopicIndex != null && this.state.topicContext.maxTopicIndex >= 0;
-  }
-
-  parseFSharpPipelineBody(prec, noIn) {
-    const startPos = this.state.start;
-    const startLoc = this.state.startLoc;
-    this.state.potentialArrowAt = this.state.start;
-    const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
-    this.state.inFSharpPipelineDirectBody = true;
-    const ret = this.parseExprOp(this.parseMaybeUnary(), startPos, startLoc, prec, noIn);
-    this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
-    return ret;
-  }
-
-}
-
-exports.default = ExpressionParser;