add CI pipeline with lint, test, build

node_modules/espree/lib/espree.js

@@ -0,0 +1,493 @@
+/* eslint no-param-reassign: 0 -- stylistic choice */
+
+import TokenTranslator from "./token-translator.js";
+import { normalizeOptions } from "./options.js";
+
+/**
+ * @import {
+ *   CommentType,
+ *   EspreeParserCtor,
+ *   EsprimaNode,
+ *   AcornJsxParserCtorEnhanced,
+ *   TokTypes
+ * } from "./types.js";
+ * @import {
+ *   Options,
+ *   EspreeToken as EsprimaToken,
+ *   EspreeTokens as EsprimaTokens,
+ *   EspreeComment as EsprimaComment
+ * } from "../espree.js";
+ * @import { NormalizedEcmaVersion } from "./options.js";
+ * @import * as acorn from "acorn";
+ */
+
+/**
+ * @typedef {{
+ *   originalSourceType: "script" | "module" | "commonjs" | undefined
+ *   tokens: EsprimaToken[] | null,
+ *   comments: EsprimaComment[] | null,
+ *   impliedStrict: boolean,
+ *   ecmaVersion: NormalizedEcmaVersion,
+ *   jsxAttrValueToken: boolean,
+ *   lastToken: acorn.Token | null,
+ *   templateElements: acorn.TemplateElement[]
+ * }} State
+ */
+
+/**
+ * @typedef {{
+ *   sourceType?: "script"|"module"|"commonjs";
+ *   comments?: EsprimaComment[];
+ *   tokens?: EsprimaToken[];
+ *   body: acorn.Node[];
+ * } & acorn.Program} EsprimaProgramNode
+ */
+
+// ----------------------------------------------------------------------------
+// Types exported from file
+// ----------------------------------------------------------------------------
+/**
+ * @typedef {{
+ *   index?: number;
+ *   lineNumber?: number;
+ *   column?: number;
+ * } & SyntaxError} EnhancedSyntaxError
+ */
+
+// We add `jsxAttrValueToken` ourselves.
+/**
+ * @typedef {{
+ *   jsxAttrValueToken?: acorn.TokenType;
+ * } & TokTypes} EnhancedTokTypes
+ */
+
+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 {number} start The index at which the comment starts.
+ * @param {number} end The index at which the comment ends.
+ * @param {acorn.Position | undefined} startLoc The location at which the comment starts.
+ * @param {acorn.Position | undefined} endLoc The location at which the comment ends.
+ * @param {string} code The source code being parsed.
+ * @returns {EsprimaComment} The comment object.
+ * @private
+ */
+function convertAcornCommentToEsprimaComment(
+	block,
+	text,
+	start,
+	end,
+	startLoc,
+	endLoc,
+	code,
+) {
+	/** @type {CommentType} */
+	let type;
+
+	if (block) {
+		type = "Block";
+	} else if (code.slice(start, start + 2) === "#!") {
+		type = "Hashbang";
+	} else {
+		type = "Line";
+	}
+
+	/**
+	 * @type {{
+	 *   type: CommentType,
+	 *   value: string,
+	 *   start?: number,
+	 *   end?: number,
+	 *   range?: [number, number],
+	 *   loc?: {
+	 *     start: acorn.Position | undefined,
+	 *     end: acorn.Position | undefined
+	 *   }
+	 * }}
+	 */
+	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;
+}
+
+// eslint-disable-next-line arrow-body-style -- For TS
+export default () => {
+	/**
+	 * Returns the Espree parser.
+	 * @param {AcornJsxParserCtorEnhanced} Parser The Acorn parser. The `acorn` property is missing from acorn's
+	 *   TypeScript but is present statically on the class.
+	 * @returns {EspreeParserCtor} The Espree Parser constructor.
+	 */
+	return Parser => {
+		const tokTypes = /** @type {EnhancedTokTypes} */ (
+			Object.assign({}, Parser.acorn.tokTypes)
+		);
+
+		if (Parser.acornJsx) {
+			Object.assign(tokTypes, Parser.acornJsx.tokTypes);
+		}
+
+		return class Espree extends Parser {
+			/**
+			 * @param {Options | null | undefined} opts The parser options
+			 * @param {string | object} code The code which will be converted to a string.
+			 */
+			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,
+
+								// @ts-expect-error Appears to be a TS bug since the type is indeed string|String
+								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`.
+				 * @type {State}
+				 */
+				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,
+
+									/**
+									 * @type {Omit<State, "tokens"> & {
+									 *   tokens: EsprimaToken[]
+									 * }}
+									 */
+									(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,
+
+										// @ts-expect-error Appears to be a TS bug
+										//   since the type is indeed string|String
+										code,
+									);
+
+								state.comments.push(comment);
+							}
+						},
+					},
+					// @ts-expect-error Appears to be a TS bug
+					//   since the type is indeed string|String
+					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;
+			}
+
+			/**
+			 * Returns Espree tokens.
+			 * @returns {EsprimaTokens} The Esprima-compatible tokens
+			 */
+			tokenize() {
+				do {
+					this.next();
+				} while (this.type !== tokTypes.eof);
+
+				// Consume the final eof token
+				this.next();
+
+				const extra = this[STATE];
+				const tokens = /** @type {EsprimaTokens} */ (extra.tokens);
+
+				if (extra.comments) {
+					tokens.comments = extra.comments;
+				}
+
+				return tokens;
+			}
+
+			/**
+			 * Calls parent.
+			 * @param {acorn.Node} node The node
+			 * @param {string} type The type
+			 * @returns {acorn.Node} The altered Node
+			 */
+			finishNode(node, type) {
+				const result = super.finishNode(node, type);
+
+				return this[ESPRIMA_FINISH_NODE](result);
+			}
+
+			/**
+			 * Calls parent.
+			 * @param {acorn.Node} node The node
+			 * @param {string} type The type
+			 * @param {number} pos The position
+			 * @param {acorn.Position} loc The location
+			 * @returns {acorn.Node} The altered Node
+			 */
+			finishNodeAt(node, type, pos, loc) {
+				const result = super.finishNodeAt(node, type, pos, loc);
+
+				return this[ESPRIMA_FINISH_NODE](result);
+			}
+
+			/**
+			 * Parses.
+			 * @returns {EsprimaProgramNode} The program Node
+			 */
+			parse() {
+				const extra = this[STATE];
+				const prog = super.parse();
+
+				const program = /** @type {EsprimaProgramNode} */ (prog);
+
+				// @ts-expect-error TS bug? We've already converted to `EsprimaProgramNode`
+				program.sourceType = extra.originalSourceType;
+
+				if (extra.comments) {
+					program.comments = extra.comments;
+				}
+				if (extra.tokens) {
+					program.tokens = extra.tokens;
+				}
+
+				/*
+				 * 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;
+			}
+
+			/**
+			 * Parses top level.
+			 * @param {acorn.Node} node AST Node
+			 * @returns {acorn.Node} The changed node
+			 */
+			parseTopLevel(node) {
+				if (this[STATE].impliedStrict) {
+					this.strict = true;
+				}
+				return super.parseTopLevel(node);
+			}
+
+			/**
+			 * Overwrites the default raise method to throw Esprima-style errors.
+			 * @param {number} pos The position of the error.
+			 * @param {string} message The error message.
+			 * @throws {EnhancedSyntaxError} A syntax error.
+			 * @returns {void}
+			 */
+			raise(pos, message) {
+				const loc = Parser.acorn.getLineInfo(this.input, pos);
+				const err = /** @type {EnhancedSyntaxError} */ (
+					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 {number} 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 {number} 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.
+			 * @param {number} quote A character code
+			 * @returns {void}
+			 */ // eslint-disable-next-line camelcase -- required by API
+			jsx_readString(quote) {
+				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 {acorn.Node} result The node to check.
+			 * @returns {EsprimaNode} 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(
+						/** @type {acorn.TemplateElement} */
+						(result),
+					);
+				}
+
+				if (
+					result.type.includes("Function") &&
+					!("generator" in result)
+				) {
+					/**
+					 * @type {acorn.FunctionDeclaration|acorn.FunctionExpression|
+					 *   acorn.ArrowFunctionExpression}
+					 */
+					(result).generator = false;
+				}
+
+				return result;
+			}
+		};
+	};
+};

node_modules/espree/lib/options.js

@@ -0,0 +1,176 @@
+/**
+ * @fileoverview A collection of methods for processing Espree's options.
+ * @author Kai Cataldo
+ */
+
+/**
+ * @import { EcmaVersion, Options } from "../espree.js";
+ */
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const SUPPORTED_VERSIONS = /** @type {const} */ ([
+	3,
+	5,
+	6, // 2015
+	7, // 2016
+	8, // 2017
+	9, // 2018
+	10, // 2019
+	11, // 2020
+	12, // 2021
+	13, // 2022
+	14, // 2023
+	15, // 2024
+	16, // 2025
+	17, // 2026
+]);
+
+/**
+ * @typedef {typeof SUPPORTED_VERSIONS[number]} NormalizedEcmaVersion
+ */
+
+const LATEST_ECMA_VERSION =
+	/* eslint-disable jsdoc/valid-types -- Bug */
+	/** @type {typeof SUPPORTED_VERSIONS extends readonly [...unknown[], infer L] ? L : never} */ (
+		SUPPORTED_VERSIONS.at(-1)
+		/* eslint-enable jsdoc/valid-types -- Bug */
+	);
+
+/**
+ * Get the latest ECMAScript version supported by Espree.
+ * @returns {typeof LATEST_ECMA_VERSION} The latest ECMAScript version.
+ */
+export function getLatestEcmaVersion() {
+	return LATEST_ECMA_VERSION;
+}
+
+/**
+ * Get the list of ECMAScript versions supported by Espree.
+ * @returns {[...typeof SUPPORTED_VERSIONS]} An array containing the supported ECMAScript versions.
+ */
+export function getSupportedEcmaVersions() {
+	return [...SUPPORTED_VERSIONS];
+}
+
+/**
+ * Normalize ECMAScript version from the initial config
+ * @param {EcmaVersion} ecmaVersion ECMAScript version from the initial config
+ * @throws {Error} throws an error if the ecmaVersion is invalid.
+ * @returns {NormalizedEcmaVersion} 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(
+			/** @type {NormalizedEcmaVersion} */
+			(version),
+		)
+	) {
+		throw new Error("Invalid ecmaVersion.");
+	}
+
+	return /** @type {NormalizedEcmaVersion} */ (version);
+}
+
+/**
+ * Normalize sourceType from the initial config
+ * @param {string} sourceType to normalize
+ * @throws {Error} throw an error if sourceType is invalid
+ * @returns {"script"|"module"|"commonjs"} normalized sourceType
+ */
+function normalizeSourceType(sourceType = "script") {
+	if (
+		sourceType === "script" ||
+		sourceType === "module" ||
+		sourceType === "commonjs"
+	) {
+		return sourceType;
+	}
+
+	throw new Error("Invalid sourceType.");
+}
+
+/**
+ * @typedef {{
+ *   ecmaVersion: NormalizedEcmaVersion,
+ *   sourceType: "script"|"module"|"commonjs",
+ *   range?: boolean,
+ *   loc?: boolean,
+ *   allowReserved: boolean | "never",
+ *   ecmaFeatures?: {
+ *     jsx?: boolean,
+ *     globalReturn?: boolean,
+ *     impliedStrict?: boolean
+ *   },
+ *   ranges: boolean,
+ *   locations: boolean,
+ *   allowReturnOutsideFunction: boolean,
+ *   tokens?: boolean,
+ *   comment?: boolean
+ * }} NormalizedParserOptions
+ */
+
+/**
+ * Normalize parserOptions
+ * @param {Options} options the parser options to normalize
+ * @throws {Error} throw an error if found invalid option.
+ * @returns {NormalizedParserOptions} normalized options
+ */
+export 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,
+	});
+}

node_modules/espree/lib/token-translator.js

@@ -0,0 +1,306 @@
+/**
+ * @fileoverview Translates tokens between Acorn format and Esprima format.
+ * @author Nicholas C. Zakas
+ */
+
+/**
+ * @import * as acorn from "acorn";
+ * @import { EnhancedTokTypes } from "./espree.js"
+ * @import { NormalizedEcmaVersion } from "./options.js";
+ * @import { EspreeToken as EsprimaToken } from "../espree.js";
+ */
+/**
+ * Based on the `acorn.Token` class, but without a fixed `type` (since we need
+ * it to be a string). Avoiding `type` lets us make one extending interface
+ * more strict and another more lax.
+ *
+ * We could make `value` more strict to `string` even though the original is
+ * `any`.
+ *
+ * `start` and `end` are required in `acorn.Token`
+ *
+ * `loc` and `range` are from `acorn.Token`
+ *
+ * Adds `regex`.
+ */
+/**
+ * @typedef {{
+ *   jsxAttrValueToken: boolean;
+ *   ecmaVersion: NormalizedEcmaVersion;
+ * }} ExtraNoTokens
+ * @typedef {{
+ *   tokens: EsprimaToken[]
+ * } & ExtraNoTokens} Extra
+ */
+
+//------------------------------------------------------------------------------
+// Private
+//------------------------------------------------------------------------------
+
+// Esprima Token Types
+const Token = {
+	Boolean: "Boolean",
+	EOF: "<end>",
+	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 {acorn.Token[]} 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 =
+			/** @type {acorn.Token & { loc: acorn.SourceLocation, range: [number, number] }} */ (
+				tokens.at(-1)
+			);
+
+	/** @type {EsprimaToken} */
+	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;
+}
+
+/* eslint-disable jsdoc/check-types -- The API allows either */
+/**
+ * Contains logic to translate Acorn tokens into Esprima tokens.
+ */
+class TokenTranslator {
+	/**
+	 * Contains logic to translate Acorn tokens into Esprima tokens.
+	 * @param {EnhancedTokTypes} acornTokTypes The Acorn token types.
+	 * @param {string|String} code The source code Acorn is parsing. This is necessary
+	 *      to correct the "value" property of some tokens.
+	 */
+	constructor(acornTokTypes, code) {
+		/* eslint-enable jsdoc/check-types -- The API allows either */
+
+		// token types
+		this._acornTokTypes = acornTokTypes;
+
+		// token buffer for templates
+		/** @type {acorn.Token[]} */
+		this._tokens = [];
+
+		// track the last curly brace
+		this._curlyBrace = null;
+
+		// the source code
+		this._code = code;
+	}
+
+	/**
+	 * 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 {acorn.Token} token The Acorn token to translate.
+	 * @param {ExtraNoTokens} extra Espree extra object.
+	 * @returns {EsprimaToken} The Esprima version of the token.
+	 */
+	translate(token, extra) {
+		const type = token.type,
+			tt = this._acornTokTypes,
+			// We use an unknown type because `acorn.Token` is a class whose
+			//   `type` property we cannot override to our desired `string`;
+			//   this also allows us to define a stricter `EsprimaToken` with
+			//   a string-only `type` property
+			unknownTokenType = /** @type {unknown} */ (token),
+			newToken = /** @type {EsprimaToken} */ (unknownTokenType);
+
+		if (type === tt.name) {
+			newToken.type = Token.Identifier;
+
+			// TODO: See if this is an Acorn bug
+			if ("value" in token && token.value === "static") {
+				newToken.type = Token.Keyword;
+			}
+
+			if (
+				extra.ecmaVersion > 5 &&
+				"value" in token &&
+				(token.value === "yield" || token.value === "let")
+			) {
+				newToken.type = Token.Keyword;
+			}
+		} else if (type === tt.privateId) {
+			newToken.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 ||
+			("binop" in type && type.binop && !type.keyword) ||
+			("isAssign" in type && type.isAssign)
+		) {
+			newToken.type = Token.Punctuator;
+			newToken.value = this._code.slice(token.start, token.end);
+		} else if (type === tt.jsxName) {
+			newToken.type = Token.JSXIdentifier;
+		} else if (type.label === "jsxText" || type === tt.jsxAttrValueToken) {
+			newToken.type = Token.JSXText;
+		} else if (type.keyword) {
+			if (type.keyword === "true" || type.keyword === "false") {
+				newToken.type = Token.Boolean;
+			} else if (type.keyword === "null") {
+				newToken.type = Token.Null;
+			} else {
+				newToken.type = Token.Keyword;
+			}
+		} else if (type === tt.num) {
+			newToken.type = Token.Numeric;
+			newToken.value = this._code.slice(token.start, token.end);
+		} else if (type === tt.string) {
+			if (extra.jsxAttrValueToken) {
+				extra.jsxAttrValueToken = false;
+				newToken.type = Token.JSXText;
+			} else {
+				newToken.type = Token.String;
+			}
+
+			newToken.value = this._code.slice(token.start, token.end);
+		} else if (type === tt.regexp) {
+			newToken.type = Token.RegularExpression;
+			const value = /** @type {{flags: string, pattern: string}} */ (
+				"value" in token && token.value
+			);
+
+			newToken.regex = {
+				flags: value.flags,
+				pattern: value.pattern,
+			};
+			newToken.value = `/${value.pattern}/${value.flags}`;
+		}
+
+		return newToken;
+	}
+
+	/**
+	 * Function to call during Acorn's onToken handler.
+	 * @param {acorn.Token} token The Acorn token.
+	 * @param {Extra} 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));
+	}
+}
+
+//------------------------------------------------------------------------------
+// Public
+//------------------------------------------------------------------------------
+
+export default TokenTranslator;

node_modules/espree/lib/types.js

@@ -0,0 +1,118 @@
+/**
+ * @import * as acorn from "acorn";
+ * @import { Options, EspreeTokens } from "../espree.js";
+ */
+
+/**
+ * @typedef {acorn.tokTypes & {
+ *   jsxName: acorn.TokenType,
+ *   jsxText: acorn.TokenType,
+ *   jsxTagEnd: acorn.TokenType,
+ *   jsxTagStart: acorn.TokenType
+ * }} TokTypes
+ */
+
+/**
+ * @typedef {new (
+ *   token: string,
+ *   isExpr: boolean,
+ *   preserveSpace: boolean,
+ *   override?: (parser: any) => void
+ * ) => void} TokContext
+ */
+
+/**
+ * @typedef {{
+ *   tc_oTag: TokContext,
+ *   tc_cTag: TokContext,
+ *   tc_expr: TokContext
+ * }} TokContexts
+ */
+
+/**
+ * @typedef {{
+ *   generator?: boolean
+ * } & acorn.Node} EsprimaNode
+ */
+
+/**
+ * @typedef {"Block"|"Hashbang"|"Line"} CommentType
+ */
+
+/**
+ * @typedef {{
+ *   tokenize: () => EspreeTokens,
+ *   parse: () => acorn.Program
+ * }} EspreeParser
+ */
+
+/* eslint-disable jsdoc/valid-types -- Waiting on jsdoc plugin update */
+/**
+ * @typedef {acorn.Parser & {
+ *   jsx_readToken(): string;
+ *   jsx_readNewLine(normalizeCRLF: boolean): void;
+ *   jsx_readString(quote: number): void;
+ *   jsx_readEntity(): string;
+ *   jsx_readWord(): void;
+ *   jsx_parseIdentifier(): acorn.Node;
+ *   jsx_parseNamespacedName(): acorn.Node;
+ *   jsx_parseElementName(): acorn.Node | string;
+ *   jsx_parseAttributeValue(): acorn.Node;
+ *   jsx_parseEmptyExpression(): acorn.Node;
+ *   jsx_parseExpressionContainer(): acorn.Node;
+ *   jsx_parseAttribute(): acorn.Node;
+ *   jsx_parseOpeningElementAt(startPos: number, startLoc?: acorn.SourceLocation): acorn.Node;
+ *   jsx_parseClosingElementAt(startPos: number, startLoc?: acorn.SourceLocation): acorn.Node;
+ *   jsx_parseElementAt(startPos: number, startLoc?: acorn.SourceLocation): acorn.Node;
+ *   jsx_parseText(): acorn.Node;
+ *   jsx_parseElement(): acorn.Node;
+ * }} AcornJsxParser
+ */
+
+/**
+ * We pick (statics) from acorn rather than plain extending to avoid complaint
+ *   about base constructors needing the same return type (i.e., we return
+ *   `AcornJsxParser` here)
+ * @typedef {Pick<typeof acorn.Parser, keyof typeof acorn.Parser> & {
+ *   readonly acornJsx: {
+ *     tokTypes: TokTypes;
+ *     tokContexts: TokContexts
+ *   };
+ *   new (options: acorn.Options, input: string, startPos?: number): AcornJsxParser;
+ * }} AcornJsxParserCtor
+ */
+/**
+ * @typedef {{
+ *   new (opts: Options | null | undefined, code: string | object): EspreeParser
+ * } & Pick<typeof acorn.Parser, keyof typeof acorn.Parser>} EspreeParserCtor
+ */
+/**
+ * @typedef {{
+ *   new (opts: Options | null | undefined, code: string | object): EspreeParser
+ * } & Pick<AcornJsxParserCtor, keyof AcornJsxParserCtor>} EspreeParserJsxCtor
+ */
+
+/**
+ * @typedef {Pick<AcornJsxParserCtor, keyof AcornJsxParserCtor> & {
+ *   acorn: {
+ *     tokTypes: TokTypes,
+ *     getLineInfo: (input: string, pos: number) => {
+ *       line: number,
+ *       column: number
+ *     }
+ *   }
+ *   new (options: acorn.Options, input: string, startPos?: number): AcornJsxParser & {
+ *     next: () => void,
+ *     type: acorn.TokenType,
+ *     curLine: number,
+ *     start: number,
+ *     end: number,
+ *     finishNode (node: acorn.Node, type: string): acorn.Node,
+ *     finishNodeAt (node: acorn.Node, type: string, pos: number, loc: acorn.Position): acorn.Node,
+ *     parseTopLevel (node: acorn.Node): acorn.Node,
+ *     nextToken (): void
+ *   }
+ * }} AcornJsxParserCtorEnhanced
+ */
+
+/* eslint-enable jsdoc/valid-types -- Bug in older versions */