@coderwyd/eslint-config 4.3.0 → 4.4.0

package/dist/dist-DYrxmIwK.js

@@ -0,0 +1,1887 @@
+import { createRequire } from "node:module";
+
+//#region rolldown:runtime
+var __create$1 = Object.create;
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames$1 = Object.getOwnPropertyNames;
+var __getProtoOf$1 = Object.getPrototypeOf;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __commonJS$1 = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames$1(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps$1 = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames$1(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp$1.call(to, key) && key !== except) __defProp$1(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc$1(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM$1 = (mod, isNodeMode, target) => (target = mod != null ? __create$1(__getProtoOf$1(mod)) : {}, __copyProps$1(isNodeMode || !mod || !mod.__esModule ? __defProp$1(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+//#region node_modules/.pnpm/eslint-plugin-import-lite@0_c838f1a32201d76532b4c7682b426a35/node_modules/eslint-plugin-import-lite/dist/rolldown-runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function() {
+	return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region node_modules/.pnpm/eslint-plugin-import-lite@0_c838f1a32201d76532b4c7682b426a35/node_modules/eslint-plugin-import-lite/dist/vender.js
+var require_deepMerge = __commonJS({ "node_modules/.pnpm/@typescript-eslint+utils@8.34.0_eslint@9.28.0_jiti@2.4.2__typescript@5.8.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/deepMerge.js"(exports$1) {
+	Object.defineProperty(exports$1, "__esModule", { value: true });
+	exports$1.isObjectNotArray = isObjectNotArray;
+	exports$1.deepMerge = deepMerge;
+	/**
+	* Check if the variable contains an object strictly rejecting arrays
+	* @returns `true` if obj is an object
+	*/
+	function isObjectNotArray(obj) {
+		return typeof obj === "object" && obj != null && !Array.isArray(obj);
+	}
+	/**
+	* Pure function - doesn't mutate either parameter!
+	* Merges two objects together deeply, overwriting the properties in first with the properties in second
+	* @param first The first object
+	* @param second The second object
+	* @returns a new object
+	*/
+	function deepMerge(first = {}, second = {}) {
+		const keys = new Set([...Object.keys(first), ...Object.keys(second)]);
+		return Object.fromEntries([...keys].map((key) => {
+			const firstHasKey = key in first;
+			const secondHasKey = key in second;
+			const firstValue = first[key];
+			const secondValue = second[key];
+			let value;
+			if (firstHasKey && secondHasKey) if (isObjectNotArray(firstValue) && isObjectNotArray(secondValue)) value = deepMerge(firstValue, secondValue);
+			else value = secondValue;
+			else if (firstHasKey) value = firstValue;
+			else value = secondValue;
+			return [key, value];
+		}));
+	}
+} });
+var require_applyDefault = __commonJS({ "node_modules/.pnpm/@typescript-eslint+utils@8.34.0_eslint@9.28.0_jiti@2.4.2__typescript@5.8.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/applyDefault.js"(exports$1) {
+	Object.defineProperty(exports$1, "__esModule", { value: true });
+	exports$1.applyDefault = applyDefault;
+	const deepMerge_1 = require_deepMerge();
+	/**
+	* Pure function - doesn't mutate either parameter!
+	* Uses the default options and overrides with the options provided by the user
+	* @param defaultOptions the defaults
+	* @param userOptions the user opts
+	* @returns the options with defaults
+	*/
+	function applyDefault(defaultOptions, userOptions) {
+		const options = structuredClone(defaultOptions);
+		if (userOptions == null) return options;
+		options.forEach((opt, i) => {
+			if (userOptions[i] !== void 0) {
+				const userOpt = userOptions[i];
+				if ((0, deepMerge_1.isObjectNotArray)(userOpt) && (0, deepMerge_1.isObjectNotArray)(opt)) options[i] = (0, deepMerge_1.deepMerge)(opt, userOpt);
+				else options[i] = userOpt;
+			}
+		});
+		return options;
+	}
+} });
+var require_parserSeemsToBeTSESLint = __commonJS({ "node_modules/.pnpm/@typescript-eslint+utils@8.34.0_eslint@9.28.0_jiti@2.4.2__typescript@5.8.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/parserSeemsToBeTSESLint.js"(exports$1) {
+	Object.defineProperty(exports$1, "__esModule", { value: true });
+	exports$1.parserSeemsToBeTSESLint = parserSeemsToBeTSESLint;
+	function parserSeemsToBeTSESLint(parser) {
+		return !!parser && /(?:typescript-eslint|\.\.)[\w/\\]*parser/.test(parser);
+	}
+} });
+var require_getParserServices = __commonJS({ "node_modules/.pnpm/@typescript-eslint+utils@8.34.0_eslint@9.28.0_jiti@2.4.2__typescript@5.8.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/getParserServices.js"(exports$1) {
+	Object.defineProperty(exports$1, "__esModule", { value: true });
+	exports$1.getParserServices = getParserServices;
+	const parserSeemsToBeTSESLint_1 = require_parserSeemsToBeTSESLint();
+	const ERROR_MESSAGE_REQUIRES_PARSER_SERVICES = "You have used a rule which requires type information, but don't have parserOptions set to generate type information for this file. See https://typescript-eslint.io/getting-started/typed-linting for enabling linting with type information.";
+	const ERROR_MESSAGE_UNKNOWN_PARSER = "Note: detected a parser other than @typescript-eslint/parser. Make sure the parser is configured to forward \"parserOptions.project\" to @typescript-eslint/parser.";
+	function getParserServices(context, allowWithoutFullTypeInformation = false) {
+		const parser = context.parserPath || context.languageOptions.parser?.meta?.name;
+		if (context.sourceCode.parserServices?.esTreeNodeToTSNodeMap == null || context.sourceCode.parserServices.tsNodeToESTreeNodeMap == null) throwError(parser);
+		if (context.sourceCode.parserServices.program == null && !allowWithoutFullTypeInformation) throwError(parser);
+		return context.sourceCode.parserServices;
+	}
+	function throwError(parser) {
+		const messages = [
+			ERROR_MESSAGE_REQUIRES_PARSER_SERVICES,
+			`Parser: ${parser || "(unknown)"}`,
+			!(0, parserSeemsToBeTSESLint_1.parserSeemsToBeTSESLint)(parser) && ERROR_MESSAGE_UNKNOWN_PARSER
+		].filter(Boolean);
+		throw new Error(messages.join("\n"));
+	}
+} });
+var require_InferTypesFromRule = __commonJS({ "node_modules/.pnpm/@typescript-eslint+utils@8.34.0_eslint@9.28.0_jiti@2.4.2__typescript@5.8.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/InferTypesFromRule.js"(exports$1) {
+	Object.defineProperty(exports$1, "__esModule", { value: true });
+} });
+var require_nullThrows = __commonJS({ "node_modules/.pnpm/@typescript-eslint+utils@8.34.0_eslint@9.28.0_jiti@2.4.2__typescript@5.8.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/nullThrows.js"(exports$1) {
+	Object.defineProperty(exports$1, "__esModule", { value: true });
+	exports$1.NullThrowsReasons = void 0;
+	exports$1.nullThrows = nullThrows;
+	/**
+	* A set of common reasons for calling nullThrows
+	*/
+	exports$1.NullThrowsReasons = {
+		MissingParent: "Expected node to have a parent.",
+		MissingToken: (token, thing) => `Expected to find a ${token} for the ${thing}.`
+	};
+	/**
+	* Assert that a value must not be null or undefined.
+	* This is a nice explicit alternative to the non-null assertion operator.
+	*/
+	function nullThrows(value, message) {
+		if (value == null) throw new Error(`Non-null Assertion Failed: ${message}`);
+		return value;
+	}
+} });
+var require_RuleCreator = __commonJS({ "node_modules/.pnpm/@typescript-eslint+utils@8.34.0_eslint@9.28.0_jiti@2.4.2__typescript@5.8.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/RuleCreator.js"(exports$1) {
+	Object.defineProperty(exports$1, "__esModule", { value: true });
+	exports$1.RuleCreator = RuleCreator;
+	const applyDefault_1 = require_applyDefault();
+	/**
+	* Creates reusable function to create rules with default options and docs URLs.
+	*
+	* @param urlCreator Creates a documentation URL for a given rule name.
+	* @returns Function to create a rule with the docs URL format.
+	*/
+	function RuleCreator(urlCreator) {
+		return function createNamedRule({ meta, name,...rule }) {
+			return createRule$1({
+				meta: {
+					...meta,
+					docs: {
+						...meta.docs,
+						url: urlCreator(name)
+					}
+				},
+				...rule
+			});
+		};
+	}
+	function createRule$1({ create, defaultOptions, meta }) {
+		return {
+			create(context) {
+				const optionsWithDefault = (0, applyDefault_1.applyDefault)(defaultOptions, context.options);
+				return create(context, optionsWithDefault);
+			},
+			defaultOptions,
+			meta
+		};
+	}
+	/**
+	* Creates a well-typed TSESLint custom ESLint rule without a docs URL.
+	*
+	* @returns Well-typed TSESLint custom ESLint rule.
+	* @remarks It is generally better to provide a docs URL function to RuleCreator.
+	*/
+	RuleCreator.withoutDocs = function withoutDocs(args) {
+		return createRule$1(args);
+	};
+} });
+var require_eslint_utils$1 = __commonJS({ "node_modules/.pnpm/@typescript-eslint+utils@8.34.0_eslint@9.28.0_jiti@2.4.2__typescript@5.8.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/index.js"(exports$1) {
+	var __createBinding$7 = Object.create ? function(o, m, k, k2) {
+		if (k2 === void 0) 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 === void 0) k2 = k;
+		o[k2] = m[k];
+	};
+	var __exportStar$2 = function(m, exports$1$1) {
+		for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports$1$1, p)) __createBinding$7(exports$1$1, m, p);
+	};
+	Object.defineProperty(exports$1, "__esModule", { value: true });
+	__exportStar$2(require_applyDefault(), exports$1);
+	__exportStar$2(require_deepMerge(), exports$1);
+	__exportStar$2(require_getParserServices(), exports$1);
+	__exportStar$2(require_InferTypesFromRule(), exports$1);
+	__exportStar$2(require_nullThrows(), exports$1);
+	__exportStar$2(require_RuleCreator(), exports$1);
+} });
+var require_astUtilities = __commonJS({ "node_modules/.pnpm/@typescript-eslint+utils@8.34.0_eslint@9.28.0_jiti@2.4.2__typescript@5.8.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/astUtilities.js"(exports$1) {
+	var __createBinding$6 = Object.create ? function(o, m, k, k2) {
+		if (k2 === void 0) 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 === void 0) k2 = k;
+		o[k2] = m[k];
+	};
+	var __setModuleDefault$4 = Object.create ? function(o, v) {
+		Object.defineProperty(o, "default", {
+			enumerable: true,
+			value: v
+		});
+	} : function(o, v) {
+		o["default"] = v;
+	};
+	var __importStar$4 = function() {
+		var ownKeys = function(o) {
+			ownKeys = Object.getOwnPropertyNames || function(o$1) {
+				var ar = [];
+				for (var k in o$1) if (Object.prototype.hasOwnProperty.call(o$1, k)) ar[ar.length] = k;
+				return ar;
+			};
+			return ownKeys(o);
+		};
+		return function(mod) {
+			if (mod && mod.__esModule) return mod;
+			var result = {};
+			if (mod != null) {
+				for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding$6(result, mod, k[i]);
+			}
+			__setModuleDefault$4(result, mod);
+			return result;
+		};
+	}();
+	Object.defineProperty(exports$1, "__esModule", { value: true });
+	exports$1.isParenthesized = exports$1.hasSideEffect = exports$1.getStringIfConstant = exports$1.getStaticValue = exports$1.getPropertyName = exports$1.getFunctionNameWithKind = exports$1.getFunctionHeadLocation = void 0;
+	const eslintUtils$4 = __importStar$4(__require("@eslint-community/eslint-utils"));
+	/**
+	* Get the proper location of a given function node to report.
+	*
+	* @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getfunctionheadlocation}
+	*/
+	exports$1.getFunctionHeadLocation = eslintUtils$4.getFunctionHeadLocation;
+	/**
+	* Get the name and kind of a given function node.
+	*
+	* @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getfunctionnamewithkind}
+	*/
+	exports$1.getFunctionNameWithKind = eslintUtils$4.getFunctionNameWithKind;
+	/**
+	* Get the property name of a given property node.
+	* If the node is a computed property, this tries to compute the property name by the getStringIfConstant function.
+	*
+	* @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getpropertyname}
+	* @returns The property name of the node. If the property name is not constant then it returns `null`.
+	*/
+	exports$1.getPropertyName = eslintUtils$4.getPropertyName;
+	/**
+	* Get the value of a given node if it can decide the value statically.
+	* If the 2nd parameter `initialScope` was given, this function tries to resolve identifier references which are in the
+	* given node as much as possible. In the resolving way, it does on the assumption that built-in global objects have
+	* not been modified.
+	* For example, it considers `Symbol.iterator`, `Symbol.for('k')`, ` String.raw``hello`` `, and `Object.freeze({a: 1}).a` as static, but `Symbol('k')` is not static.
+	*
+	* @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getstaticvalue}
+	* @returns The `{ value: any }` shaped object. The `value` property is the static value. If it couldn't compute the
+	* static value of the node, it returns `null`.
+	*/
+	exports$1.getStaticValue = eslintUtils$4.getStaticValue;
+	/**
+	* Get the string value of a given node.
+	* This function is a tiny wrapper of the getStaticValue function.
+	*
+	* @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getstringifconstant}
+	*/
+	exports$1.getStringIfConstant = eslintUtils$4.getStringIfConstant;
+	/**
+	* Check whether a given node has any side effect or not.
+	* The side effect means that it may modify a certain variable or object member. This function considers the node which
+	* contains the following types as the node which has side effects:
+	* - `AssignmentExpression`
+	* - `AwaitExpression`
+	* - `CallExpression`
+	* - `ImportExpression`
+	* - `NewExpression`
+	* - `UnaryExpression([operator = "delete"])`
+	* - `UpdateExpression`
+	* - `YieldExpression`
+	* - When `options.considerGetters` is `true`:
+	*   - `MemberExpression`
+	* - When `options.considerImplicitTypeConversion` is `true`:
+	*   - `BinaryExpression([operator = "==" | "!=" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "|" | "^" | "&" | "in"])`
+	*   - `MemberExpression([computed = true])`
+	*   - `MethodDefinition([computed = true])`
+	*   - `Property([computed = true])`
+	*   - `UnaryExpression([operator = "-" | "+" | "!" | "~"])`
+	*
+	* @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#hassideeffect}
+	*/
+	exports$1.hasSideEffect = eslintUtils$4.hasSideEffect;
+	exports$1.isParenthesized = eslintUtils$4.isParenthesized;
+} });
+var require_PatternMatcher = __commonJS({ "node_modules/.pnpm/@typescript-eslint+utils@8.34.0_eslint@9.28.0_jiti@2.4.2__typescript@5.8.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/PatternMatcher.js"(exports$1) {
+	var __createBinding$5 = Object.create ? function(o, m, k, k2) {
+		if (k2 === void 0) 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 === void 0) k2 = k;
+		o[k2] = m[k];
+	};
+	var __setModuleDefault$3 = Object.create ? function(o, v) {
+		Object.defineProperty(o, "default", {
+			enumerable: true,
+			value: v
+		});
+	} : function(o, v) {
+		o["default"] = v;
+	};
+	var __importStar$3 = function() {
+		var ownKeys = function(o) {
+			ownKeys = Object.getOwnPropertyNames || function(o$1) {
+				var ar = [];
+				for (var k in o$1) if (Object.prototype.hasOwnProperty.call(o$1, k)) ar[ar.length] = k;
+				return ar;
+			};
+			return ownKeys(o);
+		};
+		return function(mod) {
+			if (mod && mod.__esModule) return mod;
+			var result = {};
+			if (mod != null) {
+				for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding$5(result, mod, k[i]);
+			}
+			__setModuleDefault$3(result, mod);
+			return result;
+		};
+	}();
+	Object.defineProperty(exports$1, "__esModule", { value: true });
+	exports$1.PatternMatcher = void 0;
+	const eslintUtils$3 = __importStar$3(__require("@eslint-community/eslint-utils"));
+	/**
+	* The class to find a pattern in strings as handling escape sequences.
+	* It ignores the found pattern if it's escaped with `\`.
+	*
+	* @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#patternmatcher-class}
+	*/
+	exports$1.PatternMatcher = eslintUtils$3.PatternMatcher;
+} });
+var require_predicates$1 = __commonJS({ "node_modules/.pnpm/@typescript-eslint+utils@8.34.0_eslint@9.28.0_jiti@2.4.2__typescript@5.8.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/predicates.js"(exports$1) {
+	var __createBinding$4 = Object.create ? function(o, m, k, k2) {
+		if (k2 === void 0) 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 === void 0) k2 = k;
+		o[k2] = m[k];
+	};
+	var __setModuleDefault$2 = Object.create ? function(o, v) {
+		Object.defineProperty(o, "default", {
+			enumerable: true,
+			value: v
+		});
+	} : function(o, v) {
+		o["default"] = v;
+	};
+	var __importStar$2 = function() {
+		var ownKeys = function(o) {
+			ownKeys = Object.getOwnPropertyNames || function(o$1) {
+				var ar = [];
+				for (var k in o$1) if (Object.prototype.hasOwnProperty.call(o$1, k)) ar[ar.length] = k;
+				return ar;
+			};
+			return ownKeys(o);
+		};
+		return function(mod) {
+			if (mod && mod.__esModule) return mod;
+			var result = {};
+			if (mod != null) {
+				for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding$4(result, mod, k[i]);
+			}
+			__setModuleDefault$2(result, mod);
+			return result;
+		};
+	}();
+	Object.defineProperty(exports$1, "__esModule", { value: true });
+	exports$1.isNotSemicolonToken = exports$1.isSemicolonToken = exports$1.isNotOpeningParenToken = exports$1.isOpeningParenToken = exports$1.isNotOpeningBracketToken = exports$1.isOpeningBracketToken = exports$1.isNotOpeningBraceToken = exports$1.isOpeningBraceToken = exports$1.isNotCommentToken = exports$1.isCommentToken = exports$1.isNotCommaToken = exports$1.isCommaToken = exports$1.isNotColonToken = exports$1.isColonToken = exports$1.isNotClosingParenToken = exports$1.isClosingParenToken = exports$1.isNotClosingBracketToken = exports$1.isClosingBracketToken = exports$1.isNotClosingBraceToken = exports$1.isClosingBraceToken = exports$1.isNotArrowToken = exports$1.isArrowToken = void 0;
+	const eslintUtils$2 = __importStar$2(__require("@eslint-community/eslint-utils"));
+	exports$1.isArrowToken = eslintUtils$2.isArrowToken;
+	exports$1.isNotArrowToken = eslintUtils$2.isNotArrowToken;
+	exports$1.isClosingBraceToken = eslintUtils$2.isClosingBraceToken;
+	exports$1.isNotClosingBraceToken = eslintUtils$2.isNotClosingBraceToken;
+	exports$1.isClosingBracketToken = eslintUtils$2.isClosingBracketToken;
+	exports$1.isNotClosingBracketToken = eslintUtils$2.isNotClosingBracketToken;
+	exports$1.isClosingParenToken = eslintUtils$2.isClosingParenToken;
+	exports$1.isNotClosingParenToken = eslintUtils$2.isNotClosingParenToken;
+	exports$1.isColonToken = eslintUtils$2.isColonToken;
+	exports$1.isNotColonToken = eslintUtils$2.isNotColonToken;
+	exports$1.isCommaToken = eslintUtils$2.isCommaToken;
+	exports$1.isNotCommaToken = eslintUtils$2.isNotCommaToken;
+	exports$1.isCommentToken = eslintUtils$2.isCommentToken;
+	exports$1.isNotCommentToken = eslintUtils$2.isNotCommentToken;
+	exports$1.isOpeningBraceToken = eslintUtils$2.isOpeningBraceToken;
+	exports$1.isNotOpeningBraceToken = eslintUtils$2.isNotOpeningBraceToken;
+	exports$1.isOpeningBracketToken = eslintUtils$2.isOpeningBracketToken;
+	exports$1.isNotOpeningBracketToken = eslintUtils$2.isNotOpeningBracketToken;
+	exports$1.isOpeningParenToken = eslintUtils$2.isOpeningParenToken;
+	exports$1.isNotOpeningParenToken = eslintUtils$2.isNotOpeningParenToken;
+	exports$1.isSemicolonToken = eslintUtils$2.isSemicolonToken;
+	exports$1.isNotSemicolonToken = eslintUtils$2.isNotSemicolonToken;
+} });
+var require_ReferenceTracker = __commonJS({ "node_modules/.pnpm/@typescript-eslint+utils@8.34.0_eslint@9.28.0_jiti@2.4.2__typescript@5.8.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/ReferenceTracker.js"(exports$1) {
+	var __createBinding$3 = Object.create ? function(o, m, k, k2) {
+		if (k2 === void 0) 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 === void 0) k2 = k;
+		o[k2] = m[k];
+	};
+	var __setModuleDefault$1 = Object.create ? function(o, v) {
+		Object.defineProperty(o, "default", {
+			enumerable: true,
+			value: v
+		});
+	} : function(o, v) {
+		o["default"] = v;
+	};
+	var __importStar$1 = function() {
+		var ownKeys = function(o) {
+			ownKeys = Object.getOwnPropertyNames || function(o$1) {
+				var ar = [];
+				for (var k in o$1) if (Object.prototype.hasOwnProperty.call(o$1, k)) ar[ar.length] = k;
+				return ar;
+			};
+			return ownKeys(o);
+		};
+		return function(mod) {
+			if (mod && mod.__esModule) return mod;
+			var result = {};
+			if (mod != null) {
+				for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding$3(result, mod, k[i]);
+			}
+			__setModuleDefault$1(result, mod);
+			return result;
+		};
+	}();
+	Object.defineProperty(exports$1, "__esModule", { value: true });
+	exports$1.ReferenceTracker = void 0;
+	const eslintUtils$1 = __importStar$1(__require("@eslint-community/eslint-utils"));
+	const ReferenceTrackerREAD = eslintUtils$1.ReferenceTracker.READ;
+	const ReferenceTrackerCALL = eslintUtils$1.ReferenceTracker.CALL;
+	const ReferenceTrackerCONSTRUCT = eslintUtils$1.ReferenceTracker.CONSTRUCT;
+	const ReferenceTrackerESM = eslintUtils$1.ReferenceTracker.ESM;
+	/**
+	* The tracker for references. This provides reference tracking for global variables, CommonJS modules, and ES modules.
+	*
+	* @see {@link https://eslint-community.github.io/eslint-utils/api/scope-utils.html#referencetracker-class}
+	*/
+	exports$1.ReferenceTracker = eslintUtils$1.ReferenceTracker;
+} });
+var require_scopeAnalysis = __commonJS({ "node_modules/.pnpm/@typescript-eslint+utils@8.34.0_eslint@9.28.0_jiti@2.4.2__typescript@5.8.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/scopeAnalysis.js"(exports$1) {
+	var __createBinding$2 = Object.create ? function(o, m, k, k2) {
+		if (k2 === void 0) 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 === void 0) k2 = k;
+		o[k2] = m[k];
+	};
+	var __setModuleDefault$1 = Object.create ? function(o, v) {
+		Object.defineProperty(o, "default", {
+			enumerable: true,
+			value: v
+		});
+	} : function(o, v) {
+		o["default"] = v;
+	};
+	var __importStar$1 = function() {
+		var ownKeys = function(o) {
+			ownKeys = Object.getOwnPropertyNames || function(o$1) {
+				var ar = [];
+				for (var k in o$1) if (Object.prototype.hasOwnProperty.call(o$1, k)) ar[ar.length] = k;
+				return ar;
+			};
+			return ownKeys(o);
+		};
+		return function(mod) {
+			if (mod && mod.__esModule) return mod;
+			var result = {};
+			if (mod != null) {
+				for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding$2(result, mod, k[i]);
+			}
+			__setModuleDefault$1(result, mod);
+			return result;
+		};
+	}();
+	Object.defineProperty(exports$1, "__esModule", { value: true });
+	exports$1.getInnermostScope = exports$1.findVariable = void 0;
+	const eslintUtils = __importStar$1(__require("@eslint-community/eslint-utils"));
+	/**
+	* Get the variable of a given name.
+	*
+	* @see {@link https://eslint-community.github.io/eslint-utils/api/scope-utils.html#findvariable}
+	*/
+	exports$1.findVariable = eslintUtils.findVariable;
+	/**
+	* Get the innermost scope which contains a given node.
+	*
+	* @see {@link https://eslint-community.github.io/eslint-utils/api/scope-utils.html#getinnermostscope}
+	* @returns The innermost scope which contains the given node.
+	* If such scope doesn't exist then it returns the 1st argument `initialScope`.
+	*/
+	exports$1.getInnermostScope = eslintUtils.getInnermostScope;
+} });
+var require_eslint_utils = __commonJS({ "node_modules/.pnpm/@typescript-eslint+utils@8.34.0_eslint@9.28.0_jiti@2.4.2__typescript@5.8.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/index.js"(exports$1) {
+	var __createBinding$1$1 = Object.create ? function(o, m, k, k2) {
+		if (k2 === void 0) 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 === void 0) k2 = k;
+		o[k2] = m[k];
+	};
+	var __exportStar$1 = function(m, exports$1$1) {
+		for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports$1$1, p)) __createBinding$1$1(exports$1$1, m, p);
+	};
+	Object.defineProperty(exports$1, "__esModule", { value: true });
+	__exportStar$1(require_astUtilities(), exports$1);
+	__exportStar$1(require_PatternMatcher(), exports$1);
+	__exportStar$1(require_predicates$1(), exports$1);
+	__exportStar$1(require_ReferenceTracker(), exports$1);
+	__exportStar$1(require_scopeAnalysis(), exports$1);
+} });
+var require_helpers = __commonJS({ "node_modules/.pnpm/@typescript-eslint+utils@8.34.0_eslint@9.28.0_jiti@2.4.2__typescript@5.8.3/node_modules/@typescript-eslint/utils/dist/ast-utils/helpers.js"(exports$1) {
+	Object.defineProperty(exports$1, "__esModule", { value: true });
+	exports$1.isNotTokenOfTypeWithConditions = exports$1.isTokenOfTypeWithConditions = exports$1.isNodeOfTypeWithConditions = exports$1.isNodeOfTypes = exports$1.isNodeOfType = void 0;
+	const isNodeOfType = (nodeType) => (node) => node?.type === nodeType;
+	exports$1.isNodeOfType = isNodeOfType;
+	const isNodeOfTypes = (nodeTypes) => (node) => !!node && nodeTypes.includes(node.type);
+	exports$1.isNodeOfTypes = isNodeOfTypes;
+	const isNodeOfTypeWithConditions = (nodeType, conditions) => {
+		const entries = Object.entries(conditions);
+		return (node) => node?.type === nodeType && entries.every(([key, value]) => node[key] === value);
+	};
+	exports$1.isNodeOfTypeWithConditions = isNodeOfTypeWithConditions;
+	const isTokenOfTypeWithConditions = (tokenType, conditions) => {
+		const entries = Object.entries(conditions);
+		return (token) => token?.type === tokenType && entries.every(([key, value]) => token[key] === value);
+	};
+	exports$1.isTokenOfTypeWithConditions = isTokenOfTypeWithConditions;
+	const isNotTokenOfTypeWithConditions = (tokenType, conditions) => (token) => !(0, exports$1.isTokenOfTypeWithConditions)(tokenType, conditions)(token);
+	exports$1.isNotTokenOfTypeWithConditions = isNotTokenOfTypeWithConditions;
+} });
+var require_misc = __commonJS({ "node_modules/.pnpm/@typescript-eslint+utils@8.34.0_eslint@9.28.0_jiti@2.4.2__typescript@5.8.3/node_modules/@typescript-eslint/utils/dist/ast-utils/misc.js"(exports$1) {
+	Object.defineProperty(exports$1, "__esModule", { value: true });
+	exports$1.LINEBREAK_MATCHER = void 0;
+	exports$1.isTokenOnSameLine = isTokenOnSameLine;
+	exports$1.LINEBREAK_MATCHER = /\r\n|[\r\n\u2028\u2029]/;
+	/**
+	* Determines whether two adjacent tokens are on the same line
+	*/
+	function isTokenOnSameLine(left, right) {
+		return left.loc.end.line === right.loc.start.line;
+	}
+} });
+var require_ts_estree$1 = __commonJS({ "node_modules/.pnpm/@typescript-eslint+utils@8.34.0_eslint@9.28.0_jiti@2.4.2__typescript@5.8.3/node_modules/@typescript-eslint/utils/dist/ts-estree.js"(exports$1) {
+	Object.defineProperty(exports$1, "__esModule", { value: true });
+	exports$1.TSESTree = exports$1.AST_TOKEN_TYPES = exports$1.AST_NODE_TYPES = void 0;
+	var types_1 = __require("@typescript-eslint/types");
+	Object.defineProperty(exports$1, "AST_NODE_TYPES", {
+		enumerable: true,
+		get: function() {
+			return types_1.AST_NODE_TYPES;
+		}
+	});
+	Object.defineProperty(exports$1, "AST_TOKEN_TYPES", {
+		enumerable: true,
+		get: function() {
+			return types_1.AST_TOKEN_TYPES;
+		}
+	});
+	Object.defineProperty(exports$1, "TSESTree", {
+		enumerable: true,
+		get: function() {
+			return types_1.TSESTree;
+		}
+	});
+} });
+var require_predicates = __commonJS({ "node_modules/.pnpm/@typescript-eslint+utils@8.34.0_eslint@9.28.0_jiti@2.4.2__typescript@5.8.3/node_modules/@typescript-eslint/utils/dist/ast-utils/predicates.js"(exports$1) {
+	Object.defineProperty(exports$1, "__esModule", { value: true });
+	exports$1.isLoop = exports$1.isImportKeyword = exports$1.isTypeKeyword = exports$1.isAwaitKeyword = exports$1.isAwaitExpression = exports$1.isIdentifier = exports$1.isConstructor = exports$1.isClassOrTypeElement = exports$1.isTSConstructorType = exports$1.isTSFunctionType = exports$1.isFunctionOrFunctionType = exports$1.isFunctionType = exports$1.isFunction = exports$1.isVariableDeclarator = exports$1.isTypeAssertion = exports$1.isLogicalOrOperator = exports$1.isOptionalCallExpression = exports$1.isNotNonNullAssertionPunctuator = exports$1.isNonNullAssertionPunctuator = exports$1.isNotOptionalChainPunctuator = exports$1.isOptionalChainPunctuator = void 0;
+	exports$1.isSetter = isSetter;
+	const ts_estree_1 = require_ts_estree$1();
+	const helpers_1 = require_helpers();
+	exports$1.isOptionalChainPunctuator = (0, helpers_1.isTokenOfTypeWithConditions)(ts_estree_1.AST_TOKEN_TYPES.Punctuator, { value: "?." });
+	exports$1.isNotOptionalChainPunctuator = (0, helpers_1.isNotTokenOfTypeWithConditions)(ts_estree_1.AST_TOKEN_TYPES.Punctuator, { value: "?." });
+	exports$1.isNonNullAssertionPunctuator = (0, helpers_1.isTokenOfTypeWithConditions)(ts_estree_1.AST_TOKEN_TYPES.Punctuator, { value: "!" });
+	exports$1.isNotNonNullAssertionPunctuator = (0, helpers_1.isNotTokenOfTypeWithConditions)(ts_estree_1.AST_TOKEN_TYPES.Punctuator, { value: "!" });
+	/**
+	* Returns true if and only if the node represents: foo?.() or foo.bar?.()
+	*/
+	exports$1.isOptionalCallExpression = (0, helpers_1.isNodeOfTypeWithConditions)(ts_estree_1.AST_NODE_TYPES.CallExpression, { optional: true });
+	/**
+	* Returns true if and only if the node represents logical OR
+	*/
+	exports$1.isLogicalOrOperator = (0, helpers_1.isNodeOfTypeWithConditions)(ts_estree_1.AST_NODE_TYPES.LogicalExpression, { operator: "||" });
+	/**
+	* Checks if a node is a type assertion:
+	* ```
+	* x as foo
+	* <foo>x
+	* ```
+	*/
+	exports$1.isTypeAssertion = (0, helpers_1.isNodeOfTypes)([ts_estree_1.AST_NODE_TYPES.TSAsExpression, ts_estree_1.AST_NODE_TYPES.TSTypeAssertion]);
+	exports$1.isVariableDeclarator = (0, helpers_1.isNodeOfType)(ts_estree_1.AST_NODE_TYPES.VariableDeclarator);
+	const functionTypes = [
+		ts_estree_1.AST_NODE_TYPES.ArrowFunctionExpression,
+		ts_estree_1.AST_NODE_TYPES.FunctionDeclaration,
+		ts_estree_1.AST_NODE_TYPES.FunctionExpression
+	];
+	exports$1.isFunction = (0, helpers_1.isNodeOfTypes)(functionTypes);
+	const functionTypeTypes = [
+		ts_estree_1.AST_NODE_TYPES.TSCallSignatureDeclaration,
+		ts_estree_1.AST_NODE_TYPES.TSConstructorType,
+		ts_estree_1.AST_NODE_TYPES.TSConstructSignatureDeclaration,
+		ts_estree_1.AST_NODE_TYPES.TSDeclareFunction,
+		ts_estree_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression,
+		ts_estree_1.AST_NODE_TYPES.TSFunctionType,
+		ts_estree_1.AST_NODE_TYPES.TSMethodSignature
+	];
+	exports$1.isFunctionType = (0, helpers_1.isNodeOfTypes)(functionTypeTypes);
+	exports$1.isFunctionOrFunctionType = (0, helpers_1.isNodeOfTypes)([...functionTypes, ...functionTypeTypes]);
+	exports$1.isTSFunctionType = (0, helpers_1.isNodeOfType)(ts_estree_1.AST_NODE_TYPES.TSFunctionType);
+	exports$1.isTSConstructorType = (0, helpers_1.isNodeOfType)(ts_estree_1.AST_NODE_TYPES.TSConstructorType);
+	exports$1.isClassOrTypeElement = (0, helpers_1.isNodeOfTypes)([
+		ts_estree_1.AST_NODE_TYPES.PropertyDefinition,
+		ts_estree_1.AST_NODE_TYPES.FunctionExpression,
+		ts_estree_1.AST_NODE_TYPES.MethodDefinition,
+		ts_estree_1.AST_NODE_TYPES.TSAbstractPropertyDefinition,
+		ts_estree_1.AST_NODE_TYPES.TSAbstractMethodDefinition,
+		ts_estree_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression,
+		ts_estree_1.AST_NODE_TYPES.TSIndexSignature,
+		ts_estree_1.AST_NODE_TYPES.TSCallSignatureDeclaration,
+		ts_estree_1.AST_NODE_TYPES.TSConstructSignatureDeclaration,
+		ts_estree_1.AST_NODE_TYPES.TSMethodSignature,
+		ts_estree_1.AST_NODE_TYPES.TSPropertySignature
+	]);
+	/**
+	* Checks if a node is a constructor method.
+	*/
+	exports$1.isConstructor = (0, helpers_1.isNodeOfTypeWithConditions)(ts_estree_1.AST_NODE_TYPES.MethodDefinition, { kind: "constructor" });
+	/**
+	* Checks if a node is a setter method.
+	*/
+	function isSetter(node) {
+		return !!node && (node.type === ts_estree_1.AST_NODE_TYPES.MethodDefinition || node.type === ts_estree_1.AST_NODE_TYPES.Property) && node.kind === "set";
+	}
+	exports$1.isIdentifier = (0, helpers_1.isNodeOfType)(ts_estree_1.AST_NODE_TYPES.Identifier);
+	/**
+	* Checks if a node represents an `await …` expression.
+	*/
+	exports$1.isAwaitExpression = (0, helpers_1.isNodeOfType)(ts_estree_1.AST_NODE_TYPES.AwaitExpression);
+	/**
+	* Checks if a possible token is the `await` keyword.
+	*/
+	exports$1.isAwaitKeyword = (0, helpers_1.isTokenOfTypeWithConditions)(ts_estree_1.AST_TOKEN_TYPES.Identifier, { value: "await" });
+	/**
+	* Checks if a possible token is the `type` keyword.
+	*/
+	exports$1.isTypeKeyword = (0, helpers_1.isTokenOfTypeWithConditions)(ts_estree_1.AST_TOKEN_TYPES.Identifier, { value: "type" });
+	/**
+	* Checks if a possible token is the `import` keyword.
+	*/
+	exports$1.isImportKeyword = (0, helpers_1.isTokenOfTypeWithConditions)(ts_estree_1.AST_TOKEN_TYPES.Keyword, { value: "import" });
+	exports$1.isLoop = (0, helpers_1.isNodeOfTypes)([
+		ts_estree_1.AST_NODE_TYPES.DoWhileStatement,
+		ts_estree_1.AST_NODE_TYPES.ForStatement,
+		ts_estree_1.AST_NODE_TYPES.ForInStatement,
+		ts_estree_1.AST_NODE_TYPES.ForOfStatement,
+		ts_estree_1.AST_NODE_TYPES.WhileStatement
+	]);
+} });
+var require_ast_utils = __commonJS({ "node_modules/.pnpm/@typescript-eslint+utils@8.34.0_eslint@9.28.0_jiti@2.4.2__typescript@5.8.3/node_modules/@typescript-eslint/utils/dist/ast-utils/index.js"(exports$1) {
+	var __createBinding$2 = Object.create ? function(o, m, k, k2) {
+		if (k2 === void 0) 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 === void 0) k2 = k;
+		o[k2] = m[k];
+	};
+	var __exportStar$1 = function(m, exports$1$1) {
+		for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports$1$1, p)) __createBinding$2(exports$1$1, m, p);
+	};
+	Object.defineProperty(exports$1, "__esModule", { value: true });
+	__exportStar$1(require_eslint_utils(), exports$1);
+	__exportStar$1(require_helpers(), exports$1);
+	__exportStar$1(require_misc(), exports$1);
+	__exportStar$1(require_predicates(), exports$1);
+} });
+
+//#endregion
+//#region node_modules/.pnpm/@typescript-eslint+types@8.34.0/node_modules/@typescript-eslint/types/dist/generated/ast-spec.js
+var require_ast_spec = __commonJS$1({ "node_modules/.pnpm/@typescript-eslint+types@8.34.0/node_modules/@typescript-eslint/types/dist/generated/ast-spec.js"(exports) {
+	/**********************************************
+	*      DO NOT MODIFY THIS FILE MANUALLY      *
+	*                                            *
+	*  THIS FILE HAS BEEN COPIED FROM ast-spec.  *
+	* ANY CHANGES WILL BE LOST ON THE NEXT BUILD *
+	*                                            *
+	*   MAKE CHANGES TO ast-spec AND THEN RUN    *
+	*                 yarn build                 *
+	**********************************************/
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.AST_TOKEN_TYPES = exports.AST_NODE_TYPES = void 0;
+	var AST_NODE_TYPES$2;
+	(function(AST_NODE_TYPES$3) {
+		AST_NODE_TYPES$3["AccessorProperty"] = "AccessorProperty";
+		AST_NODE_TYPES$3["ArrayExpression"] = "ArrayExpression";
+		AST_NODE_TYPES$3["ArrayPattern"] = "ArrayPattern";
+		AST_NODE_TYPES$3["ArrowFunctionExpression"] = "ArrowFunctionExpression";
+		AST_NODE_TYPES$3["AssignmentExpression"] = "AssignmentExpression";
+		AST_NODE_TYPES$3["AssignmentPattern"] = "AssignmentPattern";
+		AST_NODE_TYPES$3["AwaitExpression"] = "AwaitExpression";
+		AST_NODE_TYPES$3["BinaryExpression"] = "BinaryExpression";
+		AST_NODE_TYPES$3["BlockStatement"] = "BlockStatement";
+		AST_NODE_TYPES$3["BreakStatement"] = "BreakStatement";
+		AST_NODE_TYPES$3["CallExpression"] = "CallExpression";
+		AST_NODE_TYPES$3["CatchClause"] = "CatchClause";
+		AST_NODE_TYPES$3["ChainExpression"] = "ChainExpression";
+		AST_NODE_TYPES$3["ClassBody"] = "ClassBody";
+		AST_NODE_TYPES$3["ClassDeclaration"] = "ClassDeclaration";
+		AST_NODE_TYPES$3["ClassExpression"] = "ClassExpression";
+		AST_NODE_TYPES$3["ConditionalExpression"] = "ConditionalExpression";
+		AST_NODE_TYPES$3["ContinueStatement"] = "ContinueStatement";
+		AST_NODE_TYPES$3["DebuggerStatement"] = "DebuggerStatement";
+		AST_NODE_TYPES$3["Decorator"] = "Decorator";
+		AST_NODE_TYPES$3["DoWhileStatement"] = "DoWhileStatement";
+		AST_NODE_TYPES$3["EmptyStatement"] = "EmptyStatement";
+		AST_NODE_TYPES$3["ExportAllDeclaration"] = "ExportAllDeclaration";
+		AST_NODE_TYPES$3["ExportDefaultDeclaration"] = "ExportDefaultDeclaration";
+		AST_NODE_TYPES$3["ExportNamedDeclaration"] = "ExportNamedDeclaration";
+		AST_NODE_TYPES$3["ExportSpecifier"] = "ExportSpecifier";
+		AST_NODE_TYPES$3["ExpressionStatement"] = "ExpressionStatement";
+		AST_NODE_TYPES$3["ForInStatement"] = "ForInStatement";
+		AST_NODE_TYPES$3["ForOfStatement"] = "ForOfStatement";
+		AST_NODE_TYPES$3["ForStatement"] = "ForStatement";
+		AST_NODE_TYPES$3["FunctionDeclaration"] = "FunctionDeclaration";
+		AST_NODE_TYPES$3["FunctionExpression"] = "FunctionExpression";
+		AST_NODE_TYPES$3["Identifier"] = "Identifier";
+		AST_NODE_TYPES$3["IfStatement"] = "IfStatement";
+		AST_NODE_TYPES$3["ImportAttribute"] = "ImportAttribute";
+		AST_NODE_TYPES$3["ImportDeclaration"] = "ImportDeclaration";
+		AST_NODE_TYPES$3["ImportDefaultSpecifier"] = "ImportDefaultSpecifier";
+		AST_NODE_TYPES$3["ImportExpression"] = "ImportExpression";
+		AST_NODE_TYPES$3["ImportNamespaceSpecifier"] = "ImportNamespaceSpecifier";
+		AST_NODE_TYPES$3["ImportSpecifier"] = "ImportSpecifier";
+		AST_NODE_TYPES$3["JSXAttribute"] = "JSXAttribute";
+		AST_NODE_TYPES$3["JSXClosingElement"] = "JSXClosingElement";
+		AST_NODE_TYPES$3["JSXClosingFragment"] = "JSXClosingFragment";
+		AST_NODE_TYPES$3["JSXElement"] = "JSXElement";
+		AST_NODE_TYPES$3["JSXEmptyExpression"] = "JSXEmptyExpression";
+		AST_NODE_TYPES$3["JSXExpressionContainer"] = "JSXExpressionContainer";
+		AST_NODE_TYPES$3["JSXFragment"] = "JSXFragment";
+		AST_NODE_TYPES$3["JSXIdentifier"] = "JSXIdentifier";
+		AST_NODE_TYPES$3["JSXMemberExpression"] = "JSXMemberExpression";
+		AST_NODE_TYPES$3["JSXNamespacedName"] = "JSXNamespacedName";
+		AST_NODE_TYPES$3["JSXOpeningElement"] = "JSXOpeningElement";
+		AST_NODE_TYPES$3["JSXOpeningFragment"] = "JSXOpeningFragment";
+		AST_NODE_TYPES$3["JSXSpreadAttribute"] = "JSXSpreadAttribute";
+		AST_NODE_TYPES$3["JSXSpreadChild"] = "JSXSpreadChild";
+		AST_NODE_TYPES$3["JSXText"] = "JSXText";
+		AST_NODE_TYPES$3["LabeledStatement"] = "LabeledStatement";
+		AST_NODE_TYPES$3["Literal"] = "Literal";
+		AST_NODE_TYPES$3["LogicalExpression"] = "LogicalExpression";
+		AST_NODE_TYPES$3["MemberExpression"] = "MemberExpression";
+		AST_NODE_TYPES$3["MetaProperty"] = "MetaProperty";
+		AST_NODE_TYPES$3["MethodDefinition"] = "MethodDefinition";
+		AST_NODE_TYPES$3["NewExpression"] = "NewExpression";
+		AST_NODE_TYPES$3["ObjectExpression"] = "ObjectExpression";
+		AST_NODE_TYPES$3["ObjectPattern"] = "ObjectPattern";
+		AST_NODE_TYPES$3["PrivateIdentifier"] = "PrivateIdentifier";
+		AST_NODE_TYPES$3["Program"] = "Program";
+		AST_NODE_TYPES$3["Property"] = "Property";
+		AST_NODE_TYPES$3["PropertyDefinition"] = "PropertyDefinition";
+		AST_NODE_TYPES$3["RestElement"] = "RestElement";
+		AST_NODE_TYPES$3["ReturnStatement"] = "ReturnStatement";
+		AST_NODE_TYPES$3["SequenceExpression"] = "SequenceExpression";
+		AST_NODE_TYPES$3["SpreadElement"] = "SpreadElement";
+		AST_NODE_TYPES$3["StaticBlock"] = "StaticBlock";
+		AST_NODE_TYPES$3["Super"] = "Super";
+		AST_NODE_TYPES$3["SwitchCase"] = "SwitchCase";
+		AST_NODE_TYPES$3["SwitchStatement"] = "SwitchStatement";
+		AST_NODE_TYPES$3["TaggedTemplateExpression"] = "TaggedTemplateExpression";
+		AST_NODE_TYPES$3["TemplateElement"] = "TemplateElement";
+		AST_NODE_TYPES$3["TemplateLiteral"] = "TemplateLiteral";
+		AST_NODE_TYPES$3["ThisExpression"] = "ThisExpression";
+		AST_NODE_TYPES$3["ThrowStatement"] = "ThrowStatement";
+		AST_NODE_TYPES$3["TryStatement"] = "TryStatement";
+		AST_NODE_TYPES$3["UnaryExpression"] = "UnaryExpression";
+		AST_NODE_TYPES$3["UpdateExpression"] = "UpdateExpression";
+		AST_NODE_TYPES$3["VariableDeclaration"] = "VariableDeclaration";
+		AST_NODE_TYPES$3["VariableDeclarator"] = "VariableDeclarator";
+		AST_NODE_TYPES$3["WhileStatement"] = "WhileStatement";
+		AST_NODE_TYPES$3["WithStatement"] = "WithStatement";
+		AST_NODE_TYPES$3["YieldExpression"] = "YieldExpression";
+		AST_NODE_TYPES$3["TSAbstractAccessorProperty"] = "TSAbstractAccessorProperty";
+		AST_NODE_TYPES$3["TSAbstractKeyword"] = "TSAbstractKeyword";
+		AST_NODE_TYPES$3["TSAbstractMethodDefinition"] = "TSAbstractMethodDefinition";
+		AST_NODE_TYPES$3["TSAbstractPropertyDefinition"] = "TSAbstractPropertyDefinition";
+		AST_NODE_TYPES$3["TSAnyKeyword"] = "TSAnyKeyword";
+		AST_NODE_TYPES$3["TSArrayType"] = "TSArrayType";
+		AST_NODE_TYPES$3["TSAsExpression"] = "TSAsExpression";
+		AST_NODE_TYPES$3["TSAsyncKeyword"] = "TSAsyncKeyword";
+		AST_NODE_TYPES$3["TSBigIntKeyword"] = "TSBigIntKeyword";
+		AST_NODE_TYPES$3["TSBooleanKeyword"] = "TSBooleanKeyword";
+		AST_NODE_TYPES$3["TSCallSignatureDeclaration"] = "TSCallSignatureDeclaration";
+		AST_NODE_TYPES$3["TSClassImplements"] = "TSClassImplements";
+		AST_NODE_TYPES$3["TSConditionalType"] = "TSConditionalType";
+		AST_NODE_TYPES$3["TSConstructorType"] = "TSConstructorType";
+		AST_NODE_TYPES$3["TSConstructSignatureDeclaration"] = "TSConstructSignatureDeclaration";
+		AST_NODE_TYPES$3["TSDeclareFunction"] = "TSDeclareFunction";
+		AST_NODE_TYPES$3["TSDeclareKeyword"] = "TSDeclareKeyword";
+		AST_NODE_TYPES$3["TSEmptyBodyFunctionExpression"] = "TSEmptyBodyFunctionExpression";
+		AST_NODE_TYPES$3["TSEnumBody"] = "TSEnumBody";
+		AST_NODE_TYPES$3["TSEnumDeclaration"] = "TSEnumDeclaration";
+		AST_NODE_TYPES$3["TSEnumMember"] = "TSEnumMember";
+		AST_NODE_TYPES$3["TSExportAssignment"] = "TSExportAssignment";
+		AST_NODE_TYPES$3["TSExportKeyword"] = "TSExportKeyword";
+		AST_NODE_TYPES$3["TSExternalModuleReference"] = "TSExternalModuleReference";
+		AST_NODE_TYPES$3["TSFunctionType"] = "TSFunctionType";
+		AST_NODE_TYPES$3["TSImportEqualsDeclaration"] = "TSImportEqualsDeclaration";
+		AST_NODE_TYPES$3["TSImportType"] = "TSImportType";
+		AST_NODE_TYPES$3["TSIndexedAccessType"] = "TSIndexedAccessType";
+		AST_NODE_TYPES$3["TSIndexSignature"] = "TSIndexSignature";
+		AST_NODE_TYPES$3["TSInferType"] = "TSInferType";
+		AST_NODE_TYPES$3["TSInstantiationExpression"] = "TSInstantiationExpression";
+		AST_NODE_TYPES$3["TSInterfaceBody"] = "TSInterfaceBody";
+		AST_NODE_TYPES$3["TSInterfaceDeclaration"] = "TSInterfaceDeclaration";
+		AST_NODE_TYPES$3["TSInterfaceHeritage"] = "TSInterfaceHeritage";
+		AST_NODE_TYPES$3["TSIntersectionType"] = "TSIntersectionType";
+		AST_NODE_TYPES$3["TSIntrinsicKeyword"] = "TSIntrinsicKeyword";
+		AST_NODE_TYPES$3["TSLiteralType"] = "TSLiteralType";
+		AST_NODE_TYPES$3["TSMappedType"] = "TSMappedType";
+		AST_NODE_TYPES$3["TSMethodSignature"] = "TSMethodSignature";
+		AST_NODE_TYPES$3["TSModuleBlock"] = "TSModuleBlock";
+		AST_NODE_TYPES$3["TSModuleDeclaration"] = "TSModuleDeclaration";
+		AST_NODE_TYPES$3["TSNamedTupleMember"] = "TSNamedTupleMember";
+		AST_NODE_TYPES$3["TSNamespaceExportDeclaration"] = "TSNamespaceExportDeclaration";
+		AST_NODE_TYPES$3["TSNeverKeyword"] = "TSNeverKeyword";
+		AST_NODE_TYPES$3["TSNonNullExpression"] = "TSNonNullExpression";
+		AST_NODE_TYPES$3["TSNullKeyword"] = "TSNullKeyword";
+		AST_NODE_TYPES$3["TSNumberKeyword"] = "TSNumberKeyword";
+		AST_NODE_TYPES$3["TSObjectKeyword"] = "TSObjectKeyword";
+		AST_NODE_TYPES$3["TSOptionalType"] = "TSOptionalType";
+		AST_NODE_TYPES$3["TSParameterProperty"] = "TSParameterProperty";
+		AST_NODE_TYPES$3["TSPrivateKeyword"] = "TSPrivateKeyword";
+		AST_NODE_TYPES$3["TSPropertySignature"] = "TSPropertySignature";
+		AST_NODE_TYPES$3["TSProtectedKeyword"] = "TSProtectedKeyword";
+		AST_NODE_TYPES$3["TSPublicKeyword"] = "TSPublicKeyword";
+		AST_NODE_TYPES$3["TSQualifiedName"] = "TSQualifiedName";
+		AST_NODE_TYPES$3["TSReadonlyKeyword"] = "TSReadonlyKeyword";
+		AST_NODE_TYPES$3["TSRestType"] = "TSRestType";
+		AST_NODE_TYPES$3["TSSatisfiesExpression"] = "TSSatisfiesExpression";
+		AST_NODE_TYPES$3["TSStaticKeyword"] = "TSStaticKeyword";
+		AST_NODE_TYPES$3["TSStringKeyword"] = "TSStringKeyword";
+		AST_NODE_TYPES$3["TSSymbolKeyword"] = "TSSymbolKeyword";
+		AST_NODE_TYPES$3["TSTemplateLiteralType"] = "TSTemplateLiteralType";
+		AST_NODE_TYPES$3["TSThisType"] = "TSThisType";
+		AST_NODE_TYPES$3["TSTupleType"] = "TSTupleType";
+		AST_NODE_TYPES$3["TSTypeAliasDeclaration"] = "TSTypeAliasDeclaration";
+		AST_NODE_TYPES$3["TSTypeAnnotation"] = "TSTypeAnnotation";
+		AST_NODE_TYPES$3["TSTypeAssertion"] = "TSTypeAssertion";
+		AST_NODE_TYPES$3["TSTypeLiteral"] = "TSTypeLiteral";
+		AST_NODE_TYPES$3["TSTypeOperator"] = "TSTypeOperator";
+		AST_NODE_TYPES$3["TSTypeParameter"] = "TSTypeParameter";
+		AST_NODE_TYPES$3["TSTypeParameterDeclaration"] = "TSTypeParameterDeclaration";
+		AST_NODE_TYPES$3["TSTypeParameterInstantiation"] = "TSTypeParameterInstantiation";
+		AST_NODE_TYPES$3["TSTypePredicate"] = "TSTypePredicate";
+		AST_NODE_TYPES$3["TSTypeQuery"] = "TSTypeQuery";
+		AST_NODE_TYPES$3["TSTypeReference"] = "TSTypeReference";
+		AST_NODE_TYPES$3["TSUndefinedKeyword"] = "TSUndefinedKeyword";
+		AST_NODE_TYPES$3["TSUnionType"] = "TSUnionType";
+		AST_NODE_TYPES$3["TSUnknownKeyword"] = "TSUnknownKeyword";
+		AST_NODE_TYPES$3["TSVoidKeyword"] = "TSVoidKeyword";
+	})(AST_NODE_TYPES$2 || (exports.AST_NODE_TYPES = AST_NODE_TYPES$2 = {}));
+	var AST_TOKEN_TYPES$1;
+	(function(AST_TOKEN_TYPES$2) {
+		AST_TOKEN_TYPES$2["Boolean"] = "Boolean";
+		AST_TOKEN_TYPES$2["Identifier"] = "Identifier";
+		AST_TOKEN_TYPES$2["JSXIdentifier"] = "JSXIdentifier";
+		AST_TOKEN_TYPES$2["PrivateIdentifier"] = "PrivateIdentifier";
+		AST_TOKEN_TYPES$2["JSXText"] = "JSXText";
+		AST_TOKEN_TYPES$2["Keyword"] = "Keyword";
+		AST_TOKEN_TYPES$2["Null"] = "Null";
+		AST_TOKEN_TYPES$2["Numeric"] = "Numeric";
+		AST_TOKEN_TYPES$2["Punctuator"] = "Punctuator";
+		AST_TOKEN_TYPES$2["RegularExpression"] = "RegularExpression";
+		AST_TOKEN_TYPES$2["String"] = "String";
+		AST_TOKEN_TYPES$2["Template"] = "Template";
+		AST_TOKEN_TYPES$2["Block"] = "Block";
+		AST_TOKEN_TYPES$2["Line"] = "Line";
+	})(AST_TOKEN_TYPES$1 || (exports.AST_TOKEN_TYPES = AST_TOKEN_TYPES$1 = {}));
+} });
+
+//#endregion
+//#region node_modules/.pnpm/@typescript-eslint+types@8.34.0/node_modules/@typescript-eslint/types/dist/lib.js
+var require_lib = __commonJS$1({ "node_modules/.pnpm/@typescript-eslint+types@8.34.0/node_modules/@typescript-eslint/types/dist/lib.js"(exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+} });
+
+//#endregion
+//#region node_modules/.pnpm/@typescript-eslint+types@8.34.0/node_modules/@typescript-eslint/types/dist/parser-options.js
+var require_parser_options = __commonJS$1({ "node_modules/.pnpm/@typescript-eslint+types@8.34.0/node_modules/@typescript-eslint/types/dist/parser-options.js"(exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+} });
+
+//#endregion
+//#region node_modules/.pnpm/@typescript-eslint+types@8.34.0/node_modules/@typescript-eslint/types/dist/ts-estree.js
+var require_ts_estree = __commonJS$1({ "node_modules/.pnpm/@typescript-eslint+types@8.34.0/node_modules/@typescript-eslint/types/dist/ts-estree.js"(exports) {
+	var __createBinding$1 = void 0 && (void 0).__createBinding || (Object.create ? function(o, m, k, k2) {
+		if (k2 === void 0) 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 === void 0) k2 = k;
+		o[k2] = m[k];
+	});
+	var __setModuleDefault = void 0 && (void 0).__setModuleDefault || (Object.create ? function(o, v) {
+		Object.defineProperty(o, "default", {
+			enumerable: true,
+			value: v
+		});
+	} : function(o, v) {
+		o["default"] = v;
+	});
+	var __importStar = void 0 && (void 0).__importStar || function() {
+		var ownKeys = function(o) {
+			ownKeys = Object.getOwnPropertyNames || function(o$1) {
+				var ar = [];
+				for (var k in o$1) if (Object.prototype.hasOwnProperty.call(o$1, k)) ar[ar.length] = k;
+				return ar;
+			};
+			return ownKeys(o);
+		};
+		return function(mod) {
+			if (mod && mod.__esModule) return mod;
+			var result = {};
+			if (mod != null) {
+				for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding$1(result, mod, k[i]);
+			}
+			__setModuleDefault(result, mod);
+			return result;
+		};
+	}();
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.TSESTree = void 0;
+	exports.TSESTree = __importStar(require_ast_spec());
+} });
+
+//#endregion
+//#region node_modules/.pnpm/@typescript-eslint+types@8.34.0/node_modules/@typescript-eslint/types/dist/index.js
+var require_dist = __commonJS$1({ "node_modules/.pnpm/@typescript-eslint+types@8.34.0/node_modules/@typescript-eslint/types/dist/index.js"(exports) {
+	var __createBinding = void 0 && (void 0).__createBinding || (Object.create ? function(o, m, k, k2) {
+		if (k2 === void 0) 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 === void 0) k2 = k;
+		o[k2] = m[k];
+	});
+	var __exportStar = void 0 && (void 0).__exportStar || function(m, exports$1) {
+		for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports$1, p)) __createBinding(exports$1, m, p);
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.AST_TOKEN_TYPES = exports.AST_NODE_TYPES = void 0;
+	var ast_spec_1 = require_ast_spec();
+	Object.defineProperty(exports, "AST_NODE_TYPES", {
+		enumerable: true,
+		get: function() {
+			return ast_spec_1.AST_NODE_TYPES;
+		}
+	});
+	Object.defineProperty(exports, "AST_TOKEN_TYPES", {
+		enumerable: true,
+		get: function() {
+			return ast_spec_1.AST_TOKEN_TYPES;
+		}
+	});
+	__exportStar(require_lib(), exports);
+	__exportStar(require_parser_options(), exports);
+	__exportStar(require_ts_estree(), exports);
+} });
+
+//#endregion
+//#region node_modules/.pnpm/eslint-plugin-import-lite@0_c838f1a32201d76532b4c7682b426a35/node_modules/eslint-plugin-import-lite/dist/utils.js
+var import_dist = __toESM$1(require_dist(), 1);
+function createRule({ name, create, defaultOptions = [], meta }) {
+	return {
+		create: (context) => {
+			const optionsCount = Math.max(context.options.length, defaultOptions.length);
+			const optionsWithDefault = Array.from({ length: optionsCount }, (_, i) => {
+				if ((0, import_eslint_utils.isObjectNotArray)(context.options[i]) && (0, import_eslint_utils.isObjectNotArray)(defaultOptions[i])) return (0, import_eslint_utils.deepMerge)(defaultOptions[i], context.options[i]);
+				return context.options[i] ?? defaultOptions[i];
+			});
+			return create(context, optionsWithDefault);
+		},
+		defaultOptions,
+		meta: {
+			...meta,
+			docs: {
+				...meta.docs,
+				url: `https://github.com/9romise/eslint-plugin-import-lite/blob/main/src/rules/${name}/README.md`
+			}
+		}
+	};
+}
+function sourceType(context) {
+	if ("sourceType" in context.parserOptions) return context.parserOptions.sourceType;
+	if ("languageOptions" in context && context.languageOptions) return context.languageOptions.sourceType;
+}
+var import_eslint_utils;
+var init_utils = __esm({ "src/utils/index.ts"() {
+	import_eslint_utils = __toESM(require_eslint_utils$1(), 1);
+} });
+var ast_exports = {};
+__export(ast_exports, {
+	AST_NODE_TYPES: () => import_dist.AST_NODE_TYPES,
+	AST_TOKEN_TYPES: () => import_dist.AST_TOKEN_TYPES,
+	getValue: () => getValue
+});
+function getValue(node) {
+	switch (node.type) {
+		case import_dist.AST_NODE_TYPES.Identifier: return node.name;
+		case import_dist.AST_NODE_TYPES.Literal: return node.value;
+		default: throw new Error(`Unsupported node type: ${node.type}`);
+	}
+}
+var init_ast = __esm({ "src/utils/ast.ts"() {
+	__reExport(ast_exports, __toESM(require_ast_utils(), 1));
+} });
+
+//#endregion
+//#region node_modules/.pnpm/eslint-plugin-import-lite@0_c838f1a32201d76532b4c7682b426a35/node_modules/eslint-plugin-import-lite/dist/rules/consistent-type-specifier-style.js
+function getImportText(node, sourceCode, specifiers) {
+	const sourceString = sourceCode.getText(node.source);
+	if (specifiers.length === 0) return "";
+	const names = specifiers.map((s) => {
+		const importedName = getValue(s.imported);
+		if (importedName === s.local.name) return importedName;
+		return `${importedName} as ${s.local.name}`;
+	});
+	return `import type {${names.join(", ")}} from ${sourceString};`;
+}
+var consistent_type_specifier_style_default;
+var init_consistent_type_specifier_style = __esm({ "src/rules/consistent-type-specifier-style/consistent-type-specifier-style.ts"() {
+	init_utils();
+	init_ast();
+	consistent_type_specifier_style_default = createRule({
+		name: "consistent-type-specifier-style",
+		meta: {
+			type: "suggestion",
+			docs: { description: "Enforce or ban the use of inline type-only markers for named imports." },
+			fixable: "code",
+			schema: [{
+				type: "string",
+				enum: [
+					"top-level",
+					"inline",
+					"prefer-top-level"
+				],
+				default: "top-level"
+			}],
+			messages: {
+				inline: "Prefer using inline {{kind}} specifiers instead of a top-level {{kind}}-only import.",
+				topLevel: "Prefer using a top-level {{kind}}-only import instead of inline {{kind}} specifiers."
+			}
+		},
+		defaultOptions: ["top-level"],
+		create(context, [options]) {
+			const { sourceCode } = context;
+			if (options === "inline") return { ImportDeclaration(node) {
+				if (node.importKind === "value" || node.importKind == null) return;
+				if (node.specifiers.length === 0 || node.specifiers.length === 1 && (node.specifiers[0].type === "ImportDefaultSpecifier" || node.specifiers[0].type === "ImportNamespaceSpecifier")) return;
+				context.report({
+					node,
+					messageId: "inline",
+					data: { kind: node.importKind },
+					fix(fixer) {
+						const kindToken = sourceCode.getFirstToken(node, { skip: 1 });
+						return [kindToken ? fixer.remove(kindToken) : [], node.specifiers.map((specifier) => fixer.insertTextBefore(specifier, `${node.importKind} `))].flat();
+					}
+				});
+			} };
+			return { ImportDeclaration(node) {
+				if (node.importKind === "type" || node.specifiers.length === 0 || node.specifiers.length === 1 && (node.specifiers[0].type === "ImportDefaultSpecifier" || node.specifiers[0].type === "ImportNamespaceSpecifier")) return;
+				const typeSpecifiers = [];
+				const valueSpecifiers = [];
+				let defaultSpecifier = null;
+				for (const specifier of node.specifiers) {
+					if (specifier.type === "ImportDefaultSpecifier") {
+						defaultSpecifier = specifier;
+						continue;
+					}
+					if (!("importKind" in specifier)) continue;
+					if (specifier.importKind === "type") typeSpecifiers.push(specifier);
+					else if (specifier.importKind === "value" || specifier.importKind == null) valueSpecifiers.push(specifier);
+				}
+				const typeImport = getImportText(node, sourceCode, typeSpecifiers);
+				if (typeSpecifiers.length === node.specifiers.length) context.report({
+					node,
+					messageId: "topLevel",
+					data: { kind: "type" },
+					fix(fixer) {
+						return fixer.replaceText(node, typeImport);
+					}
+				});
+				else if (options === "top-level") for (const specifier of typeSpecifiers) context.report({
+					node: specifier,
+					messageId: "topLevel",
+					data: { kind: specifier.importKind },
+					fix(fixer) {
+						const fixes = [];
+						if (valueSpecifiers.length > 0) {
+							for (const specifier$1 of typeSpecifiers) {
+								const token = sourceCode.getTokenAfter(specifier$1);
+								if (token && (0, ast_exports.isCommaToken)(token)) fixes.push(fixer.remove(token));
+								fixes.push(fixer.remove(specifier$1));
+							}
+							const maybeComma = sourceCode.getTokenAfter(valueSpecifiers[valueSpecifiers.length - 1]);
+							if ((0, ast_exports.isCommaToken)(maybeComma)) fixes.push(fixer.remove(maybeComma));
+						} else if (defaultSpecifier) {
+							const comma = sourceCode.getTokenAfter(defaultSpecifier, ast_exports.isCommaToken);
+							const closingBrace = sourceCode.getTokenAfter(node.specifiers[node.specifiers.length - 1], (token) => token.type === "Punctuator" && token.value === "}");
+							fixes.push(fixer.removeRange([comma.range[0], closingBrace.range[1]]));
+						}
+						return [...fixes, fixer.insertTextAfter(node, `\n${typeImport}`)];
+					}
+				});
+			} };
+		}
+	});
+} });
+
+//#endregion
+//#region node_modules/.pnpm/eslint-plugin-import-lite@0_c838f1a32201d76532b4c7682b426a35/node_modules/eslint-plugin-import-lite/dist/rules/first.js
+function getImportValue(node) {
+	return node.type === "ImportDeclaration" ? node.source.value : "moduleReference" in node && "expression" in node.moduleReference && "value" in node.moduleReference.expression && node.moduleReference.expression.value;
+}
+function isPossibleDirective(node) {
+	return node.type === "ExpressionStatement" && node.expression.type === "Literal" && typeof node.expression.value === "string";
+}
+var first_default;
+var init_first = __esm({ "src/rules/first/first.ts"() {
+	init_utils();
+	first_default = createRule({
+		name: "first",
+		meta: {
+			type: "suggestion",
+			docs: { description: "Ensure all imports appear before other statements." },
+			fixable: "code",
+			schema: [{
+				type: "string",
+				enum: ["absolute-first", "disable-absolute-first"]
+			}],
+			messages: {
+				absolute: "Absolute imports should come before relative imports.",
+				order: "Import in body of module; reorder to top."
+			}
+		},
+		defaultOptions: [],
+		create(context, options) {
+			return { Program(n) {
+				const body = n.body;
+				if (!body?.length) return;
+				const absoluteFirst = options[0] === "absolute-first";
+				const { sourceCode } = context;
+				const originSourceCode = sourceCode.getText();
+				let nonImportCount = 0;
+				let anyExpressions = false;
+				let anyRelative = false;
+				let lastLegalImp = null;
+				const errorInfos = [];
+				let shouldSort = true;
+				let lastSortNodesIndex = 0;
+				for (const [index, node] of body.entries()) {
+					if (!anyExpressions && isPossibleDirective(node)) continue;
+					anyExpressions = true;
+					if (node.type === "ImportDeclaration" || node.type === "TSImportEqualsDeclaration") {
+						if (absoluteFirst) {
+							const importValue = getImportValue(node);
+							if (typeof importValue === "string" && /^\./.test(importValue)) anyRelative = true;
+							else if (anyRelative) context.report({
+								node: node.type === "ImportDeclaration" ? node.source : node.moduleReference,
+								messageId: "absolute"
+							});
+						}
+						if (nonImportCount > 0) {
+							/** @see https://eslint.org/docs/next/use/migrate-to-9.0.0#-removed-multiple-context-methods */
+							for (const variable of sourceCode.getDeclaredVariables(node)) {
+								if (!shouldSort) break;
+								for (const reference of variable.references) if (reference.identifier.range[0] < node.range[1]) {
+									shouldSort = false;
+									break;
+								}
+							}
+							if (shouldSort) lastSortNodesIndex = errorInfos.length;
+							errorInfos.push({
+								node,
+								range: [body[index - 1].range[1], node.range[1]]
+							});
+						} else lastLegalImp = node;
+					} else nonImportCount++;
+				}
+				if (errorInfos.length === 0) return;
+				for (const [index, { node }] of errorInfos.entries()) {
+					let fix;
+					if (index < lastSortNodesIndex) fix = (fixer) => fixer.insertTextAfter(node, "");
+					else if (index === lastSortNodesIndex) {
+						const sortNodes = errorInfos.slice(0, lastSortNodesIndex + 1);
+						fix = (fixer) => {
+							const removeFixers = sortNodes.map(({ range: range$1 }) => fixer.removeRange(range$1));
+							const range = [0, removeFixers[removeFixers.length - 1].range[1]];
+							let insertSourceCode = sortNodes.map(({ range: range$1 }) => {
+								const nodeSourceCode = originSourceCode.slice(...range$1);
+								if (/\S/.test(nodeSourceCode[0])) return `\n${nodeSourceCode}`;
+								return nodeSourceCode;
+							}).join("");
+							let replaceSourceCode = "";
+							if (!lastLegalImp) insertSourceCode = insertSourceCode.trim() + insertSourceCode.match(/^(\s+)/)[0];
+							const insertFixer = lastLegalImp ? fixer.insertTextAfter(lastLegalImp, insertSourceCode) : fixer.insertTextBefore(body[0], insertSourceCode);
+							const fixers = [insertFixer, ...removeFixers];
+							for (const [i, computedFixer] of fixers.entries()) replaceSourceCode += originSourceCode.slice(fixers[i - 1] ? fixers[i - 1].range[1] : 0, computedFixer.range[0]) + computedFixer.text;
+							return fixer.replaceTextRange(range, replaceSourceCode);
+						};
+					}
+					context.report({
+						node,
+						messageId: "order",
+						fix
+					});
+				}
+			} };
+		}
+	});
+} });
+
+//#endregion
+//#region node_modules/.pnpm/eslint-plugin-import-lite@0_c838f1a32201d76532b4c7682b426a35/node_modules/eslint-plugin-import-lite/dist/rules/newline-after-import.js
+function isStaticRequire(node) {
+	return node && node.callee && node.callee.type === "Identifier" && node.callee.name === "require" && node.arguments.length === 1 && node.arguments[0].type === "Literal" && typeof node.arguments[0].value === "string";
+}
+function containsNodeOrEqual(outerNode, innerNode) {
+	return outerNode.range[0] <= innerNode.range[0] && outerNode.range[1] >= innerNode.range[1];
+}
+function getScopeBody(scope) {
+	if (scope.block.type === "SwitchStatement") {
+		console.log("SwitchStatement scopes not supported");
+		return [];
+	}
+	const body = "body" in scope.block ? scope.block.body : null;
+	if (body && "type" in body && body.type === "BlockStatement") return body.body;
+	return Array.isArray(body) ? body : [];
+}
+function findNodeIndexInScopeBody(body, nodeToFind) {
+	return body.findIndex((node) => containsNodeOrEqual(node, nodeToFind));
+}
+function getLineDifference(node, nextNode) {
+	return nextNode.loc.start.line - node.loc.end.line;
+}
+function isClassWithDecorator(node) {
+	return node.type === "ClassDeclaration" && !!node.decorators?.length;
+}
+function isExportDefaultClass(node) {
+	return node.type === "ExportDefaultDeclaration" && node.declaration.type === "ClassDeclaration";
+}
+function isExportNameClass(node) {
+	return node.type === "ExportNamedDeclaration" && node.declaration?.type === "ClassDeclaration";
+}
+var newline_after_import_default;
+var init_newline_after_import = __esm({ "src/rules/newline-after-import/newline-after-import.ts"() {
+	init_utils();
+	newline_after_import_default = createRule({
+		name: "newline-after-import",
+		meta: {
+			type: "layout",
+			docs: { description: "Enforce a newline after import statements." },
+			fixable: "whitespace",
+			schema: [{
+				type: "object",
+				properties: {
+					count: {
+						type: "integer",
+						minimum: 1
+					},
+					exactCount: { type: "boolean" },
+					considerComments: { type: "boolean" }
+				},
+				additionalProperties: false
+			}],
+			messages: { newline: "Expected {{count}} empty line{{lineSuffix}} after {{type}} statement not followed by another {{type}}." }
+		},
+		defaultOptions: [{
+			count: 1,
+			exactCount: false,
+			considerComments: false
+		}],
+		create(context, [options]) {
+			let level = 0;
+			const requireCalls = [];
+			function checkForNewLine(node, nextNode, type) {
+				if (isExportDefaultClass(nextNode) || isExportNameClass(nextNode)) {
+					const classNode = nextNode.declaration;
+					if (isClassWithDecorator(classNode)) nextNode = classNode.decorators[0];
+				} else if (isClassWithDecorator(nextNode)) nextNode = nextNode.decorators[0];
+				const lineDifference = getLineDifference(node, nextNode);
+				const EXPECTED_LINE_DIFFERENCE = options.count + 1;
+				if (lineDifference < EXPECTED_LINE_DIFFERENCE || options.exactCount && lineDifference !== EXPECTED_LINE_DIFFERENCE) {
+					let column = node.loc.start.column;
+					if (node.loc.start.line !== node.loc.end.line) column = 0;
+					context.report({
+						loc: {
+							line: node.loc.end.line,
+							column
+						},
+						messageId: "newline",
+						data: {
+							count: options.count,
+							lineSuffix: options.count > 1 ? "s" : "",
+							type
+						},
+						fix: options.exactCount && EXPECTED_LINE_DIFFERENCE < lineDifference ? void 0 : (fixer) => fixer.insertTextAfter(node, "\n".repeat(EXPECTED_LINE_DIFFERENCE - lineDifference))
+					});
+				}
+			}
+			function commentAfterImport(node, nextComment, type) {
+				const lineDifference = getLineDifference(node, nextComment);
+				const EXPECTED_LINE_DIFFERENCE = options.count + 1;
+				if (lineDifference < EXPECTED_LINE_DIFFERENCE) {
+					let column = node.loc.start.column;
+					if (node.loc.start.line !== node.loc.end.line) column = 0;
+					context.report({
+						loc: {
+							line: node.loc.end.line,
+							column
+						},
+						messageId: "newline",
+						data: {
+							count: options.count,
+							lineSuffix: options.count > 1 ? "s" : "",
+							type
+						},
+						fix: options.exactCount && EXPECTED_LINE_DIFFERENCE < lineDifference ? void 0 : (fixer) => fixer.insertTextAfter(node, "\n".repeat(EXPECTED_LINE_DIFFERENCE - lineDifference))
+					});
+				}
+			}
+			function incrementLevel() {
+				level++;
+			}
+			function decrementLevel() {
+				level--;
+			}
+			function checkImport(node) {
+				const { parent } = node;
+				if (!parent || !("body" in parent) || !parent.body) return;
+				const root = parent;
+				const nodePosition = root.body.indexOf(node);
+				const nextNode = root.body[nodePosition + 1];
+				const endLine = node.loc.end.line;
+				let nextComment;
+				if (root.comments !== void 0 && options.considerComments) nextComment = root.comments.find((o) => o.loc.start.line >= endLine && o.loc.start.line <= endLine + options.count + 1);
+				if (node.type === "TSImportEqualsDeclaration" && node.isExport) return;
+				if (nextComment) commentAfterImport(node, nextComment, "import");
+				else if (nextNode && nextNode.type !== "ImportDeclaration" && (nextNode.type !== "TSImportEqualsDeclaration" || nextNode.isExport)) checkForNewLine(node, nextNode, "import");
+			}
+			return {
+				"ImportDeclaration": checkImport,
+				"TSImportEqualsDeclaration": checkImport,
+				CallExpression(node) {
+					if (isStaticRequire(node) && level === 0) requireCalls.push(node);
+				},
+				"Program:exit": function(node) {
+					const scopeBody = getScopeBody(context.sourceCode.getScope(node));
+					for (const [index, node$1] of requireCalls.entries()) {
+						const nodePosition = findNodeIndexInScopeBody(scopeBody, node$1);
+						const statementWithRequireCall = scopeBody[nodePosition];
+						const nextStatement = scopeBody[nodePosition + 1];
+						const nextRequireCall = requireCalls[index + 1];
+						if (nextRequireCall && containsNodeOrEqual(statementWithRequireCall, nextRequireCall)) continue;
+						if (nextStatement && (!nextRequireCall || !containsNodeOrEqual(nextStatement, nextRequireCall))) {
+							let nextComment;
+							if ("comments" in statementWithRequireCall.parent && statementWithRequireCall.parent.comments !== void 0 && options.considerComments) {
+								const endLine = node$1.loc.end.line;
+								nextComment = statementWithRequireCall.parent.comments.find((o) => o.loc.start.line >= endLine && o.loc.start.line <= endLine + options.count + 1);
+							}
+							if (nextComment && nextComment !== void 0) commentAfterImport(statementWithRequireCall, nextComment, "require");
+							else checkForNewLine(statementWithRequireCall, nextStatement, "require");
+						}
+					}
+				},
+				"FunctionDeclaration": incrementLevel,
+				"FunctionExpression": incrementLevel,
+				"ArrowFunctionExpression": incrementLevel,
+				"BlockStatement": incrementLevel,
+				"ObjectExpression": incrementLevel,
+				"Decorator": incrementLevel,
+				"FunctionDeclaration:exit": decrementLevel,
+				"FunctionExpression:exit": decrementLevel,
+				"ArrowFunctionExpression:exit": decrementLevel,
+				"BlockStatement:exit": decrementLevel,
+				"ObjectExpression:exit": decrementLevel,
+				"Decorator:exit": decrementLevel
+			};
+		}
+	});
+} });
+
+//#endregion
+//#region node_modules/.pnpm/eslint-plugin-import-lite@0_c838f1a32201d76532b4c7682b426a35/node_modules/eslint-plugin-import-lite/dist/rules/no-default-export.js
+var no_default_export_default;
+var init_no_default_export = __esm({ "src/rules/no-default-export/no-default-export.ts"() {
+	init_utils();
+	init_ast();
+	no_default_export_default = createRule({
+		name: "no-default-export",
+		meta: {
+			type: "suggestion",
+			docs: { description: "Forbid default exports." },
+			schema: [],
+			messages: {
+				preferNamed: "Prefer named exports.",
+				noAliasDefault: "Do not alias `{{local}}` as `default`. Just export `{{local}}` itself instead."
+			}
+		},
+		defaultOptions: [],
+		create(context) {
+			if (sourceType(context) !== "module") return {};
+			const { sourceCode } = context;
+			return {
+				ExportDefaultDeclaration(node) {
+					const { loc } = sourceCode.getFirstTokens(node)[1] || {};
+					context.report({
+						node,
+						messageId: "preferNamed",
+						loc
+					});
+				},
+				ExportNamedDeclaration(node) {
+					for (const specifier of node.specifiers.filter((specifier$1) => getValue(specifier$1.exported) === "default")) {
+						const { loc } = sourceCode.getFirstTokens(node)[1] || {};
+						if (specifier.type === "ExportDefaultSpecifier") context.report({
+							node,
+							messageId: "preferNamed",
+							loc
+						});
+						else if (specifier.type === "ExportSpecifier") context.report({
+							node,
+							messageId: "noAliasDefault",
+							data: { local: getValue(specifier.local) },
+							loc
+						});
+					}
+				}
+			};
+		}
+	});
+} });
+
+//#endregion
+//#region node_modules/.pnpm/eslint-plugin-import-lite@0_c838f1a32201d76532b4c7682b426a35/node_modules/eslint-plugin-import-lite/dist/rules/no-duplicates.js
+function checkImports(imported, context) {
+	imported.forEach((nodes, module) => {
+		if (nodes.length <= 1) return;
+		for (let i = 0, len = nodes.length; i < len; i++) {
+			const node = nodes[i];
+			context.report({
+				node: node.source,
+				messageId: "duplicate",
+				data: { module },
+				fix: i === 0 ? getFix(nodes, context.sourceCode, context) : null
+			});
+		}
+	});
+}
+function getFix(nodes, sourceCode, context) {
+	const first = nodes[0];
+	if (hasProblematicComments(first, sourceCode) || hasNamespace(first)) return null;
+	const defaultImportNames = new Set(nodes.flatMap((x) => getDefaultImportName(x) || []));
+	if (defaultImportNames.size > 1) return null;
+	const rest = nodes.slice(1);
+	const restWithoutCommentsAndNamespaces = rest.filter((node) => !hasProblematicComments(node, sourceCode) && !hasNamespace(node));
+	const restWithoutCommentsAndNamespacesHasSpecifiers = restWithoutCommentsAndNamespaces.map(hasSpecifiers);
+	const specifiers = restWithoutCommentsAndNamespaces.reduce((acc, node, nodeIndex) => {
+		const tokens = sourceCode.getTokens(node);
+		const openBrace = tokens.find((token) => isPunctuator(token, "{"));
+		const closeBrace = tokens.find((token) => isPunctuator(token, "}"));
+		if (openBrace == null || closeBrace == null) return acc;
+		acc.push({
+			importNode: node,
+			identifiers: sourceCode.text.slice(openBrace.range[1], closeBrace.range[0]).split(","),
+			isEmpty: !restWithoutCommentsAndNamespacesHasSpecifiers[nodeIndex]
+		});
+		return acc;
+	}, []);
+	const unnecessaryImports = restWithoutCommentsAndNamespaces.filter((node, nodeIndex) => !restWithoutCommentsAndNamespacesHasSpecifiers[nodeIndex] && !specifiers.some((specifier) => specifier.importNode === node));
+	const shouldAddSpecifiers = specifiers.length > 0;
+	const shouldRemoveUnnecessary = unnecessaryImports.length > 0;
+	const shouldAddDefault = getDefaultImportName(first) == null && defaultImportNames.size === 1;
+	if (!shouldAddSpecifiers && !shouldRemoveUnnecessary && !shouldAddDefault) return null;
+	const preferInline = context.options[0] && context.options[0]["prefer-inline"];
+	return (fixer) => {
+		const tokens = sourceCode.getTokens(first);
+		const openBrace = tokens.find((token) => isPunctuator(token, "{"));
+		const closeBrace = tokens.find((token) => isPunctuator(token, "}"));
+		const firstToken = sourceCode.getFirstToken(first);
+		const [defaultImportName] = defaultImportNames;
+		const firstHasTrailingComma = closeBrace != null && isPunctuator(sourceCode.getTokenBefore(closeBrace), ",");
+		const firstIsEmpty = !hasSpecifiers(first);
+		const firstExistingIdentifiers = firstIsEmpty ? /* @__PURE__ */ new Set() : new Set(sourceCode.text.slice(openBrace.range[1], closeBrace.range[0]).split(",").map((x) => x.split(" as ")[0].trim()));
+		const [specifiersText] = specifiers.reduce(([result, needsComma, existingIdentifiers], specifier) => {
+			const isTypeSpecifier = "importNode" in specifier && specifier.importNode.importKind === "type";
+			const [specifierText, updatedExistingIdentifiers] = specifier.identifiers.reduce(([text, set], cur) => {
+				const trimmed = cur.trim();
+				if (trimmed.length === 0 || existingIdentifiers.has(trimmed)) return [text, set];
+				const curWithType = preferInline && isTypeSpecifier ? cur.replace(/^(\s*)/, "$1type ") : cur;
+				return [text.length > 0 ? `${text},${curWithType}` : curWithType, set.add(trimmed)];
+			}, ["", existingIdentifiers]);
+			return [
+				needsComma && !specifier.isEmpty && specifierText.length > 0 ? `${result},${specifierText}` : `${result}${specifierText}`,
+				specifier.isEmpty ? needsComma : true,
+				updatedExistingIdentifiers
+			];
+		}, [
+			"",
+			!firstHasTrailingComma && !firstIsEmpty,
+			firstExistingIdentifiers
+		]);
+		const fixes = [];
+		if (shouldAddSpecifiers && preferInline && first.importKind === "type") {
+			const typeIdentifierToken = tokens.find((token) => token.type === "Identifier" && token.value === "type");
+			if (typeIdentifierToken) fixes.push(fixer.removeRange([typeIdentifierToken.range[0], typeIdentifierToken.range[1] + 1]));
+			for (const identifier of tokens.filter((token) => firstExistingIdentifiers.has(token.value))) fixes.push(fixer.replaceTextRange([identifier.range[0], identifier.range[1]], `type ${identifier.value}`));
+		}
+		if (openBrace == null && shouldAddSpecifiers && shouldAddDefault) fixes.push(fixer.insertTextAfter(firstToken, ` ${defaultImportName}, {${specifiersText}} from`));
+		else if (openBrace == null && !shouldAddSpecifiers && shouldAddDefault) fixes.push(fixer.insertTextAfter(firstToken, ` ${defaultImportName} from`));
+		else if (openBrace != null && closeBrace != null && shouldAddDefault) {
+			fixes.push(fixer.insertTextAfter(firstToken, ` ${defaultImportName},`));
+			if (shouldAddSpecifiers) fixes.push(fixer.insertTextBefore(closeBrace, specifiersText));
+		} else if (openBrace == null && shouldAddSpecifiers && !shouldAddDefault) if (first.specifiers.length === 0) fixes.push(fixer.insertTextAfter(firstToken, ` {${specifiersText}} from`));
+		else fixes.push(fixer.insertTextAfter(first.specifiers[0], `, {${specifiersText}}`));
+		else if (openBrace != null && closeBrace != null && !shouldAddDefault) {
+			const tokenBefore = sourceCode.getTokenBefore(closeBrace);
+			fixes.push(fixer.insertTextAfter(tokenBefore, specifiersText));
+		}
+		for (const specifier of specifiers) {
+			const importNode = specifier.importNode;
+			fixes.push(fixer.remove(importNode));
+			const charAfterImportRange = [importNode.range[1], importNode.range[1] + 1];
+			const charAfterImport = sourceCode.text.slice(charAfterImportRange[0], charAfterImportRange[1]);
+			if (charAfterImport === "\n") fixes.push(fixer.removeRange(charAfterImportRange));
+		}
+		for (const node of unnecessaryImports) {
+			fixes.push(fixer.remove(node));
+			const charAfterImportRange = [node.range[1], node.range[1] + 1];
+			const charAfterImport = sourceCode.text.slice(charAfterImportRange[0], charAfterImportRange[1]);
+			if (charAfterImport === "\n") fixes.push(fixer.removeRange(charAfterImportRange));
+		}
+		return fixes;
+	};
+}
+function isPunctuator(node, value) {
+	return node.type === "Punctuator" && node.value === value;
+}
+function getDefaultImportName(node) {
+	const defaultSpecifier = node.specifiers.find((specifier) => specifier.type === "ImportDefaultSpecifier");
+	return defaultSpecifier?.local.name;
+}
+function hasNamespace(node) {
+	return node.specifiers.some((specifier) => specifier.type === "ImportNamespaceSpecifier");
+}
+function hasSpecifiers(node) {
+	return node.specifiers.some((specifier) => specifier.type === "ImportSpecifier");
+}
+function hasProblematicComments(node, sourceCode) {
+	return hasCommentBefore(node, sourceCode) || hasCommentAfter(node, sourceCode) || hasCommentInsideNonSpecifiers(node, sourceCode);
+}
+function hasCommentBefore(node, sourceCode) {
+	return sourceCode.getCommentsBefore(node).some((comment) => comment.loc.end.line >= node.loc.start.line - 1);
+}
+function hasCommentAfter(node, sourceCode) {
+	return sourceCode.getCommentsAfter(node).some((comment) => comment.loc.start.line === node.loc.end.line);
+}
+function hasCommentInsideNonSpecifiers(node, sourceCode) {
+	const tokens = sourceCode.getTokens(node);
+	const openBraceIndex = tokens.findIndex((token) => isPunctuator(token, "{"));
+	const closeBraceIndex = tokens.findIndex((token) => isPunctuator(token, "}"));
+	const someTokens = openBraceIndex !== -1 && closeBraceIndex !== -1 ? [...tokens.slice(1, openBraceIndex + 1), ...tokens.slice(closeBraceIndex + 1)] : tokens.slice(1);
+	return someTokens.some((token) => sourceCode.getCommentsBefore(token).length > 0);
+}
+var no_duplicates_default;
+var init_no_duplicates = __esm({ "src/rules/no-duplicates/no-duplicates.ts"() {
+	init_utils();
+	no_duplicates_default = createRule({
+		name: "no-duplicates",
+		meta: {
+			type: "problem",
+			docs: {
+				recommended: true,
+				description: "Forbid repeated import of the same module in multiple places."
+			},
+			fixable: "code",
+			schema: [{
+				type: "object",
+				properties: { "prefer-inline": { type: "boolean" } },
+				additionalProperties: false
+			}],
+			messages: { duplicate: "'{{module}}' imported multiple times." }
+		},
+		defaultOptions: [],
+		create(context) {
+			const preferInline = context.options[0]?.["prefer-inline"];
+			const moduleMaps = /* @__PURE__ */ new Map();
+			function getImportMap(n) {
+				const parent = n.parent;
+				let map;
+				if (moduleMaps.has(parent)) map = moduleMaps.get(parent);
+				else {
+					map = {
+						imported: /* @__PURE__ */ new Map(),
+						nsImported: /* @__PURE__ */ new Map(),
+						defaultTypesImported: /* @__PURE__ */ new Map(),
+						namespaceTypesImported: /* @__PURE__ */ new Map(),
+						namedTypesImported: /* @__PURE__ */ new Map()
+					};
+					moduleMaps.set(parent, map);
+				}
+				if (n.importKind === "type") {
+					if (n.specifiers.length > 0 && n.specifiers[0].type === "ImportDefaultSpecifier") return map.defaultTypesImported;
+					if (n.specifiers.length > 0 && n.specifiers[0].type === "ImportNamespaceSpecifier") return map.namespaceTypesImported;
+					if (!preferInline) return map.namedTypesImported;
+				}
+				if (!preferInline && n.specifiers.some((spec) => "importKind" in spec && spec.importKind === "type")) return map.namedTypesImported;
+				return hasNamespace(n) ? map.nsImported : map.imported;
+			}
+			return {
+				ImportDeclaration(n) {
+					const resolvedPath = n.source.value;
+					const importMap = getImportMap(n);
+					if (importMap.has(resolvedPath)) importMap.get(resolvedPath).push(n);
+					else importMap.set(resolvedPath, [n]);
+				},
+				"Program:exit": function() {
+					for (const map of moduleMaps.values()) {
+						checkImports(map.imported, context);
+						checkImports(map.nsImported, context);
+						checkImports(map.defaultTypesImported, context);
+						checkImports(map.namedTypesImported, context);
+					}
+				}
+			};
+		}
+	});
+} });
+
+//#endregion
+//#region node_modules/.pnpm/eslint-plugin-import-lite@0_c838f1a32201d76532b4c7682b426a35/node_modules/eslint-plugin-import-lite/dist/rules/no-mutable-exports.js
+var no_mutable_exports_default;
+var init_no_mutable_exports = __esm({ "src/rules/no-mutable-exports/no-mutable-exports.ts"() {
+	init_utils();
+	no_mutable_exports_default = createRule({
+		name: "no-mutable-exports",
+		meta: {
+			type: "suggestion",
+			docs: { description: "Forbid the use of mutable exports with `var` or `let`." },
+			schema: [],
+			messages: { noMutable: "Exporting mutable '{{kind}}' binding, use 'const' instead." }
+		},
+		defaultOptions: [],
+		create(context) {
+			function checkDeclaration(node) {
+				if ("kind" in node && (node.kind === "var" || node.kind === "let")) context.report({
+					node,
+					messageId: "noMutable",
+					data: { kind: node.kind }
+				});
+			}
+			function checkDeclarationsInScope({ variables }, name) {
+				for (const variable of variables) if (variable.name === name) {
+					for (const def of variable.defs) if (def.type === "Variable" && def.parent) checkDeclaration(def.parent);
+				}
+			}
+			return {
+				ExportDefaultDeclaration(node) {
+					const scope = context.sourceCode.getScope(node);
+					if ("name" in node.declaration) checkDeclarationsInScope(scope, node.declaration.name);
+				},
+				ExportNamedDeclaration(node) {
+					const scope = context.sourceCode.getScope(node);
+					if (node.declaration) checkDeclaration(node.declaration);
+					else if (!node.source) for (const specifier of node.specifiers) checkDeclarationsInScope(scope, specifier.local.name);
+				}
+			};
+		}
+	});
+} });
+
+//#endregion
+//#region node_modules/.pnpm/eslint-plugin-import-lite@0_c838f1a32201d76532b4c7682b426a35/node_modules/eslint-plugin-import-lite/dist/rules/no-named-default.js
+var no_named_default_default;
+var init_no_named_default = __esm({ "src/rules/no-named-default/no-named-default.ts"() {
+	init_utils();
+	init_ast();
+	no_named_default_default = createRule({
+		name: "no-named-default",
+		meta: {
+			type: "suggestion",
+			docs: { description: "Forbid named default exports." },
+			schema: [],
+			messages: { default: `Use default import syntax to import '{{importName}}'.` }
+		},
+		defaultOptions: [],
+		create(context) {
+			return { ImportDeclaration(node) {
+				for (const im of node.specifiers) {
+					if ("importKind" in im && im.importKind === "type") continue;
+					if (im.type === "ImportSpecifier" && getValue(im.imported) === "default") context.report({
+						node: im.local,
+						messageId: "default",
+						data: { importName: im.local.name }
+					});
+				}
+			} };
+		}
+	});
+} });
+
+//#endregion
+//#region node_modules/.pnpm/eslint-plugin-import-lite@0_c838f1a32201d76532b4c7682b426a35/node_modules/eslint-plugin-import-lite/dist/index.js
+var rules;
+var init_rules = __esm({ "src/rules/index.ts"() {
+	init_consistent_type_specifier_style();
+	init_first();
+	init_newline_after_import();
+	init_no_default_export();
+	init_no_duplicates();
+	init_no_mutable_exports();
+	init_no_named_default();
+	rules = {
+		"consistent-type-specifier-style": consistent_type_specifier_style_default,
+		"first": first_default,
+		"newline-after-import": newline_after_import_default,
+		"no-default-export": no_default_export_default,
+		"no-duplicates": no_duplicates_default,
+		"no-mutable-exports": no_mutable_exports_default,
+		"no-named-default": no_named_default_default
+	};
+} });
+function generateConfig(name, filter) {
+	let ruleMeta = Object.entries(rules).filter(([_, rule]) => !rule.meta?.deprecated);
+	if (filter) ruleMeta = ruleMeta.filter(([ruleName, rule]) => filter(ruleName, rule));
+	return {
+		name: `${pluginName}/${name}`,
+		plugins: { [pluginName]: {
+			name: pluginName,
+			rules
+		} },
+		rules: Object.fromEntries(ruleMeta.map(([ruleName]) => [`${pluginName}/${ruleName}`, "error"]))
+	};
+}
+var pluginName, src_default;
+var init_src = __esm({ "src/index.ts"() {
+	init_rules();
+	pluginName = "import-lite";
+	src_default = {
+		rules,
+		configs: {
+			recommended: generateConfig("recommended", (_, rule) => !!rule.meta?.docs?.recommended),
+			all: generateConfig("all")
+		}
+	};
+} });
+init_src();
+
+//#endregion
+export { src_default as default };