You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
16667 lines
464 KiB
16667 lines
464 KiB
'use strict'; |
|
|
|
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; |
|
} |
|
|
|
class Position { |
|
constructor(line, col, index) { |
|
this.line = void 0; |
|
this.column = void 0; |
|
this.index = void 0; |
|
this.line = line; |
|
this.column = col; |
|
this.index = index; |
|
} |
|
|
|
} |
|
class SourceLocation { |
|
constructor(start, end) { |
|
this.start = void 0; |
|
this.end = void 0; |
|
this.filename = void 0; |
|
this.identifierName = void 0; |
|
this.start = start; |
|
this.end = end; |
|
} |
|
|
|
} |
|
function createPositionWithColumnOffset(position, columnOffset) { |
|
const { |
|
line, |
|
column, |
|
index |
|
} = position; |
|
return new Position(line, column + columnOffset, index + columnOffset); |
|
} |
|
|
|
const ParseErrorCodes = Object.freeze({ |
|
SyntaxError: "BABEL_PARSER_SYNTAX_ERROR", |
|
SourceTypeModuleError: "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED" |
|
}); |
|
|
|
const reflect = (keys, last = keys.length - 1) => ({ |
|
get() { |
|
return keys.reduce((object, key) => object[key], this); |
|
}, |
|
|
|
set(value) { |
|
keys.reduce((item, key, i) => i === last ? item[key] = value : item[key], this); |
|
} |
|
|
|
}); |
|
|
|
const instantiate = (constructor, properties, descriptors) => Object.keys(descriptors).map(key => [key, descriptors[key]]).filter(([, descriptor]) => !!descriptor).map(([key, descriptor]) => [key, typeof descriptor === "function" ? { |
|
value: descriptor, |
|
enumerable: false |
|
} : typeof descriptor.reflect === "string" ? Object.assign({}, descriptor, reflect(descriptor.reflect.split("."))) : descriptor]).reduce((instance, [key, descriptor]) => Object.defineProperty(instance, key, Object.assign({ |
|
configurable: true |
|
}, descriptor)), Object.assign(new constructor(), properties)); |
|
|
|
var ModuleErrors = (_ => ({ |
|
ImportMetaOutsideModule: _(`import.meta may appear only with 'sourceType: "module"'`, { |
|
code: ParseErrorCodes.SourceTypeModuleError |
|
}), |
|
ImportOutsideModule: _(`'import' and 'export' may appear only with 'sourceType: "module"'`, { |
|
code: ParseErrorCodes.SourceTypeModuleError |
|
}) |
|
})); |
|
|
|
const NodeDescriptions = { |
|
ArrayPattern: "array destructuring pattern", |
|
AssignmentExpression: "assignment expression", |
|
AssignmentPattern: "assignment expression", |
|
ArrowFunctionExpression: "arrow function expression", |
|
ConditionalExpression: "conditional expression", |
|
ForOfStatement: "for-of statement", |
|
ForInStatement: "for-in statement", |
|
ForStatement: "for-loop", |
|
FormalParameters: "function parameter list", |
|
Identifier: "identifier", |
|
ObjectPattern: "object destructuring pattern", |
|
ParenthesizedExpression: "parenthesized expression", |
|
RestElement: "rest element", |
|
UpdateExpression: { |
|
true: "prefix operation", |
|
false: "postfix operation" |
|
}, |
|
VariableDeclarator: "variable declaration", |
|
YieldExpression: "yield expression" |
|
}; |
|
|
|
const toNodeDescription = ({ |
|
type, |
|
prefix |
|
}) => type === "UpdateExpression" ? NodeDescriptions.UpdateExpression[String(prefix)] : NodeDescriptions[type]; |
|
|
|
var StandardErrors = (_ => ({ |
|
AccessorIsGenerator: _(({ |
|
kind |
|
}) => `A ${kind}ter cannot be a generator.`), |
|
ArgumentsInClass: _("'arguments' is only allowed in functions and class methods."), |
|
AsyncFunctionInSingleStatementContext: _("Async functions can only be declared at the top level or inside a block."), |
|
AwaitBindingIdentifier: _("Can not use 'await' as identifier inside an async function."), |
|
AwaitBindingIdentifierInStaticBlock: _("Can not use 'await' as identifier inside a static block."), |
|
AwaitExpressionFormalParameter: _("'await' is not allowed in async function parameters."), |
|
AwaitNotInAsyncContext: _("'await' is only allowed within async functions and at the top levels of modules."), |
|
AwaitNotInAsyncFunction: _("'await' is only allowed within async functions."), |
|
BadGetterArity: _("A 'get' accesor must not have any formal parameters."), |
|
BadSetterArity: _("A 'set' accesor must have exactly one formal parameter."), |
|
BadSetterRestParameter: _("A 'set' accesor function argument must not be a rest parameter."), |
|
ConstructorClassField: _("Classes may not have a field named 'constructor'."), |
|
ConstructorClassPrivateField: _("Classes may not have a private field named '#constructor'."), |
|
ConstructorIsAccessor: _("Class constructor may not be an accessor."), |
|
ConstructorIsAsync: _("Constructor can't be an async function."), |
|
ConstructorIsGenerator: _("Constructor can't be a generator."), |
|
DeclarationMissingInitializer: _(({ |
|
kind |
|
}) => `Missing initializer in ${kind} declaration.`), |
|
DecoratorBeforeExport: _("Decorators must be placed *before* the 'export' keyword. You can set the 'decoratorsBeforeExport' option to false to use the 'export @decorator class {}' syntax."), |
|
DecoratorConstructor: _("Decorators can't be used with a constructor. Did you mean '@dec class { ... }'?"), |
|
DecoratorExportClass: _("Using the export keyword between a decorator and a class is not allowed. Please use `export @dec class` instead."), |
|
DecoratorSemicolon: _("Decorators must not be followed by a semicolon."), |
|
DecoratorStaticBlock: _("Decorators can't be used with a static block."), |
|
DeletePrivateField: _("Deleting a private field is not allowed."), |
|
DestructureNamedImport: _("ES2015 named imports do not destructure. Use another statement for destructuring after the import."), |
|
DuplicateConstructor: _("Duplicate constructor in the same class."), |
|
DuplicateDefaultExport: _("Only one default export allowed per module."), |
|
DuplicateExport: _(({ |
|
exportName |
|
}) => `\`${exportName}\` has already been exported. Exported identifiers must be unique.`), |
|
DuplicateProto: _("Redefinition of __proto__ property."), |
|
DuplicateRegExpFlags: _("Duplicate regular expression flag."), |
|
ElementAfterRest: _("Rest element must be last element."), |
|
EscapedCharNotAnIdentifier: _("Invalid Unicode escape."), |
|
ExportBindingIsString: _(({ |
|
localName, |
|
exportName |
|
}) => `A string literal cannot be used as an exported binding without \`from\`.\n- Did you mean \`export { '${localName}' as '${exportName}' } from 'some-module'\`?`), |
|
ExportDefaultFromAsIdentifier: _("'from' is not allowed as an identifier after 'export default'."), |
|
ForInOfLoopInitializer: _(({ |
|
type |
|
}) => `'${type === "ForInStatement" ? "for-in" : "for-of"}' loop variable declaration may not have an initializer.`), |
|
ForOfAsync: _("The left-hand side of a for-of loop may not be 'async'."), |
|
ForOfLet: _("The left-hand side of a for-of loop may not start with 'let'."), |
|
GeneratorInSingleStatementContext: _("Generators can only be declared at the top level or inside a block."), |
|
IllegalBreakContinue: _(({ |
|
type |
|
}) => `Unsyntactic ${type === "BreakStatement" ? "break" : "continue"}.`), |
|
IllegalLanguageModeDirective: _("Illegal 'use strict' directive in function with non-simple parameter list."), |
|
IllegalReturn: _("'return' outside of function."), |
|
ImportBindingIsString: _(({ |
|
importName |
|
}) => `A string literal cannot be used as an imported binding.\n- Did you mean \`import { "${importName}" as foo }\`?`), |
|
ImportCallArgumentTrailingComma: _("Trailing comma is disallowed inside import(...) arguments."), |
|
ImportCallArity: _(({ |
|
maxArgumentCount |
|
}) => `\`import()\` requires exactly ${maxArgumentCount === 1 ? "one argument" : "one or two arguments"}.`), |
|
ImportCallNotNewExpression: _("Cannot use new with import(...)."), |
|
ImportCallSpreadArgument: _("`...` is not allowed in `import()`."), |
|
ImportJSONBindingNotDefault: _("A JSON module can only be imported with `default`."), |
|
IncompatibleRegExpUVFlags: _("The 'u' and 'v' regular expression flags cannot be enabled at the same time."), |
|
InvalidBigIntLiteral: _("Invalid BigIntLiteral."), |
|
InvalidCodePoint: _("Code point out of bounds."), |
|
InvalidCoverInitializedName: _("Invalid shorthand property initializer."), |
|
InvalidDecimal: _("Invalid decimal."), |
|
InvalidDigit: _(({ |
|
radix |
|
}) => `Expected number in radix ${radix}.`), |
|
InvalidEscapeSequence: _("Bad character escape sequence."), |
|
InvalidEscapeSequenceTemplate: _("Invalid escape sequence in template."), |
|
InvalidEscapedReservedWord: _(({ |
|
reservedWord |
|
}) => `Escape sequence in keyword ${reservedWord}.`), |
|
InvalidIdentifier: _(({ |
|
identifierName |
|
}) => `Invalid identifier ${identifierName}.`), |
|
InvalidLhs: _(({ |
|
ancestor |
|
}) => `Invalid left-hand side in ${toNodeDescription(ancestor)}.`), |
|
InvalidLhsBinding: _(({ |
|
ancestor |
|
}) => `Binding invalid left-hand side in ${toNodeDescription(ancestor)}.`), |
|
InvalidNumber: _("Invalid number."), |
|
InvalidOrMissingExponent: _("Floating-point numbers require a valid exponent after the 'e'."), |
|
InvalidOrUnexpectedToken: _(({ |
|
unexpected |
|
}) => `Unexpected character '${unexpected}'.`), |
|
InvalidParenthesizedAssignment: _("Invalid parenthesized assignment pattern."), |
|
InvalidPrivateFieldResolution: _(({ |
|
identifierName |
|
}) => `Private name #${identifierName} is not defined.`), |
|
InvalidPropertyBindingPattern: _("Binding member expression."), |
|
InvalidRecordProperty: _("Only properties and spread elements are allowed in record definitions."), |
|
InvalidRestAssignmentPattern: _("Invalid rest operator's argument."), |
|
LabelRedeclaration: _(({ |
|
labelName |
|
}) => `Label '${labelName}' is already declared.`), |
|
LetInLexicalBinding: _("'let' is not allowed to be used as a name in 'let' or 'const' declarations."), |
|
LineTerminatorBeforeArrow: _("No line break is allowed before '=>'."), |
|
MalformedRegExpFlags: _("Invalid regular expression flag."), |
|
MissingClassName: _("A class name is required."), |
|
MissingEqInAssignment: _("Only '=' operator can be used for specifying default value."), |
|
MissingSemicolon: _("Missing semicolon."), |
|
MissingPlugin: _(({ |
|
missingPlugin |
|
}) => `This experimental syntax requires enabling the parser plugin: ${missingPlugin.map(name => JSON.stringify(name)).join(", ")}.`), |
|
MissingOneOfPlugins: _(({ |
|
missingPlugin |
|
}) => `This experimental syntax requires enabling one of the following parser plugin(s): ${missingPlugin.map(name => JSON.stringify(name)).join(", ")}.`), |
|
MissingUnicodeEscape: _("Expecting Unicode escape sequence \\uXXXX."), |
|
MixingCoalesceWithLogical: _("Nullish coalescing operator(??) requires parens when mixing with logical operators."), |
|
ModuleAttributeDifferentFromType: _("The only accepted module attribute is `type`."), |
|
ModuleAttributeInvalidValue: _("Only string literals are allowed as module attribute values."), |
|
ModuleAttributesWithDuplicateKeys: _(({ |
|
key |
|
}) => `Duplicate key "${key}" is not allowed in module attributes.`), |
|
ModuleExportNameHasLoneSurrogate: _(({ |
|
surrogateCharCode |
|
}) => `An export name cannot include a lone surrogate, found '\\u${surrogateCharCode.toString(16)}'.`), |
|
ModuleExportUndefined: _(({ |
|
localName |
|
}) => `Export '${localName}' is not defined.`), |
|
MultipleDefaultsInSwitch: _("Multiple default clauses."), |
|
NewlineAfterThrow: _("Illegal newline after throw."), |
|
NoCatchOrFinally: _("Missing catch or finally clause."), |
|
NumberIdentifier: _("Identifier directly after number."), |
|
NumericSeparatorInEscapeSequence: _("Numeric separators are not allowed inside unicode escape sequences or hex escape sequences."), |
|
ObsoleteAwaitStar: _("'await*' has been removed from the async functions proposal. Use Promise.all() instead."), |
|
OptionalChainingNoNew: _("Constructors in/after an Optional Chain are not allowed."), |
|
OptionalChainingNoTemplate: _("Tagged Template Literals are not allowed in optionalChain."), |
|
OverrideOnConstructor: _("'override' modifier cannot appear on a constructor declaration."), |
|
ParamDupe: _("Argument name clash."), |
|
PatternHasAccessor: _("Object pattern can't contain getter or setter."), |
|
PatternHasMethod: _("Object pattern can't contain methods."), |
|
PrivateInExpectedIn: _(({ |
|
identifierName |
|
}) => `Private names are only allowed in property accesses (\`obj.#${identifierName}\`) or in \`in\` expressions (\`#${identifierName} in obj\`).`), |
|
PrivateNameRedeclaration: _(({ |
|
identifierName |
|
}) => `Duplicate private name #${identifierName}.`), |
|
RecordExpressionBarIncorrectEndSyntaxType: _("Record expressions ending with '|}' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'."), |
|
RecordExpressionBarIncorrectStartSyntaxType: _("Record expressions starting with '{|' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'."), |
|
RecordExpressionHashIncorrectStartSyntaxType: _("Record expressions starting with '#{' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'hash'."), |
|
RecordNoProto: _("'__proto__' is not allowed in Record expressions."), |
|
RestTrailingComma: _("Unexpected trailing comma after rest element."), |
|
SloppyFunction: _("In non-strict mode code, functions can only be declared at top level, inside a block, or as the body of an if statement."), |
|
StaticPrototype: _("Classes may not have static property named prototype."), |
|
SuperNotAllowed: _("`super()` is only valid inside a class constructor of a subclass. Maybe a typo in the method name ('constructor') or not extending another class?"), |
|
SuperPrivateField: _("Private fields can't be accessed on super."), |
|
TrailingDecorator: _("Decorators must be attached to a class element."), |
|
TupleExpressionBarIncorrectEndSyntaxType: _("Tuple expressions ending with '|]' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'."), |
|
TupleExpressionBarIncorrectStartSyntaxType: _("Tuple expressions starting with '[|' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'."), |
|
TupleExpressionHashIncorrectStartSyntaxType: _("Tuple expressions starting with '#[' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'hash'."), |
|
UnexpectedArgumentPlaceholder: _("Unexpected argument placeholder."), |
|
UnexpectedAwaitAfterPipelineBody: _('Unexpected "await" after pipeline body; await must have parentheses in minimal proposal.'), |
|
UnexpectedDigitAfterHash: _("Unexpected digit after hash token."), |
|
UnexpectedImportExport: _("'import' and 'export' may only appear at the top level."), |
|
UnexpectedKeyword: _(({ |
|
keyword |
|
}) => `Unexpected keyword '${keyword}'.`), |
|
UnexpectedLeadingDecorator: _("Leading decorators must be attached to a class declaration."), |
|
UnexpectedLexicalDeclaration: _("Lexical declaration cannot appear in a single-statement context."), |
|
UnexpectedNewTarget: _("`new.target` can only be used in functions or class properties."), |
|
UnexpectedNumericSeparator: _("A numeric separator is only allowed between two digits."), |
|
UnexpectedPrivateField: _("Unexpected private name."), |
|
UnexpectedReservedWord: _(({ |
|
reservedWord |
|
}) => `Unexpected reserved word '${reservedWord}'.`), |
|
UnexpectedSuper: _("'super' is only allowed in object methods and classes."), |
|
UnexpectedToken: _(({ |
|
expected, |
|
unexpected |
|
}) => `Unexpected token${unexpected ? ` '${unexpected}'.` : ""}${expected ? `, expected "${expected}"` : ""}`), |
|
UnexpectedTokenUnaryExponentiation: _("Illegal expression. Wrap left hand side or entire exponentiation in parentheses."), |
|
UnsupportedBind: _("Binding should be performed on object property."), |
|
UnsupportedDecoratorExport: _("A decorated export must export a class declaration."), |
|
UnsupportedDefaultExport: _("Only expressions, functions or classes are allowed as the `default` export."), |
|
UnsupportedImport: _("`import` can only be used in `import()` or `import.meta`."), |
|
UnsupportedMetaProperty: _(({ |
|
target, |
|
onlyValidPropertyName |
|
}) => `The only valid meta property for ${target} is ${target}.${onlyValidPropertyName}.`), |
|
UnsupportedParameterDecorator: _("Decorators cannot be used to decorate parameters."), |
|
UnsupportedPropertyDecorator: _("Decorators cannot be used to decorate object literal properties."), |
|
UnsupportedSuper: _("'super' can only be used with function calls (i.e. super()) or in property accesses (i.e. super.prop or super[prop])."), |
|
UnterminatedComment: _("Unterminated comment."), |
|
UnterminatedRegExp: _("Unterminated regular expression."), |
|
UnterminatedString: _("Unterminated string constant."), |
|
UnterminatedTemplate: _("Unterminated template."), |
|
VarRedeclaration: _(({ |
|
identifierName |
|
}) => `Identifier '${identifierName}' has already been declared.`), |
|
YieldBindingIdentifier: _("Can not use 'yield' as identifier inside a generator."), |
|
YieldInParameter: _("Yield expression is not allowed in formal parameters."), |
|
ZeroDigitNumericSeparator: _("Numeric separator can not be used after leading 0.") |
|
})); |
|
|
|
var StrictModeErrors = (_ => ({ |
|
StrictDelete: _("Deleting local variable in strict mode."), |
|
StrictEvalArguments: _(({ |
|
referenceName |
|
}) => `Assigning to '${referenceName}' in strict mode.`), |
|
StrictEvalArgumentsBinding: _(({ |
|
bindingName |
|
}) => `Binding '${bindingName}' in strict mode.`), |
|
StrictFunction: _("In strict mode code, functions can only be declared at top level or inside a block."), |
|
StrictNumericEscape: _("The only valid numeric escape in strict mode is '\\0'."), |
|
StrictOctalLiteral: _("Legacy octal literals are not allowed in strict mode."), |
|
StrictWith: _("'with' in strict mode.") |
|
})); |
|
|
|
const UnparenthesizedPipeBodyDescriptions = new Set(["ArrowFunctionExpression", "AssignmentExpression", "ConditionalExpression", "YieldExpression"]); |
|
var PipelineOperatorErrors = (_ => ({ |
|
PipeBodyIsTighter: _("Unexpected yield after pipeline body; any yield expression acting as Hack-style pipe body must be parenthesized due to its loose operator precedence."), |
|
PipeTopicRequiresHackPipes: _('Topic reference is used, but the pipelineOperator plugin was not passed a "proposal": "hack" or "smart" option.'), |
|
PipeTopicUnbound: _("Topic reference is unbound; it must be inside a pipe body."), |
|
PipeTopicUnconfiguredToken: _(({ |
|
token |
|
}) => `Invalid topic token ${token}. In order to use ${token} as a topic reference, the pipelineOperator plugin must be configured with { "proposal": "hack", "topicToken": "${token}" }.`), |
|
PipeTopicUnused: _("Hack-style pipe body does not contain a topic reference; Hack-style pipes must use topic at least once."), |
|
PipeUnparenthesizedBody: _(({ |
|
type |
|
}) => `Hack-style pipe body cannot be an unparenthesized ${toNodeDescription({ |
|
type |
|
})}; please wrap it in parentheses.`), |
|
PipelineBodyNoArrow: _('Unexpected arrow "=>" after pipeline body; arrow function in pipeline body must be parenthesized.'), |
|
PipelineBodySequenceExpression: _("Pipeline body may not be a comma-separated sequence expression."), |
|
PipelineHeadSequenceExpression: _("Pipeline head should not be a comma-separated sequence expression."), |
|
PipelineTopicUnused: _("Pipeline is in topic style but does not use topic reference."), |
|
PrimaryTopicNotAllowed: _("Topic reference was used in a lexical context without topic binding."), |
|
PrimaryTopicRequiresSmartPipeline: _('Topic reference is used, but the pipelineOperator plugin was not passed a "proposal": "hack" or "smart" option.') |
|
})); |
|
|
|
const _excluded$1 = ["toMessage"]; |
|
|
|
function toParseErrorConstructor(_ref) { |
|
let { |
|
toMessage |
|
} = _ref, |
|
properties = _objectWithoutPropertiesLoose(_ref, _excluded$1); |
|
|
|
return function constructor({ |
|
loc, |
|
details |
|
}) { |
|
return instantiate(SyntaxError, Object.assign({}, properties, { |
|
loc |
|
}), { |
|
clone(overrides = {}) { |
|
const loc = overrides.loc || {}; |
|
return constructor({ |
|
loc: new Position("line" in loc ? loc.line : this.loc.line, "column" in loc ? loc.column : this.loc.column, "index" in loc ? loc.index : this.loc.index), |
|
details: Object.assign({}, this.details, overrides.details) |
|
}); |
|
}, |
|
|
|
details: { |
|
value: details, |
|
enumerable: false |
|
}, |
|
message: { |
|
get() { |
|
return `${toMessage(this.details)} (${this.loc.line}:${this.loc.column})`; |
|
}, |
|
|
|
set(value) { |
|
Object.defineProperty(this, "message", { |
|
value |
|
}); |
|
} |
|
|
|
}, |
|
pos: { |
|
reflect: "loc.index", |
|
enumerable: true |
|
}, |
|
missingPlugin: "missingPlugin" in details && { |
|
reflect: "details.missingPlugin", |
|
enumerable: true |
|
} |
|
}); |
|
}; |
|
} |
|
|
|
function toParseErrorCredentials(toMessageOrMessage, credentials) { |
|
return Object.assign({ |
|
toMessage: typeof toMessageOrMessage === "string" ? () => toMessageOrMessage : toMessageOrMessage |
|
}, credentials); |
|
} |
|
function ParseErrorEnum(argument, syntaxPlugin) { |
|
if (Array.isArray(argument)) { |
|
return toParseErrorCredentialsMap => ParseErrorEnum(toParseErrorCredentialsMap, argument[0]); |
|
} |
|
|
|
const partialCredentials = argument(toParseErrorCredentials); |
|
const ParseErrorConstructors = {}; |
|
|
|
for (const reasonCode of Object.keys(partialCredentials)) { |
|
ParseErrorConstructors[reasonCode] = toParseErrorConstructor(Object.assign({ |
|
code: ParseErrorCodes.SyntaxError, |
|
reasonCode |
|
}, syntaxPlugin ? { |
|
syntaxPlugin |
|
} : {}, partialCredentials[reasonCode])); |
|
} |
|
|
|
return ParseErrorConstructors; |
|
} |
|
const Errors = Object.assign({}, ParseErrorEnum(ModuleErrors), ParseErrorEnum(StandardErrors), ParseErrorEnum(StrictModeErrors), ParseErrorEnum`pipelineOperator`(PipelineOperatorErrors)); |
|
|
|
const { |
|
defineProperty |
|
} = Object; |
|
|
|
const toUnenumerable = (object, key) => 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"); |
|
return node; |
|
} |
|
|
|
var estree = (superClass => class extends superClass { |
|
parse() { |
|
const file = toESTreeLocation(super.parse()); |
|
|
|
if (this.options.tokens) { |
|
file.tokens = file.tokens.map(toESTreeLocation); |
|
} |
|
|
|
return file; |
|
} |
|
|
|
parseRegExpLiteral({ |
|
pattern, |
|
flags |
|
}) { |
|
let regex = null; |
|
|
|
try { |
|
regex = new RegExp(pattern, flags); |
|
} catch (e) {} |
|
|
|
const node = this.estreeParseLiteral(regex); |
|
node.regex = { |
|
pattern, |
|
flags |
|
}; |
|
return node; |
|
} |
|
|
|
parseBigIntLiteral(value) { |
|
let bigInt; |
|
|
|
try { |
|
bigInt = BigInt(value); |
|
} catch (_unused) { |
|
bigInt = null; |
|
} |
|
|
|
const node = this.estreeParseLiteral(bigInt); |
|
node.bigint = String(node.value || value); |
|
return node; |
|
} |
|
|
|
parseDecimalLiteral(value) { |
|
const decimal = null; |
|
const node = this.estreeParseLiteral(decimal); |
|
node.decimal = String(node.value || value); |
|
return node; |
|
} |
|
|
|
estreeParseLiteral(value) { |
|
return this.parseLiteral(value, "Literal"); |
|
} |
|
|
|
parseStringLiteral(value) { |
|
return this.estreeParseLiteral(value); |
|
} |
|
|
|
parseNumericLiteral(value) { |
|
return this.estreeParseLiteral(value); |
|
} |
|
|
|
parseNullLiteral() { |
|
return this.estreeParseLiteral(null); |
|
} |
|
|
|
parseBooleanLiteral(value) { |
|
return this.estreeParseLiteral(value); |
|
} |
|
|
|
directiveToStmt(directive) { |
|
const directiveLiteral = directive.value; |
|
const stmt = this.startNodeAt(directive.start, directive.loc.start); |
|
const expression = this.startNodeAt(directiveLiteral.start, directiveLiteral.loc.start); |
|
expression.value = directiveLiteral.extra.expressionValue; |
|
expression.raw = directiveLiteral.extra.raw; |
|
stmt.expression = this.finishNodeAt(expression, "Literal", directiveLiteral.loc.end); |
|
stmt.directive = directiveLiteral.extra.raw.slice(1, -1); |
|
return this.finishNodeAt(stmt, "ExpressionStatement", directive.loc.end); |
|
} |
|
|
|
initFunction(node, isAsync) { |
|
super.initFunction(node, isAsync); |
|
node.expression = false; |
|
} |
|
|
|
checkDeclaration(node) { |
|
if (node != null && this.isObjectProperty(node)) { |
|
this.checkDeclaration(node.value); |
|
} else { |
|
super.checkDeclaration(node); |
|
} |
|
} |
|
|
|
getObjectOrClassMethodParams(method) { |
|
return method.value.params; |
|
} |
|
|
|
isValidDirective(stmt) { |
|
var _stmt$expression$extr; |
|
|
|
return stmt.type === "ExpressionStatement" && stmt.expression.type === "Literal" && typeof stmt.expression.value === "string" && !((_stmt$expression$extr = stmt.expression.extra) != null && _stmt$expression$extr.parenthesized); |
|
} |
|
|
|
parseBlockBody(node, ...args) { |
|
super.parseBlockBody(node, ...args); |
|
const directiveStatements = node.directives.map(d => this.directiveToStmt(d)); |
|
node.body = directiveStatements.concat(node.body); |
|
delete node.directives; |
|
} |
|
|
|
pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) { |
|
this.parseMethod(method, isGenerator, isAsync, isConstructor, allowsDirectSuper, "ClassMethod", true); |
|
|
|
if (method.typeParameters) { |
|
method.value.typeParameters = method.typeParameters; |
|
delete method.typeParameters; |
|
} |
|
|
|
classBody.body.push(method); |
|
} |
|
|
|
parsePrivateName() { |
|
const node = super.parsePrivateName(); |
|
{ |
|
if (!this.getPluginOption("estree", "classFeatures")) { |
|
return node; |
|
} |
|
} |
|
return this.convertPrivateNameToPrivateIdentifier(node); |
|
} |
|
|
|
convertPrivateNameToPrivateIdentifier(node) { |
|
const name = super.getPrivateNameSV(node); |
|
node = node; |
|
delete node.id; |
|
node.name = name; |
|
node.type = "PrivateIdentifier"; |
|
return node; |
|
} |
|
|
|
isPrivateName(node) { |
|
{ |
|
if (!this.getPluginOption("estree", "classFeatures")) { |
|
return super.isPrivateName(node); |
|
} |
|
} |
|
return node.type === "PrivateIdentifier"; |
|
} |
|
|
|
getPrivateNameSV(node) { |
|
{ |
|
if (!this.getPluginOption("estree", "classFeatures")) { |
|
return super.getPrivateNameSV(node); |
|
} |
|
} |
|
return node.name; |
|
} |
|
|
|
parseLiteral(value, type) { |
|
const node = super.parseLiteral(value, type); |
|
node.raw = node.extra.raw; |
|
delete node.extra; |
|
return node; |
|
} |
|
|
|
parseFunctionBody(node, allowExpression, isMethod = false) { |
|
super.parseFunctionBody(node, allowExpression, isMethod); |
|
node.expression = node.body.type !== "BlockStatement"; |
|
} |
|
|
|
parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope = false) { |
|
let funcNode = this.startNode(); |
|
funcNode.kind = node.kind; |
|
funcNode = super.parseMethod(funcNode, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope); |
|
funcNode.type = "FunctionExpression"; |
|
delete funcNode.kind; |
|
node.value = funcNode; |
|
|
|
if (type === "ClassPrivateMethod") { |
|
node.computed = false; |
|
} |
|
|
|
type = "MethodDefinition"; |
|
return this.finishNode(node, type); |
|
} |
|
|
|
parseClassProperty(...args) { |
|
const propertyNode = super.parseClassProperty(...args); |
|
{ |
|
if (!this.getPluginOption("estree", "classFeatures")) { |
|
return propertyNode; |
|
} |
|
} |
|
propertyNode.type = "PropertyDefinition"; |
|
return propertyNode; |
|
} |
|
|
|
parseClassPrivateProperty(...args) { |
|
const propertyNode = super.parseClassPrivateProperty(...args); |
|
{ |
|
if (!this.getPluginOption("estree", "classFeatures")) { |
|
return propertyNode; |
|
} |
|
} |
|
propertyNode.type = "PropertyDefinition"; |
|
propertyNode.computed = false; |
|
return propertyNode; |
|
} |
|
|
|
parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) { |
|
const node = super.parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor); |
|
|
|
if (node) { |
|
node.type = "Property"; |
|
if (node.kind === "method") node.kind = "init"; |
|
node.shorthand = false; |
|
} |
|
|
|
return node; |
|
} |
|
|
|
parseObjectProperty(prop, startPos, startLoc, isPattern, refExpressionErrors) { |
|
const node = super.parseObjectProperty(prop, startPos, startLoc, isPattern, refExpressionErrors); |
|
|
|
if (node) { |
|
node.kind = "init"; |
|
node.type = "Property"; |
|
} |
|
|
|
return node; |
|
} |
|
|
|
isValidLVal(type, ...rest) { |
|
return type === "Property" ? "value" : super.isValidLVal(type, ...rest); |
|
} |
|
|
|
isAssignable(node, isBinding) { |
|
if (node != null && this.isObjectProperty(node)) { |
|
return this.isAssignable(node.value, isBinding); |
|
} |
|
|
|
return super.isAssignable(node, isBinding); |
|
} |
|
|
|
toAssignable(node, isLHS = false) { |
|
if (node != null && this.isObjectProperty(node)) { |
|
const { |
|
key, |
|
value |
|
} = node; |
|
|
|
if (this.isPrivateName(key)) { |
|
this.classScope.usePrivateName(this.getPrivateNameSV(key), key.loc.start); |
|
} |
|
|
|
this.toAssignable(value, isLHS); |
|
} else { |
|
super.toAssignable(node, isLHS); |
|
} |
|
} |
|
|
|
toAssignableObjectExpressionProp(prop) { |
|
if (prop.kind === "get" || prop.kind === "set") { |
|
this.raise(Errors.PatternHasAccessor, { |
|
at: prop.key |
|
}); |
|
} else if (prop.method) { |
|
this.raise(Errors.PatternHasMethod, { |
|
at: prop.key |
|
}); |
|
} else { |
|
super.toAssignableObjectExpressionProp(...arguments); |
|
} |
|
} |
|
|
|
finishCallExpression(node, optional) { |
|
super.finishCallExpression(node, optional); |
|
|
|
if (node.callee.type === "Import") { |
|
node.type = "ImportExpression"; |
|
node.source = node.arguments[0]; |
|
|
|
if (this.hasPlugin("importAssertions")) { |
|
var _node$arguments$; |
|
|
|
node.attributes = (_node$arguments$ = node.arguments[1]) != null ? _node$arguments$ : null; |
|
} |
|
|
|
delete node.arguments; |
|
delete node.callee; |
|
} |
|
|
|
return node; |
|
} |
|
|
|
toReferencedArguments(node) { |
|
if (node.type === "ImportExpression") { |
|
return; |
|
} |
|
|
|
super.toReferencedArguments(node); |
|
} |
|
|
|
parseExport(node) { |
|
super.parseExport(node); |
|
|
|
switch (node.type) { |
|
case "ExportAllDeclaration": |
|
node.exported = null; |
|
break; |
|
|
|
case "ExportNamedDeclaration": |
|
if (node.specifiers.length === 1 && node.specifiers[0].type === "ExportNamespaceSpecifier") { |
|
node.type = "ExportAllDeclaration"; |
|
node.exported = node.specifiers[0].exported; |
|
delete node.specifiers; |
|
} |
|
|
|
break; |
|
} |
|
|
|
return node; |
|
} |
|
|
|
parseSubscript(base, startPos, startLoc, noCalls, state) { |
|
const node = super.parseSubscript(base, startPos, startLoc, noCalls, state); |
|
|
|
if (state.optionalChainMember) { |
|
if (node.type === "OptionalMemberExpression" || node.type === "OptionalCallExpression") { |
|
node.type = node.type.substring(8); |
|
} |
|
|
|
if (state.stop) { |
|
const chain = this.startNodeAtNode(node); |
|
chain.expression = node; |
|
return this.finishNode(chain, "ChainExpression"); |
|
} |
|
} else if (node.type === "MemberExpression" || node.type === "CallExpression") { |
|
node.optional = false; |
|
} |
|
|
|
return node; |
|
} |
|
|
|
hasPropertyAsPrivateName(node) { |
|
if (node.type === "ChainExpression") { |
|
node = node.expression; |
|
} |
|
|
|
return super.hasPropertyAsPrivateName(node); |
|
} |
|
|
|
isOptionalChain(node) { |
|
return node.type === "ChainExpression"; |
|
} |
|
|
|
isObjectProperty(node) { |
|
return node.type === "Property" && node.kind === "init" && !node.method; |
|
} |
|
|
|
isObjectMethod(node) { |
|
return node.method || node.kind === "get" || node.kind === "set"; |
|
} |
|
|
|
finishNodeAt(node, type, endLoc) { |
|
return toESTreeLocation(super.finishNodeAt(node, type, endLoc)); |
|
} |
|
|
|
resetStartLocation(node, start, startLoc) { |
|
super.resetStartLocation(node, start, startLoc); |
|
toESTreeLocation(node); |
|
} |
|
|
|
resetEndLocation(node, endLoc = this.state.lastTokEndLoc) { |
|
super.resetEndLocation(node, endLoc); |
|
toESTreeLocation(node); |
|
} |
|
|
|
}); |
|
|
|
class TokContext { |
|
constructor(token, preserveSpace) { |
|
this.token = void 0; |
|
this.preserveSpace = void 0; |
|
this.token = token; |
|
this.preserveSpace = !!preserveSpace; |
|
} |
|
|
|
} |
|
const types = { |
|
brace: new TokContext("{"), |
|
j_oTag: new TokContext("<tag"), |
|
j_cTag: new TokContext("</tag"), |
|
j_expr: new TokContext("<tag>...</tag>", true) |
|
}; |
|
{ |
|
types.template = new TokContext("`", true); |
|
} |
|
|
|
const beforeExpr = true; |
|
const startsExpr = true; |
|
const isLoop = true; |
|
const isAssign = true; |
|
const prefix = true; |
|
const postfix = true; |
|
class ExportedTokenType { |
|
constructor(label, conf = {}) { |
|
this.label = void 0; |
|
this.keyword = void 0; |
|
this.beforeExpr = void 0; |
|
this.startsExpr = void 0; |
|
this.rightAssociative = void 0; |
|
this.isLoop = void 0; |
|
this.isAssign = void 0; |
|
this.prefix = void 0; |
|
this.postfix = void 0; |
|
this.binop = void 0; |
|
this.label = label; |
|
this.keyword = conf.keyword; |
|
this.beforeExpr = !!conf.beforeExpr; |
|
this.startsExpr = !!conf.startsExpr; |
|
this.rightAssociative = !!conf.rightAssociative; |
|
this.isLoop = !!conf.isLoop; |
|
this.isAssign = !!conf.isAssign; |
|
this.prefix = !!conf.prefix; |
|
this.postfix = !!conf.postfix; |
|
this.binop = conf.binop != null ? conf.binop : null; |
|
{ |
|
this.updateContext = null; |
|
} |
|
} |
|
|
|
} |
|
const keywords$1 = new Map(); |
|
|
|
function createKeyword(name, options = {}) { |
|
options.keyword = name; |
|
const token = createToken(name, options); |
|
keywords$1.set(name, token); |
|
return token; |
|
} |
|
|
|
function createBinop(name, binop) { |
|
return createToken(name, { |
|
beforeExpr, |
|
binop |
|
}); |
|
} |
|
|
|
let tokenTypeCounter = -1; |
|
const tokenTypes = []; |
|
const tokenLabels = []; |
|
const tokenBinops = []; |
|
const tokenBeforeExprs = []; |
|
const tokenStartsExprs = []; |
|
const tokenPrefixes = []; |
|
|
|
function createToken(name, options = {}) { |
|
var _options$binop, _options$beforeExpr, _options$startsExpr, _options$prefix; |
|
|
|
++tokenTypeCounter; |
|
tokenLabels.push(name); |
|
tokenBinops.push((_options$binop = options.binop) != null ? _options$binop : -1); |
|
tokenBeforeExprs.push((_options$beforeExpr = options.beforeExpr) != null ? _options$beforeExpr : false); |
|
tokenStartsExprs.push((_options$startsExpr = options.startsExpr) != null ? _options$startsExpr : false); |
|
tokenPrefixes.push((_options$prefix = options.prefix) != null ? _options$prefix : false); |
|
tokenTypes.push(new ExportedTokenType(name, options)); |
|
return tokenTypeCounter; |
|
} |
|
|
|
function createKeywordLike(name, options = {}) { |
|
var _options$binop2, _options$beforeExpr2, _options$startsExpr2, _options$prefix2; |
|
|
|
++tokenTypeCounter; |
|
keywords$1.set(name, tokenTypeCounter); |
|
tokenLabels.push(name); |
|
tokenBinops.push((_options$binop2 = options.binop) != null ? _options$binop2 : -1); |
|
tokenBeforeExprs.push((_options$beforeExpr2 = options.beforeExpr) != null ? _options$beforeExpr2 : false); |
|
tokenStartsExprs.push((_options$startsExpr2 = options.startsExpr) != null ? _options$startsExpr2 : false); |
|
tokenPrefixes.push((_options$prefix2 = options.prefix) != null ? _options$prefix2 : false); |
|
tokenTypes.push(new ExportedTokenType("name", options)); |
|
return tokenTypeCounter; |
|
} |
|
|
|
const tt = { |
|
bracketL: createToken("[", { |
|
beforeExpr, |
|
startsExpr |
|
}), |
|
bracketHashL: createToken("#[", { |
|
beforeExpr, |
|
startsExpr |
|
}), |
|
bracketBarL: createToken("[|", { |
|
beforeExpr, |
|
startsExpr |
|
}), |
|
bracketR: createToken("]"), |
|
bracketBarR: createToken("|]"), |
|
braceL: createToken("{", { |
|
beforeExpr, |
|
startsExpr |
|
}), |
|
braceBarL: createToken("{|", { |
|
beforeExpr, |
|
startsExpr |
|
}), |
|
braceHashL: createToken("#{", { |
|
beforeExpr, |
|
startsExpr |
|
}), |
|
braceR: createToken("}"), |
|
braceBarR: createToken("|}"), |
|
parenL: createToken("(", { |
|
beforeExpr, |
|
startsExpr |
|
}), |
|
parenR: createToken(")"), |
|
comma: createToken(",", { |
|
beforeExpr |
|
}), |
|
semi: createToken(";", { |
|
beforeExpr |
|
}), |
|
colon: createToken(":", { |
|
beforeExpr |
|
}), |
|
doubleColon: createToken("::", { |
|
beforeExpr |
|
}), |
|
dot: createToken("."), |
|
question: createToken("?", { |
|
beforeExpr |
|
}), |
|
questionDot: createToken("?."), |
|
arrow: createToken("=>", { |
|
beforeExpr |
|
}), |
|
template: createToken("template"), |
|
ellipsis: createToken("...", { |
|
beforeExpr |
|
}), |
|
backQuote: createToken("`", { |
|
startsExpr |
|
}), |
|
dollarBraceL: createToken("${", { |
|
beforeExpr, |
|
startsExpr |
|
}), |
|
templateTail: createToken("...`", { |
|
startsExpr |
|
}), |
|
templateNonTail: createToken("...${", { |
|
beforeExpr, |
|
startsExpr |
|
}), |
|
at: createToken("@"), |
|
hash: createToken("#", { |
|
startsExpr |
|
}), |
|
interpreterDirective: createToken("#!..."), |
|
eq: createToken("=", { |
|
beforeExpr, |
|
isAssign |
|
}), |
|
assign: createToken("_=", { |
|
beforeExpr, |
|
isAssign |
|
}), |
|
slashAssign: createToken("_=", { |
|
beforeExpr, |
|
isAssign |
|
}), |
|
xorAssign: createToken("_=", { |
|
beforeExpr, |
|
isAssign |
|
}), |
|
moduloAssign: createToken("_=", { |
|
beforeExpr, |
|
isAssign |
|
}), |
|
incDec: createToken("++/--", { |
|
prefix, |
|
postfix, |
|
startsExpr |
|
}), |
|
bang: createToken("!", { |
|
beforeExpr, |
|
prefix, |
|
startsExpr |
|
}), |
|
tilde: createToken("~", { |
|
beforeExpr, |
|
prefix, |
|
startsExpr |
|
}), |
|
doubleCaret: createToken("^^", { |
|
startsExpr |
|
}), |
|
doubleAt: createToken("@@", { |
|
startsExpr |
|
}), |
|
pipeline: createBinop("|>", 0), |
|
nullishCoalescing: createBinop("??", 1), |
|
logicalOR: createBinop("||", 1), |
|
logicalAND: createBinop("&&", 2), |
|
bitwiseOR: createBinop("|", 3), |
|
bitwiseXOR: createBinop("^", 4), |
|
bitwiseAND: createBinop("&", 5), |
|
equality: createBinop("==/!=/===/!==", 6), |
|
lt: createBinop("</>/<=/>=", 7), |
|
gt: createBinop("</>/<=/>=", 7), |
|
relational: createBinop("</>/<=/>=", 7), |
|
bitShift: createBinop("<</>>/>>>", 8), |
|
bitShiftL: createBinop("<</>>/>>>", 8), |
|
bitShiftR: createBinop("<</>>/>>>", 8), |
|
plusMin: createToken("+/-", { |
|
beforeExpr, |
|
binop: 9, |
|
prefix, |
|
startsExpr |
|
}), |
|
modulo: createToken("%", { |
|
binop: 10, |
|
startsExpr |
|
}), |
|
star: createToken("*", { |
|
binop: 10 |
|
}), |
|
slash: createBinop("/", 10), |
|
exponent: createToken("**", { |
|
beforeExpr, |
|
binop: 11, |
|
rightAssociative: true |
|
}), |
|
_in: createKeyword("in", { |
|
beforeExpr, |
|
binop: 7 |
|
}), |
|
_instanceof: createKeyword("instanceof", { |
|
beforeExpr, |
|
binop: 7 |
|
}), |
|
_break: createKeyword("break"), |
|
_case: createKeyword("case", { |
|
beforeExpr |
|
}), |
|
_catch: createKeyword("catch"), |
|
_continue: createKeyword("continue"), |
|
_debugger: createKeyword("debugger"), |
|
_default: createKeyword("default", { |
|
beforeExpr |
|
}), |
|
_else: createKeyword("else", { |
|
beforeExpr |
|
}), |
|
_finally: createKeyword("finally"), |
|
_function: createKeyword("function", { |
|
startsExpr |
|
}), |
|
_if: createKeyword("if"), |
|
_return: createKeyword("return", { |
|
beforeExpr |
|
}), |
|
_switch: createKeyword("switch"), |
|
_throw: createKeyword("throw", { |
|
beforeExpr, |
|
prefix, |
|
startsExpr |
|
}), |
|
_try: createKeyword("try"), |
|
_var: createKeyword("var"), |
|
_const: createKeyword("const"), |
|
_with: createKeyword("with"), |
|
_new: createKeyword("new", { |
|
beforeExpr, |
|
startsExpr |
|
}), |
|
_this: createKeyword("this", { |
|
startsExpr |
|
}), |
|
_super: createKeyword("super", { |
|
startsExpr |
|
}), |
|
_class: createKeyword("class", { |
|
startsExpr |
|
}), |
|
_extends: createKeyword("extends", { |
|
beforeExpr |
|
}), |
|
_export: createKeyword("export"), |
|
_import: createKeyword("import", { |
|
startsExpr |
|
}), |
|
_null: createKeyword("null", { |
|
startsExpr |
|
}), |
|
_true: createKeyword("true", { |
|
startsExpr |
|
}), |
|
_false: createKeyword("false", { |
|
startsExpr |
|
}), |
|
_typeof: createKeyword("typeof", { |
|
beforeExpr, |
|
prefix, |
|
startsExpr |
|
}), |
|
_void: createKeyword("void", { |
|
beforeExpr, |
|
prefix, |
|
startsExpr |
|
}), |
|
_delete: createKeyword("delete", { |
|
beforeExpr, |
|
prefix, |
|
startsExpr |
|
}), |
|
_do: createKeyword("do", { |
|
isLoop, |
|
beforeExpr |
|
}), |
|
_for: createKeyword("for", { |
|
isLoop |
|
}), |
|
_while: createKeyword("while", { |
|
isLoop |
|
}), |
|
_as: createKeywordLike("as", { |
|
startsExpr |
|
}), |
|
_assert: createKeywordLike("assert", { |
|
startsExpr |
|
}), |
|
_async: createKeywordLike("async", { |
|
startsExpr |
|
}), |
|
_await: createKeywordLike("await", { |
|
startsExpr |
|
}), |
|
_from: createKeywordLike("from", { |
|
startsExpr |
|
}), |
|
_get: createKeywordLike("get", { |
|
startsExpr |
|
}), |
|
_let: createKeywordLike("let", { |
|
startsExpr |
|
}), |
|
_meta: createKeywordLike("meta", { |
|
startsExpr |
|
}), |
|
_of: createKeywordLike("of", { |
|
startsExpr |
|
}), |
|
_sent: createKeywordLike("sent", { |
|
startsExpr |
|
}), |
|
_set: createKeywordLike("set", { |
|
startsExpr |
|
}), |
|
_static: createKeywordLike("static", { |
|
startsExpr |
|
}), |
|
_yield: createKeywordLike("yield", { |
|
startsExpr |
|
}), |
|
_asserts: createKeywordLike("asserts", { |
|
startsExpr |
|
}), |
|
_checks: createKeywordLike("checks", { |
|
startsExpr |
|
}), |
|
_exports: createKeywordLike("exports", { |
|
startsExpr |
|
}), |
|
_global: createKeywordLike("global", { |
|
startsExpr |
|
}), |
|
_implements: createKeywordLike("implements", { |
|
startsExpr |
|
}), |
|
_intrinsic: createKeywordLike("intrinsic", { |
|
startsExpr |
|
}), |
|
_infer: createKeywordLike("infer", { |
|
startsExpr |
|
}), |
|
_is: createKeywordLike("is", { |
|
startsExpr |
|
}), |
|
_mixins: createKeywordLike("mixins", { |
|
startsExpr |
|
}), |
|
_proto: createKeywordLike("proto", { |
|
startsExpr |
|
}), |
|
_require: createKeywordLike("require", { |
|
startsExpr |
|
}), |
|
_keyof: createKeywordLike("keyof", { |
|
startsExpr |
|
}), |
|
_readonly: createKeywordLike("readonly", { |
|
startsExpr |
|
}), |
|
_unique: createKeywordLike("unique", { |
|
startsExpr |
|
}), |
|
_abstract: createKeywordLike("abstract", { |
|
startsExpr |
|
}), |
|
_declare: createKeywordLike("declare", { |
|
startsExpr |
|
}), |
|
_enum: createKeywordLike("enum", { |
|
startsExpr |
|
}), |
|
_module: createKeywordLike("module", { |
|
startsExpr |
|
}), |
|
_namespace: createKeywordLike("namespace", { |
|
startsExpr |
|
}), |
|
_interface: createKeywordLike("interface", { |
|
startsExpr |
|
}), |
|
_type: createKeywordLike("type", { |
|
startsExpr |
|
}), |
|
_opaque: createKeywordLike("opaque", { |
|
startsExpr |
|
}), |
|
name: createToken("name", { |
|
startsExpr |
|
}), |
|
string: createToken("string", { |
|
startsExpr |
|
}), |
|
num: createToken("num", { |
|
startsExpr |
|
}), |
|
bigint: createToken("bigint", { |
|
startsExpr |
|
}), |
|
decimal: createToken("decimal", { |
|
startsExpr |
|
}), |
|
regexp: createToken("regexp", { |
|
startsExpr |
|
}), |
|
privateName: createToken("#name", { |
|
startsExpr |
|
}), |
|
eof: createToken("eof"), |
|
jsxName: createToken("jsxName"), |
|
jsxText: createToken("jsxText", { |
|
beforeExpr: true |
|
}), |
|
jsxTagStart: createToken("jsxTagStart", { |
|
startsExpr: true |
|
}), |
|
jsxTagEnd: createToken("jsxTagEnd"), |
|
placeholder: createToken("%%", { |
|
startsExpr: true |
|
}) |
|
}; |
|
function tokenIsIdentifier(token) { |
|
return token >= 93 && token <= 128; |
|
} |
|
function tokenKeywordOrIdentifierIsKeyword(token) { |
|
return token <= 92; |
|
} |
|
function tokenIsKeywordOrIdentifier(token) { |
|
return token >= 58 && token <= 128; |
|
} |
|
function tokenIsLiteralPropertyName(token) { |
|
return token >= 58 && token <= 132; |
|
} |
|
function tokenComesBeforeExpression(token) { |
|
return tokenBeforeExprs[token]; |
|
} |
|
function tokenCanStartExpression(token) { |
|
return tokenStartsExprs[token]; |
|
} |
|
function tokenIsAssignment(token) { |
|
return token >= 29 && token <= 33; |
|
} |
|
function tokenIsFlowInterfaceOrTypeOrOpaque(token) { |
|
return token >= 125 && token <= 127; |
|
} |
|
function tokenIsLoop(token) { |
|
return token >= 90 && token <= 92; |
|
} |
|
function tokenIsKeyword(token) { |
|
return token >= 58 && token <= 92; |
|
} |
|
function tokenIsOperator(token) { |
|
return token >= 39 && token <= 59; |
|
} |
|
function tokenIsPostfix(token) { |
|
return token === 34; |
|
} |
|
function tokenIsPrefix(token) { |
|
return tokenPrefixes[token]; |
|
} |
|
function tokenIsTSTypeOperator(token) { |
|
return token >= 117 && token <= 119; |
|
} |
|
function tokenIsTSDeclarationStart(token) { |
|
return token >= 120 && token <= 126; |
|
} |
|
function tokenLabelName(token) { |
|
return tokenLabels[token]; |
|
} |
|
function tokenOperatorPrecedence(token) { |
|
return tokenBinops[token]; |
|
} |
|
function tokenIsRightAssociative(token) { |
|
return token === 57; |
|
} |
|
function tokenIsTemplate(token) { |
|
return token >= 24 && token <= 25; |
|
} |
|
function getExportedToken(token) { |
|
return tokenTypes[token]; |
|
} |
|
{ |
|
tokenTypes[8].updateContext = context => { |
|
context.pop(); |
|
}; |
|
|
|
tokenTypes[5].updateContext = tokenTypes[7].updateContext = tokenTypes[23].updateContext = context => { |
|
context.push(types.brace); |
|
}; |
|
|
|
tokenTypes[22].updateContext = context => { |
|
if (context[context.length - 1] === types.template) { |
|
context.pop(); |
|
} else { |
|
context.push(types.template); |
|
} |
|
}; |
|
|
|
tokenTypes[138].updateContext = context => { |
|
context.push(types.j_expr, types.j_oTag); |
|
}; |
|
} |
|
|
|
let nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u0870-\u0887\u0889-\u088e\u08a0-\u08c9\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c5d\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cdd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1711\u171f-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4c\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7ca\ua7d0\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc"; |
|
let nonASCIIidentifierChars = "\u200c\u200d\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u0898-\u089f\u08ca-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3c\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u180f-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1abf-\u1ace\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1dff\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f"; |
|
const nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]"); |
|
const nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]"); |
|
nonASCIIidentifierStartChars = nonASCIIidentifierChars = null; |
|
const astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 13, 10, 2, 14, 2, 6, 2, 1, 2, 10, 2, 14, 2, 6, 2, 1, 68, 310, 10, 21, 11, 7, 25, 5, 2, 41, 2, 8, 70, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 71, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 349, 41, 7, 1, 79, 28, 11, 0, 9, 21, 43, 17, 47, 20, 28, 22, 13, 52, 58, 1, 3, 0, 14, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 85, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 159, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 38, 6, 186, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 19, 72, 264, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 328, 18, 190, 0, 80, 921, 103, 110, 18, 195, 2637, 96, 16, 1070, 4050, 582, 8634, 568, 8, 30, 18, 78, 18, 29, 19, 47, 17, 3, 32, 20, 6, 18, 689, 63, 129, 74, 6, 0, 67, 12, 65, 1, 2, 0, 29, 6135, 9, 1237, 43, 8, 8936, 3, 2, 6, 2, 1, 2, 290, 46, 2, 18, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 1845, 30, 482, 44, 11, 6, 17, 0, 322, 29, 19, 43, 1269, 6, 2, 3, 2, 1, 2, 14, 2, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42719, 33, 4152, 8, 221, 3, 5761, 15, 7472, 3104, 541, 1507, 4938]; |
|
const astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 370, 1, 154, 10, 50, 3, 123, 2, 54, 14, 32, 10, 3, 1, 11, 3, 46, 10, 8, 0, 46, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 161, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 193, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 84, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 406, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 330, 3, 19306, 9, 87, 9, 39, 4, 60, 6, 26, 9, 1014, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 4706, 45, 3, 22, 543, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 262, 6, 10, 9, 357, 0, 62, 13, 1495, 6, 110, 6, 6, 9, 4759, 9, 787719, 239]; |
|
|
|
function isInAstralSet(code, set) { |
|
let pos = 0x10000; |
|
|
|
for (let i = 0, length = set.length; i < length; i += 2) { |
|
pos += set[i]; |
|
if (pos > code) return false; |
|
pos += set[i + 1]; |
|
if (pos >= code) return true; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
function isIdentifierStart(code) { |
|
if (code < 65) return code === 36; |
|
if (code <= 90) return true; |
|
if (code < 97) return code === 95; |
|
if (code <= 122) return true; |
|
|
|
if (code <= 0xffff) { |
|
return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code)); |
|
} |
|
|
|
return isInAstralSet(code, astralIdentifierStartCodes); |
|
} |
|
function isIdentifierChar(code) { |
|
if (code < 48) return code === 36; |
|
if (code < 58) return true; |
|
if (code < 65) return false; |
|
if (code <= 90) return true; |
|
if (code < 97) return code === 95; |
|
if (code <= 122) return true; |
|
|
|
if (code <= 0xffff) { |
|
return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code)); |
|
} |
|
|
|
return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes); |
|
} |
|
|
|
const reservedWords = { |
|
keyword: ["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete"], |
|
strict: ["implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"], |
|
strictBind: ["eval", "arguments"] |
|
}; |
|
const keywords = new Set(reservedWords.keyword); |
|
const reservedWordsStrictSet = new Set(reservedWords.strict); |
|
const reservedWordsStrictBindSet = new Set(reservedWords.strictBind); |
|
function isReservedWord(word, inModule) { |
|
return inModule && word === "await" || word === "enum"; |
|
} |
|
function isStrictReservedWord(word, inModule) { |
|
return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word); |
|
} |
|
function isStrictBindOnlyReservedWord(word) { |
|
return reservedWordsStrictBindSet.has(word); |
|
} |
|
function isStrictBindReservedWord(word, inModule) { |
|
return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word); |
|
} |
|
function isKeyword(word) { |
|
return keywords.has(word); |
|
} |
|
|
|
function isIteratorStart(current, next, next2) { |
|
return current === 64 && next === 64 && isIdentifierStart(next2); |
|
} |
|
const reservedWordLikeSet = new Set(["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete", "implements", "interface", "let", "package", "private", "protected", "public", "static", "yield", "eval", "arguments", "enum", "await"]); |
|
function canBeReservedWord(word) { |
|
return reservedWordLikeSet.has(word); |
|
} |
|
|
|
const SCOPE_OTHER = 0b000000000, |
|
SCOPE_PROGRAM = 0b000000001, |
|
SCOPE_FUNCTION = 0b000000010, |
|
SCOPE_ARROW = 0b000000100, |
|
SCOPE_SIMPLE_CATCH = 0b000001000, |
|
SCOPE_SUPER = 0b000010000, |
|
SCOPE_DIRECT_SUPER = 0b000100000, |
|
SCOPE_CLASS = 0b001000000, |
|
SCOPE_STATIC_BLOCK = 0b010000000, |
|
SCOPE_TS_MODULE = 0b100000000, |
|
SCOPE_VAR = SCOPE_PROGRAM | SCOPE_FUNCTION | SCOPE_TS_MODULE; |
|
const BIND_KIND_VALUE = 0b000000000001, |
|
BIND_KIND_TYPE = 0b000000000010, |
|
BIND_SCOPE_VAR = 0b000000000100, |
|
BIND_SCOPE_LEXICAL = 0b000000001000, |
|
BIND_SCOPE_FUNCTION = 0b000000010000, |
|
BIND_FLAGS_NONE = 0b000001000000, |
|
BIND_FLAGS_CLASS = 0b000010000000, |
|
BIND_FLAGS_TS_ENUM = 0b000100000000, |
|
BIND_FLAGS_TS_CONST_ENUM = 0b001000000000, |
|
BIND_FLAGS_TS_EXPORT_ONLY = 0b010000000000, |
|
BIND_FLAGS_FLOW_DECLARE_FN = 0b100000000000; |
|
const BIND_CLASS = BIND_KIND_VALUE | BIND_KIND_TYPE | BIND_SCOPE_LEXICAL | BIND_FLAGS_CLASS, |
|
BIND_LEXICAL = BIND_KIND_VALUE | 0 | BIND_SCOPE_LEXICAL | 0, |
|
BIND_VAR = BIND_KIND_VALUE | 0 | BIND_SCOPE_VAR | 0, |
|
BIND_FUNCTION = BIND_KIND_VALUE | 0 | BIND_SCOPE_FUNCTION | 0, |
|
BIND_TS_INTERFACE = 0 | BIND_KIND_TYPE | 0 | BIND_FLAGS_CLASS, |
|
BIND_TS_TYPE = 0 | BIND_KIND_TYPE | 0 | 0, |
|
BIND_TS_ENUM = BIND_KIND_VALUE | BIND_KIND_TYPE | BIND_SCOPE_LEXICAL | BIND_FLAGS_TS_ENUM, |
|
BIND_TS_AMBIENT = 0 | 0 | 0 | BIND_FLAGS_TS_EXPORT_ONLY, |
|
BIND_NONE = 0 | 0 | 0 | BIND_FLAGS_NONE, |
|
BIND_OUTSIDE = BIND_KIND_VALUE | 0 | 0 | BIND_FLAGS_NONE, |
|
BIND_TS_CONST_ENUM = BIND_TS_ENUM | BIND_FLAGS_TS_CONST_ENUM, |
|
BIND_TS_NAMESPACE = 0 | 0 | 0 | BIND_FLAGS_TS_EXPORT_ONLY, |
|
BIND_FLOW_DECLARE_FN = BIND_FLAGS_FLOW_DECLARE_FN; |
|
const CLASS_ELEMENT_FLAG_STATIC = 0b100, |
|
CLASS_ELEMENT_KIND_GETTER = 0b010, |
|
CLASS_ELEMENT_KIND_SETTER = 0b001, |
|
CLASS_ELEMENT_KIND_ACCESSOR = CLASS_ELEMENT_KIND_GETTER | CLASS_ELEMENT_KIND_SETTER; |
|
const CLASS_ELEMENT_STATIC_GETTER = CLASS_ELEMENT_KIND_GETTER | CLASS_ELEMENT_FLAG_STATIC, |
|
CLASS_ELEMENT_STATIC_SETTER = CLASS_ELEMENT_KIND_SETTER | CLASS_ELEMENT_FLAG_STATIC, |
|
CLASS_ELEMENT_INSTANCE_GETTER = CLASS_ELEMENT_KIND_GETTER, |
|
CLASS_ELEMENT_INSTANCE_SETTER = CLASS_ELEMENT_KIND_SETTER, |
|
CLASS_ELEMENT_OTHER = 0; |
|
|
|
class BaseParser { |
|
constructor() { |
|
this.sawUnambiguousESM = false; |
|
this.ambiguousScriptDifferentAst = false; |
|
} |
|
|
|
hasPlugin(pluginConfig) { |
|
if (typeof pluginConfig === "string") { |
|
return this.plugins.has(pluginConfig); |
|
} else { |
|
const [pluginName, pluginOptions] = pluginConfig; |
|
|
|
if (!this.hasPlugin(pluginName)) { |
|
return false; |
|
} |
|
|
|
const actualOptions = this.plugins.get(pluginName); |
|
|
|
for (const key of Object.keys(pluginOptions)) { |
|
if ((actualOptions == null ? void 0 : actualOptions[key]) !== pluginOptions[key]) { |
|
return false; |
|
} |
|
} |
|
|
|
return true; |
|
} |
|
} |
|
|
|
getPluginOption(plugin, name) { |
|
var _this$plugins$get; |
|
|
|
return (_this$plugins$get = this.plugins.get(plugin)) == null ? void 0 : _this$plugins$get[name]; |
|
} |
|
|
|
} |
|
|
|
function setTrailingComments(node, comments) { |
|
if (node.trailingComments === undefined) { |
|
node.trailingComments = comments; |
|
} else { |
|
node.trailingComments.unshift(...comments); |
|
} |
|
} |
|
|
|
function setLeadingComments(node, comments) { |
|
if (node.leadingComments === undefined) { |
|
node.leadingComments = comments; |
|
} else { |
|
node.leadingComments.unshift(...comments); |
|
} |
|
} |
|
|
|
function setInnerComments(node, comments) { |
|
if (node.innerComments === undefined) { |
|
node.innerComments = comments; |
|
} else { |
|
node.innerComments.unshift(...comments); |
|
} |
|
} |
|
|
|
function adjustInnerComments(node, elements, commentWS) { |
|
let lastElement = null; |
|
let i = elements.length; |
|
|
|
while (lastElement === null && i > 0) { |
|
lastElement = elements[--i]; |
|
} |
|
|
|
if (lastElement === null || lastElement.start > commentWS.start) { |
|
setInnerComments(node, commentWS.comments); |
|
} else { |
|
setTrailingComments(lastElement, commentWS.comments); |
|
} |
|
} |
|
|
|
class CommentsParser extends BaseParser { |
|
addComment(comment) { |
|
if (this.filename) comment.loc.filename = this.filename; |
|
this.state.comments.push(comment); |
|
} |
|
|
|
processComment(node) { |
|
const { |
|
commentStack |
|
} = this.state; |
|
const commentStackLength = commentStack.length; |
|
if (commentStackLength === 0) return; |
|
let i = commentStackLength - 1; |
|
const lastCommentWS = commentStack[i]; |
|
|
|
if (lastCommentWS.start === node.end) { |
|
lastCommentWS.leadingNode = node; |
|
i--; |
|
} |
|
|
|
const { |
|
start: nodeStart |
|
} = node; |
|
|
|
for (; i >= 0; i--) { |
|
const commentWS = commentStack[i]; |
|
const commentEnd = commentWS.end; |
|
|
|
if (commentEnd > nodeStart) { |
|
commentWS.containingNode = node; |
|
this.finalizeComment(commentWS); |
|
commentStack.splice(i, 1); |
|
} else { |
|
if (commentEnd === nodeStart) { |
|
commentWS.trailingNode = node; |
|
} |
|
|
|
break; |
|
} |
|
} |
|
} |
|
|
|
finalizeComment(commentWS) { |
|
const { |
|
comments |
|
} = commentWS; |
|
|
|
if (commentWS.leadingNode !== null || commentWS.trailingNode !== null) { |
|
if (commentWS.leadingNode !== null) { |
|
setTrailingComments(commentWS.leadingNode, comments); |
|
} |
|
|
|
if (commentWS.trailingNode !== null) { |
|
setLeadingComments(commentWS.trailingNode, comments); |
|
} |
|
} else { |
|
const { |
|
containingNode: node, |
|
start: commentStart |
|
} = commentWS; |
|
|
|
if (this.input.charCodeAt(commentStart - 1) === 44) { |
|
switch (node.type) { |
|
case "ObjectExpression": |
|
case "ObjectPattern": |
|
case "RecordExpression": |
|
adjustInnerComments(node, node.properties, commentWS); |
|
break; |
|
|
|
case "CallExpression": |
|
case "OptionalCallExpression": |
|
adjustInnerComments(node, node.arguments, commentWS); |
|
break; |
|
|
|
case "FunctionDeclaration": |
|
case "FunctionExpression": |
|
case "ArrowFunctionExpression": |
|
case "ObjectMethod": |
|
case "ClassMethod": |
|
case "ClassPrivateMethod": |
|
adjustInnerComments(node, node.params, commentWS); |
|
break; |
|
|
|
case "ArrayExpression": |
|
case "ArrayPattern": |
|
case "TupleExpression": |
|
adjustInnerComments(node, node.elements, commentWS); |
|
break; |
|
|
|
case "ExportNamedDeclaration": |
|
case "ImportDeclaration": |
|
adjustInnerComments(node, node.specifiers, commentWS); |
|
break; |
|
|
|
default: |
|
{ |
|
setInnerComments(node, comments); |
|
} |
|
} |
|
} else { |
|
setInnerComments(node, comments); |
|
} |
|
} |
|
} |
|
|
|
finalizeRemainingComments() { |
|
const { |
|
commentStack |
|
} = this.state; |
|
|
|
for (let i = commentStack.length - 1; i >= 0; i--) { |
|
this.finalizeComment(commentStack[i]); |
|
} |
|
|
|
this.state.commentStack = []; |
|
} |
|
|
|
resetPreviousNodeTrailingComments(node) { |
|
const { |
|
commentStack |
|
} = this.state; |
|
const { |
|
length |
|
} = commentStack; |
|
if (length === 0) return; |
|
const commentWS = commentStack[length - 1]; |
|
|
|
if (commentWS.leadingNode === node) { |
|
commentWS.leadingNode = null; |
|
} |
|
} |
|
|
|
takeSurroundingComments(node, start, end) { |
|
const { |
|
commentStack |
|
} = this.state; |
|
const commentStackLength = commentStack.length; |
|
if (commentStackLength === 0) return; |
|
let i = commentStackLength - 1; |
|
|
|
for (; i >= 0; i--) { |
|
const commentWS = commentStack[i]; |
|
const commentEnd = commentWS.end; |
|
const commentStart = commentWS.start; |
|
|
|
if (commentStart === end) { |
|
commentWS.leadingNode = node; |
|
} else if (commentEnd === start) { |
|
commentWS.trailingNode = node; |
|
} else if (commentEnd < start) { |
|
break; |
|
} |
|
} |
|
} |
|
|
|
} |
|
|
|
const lineBreak = /\r\n?|[\n\u2028\u2029]/; |
|
const lineBreakG = new RegExp(lineBreak.source, "g"); |
|
function isNewLine(code) { |
|
switch (code) { |
|
case 10: |
|
case 13: |
|
case 8232: |
|
case 8233: |
|
return true; |
|
|
|
default: |
|
return false; |
|
} |
|
} |
|
const skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g; |
|
const skipWhiteSpaceInLine = /(?:[^\S\n\r\u2028\u2029]|\/\/.*|\/\*.*?\*\/)*/y; |
|
const skipWhiteSpaceToLineBreak = new RegExp("(?=(" + skipWhiteSpaceInLine.source + "))\\1" + /(?=[\n\r\u2028\u2029]|\/\*(?!.*?\*\/)|$)/.source, "y"); |
|
function isWhitespace(code) { |
|
switch (code) { |
|
case 0x0009: |
|
case 0x000b: |
|
case 0x000c: |
|
case 32: |
|
case 160: |
|
case 5760: |
|
case 0x2000: |
|
case 0x2001: |
|
case 0x2002: |
|
case 0x2003: |
|
case 0x2004: |
|
case 0x2005: |
|
case 0x2006: |
|
case 0x2007: |
|
case 0x2008: |
|
case 0x2009: |
|
case 0x200a: |
|
case 0x202f: |
|
case 0x205f: |
|
case 0x3000: |
|
case 0xfeff: |
|
return true; |
|
|
|
default: |
|
return false; |
|
} |
|
} |
|
|
|
class State { |
|
constructor() { |
|
this.strict = void 0; |
|
this.curLine = void 0; |
|
this.lineStart = void 0; |
|
this.startLoc = void 0; |
|
this.endLoc = void 0; |
|
this.errors = []; |
|
this.potentialArrowAt = -1; |
|
this.noArrowAt = []; |
|
this.noArrowParamsConversionAt = []; |
|
this.maybeInArrowParameters = false; |
|
this.inType = false; |
|
this.noAnonFunctionType = false; |
|
this.hasFlowComment = false; |
|
this.isAmbientContext = false; |
|
this.inAbstractClass = false; |
|
this.inDisallowConditionalTypesContext = false; |
|
this.topicContext = { |
|
maxNumOfResolvableTopics: 0, |
|
maxTopicIndex: null |
|
}; |
|
this.soloAwait = false; |
|
this.inFSharpPipelineDirectBody = false; |
|
this.labels = []; |
|
this.decoratorStack = [[]]; |
|
this.comments = []; |
|
this.commentStack = []; |
|
this.pos = 0; |
|
this.type = 135; |
|
this.value = null; |
|
this.start = 0; |
|
this.end = 0; |
|
this.lastTokEndLoc = null; |
|
this.lastTokStartLoc = null; |
|
this.lastTokStart = 0; |
|
this.context = [types.brace]; |
|
this.canStartJSXElement = true; |
|
this.containsEsc = false; |
|
this.strictErrors = new Map(); |
|
this.tokensLength = 0; |
|
} |
|
|
|
init({ |
|
strictMode, |
|
sourceType, |
|
startLine, |
|
startColumn |
|
}) { |
|
this.strict = strictMode === false ? false : strictMode === true ? true : sourceType === "module"; |
|
this.curLine = startLine; |
|
this.lineStart = -startColumn; |
|
this.startLoc = this.endLoc = new Position(startLine, startColumn, 0); |
|
} |
|
|
|
curPosition() { |
|
return new Position(this.curLine, this.pos - this.lineStart, this.pos); |
|
} |
|
|
|
clone(skipArrays) { |
|
const state = new State(); |
|
const keys = Object.keys(this); |
|
|
|
for (let i = 0, length = keys.length; i < length; i++) { |
|
const key = keys[i]; |
|
let val = this[key]; |
|
|
|
if (!skipArrays && Array.isArray(val)) { |
|
val = val.slice(); |
|
} |
|
|
|
state[key] = val; |
|
} |
|
|
|
return state; |
|
} |
|
|
|
} |
|
|
|
const _excluded = ["at"], |
|
_excluded2 = ["at"]; |
|
|
|
var _isDigit = function isDigit(code) { |
|
return code >= 48 && code <= 57; |
|
}; |
|
const VALID_REGEX_FLAGS = new Set([103, 109, 115, 105, 121, 117, 100, 118]); |
|
const forbiddenNumericSeparatorSiblings = { |
|
decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]), |
|
hex: new Set([46, 88, 95, 120]) |
|
}; |
|
const isAllowedNumericSeparatorSibling = { |
|
bin: ch => ch === 48 || ch === 49, |
|
oct: ch => ch >= 48 && ch <= 55, |
|
dec: ch => ch >= 48 && ch <= 57, |
|
hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102 |
|
}; |
|
class Token { |
|
constructor(state) { |
|
this.type = state.type; |
|
this.value = state.value; |
|
this.start = state.start; |
|
this.end = state.end; |
|
this.loc = new SourceLocation(state.startLoc, state.endLoc); |
|
} |
|
|
|
} |
|
class Tokenizer extends CommentsParser { |
|
constructor(options, input) { |
|
super(); |
|
this.isLookahead = void 0; |
|
this.tokens = []; |
|
this.state = new State(); |
|
this.state.init(options); |
|
this.input = input; |
|
this.length = input.length; |
|
this.isLookahead = false; |
|
} |
|
|
|
pushToken(token) { |
|
this.tokens.length = this.state.tokensLength; |
|
this.tokens.push(token); |
|
++this.state.tokensLength; |
|
} |
|
|
|
next() { |
|
this.checkKeywordEscapes(); |
|
|
|
if (this.options.tokens) { |
|
this.pushToken(new Token(this.state)); |
|
} |
|
|
|
this.state.lastTokStart = this.state.start; |
|
this.state.lastTokEndLoc = this.state.endLoc; |
|
this.state.lastTokStartLoc = this.state.startLoc; |
|
this.nextToken(); |
|
} |
|
|
|
eat(type) { |
|
if (this.match(type)) { |
|
this.next(); |
|
return true; |
|
} else { |
|
return false; |
|
} |
|
} |
|
|
|
match(type) { |
|
return this.state.type === type; |
|
} |
|
|
|
createLookaheadState(state) { |
|
return { |
|
pos: state.pos, |
|
value: null, |
|
type: state.type, |
|
start: state.start, |
|
end: state.end, |
|
context: [this.curContext()], |
|
inType: state.inType, |
|
startLoc: state.startLoc, |
|
lastTokEndLoc: state.lastTokEndLoc, |
|
curLine: state.curLine, |
|
lineStart: state.lineStart, |
|
curPosition: state.curPosition |
|
}; |
|
} |
|
|
|
lookahead() { |
|
const old = this.state; |
|
this.state = this.createLookaheadState(old); |
|
this.isLookahead = true; |
|
this.nextToken(); |
|
this.isLookahead = false; |
|
const curr = this.state; |
|
this.state = old; |
|
return curr; |
|
} |
|
|
|
nextTokenStart() { |
|
return this.nextTokenStartSince(this.state.pos); |
|
} |
|
|
|
nextTokenStartSince(pos) { |
|
skipWhiteSpace.lastIndex = pos; |
|
return skipWhiteSpace.test(this.input) ? skipWhiteSpace.lastIndex : pos; |
|
} |
|
|
|
lookaheadCharCode() { |
|
return this.input.charCodeAt(this.nextTokenStart()); |
|
} |
|
|
|
codePointAtPos(pos) { |
|
let cp = this.input.charCodeAt(pos); |
|
|
|
if ((cp & 0xfc00) === 0xd800 && ++pos < this.input.length) { |
|
const trail = this.input.charCodeAt(pos); |
|
|
|
if ((trail & 0xfc00) === 0xdc00) { |
|
cp = 0x10000 + ((cp & 0x3ff) << 10) + (trail & 0x3ff); |
|
} |
|
} |
|
|
|
return cp; |
|
} |
|
|
|
setStrict(strict) { |
|
this.state.strict = strict; |
|
|
|
if (strict) { |
|
this.state.strictErrors.forEach(([toParseError, at]) => this.raise(toParseError, { |
|
at |
|
})); |
|
this.state.strictErrors.clear(); |
|
} |
|
} |
|
|
|
curContext() { |
|
return this.state.context[this.state.context.length - 1]; |
|
} |
|
|
|
nextToken() { |
|
this.skipSpace(); |
|
this.state.start = this.state.pos; |
|
if (!this.isLookahead) this.state.startLoc = this.state.curPosition(); |
|
|
|
if (this.state.pos >= this.length) { |
|
this.finishToken(135); |
|
return; |
|
} |
|
|
|
this.getTokenFromCode(this.codePointAtPos(this.state.pos)); |
|
} |
|
|
|
skipBlockComment() { |
|
let startLoc; |
|
if (!this.isLookahead) startLoc = this.state.curPosition(); |
|
const start = this.state.pos; |
|
const end = this.input.indexOf("*/", start + 2); |
|
|
|
if (end === -1) { |
|
throw this.raise(Errors.UnterminatedComment, { |
|
at: this.state.curPosition() |
|
}); |
|
} |
|
|
|
this.state.pos = end + 2; |
|
lineBreakG.lastIndex = start + 2; |
|
|
|
while (lineBreakG.test(this.input) && lineBreakG.lastIndex <= end) { |
|
++this.state.curLine; |
|
this.state.lineStart = lineBreakG.lastIndex; |
|
} |
|
|
|
if (this.isLookahead) return; |
|
const comment = { |
|
type: "CommentBlock", |
|
value: this.input.slice(start + 2, end), |
|
start, |
|
end: end + 2, |
|
loc: new SourceLocation(startLoc, this.state.curPosition()) |
|
}; |
|
if (this.options.tokens) this.pushToken(comment); |
|
return comment; |
|
} |
|
|
|
skipLineComment(startSkip) { |
|
const start = this.state.pos; |
|
let startLoc; |
|
if (!this.isLookahead) startLoc = this.state.curPosition(); |
|
let ch = this.input.charCodeAt(this.state.pos += startSkip); |
|
|
|
if (this.state.pos < this.length) { |
|
while (!isNewLine(ch) && ++this.state.pos < this.length) { |
|
ch = this.input.charCodeAt(this.state.pos); |
|
} |
|
} |
|
|
|
if (this.isLookahead) return; |
|
const end = this.state.pos; |
|
const value = this.input.slice(start + startSkip, end); |
|
const comment = { |
|
type: "CommentLine", |
|
value, |
|
start, |
|
end, |
|
loc: new SourceLocation(startLoc, this.state.curPosition()) |
|
}; |
|
if (this.options.tokens) this.pushToken(comment); |
|
return comment; |
|
} |
|
|
|
skipSpace() { |
|
const spaceStart = this.state.pos; |
|
const comments = []; |
|
|
|
loop: while (this.state.pos < this.length) { |
|
const ch = this.input.charCodeAt(this.state.pos); |
|
|
|
switch (ch) { |
|
case 32: |
|
case 160: |
|
case 9: |
|
++this.state.pos; |
|
break; |
|
|
|
case 13: |
|
if (this.input.charCodeAt(this.state.pos + 1) === 10) { |
|
++this.state.pos; |
|
} |
|
|
|
case 10: |
|
case 8232: |
|
case 8233: |
|
++this.state.pos; |
|
++this.state.curLine; |
|
this.state.lineStart = this.state.pos; |
|
break; |
|
|
|
case 47: |
|
switch (this.input.charCodeAt(this.state.pos + 1)) { |
|
case 42: |
|
{ |
|
const comment = this.skipBlockComment(); |
|
|
|
if (comment !== undefined) { |
|
this.addComment(comment); |
|
if (this.options.attachComment) comments.push(comment); |
|
} |
|
|
|
break; |
|
} |
|
|
|
case 47: |
|
{ |
|
const comment = this.skipLineComment(2); |
|
|
|
if (comment !== undefined) { |
|
this.addComment(comment); |
|
if (this.options.attachComment) comments.push(comment); |
|
} |
|
|
|
break; |
|
} |
|
|
|
default: |
|
break loop; |
|
} |
|
|
|
break; |
|
|
|
default: |
|
if (isWhitespace(ch)) { |
|
++this.state.pos; |
|
} else if (ch === 45 && !this.inModule) { |
|
const pos = this.state.pos; |
|
|
|
if (this.input.charCodeAt(pos + 1) === 45 && this.input.charCodeAt(pos + 2) === 62 && (spaceStart === 0 || this.state.lineStart > spaceStart)) { |
|
const comment = this.skipLineComment(3); |
|
|
|
if (comment !== undefined) { |
|
this.addComment(comment); |
|
if (this.options.attachComment) comments.push(comment); |
|
} |
|
} else { |
|
break loop; |
|
} |
|
} else if (ch === 60 && !this.inModule) { |
|
const pos = this.state.pos; |
|
|
|
if (this.input.charCodeAt(pos + 1) === 33 && this.input.charCodeAt(pos + 2) === 45 && this.input.charCodeAt(pos + 3) === 45) { |
|
const comment = this.skipLineComment(4); |
|
|
|
if (comment !== undefined) { |
|
this.addComment(comment); |
|
if (this.options.attachComment) comments.push(comment); |
|
} |
|
} else { |
|
break loop; |
|
} |
|
} else { |
|
break loop; |
|
} |
|
|
|
} |
|
} |
|
|
|
if (comments.length > 0) { |
|
const end = this.state.pos; |
|
const CommentWhitespace = { |
|
start: spaceStart, |
|
end, |
|
comments, |
|
leadingNode: null, |
|
trailingNode: null, |
|
containingNode: null |
|
}; |
|
this.state.commentStack.push(CommentWhitespace); |
|
} |
|
} |
|
|
|
finishToken(type, val) { |
|
this.state.end = this.state.pos; |
|
this.state.endLoc = this.state.curPosition(); |
|
const prevType = this.state.type; |
|
this.state.type = type; |
|
this.state.value = val; |
|
|
|
if (!this.isLookahead) { |
|
this.updateContext(prevType); |
|
} |
|
} |
|
|
|
replaceToken(type) { |
|
this.state.type = type; |
|
this.updateContext(); |
|
} |
|
|
|
readToken_numberSign() { |
|
if (this.state.pos === 0 && this.readToken_interpreter()) { |
|
return; |
|
} |
|
|
|
const nextPos = this.state.pos + 1; |
|
const next = this.codePointAtPos(nextPos); |
|
|
|
if (next >= 48 && next <= 57) { |
|
throw this.raise(Errors.UnexpectedDigitAfterHash, { |
|
at: this.state.curPosition() |
|
}); |
|
} |
|
|
|
if (next === 123 || next === 91 && this.hasPlugin("recordAndTuple")) { |
|
this.expectPlugin("recordAndTuple"); |
|
|
|
if (this.getPluginOption("recordAndTuple", "syntaxType") !== "hash") { |
|
throw this.raise(next === 123 ? Errors.RecordExpressionHashIncorrectStartSyntaxType : Errors.TupleExpressionHashIncorrectStartSyntaxType, { |
|
at: this.state.curPosition() |
|
}); |
|
} |
|
|
|
this.state.pos += 2; |
|
|
|
if (next === 123) { |
|
this.finishToken(7); |
|
} else { |
|
this.finishToken(1); |
|
} |
|
} else if (isIdentifierStart(next)) { |
|
++this.state.pos; |
|
this.finishToken(134, this.readWord1(next)); |
|
} else if (next === 92) { |
|
++this.state.pos; |
|
this.finishToken(134, this.readWord1()); |
|
} else { |
|
this.finishOp(27, 1); |
|
} |
|
} |
|
|
|
readToken_dot() { |
|
const next = this.input.charCodeAt(this.state.pos + 1); |
|
|
|
if (next >= 48 && next <= 57) { |
|
this.readNumber(true); |
|
return; |
|
} |
|
|
|
if (next === 46 && this.input.charCodeAt(this.state.pos + 2) === 46) { |
|
this.state.pos += 3; |
|
this.finishToken(21); |
|
} else { |
|
++this.state.pos; |
|
this.finishToken(16); |
|
} |
|
} |
|
|
|
readToken_slash() { |
|
const next = this.input.charCodeAt(this.state.pos + 1); |
|
|
|
if (next === 61) { |
|
this.finishOp(31, 2); |
|
} else { |
|
this.finishOp(56, 1); |
|
} |
|
} |
|
|
|
readToken_interpreter() { |
|
if (this.state.pos !== 0 || this.length < 2) return false; |
|
let ch = this.input.charCodeAt(this.state.pos + 1); |
|
if (ch !== 33) return false; |
|
const start = this.state.pos; |
|
this.state.pos += 1; |
|
|
|
while (!isNewLine(ch) && ++this.state.pos < this.length) { |
|
ch = this.input.charCodeAt(this.state.pos); |
|
} |
|
|
|
const value = this.input.slice(start + 2, this.state.pos); |
|
this.finishToken(28, value); |
|
return true; |
|
} |
|
|
|
readToken_mult_modulo(code) { |
|
let type = code === 42 ? 55 : 54; |
|
let width = 1; |
|
let next = this.input.charCodeAt(this.state.pos + 1); |
|
|
|
if (code === 42 && next === 42) { |
|
width++; |
|
next = this.input.charCodeAt(this.state.pos + 2); |
|
type = 57; |
|
} |
|
|
|
if (next === 61 && !this.state.inType) { |
|
width++; |
|
type = code === 37 ? 33 : 30; |
|
} |
|
|
|
this.finishOp(type, width); |
|
} |
|
|
|
readToken_pipe_amp(code) { |
|
const next = this.input.charCodeAt(this.state.pos + 1); |
|
|
|
if (next === code) { |
|
if (this.input.charCodeAt(this.state.pos + 2) === 61) { |
|
this.finishOp(30, 3); |
|
} else { |
|
this.finishOp(code === 124 ? 41 : 42, 2); |
|
} |
|
|
|
return; |
|
} |
|
|
|
if (code === 124) { |
|
if (next === 62) { |
|
this.finishOp(39, 2); |
|
return; |
|
} |
|
|
|
if (this.hasPlugin("recordAndTuple") && next === 125) { |
|
if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") { |
|
throw this.raise(Errors.RecordExpressionBarIncorrectEndSyntaxType, { |
|
at: this.state.curPosition() |
|
}); |
|
} |
|
|
|
this.state.pos += 2; |
|
this.finishToken(9); |
|
return; |
|
} |
|
|
|
if (this.hasPlugin("recordAndTuple") && next === 93) { |
|
if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") { |
|
throw this.raise(Errors.TupleExpressionBarIncorrectEndSyntaxType, { |
|
at: this.state.curPosition() |
|
}); |
|
} |
|
|
|
this.state.pos += 2; |
|
this.finishToken(4); |
|
return; |
|
} |
|
} |
|
|
|
if (next === 61) { |
|
this.finishOp(30, 2); |
|
return; |
|
} |
|
|
|
this.finishOp(code === 124 ? 43 : 45, 1); |
|
} |
|
|
|
readToken_caret() { |
|
const next = this.input.charCodeAt(this.state.pos + 1); |
|
|
|
if (next === 61 && !this.state.inType) { |
|
this.finishOp(32, 2); |
|
} else if (next === 94 && this.hasPlugin(["pipelineOperator", { |
|
proposal: "hack", |
|
topicToken: "^^" |
|
}])) { |
|
this.finishOp(37, 2); |
|
const lookaheadCh = this.input.codePointAt(this.state.pos); |
|
|
|
if (lookaheadCh === 94) { |
|
throw this.unexpected(); |
|
} |
|
} else { |
|
this.finishOp(44, 1); |
|
} |
|
} |
|
|
|
readToken_atSign() { |
|
const next = this.input.charCodeAt(this.state.pos + 1); |
|
|
|
if (next === 64 && this.hasPlugin(["pipelineOperator", { |
|
proposal: "hack", |
|
topicToken: "@@" |
|
}])) { |
|
this.finishOp(38, 2); |
|
} else { |
|
this.finishOp(26, 1); |
|
} |
|
} |
|
|
|
readToken_plus_min(code) { |
|
const next = this.input.charCodeAt(this.state.pos + 1); |
|
|
|
if (next === code) { |
|
this.finishOp(34, 2); |
|
return; |
|
} |
|
|
|
if (next === 61) { |
|
this.finishOp(30, 2); |
|
} else { |
|
this.finishOp(53, 1); |
|
} |
|
} |
|
|
|
readToken_lt() { |
|
const { |
|
pos |
|
} = this.state; |
|
const next = this.input.charCodeAt(pos + 1); |
|
|
|
if (next === 60) { |
|
if (this.input.charCodeAt(pos + 2) === 61) { |
|
this.finishOp(30, 3); |
|
return; |
|
} |
|
|
|
this.finishOp(51, 2); |
|
return; |
|
} |
|
|
|
if (next === 61) { |
|
this.finishOp(49, 2); |
|
return; |
|
} |
|
|
|
this.finishOp(47, 1); |
|
} |
|
|
|
readToken_gt() { |
|
const { |
|
pos |
|
} = this.state; |
|
const next = this.input.charCodeAt(pos + 1); |
|
|
|
if (next === 62) { |
|
const size = this.input.charCodeAt(pos + 2) === 62 ? 3 : 2; |
|
|
|
if (this.input.charCodeAt(pos + size) === 61) { |
|
this.finishOp(30, size + 1); |
|
return; |
|
} |
|
|
|
this.finishOp(52, size); |
|
return; |
|
} |
|
|
|
if (next === 61) { |
|
this.finishOp(49, 2); |
|
return; |
|
} |
|
|
|
this.finishOp(48, 1); |
|
} |
|
|
|
readToken_eq_excl(code) { |
|
const next = this.input.charCodeAt(this.state.pos + 1); |
|
|
|
if (next === 61) { |
|
this.finishOp(46, this.input.charCodeAt(this.state.pos + 2) === 61 ? 3 : 2); |
|
return; |
|
} |
|
|
|
if (code === 61 && next === 62) { |
|
this.state.pos += 2; |
|
this.finishToken(19); |
|
return; |
|
} |
|
|
|
this.finishOp(code === 61 ? 29 : 35, 1); |
|
} |
|
|
|
readToken_question() { |
|
const next = this.input.charCodeAt(this.state.pos + 1); |
|
const next2 = this.input.charCodeAt(this.state.pos + 2); |
|
|
|
if (next === 63) { |
|
if (next2 === 61) { |
|
this.finishOp(30, 3); |
|
} else { |
|
this.finishOp(40, 2); |
|
} |
|
} else if (next === 46 && !(next2 >= 48 && next2 <= 57)) { |
|
this.state.pos += 2; |
|
this.finishToken(18); |
|
} else { |
|
++this.state.pos; |
|
this.finishToken(17); |
|
} |
|
} |
|
|
|
getTokenFromCode(code) { |
|
switch (code) { |
|
case 46: |
|
this.readToken_dot(); |
|
return; |
|
|
|
case 40: |
|
++this.state.pos; |
|
this.finishToken(10); |
|
return; |
|
|
|
case 41: |
|
++this.state.pos; |
|
this.finishToken(11); |
|
return; |
|
|
|
case 59: |
|
++this.state.pos; |
|
this.finishToken(13); |
|
return; |
|
|
|
case 44: |
|
++this.state.pos; |
|
this.finishToken(12); |
|
return; |
|
|
|
case 91: |
|
if (this.hasPlugin("recordAndTuple") && this.input.charCodeAt(this.state.pos + 1) === 124) { |
|
if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") { |
|
throw this.raise(Errors.TupleExpressionBarIncorrectStartSyntaxType, { |
|
at: this.state.curPosition() |
|
}); |
|
} |
|
|
|
this.state.pos += 2; |
|
this.finishToken(2); |
|
} else { |
|
++this.state.pos; |
|
this.finishToken(0); |
|
} |
|
|
|
return; |
|
|
|
case 93: |
|
++this.state.pos; |
|
this.finishToken(3); |
|
return; |
|
|
|
case 123: |
|
if (this.hasPlugin("recordAndTuple") && this.input.charCodeAt(this.state.pos + 1) === 124) { |
|
if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") { |
|
throw this.raise(Errors.RecordExpressionBarIncorrectStartSyntaxType, { |
|
at: this.state.curPosition() |
|
}); |
|
} |
|
|
|
this.state.pos += 2; |
|
this.finishToken(6); |
|
} else { |
|
++this.state.pos; |
|
this.finishToken(5); |
|
} |
|
|
|
return; |
|
|
|
case 125: |
|
++this.state.pos; |
|
this.finishToken(8); |
|
return; |
|
|
|
case 58: |
|
if (this.hasPlugin("functionBind") && this.input.charCodeAt(this.state.pos + 1) === 58) { |
|
this.finishOp(15, 2); |
|
} else { |
|
++this.state.pos; |
|
this.finishToken(14); |
|
} |
|
|
|
return; |
|
|
|
case 63: |
|
this.readToken_question(); |
|
return; |
|
|
|
case 96: |
|
this.readTemplateToken(); |
|
return; |
|
|
|
case 48: |
|
{ |
|
const next = this.input.charCodeAt(this.state.pos + 1); |
|
|
|
if (next === 120 || next === 88) { |
|
this.readRadixNumber(16); |
|
return; |
|
} |
|
|
|
if (next === 111 || next === 79) { |
|
this.readRadixNumber(8); |
|
return; |
|
} |
|
|
|
if (next === 98 || next === 66) { |
|
this.readRadixNumber(2); |
|
return; |
|
} |
|
} |
|
|
|
case 49: |
|
case 50: |
|
case 51: |
|
case 52: |
|
case 53: |
|
case 54: |
|
case 55: |
|
case 56: |
|
case 57: |
|
this.readNumber(false); |
|
return; |
|
|
|
case 34: |
|
case 39: |
|
this.readString(code); |
|
return; |
|
|
|
case 47: |
|
this.readToken_slash(); |
|
return; |
|
|
|
case 37: |
|
case 42: |
|
this.readToken_mult_modulo(code); |
|
return; |
|
|
|
case 124: |
|
case 38: |
|
this.readToken_pipe_amp(code); |
|
return; |
|
|
|
case 94: |
|
this.readToken_caret(); |
|
return; |
|
|
|
case 43: |
|
case 45: |
|
this.readToken_plus_min(code); |
|
return; |
|
|
|
case 60: |
|
this.readToken_lt(); |
|
return; |
|
|
|
case 62: |
|
this.readToken_gt(); |
|
return; |
|
|
|
case 61: |
|
case 33: |
|
this.readToken_eq_excl(code); |
|
return; |
|
|
|
case 126: |
|
this.finishOp(36, 1); |
|
return; |
|
|
|
case 64: |
|
this.readToken_atSign(); |
|
return; |
|
|
|
case 35: |
|
this.readToken_numberSign(); |
|
return; |
|
|
|
case 92: |
|
this.readWord(); |
|
return; |
|
|
|
default: |
|
if (isIdentifierStart(code)) { |
|
this.readWord(code); |
|
return; |
|
} |
|
|
|
} |
|
|
|
throw this.raise(Errors.InvalidOrUnexpectedToken, { |
|
at: this.state.curPosition(), |
|
unexpected: String.fromCodePoint(code) |
|
}); |
|
} |
|
|
|
finishOp(type, size) { |
|
const str = this.input.slice(this.state.pos, this.state.pos + size); |
|
this.state.pos += size; |
|
this.finishToken(type, str); |
|
} |
|
|
|
readRegexp() { |
|
const startLoc = this.state.startLoc; |
|
const start = this.state.start + 1; |
|
let escaped, inClass; |
|
let { |
|
pos |
|
} = this.state; |
|
|
|
for (;; ++pos) { |
|
if (pos >= this.length) { |
|
throw this.raise(Errors.UnterminatedRegExp, { |
|
at: createPositionWithColumnOffset(startLoc, 1) |
|
}); |
|
} |
|
|
|
const ch = this.input.charCodeAt(pos); |
|
|
|
if (isNewLine(ch)) { |
|
throw this.raise(Errors.UnterminatedRegExp, { |
|
at: createPositionWithColumnOffset(startLoc, 1) |
|
}); |
|
} |
|
|
|
if (escaped) { |
|
escaped = false; |
|
} else { |
|
if (ch === 91) { |
|
inClass = true; |
|
} else if (ch === 93 && inClass) { |
|
inClass = false; |
|
} else if (ch === 47 && !inClass) { |
|
break; |
|
} |
|
|
|
escaped = ch === 92; |
|
} |
|
} |
|
|
|
const content = this.input.slice(start, pos); |
|
++pos; |
|
let mods = ""; |
|
|
|
const nextPos = () => createPositionWithColumnOffset(startLoc, pos + 2 - start); |
|
|
|
while (pos < this.length) { |
|
const cp = this.codePointAtPos(pos); |
|
const char = String.fromCharCode(cp); |
|
|
|
if (VALID_REGEX_FLAGS.has(cp)) { |
|
if (cp === 118) { |
|
this.expectPlugin("regexpUnicodeSets", nextPos()); |
|
|
|
if (mods.includes("u")) { |
|
this.raise(Errors.IncompatibleRegExpUVFlags, { |
|
at: nextPos() |
|
}); |
|
} |
|
} else if (cp === 117) { |
|
if (mods.includes("v")) { |
|
this.raise(Errors.IncompatibleRegExpUVFlags, { |
|
at: nextPos() |
|
}); |
|
} |
|
} |
|
|
|
if (mods.includes(char)) { |
|
this.raise(Errors.DuplicateRegExpFlags, { |
|
at: nextPos() |
|
}); |
|
} |
|
} else if (isIdentifierChar(cp) || cp === 92) { |
|
this.raise(Errors.MalformedRegExpFlags, { |
|
at: nextPos() |
|
}); |
|
} else { |
|
break; |
|
} |
|
|
|
++pos; |
|
mods += char; |
|
} |
|
|
|
this.state.pos = pos; |
|
this.finishToken(133, { |
|
pattern: content, |
|
flags: mods |
|
}); |
|
} |
|
|
|
readInt(radix, len, forceLen, allowNumSeparator = true) { |
|
const start = this.state.pos; |
|
const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct; |
|
const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin; |
|
let invalid = false; |
|
let total = 0; |
|
|
|
for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) { |
|
const code = this.input.charCodeAt(this.state.pos); |
|
let val; |
|
|
|
if (code === 95 && allowNumSeparator !== "bail") { |
|
const prev = this.input.charCodeAt(this.state.pos - 1); |
|
const next = this.input.charCodeAt(this.state.pos + 1); |
|
|
|
if (!allowNumSeparator) { |
|
this.raise(Errors.NumericSeparatorInEscapeSequence, { |
|
at: this.state.curPosition() |
|
}); |
|
} else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) { |
|
this.raise(Errors.UnexpectedNumericSeparator, { |
|
at: this.state.curPosition() |
|
}); |
|
} |
|
|
|
++this.state.pos; |
|
continue; |
|
} |
|
|
|
if (code >= 97) { |
|
val = code - 97 + 10; |
|
} else if (code >= 65) { |
|
val = code - 65 + 10; |
|
} else if (_isDigit(code)) { |
|
val = code - 48; |
|
} else { |
|
val = Infinity; |
|
} |
|
|
|
if (val >= radix) { |
|
if (this.options.errorRecovery && val <= 9) { |
|
val = 0; |
|
this.raise(Errors.InvalidDigit, { |
|
at: this.state.curPosition(), |
|
radix |
|
}); |
|
} else if (forceLen) { |
|
val = 0; |
|
invalid = true; |
|
} else { |
|
break; |
|
} |
|
} |
|
|
|
++this.state.pos; |
|
total = total * radix + val; |
|
} |
|
|
|
if (this.state.pos === start || len != null && this.state.pos - start !== len || invalid) { |
|
return null; |
|
} |
|
|
|
return total; |
|
} |
|
|
|
readRadixNumber(radix) { |
|
const startLoc = this.state.curPosition(); |
|
let isBigInt = false; |
|
this.state.pos += 2; |
|
const val = this.readInt(radix); |
|
|
|
if (val == null) { |
|
this.raise(Errors.InvalidDigit, { |
|
at: createPositionWithColumnOffset(startLoc, 2), |
|
radix |
|
}); |
|
} |
|
|
|
const next = this.input.charCodeAt(this.state.pos); |
|
|
|
if (next === 110) { |
|
++this.state.pos; |
|
isBigInt = true; |
|
} else if (next === 109) { |
|
throw this.raise(Errors.InvalidDecimal, { |
|
at: startLoc |
|
}); |
|
} |
|
|
|
if (isIdentifierStart(this.codePointAtPos(this.state.pos))) { |
|
throw this.raise(Errors.NumberIdentifier, { |
|
at: this.state.curPosition() |
|
}); |
|
} |
|
|
|
if (isBigInt) { |
|
const str = this.input.slice(startLoc.index, this.state.pos).replace(/[_n]/g, ""); |
|
this.finishToken(131, str); |
|
return; |
|
} |
|
|
|
this.finishToken(130, val); |
|
} |
|
|
|
readNumber(startsWithDot) { |
|
const start = this.state.pos; |
|
const startLoc = this.state.curPosition(); |
|
let isFloat = false; |
|
let isBigInt = false; |
|
let isDecimal = false; |
|
let hasExponent = false; |
|
let isOctal = false; |
|
|
|
if (!startsWithDot && this.readInt(10) === null) { |
|
this.raise(Errors.InvalidNumber, { |
|
at: this.state.curPosition() |
|
}); |
|
} |
|
|
|
const hasLeadingZero = this.state.pos - start >= 2 && this.input.charCodeAt(start) === 48; |
|
|
|
if (hasLeadingZero) { |
|
const integer = this.input.slice(start, this.state.pos); |
|
this.recordStrictModeErrors(Errors.StrictOctalLiteral, { |
|
at: startLoc |
|
}); |
|
|
|
if (!this.state.strict) { |
|
const underscorePos = integer.indexOf("_"); |
|
|
|
if (underscorePos > 0) { |
|
this.raise(Errors.ZeroDigitNumericSeparator, { |
|
at: createPositionWithColumnOffset(startLoc, underscorePos) |
|
}); |
|
} |
|
} |
|
|
|
isOctal = hasLeadingZero && !/[89]/.test(integer); |
|
} |
|
|
|
let next = this.input.charCodeAt(this.state.pos); |
|
|
|
if (next === 46 && !isOctal) { |
|
++this.state.pos; |
|
this.readInt(10); |
|
isFloat = true; |
|
next = this.input.charCodeAt(this.state.pos); |
|
} |
|
|
|
if ((next === 69 || next === 101) && !isOctal) { |
|
next = this.input.charCodeAt(++this.state.pos); |
|
|
|
if (next === 43 || next === 45) { |
|
++this.state.pos; |
|
} |
|
|
|
if (this.readInt(10) === null) { |
|
this.raise(Errors.InvalidOrMissingExponent, { |
|
at: startLoc |
|
}); |
|
} |
|
|
|
isFloat = true; |
|
hasExponent = true; |
|
next = this.input.charCodeAt(this.state.pos); |
|
} |
|
|
|
if (next === 110) { |
|
if (isFloat || hasLeadingZero) { |
|
this.raise(Errors.InvalidBigIntLiteral, { |
|
at: startLoc |
|
}); |
|
} |
|
|
|
++this.state.pos; |
|
isBigInt = true; |
|
} |
|
|
|
if (next === 109) { |
|
this.expectPlugin("decimal", this.state.curPosition()); |
|
|
|
if (hasExponent || hasLeadingZero) { |
|
this.raise(Errors.InvalidDecimal, { |
|
at: startLoc |
|
}); |
|
} |
|
|
|
++this.state.pos; |
|
isDecimal = true; |
|
} |
|
|
|
if (isIdentifierStart(this.codePointAtPos(this.state.pos))) { |
|
throw this.raise(Errors.NumberIdentifier, { |
|
at: this.state.curPosition() |
|
}); |
|
} |
|
|
|
const str = this.input.slice(start, this.state.pos).replace(/[_mn]/g, ""); |
|
|
|
if (isBigInt) { |
|
this.finishToken(131, str); |
|
return; |
|
} |
|
|
|
if (isDecimal) { |
|
this.finishToken(132, str); |
|
return; |
|
} |
|
|
|
const val = isOctal ? parseInt(str, 8) : parseFloat(str); |
|
this.finishToken(130, val); |
|
} |
|
|
|
readCodePoint(throwOnInvalid) { |
|
const ch = this.input.charCodeAt(this.state.pos); |
|
let code; |
|
|
|
if (ch === 123) { |
|
++this.state.pos; |
|
code = this.readHexChar(this.input.indexOf("}", this.state.pos) - this.state.pos, true, throwOnInvalid); |
|
++this.state.pos; |
|
|
|
if (code !== null && code > 0x10ffff) { |
|
if (throwOnInvalid) { |
|
this.raise(Errors.InvalidCodePoint, { |
|
at: this.state.curPosition() |
|
}); |
|
} else { |
|
return null; |
|
} |
|
} |
|
} else { |
|
code = this.readHexChar(4, false, throwOnInvalid); |
|
} |
|
|
|
return code; |
|
} |
|
|
|
readString(quote) { |
|
let out = "", |
|
chunkStart = ++this.state.pos; |
|
|
|
for (;;) { |
|
if (this.state.pos >= this.length) { |
|
throw this.raise(Errors.UnterminatedString, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
|
|
const ch = this.input.charCodeAt(this.state.pos); |
|
if (ch === quote) break; |
|
|
|
if (ch === 92) { |
|
out += this.input.slice(chunkStart, this.state.pos); |
|
out += this.readEscapedChar(false); |
|
chunkStart = this.state.pos; |
|
} else if (ch === 8232 || ch === 8233) { |
|
++this.state.pos; |
|
++this.state.curLine; |
|
this.state.lineStart = this.state.pos; |
|
} else if (isNewLine(ch)) { |
|
throw this.raise(Errors.UnterminatedString, { |
|
at: this.state.startLoc |
|
}); |
|
} else { |
|
++this.state.pos; |
|
} |
|
} |
|
|
|
out += this.input.slice(chunkStart, this.state.pos++); |
|
this.finishToken(129, out); |
|
} |
|
|
|
readTemplateContinuation() { |
|
if (!this.match(8)) { |
|
this.unexpected(null, 8); |
|
} |
|
|
|
this.state.pos--; |
|
this.readTemplateToken(); |
|
} |
|
|
|
readTemplateToken() { |
|
let out = "", |
|
chunkStart = this.state.pos, |
|
containsInvalid = false; |
|
++this.state.pos; |
|
|
|
for (;;) { |
|
if (this.state.pos >= this.length) { |
|
throw this.raise(Errors.UnterminatedTemplate, { |
|
at: createPositionWithColumnOffset(this.state.startLoc, 1) |
|
}); |
|
} |
|
|
|
const ch = this.input.charCodeAt(this.state.pos); |
|
|
|
if (ch === 96) { |
|
++this.state.pos; |
|
out += this.input.slice(chunkStart, this.state.pos); |
|
this.finishToken(24, containsInvalid ? null : out); |
|
return; |
|
} |
|
|
|
if (ch === 36 && this.input.charCodeAt(this.state.pos + 1) === 123) { |
|
this.state.pos += 2; |
|
out += this.input.slice(chunkStart, this.state.pos); |
|
this.finishToken(25, containsInvalid ? null : out); |
|
return; |
|
} |
|
|
|
if (ch === 92) { |
|
out += this.input.slice(chunkStart, this.state.pos); |
|
const escaped = this.readEscapedChar(true); |
|
|
|
if (escaped === null) { |
|
containsInvalid = true; |
|
} else { |
|
out += escaped; |
|
} |
|
|
|
chunkStart = this.state.pos; |
|
} else if (isNewLine(ch)) { |
|
out += this.input.slice(chunkStart, this.state.pos); |
|
++this.state.pos; |
|
|
|
switch (ch) { |
|
case 13: |
|
if (this.input.charCodeAt(this.state.pos) === 10) { |
|
++this.state.pos; |
|
} |
|
|
|
case 10: |
|
out += "\n"; |
|
break; |
|
|
|
default: |
|
out += String.fromCharCode(ch); |
|
break; |
|
} |
|
|
|
++this.state.curLine; |
|
this.state.lineStart = this.state.pos; |
|
chunkStart = this.state.pos; |
|
} else { |
|
++this.state.pos; |
|
} |
|
} |
|
} |
|
|
|
recordStrictModeErrors(toParseError, { |
|
at |
|
}) { |
|
const index = at.index; |
|
|
|
if (this.state.strict && !this.state.strictErrors.has(index)) { |
|
this.raise(toParseError, { |
|
at |
|
}); |
|
} else { |
|
this.state.strictErrors.set(index, [toParseError, at]); |
|
} |
|
} |
|
|
|
readEscapedChar(inTemplate) { |
|
const throwOnInvalid = !inTemplate; |
|
const ch = this.input.charCodeAt(++this.state.pos); |
|
++this.state.pos; |
|
|
|
switch (ch) { |
|
case 110: |
|
return "\n"; |
|
|
|
case 114: |
|
return "\r"; |
|
|
|
case 120: |
|
{ |
|
const code = this.readHexChar(2, false, throwOnInvalid); |
|
return code === null ? null : String.fromCharCode(code); |
|
} |
|
|
|
case 117: |
|
{ |
|
const code = this.readCodePoint(throwOnInvalid); |
|
return code === null ? null : String.fromCodePoint(code); |
|
} |
|
|
|
case 116: |
|
return "\t"; |
|
|
|
case 98: |
|
return "\b"; |
|
|
|
case 118: |
|
return "\u000b"; |
|
|
|
case 102: |
|
return "\f"; |
|
|
|
case 13: |
|
if (this.input.charCodeAt(this.state.pos) === 10) { |
|
++this.state.pos; |
|
} |
|
|
|
case 10: |
|
this.state.lineStart = this.state.pos; |
|
++this.state.curLine; |
|
|
|
case 8232: |
|
case 8233: |
|
return ""; |
|
|
|
case 56: |
|
case 57: |
|
if (inTemplate) { |
|
return null; |
|
} else { |
|
this.recordStrictModeErrors(Errors.StrictNumericEscape, { |
|
at: createPositionWithColumnOffset(this.state.curPosition(), -1) |
|
}); |
|
} |
|
|
|
default: |
|
if (ch >= 48 && ch <= 55) { |
|
const codePos = createPositionWithColumnOffset(this.state.curPosition(), -1); |
|
const match = this.input.slice(this.state.pos - 1, this.state.pos + 2).match(/^[0-7]+/); |
|
let octalStr = match[0]; |
|
let octal = parseInt(octalStr, 8); |
|
|
|
if (octal > 255) { |
|
octalStr = octalStr.slice(0, -1); |
|
octal = parseInt(octalStr, 8); |
|
} |
|
|
|
this.state.pos += octalStr.length - 1; |
|
const next = this.input.charCodeAt(this.state.pos); |
|
|
|
if (octalStr !== "0" || next === 56 || next === 57) { |
|
if (inTemplate) { |
|
return null; |
|
} else { |
|
this.recordStrictModeErrors(Errors.StrictNumericEscape, { |
|
at: codePos |
|
}); |
|
} |
|
} |
|
|
|
return String.fromCharCode(octal); |
|
} |
|
|
|
return String.fromCharCode(ch); |
|
} |
|
} |
|
|
|
readHexChar(len, forceLen, throwOnInvalid) { |
|
const codeLoc = this.state.curPosition(); |
|
const n = this.readInt(16, len, forceLen, false); |
|
|
|
if (n === null) { |
|
if (throwOnInvalid) { |
|
this.raise(Errors.InvalidEscapeSequence, { |
|
at: codeLoc |
|
}); |
|
} else { |
|
this.state.pos = codeLoc.index - 1; |
|
} |
|
} |
|
|
|
return n; |
|
} |
|
|
|
readWord1(firstCode) { |
|
this.state.containsEsc = false; |
|
let word = ""; |
|
const start = this.state.pos; |
|
let chunkStart = this.state.pos; |
|
|
|
if (firstCode !== undefined) { |
|
this.state.pos += firstCode <= 0xffff ? 1 : 2; |
|
} |
|
|
|
while (this.state.pos < this.length) { |
|
const ch = this.codePointAtPos(this.state.pos); |
|
|
|
if (isIdentifierChar(ch)) { |
|
this.state.pos += ch <= 0xffff ? 1 : 2; |
|
} else if (ch === 92) { |
|
this.state.containsEsc = true; |
|
word += this.input.slice(chunkStart, this.state.pos); |
|
const escStart = this.state.curPosition(); |
|
const identifierCheck = this.state.pos === start ? isIdentifierStart : isIdentifierChar; |
|
|
|
if (this.input.charCodeAt(++this.state.pos) !== 117) { |
|
this.raise(Errors.MissingUnicodeEscape, { |
|
at: this.state.curPosition() |
|
}); |
|
chunkStart = this.state.pos - 1; |
|
continue; |
|
} |
|
|
|
++this.state.pos; |
|
const esc = this.readCodePoint(true); |
|
|
|
if (esc !== null) { |
|
if (!identifierCheck(esc)) { |
|
this.raise(Errors.EscapedCharNotAnIdentifier, { |
|
at: escStart |
|
}); |
|
} |
|
|
|
word += String.fromCodePoint(esc); |
|
} |
|
|
|
chunkStart = this.state.pos; |
|
} else { |
|
break; |
|
} |
|
} |
|
|
|
return word + this.input.slice(chunkStart, this.state.pos); |
|
} |
|
|
|
readWord(firstCode) { |
|
const word = this.readWord1(firstCode); |
|
const type = keywords$1.get(word); |
|
|
|
if (type !== undefined) { |
|
this.finishToken(type, tokenLabelName(type)); |
|
} else { |
|
this.finishToken(128, word); |
|
} |
|
} |
|
|
|
checkKeywordEscapes() { |
|
const { |
|
type |
|
} = this.state; |
|
|
|
if (tokenIsKeyword(type) && this.state.containsEsc) { |
|
this.raise(Errors.InvalidEscapedReservedWord, { |
|
at: this.state.startLoc, |
|
reservedWord: tokenLabelName(type) |
|
}); |
|
} |
|
} |
|
|
|
raise(toParseError, raiseProperties) { |
|
const { |
|
at |
|
} = raiseProperties, |
|
details = _objectWithoutPropertiesLoose(raiseProperties, _excluded); |
|
|
|
const loc = at instanceof Position ? at : at.loc.start; |
|
const error = toParseError({ |
|
loc, |
|
details |
|
}); |
|
if (!this.options.errorRecovery) throw error; |
|
if (!this.isLookahead) this.state.errors.push(error); |
|
return error; |
|
} |
|
|
|
raiseOverwrite(toParseError, raiseProperties) { |
|
const { |
|
at |
|
} = raiseProperties, |
|
details = _objectWithoutPropertiesLoose(raiseProperties, _excluded2); |
|
|
|
const loc = at instanceof Position ? at : at.loc.start; |
|
const pos = loc.index; |
|
const errors = this.state.errors; |
|
|
|
for (let i = errors.length - 1; i >= 0; i--) { |
|
const error = errors[i]; |
|
|
|
if (error.loc.index === pos) { |
|
return errors[i] = toParseError({ |
|
loc, |
|
details |
|
}); |
|
} |
|
|
|
if (error.loc.index < pos) break; |
|
} |
|
|
|
return this.raise(toParseError, raiseProperties); |
|
} |
|
|
|
updateContext(prevType) {} |
|
|
|
unexpected(loc, type) { |
|
throw this.raise(Errors.UnexpectedToken, { |
|
expected: type ? tokenLabelName(type) : null, |
|
at: loc != null ? loc : this.state.startLoc |
|
}); |
|
} |
|
|
|
expectPlugin(pluginName, loc) { |
|
if (this.hasPlugin(pluginName)) { |
|
return true; |
|
} |
|
|
|
throw this.raise(Errors.MissingPlugin, { |
|
at: loc != null ? loc : this.state.startLoc, |
|
missingPlugin: [pluginName] |
|
}); |
|
} |
|
|
|
expectOnePlugin(pluginNames) { |
|
if (!pluginNames.some(name => this.hasPlugin(name))) { |
|
throw this.raise(Errors.MissingOneOfPlugins, { |
|
at: this.state.startLoc, |
|
missingPlugin: pluginNames |
|
}); |
|
} |
|
} |
|
|
|
} |
|
|
|
class Scope { |
|
constructor(flags) { |
|
this.var = new Set(); |
|
this.lexical = new Set(); |
|
this.functions = new Set(); |
|
this.flags = flags; |
|
} |
|
|
|
} |
|
class ScopeHandler { |
|
constructor(parser, inModule) { |
|
this.parser = void 0; |
|
this.scopeStack = []; |
|
this.inModule = void 0; |
|
this.undefinedExports = new Map(); |
|
this.parser = parser; |
|
this.inModule = inModule; |
|
} |
|
|
|
get inFunction() { |
|
return (this.currentVarScopeFlags() & SCOPE_FUNCTION) > 0; |
|
} |
|
|
|
get allowSuper() { |
|
return (this.currentThisScopeFlags() & SCOPE_SUPER) > 0; |
|
} |
|
|
|
get allowDirectSuper() { |
|
return (this.currentThisScopeFlags() & SCOPE_DIRECT_SUPER) > 0; |
|
} |
|
|
|
get inClass() { |
|
return (this.currentThisScopeFlags() & SCOPE_CLASS) > 0; |
|
} |
|
|
|
get inClassAndNotInNonArrowFunction() { |
|
const flags = this.currentThisScopeFlags(); |
|
return (flags & SCOPE_CLASS) > 0 && (flags & SCOPE_FUNCTION) === 0; |
|
} |
|
|
|
get inStaticBlock() { |
|
for (let i = this.scopeStack.length - 1;; i--) { |
|
const { |
|
flags |
|
} = this.scopeStack[i]; |
|
|
|
if (flags & SCOPE_STATIC_BLOCK) { |
|
return true; |
|
} |
|
|
|
if (flags & (SCOPE_VAR | SCOPE_CLASS)) { |
|
return false; |
|
} |
|
} |
|
} |
|
|
|
get inNonArrowFunction() { |
|
return (this.currentThisScopeFlags() & SCOPE_FUNCTION) > 0; |
|
} |
|
|
|
get treatFunctionsAsVar() { |
|
return this.treatFunctionsAsVarInScope(this.currentScope()); |
|
} |
|
|
|
createScope(flags) { |
|
return new Scope(flags); |
|
} |
|
|
|
enter(flags) { |
|
this.scopeStack.push(this.createScope(flags)); |
|
} |
|
|
|
exit() { |
|
this.scopeStack.pop(); |
|
} |
|
|
|
treatFunctionsAsVarInScope(scope) { |
|
return !!(scope.flags & (SCOPE_FUNCTION | SCOPE_STATIC_BLOCK) || !this.parser.inModule && scope.flags & SCOPE_PROGRAM); |
|
} |
|
|
|
declareName(name, bindingType, loc) { |
|
let scope = this.currentScope(); |
|
|
|
if (bindingType & BIND_SCOPE_LEXICAL || bindingType & BIND_SCOPE_FUNCTION) { |
|
this.checkRedeclarationInScope(scope, name, bindingType, loc); |
|
|
|
if (bindingType & BIND_SCOPE_FUNCTION) { |
|
scope.functions.add(name); |
|
} else { |
|
scope.lexical.add(name); |
|
} |
|
|
|
if (bindingType & BIND_SCOPE_LEXICAL) { |
|
this.maybeExportDefined(scope, name); |
|
} |
|
} else if (bindingType & BIND_SCOPE_VAR) { |
|
for (let i = this.scopeStack.length - 1; i >= 0; --i) { |
|
scope = this.scopeStack[i]; |
|
this.checkRedeclarationInScope(scope, name, bindingType, loc); |
|
scope.var.add(name); |
|
this.maybeExportDefined(scope, name); |
|
if (scope.flags & SCOPE_VAR) break; |
|
} |
|
} |
|
|
|
if (this.parser.inModule && scope.flags & SCOPE_PROGRAM) { |
|
this.undefinedExports.delete(name); |
|
} |
|
} |
|
|
|
maybeExportDefined(scope, name) { |
|
if (this.parser.inModule && scope.flags & SCOPE_PROGRAM) { |
|
this.undefinedExports.delete(name); |
|
} |
|
} |
|
|
|
checkRedeclarationInScope(scope, name, bindingType, loc) { |
|
if (this.isRedeclaredInScope(scope, name, bindingType)) { |
|
this.parser.raise(Errors.VarRedeclaration, { |
|
at: loc, |
|
identifierName: name |
|
}); |
|
} |
|
} |
|
|
|
isRedeclaredInScope(scope, name, bindingType) { |
|
if (!(bindingType & BIND_KIND_VALUE)) return false; |
|
|
|
if (bindingType & BIND_SCOPE_LEXICAL) { |
|
return scope.lexical.has(name) || scope.functions.has(name) || scope.var.has(name); |
|
} |
|
|
|
if (bindingType & BIND_SCOPE_FUNCTION) { |
|
return scope.lexical.has(name) || !this.treatFunctionsAsVarInScope(scope) && scope.var.has(name); |
|
} |
|
|
|
return scope.lexical.has(name) && !(scope.flags & SCOPE_SIMPLE_CATCH && scope.lexical.values().next().value === name) || !this.treatFunctionsAsVarInScope(scope) && scope.functions.has(name); |
|
} |
|
|
|
checkLocalExport(id) { |
|
const { |
|
name |
|
} = id; |
|
const topLevelScope = this.scopeStack[0]; |
|
|
|
if (!topLevelScope.lexical.has(name) && !topLevelScope.var.has(name) && !topLevelScope.functions.has(name)) { |
|
this.undefinedExports.set(name, id.loc.start); |
|
} |
|
} |
|
|
|
currentScope() { |
|
return this.scopeStack[this.scopeStack.length - 1]; |
|
} |
|
|
|
currentVarScopeFlags() { |
|
for (let i = this.scopeStack.length - 1;; i--) { |
|
const { |
|
flags |
|
} = this.scopeStack[i]; |
|
|
|
if (flags & SCOPE_VAR) { |
|
return flags; |
|
} |
|
} |
|
} |
|
|
|
currentThisScopeFlags() { |
|
for (let i = this.scopeStack.length - 1;; i--) { |
|
const { |
|
flags |
|
} = this.scopeStack[i]; |
|
|
|
if (flags & (SCOPE_VAR | SCOPE_CLASS) && !(flags & SCOPE_ARROW)) { |
|
return flags; |
|
} |
|
} |
|
} |
|
|
|
} |
|
|
|
class FlowScope extends Scope { |
|
constructor(...args) { |
|
super(...args); |
|
this.declareFunctions = new Set(); |
|
} |
|
|
|
} |
|
|
|
class FlowScopeHandler extends ScopeHandler { |
|
createScope(flags) { |
|
return new FlowScope(flags); |
|
} |
|
|
|
declareName(name, bindingType, loc) { |
|
const scope = this.currentScope(); |
|
|
|
if (bindingType & BIND_FLAGS_FLOW_DECLARE_FN) { |
|
this.checkRedeclarationInScope(scope, name, bindingType, loc); |
|
this.maybeExportDefined(scope, name); |
|
scope.declareFunctions.add(name); |
|
return; |
|
} |
|
|
|
super.declareName(...arguments); |
|
} |
|
|
|
isRedeclaredInScope(scope, name, bindingType) { |
|
if (super.isRedeclaredInScope(...arguments)) return true; |
|
|
|
if (bindingType & BIND_FLAGS_FLOW_DECLARE_FN) { |
|
return !scope.declareFunctions.has(name) && (scope.lexical.has(name) || scope.functions.has(name)); |
|
} |
|
|
|
return false; |
|
} |
|
|
|
checkLocalExport(id) { |
|
if (!this.scopeStack[0].declareFunctions.has(id.name)) { |
|
super.checkLocalExport(id); |
|
} |
|
} |
|
|
|
} |
|
|
|
class ClassScope { |
|
constructor() { |
|
this.privateNames = new Set(); |
|
this.loneAccessors = new Map(); |
|
this.undefinedPrivateNames = new Map(); |
|
} |
|
|
|
} |
|
class ClassScopeHandler { |
|
constructor(parser) { |
|
this.parser = void 0; |
|
this.stack = []; |
|
this.undefinedPrivateNames = new Map(); |
|
this.parser = parser; |
|
} |
|
|
|
current() { |
|
return this.stack[this.stack.length - 1]; |
|
} |
|
|
|
enter() { |
|
this.stack.push(new ClassScope()); |
|
} |
|
|
|
exit() { |
|
const oldClassScope = this.stack.pop(); |
|
const current = this.current(); |
|
|
|
for (const [name, loc] of Array.from(oldClassScope.undefinedPrivateNames)) { |
|
if (current) { |
|
if (!current.undefinedPrivateNames.has(name)) { |
|
current.undefinedPrivateNames.set(name, loc); |
|
} |
|
} else { |
|
this.parser.raise(Errors.InvalidPrivateFieldResolution, { |
|
at: loc, |
|
identifierName: name |
|
}); |
|
} |
|
} |
|
} |
|
|
|
declarePrivateName(name, elementType, loc) { |
|
const { |
|
privateNames, |
|
loneAccessors, |
|
undefinedPrivateNames |
|
} = this.current(); |
|
let redefined = privateNames.has(name); |
|
|
|
if (elementType & CLASS_ELEMENT_KIND_ACCESSOR) { |
|
const accessor = redefined && loneAccessors.get(name); |
|
|
|
if (accessor) { |
|
const oldStatic = accessor & CLASS_ELEMENT_FLAG_STATIC; |
|
const newStatic = elementType & CLASS_ELEMENT_FLAG_STATIC; |
|
const oldKind = accessor & CLASS_ELEMENT_KIND_ACCESSOR; |
|
const newKind = elementType & CLASS_ELEMENT_KIND_ACCESSOR; |
|
redefined = oldKind === newKind || oldStatic !== newStatic; |
|
if (!redefined) loneAccessors.delete(name); |
|
} else if (!redefined) { |
|
loneAccessors.set(name, elementType); |
|
} |
|
} |
|
|
|
if (redefined) { |
|
this.parser.raise(Errors.PrivateNameRedeclaration, { |
|
at: loc, |
|
identifierName: name |
|
}); |
|
} |
|
|
|
privateNames.add(name); |
|
undefinedPrivateNames.delete(name); |
|
} |
|
|
|
usePrivateName(name, loc) { |
|
let classScope; |
|
|
|
for (classScope of this.stack) { |
|
if (classScope.privateNames.has(name)) return; |
|
} |
|
|
|
if (classScope) { |
|
classScope.undefinedPrivateNames.set(name, loc); |
|
} else { |
|
this.parser.raise(Errors.InvalidPrivateFieldResolution, { |
|
at: loc, |
|
identifierName: name |
|
}); |
|
} |
|
} |
|
|
|
} |
|
|
|
const kExpression = 0, |
|
kMaybeArrowParameterDeclaration = 1, |
|
kMaybeAsyncArrowParameterDeclaration = 2, |
|
kParameterDeclaration = 3; |
|
|
|
class ExpressionScope { |
|
constructor(type = kExpression) { |
|
this.type = void 0; |
|
this.type = type; |
|
} |
|
|
|
canBeArrowParameterDeclaration() { |
|
return this.type === kMaybeAsyncArrowParameterDeclaration || this.type === kMaybeArrowParameterDeclaration; |
|
} |
|
|
|
isCertainlyParameterDeclaration() { |
|
return this.type === kParameterDeclaration; |
|
} |
|
|
|
} |
|
|
|
class ArrowHeadParsingScope extends ExpressionScope { |
|
constructor(type) { |
|
super(type); |
|
this.declarationErrors = new Map(); |
|
} |
|
|
|
recordDeclarationError(ParsingErrorClass, { |
|
at |
|
}) { |
|
const index = at.index; |
|
this.declarationErrors.set(index, [ParsingErrorClass, at]); |
|
} |
|
|
|
clearDeclarationError(index) { |
|
this.declarationErrors.delete(index); |
|
} |
|
|
|
iterateErrors(iterator) { |
|
this.declarationErrors.forEach(iterator); |
|
} |
|
|
|
} |
|
|
|
class ExpressionScopeHandler { |
|
constructor(parser) { |
|
this.parser = void 0; |
|
this.stack = [new ExpressionScope()]; |
|
this.parser = parser; |
|
} |
|
|
|
enter(scope) { |
|
this.stack.push(scope); |
|
} |
|
|
|
exit() { |
|
this.stack.pop(); |
|
} |
|
|
|
recordParameterInitializerError(toParseError, { |
|
at: node |
|
}) { |
|
const origin = { |
|
at: node.loc.start |
|
}; |
|
const { |
|
stack |
|
} = this; |
|
let i = stack.length - 1; |
|
let scope = stack[i]; |
|
|
|
while (!scope.isCertainlyParameterDeclaration()) { |
|
if (scope.canBeArrowParameterDeclaration()) { |
|
scope.recordDeclarationError(toParseError, origin); |
|
} else { |
|
return; |
|
} |
|
|
|
scope = stack[--i]; |
|
} |
|
|
|
this.parser.raise(toParseError, origin); |
|
} |
|
|
|
recordArrowParemeterBindingError(error, { |
|
at: node |
|
}) { |
|
const { |
|
stack |
|
} = this; |
|
const scope = stack[stack.length - 1]; |
|
const origin = { |
|
at: node.loc.start |
|
}; |
|
|
|
if (scope.isCertainlyParameterDeclaration()) { |
|
this.parser.raise(error, origin); |
|
} else if (scope.canBeArrowParameterDeclaration()) { |
|
scope.recordDeclarationError(error, origin); |
|
} else { |
|
return; |
|
} |
|
} |
|
|
|
recordAsyncArrowParametersError({ |
|
at |
|
}) { |
|
const { |
|
stack |
|
} = this; |
|
let i = stack.length - 1; |
|
let scope = stack[i]; |
|
|
|
while (scope.canBeArrowParameterDeclaration()) { |
|
if (scope.type === kMaybeAsyncArrowParameterDeclaration) { |
|
scope.recordDeclarationError(Errors.AwaitBindingIdentifier, { |
|
at |
|
}); |
|
} |
|
|
|
scope = stack[--i]; |
|
} |
|
} |
|
|
|
validateAsPattern() { |
|
const { |
|
stack |
|
} = this; |
|
const currentScope = stack[stack.length - 1]; |
|
if (!currentScope.canBeArrowParameterDeclaration()) return; |
|
currentScope.iterateErrors(([toParseError, loc]) => { |
|
this.parser.raise(toParseError, { |
|
at: loc |
|
}); |
|
let i = stack.length - 2; |
|
let scope = stack[i]; |
|
|
|
while (scope.canBeArrowParameterDeclaration()) { |
|
scope.clearDeclarationError(loc.index); |
|
scope = stack[--i]; |
|
} |
|
}); |
|
} |
|
|
|
} |
|
function newParameterDeclarationScope() { |
|
return new ExpressionScope(kParameterDeclaration); |
|
} |
|
function newArrowHeadScope() { |
|
return new ArrowHeadParsingScope(kMaybeArrowParameterDeclaration); |
|
} |
|
function newAsyncArrowScope() { |
|
return new ArrowHeadParsingScope(kMaybeAsyncArrowParameterDeclaration); |
|
} |
|
function newExpressionScope() { |
|
return new ExpressionScope(); |
|
} |
|
|
|
const PARAM = 0b0000, |
|
PARAM_YIELD = 0b0001, |
|
PARAM_AWAIT = 0b0010, |
|
PARAM_RETURN = 0b0100, |
|
PARAM_IN = 0b1000; |
|
class ProductionParameterHandler { |
|
constructor() { |
|
this.stacks = []; |
|
} |
|
|
|
enter(flags) { |
|
this.stacks.push(flags); |
|
} |
|
|
|
exit() { |
|
this.stacks.pop(); |
|
} |
|
|
|
currentFlags() { |
|
return this.stacks[this.stacks.length - 1]; |
|
} |
|
|
|
get hasAwait() { |
|
return (this.currentFlags() & PARAM_AWAIT) > 0; |
|
} |
|
|
|
get hasYield() { |
|
return (this.currentFlags() & PARAM_YIELD) > 0; |
|
} |
|
|
|
get hasReturn() { |
|
return (this.currentFlags() & PARAM_RETURN) > 0; |
|
} |
|
|
|
get hasIn() { |
|
return (this.currentFlags() & PARAM_IN) > 0; |
|
} |
|
|
|
} |
|
function functionFlags(isAsync, isGenerator) { |
|
return (isAsync ? PARAM_AWAIT : 0) | (isGenerator ? PARAM_YIELD : 0); |
|
} |
|
|
|
class UtilParser extends Tokenizer { |
|
addExtra(node, key, value, enumerable = true) { |
|
if (!node) return; |
|
const extra = node.extra = node.extra || {}; |
|
|
|
if (enumerable) { |
|
extra[key] = value; |
|
} else { |
|
Object.defineProperty(extra, key, { |
|
enumerable, |
|
value |
|
}); |
|
} |
|
} |
|
|
|
isContextual(token) { |
|
return this.state.type === token && !this.state.containsEsc; |
|
} |
|
|
|
isUnparsedContextual(nameStart, name) { |
|
const nameEnd = nameStart + name.length; |
|
|
|
if (this.input.slice(nameStart, nameEnd) === name) { |
|
const nextCh = this.input.charCodeAt(nameEnd); |
|
return !(isIdentifierChar(nextCh) || (nextCh & 0xfc00) === 0xd800); |
|
} |
|
|
|
return false; |
|
} |
|
|
|
isLookaheadContextual(name) { |
|
const next = this.nextTokenStart(); |
|
return this.isUnparsedContextual(next, name); |
|
} |
|
|
|
eatContextual(token) { |
|
if (this.isContextual(token)) { |
|
this.next(); |
|
return true; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
expectContextual(token, toParseError) { |
|
if (!this.eatContextual(token)) { |
|
if (toParseError != null) { |
|
throw this.raise(toParseError, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
|
|
throw this.unexpected(null, token); |
|
} |
|
} |
|
|
|
canInsertSemicolon() { |
|
return this.match(135) || this.match(8) || this.hasPrecedingLineBreak(); |
|
} |
|
|
|
hasPrecedingLineBreak() { |
|
return lineBreak.test(this.input.slice(this.state.lastTokEndLoc.index, this.state.start)); |
|
} |
|
|
|
hasFollowingLineBreak() { |
|
skipWhiteSpaceToLineBreak.lastIndex = this.state.end; |
|
return skipWhiteSpaceToLineBreak.test(this.input); |
|
} |
|
|
|
isLineTerminator() { |
|
return this.eat(13) || this.canInsertSemicolon(); |
|
} |
|
|
|
semicolon(allowAsi = true) { |
|
if (allowAsi ? this.isLineTerminator() : this.eat(13)) return; |
|
this.raise(Errors.MissingSemicolon, { |
|
at: this.state.lastTokEndLoc |
|
}); |
|
} |
|
|
|
expect(type, loc) { |
|
this.eat(type) || this.unexpected(loc, type); |
|
} |
|
|
|
tryParse(fn, oldState = this.state.clone()) { |
|
const abortSignal = { |
|
node: null |
|
}; |
|
|
|
try { |
|
const node = fn((node = null) => { |
|
abortSignal.node = node; |
|
throw abortSignal; |
|
}); |
|
|
|
if (this.state.errors.length > oldState.errors.length) { |
|
const failState = this.state; |
|
this.state = oldState; |
|
this.state.tokensLength = failState.tokensLength; |
|
return { |
|
node, |
|
error: failState.errors[oldState.errors.length], |
|
thrown: false, |
|
aborted: false, |
|
failState |
|
}; |
|
} |
|
|
|
return { |
|
node, |
|
error: null, |
|
thrown: false, |
|
aborted: false, |
|
failState: null |
|
}; |
|
} catch (error) { |
|
const failState = this.state; |
|
this.state = oldState; |
|
|
|
if (error instanceof SyntaxError) { |
|
return { |
|
node: null, |
|
error, |
|
thrown: true, |
|
aborted: false, |
|
failState |
|
}; |
|
} |
|
|
|
if (error === abortSignal) { |
|
return { |
|
node: abortSignal.node, |
|
error: null, |
|
thrown: false, |
|
aborted: true, |
|
failState |
|
}; |
|
} |
|
|
|
throw error; |
|
} |
|
} |
|
|
|
checkExpressionErrors(refExpressionErrors, andThrow) { |
|
if (!refExpressionErrors) return false; |
|
const { |
|
shorthandAssignLoc, |
|
doubleProtoLoc, |
|
privateKeyLoc, |
|
optionalParametersLoc |
|
} = refExpressionErrors; |
|
const hasErrors = !!shorthandAssignLoc || !!doubleProtoLoc || !!optionalParametersLoc || !!privateKeyLoc; |
|
|
|
if (!andThrow) { |
|
return hasErrors; |
|
} |
|
|
|
if (shorthandAssignLoc != null) { |
|
this.raise(Errors.InvalidCoverInitializedName, { |
|
at: shorthandAssignLoc |
|
}); |
|
} |
|
|
|
if (doubleProtoLoc != null) { |
|
this.raise(Errors.DuplicateProto, { |
|
at: doubleProtoLoc |
|
}); |
|
} |
|
|
|
if (privateKeyLoc != null) { |
|
this.raise(Errors.UnexpectedPrivateField, { |
|
at: privateKeyLoc |
|
}); |
|
} |
|
|
|
if (optionalParametersLoc != null) { |
|
this.unexpected(optionalParametersLoc); |
|
} |
|
} |
|
|
|
isLiteralPropertyName() { |
|
return tokenIsLiteralPropertyName(this.state.type); |
|
} |
|
|
|
isPrivateName(node) { |
|
return node.type === "PrivateName"; |
|
} |
|
|
|
getPrivateNameSV(node) { |
|
return node.id.name; |
|
} |
|
|
|
hasPropertyAsPrivateName(node) { |
|
return (node.type === "MemberExpression" || node.type === "OptionalMemberExpression") && this.isPrivateName(node.property); |
|
} |
|
|
|
isOptionalChain(node) { |
|
return node.type === "OptionalMemberExpression" || node.type === "OptionalCallExpression"; |
|
} |
|
|
|
isObjectProperty(node) { |
|
return node.type === "ObjectProperty"; |
|
} |
|
|
|
isObjectMethod(node) { |
|
return node.type === "ObjectMethod"; |
|
} |
|
|
|
initializeScopes(inModule = this.options.sourceType === "module") { |
|
const oldLabels = this.state.labels; |
|
this.state.labels = []; |
|
const oldExportedIdentifiers = this.exportedIdentifiers; |
|
this.exportedIdentifiers = new Set(); |
|
const oldInModule = this.inModule; |
|
this.inModule = inModule; |
|
const oldScope = this.scope; |
|
const ScopeHandler = this.getScopeHandler(); |
|
this.scope = new ScopeHandler(this, inModule); |
|
const oldProdParam = this.prodParam; |
|
this.prodParam = new ProductionParameterHandler(); |
|
const oldClassScope = this.classScope; |
|
this.classScope = new ClassScopeHandler(this); |
|
const oldExpressionScope = this.expressionScope; |
|
this.expressionScope = new ExpressionScopeHandler(this); |
|
return () => { |
|
this.state.labels = oldLabels; |
|
this.exportedIdentifiers = oldExportedIdentifiers; |
|
this.inModule = oldInModule; |
|
this.scope = oldScope; |
|
this.prodParam = oldProdParam; |
|
this.classScope = oldClassScope; |
|
this.expressionScope = oldExpressionScope; |
|
}; |
|
} |
|
|
|
enterInitialScopes() { |
|
let paramFlags = PARAM; |
|
|
|
if (this.inModule) { |
|
paramFlags |= PARAM_AWAIT; |
|
} |
|
|
|
this.scope.enter(SCOPE_PROGRAM); |
|
this.prodParam.enter(paramFlags); |
|
} |
|
|
|
checkDestructuringPrivate(refExpressionErrors) { |
|
const { |
|
privateKeyLoc |
|
} = refExpressionErrors; |
|
|
|
if (privateKeyLoc !== null) { |
|
this.expectPlugin("destructuringPrivate", privateKeyLoc); |
|
} |
|
} |
|
|
|
} |
|
class ExpressionErrors { |
|
constructor() { |
|
this.shorthandAssignLoc = null; |
|
this.doubleProtoLoc = null; |
|
this.privateKeyLoc = null; |
|
this.optionalParametersLoc = null; |
|
} |
|
|
|
} |
|
|
|
class Node { |
|
constructor(parser, pos, loc) { |
|
this.type = ""; |
|
this.start = pos; |
|
this.end = 0; |
|
this.loc = new SourceLocation(loc); |
|
if (parser != null && parser.options.ranges) this.range = [pos, 0]; |
|
if (parser != null && parser.filename) this.loc.filename = parser.filename; |
|
} |
|
|
|
} |
|
|
|
const NodePrototype = Node.prototype; |
|
{ |
|
NodePrototype.__clone = function () { |
|
const newNode = new Node(); |
|
const keys = Object.keys(this); |
|
|
|
for (let i = 0, length = keys.length; i < length; i++) { |
|
const key = keys[i]; |
|
|
|
if (key !== "leadingComments" && key !== "trailingComments" && key !== "innerComments") { |
|
newNode[key] = this[key]; |
|
} |
|
} |
|
|
|
return newNode; |
|
}; |
|
} |
|
|
|
function clonePlaceholder(node) { |
|
return cloneIdentifier(node); |
|
} |
|
|
|
function cloneIdentifier(node) { |
|
const { |
|
type, |
|
start, |
|
end, |
|
loc, |
|
range, |
|
extra, |
|
name |
|
} = node; |
|
const cloned = Object.create(NodePrototype); |
|
cloned.type = type; |
|
cloned.start = start; |
|
cloned.end = end; |
|
cloned.loc = loc; |
|
cloned.range = range; |
|
cloned.extra = extra; |
|
cloned.name = name; |
|
|
|
if (type === "Placeholder") { |
|
cloned.expectedNode = node.expectedNode; |
|
} |
|
|
|
return cloned; |
|
} |
|
function cloneStringLiteral(node) { |
|
const { |
|
type, |
|
start, |
|
end, |
|
loc, |
|
range, |
|
extra |
|
} = node; |
|
|
|
if (type === "Placeholder") { |
|
return clonePlaceholder(node); |
|
} |
|
|
|
const cloned = Object.create(NodePrototype); |
|
cloned.type = type; |
|
cloned.start = start; |
|
cloned.end = end; |
|
cloned.loc = loc; |
|
cloned.range = range; |
|
|
|
if (node.raw !== undefined) { |
|
cloned.raw = node.raw; |
|
} else { |
|
cloned.extra = extra; |
|
} |
|
|
|
cloned.value = node.value; |
|
return cloned; |
|
} |
|
class NodeUtils extends UtilParser { |
|
startNode() { |
|
return new Node(this, this.state.start, this.state.startLoc); |
|
} |
|
|
|
startNodeAt(pos, loc) { |
|
return new Node(this, pos, loc); |
|
} |
|
|
|
startNodeAtNode(type) { |
|
return this.startNodeAt(type.start, type.loc.start); |
|
} |
|
|
|
finishNode(node, type) { |
|
return this.finishNodeAt(node, type, this.state.lastTokEndLoc); |
|
} |
|
|
|
finishNodeAt(node, type, endLoc) { |
|
|
|
node.type = type; |
|
node.end = endLoc.index; |
|
node.loc.end = endLoc; |
|
if (this.options.ranges) node.range[1] = endLoc.index; |
|
if (this.options.attachComment) this.processComment(node); |
|
return node; |
|
} |
|
|
|
resetStartLocation(node, start, startLoc) { |
|
node.start = start; |
|
node.loc.start = startLoc; |
|
if (this.options.ranges) node.range[0] = start; |
|
} |
|
|
|
resetEndLocation(node, endLoc = this.state.lastTokEndLoc) { |
|
node.end = endLoc.index; |
|
node.loc.end = endLoc; |
|
if (this.options.ranges) node.range[1] = endLoc.index; |
|
} |
|
|
|
resetStartLocationFromNode(node, locationNode) { |
|
this.resetStartLocation(node, locationNode.start, locationNode.loc.start); |
|
} |
|
|
|
} |
|
|
|
const reservedTypes = new Set(["_", "any", "bool", "boolean", "empty", "extends", "false", "interface", "mixed", "null", "number", "static", "string", "true", "typeof", "void"]); |
|
const FlowErrors = ParseErrorEnum`flow`(_ => ({ |
|
AmbiguousConditionalArrow: _("Ambiguous expression: wrap the arrow functions in parentheses to disambiguate."), |
|
AmbiguousDeclareModuleKind: _("Found both `declare module.exports` and `declare export` in the same module. Modules can only have 1 since they are either an ES module or they are a CommonJS module."), |
|
AssignReservedType: _(({ |
|
reservedType |
|
}) => `Cannot overwrite reserved type ${reservedType}.`), |
|
DeclareClassElement: _("The `declare` modifier can only appear on class fields."), |
|
DeclareClassFieldInitializer: _("Initializers are not allowed in fields with the `declare` modifier."), |
|
DuplicateDeclareModuleExports: _("Duplicate `declare module.exports` statement."), |
|
EnumBooleanMemberNotInitialized: _(({ |
|
memberName, |
|
enumName |
|
}) => `Boolean enum members need to be initialized. Use either \`${memberName} = true,\` or \`${memberName} = false,\` in enum \`${enumName}\`.`), |
|
EnumDuplicateMemberName: _(({ |
|
memberName, |
|
enumName |
|
}) => `Enum member names need to be unique, but the name \`${memberName}\` has already been used before in enum \`${enumName}\`.`), |
|
EnumInconsistentMemberValues: _(({ |
|
enumName |
|
}) => `Enum \`${enumName}\` has inconsistent member initializers. Either use no initializers, or consistently use literals (either booleans, numbers, or strings) for all member initializers.`), |
|
EnumInvalidExplicitType: _(({ |
|
invalidEnumType, |
|
enumName |
|
}) => `Enum type \`${invalidEnumType}\` is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${enumName}\`.`), |
|
EnumInvalidExplicitTypeUnknownSupplied: _(({ |
|
enumName |
|
}) => `Supplied enum type is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${enumName}\`.`), |
|
EnumInvalidMemberInitializerPrimaryType: _(({ |
|
enumName, |
|
memberName, |
|
explicitType |
|
}) => `Enum \`${enumName}\` has type \`${explicitType}\`, so the initializer of \`${memberName}\` needs to be a ${explicitType} literal.`), |
|
EnumInvalidMemberInitializerSymbolType: _(({ |
|
enumName, |
|
memberName |
|
}) => `Symbol enum members cannot be initialized. Use \`${memberName},\` in enum \`${enumName}\`.`), |
|
EnumInvalidMemberInitializerUnknownType: _(({ |
|
enumName, |
|
memberName |
|
}) => `The enum member initializer for \`${memberName}\` needs to be a literal (either a boolean, number, or string) in enum \`${enumName}\`.`), |
|
EnumInvalidMemberName: _(({ |
|
enumName, |
|
memberName, |
|
suggestion |
|
}) => `Enum member names cannot start with lowercase 'a' through 'z'. Instead of using \`${memberName}\`, consider using \`${suggestion}\`, in enum \`${enumName}\`.`), |
|
EnumNumberMemberNotInitialized: _(({ |
|
enumName, |
|
memberName |
|
}) => `Number enum members need to be initialized, e.g. \`${memberName} = 1\` in enum \`${enumName}\`.`), |
|
EnumStringMemberInconsistentlyInitailized: _(({ |
|
enumName |
|
}) => `String enum members need to consistently either all use initializers, or use no initializers, in enum \`${enumName}\`.`), |
|
GetterMayNotHaveThisParam: _("A getter cannot have a `this` parameter."), |
|
ImportTypeShorthandOnlyInPureImport: _("The `type` and `typeof` keywords on named imports can only be used on regular `import` statements. It cannot be used with `import type` or `import typeof` statements."), |
|
InexactInsideExact: _("Explicit inexact syntax cannot appear inside an explicit exact object type."), |
|
InexactInsideNonObject: _("Explicit inexact syntax cannot appear in class or interface definitions."), |
|
InexactVariance: _("Explicit inexact syntax cannot have variance."), |
|
InvalidNonTypeImportInDeclareModule: _("Imports within a `declare module` body must always be `import type` or `import typeof`."), |
|
MissingTypeParamDefault: _("Type parameter declaration needs a default, since a preceding type parameter declaration has a default."), |
|
NestedDeclareModule: _("`declare module` cannot be used inside another `declare module`."), |
|
NestedFlowComment: _("Cannot have a flow comment inside another flow comment."), |
|
PatternIsOptional: _("A binding pattern parameter cannot be optional in an implementation signature.", { |
|
reasonCode: "OptionalBindingPattern" |
|
}), |
|
SetterMayNotHaveThisParam: _("A setter cannot have a `this` parameter."), |
|
SpreadVariance: _("Spread properties cannot have variance."), |
|
ThisParamAnnotationRequired: _("A type annotation is required for the `this` parameter."), |
|
ThisParamBannedInConstructor: _("Constructors cannot have a `this` parameter; constructors don't bind `this` like other functions."), |
|
ThisParamMayNotBeOptional: _("The `this` parameter cannot be optional."), |
|
ThisParamMustBeFirst: _("The `this` parameter must be the first function parameter."), |
|
ThisParamNoDefault: _("The `this` parameter may not have a default value."), |
|
TypeBeforeInitializer: _("Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`."), |
|
TypeCastInPattern: _("The type cast expression is expected to be wrapped with parenthesis."), |
|
UnexpectedExplicitInexactInObject: _("Explicit inexact syntax must appear at the end of an inexact object."), |
|
UnexpectedReservedType: _(({ |
|
reservedType |
|
}) => `Unexpected reserved type ${reservedType}.`), |
|
UnexpectedReservedUnderscore: _("`_` is only allowed as a type argument to call or new."), |
|
UnexpectedSpaceBetweenModuloChecks: _("Spaces between `%` and `checks` are not allowed here."), |
|
UnexpectedSpreadType: _("Spread operator cannot appear in class or interface definitions."), |
|
UnexpectedSubtractionOperand: _('Unexpected token, expected "number" or "bigint".'), |
|
UnexpectedTokenAfterTypeParameter: _("Expected an arrow function after this type parameter declaration."), |
|
UnexpectedTypeParameterBeforeAsyncArrowFunction: _("Type parameters must come after the async keyword, e.g. instead of `<T> async () => {}`, use `async <T>() => {}`."), |
|
UnsupportedDeclareExportKind: _(({ |
|
unsupportedExportKind, |
|
suggestion |
|
}) => `\`declare export ${unsupportedExportKind}\` is not supported. Use \`${suggestion}\` instead.`), |
|
UnsupportedStatementInDeclareModule: _("Only declares and type imports are allowed inside declare module."), |
|
UnterminatedFlowComment: _("Unterminated flow-comment.") |
|
})); |
|
|
|
function isEsModuleType(bodyElement) { |
|
return bodyElement.type === "DeclareExportAllDeclaration" || bodyElement.type === "DeclareExportDeclaration" && (!bodyElement.declaration || bodyElement.declaration.type !== "TypeAlias" && bodyElement.declaration.type !== "InterfaceDeclaration"); |
|
} |
|
|
|
function hasTypeImportKind(node) { |
|
return node.importKind === "type" || node.importKind === "typeof"; |
|
} |
|
|
|
function isMaybeDefaultImport(type) { |
|
return tokenIsKeywordOrIdentifier(type) && type !== 97; |
|
} |
|
|
|
const exportSuggestions = { |
|
const: "declare export var", |
|
let: "declare export var", |
|
type: "export type", |
|
interface: "export interface" |
|
}; |
|
|
|
function partition(list, test) { |
|
const list1 = []; |
|
const list2 = []; |
|
|
|
for (let i = 0; i < list.length; i++) { |
|
(test(list[i], i, list) ? list1 : list2).push(list[i]); |
|
} |
|
|
|
return [list1, list2]; |
|
} |
|
|
|
const FLOW_PRAGMA_REGEX = /\*?\s*@((?:no)?flow)\b/; |
|
var flow = (superClass => class extends superClass { |
|
constructor(...args) { |
|
super(...args); |
|
this.flowPragma = undefined; |
|
} |
|
|
|
getScopeHandler() { |
|
return FlowScopeHandler; |
|
} |
|
|
|
shouldParseTypes() { |
|
return this.getPluginOption("flow", "all") || this.flowPragma === "flow"; |
|
} |
|
|
|
shouldParseEnums() { |
|
return !!this.getPluginOption("flow", "enums"); |
|
} |
|
|
|
finishToken(type, val) { |
|
if (type !== 129 && type !== 13 && type !== 28) { |
|
if (this.flowPragma === undefined) { |
|
this.flowPragma = null; |
|
} |
|
} |
|
|
|
return super.finishToken(type, val); |
|
} |
|
|
|
addComment(comment) { |
|
if (this.flowPragma === undefined) { |
|
const matches = FLOW_PRAGMA_REGEX.exec(comment.value); |
|
|
|
if (!matches) ; else if (matches[1] === "flow") { |
|
this.flowPragma = "flow"; |
|
} else if (matches[1] === "noflow") { |
|
this.flowPragma = "noflow"; |
|
} else { |
|
throw new Error("Unexpected flow pragma"); |
|
} |
|
} |
|
|
|
return super.addComment(comment); |
|
} |
|
|
|
flowParseTypeInitialiser(tok) { |
|
const oldInType = this.state.inType; |
|
this.state.inType = true; |
|
this.expect(tok || 14); |
|
const type = this.flowParseType(); |
|
this.state.inType = oldInType; |
|
return type; |
|
} |
|
|
|
flowParsePredicate() { |
|
const node = this.startNode(); |
|
const moduloLoc = this.state.startLoc; |
|
this.next(); |
|
this.expectContextual(107); |
|
|
|
if (this.state.lastTokStart > moduloLoc.index + 1) { |
|
this.raise(FlowErrors.UnexpectedSpaceBetweenModuloChecks, { |
|
at: moduloLoc |
|
}); |
|
} |
|
|
|
if (this.eat(10)) { |
|
node.value = this.parseExpression(); |
|
this.expect(11); |
|
return this.finishNode(node, "DeclaredPredicate"); |
|
} else { |
|
return this.finishNode(node, "InferredPredicate"); |
|
} |
|
} |
|
|
|
flowParseTypeAndPredicateInitialiser() { |
|
const oldInType = this.state.inType; |
|
this.state.inType = true; |
|
this.expect(14); |
|
let type = null; |
|
let predicate = null; |
|
|
|
if (this.match(54)) { |
|
this.state.inType = oldInType; |
|
predicate = this.flowParsePredicate(); |
|
} else { |
|
type = this.flowParseType(); |
|
this.state.inType = oldInType; |
|
|
|
if (this.match(54)) { |
|
predicate = this.flowParsePredicate(); |
|
} |
|
} |
|
|
|
return [type, predicate]; |
|
} |
|
|
|
flowParseDeclareClass(node) { |
|
this.next(); |
|
this.flowParseInterfaceish(node, true); |
|
return this.finishNode(node, "DeclareClass"); |
|
} |
|
|
|
flowParseDeclareFunction(node) { |
|
this.next(); |
|
const id = node.id = this.parseIdentifier(); |
|
const typeNode = this.startNode(); |
|
const typeContainer = this.startNode(); |
|
|
|
if (this.match(47)) { |
|
typeNode.typeParameters = this.flowParseTypeParameterDeclaration(); |
|
} else { |
|
typeNode.typeParameters = null; |
|
} |
|
|
|
this.expect(10); |
|
const tmp = this.flowParseFunctionTypeParams(); |
|
typeNode.params = tmp.params; |
|
typeNode.rest = tmp.rest; |
|
typeNode.this = tmp._this; |
|
this.expect(11); |
|
[typeNode.returnType, node.predicate] = this.flowParseTypeAndPredicateInitialiser(); |
|
typeContainer.typeAnnotation = this.finishNode(typeNode, "FunctionTypeAnnotation"); |
|
id.typeAnnotation = this.finishNode(typeContainer, "TypeAnnotation"); |
|
this.resetEndLocation(id); |
|
this.semicolon(); |
|
this.scope.declareName(node.id.name, BIND_FLOW_DECLARE_FN, node.id.loc.start); |
|
return this.finishNode(node, "DeclareFunction"); |
|
} |
|
|
|
flowParseDeclare(node, insideModule) { |
|
if (this.match(80)) { |
|
return this.flowParseDeclareClass(node); |
|
} else if (this.match(68)) { |
|
return this.flowParseDeclareFunction(node); |
|
} else if (this.match(74)) { |
|
return this.flowParseDeclareVariable(node); |
|
} else if (this.eatContextual(123)) { |
|
if (this.match(16)) { |
|
return this.flowParseDeclareModuleExports(node); |
|
} else { |
|
if (insideModule) { |
|
this.raise(FlowErrors.NestedDeclareModule, { |
|
at: this.state.lastTokStartLoc |
|
}); |
|
} |
|
|
|
return this.flowParseDeclareModule(node); |
|
} |
|
} else if (this.isContextual(126)) { |
|
return this.flowParseDeclareTypeAlias(node); |
|
} else if (this.isContextual(127)) { |
|
return this.flowParseDeclareOpaqueType(node); |
|
} else if (this.isContextual(125)) { |
|
return this.flowParseDeclareInterface(node); |
|
} else if (this.match(82)) { |
|
return this.flowParseDeclareExportDeclaration(node, insideModule); |
|
} else { |
|
throw this.unexpected(); |
|
} |
|
} |
|
|
|
flowParseDeclareVariable(node) { |
|
this.next(); |
|
node.id = this.flowParseTypeAnnotatableIdentifier(true); |
|
this.scope.declareName(node.id.name, BIND_VAR, node.id.loc.start); |
|
this.semicolon(); |
|
return this.finishNode(node, "DeclareVariable"); |
|
} |
|
|
|
flowParseDeclareModule(node) { |
|
this.scope.enter(SCOPE_OTHER); |
|
|
|
if (this.match(129)) { |
|
node.id = this.parseExprAtom(); |
|
} else { |
|
node.id = this.parseIdentifier(); |
|
} |
|
|
|
const bodyNode = node.body = this.startNode(); |
|
const body = bodyNode.body = []; |
|
this.expect(5); |
|
|
|
while (!this.match(8)) { |
|
let bodyNode = this.startNode(); |
|
|
|
if (this.match(83)) { |
|
this.next(); |
|
|
|
if (!this.isContextual(126) && !this.match(87)) { |
|
this.raise(FlowErrors.InvalidNonTypeImportInDeclareModule, { |
|
at: this.state.lastTokStartLoc |
|
}); |
|
} |
|
|
|
this.parseImport(bodyNode); |
|
} else { |
|
this.expectContextual(121, FlowErrors.UnsupportedStatementInDeclareModule); |
|
bodyNode = this.flowParseDeclare(bodyNode, true); |
|
} |
|
|
|
body.push(bodyNode); |
|
} |
|
|
|
this.scope.exit(); |
|
this.expect(8); |
|
this.finishNode(bodyNode, "BlockStatement"); |
|
let kind = null; |
|
let hasModuleExport = false; |
|
body.forEach(bodyElement => { |
|
if (isEsModuleType(bodyElement)) { |
|
if (kind === "CommonJS") { |
|
this.raise(FlowErrors.AmbiguousDeclareModuleKind, { |
|
at: bodyElement |
|
}); |
|
} |
|
|
|
kind = "ES"; |
|
} else if (bodyElement.type === "DeclareModuleExports") { |
|
if (hasModuleExport) { |
|
this.raise(FlowErrors.DuplicateDeclareModuleExports, { |
|
at: bodyElement |
|
}); |
|
} |
|
|
|
if (kind === "ES") { |
|
this.raise(FlowErrors.AmbiguousDeclareModuleKind, { |
|
at: bodyElement |
|
}); |
|
} |
|
|
|
kind = "CommonJS"; |
|
hasModuleExport = true; |
|
} |
|
}); |
|
node.kind = kind || "CommonJS"; |
|
return this.finishNode(node, "DeclareModule"); |
|
} |
|
|
|
flowParseDeclareExportDeclaration(node, insideModule) { |
|
this.expect(82); |
|
|
|
if (this.eat(65)) { |
|
if (this.match(68) || this.match(80)) { |
|
node.declaration = this.flowParseDeclare(this.startNode()); |
|
} else { |
|
node.declaration = this.flowParseType(); |
|
this.semicolon(); |
|
} |
|
|
|
node.default = true; |
|
return this.finishNode(node, "DeclareExportDeclaration"); |
|
} else { |
|
if (this.match(75) || this.isLet() || (this.isContextual(126) || this.isContextual(125)) && !insideModule) { |
|
const label = this.state.value; |
|
throw this.raise(FlowErrors.UnsupportedDeclareExportKind, { |
|
at: this.state.startLoc, |
|
unsupportedExportKind: label, |
|
suggestion: exportSuggestions[label] |
|
}); |
|
} |
|
|
|
if (this.match(74) || this.match(68) || this.match(80) || this.isContextual(127)) { |
|
node.declaration = this.flowParseDeclare(this.startNode()); |
|
node.default = false; |
|
return this.finishNode(node, "DeclareExportDeclaration"); |
|
} else if (this.match(55) || this.match(5) || this.isContextual(125) || this.isContextual(126) || this.isContextual(127)) { |
|
node = this.parseExport(node); |
|
|
|
if (node.type === "ExportNamedDeclaration") { |
|
node.type = "ExportDeclaration"; |
|
node.default = false; |
|
delete node.exportKind; |
|
} |
|
|
|
node.type = "Declare" + node.type; |
|
return node; |
|
} |
|
} |
|
|
|
throw this.unexpected(); |
|
} |
|
|
|
flowParseDeclareModuleExports(node) { |
|
this.next(); |
|
this.expectContextual(108); |
|
node.typeAnnotation = this.flowParseTypeAnnotation(); |
|
this.semicolon(); |
|
return this.finishNode(node, "DeclareModuleExports"); |
|
} |
|
|
|
flowParseDeclareTypeAlias(node) { |
|
this.next(); |
|
this.flowParseTypeAlias(node); |
|
node.type = "DeclareTypeAlias"; |
|
return node; |
|
} |
|
|
|
flowParseDeclareOpaqueType(node) { |
|
this.next(); |
|
this.flowParseOpaqueType(node, true); |
|
node.type = "DeclareOpaqueType"; |
|
return node; |
|
} |
|
|
|
flowParseDeclareInterface(node) { |
|
this.next(); |
|
this.flowParseInterfaceish(node); |
|
return this.finishNode(node, "DeclareInterface"); |
|
} |
|
|
|
flowParseInterfaceish(node, isClass = false) { |
|
node.id = this.flowParseRestrictedIdentifier(!isClass, true); |
|
this.scope.declareName(node.id.name, isClass ? BIND_FUNCTION : BIND_LEXICAL, node.id.loc.start); |
|
|
|
if (this.match(47)) { |
|
node.typeParameters = this.flowParseTypeParameterDeclaration(); |
|
} else { |
|
node.typeParameters = null; |
|
} |
|
|
|
node.extends = []; |
|
node.implements = []; |
|
node.mixins = []; |
|
|
|
if (this.eat(81)) { |
|
do { |
|
node.extends.push(this.flowParseInterfaceExtends()); |
|
} while (!isClass && this.eat(12)); |
|
} |
|
|
|
if (this.isContextual(114)) { |
|
this.next(); |
|
|
|
do { |
|
node.mixins.push(this.flowParseInterfaceExtends()); |
|
} while (this.eat(12)); |
|
} |
|
|
|
if (this.isContextual(110)) { |
|
this.next(); |
|
|
|
do { |
|
node.implements.push(this.flowParseInterfaceExtends()); |
|
} while (this.eat(12)); |
|
} |
|
|
|
node.body = this.flowParseObjectType({ |
|
allowStatic: isClass, |
|
allowExact: false, |
|
allowSpread: false, |
|
allowProto: isClass, |
|
allowInexact: false |
|
}); |
|
} |
|
|
|
flowParseInterfaceExtends() { |
|
const node = this.startNode(); |
|
node.id = this.flowParseQualifiedTypeIdentifier(); |
|
|
|
if (this.match(47)) { |
|
node.typeParameters = this.flowParseTypeParameterInstantiation(); |
|
} else { |
|
node.typeParameters = null; |
|
} |
|
|
|
return this.finishNode(node, "InterfaceExtends"); |
|
} |
|
|
|
flowParseInterface(node) { |
|
this.flowParseInterfaceish(node); |
|
return this.finishNode(node, "InterfaceDeclaration"); |
|
} |
|
|
|
checkNotUnderscore(word) { |
|
if (word === "_") { |
|
this.raise(FlowErrors.UnexpectedReservedUnderscore, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
} |
|
|
|
checkReservedType(word, startLoc, declaration) { |
|
if (!reservedTypes.has(word)) return; |
|
this.raise(declaration ? FlowErrors.AssignReservedType : FlowErrors.UnexpectedReservedType, { |
|
at: startLoc, |
|
reservedType: word |
|
}); |
|
} |
|
|
|
flowParseRestrictedIdentifier(liberal, declaration) { |
|
this.checkReservedType(this.state.value, this.state.startLoc, declaration); |
|
return this.parseIdentifier(liberal); |
|
} |
|
|
|
flowParseTypeAlias(node) { |
|
node.id = this.flowParseRestrictedIdentifier(false, true); |
|
this.scope.declareName(node.id.name, BIND_LEXICAL, node.id.loc.start); |
|
|
|
if (this.match(47)) { |
|
node.typeParameters = this.flowParseTypeParameterDeclaration(); |
|
} else { |
|
node.typeParameters = null; |
|
} |
|
|
|
node.right = this.flowParseTypeInitialiser(29); |
|
this.semicolon(); |
|
return this.finishNode(node, "TypeAlias"); |
|
} |
|
|
|
flowParseOpaqueType(node, declare) { |
|
this.expectContextual(126); |
|
node.id = this.flowParseRestrictedIdentifier(true, true); |
|
this.scope.declareName(node.id.name, BIND_LEXICAL, node.id.loc.start); |
|
|
|
if (this.match(47)) { |
|
node.typeParameters = this.flowParseTypeParameterDeclaration(); |
|
} else { |
|
node.typeParameters = null; |
|
} |
|
|
|
node.supertype = null; |
|
|
|
if (this.match(14)) { |
|
node.supertype = this.flowParseTypeInitialiser(14); |
|
} |
|
|
|
node.impltype = null; |
|
|
|
if (!declare) { |
|
node.impltype = this.flowParseTypeInitialiser(29); |
|
} |
|
|
|
this.semicolon(); |
|
return this.finishNode(node, "OpaqueType"); |
|
} |
|
|
|
flowParseTypeParameter(requireDefault = false) { |
|
const nodeStartLoc = this.state.startLoc; |
|
const node = this.startNode(); |
|
const variance = this.flowParseVariance(); |
|
const ident = this.flowParseTypeAnnotatableIdentifier(); |
|
node.name = ident.name; |
|
node.variance = variance; |
|
node.bound = ident.typeAnnotation; |
|
|
|
if (this.match(29)) { |
|
this.eat(29); |
|
node.default = this.flowParseType(); |
|
} else { |
|
if (requireDefault) { |
|
this.raise(FlowErrors.MissingTypeParamDefault, { |
|
at: nodeStartLoc |
|
}); |
|
} |
|
} |
|
|
|
return this.finishNode(node, "TypeParameter"); |
|
} |
|
|
|
flowParseTypeParameterDeclaration() { |
|
const oldInType = this.state.inType; |
|
const node = this.startNode(); |
|
node.params = []; |
|
this.state.inType = true; |
|
|
|
if (this.match(47) || this.match(138)) { |
|
this.next(); |
|
} else { |
|
this.unexpected(); |
|
} |
|
|
|
let defaultRequired = false; |
|
|
|
do { |
|
const typeParameter = this.flowParseTypeParameter(defaultRequired); |
|
node.params.push(typeParameter); |
|
|
|
if (typeParameter.default) { |
|
defaultRequired = true; |
|
} |
|
|
|
if (!this.match(48)) { |
|
this.expect(12); |
|
} |
|
} while (!this.match(48)); |
|
|
|
this.expect(48); |
|
this.state.inType = oldInType; |
|
return this.finishNode(node, "TypeParameterDeclaration"); |
|
} |
|
|
|
flowParseTypeParameterInstantiation() { |
|
const node = this.startNode(); |
|
const oldInType = this.state.inType; |
|
node.params = []; |
|
this.state.inType = true; |
|
this.expect(47); |
|
const oldNoAnonFunctionType = this.state.noAnonFunctionType; |
|
this.state.noAnonFunctionType = false; |
|
|
|
while (!this.match(48)) { |
|
node.params.push(this.flowParseType()); |
|
|
|
if (!this.match(48)) { |
|
this.expect(12); |
|
} |
|
} |
|
|
|
this.state.noAnonFunctionType = oldNoAnonFunctionType; |
|
this.expect(48); |
|
this.state.inType = oldInType; |
|
return this.finishNode(node, "TypeParameterInstantiation"); |
|
} |
|
|
|
flowParseTypeParameterInstantiationCallOrNew() { |
|
const node = this.startNode(); |
|
const oldInType = this.state.inType; |
|
node.params = []; |
|
this.state.inType = true; |
|
this.expect(47); |
|
|
|
while (!this.match(48)) { |
|
node.params.push(this.flowParseTypeOrImplicitInstantiation()); |
|
|
|
if (!this.match(48)) { |
|
this.expect(12); |
|
} |
|
} |
|
|
|
this.expect(48); |
|
this.state.inType = oldInType; |
|
return this.finishNode(node, "TypeParameterInstantiation"); |
|
} |
|
|
|
flowParseInterfaceType() { |
|
const node = this.startNode(); |
|
this.expectContextual(125); |
|
node.extends = []; |
|
|
|
if (this.eat(81)) { |
|
do { |
|
node.extends.push(this.flowParseInterfaceExtends()); |
|
} while (this.eat(12)); |
|
} |
|
|
|
node.body = this.flowParseObjectType({ |
|
allowStatic: false, |
|
allowExact: false, |
|
allowSpread: false, |
|
allowProto: false, |
|
allowInexact: false |
|
}); |
|
return this.finishNode(node, "InterfaceTypeAnnotation"); |
|
} |
|
|
|
flowParseObjectPropertyKey() { |
|
return this.match(130) || this.match(129) ? this.parseExprAtom() : this.parseIdentifier(true); |
|
} |
|
|
|
flowParseObjectTypeIndexer(node, isStatic, variance) { |
|
node.static = isStatic; |
|
|
|
if (this.lookahead().type === 14) { |
|
node.id = this.flowParseObjectPropertyKey(); |
|
node.key = this.flowParseTypeInitialiser(); |
|
} else { |
|
node.id = null; |
|
node.key = this.flowParseType(); |
|
} |
|
|
|
this.expect(3); |
|
node.value = this.flowParseTypeInitialiser(); |
|
node.variance = variance; |
|
return this.finishNode(node, "ObjectTypeIndexer"); |
|
} |
|
|
|
flowParseObjectTypeInternalSlot(node, isStatic) { |
|
node.static = isStatic; |
|
node.id = this.flowParseObjectPropertyKey(); |
|
this.expect(3); |
|
this.expect(3); |
|
|
|
if (this.match(47) || this.match(10)) { |
|
node.method = true; |
|
node.optional = false; |
|
node.value = this.flowParseObjectTypeMethodish(this.startNodeAt(node.start, node.loc.start)); |
|
} else { |
|
node.method = false; |
|
|
|
if (this.eat(17)) { |
|
node.optional = true; |
|
} |
|
|
|
node.value = this.flowParseTypeInitialiser(); |
|
} |
|
|
|
return this.finishNode(node, "ObjectTypeInternalSlot"); |
|
} |
|
|
|
flowParseObjectTypeMethodish(node) { |
|
node.params = []; |
|
node.rest = null; |
|
node.typeParameters = null; |
|
node.this = null; |
|
|
|
if (this.match(47)) { |
|
node.typeParameters = this.flowParseTypeParameterDeclaration(); |
|
} |
|
|
|
this.expect(10); |
|
|
|
if (this.match(78)) { |
|
node.this = this.flowParseFunctionTypeParam(true); |
|
node.this.name = null; |
|
|
|
if (!this.match(11)) { |
|
this.expect(12); |
|
} |
|
} |
|
|
|
while (!this.match(11) && !this.match(21)) { |
|
node.params.push(this.flowParseFunctionTypeParam(false)); |
|
|
|
if (!this.match(11)) { |
|
this.expect(12); |
|
} |
|
} |
|
|
|
if (this.eat(21)) { |
|
node.rest = this.flowParseFunctionTypeParam(false); |
|
} |
|
|
|
this.expect(11); |
|
node.returnType = this.flowParseTypeInitialiser(); |
|
return this.finishNode(node, "FunctionTypeAnnotation"); |
|
} |
|
|
|
flowParseObjectTypeCallProperty(node, isStatic) { |
|
const valueNode = this.startNode(); |
|
node.static = isStatic; |
|
node.value = this.flowParseObjectTypeMethodish(valueNode); |
|
return this.finishNode(node, "ObjectTypeCallProperty"); |
|
} |
|
|
|
flowParseObjectType({ |
|
allowStatic, |
|
allowExact, |
|
allowSpread, |
|
allowProto, |
|
allowInexact |
|
}) { |
|
const oldInType = this.state.inType; |
|
this.state.inType = true; |
|
const nodeStart = this.startNode(); |
|
nodeStart.callProperties = []; |
|
nodeStart.properties = []; |
|
nodeStart.indexers = []; |
|
nodeStart.internalSlots = []; |
|
let endDelim; |
|
let exact; |
|
let inexact = false; |
|
|
|
if (allowExact && this.match(6)) { |
|
this.expect(6); |
|
endDelim = 9; |
|
exact = true; |
|
} else { |
|
this.expect(5); |
|
endDelim = 8; |
|
exact = false; |
|
} |
|
|
|
nodeStart.exact = exact; |
|
|
|
while (!this.match(endDelim)) { |
|
let isStatic = false; |
|
let protoStartLoc = null; |
|
let inexactStartLoc = null; |
|
const node = this.startNode(); |
|
|
|
if (allowProto && this.isContextual(115)) { |
|
const lookahead = this.lookahead(); |
|
|
|
if (lookahead.type !== 14 && lookahead.type !== 17) { |
|
this.next(); |
|
protoStartLoc = this.state.startLoc; |
|
allowStatic = false; |
|
} |
|
} |
|
|
|
if (allowStatic && this.isContextual(104)) { |
|
const lookahead = this.lookahead(); |
|
|
|
if (lookahead.type !== 14 && lookahead.type !== 17) { |
|
this.next(); |
|
isStatic = true; |
|
} |
|
} |
|
|
|
const variance = this.flowParseVariance(); |
|
|
|
if (this.eat(0)) { |
|
if (protoStartLoc != null) { |
|
this.unexpected(protoStartLoc); |
|
} |
|
|
|
if (this.eat(0)) { |
|
if (variance) { |
|
this.unexpected(variance.loc.start); |
|
} |
|
|
|
nodeStart.internalSlots.push(this.flowParseObjectTypeInternalSlot(node, isStatic)); |
|
} else { |
|
nodeStart.indexers.push(this.flowParseObjectTypeIndexer(node, isStatic, variance)); |
|
} |
|
} else if (this.match(10) || this.match(47)) { |
|
if (protoStartLoc != null) { |
|
this.unexpected(protoStartLoc); |
|
} |
|
|
|
if (variance) { |
|
this.unexpected(variance.loc.start); |
|
} |
|
|
|
nodeStart.callProperties.push(this.flowParseObjectTypeCallProperty(node, isStatic)); |
|
} else { |
|
let kind = "init"; |
|
|
|
if (this.isContextual(98) || this.isContextual(103)) { |
|
const lookahead = this.lookahead(); |
|
|
|
if (tokenIsLiteralPropertyName(lookahead.type)) { |
|
kind = this.state.value; |
|
this.next(); |
|
} |
|
} |
|
|
|
const propOrInexact = this.flowParseObjectTypeProperty(node, isStatic, protoStartLoc, variance, kind, allowSpread, allowInexact != null ? allowInexact : !exact); |
|
|
|
if (propOrInexact === null) { |
|
inexact = true; |
|
inexactStartLoc = this.state.lastTokStartLoc; |
|
} else { |
|
nodeStart.properties.push(propOrInexact); |
|
} |
|
} |
|
|
|
this.flowObjectTypeSemicolon(); |
|
|
|
if (inexactStartLoc && !this.match(8) && !this.match(9)) { |
|
this.raise(FlowErrors.UnexpectedExplicitInexactInObject, { |
|
at: inexactStartLoc |
|
}); |
|
} |
|
} |
|
|
|
this.expect(endDelim); |
|
|
|
if (allowSpread) { |
|
nodeStart.inexact = inexact; |
|
} |
|
|
|
const out = this.finishNode(nodeStart, "ObjectTypeAnnotation"); |
|
this.state.inType = oldInType; |
|
return out; |
|
} |
|
|
|
flowParseObjectTypeProperty(node, isStatic, protoStartLoc, variance, kind, allowSpread, allowInexact) { |
|
if (this.eat(21)) { |
|
const isInexactToken = this.match(12) || this.match(13) || this.match(8) || this.match(9); |
|
|
|
if (isInexactToken) { |
|
if (!allowSpread) { |
|
this.raise(FlowErrors.InexactInsideNonObject, { |
|
at: this.state.lastTokStartLoc |
|
}); |
|
} else if (!allowInexact) { |
|
this.raise(FlowErrors.InexactInsideExact, { |
|
at: this.state.lastTokStartLoc |
|
}); |
|
} |
|
|
|
if (variance) { |
|
this.raise(FlowErrors.InexactVariance, { |
|
at: variance |
|
}); |
|
} |
|
|
|
return null; |
|
} |
|
|
|
if (!allowSpread) { |
|
this.raise(FlowErrors.UnexpectedSpreadType, { |
|
at: this.state.lastTokStartLoc |
|
}); |
|
} |
|
|
|
if (protoStartLoc != null) { |
|
this.unexpected(protoStartLoc); |
|
} |
|
|
|
if (variance) { |
|
this.raise(FlowErrors.SpreadVariance, { |
|
at: variance |
|
}); |
|
} |
|
|
|
node.argument = this.flowParseType(); |
|
return this.finishNode(node, "ObjectTypeSpreadProperty"); |
|
} else { |
|
node.key = this.flowParseObjectPropertyKey(); |
|
node.static = isStatic; |
|
node.proto = protoStartLoc != null; |
|
node.kind = kind; |
|
let optional = false; |
|
|
|
if (this.match(47) || this.match(10)) { |
|
node.method = true; |
|
|
|
if (protoStartLoc != null) { |
|
this.unexpected(protoStartLoc); |
|
} |
|
|
|
if (variance) { |
|
this.unexpected(variance.loc.start); |
|
} |
|
|
|
node.value = this.flowParseObjectTypeMethodish(this.startNodeAt(node.start, node.loc.start)); |
|
|
|
if (kind === "get" || kind === "set") { |
|
this.flowCheckGetterSetterParams(node); |
|
} |
|
|
|
if (!allowSpread && node.key.name === "constructor" && node.value.this) { |
|
this.raise(FlowErrors.ThisParamBannedInConstructor, { |
|
at: node.value.this |
|
}); |
|
} |
|
} else { |
|
if (kind !== "init") this.unexpected(); |
|
node.method = false; |
|
|
|
if (this.eat(17)) { |
|
optional = true; |
|
} |
|
|
|
node.value = this.flowParseTypeInitialiser(); |
|
node.variance = variance; |
|
} |
|
|
|
node.optional = optional; |
|
return this.finishNode(node, "ObjectTypeProperty"); |
|
} |
|
} |
|
|
|
flowCheckGetterSetterParams(property) { |
|
const paramCount = property.kind === "get" ? 0 : 1; |
|
const length = property.value.params.length + (property.value.rest ? 1 : 0); |
|
|
|
if (property.value.this) { |
|
this.raise(property.kind === "get" ? FlowErrors.GetterMayNotHaveThisParam : FlowErrors.SetterMayNotHaveThisParam, { |
|
at: property.value.this |
|
}); |
|
} |
|
|
|
if (length !== paramCount) { |
|
this.raise(property.kind === "get" ? Errors.BadGetterArity : Errors.BadSetterArity, { |
|
at: property |
|
}); |
|
} |
|
|
|
if (property.kind === "set" && property.value.rest) { |
|
this.raise(Errors.BadSetterRestParameter, { |
|
at: property |
|
}); |
|
} |
|
} |
|
|
|
flowObjectTypeSemicolon() { |
|
if (!this.eat(13) && !this.eat(12) && !this.match(8) && !this.match(9)) { |
|
this.unexpected(); |
|
} |
|
} |
|
|
|
flowParseQualifiedTypeIdentifier(startPos, startLoc, id) { |
|
startPos = startPos || this.state.start; |
|
startLoc = startLoc || this.state.startLoc; |
|
let node = id || this.flowParseRestrictedIdentifier(true); |
|
|
|
while (this.eat(16)) { |
|
const node2 = this.startNodeAt(startPos, startLoc); |
|
node2.qualification = node; |
|
node2.id = this.flowParseRestrictedIdentifier(true); |
|
node = this.finishNode(node2, "QualifiedTypeIdentifier"); |
|
} |
|
|
|
return node; |
|
} |
|
|
|
flowParseGenericType(startPos, startLoc, id) { |
|
const node = this.startNodeAt(startPos, startLoc); |
|
node.typeParameters = null; |
|
node.id = this.flowParseQualifiedTypeIdentifier(startPos, startLoc, id); |
|
|
|
if (this.match(47)) { |
|
node.typeParameters = this.flowParseTypeParameterInstantiation(); |
|
} |
|
|
|
return this.finishNode(node, "GenericTypeAnnotation"); |
|
} |
|
|
|
flowParseTypeofType() { |
|
const node = this.startNode(); |
|
this.expect(87); |
|
node.argument = this.flowParsePrimaryType(); |
|
return this.finishNode(node, "TypeofTypeAnnotation"); |
|
} |
|
|
|
flowParseTupleType() { |
|
const node = this.startNode(); |
|
node.types = []; |
|
this.expect(0); |
|
|
|
while (this.state.pos < this.length && !this.match(3)) { |
|
node.types.push(this.flowParseType()); |
|
if (this.match(3)) break; |
|
this.expect(12); |
|
} |
|
|
|
this.expect(3); |
|
return this.finishNode(node, "TupleTypeAnnotation"); |
|
} |
|
|
|
flowParseFunctionTypeParam(first) { |
|
let name = null; |
|
let optional = false; |
|
let typeAnnotation = null; |
|
const node = this.startNode(); |
|
const lh = this.lookahead(); |
|
const isThis = this.state.type === 78; |
|
|
|
if (lh.type === 14 || lh.type === 17) { |
|
if (isThis && !first) { |
|
this.raise(FlowErrors.ThisParamMustBeFirst, { |
|
at: node |
|
}); |
|
} |
|
|
|
name = this.parseIdentifier(isThis); |
|
|
|
if (this.eat(17)) { |
|
optional = true; |
|
|
|
if (isThis) { |
|
this.raise(FlowErrors.ThisParamMayNotBeOptional, { |
|
at: node |
|
}); |
|
} |
|
} |
|
|
|
typeAnnotation = this.flowParseTypeInitialiser(); |
|
} else { |
|
typeAnnotation = this.flowParseType(); |
|
} |
|
|
|
node.name = name; |
|
node.optional = optional; |
|
node.typeAnnotation = typeAnnotation; |
|
return this.finishNode(node, "FunctionTypeParam"); |
|
} |
|
|
|
reinterpretTypeAsFunctionTypeParam(type) { |
|
const node = this.startNodeAt(type.start, type.loc.start); |
|
node.name = null; |
|
node.optional = false; |
|
node.typeAnnotation = type; |
|
return this.finishNode(node, "FunctionTypeParam"); |
|
} |
|
|
|
flowParseFunctionTypeParams(params = []) { |
|
let rest = null; |
|
let _this = null; |
|
|
|
if (this.match(78)) { |
|
_this = this.flowParseFunctionTypeParam(true); |
|
_this.name = null; |
|
|
|
if (!this.match(11)) { |
|
this.expect(12); |
|
} |
|
} |
|
|
|
while (!this.match(11) && !this.match(21)) { |
|
params.push(this.flowParseFunctionTypeParam(false)); |
|
|
|
if (!this.match(11)) { |
|
this.expect(12); |
|
} |
|
} |
|
|
|
if (this.eat(21)) { |
|
rest = this.flowParseFunctionTypeParam(false); |
|
} |
|
|
|
return { |
|
params, |
|
rest, |
|
_this |
|
}; |
|
} |
|
|
|
flowIdentToTypeAnnotation(startPos, startLoc, node, id) { |
|
switch (id.name) { |
|
case "any": |
|
return this.finishNode(node, "AnyTypeAnnotation"); |
|
|
|
case "bool": |
|
case "boolean": |
|
return this.finishNode(node, "BooleanTypeAnnotation"); |
|
|
|
case "mixed": |
|
return this.finishNode(node, "MixedTypeAnnotation"); |
|
|
|
case "empty": |
|
return this.finishNode(node, "EmptyTypeAnnotation"); |
|
|
|
case "number": |
|
return this.finishNode(node, "NumberTypeAnnotation"); |
|
|
|
case "string": |
|
return this.finishNode(node, "StringTypeAnnotation"); |
|
|
|
case "symbol": |
|
return this.finishNode(node, "SymbolTypeAnnotation"); |
|
|
|
default: |
|
this.checkNotUnderscore(id.name); |
|
return this.flowParseGenericType(startPos, startLoc, id); |
|
} |
|
} |
|
|
|
flowParsePrimaryType() { |
|
const startPos = this.state.start; |
|
const startLoc = this.state.startLoc; |
|
const node = this.startNode(); |
|
let tmp; |
|
let type; |
|
let isGroupedType = false; |
|
const oldNoAnonFunctionType = this.state.noAnonFunctionType; |
|
|
|
switch (this.state.type) { |
|
case 5: |
|
return this.flowParseObjectType({ |
|
allowStatic: false, |
|
allowExact: false, |
|
allowSpread: true, |
|
allowProto: false, |
|
allowInexact: true |
|
}); |
|
|
|
case 6: |
|
return this.flowParseObjectType({ |
|
allowStatic: false, |
|
allowExact: true, |
|
allowSpread: true, |
|
allowProto: false, |
|
allowInexact: false |
|
}); |
|
|
|
case 0: |
|
this.state.noAnonFunctionType = false; |
|
type = this.flowParseTupleType(); |
|
this.state.noAnonFunctionType = oldNoAnonFunctionType; |
|
return type; |
|
|
|
case 47: |
|
node.typeParameters = this.flowParseTypeParameterDeclaration(); |
|
this.expect(10); |
|
tmp = this.flowParseFunctionTypeParams(); |
|
node.params = tmp.params; |
|
node.rest = tmp.rest; |
|
node.this = tmp._this; |
|
this.expect(11); |
|
this.expect(19); |
|
node.returnType = this.flowParseType(); |
|
return this.finishNode(node, "FunctionTypeAnnotation"); |
|
|
|
case 10: |
|
this.next(); |
|
|
|
if (!this.match(11) && !this.match(21)) { |
|
if (tokenIsIdentifier(this.state.type) || this.match(78)) { |
|
const token = this.lookahead().type; |
|
isGroupedType = token !== 17 && token !== 14; |
|
} else { |
|
isGroupedType = true; |
|
} |
|
} |
|
|
|
if (isGroupedType) { |
|
this.state.noAnonFunctionType = false; |
|
type = this.flowParseType(); |
|
this.state.noAnonFunctionType = oldNoAnonFunctionType; |
|
|
|
if (this.state.noAnonFunctionType || !(this.match(12) || this.match(11) && this.lookahead().type === 19)) { |
|
this.expect(11); |
|
return type; |
|
} else { |
|
this.eat(12); |
|
} |
|
} |
|
|
|
if (type) { |
|
tmp = this.flowParseFunctionTypeParams([this.reinterpretTypeAsFunctionTypeParam(type)]); |
|
} else { |
|
tmp = this.flowParseFunctionTypeParams(); |
|
} |
|
|
|
node.params = tmp.params; |
|
node.rest = tmp.rest; |
|
node.this = tmp._this; |
|
this.expect(11); |
|
this.expect(19); |
|
node.returnType = this.flowParseType(); |
|
node.typeParameters = null; |
|
return this.finishNode(node, "FunctionTypeAnnotation"); |
|
|
|
case 129: |
|
return this.parseLiteral(this.state.value, "StringLiteralTypeAnnotation"); |
|
|
|
case 85: |
|
case 86: |
|
node.value = this.match(85); |
|
this.next(); |
|
return this.finishNode(node, "BooleanLiteralTypeAnnotation"); |
|
|
|
case 53: |
|
if (this.state.value === "-") { |
|
this.next(); |
|
|
|
if (this.match(130)) { |
|
return this.parseLiteralAtNode(-this.state.value, "NumberLiteralTypeAnnotation", node); |
|
} |
|
|
|
if (this.match(131)) { |
|
return this.parseLiteralAtNode(-this.state.value, "BigIntLiteralTypeAnnotation", node); |
|
} |
|
|
|
throw this.raise(FlowErrors.UnexpectedSubtractionOperand, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
|
|
throw this.unexpected(); |
|
|
|
case 130: |
|
return this.parseLiteral(this.state.value, "NumberLiteralTypeAnnotation"); |
|
|
|
case 131: |
|
return this.parseLiteral(this.state.value, "BigIntLiteralTypeAnnotation"); |
|
|
|
case 88: |
|
this.next(); |
|
return this.finishNode(node, "VoidTypeAnnotation"); |
|
|
|
case 84: |
|
this.next(); |
|
return this.finishNode(node, "NullLiteralTypeAnnotation"); |
|
|
|
case 78: |
|
this.next(); |
|
return this.finishNode(node, "ThisTypeAnnotation"); |
|
|
|
case 55: |
|
this.next(); |
|
return this.finishNode(node, "ExistsTypeAnnotation"); |
|
|
|
case 87: |
|
return this.flowParseTypeofType(); |
|
|
|
default: |
|
if (tokenIsKeyword(this.state.type)) { |
|
const label = tokenLabelName(this.state.type); |
|
this.next(); |
|
return super.createIdentifier(node, label); |
|
} else if (tokenIsIdentifier(this.state.type)) { |
|
if (this.isContextual(125)) { |
|
return this.flowParseInterfaceType(); |
|
} |
|
|
|
return this.flowIdentToTypeAnnotation(startPos, startLoc, node, this.parseIdentifier()); |
|
} |
|
|
|
} |
|
|
|
throw this.unexpected(); |
|
} |
|
|
|
flowParsePostfixType() { |
|
const startPos = this.state.start; |
|
const startLoc = this.state.startLoc; |
|
let type = this.flowParsePrimaryType(); |
|
let seenOptionalIndexedAccess = false; |
|
|
|
while ((this.match(0) || this.match(18)) && !this.canInsertSemicolon()) { |
|
const node = this.startNodeAt(startPos, startLoc); |
|
const optional = this.eat(18); |
|
seenOptionalIndexedAccess = seenOptionalIndexedAccess || optional; |
|
this.expect(0); |
|
|
|
if (!optional && this.match(3)) { |
|
node.elementType = type; |
|
this.next(); |
|
type = this.finishNode(node, "ArrayTypeAnnotation"); |
|
} else { |
|
node.objectType = type; |
|
node.indexType = this.flowParseType(); |
|
this.expect(3); |
|
|
|
if (seenOptionalIndexedAccess) { |
|
node.optional = optional; |
|
type = this.finishNode(node, "OptionalIndexedAccessType"); |
|
} else { |
|
type = this.finishNode(node, "IndexedAccessType"); |
|
} |
|
} |
|
} |
|
|
|
return type; |
|
} |
|
|
|
flowParsePrefixType() { |
|
const node = this.startNode(); |
|
|
|
if (this.eat(17)) { |
|
node.typeAnnotation = this.flowParsePrefixType(); |
|
return this.finishNode(node, "NullableTypeAnnotation"); |
|
} else { |
|
return this.flowParsePostfixType(); |
|
} |
|
} |
|
|
|
flowParseAnonFunctionWithoutParens() { |
|
const param = this.flowParsePrefixType(); |
|
|
|
if (!this.state.noAnonFunctionType && this.eat(19)) { |
|
const node = this.startNodeAt(param.start, param.loc.start); |
|
node.params = [this.reinterpretTypeAsFunctionTypeParam(param)]; |
|
node.rest = null; |
|
node.this = null; |
|
node.returnType = this.flowParseType(); |
|
node.typeParameters = null; |
|
return this.finishNode(node, "FunctionTypeAnnotation"); |
|
} |
|
|
|
return param; |
|
} |
|
|
|
flowParseIntersectionType() { |
|
const node = this.startNode(); |
|
this.eat(45); |
|
const type = this.flowParseAnonFunctionWithoutParens(); |
|
node.types = [type]; |
|
|
|
while (this.eat(45)) { |
|
node.types.push(this.flowParseAnonFunctionWithoutParens()); |
|
} |
|
|
|
return node.types.length === 1 ? type : this.finishNode(node, "IntersectionTypeAnnotation"); |
|
} |
|
|
|
flowParseUnionType() { |
|
const node = this.startNode(); |
|
this.eat(43); |
|
const type = this.flowParseIntersectionType(); |
|
node.types = [type]; |
|
|
|
while (this.eat(43)) { |
|
node.types.push(this.flowParseIntersectionType()); |
|
} |
|
|
|
return node.types.length === 1 ? type : this.finishNode(node, "UnionTypeAnnotation"); |
|
} |
|
|
|
flowParseType() { |
|
const oldInType = this.state.inType; |
|
this.state.inType = true; |
|
const type = this.flowParseUnionType(); |
|
this.state.inType = oldInType; |
|
return type; |
|
} |
|
|
|
flowParseTypeOrImplicitInstantiation() { |
|
if (this.state.type === 128 && this.state.value === "_") { |
|
const startPos = this.state.start; |
|
const startLoc = this.state.startLoc; |
|
const node = this.parseIdentifier(); |
|
return this.flowParseGenericType(startPos, startLoc, node); |
|
} else { |
|
return this.flowParseType(); |
|
} |
|
} |
|
|
|
flowParseTypeAnnotation() { |
|
const node = this.startNode(); |
|
node.typeAnnotation = this.flowParseTypeInitialiser(); |
|
return this.finishNode(node, "TypeAnnotation"); |
|
} |
|
|
|
flowParseTypeAnnotatableIdentifier(allowPrimitiveOverride) { |
|
const ident = allowPrimitiveOverride ? this.parseIdentifier() : this.flowParseRestrictedIdentifier(); |
|
|
|
if (this.match(14)) { |
|
ident.typeAnnotation = this.flowParseTypeAnnotation(); |
|
this.resetEndLocation(ident); |
|
} |
|
|
|
return ident; |
|
} |
|
|
|
typeCastToParameter(node) { |
|
node.expression.typeAnnotation = node.typeAnnotation; |
|
this.resetEndLocation(node.expression, node.typeAnnotation.loc.end); |
|
return node.expression; |
|
} |
|
|
|
flowParseVariance() { |
|
let variance = null; |
|
|
|
if (this.match(53)) { |
|
variance = this.startNode(); |
|
|
|
if (this.state.value === "+") { |
|
variance.kind = "plus"; |
|
} else { |
|
variance.kind = "minus"; |
|
} |
|
|
|
this.next(); |
|
this.finishNode(variance, "Variance"); |
|
} |
|
|
|
return variance; |
|
} |
|
|
|
parseFunctionBody(node, allowExpressionBody, isMethod = false) { |
|
if (allowExpressionBody) { |
|
return this.forwardNoArrowParamsConversionAt(node, () => super.parseFunctionBody(node, true, isMethod)); |
|
} |
|
|
|
return super.parseFunctionBody(node, false, isMethod); |
|
} |
|
|
|
parseFunctionBodyAndFinish(node, type, isMethod = false) { |
|
if (this.match(14)) { |
|
const typeNode = this.startNode(); |
|
[typeNode.typeAnnotation, node.predicate] = this.flowParseTypeAndPredicateInitialiser(); |
|
node.returnType = typeNode.typeAnnotation ? this.finishNode(typeNode, "TypeAnnotation") : null; |
|
} |
|
|
|
super.parseFunctionBodyAndFinish(node, type, isMethod); |
|
} |
|
|
|
parseStatement(context, topLevel) { |
|
if (this.state.strict && this.isContextual(125)) { |
|
const lookahead = this.lookahead(); |
|
|
|
if (tokenIsKeywordOrIdentifier(lookahead.type)) { |
|
const node = this.startNode(); |
|
this.next(); |
|
return this.flowParseInterface(node); |
|
} |
|
} else if (this.shouldParseEnums() && this.isContextual(122)) { |
|
const node = this.startNode(); |
|
this.next(); |
|
return this.flowParseEnumDeclaration(node); |
|
} |
|
|
|
const stmt = super.parseStatement(context, topLevel); |
|
|
|
if (this.flowPragma === undefined && !this.isValidDirective(stmt)) { |
|
this.flowPragma = null; |
|
} |
|
|
|
return stmt; |
|
} |
|
|
|
parseExpressionStatement(node, expr) { |
|
if (expr.type === "Identifier") { |
|
if (expr.name === "declare") { |
|
if (this.match(80) || tokenIsIdentifier(this.state.type) || this.match(68) || this.match(74) || this.match(82)) { |
|
return this.flowParseDeclare(node); |
|
} |
|
} else if (tokenIsIdentifier(this.state.type)) { |
|
if (expr.name === "interface") { |
|
return this.flowParseInterface(node); |
|
} else if (expr.name === "type") { |
|
return this.flowParseTypeAlias(node); |
|
} else if (expr.name === "opaque") { |
|
return this.flowParseOpaqueType(node, false); |
|
} |
|
} |
|
} |
|
|
|
return super.parseExpressionStatement(node, expr); |
|
} |
|
|
|
shouldParseExportDeclaration() { |
|
const { |
|
type |
|
} = this.state; |
|
|
|
if (tokenIsFlowInterfaceOrTypeOrOpaque(type) || this.shouldParseEnums() && type === 122) { |
|
return !this.state.containsEsc; |
|
} |
|
|
|
return super.shouldParseExportDeclaration(); |
|
} |
|
|
|
isExportDefaultSpecifier() { |
|
const { |
|
type |
|
} = this.state; |
|
|
|
if (tokenIsFlowInterfaceOrTypeOrOpaque(type) || this.shouldParseEnums() && type === 122) { |
|
return this.state.containsEsc; |
|
} |
|
|
|
return super.isExportDefaultSpecifier(); |
|
} |
|
|
|
parseExportDefaultExpression() { |
|
if (this.shouldParseEnums() && this.isContextual(122)) { |
|
const node = this.startNode(); |
|
this.next(); |
|
return this.flowParseEnumDeclaration(node); |
|
} |
|
|
|
return super.parseExportDefaultExpression(); |
|
} |
|
|
|
parseConditional(expr, startPos, startLoc, refExpressionErrors) { |
|
if (!this.match(17)) return expr; |
|
|
|
if (this.state.maybeInArrowParameters) { |
|
const nextCh = this.lookaheadCharCode(); |
|
|
|
if (nextCh === 44 || nextCh === 61 || nextCh === 58 || nextCh === 41) { |
|
this.setOptionalParametersError(refExpressionErrors); |
|
return expr; |
|
} |
|
} |
|
|
|
this.expect(17); |
|
const state = this.state.clone(); |
|
const originalNoArrowAt = this.state.noArrowAt; |
|
const node = this.startNodeAt(startPos, startLoc); |
|
let { |
|
consequent, |
|
failed |
|
} = this.tryParseConditionalConsequent(); |
|
let [valid, invalid] = this.getArrowLikeExpressions(consequent); |
|
|
|
if (failed || invalid.length > 0) { |
|
const noArrowAt = [...originalNoArrowAt]; |
|
|
|
if (invalid.length > 0) { |
|
this.state = state; |
|
this.state.noArrowAt = noArrowAt; |
|
|
|
for (let i = 0; i < invalid.length; i++) { |
|
noArrowAt.push(invalid[i].start); |
|
} |
|
|
|
({ |
|
consequent, |
|
failed |
|
} = this.tryParseConditionalConsequent()); |
|
[valid, invalid] = this.getArrowLikeExpressions(consequent); |
|
} |
|
|
|
if (failed && valid.length > 1) { |
|
this.raise(FlowErrors.AmbiguousConditionalArrow, { |
|
at: state.startLoc |
|
}); |
|
} |
|
|
|
if (failed && valid.length === 1) { |
|
this.state = state; |
|
noArrowAt.push(valid[0].start); |
|
this.state.noArrowAt = noArrowAt; |
|
({ |
|
consequent, |
|
failed |
|
} = this.tryParseConditionalConsequent()); |
|
} |
|
} |
|
|
|
this.getArrowLikeExpressions(consequent, true); |
|
this.state.noArrowAt = originalNoArrowAt; |
|
this.expect(14); |
|
node.test = expr; |
|
node.consequent = consequent; |
|
node.alternate = this.forwardNoArrowParamsConversionAt(node, () => this.parseMaybeAssign(undefined, undefined)); |
|
return this.finishNode(node, "ConditionalExpression"); |
|
} |
|
|
|
tryParseConditionalConsequent() { |
|
this.state.noArrowParamsConversionAt.push(this.state.start); |
|
const consequent = this.parseMaybeAssignAllowIn(); |
|
const failed = !this.match(14); |
|
this.state.noArrowParamsConversionAt.pop(); |
|
return { |
|
consequent, |
|
failed |
|
}; |
|
} |
|
|
|
getArrowLikeExpressions(node, disallowInvalid) { |
|
const stack = [node]; |
|
const arrows = []; |
|
|
|
while (stack.length !== 0) { |
|
const node = stack.pop(); |
|
|
|
if (node.type === "ArrowFunctionExpression") { |
|
if (node.typeParameters || !node.returnType) { |
|
this.finishArrowValidation(node); |
|
} else { |
|
arrows.push(node); |
|
} |
|
|
|
stack.push(node.body); |
|
} else if (node.type === "ConditionalExpression") { |
|
stack.push(node.consequent); |
|
stack.push(node.alternate); |
|
} |
|
} |
|
|
|
if (disallowInvalid) { |
|
arrows.forEach(node => this.finishArrowValidation(node)); |
|
return [arrows, []]; |
|
} |
|
|
|
return partition(arrows, node => node.params.every(param => this.isAssignable(param, true))); |
|
} |
|
|
|
finishArrowValidation(node) { |
|
var _node$extra; |
|
|
|
this.toAssignableList(node.params, (_node$extra = node.extra) == null ? void 0 : _node$extra.trailingCommaLoc, false); |
|
this.scope.enter(SCOPE_FUNCTION | SCOPE_ARROW); |
|
super.checkParams(node, false, true); |
|
this.scope.exit(); |
|
} |
|
|
|
forwardNoArrowParamsConversionAt(node, parse) { |
|
let result; |
|
|
|
if (this.state.noArrowParamsConversionAt.indexOf(node.start) !== -1) { |
|
this.state.noArrowParamsConversionAt.push(this.state.start); |
|
result = parse(); |
|
this.state.noArrowParamsConversionAt.pop(); |
|
} else { |
|
result = parse(); |
|
} |
|
|
|
return result; |
|
} |
|
|
|
parseParenItem(node, startPos, startLoc) { |
|
node = super.parseParenItem(node, startPos, startLoc); |
|
|
|
if (this.eat(17)) { |
|
node.optional = true; |
|
this.resetEndLocation(node); |
|
} |
|
|
|
if (this.match(14)) { |
|
const typeCastNode = this.startNodeAt(startPos, startLoc); |
|
typeCastNode.expression = node; |
|
typeCastNode.typeAnnotation = this.flowParseTypeAnnotation(); |
|
return this.finishNode(typeCastNode, "TypeCastExpression"); |
|
} |
|
|
|
return node; |
|
} |
|
|
|
assertModuleNodeAllowed(node) { |
|
if (node.type === "ImportDeclaration" && (node.importKind === "type" || node.importKind === "typeof") || node.type === "ExportNamedDeclaration" && node.exportKind === "type" || node.type === "ExportAllDeclaration" && node.exportKind === "type") { |
|
return; |
|
} |
|
|
|
super.assertModuleNodeAllowed(node); |
|
} |
|
|
|
parseExport(node) { |
|
const decl = super.parseExport(node); |
|
|
|
if (decl.type === "ExportNamedDeclaration" || decl.type === "ExportAllDeclaration") { |
|
decl.exportKind = decl.exportKind || "value"; |
|
} |
|
|
|
return decl; |
|
} |
|
|
|
parseExportDeclaration(node) { |
|
if (this.isContextual(126)) { |
|
node.exportKind = "type"; |
|
const declarationNode = this.startNode(); |
|
this.next(); |
|
|
|
if (this.match(5)) { |
|
node.specifiers = this.parseExportSpecifiers(true); |
|
this.parseExportFrom(node); |
|
return null; |
|
} else { |
|
return this.flowParseTypeAlias(declarationNode); |
|
} |
|
} else if (this.isContextual(127)) { |
|
node.exportKind = "type"; |
|
const declarationNode = this.startNode(); |
|
this.next(); |
|
return this.flowParseOpaqueType(declarationNode, false); |
|
} else if (this.isContextual(125)) { |
|
node.exportKind = "type"; |
|
const declarationNode = this.startNode(); |
|
this.next(); |
|
return this.flowParseInterface(declarationNode); |
|
} else if (this.shouldParseEnums() && this.isContextual(122)) { |
|
node.exportKind = "value"; |
|
const declarationNode = this.startNode(); |
|
this.next(); |
|
return this.flowParseEnumDeclaration(declarationNode); |
|
} else { |
|
return super.parseExportDeclaration(node); |
|
} |
|
} |
|
|
|
eatExportStar(node) { |
|
if (super.eatExportStar(...arguments)) return true; |
|
|
|
if (this.isContextual(126) && this.lookahead().type === 55) { |
|
node.exportKind = "type"; |
|
this.next(); |
|
this.next(); |
|
return true; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
maybeParseExportNamespaceSpecifier(node) { |
|
const { |
|
startLoc |
|
} = this.state; |
|
const hasNamespace = super.maybeParseExportNamespaceSpecifier(node); |
|
|
|
if (hasNamespace && node.exportKind === "type") { |
|
this.unexpected(startLoc); |
|
} |
|
|
|
return hasNamespace; |
|
} |
|
|
|
parseClassId(node, isStatement, optionalId) { |
|
super.parseClassId(node, isStatement, optionalId); |
|
|
|
if (this.match(47)) { |
|
node.typeParameters = this.flowParseTypeParameterDeclaration(); |
|
} |
|
} |
|
|
|
parseClassMember(classBody, member, state) { |
|
const { |
|
startLoc |
|
} = this.state; |
|
|
|
if (this.isContextual(121)) { |
|
if (this.parseClassMemberFromModifier(classBody, member)) { |
|
return; |
|
} |
|
|
|
member.declare = true; |
|
} |
|
|
|
super.parseClassMember(classBody, member, state); |
|
|
|
if (member.declare) { |
|
if (member.type !== "ClassProperty" && member.type !== "ClassPrivateProperty" && member.type !== "PropertyDefinition") { |
|
this.raise(FlowErrors.DeclareClassElement, { |
|
at: startLoc |
|
}); |
|
} else if (member.value) { |
|
this.raise(FlowErrors.DeclareClassFieldInitializer, { |
|
at: member.value |
|
}); |
|
} |
|
} |
|
} |
|
|
|
isIterator(word) { |
|
return word === "iterator" || word === "asyncIterator"; |
|
} |
|
|
|
readIterator() { |
|
const word = super.readWord1(); |
|
const fullWord = "@@" + word; |
|
|
|
if (!this.isIterator(word) || !this.state.inType) { |
|
this.raise(Errors.InvalidIdentifier, { |
|
at: this.state.curPosition(), |
|
identifierName: fullWord |
|
}); |
|
} |
|
|
|
this.finishToken(128, fullWord); |
|
} |
|
|
|
getTokenFromCode(code) { |
|
const next = this.input.charCodeAt(this.state.pos + 1); |
|
|
|
if (code === 123 && next === 124) { |
|
return this.finishOp(6, 2); |
|
} else if (this.state.inType && (code === 62 || code === 60)) { |
|
return this.finishOp(code === 62 ? 48 : 47, 1); |
|
} else if (this.state.inType && code === 63) { |
|
if (next === 46) { |
|
return this.finishOp(18, 2); |
|
} |
|
|
|
return this.finishOp(17, 1); |
|
} else if (isIteratorStart(code, next, this.input.charCodeAt(this.state.pos + 2))) { |
|
this.state.pos += 2; |
|
return this.readIterator(); |
|
} else { |
|
return super.getTokenFromCode(code); |
|
} |
|
} |
|
|
|
isAssignable(node, isBinding) { |
|
if (node.type === "TypeCastExpression") { |
|
return this.isAssignable(node.expression, isBinding); |
|
} else { |
|
return super.isAssignable(node, isBinding); |
|
} |
|
} |
|
|
|
toAssignable(node, isLHS = false) { |
|
if (!isLHS && node.type === "AssignmentExpression" && node.left.type === "TypeCastExpression") { |
|
node.left = this.typeCastToParameter(node.left); |
|
} |
|
|
|
super.toAssignable(...arguments); |
|
} |
|
|
|
toAssignableList(exprList, trailingCommaLoc, isLHS) { |
|
for (let i = 0; i < exprList.length; i++) { |
|
const expr = exprList[i]; |
|
|
|
if ((expr == null ? void 0 : expr.type) === "TypeCastExpression") { |
|
exprList[i] = this.typeCastToParameter(expr); |
|
} |
|
} |
|
|
|
super.toAssignableList(exprList, trailingCommaLoc, isLHS); |
|
} |
|
|
|
toReferencedList(exprList, isParenthesizedExpr) { |
|
for (let i = 0; i < exprList.length; i++) { |
|
var _expr$extra; |
|
|
|
const expr = exprList[i]; |
|
|
|
if (expr && expr.type === "TypeCastExpression" && !((_expr$extra = expr.extra) != null && _expr$extra.parenthesized) && (exprList.length > 1 || !isParenthesizedExpr)) { |
|
this.raise(FlowErrors.TypeCastInPattern, { |
|
at: expr.typeAnnotation |
|
}); |
|
} |
|
} |
|
|
|
return exprList; |
|
} |
|
|
|
parseArrayLike(close, canBePattern, isTuple, refExpressionErrors) { |
|
const node = super.parseArrayLike(close, canBePattern, isTuple, refExpressionErrors); |
|
|
|
if (canBePattern && !this.state.maybeInArrowParameters) { |
|
this.toReferencedList(node.elements); |
|
} |
|
|
|
return node; |
|
} |
|
|
|
isValidLVal(type, ...rest) { |
|
return type === "TypeCastExpression" || super.isValidLVal(type, ...rest); |
|
} |
|
|
|
parseClassProperty(node) { |
|
if (this.match(14)) { |
|
node.typeAnnotation = this.flowParseTypeAnnotation(); |
|
} |
|
|
|
return super.parseClassProperty(node); |
|
} |
|
|
|
parseClassPrivateProperty(node) { |
|
if (this.match(14)) { |
|
node.typeAnnotation = this.flowParseTypeAnnotation(); |
|
} |
|
|
|
return super.parseClassPrivateProperty(node); |
|
} |
|
|
|
isClassMethod() { |
|
return this.match(47) || super.isClassMethod(); |
|
} |
|
|
|
isClassProperty() { |
|
return this.match(14) || super.isClassProperty(); |
|
} |
|
|
|
isNonstaticConstructor(method) { |
|
return !this.match(14) && super.isNonstaticConstructor(method); |
|
} |
|
|
|
pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) { |
|
if (method.variance) { |
|
this.unexpected(method.variance.loc.start); |
|
} |
|
|
|
delete method.variance; |
|
|
|
if (this.match(47)) { |
|
method.typeParameters = this.flowParseTypeParameterDeclaration(); |
|
} |
|
|
|
super.pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper); |
|
|
|
if (method.params && isConstructor) { |
|
const params = method.params; |
|
|
|
if (params.length > 0 && this.isThisParam(params[0])) { |
|
this.raise(FlowErrors.ThisParamBannedInConstructor, { |
|
at: method |
|
}); |
|
} |
|
} else if (method.type === "MethodDefinition" && isConstructor && method.value.params) { |
|
const params = method.value.params; |
|
|
|
if (params.length > 0 && this.isThisParam(params[0])) { |
|
this.raise(FlowErrors.ThisParamBannedInConstructor, { |
|
at: method |
|
}); |
|
} |
|
} |
|
} |
|
|
|
pushClassPrivateMethod(classBody, method, isGenerator, isAsync) { |
|
if (method.variance) { |
|
this.unexpected(method.variance.loc.start); |
|
} |
|
|
|
delete method.variance; |
|
|
|
if (this.match(47)) { |
|
method.typeParameters = this.flowParseTypeParameterDeclaration(); |
|
} |
|
|
|
super.pushClassPrivateMethod(classBody, method, isGenerator, isAsync); |
|
} |
|
|
|
parseClassSuper(node) { |
|
super.parseClassSuper(node); |
|
|
|
if (node.superClass && this.match(47)) { |
|
node.superTypeParameters = this.flowParseTypeParameterInstantiation(); |
|
} |
|
|
|
if (this.isContextual(110)) { |
|
this.next(); |
|
const implemented = node.implements = []; |
|
|
|
do { |
|
const node = this.startNode(); |
|
node.id = this.flowParseRestrictedIdentifier(true); |
|
|
|
if (this.match(47)) { |
|
node.typeParameters = this.flowParseTypeParameterInstantiation(); |
|
} else { |
|
node.typeParameters = null; |
|
} |
|
|
|
implemented.push(this.finishNode(node, "ClassImplements")); |
|
} while (this.eat(12)); |
|
} |
|
} |
|
|
|
checkGetterSetterParams(method) { |
|
super.checkGetterSetterParams(method); |
|
const params = this.getObjectOrClassMethodParams(method); |
|
|
|
if (params.length > 0) { |
|
const param = params[0]; |
|
|
|
if (this.isThisParam(param) && method.kind === "get") { |
|
this.raise(FlowErrors.GetterMayNotHaveThisParam, { |
|
at: param |
|
}); |
|
} else if (this.isThisParam(param)) { |
|
this.raise(FlowErrors.SetterMayNotHaveThisParam, { |
|
at: param |
|
}); |
|
} |
|
} |
|
} |
|
|
|
parsePropertyNamePrefixOperator(node) { |
|
node.variance = this.flowParseVariance(); |
|
} |
|
|
|
parseObjPropValue(prop, startPos, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) { |
|
if (prop.variance) { |
|
this.unexpected(prop.variance.loc.start); |
|
} |
|
|
|
delete prop.variance; |
|
let typeParameters; |
|
|
|
if (this.match(47) && !isAccessor) { |
|
typeParameters = this.flowParseTypeParameterDeclaration(); |
|
if (!this.match(10)) this.unexpected(); |
|
} |
|
|
|
super.parseObjPropValue(prop, startPos, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors); |
|
|
|
if (typeParameters) { |
|
(prop.value || prop).typeParameters = typeParameters; |
|
} |
|
} |
|
|
|
parseAssignableListItemTypes(param) { |
|
if (this.eat(17)) { |
|
if (param.type !== "Identifier") { |
|
this.raise(FlowErrors.PatternIsOptional, { |
|
at: param |
|
}); |
|
} |
|
|
|
if (this.isThisParam(param)) { |
|
this.raise(FlowErrors.ThisParamMayNotBeOptional, { |
|
at: param |
|
}); |
|
} |
|
|
|
param.optional = true; |
|
} |
|
|
|
if (this.match(14)) { |
|
param.typeAnnotation = this.flowParseTypeAnnotation(); |
|
} else if (this.isThisParam(param)) { |
|
this.raise(FlowErrors.ThisParamAnnotationRequired, { |
|
at: param |
|
}); |
|
} |
|
|
|
if (this.match(29) && this.isThisParam(param)) { |
|
this.raise(FlowErrors.ThisParamNoDefault, { |
|
at: param |
|
}); |
|
} |
|
|
|
this.resetEndLocation(param); |
|
return param; |
|
} |
|
|
|
parseMaybeDefault(startPos, startLoc, left) { |
|
const node = super.parseMaybeDefault(startPos, startLoc, left); |
|
|
|
if (node.type === "AssignmentPattern" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) { |
|
this.raise(FlowErrors.TypeBeforeInitializer, { |
|
at: node.typeAnnotation |
|
}); |
|
} |
|
|
|
return node; |
|
} |
|
|
|
shouldParseDefaultImport(node) { |
|
if (!hasTypeImportKind(node)) { |
|
return super.shouldParseDefaultImport(node); |
|
} |
|
|
|
return isMaybeDefaultImport(this.state.type); |
|
} |
|
|
|
parseImportSpecifierLocal(node, specifier, type) { |
|
specifier.local = hasTypeImportKind(node) ? this.flowParseRestrictedIdentifier(true, true) : this.parseIdentifier(); |
|
node.specifiers.push(this.finishImportSpecifier(specifier, type)); |
|
} |
|
|
|
maybeParseDefaultImportSpecifier(node) { |
|
node.importKind = "value"; |
|
let kind = null; |
|
|
|
if (this.match(87)) { |
|
kind = "typeof"; |
|
} else if (this.isContextual(126)) { |
|
kind = "type"; |
|
} |
|
|
|
if (kind) { |
|
const lh = this.lookahead(); |
|
const { |
|
type |
|
} = lh; |
|
|
|
if (kind === "type" && type === 55) { |
|
this.unexpected(null, lh.type); |
|
} |
|
|
|
if (isMaybeDefaultImport(type) || type === 5 || type === 55) { |
|
this.next(); |
|
node.importKind = kind; |
|
} |
|
} |
|
|
|
return super.maybeParseDefaultImportSpecifier(node); |
|
} |
|
|
|
parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly) { |
|
const firstIdent = specifier.imported; |
|
let specifierTypeKind = null; |
|
|
|
if (firstIdent.type === "Identifier") { |
|
if (firstIdent.name === "type") { |
|
specifierTypeKind = "type"; |
|
} else if (firstIdent.name === "typeof") { |
|
specifierTypeKind = "typeof"; |
|
} |
|
} |
|
|
|
let isBinding = false; |
|
|
|
if (this.isContextual(93) && !this.isLookaheadContextual("as")) { |
|
const as_ident = this.parseIdentifier(true); |
|
|
|
if (specifierTypeKind !== null && !tokenIsKeywordOrIdentifier(this.state.type)) { |
|
specifier.imported = as_ident; |
|
specifier.importKind = specifierTypeKind; |
|
specifier.local = cloneIdentifier(as_ident); |
|
} else { |
|
specifier.imported = firstIdent; |
|
specifier.importKind = null; |
|
specifier.local = this.parseIdentifier(); |
|
} |
|
} else { |
|
if (specifierTypeKind !== null && tokenIsKeywordOrIdentifier(this.state.type)) { |
|
specifier.imported = this.parseIdentifier(true); |
|
specifier.importKind = specifierTypeKind; |
|
} else { |
|
if (importedIsString) { |
|
throw this.raise(Errors.ImportBindingIsString, { |
|
at: specifier, |
|
importName: firstIdent.value |
|
}); |
|
} |
|
|
|
specifier.imported = firstIdent; |
|
specifier.importKind = null; |
|
} |
|
|
|
if (this.eatContextual(93)) { |
|
specifier.local = this.parseIdentifier(); |
|
} else { |
|
isBinding = true; |
|
specifier.local = cloneIdentifier(specifier.imported); |
|
} |
|
} |
|
|
|
const specifierIsTypeImport = hasTypeImportKind(specifier); |
|
|
|
if (isInTypeOnlyImport && specifierIsTypeImport) { |
|
this.raise(FlowErrors.ImportTypeShorthandOnlyInPureImport, { |
|
at: specifier |
|
}); |
|
} |
|
|
|
if (isInTypeOnlyImport || specifierIsTypeImport) { |
|
this.checkReservedType(specifier.local.name, specifier.local.loc.start, true); |
|
} |
|
|
|
if (isBinding && !isInTypeOnlyImport && !specifierIsTypeImport) { |
|
this.checkReservedWord(specifier.local.name, specifier.loc.start, true, true); |
|
} |
|
|
|
return this.finishImportSpecifier(specifier, "ImportSpecifier"); |
|
} |
|
|
|
parseBindingAtom() { |
|
switch (this.state.type) { |
|
case 78: |
|
return this.parseIdentifier(true); |
|
|
|
default: |
|
return super.parseBindingAtom(); |
|
} |
|
} |
|
|
|
parseFunctionParams(node, allowModifiers) { |
|
const kind = node.kind; |
|
|
|
if (kind !== "get" && kind !== "set" && this.match(47)) { |
|
node.typeParameters = this.flowParseTypeParameterDeclaration(); |
|
} |
|
|
|
super.parseFunctionParams(node, allowModifiers); |
|
} |
|
|
|
parseVarId(decl, kind) { |
|
super.parseVarId(decl, kind); |
|
|
|
if (this.match(14)) { |
|
decl.id.typeAnnotation = this.flowParseTypeAnnotation(); |
|
this.resetEndLocation(decl.id); |
|
} |
|
} |
|
|
|
parseAsyncArrowFromCallExpression(node, call) { |
|
if (this.match(14)) { |
|
const oldNoAnonFunctionType = this.state.noAnonFunctionType; |
|
this.state.noAnonFunctionType = true; |
|
node.returnType = this.flowParseTypeAnnotation(); |
|
this.state.noAnonFunctionType = oldNoAnonFunctionType; |
|
} |
|
|
|
return super.parseAsyncArrowFromCallExpression(node, call); |
|
} |
|
|
|
shouldParseAsyncArrow() { |
|
return this.match(14) || super.shouldParseAsyncArrow(); |
|
} |
|
|
|
parseMaybeAssign(refExpressionErrors, afterLeftParse) { |
|
var _jsx; |
|
|
|
let state = null; |
|
let jsx; |
|
|
|
if (this.hasPlugin("jsx") && (this.match(138) || this.match(47))) { |
|
state = this.state.clone(); |
|
jsx = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state); |
|
if (!jsx.error) return jsx.node; |
|
const { |
|
context |
|
} = this.state; |
|
const currentContext = context[context.length - 1]; |
|
|
|
if (currentContext === types.j_oTag || currentContext === types.j_expr) { |
|
context.pop(); |
|
} |
|
} |
|
|
|
if ((_jsx = jsx) != null && _jsx.error || this.match(47)) { |
|
var _jsx2, _jsx3; |
|
|
|
state = state || this.state.clone(); |
|
let typeParameters; |
|
const arrow = this.tryParse(abort => { |
|
var _arrowExpression$extr; |
|
|
|
typeParameters = this.flowParseTypeParameterDeclaration(); |
|
const arrowExpression = this.forwardNoArrowParamsConversionAt(typeParameters, () => { |
|
const result = super.parseMaybeAssign(refExpressionErrors, afterLeftParse); |
|
this.resetStartLocationFromNode(result, typeParameters); |
|
return result; |
|
}); |
|
if ((_arrowExpression$extr = arrowExpression.extra) != null && _arrowExpression$extr.parenthesized) abort(); |
|
const expr = this.maybeUnwrapTypeCastExpression(arrowExpression); |
|
if (expr.type !== "ArrowFunctionExpression") abort(); |
|
expr.typeParameters = typeParameters; |
|
this.resetStartLocationFromNode(expr, typeParameters); |
|
return arrowExpression; |
|
}, state); |
|
let arrowExpression = null; |
|
|
|
if (arrow.node && this.maybeUnwrapTypeCastExpression(arrow.node).type === "ArrowFunctionExpression") { |
|
if (!arrow.error && !arrow.aborted) { |
|
if (arrow.node.async) { |
|
this.raise(FlowErrors.UnexpectedTypeParameterBeforeAsyncArrowFunction, { |
|
at: typeParameters |
|
}); |
|
} |
|
|
|
return arrow.node; |
|
} |
|
|
|
arrowExpression = arrow.node; |
|
} |
|
|
|
if ((_jsx2 = jsx) != null && _jsx2.node) { |
|
this.state = jsx.failState; |
|
return jsx.node; |
|
} |
|
|
|
if (arrowExpression) { |
|
this.state = arrow.failState; |
|
return arrowExpression; |
|
} |
|
|
|
if ((_jsx3 = jsx) != null && _jsx3.thrown) throw jsx.error; |
|
if (arrow.thrown) throw arrow.error; |
|
throw this.raise(FlowErrors.UnexpectedTokenAfterTypeParameter, { |
|
at: typeParameters |
|
}); |
|
} |
|
|
|
return super.parseMaybeAssign(refExpressionErrors, afterLeftParse); |
|
} |
|
|
|
parseArrow(node) { |
|
if (this.match(14)) { |
|
const result = this.tryParse(() => { |
|
const oldNoAnonFunctionType = this.state.noAnonFunctionType; |
|
this.state.noAnonFunctionType = true; |
|
const typeNode = this.startNode(); |
|
[typeNode.typeAnnotation, node.predicate] = this.flowParseTypeAndPredicateInitialiser(); |
|
this.state.noAnonFunctionType = oldNoAnonFunctionType; |
|
if (this.canInsertSemicolon()) this.unexpected(); |
|
if (!this.match(19)) this.unexpected(); |
|
return typeNode; |
|
}); |
|
if (result.thrown) return null; |
|
if (result.error) this.state = result.failState; |
|
node.returnType = result.node.typeAnnotation ? this.finishNode(result.node, "TypeAnnotation") : null; |
|
} |
|
|
|
return super.parseArrow(node); |
|
} |
|
|
|
shouldParseArrow(params) { |
|
return this.match(14) || super.shouldParseArrow(params); |
|
} |
|
|
|
setArrowFunctionParameters(node, params) { |
|
if (this.state.noArrowParamsConversionAt.indexOf(node.start) !== -1) { |
|
node.params = params; |
|
} else { |
|
super.setArrowFunctionParameters(node, params); |
|
} |
|
} |
|
|
|
checkParams(node, allowDuplicates, isArrowFunction) { |
|
if (isArrowFunction && this.state.noArrowParamsConversionAt.indexOf(node.start) !== -1) { |
|
return; |
|
} |
|
|
|
for (let i = 0; i < node.params.length; i++) { |
|
if (this.isThisParam(node.params[i]) && i > 0) { |
|
this.raise(FlowErrors.ThisParamMustBeFirst, { |
|
at: node.params[i] |
|
}); |
|
} |
|
} |
|
|
|
return super.checkParams(...arguments); |
|
} |
|
|
|
parseParenAndDistinguishExpression(canBeArrow) { |
|
return super.parseParenAndDistinguishExpression(canBeArrow && this.state.noArrowAt.indexOf(this.state.start) === -1); |
|
} |
|
|
|
parseSubscripts(base, startPos, startLoc, noCalls) { |
|
if (base.type === "Identifier" && base.name === "async" && this.state.noArrowAt.indexOf(startPos) !== -1) { |
|
this.next(); |
|
const node = this.startNodeAt(startPos, startLoc); |
|
node.callee = base; |
|
node.arguments = this.parseCallExpressionArguments(11, false); |
|
base = this.finishNode(node, "CallExpression"); |
|
} else if (base.type === "Identifier" && base.name === "async" && this.match(47)) { |
|
const state = this.state.clone(); |
|
const arrow = this.tryParse(abort => this.parseAsyncArrowWithTypeParameters(startPos, startLoc) || abort(), state); |
|
if (!arrow.error && !arrow.aborted) return arrow.node; |
|
const result = this.tryParse(() => super.parseSubscripts(base, startPos, startLoc, noCalls), state); |
|
if (result.node && !result.error) return result.node; |
|
|
|
if (arrow.node) { |
|
this.state = arrow.failState; |
|
return arrow.node; |
|
} |
|
|
|
if (result.node) { |
|
this.state = result.failState; |
|
return result.node; |
|
} |
|
|
|
throw arrow.error || result.error; |
|
} |
|
|
|
return super.parseSubscripts(base, startPos, startLoc, noCalls); |
|
} |
|
|
|
parseSubscript(base, startPos, startLoc, noCalls, subscriptState) { |
|
if (this.match(18) && this.isLookaheadToken_lt()) { |
|
subscriptState.optionalChainMember = true; |
|
|
|
if (noCalls) { |
|
subscriptState.stop = true; |
|
return base; |
|
} |
|
|
|
this.next(); |
|
const node = this.startNodeAt(startPos, startLoc); |
|
node.callee = base; |
|
node.typeArguments = this.flowParseTypeParameterInstantiation(); |
|
this.expect(10); |
|
node.arguments = this.parseCallExpressionArguments(11, false); |
|
node.optional = true; |
|
return this.finishCallExpression(node, true); |
|
} else if (!noCalls && this.shouldParseTypes() && this.match(47)) { |
|
const node = this.startNodeAt(startPos, startLoc); |
|
node.callee = base; |
|
const result = this.tryParse(() => { |
|
node.typeArguments = this.flowParseTypeParameterInstantiationCallOrNew(); |
|
this.expect(10); |
|
node.arguments = this.parseCallExpressionArguments(11, false); |
|
if (subscriptState.optionalChainMember) node.optional = false; |
|
return this.finishCallExpression(node, subscriptState.optionalChainMember); |
|
}); |
|
|
|
if (result.node) { |
|
if (result.error) this.state = result.failState; |
|
return result.node; |
|
} |
|
} |
|
|
|
return super.parseSubscript(base, startPos, startLoc, noCalls, subscriptState); |
|
} |
|
|
|
parseNewCallee(node) { |
|
super.parseNewCallee(node); |
|
let targs = null; |
|
|
|
if (this.shouldParseTypes() && this.match(47)) { |
|
targs = this.tryParse(() => this.flowParseTypeParameterInstantiationCallOrNew()).node; |
|
} |
|
|
|
node.typeArguments = targs; |
|
} |
|
|
|
parseAsyncArrowWithTypeParameters(startPos, startLoc) { |
|
const node = this.startNodeAt(startPos, startLoc); |
|
this.parseFunctionParams(node); |
|
if (!this.parseArrow(node)) return; |
|
return this.parseArrowExpression(node, undefined, true); |
|
} |
|
|
|
readToken_mult_modulo(code) { |
|
const next = this.input.charCodeAt(this.state.pos + 1); |
|
|
|
if (code === 42 && next === 47 && this.state.hasFlowComment) { |
|
this.state.hasFlowComment = false; |
|
this.state.pos += 2; |
|
this.nextToken(); |
|
return; |
|
} |
|
|
|
super.readToken_mult_modulo(code); |
|
} |
|
|
|
readToken_pipe_amp(code) { |
|
const next = this.input.charCodeAt(this.state.pos + 1); |
|
|
|
if (code === 124 && next === 125) { |
|
this.finishOp(9, 2); |
|
return; |
|
} |
|
|
|
super.readToken_pipe_amp(code); |
|
} |
|
|
|
parseTopLevel(file, program) { |
|
const fileNode = super.parseTopLevel(file, program); |
|
|
|
if (this.state.hasFlowComment) { |
|
this.raise(FlowErrors.UnterminatedFlowComment, { |
|
at: this.state.curPosition() |
|
}); |
|
} |
|
|
|
return fileNode; |
|
} |
|
|
|
skipBlockComment() { |
|
if (this.hasPlugin("flowComments") && this.skipFlowComment()) { |
|
if (this.state.hasFlowComment) { |
|
throw this.raise(FlowErrors.NestedFlowComment, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
|
|
this.hasFlowCommentCompletion(); |
|
this.state.pos += this.skipFlowComment(); |
|
this.state.hasFlowComment = true; |
|
return; |
|
} |
|
|
|
if (this.state.hasFlowComment) { |
|
const end = this.input.indexOf("*-/", this.state.pos + 2); |
|
|
|
if (end === -1) { |
|
throw this.raise(Errors.UnterminatedComment, { |
|
at: this.state.curPosition() |
|
}); |
|
} |
|
|
|
this.state.pos = end + 2 + 3; |
|
return; |
|
} |
|
|
|
return super.skipBlockComment(); |
|
} |
|
|
|
skipFlowComment() { |
|
const { |
|
pos |
|
} = this.state; |
|
let shiftToFirstNonWhiteSpace = 2; |
|
|
|
while ([32, 9].includes(this.input.charCodeAt(pos + shiftToFirstNonWhiteSpace))) { |
|
shiftToFirstNonWhiteSpace++; |
|
} |
|
|
|
const ch2 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos); |
|
const ch3 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos + 1); |
|
|
|
if (ch2 === 58 && ch3 === 58) { |
|
return shiftToFirstNonWhiteSpace + 2; |
|
} |
|
|
|
if (this.input.slice(shiftToFirstNonWhiteSpace + pos, shiftToFirstNonWhiteSpace + pos + 12) === "flow-include") { |
|
return shiftToFirstNonWhiteSpace + 12; |
|
} |
|
|
|
if (ch2 === 58 && ch3 !== 58) { |
|
return shiftToFirstNonWhiteSpace; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
hasFlowCommentCompletion() { |
|
const end = this.input.indexOf("*/", this.state.pos); |
|
|
|
if (end === -1) { |
|
throw this.raise(Errors.UnterminatedComment, { |
|
at: this.state.curPosition() |
|
}); |
|
} |
|
} |
|
|
|
flowEnumErrorBooleanMemberNotInitialized(loc, { |
|
enumName, |
|
memberName |
|
}) { |
|
this.raise(FlowErrors.EnumBooleanMemberNotInitialized, { |
|
at: loc, |
|
memberName, |
|
enumName |
|
}); |
|
} |
|
|
|
flowEnumErrorInvalidMemberInitializer(loc, enumContext) { |
|
return this.raise(!enumContext.explicitType ? FlowErrors.EnumInvalidMemberInitializerUnknownType : enumContext.explicitType === "symbol" ? FlowErrors.EnumInvalidMemberInitializerSymbolType : FlowErrors.EnumInvalidMemberInitializerPrimaryType, Object.assign({ |
|
at: loc |
|
}, enumContext)); |
|
} |
|
|
|
flowEnumErrorNumberMemberNotInitialized(loc, { |
|
enumName, |
|
memberName |
|
}) { |
|
this.raise(FlowErrors.EnumNumberMemberNotInitialized, { |
|
at: loc, |
|
enumName, |
|
memberName |
|
}); |
|
} |
|
|
|
flowEnumErrorStringMemberInconsistentlyInitailized(node, { |
|
enumName |
|
}) { |
|
this.raise(FlowErrors.EnumStringMemberInconsistentlyInitailized, { |
|
at: node, |
|
enumName |
|
}); |
|
} |
|
|
|
flowEnumMemberInit() { |
|
const startLoc = this.state.startLoc; |
|
|
|
const endOfInit = () => this.match(12) || this.match(8); |
|
|
|
switch (this.state.type) { |
|
case 130: |
|
{ |
|
const literal = this.parseNumericLiteral(this.state.value); |
|
|
|
if (endOfInit()) { |
|
return { |
|
type: "number", |
|
loc: literal.loc.start, |
|
value: literal |
|
}; |
|
} |
|
|
|
return { |
|
type: "invalid", |
|
loc: startLoc |
|
}; |
|
} |
|
|
|
case 129: |
|
{ |
|
const literal = this.parseStringLiteral(this.state.value); |
|
|
|
if (endOfInit()) { |
|
return { |
|
type: "string", |
|
loc: literal.loc.start, |
|
value: literal |
|
}; |
|
} |
|
|
|
return { |
|
type: "invalid", |
|
loc: startLoc |
|
}; |
|
} |
|
|
|
case 85: |
|
case 86: |
|
{ |
|
const literal = this.parseBooleanLiteral(this.match(85)); |
|
|
|
if (endOfInit()) { |
|
return { |
|
type: "boolean", |
|
loc: literal.loc.start, |
|
value: literal |
|
}; |
|
} |
|
|
|
return { |
|
type: "invalid", |
|
loc: startLoc |
|
}; |
|
} |
|
|
|
default: |
|
return { |
|
type: "invalid", |
|
loc: startLoc |
|
}; |
|
} |
|
} |
|
|
|
flowEnumMemberRaw() { |
|
const loc = this.state.startLoc; |
|
const id = this.parseIdentifier(true); |
|
const init = this.eat(29) ? this.flowEnumMemberInit() : { |
|
type: "none", |
|
loc |
|
}; |
|
return { |
|
id, |
|
init |
|
}; |
|
} |
|
|
|
flowEnumCheckExplicitTypeMismatch(loc, context, expectedType) { |
|
const { |
|
explicitType |
|
} = context; |
|
|
|
if (explicitType === null) { |
|
return; |
|
} |
|
|
|
if (explicitType !== expectedType) { |
|
this.flowEnumErrorInvalidMemberInitializer(loc, context); |
|
} |
|
} |
|
|
|
flowEnumMembers({ |
|
enumName, |
|
explicitType |
|
}) { |
|
const seenNames = new Set(); |
|
const members = { |
|
booleanMembers: [], |
|
numberMembers: [], |
|
stringMembers: [], |
|
defaultedMembers: [] |
|
}; |
|
let hasUnknownMembers = false; |
|
|
|
while (!this.match(8)) { |
|
if (this.eat(21)) { |
|
hasUnknownMembers = true; |
|
break; |
|
} |
|
|
|
const memberNode = this.startNode(); |
|
const { |
|
id, |
|
init |
|
} = this.flowEnumMemberRaw(); |
|
const memberName = id.name; |
|
|
|
if (memberName === "") { |
|
continue; |
|
} |
|
|
|
if (/^[a-z]/.test(memberName)) { |
|
this.raise(FlowErrors.EnumInvalidMemberName, { |
|
at: id, |
|
memberName, |
|
suggestion: memberName[0].toUpperCase() + memberName.slice(1), |
|
enumName |
|
}); |
|
} |
|
|
|
if (seenNames.has(memberName)) { |
|
this.raise(FlowErrors.EnumDuplicateMemberName, { |
|
at: id, |
|
memberName, |
|
enumName |
|
}); |
|
} |
|
|
|
seenNames.add(memberName); |
|
const context = { |
|
enumName, |
|
explicitType, |
|
memberName |
|
}; |
|
memberNode.id = id; |
|
|
|
switch (init.type) { |
|
case "boolean": |
|
{ |
|
this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "boolean"); |
|
memberNode.init = init.value; |
|
members.booleanMembers.push(this.finishNode(memberNode, "EnumBooleanMember")); |
|
break; |
|
} |
|
|
|
case "number": |
|
{ |
|
this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "number"); |
|
memberNode.init = init.value; |
|
members.numberMembers.push(this.finishNode(memberNode, "EnumNumberMember")); |
|
break; |
|
} |
|
|
|
case "string": |
|
{ |
|
this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "string"); |
|
memberNode.init = init.value; |
|
members.stringMembers.push(this.finishNode(memberNode, "EnumStringMember")); |
|
break; |
|
} |
|
|
|
case "invalid": |
|
{ |
|
throw this.flowEnumErrorInvalidMemberInitializer(init.loc, context); |
|
} |
|
|
|
case "none": |
|
{ |
|
switch (explicitType) { |
|
case "boolean": |
|
this.flowEnumErrorBooleanMemberNotInitialized(init.loc, context); |
|
break; |
|
|
|
case "number": |
|
this.flowEnumErrorNumberMemberNotInitialized(init.loc, context); |
|
break; |
|
|
|
default: |
|
members.defaultedMembers.push(this.finishNode(memberNode, "EnumDefaultedMember")); |
|
} |
|
} |
|
} |
|
|
|
if (!this.match(8)) { |
|
this.expect(12); |
|
} |
|
} |
|
|
|
return { |
|
members, |
|
hasUnknownMembers |
|
}; |
|
} |
|
|
|
flowEnumStringMembers(initializedMembers, defaultedMembers, { |
|
enumName |
|
}) { |
|
if (initializedMembers.length === 0) { |
|
return defaultedMembers; |
|
} else if (defaultedMembers.length === 0) { |
|
return initializedMembers; |
|
} else if (defaultedMembers.length > initializedMembers.length) { |
|
for (const member of initializedMembers) { |
|
this.flowEnumErrorStringMemberInconsistentlyInitailized(member, { |
|
enumName |
|
}); |
|
} |
|
|
|
return defaultedMembers; |
|
} else { |
|
for (const member of defaultedMembers) { |
|
this.flowEnumErrorStringMemberInconsistentlyInitailized(member, { |
|
enumName |
|
}); |
|
} |
|
|
|
return initializedMembers; |
|
} |
|
} |
|
|
|
flowEnumParseExplicitType({ |
|
enumName |
|
}) { |
|
if (!this.eatContextual(101)) return null; |
|
|
|
if (!tokenIsIdentifier(this.state.type)) { |
|
throw this.raise(FlowErrors.EnumInvalidExplicitTypeUnknownSupplied, { |
|
at: this.state.startLoc, |
|
enumName |
|
}); |
|
} |
|
|
|
const { |
|
value |
|
} = this.state; |
|
this.next(); |
|
|
|
if (value !== "boolean" && value !== "number" && value !== "string" && value !== "symbol") { |
|
this.raise(FlowErrors.EnumInvalidExplicitType, { |
|
at: this.state.startLoc, |
|
enumName, |
|
invalidEnumType: value |
|
}); |
|
} |
|
|
|
return value; |
|
} |
|
|
|
flowEnumBody(node, id) { |
|
const enumName = id.name; |
|
const nameLoc = id.loc.start; |
|
const explicitType = this.flowEnumParseExplicitType({ |
|
enumName |
|
}); |
|
this.expect(5); |
|
const { |
|
members, |
|
hasUnknownMembers |
|
} = this.flowEnumMembers({ |
|
enumName, |
|
explicitType |
|
}); |
|
node.hasUnknownMembers = hasUnknownMembers; |
|
|
|
switch (explicitType) { |
|
case "boolean": |
|
node.explicitType = true; |
|
node.members = members.booleanMembers; |
|
this.expect(8); |
|
return this.finishNode(node, "EnumBooleanBody"); |
|
|
|
case "number": |
|
node.explicitType = true; |
|
node.members = members.numberMembers; |
|
this.expect(8); |
|
return this.finishNode(node, "EnumNumberBody"); |
|
|
|
case "string": |
|
node.explicitType = true; |
|
node.members = this.flowEnumStringMembers(members.stringMembers, members.defaultedMembers, { |
|
enumName |
|
}); |
|
this.expect(8); |
|
return this.finishNode(node, "EnumStringBody"); |
|
|
|
case "symbol": |
|
node.members = members.defaultedMembers; |
|
this.expect(8); |
|
return this.finishNode(node, "EnumSymbolBody"); |
|
|
|
default: |
|
{ |
|
const empty = () => { |
|
node.members = []; |
|
this.expect(8); |
|
return this.finishNode(node, "EnumStringBody"); |
|
}; |
|
|
|
node.explicitType = false; |
|
const boolsLen = members.booleanMembers.length; |
|
const numsLen = members.numberMembers.length; |
|
const strsLen = members.stringMembers.length; |
|
const defaultedLen = members.defaultedMembers.length; |
|
|
|
if (!boolsLen && !numsLen && !strsLen && !defaultedLen) { |
|
return empty(); |
|
} else if (!boolsLen && !numsLen) { |
|
node.members = this.flowEnumStringMembers(members.stringMembers, members.defaultedMembers, { |
|
enumName |
|
}); |
|
this.expect(8); |
|
return this.finishNode(node, "EnumStringBody"); |
|
} else if (!numsLen && !strsLen && boolsLen >= defaultedLen) { |
|
for (const member of members.defaultedMembers) { |
|
this.flowEnumErrorBooleanMemberNotInitialized(member.loc.start, { |
|
enumName, |
|
memberName: member.id.name |
|
}); |
|
} |
|
|
|
node.members = members.booleanMembers; |
|
this.expect(8); |
|
return this.finishNode(node, "EnumBooleanBody"); |
|
} else if (!boolsLen && !strsLen && numsLen >= defaultedLen) { |
|
for (const member of members.defaultedMembers) { |
|
this.flowEnumErrorNumberMemberNotInitialized(member.loc.start, { |
|
enumName, |
|
memberName: member.id.name |
|
}); |
|
} |
|
|
|
node.members = members.numberMembers; |
|
this.expect(8); |
|
return this.finishNode(node, "EnumNumberBody"); |
|
} else { |
|
this.raise(FlowErrors.EnumInconsistentMemberValues, { |
|
at: nameLoc, |
|
enumName |
|
}); |
|
return empty(); |
|
} |
|
} |
|
} |
|
} |
|
|
|
flowParseEnumDeclaration(node) { |
|
const id = this.parseIdentifier(); |
|
node.id = id; |
|
node.body = this.flowEnumBody(this.startNode(), id); |
|
return this.finishNode(node, "EnumDeclaration"); |
|
} |
|
|
|
isLookaheadToken_lt() { |
|
const next = this.nextTokenStart(); |
|
|
|
if (this.input.charCodeAt(next) === 60) { |
|
const afterNext = this.input.charCodeAt(next + 1); |
|
return afterNext !== 60 && afterNext !== 61; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
maybeUnwrapTypeCastExpression(node) { |
|
return node.type === "TypeCastExpression" ? node.expression : node; |
|
} |
|
|
|
}); |
|
|
|
const entities = { |
|
__proto__: null, |
|
quot: "\u0022", |
|
amp: "&", |
|
apos: "\u0027", |
|
lt: "<", |
|
gt: ">", |
|
nbsp: "\u00A0", |
|
iexcl: "\u00A1", |
|
cent: "\u00A2", |
|
pound: "\u00A3", |
|
curren: "\u00A4", |
|
yen: "\u00A5", |
|
brvbar: "\u00A6", |
|
sect: "\u00A7", |
|
uml: "\u00A8", |
|
copy: "\u00A9", |
|
ordf: "\u00AA", |
|
laquo: "\u00AB", |
|
not: "\u00AC", |
|
shy: "\u00AD", |
|
reg: "\u00AE", |
|
macr: "\u00AF", |
|
deg: "\u00B0", |
|
plusmn: "\u00B1", |
|
sup2: "\u00B2", |
|
sup3: "\u00B3", |
|
acute: "\u00B4", |
|
micro: "\u00B5", |
|
para: "\u00B6", |
|
middot: "\u00B7", |
|
cedil: "\u00B8", |
|
sup1: "\u00B9", |
|
ordm: "\u00BA", |
|
raquo: "\u00BB", |
|
frac14: "\u00BC", |
|
frac12: "\u00BD", |
|
frac34: "\u00BE", |
|
iquest: "\u00BF", |
|
Agrave: "\u00C0", |
|
Aacute: "\u00C1", |
|
Acirc: "\u00C2", |
|
Atilde: "\u00C3", |
|
Auml: "\u00C4", |
|
Aring: "\u00C5", |
|
AElig: "\u00C6", |
|
Ccedil: "\u00C7", |
|
Egrave: "\u00C8", |
|
Eacute: "\u00C9", |
|
Ecirc: "\u00CA", |
|
Euml: "\u00CB", |
|
Igrave: "\u00CC", |
|
Iacute: "\u00CD", |
|
Icirc: "\u00CE", |
|
Iuml: "\u00CF", |
|
ETH: "\u00D0", |
|
Ntilde: "\u00D1", |
|
Ograve: "\u00D2", |
|
Oacute: "\u00D3", |
|
Ocirc: "\u00D4", |
|
Otilde: "\u00D5", |
|
Ouml: "\u00D6", |
|
times: "\u00D7", |
|
Oslash: "\u00D8", |
|
Ugrave: "\u00D9", |
|
Uacute: "\u00DA", |
|
Ucirc: "\u00DB", |
|
Uuml: "\u00DC", |
|
Yacute: "\u00DD", |
|
THORN: "\u00DE", |
|
szlig: "\u00DF", |
|
agrave: "\u00E0", |
|
aacute: "\u00E1", |
|
acirc: "\u00E2", |
|
atilde: "\u00E3", |
|
auml: "\u00E4", |
|
aring: "\u00E5", |
|
aelig: "\u00E6", |
|
ccedil: "\u00E7", |
|
egrave: "\u00E8", |
|
eacute: "\u00E9", |
|
ecirc: "\u00EA", |
|
euml: "\u00EB", |
|
igrave: "\u00EC", |
|
iacute: "\u00ED", |
|
icirc: "\u00EE", |
|
iuml: "\u00EF", |
|
eth: "\u00F0", |
|
ntilde: "\u00F1", |
|
ograve: "\u00F2", |
|
oacute: "\u00F3", |
|
ocirc: "\u00F4", |
|
otilde: "\u00F5", |
|
ouml: "\u00F6", |
|
divide: "\u00F7", |
|
oslash: "\u00F8", |
|
ugrave: "\u00F9", |
|
uacute: "\u00FA", |
|
ucirc: "\u00FB", |
|
uuml: "\u00FC", |
|
yacute: "\u00FD", |
|
thorn: "\u00FE", |
|
yuml: "\u00FF", |
|
OElig: "\u0152", |
|
oelig: "\u0153", |
|
Scaron: "\u0160", |
|
scaron: "\u0161", |
|
Yuml: "\u0178", |
|
fnof: "\u0192", |
|
circ: "\u02C6", |
|
tilde: "\u02DC", |
|
Alpha: "\u0391", |
|
Beta: "\u0392", |
|
Gamma: "\u0393", |
|
Delta: "\u0394", |
|
Epsilon: "\u0395", |
|
Zeta: "\u0396", |
|
Eta: "\u0397", |
|
Theta: "\u0398", |
|
Iota: "\u0399", |
|
Kappa: "\u039A", |
|
Lambda: "\u039B", |
|
Mu: "\u039C", |
|
Nu: "\u039D", |
|
Xi: "\u039E", |
|
Omicron: "\u039F", |
|
Pi: "\u03A0", |
|
Rho: "\u03A1", |
|
Sigma: "\u03A3", |
|
Tau: "\u03A4", |
|
Upsilon: "\u03A5", |
|
Phi: "\u03A6", |
|
Chi: "\u03A7", |
|
Psi: "\u03A8", |
|
Omega: "\u03A9", |
|
alpha: "\u03B1", |
|
beta: "\u03B2", |
|
gamma: "\u03B3", |
|
delta: "\u03B4", |
|
epsilon: "\u03B5", |
|
zeta: "\u03B6", |
|
eta: "\u03B7", |
|
theta: "\u03B8", |
|
iota: "\u03B9", |
|
kappa: "\u03BA", |
|
lambda: "\u03BB", |
|
mu: "\u03BC", |
|
nu: "\u03BD", |
|
xi: "\u03BE", |
|
omicron: "\u03BF", |
|
pi: "\u03C0", |
|
rho: "\u03C1", |
|
sigmaf: "\u03C2", |
|
sigma: "\u03C3", |
|
tau: "\u03C4", |
|
upsilon: "\u03C5", |
|
phi: "\u03C6", |
|
chi: "\u03C7", |
|
psi: "\u03C8", |
|
omega: "\u03C9", |
|
thetasym: "\u03D1", |
|
upsih: "\u03D2", |
|
piv: "\u03D6", |
|
ensp: "\u2002", |
|
emsp: "\u2003", |
|
thinsp: "\u2009", |
|
zwnj: "\u200C", |
|
zwj: "\u200D", |
|
lrm: "\u200E", |
|
rlm: "\u200F", |
|
ndash: "\u2013", |
|
mdash: "\u2014", |
|
lsquo: "\u2018", |
|
rsquo: "\u2019", |
|
sbquo: "\u201A", |
|
ldquo: "\u201C", |
|
rdquo: "\u201D", |
|
bdquo: "\u201E", |
|
dagger: "\u2020", |
|
Dagger: "\u2021", |
|
bull: "\u2022", |
|
hellip: "\u2026", |
|
permil: "\u2030", |
|
prime: "\u2032", |
|
Prime: "\u2033", |
|
lsaquo: "\u2039", |
|
rsaquo: "\u203A", |
|
oline: "\u203E", |
|
frasl: "\u2044", |
|
euro: "\u20AC", |
|
image: "\u2111", |
|
weierp: "\u2118", |
|
real: "\u211C", |
|
trade: "\u2122", |
|
alefsym: "\u2135", |
|
larr: "\u2190", |
|
uarr: "\u2191", |
|
rarr: "\u2192", |
|
darr: "\u2193", |
|
harr: "\u2194", |
|
crarr: "\u21B5", |
|
lArr: "\u21D0", |
|
uArr: "\u21D1", |
|
rArr: "\u21D2", |
|
dArr: "\u21D3", |
|
hArr: "\u21D4", |
|
forall: "\u2200", |
|
part: "\u2202", |
|
exist: "\u2203", |
|
empty: "\u2205", |
|
nabla: "\u2207", |
|
isin: "\u2208", |
|
notin: "\u2209", |
|
ni: "\u220B", |
|
prod: "\u220F", |
|
sum: "\u2211", |
|
minus: "\u2212", |
|
lowast: "\u2217", |
|
radic: "\u221A", |
|
prop: "\u221D", |
|
infin: "\u221E", |
|
ang: "\u2220", |
|
and: "\u2227", |
|
or: "\u2228", |
|
cap: "\u2229", |
|
cup: "\u222A", |
|
int: "\u222B", |
|
there4: "\u2234", |
|
sim: "\u223C", |
|
cong: "\u2245", |
|
asymp: "\u2248", |
|
ne: "\u2260", |
|
equiv: "\u2261", |
|
le: "\u2264", |
|
ge: "\u2265", |
|
sub: "\u2282", |
|
sup: "\u2283", |
|
nsub: "\u2284", |
|
sube: "\u2286", |
|
supe: "\u2287", |
|
oplus: "\u2295", |
|
otimes: "\u2297", |
|
perp: "\u22A5", |
|
sdot: "\u22C5", |
|
lceil: "\u2308", |
|
rceil: "\u2309", |
|
lfloor: "\u230A", |
|
rfloor: "\u230B", |
|
lang: "\u2329", |
|
rang: "\u232A", |
|
loz: "\u25CA", |
|
spades: "\u2660", |
|
clubs: "\u2663", |
|
hearts: "\u2665", |
|
diams: "\u2666" |
|
}; |
|
|
|
const JsxErrors = ParseErrorEnum`jsx`(_ => ({ |
|
AttributeIsEmpty: _("JSX attributes must only be assigned a non-empty expression."), |
|
MissingClosingTagElement: _(({ |
|
openingTagName |
|
}) => `Expected corresponding JSX closing tag for <${openingTagName}>.`), |
|
MissingClosingTagFragment: _("Expected corresponding JSX closing tag for <>."), |
|
UnexpectedSequenceExpression: _("Sequence expressions cannot be directly nested inside JSX. Did you mean to wrap it in parentheses (...)?"), |
|
UnexpectedToken: _(({ |
|
unexpected, |
|
HTMLEntity |
|
}) => `Unexpected token \`${unexpected}\`. Did you mean \`${HTMLEntity}\` or \`{'${unexpected}'}\`?`), |
|
UnsupportedJsxValue: _("JSX value should be either an expression or a quoted JSX text."), |
|
UnterminatedJsxContent: _("Unterminated JSX contents."), |
|
UnwrappedAdjacentJSXElements: _("Adjacent JSX elements must be wrapped in an enclosing tag. Did you want a JSX fragment <>...</>?") |
|
})); |
|
|
|
function isFragment(object) { |
|
return object ? object.type === "JSXOpeningFragment" || object.type === "JSXClosingFragment" : false; |
|
} |
|
|
|
function getQualifiedJSXName(object) { |
|
if (object.type === "JSXIdentifier") { |
|
return object.name; |
|
} |
|
|
|
if (object.type === "JSXNamespacedName") { |
|
return object.namespace.name + ":" + object.name.name; |
|
} |
|
|
|
if (object.type === "JSXMemberExpression") { |
|
return getQualifiedJSXName(object.object) + "." + getQualifiedJSXName(object.property); |
|
} |
|
|
|
throw new Error("Node had unexpected type: " + object.type); |
|
} |
|
|
|
var jsx = (superClass => class extends superClass { |
|
jsxReadToken() { |
|
let out = ""; |
|
let chunkStart = this.state.pos; |
|
|
|
for (;;) { |
|
if (this.state.pos >= this.length) { |
|
throw this.raise(JsxErrors.UnterminatedJsxContent, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
|
|
const ch = this.input.charCodeAt(this.state.pos); |
|
|
|
switch (ch) { |
|
case 60: |
|
case 123: |
|
if (this.state.pos === this.state.start) { |
|
if (ch === 60 && this.state.canStartJSXElement) { |
|
++this.state.pos; |
|
return this.finishToken(138); |
|
} |
|
|
|
return super.getTokenFromCode(ch); |
|
} |
|
|
|
out += this.input.slice(chunkStart, this.state.pos); |
|
return this.finishToken(137, out); |
|
|
|
case 38: |
|
out += this.input.slice(chunkStart, this.state.pos); |
|
out += this.jsxReadEntity(); |
|
chunkStart = this.state.pos; |
|
break; |
|
|
|
case 62: |
|
case 125: |
|
|
|
default: |
|
if (isNewLine(ch)) { |
|
out += this.input.slice(chunkStart, this.state.pos); |
|
out += this.jsxReadNewLine(true); |
|
chunkStart = this.state.pos; |
|
} else { |
|
++this.state.pos; |
|
} |
|
|
|
} |
|
} |
|
} |
|
|
|
jsxReadNewLine(normalizeCRLF) { |
|
const ch = this.input.charCodeAt(this.state.pos); |
|
let out; |
|
++this.state.pos; |
|
|
|
if (ch === 13 && this.input.charCodeAt(this.state.pos) === 10) { |
|
++this.state.pos; |
|
out = normalizeCRLF ? "\n" : "\r\n"; |
|
} else { |
|
out = String.fromCharCode(ch); |
|
} |
|
|
|
++this.state.curLine; |
|
this.state.lineStart = this.state.pos; |
|
return out; |
|
} |
|
|
|
jsxReadString(quote) { |
|
let out = ""; |
|
let chunkStart = ++this.state.pos; |
|
|
|
for (;;) { |
|
if (this.state.pos >= this.length) { |
|
throw this.raise(Errors.UnterminatedString, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
|
|
const ch = this.input.charCodeAt(this.state.pos); |
|
if (ch === quote) break; |
|
|
|
if (ch === 38) { |
|
out += this.input.slice(chunkStart, this.state.pos); |
|
out += this.jsxReadEntity(); |
|
chunkStart = this.state.pos; |
|
} else if (isNewLine(ch)) { |
|
out += this.input.slice(chunkStart, this.state.pos); |
|
out += this.jsxReadNewLine(false); |
|
chunkStart = this.state.pos; |
|
} else { |
|
++this.state.pos; |
|
} |
|
} |
|
|
|
out += this.input.slice(chunkStart, this.state.pos++); |
|
return this.finishToken(129, out); |
|
} |
|
|
|
jsxReadEntity() { |
|
const startPos = ++this.state.pos; |
|
|
|
if (this.codePointAtPos(this.state.pos) === 35) { |
|
++this.state.pos; |
|
let radix = 10; |
|
|
|
if (this.codePointAtPos(this.state.pos) === 120) { |
|
radix = 16; |
|
++this.state.pos; |
|
} |
|
|
|
const codePoint = this.readInt(radix, undefined, false, "bail"); |
|
|
|
if (codePoint !== null && this.codePointAtPos(this.state.pos) === 59) { |
|
++this.state.pos; |
|
return String.fromCodePoint(codePoint); |
|
} |
|
} else { |
|
let count = 0; |
|
let semi = false; |
|
|
|
while (count++ < 10 && this.state.pos < this.length && !(semi = this.codePointAtPos(this.state.pos) == 59)) { |
|
++this.state.pos; |
|
} |
|
|
|
if (semi) { |
|
const desc = this.input.slice(startPos, this.state.pos); |
|
const entity = entities[desc]; |
|
++this.state.pos; |
|
|
|
if (entity) { |
|
return entity; |
|
} |
|
} |
|
} |
|
|
|
this.state.pos = startPos; |
|
return "&"; |
|
} |
|
|
|
jsxReadWord() { |
|
let ch; |
|
const start = this.state.pos; |
|
|
|
do { |
|
ch = this.input.charCodeAt(++this.state.pos); |
|
} while (isIdentifierChar(ch) || ch === 45); |
|
|
|
return this.finishToken(136, this.input.slice(start, this.state.pos)); |
|
} |
|
|
|
jsxParseIdentifier() { |
|
const node = this.startNode(); |
|
|
|
if (this.match(136)) { |
|
node.name = this.state.value; |
|
} else if (tokenIsKeyword(this.state.type)) { |
|
node.name = tokenLabelName(this.state.type); |
|
} else { |
|
this.unexpected(); |
|
} |
|
|
|
this.next(); |
|
return this.finishNode(node, "JSXIdentifier"); |
|
} |
|
|
|
jsxParseNamespacedName() { |
|
const startPos = this.state.start; |
|
const startLoc = this.state.startLoc; |
|
const name = this.jsxParseIdentifier(); |
|
if (!this.eat(14)) return name; |
|
const node = this.startNodeAt(startPos, startLoc); |
|
node.namespace = name; |
|
node.name = this.jsxParseIdentifier(); |
|
return this.finishNode(node, "JSXNamespacedName"); |
|
} |
|
|
|
jsxParseElementName() { |
|
const startPos = this.state.start; |
|
const startLoc = this.state.startLoc; |
|
let node = this.jsxParseNamespacedName(); |
|
|
|
if (node.type === "JSXNamespacedName") { |
|
return node; |
|
} |
|
|
|
while (this.eat(16)) { |
|
const newNode = this.startNodeAt(startPos, startLoc); |
|
newNode.object = node; |
|
newNode.property = this.jsxParseIdentifier(); |
|
node = this.finishNode(newNode, "JSXMemberExpression"); |
|
} |
|
|
|
return node; |
|
} |
|
|
|
jsxParseAttributeValue() { |
|
let node; |
|
|
|
switch (this.state.type) { |
|
case 5: |
|
node = this.startNode(); |
|
this.setContext(types.brace); |
|
this.next(); |
|
node = this.jsxParseExpressionContainer(node, types.j_oTag); |
|
|
|
if (node.expression.type === "JSXEmptyExpression") { |
|
this.raise(JsxErrors.AttributeIsEmpty, { |
|
at: node |
|
}); |
|
} |
|
|
|
return node; |
|
|
|
case 138: |
|
case 129: |
|
return this.parseExprAtom(); |
|
|
|
default: |
|
throw this.raise(JsxErrors.UnsupportedJsxValue, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
} |
|
|
|
jsxParseEmptyExpression() { |
|
const node = this.startNodeAt(this.state.lastTokEndLoc.index, this.state.lastTokEndLoc); |
|
return this.finishNodeAt(node, "JSXEmptyExpression", this.state.startLoc); |
|
} |
|
|
|
jsxParseSpreadChild(node) { |
|
this.next(); |
|
node.expression = this.parseExpression(); |
|
this.setContext(types.j_oTag); |
|
this.state.canStartJSXElement = true; |
|
this.expect(8); |
|
return this.finishNode(node, "JSXSpreadChild"); |
|
} |
|
|
|
jsxParseExpressionContainer(node, previousContext) { |
|
if (this.match(8)) { |
|
node.expression = this.jsxParseEmptyExpression(); |
|
} else { |
|
const expression = this.parseExpression(); |
|
node.expression = expression; |
|
} |
|
|
|
this.setContext(previousContext); |
|
this.state.canStartJSXElement = true; |
|
this.expect(8); |
|
return this.finishNode(node, "JSXExpressionContainer"); |
|
} |
|
|
|
jsxParseAttribute() { |
|
const node = this.startNode(); |
|
|
|
if (this.match(5)) { |
|
this.setContext(types.brace); |
|
this.next(); |
|
this.expect(21); |
|
node.argument = this.parseMaybeAssignAllowIn(); |
|
this.setContext(types.j_oTag); |
|
this.state.canStartJSXElement = true; |
|
this.expect(8); |
|
return this.finishNode(node, "JSXSpreadAttribute"); |
|
} |
|
|
|
node.name = this.jsxParseNamespacedName(); |
|
node.value = this.eat(29) ? this.jsxParseAttributeValue() : null; |
|
return this.finishNode(node, "JSXAttribute"); |
|
} |
|
|
|
jsxParseOpeningElementAt(startPos, startLoc) { |
|
const node = this.startNodeAt(startPos, startLoc); |
|
|
|
if (this.eat(139)) { |
|
return this.finishNode(node, "JSXOpeningFragment"); |
|
} |
|
|
|
node.name = this.jsxParseElementName(); |
|
return this.jsxParseOpeningElementAfterName(node); |
|
} |
|
|
|
jsxParseOpeningElementAfterName(node) { |
|
const attributes = []; |
|
|
|
while (!this.match(56) && !this.match(139)) { |
|
attributes.push(this.jsxParseAttribute()); |
|
} |
|
|
|
node.attributes = attributes; |
|
node.selfClosing = this.eat(56); |
|
this.expect(139); |
|
return this.finishNode(node, "JSXOpeningElement"); |
|
} |
|
|
|
jsxParseClosingElementAt(startPos, startLoc) { |
|
const node = this.startNodeAt(startPos, startLoc); |
|
|
|
if (this.eat(139)) { |
|
return this.finishNode(node, "JSXClosingFragment"); |
|
} |
|
|
|
node.name = this.jsxParseElementName(); |
|
this.expect(139); |
|
return this.finishNode(node, "JSXClosingElement"); |
|
} |
|
|
|
jsxParseElementAt(startPos, startLoc) { |
|
const node = this.startNodeAt(startPos, startLoc); |
|
const children = []; |
|
const openingElement = this.jsxParseOpeningElementAt(startPos, startLoc); |
|
let closingElement = null; |
|
|
|
if (!openingElement.selfClosing) { |
|
contents: for (;;) { |
|
switch (this.state.type) { |
|
case 138: |
|
startPos = this.state.start; |
|
startLoc = this.state.startLoc; |
|
this.next(); |
|
|
|
if (this.eat(56)) { |
|
closingElement = this.jsxParseClosingElementAt(startPos, startLoc); |
|
break contents; |
|
} |
|
|
|
children.push(this.jsxParseElementAt(startPos, startLoc)); |
|
break; |
|
|
|
case 137: |
|
children.push(this.parseExprAtom()); |
|
break; |
|
|
|
case 5: |
|
{ |
|
const node = this.startNode(); |
|
this.setContext(types.brace); |
|
this.next(); |
|
|
|
if (this.match(21)) { |
|
children.push(this.jsxParseSpreadChild(node)); |
|
} else { |
|
children.push(this.jsxParseExpressionContainer(node, types.j_expr)); |
|
} |
|
|
|
break; |
|
} |
|
|
|
default: |
|
throw this.unexpected(); |
|
} |
|
} |
|
|
|
if (isFragment(openingElement) && !isFragment(closingElement) && closingElement !== null) { |
|
this.raise(JsxErrors.MissingClosingTagFragment, { |
|
at: closingElement |
|
}); |
|
} else if (!isFragment(openingElement) && isFragment(closingElement)) { |
|
this.raise(JsxErrors.MissingClosingTagElement, { |
|
at: closingElement, |
|
openingTagName: getQualifiedJSXName(openingElement.name) |
|
}); |
|
} else if (!isFragment(openingElement) && !isFragment(closingElement)) { |
|
if (getQualifiedJSXName(closingElement.name) !== getQualifiedJSXName(openingElement.name)) { |
|
this.raise(JsxErrors.MissingClosingTagElement, { |
|
at: closingElement, |
|
openingTagName: getQualifiedJSXName(openingElement.name) |
|
}); |
|
} |
|
} |
|
} |
|
|
|
if (isFragment(openingElement)) { |
|
node.openingFragment = openingElement; |
|
node.closingFragment = closingElement; |
|
} else { |
|
node.openingElement = openingElement; |
|
node.closingElement = closingElement; |
|
} |
|
|
|
node.children = children; |
|
|
|
if (this.match(47)) { |
|
throw this.raise(JsxErrors.UnwrappedAdjacentJSXElements, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
|
|
return isFragment(openingElement) ? this.finishNode(node, "JSXFragment") : this.finishNode(node, "JSXElement"); |
|
} |
|
|
|
jsxParseElement() { |
|
const startPos = this.state.start; |
|
const startLoc = this.state.startLoc; |
|
this.next(); |
|
return this.jsxParseElementAt(startPos, startLoc); |
|
} |
|
|
|
setContext(newContext) { |
|
const { |
|
context |
|
} = this.state; |
|
context[context.length - 1] = newContext; |
|
} |
|
|
|
parseExprAtom(refExpressionErrors) { |
|
if (this.match(137)) { |
|
return this.parseLiteral(this.state.value, "JSXText"); |
|
} else if (this.match(138)) { |
|
return this.jsxParseElement(); |
|
} else if (this.match(47) && this.input.charCodeAt(this.state.pos) !== 33) { |
|
this.replaceToken(138); |
|
return this.jsxParseElement(); |
|
} else { |
|
return super.parseExprAtom(refExpressionErrors); |
|
} |
|
} |
|
|
|
skipSpace() { |
|
const curContext = this.curContext(); |
|
if (!curContext.preserveSpace) super.skipSpace(); |
|
} |
|
|
|
getTokenFromCode(code) { |
|
const context = this.curContext(); |
|
|
|
if (context === types.j_expr) { |
|
return this.jsxReadToken(); |
|
} |
|
|
|
if (context === types.j_oTag || context === types.j_cTag) { |
|
if (isIdentifierStart(code)) { |
|
return this.jsxReadWord(); |
|
} |
|
|
|
if (code === 62) { |
|
++this.state.pos; |
|
return this.finishToken(139); |
|
} |
|
|
|
if ((code === 34 || code === 39) && context === types.j_oTag) { |
|
return this.jsxReadString(code); |
|
} |
|
} |
|
|
|
if (code === 60 && this.state.canStartJSXElement && this.input.charCodeAt(this.state.pos + 1) !== 33) { |
|
++this.state.pos; |
|
return this.finishToken(138); |
|
} |
|
|
|
return super.getTokenFromCode(code); |
|
} |
|
|
|
updateContext(prevType) { |
|
const { |
|
context, |
|
type |
|
} = this.state; |
|
|
|
if (type === 56 && prevType === 138) { |
|
context.splice(-2, 2, types.j_cTag); |
|
this.state.canStartJSXElement = false; |
|
} else if (type === 138) { |
|
context.push(types.j_oTag); |
|
} else if (type === 139) { |
|
const out = context[context.length - 1]; |
|
|
|
if (out === types.j_oTag && prevType === 56 || out === types.j_cTag) { |
|
context.pop(); |
|
this.state.canStartJSXElement = context[context.length - 1] === types.j_expr; |
|
} else { |
|
this.setContext(types.j_expr); |
|
this.state.canStartJSXElement = true; |
|
} |
|
} else { |
|
this.state.canStartJSXElement = tokenComesBeforeExpression(type); |
|
} |
|
} |
|
|
|
}); |
|
|
|
class TypeScriptScope extends Scope { |
|
constructor(...args) { |
|
super(...args); |
|
this.types = new Set(); |
|
this.enums = new Set(); |
|
this.constEnums = new Set(); |
|
this.classes = new Set(); |
|
this.exportOnlyBindings = new Set(); |
|
} |
|
|
|
} |
|
|
|
class TypeScriptScopeHandler extends ScopeHandler { |
|
createScope(flags) { |
|
return new TypeScriptScope(flags); |
|
} |
|
|
|
declareName(name, bindingType, loc) { |
|
const scope = this.currentScope(); |
|
|
|
if (bindingType & BIND_FLAGS_TS_EXPORT_ONLY) { |
|
this.maybeExportDefined(scope, name); |
|
scope.exportOnlyBindings.add(name); |
|
return; |
|
} |
|
|
|
super.declareName(...arguments); |
|
|
|
if (bindingType & BIND_KIND_TYPE) { |
|
if (!(bindingType & BIND_KIND_VALUE)) { |
|
this.checkRedeclarationInScope(scope, name, bindingType, loc); |
|
this.maybeExportDefined(scope, name); |
|
} |
|
|
|
scope.types.add(name); |
|
} |
|
|
|
if (bindingType & BIND_FLAGS_TS_ENUM) scope.enums.add(name); |
|
if (bindingType & BIND_FLAGS_TS_CONST_ENUM) scope.constEnums.add(name); |
|
if (bindingType & BIND_FLAGS_CLASS) scope.classes.add(name); |
|
} |
|
|
|
isRedeclaredInScope(scope, name, bindingType) { |
|
if (scope.enums.has(name)) { |
|
if (bindingType & BIND_FLAGS_TS_ENUM) { |
|
const isConst = !!(bindingType & BIND_FLAGS_TS_CONST_ENUM); |
|
const wasConst = scope.constEnums.has(name); |
|
return isConst !== wasConst; |
|
} |
|
|
|
return true; |
|
} |
|
|
|
if (bindingType & BIND_FLAGS_CLASS && scope.classes.has(name)) { |
|
if (scope.lexical.has(name)) { |
|
return !!(bindingType & BIND_KIND_VALUE); |
|
} else { |
|
return false; |
|
} |
|
} |
|
|
|
if (bindingType & BIND_KIND_TYPE && scope.types.has(name)) { |
|
return true; |
|
} |
|
|
|
return super.isRedeclaredInScope(...arguments); |
|
} |
|
|
|
checkLocalExport(id) { |
|
const topLevelScope = this.scopeStack[0]; |
|
const { |
|
name |
|
} = id; |
|
|
|
if (!topLevelScope.types.has(name) && !topLevelScope.exportOnlyBindings.has(name)) { |
|
super.checkLocalExport(id); |
|
} |
|
} |
|
|
|
} |
|
|
|
const getOwn$1 = (object, key) => Object.hasOwnProperty.call(object, key) && object[key]; |
|
|
|
function nonNull(x) { |
|
if (x == null) { |
|
throw new Error(`Unexpected ${x} value.`); |
|
} |
|
|
|
return x; |
|
} |
|
|
|
function assert(x) { |
|
if (!x) { |
|
throw new Error("Assert fail"); |
|
} |
|
} |
|
|
|
const TSErrors = ParseErrorEnum`typescript`(_ => ({ |
|
AbstractMethodHasImplementation: _(({ |
|
methodName |
|
}) => `Method '${methodName}' cannot have an implementation because it is marked abstract.`), |
|
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."), |
|
CannotFindName: _(({ |
|
name |
|
}) => `Cannot find name '${name}'.`), |
|
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."), |
|
ConstructorHasTypeParameters: _("Type parameters cannot appear on a constructor declaration."), |
|
DeclareAccessor: _(({ |
|
kind |
|
}) => `'declare' is not allowed in ${kind}ters.`), |
|
DeclareClassFieldHasInitializer: _("Initializers are not allowed in ambient contexts."), |
|
DeclareFunctionHasImplementation: _("An implementation cannot be declared in ambient contexts."), |
|
DuplicateAccessibilityModifier: _(({ |
|
modifier |
|
}) => `Accessibility modifier already seen.`), |
|
DuplicateModifier: _(({ |
|
modifier |
|
}) => `Duplicate modifier: '${modifier}'.`), |
|
EmptyHeritageClauseType: _(({ |
|
token |
|
}) => `'${token}' list cannot be empty.`), |
|
EmptyTypeArguments: _("Type argument list cannot be empty."), |
|
EmptyTypeParameters: _("Type parameter list cannot be empty."), |
|
ExpectedAmbientAfterExportDeclare: _("'export declare' must be followed by an ambient declaration."), |
|
ImportAliasHasImportType: _("An import alias can not use 'import type'."), |
|
IncompatibleModifiers: _(({ |
|
modifiers |
|
}) => `'${modifiers[0]}' modifier cannot be used with '${modifiers[1]}' modifier.`), |
|
IndexSignatureHasAbstract: _("Index signatures cannot have the 'abstract' modifier."), |
|
IndexSignatureHasAccessibility: _(({ |
|
modifier |
|
}) => `Index signatures cannot have an accessibility modifier ('${modifier}').`), |
|
IndexSignatureHasDeclare: _("Index signatures cannot have the 'declare' modifier."), |
|
IndexSignatureHasOverride: _("'override' modifier cannot appear on an index signature."), |
|
IndexSignatureHasStatic: _("Index signatures cannot have the 'static' modifier."), |
|
InitializerNotAllowedInAmbientContext: _("Initializers are not allowed in ambient contexts."), |
|
InvalidModifierOnTypeMember: _(({ |
|
modifier |
|
}) => `'${modifier}' modifier cannot appear on a type member.`), |
|
InvalidModifierOnTypeParameter: _(({ |
|
modifier |
|
}) => `'${modifier}' modifier cannot appear on a type parameter.`), |
|
InvalidModifierOnTypeParameterPositions: _(({ |
|
modifier |
|
}) => `'${modifier}' modifier can only appear on a type parameter of a class, interface or type alias.`), |
|
InvalidModifiersOrder: _(({ |
|
orderedModifiers |
|
}) => `'${orderedModifiers[0]}' modifier must precede '${orderedModifiers[1]}' modifier.`), |
|
InvalidPropertyAccessAfterInstantiationExpression: _("Invalid property access after an instantiation expression. " + "You can either wrap the instantiation expression in parentheses, or delete the type arguments."), |
|
InvalidTupleMemberLabel: _("Tuple members must be labeled with a simple identifier."), |
|
MissingInterfaceName: _("'interface' declarations must be followed by an identifier."), |
|
MixedLabeledAndUnlabeledElements: _("Tuple members must all have names or all not have names."), |
|
NonAbstractClassHasAbstractMethod: _("Abstract methods can only appear within an abstract class."), |
|
NonClassMethodPropertyHasAbstractModifer: _("'abstract' modifier can only appear on a class, method, or property declaration."), |
|
OptionalTypeBeforeRequired: _("A required element cannot follow an optional element."), |
|
OverrideNotInSubClass: _("This member cannot have an 'override' modifier because its containing class does not extend another class."), |
|
PatternIsOptional: _("A binding pattern parameter cannot be optional in an implementation signature."), |
|
PrivateElementHasAbstract: _("Private elements cannot have the 'abstract' modifier."), |
|
PrivateElementHasAccessibility: _(({ |
|
modifier |
|
}) => `Private elements cannot have an accessibility modifier ('${modifier}').`), |
|
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."), |
|
SingleTypeParameterWithoutTrailingComma: _(({ |
|
typeParameterName |
|
}) => `Single type parameter ${typeParameterName} should have a trailing comma. Example usage: <${typeParameterName},>.`), |
|
StaticBlockCannotHaveModifier: _("Static class blocks cannot have any modifier."), |
|
TypeAnnotationAfterAssign: _("Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`."), |
|
TypeImportCannotSpecifyDefaultAndNamed: _("A type-only import can specify a default import or named bindings, but not both."), |
|
TypeModifierIsUsedInTypeExports: _("The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement."), |
|
TypeModifierIsUsedInTypeImports: _("The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement."), |
|
UnexpectedParameterModifier: _("A parameter property is only allowed in a constructor implementation."), |
|
UnexpectedReadonly: _("'readonly' type modifier is only permitted on array and tuple literal types."), |
|
UnexpectedTypeAnnotation: _("Did not expect a type annotation here."), |
|
UnexpectedTypeCastInParameter: _("Unexpected type cast in parameter position."), |
|
UnsupportedImportTypeArgument: _("Argument in a type import must be a string literal."), |
|
UnsupportedParameterPropertyKind: _("A parameter property may not be declared using a binding pattern."), |
|
UnsupportedSignatureParameterKind: _(({ |
|
type |
|
}) => `Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got ${type}.`) |
|
})); |
|
|
|
function keywordTypeFromName(value) { |
|
switch (value) { |
|
case "any": |
|
return "TSAnyKeyword"; |
|
|
|
case "boolean": |
|
return "TSBooleanKeyword"; |
|
|
|
case "bigint": |
|
return "TSBigIntKeyword"; |
|
|
|
case "never": |
|
return "TSNeverKeyword"; |
|
|
|
case "number": |
|
return "TSNumberKeyword"; |
|
|
|
case "object": |
|
return "TSObjectKeyword"; |
|
|
|
case "string": |
|
return "TSStringKeyword"; |
|
|
|
case "symbol": |
|
return "TSSymbolKeyword"; |
|
|
|
case "undefined": |
|
return "TSUndefinedKeyword"; |
|
|
|
case "unknown": |
|
return "TSUnknownKeyword"; |
|
|
|
default: |
|
return undefined; |
|
} |
|
} |
|
|
|
function tsIsAccessModifier(modifier) { |
|
return modifier === "private" || modifier === "public" || modifier === "protected"; |
|
} |
|
|
|
function tsIsVarianceAnnotations(modifier) { |
|
return modifier === "in" || modifier === "out"; |
|
} |
|
|
|
var typescript = (superClass => class extends superClass { |
|
getScopeHandler() { |
|
return TypeScriptScopeHandler; |
|
} |
|
|
|
tsIsIdentifier() { |
|
return tokenIsIdentifier(this.state.type); |
|
} |
|
|
|
tsTokenCanFollowModifier() { |
|
return (this.match(0) || this.match(5) || this.match(55) || this.match(21) || this.match(134) || this.isLiteralPropertyName()) && !this.hasPrecedingLineBreak(); |
|
} |
|
|
|
tsNextTokenCanFollowModifier() { |
|
this.next(); |
|
return this.tsTokenCanFollowModifier(); |
|
} |
|
|
|
tsParseModifier(allowedModifiers, stopOnStartOfClassStaticBlock) { |
|
if (!tokenIsIdentifier(this.state.type) && this.state.type !== 58) { |
|
return undefined; |
|
} |
|
|
|
const modifier = this.state.value; |
|
|
|
if (allowedModifiers.indexOf(modifier) !== -1) { |
|
if (stopOnStartOfClassStaticBlock && this.tsIsStartOfStaticBlocks()) { |
|
return undefined; |
|
} |
|
|
|
if (this.tsTryParse(this.tsNextTokenCanFollowModifier.bind(this))) { |
|
return modifier; |
|
} |
|
} |
|
|
|
return undefined; |
|
} |
|
|
|
tsParseModifiers({ |
|
modified, |
|
allowedModifiers, |
|
disallowedModifiers, |
|
stopOnStartOfClassStaticBlock, |
|
errorTemplate = TSErrors.InvalidModifierOnTypeMember |
|
}) { |
|
const enforceOrder = (loc, modifier, before, after) => { |
|
if (modifier === before && modified[after]) { |
|
this.raise(TSErrors.InvalidModifiersOrder, { |
|
at: loc, |
|
orderedModifiers: [before, after] |
|
}); |
|
} |
|
}; |
|
|
|
const incompatible = (loc, modifier, mod1, mod2) => { |
|
if (modified[mod1] && modifier === mod2 || modified[mod2] && modifier === mod1) { |
|
this.raise(TSErrors.IncompatibleModifiers, { |
|
at: loc, |
|
modifiers: [mod1, mod2] |
|
}); |
|
} |
|
}; |
|
|
|
for (;;) { |
|
const { |
|
startLoc |
|
} = this.state; |
|
const modifier = this.tsParseModifier(allowedModifiers.concat(disallowedModifiers != null ? disallowedModifiers : []), stopOnStartOfClassStaticBlock); |
|
if (!modifier) break; |
|
|
|
if (tsIsAccessModifier(modifier)) { |
|
if (modified.accessibility) { |
|
this.raise(TSErrors.DuplicateAccessibilityModifier, { |
|
at: startLoc, |
|
modifier |
|
}); |
|
} else { |
|
enforceOrder(startLoc, modifier, modifier, "override"); |
|
enforceOrder(startLoc, modifier, modifier, "static"); |
|
enforceOrder(startLoc, modifier, modifier, "readonly"); |
|
modified.accessibility = modifier; |
|
} |
|
} else if (tsIsVarianceAnnotations(modifier)) { |
|
if (modified[modifier]) { |
|
this.raise(TSErrors.DuplicateModifier, { |
|
at: startLoc, |
|
modifier |
|
}); |
|
} |
|
|
|
modified[modifier] = true; |
|
enforceOrder(startLoc, modifier, "in", "out"); |
|
} else { |
|
if (Object.hasOwnProperty.call(modified, modifier)) { |
|
this.raise(TSErrors.DuplicateModifier, { |
|
at: startLoc, |
|
modifier |
|
}); |
|
} else { |
|
enforceOrder(startLoc, modifier, "static", "readonly"); |
|
enforceOrder(startLoc, modifier, "static", "override"); |
|
enforceOrder(startLoc, modifier, "override", "readonly"); |
|
enforceOrder(startLoc, modifier, "abstract", "override"); |
|
incompatible(startLoc, modifier, "declare", "override"); |
|
incompatible(startLoc, modifier, "static", "abstract"); |
|
} |
|
|
|
modified[modifier] = true; |
|
} |
|
|
|
if (disallowedModifiers != null && disallowedModifiers.includes(modifier)) { |
|
this.raise(errorTemplate, { |
|
at: startLoc, |
|
modifier |
|
}); |
|
} |
|
} |
|
} |
|
|
|
tsIsListTerminator(kind) { |
|
switch (kind) { |
|
case "EnumMembers": |
|
case "TypeMembers": |
|
return this.match(8); |
|
|
|
case "HeritageClauseElement": |
|
return this.match(5); |
|
|
|
case "TupleElementTypes": |
|
return this.match(3); |
|
|
|
case "TypeParametersOrArguments": |
|
return this.match(48); |
|
} |
|
|
|
throw new Error("Unreachable"); |
|
} |
|
|
|
tsParseList(kind, parseElement) { |
|
const result = []; |
|
|
|
while (!this.tsIsListTerminator(kind)) { |
|
result.push(parseElement()); |
|
} |
|
|
|
return result; |
|
} |
|
|
|
tsParseDelimitedList(kind, parseElement, refTrailingCommaPos) { |
|
return nonNull(this.tsParseDelimitedListWorker(kind, parseElement, true, refTrailingCommaPos)); |
|
} |
|
|
|
tsParseDelimitedListWorker(kind, parseElement, expectSuccess, refTrailingCommaPos) { |
|
const result = []; |
|
let trailingCommaPos = -1; |
|
|
|
for (;;) { |
|
if (this.tsIsListTerminator(kind)) { |
|
break; |
|
} |
|
|
|
trailingCommaPos = -1; |
|
const element = parseElement(); |
|
|
|
if (element == null) { |
|
return undefined; |
|
} |
|
|
|
result.push(element); |
|
|
|
if (this.eat(12)) { |
|
trailingCommaPos = this.state.lastTokStart; |
|
continue; |
|
} |
|
|
|
if (this.tsIsListTerminator(kind)) { |
|
break; |
|
} |
|
|
|
if (expectSuccess) { |
|
this.expect(12); |
|
} |
|
|
|
return undefined; |
|
} |
|
|
|
if (refTrailingCommaPos) { |
|
refTrailingCommaPos.value = trailingCommaPos; |
|
} |
|
|
|
return result; |
|
} |
|
|
|
tsParseBracketedList(kind, parseElement, bracket, skipFirstToken, refTrailingCommaPos) { |
|
if (!skipFirstToken) { |
|
if (bracket) { |
|
this.expect(0); |
|
} else { |
|
this.expect(47); |
|
} |
|
} |
|
|
|
const result = this.tsParseDelimitedList(kind, parseElement, refTrailingCommaPos); |
|
|
|
if (bracket) { |
|
this.expect(3); |
|
} else { |
|
this.expect(48); |
|
} |
|
|
|
return result; |
|
} |
|
|
|
tsParseImportType() { |
|
const node = this.startNode(); |
|
this.expect(83); |
|
this.expect(10); |
|
|
|
if (!this.match(129)) { |
|
this.raise(TSErrors.UnsupportedImportTypeArgument, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
|
|
node.argument = this.parseExprAtom(); |
|
this.expect(11); |
|
|
|
if (this.eat(16)) { |
|
node.qualifier = this.tsParseEntityName(); |
|
} |
|
|
|
if (this.match(47)) { |
|
node.typeParameters = this.tsParseTypeArguments(); |
|
} |
|
|
|
return this.finishNode(node, "TSImportType"); |
|
} |
|
|
|
tsParseEntityName(allowReservedWords = true) { |
|
let entity = this.parseIdentifier(allowReservedWords); |
|
|
|
while (this.eat(16)) { |
|
const node = this.startNodeAtNode(entity); |
|
node.left = entity; |
|
node.right = this.parseIdentifier(allowReservedWords); |
|
entity = this.finishNode(node, "TSQualifiedName"); |
|
} |
|
|
|
return entity; |
|
} |
|
|
|
tsParseTypeReference() { |
|
const node = this.startNode(); |
|
node.typeName = this.tsParseEntityName(); |
|
|
|
if (!this.hasPrecedingLineBreak() && this.match(47)) { |
|
node.typeParameters = this.tsParseTypeArguments(); |
|
} |
|
|
|
return this.finishNode(node, "TSTypeReference"); |
|
} |
|
|
|
tsParseThisTypePredicate(lhs) { |
|
this.next(); |
|
const node = this.startNodeAtNode(lhs); |
|
node.parameterName = lhs; |
|
node.typeAnnotation = this.tsParseTypeAnnotation(false); |
|
node.asserts = false; |
|
return this.finishNode(node, "TSTypePredicate"); |
|
} |
|
|
|
tsParseThisTypeNode() { |
|
const node = this.startNode(); |
|
this.next(); |
|
return this.finishNode(node, "TSThisType"); |
|
} |
|
|
|
tsParseTypeQuery() { |
|
const node = this.startNode(); |
|
this.expect(87); |
|
|
|
if (this.match(83)) { |
|
node.exprName = this.tsParseImportType(); |
|
} else { |
|
node.exprName = this.tsParseEntityName(); |
|
} |
|
|
|
if (!this.hasPrecedingLineBreak() && this.match(47)) { |
|
node.typeParameters = this.tsParseTypeArguments(); |
|
} |
|
|
|
return this.finishNode(node, "TSTypeQuery"); |
|
} |
|
|
|
tsParseInOutModifiers(node) { |
|
this.tsParseModifiers({ |
|
modified: node, |
|
allowedModifiers: ["in", "out"], |
|
disallowedModifiers: ["public", "private", "protected", "readonly", "declare", "abstract", "override"], |
|
errorTemplate: TSErrors.InvalidModifierOnTypeParameter |
|
}); |
|
} |
|
|
|
tsParseNoneModifiers(node) { |
|
this.tsParseModifiers({ |
|
modified: node, |
|
allowedModifiers: [], |
|
disallowedModifiers: ["in", "out"], |
|
errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions |
|
}); |
|
} |
|
|
|
tsParseTypeParameter(parseModifiers = this.tsParseNoneModifiers.bind(this)) { |
|
const node = this.startNode(); |
|
parseModifiers(node); |
|
node.name = this.tsParseTypeParameterName(); |
|
node.constraint = this.tsEatThenParseType(81); |
|
node.default = this.tsEatThenParseType(29); |
|
return this.finishNode(node, "TSTypeParameter"); |
|
} |
|
|
|
tsTryParseTypeParameters(parseModifiers) { |
|
if (this.match(47)) { |
|
return this.tsParseTypeParameters(parseModifiers); |
|
} |
|
} |
|
|
|
tsParseTypeParameters(parseModifiers) { |
|
const node = this.startNode(); |
|
|
|
if (this.match(47) || this.match(138)) { |
|
this.next(); |
|
} else { |
|
this.unexpected(); |
|
} |
|
|
|
const refTrailingCommaPos = { |
|
value: -1 |
|
}; |
|
node.params = this.tsParseBracketedList("TypeParametersOrArguments", this.tsParseTypeParameter.bind(this, parseModifiers), false, true, refTrailingCommaPos); |
|
|
|
if (node.params.length === 0) { |
|
this.raise(TSErrors.EmptyTypeParameters, { |
|
at: node |
|
}); |
|
} |
|
|
|
if (refTrailingCommaPos.value !== -1) { |
|
this.addExtra(node, "trailingComma", refTrailingCommaPos.value); |
|
} |
|
|
|
return this.finishNode(node, "TSTypeParameterDeclaration"); |
|
} |
|
|
|
tsTryNextParseConstantContext() { |
|
if (this.lookahead().type !== 75) return null; |
|
this.next(); |
|
const typeReference = this.tsParseTypeReference(); |
|
|
|
if (typeReference.typeParameters) { |
|
this.raise(TSErrors.CannotFindName, { |
|
at: typeReference.typeName, |
|
name: "const" |
|
}); |
|
} |
|
|
|
return typeReference; |
|
} |
|
|
|
tsFillSignature(returnToken, signature) { |
|
const returnTokenRequired = returnToken === 19; |
|
const paramsKey = "parameters"; |
|
const returnTypeKey = "typeAnnotation"; |
|
signature.typeParameters = this.tsTryParseTypeParameters(); |
|
this.expect(10); |
|
signature[paramsKey] = this.tsParseBindingListForSignature(); |
|
|
|
if (returnTokenRequired) { |
|
signature[returnTypeKey] = this.tsParseTypeOrTypePredicateAnnotation(returnToken); |
|
} else if (this.match(returnToken)) { |
|
signature[returnTypeKey] = this.tsParseTypeOrTypePredicateAnnotation(returnToken); |
|
} |
|
} |
|
|
|
tsParseBindingListForSignature() { |
|
return this.parseBindingList(11, 41).map(pattern => { |
|
if (pattern.type !== "Identifier" && pattern.type !== "RestElement" && pattern.type !== "ObjectPattern" && pattern.type !== "ArrayPattern") { |
|
this.raise(TSErrors.UnsupportedSignatureParameterKind, { |
|
at: pattern, |
|
type: pattern.type |
|
}); |
|
} |
|
|
|
return pattern; |
|
}); |
|
} |
|
|
|
tsParseTypeMemberSemicolon() { |
|
if (!this.eat(12) && !this.isLineTerminator()) { |
|
this.expect(13); |
|
} |
|
} |
|
|
|
tsParseSignatureMember(kind, node) { |
|
this.tsFillSignature(14, node); |
|
this.tsParseTypeMemberSemicolon(); |
|
return this.finishNode(node, kind); |
|
} |
|
|
|
tsIsUnambiguouslyIndexSignature() { |
|
this.next(); |
|
|
|
if (tokenIsIdentifier(this.state.type)) { |
|
this.next(); |
|
return this.match(14); |
|
} |
|
|
|
return false; |
|
} |
|
|
|
tsTryParseIndexSignature(node) { |
|
if (!(this.match(0) && this.tsLookAhead(this.tsIsUnambiguouslyIndexSignature.bind(this)))) { |
|
return undefined; |
|
} |
|
|
|
this.expect(0); |
|
const id = this.parseIdentifier(); |
|
id.typeAnnotation = this.tsParseTypeAnnotation(); |
|
this.resetEndLocation(id); |
|
this.expect(3); |
|
node.parameters = [id]; |
|
const type = this.tsTryParseTypeAnnotation(); |
|
if (type) node.typeAnnotation = type; |
|
this.tsParseTypeMemberSemicolon(); |
|
return this.finishNode(node, "TSIndexSignature"); |
|
} |
|
|
|
tsParsePropertyOrMethodSignature(node, readonly) { |
|
if (this.eat(17)) node.optional = true; |
|
const nodeAny = node; |
|
|
|
if (this.match(10) || this.match(47)) { |
|
if (readonly) { |
|
this.raise(TSErrors.ReadonlyForMethodSignature, { |
|
at: node |
|
}); |
|
} |
|
|
|
const method = nodeAny; |
|
|
|
if (method.kind && this.match(47)) { |
|
this.raise(TSErrors.AccesorCannotHaveTypeParameters, { |
|
at: this.state.curPosition() |
|
}); |
|
} |
|
|
|
this.tsFillSignature(14, method); |
|
this.tsParseTypeMemberSemicolon(); |
|
const paramsKey = "parameters"; |
|
const returnTypeKey = "typeAnnotation"; |
|
|
|
if (method.kind === "get") { |
|
if (method[paramsKey].length > 0) { |
|
this.raise(Errors.BadGetterArity, { |
|
at: this.state.curPosition() |
|
}); |
|
|
|
if (this.isThisParam(method[paramsKey][0])) { |
|
this.raise(TSErrors.AccesorCannotDeclareThisParameter, { |
|
at: this.state.curPosition() |
|
}); |
|
} |
|
} |
|
} else if (method.kind === "set") { |
|
if (method[paramsKey].length !== 1) { |
|
this.raise(Errors.BadSetterArity, { |
|
at: this.state.curPosition() |
|
}); |
|
} else { |
|
const firstParameter = method[paramsKey][0]; |
|
|
|
if (this.isThisParam(firstParameter)) { |
|
this.raise(TSErrors.AccesorCannotDeclareThisParameter, { |
|
at: this.state.curPosition() |
|
}); |
|
} |
|
|
|
if (firstParameter.type === "Identifier" && firstParameter.optional) { |
|
this.raise(TSErrors.SetAccesorCannotHaveOptionalParameter, { |
|
at: this.state.curPosition() |
|
}); |
|
} |
|
|
|
if (firstParameter.type === "RestElement") { |
|
this.raise(TSErrors.SetAccesorCannotHaveRestParameter, { |
|
at: this.state.curPosition() |
|
}); |
|
} |
|
} |
|
|
|
if (method[returnTypeKey]) { |
|
this.raise(TSErrors.SetAccesorCannotHaveReturnType, { |
|
at: method[returnTypeKey] |
|
}); |
|
} |
|
} else { |
|
method.kind = "method"; |
|
} |
|
|
|
return this.finishNode(method, "TSMethodSignature"); |
|
} else { |
|
const property = nodeAny; |
|
if (readonly) property.readonly = true; |
|
const type = this.tsTryParseTypeAnnotation(); |
|
if (type) property.typeAnnotation = type; |
|
this.tsParseTypeMemberSemicolon(); |
|
return this.finishNode(property, "TSPropertySignature"); |
|
} |
|
} |
|
|
|
tsParseTypeMember() { |
|
const node = this.startNode(); |
|
|
|
if (this.match(10) || this.match(47)) { |
|
return this.tsParseSignatureMember("TSCallSignatureDeclaration", node); |
|
} |
|
|
|
if (this.match(77)) { |
|
const id = this.startNode(); |
|
this.next(); |
|
|
|
if (this.match(10) || this.match(47)) { |
|
return this.tsParseSignatureMember("TSConstructSignatureDeclaration", node); |
|
} else { |
|
node.key = this.createIdentifier(id, "new"); |
|
return this.tsParsePropertyOrMethodSignature(node, false); |
|
} |
|
} |
|
|
|
this.tsParseModifiers({ |
|
modified: node, |
|
allowedModifiers: ["readonly"], |
|
disallowedModifiers: ["declare", "abstract", "private", "protected", "public", "static", "override"] |
|
}); |
|
const idx = this.tsTryParseIndexSignature(node); |
|
|
|
if (idx) { |
|
return idx; |
|
} |
|
|
|
this.parsePropertyName(node); |
|
|
|
if (!node.computed && node.key.type === "Identifier" && (node.key.name === "get" || node.key.name === "set") && this.tsTokenCanFollowModifier()) { |
|
node.kind = node.key.name; |
|
this.parsePropertyName(node); |
|
} |
|
|
|
return this.tsParsePropertyOrMethodSignature(node, !!node.readonly); |
|
} |
|
|
|
tsParseTypeLiteral() { |
|
const node = this.startNode(); |
|
node.members = this.tsParseObjectTypeMembers(); |
|
return this.finishNode(node, "TSTypeLiteral"); |
|
} |
|
|
|
tsParseObjectTypeMembers() { |
|
this.expect(5); |
|
const members = this.tsParseList("TypeMembers", this.tsParseTypeMember.bind(this)); |
|
this.expect(8); |
|
return members; |
|
} |
|
|
|
tsIsStartOfMappedType() { |
|
this.next(); |
|
|
|
if (this.eat(53)) { |
|
return this.isContextual(118); |
|
} |
|
|
|
if (this.isContextual(118)) { |
|
this.next(); |
|
} |
|
|
|
if (!this.match(0)) { |
|
return false; |
|
} |
|
|
|
this.next(); |
|
|
|
if (!this.tsIsIdentifier()) { |
|
return false; |
|
} |
|
|
|
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); |
|
|
|
if (this.match(53)) { |
|
node.readonly = this.state.value; |
|
this.next(); |
|
this.expectContextual(118); |
|
} else if (this.eatContextual(118)) { |
|
node.readonly = true; |
|
} |
|
|
|
this.expect(0); |
|
node.typeParameter = this.tsParseMappedTypeParameter(); |
|
node.nameType = this.eatContextual(93) ? this.tsParseType() : null; |
|
this.expect(3); |
|
|
|
if (this.match(53)) { |
|
node.optional = this.state.value; |
|
this.next(); |
|
this.expect(17); |
|
} else if (this.eat(17)) { |
|
node.optional = true; |
|
} |
|
|
|
node.typeAnnotation = this.tsTryParseType(); |
|
this.semicolon(); |
|
this.expect(8); |
|
return this.finishNode(node, "TSMappedType"); |
|
} |
|
|
|
tsParseTupleType() { |
|
const node = this.startNode(); |
|
node.elementTypes = this.tsParseBracketedList("TupleElementTypes", this.tsParseTupleElementType.bind(this), true, false); |
|
let seenOptionalElement = false; |
|
let labeledElements = null; |
|
node.elementTypes.forEach(elementNode => { |
|
var _labeledElements; |
|
|
|
let { |
|
type |
|
} = elementNode; |
|
|
|
if (seenOptionalElement && type !== "TSRestType" && type !== "TSOptionalType" && !(type === "TSNamedTupleMember" && elementNode.optional)) { |
|
this.raise(TSErrors.OptionalTypeBeforeRequired, { |
|
at: elementNode |
|
}); |
|
} |
|
|
|
seenOptionalElement = seenOptionalElement || type === "TSNamedTupleMember" && elementNode.optional || type === "TSOptionalType"; |
|
|
|
if (type === "TSRestType") { |
|
elementNode = elementNode.typeAnnotation; |
|
type = elementNode.type; |
|
} |
|
|
|
const isLabeled = type === "TSNamedTupleMember"; |
|
labeledElements = (_labeledElements = labeledElements) != null ? _labeledElements : isLabeled; |
|
|
|
if (labeledElements !== isLabeled) { |
|
this.raise(TSErrors.MixedLabeledAndUnlabeledElements, { |
|
at: elementNode |
|
}); |
|
} |
|
}); |
|
return this.finishNode(node, "TSTupleType"); |
|
} |
|
|
|
tsParseTupleElementType() { |
|
const { |
|
start: startPos, |
|
startLoc |
|
} = this.state; |
|
const rest = this.eat(21); |
|
let type = this.tsParseType(); |
|
const optional = this.eat(17); |
|
const labeled = this.eat(14); |
|
|
|
if (labeled) { |
|
const labeledNode = this.startNodeAtNode(type); |
|
labeledNode.optional = optional; |
|
|
|
if (type.type === "TSTypeReference" && !type.typeParameters && type.typeName.type === "Identifier") { |
|
labeledNode.label = type.typeName; |
|
} else { |
|
this.raise(TSErrors.InvalidTupleMemberLabel, { |
|
at: type |
|
}); |
|
labeledNode.label = type; |
|
} |
|
|
|
labeledNode.elementType = this.tsParseType(); |
|
type = this.finishNode(labeledNode, "TSNamedTupleMember"); |
|
} else if (optional) { |
|
const optionalTypeNode = this.startNodeAtNode(type); |
|
optionalTypeNode.typeAnnotation = type; |
|
type = this.finishNode(optionalTypeNode, "TSOptionalType"); |
|
} |
|
|
|
if (rest) { |
|
const restNode = this.startNodeAt(startPos, startLoc); |
|
restNode.typeAnnotation = type; |
|
type = this.finishNode(restNode, "TSRestType"); |
|
} |
|
|
|
return type; |
|
} |
|
|
|
tsParseParenthesizedType() { |
|
const node = this.startNode(); |
|
this.expect(10); |
|
node.typeAnnotation = this.tsParseType(); |
|
this.expect(11); |
|
return this.finishNode(node, "TSParenthesizedType"); |
|
} |
|
|
|
tsParseFunctionOrConstructorType(type, abstract) { |
|
const node = this.startNode(); |
|
|
|
if (type === "TSConstructorType") { |
|
node.abstract = !!abstract; |
|
if (abstract) this.next(); |
|
this.next(); |
|
} |
|
|
|
this.tsInAllowConditionalTypesContext(() => this.tsFillSignature(19, node)); |
|
return this.finishNode(node, type); |
|
} |
|
|
|
tsParseLiteralTypeNode() { |
|
const node = this.startNode(); |
|
|
|
node.literal = (() => { |
|
switch (this.state.type) { |
|
case 130: |
|
case 131: |
|
case 129: |
|
case 85: |
|
case 86: |
|
return this.parseExprAtom(); |
|
|
|
default: |
|
throw this.unexpected(); |
|
} |
|
})(); |
|
|
|
return this.finishNode(node, "TSLiteralType"); |
|
} |
|
|
|
tsParseTemplateLiteralType() { |
|
const node = this.startNode(); |
|
node.literal = this.parseTemplate(false); |
|
return this.finishNode(node, "TSLiteralType"); |
|
} |
|
|
|
parseTemplateSubstitution() { |
|
if (this.state.inType) return this.tsParseType(); |
|
return super.parseTemplateSubstitution(); |
|
} |
|
|
|
tsParseThisTypeOrThisTypePredicate() { |
|
const thisKeyword = this.tsParseThisTypeNode(); |
|
|
|
if (this.isContextual(113) && !this.hasPrecedingLineBreak()) { |
|
return this.tsParseThisTypePredicate(thisKeyword); |
|
} else { |
|
return thisKeyword; |
|
} |
|
} |
|
|
|
tsParseNonArrayType() { |
|
switch (this.state.type) { |
|
case 129: |
|
case 130: |
|
case 131: |
|
case 85: |
|
case 86: |
|
return this.tsParseLiteralTypeNode(); |
|
|
|
case 53: |
|
if (this.state.value === "-") { |
|
const node = this.startNode(); |
|
const nextToken = this.lookahead(); |
|
|
|
if (nextToken.type !== 130 && nextToken.type !== 131) { |
|
throw this.unexpected(); |
|
} |
|
|
|
node.literal = this.parseMaybeUnary(); |
|
return this.finishNode(node, "TSLiteralType"); |
|
} |
|
|
|
break; |
|
|
|
case 78: |
|
return this.tsParseThisTypeOrThisTypePredicate(); |
|
|
|
case 87: |
|
return this.tsParseTypeQuery(); |
|
|
|
case 83: |
|
return this.tsParseImportType(); |
|
|
|
case 5: |
|
return this.tsLookAhead(this.tsIsStartOfMappedType.bind(this)) ? this.tsParseMappedType() : this.tsParseTypeLiteral(); |
|
|
|
case 0: |
|
return this.tsParseTupleType(); |
|
|
|
case 10: |
|
return this.tsParseParenthesizedType(); |
|
|
|
case 25: |
|
case 24: |
|
return this.tsParseTemplateLiteralType(); |
|
|
|
default: |
|
{ |
|
const { |
|
type |
|
} = this.state; |
|
|
|
if (tokenIsIdentifier(type) || type === 88 || type === 84) { |
|
const nodeType = type === 88 ? "TSVoidKeyword" : type === 84 ? "TSNullKeyword" : keywordTypeFromName(this.state.value); |
|
|
|
if (nodeType !== undefined && this.lookaheadCharCode() !== 46) { |
|
const node = this.startNode(); |
|
this.next(); |
|
return this.finishNode(node, nodeType); |
|
} |
|
|
|
return this.tsParseTypeReference(); |
|
} |
|
} |
|
} |
|
|
|
throw this.unexpected(); |
|
} |
|
|
|
tsParseArrayTypeOrHigher() { |
|
let type = this.tsParseNonArrayType(); |
|
|
|
while (!this.hasPrecedingLineBreak() && this.eat(0)) { |
|
if (this.match(3)) { |
|
const node = this.startNodeAtNode(type); |
|
node.elementType = type; |
|
this.expect(3); |
|
type = this.finishNode(node, "TSArrayType"); |
|
} else { |
|
const node = this.startNodeAtNode(type); |
|
node.objectType = type; |
|
node.indexType = this.tsParseType(); |
|
this.expect(3); |
|
type = this.finishNode(node, "TSIndexedAccessType"); |
|
} |
|
} |
|
|
|
return type; |
|
} |
|
|
|
tsParseTypeOperator() { |
|
const node = this.startNode(); |
|
const operator = this.state.value; |
|
this.next(); |
|
node.operator = operator; |
|
node.typeAnnotation = this.tsParseTypeOperatorOrHigher(); |
|
|
|
if (operator === "readonly") { |
|
this.tsCheckTypeAnnotationForReadOnly(node); |
|
} |
|
|
|
return this.finishNode(node, "TSTypeOperator"); |
|
} |
|
|
|
tsCheckTypeAnnotationForReadOnly(node) { |
|
switch (node.typeAnnotation.type) { |
|
case "TSTupleType": |
|
case "TSArrayType": |
|
return; |
|
|
|
default: |
|
this.raise(TSErrors.UnexpectedReadonly, { |
|
at: node |
|
}); |
|
} |
|
} |
|
|
|
tsParseInferType() { |
|
const node = this.startNode(); |
|
this.expectContextual(112); |
|
const typeParameter = this.startNode(); |
|
typeParameter.name = this.tsParseTypeParameterName(); |
|
typeParameter.constraint = this.tsTryParse(() => this.tsParseConstraintForInferType()); |
|
node.typeParameter = this.finishNode(typeParameter, "TSTypeParameter"); |
|
return this.finishNode(node, "TSInferType"); |
|
} |
|
|
|
tsParseConstraintForInferType() { |
|
if (this.eat(81)) { |
|
const constraint = this.tsInDisallowConditionalTypesContext(() => this.tsParseType()); |
|
|
|
if (this.state.inDisallowConditionalTypesContext || !this.match(17)) { |
|
return constraint; |
|
} |
|
} |
|
} |
|
|
|
tsParseTypeOperatorOrHigher() { |
|
const isTypeOperator = tokenIsTSTypeOperator(this.state.type) && !this.state.containsEsc; |
|
return isTypeOperator ? this.tsParseTypeOperator() : this.isContextual(112) ? this.tsParseInferType() : this.tsInAllowConditionalTypesContext(() => this.tsParseArrayTypeOrHigher()); |
|
} |
|
|
|
tsParseUnionOrIntersectionType(kind, parseConstituentType, operator) { |
|
const node = this.startNode(); |
|
const hasLeadingOperator = this.eat(operator); |
|
const types = []; |
|
|
|
do { |
|
types.push(parseConstituentType()); |
|
} while (this.eat(operator)); |
|
|
|
if (types.length === 1 && !hasLeadingOperator) { |
|
return types[0]; |
|
} |
|
|
|
node.types = types; |
|
return this.finishNode(node, kind); |
|
} |
|
|
|
tsParseIntersectionTypeOrHigher() { |
|
return this.tsParseUnionOrIntersectionType("TSIntersectionType", this.tsParseTypeOperatorOrHigher.bind(this), 45); |
|
} |
|
|
|
tsParseUnionTypeOrHigher() { |
|
return this.tsParseUnionOrIntersectionType("TSUnionType", this.tsParseIntersectionTypeOrHigher.bind(this), 43); |
|
} |
|
|
|
tsIsStartOfFunctionType() { |
|
if (this.match(47)) { |
|
return true; |
|
} |
|
|
|
return this.match(10) && this.tsLookAhead(this.tsIsUnambiguouslyStartOfFunctionType.bind(this)); |
|
} |
|
|
|
tsSkipParameterStart() { |
|
if (tokenIsIdentifier(this.state.type) || this.match(78)) { |
|
this.next(); |
|
return true; |
|
} |
|
|
|
if (this.match(5)) { |
|
const { |
|
errors |
|
} = this.state; |
|
const previousErrorCount = errors.length; |
|
|
|
try { |
|
this.parseObjectLike(8, true); |
|
return errors.length === previousErrorCount; |
|
} catch (_unused) { |
|
return false; |
|
} |
|
} |
|
|
|
if (this.match(0)) { |
|
this.next(); |
|
const { |
|
errors |
|
} = this.state; |
|
const previousErrorCount = errors.length; |
|
|
|
try { |
|
this.parseBindingList(3, 93, true); |
|
return errors.length === previousErrorCount; |
|
} catch (_unused2) { |
|
return false; |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
tsIsUnambiguouslyStartOfFunctionType() { |
|
this.next(); |
|
|
|
if (this.match(11) || this.match(21)) { |
|
return true; |
|
} |
|
|
|
if (this.tsSkipParameterStart()) { |
|
if (this.match(14) || this.match(12) || this.match(17) || this.match(29)) { |
|
return true; |
|
} |
|
|
|
if (this.match(11)) { |
|
this.next(); |
|
|
|
if (this.match(19)) { |
|
return true; |
|
} |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
tsParseTypeOrTypePredicateAnnotation(returnToken) { |
|
return this.tsInType(() => { |
|
const t = this.startNode(); |
|
this.expect(returnToken); |
|
const node = this.startNode(); |
|
const asserts = !!this.tsTryParse(this.tsParseTypePredicateAsserts.bind(this)); |
|
|
|
if (asserts && this.match(78)) { |
|
let thisTypePredicate = this.tsParseThisTypeOrThisTypePredicate(); |
|
|
|
if (thisTypePredicate.type === "TSThisType") { |
|
node.parameterName = thisTypePredicate; |
|
node.asserts = true; |
|
node.typeAnnotation = null; |
|
thisTypePredicate = this.finishNode(node, "TSTypePredicate"); |
|
} else { |
|
this.resetStartLocationFromNode(thisTypePredicate, node); |
|
thisTypePredicate.asserts = true; |
|
} |
|
|
|
t.typeAnnotation = thisTypePredicate; |
|
return this.finishNode(t, "TSTypeAnnotation"); |
|
} |
|
|
|
const typePredicateVariable = this.tsIsIdentifier() && this.tsTryParse(this.tsParseTypePredicatePrefix.bind(this)); |
|
|
|
if (!typePredicateVariable) { |
|
if (!asserts) { |
|
return this.tsParseTypeAnnotation(false, t); |
|
} |
|
|
|
node.parameterName = this.parseIdentifier(); |
|
node.asserts = asserts; |
|
node.typeAnnotation = null; |
|
t.typeAnnotation = this.finishNode(node, "TSTypePredicate"); |
|
return this.finishNode(t, "TSTypeAnnotation"); |
|
} |
|
|
|
const type = this.tsParseTypeAnnotation(false); |
|
node.parameterName = typePredicateVariable; |
|
node.typeAnnotation = type; |
|
node.asserts = asserts; |
|
t.typeAnnotation = this.finishNode(node, "TSTypePredicate"); |
|
return this.finishNode(t, "TSTypeAnnotation"); |
|
}); |
|
} |
|
|
|
tsTryParseTypeOrTypePredicateAnnotation() { |
|
return this.match(14) ? this.tsParseTypeOrTypePredicateAnnotation(14) : undefined; |
|
} |
|
|
|
tsTryParseTypeAnnotation() { |
|
return this.match(14) ? this.tsParseTypeAnnotation() : undefined; |
|
} |
|
|
|
tsTryParseType() { |
|
return this.tsEatThenParseType(14); |
|
} |
|
|
|
tsParseTypePredicatePrefix() { |
|
const id = this.parseIdentifier(); |
|
|
|
if (this.isContextual(113) && !this.hasPrecedingLineBreak()) { |
|
this.next(); |
|
return id; |
|
} |
|
} |
|
|
|
tsParseTypePredicateAsserts() { |
|
if (this.state.type !== 106) { |
|
return false; |
|
} |
|
|
|
const containsEsc = this.state.containsEsc; |
|
this.next(); |
|
|
|
if (!tokenIsIdentifier(this.state.type) && !this.match(78)) { |
|
return false; |
|
} |
|
|
|
if (containsEsc) { |
|
this.raise(Errors.InvalidEscapedReservedWord, { |
|
at: this.state.lastTokStartLoc, |
|
reservedWord: "asserts" |
|
}); |
|
} |
|
|
|
return true; |
|
} |
|
|
|
tsParseTypeAnnotation(eatColon = true, t = this.startNode()) { |
|
this.tsInType(() => { |
|
if (eatColon) this.expect(14); |
|
t.typeAnnotation = this.tsParseType(); |
|
}); |
|
return this.finishNode(t, "TSTypeAnnotation"); |
|
} |
|
|
|
tsParseType() { |
|
assert(this.state.inType); |
|
const type = this.tsParseNonConditionalType(); |
|
|
|
if (this.state.inDisallowConditionalTypesContext || this.hasPrecedingLineBreak() || !this.eat(81)) { |
|
return type; |
|
} |
|
|
|
const node = this.startNodeAtNode(type); |
|
node.checkType = type; |
|
node.extendsType = this.tsInDisallowConditionalTypesContext(() => this.tsParseNonConditionalType()); |
|
this.expect(17); |
|
node.trueType = this.tsInAllowConditionalTypesContext(() => this.tsParseType()); |
|
this.expect(14); |
|
node.falseType = this.tsInAllowConditionalTypesContext(() => this.tsParseType()); |
|
return this.finishNode(node, "TSConditionalType"); |
|
} |
|
|
|
isAbstractConstructorSignature() { |
|
return this.isContextual(120) && this.lookahead().type === 77; |
|
} |
|
|
|
tsParseNonConditionalType() { |
|
if (this.tsIsStartOfFunctionType()) { |
|
return this.tsParseFunctionOrConstructorType("TSFunctionType"); |
|
} |
|
|
|
if (this.match(77)) { |
|
return this.tsParseFunctionOrConstructorType("TSConstructorType"); |
|
} else if (this.isAbstractConstructorSignature()) { |
|
return this.tsParseFunctionOrConstructorType("TSConstructorType", true); |
|
} |
|
|
|
return this.tsParseUnionTypeOrHigher(); |
|
} |
|
|
|
tsParseTypeAssertion() { |
|
if (this.getPluginOption("typescript", "disallowAmbiguousJSXLike")) { |
|
this.raise(TSErrors.ReservedTypeAssertion, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
|
|
const node = this.startNode(); |
|
|
|
const _const = this.tsTryNextParseConstantContext(); |
|
|
|
node.typeAnnotation = _const || this.tsNextThenParseType(); |
|
this.expect(48); |
|
node.expression = this.parseMaybeUnary(); |
|
return this.finishNode(node, "TSTypeAssertion"); |
|
} |
|
|
|
tsParseHeritageClause(token) { |
|
const originalStartLoc = this.state.startLoc; |
|
const delimitedList = this.tsParseDelimitedList("HeritageClauseElement", () => { |
|
const node = this.startNode(); |
|
node.expression = this.tsParseEntityName(); |
|
|
|
if (this.match(47)) { |
|
node.typeParameters = this.tsParseTypeArguments(); |
|
} |
|
|
|
return this.finishNode(node, "TSExpressionWithTypeArguments"); |
|
}); |
|
|
|
if (!delimitedList.length) { |
|
this.raise(TSErrors.EmptyHeritageClauseType, { |
|
at: originalStartLoc, |
|
token |
|
}); |
|
} |
|
|
|
return delimitedList; |
|
} |
|
|
|
tsParseInterfaceDeclaration(node, properties = {}) { |
|
if (this.hasFollowingLineBreak()) return null; |
|
this.expectContextual(125); |
|
if (properties.declare) node.declare = true; |
|
|
|
if (tokenIsIdentifier(this.state.type)) { |
|
node.id = this.parseIdentifier(); |
|
this.checkIdentifier(node.id, BIND_TS_INTERFACE); |
|
} else { |
|
node.id = null; |
|
this.raise(TSErrors.MissingInterfaceName, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
|
|
node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutModifiers.bind(this)); |
|
|
|
if (this.eat(81)) { |
|
node.extends = this.tsParseHeritageClause("extends"); |
|
} |
|
|
|
const body = this.startNode(); |
|
body.body = this.tsInType(this.tsParseObjectTypeMembers.bind(this)); |
|
node.body = this.finishNode(body, "TSInterfaceBody"); |
|
return this.finishNode(node, "TSInterfaceDeclaration"); |
|
} |
|
|
|
tsParseTypeAliasDeclaration(node) { |
|
node.id = this.parseIdentifier(); |
|
this.checkIdentifier(node.id, BIND_TS_TYPE); |
|
node.typeAnnotation = this.tsInType(() => { |
|
node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutModifiers.bind(this)); |
|
this.expect(29); |
|
|
|
if (this.isContextual(111) && this.lookahead().type !== 16) { |
|
const node = this.startNode(); |
|
this.next(); |
|
return this.finishNode(node, "TSIntrinsicKeyword"); |
|
} |
|
|
|
return this.tsParseType(); |
|
}); |
|
this.semicolon(); |
|
return this.finishNode(node, "TSTypeAliasDeclaration"); |
|
} |
|
|
|
tsInNoContext(cb) { |
|
const oldContext = this.state.context; |
|
this.state.context = [oldContext[0]]; |
|
|
|
try { |
|
return cb(); |
|
} finally { |
|
this.state.context = oldContext; |
|
} |
|
} |
|
|
|
tsInType(cb) { |
|
const oldInType = this.state.inType; |
|
this.state.inType = true; |
|
|
|
try { |
|
return cb(); |
|
} finally { |
|
this.state.inType = oldInType; |
|
} |
|
} |
|
|
|
tsInDisallowConditionalTypesContext(cb) { |
|
const oldInDisallowConditionalTypesContext = this.state.inDisallowConditionalTypesContext; |
|
this.state.inDisallowConditionalTypesContext = true; |
|
|
|
try { |
|
return cb(); |
|
} finally { |
|
this.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext; |
|
} |
|
} |
|
|
|
tsInAllowConditionalTypesContext(cb) { |
|
const oldInDisallowConditionalTypesContext = this.state.inDisallowConditionalTypesContext; |
|
this.state.inDisallowConditionalTypesContext = false; |
|
|
|
try { |
|
return cb(); |
|
} finally { |
|
this.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext; |
|
} |
|
} |
|
|
|
tsEatThenParseType(token) { |
|
return !this.match(token) ? undefined : this.tsNextThenParseType(); |
|
} |
|
|
|
tsExpectThenParseType(token) { |
|
return this.tsDoThenParseType(() => this.expect(token)); |
|
} |
|
|
|
tsNextThenParseType() { |
|
return this.tsDoThenParseType(() => this.next()); |
|
} |
|
|
|
tsDoThenParseType(cb) { |
|
return this.tsInType(() => { |
|
cb(); |
|
return this.tsParseType(); |
|
}); |
|
} |
|
|
|
tsParseEnumMember() { |
|
const node = this.startNode(); |
|
node.id = this.match(129) ? this.parseExprAtom() : this.parseIdentifier(true); |
|
|
|
if (this.eat(29)) { |
|
node.initializer = this.parseMaybeAssignAllowIn(); |
|
} |
|
|
|
return this.finishNode(node, "TSEnumMember"); |
|
} |
|
|
|
tsParseEnumDeclaration(node, properties = {}) { |
|
if (properties.const) node.const = true; |
|
if (properties.declare) node.declare = true; |
|
this.expectContextual(122); |
|
node.id = this.parseIdentifier(); |
|
this.checkIdentifier(node.id, node.const ? BIND_TS_CONST_ENUM : BIND_TS_ENUM); |
|
this.expect(5); |
|
node.members = this.tsParseDelimitedList("EnumMembers", this.tsParseEnumMember.bind(this)); |
|
this.expect(8); |
|
return this.finishNode(node, "TSEnumDeclaration"); |
|
} |
|
|
|
tsParseModuleBlock() { |
|
const node = this.startNode(); |
|
this.scope.enter(SCOPE_OTHER); |
|
this.expect(5); |
|
this.parseBlockOrModuleBlockBody(node.body = [], undefined, true, 8); |
|
this.scope.exit(); |
|
return this.finishNode(node, "TSModuleBlock"); |
|
} |
|
|
|
tsParseModuleOrNamespaceDeclaration(node, nested = false) { |
|
node.id = this.parseIdentifier(); |
|
|
|
if (!nested) { |
|
this.checkIdentifier(node.id, BIND_TS_NAMESPACE); |
|
} |
|
|
|
if (this.eat(16)) { |
|
const inner = this.startNode(); |
|
this.tsParseModuleOrNamespaceDeclaration(inner, true); |
|
node.body = inner; |
|
} else { |
|
this.scope.enter(SCOPE_TS_MODULE); |
|
this.prodParam.enter(PARAM); |
|
node.body = this.tsParseModuleBlock(); |
|
this.prodParam.exit(); |
|
this.scope.exit(); |
|
} |
|
|
|
return this.finishNode(node, "TSModuleDeclaration"); |
|
} |
|
|
|
tsParseAmbientExternalModuleDeclaration(node) { |
|
if (this.isContextual(109)) { |
|
node.global = true; |
|
node.id = this.parseIdentifier(); |
|
} else if (this.match(129)) { |
|
node.id = this.parseExprAtom(); |
|
} else { |
|
this.unexpected(); |
|
} |
|
|
|
if (this.match(5)) { |
|
this.scope.enter(SCOPE_TS_MODULE); |
|
this.prodParam.enter(PARAM); |
|
node.body = this.tsParseModuleBlock(); |
|
this.prodParam.exit(); |
|
this.scope.exit(); |
|
} else { |
|
this.semicolon(); |
|
} |
|
|
|
return this.finishNode(node, "TSModuleDeclaration"); |
|
} |
|
|
|
tsParseImportEqualsDeclaration(node, isExport) { |
|
node.isExport = isExport || false; |
|
node.id = this.parseIdentifier(); |
|
this.checkIdentifier(node.id, BIND_LEXICAL); |
|
this.expect(29); |
|
const moduleReference = this.tsParseModuleReference(); |
|
|
|
if (node.importKind === "type" && moduleReference.type !== "TSExternalModuleReference") { |
|
this.raise(TSErrors.ImportAliasHasImportType, { |
|
at: moduleReference |
|
}); |
|
} |
|
|
|
node.moduleReference = moduleReference; |
|
this.semicolon(); |
|
return this.finishNode(node, "TSImportEqualsDeclaration"); |
|
} |
|
|
|
tsIsExternalModuleReference() { |
|
return this.isContextual(116) && this.lookaheadCharCode() === 40; |
|
} |
|
|
|
tsParseModuleReference() { |
|
return this.tsIsExternalModuleReference() ? this.tsParseExternalModuleReference() : this.tsParseEntityName(false); |
|
} |
|
|
|
tsParseExternalModuleReference() { |
|
const node = this.startNode(); |
|
this.expectContextual(116); |
|
this.expect(10); |
|
|
|
if (!this.match(129)) { |
|
throw this.unexpected(); |
|
} |
|
|
|
node.expression = this.parseExprAtom(); |
|
this.expect(11); |
|
return this.finishNode(node, "TSExternalModuleReference"); |
|
} |
|
|
|
tsLookAhead(f) { |
|
const state = this.state.clone(); |
|
const res = f(); |
|
this.state = state; |
|
return res; |
|
} |
|
|
|
tsTryParseAndCatch(f) { |
|
const result = this.tryParse(abort => f() || abort()); |
|
if (result.aborted || !result.node) return undefined; |
|
if (result.error) this.state = result.failState; |
|
return result.node; |
|
} |
|
|
|
tsTryParse(f) { |
|
const state = this.state.clone(); |
|
const result = f(); |
|
|
|
if (result !== undefined && result !== false) { |
|
return result; |
|
} else { |
|
this.state = state; |
|
return undefined; |
|
} |
|
} |
|
|
|
tsTryParseDeclare(nany) { |
|
if (this.isLineTerminator()) { |
|
return; |
|
} |
|
|
|
let starttype = this.state.type; |
|
let kind; |
|
|
|
if (this.isContextual(99)) { |
|
starttype = 74; |
|
kind = "let"; |
|
} |
|
|
|
return this.tsInAmbientContext(() => { |
|
if (starttype === 68) { |
|
nany.declare = true; |
|
return this.parseFunctionStatement(nany, false, true); |
|
} |
|
|
|
if (starttype === 80) { |
|
nany.declare = true; |
|
return this.parseClass(nany, true, false); |
|
} |
|
|
|
if (starttype === 122) { |
|
return this.tsParseEnumDeclaration(nany, { |
|
declare: true |
|
}); |
|
} |
|
|
|
if (starttype === 109) { |
|
return this.tsParseAmbientExternalModuleDeclaration(nany); |
|
} |
|
|
|
if (starttype === 75 || starttype === 74) { |
|
if (!this.match(75) || !this.isLookaheadContextual("enum")) { |
|
nany.declare = true; |
|
return this.parseVarStatement(nany, kind || this.state.value, true); |
|
} |
|
|
|
this.expect(75); |
|
return this.tsParseEnumDeclaration(nany, { |
|
const: true, |
|
declare: true |
|
}); |
|
} |
|
|
|
if (starttype === 125) { |
|
const result = this.tsParseInterfaceDeclaration(nany, { |
|
declare: true |
|
}); |
|
if (result) return result; |
|
} |
|
|
|
if (tokenIsIdentifier(starttype)) { |
|
return this.tsParseDeclaration(nany, this.state.value, true); |
|
} |
|
}); |
|
} |
|
|
|
tsTryParseExportDeclaration() { |
|
return this.tsParseDeclaration(this.startNode(), this.state.value, true); |
|
} |
|
|
|
tsParseExpressionStatement(node, expr) { |
|
switch (expr.name) { |
|
case "declare": |
|
{ |
|
const declaration = this.tsTryParseDeclare(node); |
|
|
|
if (declaration) { |
|
declaration.declare = true; |
|
return declaration; |
|
} |
|
|
|
break; |
|
} |
|
|
|
case "global": |
|
if (this.match(5)) { |
|
this.scope.enter(SCOPE_TS_MODULE); |
|
this.prodParam.enter(PARAM); |
|
const mod = node; |
|
mod.global = true; |
|
mod.id = expr; |
|
mod.body = this.tsParseModuleBlock(); |
|
this.scope.exit(); |
|
this.prodParam.exit(); |
|
return this.finishNode(mod, "TSModuleDeclaration"); |
|
} |
|
|
|
break; |
|
|
|
default: |
|
return this.tsParseDeclaration(node, expr.name, false); |
|
} |
|
} |
|
|
|
tsParseDeclaration(node, value, next) { |
|
switch (value) { |
|
case "abstract": |
|
if (this.tsCheckLineTerminator(next) && (this.match(80) || tokenIsIdentifier(this.state.type))) { |
|
return this.tsParseAbstractDeclaration(node); |
|
} |
|
|
|
break; |
|
|
|
case "module": |
|
if (this.tsCheckLineTerminator(next)) { |
|
if (this.match(129)) { |
|
return this.tsParseAmbientExternalModuleDeclaration(node); |
|
} else if (tokenIsIdentifier(this.state.type)) { |
|
return this.tsParseModuleOrNamespaceDeclaration(node); |
|
} |
|
} |
|
|
|
break; |
|
|
|
case "namespace": |
|
if (this.tsCheckLineTerminator(next) && tokenIsIdentifier(this.state.type)) { |
|
return this.tsParseModuleOrNamespaceDeclaration(node); |
|
} |
|
|
|
break; |
|
|
|
case "type": |
|
if (this.tsCheckLineTerminator(next) && tokenIsIdentifier(this.state.type)) { |
|
return this.tsParseTypeAliasDeclaration(node); |
|
} |
|
|
|
break; |
|
} |
|
} |
|
|
|
tsCheckLineTerminator(next) { |
|
if (next) { |
|
if (this.hasFollowingLineBreak()) return false; |
|
this.next(); |
|
return true; |
|
} |
|
|
|
return !this.isLineTerminator(); |
|
} |
|
|
|
tsTryParseGenericAsyncArrowFunction(startPos, startLoc) { |
|
if (!this.match(47)) { |
|
return undefined; |
|
} |
|
|
|
const oldMaybeInArrowParameters = this.state.maybeInArrowParameters; |
|
this.state.maybeInArrowParameters = true; |
|
const res = this.tsTryParseAndCatch(() => { |
|
const node = this.startNodeAt(startPos, startLoc); |
|
node.typeParameters = this.tsParseTypeParameters(); |
|
super.parseFunctionParams(node); |
|
node.returnType = this.tsTryParseTypeOrTypePredicateAnnotation(); |
|
this.expect(19); |
|
return node; |
|
}); |
|
this.state.maybeInArrowParameters = oldMaybeInArrowParameters; |
|
|
|
if (!res) { |
|
return undefined; |
|
} |
|
|
|
return this.parseArrowExpression(res, null, true); |
|
} |
|
|
|
tsParseTypeArgumentsInExpression() { |
|
if (this.reScan_lt() !== 47) { |
|
return undefined; |
|
} |
|
|
|
return this.tsParseTypeArguments(); |
|
} |
|
|
|
tsParseTypeArguments() { |
|
const node = this.startNode(); |
|
node.params = this.tsInType(() => this.tsInNoContext(() => { |
|
this.expect(47); |
|
return this.tsParseDelimitedList("TypeParametersOrArguments", this.tsParseType.bind(this)); |
|
})); |
|
|
|
if (node.params.length === 0) { |
|
this.raise(TSErrors.EmptyTypeArguments, { |
|
at: node |
|
}); |
|
} |
|
|
|
this.expect(48); |
|
return this.finishNode(node, "TSTypeParameterInstantiation"); |
|
} |
|
|
|
tsIsDeclarationStart() { |
|
return tokenIsTSDeclarationStart(this.state.type); |
|
} |
|
|
|
isExportDefaultSpecifier() { |
|
if (this.tsIsDeclarationStart()) return false; |
|
return super.isExportDefaultSpecifier(); |
|
} |
|
|
|
parseAssignableListItem(allowModifiers, decorators) { |
|
const startPos = this.state.start; |
|
const startLoc = this.state.startLoc; |
|
let accessibility; |
|
let readonly = false; |
|
let override = false; |
|
|
|
if (allowModifiers !== undefined) { |
|
const modified = {}; |
|
this.tsParseModifiers({ |
|
modified, |
|
allowedModifiers: ["public", "private", "protected", "override", "readonly"] |
|
}); |
|
accessibility = modified.accessibility; |
|
override = modified.override; |
|
readonly = modified.readonly; |
|
|
|
if (allowModifiers === false && (accessibility || readonly || override)) { |
|
this.raise(TSErrors.UnexpectedParameterModifier, { |
|
at: startLoc |
|
}); |
|
} |
|
} |
|
|
|
const left = this.parseMaybeDefault(); |
|
this.parseAssignableListItemTypes(left); |
|
const elt = this.parseMaybeDefault(left.start, left.loc.start, left); |
|
|
|
if (accessibility || readonly || override) { |
|
const pp = this.startNodeAt(startPos, startLoc); |
|
|
|
if (decorators.length) { |
|
pp.decorators = decorators; |
|
} |
|
|
|
if (accessibility) pp.accessibility = accessibility; |
|
if (readonly) pp.readonly = readonly; |
|
if (override) pp.override = override; |
|
|
|
if (elt.type !== "Identifier" && elt.type !== "AssignmentPattern") { |
|
this.raise(TSErrors.UnsupportedParameterPropertyKind, { |
|
at: pp |
|
}); |
|
} |
|
|
|
pp.parameter = elt; |
|
return this.finishNode(pp, "TSParameterProperty"); |
|
} |
|
|
|
if (decorators.length) { |
|
left.decorators = decorators; |
|
} |
|
|
|
return elt; |
|
} |
|
|
|
isSimpleParameter(node) { |
|
return node.type === "TSParameterProperty" && super.isSimpleParameter(node.parameter) || super.isSimpleParameter(node); |
|
} |
|
|
|
parseFunctionBodyAndFinish(node, type, isMethod = false) { |
|
if (this.match(14)) { |
|
node.returnType = this.tsParseTypeOrTypePredicateAnnotation(14); |
|
} |
|
|
|
const bodilessType = type === "FunctionDeclaration" ? "TSDeclareFunction" : type === "ClassMethod" || type === "ClassPrivateMethod" ? "TSDeclareMethod" : undefined; |
|
|
|
if (bodilessType && !this.match(5) && this.isLineTerminator()) { |
|
this.finishNode(node, bodilessType); |
|
return; |
|
} |
|
|
|
if (bodilessType === "TSDeclareFunction" && this.state.isAmbientContext) { |
|
this.raise(TSErrors.DeclareFunctionHasImplementation, { |
|
at: node |
|
}); |
|
|
|
if (node.declare) { |
|
super.parseFunctionBodyAndFinish(node, bodilessType, isMethod); |
|
return; |
|
} |
|
} |
|
|
|
super.parseFunctionBodyAndFinish(node, type, isMethod); |
|
} |
|
|
|
registerFunctionStatementId(node) { |
|
if (!node.body && node.id) { |
|
this.checkIdentifier(node.id, BIND_TS_AMBIENT); |
|
} else { |
|
super.registerFunctionStatementId(...arguments); |
|
} |
|
} |
|
|
|
tsCheckForInvalidTypeCasts(items) { |
|
items.forEach(node => { |
|
if ((node == null ? void 0 : node.type) === "TSTypeCastExpression") { |
|
this.raise(TSErrors.UnexpectedTypeAnnotation, { |
|
at: node.typeAnnotation |
|
}); |
|
} |
|
}); |
|
} |
|
|
|
toReferencedList(exprList, isInParens) { |
|
this.tsCheckForInvalidTypeCasts(exprList); |
|
return exprList; |
|
} |
|
|
|
parseArrayLike(...args) { |
|
const node = super.parseArrayLike(...args); |
|
|
|
if (node.type === "ArrayExpression") { |
|
this.tsCheckForInvalidTypeCasts(node.elements); |
|
} |
|
|
|
return node; |
|
} |
|
|
|
parseSubscript(base, startPos, startLoc, noCalls, state) { |
|
if (!this.hasPrecedingLineBreak() && this.match(35)) { |
|
this.state.canStartJSXElement = false; |
|
this.next(); |
|
const nonNullExpression = this.startNodeAt(startPos, startLoc); |
|
nonNullExpression.expression = base; |
|
return this.finishNode(nonNullExpression, "TSNonNullExpression"); |
|
} |
|
|
|
let isOptionalCall = false; |
|
|
|
if (this.match(18) && this.lookaheadCharCode() === 60) { |
|
if (noCalls) { |
|
state.stop = true; |
|
return base; |
|
} |
|
|
|
state.optionalChainMember = isOptionalCall = true; |
|
this.next(); |
|
} |
|
|
|
if (this.match(47) || this.match(51)) { |
|
let missingParenErrorLoc; |
|
const result = this.tsTryParseAndCatch(() => { |
|
if (!noCalls && this.atPossibleAsyncArrow(base)) { |
|
const asyncArrowFn = this.tsTryParseGenericAsyncArrowFunction(startPos, startLoc); |
|
|
|
if (asyncArrowFn) { |
|
return asyncArrowFn; |
|
} |
|
} |
|
|
|
const typeArguments = this.tsParseTypeArgumentsInExpression(); |
|
if (!typeArguments) return; |
|
|
|
if (isOptionalCall && !this.match(10)) { |
|
missingParenErrorLoc = this.state.curPosition(); |
|
return; |
|
} |
|
|
|
if (tokenIsTemplate(this.state.type)) { |
|
const result = this.parseTaggedTemplateExpression(base, startPos, startLoc, state); |
|
result.typeParameters = typeArguments; |
|
return result; |
|
} |
|
|
|
if (!noCalls && this.eat(10)) { |
|
const node = this.startNodeAt(startPos, startLoc); |
|
node.callee = base; |
|
node.arguments = this.parseCallExpressionArguments(11, false); |
|
this.tsCheckForInvalidTypeCasts(node.arguments); |
|
node.typeParameters = typeArguments; |
|
|
|
if (state.optionalChainMember) { |
|
node.optional = isOptionalCall; |
|
} |
|
|
|
return this.finishCallExpression(node, state.optionalChainMember); |
|
} |
|
|
|
const tokenType = this.state.type; |
|
|
|
if (tokenType === 48 || tokenType !== 10 && tokenCanStartExpression(tokenType) && !this.hasPrecedingLineBreak()) { |
|
return; |
|
} |
|
|
|
const node = this.startNodeAt(startPos, startLoc); |
|
node.expression = base; |
|
node.typeParameters = typeArguments; |
|
return this.finishNode(node, "TSInstantiationExpression"); |
|
}); |
|
|
|
if (missingParenErrorLoc) { |
|
this.unexpected(missingParenErrorLoc, 10); |
|
} |
|
|
|
if (result) { |
|
if (result.type === "TSInstantiationExpression" && (this.match(16) || this.match(18) && this.lookaheadCharCode() !== 40)) { |
|
this.raise(TSErrors.InvalidPropertyAccessAfterInstantiationExpression, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
|
|
return result; |
|
} |
|
} |
|
|
|
return super.parseSubscript(base, startPos, startLoc, noCalls, state); |
|
} |
|
|
|
parseNewCallee(node) { |
|
var _callee$extra; |
|
|
|
super.parseNewCallee(node); |
|
const { |
|
callee |
|
} = node; |
|
|
|
if (callee.type === "TSInstantiationExpression" && !((_callee$extra = callee.extra) != null && _callee$extra.parenthesized)) { |
|
node.typeParameters = callee.typeParameters; |
|
node.callee = callee.expression; |
|
} |
|
} |
|
|
|
parseExprOp(left, leftStartPos, leftStartLoc, minPrec) { |
|
if (tokenOperatorPrecedence(58) > minPrec && !this.hasPrecedingLineBreak() && this.isContextual(93)) { |
|
const node = this.startNodeAt(leftStartPos, leftStartLoc); |
|
node.expression = left; |
|
|
|
const _const = this.tsTryNextParseConstantContext(); |
|
|
|
if (_const) { |
|
node.typeAnnotation = _const; |
|
} else { |
|
node.typeAnnotation = this.tsNextThenParseType(); |
|
} |
|
|
|
this.finishNode(node, "TSAsExpression"); |
|
this.reScan_lt_gt(); |
|
return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec); |
|
} |
|
|
|
return super.parseExprOp(left, leftStartPos, leftStartLoc, minPrec); |
|
} |
|
|
|
checkReservedWord(word, startLoc, checkKeywords, isBinding) { |
|
if (!this.state.isAmbientContext) { |
|
super.checkReservedWord(word, startLoc, checkKeywords, isBinding); |
|
} |
|
} |
|
|
|
checkDuplicateExports() {} |
|
|
|
parseImport(node) { |
|
node.importKind = "value"; |
|
|
|
if (tokenIsIdentifier(this.state.type) || this.match(55) || this.match(5)) { |
|
let ahead = this.lookahead(); |
|
|
|
if (this.isContextual(126) && ahead.type !== 12 && ahead.type !== 97 && ahead.type !== 29) { |
|
node.importKind = "type"; |
|
this.next(); |
|
ahead = this.lookahead(); |
|
} |
|
|
|
if (tokenIsIdentifier(this.state.type) && ahead.type === 29) { |
|
return this.tsParseImportEqualsDeclaration(node); |
|
} |
|
} |
|
|
|
const importNode = super.parseImport(node); |
|
|
|
if (importNode.importKind === "type" && importNode.specifiers.length > 1 && importNode.specifiers[0].type === "ImportDefaultSpecifier") { |
|
this.raise(TSErrors.TypeImportCannotSpecifyDefaultAndNamed, { |
|
at: importNode |
|
}); |
|
} |
|
|
|
return importNode; |
|
} |
|
|
|
parseExport(node) { |
|
if (this.match(83)) { |
|
this.next(); |
|
|
|
if (this.isContextual(126) && this.lookaheadCharCode() !== 61) { |
|
node.importKind = "type"; |
|
this.next(); |
|
} else { |
|
node.importKind = "value"; |
|
} |
|
|
|
return this.tsParseImportEqualsDeclaration(node, true); |
|
} else if (this.eat(29)) { |
|
const assign = node; |
|
assign.expression = this.parseExpression(); |
|
this.semicolon(); |
|
return this.finishNode(assign, "TSExportAssignment"); |
|
} else if (this.eatContextual(93)) { |
|
const decl = node; |
|
this.expectContextual(124); |
|
decl.id = this.parseIdentifier(); |
|
this.semicolon(); |
|
return this.finishNode(decl, "TSNamespaceExportDeclaration"); |
|
} else { |
|
if (this.isContextual(126) && this.lookahead().type === 5) { |
|
this.next(); |
|
node.exportKind = "type"; |
|
} else { |
|
node.exportKind = "value"; |
|
} |
|
|
|
return super.parseExport(node); |
|
} |
|
} |
|
|
|
isAbstractClass() { |
|
return this.isContextual(120) && this.lookahead().type === 80; |
|
} |
|
|
|
parseExportDefaultExpression() { |
|
if (this.isAbstractClass()) { |
|
const cls = this.startNode(); |
|
this.next(); |
|
cls.abstract = true; |
|
this.parseClass(cls, true, true); |
|
return cls; |
|
} |
|
|
|
if (this.match(125)) { |
|
const result = this.tsParseInterfaceDeclaration(this.startNode()); |
|
if (result) return result; |
|
} |
|
|
|
return super.parseExportDefaultExpression(); |
|
} |
|
|
|
parseVarStatement(node, kind, allowMissingInitializer = false) { |
|
const { |
|
isAmbientContext |
|
} = this.state; |
|
const declaration = super.parseVarStatement(node, kind, allowMissingInitializer || isAmbientContext); |
|
if (!isAmbientContext) return declaration; |
|
|
|
for (const { |
|
id, |
|
init |
|
} of declaration.declarations) { |
|
if (!init) continue; |
|
|
|
if (kind !== "const" || !!id.typeAnnotation) { |
|
this.raise(TSErrors.InitializerNotAllowedInAmbientContext, { |
|
at: init |
|
}); |
|
} else if (init.type !== "StringLiteral" && init.type !== "BooleanLiteral" && init.type !== "NumericLiteral" && init.type !== "BigIntLiteral" && (init.type !== "TemplateLiteral" || init.expressions.length > 0) && !isPossiblyLiteralEnum(init)) { |
|
this.raise(TSErrors.ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference, { |
|
at: init |
|
}); |
|
} |
|
} |
|
|
|
return declaration; |
|
} |
|
|
|
parseStatementContent(context, topLevel) { |
|
if (this.match(75) && this.isLookaheadContextual("enum")) { |
|
const node = this.startNode(); |
|
this.expect(75); |
|
return this.tsParseEnumDeclaration(node, { |
|
const: true |
|
}); |
|
} |
|
|
|
if (this.isContextual(122)) { |
|
return this.tsParseEnumDeclaration(this.startNode()); |
|
} |
|
|
|
if (this.isContextual(125)) { |
|
const result = this.tsParseInterfaceDeclaration(this.startNode()); |
|
if (result) return result; |
|
} |
|
|
|
return super.parseStatementContent(context, topLevel); |
|
} |
|
|
|
parseAccessModifier() { |
|
return this.tsParseModifier(["public", "protected", "private"]); |
|
} |
|
|
|
tsHasSomeModifiers(member, modifiers) { |
|
return modifiers.some(modifier => { |
|
if (tsIsAccessModifier(modifier)) { |
|
return member.accessibility === modifier; |
|
} |
|
|
|
return !!member[modifier]; |
|
}); |
|
} |
|
|
|
tsIsStartOfStaticBlocks() { |
|
return this.isContextual(104) && this.lookaheadCharCode() === 123; |
|
} |
|
|
|
parseClassMember(classBody, member, state) { |
|
const modifiers = ["declare", "private", "public", "protected", "override", "abstract", "readonly", "static"]; |
|
this.tsParseModifiers({ |
|
modified: member, |
|
allowedModifiers: modifiers, |
|
disallowedModifiers: ["in", "out"], |
|
stopOnStartOfClassStaticBlock: true, |
|
errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions |
|
}); |
|
|
|
const callParseClassMemberWithIsStatic = () => { |
|
if (this.tsIsStartOfStaticBlocks()) { |
|
this.next(); |
|
this.next(); |
|
|
|
if (this.tsHasSomeModifiers(member, modifiers)) { |
|
this.raise(TSErrors.StaticBlockCannotHaveModifier, { |
|
at: this.state.curPosition() |
|
}); |
|
} |
|
|
|
this.parseClassStaticBlock(classBody, member); |
|
} else { |
|
this.parseClassMemberWithIsStatic(classBody, member, state, !!member.static); |
|
} |
|
}; |
|
|
|
if (member.declare) { |
|
this.tsInAmbientContext(callParseClassMemberWithIsStatic); |
|
} else { |
|
callParseClassMemberWithIsStatic(); |
|
} |
|
} |
|
|
|
parseClassMemberWithIsStatic(classBody, member, state, isStatic) { |
|
const idx = this.tsTryParseIndexSignature(member); |
|
|
|
if (idx) { |
|
classBody.body.push(idx); |
|
|
|
if (member.abstract) { |
|
this.raise(TSErrors.IndexSignatureHasAbstract, { |
|
at: member |
|
}); |
|
} |
|
|
|
if (member.accessibility) { |
|
this.raise(TSErrors.IndexSignatureHasAccessibility, { |
|
at: member, |
|
modifier: member.accessibility |
|
}); |
|
} |
|
|
|
if (member.declare) { |
|
this.raise(TSErrors.IndexSignatureHasDeclare, { |
|
at: member |
|
}); |
|
} |
|
|
|
if (member.override) { |
|
this.raise(TSErrors.IndexSignatureHasOverride, { |
|
at: member |
|
}); |
|
} |
|
|
|
return; |
|
} |
|
|
|
if (!this.state.inAbstractClass && member.abstract) { |
|
this.raise(TSErrors.NonAbstractClassHasAbstractMethod, { |
|
at: member |
|
}); |
|
} |
|
|
|
if (member.override) { |
|
if (!state.hadSuperClass) { |
|
this.raise(TSErrors.OverrideNotInSubClass, { |
|
at: member |
|
}); |
|
} |
|
} |
|
|
|
super.parseClassMemberWithIsStatic(classBody, member, state, isStatic); |
|
} |
|
|
|
parsePostMemberNameModifiers(methodOrProp) { |
|
const optional = this.eat(17); |
|
if (optional) methodOrProp.optional = true; |
|
|
|
if (methodOrProp.readonly && this.match(10)) { |
|
this.raise(TSErrors.ClassMethodHasReadonly, { |
|
at: methodOrProp |
|
}); |
|
} |
|
|
|
if (methodOrProp.declare && this.match(10)) { |
|
this.raise(TSErrors.ClassMethodHasDeclare, { |
|
at: methodOrProp |
|
}); |
|
} |
|
} |
|
|
|
parseExpressionStatement(node, expr) { |
|
const decl = expr.type === "Identifier" ? this.tsParseExpressionStatement(node, expr) : undefined; |
|
return decl || super.parseExpressionStatement(node, expr); |
|
} |
|
|
|
shouldParseExportDeclaration() { |
|
if (this.tsIsDeclarationStart()) return true; |
|
return super.shouldParseExportDeclaration(); |
|
} |
|
|
|
parseConditional(expr, startPos, startLoc, refExpressionErrors) { |
|
if (!this.state.maybeInArrowParameters || !this.match(17)) { |
|
return super.parseConditional(expr, startPos, startLoc, refExpressionErrors); |
|
} |
|
|
|
const result = this.tryParse(() => super.parseConditional(expr, startPos, startLoc)); |
|
|
|
if (!result.node) { |
|
if (result.error) { |
|
super.setOptionalParametersError(refExpressionErrors, result.error); |
|
} |
|
|
|
return expr; |
|
} |
|
|
|
if (result.error) this.state = result.failState; |
|
return result.node; |
|
} |
|
|
|
parseParenItem(node, startPos, startLoc) { |
|
node = super.parseParenItem(node, startPos, startLoc); |
|
|
|
if (this.eat(17)) { |
|
node.optional = true; |
|
this.resetEndLocation(node); |
|
} |
|
|
|
if (this.match(14)) { |
|
const typeCastNode = this.startNodeAt(startPos, startLoc); |
|
typeCastNode.expression = node; |
|
typeCastNode.typeAnnotation = this.tsParseTypeAnnotation(); |
|
return this.finishNode(typeCastNode, "TSTypeCastExpression"); |
|
} |
|
|
|
return node; |
|
} |
|
|
|
parseExportDeclaration(node) { |
|
if (!this.state.isAmbientContext && this.isContextual(121)) { |
|
return this.tsInAmbientContext(() => this.parseExportDeclaration(node)); |
|
} |
|
|
|
const startPos = this.state.start; |
|
const startLoc = this.state.startLoc; |
|
const isDeclare = this.eatContextual(121); |
|
|
|
if (isDeclare && (this.isContextual(121) || !this.shouldParseExportDeclaration())) { |
|
throw this.raise(TSErrors.ExpectedAmbientAfterExportDeclare, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
|
|
const isIdentifier = tokenIsIdentifier(this.state.type); |
|
const declaration = isIdentifier && this.tsTryParseExportDeclaration() || super.parseExportDeclaration(node); |
|
if (!declaration) return null; |
|
|
|
if (declaration.type === "TSInterfaceDeclaration" || declaration.type === "TSTypeAliasDeclaration" || isDeclare) { |
|
node.exportKind = "type"; |
|
} |
|
|
|
if (isDeclare) { |
|
this.resetStartLocation(declaration, startPos, startLoc); |
|
declaration.declare = true; |
|
} |
|
|
|
return declaration; |
|
} |
|
|
|
parseClassId(node, isStatement, optionalId) { |
|
if ((!isStatement || optionalId) && this.isContextual(110)) { |
|
return; |
|
} |
|
|
|
super.parseClassId(node, isStatement, optionalId, node.declare ? BIND_TS_AMBIENT : BIND_CLASS); |
|
const typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutModifiers.bind(this)); |
|
if (typeParameters) node.typeParameters = typeParameters; |
|
} |
|
|
|
parseClassPropertyAnnotation(node) { |
|
if (!node.optional && this.eat(35)) { |
|
node.definite = true; |
|
} |
|
|
|
const type = this.tsTryParseTypeAnnotation(); |
|
if (type) node.typeAnnotation = type; |
|
} |
|
|
|
parseClassProperty(node) { |
|
this.parseClassPropertyAnnotation(node); |
|
|
|
if (this.state.isAmbientContext && this.match(29)) { |
|
this.raise(TSErrors.DeclareClassFieldHasInitializer, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
|
|
if (node.abstract && this.match(29)) { |
|
const { |
|
key |
|
} = node; |
|
this.raise(TSErrors.AbstractPropertyHasInitializer, { |
|
at: this.state.startLoc, |
|
propertyName: key.type === "Identifier" && !node.computed ? key.name : `[${this.input.slice(key.start, key.end)}]` |
|
}); |
|
} |
|
|
|
return super.parseClassProperty(node); |
|
} |
|
|
|
parseClassPrivateProperty(node) { |
|
if (node.abstract) { |
|
this.raise(TSErrors.PrivateElementHasAbstract, { |
|
at: node |
|
}); |
|
} |
|
|
|
if (node.accessibility) { |
|
this.raise(TSErrors.PrivateElementHasAccessibility, { |
|
at: node, |
|
modifier: node.accessibility |
|
}); |
|
} |
|
|
|
this.parseClassPropertyAnnotation(node); |
|
return super.parseClassPrivateProperty(node); |
|
} |
|
|
|
pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) { |
|
const typeParameters = this.tsTryParseTypeParameters(); |
|
|
|
if (typeParameters && isConstructor) { |
|
this.raise(TSErrors.ConstructorHasTypeParameters, { |
|
at: typeParameters |
|
}); |
|
} |
|
|
|
const { |
|
declare = false, |
|
kind |
|
} = method; |
|
|
|
if (declare && (kind === "get" || kind === "set")) { |
|
this.raise(TSErrors.DeclareAccessor, { |
|
at: method, |
|
kind |
|
}); |
|
} |
|
|
|
if (typeParameters) method.typeParameters = typeParameters; |
|
super.pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper); |
|
} |
|
|
|
pushClassPrivateMethod(classBody, method, isGenerator, isAsync) { |
|
const typeParameters = this.tsTryParseTypeParameters(); |
|
if (typeParameters) method.typeParameters = typeParameters; |
|
super.pushClassPrivateMethod(classBody, method, isGenerator, isAsync); |
|
} |
|
|
|
declareClassPrivateMethodInScope(node, kind) { |
|
if (node.type === "TSDeclareMethod") return; |
|
if (node.type === "MethodDefinition" && !node.value.body) return; |
|
super.declareClassPrivateMethodInScope(node, kind); |
|
} |
|
|
|
parseClassSuper(node) { |
|
super.parseClassSuper(node); |
|
|
|
if (node.superClass && (this.match(47) || this.match(51))) { |
|
node.superTypeParameters = this.tsParseTypeArgumentsInExpression(); |
|
} |
|
|
|
if (this.eatContextual(110)) { |
|
node.implements = this.tsParseHeritageClause("implements"); |
|
} |
|
} |
|
|
|
parseObjPropValue(prop, ...args) { |
|
const typeParameters = this.tsTryParseTypeParameters(); |
|
if (typeParameters) prop.typeParameters = typeParameters; |
|
super.parseObjPropValue(prop, ...args); |
|
} |
|
|
|
parseFunctionParams(node, allowModifiers) { |
|
const typeParameters = this.tsTryParseTypeParameters(); |
|
if (typeParameters) node.typeParameters = typeParameters; |
|
super.parseFunctionParams(node, allowModifiers); |
|
} |
|
|
|
parseVarId(decl, kind) { |
|
super.parseVarId(decl, kind); |
|
|
|
if (decl.id.type === "Identifier" && !this.hasPrecedingLineBreak() && this.eat(35)) { |
|
decl.definite = true; |
|
} |
|
|
|
const type = this.tsTryParseTypeAnnotation(); |
|
|
|
if (type) { |
|
decl.id.typeAnnotation = type; |
|
this.resetEndLocation(decl.id); |
|
} |
|
} |
|
|
|
parseAsyncArrowFromCallExpression(node, call) { |
|
if (this.match(14)) { |
|
node.returnType = this.tsParseTypeAnnotation(); |
|
} |
|
|
|
return super.parseAsyncArrowFromCallExpression(node, call); |
|
} |
|
|
|
parseMaybeAssign(...args) { |
|
var _jsx, _jsx2, _typeCast, _jsx3, _typeCast2, _jsx4, _typeCast3; |
|
|
|
let state; |
|
let jsx; |
|
let typeCast; |
|
|
|
if (this.hasPlugin("jsx") && (this.match(138) || this.match(47))) { |
|
state = this.state.clone(); |
|
jsx = this.tryParse(() => super.parseMaybeAssign(...args), state); |
|
if (!jsx.error) return jsx.node; |
|
const { |
|
context |
|
} = this.state; |
|
const currentContext = context[context.length - 1]; |
|
|
|
if (currentContext === types.j_oTag || currentContext === types.j_expr) { |
|
context.pop(); |
|
} |
|
} |
|
|
|
if (!((_jsx = jsx) != null && _jsx.error) && !this.match(47)) { |
|
return super.parseMaybeAssign(...args); |
|
} |
|
|
|
if (!state || state === this.state) state = this.state.clone(); |
|
let typeParameters; |
|
const arrow = this.tryParse(abort => { |
|
var _expr$extra, _typeParameters; |
|
|
|
typeParameters = this.tsParseTypeParameters(); |
|
const expr = super.parseMaybeAssign(...args); |
|
|
|
if (expr.type !== "ArrowFunctionExpression" || (_expr$extra = expr.extra) != null && _expr$extra.parenthesized) { |
|
abort(); |
|
} |
|
|
|
if (((_typeParameters = typeParameters) == null ? void 0 : _typeParameters.params.length) !== 0) { |
|
this.resetStartLocationFromNode(expr, typeParameters); |
|
} |
|
|
|
expr.typeParameters = typeParameters; |
|
return expr; |
|
}, state); |
|
|
|
if (!arrow.error && !arrow.aborted) { |
|
if (typeParameters) this.reportReservedArrowTypeParam(typeParameters); |
|
return arrow.node; |
|
} |
|
|
|
if (!jsx) { |
|
assert(!this.hasPlugin("jsx")); |
|
typeCast = this.tryParse(() => super.parseMaybeAssign(...args), state); |
|
if (!typeCast.error) return typeCast.node; |
|
} |
|
|
|
if ((_jsx2 = jsx) != null && _jsx2.node) { |
|
this.state = jsx.failState; |
|
return jsx.node; |
|
} |
|
|
|
if (arrow.node) { |
|
this.state = arrow.failState; |
|
if (typeParameters) this.reportReservedArrowTypeParam(typeParameters); |
|
return arrow.node; |
|
} |
|
|
|
if ((_typeCast = typeCast) != null && _typeCast.node) { |
|
this.state = typeCast.failState; |
|
return typeCast.node; |
|
} |
|
|
|
if ((_jsx3 = jsx) != null && _jsx3.thrown) throw jsx.error; |
|
if (arrow.thrown) throw arrow.error; |
|
if ((_typeCast2 = typeCast) != null && _typeCast2.thrown) throw typeCast.error; |
|
throw ((_jsx4 = jsx) == null ? void 0 : _jsx4.error) || arrow.error || ((_typeCast3 = typeCast) == null ? void 0 : _typeCast3.error); |
|
} |
|
|
|
reportReservedArrowTypeParam(node) { |
|
var _node$extra; |
|
|
|
if (node.params.length === 1 && !((_node$extra = node.extra) != null && _node$extra.trailingComma) && this.getPluginOption("typescript", "disallowAmbiguousJSXLike")) { |
|
this.raise(TSErrors.ReservedArrowTypeParam, { |
|
at: node |
|
}); |
|
} |
|
} |
|
|
|
parseMaybeUnary(refExpressionErrors) { |
|
if (!this.hasPlugin("jsx") && this.match(47)) { |
|
return this.tsParseTypeAssertion(); |
|
} else { |
|
return super.parseMaybeUnary(refExpressionErrors); |
|
} |
|
} |
|
|
|
parseArrow(node) { |
|
if (this.match(14)) { |
|
const result = this.tryParse(abort => { |
|
const returnType = this.tsParseTypeOrTypePredicateAnnotation(14); |
|
if (this.canInsertSemicolon() || !this.match(19)) abort(); |
|
return returnType; |
|
}); |
|
if (result.aborted) return; |
|
|
|
if (!result.thrown) { |
|
if (result.error) this.state = result.failState; |
|
node.returnType = result.node; |
|
} |
|
} |
|
|
|
return super.parseArrow(node); |
|
} |
|
|
|
parseAssignableListItemTypes(param) { |
|
if (this.eat(17)) { |
|
if (param.type !== "Identifier" && !this.state.isAmbientContext && !this.state.inType) { |
|
this.raise(TSErrors.PatternIsOptional, { |
|
at: param |
|
}); |
|
} |
|
|
|
param.optional = true; |
|
} |
|
|
|
const type = this.tsTryParseTypeAnnotation(); |
|
if (type) param.typeAnnotation = type; |
|
this.resetEndLocation(param); |
|
return param; |
|
} |
|
|
|
isAssignable(node, isBinding) { |
|
switch (node.type) { |
|
case "TSTypeCastExpression": |
|
return this.isAssignable(node.expression, isBinding); |
|
|
|
case "TSParameterProperty": |
|
return true; |
|
|
|
default: |
|
return super.isAssignable(node, isBinding); |
|
} |
|
} |
|
|
|
toAssignable(node, isLHS = false) { |
|
switch (node.type) { |
|
case "ParenthesizedExpression": |
|
this.toAssignableParenthesizedExpression(node, isLHS); |
|
break; |
|
|
|
case "TSAsExpression": |
|
case "TSNonNullExpression": |
|
case "TSTypeAssertion": |
|
if (isLHS) { |
|
this.expressionScope.recordArrowParemeterBindingError(TSErrors.UnexpectedTypeCastInParameter, { |
|
at: node |
|
}); |
|
} else { |
|
this.raise(TSErrors.UnexpectedTypeCastInParameter, { |
|
at: node |
|
}); |
|
} |
|
|
|
this.toAssignable(node.expression, isLHS); |
|
break; |
|
|
|
case "AssignmentExpression": |
|
if (!isLHS && node.left.type === "TSTypeCastExpression") { |
|
node.left = this.typeCastToParameter(node.left); |
|
} |
|
|
|
default: |
|
super.toAssignable(node, isLHS); |
|
} |
|
} |
|
|
|
toAssignableParenthesizedExpression(node, isLHS) { |
|
switch (node.expression.type) { |
|
case "TSAsExpression": |
|
case "TSNonNullExpression": |
|
case "TSTypeAssertion": |
|
case "ParenthesizedExpression": |
|
this.toAssignable(node.expression, isLHS); |
|
break; |
|
|
|
default: |
|
super.toAssignable(node, isLHS); |
|
} |
|
} |
|
|
|
checkToRestConversion(node, allowPattern) { |
|
switch (node.type) { |
|
case "TSAsExpression": |
|
case "TSTypeAssertion": |
|
case "TSNonNullExpression": |
|
this.checkToRestConversion(node.expression, false); |
|
break; |
|
|
|
default: |
|
super.checkToRestConversion(node, allowPattern); |
|
} |
|
} |
|
|
|
isValidLVal(type, isUnparenthesizedInAssign, binding) { |
|
return getOwn$1({ |
|
TSTypeCastExpression: true, |
|
TSParameterProperty: "parameter", |
|
TSNonNullExpression: "expression", |
|
TSAsExpression: (binding !== BIND_NONE || !isUnparenthesizedInAssign) && ["expression", true], |
|
TSTypeAssertion: (binding !== BIND_NONE || !isUnparenthesizedInAssign) && ["expression", true] |
|
}, type) || super.isValidLVal(type, isUnparenthesizedInAssign, binding); |
|
} |
|
|
|
parseBindingAtom() { |
|
switch (this.state.type) { |
|
case 78: |
|
return this.parseIdentifier(true); |
|
|
|
default: |
|
return super.parseBindingAtom(); |
|
} |
|
} |
|
|
|
parseMaybeDecoratorArguments(expr) { |
|
if (this.match(47) || this.match(51)) { |
|
const typeArguments = this.tsParseTypeArgumentsInExpression(); |
|
|
|
if (this.match(10)) { |
|
const call = super.parseMaybeDecoratorArguments(expr); |
|
call.typeParameters = typeArguments; |
|
return call; |
|
} |
|
|
|
this.unexpected(null, 10); |
|
} |
|
|
|
return super.parseMaybeDecoratorArguments(expr); |
|
} |
|
|
|
checkCommaAfterRest(close) { |
|
if (this.state.isAmbientContext && this.match(12) && this.lookaheadCharCode() === close) { |
|
this.next(); |
|
return false; |
|
} else { |
|
return super.checkCommaAfterRest(close); |
|
} |
|
} |
|
|
|
isClassMethod() { |
|
return this.match(47) || super.isClassMethod(); |
|
} |
|
|
|
isClassProperty() { |
|
return this.match(35) || this.match(14) || super.isClassProperty(); |
|
} |
|
|
|
parseMaybeDefault(...args) { |
|
const node = super.parseMaybeDefault(...args); |
|
|
|
if (node.type === "AssignmentPattern" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) { |
|
this.raise(TSErrors.TypeAnnotationAfterAssign, { |
|
at: node.typeAnnotation |
|
}); |
|
} |
|
|
|
return node; |
|
} |
|
|
|
getTokenFromCode(code) { |
|
if (this.state.inType) { |
|
if (code === 62) { |
|
return this.finishOp(48, 1); |
|
} |
|
|
|
if (code === 60) { |
|
return this.finishOp(47, 1); |
|
} |
|
} |
|
|
|
return super.getTokenFromCode(code); |
|
} |
|
|
|
reScan_lt_gt() { |
|
const { |
|
type |
|
} = this.state; |
|
|
|
if (type === 47) { |
|
this.state.pos -= 1; |
|
this.readToken_lt(); |
|
} else if (type === 48) { |
|
this.state.pos -= 1; |
|
this.readToken_gt(); |
|
} |
|
} |
|
|
|
reScan_lt() { |
|
const { |
|
type |
|
} = this.state; |
|
|
|
if (type === 51) { |
|
this.state.pos -= 2; |
|
this.finishOp(47, 1); |
|
return 47; |
|
} |
|
|
|
return type; |
|
} |
|
|
|
toAssignableList(exprList) { |
|
for (let i = 0; i < exprList.length; i++) { |
|
const expr = exprList[i]; |
|
|
|
if ((expr == null ? void 0 : expr.type) === "TSTypeCastExpression") { |
|
exprList[i] = this.typeCastToParameter(expr); |
|
} |
|
} |
|
|
|
super.toAssignableList(...arguments); |
|
} |
|
|
|
typeCastToParameter(node) { |
|
node.expression.typeAnnotation = node.typeAnnotation; |
|
this.resetEndLocation(node.expression, node.typeAnnotation.loc.end); |
|
return node.expression; |
|
} |
|
|
|
shouldParseArrow(params) { |
|
if (this.match(14)) { |
|
return params.every(expr => this.isAssignable(expr, true)); |
|
} |
|
|
|
return super.shouldParseArrow(params); |
|
} |
|
|
|
shouldParseAsyncArrow() { |
|
return this.match(14) || super.shouldParseAsyncArrow(); |
|
} |
|
|
|
canHaveLeadingDecorator() { |
|
return super.canHaveLeadingDecorator() || this.isAbstractClass(); |
|
} |
|
|
|
jsxParseOpeningElementAfterName(node) { |
|
if (this.match(47) || this.match(51)) { |
|
const typeArguments = this.tsTryParseAndCatch(() => this.tsParseTypeArgumentsInExpression()); |
|
if (typeArguments) node.typeParameters = typeArguments; |
|
} |
|
|
|
return super.jsxParseOpeningElementAfterName(node); |
|
} |
|
|
|
getGetterSetterExpectedParamCount(method) { |
|
const baseCount = super.getGetterSetterExpectedParamCount(method); |
|
const params = this.getObjectOrClassMethodParams(method); |
|
const firstParam = params[0]; |
|
const hasContextParam = firstParam && this.isThisParam(firstParam); |
|
return hasContextParam ? baseCount + 1 : baseCount; |
|
} |
|
|
|
parseCatchClauseParam() { |
|
const param = super.parseCatchClauseParam(); |
|
const type = this.tsTryParseTypeAnnotation(); |
|
|
|
if (type) { |
|
param.typeAnnotation = type; |
|
this.resetEndLocation(param); |
|
} |
|
|
|
return param; |
|
} |
|
|
|
tsInAmbientContext(cb) { |
|
const oldIsAmbientContext = this.state.isAmbientContext; |
|
this.state.isAmbientContext = true; |
|
|
|
try { |
|
return cb(); |
|
} finally { |
|
this.state.isAmbientContext = oldIsAmbientContext; |
|
} |
|
} |
|
|
|
parseClass(node, ...args) { |
|
const oldInAbstractClass = this.state.inAbstractClass; |
|
this.state.inAbstractClass = !!node.abstract; |
|
|
|
try { |
|
return super.parseClass(node, ...args); |
|
} finally { |
|
this.state.inAbstractClass = oldInAbstractClass; |
|
} |
|
} |
|
|
|
tsParseAbstractDeclaration(node) { |
|
if (this.match(80)) { |
|
node.abstract = true; |
|
return this.parseClass(node, true, false); |
|
} else if (this.isContextual(125)) { |
|
if (!this.hasFollowingLineBreak()) { |
|
node.abstract = true; |
|
this.raise(TSErrors.NonClassMethodPropertyHasAbstractModifer, { |
|
at: node |
|
}); |
|
return this.tsParseInterfaceDeclaration(node); |
|
} |
|
} else { |
|
this.unexpected(null, 80); |
|
} |
|
} |
|
|
|
parseMethod(...args) { |
|
const method = super.parseMethod(...args); |
|
|
|
if (method.abstract) { |
|
const hasBody = this.hasPlugin("estree") ? !!method.value.body : !!method.body; |
|
|
|
if (hasBody) { |
|
const { |
|
key |
|
} = method; |
|
this.raise(TSErrors.AbstractMethodHasImplementation, { |
|
at: method, |
|
methodName: key.type === "Identifier" && !method.computed ? key.name : `[${this.input.slice(key.start, key.end)}]` |
|
}); |
|
} |
|
} |
|
|
|
return method; |
|
} |
|
|
|
tsParseTypeParameterName() { |
|
const typeName = this.parseIdentifier(); |
|
return typeName.name; |
|
} |
|
|
|
shouldParseAsAmbientContext() { |
|
return !!this.getPluginOption("typescript", "dts"); |
|
} |
|
|
|
parse() { |
|
if (this.shouldParseAsAmbientContext()) { |
|
this.state.isAmbientContext = true; |
|
} |
|
|
|
return super.parse(); |
|
} |
|
|
|
getExpression() { |
|
if (this.shouldParseAsAmbientContext()) { |
|
this.state.isAmbientContext = true; |
|
} |
|
|
|
return super.getExpression(); |
|
} |
|
|
|
parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly) { |
|
if (!isString && isMaybeTypeOnly) { |
|
this.parseTypeOnlyImportExportSpecifier(node, false, isInTypeExport); |
|
return this.finishNode(node, "ExportSpecifier"); |
|
} |
|
|
|
node.exportKind = "value"; |
|
return super.parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly); |
|
} |
|
|
|
parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly) { |
|
if (!importedIsString && isMaybeTypeOnly) { |
|
this.parseTypeOnlyImportExportSpecifier(specifier, true, isInTypeOnlyImport); |
|
return this.finishNode(specifier, "ImportSpecifier"); |
|
} |
|
|
|
specifier.importKind = "value"; |
|
return super.parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly); |
|
} |
|
|
|
parseTypeOnlyImportExportSpecifier(node, isImport, isInTypeOnlyImportExport) { |
|
const leftOfAsKey = isImport ? "imported" : "local"; |
|
const rightOfAsKey = isImport ? "local" : "exported"; |
|
let leftOfAs = node[leftOfAsKey]; |
|
let rightOfAs; |
|
let hasTypeSpecifier = false; |
|
let canParseAsKeyword = true; |
|
const loc = leftOfAs.loc.start; |
|
|
|
if (this.isContextual(93)) { |
|
const firstAs = this.parseIdentifier(); |
|
|
|
if (this.isContextual(93)) { |
|
const secondAs = this.parseIdentifier(); |
|
|
|
if (tokenIsKeywordOrIdentifier(this.state.type)) { |
|
hasTypeSpecifier = true; |
|
leftOfAs = firstAs; |
|
rightOfAs = isImport ? this.parseIdentifier() : this.parseModuleExportName(); |
|
canParseAsKeyword = false; |
|
} else { |
|
rightOfAs = secondAs; |
|
canParseAsKeyword = false; |
|
} |
|
} else if (tokenIsKeywordOrIdentifier(this.state.type)) { |
|
canParseAsKeyword = false; |
|
rightOfAs = isImport ? this.parseIdentifier() : this.parseModuleExportName(); |
|
} else { |
|
hasTypeSpecifier = true; |
|
leftOfAs = firstAs; |
|
} |
|
} else if (tokenIsKeywordOrIdentifier(this.state.type)) { |
|
hasTypeSpecifier = true; |
|
|
|
if (isImport) { |
|
leftOfAs = this.parseIdentifier(true); |
|
|
|
if (!this.isContextual(93)) { |
|
this.checkReservedWord(leftOfAs.name, leftOfAs.loc.start, true, true); |
|
} |
|
} else { |
|
leftOfAs = this.parseModuleExportName(); |
|
} |
|
} |
|
|
|
if (hasTypeSpecifier && isInTypeOnlyImportExport) { |
|
this.raise(isImport ? TSErrors.TypeModifierIsUsedInTypeImports : TSErrors.TypeModifierIsUsedInTypeExports, { |
|
at: loc |
|
}); |
|
} |
|
|
|
node[leftOfAsKey] = leftOfAs; |
|
node[rightOfAsKey] = rightOfAs; |
|
const kindKey = isImport ? "importKind" : "exportKind"; |
|
node[kindKey] = hasTypeSpecifier ? "type" : "value"; |
|
|
|
if (canParseAsKeyword && this.eatContextual(93)) { |
|
node[rightOfAsKey] = isImport ? this.parseIdentifier() : this.parseModuleExportName(); |
|
} |
|
|
|
if (!node[rightOfAsKey]) { |
|
node[rightOfAsKey] = cloneIdentifier(node[leftOfAsKey]); |
|
} |
|
|
|
if (isImport) { |
|
this.checkIdentifier(node[rightOfAsKey], BIND_LEXICAL); |
|
} |
|
} |
|
|
|
}); |
|
|
|
function isPossiblyLiteralEnum(expression) { |
|
if (expression.type !== "MemberExpression") return false; |
|
const { |
|
computed, |
|
property |
|
} = expression; |
|
|
|
if (computed && property.type !== "StringLiteral" && (property.type !== "TemplateLiteral" || property.expressions.length > 0)) { |
|
return false; |
|
} |
|
|
|
return isUncomputedMemberExpressionChain(expression.object); |
|
} |
|
|
|
function isUncomputedMemberExpressionChain(expression) { |
|
if (expression.type === "Identifier") return true; |
|
if (expression.type !== "MemberExpression") return false; |
|
if (expression.computed) return false; |
|
return isUncomputedMemberExpressionChain(expression.object); |
|
} |
|
|
|
const PlaceholderErrors = ParseErrorEnum`placeholders`(_ => ({ |
|
ClassNameIsRequired: _("A class name is required."), |
|
UnexpectedSpace: _("Unexpected space in placeholder.") |
|
})); |
|
var placeholders = (superClass => class extends superClass { |
|
parsePlaceholder(expectedNode) { |
|
if (this.match(140)) { |
|
const node = this.startNode(); |
|
this.next(); |
|
this.assertNoSpace(); |
|
node.name = super.parseIdentifier(true); |
|
this.assertNoSpace(); |
|
this.expect(140); |
|
return this.finishPlaceholder(node, expectedNode); |
|
} |
|
} |
|
|
|
finishPlaceholder(node, expectedNode) { |
|
const isFinished = !!(node.expectedNode && node.type === "Placeholder"); |
|
node.expectedNode = expectedNode; |
|
return isFinished ? node : this.finishNode(node, "Placeholder"); |
|
} |
|
|
|
getTokenFromCode(code) { |
|
if (code === 37 && this.input.charCodeAt(this.state.pos + 1) === 37) { |
|
return this.finishOp(140, 2); |
|
} |
|
|
|
return super.getTokenFromCode(...arguments); |
|
} |
|
|
|
parseExprAtom() { |
|
return this.parsePlaceholder("Expression") || super.parseExprAtom(...arguments); |
|
} |
|
|
|
parseIdentifier() { |
|
return this.parsePlaceholder("Identifier") || super.parseIdentifier(...arguments); |
|
} |
|
|
|
checkReservedWord(word) { |
|
if (word !== undefined) super.checkReservedWord(...arguments); |
|
} |
|
|
|
parseBindingAtom() { |
|
return this.parsePlaceholder("Pattern") || super.parseBindingAtom(...arguments); |
|
} |
|
|
|
isValidLVal(type, ...rest) { |
|
return type === "Placeholder" || super.isValidLVal(type, ...rest); |
|
} |
|
|
|
toAssignable(node) { |
|
if (node && node.type === "Placeholder" && node.expectedNode === "Expression") { |
|
node.expectedNode = "Pattern"; |
|
} else { |
|
super.toAssignable(...arguments); |
|
} |
|
} |
|
|
|
isLet(context) { |
|
if (super.isLet(context)) { |
|
return true; |
|
} |
|
|
|
if (!this.isContextual(99)) { |
|
return false; |
|
} |
|
|
|
if (context) return false; |
|
const nextToken = this.lookahead(); |
|
|
|
if (nextToken.type === 140) { |
|
return true; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
verifyBreakContinue(node) { |
|
if (node.label && node.label.type === "Placeholder") return; |
|
super.verifyBreakContinue(...arguments); |
|
} |
|
|
|
parseExpressionStatement(node, expr) { |
|
if (expr.type !== "Placeholder" || expr.extra && expr.extra.parenthesized) { |
|
return super.parseExpressionStatement(...arguments); |
|
} |
|
|
|
if (this.match(14)) { |
|
const stmt = node; |
|
stmt.label = this.finishPlaceholder(expr, "Identifier"); |
|
this.next(); |
|
stmt.body = this.parseStatement("label"); |
|
return this.finishNode(stmt, "LabeledStatement"); |
|
} |
|
|
|
this.semicolon(); |
|
node.name = expr.name; |
|
return this.finishPlaceholder(node, "Statement"); |
|
} |
|
|
|
parseBlock() { |
|
return this.parsePlaceholder("BlockStatement") || super.parseBlock(...arguments); |
|
} |
|
|
|
parseFunctionId() { |
|
return this.parsePlaceholder("Identifier") || super.parseFunctionId(...arguments); |
|
} |
|
|
|
parseClass(node, isStatement, optionalId) { |
|
const type = isStatement ? "ClassDeclaration" : "ClassExpression"; |
|
this.next(); |
|
this.takeDecorators(node); |
|
const oldStrict = this.state.strict; |
|
const placeholder = this.parsePlaceholder("Identifier"); |
|
|
|
if (placeholder) { |
|
if (this.match(81) || this.match(140) || this.match(5)) { |
|
node.id = placeholder; |
|
} else if (optionalId || !isStatement) { |
|
node.id = null; |
|
node.body = this.finishPlaceholder(placeholder, "ClassBody"); |
|
return this.finishNode(node, type); |
|
} else { |
|
throw this.raise(PlaceholderErrors.ClassNameIsRequired, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
} else { |
|
this.parseClassId(node, isStatement, optionalId); |
|
} |
|
|
|
this.parseClassSuper(node); |
|
node.body = this.parsePlaceholder("ClassBody") || this.parseClassBody(!!node.superClass, oldStrict); |
|
return this.finishNode(node, type); |
|
} |
|
|
|
parseExport(node) { |
|
const placeholder = this.parsePlaceholder("Identifier"); |
|
if (!placeholder) return super.parseExport(...arguments); |
|
|
|
if (!this.isContextual(97) && !this.match(12)) { |
|
node.specifiers = []; |
|
node.source = null; |
|
node.declaration = this.finishPlaceholder(placeholder, "Declaration"); |
|
return this.finishNode(node, "ExportNamedDeclaration"); |
|
} |
|
|
|
this.expectPlugin("exportDefaultFrom"); |
|
const specifier = this.startNode(); |
|
specifier.exported = placeholder; |
|
node.specifiers = [this.finishNode(specifier, "ExportDefaultSpecifier")]; |
|
return super.parseExport(node); |
|
} |
|
|
|
isExportDefaultSpecifier() { |
|
if (this.match(65)) { |
|
const next = this.nextTokenStart(); |
|
|
|
if (this.isUnparsedContextual(next, "from")) { |
|
if (this.input.startsWith(tokenLabelName(140), this.nextTokenStartSince(next + 4))) { |
|
return true; |
|
} |
|
} |
|
} |
|
|
|
return super.isExportDefaultSpecifier(); |
|
} |
|
|
|
maybeParseExportDefaultSpecifier(node) { |
|
if (node.specifiers && node.specifiers.length > 0) { |
|
return true; |
|
} |
|
|
|
return super.maybeParseExportDefaultSpecifier(...arguments); |
|
} |
|
|
|
checkExport(node) { |
|
const { |
|
specifiers |
|
} = node; |
|
|
|
if (specifiers != null && specifiers.length) { |
|
node.specifiers = specifiers.filter(node => node.exported.type === "Placeholder"); |
|
} |
|
|
|
super.checkExport(node); |
|
node.specifiers = specifiers; |
|
} |
|
|
|
parseImport(node) { |
|
const placeholder = this.parsePlaceholder("Identifier"); |
|
if (!placeholder) return super.parseImport(...arguments); |
|
node.specifiers = []; |
|
|
|
if (!this.isContextual(97) && !this.match(12)) { |
|
node.source = this.finishPlaceholder(placeholder, "StringLiteral"); |
|
this.semicolon(); |
|
return this.finishNode(node, "ImportDeclaration"); |
|
} |
|
|
|
const specifier = this.startNodeAtNode(placeholder); |
|
specifier.local = placeholder; |
|
this.finishNode(specifier, "ImportDefaultSpecifier"); |
|
node.specifiers.push(specifier); |
|
|
|
if (this.eat(12)) { |
|
const hasStarImport = this.maybeParseStarImportSpecifier(node); |
|
if (!hasStarImport) this.parseNamedImportSpecifiers(node); |
|
} |
|
|
|
this.expectContextual(97); |
|
node.source = this.parseImportSource(); |
|
this.semicolon(); |
|
return this.finishNode(node, "ImportDeclaration"); |
|
} |
|
|
|
parseImportSource() { |
|
return this.parsePlaceholder("StringLiteral") || super.parseImportSource(...arguments); |
|
} |
|
|
|
assertNoSpace() { |
|
if (this.state.start > this.state.lastTokEndLoc.index) { |
|
this.raise(PlaceholderErrors.UnexpectedSpace, { |
|
at: this.state.lastTokEndLoc |
|
}); |
|
} |
|
} |
|
|
|
}); |
|
|
|
var v8intrinsic = (superClass => class extends superClass { |
|
parseV8Intrinsic() { |
|
if (this.match(54)) { |
|
const v8IntrinsicStartLoc = this.state.startLoc; |
|
const node = this.startNode(); |
|
this.next(); |
|
|
|
if (tokenIsIdentifier(this.state.type)) { |
|
const name = this.parseIdentifierName(this.state.start); |
|
const identifier = this.createIdentifier(node, name); |
|
identifier.type = "V8IntrinsicIdentifier"; |
|
|
|
if (this.match(10)) { |
|
return identifier; |
|
} |
|
} |
|
|
|
this.unexpected(v8IntrinsicStartLoc); |
|
} |
|
} |
|
|
|
parseExprAtom() { |
|
return this.parseV8Intrinsic() || super.parseExprAtom(...arguments); |
|
} |
|
|
|
}); |
|
|
|
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)) { |
|
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")) { |
|
throw new Error("Cannot use the decorators and decorators-legacy plugin together"); |
|
} |
|
|
|
const decoratorsBeforeExport = getPluginOption(plugins, "decorators", "decoratorsBeforeExport"); |
|
|
|
if (decoratorsBeforeExport == null) { |
|
throw new Error("The 'decorators' plugin requires a 'decoratorsBeforeExport' option," + " whose value must be a boolean. If you are migrating from" + " Babylon/Babel 6 or want to use the old decorators proposal, you" + " should use the 'decorators-legacy' plugin instead of 'decorators'."); |
|
} else if (typeof decoratorsBeforeExport !== "boolean") { |
|
throw new Error("'decoratorsBeforeExport' must be a boolean."); |
|
} |
|
} |
|
|
|
if (hasPlugin(plugins, "flow") && hasPlugin(plugins, "typescript")) { |
|
throw new Error("Cannot combine flow and typescript plugins."); |
|
} |
|
|
|
if (hasPlugin(plugins, "placeholders") && hasPlugin(plugins, "v8intrinsic")) { |
|
throw new Error("Cannot combine placeholders and v8intrinsic plugins."); |
|
} |
|
|
|
if (hasPlugin(plugins, "pipelineOperator")) { |
|
const proposal = getPluginOption(plugins, "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" |
|
}]); |
|
|
|
if (proposal === "hack") { |
|
if (hasPlugin(plugins, "placeholders")) { |
|
throw new Error("Cannot combine placeholders plugin and Hack-style pipes."); |
|
} |
|
|
|
if (hasPlugin(plugins, "v8intrinsic")) { |
|
throw new Error("Cannot combine v8intrinsic plugin and Hack-style pipes."); |
|
} |
|
|
|
const topicToken = getPluginOption(plugins, "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"}]`.'); |
|
} |
|
} else if (proposal === "smart" && tupleSyntaxIsHash) { |
|
throw new Error('Plugin conflict between `["pipelineOperator", { proposal: "smart" }]` and `["recordAndtuple", { syntaxType: "hash"}]`.'); |
|
} |
|
} |
|
|
|
if (hasPlugin(plugins, "moduleAttributes")) { |
|
{ |
|
if (hasPlugin(plugins, "importAssertions")) { |
|
throw new Error("Cannot combine importAssertions and moduleAttributes plugins."); |
|
} |
|
|
|
const moduleAttributesVersionPluginOption = getPluginOption(plugins, "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, "recordAndTuple") && !RECORD_AND_TUPLE_SYNTAX_TYPES.includes(getPluginOption(plugins, "recordAndTuple", "syntaxType"))) { |
|
throw new Error("'recordAndTuple' requires 'syntaxType' option whose value should be one of: " + RECORD_AND_TUPLE_SYNTAX_TYPES.map(p => `'${p}'`).join(", ")); |
|
} |
|
|
|
if (hasPlugin(plugins, "asyncDoExpressions") && !hasPlugin(plugins, "doExpressions")) { |
|
const error = new Error("'asyncDoExpressions' requires 'doExpressions', please add 'doExpressions' to parser plugins."); |
|
error.missingPlugins = "doExpressions"; |
|
throw error; |
|
} |
|
} |
|
const mixinPlugins = { |
|
estree, |
|
jsx, |
|
flow, |
|
typescript, |
|
v8intrinsic, |
|
placeholders |
|
}; |
|
const mixinPluginNames = Object.keys(mixinPlugins); |
|
|
|
const defaultOptions = { |
|
sourceType: "script", |
|
sourceFilename: undefined, |
|
startColumn: 0, |
|
startLine: 1, |
|
allowAwaitOutsideFunction: false, |
|
allowReturnOutsideFunction: false, |
|
allowImportExportEverywhere: false, |
|
allowSuperOutsideMethod: false, |
|
allowUndeclaredExports: false, |
|
plugins: [], |
|
strictMode: null, |
|
ranges: false, |
|
tokens: false, |
|
createParenthesizedExpressions: false, |
|
errorRecovery: false, |
|
attachComment: true |
|
}; |
|
function getOptions(opts) { |
|
const options = {}; |
|
|
|
for (const key of Object.keys(defaultOptions)) { |
|
options[key] = opts && opts[key] != null ? opts[key] : defaultOptions[key]; |
|
} |
|
|
|
return options; |
|
} |
|
|
|
const getOwn = (object, key) => Object.hasOwnProperty.call(object, key) && object[key]; |
|
|
|
const unwrapParenthesizedExpression = node => { |
|
return node.type === "ParenthesizedExpression" ? unwrapParenthesizedExpression(node.expression) : node; |
|
}; |
|
|
|
class LValParser extends NodeUtils { |
|
toAssignable(node, isLHS = false) { |
|
var _node$extra, _node$extra3; |
|
|
|
let parenthesized = undefined; |
|
|
|
if (node.type === "ParenthesizedExpression" || (_node$extra = node.extra) != null && _node$extra.parenthesized) { |
|
parenthesized = unwrapParenthesizedExpression(node); |
|
|
|
if (isLHS) { |
|
if (parenthesized.type === "Identifier") { |
|
this.expressionScope.recordArrowParemeterBindingError(Errors.InvalidParenthesizedAssignment, { |
|
at: node |
|
}); |
|
} else if (parenthesized.type !== "MemberExpression") { |
|
this.raise(Errors.InvalidParenthesizedAssignment, { |
|
at: node |
|
}); |
|
} |
|
} else { |
|
this.raise(Errors.InvalidParenthesizedAssignment, { |
|
at: node |
|
}); |
|
} |
|
} |
|
|
|
switch (node.type) { |
|
case "Identifier": |
|
case "ObjectPattern": |
|
case "ArrayPattern": |
|
case "AssignmentPattern": |
|
case "RestElement": |
|
break; |
|
|
|
case "ObjectExpression": |
|
node.type = "ObjectPattern"; |
|
|
|
for (let i = 0, length = node.properties.length, last = length - 1; i < length; i++) { |
|
var _node$extra2; |
|
|
|
const prop = node.properties[i]; |
|
const isLast = i === last; |
|
this.toAssignableObjectExpressionProp(prop, isLast, isLHS); |
|
|
|
if (isLast && prop.type === "RestElement" && (_node$extra2 = node.extra) != null && _node$extra2.trailingCommaLoc) { |
|
this.raise(Errors.RestTrailingComma, { |
|
at: node.extra.trailingCommaLoc |
|
}); |
|
} |
|
} |
|
|
|
break; |
|
|
|
case "ObjectProperty": |
|
{ |
|
const { |
|
key, |
|
value |
|
} = node; |
|
|
|
if (this.isPrivateName(key)) { |
|
this.classScope.usePrivateName(this.getPrivateNameSV(key), key.loc.start); |
|
} |
|
|
|
this.toAssignable(value, isLHS); |
|
break; |
|
} |
|
|
|
case "SpreadElement": |
|
{ |
|
throw new Error("Internal @babel/parser error (this is a bug, please report it)." + " SpreadElement should be converted by .toAssignable's caller."); |
|
} |
|
|
|
case "ArrayExpression": |
|
node.type = "ArrayPattern"; |
|
this.toAssignableList(node.elements, (_node$extra3 = node.extra) == null ? void 0 : _node$extra3.trailingCommaLoc, isLHS); |
|
break; |
|
|
|
case "AssignmentExpression": |
|
if (node.operator !== "=") { |
|
this.raise(Errors.MissingEqInAssignment, { |
|
at: node.left.loc.end |
|
}); |
|
} |
|
|
|
node.type = "AssignmentPattern"; |
|
delete node.operator; |
|
this.toAssignable(node.left, isLHS); |
|
break; |
|
|
|
case "ParenthesizedExpression": |
|
this.toAssignable(parenthesized, isLHS); |
|
break; |
|
} |
|
} |
|
|
|
toAssignableObjectExpressionProp(prop, isLast, isLHS) { |
|
if (prop.type === "ObjectMethod") { |
|
this.raise(prop.kind === "get" || prop.kind === "set" ? Errors.PatternHasAccessor : Errors.PatternHasMethod, { |
|
at: prop.key |
|
}); |
|
} else if (prop.type === "SpreadElement") { |
|
prop.type = "RestElement"; |
|
const arg = prop.argument; |
|
this.checkToRestConversion(arg, false); |
|
this.toAssignable(arg, isLHS); |
|
|
|
if (!isLast) { |
|
this.raise(Errors.RestTrailingComma, { |
|
at: prop |
|
}); |
|
} |
|
} else { |
|
this.toAssignable(prop, isLHS); |
|
} |
|
} |
|
|
|
toAssignableList(exprList, trailingCommaLoc, isLHS) { |
|
const end = exprList.length - 1; |
|
|
|
for (let i = 0; i <= end; i++) { |
|
const elt = exprList[i]; |
|
if (!elt) continue; |
|
|
|
if (elt.type === "SpreadElement") { |
|
elt.type = "RestElement"; |
|
const arg = elt.argument; |
|
this.checkToRestConversion(arg, true); |
|
this.toAssignable(arg, isLHS); |
|
} else { |
|
this.toAssignable(elt, isLHS); |
|
} |
|
|
|
if (elt.type === "RestElement") { |
|
if (i < end) { |
|
this.raise(Errors.RestTrailingComma, { |
|
at: elt |
|
}); |
|
} else if (trailingCommaLoc) { |
|
this.raise(Errors.RestTrailingComma, { |
|
at: trailingCommaLoc |
|
}); |
|
} |
|
} |
|
} |
|
} |
|
|
|
isAssignable(node, isBinding) { |
|
switch (node.type) { |
|
case "Identifier": |
|
case "ObjectPattern": |
|
case "ArrayPattern": |
|
case "AssignmentPattern": |
|
case "RestElement": |
|
return true; |
|
|
|
case "ObjectExpression": |
|
{ |
|
const last = node.properties.length - 1; |
|
return node.properties.every((prop, i) => { |
|
return prop.type !== "ObjectMethod" && (i === last || prop.type !== "SpreadElement") && this.isAssignable(prop); |
|
}); |
|
} |
|
|
|
case "ObjectProperty": |
|
return this.isAssignable(node.value); |
|
|
|
case "SpreadElement": |
|
return this.isAssignable(node.argument); |
|
|
|
case "ArrayExpression": |
|
return node.elements.every(element => element === null || this.isAssignable(element)); |
|
|
|
case "AssignmentExpression": |
|
return node.operator === "="; |
|
|
|
case "ParenthesizedExpression": |
|
return this.isAssignable(node.expression); |
|
|
|
case "MemberExpression": |
|
case "OptionalMemberExpression": |
|
return !isBinding; |
|
|
|
default: |
|
return false; |
|
} |
|
} |
|
|
|
toReferencedList(exprList, isParenthesizedExpr) { |
|
return exprList; |
|
} |
|
|
|
toReferencedListDeep(exprList, isParenthesizedExpr) { |
|
this.toReferencedList(exprList, isParenthesizedExpr); |
|
|
|
for (const expr of exprList) { |
|
if ((expr == null ? void 0 : expr.type) === "ArrayExpression") { |
|
this.toReferencedListDeep(expr.elements); |
|
} |
|
} |
|
} |
|
|
|
parseSpread(refExpressionErrors, refNeedsArrowPos) { |
|
const node = this.startNode(); |
|
this.next(); |
|
node.argument = this.parseMaybeAssignAllowIn(refExpressionErrors, undefined, refNeedsArrowPos); |
|
return this.finishNode(node, "SpreadElement"); |
|
} |
|
|
|
parseRestBinding() { |
|
const node = this.startNode(); |
|
this.next(); |
|
node.argument = this.parseBindingAtom(); |
|
return this.finishNode(node, "RestElement"); |
|
} |
|
|
|
parseBindingAtom() { |
|
switch (this.state.type) { |
|
case 0: |
|
{ |
|
const node = this.startNode(); |
|
this.next(); |
|
node.elements = this.parseBindingList(3, 93, true); |
|
return this.finishNode(node, "ArrayPattern"); |
|
} |
|
|
|
case 5: |
|
return this.parseObjectLike(8, true); |
|
} |
|
|
|
return this.parseIdentifier(); |
|
} |
|
|
|
parseBindingList(close, closeCharCode, allowEmpty, allowModifiers) { |
|
const elts = []; |
|
let first = true; |
|
|
|
while (!this.eat(close)) { |
|
if (first) { |
|
first = false; |
|
} else { |
|
this.expect(12); |
|
} |
|
|
|
if (allowEmpty && this.match(12)) { |
|
elts.push(null); |
|
} else if (this.eat(close)) { |
|
break; |
|
} else if (this.match(21)) { |
|
elts.push(this.parseAssignableListItemTypes(this.parseRestBinding())); |
|
|
|
if (!this.checkCommaAfterRest(closeCharCode)) { |
|
this.expect(close); |
|
break; |
|
} |
|
} else { |
|
const decorators = []; |
|
|
|
if (this.match(26) && this.hasPlugin("decorators")) { |
|
this.raise(Errors.UnsupportedParameterDecorator, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
|
|
while (this.match(26)) { |
|
decorators.push(this.parseDecorator()); |
|
} |
|
|
|
elts.push(this.parseAssignableListItem(allowModifiers, decorators)); |
|
} |
|
} |
|
|
|
return elts; |
|
} |
|
|
|
parseBindingRestProperty(prop) { |
|
this.next(); |
|
prop.argument = this.parseIdentifier(); |
|
this.checkCommaAfterRest(125); |
|
return this.finishNode(prop, "RestElement"); |
|
} |
|
|
|
parseBindingProperty() { |
|
const prop = this.startNode(); |
|
const { |
|
type, |
|
start: startPos, |
|
startLoc |
|
} = this.state; |
|
|
|
if (type === 21) { |
|
return this.parseBindingRestProperty(prop); |
|
} else if (type === 134) { |
|
this.expectPlugin("destructuringPrivate", startLoc); |
|
this.classScope.usePrivateName(this.state.value, startLoc); |
|
prop.key = this.parsePrivateName(); |
|
} else { |
|
this.parsePropertyName(prop); |
|
} |
|
|
|
prop.method = false; |
|
this.parseObjPropValue(prop, startPos, startLoc, false, false, true, false); |
|
return prop; |
|
} |
|
|
|
parseAssignableListItem(allowModifiers, decorators) { |
|
const left = this.parseMaybeDefault(); |
|
this.parseAssignableListItemTypes(left); |
|
const elt = this.parseMaybeDefault(left.start, left.loc.start, left); |
|
|
|
if (decorators.length) { |
|
left.decorators = decorators; |
|
} |
|
|
|
return elt; |
|
} |
|
|
|
parseAssignableListItemTypes(param) { |
|
return param; |
|
} |
|
|
|
parseMaybeDefault(startPos, startLoc, left) { |
|
var _startLoc, _startPos, _left; |
|
|
|
startLoc = (_startLoc = startLoc) != null ? _startLoc : this.state.startLoc; |
|
startPos = (_startPos = startPos) != null ? _startPos : this.state.start; |
|
left = (_left = left) != null ? _left : this.parseBindingAtom(); |
|
if (!this.eat(29)) return left; |
|
const node = this.startNodeAt(startPos, startLoc); |
|
node.left = left; |
|
node.right = this.parseMaybeAssignAllowIn(); |
|
return this.finishNode(node, "AssignmentPattern"); |
|
} |
|
|
|
isValidLVal(type, isUnparenthesizedInAssign, binding) { |
|
return getOwn({ |
|
AssignmentPattern: "left", |
|
RestElement: "argument", |
|
ObjectProperty: "value", |
|
ParenthesizedExpression: "expression", |
|
ArrayPattern: "elements", |
|
ObjectPattern: "properties" |
|
}, type); |
|
} |
|
|
|
checkLVal(expression, { |
|
in: ancestor, |
|
binding = BIND_NONE, |
|
checkClashes = false, |
|
strictModeChanged = false, |
|
allowingSloppyLetBinding = !(binding & BIND_SCOPE_LEXICAL), |
|
hasParenthesizedAncestor = false |
|
}) { |
|
var _expression$extra; |
|
|
|
const type = expression.type; |
|
if (this.isObjectMethod(expression)) return; |
|
|
|
if (type === "MemberExpression") { |
|
if (binding !== BIND_NONE) { |
|
this.raise(Errors.InvalidPropertyBindingPattern, { |
|
at: expression |
|
}); |
|
} |
|
|
|
return; |
|
} |
|
|
|
if (expression.type === "Identifier") { |
|
this.checkIdentifier(expression, binding, strictModeChanged, allowingSloppyLetBinding); |
|
const { |
|
name |
|
} = expression; |
|
|
|
if (checkClashes) { |
|
if (checkClashes.has(name)) { |
|
this.raise(Errors.ParamDupe, { |
|
at: expression |
|
}); |
|
} else { |
|
checkClashes.add(name); |
|
} |
|
} |
|
|
|
return; |
|
} |
|
|
|
const validity = this.isValidLVal(expression.type, !(hasParenthesizedAncestor || (_expression$extra = expression.extra) != null && _expression$extra.parenthesized) && ancestor.type === "AssignmentExpression", binding); |
|
if (validity === true) return; |
|
|
|
if (validity === false) { |
|
const ParseErrorClass = binding === BIND_NONE ? Errors.InvalidLhs : Errors.InvalidLhsBinding; |
|
this.raise(ParseErrorClass, { |
|
at: expression, |
|
ancestor: ancestor.type === "UpdateExpression" ? { |
|
type: "UpdateExpression", |
|
prefix: ancestor.prefix |
|
} : { |
|
type: ancestor.type |
|
} |
|
}); |
|
return; |
|
} |
|
|
|
const [key, isParenthesizedExpression] = Array.isArray(validity) ? validity : [validity, type === "ParenthesizedExpression"]; |
|
const nextAncestor = expression.type === "ArrayPattern" || expression.type === "ObjectPattern" || expression.type === "ParenthesizedExpression" ? expression : ancestor; |
|
|
|
for (const child of [].concat(expression[key])) { |
|
if (child) { |
|
this.checkLVal(child, { |
|
in: nextAncestor, |
|
binding, |
|
checkClashes, |
|
allowingSloppyLetBinding, |
|
strictModeChanged, |
|
hasParenthesizedAncestor: isParenthesizedExpression |
|
}); |
|
} |
|
} |
|
} |
|
|
|
checkIdentifier(at, bindingType, strictModeChanged = false, allowLetBinding = !(bindingType & BIND_SCOPE_LEXICAL)) { |
|
if (this.state.strict && (strictModeChanged ? isStrictBindReservedWord(at.name, this.inModule) : isStrictBindOnlyReservedWord(at.name))) { |
|
if (bindingType === BIND_NONE) { |
|
this.raise(Errors.StrictEvalArguments, { |
|
at, |
|
referenceName: at.name |
|
}); |
|
} else { |
|
this.raise(Errors.StrictEvalArgumentsBinding, { |
|
at, |
|
bindingName: at.name |
|
}); |
|
} |
|
} |
|
|
|
if (!allowLetBinding && at.name === "let") { |
|
this.raise(Errors.LetInLexicalBinding, { |
|
at |
|
}); |
|
} |
|
|
|
if (!(bindingType & BIND_NONE)) { |
|
this.declareNameFromIdentifier(at, bindingType); |
|
} |
|
} |
|
|
|
declareNameFromIdentifier(identifier, binding) { |
|
this.scope.declareName(identifier.name, binding, identifier.loc.start); |
|
} |
|
|
|
checkToRestConversion(node, allowPattern) { |
|
switch (node.type) { |
|
case "ParenthesizedExpression": |
|
this.checkToRestConversion(node.expression, allowPattern); |
|
break; |
|
|
|
case "Identifier": |
|
case "MemberExpression": |
|
break; |
|
|
|
case "ArrayExpression": |
|
case "ObjectExpression": |
|
if (allowPattern) break; |
|
|
|
default: |
|
this.raise(Errors.InvalidRestAssignmentPattern, { |
|
at: node |
|
}); |
|
} |
|
} |
|
|
|
checkCommaAfterRest(close) { |
|
if (!this.match(12)) { |
|
return false; |
|
} |
|
|
|
this.raise(this.lookaheadCharCode() === close ? Errors.RestTrailingComma : Errors.ElementAfterRest, { |
|
at: this.state.startLoc |
|
}); |
|
return true; |
|
} |
|
|
|
} |
|
|
|
class ExpressionParser extends LValParser { |
|
checkProto(prop, isRecord, protoRef, refExpressionErrors) { |
|
if (prop.type === "SpreadElement" || this.isObjectMethod(prop) || prop.computed || prop.shorthand) { |
|
return; |
|
} |
|
|
|
const key = prop.key; |
|
const name = key.type === "Identifier" ? key.name : key.value; |
|
|
|
if (name === "__proto__") { |
|
if (isRecord) { |
|
this.raise(Errors.RecordNoProto, { |
|
at: key |
|
}); |
|
return; |
|
} |
|
|
|
if (protoRef.used) { |
|
if (refExpressionErrors) { |
|
if (refExpressionErrors.doubleProtoLoc === null) { |
|
refExpressionErrors.doubleProtoLoc = key.loc.start; |
|
} |
|
} else { |
|
this.raise(Errors.DuplicateProto, { |
|
at: key |
|
}); |
|
} |
|
} |
|
|
|
protoRef.used = true; |
|
} |
|
} |
|
|
|
shouldExitDescending(expr, potentialArrowAt) { |
|
return expr.type === "ArrowFunctionExpression" && expr.start === potentialArrowAt; |
|
} |
|
|
|
getExpression() { |
|
this.enterInitialScopes(); |
|
this.nextToken(); |
|
const expr = this.parseExpression(); |
|
|
|
if (!this.match(135)) { |
|
this.unexpected(); |
|
} |
|
|
|
this.finalizeRemainingComments(); |
|
expr.comments = this.state.comments; |
|
expr.errors = this.state.errors; |
|
|
|
if (this.options.tokens) { |
|
expr.tokens = this.tokens; |
|
} |
|
|
|
return expr; |
|
} |
|
|
|
parseExpression(disallowIn, refExpressionErrors) { |
|
if (disallowIn) { |
|
return this.disallowInAnd(() => this.parseExpressionBase(refExpressionErrors)); |
|
} |
|
|
|
return this.allowInAnd(() => this.parseExpressionBase(refExpressionErrors)); |
|
} |
|
|
|
parseExpressionBase(refExpressionErrors) { |
|
const startPos = this.state.start; |
|
const startLoc = this.state.startLoc; |
|
const expr = this.parseMaybeAssign(refExpressionErrors); |
|
|
|
if (this.match(12)) { |
|
const node = this.startNodeAt(startPos, startLoc); |
|
node.expressions = [expr]; |
|
|
|
while (this.eat(12)) { |
|
node.expressions.push(this.parseMaybeAssign(refExpressionErrors)); |
|
} |
|
|
|
this.toReferencedList(node.expressions); |
|
return this.finishNode(node, "SequenceExpression"); |
|
} |
|
|
|
return expr; |
|
} |
|
|
|
parseMaybeAssignDisallowIn(refExpressionErrors, afterLeftParse) { |
|
return this.disallowInAnd(() => this.parseMaybeAssign(refExpressionErrors, afterLeftParse)); |
|
} |
|
|
|
parseMaybeAssignAllowIn(refExpressionErrors, afterLeftParse) { |
|
return this.allowInAnd(() => this.parseMaybeAssign(refExpressionErrors, afterLeftParse)); |
|
} |
|
|
|
setOptionalParametersError(refExpressionErrors, resultError) { |
|
var _resultError$loc; |
|
|
|
refExpressionErrors.optionalParametersLoc = (_resultError$loc = resultError == null ? void 0 : resultError.loc) != null ? _resultError$loc : this.state.startLoc; |
|
} |
|
|
|
parseMaybeAssign(refExpressionErrors, afterLeftParse) { |
|
const startPos = this.state.start; |
|
const startLoc = this.state.startLoc; |
|
|
|
if (this.isContextual(105)) { |
|
if (this.prodParam.hasYield) { |
|
let left = this.parseYield(); |
|
|
|
if (afterLeftParse) { |
|
left = afterLeftParse.call(this, left, startPos, startLoc); |
|
} |
|
|
|
return left; |
|
} |
|
} |
|
|
|
let ownExpressionErrors; |
|
|
|
if (refExpressionErrors) { |
|
ownExpressionErrors = false; |
|
} else { |
|
refExpressionErrors = new ExpressionErrors(); |
|
ownExpressionErrors = true; |
|
} |
|
|
|
const { |
|
type |
|
} = this.state; |
|
|
|
if (type === 10 || tokenIsIdentifier(type)) { |
|
this.state.potentialArrowAt = this.state.start; |
|
} |
|
|
|
let left = this.parseMaybeConditional(refExpressionErrors); |
|
|
|
if (afterLeftParse) { |
|
left = afterLeftParse.call(this, left, startPos, startLoc); |
|
} |
|
|
|
if (tokenIsAssignment(this.state.type)) { |
|
const node = this.startNodeAt(startPos, startLoc); |
|
const operator = this.state.value; |
|
node.operator = operator; |
|
|
|
if (this.match(29)) { |
|
this.toAssignable(left, true); |
|
node.left = left; |
|
|
|
if (refExpressionErrors.doubleProtoLoc != null && refExpressionErrors.doubleProtoLoc.index >= startPos) { |
|
refExpressionErrors.doubleProtoLoc = null; |
|
} |
|
|
|
if (refExpressionErrors.shorthandAssignLoc != null && refExpressionErrors.shorthandAssignLoc.index >= startPos) { |
|
refExpressionErrors.shorthandAssignLoc = null; |
|
} |
|
|
|
if (refExpressionErrors.privateKeyLoc != null && refExpressionErrors.privateKeyLoc.index >= startPos) { |
|
this.checkDestructuringPrivate(refExpressionErrors); |
|
refExpressionErrors.privateKeyLoc = null; |
|
} |
|
} else { |
|
node.left = left; |
|
} |
|
|
|
this.next(); |
|
node.right = this.parseMaybeAssign(); |
|
this.checkLVal(left, { |
|
in: this.finishNode(node, "AssignmentExpression") |
|
}); |
|
return node; |
|
} else if (ownExpressionErrors) { |
|
this.checkExpressionErrors(refExpressionErrors, true); |
|
} |
|
|
|
return left; |
|
} |
|
|
|
parseMaybeConditional(refExpressionErrors) { |
|
const startPos = this.state.start; |
|
const startLoc = this.state.startLoc; |
|
const potentialArrowAt = this.state.potentialArrowAt; |
|
const expr = this.parseExprOps(refExpressionErrors); |
|
|
|
if (this.shouldExitDescending(expr, potentialArrowAt)) { |
|
return expr; |
|
} |
|
|
|
return this.parseConditional(expr, startPos, startLoc, refExpressionErrors); |
|
} |
|
|
|
parseConditional(expr, startPos, startLoc, refExpressionErrors) { |
|
if (this.eat(17)) { |
|
const node = this.startNodeAt(startPos, startLoc); |
|
node.test = expr; |
|
node.consequent = this.parseMaybeAssignAllowIn(); |
|
this.expect(14); |
|
node.alternate = this.parseMaybeAssign(); |
|
return this.finishNode(node, "ConditionalExpression"); |
|
} |
|
|
|
return expr; |
|
} |
|
|
|
parseMaybeUnaryOrPrivate(refExpressionErrors) { |
|
return this.match(134) ? this.parsePrivateName() : this.parseMaybeUnary(refExpressionErrors); |
|
} |
|
|
|
parseExprOps(refExpressionErrors) { |
|
const startPos = this.state.start; |
|
const startLoc = this.state.startLoc; |
|
const potentialArrowAt = this.state.potentialArrowAt; |
|
const expr = this.parseMaybeUnaryOrPrivate(refExpressionErrors); |
|
|
|
if (this.shouldExitDescending(expr, potentialArrowAt)) { |
|
return expr; |
|
} |
|
|
|
return this.parseExprOp(expr, startPos, startLoc, -1); |
|
} |
|
|
|
parseExprOp(left, leftStartPos, leftStartLoc, minPrec) { |
|
if (this.isPrivateName(left)) { |
|
const value = this.getPrivateNameSV(left); |
|
|
|
if (minPrec >= tokenOperatorPrecedence(58) || !this.prodParam.hasIn || !this.match(58)) { |
|
this.raise(Errors.PrivateInExpectedIn, { |
|
at: left, |
|
identifierName: value |
|
}); |
|
} |
|
|
|
this.classScope.usePrivateName(value, left.loc.start); |
|
} |
|
|
|
const op = this.state.type; |
|
|
|
if (tokenIsOperator(op) && (this.prodParam.hasIn || !this.match(58))) { |
|
let prec = tokenOperatorPrecedence(op); |
|
|
|
if (prec > minPrec) { |
|
if (op === 39) { |
|
this.expectPlugin("pipelineOperator"); |
|
|
|
if (this.state.inFSharpPipelineDirectBody) { |
|
return left; |
|
} |
|
|
|
this.checkPipelineAtInfixOperator(left, leftStartLoc); |
|
} |
|
|
|
const node = this.startNodeAt(leftStartPos, leftStartLoc); |
|
node.left = left; |
|
node.operator = this.state.value; |
|
const logical = op === 41 || op === 42; |
|
const coalesce = op === 40; |
|
|
|
if (coalesce) { |
|
prec = tokenOperatorPrecedence(42); |
|
} |
|
|
|
this.next(); |
|
|
|
if (op === 39 && this.hasPlugin(["pipelineOperator", { |
|
proposal: "minimal" |
|
}])) { |
|
if (this.state.type === 96 && this.prodParam.hasAwait) { |
|
throw this.raise(Errors.UnexpectedAwaitAfterPipelineBody, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
} |
|
|
|
node.right = this.parseExprOpRightExpr(op, prec); |
|
this.finishNode(node, logical || coalesce ? "LogicalExpression" : "BinaryExpression"); |
|
const nextOp = this.state.type; |
|
|
|
if (coalesce && (nextOp === 41 || nextOp === 42) || logical && nextOp === 40) { |
|
throw this.raise(Errors.MixingCoalesceWithLogical, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
|
|
return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec); |
|
} |
|
} |
|
|
|
return left; |
|
} |
|
|
|
parseExprOpRightExpr(op, prec) { |
|
const startPos = this.state.start; |
|
const startLoc = this.state.startLoc; |
|
|
|
switch (op) { |
|
case 39: |
|
switch (this.getPluginOption("pipelineOperator", "proposal")) { |
|
case "hack": |
|
return this.withTopicBindingContext(() => { |
|
return this.parseHackPipeBody(); |
|
}); |
|
|
|
case "smart": |
|
return this.withTopicBindingContext(() => { |
|
if (this.prodParam.hasYield && this.isContextual(105)) { |
|
throw this.raise(Errors.PipeBodyIsTighter, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
|
|
return this.parseSmartPipelineBodyInStyle(this.parseExprOpBaseRightExpr(op, prec), startPos, startLoc); |
|
}); |
|
|
|
case "fsharp": |
|
return this.withSoloAwaitPermittingContext(() => { |
|
return this.parseFSharpPipelineBody(prec); |
|
}); |
|
} |
|
|
|
default: |
|
return this.parseExprOpBaseRightExpr(op, prec); |
|
} |
|
} |
|
|
|
parseExprOpBaseRightExpr(op, prec) { |
|
const startPos = this.state.start; |
|
const startLoc = this.state.startLoc; |
|
return this.parseExprOp(this.parseMaybeUnaryOrPrivate(), startPos, startLoc, tokenIsRightAssociative(op) ? prec - 1 : prec); |
|
} |
|
|
|
parseHackPipeBody() { |
|
var _body$extra; |
|
|
|
const { |
|
startLoc |
|
} = this.state; |
|
const body = this.parseMaybeAssign(); |
|
const requiredParentheses = UnparenthesizedPipeBodyDescriptions.has(body.type); |
|
|
|
if (requiredParentheses && !((_body$extra = body.extra) != null && _body$extra.parenthesized)) { |
|
this.raise(Errors.PipeUnparenthesizedBody, { |
|
at: startLoc, |
|
type: body.type |
|
}); |
|
} |
|
|
|
if (!this.topicReferenceWasUsedInCurrentContext()) { |
|
this.raise(Errors.PipeTopicUnused, { |
|
at: startLoc |
|
}); |
|
} |
|
|
|
return body; |
|
} |
|
|
|
checkExponentialAfterUnary(node) { |
|
if (this.match(57)) { |
|
this.raise(Errors.UnexpectedTokenUnaryExponentiation, { |
|
at: node.argument |
|
}); |
|
} |
|
} |
|
|
|
parseMaybeUnary(refExpressionErrors, sawUnary) { |
|
const startPos = this.state.start; |
|
const startLoc = this.state.startLoc; |
|
const isAwait = this.isContextual(96); |
|
|
|
if (isAwait && this.isAwaitAllowed()) { |
|
this.next(); |
|
const expr = this.parseAwait(startPos, startLoc); |
|
if (!sawUnary) this.checkExponentialAfterUnary(expr); |
|
return expr; |
|
} |
|
|
|
const update = this.match(34); |
|
const node = this.startNode(); |
|
|
|
if (tokenIsPrefix(this.state.type)) { |
|
node.operator = this.state.value; |
|
node.prefix = true; |
|
|
|
if (this.match(72)) { |
|
this.expectPlugin("throwExpressions"); |
|
} |
|
|
|
const isDelete = this.match(89); |
|
this.next(); |
|
node.argument = this.parseMaybeUnary(null, true); |
|
this.checkExpressionErrors(refExpressionErrors, true); |
|
|
|
if (this.state.strict && isDelete) { |
|
const arg = node.argument; |
|
|
|
if (arg.type === "Identifier") { |
|
this.raise(Errors.StrictDelete, { |
|
at: node |
|
}); |
|
} else if (this.hasPropertyAsPrivateName(arg)) { |
|
this.raise(Errors.DeletePrivateField, { |
|
at: node |
|
}); |
|
} |
|
} |
|
|
|
if (!update) { |
|
if (!sawUnary) this.checkExponentialAfterUnary(node); |
|
return this.finishNode(node, "UnaryExpression"); |
|
} |
|
} |
|
|
|
const expr = this.parseUpdate(node, update, refExpressionErrors); |
|
|
|
if (isAwait) { |
|
const { |
|
type |
|
} = this.state; |
|
const startsExpr = this.hasPlugin("v8intrinsic") ? tokenCanStartExpression(type) : tokenCanStartExpression(type) && !this.match(54); |
|
|
|
if (startsExpr && !this.isAmbiguousAwait()) { |
|
this.raiseOverwrite(Errors.AwaitNotInAsyncContext, { |
|
at: startLoc |
|
}); |
|
return this.parseAwait(startPos, startLoc); |
|
} |
|
} |
|
|
|
return expr; |
|
} |
|
|
|
parseUpdate(node, update, refExpressionErrors) { |
|
if (update) { |
|
this.checkLVal(node.argument, { |
|
in: this.finishNode(node, "UpdateExpression") |
|
}); |
|
return node; |
|
} |
|
|
|
const startPos = this.state.start; |
|
const startLoc = this.state.startLoc; |
|
let expr = this.parseExprSubscripts(refExpressionErrors); |
|
if (this.checkExpressionErrors(refExpressionErrors, false)) return expr; |
|
|
|
while (tokenIsPostfix(this.state.type) && !this.canInsertSemicolon()) { |
|
const node = this.startNodeAt(startPos, startLoc); |
|
node.operator = this.state.value; |
|
node.prefix = false; |
|
node.argument = expr; |
|
this.next(); |
|
this.checkLVal(expr, { |
|
in: expr = this.finishNode(node, "UpdateExpression") |
|
}); |
|
} |
|
|
|
return expr; |
|
} |
|
|
|
parseExprSubscripts(refExpressionErrors) { |
|
const startPos = this.state.start; |
|
const startLoc = this.state.startLoc; |
|
const potentialArrowAt = this.state.potentialArrowAt; |
|
const expr = this.parseExprAtom(refExpressionErrors); |
|
|
|
if (this.shouldExitDescending(expr, potentialArrowAt)) { |
|
return expr; |
|
} |
|
|
|
return this.parseSubscripts(expr, startPos, startLoc); |
|
} |
|
|
|
parseSubscripts(base, startPos, startLoc, noCalls) { |
|
const state = { |
|
optionalChainMember: false, |
|
maybeAsyncArrow: this.atPossibleAsyncArrow(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) { |
|
const { |
|
type |
|
} = this.state; |
|
|
|
if (!noCalls && type === 15) { |
|
return this.parseBind(base, startPos, startLoc, noCalls, state); |
|
} else if (tokenIsTemplate(type)) { |
|
return this.parseTaggedTemplateExpression(base, startPos, startLoc, state); |
|
} |
|
|
|
let optional = false; |
|
|
|
if (type === 18) { |
|
if (noCalls && this.lookaheadCharCode() === 40) { |
|
state.stop = true; |
|
return base; |
|
} |
|
|
|
state.optionalChainMember = optional = true; |
|
this.next(); |
|
} |
|
|
|
if (!noCalls && this.match(10)) { |
|
return this.parseCoverCallAndAsyncArrowHead(base, startPos, startLoc, state, optional); |
|
} else { |
|
const computed = this.eat(0); |
|
|
|
if (computed || optional || this.eat(16)) { |
|
return this.parseMember(base, startPos, startLoc, state, computed, optional); |
|
} else { |
|
state.stop = true; |
|
return base; |
|
} |
|
} |
|
} |
|
|
|
parseMember(base, startPos, startLoc, state, computed, optional) { |
|
const node = this.startNodeAt(startPos, startLoc); |
|
node.object = base; |
|
node.computed = computed; |
|
|
|
if (computed) { |
|
node.property = this.parseExpression(); |
|
this.expect(3); |
|
} else if (this.match(134)) { |
|
if (base.type === "Super") { |
|
this.raise(Errors.SuperPrivateField, { |
|
at: startLoc |
|
}); |
|
} |
|
|
|
this.classScope.usePrivateName(this.state.value, this.state.startLoc); |
|
node.property = this.parsePrivateName(); |
|
} else { |
|
node.property = this.parseIdentifier(true); |
|
} |
|
|
|
if (state.optionalChainMember) { |
|
node.optional = optional; |
|
return this.finishNode(node, "OptionalMemberExpression"); |
|
} else { |
|
return this.finishNode(node, "MemberExpression"); |
|
} |
|
} |
|
|
|
parseBind(base, startPos, startLoc, noCalls, state) { |
|
const node = this.startNodeAt(startPos, startLoc); |
|
node.object = base; |
|
this.next(); |
|
node.callee = this.parseNoCallExpr(); |
|
state.stop = true; |
|
return this.parseSubscripts(this.finishNode(node, "BindExpression"), startPos, startLoc, noCalls); |
|
} |
|
|
|
parseCoverCallAndAsyncArrowHead(base, startPos, startLoc, state, optional) { |
|
const oldMaybeInArrowParameters = this.state.maybeInArrowParameters; |
|
let refExpressionErrors = null; |
|
this.state.maybeInArrowParameters = true; |
|
this.next(); |
|
let node = this.startNodeAt(startPos, startLoc); |
|
node.callee = base; |
|
const { |
|
maybeAsyncArrow, |
|
optionalChainMember |
|
} = state; |
|
|
|
if (maybeAsyncArrow) { |
|
this.expressionScope.enter(newAsyncArrowScope()); |
|
refExpressionErrors = new ExpressionErrors(); |
|
} |
|
|
|
if (optionalChainMember) { |
|
node.optional = optional; |
|
} |
|
|
|
if (optional) { |
|
node.arguments = this.parseCallExpressionArguments(11); |
|
} else { |
|
node.arguments = this.parseCallExpressionArguments(11, base.type === "Import", base.type !== "Super", node, refExpressionErrors); |
|
} |
|
|
|
this.finishCallExpression(node, optionalChainMember); |
|
|
|
if (maybeAsyncArrow && this.shouldParseAsyncArrow() && !optional) { |
|
state.stop = true; |
|
this.checkDestructuringPrivate(refExpressionErrors); |
|
this.expressionScope.validateAsPattern(); |
|
this.expressionScope.exit(); |
|
node = this.parseAsyncArrowFromCallExpression(this.startNodeAt(startPos, startLoc), node); |
|
} else { |
|
if (maybeAsyncArrow) { |
|
this.checkExpressionErrors(refExpressionErrors, true); |
|
this.expressionScope.exit(); |
|
} |
|
|
|
this.toReferencedArguments(node); |
|
} |
|
|
|
this.state.maybeInArrowParameters = oldMaybeInArrowParameters; |
|
return node; |
|
} |
|
|
|
toReferencedArguments(node, isParenthesizedExpr) { |
|
this.toReferencedListDeep(node.arguments, isParenthesizedExpr); |
|
} |
|
|
|
parseTaggedTemplateExpression(base, startPos, startLoc, state) { |
|
const node = this.startNodeAt(startPos, startLoc); |
|
node.tag = base; |
|
node.quasi = this.parseTemplate(true); |
|
|
|
if (state.optionalChainMember) { |
|
this.raise(Errors.OptionalChainingNoTemplate, { |
|
at: startLoc |
|
}); |
|
} |
|
|
|
return this.finishNode(node, "TaggedTemplateExpression"); |
|
} |
|
|
|
atPossibleAsyncArrow(base) { |
|
return base.type === "Identifier" && base.name === "async" && this.state.lastTokEndLoc.index === base.end && !this.canInsertSemicolon() && base.end - base.start === 5 && base.start === this.state.potentialArrowAt; |
|
} |
|
|
|
finishCallExpression(node, optional) { |
|
if (node.callee.type === "Import") { |
|
if (node.arguments.length === 2) { |
|
{ |
|
if (!this.hasPlugin("moduleAttributes")) { |
|
this.expectPlugin("importAssertions"); |
|
} |
|
} |
|
} |
|
|
|
if (node.arguments.length === 0 || node.arguments.length > 2) { |
|
this.raise(Errors.ImportCallArity, { |
|
at: node, |
|
maxArgumentCount: this.hasPlugin("importAssertions") || this.hasPlugin("moduleAttributes") ? 2 : 1 |
|
}); |
|
} else { |
|
for (const arg of node.arguments) { |
|
if (arg.type === "SpreadElement") { |
|
this.raise(Errors.ImportCallSpreadArgument, { |
|
at: arg |
|
}); |
|
} |
|
} |
|
} |
|
} |
|
|
|
return this.finishNode(node, optional ? "OptionalCallExpression" : "CallExpression"); |
|
} |
|
|
|
parseCallExpressionArguments(close, dynamicImport, allowPlaceholder, nodeForExtra, refExpressionErrors) { |
|
const elts = []; |
|
let first = true; |
|
const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody; |
|
this.state.inFSharpPipelineDirectBody = false; |
|
|
|
while (!this.eat(close)) { |
|
if (first) { |
|
first = false; |
|
} else { |
|
this.expect(12); |
|
|
|
if (this.match(close)) { |
|
if (dynamicImport && !this.hasPlugin("importAssertions") && !this.hasPlugin("moduleAttributes")) { |
|
this.raise(Errors.ImportCallArgumentTrailingComma, { |
|
at: this.state.lastTokStartLoc |
|
}); |
|
} |
|
|
|
if (nodeForExtra) { |
|
this.addTrailingCommaExtraToNode(nodeForExtra); |
|
} |
|
|
|
this.next(); |
|
break; |
|
} |
|
} |
|
|
|
elts.push(this.parseExprListItem(false, refExpressionErrors, allowPlaceholder)); |
|
} |
|
|
|
this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody; |
|
return elts; |
|
} |
|
|
|
shouldParseAsyncArrow() { |
|
return this.match(19) && !this.canInsertSemicolon(); |
|
} |
|
|
|
parseAsyncArrowFromCallExpression(node, call) { |
|
var _call$extra; |
|
|
|
this.resetPreviousNodeTrailingComments(call); |
|
this.expect(19); |
|
this.parseArrowExpression(node, call.arguments, true, (_call$extra = call.extra) == null ? void 0 : _call$extra.trailingCommaLoc); |
|
|
|
if (call.innerComments) { |
|
setInnerComments(node, call.innerComments); |
|
} |
|
|
|
if (call.callee.trailingComments) { |
|
setInnerComments(node, call.callee.trailingComments); |
|
} |
|
|
|
return node; |
|
} |
|
|
|
parseNoCallExpr() { |
|
const startPos = this.state.start; |
|
const startLoc = this.state.startLoc; |
|
return this.parseSubscripts(this.parseExprAtom(), startPos, startLoc, true); |
|
} |
|
|
|
parseExprAtom(refExpressionErrors) { |
|
let node; |
|
const { |
|
type |
|
} = this.state; |
|
|
|
switch (type) { |
|
case 79: |
|
return this.parseSuper(); |
|
|
|
case 83: |
|
node = this.startNode(); |
|
this.next(); |
|
|
|
if (this.match(16)) { |
|
return this.parseImportMetaProperty(node); |
|
} |
|
|
|
if (!this.match(10)) { |
|
this.raise(Errors.UnsupportedImport, { |
|
at: this.state.lastTokStartLoc |
|
}); |
|
} |
|
|
|
return this.finishNode(node, "Import"); |
|
|
|
case 78: |
|
node = this.startNode(); |
|
this.next(); |
|
return this.finishNode(node, "ThisExpression"); |
|
|
|
case 90: |
|
{ |
|
return this.parseDo(this.startNode(), false); |
|
} |
|
|
|
case 56: |
|
case 31: |
|
{ |
|
this.readRegexp(); |
|
return this.parseRegExpLiteral(this.state.value); |
|
} |
|
|
|
case 130: |
|
return this.parseNumericLiteral(this.state.value); |
|
|
|
case 131: |
|
return this.parseBigIntLiteral(this.state.value); |
|
|
|
case 132: |
|
return this.parseDecimalLiteral(this.state.value); |
|
|
|
case 129: |
|
return this.parseStringLiteral(this.state.value); |
|
|
|
case 84: |
|
return this.parseNullLiteral(); |
|
|
|
case 85: |
|
return this.parseBooleanLiteral(true); |
|
|
|
case 86: |
|
return this.parseBooleanLiteral(false); |
|
|
|
case 10: |
|
{ |
|
const canBeArrow = this.state.potentialArrowAt === this.state.start; |
|
return this.parseParenAndDistinguishExpression(canBeArrow); |
|
} |
|
|
|
case 2: |
|
case 1: |
|
{ |
|
return this.parseArrayLike(this.state.type === 2 ? 4 : 3, false, true); |
|
} |
|
|
|
case 0: |
|
{ |
|
return this.parseArrayLike(3, true, false, refExpressionErrors); |
|
} |
|
|
|
case 6: |
|
case 7: |
|
{ |
|
return this.parseObjectLike(this.state.type === 6 ? 9 : 8, false, true); |
|
} |
|
|
|
case 5: |
|
{ |
|
return this.parseObjectLike(8, false, false, refExpressionErrors); |
|
} |
|
|
|
case 68: |
|
return this.parseFunctionOrFunctionSent(); |
|
|
|
case 26: |
|
this.parseDecorators(); |
|
|
|
case 80: |
|
node = this.startNode(); |
|
this.takeDecorators(node); |
|
return this.parseClass(node, false); |
|
|
|
case 77: |
|
return this.parseNewOrNewTarget(); |
|
|
|
case 25: |
|
case 24: |
|
return this.parseTemplate(false); |
|
|
|
case 15: |
|
{ |
|
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(Errors.UnsupportedBind, { |
|
at: callee |
|
}); |
|
} |
|
} |
|
|
|
case 134: |
|
{ |
|
this.raise(Errors.PrivateInExpectedIn, { |
|
at: this.state.startLoc, |
|
identifierName: this.state.value |
|
}); |
|
return this.parsePrivateName(); |
|
} |
|
|
|
case 33: |
|
{ |
|
return this.parseTopicReferenceThenEqualsSign(54, "%"); |
|
} |
|
|
|
case 32: |
|
{ |
|
return this.parseTopicReferenceThenEqualsSign(44, "^"); |
|
} |
|
|
|
case 37: |
|
case 38: |
|
{ |
|
return this.parseTopicReference("hack"); |
|
} |
|
|
|
case 44: |
|
case 54: |
|
case 27: |
|
{ |
|
const pipeProposal = this.getPluginOption("pipelineOperator", "proposal"); |
|
|
|
if (pipeProposal) { |
|
return this.parseTopicReference(pipeProposal); |
|
} else { |
|
throw this.unexpected(); |
|
} |
|
} |
|
|
|
case 47: |
|
{ |
|
const lookaheadCh = this.input.codePointAt(this.nextTokenStart()); |
|
|
|
if (isIdentifierStart(lookaheadCh) || lookaheadCh === 62) { |
|
this.expectOnePlugin(["jsx", "flow", "typescript"]); |
|
break; |
|
} else { |
|
throw this.unexpected(); |
|
} |
|
} |
|
|
|
default: |
|
if (tokenIsIdentifier(type)) { |
|
if (this.isContextual(123) && this.lookaheadCharCode() === 123 && !this.hasFollowingLineBreak()) { |
|
return this.parseModuleExpression(); |
|
} |
|
|
|
const canBeArrow = this.state.potentialArrowAt === this.state.start; |
|
const containsEsc = this.state.containsEsc; |
|
const id = this.parseIdentifier(); |
|
|
|
if (!containsEsc && id.name === "async" && !this.canInsertSemicolon()) { |
|
const { |
|
type |
|
} = this.state; |
|
|
|
if (type === 68) { |
|
this.resetPreviousNodeTrailingComments(id); |
|
this.next(); |
|
return this.parseFunction(this.startNodeAtNode(id), undefined, true); |
|
} else if (tokenIsIdentifier(type)) { |
|
if (this.lookaheadCharCode() === 61) { |
|
return this.parseAsyncArrowUnaryFunction(this.startNodeAtNode(id)); |
|
} else { |
|
return id; |
|
} |
|
} else if (type === 90) { |
|
this.resetPreviousNodeTrailingComments(id); |
|
return this.parseDo(this.startNodeAtNode(id), true); |
|
} |
|
} |
|
|
|
if (canBeArrow && this.match(19) && !this.canInsertSemicolon()) { |
|
this.next(); |
|
return this.parseArrowExpression(this.startNodeAtNode(id), [id], false); |
|
} |
|
|
|
return id; |
|
} else { |
|
throw this.unexpected(); |
|
} |
|
|
|
} |
|
} |
|
|
|
parseTopicReferenceThenEqualsSign(topicTokenType, topicTokenValue) { |
|
const pipeProposal = this.getPluginOption("pipelineOperator", "proposal"); |
|
|
|
if (pipeProposal) { |
|
this.state.type = topicTokenType; |
|
this.state.value = topicTokenValue; |
|
this.state.pos--; |
|
this.state.end--; |
|
this.state.endLoc = createPositionWithColumnOffset(this.state.endLoc, -1); |
|
return this.parseTopicReference(pipeProposal); |
|
} else { |
|
throw this.unexpected(); |
|
} |
|
} |
|
|
|
parseTopicReference(pipeProposal) { |
|
const node = this.startNode(); |
|
const startLoc = this.state.startLoc; |
|
const tokenType = this.state.type; |
|
this.next(); |
|
return this.finishTopicReference(node, startLoc, pipeProposal, tokenType); |
|
} |
|
|
|
finishTopicReference(node, startLoc, pipeProposal, tokenType) { |
|
if (this.testTopicReferenceConfiguration(pipeProposal, startLoc, tokenType)) { |
|
const nodeType = pipeProposal === "smart" ? "PipelinePrimaryTopicReference" : "TopicReference"; |
|
|
|
if (!this.topicReferenceIsAllowedInCurrentContext()) { |
|
this.raise(pipeProposal === "smart" ? Errors.PrimaryTopicNotAllowed : Errors.PipeTopicUnbound, { |
|
at: startLoc |
|
}); |
|
} |
|
|
|
this.registerTopicReference(); |
|
return this.finishNode(node, nodeType); |
|
} else { |
|
throw this.raise(Errors.PipeTopicUnconfiguredToken, { |
|
at: startLoc, |
|
token: tokenLabelName(tokenType) |
|
}); |
|
} |
|
} |
|
|
|
testTopicReferenceConfiguration(pipeProposal, startLoc, tokenType) { |
|
switch (pipeProposal) { |
|
case "hack": |
|
{ |
|
return this.hasPlugin(["pipelineOperator", { |
|
topicToken: tokenLabelName(tokenType) |
|
}]); |
|
} |
|
|
|
case "smart": |
|
return tokenType === 27; |
|
|
|
default: |
|
throw this.raise(Errors.PipeTopicRequiresHackPipes, { |
|
at: startLoc |
|
}); |
|
} |
|
} |
|
|
|
parseAsyncArrowUnaryFunction(node) { |
|
this.prodParam.enter(functionFlags(true, this.prodParam.hasYield)); |
|
const params = [this.parseIdentifier()]; |
|
this.prodParam.exit(); |
|
|
|
if (this.hasPrecedingLineBreak()) { |
|
this.raise(Errors.LineTerminatorBeforeArrow, { |
|
at: this.state.curPosition() |
|
}); |
|
} |
|
|
|
this.expect(19); |
|
this.parseArrowExpression(node, params, true); |
|
return node; |
|
} |
|
|
|
parseDo(node, isAsync) { |
|
this.expectPlugin("doExpressions"); |
|
|
|
if (isAsync) { |
|
this.expectPlugin("asyncDoExpressions"); |
|
} |
|
|
|
node.async = isAsync; |
|
this.next(); |
|
const oldLabels = this.state.labels; |
|
this.state.labels = []; |
|
|
|
if (isAsync) { |
|
this.prodParam.enter(PARAM_AWAIT); |
|
node.body = this.parseBlock(); |
|
this.prodParam.exit(); |
|
} else { |
|
node.body = this.parseBlock(); |
|
} |
|
|
|
this.state.labels = oldLabels; |
|
return this.finishNode(node, "DoExpression"); |
|
} |
|
|
|
parseSuper() { |
|
const node = this.startNode(); |
|
this.next(); |
|
|
|
if (this.match(10) && !this.scope.allowDirectSuper && !this.options.allowSuperOutsideMethod) { |
|
this.raise(Errors.SuperNotAllowed, { |
|
at: node |
|
}); |
|
} else if (!this.scope.allowSuper && !this.options.allowSuperOutsideMethod) { |
|
this.raise(Errors.UnexpectedSuper, { |
|
at: node |
|
}); |
|
} |
|
|
|
if (!this.match(10) && !this.match(0) && !this.match(16)) { |
|
this.raise(Errors.UnsupportedSuper, { |
|
at: node |
|
}); |
|
} |
|
|
|
return this.finishNode(node, "Super"); |
|
} |
|
|
|
parsePrivateName() { |
|
const node = this.startNode(); |
|
const id = this.startNodeAt(this.state.start + 1, new Position(this.state.curLine, this.state.start + 1 - this.state.lineStart, this.state.start + 1)); |
|
const name = this.state.value; |
|
this.next(); |
|
node.id = this.createIdentifier(id, name); |
|
return this.finishNode(node, "PrivateName"); |
|
} |
|
|
|
parseFunctionOrFunctionSent() { |
|
const node = this.startNode(); |
|
this.next(); |
|
|
|
if (this.prodParam.hasYield && this.match(16)) { |
|
const meta = this.createIdentifier(this.startNodeAtNode(node), "function"); |
|
this.next(); |
|
|
|
if (this.match(102)) { |
|
this.expectPlugin("functionSent"); |
|
} else if (!this.hasPlugin("functionSent")) { |
|
this.unexpected(); |
|
} |
|
|
|
return this.parseMetaProperty(node, meta, "sent"); |
|
} |
|
|
|
return this.parseFunction(node); |
|
} |
|
|
|
parseMetaProperty(node, meta, propertyName) { |
|
node.meta = meta; |
|
const containsEsc = this.state.containsEsc; |
|
node.property = this.parseIdentifier(true); |
|
|
|
if (node.property.name !== propertyName || containsEsc) { |
|
this.raise(Errors.UnsupportedMetaProperty, { |
|
at: node.property, |
|
target: meta.name, |
|
onlyValidPropertyName: propertyName |
|
}); |
|
} |
|
|
|
return this.finishNode(node, "MetaProperty"); |
|
} |
|
|
|
parseImportMetaProperty(node) { |
|
const id = this.createIdentifier(this.startNodeAtNode(node), "import"); |
|
this.next(); |
|
|
|
if (this.isContextual(100)) { |
|
if (!this.inModule) { |
|
this.raise(Errors.ImportMetaOutsideModule, { |
|
at: id |
|
}); |
|
} |
|
|
|
this.sawUnambiguousESM = true; |
|
} |
|
|
|
return this.parseMetaProperty(node, id, "meta"); |
|
} |
|
|
|
parseLiteralAtNode(value, type, node) { |
|
this.addExtra(node, "rawValue", value); |
|
this.addExtra(node, "raw", this.input.slice(node.start, this.state.end)); |
|
node.value = value; |
|
this.next(); |
|
return this.finishNode(node, type); |
|
} |
|
|
|
parseLiteral(value, type) { |
|
const node = this.startNode(); |
|
return this.parseLiteralAtNode(value, type, node); |
|
} |
|
|
|
parseStringLiteral(value) { |
|
return this.parseLiteral(value, "StringLiteral"); |
|
} |
|
|
|
parseNumericLiteral(value) { |
|
return this.parseLiteral(value, "NumericLiteral"); |
|
} |
|
|
|
parseBigIntLiteral(value) { |
|
return this.parseLiteral(value, "BigIntLiteral"); |
|
} |
|
|
|
parseDecimalLiteral(value) { |
|
return this.parseLiteral(value, "DecimalLiteral"); |
|
} |
|
|
|
parseRegExpLiteral(value) { |
|
const node = this.parseLiteral(value.value, "RegExpLiteral"); |
|
node.pattern = value.pattern; |
|
node.flags = value.flags; |
|
return node; |
|
} |
|
|
|
parseBooleanLiteral(value) { |
|
const node = this.startNode(); |
|
node.value = value; |
|
this.next(); |
|
return this.finishNode(node, "BooleanLiteral"); |
|
} |
|
|
|
parseNullLiteral() { |
|
const node = this.startNode(); |
|
this.next(); |
|
return this.finishNode(node, "NullLiteral"); |
|
} |
|
|
|
parseParenAndDistinguishExpression(canBeArrow) { |
|
const startPos = this.state.start; |
|
const startLoc = this.state.startLoc; |
|
let val; |
|
this.next(); |
|
this.expressionScope.enter(newArrowHeadScope()); |
|
const oldMaybeInArrowParameters = this.state.maybeInArrowParameters; |
|
const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody; |
|
this.state.maybeInArrowParameters = true; |
|
this.state.inFSharpPipelineDirectBody = false; |
|
const innerStartPos = this.state.start; |
|
const innerStartLoc = this.state.startLoc; |
|
const exprList = []; |
|
const refExpressionErrors = new ExpressionErrors(); |
|
let first = true; |
|
let spreadStartLoc; |
|
let optionalCommaStartLoc; |
|
|
|
while (!this.match(11)) { |
|
if (first) { |
|
first = false; |
|
} else { |
|
this.expect(12, refExpressionErrors.optionalParametersLoc === null ? null : refExpressionErrors.optionalParametersLoc); |
|
|
|
if (this.match(11)) { |
|
optionalCommaStartLoc = this.state.startLoc; |
|
break; |
|
} |
|
} |
|
|
|
if (this.match(21)) { |
|
const spreadNodeStartPos = this.state.start; |
|
const spreadNodeStartLoc = this.state.startLoc; |
|
spreadStartLoc = this.state.startLoc; |
|
exprList.push(this.parseParenItem(this.parseRestBinding(), spreadNodeStartPos, spreadNodeStartLoc)); |
|
|
|
if (!this.checkCommaAfterRest(41)) { |
|
break; |
|
} |
|
} else { |
|
exprList.push(this.parseMaybeAssignAllowIn(refExpressionErrors, this.parseParenItem)); |
|
} |
|
} |
|
|
|
const innerEndLoc = this.state.lastTokEndLoc; |
|
this.expect(11); |
|
this.state.maybeInArrowParameters = oldMaybeInArrowParameters; |
|
this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody; |
|
let arrowNode = this.startNodeAt(startPos, startLoc); |
|
|
|
if (canBeArrow && this.shouldParseArrow(exprList) && (arrowNode = this.parseArrow(arrowNode))) { |
|
this.checkDestructuringPrivate(refExpressionErrors); |
|
this.expressionScope.validateAsPattern(); |
|
this.expressionScope.exit(); |
|
this.parseArrowExpression(arrowNode, exprList, false); |
|
return arrowNode; |
|
} |
|
|
|
this.expressionScope.exit(); |
|
|
|
if (!exprList.length) { |
|
this.unexpected(this.state.lastTokStartLoc); |
|
} |
|
|
|
if (optionalCommaStartLoc) this.unexpected(optionalCommaStartLoc); |
|
if (spreadStartLoc) this.unexpected(spreadStartLoc); |
|
this.checkExpressionErrors(refExpressionErrors, true); |
|
this.toReferencedListDeep(exprList, true); |
|
|
|
if (exprList.length > 1) { |
|
val = this.startNodeAt(innerStartPos, innerStartLoc); |
|
val.expressions = exprList; |
|
this.finishNode(val, "SequenceExpression"); |
|
this.resetEndLocation(val, innerEndLoc); |
|
} else { |
|
val = exprList[0]; |
|
} |
|
|
|
return this.wrapParenthesis(startPos, startLoc, val); |
|
} |
|
|
|
wrapParenthesis(startPos, startLoc, expression) { |
|
if (!this.options.createParenthesizedExpressions) { |
|
this.addExtra(expression, "parenthesized", true); |
|
this.addExtra(expression, "parenStart", startPos); |
|
this.takeSurroundingComments(expression, startPos, this.state.lastTokEndLoc.index); |
|
return expression; |
|
} |
|
|
|
const parenExpression = this.startNodeAt(startPos, startLoc); |
|
parenExpression.expression = expression; |
|
this.finishNode(parenExpression, "ParenthesizedExpression"); |
|
return parenExpression; |
|
} |
|
|
|
shouldParseArrow(params) { |
|
return !this.canInsertSemicolon(); |
|
} |
|
|
|
parseArrow(node) { |
|
if (this.eat(19)) { |
|
return node; |
|
} |
|
} |
|
|
|
parseParenItem(node, startPos, startLoc) { |
|
return node; |
|
} |
|
|
|
parseNewOrNewTarget() { |
|
const node = this.startNode(); |
|
this.next(); |
|
|
|
if (this.match(16)) { |
|
const meta = this.createIdentifier(this.startNodeAtNode(node), "new"); |
|
this.next(); |
|
const metaProp = this.parseMetaProperty(node, meta, "target"); |
|
|
|
if (!this.scope.inNonArrowFunction && !this.scope.inClass) { |
|
this.raise(Errors.UnexpectedNewTarget, { |
|
at: metaProp |
|
}); |
|
} |
|
|
|
return metaProp; |
|
} |
|
|
|
return this.parseNew(node); |
|
} |
|
|
|
parseNew(node) { |
|
this.parseNewCallee(node); |
|
|
|
if (this.eat(10)) { |
|
const args = this.parseExprList(11); |
|
this.toReferencedList(args); |
|
node.arguments = args; |
|
} else { |
|
node.arguments = []; |
|
} |
|
|
|
return this.finishNode(node, "NewExpression"); |
|
} |
|
|
|
parseNewCallee(node) { |
|
node.callee = this.parseNoCallExpr(); |
|
|
|
if (node.callee.type === "Import") { |
|
this.raise(Errors.ImportCallNotNewExpression, { |
|
at: node.callee |
|
}); |
|
} else if (this.isOptionalChain(node.callee)) { |
|
this.raise(Errors.OptionalChainingNoNew, { |
|
at: this.state.lastTokEndLoc |
|
}); |
|
} else if (this.eat(18)) { |
|
this.raise(Errors.OptionalChainingNoNew, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
} |
|
|
|
parseTemplateElement(isTagged) { |
|
const { |
|
start, |
|
startLoc, |
|
end, |
|
value |
|
} = this.state; |
|
const elemStart = start + 1; |
|
const elem = this.startNodeAt(elemStart, createPositionWithColumnOffset(startLoc, 1)); |
|
|
|
if (value === null) { |
|
if (!isTagged) { |
|
this.raise(Errors.InvalidEscapeSequenceTemplate, { |
|
at: createPositionWithColumnOffset(startLoc, 2) |
|
}); |
|
} |
|
} |
|
|
|
const isTail = this.match(24); |
|
const endOffset = isTail ? -1 : -2; |
|
const elemEnd = end + endOffset; |
|
elem.value = { |
|
raw: this.input.slice(elemStart, elemEnd).replace(/\r\n?/g, "\n"), |
|
cooked: value === null ? null : value.slice(1, endOffset) |
|
}; |
|
elem.tail = isTail; |
|
this.next(); |
|
this.finishNode(elem, "TemplateElement"); |
|
this.resetEndLocation(elem, createPositionWithColumnOffset(this.state.lastTokEndLoc, endOffset)); |
|
return elem; |
|
} |
|
|
|
parseTemplate(isTagged) { |
|
const node = this.startNode(); |
|
node.expressions = []; |
|
let curElt = this.parseTemplateElement(isTagged); |
|
node.quasis = [curElt]; |
|
|
|
while (!curElt.tail) { |
|
node.expressions.push(this.parseTemplateSubstitution()); |
|
this.readTemplateContinuation(); |
|
node.quasis.push(curElt = this.parseTemplateElement(isTagged)); |
|
} |
|
|
|
return this.finishNode(node, "TemplateLiteral"); |
|
} |
|
|
|
parseTemplateSubstitution() { |
|
return this.parseExpression(); |
|
} |
|
|
|
parseObjectLike(close, isPattern, isRecord, refExpressionErrors) { |
|
if (isRecord) { |
|
this.expectPlugin("recordAndTuple"); |
|
} |
|
|
|
const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody; |
|
this.state.inFSharpPipelineDirectBody = false; |
|
const propHash = Object.create(null); |
|
let first = true; |
|
const node = this.startNode(); |
|
node.properties = []; |
|
this.next(); |
|
|
|
while (!this.match(close)) { |
|
if (first) { |
|
first = false; |
|
} else { |
|
this.expect(12); |
|
|
|
if (this.match(close)) { |
|
this.addTrailingCommaExtraToNode(node); |
|
break; |
|
} |
|
} |
|
|
|
let prop; |
|
|
|
if (isPattern) { |
|
prop = this.parseBindingProperty(); |
|
} else { |
|
prop = this.parsePropertyDefinition(refExpressionErrors); |
|
this.checkProto(prop, isRecord, propHash, refExpressionErrors); |
|
} |
|
|
|
if (isRecord && !this.isObjectProperty(prop) && prop.type !== "SpreadElement") { |
|
this.raise(Errors.InvalidRecordProperty, { |
|
at: prop |
|
}); |
|
} |
|
|
|
if (prop.shorthand) { |
|
this.addExtra(prop, "shorthand", true); |
|
} |
|
|
|
node.properties.push(prop); |
|
} |
|
|
|
this.next(); |
|
this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody; |
|
let type = "ObjectExpression"; |
|
|
|
if (isPattern) { |
|
type = "ObjectPattern"; |
|
} else if (isRecord) { |
|
type = "RecordExpression"; |
|
} |
|
|
|
return this.finishNode(node, type); |
|
} |
|
|
|
addTrailingCommaExtraToNode(node) { |
|
this.addExtra(node, "trailingComma", this.state.lastTokStart); |
|
this.addExtra(node, "trailingCommaLoc", this.state.lastTokStartLoc, false); |
|
} |
|
|
|
maybeAsyncOrAccessorProp(prop) { |
|
return !prop.computed && prop.key.type === "Identifier" && (this.isLiteralPropertyName() || this.match(0) || this.match(55)); |
|
} |
|
|
|
parsePropertyDefinition(refExpressionErrors) { |
|
let decorators = []; |
|
|
|
if (this.match(26)) { |
|
if (this.hasPlugin("decorators")) { |
|
this.raise(Errors.UnsupportedPropertyDecorator, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
|
|
while (this.match(26)) { |
|
decorators.push(this.parseDecorator()); |
|
} |
|
} |
|
|
|
const prop = this.startNode(); |
|
let isAsync = false; |
|
let isAccessor = false; |
|
let startPos; |
|
let startLoc; |
|
|
|
if (this.match(21)) { |
|
if (decorators.length) this.unexpected(); |
|
return this.parseSpread(); |
|
} |
|
|
|
if (decorators.length) { |
|
prop.decorators = decorators; |
|
decorators = []; |
|
} |
|
|
|
prop.method = false; |
|
|
|
if (refExpressionErrors) { |
|
startPos = this.state.start; |
|
startLoc = this.state.startLoc; |
|
} |
|
|
|
let isGenerator = this.eat(55); |
|
this.parsePropertyNamePrefixOperator(prop); |
|
const containsEsc = this.state.containsEsc; |
|
const key = this.parsePropertyName(prop, refExpressionErrors); |
|
|
|
if (!isGenerator && !containsEsc && this.maybeAsyncOrAccessorProp(prop)) { |
|
const keyName = key.name; |
|
|
|
if (keyName === "async" && !this.hasPrecedingLineBreak()) { |
|
isAsync = true; |
|
this.resetPreviousNodeTrailingComments(key); |
|
isGenerator = this.eat(55); |
|
this.parsePropertyName(prop); |
|
} |
|
|
|
if (keyName === "get" || keyName === "set") { |
|
isAccessor = true; |
|
this.resetPreviousNodeTrailingComments(key); |
|
prop.kind = keyName; |
|
|
|
if (this.match(55)) { |
|
isGenerator = true; |
|
this.raise(Errors.AccessorIsGenerator, { |
|
at: this.state.curPosition(), |
|
kind: keyName |
|
}); |
|
this.next(); |
|
} |
|
|
|
this.parsePropertyName(prop); |
|
} |
|
} |
|
|
|
this.parseObjPropValue(prop, startPos, startLoc, isGenerator, isAsync, false, isAccessor, refExpressionErrors); |
|
return prop; |
|
} |
|
|
|
getGetterSetterExpectedParamCount(method) { |
|
return method.kind === "get" ? 0 : 1; |
|
} |
|
|
|
getObjectOrClassMethodParams(method) { |
|
return method.params; |
|
} |
|
|
|
checkGetterSetterParams(method) { |
|
var _params; |
|
|
|
const paramCount = this.getGetterSetterExpectedParamCount(method); |
|
const params = this.getObjectOrClassMethodParams(method); |
|
|
|
if (params.length !== paramCount) { |
|
this.raise(method.kind === "get" ? Errors.BadGetterArity : Errors.BadSetterArity, { |
|
at: method |
|
}); |
|
} |
|
|
|
if (method.kind === "set" && ((_params = params[params.length - 1]) == null ? void 0 : _params.type) === "RestElement") { |
|
this.raise(Errors.BadSetterRestParameter, { |
|
at: method |
|
}); |
|
} |
|
} |
|
|
|
parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) { |
|
if (isAccessor) { |
|
this.parseMethod(prop, isGenerator, false, false, false, "ObjectMethod"); |
|
this.checkGetterSetterParams(prop); |
|
return prop; |
|
} |
|
|
|
if (isAsync || isGenerator || this.match(10)) { |
|
if (isPattern) this.unexpected(); |
|
prop.kind = "method"; |
|
prop.method = true; |
|
return this.parseMethod(prop, isGenerator, isAsync, false, false, "ObjectMethod"); |
|
} |
|
} |
|
|
|
parseObjectProperty(prop, startPos, startLoc, isPattern, refExpressionErrors) { |
|
prop.shorthand = false; |
|
|
|
if (this.eat(14)) { |
|
prop.value = isPattern ? this.parseMaybeDefault(this.state.start, this.state.startLoc) : this.parseMaybeAssignAllowIn(refExpressionErrors); |
|
return this.finishNode(prop, "ObjectProperty"); |
|
} |
|
|
|
if (!prop.computed && prop.key.type === "Identifier") { |
|
this.checkReservedWord(prop.key.name, prop.key.loc.start, true, false); |
|
|
|
if (isPattern) { |
|
prop.value = this.parseMaybeDefault(startPos, startLoc, cloneIdentifier(prop.key)); |
|
} else if (this.match(29)) { |
|
const shorthandAssignLoc = this.state.startLoc; |
|
|
|
if (refExpressionErrors != null) { |
|
if (refExpressionErrors.shorthandAssignLoc === null) { |
|
refExpressionErrors.shorthandAssignLoc = shorthandAssignLoc; |
|
} |
|
} else { |
|
this.raise(Errors.InvalidCoverInitializedName, { |
|
at: shorthandAssignLoc |
|
}); |
|
} |
|
|
|
prop.value = this.parseMaybeDefault(startPos, startLoc, cloneIdentifier(prop.key)); |
|
} else { |
|
prop.value = cloneIdentifier(prop.key); |
|
} |
|
|
|
prop.shorthand = true; |
|
return this.finishNode(prop, "ObjectProperty"); |
|
} |
|
} |
|
|
|
parseObjPropValue(prop, startPos, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) { |
|
const node = this.parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) || this.parseObjectProperty(prop, startPos, startLoc, isPattern, refExpressionErrors); |
|
if (!node) this.unexpected(); |
|
return node; |
|
} |
|
|
|
parsePropertyName(prop, refExpressionErrors) { |
|
if (this.eat(0)) { |
|
prop.computed = true; |
|
prop.key = this.parseMaybeAssignAllowIn(); |
|
this.expect(3); |
|
} else { |
|
const { |
|
type, |
|
value |
|
} = this.state; |
|
let key; |
|
|
|
if (tokenIsKeywordOrIdentifier(type)) { |
|
key = this.parseIdentifier(true); |
|
} else { |
|
switch (type) { |
|
case 130: |
|
key = this.parseNumericLiteral(value); |
|
break; |
|
|
|
case 129: |
|
key = this.parseStringLiteral(value); |
|
break; |
|
|
|
case 131: |
|
key = this.parseBigIntLiteral(value); |
|
break; |
|
|
|
case 132: |
|
key = this.parseDecimalLiteral(value); |
|
break; |
|
|
|
case 134: |
|
{ |
|
const privateKeyLoc = this.state.startLoc; |
|
|
|
if (refExpressionErrors != null) { |
|
if (refExpressionErrors.privateKeyLoc === null) { |
|
refExpressionErrors.privateKeyLoc = privateKeyLoc; |
|
} |
|
} else { |
|
this.raise(Errors.UnexpectedPrivateField, { |
|
at: privateKeyLoc |
|
}); |
|
} |
|
|
|
key = this.parsePrivateName(); |
|
break; |
|
} |
|
|
|
default: |
|
throw this.unexpected(); |
|
} |
|
} |
|
|
|
prop.key = key; |
|
|
|
if (type !== 134) { |
|
prop.computed = false; |
|
} |
|
} |
|
|
|
return prop.key; |
|
} |
|
|
|
initFunction(node, isAsync) { |
|
node.id = null; |
|
node.generator = false; |
|
node.async = !!isAsync; |
|
} |
|
|
|
parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope = false) { |
|
this.initFunction(node, isAsync); |
|
node.generator = !!isGenerator; |
|
const allowModifiers = isConstructor; |
|
this.scope.enter(SCOPE_FUNCTION | SCOPE_SUPER | (inClassScope ? SCOPE_CLASS : 0) | (allowDirectSuper ? SCOPE_DIRECT_SUPER : 0)); |
|
this.prodParam.enter(functionFlags(isAsync, node.generator)); |
|
this.parseFunctionParams(node, allowModifiers); |
|
this.parseFunctionBodyAndFinish(node, type, true); |
|
this.prodParam.exit(); |
|
this.scope.exit(); |
|
return node; |
|
} |
|
|
|
parseArrayLike(close, canBePattern, isTuple, refExpressionErrors) { |
|
if (isTuple) { |
|
this.expectPlugin("recordAndTuple"); |
|
} |
|
|
|
const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody; |
|
this.state.inFSharpPipelineDirectBody = false; |
|
const node = this.startNode(); |
|
this.next(); |
|
node.elements = this.parseExprList(close, !isTuple, refExpressionErrors, node); |
|
this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody; |
|
return this.finishNode(node, isTuple ? "TupleExpression" : "ArrayExpression"); |
|
} |
|
|
|
parseArrowExpression(node, params, isAsync, trailingCommaLoc) { |
|
this.scope.enter(SCOPE_FUNCTION | SCOPE_ARROW); |
|
let flags = functionFlags(isAsync, false); |
|
|
|
if (!this.match(5) && this.prodParam.hasIn) { |
|
flags |= PARAM_IN; |
|
} |
|
|
|
this.prodParam.enter(flags); |
|
this.initFunction(node, isAsync); |
|
const oldMaybeInArrowParameters = this.state.maybeInArrowParameters; |
|
|
|
if (params) { |
|
this.state.maybeInArrowParameters = true; |
|
this.setArrowFunctionParameters(node, params, trailingCommaLoc); |
|
} |
|
|
|
this.state.maybeInArrowParameters = false; |
|
this.parseFunctionBody(node, true); |
|
this.prodParam.exit(); |
|
this.scope.exit(); |
|
this.state.maybeInArrowParameters = oldMaybeInArrowParameters; |
|
return this.finishNode(node, "ArrowFunctionExpression"); |
|
} |
|
|
|
setArrowFunctionParameters(node, params, trailingCommaLoc) { |
|
this.toAssignableList(params, trailingCommaLoc, false); |
|
node.params = params; |
|
} |
|
|
|
parseFunctionBodyAndFinish(node, type, isMethod = false) { |
|
this.parseFunctionBody(node, false, isMethod); |
|
this.finishNode(node, type); |
|
} |
|
|
|
parseFunctionBody(node, allowExpression, isMethod = false) { |
|
const isExpression = allowExpression && !this.match(5); |
|
this.expressionScope.enter(newExpressionScope()); |
|
|
|
if (isExpression) { |
|
node.body = this.parseMaybeAssign(); |
|
this.checkParams(node, false, allowExpression, false); |
|
} else { |
|
const oldStrict = this.state.strict; |
|
const oldLabels = this.state.labels; |
|
this.state.labels = []; |
|
this.prodParam.enter(this.prodParam.currentFlags() | PARAM_RETURN); |
|
node.body = this.parseBlock(true, false, hasStrictModeDirective => { |
|
const nonSimple = !this.isSimpleParamList(node.params); |
|
|
|
if (hasStrictModeDirective && nonSimple) { |
|
this.raise(Errors.IllegalLanguageModeDirective, { |
|
at: (node.kind === "method" || node.kind === "constructor") && !!node.key ? node.key.loc.end : node |
|
}); |
|
} |
|
|
|
const strictModeChanged = !oldStrict && this.state.strict; |
|
this.checkParams(node, !this.state.strict && !allowExpression && !isMethod && !nonSimple, allowExpression, strictModeChanged); |
|
|
|
if (this.state.strict && node.id) { |
|
this.checkIdentifier(node.id, BIND_OUTSIDE, strictModeChanged); |
|
} |
|
}); |
|
this.prodParam.exit(); |
|
this.state.labels = oldLabels; |
|
} |
|
|
|
this.expressionScope.exit(); |
|
} |
|
|
|
isSimpleParameter(node) { |
|
return node.type === "Identifier"; |
|
} |
|
|
|
isSimpleParamList(params) { |
|
for (let i = 0, len = params.length; i < len; i++) { |
|
if (!this.isSimpleParameter(params[i])) return false; |
|
} |
|
|
|
return true; |
|
} |
|
|
|
checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged = true) { |
|
const checkClashes = !allowDuplicates && new Set(); |
|
const formalParameters = { |
|
type: "FormalParameters" |
|
}; |
|
|
|
for (const param of node.params) { |
|
this.checkLVal(param, { |
|
in: formalParameters, |
|
binding: BIND_VAR, |
|
checkClashes, |
|
strictModeChanged |
|
}); |
|
} |
|
} |
|
|
|
parseExprList(close, allowEmpty, refExpressionErrors, nodeForExtra) { |
|
const elts = []; |
|
let first = true; |
|
|
|
while (!this.eat(close)) { |
|
if (first) { |
|
first = false; |
|
} else { |
|
this.expect(12); |
|
|
|
if (this.match(close)) { |
|
if (nodeForExtra) { |
|
this.addTrailingCommaExtraToNode(nodeForExtra); |
|
} |
|
|
|
this.next(); |
|
break; |
|
} |
|
} |
|
|
|
elts.push(this.parseExprListItem(allowEmpty, refExpressionErrors)); |
|
} |
|
|
|
return elts; |
|
} |
|
|
|
parseExprListItem(allowEmpty, refExpressionErrors, allowPlaceholder) { |
|
let elt; |
|
|
|
if (this.match(12)) { |
|
if (!allowEmpty) { |
|
this.raise(Errors.UnexpectedToken, { |
|
at: this.state.curPosition(), |
|
unexpected: "," |
|
}); |
|
} |
|
|
|
elt = null; |
|
} else if (this.match(21)) { |
|
const spreadNodeStartPos = this.state.start; |
|
const spreadNodeStartLoc = this.state.startLoc; |
|
elt = this.parseParenItem(this.parseSpread(refExpressionErrors), spreadNodeStartPos, spreadNodeStartLoc); |
|
} else if (this.match(17)) { |
|
this.expectPlugin("partialApplication"); |
|
|
|
if (!allowPlaceholder) { |
|
this.raise(Errors.UnexpectedArgumentPlaceholder, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
|
|
const node = this.startNode(); |
|
this.next(); |
|
elt = this.finishNode(node, "ArgumentPlaceholder"); |
|
} else { |
|
elt = this.parseMaybeAssignAllowIn(refExpressionErrors, this.parseParenItem); |
|
} |
|
|
|
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; |
|
const { |
|
startLoc, |
|
type |
|
} = this.state; |
|
|
|
if (tokenIsKeywordOrIdentifier(type)) { |
|
name = this.state.value; |
|
} else { |
|
throw this.unexpected(); |
|
} |
|
|
|
const tokenIsKeyword = tokenKeywordOrIdentifierIsKeyword(type); |
|
|
|
if (liberal) { |
|
if (tokenIsKeyword) { |
|
this.replaceToken(128); |
|
} |
|
} else { |
|
this.checkReservedWord(name, startLoc, tokenIsKeyword, false); |
|
} |
|
|
|
this.next(); |
|
return name; |
|
} |
|
|
|
checkReservedWord(word, startLoc, checkKeywords, isBinding) { |
|
if (word.length > 10) { |
|
return; |
|
} |
|
|
|
if (!canBeReservedWord(word)) { |
|
return; |
|
} |
|
|
|
if (word === "yield") { |
|
if (this.prodParam.hasYield) { |
|
this.raise(Errors.YieldBindingIdentifier, { |
|
at: startLoc |
|
}); |
|
return; |
|
} |
|
} else if (word === "await") { |
|
if (this.prodParam.hasAwait) { |
|
this.raise(Errors.AwaitBindingIdentifier, { |
|
at: startLoc |
|
}); |
|
return; |
|
} |
|
|
|
if (this.scope.inStaticBlock) { |
|
this.raise(Errors.AwaitBindingIdentifierInStaticBlock, { |
|
at: startLoc |
|
}); |
|
return; |
|
} |
|
|
|
this.expressionScope.recordAsyncArrowParametersError({ |
|
at: startLoc |
|
}); |
|
} else if (word === "arguments") { |
|
if (this.scope.inClassAndNotInNonArrowFunction) { |
|
this.raise(Errors.ArgumentsInClass, { |
|
at: startLoc |
|
}); |
|
return; |
|
} |
|
} |
|
|
|
if (checkKeywords && isKeyword(word)) { |
|
this.raise(Errors.UnexpectedKeyword, { |
|
at: startLoc, |
|
keyword: word |
|
}); |
|
return; |
|
} |
|
|
|
const reservedTest = !this.state.strict ? isReservedWord : isBinding ? isStrictBindReservedWord : isStrictReservedWord; |
|
|
|
if (reservedTest(word, this.inModule)) { |
|
this.raise(Errors.UnexpectedReservedWord, { |
|
at: startLoc, |
|
reservedWord: word |
|
}); |
|
} |
|
} |
|
|
|
isAwaitAllowed() { |
|
if (this.prodParam.hasAwait) return true; |
|
|
|
if (this.options.allowAwaitOutsideFunction && !this.scope.inFunction) { |
|
return true; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
parseAwait(startPos, startLoc) { |
|
const node = this.startNodeAt(startPos, startLoc); |
|
this.expressionScope.recordParameterInitializerError(Errors.AwaitExpressionFormalParameter, { |
|
at: node |
|
}); |
|
|
|
if (this.eat(55)) { |
|
this.raise(Errors.ObsoleteAwaitStar, { |
|
at: node |
|
}); |
|
} |
|
|
|
if (!this.scope.inFunction && !this.options.allowAwaitOutsideFunction) { |
|
if (this.isAmbiguousAwait()) { |
|
this.ambiguousScriptDifferentAst = true; |
|
} else { |
|
this.sawUnambiguousESM = true; |
|
} |
|
} |
|
|
|
if (!this.state.soloAwait) { |
|
node.argument = this.parseMaybeUnary(null, true); |
|
} |
|
|
|
return this.finishNode(node, "AwaitExpression"); |
|
} |
|
|
|
isAmbiguousAwait() { |
|
if (this.hasPrecedingLineBreak()) return true; |
|
const { |
|
type |
|
} = this.state; |
|
return type === 53 || type === 10 || type === 0 || tokenIsTemplate(type) || type === 133 || type === 56 || this.hasPlugin("v8intrinsic") && type === 54; |
|
} |
|
|
|
parseYield() { |
|
const node = this.startNode(); |
|
this.expressionScope.recordParameterInitializerError(Errors.YieldInParameter, { |
|
at: node |
|
}); |
|
this.next(); |
|
let delegating = false; |
|
let argument = null; |
|
|
|
if (!this.hasPrecedingLineBreak()) { |
|
delegating = this.eat(55); |
|
|
|
switch (this.state.type) { |
|
case 13: |
|
case 135: |
|
case 8: |
|
case 11: |
|
case 3: |
|
case 9: |
|
case 14: |
|
case 12: |
|
if (!delegating) break; |
|
|
|
default: |
|
argument = this.parseMaybeAssign(); |
|
} |
|
} |
|
|
|
node.delegate = delegating; |
|
node.argument = argument; |
|
return this.finishNode(node, "YieldExpression"); |
|
} |
|
|
|
checkPipelineAtInfixOperator(left, leftStartLoc) { |
|
if (this.hasPlugin(["pipelineOperator", { |
|
proposal: "smart" |
|
}])) { |
|
if (left.type === "SequenceExpression") { |
|
this.raise(Errors.PipelineHeadSequenceExpression, { |
|
at: leftStartLoc |
|
}); |
|
} |
|
} |
|
} |
|
|
|
parseSmartPipelineBodyInStyle(childExpr, startPos, startLoc) { |
|
const bodyNode = this.startNodeAt(startPos, startLoc); |
|
|
|
if (this.isSimpleReference(childExpr)) { |
|
bodyNode.callee = childExpr; |
|
return this.finishNode(bodyNode, "PipelineBareFunction"); |
|
} else { |
|
this.checkSmartPipeTopicBodyEarlyErrors(startLoc); |
|
bodyNode.expression = childExpr; |
|
return this.finishNode(bodyNode, "PipelineTopicExpression"); |
|
} |
|
} |
|
|
|
isSimpleReference(expression) { |
|
switch (expression.type) { |
|
case "MemberExpression": |
|
return !expression.computed && this.isSimpleReference(expression.object); |
|
|
|
case "Identifier": |
|
return true; |
|
|
|
default: |
|
return false; |
|
} |
|
} |
|
|
|
checkSmartPipeTopicBodyEarlyErrors(startLoc) { |
|
if (this.match(19)) { |
|
throw this.raise(Errors.PipelineBodyNoArrow, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
|
|
if (!this.topicReferenceWasUsedInCurrentContext()) { |
|
this.raise(Errors.PipelineTopicUnused, { |
|
at: startLoc |
|
}); |
|
} |
|
} |
|
|
|
withTopicBindingContext(callback) { |
|
const outerContextTopicState = this.state.topicContext; |
|
this.state.topicContext = { |
|
maxNumOfResolvableTopics: 1, |
|
maxTopicIndex: null |
|
}; |
|
|
|
try { |
|
return callback(); |
|
} finally { |
|
this.state.topicContext = outerContextTopicState; |
|
} |
|
} |
|
|
|
withSmartMixTopicForbiddingContext(callback) { |
|
if (this.hasPlugin(["pipelineOperator", { |
|
proposal: "smart" |
|
}])) { |
|
const outerContextTopicState = this.state.topicContext; |
|
this.state.topicContext = { |
|
maxNumOfResolvableTopics: 0, |
|
maxTopicIndex: null |
|
}; |
|
|
|
try { |
|
return callback(); |
|
} finally { |
|
this.state.topicContext = outerContextTopicState; |
|
} |
|
} else { |
|
return callback(); |
|
} |
|
} |
|
|
|
withSoloAwaitPermittingContext(callback) { |
|
const outerContextSoloAwaitState = this.state.soloAwait; |
|
this.state.soloAwait = true; |
|
|
|
try { |
|
return callback(); |
|
} finally { |
|
this.state.soloAwait = outerContextSoloAwaitState; |
|
} |
|
} |
|
|
|
allowInAnd(callback) { |
|
const flags = this.prodParam.currentFlags(); |
|
const prodParamToSet = PARAM_IN & ~flags; |
|
|
|
if (prodParamToSet) { |
|
this.prodParam.enter(flags | PARAM_IN); |
|
|
|
try { |
|
return callback(); |
|
} finally { |
|
this.prodParam.exit(); |
|
} |
|
} |
|
|
|
return callback(); |
|
} |
|
|
|
disallowInAnd(callback) { |
|
const flags = this.prodParam.currentFlags(); |
|
const prodParamToClear = PARAM_IN & flags; |
|
|
|
if (prodParamToClear) { |
|
this.prodParam.enter(flags & ~PARAM_IN); |
|
|
|
try { |
|
return callback(); |
|
} finally { |
|
this.prodParam.exit(); |
|
} |
|
} |
|
|
|
return callback(); |
|
} |
|
|
|
registerTopicReference() { |
|
this.state.topicContext.maxTopicIndex = 0; |
|
} |
|
|
|
topicReferenceIsAllowedInCurrentContext() { |
|
return this.state.topicContext.maxNumOfResolvableTopics >= 1; |
|
} |
|
|
|
topicReferenceWasUsedInCurrentContext() { |
|
return this.state.topicContext.maxTopicIndex != null && this.state.topicContext.maxTopicIndex >= 0; |
|
} |
|
|
|
parseFSharpPipelineBody(prec) { |
|
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.parseMaybeUnaryOrPrivate(), startPos, startLoc, prec); |
|
this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody; |
|
return ret; |
|
} |
|
|
|
parseModuleExpression() { |
|
this.expectPlugin("moduleBlocks"); |
|
const node = this.startNode(); |
|
this.next(); |
|
this.eat(5); |
|
const revertScopes = this.initializeScopes(true); |
|
this.enterInitialScopes(); |
|
const program = this.startNode(); |
|
|
|
try { |
|
node.body = this.parseProgram(program, 8, "module"); |
|
} finally { |
|
revertScopes(); |
|
} |
|
|
|
this.eat(8); |
|
return this.finishNode(node, "ModuleExpression"); |
|
} |
|
|
|
parsePropertyNamePrefixOperator(prop) {} |
|
|
|
} |
|
|
|
const loopLabel = { |
|
kind: "loop" |
|
}, |
|
switchLabel = { |
|
kind: "switch" |
|
}; |
|
const FUNC_NO_FLAGS = 0b000, |
|
FUNC_STATEMENT = 0b001, |
|
FUNC_HANGING_STATEMENT = 0b010, |
|
FUNC_NULLABLE_ID = 0b100; |
|
const loneSurrogate = /[\uD800-\uDFFF]/u; |
|
const keywordRelationalOperator = /in(?:stanceof)?/y; |
|
|
|
function babel7CompatTokens(tokens, input) { |
|
for (let i = 0; i < tokens.length; i++) { |
|
const token = tokens[i]; |
|
const { |
|
type |
|
} = token; |
|
|
|
if (typeof type === "number") { |
|
{ |
|
if (type === 134) { |
|
const { |
|
loc, |
|
start, |
|
value, |
|
end |
|
} = token; |
|
const hashEndPos = start + 1; |
|
const hashEndLoc = createPositionWithColumnOffset(loc.start, 1); |
|
tokens.splice(i, 1, new Token({ |
|
type: getExportedToken(27), |
|
value: "#", |
|
start: start, |
|
end: hashEndPos, |
|
startLoc: loc.start, |
|
endLoc: hashEndLoc |
|
}), new Token({ |
|
type: getExportedToken(128), |
|
value: value, |
|
start: hashEndPos, |
|
end: end, |
|
startLoc: hashEndLoc, |
|
endLoc: loc.end |
|
})); |
|
i++; |
|
continue; |
|
} |
|
|
|
if (tokenIsTemplate(type)) { |
|
const { |
|
loc, |
|
start, |
|
value, |
|
end |
|
} = token; |
|
const backquoteEnd = start + 1; |
|
const backquoteEndLoc = createPositionWithColumnOffset(loc.start, 1); |
|
let startToken; |
|
|
|
if (input.charCodeAt(start) === 96) { |
|
startToken = new Token({ |
|
type: getExportedToken(22), |
|
value: "`", |
|
start: start, |
|
end: backquoteEnd, |
|
startLoc: loc.start, |
|
endLoc: backquoteEndLoc |
|
}); |
|
} else { |
|
startToken = new Token({ |
|
type: getExportedToken(8), |
|
value: "}", |
|
start: start, |
|
end: backquoteEnd, |
|
startLoc: loc.start, |
|
endLoc: backquoteEndLoc |
|
}); |
|
} |
|
|
|
let templateValue, templateElementEnd, templateElementEndLoc, endToken; |
|
|
|
if (type === 24) { |
|
templateElementEnd = end - 1; |
|
templateElementEndLoc = createPositionWithColumnOffset(loc.end, -1); |
|
templateValue = value === null ? null : value.slice(1, -1); |
|
endToken = new Token({ |
|
type: getExportedToken(22), |
|
value: "`", |
|
start: templateElementEnd, |
|
end: end, |
|
startLoc: templateElementEndLoc, |
|
endLoc: loc.end |
|
}); |
|
} else { |
|
templateElementEnd = end - 2; |
|
templateElementEndLoc = createPositionWithColumnOffset(loc.end, -2); |
|
templateValue = value === null ? null : value.slice(1, -2); |
|
endToken = new Token({ |
|
type: getExportedToken(23), |
|
value: "${", |
|
start: templateElementEnd, |
|
end: end, |
|
startLoc: templateElementEndLoc, |
|
endLoc: loc.end |
|
}); |
|
} |
|
|
|
tokens.splice(i, 1, startToken, new Token({ |
|
type: getExportedToken(20), |
|
value: templateValue, |
|
start: backquoteEnd, |
|
end: templateElementEnd, |
|
startLoc: backquoteEndLoc, |
|
endLoc: templateElementEndLoc |
|
}), endToken); |
|
i += 2; |
|
continue; |
|
} |
|
} |
|
token.type = getExportedToken(type); |
|
} |
|
} |
|
|
|
return tokens; |
|
} |
|
|
|
class StatementParser extends ExpressionParser { |
|
parseTopLevel(file, program) { |
|
file.program = this.parseProgram(program); |
|
file.comments = this.state.comments; |
|
|
|
if (this.options.tokens) { |
|
file.tokens = babel7CompatTokens(this.tokens, this.input); |
|
} |
|
|
|
return this.finishNode(file, "File"); |
|
} |
|
|
|
parseProgram(program, end = 135, sourceType = this.options.sourceType) { |
|
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 |
|
}); |
|
} |
|
} |
|
|
|
return this.finishNode(program, "Program"); |
|
} |
|
|
|
stmtToDirective(stmt) { |
|
const directive = stmt; |
|
directive.type = "Directive"; |
|
directive.value = directive.expression; |
|
delete directive.expression; |
|
const directiveLiteral = directive.value; |
|
const expressionValue = directiveLiteral.value; |
|
const raw = this.input.slice(directiveLiteral.start, directiveLiteral.end); |
|
const val = directiveLiteral.value = raw.slice(1, -1); |
|
this.addExtra(directiveLiteral, "raw", raw); |
|
this.addExtra(directiveLiteral, "rawValue", val); |
|
this.addExtra(directiveLiteral, "expressionValue", expressionValue); |
|
directiveLiteral.type = "DirectiveLiteral"; |
|
return directive; |
|
} |
|
|
|
parseInterpreterDirective() { |
|
if (!this.match(28)) { |
|
return null; |
|
} |
|
|
|
const node = this.startNode(); |
|
node.value = this.state.value; |
|
this.next(); |
|
return this.finishNode(node, "InterpreterDirective"); |
|
} |
|
|
|
isLet(context) { |
|
if (!this.isContextual(99)) { |
|
return false; |
|
} |
|
|
|
return this.isLetKeyword(context); |
|
} |
|
|
|
isLetKeyword(context) { |
|
const next = this.nextTokenStart(); |
|
const nextCh = this.codePointAtPos(next); |
|
|
|
if (nextCh === 92 || nextCh === 91) { |
|
return true; |
|
} |
|
|
|
if (context) return false; |
|
if (nextCh === 123) return true; |
|
|
|
if (isIdentifierStart(nextCh)) { |
|
keywordRelationalOperator.lastIndex = next; |
|
|
|
if (keywordRelationalOperator.test(this.input)) { |
|
const endCh = this.codePointAtPos(keywordRelationalOperator.lastIndex); |
|
|
|
if (!isIdentifierChar(endCh) && endCh !== 92) { |
|
return false; |
|
} |
|
} |
|
|
|
return true; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
parseStatement(context, topLevel) { |
|
if (this.match(26)) { |
|
this.parseDecorators(true); |
|
} |
|
|
|
return this.parseStatementContent(context, topLevel); |
|
} |
|
|
|
parseStatementContent(context, topLevel) { |
|
let starttype = this.state.type; |
|
const node = this.startNode(); |
|
let kind; |
|
|
|
if (this.isLet(context)) { |
|
starttype = 74; |
|
kind = "let"; |
|
} |
|
|
|
switch (starttype) { |
|
case 60: |
|
return this.parseBreakContinueStatement(node, true); |
|
|
|
case 63: |
|
return this.parseBreakContinueStatement(node, false); |
|
|
|
case 64: |
|
return this.parseDebuggerStatement(node); |
|
|
|
case 90: |
|
return this.parseDoStatement(node); |
|
|
|
case 91: |
|
return this.parseForStatement(node); |
|
|
|
case 68: |
|
if (this.lookaheadCharCode() === 46) break; |
|
|
|
if (context) { |
|
if (this.state.strict) { |
|
this.raise(Errors.StrictFunction, { |
|
at: this.state.startLoc |
|
}); |
|
} else if (context !== "if" && context !== "label") { |
|
this.raise(Errors.SloppyFunction, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
} |
|
|
|
return this.parseFunctionStatement(node, false, !context); |
|
|
|
case 80: |
|
if (context) this.unexpected(); |
|
return this.parseClass(node, true); |
|
|
|
case 69: |
|
return this.parseIfStatement(node); |
|
|
|
case 70: |
|
return this.parseReturnStatement(node); |
|
|
|
case 71: |
|
return this.parseSwitchStatement(node); |
|
|
|
case 72: |
|
return this.parseThrowStatement(node); |
|
|
|
case 73: |
|
return this.parseTryStatement(node); |
|
|
|
case 75: |
|
case 74: |
|
kind = kind || this.state.value; |
|
|
|
if (context && kind !== "var") { |
|
this.raise(Errors.UnexpectedLexicalDeclaration, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
|
|
return this.parseVarStatement(node, kind); |
|
|
|
case 92: |
|
return this.parseWhileStatement(node); |
|
|
|
case 76: |
|
return this.parseWithStatement(node); |
|
|
|
case 5: |
|
return this.parseBlock(); |
|
|
|
case 13: |
|
return this.parseEmptyStatement(node); |
|
|
|
case 83: |
|
{ |
|
const nextTokenCharCode = this.lookaheadCharCode(); |
|
|
|
if (nextTokenCharCode === 40 || nextTokenCharCode === 46) { |
|
break; |
|
} |
|
} |
|
|
|
case 82: |
|
{ |
|
if (!this.options.allowImportExportEverywhere && !topLevel) { |
|
this.raise(Errors.UnexpectedImportExport, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
|
|
this.next(); |
|
let result; |
|
|
|
if (starttype === 83) { |
|
result = this.parseImport(node); |
|
|
|
if (result.type === "ImportDeclaration" && (!result.importKind || result.importKind === "value")) { |
|
this.sawUnambiguousESM = true; |
|
} |
|
} else { |
|
result = this.parseExport(node); |
|
|
|
if (result.type === "ExportNamedDeclaration" && (!result.exportKind || result.exportKind === "value") || result.type === "ExportAllDeclaration" && (!result.exportKind || result.exportKind === "value") || result.type === "ExportDefaultDeclaration") { |
|
this.sawUnambiguousESM = true; |
|
} |
|
} |
|
|
|
this.assertModuleNodeAllowed(node); |
|
return result; |
|
} |
|
|
|
default: |
|
{ |
|
if (this.isAsyncFunction()) { |
|
if (context) { |
|
this.raise(Errors.AsyncFunctionInSingleStatementContext, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
|
|
this.next(); |
|
return this.parseFunctionStatement(node, true, !context); |
|
} |
|
} |
|
} |
|
|
|
const maybeName = this.state.value; |
|
const expr = this.parseExpression(); |
|
|
|
if (tokenIsIdentifier(starttype) && expr.type === "Identifier" && this.eat(14)) { |
|
return this.parseLabeledStatement(node, maybeName, expr, context); |
|
} else { |
|
return this.parseExpressionStatement(node, expr); |
|
} |
|
} |
|
|
|
assertModuleNodeAllowed(node) { |
|
if (!this.options.allowImportExportEverywhere && !this.inModule) { |
|
this.raise(Errors.ImportOutsideModule, { |
|
at: node |
|
}); |
|
} |
|
} |
|
|
|
takeDecorators(node) { |
|
const decorators = this.state.decoratorStack[this.state.decoratorStack.length - 1]; |
|
|
|
if (decorators.length) { |
|
node.decorators = decorators; |
|
this.resetStartLocationFromNode(node, decorators[0]); |
|
this.state.decoratorStack[this.state.decoratorStack.length - 1] = []; |
|
} |
|
} |
|
|
|
canHaveLeadingDecorator() { |
|
return this.match(80); |
|
} |
|
|
|
parseDecorators(allowExport) { |
|
const currentContextDecorators = this.state.decoratorStack[this.state.decoratorStack.length - 1]; |
|
|
|
while (this.match(26)) { |
|
const decorator = this.parseDecorator(); |
|
currentContextDecorators.push(decorator); |
|
} |
|
|
|
if (this.match(82)) { |
|
if (!allowExport) { |
|
this.unexpected(); |
|
} |
|
|
|
if (this.hasPlugin("decorators") && !this.getPluginOption("decorators", "decoratorsBeforeExport")) { |
|
this.raise(Errors.DecoratorExportClass, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
} else if (!this.canHaveLeadingDecorator()) { |
|
throw this.raise(Errors.UnexpectedLeadingDecorator, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
} |
|
|
|
parseDecorator() { |
|
this.expectOnePlugin(["decorators-legacy", "decorators"]); |
|
const node = this.startNode(); |
|
this.next(); |
|
|
|
if (this.hasPlugin("decorators")) { |
|
this.state.decoratorStack.push([]); |
|
const startPos = this.state.start; |
|
const startLoc = this.state.startLoc; |
|
let expr; |
|
|
|
if (this.match(10)) { |
|
const startPos = this.state.start; |
|
const startLoc = this.state.startLoc; |
|
this.next(); |
|
expr = this.parseExpression(); |
|
this.expect(11); |
|
expr = this.wrapParenthesis(startPos, startLoc, expr); |
|
} else { |
|
expr = this.parseIdentifier(false); |
|
|
|
while (this.eat(16)) { |
|
const node = this.startNodeAt(startPos, startLoc); |
|
node.object = expr; |
|
node.property = this.parseIdentifier(true); |
|
node.computed = false; |
|
expr = this.finishNode(node, "MemberExpression"); |
|
} |
|
} |
|
|
|
node.expression = this.parseMaybeDecoratorArguments(expr); |
|
this.state.decoratorStack.pop(); |
|
} else { |
|
node.expression = this.parseExprSubscripts(); |
|
} |
|
|
|
return this.finishNode(node, "Decorator"); |
|
} |
|
|
|
parseMaybeDecoratorArguments(expr) { |
|
if (this.eat(10)) { |
|
const node = this.startNodeAtNode(expr); |
|
node.callee = expr; |
|
node.arguments = this.parseCallExpressionArguments(11, false); |
|
this.toReferencedList(node.arguments); |
|
return this.finishNode(node, "CallExpression"); |
|
} |
|
|
|
return expr; |
|
} |
|
|
|
parseBreakContinueStatement(node, isBreak) { |
|
this.next(); |
|
|
|
if (this.isLineTerminator()) { |
|
node.label = null; |
|
} else { |
|
node.label = this.parseIdentifier(); |
|
this.semicolon(); |
|
} |
|
|
|
this.verifyBreakContinue(node, isBreak); |
|
return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement"); |
|
} |
|
|
|
verifyBreakContinue(node, isBreak) { |
|
let i; |
|
|
|
for (i = 0; i < this.state.labels.length; ++i) { |
|
const lab = this.state.labels[i]; |
|
|
|
if (node.label == null || lab.name === node.label.name) { |
|
if (lab.kind != null && (isBreak || lab.kind === "loop")) break; |
|
if (node.label && isBreak) break; |
|
} |
|
} |
|
|
|
if (i === this.state.labels.length) { |
|
const type = isBreak ? "BreakStatement" : "ContinueStatement"; |
|
this.raise(Errors.IllegalBreakContinue, { |
|
at: node, |
|
type |
|
}); |
|
} |
|
} |
|
|
|
parseDebuggerStatement(node) { |
|
this.next(); |
|
this.semicolon(); |
|
return this.finishNode(node, "DebuggerStatement"); |
|
} |
|
|
|
parseHeaderExpression() { |
|
this.expect(10); |
|
const val = this.parseExpression(); |
|
this.expect(11); |
|
return val; |
|
} |
|
|
|
parseDoStatement(node) { |
|
this.next(); |
|
this.state.labels.push(loopLabel); |
|
node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement("do")); |
|
this.state.labels.pop(); |
|
this.expect(92); |
|
node.test = this.parseHeaderExpression(); |
|
this.eat(13); |
|
return this.finishNode(node, "DoWhileStatement"); |
|
} |
|
|
|
parseForStatement(node) { |
|
this.next(); |
|
this.state.labels.push(loopLabel); |
|
let awaitAt = null; |
|
|
|
if (this.isAwaitAllowed() && this.eatContextual(96)) { |
|
awaitAt = this.state.lastTokStartLoc; |
|
} |
|
|
|
this.scope.enter(SCOPE_OTHER); |
|
this.expect(10); |
|
|
|
if (this.match(13)) { |
|
if (awaitAt !== null) { |
|
this.unexpected(awaitAt); |
|
} |
|
|
|
return this.parseFor(node, null); |
|
} |
|
|
|
const startsWithLet = this.isContextual(99); |
|
const isLet = startsWithLet && this.isLetKeyword(); |
|
|
|
if (this.match(74) || this.match(75) || isLet) { |
|
const init = this.startNode(); |
|
const kind = isLet ? "let" : this.state.value; |
|
this.next(); |
|
this.parseVar(init, true, kind); |
|
this.finishNode(init, "VariableDeclaration"); |
|
|
|
if ((this.match(58) || this.isContextual(101)) && init.declarations.length === 1) { |
|
return this.parseForIn(node, init, awaitAt); |
|
} |
|
|
|
if (awaitAt !== null) { |
|
this.unexpected(awaitAt); |
|
} |
|
|
|
return this.parseFor(node, init); |
|
} |
|
|
|
const startsWithAsync = this.isContextual(95); |
|
const refExpressionErrors = new ExpressionErrors(); |
|
const init = this.parseExpression(true, refExpressionErrors); |
|
const isForOf = this.isContextual(101); |
|
|
|
if (isForOf) { |
|
if (startsWithLet) { |
|
this.raise(Errors.ForOfLet, { |
|
at: init |
|
}); |
|
} |
|
|
|
if (awaitAt === null && startsWithAsync && init.type === "Identifier") { |
|
this.raise(Errors.ForOfAsync, { |
|
at: init |
|
}); |
|
} |
|
} |
|
|
|
if (isForOf || this.match(58)) { |
|
this.checkDestructuringPrivate(refExpressionErrors); |
|
this.toAssignable(init, true); |
|
const type = isForOf ? "ForOfStatement" : "ForInStatement"; |
|
this.checkLVal(init, { |
|
in: { |
|
type |
|
} |
|
}); |
|
return this.parseForIn(node, init, awaitAt); |
|
} else { |
|
this.checkExpressionErrors(refExpressionErrors, true); |
|
} |
|
|
|
if (awaitAt !== null) { |
|
this.unexpected(awaitAt); |
|
} |
|
|
|
return this.parseFor(node, init); |
|
} |
|
|
|
parseFunctionStatement(node, isAsync, declarationPosition) { |
|
this.next(); |
|
return this.parseFunction(node, FUNC_STATEMENT | (declarationPosition ? 0 : FUNC_HANGING_STATEMENT), isAsync); |
|
} |
|
|
|
parseIfStatement(node) { |
|
this.next(); |
|
node.test = this.parseHeaderExpression(); |
|
node.consequent = this.parseStatement("if"); |
|
node.alternate = this.eat(66) ? this.parseStatement("if") : null; |
|
return this.finishNode(node, "IfStatement"); |
|
} |
|
|
|
parseReturnStatement(node) { |
|
if (!this.prodParam.hasReturn && !this.options.allowReturnOutsideFunction) { |
|
this.raise(Errors.IllegalReturn, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
|
|
this.next(); |
|
|
|
if (this.isLineTerminator()) { |
|
node.argument = null; |
|
} else { |
|
node.argument = this.parseExpression(); |
|
this.semicolon(); |
|
} |
|
|
|
return this.finishNode(node, "ReturnStatement"); |
|
} |
|
|
|
parseSwitchStatement(node) { |
|
this.next(); |
|
node.discriminant = this.parseHeaderExpression(); |
|
const cases = node.cases = []; |
|
this.expect(5); |
|
this.state.labels.push(switchLabel); |
|
this.scope.enter(SCOPE_OTHER); |
|
let cur; |
|
|
|
for (let sawDefault; !this.match(8);) { |
|
if (this.match(61) || this.match(65)) { |
|
const isCase = this.match(61); |
|
if (cur) this.finishNode(cur, "SwitchCase"); |
|
cases.push(cur = this.startNode()); |
|
cur.consequent = []; |
|
this.next(); |
|
|
|
if (isCase) { |
|
cur.test = this.parseExpression(); |
|
} else { |
|
if (sawDefault) { |
|
this.raise(Errors.MultipleDefaultsInSwitch, { |
|
at: this.state.lastTokStartLoc |
|
}); |
|
} |
|
|
|
sawDefault = true; |
|
cur.test = null; |
|
} |
|
|
|
this.expect(14); |
|
} else { |
|
if (cur) { |
|
cur.consequent.push(this.parseStatement(null)); |
|
} else { |
|
this.unexpected(); |
|
} |
|
} |
|
} |
|
|
|
this.scope.exit(); |
|
if (cur) this.finishNode(cur, "SwitchCase"); |
|
this.next(); |
|
this.state.labels.pop(); |
|
return this.finishNode(node, "SwitchStatement"); |
|
} |
|
|
|
parseThrowStatement(node) { |
|
this.next(); |
|
|
|
if (this.hasPrecedingLineBreak()) { |
|
this.raise(Errors.NewlineAfterThrow, { |
|
at: this.state.lastTokEndLoc |
|
}); |
|
} |
|
|
|
node.argument = this.parseExpression(); |
|
this.semicolon(); |
|
return this.finishNode(node, "ThrowStatement"); |
|
} |
|
|
|
parseCatchClauseParam() { |
|
const param = this.parseBindingAtom(); |
|
const simple = param.type === "Identifier"; |
|
this.scope.enter(simple ? SCOPE_SIMPLE_CATCH : 0); |
|
this.checkLVal(param, { |
|
in: { |
|
type: "CatchClause" |
|
}, |
|
binding: BIND_LEXICAL, |
|
allowingSloppyLetBinding: true |
|
}); |
|
return param; |
|
} |
|
|
|
parseTryStatement(node) { |
|
this.next(); |
|
node.block = this.parseBlock(); |
|
node.handler = null; |
|
|
|
if (this.match(62)) { |
|
const clause = this.startNode(); |
|
this.next(); |
|
|
|
if (this.match(10)) { |
|
this.expect(10); |
|
clause.param = this.parseCatchClauseParam(); |
|
this.expect(11); |
|
} else { |
|
clause.param = null; |
|
this.scope.enter(SCOPE_OTHER); |
|
} |
|
|
|
clause.body = this.withSmartMixTopicForbiddingContext(() => this.parseBlock(false, false)); |
|
this.scope.exit(); |
|
node.handler = this.finishNode(clause, "CatchClause"); |
|
} |
|
|
|
node.finalizer = this.eat(67) ? this.parseBlock() : null; |
|
|
|
if (!node.handler && !node.finalizer) { |
|
this.raise(Errors.NoCatchOrFinally, { |
|
at: node |
|
}); |
|
} |
|
|
|
return this.finishNode(node, "TryStatement"); |
|
} |
|
|
|
parseVarStatement(node, kind, allowMissingInitializer = false) { |
|
this.next(); |
|
this.parseVar(node, false, kind, allowMissingInitializer); |
|
this.semicolon(); |
|
return this.finishNode(node, "VariableDeclaration"); |
|
} |
|
|
|
parseWhileStatement(node) { |
|
this.next(); |
|
node.test = this.parseHeaderExpression(); |
|
this.state.labels.push(loopLabel); |
|
node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement("while")); |
|
this.state.labels.pop(); |
|
return this.finishNode(node, "WhileStatement"); |
|
} |
|
|
|
parseWithStatement(node) { |
|
if (this.state.strict) { |
|
this.raise(Errors.StrictWith, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
|
|
this.next(); |
|
node.object = this.parseHeaderExpression(); |
|
node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement("with")); |
|
return this.finishNode(node, "WithStatement"); |
|
} |
|
|
|
parseEmptyStatement(node) { |
|
this.next(); |
|
return this.finishNode(node, "EmptyStatement"); |
|
} |
|
|
|
parseLabeledStatement(node, maybeName, expr, context) { |
|
for (const label of this.state.labels) { |
|
if (label.name === maybeName) { |
|
this.raise(Errors.LabelRedeclaration, { |
|
at: expr, |
|
labelName: maybeName |
|
}); |
|
} |
|
} |
|
|
|
const kind = tokenIsLoop(this.state.type) ? "loop" : this.match(71) ? "switch" : null; |
|
|
|
for (let i = this.state.labels.length - 1; i >= 0; i--) { |
|
const label = this.state.labels[i]; |
|
|
|
if (label.statementStart === node.start) { |
|
label.statementStart = this.state.start; |
|
label.kind = kind; |
|
} else { |
|
break; |
|
} |
|
} |
|
|
|
this.state.labels.push({ |
|
name: maybeName, |
|
kind: kind, |
|
statementStart: this.state.start |
|
}); |
|
node.body = this.parseStatement(context ? context.indexOf("label") === -1 ? context + "label" : context : "label"); |
|
this.state.labels.pop(); |
|
node.label = expr; |
|
return this.finishNode(node, "LabeledStatement"); |
|
} |
|
|
|
parseExpressionStatement(node, expr) { |
|
node.expression = expr; |
|
this.semicolon(); |
|
return this.finishNode(node, "ExpressionStatement"); |
|
} |
|
|
|
parseBlock(allowDirectives = false, createNewLexicalScope = true, afterBlockParse) { |
|
const node = this.startNode(); |
|
|
|
if (allowDirectives) { |
|
this.state.strictErrors.clear(); |
|
} |
|
|
|
this.expect(5); |
|
|
|
if (createNewLexicalScope) { |
|
this.scope.enter(SCOPE_OTHER); |
|
} |
|
|
|
this.parseBlockBody(node, allowDirectives, false, 8, afterBlockParse); |
|
|
|
if (createNewLexicalScope) { |
|
this.scope.exit(); |
|
} |
|
|
|
return this.finishNode(node, "BlockStatement"); |
|
} |
|
|
|
isValidDirective(stmt) { |
|
return stmt.type === "ExpressionStatement" && stmt.expression.type === "StringLiteral" && !stmt.expression.extra.parenthesized; |
|
} |
|
|
|
parseBlockBody(node, allowDirectives, topLevel, end, afterBlockParse) { |
|
const body = node.body = []; |
|
const directives = node.directives = []; |
|
this.parseBlockOrModuleBlockBody(body, allowDirectives ? directives : undefined, topLevel, end, afterBlockParse); |
|
} |
|
|
|
parseBlockOrModuleBlockBody(body, directives, topLevel, end, afterBlockParse) { |
|
const oldStrict = this.state.strict; |
|
let hasStrictModeDirective = false; |
|
let parsedNonDirective = false; |
|
|
|
while (!this.match(end)) { |
|
const stmt = this.parseStatement(null, topLevel); |
|
|
|
if (directives && !parsedNonDirective) { |
|
if (this.isValidDirective(stmt)) { |
|
const directive = this.stmtToDirective(stmt); |
|
directives.push(directive); |
|
|
|
if (!hasStrictModeDirective && directive.value.value === "use strict") { |
|
hasStrictModeDirective = true; |
|
this.setStrict(true); |
|
} |
|
|
|
continue; |
|
} |
|
|
|
parsedNonDirective = true; |
|
this.state.strictErrors.clear(); |
|
} |
|
|
|
body.push(stmt); |
|
} |
|
|
|
if (afterBlockParse) { |
|
afterBlockParse.call(this, hasStrictModeDirective); |
|
} |
|
|
|
if (!oldStrict) { |
|
this.setStrict(false); |
|
} |
|
|
|
this.next(); |
|
} |
|
|
|
parseFor(node, init) { |
|
node.init = init; |
|
this.semicolon(false); |
|
node.test = this.match(13) ? null : this.parseExpression(); |
|
this.semicolon(false); |
|
node.update = this.match(11) ? null : this.parseExpression(); |
|
this.expect(11); |
|
node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement("for")); |
|
this.scope.exit(); |
|
this.state.labels.pop(); |
|
return this.finishNode(node, "ForStatement"); |
|
} |
|
|
|
parseForIn(node, init, awaitAt) { |
|
const isForIn = this.match(58); |
|
this.next(); |
|
|
|
if (isForIn) { |
|
if (awaitAt !== null) this.unexpected(awaitAt); |
|
} else { |
|
node.await = awaitAt !== null; |
|
} |
|
|
|
if (init.type === "VariableDeclaration" && init.declarations[0].init != null && (!isForIn || this.state.strict || init.kind !== "var" || init.declarations[0].id.type !== "Identifier")) { |
|
this.raise(Errors.ForInOfLoopInitializer, { |
|
at: init, |
|
type: isForIn ? "ForInStatement" : "ForOfStatement" |
|
}); |
|
} |
|
|
|
if (init.type === "AssignmentPattern") { |
|
this.raise(Errors.InvalidLhs, { |
|
at: init, |
|
ancestor: { |
|
type: "ForStatement" |
|
} |
|
}); |
|
} |
|
|
|
node.left = init; |
|
node.right = isForIn ? this.parseExpression() : this.parseMaybeAssignAllowIn(); |
|
this.expect(11); |
|
node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement("for")); |
|
this.scope.exit(); |
|
this.state.labels.pop(); |
|
return this.finishNode(node, isForIn ? "ForInStatement" : "ForOfStatement"); |
|
} |
|
|
|
parseVar(node, isFor, kind, allowMissingInitializer = false) { |
|
const declarations = node.declarations = []; |
|
node.kind = kind; |
|
|
|
for (;;) { |
|
const decl = this.startNode(); |
|
this.parseVarId(decl, kind); |
|
decl.init = !this.eat(29) ? null : isFor ? this.parseMaybeAssignDisallowIn() : this.parseMaybeAssignAllowIn(); |
|
|
|
if (decl.init === null && !allowMissingInitializer) { |
|
if (decl.id.type !== "Identifier" && !(isFor && (this.match(58) || this.isContextual(101)))) { |
|
this.raise(Errors.DeclarationMissingInitializer, { |
|
at: this.state.lastTokEndLoc, |
|
kind: "destructuring" |
|
}); |
|
} else if (kind === "const" && !(this.match(58) || this.isContextual(101))) { |
|
this.raise(Errors.DeclarationMissingInitializer, { |
|
at: this.state.lastTokEndLoc, |
|
kind: "const" |
|
}); |
|
} |
|
} |
|
|
|
declarations.push(this.finishNode(decl, "VariableDeclarator")); |
|
if (!this.eat(12)) break; |
|
} |
|
|
|
return node; |
|
} |
|
|
|
parseVarId(decl, kind) { |
|
decl.id = this.parseBindingAtom(); |
|
this.checkLVal(decl.id, { |
|
in: { |
|
type: "VariableDeclarator" |
|
}, |
|
binding: kind === "var" ? BIND_VAR : BIND_LEXICAL |
|
}); |
|
} |
|
|
|
parseFunction(node, statement = FUNC_NO_FLAGS, isAsync = false) { |
|
const isStatement = statement & FUNC_STATEMENT; |
|
const isHangingStatement = statement & FUNC_HANGING_STATEMENT; |
|
const requireId = !!isStatement && !(statement & FUNC_NULLABLE_ID); |
|
this.initFunction(node, isAsync); |
|
|
|
if (this.match(55) && isHangingStatement) { |
|
this.raise(Errors.GeneratorInSingleStatementContext, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
|
|
node.generator = this.eat(55); |
|
|
|
if (isStatement) { |
|
node.id = this.parseFunctionId(requireId); |
|
} |
|
|
|
const oldMaybeInArrowParameters = this.state.maybeInArrowParameters; |
|
this.state.maybeInArrowParameters = false; |
|
this.scope.enter(SCOPE_FUNCTION); |
|
this.prodParam.enter(functionFlags(isAsync, node.generator)); |
|
|
|
if (!isStatement) { |
|
node.id = this.parseFunctionId(); |
|
} |
|
|
|
this.parseFunctionParams(node, false); |
|
this.withSmartMixTopicForbiddingContext(() => { |
|
this.parseFunctionBodyAndFinish(node, isStatement ? "FunctionDeclaration" : "FunctionExpression"); |
|
}); |
|
this.prodParam.exit(); |
|
this.scope.exit(); |
|
|
|
if (isStatement && !isHangingStatement) { |
|
this.registerFunctionStatementId(node); |
|
} |
|
|
|
this.state.maybeInArrowParameters = oldMaybeInArrowParameters; |
|
return node; |
|
} |
|
|
|
parseFunctionId(requireId) { |
|
return requireId || tokenIsIdentifier(this.state.type) ? this.parseIdentifier() : null; |
|
} |
|
|
|
parseFunctionParams(node, allowModifiers) { |
|
this.expect(10); |
|
this.expressionScope.enter(newParameterDeclarationScope()); |
|
node.params = this.parseBindingList(11, 41, false, allowModifiers); |
|
this.expressionScope.exit(); |
|
} |
|
|
|
registerFunctionStatementId(node) { |
|
if (!node.id) return; |
|
this.scope.declareName(node.id.name, this.state.strict || node.generator || node.async ? this.scope.treatFunctionsAsVar ? BIND_VAR : BIND_LEXICAL : BIND_FUNCTION, node.id.loc.start); |
|
} |
|
|
|
parseClass(node, isStatement, optionalId) { |
|
this.next(); |
|
this.takeDecorators(node); |
|
const oldStrict = this.state.strict; |
|
this.state.strict = true; |
|
this.parseClassId(node, isStatement, optionalId); |
|
this.parseClassSuper(node); |
|
node.body = this.parseClassBody(!!node.superClass, oldStrict); |
|
return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression"); |
|
} |
|
|
|
isClassProperty() { |
|
return this.match(29) || this.match(13) || this.match(8); |
|
} |
|
|
|
isClassMethod() { |
|
return this.match(10); |
|
} |
|
|
|
isNonstaticConstructor(method) { |
|
return !method.computed && !method.static && (method.key.name === "constructor" || method.key.value === "constructor"); |
|
} |
|
|
|
parseClassBody(hadSuperClass, oldStrict) { |
|
this.classScope.enter(); |
|
const state = { |
|
hadConstructor: false, |
|
hadSuperClass |
|
}; |
|
let decorators = []; |
|
const classBody = this.startNode(); |
|
classBody.body = []; |
|
this.expect(5); |
|
this.withSmartMixTopicForbiddingContext(() => { |
|
while (!this.match(8)) { |
|
if (this.eat(13)) { |
|
if (decorators.length > 0) { |
|
throw this.raise(Errors.DecoratorSemicolon, { |
|
at: this.state.lastTokEndLoc |
|
}); |
|
} |
|
|
|
continue; |
|
} |
|
|
|
if (this.match(26)) { |
|
decorators.push(this.parseDecorator()); |
|
continue; |
|
} |
|
|
|
const member = this.startNode(); |
|
|
|
if (decorators.length) { |
|
member.decorators = decorators; |
|
this.resetStartLocationFromNode(member, decorators[0]); |
|
decorators = []; |
|
} |
|
|
|
this.parseClassMember(classBody, member, state); |
|
|
|
if (member.kind === "constructor" && member.decorators && member.decorators.length > 0) { |
|
this.raise(Errors.DecoratorConstructor, { |
|
at: member |
|
}); |
|
} |
|
} |
|
}); |
|
this.state.strict = oldStrict; |
|
this.next(); |
|
|
|
if (decorators.length) { |
|
throw this.raise(Errors.TrailingDecorator, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
|
|
this.classScope.exit(); |
|
return this.finishNode(classBody, "ClassBody"); |
|
} |
|
|
|
parseClassMemberFromModifier(classBody, member) { |
|
const key = this.parseIdentifier(true); |
|
|
|
if (this.isClassMethod()) { |
|
const method = member; |
|
method.kind = "method"; |
|
method.computed = false; |
|
method.key = key; |
|
method.static = false; |
|
this.pushClassMethod(classBody, method, false, false, false, false); |
|
return true; |
|
} else if (this.isClassProperty()) { |
|
const prop = member; |
|
prop.computed = false; |
|
prop.key = key; |
|
prop.static = false; |
|
classBody.body.push(this.parseClassProperty(prop)); |
|
return true; |
|
} |
|
|
|
this.resetPreviousNodeTrailingComments(key); |
|
return false; |
|
} |
|
|
|
parseClassMember(classBody, member, state) { |
|
const isStatic = this.isContextual(104); |
|
|
|
if (isStatic) { |
|
if (this.parseClassMemberFromModifier(classBody, member)) { |
|
return; |
|
} |
|
|
|
if (this.eat(5)) { |
|
this.parseClassStaticBlock(classBody, member); |
|
return; |
|
} |
|
} |
|
|
|
this.parseClassMemberWithIsStatic(classBody, member, state, isStatic); |
|
} |
|
|
|
parseClassMemberWithIsStatic(classBody, member, state, isStatic) { |
|
const publicMethod = member; |
|
const privateMethod = member; |
|
const publicProp = member; |
|
const privateProp = member; |
|
const accessorProp = member; |
|
const method = publicMethod; |
|
const publicMember = publicMethod; |
|
member.static = isStatic; |
|
this.parsePropertyNamePrefixOperator(member); |
|
|
|
if (this.eat(55)) { |
|
method.kind = "method"; |
|
const isPrivateName = this.match(134); |
|
this.parseClassElementName(method); |
|
|
|
if (isPrivateName) { |
|
this.pushClassPrivateMethod(classBody, privateMethod, true, false); |
|
return; |
|
} |
|
|
|
if (this.isNonstaticConstructor(publicMethod)) { |
|
this.raise(Errors.ConstructorIsGenerator, { |
|
at: publicMethod.key |
|
}); |
|
} |
|
|
|
this.pushClassMethod(classBody, publicMethod, true, false, false, false); |
|
return; |
|
} |
|
|
|
const isContextual = tokenIsIdentifier(this.state.type) && !this.state.containsEsc; |
|
const isPrivate = this.match(134); |
|
const key = this.parseClassElementName(member); |
|
const maybeQuestionTokenStartLoc = this.state.startLoc; |
|
this.parsePostMemberNameModifiers(publicMember); |
|
|
|
if (this.isClassMethod()) { |
|
method.kind = "method"; |
|
|
|
if (isPrivate) { |
|
this.pushClassPrivateMethod(classBody, privateMethod, false, false); |
|
return; |
|
} |
|
|
|
const isConstructor = this.isNonstaticConstructor(publicMethod); |
|
let allowsDirectSuper = false; |
|
|
|
if (isConstructor) { |
|
publicMethod.kind = "constructor"; |
|
|
|
if (state.hadConstructor && !this.hasPlugin("typescript")) { |
|
this.raise(Errors.DuplicateConstructor, { |
|
at: key |
|
}); |
|
} |
|
|
|
if (isConstructor && this.hasPlugin("typescript") && member.override) { |
|
this.raise(Errors.OverrideOnConstructor, { |
|
at: key |
|
}); |
|
} |
|
|
|
state.hadConstructor = true; |
|
allowsDirectSuper = state.hadSuperClass; |
|
} |
|
|
|
this.pushClassMethod(classBody, publicMethod, false, false, isConstructor, allowsDirectSuper); |
|
} else if (this.isClassProperty()) { |
|
if (isPrivate) { |
|
this.pushClassPrivateProperty(classBody, privateProp); |
|
} else { |
|
this.pushClassProperty(classBody, publicProp); |
|
} |
|
} else if (isContextual && key.name === "async" && !this.isLineTerminator()) { |
|
this.resetPreviousNodeTrailingComments(key); |
|
const isGenerator = this.eat(55); |
|
|
|
if (publicMember.optional) { |
|
this.unexpected(maybeQuestionTokenStartLoc); |
|
} |
|
|
|
method.kind = "method"; |
|
const isPrivate = this.match(134); |
|
this.parseClassElementName(method); |
|
this.parsePostMemberNameModifiers(publicMember); |
|
|
|
if (isPrivate) { |
|
this.pushClassPrivateMethod(classBody, privateMethod, isGenerator, true); |
|
} else { |
|
if (this.isNonstaticConstructor(publicMethod)) { |
|
this.raise(Errors.ConstructorIsAsync, { |
|
at: publicMethod.key |
|
}); |
|
} |
|
|
|
this.pushClassMethod(classBody, publicMethod, isGenerator, true, false, false); |
|
} |
|
} else if (isContextual && (key.name === "get" || key.name === "set") && !(this.match(55) && this.isLineTerminator())) { |
|
this.resetPreviousNodeTrailingComments(key); |
|
method.kind = key.name; |
|
const isPrivate = this.match(134); |
|
this.parseClassElementName(publicMethod); |
|
|
|
if (isPrivate) { |
|
this.pushClassPrivateMethod(classBody, privateMethod, false, false); |
|
} else { |
|
if (this.isNonstaticConstructor(publicMethod)) { |
|
this.raise(Errors.ConstructorIsAccessor, { |
|
at: publicMethod.key |
|
}); |
|
} |
|
|
|
this.pushClassMethod(classBody, publicMethod, false, false, false, false); |
|
} |
|
|
|
this.checkGetterSetterParams(publicMethod); |
|
} else if (isContextual && key.name === "accessor" && !this.isLineTerminator()) { |
|
this.expectPlugin("decoratorAutoAccessors"); |
|
this.resetPreviousNodeTrailingComments(key); |
|
const isPrivate = this.match(134); |
|
this.parseClassElementName(publicProp); |
|
this.pushClassAccessorProperty(classBody, accessorProp, isPrivate); |
|
} else if (this.isLineTerminator()) { |
|
if (isPrivate) { |
|
this.pushClassPrivateProperty(classBody, privateProp); |
|
} else { |
|
this.pushClassProperty(classBody, publicProp); |
|
} |
|
} else { |
|
this.unexpected(); |
|
} |
|
} |
|
|
|
parseClassElementName(member) { |
|
const { |
|
type, |
|
value |
|
} = this.state; |
|
|
|
if ((type === 128 || type === 129) && member.static && value === "prototype") { |
|
this.raise(Errors.StaticPrototype, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
|
|
if (type === 134) { |
|
if (value === "constructor") { |
|
this.raise(Errors.ConstructorClassPrivateField, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
|
|
const key = this.parsePrivateName(); |
|
member.key = key; |
|
return key; |
|
} |
|
|
|
return this.parsePropertyName(member); |
|
} |
|
|
|
parseClassStaticBlock(classBody, member) { |
|
var _member$decorators; |
|
|
|
this.scope.enter(SCOPE_CLASS | SCOPE_STATIC_BLOCK | SCOPE_SUPER); |
|
const oldLabels = this.state.labels; |
|
this.state.labels = []; |
|
this.prodParam.enter(PARAM); |
|
const body = member.body = []; |
|
this.parseBlockOrModuleBlockBody(body, undefined, false, 8); |
|
this.prodParam.exit(); |
|
this.scope.exit(); |
|
this.state.labels = oldLabels; |
|
classBody.body.push(this.finishNode(member, "StaticBlock")); |
|
|
|
if ((_member$decorators = member.decorators) != null && _member$decorators.length) { |
|
this.raise(Errors.DecoratorStaticBlock, { |
|
at: member |
|
}); |
|
} |
|
} |
|
|
|
pushClassProperty(classBody, prop) { |
|
if (!prop.computed && (prop.key.name === "constructor" || prop.key.value === "constructor")) { |
|
this.raise(Errors.ConstructorClassField, { |
|
at: prop.key |
|
}); |
|
} |
|
|
|
classBody.body.push(this.parseClassProperty(prop)); |
|
} |
|
|
|
pushClassPrivateProperty(classBody, prop) { |
|
const node = this.parseClassPrivateProperty(prop); |
|
classBody.body.push(node); |
|
this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), CLASS_ELEMENT_OTHER, node.key.loc.start); |
|
} |
|
|
|
pushClassAccessorProperty(classBody, prop, isPrivate) { |
|
if (!isPrivate && !prop.computed) { |
|
const key = prop.key; |
|
|
|
if (key.name === "constructor" || key.value === "constructor") { |
|
this.raise(Errors.ConstructorClassField, { |
|
at: key |
|
}); |
|
} |
|
} |
|
|
|
const node = this.parseClassAccessorProperty(prop); |
|
classBody.body.push(node); |
|
|
|
if (isPrivate) { |
|
this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), CLASS_ELEMENT_OTHER, node.key.loc.start); |
|
} |
|
} |
|
|
|
pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) { |
|
classBody.body.push(this.parseMethod(method, isGenerator, isAsync, isConstructor, allowsDirectSuper, "ClassMethod", true)); |
|
} |
|
|
|
pushClassPrivateMethod(classBody, method, isGenerator, isAsync) { |
|
const node = this.parseMethod(method, isGenerator, isAsync, false, false, "ClassPrivateMethod", true); |
|
classBody.body.push(node); |
|
const kind = node.kind === "get" ? node.static ? CLASS_ELEMENT_STATIC_GETTER : CLASS_ELEMENT_INSTANCE_GETTER : node.kind === "set" ? node.static ? CLASS_ELEMENT_STATIC_SETTER : CLASS_ELEMENT_INSTANCE_SETTER : CLASS_ELEMENT_OTHER; |
|
this.declareClassPrivateMethodInScope(node, kind); |
|
} |
|
|
|
declareClassPrivateMethodInScope(node, kind) { |
|
this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), kind, node.key.loc.start); |
|
} |
|
|
|
parsePostMemberNameModifiers(methodOrProp) {} |
|
|
|
parseClassPrivateProperty(node) { |
|
this.parseInitializer(node); |
|
this.semicolon(); |
|
return this.finishNode(node, "ClassPrivateProperty"); |
|
} |
|
|
|
parseClassProperty(node) { |
|
this.parseInitializer(node); |
|
this.semicolon(); |
|
return this.finishNode(node, "ClassProperty"); |
|
} |
|
|
|
parseClassAccessorProperty(node) { |
|
this.parseInitializer(node); |
|
this.semicolon(); |
|
return this.finishNode(node, "ClassAccessorProperty"); |
|
} |
|
|
|
parseInitializer(node) { |
|
this.scope.enter(SCOPE_CLASS | SCOPE_SUPER); |
|
this.expressionScope.enter(newExpressionScope()); |
|
this.prodParam.enter(PARAM); |
|
node.value = this.eat(29) ? this.parseMaybeAssignAllowIn() : null; |
|
this.expressionScope.exit(); |
|
this.prodParam.exit(); |
|
this.scope.exit(); |
|
} |
|
|
|
parseClassId(node, isStatement, optionalId, bindingType = BIND_CLASS) { |
|
if (tokenIsIdentifier(this.state.type)) { |
|
node.id = this.parseIdentifier(); |
|
|
|
if (isStatement) { |
|
this.declareNameFromIdentifier(node.id, bindingType); |
|
} |
|
} else { |
|
if (optionalId || !isStatement) { |
|
node.id = null; |
|
} else { |
|
throw this.raise(Errors.MissingClassName, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
} |
|
} |
|
|
|
parseClassSuper(node) { |
|
node.superClass = this.eat(81) ? this.parseExprSubscripts() : null; |
|
} |
|
|
|
parseExport(node) { |
|
const hasDefault = this.maybeParseExportDefaultSpecifier(node); |
|
const parseAfterDefault = !hasDefault || this.eat(12); |
|
const hasStar = parseAfterDefault && this.eatExportStar(node); |
|
const hasNamespace = hasStar && this.maybeParseExportNamespaceSpecifier(node); |
|
const parseAfterNamespace = parseAfterDefault && (!hasNamespace || this.eat(12)); |
|
const isFromRequired = hasDefault || hasStar; |
|
|
|
if (hasStar && !hasNamespace) { |
|
if (hasDefault) this.unexpected(); |
|
this.parseExportFrom(node, true); |
|
return this.finishNode(node, "ExportAllDeclaration"); |
|
} |
|
|
|
const hasSpecifiers = this.maybeParseExportNamedSpecifiers(node); |
|
|
|
if (hasDefault && parseAfterDefault && !hasStar && !hasSpecifiers || hasNamespace && parseAfterNamespace && !hasSpecifiers) { |
|
throw this.unexpected(null, 5); |
|
} |
|
|
|
let hasDeclaration; |
|
|
|
if (isFromRequired || hasSpecifiers) { |
|
hasDeclaration = false; |
|
this.parseExportFrom(node, isFromRequired); |
|
} else { |
|
hasDeclaration = this.maybeParseExportDeclaration(node); |
|
} |
|
|
|
if (isFromRequired || hasSpecifiers || hasDeclaration) { |
|
this.checkExport(node, true, false, !!node.source); |
|
return this.finishNode(node, "ExportNamedDeclaration"); |
|
} |
|
|
|
if (this.eat(65)) { |
|
node.declaration = this.parseExportDefaultExpression(); |
|
this.checkExport(node, true, true); |
|
return this.finishNode(node, "ExportDefaultDeclaration"); |
|
} |
|
|
|
throw this.unexpected(null, 5); |
|
} |
|
|
|
eatExportStar(node) { |
|
return this.eat(55); |
|
} |
|
|
|
maybeParseExportDefaultSpecifier(node) { |
|
if (this.isExportDefaultSpecifier()) { |
|
this.expectPlugin("exportDefaultFrom"); |
|
const specifier = this.startNode(); |
|
specifier.exported = this.parseIdentifier(true); |
|
node.specifiers = [this.finishNode(specifier, "ExportDefaultSpecifier")]; |
|
return true; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
maybeParseExportNamespaceSpecifier(node) { |
|
if (this.isContextual(93)) { |
|
if (!node.specifiers) node.specifiers = []; |
|
const specifier = this.startNodeAt(this.state.lastTokStart, this.state.lastTokStartLoc); |
|
this.next(); |
|
specifier.exported = this.parseModuleExportName(); |
|
node.specifiers.push(this.finishNode(specifier, "ExportNamespaceSpecifier")); |
|
return true; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
maybeParseExportNamedSpecifiers(node) { |
|
if (this.match(5)) { |
|
if (!node.specifiers) node.specifiers = []; |
|
const isTypeExport = node.exportKind === "type"; |
|
node.specifiers.push(...this.parseExportSpecifiers(isTypeExport)); |
|
node.source = null; |
|
node.declaration = null; |
|
|
|
if (this.hasPlugin("importAssertions")) { |
|
node.assertions = []; |
|
} |
|
|
|
return true; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
maybeParseExportDeclaration(node) { |
|
if (this.shouldParseExportDeclaration()) { |
|
node.specifiers = []; |
|
node.source = null; |
|
|
|
if (this.hasPlugin("importAssertions")) { |
|
node.assertions = []; |
|
} |
|
|
|
node.declaration = this.parseExportDeclaration(node); |
|
return true; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
isAsyncFunction() { |
|
if (!this.isContextual(95)) return false; |
|
const next = this.nextTokenStart(); |
|
return !lineBreak.test(this.input.slice(this.state.pos, next)) && this.isUnparsedContextual(next, "function"); |
|
} |
|
|
|
parseExportDefaultExpression() { |
|
const expr = this.startNode(); |
|
const isAsync = this.isAsyncFunction(); |
|
|
|
if (this.match(68) || isAsync) { |
|
this.next(); |
|
|
|
if (isAsync) { |
|
this.next(); |
|
} |
|
|
|
return this.parseFunction(expr, FUNC_STATEMENT | FUNC_NULLABLE_ID, isAsync); |
|
} |
|
|
|
if (this.match(80)) { |
|
return this.parseClass(expr, true, true); |
|
} |
|
|
|
if (this.match(26)) { |
|
if (this.hasPlugin("decorators") && this.getPluginOption("decorators", "decoratorsBeforeExport")) { |
|
this.raise(Errors.DecoratorBeforeExport, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
|
|
this.parseDecorators(false); |
|
return this.parseClass(expr, true, true); |
|
} |
|
|
|
if (this.match(75) || this.match(74) || this.isLet()) { |
|
throw this.raise(Errors.UnsupportedDefaultExport, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
|
|
const res = this.parseMaybeAssignAllowIn(); |
|
this.semicolon(); |
|
return res; |
|
} |
|
|
|
parseExportDeclaration(node) { |
|
return this.parseStatement(null); |
|
} |
|
|
|
isExportDefaultSpecifier() { |
|
const { |
|
type |
|
} = this.state; |
|
|
|
if (tokenIsIdentifier(type)) { |
|
if (type === 95 && !this.state.containsEsc || type === 99) { |
|
return false; |
|
} |
|
|
|
if ((type === 126 || type === 125) && !this.state.containsEsc) { |
|
const { |
|
type: nextType |
|
} = this.lookahead(); |
|
|
|
if (tokenIsIdentifier(nextType) && nextType !== 97 || nextType === 5) { |
|
this.expectOnePlugin(["flow", "typescript"]); |
|
return false; |
|
} |
|
} |
|
} else if (!this.match(65)) { |
|
return false; |
|
} |
|
|
|
const next = this.nextTokenStart(); |
|
const hasFrom = this.isUnparsedContextual(next, "from"); |
|
|
|
if (this.input.charCodeAt(next) === 44 || tokenIsIdentifier(this.state.type) && hasFrom) { |
|
return true; |
|
} |
|
|
|
if (this.match(65) && hasFrom) { |
|
const nextAfterFrom = this.input.charCodeAt(this.nextTokenStartSince(next + 4)); |
|
return nextAfterFrom === 34 || nextAfterFrom === 39; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
parseExportFrom(node, expect) { |
|
if (this.eatContextual(97)) { |
|
node.source = this.parseImportSource(); |
|
this.checkExport(node); |
|
const assertions = this.maybeParseImportAssertions(); |
|
|
|
if (assertions) { |
|
node.assertions = assertions; |
|
this.checkJSONModuleImport(node); |
|
} |
|
} else if (expect) { |
|
this.unexpected(); |
|
} |
|
|
|
this.semicolon(); |
|
} |
|
|
|
shouldParseExportDeclaration() { |
|
const { |
|
type |
|
} = this.state; |
|
|
|
if (type === 26) { |
|
this.expectOnePlugin(["decorators", "decorators-legacy"]); |
|
|
|
if (this.hasPlugin("decorators")) { |
|
if (this.getPluginOption("decorators", "decoratorsBeforeExport")) { |
|
throw this.raise(Errors.DecoratorBeforeExport, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
|
|
return true; |
|
} |
|
} |
|
|
|
return type === 74 || type === 75 || type === 68 || type === 80 || this.isLet() || this.isAsyncFunction(); |
|
} |
|
|
|
checkExport(node, checkNames, isDefault, isFrom) { |
|
if (checkNames) { |
|
if (isDefault) { |
|
this.checkDuplicateExports(node, "default"); |
|
|
|
if (this.hasPlugin("exportDefaultFrom")) { |
|
var _declaration$extra; |
|
|
|
const declaration = node.declaration; |
|
|
|
if (declaration.type === "Identifier" && declaration.name === "from" && declaration.end - declaration.start === 4 && !((_declaration$extra = declaration.extra) != null && _declaration$extra.parenthesized)) { |
|
this.raise(Errors.ExportDefaultFromAsIdentifier, { |
|
at: declaration |
|
}); |
|
} |
|
} |
|
} else if (node.specifiers && node.specifiers.length) { |
|
for (const specifier of node.specifiers) { |
|
const { |
|
exported |
|
} = specifier; |
|
const exportName = exported.type === "Identifier" ? exported.name : exported.value; |
|
this.checkDuplicateExports(specifier, exportName); |
|
|
|
if (!isFrom && specifier.local) { |
|
const { |
|
local |
|
} = specifier; |
|
|
|
if (local.type !== "Identifier") { |
|
this.raise(Errors.ExportBindingIsString, { |
|
at: specifier, |
|
localName: local.value, |
|
exportName |
|
}); |
|
} else { |
|
this.checkReservedWord(local.name, local.loc.start, true, false); |
|
this.scope.checkLocalExport(local); |
|
} |
|
} |
|
} |
|
} else if (node.declaration) { |
|
if (node.declaration.type === "FunctionDeclaration" || node.declaration.type === "ClassDeclaration") { |
|
const id = node.declaration.id; |
|
if (!id) throw new Error("Assertion failure"); |
|
this.checkDuplicateExports(node, id.name); |
|
} else if (node.declaration.type === "VariableDeclaration") { |
|
for (const declaration of node.declaration.declarations) { |
|
this.checkDeclaration(declaration.id); |
|
} |
|
} |
|
} |
|
} |
|
|
|
const currentContextDecorators = this.state.decoratorStack[this.state.decoratorStack.length - 1]; |
|
|
|
if (currentContextDecorators.length) { |
|
throw this.raise(Errors.UnsupportedDecoratorExport, { |
|
at: node |
|
}); |
|
} |
|
} |
|
|
|
checkDeclaration(node) { |
|
if (node.type === "Identifier") { |
|
this.checkDuplicateExports(node, node.name); |
|
} else if (node.type === "ObjectPattern") { |
|
for (const prop of node.properties) { |
|
this.checkDeclaration(prop); |
|
} |
|
} else if (node.type === "ArrayPattern") { |
|
for (const elem of node.elements) { |
|
if (elem) { |
|
this.checkDeclaration(elem); |
|
} |
|
} |
|
} else if (node.type === "ObjectProperty") { |
|
this.checkDeclaration(node.value); |
|
} else if (node.type === "RestElement") { |
|
this.checkDeclaration(node.argument); |
|
} else if (node.type === "AssignmentPattern") { |
|
this.checkDeclaration(node.left); |
|
} |
|
} |
|
|
|
checkDuplicateExports(node, exportName) { |
|
if (this.exportedIdentifiers.has(exportName)) { |
|
if (exportName === "default") { |
|
this.raise(Errors.DuplicateDefaultExport, { |
|
at: node |
|
}); |
|
} else { |
|
this.raise(Errors.DuplicateExport, { |
|
at: node, |
|
exportName |
|
}); |
|
} |
|
} |
|
|
|
this.exportedIdentifiers.add(exportName); |
|
} |
|
|
|
parseExportSpecifiers(isInTypeExport) { |
|
const nodes = []; |
|
let first = true; |
|
this.expect(5); |
|
|
|
while (!this.eat(8)) { |
|
if (first) { |
|
first = false; |
|
} else { |
|
this.expect(12); |
|
if (this.eat(8)) break; |
|
} |
|
|
|
const isMaybeTypeOnly = this.isContextual(126); |
|
const isString = this.match(129); |
|
const node = this.startNode(); |
|
node.local = this.parseModuleExportName(); |
|
nodes.push(this.parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly)); |
|
} |
|
|
|
return nodes; |
|
} |
|
|
|
parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly) { |
|
if (this.eatContextual(93)) { |
|
node.exported = this.parseModuleExportName(); |
|
} else if (isString) { |
|
node.exported = cloneStringLiteral(node.local); |
|
} else if (!node.exported) { |
|
node.exported = cloneIdentifier(node.local); |
|
} |
|
|
|
return this.finishNode(node, "ExportSpecifier"); |
|
} |
|
|
|
parseModuleExportName() { |
|
if (this.match(129)) { |
|
const result = this.parseStringLiteral(this.state.value); |
|
const surrogate = result.value.match(loneSurrogate); |
|
|
|
if (surrogate) { |
|
this.raise(Errors.ModuleExportNameHasLoneSurrogate, { |
|
at: result, |
|
surrogateCharCode: surrogate[0].charCodeAt(0) |
|
}); |
|
} |
|
|
|
return result; |
|
} |
|
|
|
return this.parseIdentifier(true); |
|
} |
|
|
|
isJSONModuleImport(node) { |
|
if (node.assertions != null) { |
|
return node.assertions.some(({ |
|
key, |
|
value |
|
}) => { |
|
return value.value === "json" && (key.type === "Identifier" ? key.name === "type" : key.value === "type"); |
|
}); |
|
} |
|
|
|
return false; |
|
} |
|
|
|
checkJSONModuleImport(node) { |
|
if (this.isJSONModuleImport(node) && node.type !== "ExportAllDeclaration") { |
|
const { |
|
specifiers |
|
} = node; |
|
|
|
if (node.specifiers != null) { |
|
const nonDefaultNamedSpecifier = specifiers.find(specifier => { |
|
let imported; |
|
|
|
if (specifier.type === "ExportSpecifier") { |
|
imported = specifier.local; |
|
} else if (specifier.type === "ImportSpecifier") { |
|
imported = specifier.imported; |
|
} |
|
|
|
if (imported !== undefined) { |
|
return imported.type === "Identifier" ? imported.name !== "default" : imported.value !== "default"; |
|
} |
|
}); |
|
|
|
if (nonDefaultNamedSpecifier !== undefined) { |
|
this.raise(Errors.ImportJSONBindingNotDefault, { |
|
at: nonDefaultNamedSpecifier.loc.start |
|
}); |
|
} |
|
} |
|
} |
|
} |
|
|
|
parseImport(node) { |
|
node.specifiers = []; |
|
|
|
if (!this.match(129)) { |
|
const hasDefault = this.maybeParseDefaultImportSpecifier(node); |
|
const parseNext = !hasDefault || this.eat(12); |
|
const hasStar = parseNext && this.maybeParseStarImportSpecifier(node); |
|
if (parseNext && !hasStar) this.parseNamedImportSpecifiers(node); |
|
this.expectContextual(97); |
|
} |
|
|
|
node.source = this.parseImportSource(); |
|
const assertions = this.maybeParseImportAssertions(); |
|
|
|
if (assertions) { |
|
node.assertions = assertions; |
|
} else { |
|
const attributes = this.maybeParseModuleAttributes(); |
|
|
|
if (attributes) { |
|
node.attributes = attributes; |
|
} |
|
} |
|
|
|
this.checkJSONModuleImport(node); |
|
this.semicolon(); |
|
return this.finishNode(node, "ImportDeclaration"); |
|
} |
|
|
|
parseImportSource() { |
|
if (!this.match(129)) this.unexpected(); |
|
return this.parseExprAtom(); |
|
} |
|
|
|
shouldParseDefaultImport(node) { |
|
return tokenIsIdentifier(this.state.type); |
|
} |
|
|
|
parseImportSpecifierLocal(node, specifier, type) { |
|
specifier.local = this.parseIdentifier(); |
|
node.specifiers.push(this.finishImportSpecifier(specifier, type)); |
|
} |
|
|
|
finishImportSpecifier(specifier, type) { |
|
this.checkLVal(specifier.local, { |
|
in: specifier, |
|
binding: BIND_LEXICAL |
|
}); |
|
return this.finishNode(specifier, type); |
|
} |
|
|
|
parseAssertEntries() { |
|
const attrs = []; |
|
const attrNames = new Set(); |
|
|
|
do { |
|
if (this.match(8)) { |
|
break; |
|
} |
|
|
|
const node = this.startNode(); |
|
const keyName = this.state.value; |
|
|
|
if (attrNames.has(keyName)) { |
|
this.raise(Errors.ModuleAttributesWithDuplicateKeys, { |
|
at: this.state.startLoc, |
|
key: keyName |
|
}); |
|
} |
|
|
|
attrNames.add(keyName); |
|
|
|
if (this.match(129)) { |
|
node.key = this.parseStringLiteral(keyName); |
|
} else { |
|
node.key = this.parseIdentifier(true); |
|
} |
|
|
|
this.expect(14); |
|
|
|
if (!this.match(129)) { |
|
throw this.raise(Errors.ModuleAttributeInvalidValue, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
|
|
node.value = this.parseStringLiteral(this.state.value); |
|
this.finishNode(node, "ImportAttribute"); |
|
attrs.push(node); |
|
} while (this.eat(12)); |
|
|
|
return attrs; |
|
} |
|
|
|
maybeParseModuleAttributes() { |
|
if (this.match(76) && !this.hasPrecedingLineBreak()) { |
|
this.expectPlugin("moduleAttributes"); |
|
this.next(); |
|
} else { |
|
if (this.hasPlugin("moduleAttributes")) return []; |
|
return null; |
|
} |
|
|
|
const attrs = []; |
|
const attributes = new Set(); |
|
|
|
do { |
|
const node = this.startNode(); |
|
node.key = this.parseIdentifier(true); |
|
|
|
if (node.key.name !== "type") { |
|
this.raise(Errors.ModuleAttributeDifferentFromType, { |
|
at: node.key |
|
}); |
|
} |
|
|
|
if (attributes.has(node.key.name)) { |
|
this.raise(Errors.ModuleAttributesWithDuplicateKeys, { |
|
at: node.key, |
|
key: node.key.name |
|
}); |
|
} |
|
|
|
attributes.add(node.key.name); |
|
this.expect(14); |
|
|
|
if (!this.match(129)) { |
|
throw this.raise(Errors.ModuleAttributeInvalidValue, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
|
|
node.value = this.parseStringLiteral(this.state.value); |
|
this.finishNode(node, "ImportAttribute"); |
|
attrs.push(node); |
|
} while (this.eat(12)); |
|
|
|
return attrs; |
|
} |
|
|
|
maybeParseImportAssertions() { |
|
if (this.isContextual(94) && !this.hasPrecedingLineBreak()) { |
|
this.expectPlugin("importAssertions"); |
|
this.next(); |
|
} else { |
|
if (this.hasPlugin("importAssertions")) return []; |
|
return null; |
|
} |
|
|
|
this.eat(5); |
|
const attrs = this.parseAssertEntries(); |
|
this.eat(8); |
|
return attrs; |
|
} |
|
|
|
maybeParseDefaultImportSpecifier(node) { |
|
if (this.shouldParseDefaultImport(node)) { |
|
this.parseImportSpecifierLocal(node, this.startNode(), "ImportDefaultSpecifier"); |
|
return true; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
maybeParseStarImportSpecifier(node) { |
|
if (this.match(55)) { |
|
const specifier = this.startNode(); |
|
this.next(); |
|
this.expectContextual(93); |
|
this.parseImportSpecifierLocal(node, specifier, "ImportNamespaceSpecifier"); |
|
return true; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
parseNamedImportSpecifiers(node) { |
|
let first = true; |
|
this.expect(5); |
|
|
|
while (!this.eat(8)) { |
|
if (first) { |
|
first = false; |
|
} else { |
|
if (this.eat(14)) { |
|
throw this.raise(Errors.DestructureNamedImport, { |
|
at: this.state.startLoc |
|
}); |
|
} |
|
|
|
this.expect(12); |
|
if (this.eat(8)) break; |
|
} |
|
|
|
const specifier = this.startNode(); |
|
const importedIsString = this.match(129); |
|
const isMaybeTypeOnly = this.isContextual(126); |
|
specifier.imported = this.parseModuleExportName(); |
|
const importSpecifier = this.parseImportSpecifier(specifier, importedIsString, node.importKind === "type" || node.importKind === "typeof", isMaybeTypeOnly); |
|
node.specifiers.push(importSpecifier); |
|
} |
|
} |
|
|
|
parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly) { |
|
if (this.eatContextual(93)) { |
|
specifier.local = this.parseIdentifier(); |
|
} else { |
|
const { |
|
imported |
|
} = specifier; |
|
|
|
if (importedIsString) { |
|
throw this.raise(Errors.ImportBindingIsString, { |
|
at: specifier, |
|
importName: imported.value |
|
}); |
|
} |
|
|
|
this.checkReservedWord(imported.name, specifier.loc.start, true, true); |
|
|
|
if (!specifier.local) { |
|
specifier.local = cloneIdentifier(imported); |
|
} |
|
} |
|
|
|
return this.finishImportSpecifier(specifier, "ImportSpecifier"); |
|
} |
|
|
|
isThisParam(param) { |
|
return param.type === "Identifier" && param.name === "this"; |
|
} |
|
|
|
} |
|
|
|
class Parser extends StatementParser { |
|
constructor(options, input) { |
|
options = getOptions(options); |
|
super(options, input); |
|
this.options = options; |
|
this.initializeScopes(); |
|
this.plugins = pluginsMap(this.options.plugins); |
|
this.filename = options.sourceFilename; |
|
} |
|
|
|
getScopeHandler() { |
|
return ScopeHandler; |
|
} |
|
|
|
parse() { |
|
this.enterInitialScopes(); |
|
const file = this.startNode(); |
|
const program = this.startNode(); |
|
this.nextToken(); |
|
file.errors = null; |
|
this.parseTopLevel(file, program); |
|
file.errors = this.state.errors; |
|
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") { |
|
options = Object.assign({}, options); |
|
|
|
try { |
|
options.sourceType = "module"; |
|
const parser = getParser(options, input); |
|
const ast = parser.parse(); |
|
|
|
if (parser.sawUnambiguousESM) { |
|
return ast; |
|
} |
|
|
|
if (parser.ambiguousScriptDifferentAst) { |
|
try { |
|
options.sourceType = "script"; |
|
return getParser(options, input).parse(); |
|
} catch (_unused) {} |
|
} else { |
|
ast.program.sourceType = "script"; |
|
} |
|
|
|
return ast; |
|
} catch (moduleError) { |
|
try { |
|
options.sourceType = "script"; |
|
return getParser(options, input).parse(); |
|
} catch (_unused2) {} |
|
|
|
throw moduleError; |
|
} |
|
} else { |
|
return getParser(options, input).parse(); |
|
} |
|
} |
|
function parseExpression(input, options) { |
|
const parser = getParser(options, input); |
|
|
|
if (parser.options.strictMode) { |
|
parser.state.strict = true; |
|
} |
|
|
|
return parser.getExpression(); |
|
} |
|
|
|
function generateExportedTokenTypes(internalTokenTypes) { |
|
const tokenTypes = {}; |
|
|
|
for (const typeName of Object.keys(internalTokenTypes)) { |
|
tokenTypes[typeName] = getExportedToken(internalTokenTypes[typeName]); |
|
} |
|
|
|
return tokenTypes; |
|
} |
|
|
|
const tokTypes = generateExportedTokenTypes(tt); |
|
|
|
function getParser(options, input) { |
|
let cls = Parser; |
|
|
|
if (options != null && options.plugins) { |
|
validatePlugins(options.plugins); |
|
cls = getParserClass(options.plugins); |
|
} |
|
|
|
return new cls(options, input); |
|
} |
|
|
|
const parserClassCache = {}; |
|
|
|
function getParserClass(pluginsFromOptions) { |
|
const pluginList = mixinPluginNames.filter(name => hasPlugin(pluginsFromOptions, name)); |
|
const key = pluginList.join("/"); |
|
let cls = parserClassCache[key]; |
|
|
|
if (!cls) { |
|
cls = Parser; |
|
|
|
for (const plugin of pluginList) { |
|
cls = mixinPlugins[plugin](cls); |
|
} |
|
|
|
parserClassCache[key] = cls; |
|
} |
|
|
|
return cls; |
|
} |
|
|
|
exports.parse = parse; |
|
exports.parseExpression = parseExpression; |
|
exports.tokTypes = tokTypes; |
|
//# sourceMappingURL=index.js.map
|
|
|