@alexlit/lint-kit 175.0.0 → 176.0.1

package/packages/config-eslint/node_modules/espree/dist/espree.cjs

@@ -1,1272 +0,0 @@
-'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
- */
-
-/**
- * @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));
-    }
-}
-
-/**
- * @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.
- */
-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.
- */
-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
- */
-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 */
-
-/**
- * @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
-var espree = () => {
-
-    /**
-     * 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;
-            }
-        };
-    };
-};
-
-/**
- * @fileoverview Main Espree file that converts Acorn into Esprima output.
- *
- * This file contains code from the following MIT-licensed projects:
- * 1. Acorn
- * 2. Babylon
- * 3. Babel-ESLint
- *
- * This file also contains code from Esprima, which is BSD licensed.
- *
- * Acorn is Copyright 2012-2015 Acorn Contributors (https://github.com/marijnh/acorn/blob/master/AUTHORS)
- * Babylon is Copyright 2014-2015 various contributors (https://github.com/babel/babel/blob/master/packages/babylon/AUTHORS)
- * Babel-ESLint is Copyright 2014-2015 Sebastian McKenzie <sebmck@gmail.com>
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- * * Redistributions of source code must retain the above copyright
- *   notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- *   notice, this list of conditions and the following disclaimer in the
- *   documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * Esprima is Copyright (c) jQuery Foundation, Inc. and Contributors, All Rights Reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *   * Redistributions of source code must retain the above copyright
- *     notice, this list of conditions and the following disclaimer.
- *   * Redistributions in binary form must reproduce the above copyright
- *     notice, this list of conditions and the following disclaimer in the
- *     documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/**
- * @import { EspreeParserCtor, EspreeParserJsxCtor } from "./lib/types.js";
- */
-
-// ----------------------------------------------------------------------------
-// Types exported from file
-// ----------------------------------------------------------------------------
-/**
- * @typedef {3|5|6|7|8|9|10|11|12|13|14|15|16|17|2015|2016|2017|2018|2019|2020|2021|2022|2023|2024|2025|2026|'latest'} EcmaVersion
- */
-
-/**
- * @typedef {{
- *   type: string;
- *   value: any;
- *   start?: number;
- *   end?: number;
- *   loc?: acorn.SourceLocation;
- *   range?: [number, number];
- *   regex?: {flags: string, pattern: string};
- * }} EspreeToken
- */
-
-/**
- * @typedef {{
- *   type: "Block" | "Hashbang" | "Line",
- *   value: string,
- *   range?: [number, number],
- *   start?: number,
- *   end?: number,
- *   loc?: {
- *     start: acorn.Position | undefined,
- *     end: acorn.Position | undefined
- *   }
- * }} EspreeComment
- */
-
-/**
- * @typedef {{
- *   comments?: EspreeComment[]
- * } & EspreeToken[]} EspreeTokens
- */
-
-/**
- * `allowReserved` is as in `acorn.Options`
- *
- * `ecmaVersion` currently as in `acorn.Options` though optional
- *
- * `sourceType` as in `acorn.Options` but also allows `commonjs`
- *
- * `ecmaFeatures`, `range`, `loc`, `tokens` are not in `acorn.Options`
- *
- * `comment` is not in `acorn.Options` and doesn't err without it, but is used
- */
-/**
- * @typedef {{
- *   allowReserved?: boolean,
- *   ecmaVersion?: EcmaVersion,
- *   sourceType?: "script"|"module"|"commonjs",
- *   ecmaFeatures?: {
- *     jsx?: boolean,
- *     globalReturn?: boolean,
- *     impliedStrict?: boolean
- *   },
- *   range?: boolean,
- *   loc?: boolean,
- *   tokens?: boolean,
- *   comment?: boolean,
- * }} Options
- */
-
-// To initialize lazily.
-const parsers = {
-
-    /** @type {EspreeParserCtor|null} */
-    _regular: null,
-
-    /** @type {EspreeParserJsxCtor|null} */
-    _jsx: null,
-
-    /**
-     * Returns regular Parser
-     * @returns {EspreeParserCtor} Regular Acorn parser
-     */
-    get regular() {
-        if (this._regular === null) {
-            const espreeParserFactory = /** @type {unknown} */ (espree());
-
-            this._regular = /** @type {EspreeParserCtor} */ (
-                // Without conversion, types are incompatible, as
-                // acorn's has a protected constructor
-                /** @type {unknown} */
-                (acorn__namespace.Parser.extend(
-                    /**
-                     * @type {(
-                     *   BaseParser: typeof acorn.Parser
-                     * ) => typeof acorn.Parser}
-                     */ (espreeParserFactory)
-                ))
-            );
-        }
-        return this._regular;
-    },
-
-    /**
-     * Returns JSX Parser
-     * @returns {EspreeParserJsxCtor} JSX Acorn parser
-     */
-    get jsx() {
-        if (this._jsx === null) {
-            const espreeParserFactory = /** @type {unknown} */ (espree());
-            const jsxFactory = jsx__default["default"]();
-
-            this._jsx = /** @type {EspreeParserJsxCtor} */ (
-                // Without conversion, types are incompatible, as
-                // acorn's has a protected constructor
-                /** @type {unknown} */
-                (acorn__namespace.Parser.extend(
-                    jsxFactory,
-
-                    /** @type {(BaseParser: typeof acorn.Parser) => typeof acorn.Parser} */
-                    (espreeParserFactory)
-                ))
-            );
-        }
-        return this._jsx;
-    },
-
-    /**
-     * Gets the parser object based on the supplied options.
-     * @param {Options} [options] The parser options.
-     * @returns {EspreeParserJsxCtor|EspreeParserCtor} Regular or JSX Acorn parser
-     */
-    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 {Options} [options] Options defining how to tokenize.
- * @returns {EspreeTokens} An array of tokens.
- * @throws {EnhancedSyntaxError} 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 /** @type {EspreeTokens} */ (new Parser(options, code).tokenize());
-}
-
-//------------------------------------------------------------------------------
-// Parser
-//------------------------------------------------------------------------------
-
-/**
- * Parses the given code.
- * @param {string} code The code to tokenize.
- * @param {Options} [options] Options defining how to tokenize.
- * @returns {acorn.Program} The "Program" AST node.
- * @throws {EnhancedSyntaxError} If the input code is invalid.
- */
-function parse(code, options) {
-    const Parser = parsers.get(options);
-
-    return new Parser(options, code).parse();
-}
-
-//------------------------------------------------------------------------------
-// Public
-//------------------------------------------------------------------------------
-
-/** @type {string} */
-const version = "11.1.0"; // x-release-please-version
-const name = "espree";
-
-/* istanbul ignore next */
-/**
- * @type {visitorKeys.VisitorKeys}
- */
-const VisitorKeys = (function() {
-    return visitorKeys__namespace.KEYS;
-}());
-
-// Derive node types from VisitorKeys
-/* istanbul ignore next */
-const Syntax = (function() {
-    let key,
-
-        /** @type {Record<string,string>} */
-        types = {};
-
-    if (typeof Object.create === "function") {
-        types = Object.create(null);
-    }
-
-    for (key in VisitorKeys) {
-        if (Object.hasOwn(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;