@alexlit/lint-kit 183.1.0 → 183.2.0

package/packages/config-eslint/node_modules/espree/lib/espree.js

@@ -1,493 +0,0 @@
-/* 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;
-			}
-		};
-	};
-};

package/packages/config-eslint/node_modules/espree/lib/options.js

@@ -1,176 +0,0 @@
-/**
- * @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,
-	});
-}