update socials section
This commit is contained in:
349
node_modules/espree/lib/espree.js
generated
vendored
Normal file
349
node_modules/espree/lib/espree.js
generated
vendored
Normal file
@ -0,0 +1,349 @@
|
||||
/* eslint no-param-reassign: 0 -- stylistic choice */
|
||||
|
||||
import TokenTranslator from "./token-translator.js";
|
||||
import { normalizeOptions } from "./options.js";
|
||||
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
export default () => 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;
|
||||
}
|
||||
};
|
||||
};
|
||||
Reference in New Issue
Block a user