diff options
Diffstat (limited to 'node_modules/@babel/parser/lib/index.js')
| -rw-r--r-- | node_modules/@babel/parser/lib/index.js | 621 |
1 files changed, 302 insertions, 319 deletions
diff --git a/node_modules/@babel/parser/lib/index.js b/node_modules/@babel/parser/lib/index.js index 63373c8c..3b5c6bc8 100644 --- a/node_modules/@babel/parser/lib/index.js +++ b/node_modules/@babel/parser/lib/index.js @@ -3,17 +3,14 @@ Object.defineProperty(exports, '__esModule', { value: true }); -function _objectWithoutPropertiesLoose(source, excluded) { - if (source == null) return {}; - var target = {}; - var sourceKeys = Object.keys(source); - var key, i; - for (i = 0; i < sourceKeys.length; i++) { - key = sourceKeys[i]; - if (excluded.indexOf(key) >= 0) continue; - target[key] = source[key]; - } - return target; +function _objectWithoutPropertiesLoose(r, e) { + if (null == r) return {}; + var t = {}; + for (var n in r) if ({}.hasOwnProperty.call(r, n)) { + if (e.includes(n)) continue; + t[n] = r[n]; + } + return t; } class Position { constructor(line, col, index) { @@ -333,8 +330,7 @@ var PipelineOperatorErrors = { PrimaryTopicNotAllowed: "Topic reference was used in a lexical context without topic binding.", PrimaryTopicRequiresSmartPipeline: 'Topic reference is used, but the pipelineOperator plugin was not passed a "proposal": "hack" or "smart" option.' }; -const _excluded = ["toMessage"], - _excluded2 = ["message"]; +const _excluded = ["message"]; function defineHidden(obj, key, value) { Object.defineProperty(obj, key, { enumerable: false, @@ -342,21 +338,35 @@ function defineHidden(obj, key, value) { value }); } -function toParseErrorConstructor(_ref) { - let { - toMessage - } = _ref, - properties = _objectWithoutPropertiesLoose(_ref, _excluded); +function toParseErrorConstructor({ + toMessage, + code, + reasonCode, + syntaxPlugin +}) { + const hasMissingPlugin = reasonCode === "MissingPlugin" || reasonCode === "MissingOneOfPlugins"; + { + const oldReasonCodes = { + AccessorCannotDeclareThisParameter: "AccesorCannotDeclareThisParameter", + AccessorCannotHaveTypeParameters: "AccesorCannotHaveTypeParameters", + ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference: "ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference", + SetAccessorCannotHaveOptionalParameter: "SetAccesorCannotHaveOptionalParameter", + SetAccessorCannotHaveRestParameter: "SetAccesorCannotHaveRestParameter", + SetAccessorCannotHaveReturnType: "SetAccesorCannotHaveReturnType" + }; + if (oldReasonCodes[reasonCode]) { + reasonCode = oldReasonCodes[reasonCode]; + } + } return function constructor(loc, details) { const error = new SyntaxError(); - Object.assign(error, properties, { - loc, - pos: loc.index - }); - if ("missingPlugin" in details) { - Object.assign(error, { - missingPlugin: details.missingPlugin - }); + error.code = code; + error.reasonCode = reasonCode; + error.loc = loc; + error.pos = loc.index; + error.syntaxPlugin = syntaxPlugin; + if (hasMissingPlugin) { + error.missingPlugin = details.missingPlugin; } defineHidden(error, "clone", function clone(overrides = {}) { var _overrides$loc; @@ -392,15 +402,15 @@ function ParseErrorEnum(argument, syntaxPlugin) { const ParseErrorConstructors = {}; for (const reasonCode of Object.keys(argument)) { const template = argument[reasonCode]; - const _ref2 = typeof template === "string" ? { + const _ref = typeof template === "string" ? { message: () => template } : typeof template === "function" ? { message: template } : template, { message - } = _ref2, - rest = _objectWithoutPropertiesLoose(_ref2, _excluded2); + } = _ref, + rest = _objectWithoutPropertiesLoose(_ref, _excluded); const toMessage = typeof message === "string" ? () => message : message; ParseErrorConstructors[reasonCode] = toParseErrorConstructor(Object.assign({ code: "BABEL_PARSER_SYNTAX_ERROR", @@ -416,13 +426,17 @@ const Errors = Object.assign({}, ParseErrorEnum(ModuleErrors), ParseErrorEnum(St const { defineProperty } = Object; -const toUnenumerable = (object, key) => defineProperty(object, key, { - enumerable: false, - value: object[key] -}); +const toUnenumerable = (object, key) => { + if (object) { + defineProperty(object, key, { + enumerable: false, + value: object[key] + }); + } +}; function toESTreeLocation(node) { - node.loc.start && toUnenumerable(node.loc.start, "index"); - node.loc.end && toUnenumerable(node.loc.end, "index"); + toUnenumerable(node.loc.start, "index"); + toUnenumerable(node.loc.end, "index"); return node; } var estree = superClass => class ESTreeParserMixin extends superClass { @@ -440,7 +454,7 @@ var estree = superClass => class ESTreeParserMixin extends superClass { let regex = null; try { regex = new RegExp(pattern, flags); - } catch (e) {} + } catch (_) {} const node = this.estreeParseLiteral(regex); node.regex = { pattern, @@ -1786,7 +1800,7 @@ class CommentsParser extends BaseParser { } } } -const lineBreak = /\r\n?|[\n\u2028\u2029]/; +const lineBreak = /\r\n|[\r\n\u2028\u2029]/; const lineBreakG = new RegExp(lineBreak.source, "g"); function isNewLine(code) { switch (code) { @@ -1799,9 +1813,16 @@ function isNewLine(code) { return false; } } +function hasNewLine(input, start, end) { + for (let i = start; i < end; i++) { + if (isNewLine(input.charCodeAt(i))) { + return true; + } + } + return false; +} const skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g; const skipWhiteSpaceInLine = /(?:[^\S\n\r\u2028\u2029]|\/\/.*|\/\*.*?\*\/)*/g; -const skipWhiteSpaceToLineBreak = new RegExp("(?=(" + skipWhiteSpaceInLine.source + "))\\1" + /(?=[\n\r\u2028\u2029]|\/\*(?!.*?\*\/)|$)/.source, "y"); function isWhitespace(code) { switch (code) { case 0x0009: @@ -1863,12 +1884,8 @@ class State { get strict() { return (this.flags & 1) > 0; } - set strict(value) { - if (value) { - this.flags |= 1; - } else { - this.flags &= ~1; - } + set strict(v) { + if (v) this.flags |= 1;else this.flags &= -2; } init({ strictMode, @@ -1884,112 +1901,74 @@ class State { get maybeInArrowParameters() { return (this.flags & 2) > 0; } - set maybeInArrowParameters(value) { - if (value) { - this.flags |= 2; - } else { - this.flags &= ~2; - } + set maybeInArrowParameters(v) { + if (v) this.flags |= 2;else this.flags &= -3; } get inType() { return (this.flags & 4) > 0; } - set inType(value) { - if (value) { - this.flags |= 4; - } else { - this.flags &= ~4; - } + set inType(v) { + if (v) this.flags |= 4;else this.flags &= -5; } get noAnonFunctionType() { return (this.flags & 8) > 0; } - set noAnonFunctionType(value) { - if (value) { - this.flags |= 8; - } else { - this.flags &= ~8; - } + set noAnonFunctionType(v) { + if (v) this.flags |= 8;else this.flags &= -9; } get hasFlowComment() { return (this.flags & 16) > 0; } - set hasFlowComment(value) { - if (value) { - this.flags |= 16; - } else { - this.flags &= ~16; - } + set hasFlowComment(v) { + if (v) this.flags |= 16;else this.flags &= -17; } get isAmbientContext() { return (this.flags & 32) > 0; } - set isAmbientContext(value) { - if (value) { - this.flags |= 32; - } else { - this.flags &= ~32; - } + set isAmbientContext(v) { + if (v) this.flags |= 32;else this.flags &= -33; } get inAbstractClass() { return (this.flags & 64) > 0; } - set inAbstractClass(value) { - if (value) { - this.flags |= 64; - } else { - this.flags &= ~64; - } + set inAbstractClass(v) { + if (v) this.flags |= 64;else this.flags &= -65; } get inDisallowConditionalTypesContext() { return (this.flags & 128) > 0; } - set inDisallowConditionalTypesContext(value) { - if (value) { - this.flags |= 128; - } else { - this.flags &= ~128; - } + set inDisallowConditionalTypesContext(v) { + if (v) this.flags |= 128;else this.flags &= -129; } get soloAwait() { return (this.flags & 256) > 0; } - set soloAwait(value) { - if (value) { - this.flags |= 256; - } else { - this.flags &= ~256; - } + set soloAwait(v) { + if (v) this.flags |= 256;else this.flags &= -257; } get inFSharpPipelineDirectBody() { return (this.flags & 512) > 0; } - set inFSharpPipelineDirectBody(value) { - if (value) { - this.flags |= 512; - } else { - this.flags &= ~512; - } + set inFSharpPipelineDirectBody(v) { + if (v) this.flags |= 512;else this.flags &= -513; } get canStartJSXElement() { return (this.flags & 1024) > 0; } - set canStartJSXElement(value) { - if (value) { - this.flags |= 1024; - } else { - this.flags &= ~1024; - } + set canStartJSXElement(v) { + if (v) this.flags |= 1024;else this.flags &= -1025; } get containsEsc() { return (this.flags & 2048) > 0; } - set containsEsc(value) { - if (value) { - this.flags |= 2048; - } else { - this.flags &= ~2048; - } + set containsEsc(v) { + if (v) this.flags |= 2048;else this.flags &= -2049; + } + get hasTopLevelAwait() { + return (this.flags & 4096) > 0; + } + set hasTopLevelAwait(v) { + if (v) this.flags |= 4096;else this.flags &= -4097; } curPosition() { return new Position(this.curLine, this.pos - this.lineStart, this.pos); @@ -2171,7 +2150,7 @@ function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) { default: if (ch >= 48 && ch <= 55) { const startPos = pos - 1; - const match = input.slice(startPos, pos + 2).match(/^[0-7]+/); + const match = /^[0-7]+/.exec(input.slice(startPos, pos + 2)); let octalStr = match[0]; let octal = parseInt(octalStr, 8); if (octal > 255) { @@ -3544,7 +3523,13 @@ function functionFlags(isAsync, isGenerator) { class UtilParser extends Tokenizer { addExtra(node, key, value, enumerable = true) { if (!node) return; - const extra = node.extra = node.extra || {}; + let { + extra + } = node; + if (extra == null) { + extra = {}; + node.extra = extra; + } if (enumerable) { extra[key] = value; } else { @@ -3588,11 +3573,10 @@ class UtilParser extends Tokenizer { return this.match(139) || this.match(8) || this.hasPrecedingLineBreak(); } hasPrecedingLineBreak() { - return lineBreak.test(this.input.slice(this.state.lastTokEndLoc.index, this.state.start)); + return hasNewLine(this.input, this.state.lastTokEndLoc.index, this.state.start); } hasFollowingLineBreak() { - skipWhiteSpaceToLineBreak.lastIndex = this.state.end; - return skipWhiteSpaceToLineBreak.test(this.input); + return hasNewLine(this.input, this.state.end, this.nextTokenStart()); } isLineTerminator() { return this.eat(13) || this.canInsertSemicolon(); @@ -3602,7 +3586,9 @@ class UtilParser extends Tokenizer { this.raise(Errors.MissingSemicolon, this.state.lastTokEndLoc); } expect(type, loc) { - this.eat(type) || this.unexpected(loc, type); + if (!this.eat(type)) { + this.unexpected(loc, type); + } } tryParse(fn, oldState = this.state.clone()) { const abortSignal = { @@ -5207,7 +5193,7 @@ var flow = superClass => class FlowParserMixin extends superClass { } forwardNoArrowParamsConversionAt(node, parse) { let result; - if (this.state.noArrowParamsConversionAt.indexOf(node.start) !== -1) { + if (this.state.noArrowParamsConversionAt.includes(node.start)) { this.state.noArrowParamsConversionAt.push(this.state.start); result = parse(); this.state.noArrowParamsConversionAt.pop(); @@ -5717,14 +5703,14 @@ var flow = superClass => class FlowParserMixin extends superClass { return this.match(14) || super.shouldParseArrow(params); } setArrowFunctionParameters(node, params) { - if (this.state.noArrowParamsConversionAt.indexOf(node.start) !== -1) { + if (this.state.noArrowParamsConversionAt.includes(node.start)) { node.params = params; } else { super.setArrowFunctionParameters(node, params); } } checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged = true) { - if (isArrowFunction && this.state.noArrowParamsConversionAt.indexOf(node.start) !== -1) { + if (isArrowFunction && this.state.noArrowParamsConversionAt.includes(node.start)) { return; } for (let i = 0; i < node.params.length; i++) { @@ -5735,10 +5721,10 @@ var flow = superClass => class FlowParserMixin extends superClass { super.checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged); } parseParenAndDistinguishExpression(canBeArrow) { - return super.parseParenAndDistinguishExpression(canBeArrow && this.state.noArrowAt.indexOf(this.state.start) === -1); + return super.parseParenAndDistinguishExpression(canBeArrow && !this.state.noArrowAt.includes(this.state.start)); } parseSubscripts(base, startLoc, noCalls) { - if (base.type === "Identifier" && base.name === "async" && this.state.noArrowAt.indexOf(startLoc.index) !== -1) { + if (base.type === "Identifier" && base.name === "async" && this.state.noArrowAt.includes(startLoc.index)) { this.next(); const node = this.startNodeAt(startLoc); node.callee = base; @@ -6999,7 +6985,6 @@ class TypeScriptScopeHandler extends ScopeHandler { super.checkLocalExport(id); } } -const getOwn$1 = (object, key) => hasOwnProperty.call(object, key) && object[key]; const unwrapParenthesizedExpression = node => { return node.type === "ParenthesizedExpression" ? unwrapParenthesizedExpression(node.expression) : node; }; @@ -7258,25 +7243,26 @@ class LValParser extends NodeUtils { return this.finishNode(node, "AssignmentPattern"); } isValidLVal(type, isUnparenthesizedInAssign, binding) { - return getOwn$1({ - AssignmentPattern: "left", - RestElement: "argument", - ObjectProperty: "value", - ParenthesizedExpression: "expression", - ArrayPattern: "elements", - ObjectPattern: "properties" - }, type); + switch (type) { + case "AssignmentPattern": + return "left"; + case "RestElement": + return "argument"; + case "ObjectProperty": + return "value"; + case "ParenthesizedExpression": + return "expression"; + case "ArrayPattern": + return "elements"; + case "ObjectPattern": + return "properties"; + } + return false; } isOptionalMemberExpression(expression) { return expression.type === "OptionalMemberExpression"; } - checkLVal(expression, { - in: ancestor, - binding = 64, - checkClashes = false, - strictModeChanged = false, - hasParenthesizedAncestor = false - }) { + checkLVal(expression, ancestor, binding = 64, checkClashes = false, strictModeChanged = false, hasParenthesizedAncestor = false) { var _expression$extra; const type = expression.type; if (this.isObjectMethod(expression)) return; @@ -7318,20 +7304,25 @@ class LValParser extends NodeUtils { }); return; } - const [key, isParenthesizedExpression] = Array.isArray(validity) ? validity : [validity, type === "ParenthesizedExpression"]; + let key, isParenthesizedExpression; + if (typeof validity === "string") { + key = validity; + isParenthesizedExpression = type === "ParenthesizedExpression"; + } else { + [key, isParenthesizedExpression] = validity; + } const nextAncestor = type === "ArrayPattern" || type === "ObjectPattern" ? { type } : ancestor; - for (const child of [].concat(expression[key])) { - if (child) { - this.checkLVal(child, { - in: nextAncestor, - binding, - checkClashes, - strictModeChanged, - hasParenthesizedAncestor: isParenthesizedExpression - }); + const val = expression[key]; + if (Array.isArray(val)) { + for (const child of val) { + if (child) { + this.checkLVal(child, nextAncestor, binding, checkClashes, strictModeChanged, isParenthesizedExpression); + } } + } else if (val) { + this.checkLVal(val, nextAncestor, binding, checkClashes, strictModeChanged, isParenthesizedExpression); } } checkIdentifier(at, bindingType, strictModeChanged = false) { @@ -7379,7 +7370,6 @@ class LValParser extends NodeUtils { return true; } } -const getOwn = (object, key) => hasOwnProperty.call(object, key) && object[key]; function nonNull(x) { if (x == null) { throw new Error(`Unexpected ${x} value.`); @@ -7398,12 +7388,12 @@ const TSErrors = ParseErrorEnum`typescript`({ AbstractPropertyHasInitializer: ({ propertyName }) => `Property '${propertyName}' cannot have an initializer because it is marked abstract.`, - AccesorCannotDeclareThisParameter: "'get' and 'set' accessors cannot declare 'this' parameters.", - AccesorCannotHaveTypeParameters: "An accessor cannot have type parameters.", AccessorCannotBeOptional: "An 'accessor' property cannot be declared optional.", + AccessorCannotDeclareThisParameter: "'get' and 'set' accessors cannot declare 'this' parameters.", + AccessorCannotHaveTypeParameters: "An accessor cannot have type parameters.", ClassMethodHasDeclare: "Class methods cannot have the 'declare' modifier.", ClassMethodHasReadonly: "Class methods cannot have the 'readonly' modifier.", - ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference: "A 'const' initializer in an ambient context must be a string or numeric literal or literal enum reference.", + ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference: "A 'const' initializer in an ambient context must be a string or numeric literal or literal enum reference.", ConstructorHasTypeParameters: "Type parameters cannot appear on a constructor declaration.", DeclareAccessor: ({ kind @@ -7462,9 +7452,9 @@ const TSErrors = ParseErrorEnum`typescript`({ ReadonlyForMethodSignature: "'readonly' modifier can only appear on a property declaration or index signature.", ReservedArrowTypeParam: "This syntax is reserved in files with the .mts or .cts extension. Add a trailing comma, as in `<T,>() => ...`.", ReservedTypeAssertion: "This syntax is reserved in files with the .mts or .cts extension. Use an `as` expression instead.", - SetAccesorCannotHaveOptionalParameter: "A 'set' accessor cannot have an optional parameter.", - SetAccesorCannotHaveRestParameter: "A 'set' accessor cannot have rest parameter.", - SetAccesorCannotHaveReturnType: "A 'set' accessor cannot have a return type annotation.", + SetAccessorCannotHaveOptionalParameter: "A 'set' accessor cannot have an optional parameter.", + SetAccessorCannotHaveRestParameter: "A 'set' accessor cannot have rest parameter.", + SetAccessorCannotHaveReturnType: "A 'set' accessor cannot have a return type annotation.", SingleTypeParameterWithoutTrailingComma: ({ typeParameterName }) => `Single type parameter ${typeParameterName} should have a trailing comma. Example usage: <${typeParameterName},>.`, @@ -7542,18 +7532,28 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass { return tokenIsIdentifier(this.state.type); } tsTokenCanFollowModifier() { - return (this.match(0) || this.match(5) || this.match(55) || this.match(21) || this.match(138) || this.isLiteralPropertyName()) && !this.hasPrecedingLineBreak(); + return this.match(0) || this.match(5) || this.match(55) || this.match(21) || this.match(138) || this.isLiteralPropertyName(); } - tsNextTokenCanFollowModifier() { + tsNextTokenOnSameLineAndCanFollowModifier() { this.next(); + if (this.hasPrecedingLineBreak()) { + return false; + } return this.tsTokenCanFollowModifier(); } + tsNextTokenCanFollowModifier() { + if (this.match(106)) { + this.next(); + return this.tsTokenCanFollowModifier(); + } + return this.tsNextTokenOnSameLineAndCanFollowModifier(); + } tsParseModifier(allowedModifiers, stopOnStartOfClassStaticBlock) { if (!tokenIsIdentifier(this.state.type) && this.state.type !== 58 && this.state.type !== 75) { return undefined; } const modifier = this.state.value; - if (allowedModifiers.indexOf(modifier) !== -1) { + if (allowedModifiers.includes(modifier)) { if (stopOnStartOfClassStaticBlock && this.tsIsStartOfStaticBlocks()) { return undefined; } @@ -7871,7 +7871,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass { } const method = nodeAny; if (method.kind && this.match(47)) { - this.raise(TSErrors.AccesorCannotHaveTypeParameters, this.state.curPosition()); + this.raise(TSErrors.AccessorCannotHaveTypeParameters, this.state.curPosition()); } this.tsFillSignature(14, method); this.tsParseTypeMemberSemicolon(); @@ -7881,7 +7881,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass { if (method[paramsKey].length > 0) { this.raise(Errors.BadGetterArity, this.state.curPosition()); if (this.isThisParam(method[paramsKey][0])) { - this.raise(TSErrors.AccesorCannotDeclareThisParameter, this.state.curPosition()); + this.raise(TSErrors.AccessorCannotDeclareThisParameter, this.state.curPosition()); } } } else if (method.kind === "set") { @@ -7890,17 +7890,17 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass { } else { const firstParameter = method[paramsKey][0]; if (this.isThisParam(firstParameter)) { - this.raise(TSErrors.AccesorCannotDeclareThisParameter, this.state.curPosition()); + this.raise(TSErrors.AccessorCannotDeclareThisParameter, this.state.curPosition()); } if (firstParameter.type === "Identifier" && firstParameter.optional) { - this.raise(TSErrors.SetAccesorCannotHaveOptionalParameter, this.state.curPosition()); + this.raise(TSErrors.SetAccessorCannotHaveOptionalParameter, this.state.curPosition()); } if (firstParameter.type === "RestElement") { - this.raise(TSErrors.SetAccesorCannotHaveRestParameter, this.state.curPosition()); + this.raise(TSErrors.SetAccessorCannotHaveRestParameter, this.state.curPosition()); } } if (method[returnTypeKey]) { - this.raise(TSErrors.SetAccesorCannotHaveReturnType, method[returnTypeKey]); + this.raise(TSErrors.SetAccessorCannotHaveReturnType, method[returnTypeKey]); } } else { method.kind = "method"; @@ -7974,12 +7974,6 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass { this.next(); return this.match(58); } - tsParseMappedTypeParameter() { - const node = this.startNode(); - node.name = this.tsParseTypeParameterName(); - node.constraint = this.tsExpectThenParseType(58); - return this.finishNode(node, "TSTypeParameter"); - } tsParseMappedType() { const node = this.startNode(); this.expect(5); @@ -7991,7 +7985,12 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass { node.readonly = true; } this.expect(0); - node.typeParameter = this.tsParseMappedTypeParameter(); + { + const typeParameter = this.startNode(); + typeParameter.name = this.tsParseTypeParameterName(); + typeParameter.constraint = this.tsExpectThenParseType(58); + node.typeParameter = this.finishNode(typeParameter, "TSTypeParameter"); + } node.nameType = this.eatContextual(93) ? this.tsParseType() : null; this.expect(3); if (this.match(53)) { @@ -9129,7 +9128,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass { if (kind !== "const" || !!id.typeAnnotation) { this.raise(TSErrors.InitializerNotAllowedInAmbientContext, init); } else if (!isValidAmbientConstInitializer(init, this.hasPlugin("estree"))) { - this.raise(TSErrors.ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference, init); + this.raise(TSErrors.ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference, init); } } return declaration; @@ -9562,14 +9561,21 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass { } } isValidLVal(type, isUnparenthesizedInAssign, binding) { - return getOwn({ - TSTypeCastExpression: true, - TSParameterProperty: "parameter", - TSNonNullExpression: "expression", - TSAsExpression: (binding !== 64 || !isUnparenthesizedInAssign) && ["expression", true], - TSSatisfiesExpression: (binding !== 64 || !isUnparenthesizedInAssign) && ["expression", true], - TSTypeAssertion: (binding !== 64 || !isUnparenthesizedInAssign) && ["expression", true] - }, type) || super.isValidLVal(type, isUnparenthesizedInAssign, binding); + switch (type) { + case "TSTypeCastExpression": + return true; + case "TSParameterProperty": + return "parameter"; + case "TSNonNullExpression": + case "TSInstantiationExpression": + return "expression"; + case "TSAsExpression": + case "TSSatisfiesExpression": + case "TSTypeAssertion": + return (binding !== 64 || !isUnparenthesizedInAssign) && ["expression", true]; + default: + return super.isValidLVal(type, isUnparenthesizedInAssign, binding); + } } parseBindingAtom() { if (this.state.type === 78) { @@ -9695,12 +9701,17 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass { return param; } tsInAmbientContext(cb) { - const oldIsAmbientContext = this.state.isAmbientContext; + const { + isAmbientContext: oldIsAmbientContext, + strict: oldStrict + } = this.state; this.state.isAmbientContext = true; + this.state.strict = false; try { return cb(); } finally { this.state.isAmbientContext = oldIsAmbientContext; + this.state.strict = oldStrict; } } parseClass(node, isStatement, optionalId) { @@ -10111,114 +10122,86 @@ var v8intrinsic = superClass => class V8IntrinsicMixin extends superClass { return this.parseV8Intrinsic() || super.parseExprAtom(refExpressionErrors); } }; -function hasPlugin(plugins, expectedConfig) { - const [expectedName, expectedOptions] = typeof expectedConfig === "string" ? [expectedConfig, {}] : expectedConfig; - const expectedKeys = Object.keys(expectedOptions); - const expectedOptionsIsEmpty = expectedKeys.length === 0; - return plugins.some(p => { - if (typeof p === "string") { - return expectedOptionsIsEmpty && p === expectedName; - } else { - const [pluginName, pluginOptions] = p; - if (pluginName !== expectedName) { - return false; - } - for (const key of expectedKeys) { - if (pluginOptions[key] !== expectedOptions[key]) { - return false; - } - } - return true; - } - }); -} -function getPluginOption(plugins, name, option) { - const plugin = plugins.find(plugin => { - if (Array.isArray(plugin)) { - return plugin[0] === name; - } else { - return plugin === name; - } - }); - if (plugin && Array.isArray(plugin) && plugin.length > 1) { - return plugin[1][option]; - } - return null; -} const PIPELINE_PROPOSALS = ["minimal", "fsharp", "hack", "smart"]; const TOPIC_TOKENS = ["^^", "@@", "^", "%", "#"]; -const RECORD_AND_TUPLE_SYNTAX_TYPES = ["hash", "bar"]; -function validatePlugins(plugins) { - if (hasPlugin(plugins, "decorators")) { - if (hasPlugin(plugins, "decorators-legacy")) { +function validatePlugins(pluginsMap) { + if (pluginsMap.has("decorators")) { + if (pluginsMap.has("decorators-legacy")) { throw new Error("Cannot use the decorators and decorators-legacy plugin together"); } - const decoratorsBeforeExport = getPluginOption(plugins, "decorators", "decoratorsBeforeExport"); + const decoratorsBeforeExport = pluginsMap.get("decorators").decoratorsBeforeExport; if (decoratorsBeforeExport != null && typeof decoratorsBeforeExport !== "boolean") { throw new Error("'decoratorsBeforeExport' must be a boolean, if specified."); } - const allowCallParenthesized = getPluginOption(plugins, "decorators", "allowCallParenthesized"); + const allowCallParenthesized = pluginsMap.get("decorators").allowCallParenthesized; if (allowCallParenthesized != null && typeof allowCallParenthesized !== "boolean") { throw new Error("'allowCallParenthesized' must be a boolean."); } } - if (hasPlugin(plugins, "flow") && hasPlugin(plugins, "typescript")) { + if (pluginsMap.has("flow") && pluginsMap.has("typescript")) { throw new Error("Cannot combine flow and typescript plugins."); } - if (hasPlugin(plugins, "placeholders") && hasPlugin(plugins, "v8intrinsic")) { + if (pluginsMap.has("placeholders") && pluginsMap.has("v8intrinsic")) { throw new Error("Cannot combine placeholders and v8intrinsic plugins."); } - if (hasPlugin(plugins, "pipelineOperator")) { - const proposal = getPluginOption(plugins, "pipelineOperator", "proposal"); + if (pluginsMap.has("pipelineOperator")) { + var _pluginsMap$get; + const proposal = pluginsMap.get("pipelineOperator").proposal; if (!PIPELINE_PROPOSALS.includes(proposal)) { const proposalList = PIPELINE_PROPOSALS.map(p => `"${p}"`).join(", "); throw new Error(`"pipelineOperator" requires "proposal" option whose value must be one of: ${proposalList}.`); } - const tupleSyntaxIsHash = hasPlugin(plugins, ["recordAndTuple", { - syntaxType: "hash" - }]); + const tupleSyntaxIsHash = ((_pluginsMap$get = pluginsMap.get("recordAndTuple")) == null ? void 0 : _pluginsMap$get.syntaxType) === "hash"; if (proposal === "hack") { - if (hasPlugin(plugins, "placeholders")) { + if (pluginsMap.has("placeholders")) { throw new Error("Cannot combine placeholders plugin and Hack-style pipes."); } - if (hasPlugin(plugins, "v8intrinsic")) { + if (pluginsMap.has("v8intrinsic")) { throw new Error("Cannot combine v8intrinsic plugin and Hack-style pipes."); } - const topicToken = getPluginOption(plugins, "pipelineOperator", "topicToken"); + const topicToken = pluginsMap.get("pipelineOperator").topicToken; if (!TOPIC_TOKENS.includes(topicToken)) { const tokenList = TOPIC_TOKENS.map(t => `"${t}"`).join(", "); throw new Error(`"pipelineOperator" in "proposal": "hack" mode also requires a "topicToken" option whose value must be one of: ${tokenList}.`); } if (topicToken === "#" && tupleSyntaxIsHash) { - throw new Error('Plugin conflict between `["pipelineOperator", { proposal: "hack", topicToken: "#" }]` and `["recordAndtuple", { syntaxType: "hash"}]`.'); + throw new Error(`Plugin conflict between \`["pipelineOperator", { proposal: "hack", topicToken: "#" }]\` and \`${JSON.stringify(["recordAndTuple", pluginsMap.get("recordAndTuple")])}\`.`); } } else if (proposal === "smart" && tupleSyntaxIsHash) { - throw new Error('Plugin conflict between `["pipelineOperator", { proposal: "smart" }]` and `["recordAndtuple", { syntaxType: "hash"}]`.'); + throw new Error(`Plugin conflict between \`["pipelineOperator", { proposal: "smart" }]\` and \`${JSON.stringify(["recordAndTuple", pluginsMap.get("recordAndTuple")])}\`.`); } } - if (hasPlugin(plugins, "moduleAttributes")) { + if (pluginsMap.has("moduleAttributes")) { { - if (hasPlugin(plugins, "importAssertions") || hasPlugin(plugins, "importAttributes")) { + if (pluginsMap.has("importAttributes") || pluginsMap.has("importAssertions")) { throw new Error("Cannot combine importAssertions, importAttributes and moduleAttributes plugins."); } - const moduleAttributesVersionPluginOption = getPluginOption(plugins, "moduleAttributes", "version"); + const moduleAttributesVersionPluginOption = pluginsMap.get("moduleAttributes").version; if (moduleAttributesVersionPluginOption !== "may-2020") { throw new Error("The 'moduleAttributes' plugin requires a 'version' option," + " representing the last proposal update. Currently, the" + " only supported value is 'may-2020'."); } } } - if (hasPlugin(plugins, "importAssertions") && hasPlugin(plugins, "importAttributes")) { + if (pluginsMap.has("importAttributes") && pluginsMap.has("importAssertions")) { throw new Error("Cannot combine importAssertions and importAttributes plugins."); } - if (hasPlugin(plugins, "recordAndTuple") && getPluginOption(plugins, "recordAndTuple", "syntaxType") != null && !RECORD_AND_TUPLE_SYNTAX_TYPES.includes(getPluginOption(plugins, "recordAndTuple", "syntaxType"))) { - throw new Error("The 'syntaxType' option of the 'recordAndTuple' plugin must be one of: " + RECORD_AND_TUPLE_SYNTAX_TYPES.map(p => `'${p}'`).join(", ")); + if (pluginsMap.has("recordAndTuple")) { + const syntaxType = pluginsMap.get("recordAndTuple").syntaxType; + if (syntaxType != null) { + { + const RECORD_AND_TUPLE_SYNTAX_TYPES = ["hash", "bar"]; + if (!RECORD_AND_TUPLE_SYNTAX_TYPES.includes(syntaxType)) { + throw new Error("The 'syntaxType' option of the 'recordAndTuple' plugin must be one of: " + RECORD_AND_TUPLE_SYNTAX_TYPES.map(p => `'${p}'`).join(", ")); + } + } + } } - if (hasPlugin(plugins, "asyncDoExpressions") && !hasPlugin(plugins, "doExpressions")) { + if (pluginsMap.has("asyncDoExpressions") && !pluginsMap.has("doExpressions")) { const error = new Error("'asyncDoExpressions' requires 'doExpressions', please add 'doExpressions' to parser plugins."); error.missingPlugins = "doExpressions"; throw error; } - if (hasPlugin(plugins, "optionalChainingAssign") && getPluginOption(plugins, "optionalChainingAssign", "version") !== "2023-07") { + if (pluginsMap.has("optionalChainingAssign") && pluginsMap.get("optionalChainingAssign").version !== "2023-07") { throw new Error("The 'optionalChainingAssign' plugin requires a 'version' option," + " representing the last proposal update. Currently, the" + " only supported value is '2023-07'."); } } @@ -10389,9 +10372,7 @@ class ExpressionParser extends LValParser { } this.next(); node.right = this.parseMaybeAssign(); - this.checkLVal(left, { - in: this.finishNode(node, "AssignmentExpression") - }); + this.checkLVal(left, this.finishNode(node, "AssignmentExpression")); return node; } else if (ownExpressionErrors) { this.checkExpressionErrors(refExpressionErrors, true); @@ -10532,7 +10513,7 @@ class ExpressionParser extends LValParser { parseMaybeUnary(refExpressionErrors, sawUnary) { const startLoc = this.state.startLoc; const isAwait = this.isContextual(96); - if (isAwait && this.isAwaitAllowed()) { + if (isAwait && this.recordAwaitIfAllowed()) { this.next(); const expr = this.parseAwait(startLoc); if (!sawUnary) this.checkExponentialAfterUnary(expr); @@ -10581,9 +10562,7 @@ class ExpressionParser extends LValParser { parseUpdate(node, update, refExpressionErrors) { if (update) { const updateExpressionNode = node; - this.checkLVal(updateExpressionNode.argument, { - in: this.finishNode(updateExpressionNode, "UpdateExpression") - }); + this.checkLVal(updateExpressionNode.argument, this.finishNode(updateExpressionNode, "UpdateExpression")); return node; } const startLoc = this.state.startLoc; @@ -10595,9 +10574,7 @@ class ExpressionParser extends LValParser { node.prefix = false; node.argument = expr; this.next(); - this.checkLVal(expr, { - in: expr = this.finishNode(node, "UpdateExpression") - }); + this.checkLVal(expr, expr = this.finishNode(node, "UpdateExpression")); } return expr; } @@ -11164,10 +11141,12 @@ class ExpressionParser extends LValParser { return this.parseLiteral(value, "DecimalLiteral"); } parseRegExpLiteral(value) { - const node = this.parseLiteral(value.value, "RegExpLiteral"); + const node = this.startNode(); + this.addExtra(node, "raw", this.input.slice(node.start, this.state.end)); node.pattern = value.pattern; node.flags = value.flags; - return node; + this.next(); + return this.finishNode(node, "RegExpLiteral"); } parseBooleanLiteral(value) { const node = this.startNode(); @@ -11376,8 +11355,10 @@ class ExpressionParser extends LValParser { if (isRecord && !this.isObjectProperty(prop) && prop.type !== "SpreadElement") { this.raise(Errors.InvalidRecordProperty, prop); } - if (prop.shorthand) { - this.addExtra(prop, "shorthand", true); + { + if (prop.shorthand) { + this.addExtra(prop, "shorthand", true); + } } node.properties.push(prop); } @@ -11665,12 +11646,7 @@ class ExpressionParser extends LValParser { type: "FormalParameters" }; for (const param of node.params) { - this.checkLVal(param, { - in: formalParameters, - binding: 5, - checkClashes, - strictModeChanged - }); + this.checkLVal(param, formalParameters, 5, checkClashes, strictModeChanged); } } parseExprList(close, allowEmpty, refExpressionErrors, nodeForExtra) { @@ -11791,12 +11767,12 @@ class ExpressionParser extends LValParser { } } } - isAwaitAllowed() { - if (this.prodParam.hasAwait) return true; - if (this.options.allowAwaitOutsideFunction && !this.scope.inFunction) { - return true; + recordAwaitIfAllowed() { + const isAwaitAllowed = this.prodParam.hasAwait || this.options.allowAwaitOutsideFunction && !this.scope.inFunction; + if (isAwaitAllowed && !this.scope.inFunction) { + this.state.hasTopLevelAwait = true; } - return false; + return isAwaitAllowed; } parseAwait(startLoc) { const node = this.startNodeAt(startLoc); @@ -12135,12 +12111,15 @@ class StatementParser extends ExpressionParser { program.sourceType = sourceType; program.interpreter = this.parseInterpreterDirective(); this.parseBlockBody(program, true, true, end); - if (this.inModule && !this.options.allowUndeclaredExports && this.scope.undefinedExports.size > 0) { - for (const [localName, at] of Array.from(this.scope.undefinedExports)) { - this.raise(Errors.ModuleExportUndefined, at, { - localName - }); + if (this.inModule) { + if (!this.options.allowUndeclaredExports && this.scope.undefinedExports.size > 0) { + for (const [localName, at] of Array.from(this.scope.undefinedExports)) { + this.raise(Errors.ModuleExportUndefined, at, { + localName + }); + } } + this.addExtra(program, "topLevelAwait", this.state.hasTopLevelAwait); } let finishedProgram; if (end === 139) { @@ -12204,10 +12183,10 @@ class StatementParser extends ExpressionParser { const nextCh = this.codePointAtPos(next); return this.chStartsBindingPattern(nextCh) || this.chStartsBindingIdentifier(nextCh, next); } - hasInLineFollowingBindingIdentifier() { + hasInLineFollowingBindingIdentifierOrBrace() { const next = this.nextTokenInLineStart(); const nextCh = this.codePointAtPos(next); - return this.chStartsBindingIdentifier(nextCh, next); + return nextCh === 123 || this.chStartsBindingIdentifier(nextCh, next); } startsUsingForOf() { const { @@ -12260,12 +12239,12 @@ class StatementParser extends ExpressionParser { return this.parseStatementContent(flags, decorators); } parseStatementContent(flags, decorators) { - const starttype = this.state.type; + const startType = this.state.type; const node = this.startNode(); const allowDeclaration = !!(flags & 2); const allowFunctionDeclaration = !!(flags & 4); const topLevel = flags & 1; - switch (starttype) { + switch (startType) { case 60: return this.parseBreakContinueStatement(node, true); case 63: @@ -12297,7 +12276,7 @@ class StatementParser extends ExpressionParser { return this.parseTryStatement(node); case 96: if (!this.state.containsEsc && this.startsAwaitUsing()) { - if (!this.isAwaitAllowed()) { + if (!this.recordAwaitIfAllowed()) { this.raise(Errors.AwaitUsingNotInAsyncContext, node); } else if (!allowDeclaration) { this.raise(Errors.UnexpectedLexicalDeclaration, node); @@ -12307,7 +12286,7 @@ class StatementParser extends ExpressionParser { } break; case 107: - if (this.state.containsEsc || !this.hasInLineFollowingBindingIdentifier()) { + if (this.state.containsEsc || !this.hasInLineFollowingBindingIdentifierOrBrace()) { break; } this.expectPlugin("explicitResourceManagement"); @@ -12364,7 +12343,7 @@ class StatementParser extends ExpressionParser { } this.next(); let result; - if (starttype === 83) { + if (startType === 83) { result = this.parseImport(node); if (result.type === "ImportDeclaration" && (!result.importKind || result.importKind === "value")) { this.sawUnambiguousESM = true; @@ -12391,7 +12370,7 @@ class StatementParser extends ExpressionParser { } const maybeName = this.state.value; const expr = this.parseExpression(); - if (tokenIsIdentifier(starttype) && expr.type === "Identifier" && this.eat(14)) { + if (tokenIsIdentifier(startType) && expr.type === "Identifier" && this.eat(14)) { return this.parseLabeledStatement(node, maybeName, expr, flags); } else { return this.parseExpressionStatement(node, expr, decorators); @@ -12544,8 +12523,9 @@ class StatementParser extends ExpressionParser { this.next(); this.state.labels.push(loopLabel); let awaitAt = null; - if (this.isAwaitAllowed() && this.eatContextual(96)) { - awaitAt = this.state.lastTokStartLoc; + if (this.isContextual(96) && this.recordAwaitIfAllowed()) { + awaitAt = this.state.startLoc; + this.next(); } this.scope.enter(0); this.expect(10); @@ -12565,7 +12545,7 @@ class StatementParser extends ExpressionParser { let kind; if (startsWithAwaitUsing) { kind = "await using"; - if (!this.isAwaitAllowed()) { + if (!this.recordAwaitIfAllowed()) { this.raise(Errors.AwaitUsingNotInAsyncContext, this.state.startLoc); } this.next(); @@ -12605,9 +12585,7 @@ class StatementParser extends ExpressionParser { this.toAssignable(init, true); const type = isForOf ? "ForOfStatement" : "ForInStatement"; this.checkLVal(init, { - in: { - type - } + type }); return this.parseForIn(node, init, awaitAt); } else { @@ -12694,11 +12672,8 @@ class StatementParser extends ExpressionParser { const param = this.parseBindingAtom(); this.scope.enter(this.options.annexB && param.type === "Identifier" ? 8 : 0); this.checkLVal(param, { - in: { - type: "CatchClause" - }, - binding: 9 - }); + type: "CatchClause" + }, 9); return param; } parseTryStatement(node) { @@ -12901,12 +12876,14 @@ class StatementParser extends ExpressionParser { } parseVarId(decl, kind) { const id = this.parseBindingAtom(); + if (kind === "using" || kind === "await using") { + if (id.type === "ArrayPattern" || id.type === "ObjectPattern") { + this.raise(Errors.UsingDeclarationHasBindingPattern, id.loc.start); + } + } this.checkLVal(id, { - in: { - type: "VariableDeclarator" - }, - binding: kind === "var" ? 5 : 8201 - }); + type: "VariableDeclarator" + }, kind === "var" ? 5 : 8201); decl.id = id; } parseAsyncFunctionExpression(node) { @@ -13600,7 +13577,7 @@ class StatementParser extends ExpressionParser { parseModuleExportName() { if (this.match(133)) { const result = this.parseStringLiteral(this.state.value); - const surrogate = result.value.match(loneSurrogate); + const surrogate = loneSurrogate.exec(result.value); if (surrogate) { this.raise(Errors.ModuleExportNameHasLoneSurrogate, result, { surrogateCharCode: surrogate[0].charCodeAt(0) @@ -13751,11 +13728,8 @@ class StatementParser extends ExpressionParser { } finishImportSpecifier(specifier, type, bindingType = 8201) { this.checkLVal(specifier.local, { - in: { - type - }, - binding: bindingType - }); + type + }, bindingType); return this.finishNode(specifier, type); } parseImportAttributes() { @@ -13921,12 +13895,12 @@ class StatementParser extends ExpressionParser { } } class Parser extends StatementParser { - constructor(options, input) { + constructor(options, input, pluginsMap) { options = getOptions(options); super(options, input); this.options = options; this.initializeScopes(); - this.plugins = pluginsMap(this.options.plugins); + this.plugins = pluginsMap; this.filename = options.sourceFilename; } getScopeHandler() { @@ -13944,14 +13918,6 @@ class Parser extends StatementParser { return file; } } -function pluginsMap(plugins) { - const pluginMap = new Map(); - for (const plugin of plugins) { - const [name, options] = Array.isArray(plugin) ? plugin : [plugin, {}]; - if (!pluginMap.has(name)) pluginMap.set(name, options || {}); - } - return pluginMap; -} function parse(input, options) { var _options; if (((_options = options) == null ? void 0 : _options.sourceType) === "unambiguous") { @@ -14000,23 +13966,40 @@ function generateExportedTokenTypes(internalTokenTypes) { const tokTypes = generateExportedTokenTypes(tt); function getParser(options, input) { let cls = Parser; + const pluginsMap = new Map(); if (options != null && options.plugins) { - validatePlugins(options.plugins); - cls = getParserClass(options.plugins); + for (const plugin of options.plugins) { + let name, opts; + if (typeof plugin === "string") { + name = plugin; + } else { + [name, opts] = plugin; + } + if (!pluginsMap.has(name)) { + pluginsMap.set(name, opts || {}); + } + } + validatePlugins(pluginsMap); + cls = getParserClass(pluginsMap); } - return new cls(options, input); + return new cls(options, input, pluginsMap); } -const parserClassCache = {}; -function getParserClass(pluginsFromOptions) { - const pluginList = mixinPluginNames.filter(name => hasPlugin(pluginsFromOptions, name)); - const key = pluginList.join("/"); - let cls = parserClassCache[key]; +const parserClassCache = new Map(); +function getParserClass(pluginsMap) { + const pluginList = []; + for (const name of mixinPluginNames) { + if (pluginsMap.has(name)) { + pluginList.push(name); + } + } + const key = pluginList.join("|"); + let cls = parserClassCache.get(key); if (!cls) { cls = Parser; for (const plugin of pluginList) { cls = mixinPlugins[plugin](cls); } - parserClassCache[key] = cls; + parserClassCache.set(key, cls); } return cls; } |