@dcf-micro/eslint-config 5.0.0

package/dist/shared/eslint-config.Bk-3rH6Y.mjs

@@ -0,0 +1,1355 @@
+import { a as requireAcorn, r as requireAcornJsx } from './eslint-config.DWoU09EE.mjs';
+
+var espree = {};
+
+var eslintVisitorKeys = {};
+
+var hasRequiredEslintVisitorKeys;
+
+function requireEslintVisitorKeys () {
+	if (hasRequiredEslintVisitorKeys) return eslintVisitorKeys;
+	hasRequiredEslintVisitorKeys = 1;
+
+	/* eslint-disable jsdoc/valid-types -- doesn't allow `readonly`.
+	   TODO: remove eslint-disable when https://github.com/jsdoc-type-pratt-parser/jsdoc-type-pratt-parser/issues/164 is fixed
+	*/
+	/**
+	 * @typedef {{ readonly [type: string]: ReadonlyArray<string> }} VisitorKeys
+	 */
+	/* eslint-enable jsdoc/valid-types -- doesn't allow `readonly string[]`. TODO: check why */
+
+	/**
+	 * @type {VisitorKeys}
+	 */
+	const KEYS = {
+	    ArrayExpression: [
+	        "elements"
+	    ],
+	    ArrayPattern: [
+	        "elements"
+	    ],
+	    ArrowFunctionExpression: [
+	        "params",
+	        "body"
+	    ],
+	    AssignmentExpression: [
+	        "left",
+	        "right"
+	    ],
+	    AssignmentPattern: [
+	        "left",
+	        "right"
+	    ],
+	    AwaitExpression: [
+	        "argument"
+	    ],
+	    BinaryExpression: [
+	        "left",
+	        "right"
+	    ],
+	    BlockStatement: [
+	        "body"
+	    ],
+	    BreakStatement: [
+	        "label"
+	    ],
+	    CallExpression: [
+	        "callee",
+	        "arguments"
+	    ],
+	    CatchClause: [
+	        "param",
+	        "body"
+	    ],
+	    ChainExpression: [
+	        "expression"
+	    ],
+	    ClassBody: [
+	        "body"
+	    ],
+	    ClassDeclaration: [
+	        "id",
+	        "superClass",
+	        "body"
+	    ],
+	    ClassExpression: [
+	        "id",
+	        "superClass",
+	        "body"
+	    ],
+	    ConditionalExpression: [
+	        "test",
+	        "consequent",
+	        "alternate"
+	    ],
+	    ContinueStatement: [
+	        "label"
+	    ],
+	    DebuggerStatement: [],
+	    DoWhileStatement: [
+	        "body",
+	        "test"
+	    ],
+	    EmptyStatement: [],
+	    ExperimentalRestProperty: [
+	        "argument"
+	    ],
+	    ExperimentalSpreadProperty: [
+	        "argument"
+	    ],
+	    ExportAllDeclaration: [
+	        "exported",
+	        "source",
+	        "attributes"
+	    ],
+	    ExportDefaultDeclaration: [
+	        "declaration"
+	    ],
+	    ExportNamedDeclaration: [
+	        "declaration",
+	        "specifiers",
+	        "source",
+	        "attributes"
+	    ],
+	    ExportSpecifier: [
+	        "exported",
+	        "local"
+	    ],
+	    ExpressionStatement: [
+	        "expression"
+	    ],
+	    ForInStatement: [
+	        "left",
+	        "right",
+	        "body"
+	    ],
+	    ForOfStatement: [
+	        "left",
+	        "right",
+	        "body"
+	    ],
+	    ForStatement: [
+	        "init",
+	        "test",
+	        "update",
+	        "body"
+	    ],
+	    FunctionDeclaration: [
+	        "id",
+	        "params",
+	        "body"
+	    ],
+	    FunctionExpression: [
+	        "id",
+	        "params",
+	        "body"
+	    ],
+	    Identifier: [],
+	    IfStatement: [
+	        "test",
+	        "consequent",
+	        "alternate"
+	    ],
+	    ImportAttribute: [
+	        "key",
+	        "value"
+	    ],
+	    ImportDeclaration: [
+	        "specifiers",
+	        "source",
+	        "attributes"
+	    ],
+	    ImportDefaultSpecifier: [
+	        "local"
+	    ],
+	    ImportExpression: [
+	        "source",
+	        "options"
+	    ],
+	    ImportNamespaceSpecifier: [
+	        "local"
+	    ],
+	    ImportSpecifier: [
+	        "imported",
+	        "local"
+	    ],
+	    JSXAttribute: [
+	        "name",
+	        "value"
+	    ],
+	    JSXClosingElement: [
+	        "name"
+	    ],
+	    JSXClosingFragment: [],
+	    JSXElement: [
+	        "openingElement",
+	        "children",
+	        "closingElement"
+	    ],
+	    JSXEmptyExpression: [],
+	    JSXExpressionContainer: [
+	        "expression"
+	    ],
+	    JSXFragment: [
+	        "openingFragment",
+	        "children",
+	        "closingFragment"
+	    ],
+	    JSXIdentifier: [],
+	    JSXMemberExpression: [
+	        "object",
+	        "property"
+	    ],
+	    JSXNamespacedName: [
+	        "namespace",
+	        "name"
+	    ],
+	    JSXOpeningElement: [
+	        "name",
+	        "attributes"
+	    ],
+	    JSXOpeningFragment: [],
+	    JSXSpreadAttribute: [
+	        "argument"
+	    ],
+	    JSXSpreadChild: [
+	        "expression"
+	    ],
+	    JSXText: [],
+	    LabeledStatement: [
+	        "label",
+	        "body"
+	    ],
+	    Literal: [],
+	    LogicalExpression: [
+	        "left",
+	        "right"
+	    ],
+	    MemberExpression: [
+	        "object",
+	        "property"
+	    ],
+	    MetaProperty: [
+	        "meta",
+	        "property"
+	    ],
+	    MethodDefinition: [
+	        "key",
+	        "value"
+	    ],
+	    NewExpression: [
+	        "callee",
+	        "arguments"
+	    ],
+	    ObjectExpression: [
+	        "properties"
+	    ],
+	    ObjectPattern: [
+	        "properties"
+	    ],
+	    PrivateIdentifier: [],
+	    Program: [
+	        "body"
+	    ],
+	    Property: [
+	        "key",
+	        "value"
+	    ],
+	    PropertyDefinition: [
+	        "key",
+	        "value"
+	    ],
+	    RestElement: [
+	        "argument"
+	    ],
+	    ReturnStatement: [
+	        "argument"
+	    ],
+	    SequenceExpression: [
+	        "expressions"
+	    ],
+	    SpreadElement: [
+	        "argument"
+	    ],
+	    StaticBlock: [
+	        "body"
+	    ],
+	    Super: [],
+	    SwitchCase: [
+	        "test",
+	        "consequent"
+	    ],
+	    SwitchStatement: [
+	        "discriminant",
+	        "cases"
+	    ],
+	    TaggedTemplateExpression: [
+	        "tag",
+	        "quasi"
+	    ],
+	    TemplateElement: [],
+	    TemplateLiteral: [
+	        "quasis",
+	        "expressions"
+	    ],
+	    ThisExpression: [],
+	    ThrowStatement: [
+	        "argument"
+	    ],
+	    TryStatement: [
+	        "block",
+	        "handler",
+	        "finalizer"
+	    ],
+	    UnaryExpression: [
+	        "argument"
+	    ],
+	    UpdateExpression: [
+	        "argument"
+	    ],
+	    VariableDeclaration: [
+	        "declarations"
+	    ],
+	    VariableDeclarator: [
+	        "id",
+	        "init"
+	    ],
+	    WhileStatement: [
+	        "test",
+	        "body"
+	    ],
+	    WithStatement: [
+	        "object",
+	        "body"
+	    ],
+	    YieldExpression: [
+	        "argument"
+	    ]
+	};
+
+	// Types.
+	const NODE_TYPES = Object.keys(KEYS);
+
+	// Freeze the keys.
+	for (const type of NODE_TYPES) {
+	    Object.freeze(KEYS[type]);
+	}
+	Object.freeze(KEYS);
+
+	/**
+	 * @author Toru Nagashima <https://github.com/mysticatea>
+	 * See LICENSE file in root directory for full license.
+	 */
+
+	/**
+	 * @typedef {import('./visitor-keys.js').VisitorKeys} VisitorKeys
+	 */
+
+	// List to ignore keys.
+	const KEY_BLACKLIST = new Set([
+	    "parent",
+	    "leadingComments",
+	    "trailingComments"
+	]);
+
+	/**
+	 * Check whether a given key should be used or not.
+	 * @param {string} key The key to check.
+	 * @returns {boolean} `true` if the key should be used.
+	 */
+	function filterKey(key) {
+	    return !KEY_BLACKLIST.has(key) && key[0] !== "_";
+	}
+
+
+	/* eslint-disable jsdoc/valid-types -- doesn't allow `readonly`.
+	   TODO: remove eslint-disable when https://github.com/jsdoc-type-pratt-parser/jsdoc-type-pratt-parser/issues/164 is fixed
+	*/
+	/**
+	 * Get visitor keys of a given node.
+	 * @param {Object} node The AST node to get keys.
+	 * @returns {readonly string[]} Visitor keys of the node.
+	 */
+	function getKeys(node) {
+	    return Object.keys(node).filter(filterKey);
+	}
+	/* eslint-enable jsdoc/valid-types -- doesn't allow `readonly` */
+
+	/**
+	 * Make the union set with `KEYS` and given keys.
+	 * @param {VisitorKeys} additionalKeys The additional keys.
+	 * @returns {VisitorKeys} The union set.
+	 */
+	function unionWith(additionalKeys) {
+	    const retv = /** @type {{ [type: string]: ReadonlyArray<string> }} */
+	        (Object.assign({}, KEYS));
+
+	    for (const type of Object.keys(additionalKeys)) {
+	        if (Object.hasOwn(retv, type)) {
+	            const keys = new Set(additionalKeys[type]);
+
+	            for (const key of retv[type]) {
+	                keys.add(key);
+	            }
+
+	            retv[type] = Object.freeze(Array.from(keys));
+	        } else {
+	            retv[type] = Object.freeze(Array.from(additionalKeys[type]));
+	        }
+	    }
+
+	    return Object.freeze(retv);
+	}
+
+	eslintVisitorKeys.KEYS = KEYS;
+	eslintVisitorKeys.getKeys = getKeys;
+	eslintVisitorKeys.unionWith = unionWith;
+	return eslintVisitorKeys;
+}
+
+var hasRequiredEspree;
+
+function requireEspree () {
+	if (hasRequiredEspree) return espree;
+	hasRequiredEspree = 1;
+
+	Object.defineProperty(espree, '__esModule', { value: true });
+
+	var acorn = requireAcorn();
+	var jsx = requireAcornJsx();
+	var visitorKeys = requireEslintVisitorKeys();
+
+	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
+	 */
+
+	//------------------------------------------------------------------------------
+	// Requirements
+	//------------------------------------------------------------------------------
+
+	// none!
+
+	//------------------------------------------------------------------------------
+	// Private
+	//------------------------------------------------------------------------------
+
+
+	// Esprima Token Types
+	const Token = {
+	    Boolean: "Boolean",
+	    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 {AcornToken[]} 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 = tokens.at(-1);
+
+	    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;
+	}
+
+	/**
+	 * Contains logic to translate Acorn tokens into Esprima tokens.
+	 * @param {Object} acornTokTypes The Acorn token types.
+	 * @param {string} code The source code Acorn is parsing. This is necessary
+	 *      to correct the "value" property of some tokens.
+	 * @constructor
+	 */
+	function TokenTranslator(acornTokTypes, code) {
+
+	    // token types
+	    this._acornTokTypes = acornTokTypes;
+
+	    // token buffer for templates
+	    this._tokens = [];
+
+	    // track the last curly brace
+	    this._curlyBrace = null;
+
+	    // the source code
+	    this._code = code;
+
+	}
+
+	TokenTranslator.prototype = {
+	    constructor: TokenTranslator,
+
+	    /**
+	     * 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 {AcornToken} token The Acorn token to translate.
+	     * @param {Object} extra Espree extra object.
+	     * @returns {EsprimaToken} The Esprima version of the token.
+	     */
+	    translate(token, extra) {
+
+	        const type = token.type,
+	            tt = this._acornTokTypes;
+
+	        if (type === tt.name) {
+	            token.type = Token.Identifier;
+
+	            // TODO: See if this is an Acorn bug
+	            if (token.value === "static") {
+	                token.type = Token.Keyword;
+	            }
+
+	            if (extra.ecmaVersion > 5 && (token.value === "yield" || token.value === "let")) {
+	                token.type = Token.Keyword;
+	            }
+
+	        } else if (type === tt.privateId) {
+	            token.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 ||
+	                 (type.binop && !type.keyword) ||
+	                 type.isAssign) {
+
+	            token.type = Token.Punctuator;
+	            token.value = this._code.slice(token.start, token.end);
+	        } else if (type === tt.jsxName) {
+	            token.type = Token.JSXIdentifier;
+	        } else if (type.label === "jsxText" || type === tt.jsxAttrValueToken) {
+	            token.type = Token.JSXText;
+	        } else if (type.keyword) {
+	            if (type.keyword === "true" || type.keyword === "false") {
+	                token.type = Token.Boolean;
+	            } else if (type.keyword === "null") {
+	                token.type = Token.Null;
+	            } else {
+	                token.type = Token.Keyword;
+	            }
+	        } else if (type === tt.num) {
+	            token.type = Token.Numeric;
+	            token.value = this._code.slice(token.start, token.end);
+	        } else if (type === tt.string) {
+
+	            if (extra.jsxAttrValueToken) {
+	                extra.jsxAttrValueToken = false;
+	                token.type = Token.JSXText;
+	            } else {
+	                token.type = Token.String;
+	            }
+
+	            token.value = this._code.slice(token.start, token.end);
+	        } else if (type === tt.regexp) {
+	            token.type = Token.RegularExpression;
+	            const value = token.value;
+
+	            token.regex = {
+	                flags: value.flags,
+	                pattern: value.pattern
+	            };
+	            token.value = `/${value.pattern}/${value.flags}`;
+	        }
+
+	        return token;
+	    },
+
+	    /**
+	     * Function to call during Acorn's onToken handler.
+	     * @param {AcornToken} token The Acorn token.
+	     * @param {Object} 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
+	 */
+
+	//------------------------------------------------------------------------------
+	// Helpers
+	//------------------------------------------------------------------------------
+
+	const SUPPORTED_VERSIONS = [
+	    3,
+	    5,
+	    6, // 2015
+	    7, // 2016
+	    8, // 2017
+	    9, // 2018
+	    10, // 2019
+	    11, // 2020
+	    12, // 2021
+	    13, // 2022
+	    14, // 2023
+	    15, // 2024
+	    16 // 2025
+	];
+
+	/**
+	 * Get the latest ECMAScript version supported by Espree.
+	 * @returns {number} The latest ECMAScript version.
+	 */
+	function getLatestEcmaVersion() {
+	    return SUPPORTED_VERSIONS.at(-1);
+	}
+
+	/**
+	 * Get the list of ECMAScript versions supported by Espree.
+	 * @returns {number[]} An array containing the supported ECMAScript versions.
+	 */
+	function getSupportedEcmaVersions() {
+	    return [...SUPPORTED_VERSIONS];
+	}
+
+	/**
+	 * Normalize ECMAScript version from the initial config
+	 * @param {(number|"latest")} ecmaVersion ECMAScript version from the initial config
+	 * @throws {Error} throws an error if the ecmaVersion is invalid.
+	 * @returns {number} 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(version)) {
+	        throw new Error("Invalid ecmaVersion.");
+	    }
+
+	    return version;
+	}
+
+	/**
+	 * Normalize sourceType from the initial config
+	 * @param {string} sourceType to normalize
+	 * @throws {Error} throw an error if sourceType is invalid
+	 * @returns {string} normalized sourceType
+	 */
+	function normalizeSourceType(sourceType = "script") {
+	    if (sourceType === "script" || sourceType === "module") {
+	        return sourceType;
+	    }
+
+	    if (sourceType === "commonjs") {
+	        return "script";
+	    }
+
+	    throw new Error("Invalid sourceType.");
+	}
+
+	/**
+	 * Normalize parserOptions
+	 * @param {Object} options the parser options to normalize
+	 * @throws {Error} throw an error if found invalid option.
+	 * @returns {Object} 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 */
+
+
+	const STATE = Symbol("espree's internal state");
+	const ESPRIMA_FINISH_NODE = Symbol("espree's esprimaFinishNode");
+
+
+	/**
+	 * Converts an Acorn comment to a Esprima comment.
+	 * @param {boolean} block True if it's a block comment, false if not.
+	 * @param {string} text The text of the comment.
+	 * @param {int} start The index at which the comment starts.
+	 * @param {int} end The index at which the comment ends.
+	 * @param {Location} startLoc The location at which the comment starts.
+	 * @param {Location} endLoc The location at which the comment ends.
+	 * @param {string} code The source code being parsed.
+	 * @returns {Object} The comment object.
+	 * @private
+	 */
+	function convertAcornCommentToEsprimaComment(block, text, start, end, startLoc, endLoc, code) {
+	    let type;
+
+	    if (block) {
+	        type = "Block";
+	    } else if (code.slice(start, start + 2) === "#!") {
+	        type = "Hashbang";
+	    } else {
+	        type = "Line";
+	    }
+
+	    const comment = {
+	        type,
+	        value: text
+	    };
+
+	    if (typeof start === "number") {
+	        comment.start = start;
+	        comment.end = end;
+	        comment.range = [start, end];
+	    }
+
+	    if (typeof startLoc === "object") {
+	        comment.loc = {
+	            start: startLoc,
+	            end: endLoc
+	        };
+	    }
+
+	    return comment;
+	}
+
+	var espree$1 = () => Parser => {
+	    const tokTypes = Object.assign({}, Parser.acorn.tokTypes);
+
+	    if (Parser.acornJsx) {
+	        Object.assign(tokTypes, Parser.acornJsx.tokTypes);
+	    }
+
+	    return class Espree extends Parser {
+	        constructor(opts, code) {
+	            if (typeof opts !== "object" || opts === null) {
+	                opts = {};
+	            }
+	            if (typeof code !== "string" && !(code instanceof String)) {
+	                code = String(code);
+	            }
+
+	            // save original source type in case of commonjs
+	            const originalSourceType = opts.sourceType;
+	            const options = normalizeOptions(opts);
+	            const ecmaFeatures = options.ecmaFeatures || {};
+	            const tokenTranslator =
+	                options.tokens === true
+	                    ? new TokenTranslator(tokTypes, code)
+	                    : null;
+
+	            /*
+	             * Data that is unique to Espree and is not represented internally
+	             * in Acorn.
+	             *
+	             * For ES2023 hashbangs, Espree will call `onComment()` during the
+	             * constructor, so we must define state before having access to
+	             * `this`.
+	             */
+	            const state = {
+	                originalSourceType: originalSourceType || options.sourceType,
+	                tokens: tokenTranslator ? [] : null,
+	                comments: options.comment === true ? [] : null,
+	                impliedStrict: ecmaFeatures.impliedStrict === true && options.ecmaVersion >= 5,
+	                ecmaVersion: options.ecmaVersion,
+	                jsxAttrValueToken: false,
+	                lastToken: null,
+	                templateElements: []
+	            };
+
+	            // Initialize acorn parser.
+	            super({
+
+	                // do not use spread, because we don't want to pass any unknown options to acorn
+	                ecmaVersion: options.ecmaVersion,
+	                sourceType: options.sourceType,
+	                ranges: options.ranges,
+	                locations: options.locations,
+	                allowReserved: options.allowReserved,
+
+	                // Truthy value is true for backward compatibility.
+	                allowReturnOutsideFunction: options.allowReturnOutsideFunction,
+
+	                // Collect tokens
+	                onToken(token) {
+	                    if (tokenTranslator) {
+
+	                        // Use `tokens`, `ecmaVersion`, and `jsxAttrValueToken` in the state.
+	                        tokenTranslator.onToken(token, state);
+	                    }
+	                    if (token.type !== tokTypes.eof) {
+	                        state.lastToken = token;
+	                    }
+	                },
+
+	                // Collect comments
+	                onComment(block, text, start, end, startLoc, endLoc) {
+	                    if (state.comments) {
+	                        const comment = convertAcornCommentToEsprimaComment(block, text, start, end, startLoc, endLoc, code);
+
+	                        state.comments.push(comment);
+	                    }
+	                }
+	            }, code);
+
+	            /*
+	             * We put all of this data into a symbol property as a way to avoid
+	             * potential naming conflicts with future versions of Acorn.
+	             */
+	            this[STATE] = state;
+	        }
+
+	        tokenize() {
+	            do {
+	                this.next();
+	            } while (this.type !== tokTypes.eof);
+
+	            // Consume the final eof token
+	            this.next();
+
+	            const extra = this[STATE];
+	            const tokens = extra.tokens;
+
+	            if (extra.comments) {
+	                tokens.comments = extra.comments;
+	            }
+
+	            return tokens;
+	        }
+
+	        finishNode(...args) {
+	            const result = super.finishNode(...args);
+
+	            return this[ESPRIMA_FINISH_NODE](result);
+	        }
+
+	        finishNodeAt(...args) {
+	            const result = super.finishNodeAt(...args);
+
+	            return this[ESPRIMA_FINISH_NODE](result);
+	        }
+
+	        parse() {
+	            const extra = this[STATE];
+	            const program = super.parse();
+
+	            program.sourceType = extra.originalSourceType;
+
+	            if (extra.comments) {
+	                program.comments = extra.comments;
+	            }
+	            if (extra.tokens) {
+	                program.tokens = extra.tokens;
+	            }
+
+	            /*
+	             * Adjust opening and closing position of program to match Esprima.
+	             * Acorn always starts programs at range 0 whereas Esprima starts at the
+	             * first AST node's start (the only real difference is when there's leading
+	             * whitespace or leading comments). Acorn also counts trailing whitespace
+	             * as part of the program whereas Esprima only counts up to the last token.
+	             */
+	            if (program.body.length) {
+	                const [firstNode] = program.body;
+
+	                if (program.range) {
+	                    program.range[0] = firstNode.range[0];
+	                }
+	                if (program.loc) {
+	                    program.loc.start = firstNode.loc.start;
+	                }
+	                program.start = firstNode.start;
+	            }
+	            if (extra.lastToken) {
+	                if (program.range) {
+	                    program.range[1] = extra.lastToken.range[1];
+	                }
+	                if (program.loc) {
+	                    program.loc.end = extra.lastToken.loc.end;
+	                }
+	                program.end = extra.lastToken.end;
+	            }
+
+
+	            /*
+	             * https://github.com/eslint/espree/issues/349
+	             * Ensure that template elements have correct range information.
+	             * This is one location where Acorn produces a different value
+	             * for its start and end properties vs. the values present in the
+	             * range property. In order to avoid confusion, we set the start
+	             * and end properties to the values that are present in range.
+	             * This is done here, instead of in finishNode(), because Acorn
+	             * uses the values of start and end internally while parsing, making
+	             * it dangerous to change those values while parsing is ongoing.
+	             * By waiting until the end of parsing, we can safely change these
+	             * values without affect any other part of the process.
+	             */
+	            this[STATE].templateElements.forEach(templateElement => {
+	                const startOffset = -1;
+	                const endOffset = templateElement.tail ? 1 : 2;
+
+	                templateElement.start += startOffset;
+	                templateElement.end += endOffset;
+
+	                if (templateElement.range) {
+	                    templateElement.range[0] += startOffset;
+	                    templateElement.range[1] += endOffset;
+	                }
+
+	                if (templateElement.loc) {
+	                    templateElement.loc.start.column += startOffset;
+	                    templateElement.loc.end.column += endOffset;
+	                }
+	            });
+
+	            return program;
+	        }
+
+	        parseTopLevel(node) {
+	            if (this[STATE].impliedStrict) {
+	                this.strict = true;
+	            }
+	            return super.parseTopLevel(node);
+	        }
+
+	        /**
+	         * Overwrites the default raise method to throw Esprima-style errors.
+	         * @param {int} pos The position of the error.
+	         * @param {string} message The error message.
+	         * @throws {SyntaxError} A syntax error.
+	         * @returns {void}
+	         */
+	        raise(pos, message) {
+	            const loc = Parser.acorn.getLineInfo(this.input, pos);
+	            const err = new SyntaxError(message);
+
+	            err.index = pos;
+	            err.lineNumber = loc.line;
+	            err.column = loc.column + 1; // acorn uses 0-based columns
+	            throw err;
+	        }
+
+	        /**
+	         * Overwrites the default raise method to throw Esprima-style errors.
+	         * @param {int} pos The position of the error.
+	         * @param {string} message The error message.
+	         * @throws {SyntaxError} A syntax error.
+	         * @returns {void}
+	         */
+	        raiseRecoverable(pos, message) {
+	            this.raise(pos, message);
+	        }
+
+	        /**
+	         * Overwrites the default unexpected method to throw Esprima-style errors.
+	         * @param {int} pos The position of the error.
+	         * @throws {SyntaxError} A syntax error.
+	         * @returns {void}
+	         */
+	        unexpected(pos) {
+	            let message = "Unexpected token";
+
+	            if (pos !== null && pos !== void 0) {
+	                this.pos = pos;
+
+	                if (this.options.locations) {
+	                    while (this.pos < this.lineStart) {
+	                        this.lineStart = this.input.lastIndexOf("\n", this.lineStart - 2) + 1;
+	                        --this.curLine;
+	                    }
+	                }
+
+	                this.nextToken();
+	            }
+
+	            if (this.end > this.start) {
+	                message += ` ${this.input.slice(this.start, this.end)}`;
+	            }
+
+	            this.raise(this.start, message);
+	        }
+
+	        /*
+	        * Esprima-FB represents JSX strings as tokens called "JSXText", but Acorn-JSX
+	        * uses regular tt.string without any distinction between this and regular JS
+	        * strings. As such, we intercept an attempt to read a JSX string and set a flag
+	        * on extra so that when tokens are converted, the next token will be switched
+	        * to JSXText via onToken.
+	        */
+	        jsx_readString(quote) { // eslint-disable-line camelcase -- required by API
+	            const result = super.jsx_readString(quote);
+
+	            if (this.type === tokTypes.string) {
+	                this[STATE].jsxAttrValueToken = true;
+	            }
+	            return result;
+	        }
+
+	        /**
+	         * Performs last-minute Esprima-specific compatibility checks and fixes.
+	         * @param {ASTNode} result The node to check.
+	         * @returns {ASTNode} The finished node.
+	         */
+	        [ESPRIMA_FINISH_NODE](result) {
+
+	            // Acorn doesn't count the opening and closing backticks as part of templates
+	            // so we have to adjust ranges/locations appropriately.
+	            if (result.type === "TemplateElement") {
+
+	                // save template element references to fix start/end later
+	                this[STATE].templateElements.push(result);
+	            }
+
+	            if (result.type.includes("Function") && !result.generator) {
+	                result.generator = false;
+	            }
+
+	            return result;
+	        }
+	    };
+	};
+
+	const version$1 = "10.3.0";
+
+	/**
+	 * @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.
+	 */
+
+
+	// To initialize lazily.
+	const parsers = {
+	    _regular: null,
+	    _jsx: null,
+
+	    get regular() {
+	        if (this._regular === null) {
+	            this._regular = acorn__namespace.Parser.extend(espree$1());
+	        }
+	        return this._regular;
+	    },
+
+	    get jsx() {
+	        if (this._jsx === null) {
+	            this._jsx = acorn__namespace.Parser.extend(jsx__default["default"](), espree$1());
+	        }
+	        return this._jsx;
+	    },
+
+	    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 {Object} options Options defining how to tokenize.
+	 * @returns {Token[]} An array of tokens.
+	 * @throws {SyntaxError} 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 new Parser(options, code).tokenize();
+	}
+
+	//------------------------------------------------------------------------------
+	// Parser
+	//------------------------------------------------------------------------------
+
+	/**
+	 * Parses the given code.
+	 * @param {string} code The code to tokenize.
+	 * @param {Object} options Options defining how to tokenize.
+	 * @returns {ASTNode} The "Program" AST node.
+	 * @throws {SyntaxError} If the input code is invalid.
+	 */
+	function parse(code, options) {
+	    const Parser = parsers.get(options);
+
+	    return new Parser(options, code).parse();
+	}
+
+	//------------------------------------------------------------------------------
+	// Public
+	//------------------------------------------------------------------------------
+
+	const version = version$1;
+	const name = "espree";
+
+	/* istanbul ignore next */
+	const VisitorKeys = (function() {
+	    return visitorKeys__namespace.KEYS;
+	}());
+
+	// Derive node types from VisitorKeys
+	/* istanbul ignore next */
+	const Syntax = (function() {
+	    let key,
+	        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();
+
+	espree.Syntax = Syntax;
+	espree.VisitorKeys = VisitorKeys;
+	espree.latestEcmaVersion = latestEcmaVersion;
+	espree.name = name;
+	espree.parse = parse;
+	espree.supportedEcmaVersions = supportedEcmaVersions;
+	espree.tokenize = tokenize;
+	espree.version = version;
+	return espree;
+}
+
+export { requireEslintVisitorKeys as a, requireEspree as r };