@dcf-micro/eslint-config 5.0.0

package/dist/shared/eslint-config.CWvTq0mr.mjs

@@ -0,0 +1,2914 @@
+import require$$0 from 'path';
+import { r as requireSemver } from './eslint-config.I8d-HnmI.mjs';
+import require$$2$1 from 'module';
+import { a as getAugmentedNamespace } from './eslint-config.BDBLGvXj.mjs';
+import { a as requireAcorn$1, r as requireAcornJsx } from './eslint-config.DWoU09EE.mjs';
+import { r as requireEslintVisitorKeys } from './eslint-config.FKVuBSa4.mjs';
+
+var lib = {};
+
+var parser = {};
+
+var espree$1 = {};
+
+var requireUtils$1 = {};
+
+var hasRequiredRequireUtils;
+
+function requireRequireUtils () {
+	if (hasRequiredRequireUtils) return requireUtils$1;
+	hasRequiredRequireUtils = 1;
+	var __importDefault = (requireUtils$1 && requireUtils$1.__importDefault) || function (mod) {
+	    return (mod && mod.__esModule) ? mod : { "default": mod };
+	};
+	Object.defineProperty(requireUtils$1, "__esModule", { value: true });
+	requireUtils$1.loadNewest = requireUtils$1.requireFromCwd = requireUtils$1.requireFromLinter = requireUtils$1.getRequireFromCwd = requireUtils$1.getRequireFromLinter = requireUtils$1.createRequire = void 0;
+	const path_1 = __importDefault(require$$0);
+	const semver_1 = requireSemver();
+	function createRequire(filename) {
+	    const Module = require$$2$1;
+	    const fn = Module.createRequire ||
+	        Module.createRequireFromPath ||
+	        ((filename2) => {
+	            const mod = new Module(filename2);
+	            mod.filename = filename2;
+	            mod.paths = Module._nodeModulePaths(path_1.default.dirname(filename2));
+	            mod._compile("module.exports = require;", filename2);
+	            return mod.exports;
+	        });
+	    return fn(filename);
+	}
+	requireUtils$1.createRequire = createRequire;
+	function isLinterPath(p) {
+	    return (p.includes(`eslint${path_1.default.sep}lib${path_1.default.sep}linter${path_1.default.sep}linter.js`) ||
+	        p.includes(`eslint${path_1.default.sep}lib${path_1.default.sep}linter.js`));
+	}
+	function getRequireFromLinter() {
+	    const linterPath = Object.keys(require.cache).find(isLinterPath);
+	    if (linterPath) {
+	        try {
+	            return createRequire(linterPath);
+	        }
+	        catch (_a) {
+	        }
+	    }
+	    return null;
+	}
+	requireUtils$1.getRequireFromLinter = getRequireFromLinter;
+	function getRequireFromCwd() {
+	    try {
+	        const cwd = process.cwd();
+	        const relativeTo = path_1.default.join(cwd, "__placeholder__.js");
+	        return createRequire(relativeTo);
+	    }
+	    catch (_a) {
+	    }
+	    return null;
+	}
+	requireUtils$1.getRequireFromCwd = getRequireFromCwd;
+	function requireFromLinter(module) {
+	    var _a;
+	    try {
+	        return (_a = getRequireFromLinter()) === null || _a === void 0 ? void 0 : _a(module);
+	    }
+	    catch (_b) {
+	    }
+	    return null;
+	}
+	requireUtils$1.requireFromLinter = requireFromLinter;
+	function requireFromCwd(module) {
+	    var _a;
+	    try {
+	        return (_a = getRequireFromCwd()) === null || _a === void 0 ? void 0 : _a(module);
+	    }
+	    catch (_b) {
+	    }
+	    return null;
+	}
+	requireUtils$1.requireFromCwd = requireFromCwd;
+	function loadNewest(items) {
+	    let target = null;
+	    for (const item of items) {
+	        const pkg = item.getPkg();
+	        if (pkg != null && (!target || (0, semver_1.lte)(target.version, pkg.version))) {
+	            target = { version: pkg.version, get: item.get };
+	        }
+	    }
+	    return target.get();
+	}
+	requireUtils$1.loadNewest = loadNewest;
+	return requireUtils$1;
+}
+
+const name$2 = "espree";
+const description$2 = "An Esprima-compatible JavaScript parser built on Acorn";
+const author$1 = "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>";
+const homepage$2 = "https://github.com/eslint/espree";
+const main$2 = "dist/espree.cjs";
+const type$1 = "module";
+const exports$2 = {
+	".": [
+		{
+			"import": "./espree.js",
+			require: "./dist/espree.cjs",
+			"default": "./dist/espree.cjs"
+		},
+		"./dist/espree.cjs"
+	],
+	"./package.json": "./package.json"
+};
+const version$2 = "9.6.1";
+const files$1 = [
+	"lib",
+	"dist/espree.cjs",
+	"espree.js"
+];
+const engines$2 = {
+	node: "^12.22.0 || ^14.17.0 || >=16.0.0"
+};
+const repository$2 = "eslint/espree";
+const bugs$1 = {
+	url: "https://github.com/eslint/espree/issues"
+};
+const funding$1 = "https://opencollective.com/eslint";
+const license$2 = "BSD-2-Clause";
+const dependencies = {
+	acorn: "^8.9.0",
+	"acorn-jsx": "^5.3.2",
+	"eslint-visitor-keys": "^3.4.1"
+};
+const devDependencies$1 = {
+	"@rollup/plugin-commonjs": "^17.1.0",
+	"@rollup/plugin-json": "^4.1.0",
+	"@rollup/plugin-node-resolve": "^11.2.0",
+	c8: "^7.11.0",
+	chai: "^4.3.6",
+	eslint: "^8.44.0",
+	"eslint-config-eslint": "^8.0.0",
+	"eslint-plugin-n": "^16.0.0",
+	"eslint-release": "^3.2.0",
+	"esprima-fb": "^8001.2001.0-dev-harmony-fb",
+	globals: "^13.20.0",
+	"lint-staged": "^13.2.0",
+	mocha: "^9.2.2",
+	"npm-run-all": "^4.1.5",
+	rollup: "^2.41.2",
+	shelljs: "^0.3.0",
+	yorkie: "^2.0.0"
+};
+const keywords$1 = [
+	"ast",
+	"ecmascript",
+	"javascript",
+	"parser",
+	"syntax",
+	"acorn"
+];
+const gitHooks = {
+	"pre-commit": "lint-staged"
+};
+const scripts$2 = {
+	unit: "npm-run-all -s unit:*",
+	"unit:esm": "c8 mocha --color --reporter progress --timeout 30000 'tests/lib/**/*.js'",
+	"unit:cjs": "mocha --color --reporter progress --timeout 30000 tests/lib/commonjs.cjs",
+	test: "npm-run-all -p unit lint",
+	lint: "eslint .  --report-unused-disable-directives",
+	fixlint: "npm run lint -- --fix",
+	build: "rollup -c rollup.config.js",
+	"build:debug": "npm run build -- -m",
+	"update-version": "node tools/update-version.js",
+	pretest: "npm run build",
+	prepublishOnly: "npm run update-version && npm run build",
+	"sync-docs": "node sync-docs.js",
+	"generate-release": "eslint-generate-release",
+	"generate-alpharelease": "eslint-generate-prerelease alpha",
+	"generate-betarelease": "eslint-generate-prerelease beta",
+	"generate-rcrelease": "eslint-generate-prerelease rc",
+	"publish-release": "eslint-publish-release"
+};
+const _package$4 = {
+	name: name$2,
+	description: description$2,
+	author: author$1,
+	homepage: homepage$2,
+	main: main$2,
+	type: type$1,
+	exports: exports$2,
+	version: version$2,
+	files: files$1,
+	engines: engines$2,
+	repository: repository$2,
+	bugs: bugs$1,
+	funding: funding$1,
+	license: license$2,
+	dependencies: dependencies,
+	devDependencies: devDependencies$1,
+	keywords: keywords$1,
+	gitHooks: gitHooks,
+	scripts: scripts$2
+};
+
+const _package$5 = {
+    __proto__: null,
+    author: author$1,
+    bugs: bugs$1,
+    default: _package$4,
+    dependencies: dependencies,
+    description: description$2,
+    devDependencies: devDependencies$1,
+    engines: engines$2,
+    exports: exports$2,
+    files: files$1,
+    funding: funding$1,
+    gitHooks: gitHooks,
+    homepage: homepage$2,
+    keywords: keywords$1,
+    license: license$2,
+    main: main$2,
+    name: name$2,
+    repository: repository$2,
+    scripts: scripts$2,
+    type: type$1,
+    version: version$2
+};
+
+const require$$4 = /*@__PURE__*/getAugmentedNamespace(_package$5);
+
+var espree = {};
+
+var hasRequiredEspree$1;
+
+function requireEspree$1 () {
+	if (hasRequiredEspree$1) return espree;
+	hasRequiredEspree$1 = 1;
+
+	Object.defineProperty(espree, '__esModule', { value: true });
+
+	var acorn = requireAcorn$1();
+	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[tokens.length - 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
+	];
+
+	/**
+	 * Get the latest ECMAScript version supported by Espree.
+	 * @returns {number} The latest ECMAScript version.
+	 */
+	function getLatestEcmaVersion() {
+	    return SUPPORTED_VERSIONS[SUPPORTED_VERSIONS.length - 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 = "9.6.1";
+
+	/* eslint-disable jsdoc/no-multi-asterisks -- needed to preserve original formatting of licences */
+
+
+	// 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.hasOwnProperty.call(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;
+}
+
+var hasRequiredEspree;
+
+function requireEspree () {
+	if (hasRequiredEspree) return espree$1;
+	hasRequiredEspree = 1;
+	Object.defineProperty(espree$1, "__esModule", { value: true });
+	espree$1.getNewestEspreeKind = espree$1.getEspree = void 0;
+	const require_utils_1 = requireRequireUtils();
+	const semver_1 = requireSemver();
+	let espreeCache = null;
+	function getEspree() {
+	    if (!espreeCache) {
+	        espreeCache = (0, require_utils_1.loadNewest)([
+	            {
+	                getPkg() {
+	                    return (0, require_utils_1.requireFromCwd)("espree/package.json");
+	                },
+	                get() {
+	                    return (0, require_utils_1.requireFromCwd)("espree");
+	                },
+	            },
+	            {
+	                getPkg() {
+	                    return (0, require_utils_1.requireFromLinter)("espree/package.json");
+	                },
+	                get() {
+	                    return (0, require_utils_1.requireFromLinter)("espree");
+	                },
+	            },
+	            {
+	                getPkg() {
+	                    return require$$4;
+	                },
+	                get() {
+	                    return requireEspree$1();
+	                },
+	            },
+	        ]);
+	    }
+	    return espreeCache;
+	}
+	espree$1.getEspree = getEspree;
+	let kindCache = null;
+	function getNewestEspreeKind() {
+	    if (kindCache) {
+	        return kindCache;
+	    }
+	    const cwdPkg = (0, require_utils_1.requireFromCwd)("espree/package.json");
+	    const linterPkg = (0, require_utils_1.requireFromLinter)("espree/package.json");
+	    const self = require$$4;
+	    let target = {
+	        kind: "self",
+	        version: self.version,
+	    };
+	    if (cwdPkg != null && (0, semver_1.lte)(target.version, cwdPkg.version)) {
+	        target = { kind: "cwd", version: cwdPkg.version };
+	    }
+	    if (linterPkg != null && (0, semver_1.lte)(target.version, linterPkg.version)) {
+	        target = { kind: "linter", version: linterPkg.version };
+	    }
+	    return (kindCache = target.kind);
+	}
+	espree$1.getNewestEspreeKind = getNewestEspreeKind;
+	return espree$1;
+}
+
+var visitorKeys = {};
+
+const name$1 = "eslint-visitor-keys";
+const version$1 = "3.4.3";
+const description$1 = "Constants and utilities about visitor keys to traverse AST.";
+const type = "module";
+const main$1 = "dist/eslint-visitor-keys.cjs";
+const types$1 = "./dist/index.d.ts";
+const exports$1 = {
+	".": [
+		{
+			"import": "./lib/index.js",
+			require: "./dist/eslint-visitor-keys.cjs"
+		},
+		"./dist/eslint-visitor-keys.cjs"
+	],
+	"./package.json": "./package.json"
+};
+const files = [
+	"dist/index.d.ts",
+	"dist/visitor-keys.d.ts",
+	"dist/eslint-visitor-keys.cjs",
+	"dist/eslint-visitor-keys.d.cts",
+	"lib"
+];
+const engines$1 = {
+	node: "^12.22.0 || ^14.17.0 || >=16.0.0"
+};
+const devDependencies = {
+	"@types/estree": "^0.0.51",
+	"@types/estree-jsx": "^0.0.1",
+	"@typescript-eslint/parser": "^5.14.0",
+	c8: "^7.11.0",
+	chai: "^4.3.6",
+	eslint: "^7.29.0",
+	"eslint-config-eslint": "^7.0.0",
+	"eslint-plugin-jsdoc": "^35.4.0",
+	"eslint-plugin-node": "^11.1.0",
+	"eslint-release": "^3.2.0",
+	esquery: "^1.4.0",
+	"json-diff": "^0.7.3",
+	mocha: "^9.2.1",
+	opener: "^1.5.2",
+	rollup: "^2.70.0",
+	"rollup-plugin-dts": "^4.2.3",
+	tsd: "^0.19.1",
+	typescript: "^4.6.2"
+};
+const scripts$1 = {
+	build: "npm run build:cjs && npm run build:types",
+	"build:cjs": "rollup -c",
+	"build:debug": "npm run build:cjs -- -m && npm run build:types",
+	"build:keys": "node tools/build-keys-from-ts",
+	"build:types": "tsc",
+	lint: "eslint .",
+	prepare: "npm run build",
+	"release:generate:latest": "eslint-generate-release",
+	"release:generate:alpha": "eslint-generate-prerelease alpha",
+	"release:generate:beta": "eslint-generate-prerelease beta",
+	"release:generate:rc": "eslint-generate-prerelease rc",
+	"release:publish": "eslint-publish-release",
+	test: "mocha tests/lib/**/*.cjs && c8 mocha tests/lib/**/*.js && npm run test:types",
+	"test:open-coverage": "c8 report --reporter lcov && opener coverage/lcov-report/index.html",
+	"test:types": "tsd"
+};
+const repository$1 = "eslint/eslint-visitor-keys";
+const funding = "https://opencollective.com/eslint";
+const keywords = [
+];
+const author = "Toru Nagashima (https://github.com/mysticatea)";
+const license$1 = "Apache-2.0";
+const bugs = {
+	url: "https://github.com/eslint/eslint-visitor-keys/issues"
+};
+const homepage$1 = "https://github.com/eslint/eslint-visitor-keys#readme";
+const _package$2 = {
+	name: name$1,
+	version: version$1,
+	description: description$1,
+	type: type,
+	main: main$1,
+	types: types$1,
+	exports: exports$1,
+	files: files,
+	engines: engines$1,
+	devDependencies: devDependencies,
+	scripts: scripts$1,
+	repository: repository$1,
+	funding: funding,
+	keywords: keywords,
+	author: author,
+	license: license$1,
+	bugs: bugs,
+	homepage: homepage$1
+};
+
+const _package$3 = {
+    __proto__: null,
+    author: author,
+    bugs: bugs,
+    default: _package$2,
+    description: description$1,
+    devDependencies: devDependencies,
+    engines: engines$1,
+    exports: exports$1,
+    files: files,
+    funding: funding,
+    homepage: homepage$1,
+    keywords: keywords,
+    license: license$1,
+    main: main$1,
+    name: name$1,
+    repository: repository$1,
+    scripts: scripts$1,
+    type: type,
+    types: types$1,
+    version: version$1
+};
+
+const require$$1 = /*@__PURE__*/getAugmentedNamespace(_package$3);
+
+var hasRequiredVisitorKeys;
+
+function requireVisitorKeys () {
+	if (hasRequiredVisitorKeys) return visitorKeys;
+	hasRequiredVisitorKeys = 1;
+	Object.defineProperty(visitorKeys, "__esModule", { value: true });
+	visitorKeys.getVisitorKeys = void 0;
+	const require_utils_1 = requireRequireUtils();
+	const jsonKeys = {
+	    Program: ["body"],
+	    JSONExpressionStatement: ["expression"],
+	    JSONArrayExpression: ["elements"],
+	    JSONObjectExpression: ["properties"],
+	    JSONProperty: ["key", "value"],
+	    JSONIdentifier: [],
+	    JSONLiteral: [],
+	    JSONUnaryExpression: ["argument"],
+	    JSONTemplateLiteral: ["quasis", "expressions"],
+	    JSONTemplateElement: [],
+	    JSONBinaryExpression: ["left", "right"],
+	};
+	let cache = null;
+	function getVisitorKeys() {
+	    if (!cache) {
+	        const vk = (0, require_utils_1.loadNewest)([
+	            {
+	                getPkg() {
+	                    return (0, require_utils_1.requireFromCwd)("eslint-visitor-keys/package.json");
+	                },
+	                get() {
+	                    return (0, require_utils_1.requireFromCwd)("eslint-visitor-keys");
+	                },
+	            },
+	            {
+	                getPkg() {
+	                    return (0, require_utils_1.requireFromLinter)("eslint-visitor-keys/package.json");
+	                },
+	                get() {
+	                    return (0, require_utils_1.requireFromLinter)("eslint-visitor-keys");
+	                },
+	            },
+	            {
+	                getPkg() {
+	                    return require$$1;
+	                },
+	                get() {
+	                    return requireEslintVisitorKeys();
+	                },
+	            },
+	        ]);
+	        cache = vk.unionWith(jsonKeys);
+	    }
+	    return cache;
+	}
+	visitorKeys.getVisitorKeys = getVisitorKeys;
+	return visitorKeys;
+}
+
+var convert = {};
+
+var validate = {};
+
+var errors = {};
+
+var utils = {};
+
+var hasRequiredUtils;
+
+function requireUtils () {
+	if (hasRequiredUtils) return utils;
+	hasRequiredUtils = 1;
+	Object.defineProperty(utils, "__esModule", { value: true });
+	utils.isRegExpLiteral = void 0;
+	function isRegExpLiteral(node) {
+	    return (Boolean(node.regex) ||
+	        node.raw.startsWith("/"));
+	}
+	utils.isRegExpLiteral = isRegExpLiteral;
+	return utils;
+}
+
+var hasRequiredErrors;
+
+function requireErrors () {
+	if (hasRequiredErrors) return errors;
+	hasRequiredErrors = 1;
+	Object.defineProperty(errors, "__esModule", { value: true });
+	errors.throwUnexpectedNodeError = errors.throwInvalidNumberError = errors.throwUnexpectedSpaceError = errors.throwUnexpectedCommentError = errors.throwUnexpectedTokenError = errors.throwUnexpectedError = errors.throwExpectedTokenError = errors.ParseError = void 0;
+	const utils_1 = requireUtils();
+	class ParseError extends SyntaxError {
+	    constructor(message, offset, line, column) {
+	        super(message);
+	        this.index = offset;
+	        this.lineNumber = line;
+	        this.column = column;
+	    }
+	}
+	errors.ParseError = ParseError;
+	function throwExpectedTokenError(name, beforeToken) {
+	    const locs = getLocation(beforeToken);
+	    const err = new ParseError(`Expected token '${name}'.`, locs.end, locs.loc.end.line, locs.loc.end.column + 1);
+	    throw err;
+	}
+	errors.throwExpectedTokenError = throwExpectedTokenError;
+	function throwUnexpectedError(name, token) {
+	    const locs = getLocation(token);
+	    const err = new ParseError(`Unexpected ${name}.`, locs.start, locs.loc.start.line, locs.loc.start.column + 1);
+	    throw err;
+	}
+	errors.throwUnexpectedError = throwUnexpectedError;
+	function throwUnexpectedTokenError(name, token) {
+	    return throwUnexpectedError(`token '${name}'`, token);
+	}
+	errors.throwUnexpectedTokenError = throwUnexpectedTokenError;
+	function throwUnexpectedCommentError(token) {
+	    return throwUnexpectedError("comment", token);
+	}
+	errors.throwUnexpectedCommentError = throwUnexpectedCommentError;
+	function throwUnexpectedSpaceError(beforeToken) {
+	    const locs = getLocation(beforeToken);
+	    const err = new ParseError("Unexpected whitespace.", locs.end, locs.loc.end.line, locs.loc.end.column + 1);
+	    throw err;
+	}
+	errors.throwUnexpectedSpaceError = throwUnexpectedSpaceError;
+	function throwInvalidNumberError(text, token) {
+	    const locs = getLocation(token);
+	    const err = new ParseError(`Invalid number ${text}.`, locs.start, locs.loc.start.line, locs.loc.start.column + 1);
+	    throw err;
+	}
+	errors.throwInvalidNumberError = throwInvalidNumberError;
+	function throwUnexpectedNodeError(node, tokens, offset) {
+	    if (node.type === "Identifier" || node.type === "JSONIdentifier") {
+	        const locs = getLocation(node);
+	        const err = new ParseError(`Unexpected identifier '${node.name}'.`, locs.start, locs.loc.start.line, locs.loc.start.column + 1);
+	        throw err;
+	    }
+	    if (node.type === "Literal" || node.type === "JSONLiteral") {
+	        const type = node.bigint
+	            ? "bigint"
+	            : (0, utils_1.isRegExpLiteral)(node)
+	                ? "regex"
+	                : node.value === null
+	                    ? "null"
+	                    : typeof node.value;
+	        const locs = getLocation(node);
+	        const err = new ParseError(`Unexpected ${type} literal.`, locs.start, locs.loc.start.line, locs.loc.start.column + 1);
+	        throw err;
+	    }
+	    if (node.type === "TemplateLiteral" || node.type === "JSONTemplateLiteral") {
+	        const locs = getLocation(node);
+	        const err = new ParseError("Unexpected template literal.", locs.start, locs.loc.start.line, locs.loc.start.column + 1);
+	        throw err;
+	    }
+	    if (node.type.endsWith("Expression") && node.type !== "FunctionExpression") {
+	        const name = node.type
+	            .replace(/^JSON/u, "")
+	            .replace(/\B([A-Z])/gu, " $1")
+	            .toLowerCase();
+	        const locs = getLocation(node);
+	        const err = new ParseError(`Unexpected ${name}.`, locs.start, locs.loc.start.line, locs.loc.start.column + 1);
+	        throw err;
+	    }
+	    const index = node.range[0] + (offset || 0);
+	    const t = tokens.findTokenByOffset(index);
+	    const name = (t === null || t === void 0 ? void 0 : t.value) || "unknown";
+	    const locs = getLocation(t || node);
+	    const err = new ParseError(`Unexpected token '${name}'.`, locs.start, locs.loc.start.line, locs.loc.start.column + 1);
+	    throw err;
+	}
+	errors.throwUnexpectedNodeError = throwUnexpectedNodeError;
+	function getLocation(token) {
+	    var _a, _b, _c, _d;
+	    const start = (_b = (_a = token.range) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : token.start;
+	    const end = (_d = (_c = token.range) === null || _c === void 0 ? void 0 : _c[1]) !== null && _d !== void 0 ? _d : token.end;
+	    const loc = token.loc;
+	    return { start, end, loc };
+	}
+	return errors;
+}
+
+var tokenStore = {};
+
+var hasRequiredTokenStore;
+
+function requireTokenStore () {
+	if (hasRequiredTokenStore) return tokenStore;
+	hasRequiredTokenStore = 1;
+	Object.defineProperty(tokenStore, "__esModule", { value: true });
+	tokenStore.isComma = tokenStore.TokenStore = void 0;
+	class TokenStore {
+	    constructor(tokens) {
+	        this.tokens = tokens;
+	    }
+	    add(token) {
+	        this.tokens.push(token);
+	    }
+	    findIndexByOffset(offset) {
+	        return this.tokens.findIndex((token) => token.range[0] <= offset && offset < token.range[1]);
+	    }
+	    findTokenByOffset(offset) {
+	        return this.tokens[this.findIndexByOffset(offset)];
+	    }
+	    getFirstToken(nodeOrToken) {
+	        return this.findTokenByOffset(nodeOrToken.range[0]);
+	    }
+	    getLastToken(nodeOrToken) {
+	        return this.findTokenByOffset(nodeOrToken.range[1] - 1);
+	    }
+	    getTokenBefore(nodeOrToken, filter) {
+	        const tokenIndex = this.findIndexByOffset(nodeOrToken.range[0]);
+	        for (let index = tokenIndex - 1; index >= 0; index--) {
+	            const token = this.tokens[index];
+	            if (!filter || filter(token)) {
+	                return token;
+	            }
+	        }
+	        return null;
+	    }
+	    getTokenAfter(nodeOrToken, filter) {
+	        const tokenIndex = this.findIndexByOffset(nodeOrToken.range[0]);
+	        for (let index = tokenIndex + 1; index < this.tokens.length; index++) {
+	            const token = this.tokens[index];
+	            if (!filter || filter(token)) {
+	                return token;
+	            }
+	        }
+	        return null;
+	    }
+	}
+	tokenStore.TokenStore = TokenStore;
+	function isComma(token) {
+	    return token.type === "Punctuator" && token.value === ",";
+	}
+	tokenStore.isComma = isComma;
+	return tokenStore;
+}
+
+var hasRequiredValidate;
+
+function requireValidate () {
+	if (hasRequiredValidate) return validate;
+	hasRequiredValidate = 1;
+	Object.defineProperty(validate, "__esModule", { value: true });
+	validate.isStaticValueIdentifier = validate.validateNode = void 0;
+	const errors_1 = requireErrors();
+	const token_store_1 = requireTokenStore();
+	const utils_1 = requireUtils();
+	const lineBreakPattern = /\r\n|[\n\r\u2028\u2029]/u;
+	const octalNumericLiteralPattern = /^0o/iu;
+	const legacyOctalNumericLiteralPattern = /^0\d/u;
+	const binaryNumericLiteralPattern = /^0b/iu;
+	const unicodeCodepointEscapePattern = /\\u\{[\dA-Fa-f]+\}/uy;
+	function hasUnicodeCodepointEscapes(code) {
+	    let escaped = false;
+	    for (let index = 0; index < code.length - 4; index++) {
+	        if (escaped) {
+	            escaped = false;
+	            continue;
+	        }
+	        const char = code[index];
+	        if (char === "\\") {
+	            unicodeCodepointEscapePattern.lastIndex = index;
+	            if (unicodeCodepointEscapePattern.test(code)) {
+	                return true;
+	            }
+	            escaped = true;
+	        }
+	    }
+	    return false;
+	}
+	function validateNode(node, tokens, ctx) {
+	    if (node.type === "ObjectExpression") {
+	        validateObjectExpressionNode(node, tokens, ctx);
+	        return;
+	    }
+	    if (node.type === "Property") {
+	        validatePropertyNode(node, tokens, ctx);
+	        return;
+	    }
+	    if (node.type === "ArrayExpression") {
+	        validateArrayExpressionNode(node, tokens, ctx);
+	        return;
+	    }
+	    if (node.type === "Literal") {
+	        validateLiteralNode(node, tokens, ctx);
+	        return;
+	    }
+	    if (node.type === "UnaryExpression") {
+	        validateUnaryExpressionNode(node, tokens, ctx);
+	        return;
+	    }
+	    if (node.type === "Identifier") {
+	        validateIdentifierNode(node, tokens, ctx);
+	        return;
+	    }
+	    if (node.type === "TemplateLiteral") {
+	        validateTemplateLiteralNode(node, tokens, ctx);
+	        return;
+	    }
+	    if (node.type === "TemplateElement") {
+	        validateTemplateElementNode(node, tokens);
+	        return;
+	    }
+	    if (node.type === "BinaryExpression") {
+	        validateBinaryExpressionNode(node, tokens, ctx);
+	        return;
+	    }
+	    throw (0, errors_1.throwUnexpectedNodeError)(node, tokens);
+	}
+	validate.validateNode = validateNode;
+	function validateObjectExpressionNode(node, tokens, ctx) {
+	    if (node.type !== "ObjectExpression") {
+	        throw (0, errors_1.throwUnexpectedNodeError)(node, tokens);
+	    }
+	    for (const prop of node.properties) {
+	        setParent(prop, node);
+	    }
+	    if (!ctx.trailingCommas) {
+	        const token = tokens.getTokenBefore(tokens.getLastToken(node));
+	        if (token && (0, token_store_1.isComma)(token)) {
+	            throw (0, errors_1.throwUnexpectedTokenError)(",", token);
+	        }
+	    }
+	}
+	function validatePropertyNode(node, tokens, ctx) {
+	    if (node.type !== "Property") {
+	        throw (0, errors_1.throwUnexpectedNodeError)(node, tokens);
+	    }
+	    setParent(node.key, node);
+	    setParent(node.value, node);
+	    if (node.computed) {
+	        throw (0, errors_1.throwUnexpectedNodeError)(node, tokens);
+	    }
+	    if (node.method) {
+	        throw (0, errors_1.throwUnexpectedNodeError)(node.value, tokens);
+	    }
+	    if (node.shorthand) {
+	        throw (0, errors_1.throwExpectedTokenError)(":", node);
+	    }
+	    if (node.kind !== "init") {
+	        throw (0, errors_1.throwExpectedTokenError)(":", tokens.getFirstToken(node));
+	    }
+	    if (node.key.type === "Literal") {
+	        const keyValueType = typeof node.key.value;
+	        if (keyValueType === "number") {
+	            if (!ctx.numberProperties) {
+	                throw (0, errors_1.throwUnexpectedNodeError)(node.key, tokens);
+	            }
+	        }
+	        else if (keyValueType !== "string") {
+	            throw (0, errors_1.throwUnexpectedNodeError)(node.key, tokens);
+	        }
+	    }
+	    else if (node.key.type === "Identifier") {
+	        if (!ctx.unquoteProperties) {
+	            throw (0, errors_1.throwUnexpectedNodeError)(node.key, tokens);
+	        }
+	    }
+	    else {
+	        throw (0, errors_1.throwUnexpectedNodeError)(node.key, tokens);
+	    }
+	    if (node.value.type === "Identifier") {
+	        if (!isStaticValueIdentifier(node.value, ctx)) {
+	            throw (0, errors_1.throwUnexpectedNodeError)(node.value, tokens);
+	        }
+	    }
+	}
+	function validateArrayExpressionNode(node, tokens, ctx) {
+	    if (node.type !== "ArrayExpression") {
+	        throw (0, errors_1.throwUnexpectedNodeError)(node, tokens);
+	    }
+	    if (!ctx.trailingCommas) {
+	        const token = tokens.getTokenBefore(tokens.getLastToken(node));
+	        if (token && (0, token_store_1.isComma)(token)) {
+	            throw (0, errors_1.throwUnexpectedTokenError)(",", token);
+	        }
+	    }
+	    node.elements.forEach((child, index) => {
+	        if (!child) {
+	            if (ctx.sparseArrays) {
+	                return;
+	            }
+	            const beforeIndex = index - 1;
+	            const before = beforeIndex >= 0
+	                ? tokens.getLastToken(node.elements[beforeIndex])
+	                : tokens.getFirstToken(node);
+	            throw (0, errors_1.throwUnexpectedTokenError)(",", tokens.getTokenAfter(before, token_store_1.isComma));
+	        }
+	        if (child.type === "Identifier") {
+	            if (!isStaticValueIdentifier(child, ctx)) {
+	                throw (0, errors_1.throwUnexpectedNodeError)(child, tokens);
+	            }
+	        }
+	        setParent(child, node);
+	    });
+	}
+	function validateLiteralNode(node, tokens, ctx) {
+	    if (node.type !== "Literal") {
+	        throw (0, errors_1.throwUnexpectedNodeError)(node, tokens);
+	    }
+	    if ((0, utils_1.isRegExpLiteral)(node)) {
+	        if (!ctx.regExpLiterals) {
+	            throw (0, errors_1.throwUnexpectedNodeError)(node, tokens);
+	        }
+	    }
+	    else if (node.bigint) {
+	        if (!ctx.bigintLiterals) {
+	            throw (0, errors_1.throwUnexpectedNodeError)(node, tokens);
+	        }
+	    }
+	    else {
+	        validateLiteral(node, ctx);
+	    }
+	}
+	function validateLiteral(node, ctx) {
+	    const value = node.value;
+	    if ((!ctx.invalidJsonNumbers ||
+	        !ctx.leadingOrTrailingDecimalPoints ||
+	        !ctx.numericSeparators) &&
+	        typeof value === "number") {
+	        const text = node.raw;
+	        if (!ctx.leadingOrTrailingDecimalPoints) {
+	            if (text.startsWith(".")) {
+	                throw (0, errors_1.throwUnexpectedTokenError)(".", node);
+	            }
+	            if (text.endsWith(".")) {
+	                throw (0, errors_1.throwUnexpectedTokenError)(".", {
+	                    range: [node.range[1] - 1, node.range[1]],
+	                    loc: {
+	                        start: {
+	                            line: node.loc.end.line,
+	                            column: node.loc.end.column - 1,
+	                        },
+	                        end: node.loc.end,
+	                    },
+	                });
+	            }
+	        }
+	        if (!ctx.numericSeparators) {
+	            if (text.includes("_")) {
+	                const index = text.indexOf("_");
+	                throw (0, errors_1.throwUnexpectedTokenError)("_", {
+	                    range: [node.range[0] + index, node.range[0] + index + 1],
+	                    loc: {
+	                        start: {
+	                            line: node.loc.start.line,
+	                            column: node.loc.start.column + index,
+	                        },
+	                        end: {
+	                            line: node.loc.start.line,
+	                            column: node.loc.start.column + index + 1,
+	                        },
+	                    },
+	                });
+	            }
+	        }
+	        if (!ctx.octalNumericLiterals) {
+	            if (octalNumericLiteralPattern.test(text)) {
+	                throw (0, errors_1.throwUnexpectedError)("octal numeric literal", node);
+	            }
+	        }
+	        if (!ctx.legacyOctalNumericLiterals) {
+	            if (legacyOctalNumericLiteralPattern.test(text)) {
+	                throw (0, errors_1.throwUnexpectedError)("legacy octal numeric literal", node);
+	            }
+	        }
+	        if (!ctx.binaryNumericLiterals) {
+	            if (binaryNumericLiteralPattern.test(text)) {
+	                throw (0, errors_1.throwUnexpectedError)("binary numeric literal", node);
+	            }
+	        }
+	        if (!ctx.invalidJsonNumbers) {
+	            try {
+	                JSON.parse(text);
+	            }
+	            catch (_a) {
+	                throw (0, errors_1.throwInvalidNumberError)(text, node);
+	            }
+	        }
+	    }
+	    if ((!ctx.multilineStrings ||
+	        !ctx.singleQuotes ||
+	        !ctx.unicodeCodepointEscapes) &&
+	        typeof value === "string") {
+	        if (!ctx.singleQuotes) {
+	            if (node.raw.startsWith("'")) {
+	                throw (0, errors_1.throwUnexpectedError)("single quoted", node);
+	            }
+	        }
+	        if (!ctx.multilineStrings) {
+	            if (lineBreakPattern.test(node.raw)) {
+	                throw (0, errors_1.throwUnexpectedError)("multiline string", node);
+	            }
+	        }
+	        if (!ctx.unicodeCodepointEscapes) {
+	            if (hasUnicodeCodepointEscapes(node.raw)) {
+	                throw (0, errors_1.throwUnexpectedError)("unicode codepoint escape", node);
+	            }
+	        }
+	    }
+	    return undefined;
+	}
+	function validateUnaryExpressionNode(node, tokens, ctx) {
+	    if (node.type !== "UnaryExpression") {
+	        throw (0, errors_1.throwUnexpectedNodeError)(node, tokens);
+	    }
+	    const operator = node.operator;
+	    if (operator === "+") {
+	        if (!ctx.plusSigns) {
+	            throw (0, errors_1.throwUnexpectedTokenError)("+", node);
+	        }
+	    }
+	    else if (operator !== "-") {
+	        throw (0, errors_1.throwUnexpectedNodeError)(node, tokens);
+	    }
+	    const argument = node.argument;
+	    if (argument.type === "Literal") {
+	        if (typeof argument.value !== "number") {
+	            throw (0, errors_1.throwUnexpectedNodeError)(argument, tokens);
+	        }
+	    }
+	    else if (argument.type === "Identifier") {
+	        if (!isNumberIdentifier(argument, ctx)) {
+	            throw (0, errors_1.throwUnexpectedNodeError)(argument, tokens);
+	        }
+	    }
+	    else {
+	        throw (0, errors_1.throwUnexpectedNodeError)(argument, tokens);
+	    }
+	    if (!ctx.spacedSigns) {
+	        if (node.range[0] + 1 < argument.range[0]) {
+	            throw (0, errors_1.throwUnexpectedSpaceError)(tokens.getFirstToken(node));
+	        }
+	    }
+	    setParent(argument, node);
+	}
+	function validateIdentifierNode(node, tokens, ctx) {
+	    if (node.type !== "Identifier") {
+	        throw (0, errors_1.throwUnexpectedNodeError)(node, tokens);
+	    }
+	    if (!ctx.escapeSequenceInIdentifier) {
+	        if (node.name.length < node.range[1] - node.range[0]) {
+	            throw (0, errors_1.throwUnexpectedError)("escape sequence", node);
+	        }
+	    }
+	}
+	function validateTemplateLiteralNode(node, tokens, ctx) {
+	    if (node.type !== "TemplateLiteral") {
+	        throw (0, errors_1.throwUnexpectedNodeError)(node, tokens);
+	    }
+	    if (!ctx.templateLiterals) {
+	        throw (0, errors_1.throwUnexpectedNodeError)(node, tokens);
+	    }
+	    if (node.expressions.length) {
+	        const token = tokens.getFirstToken(node.quasis[0]);
+	        const loc = {
+	            loc: {
+	                start: {
+	                    line: token.loc.end.line,
+	                    column: token.loc.end.column - 2,
+	                },
+	                end: token.loc.end,
+	            },
+	            range: [token.range[1] - 2, token.range[1]],
+	        };
+	        throw (0, errors_1.throwUnexpectedTokenError)("$", loc);
+	    }
+	    if (!ctx.unicodeCodepointEscapes) {
+	        if (hasUnicodeCodepointEscapes(node.quasis[0].value.raw)) {
+	            throw (0, errors_1.throwUnexpectedError)("unicode codepoint escape", node);
+	        }
+	    }
+	    for (const q of node.quasis) {
+	        setParent(q, node);
+	    }
+	}
+	function validateTemplateElementNode(node, tokens) {
+	    if (node.type !== "TemplateElement") {
+	        throw (0, errors_1.throwUnexpectedNodeError)(node, tokens);
+	    }
+	    const { cooked } = node.value;
+	    if (cooked == null) {
+	        throw (0, errors_1.throwUnexpectedNodeError)(node, tokens);
+	    }
+	    const startOffset = -1;
+	    const endOffset = node.tail ? 1 : 2;
+	    node.start += startOffset;
+	    node.end += endOffset;
+	    node.range[0] += startOffset;
+	    node.range[1] += endOffset;
+	    node.loc.start.column += startOffset;
+	    node.loc.end.column += endOffset;
+	}
+	function validateBinaryExpressionNode(node, tokens, ctx) {
+	    if (node.type !== "BinaryExpression") {
+	        throw (0, errors_1.throwUnexpectedNodeError)(node, tokens);
+	    }
+	    if (!ctx.staticExpressions) {
+	        throw (0, errors_1.throwUnexpectedNodeError)(node, tokens);
+	    }
+	    const { operator, left, right } = node;
+	    if (operator !== "+" &&
+	        operator !== "-" &&
+	        operator !== "*" &&
+	        operator !== "/" &&
+	        operator !== "%" &&
+	        operator !== "**") {
+	        throw throwOperatorError();
+	    }
+	    validateExpr(left, throwOperatorError);
+	    validateExpr(right, () => (0, errors_1.throwUnexpectedNodeError)(right, tokens));
+	    function validateExpr(expr, throwError) {
+	        if (expr.type === "Literal") {
+	            if (typeof expr.value !== "number") {
+	                throw throwError();
+	            }
+	        }
+	        else if (expr.type !== "BinaryExpression" &&
+	            expr.type !== "UnaryExpression") {
+	            throw throwError();
+	        }
+	        setParent(expr, node);
+	    }
+	    function throwOperatorError() {
+	        throw (0, errors_1.throwUnexpectedTokenError)(operator, tokens.getTokenAfter(tokens.getFirstToken(node), (t) => t.value === operator) || node);
+	    }
+	}
+	function isStaticValueIdentifier(node, ctx) {
+	    if (isNumberIdentifier(node, ctx)) {
+	        return true;
+	    }
+	    return node.name === "undefined" && ctx.undefinedKeywords;
+	}
+	validate.isStaticValueIdentifier = isStaticValueIdentifier;
+	function isNumberIdentifier(node, ctx) {
+	    if (node.name === "Infinity" && ctx.infinities) {
+	        return true;
+	    }
+	    if (node.name === "NaN" && ctx.nans) {
+	        return true;
+	    }
+	    return false;
+	}
+	function setParent(prop, parent) {
+	    prop.parent = parent;
+	}
+	return validate;
+}
+
+var acorn = {};
+
+const name = "acorn";
+const description = "ECMAScript parser";
+const homepage = "https://github.com/acornjs/acorn";
+const main = "dist/acorn.js";
+const types = "dist/acorn.d.ts";
+const module = "dist/acorn.mjs";
+const exports = {
+	".": [
+		{
+			"import": "./dist/acorn.mjs",
+			require: "./dist/acorn.js",
+			"default": "./dist/acorn.js"
+		},
+		"./dist/acorn.js"
+	],
+	"./package.json": "./package.json"
+};
+const version = "8.14.1";
+const engines = {
+	node: ">=0.4.0"
+};
+const maintainers = [
+	{
+		name: "Marijn Haverbeke",
+		email: "marijnh@gmail.com",
+		web: "https://marijnhaverbeke.nl"
+	},
+	{
+		name: "Ingvar Stepanyan",
+		email: "me@rreverser.com",
+		web: "https://rreverser.com/"
+	},
+	{
+		name: "Adrian Heine",
+		web: "http://adrianheine.de"
+	}
+];
+const repository = {
+	type: "git",
+	url: "git+https://github.com/acornjs/acorn.git"
+};
+const license = "MIT";
+const scripts = {
+	prepare: "cd ..; npm run build:main"
+};
+const bin = {
+	acorn: "bin/acorn"
+};
+const _package = {
+	name: name,
+	description: description,
+	homepage: homepage,
+	main: main,
+	types: types,
+	module: module,
+	exports: exports,
+	version: version,
+	engines: engines,
+	maintainers: maintainers,
+	repository: repository,
+	license: license,
+	scripts: scripts,
+	bin: bin
+};
+
+const _package$1 = {
+    __proto__: null,
+    bin: bin,
+    default: _package,
+    description: description,
+    engines: engines,
+    exports: exports,
+    homepage: homepage,
+    license: license,
+    main: main,
+    maintainers: maintainers,
+    module: module,
+    name: name,
+    repository: repository,
+    scripts: scripts,
+    types: types,
+    version: version
+};
+
+const require$$2 = /*@__PURE__*/getAugmentedNamespace(_package$1);
+
+var hasRequiredAcorn;
+
+function requireAcorn () {
+	if (hasRequiredAcorn) return acorn;
+	hasRequiredAcorn = 1;
+	Object.defineProperty(acorn, "__esModule", { value: true });
+	acorn.getAcorn = void 0;
+	const module_1 = require$$2$1;
+	const require_utils_1 = requireRequireUtils();
+	let acornCache;
+	function getAcorn() {
+	    if (!acornCache) {
+	        acornCache = (0, require_utils_1.loadNewest)([
+	            {
+	                getPkg() {
+	                    return (0, require_utils_1.requireFromCwd)("acorn/package.json");
+	                },
+	                get() {
+	                    return (0, require_utils_1.requireFromCwd)("acorn");
+	                },
+	            },
+	            {
+	                getPkg() {
+	                    return requireFromEspree("acorn/package.json");
+	                },
+	                get() {
+	                    return requireFromEspree("acorn");
+	                },
+	            },
+	            {
+	                getPkg() {
+	                    return require$$2;
+	                },
+	                get() {
+	                    return requireAcorn$1();
+	                },
+	            },
+	        ]);
+	    }
+	    return acornCache;
+	}
+	acorn.getAcorn = getAcorn;
+	function requireFromEspree(module) {
+	    try {
+	        return (0, module_1.createRequire)(getEspreePath())(module);
+	    }
+	    catch (_a) {
+	    }
+	    return null;
+	}
+	function getEspreePath() {
+	    return (0, require_utils_1.loadNewest)([
+	        {
+	            getPkg() {
+	                return (0, require_utils_1.requireFromCwd)("espree/package.json");
+	            },
+	            get() {
+	                return (0, require_utils_1.getRequireFromCwd)().resolve("espree");
+	            },
+	        },
+	        {
+	            getPkg() {
+	                return (0, require_utils_1.requireFromLinter)("espree/package.json");
+	            },
+	            get() {
+	                return (0, require_utils_1.getRequireFromLinter)().resolve("espree");
+	            },
+	        },
+	        {
+	            getPkg() {
+	                return require$$4;
+	            },
+	            get() {
+	                return require.resolve("espree");
+	            },
+	        },
+	    ]);
+	}
+	return acorn;
+}
+
+var hasRequiredConvert;
+
+function requireConvert () {
+	if (hasRequiredConvert) return convert;
+	hasRequiredConvert = 1;
+	Object.defineProperty(convert, "__esModule", { value: true });
+	convert.convertProgramNode = convert.TokenConvertor = void 0;
+	const validate_1 = requireValidate();
+	const errors_1 = requireErrors();
+	const acorn_1 = requireAcorn();
+	class TokenConvertor {
+	    constructor(ctx, code) {
+	        this.templateBuffer = [];
+	        this.ctx = ctx;
+	        this.code = code;
+	        this.tokTypes = (0, acorn_1.getAcorn)().tokTypes;
+	    }
+	    convertToken(token) {
+	        const { tokTypes } = this;
+	        let type, value;
+	        const additional = {};
+	        if (token.type === tokTypes.string) {
+	            type = "String";
+	            value = this.code.slice(...token.range);
+	        }
+	        else if (token.type === tokTypes.num) {
+	            type = "Numeric";
+	            value = this.code.slice(...token.range);
+	        }
+	        else if (token.type.keyword) {
+	            if (token.type.keyword === "true" || token.type.keyword === "false") {
+	                type = "Boolean";
+	            }
+	            else if (token.type.keyword === "null") {
+	                type = "Null";
+	            }
+	            else {
+	                type = "Keyword";
+	            }
+	            value = token.value;
+	        }
+	        else if (token.type === tokTypes.braceL ||
+	            token.type === tokTypes.braceR ||
+	            token.type === tokTypes.bracketL ||
+	            token.type === tokTypes.bracketR ||
+	            token.type === tokTypes.colon ||
+	            token.type === tokTypes.comma ||
+	            token.type === tokTypes.plusMin) {
+	            type = "Punctuator";
+	            value = this.code.slice(...token.range);
+	        }
+	        else if (token.type === tokTypes.name) {
+	            type = "Identifier";
+	            value = token.value;
+	        }
+	        else if (token.type === tokTypes.backQuote) {
+	            if (this.templateBuffer.length > 0) {
+	                const first = this.templateBuffer[0];
+	                this.templateBuffer.length = 0;
+	                return {
+	                    type: "Template",
+	                    value: this.code.slice(first.start, token.end),
+	                    range: [first.start, token.end],
+	                    loc: {
+	                        start: first.loc.start,
+	                        end: token.loc.end,
+	                    },
+	                };
+	            }
+	            this.templateBuffer.push(token);
+	            return null;
+	        }
+	        else if (token.type === tokTypes.template) {
+	            if (this.templateBuffer.length === 0) {
+	                return (0, errors_1.throwUnexpectedTokenError)(this.code.slice(...token.range), token);
+	            }
+	            this.templateBuffer.push(token);
+	            return null;
+	        }
+	        else if (token.type === tokTypes.regexp) {
+	            const reValue = token.value;
+	            type = "RegularExpression";
+	            additional.regex = {
+	                flags: reValue.flags,
+	                pattern: reValue.pattern,
+	            };
+	            value = `/${reValue.pattern}/${reValue.flags}`;
+	        }
+	        else if (this.ctx.parentheses &&
+	            (token.type === tokTypes.parenL || token.type === tokTypes.parenR)) {
+	            type = "Punctuator";
+	            value = this.code.slice(...token.range);
+	        }
+	        else if (this.ctx.staticExpressions &&
+	            (token.type === tokTypes.star ||
+	                token.type === tokTypes.slash ||
+	                token.type === tokTypes.modulo ||
+	                token.type === tokTypes.starstar)) {
+	            type = "Punctuator";
+	            value = this.code.slice(...token.range);
+	        }
+	        else {
+	            return (0, errors_1.throwUnexpectedTokenError)(this.code.slice(...token.range), token);
+	        }
+	        token.type = type;
+	        token.value = value;
+	        for (const k in additional) {
+	            token[k] = additional[k];
+	        }
+	        return token;
+	    }
+	}
+	convert.TokenConvertor = TokenConvertor;
+	function convertProgramNode(node, tokens, ctx, code) {
+	    if (node.type !== "JSONObjectExpression" &&
+	        node.type !== "JSONArrayExpression" &&
+	        node.type !== "JSONLiteral" &&
+	        node.type !== "JSONUnaryExpression" &&
+	        node.type !== "JSONIdentifier" &&
+	        node.type !== "JSONTemplateLiteral" &&
+	        node.type !== "JSONBinaryExpression") {
+	        return (0, errors_1.throwUnexpectedNodeError)(node, tokens);
+	    }
+	    if (node.type === "JSONIdentifier") {
+	        if (!(0, validate_1.isStaticValueIdentifier)(node, ctx)) {
+	            return (0, errors_1.throwUnexpectedNodeError)(node, tokens);
+	        }
+	    }
+	    const body = Object.assign(Object.assign({ type: "JSONExpressionStatement", expression: node }, cloneLocation(node)), { parent: null });
+	    setParent(node, body);
+	    const end = code.length;
+	    const endLoc = (0, acorn_1.getAcorn)().getLineInfo(code, end);
+	    const nn = {
+	        type: "Program",
+	        body: [body],
+	        comments: [],
+	        tokens: [],
+	        range: [0, end],
+	        loc: {
+	            start: {
+	                line: 1,
+	                column: 0,
+	            },
+	            end: {
+	                line: endLoc.line,
+	                column: endLoc.column,
+	            },
+	        },
+	        parent: null,
+	    };
+	    setParent(body, nn);
+	    return nn;
+	}
+	convert.convertProgramNode = convertProgramNode;
+	function cloneLocation(node) {
+	    const range = node.range;
+	    const loc = node.loc;
+	    return {
+	        range: [range[0], range[1]],
+	        loc: {
+	            start: {
+	                line: loc.start.line,
+	                column: loc.start.column,
+	            },
+	            end: {
+	                line: loc.end.line,
+	                column: loc.end.column,
+	            },
+	        },
+	    };
+	}
+	function setParent(prop, parent) {
+	    prop.parent = parent;
+	}
+	return convert;
+}
+
+var extendParser = {};
+
+var hasRequiredExtendParser;
+
+function requireExtendParser () {
+	if (hasRequiredExtendParser) return extendParser;
+	hasRequiredExtendParser = 1;
+	Object.defineProperty(extendParser, "__esModule", { value: true });
+	extendParser.getAnyTokenErrorParser = extendParser.getParser = void 0;
+	const validate_1 = requireValidate();
+	const acorn_1 = requireAcorn();
+	const errors_1 = requireErrors();
+	const convert_1 = requireConvert();
+	let parserCache;
+	const PRIVATE = Symbol("ExtendParser#private");
+	const PRIVATE_PROCESS_NODE = Symbol("ExtendParser#processNode");
+	function getParser() {
+	    if (parserCache) {
+	        return parserCache;
+	    }
+	    parserCache = class ExtendParser extends (0, acorn_1.getAcorn)().Parser {
+	        constructor(options, code, pos) {
+	            super((() => {
+	                const tokenConvertor = new convert_1.TokenConvertor(options.ctx, code);
+	                const onToken = options.onToken ||
+	                    ((token) => {
+	                        const t = tokenConvertor.convertToken(token);
+	                        if (t) {
+	                            this[PRIVATE].tokenStore.add(t);
+	                        }
+	                    });
+	                return {
+	                    ecmaVersion: options.ecmaVersion,
+	                    sourceType: options.sourceType,
+	                    ranges: true,
+	                    locations: true,
+	                    allowReserved: true,
+	                    onToken,
+	                    onComment: (block, text, start, end, startLoc, endLoc) => {
+	                        const comment = {
+	                            type: block ? "Block" : "Line",
+	                            value: text,
+	                            range: [start, end],
+	                            loc: {
+	                                start: startLoc,
+	                                end: endLoc,
+	                            },
+	                        };
+	                        if (!this[PRIVATE].ctx.comments) {
+	                            throw (0, errors_1.throwUnexpectedCommentError)(comment);
+	                        }
+	                        this[PRIVATE].comments.push(comment);
+	                    },
+	                };
+	            })(), code, pos);
+	            this[PRIVATE] = {
+	                code,
+	                ctx: options.ctx,
+	                tokenStore: options.tokenStore,
+	                comments: options.comments,
+	                nodes: options.nodes,
+	            };
+	        }
+	        finishNode(...args) {
+	            const result = super.finishNode(...args);
+	            return this[PRIVATE_PROCESS_NODE](result);
+	        }
+	        finishNodeAt(...args) {
+	            const result = super.finishNodeAt(...args);
+	            return this[PRIVATE_PROCESS_NODE](result);
+	        }
+	        [PRIVATE_PROCESS_NODE](node) {
+	            const { tokenStore, ctx, nodes } = this[PRIVATE];
+	            (0, validate_1.validateNode)(node, tokenStore, ctx);
+	            nodes.push(node);
+	            return node;
+	        }
+	        raise(pos, message) {
+	            const loc = (0, acorn_1.getAcorn)().getLineInfo(this[PRIVATE].code, pos);
+	            const err = new errors_1.ParseError(message, pos, loc.line, loc.column + 1);
+	            throw err;
+	        }
+	        raiseRecoverable(pos, message) {
+	            this.raise(pos, message);
+	        }
+	        unexpected(pos) {
+	            if (pos != null) {
+	                this.raise(pos, "Unexpected token.");
+	                return;
+	            }
+	            const start = this.start;
+	            const end = this.end;
+	            const token = this[PRIVATE].code.slice(start, end);
+	            if (token) {
+	                const message = `Unexpected token '${token}'.`;
+	                this.raise(start, message);
+	            }
+	            else {
+	                if (!this[PRIVATE].nodes.length) {
+	                    this.raise(0, "Expected to be an expression, but got empty.");
+	                }
+	                if (this[PRIVATE].tokenStore.tokens.length) {
+	                    const last = this[PRIVATE].tokenStore.tokens[this[PRIVATE].tokenStore.tokens.length - 1];
+	                    this.raise(last.range[0], `Unexpected token '${last.value}'.`);
+	                }
+	                this.raise(start, "Unexpected token.");
+	            }
+	        }
+	    };
+	    return parserCache;
+	}
+	extendParser.getParser = getParser;
+	function getAnyTokenErrorParser() {
+	    const parser = class ExtendParser extends getParser() {
+	        constructor(options, code, pos) {
+	            super(Object.assign(Object.assign({}, options), { onToken: (token) => {
+	                    return (0, errors_1.throwUnexpectedTokenError)(code.slice(...token.range), token);
+	                } }), code, pos);
+	        }
+	    };
+	    return parser;
+	}
+	extendParser.getAnyTokenErrorParser = getAnyTokenErrorParser;
+	return extendParser;
+}
+
+var hasRequiredParser;
+
+function requireParser () {
+	if (hasRequiredParser) return parser;
+	hasRequiredParser = 1;
+	Object.defineProperty(parser, "__esModule", { value: true });
+	parser.parseForESLint = void 0;
+	const espree_1 = requireEspree();
+	const visitor_keys_1 = requireVisitorKeys();
+	const convert_1 = requireConvert();
+	const token_store_1 = requireTokenStore();
+	const semver_1 = requireSemver();
+	const extend_parser_1 = requireExtendParser();
+	const DEFAULT_ECMA_VERSION = "latest";
+	function parseForESLint(code, options) {
+	    var _a, _b, _c, _d;
+	    const parserOptions = Object.assign({ filePath: "<input>", ecmaVersion: DEFAULT_ECMA_VERSION }, options || {}, {
+	        loc: true,
+	        range: true,
+	        raw: true,
+	        tokens: true,
+	        comment: true,
+	        eslintVisitorKeys: true,
+	        eslintScopeManager: true,
+	    });
+	    parserOptions.ecmaVersion = normalizeEcmaVersion(parserOptions.ecmaVersion);
+	    const ctx = getJSONSyntaxContext(parserOptions.jsonSyntax);
+	    const tokens = [];
+	    const comments = [];
+	    const tokenStore = new token_store_1.TokenStore(tokens);
+	    const nodes = [];
+	    parserOptions.ctx = ctx;
+	    parserOptions.tokenStore = tokenStore;
+	    parserOptions.comments = comments;
+	    parserOptions.nodes = nodes;
+	    const baseAst = (0, extend_parser_1.getParser)().parseExpressionAt(code, 0, parserOptions);
+	    for (const node of nodes) {
+	        node.type = `JSON${node.type}`;
+	    }
+	    const ast = (0, convert_1.convertProgramNode)(baseAst, tokenStore, ctx, code);
+	    let lastIndex = Math.max(baseAst.range[1], (_b = (_a = tokens[tokens.length - 1]) === null || _a === void 0 ? void 0 : _a.range[1]) !== null && _b !== void 0 ? _b : 0, (_d = (_c = comments[comments.length - 1]) === null || _c === void 0 ? void 0 : _c.range[1]) !== null && _d !== void 0 ? _d : 0);
+	    let lastChar = code[lastIndex];
+	    while (lastChar === "\n" ||
+	        lastChar === "\r" ||
+	        lastChar === " " ||
+	        lastChar === "\t") {
+	        lastIndex++;
+	        lastChar = code[lastIndex];
+	    }
+	    if (lastIndex < code.length) {
+	        (0, extend_parser_1.getAnyTokenErrorParser)().parseExpressionAt(code, lastIndex, parserOptions);
+	    }
+	    ast.tokens = tokens;
+	    ast.comments = comments;
+	    return {
+	        ast,
+	        visitorKeys: (0, visitor_keys_1.getVisitorKeys)(),
+	        services: {
+	            isJSON: true,
+	        },
+	    };
+	}
+	parser.parseForESLint = parseForESLint;
+	function getJSONSyntaxContext(str) {
+	    const upperCase = str === null || str === void 0 ? void 0 : str.toUpperCase();
+	    if (upperCase === "JSON") {
+	        return {
+	            trailingCommas: false,
+	            comments: false,
+	            plusSigns: false,
+	            spacedSigns: false,
+	            leadingOrTrailingDecimalPoints: false,
+	            infinities: false,
+	            nans: false,
+	            numericSeparators: false,
+	            binaryNumericLiterals: false,
+	            octalNumericLiterals: false,
+	            legacyOctalNumericLiterals: false,
+	            invalidJsonNumbers: false,
+	            multilineStrings: false,
+	            unquoteProperties: false,
+	            singleQuotes: false,
+	            numberProperties: false,
+	            undefinedKeywords: false,
+	            sparseArrays: false,
+	            regExpLiterals: false,
+	            templateLiterals: false,
+	            bigintLiterals: false,
+	            unicodeCodepointEscapes: false,
+	            escapeSequenceInIdentifier: false,
+	            parentheses: false,
+	            staticExpressions: false,
+	        };
+	    }
+	    if (upperCase === "JSONC") {
+	        return {
+	            trailingCommas: true,
+	            comments: true,
+	            plusSigns: false,
+	            spacedSigns: false,
+	            leadingOrTrailingDecimalPoints: false,
+	            infinities: false,
+	            nans: false,
+	            numericSeparators: false,
+	            binaryNumericLiterals: false,
+	            octalNumericLiterals: false,
+	            legacyOctalNumericLiterals: false,
+	            invalidJsonNumbers: false,
+	            multilineStrings: false,
+	            unquoteProperties: false,
+	            singleQuotes: false,
+	            numberProperties: false,
+	            undefinedKeywords: false,
+	            sparseArrays: false,
+	            regExpLiterals: false,
+	            templateLiterals: false,
+	            bigintLiterals: false,
+	            unicodeCodepointEscapes: false,
+	            escapeSequenceInIdentifier: false,
+	            parentheses: false,
+	            staticExpressions: false,
+	        };
+	    }
+	    if (upperCase === "JSON5") {
+	        return {
+	            trailingCommas: true,
+	            comments: true,
+	            plusSigns: true,
+	            spacedSigns: true,
+	            leadingOrTrailingDecimalPoints: true,
+	            infinities: true,
+	            nans: true,
+	            numericSeparators: false,
+	            binaryNumericLiterals: false,
+	            octalNumericLiterals: false,
+	            legacyOctalNumericLiterals: false,
+	            invalidJsonNumbers: true,
+	            multilineStrings: true,
+	            unquoteProperties: true,
+	            singleQuotes: true,
+	            numberProperties: false,
+	            undefinedKeywords: false,
+	            sparseArrays: false,
+	            regExpLiterals: false,
+	            templateLiterals: false,
+	            bigintLiterals: false,
+	            unicodeCodepointEscapes: false,
+	            escapeSequenceInIdentifier: false,
+	            parentheses: false,
+	            staticExpressions: false,
+	        };
+	    }
+	    return {
+	        trailingCommas: true,
+	        comments: true,
+	        plusSigns: true,
+	        spacedSigns: true,
+	        leadingOrTrailingDecimalPoints: true,
+	        infinities: true,
+	        nans: true,
+	        numericSeparators: true,
+	        binaryNumericLiterals: true,
+	        octalNumericLiterals: true,
+	        legacyOctalNumericLiterals: true,
+	        invalidJsonNumbers: true,
+	        multilineStrings: true,
+	        unquoteProperties: true,
+	        singleQuotes: true,
+	        numberProperties: true,
+	        undefinedKeywords: true,
+	        sparseArrays: true,
+	        regExpLiterals: true,
+	        templateLiterals: true,
+	        bigintLiterals: true,
+	        unicodeCodepointEscapes: true,
+	        escapeSequenceInIdentifier: true,
+	        parentheses: true,
+	        staticExpressions: true,
+	    };
+	}
+	function normalizeEcmaVersion(version) {
+	    const espree = (0, espree_1.getEspree)();
+	    const latestEcmaVersion = getLatestEcmaVersion(espree);
+	    if (version == null || version === "latest") {
+	        return latestEcmaVersion;
+	    }
+	    return Math.min(getEcmaVersionYear(version), latestEcmaVersion);
+	}
+	function getLatestEcmaVersion(espree) {
+	    if (espree.latestEcmaVersion == null) {
+	        for (const { v, latest } of [
+	            { v: "6.1.0", latest: 2020 },
+	            { v: "4.0.0", latest: 2019 },
+	        ]) {
+	            if ((0, semver_1.lte)(v, espree.version)) {
+	                return latest;
+	            }
+	        }
+	        return 2018;
+	    }
+	    return getEcmaVersionYear(espree.latestEcmaVersion);
+	}
+	function getEcmaVersionYear(version) {
+	    return version > 5 && version < 2015 ? version + 2009 : version;
+	}
+	return parser;
+}
+
+var traverse = {};
+
+var hasRequiredTraverse;
+
+function requireTraverse () {
+	if (hasRequiredTraverse) return traverse;
+	hasRequiredTraverse = 1;
+	Object.defineProperty(traverse, "__esModule", { value: true });
+	traverse.traverseNodes = traverse.getNodes = traverse.getKeys = traverse.getFallbackKeys = void 0;
+	const visitor_keys_1 = requireVisitorKeys();
+	function fallbackKeysFilter(key) {
+	    let value = null;
+	    return (key !== "comments" &&
+	        key !== "leadingComments" &&
+	        key !== "loc" &&
+	        key !== "parent" &&
+	        key !== "range" &&
+	        key !== "tokens" &&
+	        key !== "trailingComments" &&
+	        (value = this[key]) !== null &&
+	        typeof value === "object" &&
+	        (typeof value.type === "string" || Array.isArray(value)));
+	}
+	function getFallbackKeys(node) {
+	    return Object.keys(node).filter(fallbackKeysFilter, node);
+	}
+	traverse.getFallbackKeys = getFallbackKeys;
+	function getKeys(node, visitorKeys) {
+	    const keys = (visitorKeys || (0, visitor_keys_1.getVisitorKeys)())[node.type] || getFallbackKeys(node);
+	    return keys.filter((key) => !getNodes(node, key).next().done);
+	}
+	traverse.getKeys = getKeys;
+	function* getNodes(node, key) {
+	    const child = node[key];
+	    if (Array.isArray(child)) {
+	        for (const c of child) {
+	            if (isNode(c)) {
+	                yield c;
+	            }
+	        }
+	    }
+	    else if (isNode(child)) {
+	        yield child;
+	    }
+	}
+	traverse.getNodes = getNodes;
+	function isNode(x) {
+	    return x !== null && typeof x === "object" && typeof x.type === "string";
+	}
+	function traverse$1(node, parent, visitor) {
+	    visitor.enterNode(node, parent);
+	    const keys = getKeys(node, visitor.visitorKeys);
+	    for (const key of keys) {
+	        for (const child of getNodes(node, key)) {
+	            traverse$1(child, node, visitor);
+	        }
+	    }
+	    visitor.leaveNode(node, parent);
+	}
+	function traverseNodes(node, visitor) {
+	    traverse$1(node, null, visitor);
+	}
+	traverse.traverseNodes = traverseNodes;
+	return traverse;
+}
+
+var ast = {};
+
+var hasRequiredAst;
+
+function requireAst () {
+	if (hasRequiredAst) return ast;
+	hasRequiredAst = 1;
+	Object.defineProperty(ast, "__esModule", { value: true });
+	ast.getStaticJSONValue = ast.isUndefinedIdentifier = ast.isNumberIdentifier = ast.isExpression = void 0;
+	function isExpression(node) {
+	    if (node.type === "JSONIdentifier" || node.type === "JSONLiteral") {
+	        const parent = node.parent;
+	        if (parent.type === "JSONProperty" && parent.key === node) {
+	            return false;
+	        }
+	        return true;
+	    }
+	    if (node.type === "JSONObjectExpression" ||
+	        node.type === "JSONArrayExpression" ||
+	        node.type === "JSONUnaryExpression" ||
+	        node.type === "JSONTemplateLiteral" ||
+	        node.type === "JSONBinaryExpression") {
+	        return true;
+	    }
+	    return false;
+	}
+	ast.isExpression = isExpression;
+	function isNumberIdentifier(node) {
+	    return (isExpression(node) && (node.name === "Infinity" || node.name === "NaN"));
+	}
+	ast.isNumberIdentifier = isNumberIdentifier;
+	function isUndefinedIdentifier(node) {
+	    return isExpression(node) && node.name === "undefined";
+	}
+	ast.isUndefinedIdentifier = isUndefinedIdentifier;
+	const resolver = {
+	    Program(node) {
+	        if (node.body.length !== 1 ||
+	            node.body[0].type !== "JSONExpressionStatement") {
+	            throw new Error("Illegal argument");
+	        }
+	        return getStaticJSONValue(node.body[0]);
+	    },
+	    JSONExpressionStatement(node) {
+	        return getStaticJSONValue(node.expression);
+	    },
+	    JSONObjectExpression(node) {
+	        const object = {};
+	        for (const prop of node.properties) {
+	            Object.assign(object, getStaticJSONValue(prop));
+	        }
+	        return object;
+	    },
+	    JSONProperty(node) {
+	        const keyName = node.key.type === "JSONLiteral" ? `${node.key.value}` : node.key.name;
+	        return {
+	            [keyName]: getStaticJSONValue(node.value),
+	        };
+	    },
+	    JSONArrayExpression(node) {
+	        const array = [];
+	        for (let index = 0; index < node.elements.length; index++) {
+	            const element = node.elements[index];
+	            if (element) {
+	                array[index] = getStaticJSONValue(element);
+	            }
+	        }
+	        return array;
+	    },
+	    JSONLiteral(node) {
+	        if (node.regex) {
+	            try {
+	                return new RegExp(node.regex.pattern, node.regex.flags);
+	            }
+	            catch (_a) {
+	                return `/${node.regex.pattern}/${node.regex.flags}`;
+	            }
+	        }
+	        if (node.bigint != null) {
+	            try {
+	                return BigInt(node.bigint);
+	            }
+	            catch (_b) {
+	                return `${node.bigint}`;
+	            }
+	        }
+	        return node.value;
+	    },
+	    JSONUnaryExpression(node) {
+	        const value = getStaticJSONValue(node.argument);
+	        return node.operator === "-" ? -value : value;
+	    },
+	    JSONBinaryExpression(node) {
+	        const left = getStaticJSONValue(node.left);
+	        const right = getStaticJSONValue(node.right);
+	        return node.operator === "+"
+	            ? left + right
+	            : node.operator === "-"
+	                ? left - right
+	                : node.operator === "*"
+	                    ? left * right
+	                    : node.operator === "/"
+	                        ? left / right
+	                        : node.operator === "%"
+	                            ? left % right
+	                            : node.operator === "**"
+	                                ? Math.pow(left, right)
+	                                : (() => {
+	                                    throw new Error(`Unknown operator: ${node.operator}`);
+	                                })();
+	    },
+	    JSONIdentifier(node) {
+	        if (node.name === "Infinity") {
+	            return Infinity;
+	        }
+	        if (node.name === "NaN") {
+	            return NaN;
+	        }
+	        if (node.name === "undefined") {
+	            return undefined;
+	        }
+	        throw new Error("Illegal argument");
+	    },
+	    JSONTemplateLiteral(node) {
+	        return getStaticJSONValue(node.quasis[0]);
+	    },
+	    JSONTemplateElement(node) {
+	        return node.value.cooked;
+	    },
+	};
+	function getStaticJSONValue(node) {
+	    return resolver[node.type](node);
+	}
+	ast.getStaticJSONValue = getStaticJSONValue;
+	return ast;
+}
+
+var meta = {};
+
+var hasRequiredMeta;
+
+function requireMeta () {
+	if (hasRequiredMeta) return meta;
+	hasRequiredMeta = 1;
+	Object.defineProperty(meta, "__esModule", { value: true });
+	meta.version = meta.name = void 0;
+	meta.name = "jsonc-eslint-parser";
+	meta.version = "2.4.0";
+	return meta;
+}
+
+var hasRequiredLib;
+
+function requireLib () {
+	if (hasRequiredLib) return lib;
+	hasRequiredLib = 1;
+	(function (exports) {
+		var __createBinding = (lib && lib.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    var desc = Object.getOwnPropertyDescriptor(m, k);
+		    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+		      desc = { enumerable: true, get: function() { return m[k]; } };
+		    }
+		    Object.defineProperty(o, k2, desc);
+		}) : (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    o[k2] = m[k];
+		}));
+		var __setModuleDefault = (lib && lib.__setModuleDefault) || (Object.create ? (function(o, v) {
+		    Object.defineProperty(o, "default", { enumerable: true, value: v });
+		}) : function(o, v) {
+		    o["default"] = v;
+		});
+		var __importStar = (lib && lib.__importStar) || function (mod) {
+		    if (mod && mod.__esModule) return mod;
+		    var result = {};
+		    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+		    __setModuleDefault(result, mod);
+		    return result;
+		};
+		Object.defineProperty(exports, "__esModule", { value: true });
+		exports.parseJSON = exports.isUndefinedIdentifier = exports.isNumberIdentifier = exports.isExpression = exports.getStaticJSONValue = exports.traverseNodes = exports.VisitorKeys = exports.parseForESLint = exports.name = exports.meta = void 0;
+		const parser_1 = requireParser();
+		Object.defineProperty(exports, "parseForESLint", { enumerable: true, get: function () { return parser_1.parseForESLint; } });
+		const traverse_1 = requireTraverse();
+		Object.defineProperty(exports, "traverseNodes", { enumerable: true, get: function () { return traverse_1.traverseNodes; } });
+		const ast_1 = requireAst();
+		Object.defineProperty(exports, "getStaticJSONValue", { enumerable: true, get: function () { return ast_1.getStaticJSONValue; } });
+		Object.defineProperty(exports, "isExpression", { enumerable: true, get: function () { return ast_1.isExpression; } });
+		Object.defineProperty(exports, "isNumberIdentifier", { enumerable: true, get: function () { return ast_1.isNumberIdentifier; } });
+		Object.defineProperty(exports, "isUndefinedIdentifier", { enumerable: true, get: function () { return ast_1.isUndefinedIdentifier; } });
+		const visitor_keys_1 = requireVisitorKeys();
+		exports.meta = __importStar(requireMeta());
+		var meta_1 = requireMeta();
+		Object.defineProperty(exports, "name", { enumerable: true, get: function () { return meta_1.name; } });
+		exports.VisitorKeys = (0, visitor_keys_1.getVisitorKeys)();
+		function parseJSON(code, options) {
+		    return (0, parser_1.parseForESLint)(code, options).ast;
+		}
+		exports.parseJSON = parseJSON; 
+	} (lib));
+	return lib;
+}
+
+export { requireLib as r };