'use strict'; Object.defineProperty(exports, '__esModule', { value: true }); var acorn = require('acorn'); var jsx = require('acorn-jsx'); var visitorKeys = require('eslint-visitor-keys'); function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; } function _interopNamespace(e) { if (e && e.__esModule) return e; var n = Object.create(null); if (e) { Object.keys(e).forEach(function (k) { if (k !== 'default') { var d = Object.getOwnPropertyDescriptor(e, k); Object.defineProperty(n, k, d.get ? d : { enumerable: true, get: function () { return e[k]; } }); } }); } n["default"] = e; return Object.freeze(n); } var acorn__namespace = /*#__PURE__*/_interopNamespace(acorn); var jsx__default = /*#__PURE__*/_interopDefaultLegacy(jsx); var visitorKeys__namespace = /*#__PURE__*/_interopNamespace(visitorKeys); /** * @fileoverview Translates tokens between Acorn format and Esprima format. * @author Nicholas C. Zakas */ //------------------------------------------------------------------------------ // Requirements //------------------------------------------------------------------------------ // none! //------------------------------------------------------------------------------ // Private //------------------------------------------------------------------------------ // Esprima Token Types const Token = { Boolean: "Boolean", EOF: "", Identifier: "Identifier", PrivateIdentifier: "PrivateIdentifier", Keyword: "Keyword", Null: "Null", Numeric: "Numeric", Punctuator: "Punctuator", String: "String", RegularExpression: "RegularExpression", Template: "Template", JSXIdentifier: "JSXIdentifier", JSXText: "JSXText" }; /** * Converts part of a template into an Esprima token. * @param {AcornToken[]} tokens The Acorn tokens representing the template. * @param {string} code The source code. * @returns {EsprimaToken} The Esprima equivalent of the template token. * @private */ function convertTemplatePart(tokens, code) { const firstToken = tokens[0], lastTemplateToken = tokens[tokens.length - 1]; const token = { type: Token.Template, value: code.slice(firstToken.start, lastTemplateToken.end) }; if (firstToken.loc) { token.loc = { start: firstToken.loc.start, end: lastTemplateToken.loc.end }; } if (firstToken.range) { token.start = firstToken.range[0]; token.end = lastTemplateToken.range[1]; token.range = [token.start, token.end]; } return token; } /** * Contains logic to translate Acorn tokens into Esprima tokens. * @param {Object} acornTokTypes The Acorn token types. * @param {string} code The source code Acorn is parsing. This is necessary * to correct the "value" property of some tokens. * @constructor */ function TokenTranslator(acornTokTypes, code) { // token types this._acornTokTypes = acornTokTypes; // token buffer for templates this._tokens = []; // track the last curly brace this._curlyBrace = null; // the source code this._code = code; } TokenTranslator.prototype = { constructor: TokenTranslator, /** * Translates a single Esprima token to a single Acorn token. This may be * inaccurate due to how templates are handled differently in Esprima and * Acorn, but should be accurate for all other tokens. * @param {AcornToken} token The Acorn token to translate. * @param {Object} extra Espree extra object. * @returns {EsprimaToken} The Esprima version of the token. */ translate(token, extra) { const type = token.type, tt = this._acornTokTypes; if (type === tt.name) { token.type = Token.Identifier; // TODO: See if this is an Acorn bug if (token.value === "static") { token.type = Token.Keyword; } if (extra.ecmaVersion > 5 && (token.value === "yield" || token.value === "let")) { token.type = Token.Keyword; } } else if (type === tt.privateId) { token.type = Token.PrivateIdentifier; } else if (type === tt.semi || type === tt.comma || type === tt.parenL || type === tt.parenR || type === tt.braceL || type === tt.braceR || type === tt.dot || type === tt.bracketL || type === tt.colon || type === tt.question || type === tt.bracketR || type === tt.ellipsis || type === tt.arrow || type === tt.jsxTagStart || type === tt.incDec || type === tt.starstar || type === tt.jsxTagEnd || type === tt.prefix || type === tt.questionDot || (type.binop && !type.keyword) || type.isAssign) { token.type = Token.Punctuator; token.value = this._code.slice(token.start, token.end); } else if (type === tt.jsxName) { token.type = Token.JSXIdentifier; } else if (type.label === "jsxText" || type === tt.jsxAttrValueToken) { token.type = Token.JSXText; } else if (type.keyword) { if (type.keyword === "true" || type.keyword === "false") { token.type = Token.Boolean; } else if (type.keyword === "null") { token.type = Token.Null; } else { token.type = Token.Keyword; } } else if (type === tt.num) { token.type = Token.Numeric; token.value = this._code.slice(token.start, token.end); } else if (type === tt.string) { if (extra.jsxAttrValueToken) { extra.jsxAttrValueToken = false; token.type = Token.JSXText; } else { token.type = Token.String; } token.value = this._code.slice(token.start, token.end); } else if (type === tt.regexp) { token.type = Token.RegularExpression; const value = token.value; token.regex = { flags: value.flags, pattern: value.pattern }; token.value = `/${value.pattern}/${value.flags}`; } return token; }, /** * Function to call during Acorn's onToken handler. * @param {AcornToken} token The Acorn token. * @param {Object} extra The Espree extra object. * @returns {void} */ onToken(token, extra) { const tt = this._acornTokTypes, tokens = extra.tokens, templateTokens = this._tokens; /** * Flushes the buffered template tokens and resets the template * tracking. * @returns {void} * @private */ const translateTemplateTokens = () => { tokens.push(convertTemplatePart(this._tokens, this._code)); this._tokens = []; }; if (token.type === tt.eof) { // might be one last curlyBrace if (this._curlyBrace) { tokens.push(this.translate(this._curlyBrace, extra)); } return; } if (token.type === tt.backQuote) { // if there's already a curly, it's not part of the template if (this._curlyBrace) { tokens.push(this.translate(this._curlyBrace, extra)); this._curlyBrace = null; } templateTokens.push(token); // it's the end if (templateTokens.length > 1) { translateTemplateTokens(); } return; } if (token.type === tt.dollarBraceL) { templateTokens.push(token); translateTemplateTokens(); return; } if (token.type === tt.braceR) { // if there's already a curly, it's not part of the template if (this._curlyBrace) { tokens.push(this.translate(this._curlyBrace, extra)); } // store new curly for later this._curlyBrace = token; return; } if (token.type === tt.template || token.type === tt.invalidTemplate) { if (this._curlyBrace) { templateTokens.push(this._curlyBrace); this._curlyBrace = null; } templateTokens.push(token); return; } if (this._curlyBrace) { tokens.push(this.translate(this._curlyBrace, extra)); this._curlyBrace = null; } tokens.push(this.translate(token, extra)); } }; /** * @fileoverview A collection of methods for processing Espree's options. * @author Kai Cataldo */ //------------------------------------------------------------------------------ // Helpers //------------------------------------------------------------------------------ const SUPPORTED_VERSIONS = [ 3, 5, 6, // 2015 7, // 2016 8, // 2017 9, // 2018 10, // 2019 11, // 2020 12, // 2021 13, // 2022 14, // 2023 15 // 2024 ]; /** * Get the latest ECMAScript version supported by Espree. * @returns {number} The latest ECMAScript version. */ function getLatestEcmaVersion() { return SUPPORTED_VERSIONS[SUPPORTED_VERSIONS.length - 1]; } /** * Get the list of ECMAScript versions supported by Espree. * @returns {number[]} An array containing the supported ECMAScript versions. */ function getSupportedEcmaVersions() { return [...SUPPORTED_VERSIONS]; } /** * Normalize ECMAScript version from the initial config * @param {(number|"latest")} ecmaVersion ECMAScript version from the initial config * @throws {Error} throws an error if the ecmaVersion is invalid. * @returns {number} normalized ECMAScript version */ function normalizeEcmaVersion(ecmaVersion = 5) { let version = ecmaVersion === "latest" ? getLatestEcmaVersion() : ecmaVersion; if (typeof version !== "number") { throw new Error(`ecmaVersion must be a number or "latest". Received value of type ${typeof ecmaVersion} instead.`); } // Calculate ECMAScript edition number from official year version starting with // ES2015, which corresponds with ES6 (or a difference of 2009). if (version >= 2015) { version -= 2009; } if (!SUPPORTED_VERSIONS.includes(version)) { throw new Error("Invalid ecmaVersion."); } return version; } /** * Normalize sourceType from the initial config * @param {string} sourceType to normalize * @throws {Error} throw an error if sourceType is invalid * @returns {string} normalized sourceType */ function normalizeSourceType(sourceType = "script") { if (sourceType === "script" || sourceType === "module") { return sourceType; } if (sourceType === "commonjs") { return "script"; } throw new Error("Invalid sourceType."); } /** * Normalize parserOptions * @param {Object} options the parser options to normalize * @throws {Error} throw an error if found invalid option. * @returns {Object} normalized options */ function normalizeOptions(options) { const ecmaVersion = normalizeEcmaVersion(options.ecmaVersion); const sourceType = normalizeSourceType(options.sourceType); const ranges = options.range === true; const locations = options.loc === true; if (ecmaVersion !== 3 && options.allowReserved) { // a value of `false` is intentionally allowed here, so a shared config can overwrite it when needed throw new Error("`allowReserved` is only supported when ecmaVersion is 3"); } if (typeof options.allowReserved !== "undefined" && typeof options.allowReserved !== "boolean") { throw new Error("`allowReserved`, when present, must be `true` or `false`"); } const allowReserved = ecmaVersion === 3 ? (options.allowReserved || "never") : false; const ecmaFeatures = options.ecmaFeatures || {}; const allowReturnOutsideFunction = options.sourceType === "commonjs" || Boolean(ecmaFeatures.globalReturn); if (sourceType === "module" && ecmaVersion < 6) { throw new Error("sourceType 'module' is not supported when ecmaVersion < 2015. Consider adding `{ ecmaVersion: 2015 }` to the parser options."); } return Object.assign({}, options, { ecmaVersion, sourceType, ranges, locations, allowReserved, allowReturnOutsideFunction }); } /* eslint no-param-reassign: 0 -- stylistic choice */ const STATE = Symbol("espree's internal state"); const ESPRIMA_FINISH_NODE = Symbol("espree's esprimaFinishNode"); /** * Converts an Acorn comment to a Esprima comment. * @param {boolean} block True if it's a block comment, false if not. * @param {string} text The text of the comment. * @param {int} start The index at which the comment starts. * @param {int} end The index at which the comment ends. * @param {Location} startLoc The location at which the comment starts. * @param {Location} endLoc The location at which the comment ends. * @param {string} code The source code being parsed. * @returns {Object} The comment object. * @private */ function convertAcornCommentToEsprimaComment(block, text, start, end, startLoc, endLoc, code) { let type; if (block) { type = "Block"; } else if (code.slice(start, start + 2) === "#!") { type = "Hashbang"; } else { type = "Line"; } const comment = { type, value: text }; if (typeof start === "number") { comment.start = start; comment.end = end; comment.range = [start, end]; } if (typeof startLoc === "object") { comment.loc = { start: startLoc, end: endLoc }; } return comment; } var espree = () => Parser => { const tokTypes = Object.assign({}, Parser.acorn.tokTypes); if (Parser.acornJsx) { Object.assign(tokTypes, Parser.acornJsx.tokTypes); } return class Espree extends Parser { constructor(opts, code) { if (typeof opts !== "object" || opts === null) { opts = {}; } if (typeof code !== "string" && !(code instanceof String)) { code = String(code); } // save original source type in case of commonjs const originalSourceType = opts.sourceType; const options = normalizeOptions(opts); const ecmaFeatures = options.ecmaFeatures || {}; const tokenTranslator = options.tokens === true ? new TokenTranslator(tokTypes, code) : null; /* * Data that is unique to Espree and is not represented internally * in Acorn. * * For ES2023 hashbangs, Espree will call `onComment()` during the * constructor, so we must define state before having access to * `this`. */ const state = { originalSourceType: originalSourceType || options.sourceType, tokens: tokenTranslator ? [] : null, comments: options.comment === true ? [] : null, impliedStrict: ecmaFeatures.impliedStrict === true && options.ecmaVersion >= 5, ecmaVersion: options.ecmaVersion, jsxAttrValueToken: false, lastToken: null, templateElements: [] }; // Initialize acorn parser. super({ // do not use spread, because we don't want to pass any unknown options to acorn ecmaVersion: options.ecmaVersion, sourceType: options.sourceType, ranges: options.ranges, locations: options.locations, allowReserved: options.allowReserved, // Truthy value is true for backward compatibility. allowReturnOutsideFunction: options.allowReturnOutsideFunction, // Collect tokens onToken(token) { if (tokenTranslator) { // Use `tokens`, `ecmaVersion`, and `jsxAttrValueToken` in the state. tokenTranslator.onToken(token, state); } if (token.type !== tokTypes.eof) { state.lastToken = token; } }, // Collect comments onComment(block, text, start, end, startLoc, endLoc) { if (state.comments) { const comment = convertAcornCommentToEsprimaComment(block, text, start, end, startLoc, endLoc, code); state.comments.push(comment); } } }, code); /* * We put all of this data into a symbol property as a way to avoid * potential naming conflicts with future versions of Acorn. */ this[STATE] = state; } tokenize() { do { this.next(); } while (this.type !== tokTypes.eof); // Consume the final eof token this.next(); const extra = this[STATE]; const tokens = extra.tokens; if (extra.comments) { tokens.comments = extra.comments; } return tokens; } finishNode(...args) { const result = super.finishNode(...args); return this[ESPRIMA_FINISH_NODE](result); } finishNodeAt(...args) { const result = super.finishNodeAt(...args); return this[ESPRIMA_FINISH_NODE](result); } parse() { const extra = this[STATE]; const program = super.parse(); program.sourceType = extra.originalSourceType; if (extra.comments) { program.comments = extra.comments; } if (extra.tokens) { program.tokens = extra.tokens; } /* * Adjust opening and closing position of program to match Esprima. * Acorn always starts programs at range 0 whereas Esprima starts at the * first AST node's start (the only real difference is when there's leading * whitespace or leading comments). Acorn also counts trailing whitespace * as part of the program whereas Esprima only counts up to the last token. */ if (program.body.length) { const [firstNode] = program.body; if (program.range) { program.range[0] = firstNode.range[0]; } if (program.loc) { program.loc.start = firstNode.loc.start; } program.start = firstNode.start; } if (extra.lastToken) { if (program.range) { program.range[1] = extra.lastToken.range[1]; } if (program.loc) { program.loc.end = extra.lastToken.loc.end; } program.end = extra.lastToken.end; } /* * https://github.com/eslint/espree/issues/349 * Ensure that template elements have correct range information. * This is one location where Acorn produces a different value * for its start and end properties vs. the values present in the * range property. In order to avoid confusion, we set the start * and end properties to the values that are present in range. * This is done here, instead of in finishNode(), because Acorn * uses the values of start and end internally while parsing, making * it dangerous to change those values while parsing is ongoing. * By waiting until the end of parsing, we can safely change these * values without affect any other part of the process. */ this[STATE].templateElements.forEach(templateElement => { const startOffset = -1; const endOffset = templateElement.tail ? 1 : 2; templateElement.start += startOffset; templateElement.end += endOffset; if (templateElement.range) { templateElement.range[0] += startOffset; templateElement.range[1] += endOffset; } if (templateElement.loc) { templateElement.loc.start.column += startOffset; templateElement.loc.end.column += endOffset; } }); return program; } parseTopLevel(node) { if (this[STATE].impliedStrict) { this.strict = true; } return super.parseTopLevel(node); } /** * Overwrites the default raise method to throw Esprima-style errors. * @param {int} pos The position of the error. * @param {string} message The error message. * @throws {SyntaxError} A syntax error. * @returns {void} */ raise(pos, message) { const loc = Parser.acorn.getLineInfo(this.input, pos); const err = new SyntaxError(message); err.index = pos; err.lineNumber = loc.line; err.column = loc.column + 1; // acorn uses 0-based columns throw err; } /** * Overwrites the default raise method to throw Esprima-style errors. * @param {int} pos The position of the error. * @param {string} message The error message. * @throws {SyntaxError} A syntax error. * @returns {void} */ raiseRecoverable(pos, message) { this.raise(pos, message); } /** * Overwrites the default unexpected method to throw Esprima-style errors. * @param {int} pos The position of the error. * @throws {SyntaxError} A syntax error. * @returns {void} */ unexpected(pos) { let message = "Unexpected token"; if (pos !== null && pos !== void 0) { this.pos = pos; if (this.options.locations) { while (this.pos < this.lineStart) { this.lineStart = this.input.lastIndexOf("\n", this.lineStart - 2) + 1; --this.curLine; } } this.nextToken(); } if (this.end > this.start) { message += ` ${this.input.slice(this.start, this.end)}`; } this.raise(this.start, message); } /* * Esprima-FB represents JSX strings as tokens called "JSXText", but Acorn-JSX * uses regular tt.string without any distinction between this and regular JS * strings. As such, we intercept an attempt to read a JSX string and set a flag * on extra so that when tokens are converted, the next token will be switched * to JSXText via onToken. */ jsx_readString(quote) { // eslint-disable-line camelcase -- required by API const result = super.jsx_readString(quote); if (this.type === tokTypes.string) { this[STATE].jsxAttrValueToken = true; } return result; } /** * Performs last-minute Esprima-specific compatibility checks and fixes. * @param {ASTNode} result The node to check. * @returns {ASTNode} The finished node. */ [ESPRIMA_FINISH_NODE](result) { // Acorn doesn't count the opening and closing backticks as part of templates // so we have to adjust ranges/locations appropriately. if (result.type === "TemplateElement") { // save template element references to fix start/end later this[STATE].templateElements.push(result); } if (result.type.includes("Function") && !result.generator) { result.generator = false; } return result; } }; }; const version$1 = "9.6.1"; /* eslint-disable jsdoc/no-multi-asterisks -- needed to preserve original formatting of licences */ // To initialize lazily. const parsers = { _regular: null, _jsx: null, get regular() { if (this._regular === null) { this._regular = acorn__namespace.Parser.extend(espree()); } return this._regular; }, get jsx() { if (this._jsx === null) { this._jsx = acorn__namespace.Parser.extend(jsx__default["default"](), espree()); } return this._jsx; }, get(options) { const useJsx = Boolean( options && options.ecmaFeatures && options.ecmaFeatures.jsx ); return useJsx ? this.jsx : this.regular; } }; //------------------------------------------------------------------------------ // Tokenizer //------------------------------------------------------------------------------ /** * Tokenizes the given code. * @param {string} code The code to tokenize. * @param {Object} options Options defining how to tokenize. * @returns {Token[]} An array of tokens. * @throws {SyntaxError} If the input code is invalid. * @private */ function tokenize(code, options) { const Parser = parsers.get(options); // Ensure to collect tokens. if (!options || options.tokens !== true) { options = Object.assign({}, options, { tokens: true }); // eslint-disable-line no-param-reassign -- stylistic choice } return new Parser(options, code).tokenize(); } //------------------------------------------------------------------------------ // Parser //------------------------------------------------------------------------------ /** * Parses the given code. * @param {string} code The code to tokenize. * @param {Object} options Options defining how to tokenize. * @returns {ASTNode} The "Program" AST node. * @throws {SyntaxError} If the input code is invalid. */ function parse(code, options) { const Parser = parsers.get(options); return new Parser(options, code).parse(); } //------------------------------------------------------------------------------ // Public //------------------------------------------------------------------------------ const version = version$1; const name = "espree"; /* istanbul ignore next */ const VisitorKeys = (function() { return visitorKeys__namespace.KEYS; }()); // Derive node types from VisitorKeys /* istanbul ignore next */ const Syntax = (function() { let key, types = {}; if (typeof Object.create === "function") { types = Object.create(null); } for (key in VisitorKeys) { if (Object.hasOwnProperty.call(VisitorKeys, key)) { types[key] = key; } } if (typeof Object.freeze === "function") { Object.freeze(types); } return types; }()); const latestEcmaVersion = getLatestEcmaVersion(); const supportedEcmaVersions = getSupportedEcmaVersions(); exports.Syntax = Syntax; exports.VisitorKeys = VisitorKeys; exports.latestEcmaVersion = latestEcmaVersion; exports.name = name; exports.parse = parse; exports.supportedEcmaVersions = supportedEcmaVersions; exports.tokenize = tokenize; exports.version = version;