@alexlit/lint-kit 175.0.0 → 176.0.1

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

@@ -1,482 +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}
-             */
-            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 {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/features.js

@@ -1,21 +0,0 @@
-/**
- * @fileoverview The list of feature flags supported by the parser and their default
- *      settings.
- * @author Nicholas C. Zakas
- */
-
-//------------------------------------------------------------------------------
-// Public
-//------------------------------------------------------------------------------
-
-export default {
-
-    // React JSX parsing
-    jsx: false,
-
-    // allow return statement in global scope
-    globalReturn: false,
-
-    // allow implied strict mode
-    impliedStrict: false
-};

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

@@ -1,164 +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"} normalized sourceType
- */
-function normalizeSourceType(sourceType = "script") {
-    if (sourceType === "script" || sourceType === "module") {
-        return sourceType;
-    }
-
-    if (sourceType === "commonjs") {
-        return "script";
-    }
-
-    throw new Error("Invalid sourceType.");
-}
-
-/**
- * @typedef {{
- *   ecmaVersion: NormalizedEcmaVersion,
- *   sourceType: "script"|"module",
- *   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
-    });
-}