"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;