@borela-tech/eslint-config 2.4.2 → 2.5.1

package/dist/index.esm.js

@@ -0,0 +1,4729 @@
+import eslint from "@eslint/js";
+import react from "eslint-plugin-react";
+import stylistic from "@stylistic/eslint-plugin";
+import typescript from "typescript-eslint";
+import * as path from "path";
+import perfectionist from "eslint-plugin-perfectionist";
+import rule from "eslint-plugin-react-hooks";
+import eslintPluginUnicorn from "eslint-plugin-unicorn";
+//#region \0rolldown/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 __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+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 __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 __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+//#endregion
+//#region src/rules/shared/getLineIndent.ts
+function getLineIndent(sourceCode, line) {
+	return (sourceCode.getText().split("\n")[line - 1] ?? "").match(/^(\s*)/)?.[1] ?? "";
+}
+//#endregion
+//#region src/rules/arrayItemsLineBreak/buildMultilineFix.ts
+function buildMultilineFix$1(fixer, brackets, elements, sourceCode) {
+	const openingLine = brackets.openingBracket.loc.start.line;
+	const baseIndent = getLineIndent(sourceCode, openingLine);
+	const itemIndent = baseIndent + "  ";
+	const newText = `\n${elements.filter((el) => el !== null).map((element) => {
+		return `${itemIndent}${sourceCode.getText(element)}`;
+	}).join(",\n")},\n${baseIndent}`;
+	return fixer.replaceTextRange([brackets.openingBracket.range[1], brackets.closingBracket.range[0]], newText);
+}
+//#endregion
+//#region src/rules/arrayItemsLineBreak/defaultOptions.ts
+var defaultOptions$6 = { maxLength: 80 };
+//#endregion
+//#region src/rules/arrayItemsLineBreak/getBrackets.ts
+function getBrackets(sourceCode, node) {
+	const elements = node.elements;
+	if (elements.length === 0) return null;
+	const firstElement = elements.find((el) => el !== null);
+	if (!firstElement) return null;
+	const lastElement = [...elements].reverse().find((el) => el !== null);
+	if (!lastElement) return null;
+	const openingBracket = sourceCode.getTokenBefore(firstElement);
+	const closingBracket = sourceCode.getTokenAfter(lastElement);
+	if (!openingBracket || !closingBracket) return null;
+	if (openingBracket.value !== "[" || closingBracket.value !== "]") return null;
+	return {
+		closingBracket,
+		openingBracket
+	};
+}
+//#endregion
+//#region src/rules/shared/getLineLength.ts
+function getLineLength(sourceCode, lineNumber) {
+	return sourceCode.getLines()[lineNumber - 1]?.length ?? 0;
+}
+//#endregion
+//#region src/rules/arrayItemsLineBreak/checkArray.ts
+function checkArray(sourceCode, context, node) {
+	const maxLength = (context.options[0] ?? {}).maxLength ?? defaultOptions$6.maxLength;
+	const elements = node.elements;
+	if (elements.length <= 1) return;
+	const brackets = getBrackets(sourceCode, node);
+	if (!brackets) return;
+	const firstLine = brackets.openingBracket.loc.start.line;
+	if (firstLine !== brackets.closingBracket.loc.end.line) return;
+	if (getLineLength(sourceCode, firstLine) <= maxLength) return;
+	context.report({
+		fix: (fixer) => buildMultilineFix$1(fixer, brackets, elements, sourceCode),
+		messageId: "arrayItemsOnNewLine",
+		node: elements[0]
+	});
+}
+//#endregion
+//#region src/rules/arrayItemsLineBreak/index.ts
+var arrayItemsLineBreak = {
+	create(context) {
+		const sourceCode = context.sourceCode ?? context.getSourceCode();
+		return { ArrayExpression(node) {
+			checkArray(sourceCode, context, node);
+		} };
+	},
+	meta: {
+		docs: { description: "Enforce each array item to be on its own line when the array expression exceeds a configurable maximum line length." },
+		fixable: "code",
+		messages: { arrayItemsOnNewLine: "arrayItemsOnNewLine" },
+		schema: [{
+			additionalProperties: false,
+			properties: { maxLength: { type: "number" } },
+			type: "object"
+		}],
+		type: "layout"
+	}
+};
+//#endregion
+//#region src/rules/braceStyleControlStatements/getIndentation.ts
+function getIndentation(node, sourceCode) {
+	const tokenBeforeBody = sourceCode.getTokenBefore(node);
+	if (!tokenBeforeBody) return "";
+	const line = sourceCode.getText().split("\n")[tokenBeforeBody.loc.start.line - 1];
+	if (!line) return "";
+	return line.match(/^(\s*)/)?.[1] ?? "";
+}
+//#endregion
+//#region src/rules/braceStyleControlStatements/createBraceStyleFix.ts
+function createBraceStyleFix(fixer, body, sourceCode) {
+	if (body.type === "BlockStatement") {
+		const firstToken = sourceCode.getFirstToken(body);
+		if (!firstToken) return null;
+		return fixer.insertTextBefore(firstToken, "\n");
+	}
+	const bodyText = sourceCode.getText(body);
+	const indentation = getIndentation(body, sourceCode);
+	const fixedText = `{\n${indentation}  ${bodyText}\n${indentation}}`;
+	return fixer.replaceText(body, fixedText);
+}
+//#endregion
+//#region src/rules/braceStyleControlStatements/isOnSameLineAsCondition.ts
+function isOnSameLineAsCondition(node, sourceCode) {
+	const tokenBeforeBody = sourceCode.getTokenBefore(node);
+	if (!tokenBeforeBody) return false;
+	const firstToken = sourceCode.getFirstToken(node);
+	if (!firstToken) return false;
+	return tokenBeforeBody.loc.end.line === firstToken.loc.start.line;
+}
+//#endregion
+//#region src/rules/shared/isSingleLineStatement.ts
+function isSingleLineStatement(node, sourceCode) {
+	const firstToken = sourceCode.getFirstToken(node);
+	const lastToken = sourceCode.getLastToken(node);
+	if (!firstToken || !lastToken) return false;
+	return firstToken.loc.start.line === lastToken.loc.end.line;
+}
+//#endregion
+//#region src/rules/braceStyleControlStatements/reportBodyOnSameLineAsCondition.ts
+function reportBodyOnSameLineAsCondition(context, body) {
+	const sourceCode = context.sourceCode;
+	if (body.type !== "BlockStatement") {
+		if (isOnSameLineAsCondition(body, sourceCode)) context.report({
+			fix: (fixer) => createBraceStyleFix(fixer, body, sourceCode),
+			messageId: "singleLine",
+			node: body
+		});
+	} else {
+		const isOnSameLine = isOnSameLineAsCondition(body, sourceCode);
+		const isSingleLine = isSingleLineStatement(body, sourceCode);
+		if (isOnSameLine && isSingleLine) context.report({
+			fix: (fixer) => createBraceStyleFix(fixer, body, sourceCode),
+			messageId: "singleLine",
+			node: body
+		});
+	}
+}
+//#endregion
+//#region src/rules/braceStyleControlStatements/checkDoWhileStatementBraceStyle.ts
+function checkDoWhileStatementBraceStyle(node, context) {
+	reportBodyOnSameLineAsCondition(context, node.body);
+}
+//#endregion
+//#region src/rules/braceStyleControlStatements/checkForStatementBraceStyle.ts
+function checkForStatementBraceStyle(node, context) {
+	reportBodyOnSameLineAsCondition(context, node.body);
+}
+//#endregion
+//#region src/rules/braceStyleControlStatements/checkIfStatementBraceStyle.ts
+function checkIfStatementBraceStyle(node, context) {
+	const sourceCode = context.sourceCode;
+	reportBodyOnSameLineAsCondition(context, node.consequent);
+	if (!node.alternate) return;
+	if (node.alternate.type === "BlockStatement") {
+		reportBodyOnSameLineAsCondition(context, node.alternate);
+		return;
+	}
+	if (node.alternate.type !== "IfStatement") {
+		const alternate = node.alternate;
+		if (isOnSameLineAsCondition(alternate, sourceCode)) context.report({
+			fix: (fixer) => createBraceStyleFix(fixer, alternate, sourceCode),
+			messageId: "singleLine",
+			node: alternate
+		});
+	}
+}
+//#endregion
+//#region src/rules/braceStyleControlStatements/checkWhileStatementBraceStyle.ts
+function checkWhileStatementBraceStyle(node, context) {
+	reportBodyOnSameLineAsCondition(context, node.body);
+}
+//#endregion
+//#region src/rules/braceStyleControlStatements/index.ts
+var braceStyleControlStatements = {
+	create(context) {
+		return {
+			DoWhileStatement: (node) => checkDoWhileStatementBraceStyle(node, context),
+			ForStatement: (node) => checkForStatementBraceStyle(node, context),
+			IfStatement: (node) => checkIfStatementBraceStyle(node, context),
+			WhileStatement: (node) => checkWhileStatementBraceStyle(node, context)
+		};
+	},
+	meta: {
+		docs: { description: "Enforce control statements to have multi-line body." },
+		fixable: "code",
+		messages: { singleLine: "Control statement body must be on a separate line" },
+		schema: [],
+		type: "layout"
+	}
+};
+//#endregion
+//#region src/rules/braceStyleObjectLiteral/checkClosingBrace.ts
+function checkClosingBrace(sourceCode, context, node, closingBrace) {
+	const lastProperty = node.properties[node.properties.length - 1];
+	const closingLine = closingBrace.loc.end.line;
+	if (!(lastProperty.loc.end.line < closingLine)) context.report({
+		fix(fixer) {
+			return fixer.replaceTextRange([lastProperty.range[1], closingBrace.range[0]], ",\n" + getLineIndent(sourceCode, lastProperty.loc.end.line));
+		},
+		loc: closingBrace.loc,
+		messageId: "braceOnPropertyLine"
+	});
+}
+//#endregion
+//#region src/rules/braceStyleObjectLiteral/checkNestedObjects.ts
+function checkNestedObjects(sourceCode, context, node, checkObjectExpression) {
+	for (const property of node.properties) if (property.type === "Property" && property.value.type === "ObjectExpression") checkObjectExpression(sourceCode, context, property.value);
+	else if (property.type === "SpreadElement" && property.argument.type === "ObjectExpression") checkObjectExpression(sourceCode, context, property.argument);
+}
+//#endregion
+//#region src/rules/braceStyleObjectLiteral/checkOpeningBrace.ts
+function checkOpeningBrace(sourceCode, context, node, openingBrace) {
+	const firstProperty = node.properties[0];
+	const openingLine = openingBrace.loc.start.line;
+	if (!(firstProperty.loc.start.line > openingLine)) context.report({
+		fix(fixer) {
+			return fixer.replaceTextRange([openingBrace.range[1], firstProperty.range[0]], "\n" + getLineIndent(sourceCode, firstProperty.loc.start.line));
+		},
+		loc: openingBrace.loc,
+		messageId: "braceOnPropertyLine"
+	});
+}
+//#endregion
+//#region src/rules/braceStyleObjectLiteral/checkPropertyOnOwnLine.ts
+function checkPropertyOnOwnLine(sourceCode, context, prevPropertyEndLine, property) {
+	if (property.loc.start.line === prevPropertyEndLine) context.report({
+		fix(fixer) {
+			const lastNewLineIndex = sourceCode.getText().lastIndexOf("\n", property.range[0] - 1);
+			return fixer.replaceTextRange([lastNewLineIndex, property.range[0]], "\n" + getLineIndent(sourceCode, property.loc.start.line));
+		},
+		loc: property.loc,
+		messageId: "propertiesOnSameLine"
+	});
+}
+//#endregion
+//#region src/rules/braceStyleObjectLiteral/checkObjectExpression.ts
+function checkObjectExpression(sourceCode, context, node) {
+	if (node.properties.length === 0) return;
+	const openingBrace = sourceCode.getFirstToken(node);
+	const closingBrace = sourceCode.getLastToken(node);
+	if (!openingBrace || !closingBrace) return;
+	if (openingBrace.loc.start.line === closingBrace.loc.end.line) return;
+	checkOpeningBrace(sourceCode, context, node, openingBrace);
+	let prevPropertyEndLine = node.properties[0].loc.start.line;
+	for (const property of node.properties) {
+		if (property !== node.properties[0]) checkPropertyOnOwnLine(sourceCode, context, prevPropertyEndLine, property);
+		prevPropertyEndLine = property.loc.end.line;
+	}
+	checkClosingBrace(sourceCode, context, node, closingBrace);
+	checkNestedObjects(sourceCode, context, node, checkObjectExpression);
+}
+//#endregion
+//#region src/rules/braceStyleObjectLiteral/index.ts
+var braceStyleObjectLiteral = {
+	create(context) {
+		const sourceCode = context.sourceCode ?? context.getSourceCode();
+		return { ObjectExpression(node) {
+			checkObjectExpression(sourceCode, context, node);
+		} };
+	},
+	meta: {
+		docs: { description: "Enforce consistent brace positioning for object literals." },
+		fixable: "code",
+		messages: {
+			braceOnPropertyLine: "Opening brace should be on its own line",
+			propertiesOnSameLine: "Multi-line objects must have each property on its own line"
+		},
+		schema: [{
+			additionalProperties: false,
+			properties: {},
+			type: "object"
+		}],
+		type: "layout"
+	}
+};
+//#endregion
+//#region src/rules/compactArrayItems/buildCompactFix.ts
+function buildCompactFix(fixer, openingBracket, closingBracket, elements, sourceCode) {
+	const newText = `[${elements.filter((el) => el !== null).map((element) => sourceCode.getText(element)).join(", ")}]`;
+	return fixer.replaceTextRange([openingBracket.range[0], closingBracket.range[1]], newText);
+}
+//#endregion
+//#region src/rules/compactArrayItems/findBracketByRange.ts
+function findBracketByRange(tokens, range, value) {
+	return tokens?.find((t) => t.range[0] === range[0] && t.value === value);
+}
+//#endregion
+//#region src/rules/compactArrayItems/findClosingBracketByRange.ts
+function findClosingBracketByRange(tokens, range) {
+	return tokens?.find((t) => t.range[1] === range[1] && t.value === "]");
+}
+//#endregion
+//#region src/rules/compactArrayItems/hasElements.ts
+function hasElements(elements) {
+	return elements.filter((el) => el !== null).length >= 1;
+}
+//#endregion
+//#region src/rules/compactArrayItems/hasMultilineItems.ts
+function hasMultilineItems(nonNullElements) {
+	return nonNullElements.some((el) => el.loc.start.line !== el.loc.end.line);
+}
+//#endregion
+//#region src/rules/compactArrayItems/isBracketOnOwnLine.ts
+function isBracketOnOwnLine(sourceCode, openingBracket) {
+	const nextToken = sourceCode.getTokenAfter(openingBracket, { includeComments: false });
+	if (!nextToken) return false;
+	const text = sourceCode.getText();
+	const openingBracketEndIndex = openingBracket.range[1];
+	return text.slice(openingBracketEndIndex, nextToken.range[0]).includes("\n");
+}
+//#endregion
+//#region src/rules/compactArrayItems/index.ts
+var compactArrayItems = {
+	create(context) {
+		const sourceCode = context.sourceCode ?? context.getSourceCode();
+		return { ArrayExpression(node) {
+			if (!hasElements(node.elements)) return;
+			const tokens = sourceCode.ast.tokens;
+			const openingBracket = findBracketByRange(tokens, node.range, "[");
+			const closingBracket = findClosingBracketByRange(tokens, node.range);
+			if (!openingBracket || !closingBracket) return;
+			if (!isBracketOnOwnLine(sourceCode, openingBracket)) return;
+			if (!hasMultilineItems(node.elements.filter((el) => el !== null))) return;
+			context.report({
+				fix: (fixer) => buildCompactFix(fixer, openingBracket, closingBracket, node.elements, sourceCode),
+				messageId: "compactItems",
+				node
+			});
+		} };
+	},
+	meta: {
+		docs: { description: "Enforce arrays with multiline items to have a compact, inline bracket style." },
+		fixable: "code",
+		messages: { compactItems: "Array items should be compact when the array spans multiple lines." },
+		schema: [],
+		type: "layout"
+	}
+};
+//#endregion
+//#region src/rules/exportFilenameMatch/getNameFromDeclaration.ts
+function getNameFromDeclaration(node) {
+	const names = [];
+	switch (node.type) {
+		case "ClassDeclaration":
+			if (node.id) names.push(node.id.name);
+			break;
+		case "FunctionDeclaration":
+			if (node.id) names.push(node.id.name);
+			break;
+		case "TSInterfaceDeclaration":
+			names.push(node.id.name);
+			break;
+		case "TSTypeAliasDeclaration":
+			names.push(node.id.name);
+			break;
+		case "VariableDeclaration":
+			for (const d of node.declarations) if (d.id.type === "Identifier") names.push(d.id.name);
+			break;
+	}
+	return names;
+}
+//#endregion
+//#region src/rules/exportFilenameMatch/getNamesFromSpecifiers.ts
+function getNamesFromSpecifiers(node) {
+	if (!node.specifiers?.length) return [];
+	const names = [];
+	for (const specifier of node.specifiers) if (specifier.exported.type === "Identifier") names.push(specifier.exported.name);
+	return names;
+}
+//#endregion
+//#region src/rules/exportFilenameMatch/getExportedNames.ts
+function getExportedNames(node) {
+	const specifierNames = getNamesFromSpecifiers(node);
+	if (!node.declaration) return specifierNames;
+	const declarationNames = getNameFromDeclaration(node.declaration);
+	return [...specifierNames, ...declarationNames];
+}
+//#endregion
+//#region src/rules/shared/stripExtension.ts
+function stripExtension(filename) {
+	return path.basename(filename, path.extname(filename));
+}
+//#endregion
+//#region src/rules/shared/isExempt.ts
+function isExempt$2(filename) {
+	const name = stripExtension(filename);
+	return name === "index" || name.endsWith(".test") || name.endsWith(".spec") || name.endsWith(".config");
+}
+//#endregion
+//#region src/rules/exportFilenameMatch/index.ts
+var exportFilenameMatch = {
+	create(context) {
+		const fileName = context.filename;
+		const baseName = path.basename(fileName);
+		const ext = path.extname(baseName);
+		const fileNameWithoutExt = baseName.slice(0, -ext.length);
+		if (isExempt$2(fileName)) return {};
+		const exportNames = [];
+		return {
+			ExportNamedDeclaration(node) {
+				const names = getExportedNames(node);
+				exportNames.push(...names);
+			},
+			"Program:exit"(programNode) {
+				if (exportNames.length === 1) {
+					const [exportName] = exportNames;
+					if (exportName !== fileNameWithoutExt) context.report({
+						data: {
+							currentName: `${fileNameWithoutExt}${ext}`,
+							expectedName: `${exportName}${ext}`
+						},
+						messageId: "filenameMismatch",
+						node: programNode
+					});
+				}
+			}
+		};
+	},
+	meta: {
+		docs: { description: "Enforce filename matches the single named export." },
+		messages: { filenameMismatch: "File name must be '{{expectedName}}' instead of '{{currentName}}'." },
+		schema: [],
+		type: "suggestion"
+	}
+};
+//#endregion
+//#region src/rules/shared/findLinesWithMultipleNodes.ts
+function findLinesWithMultipleNodes(nodes) {
+	const lines = [];
+	for (let i = 0; i < nodes.length; i++) {
+		const nodeLine = nodes[i].loc.start.line;
+		if (i < nodes.length - 1) {
+			if (nodes[i + 1].loc.start.line === nodeLine) lines.push(nodeLine);
+		}
+	}
+	return lines;
+}
+//#endregion
+//#region src/rules/functionCallArgumentLineBreak/formatArgs.ts
+function formatArgs(sourceCode, nodes, indent) {
+	return nodes.map((arg, index) => {
+		const argText = sourceCode.getText(arg);
+		if (index === nodes.length - 1) return argText;
+		const comma = sourceCode.getTokenAfter(arg, (token) => token.value === ",");
+		if (comma && comma.loc.end.line === arg.loc.end.line) return argText + ",";
+		return argText;
+	}).map((text, index) => index === 0 ? `${indent}${text}` : `\n${indent}${text}`).join("");
+}
+//#endregion
+//#region src/rules/shared/getLineStartIndex.ts
+function getLineStartIndex(sourceCode, line) {
+	return sourceCode.getLines().slice(0, line - 1).reduce((acc, l) => acc + l.length + 1, 0);
+}
+//#endregion
+//#region src/rules/functionCallArgumentLineBreak/checkMultilineArgs.ts
+function checkMultilineArgs(sourceCode, context, args, maxLength) {
+	const linesWithMultipleArgs = findLinesWithMultipleNodes(args);
+	for (const line of linesWithMultipleArgs) {
+		const lineLength = getLineLength(sourceCode, line);
+		if (lineLength > maxLength) context.report({
+			data: { maxLength },
+			fix: (fixer) => {
+				const nodesOnLine = args.filter((arg) => arg.loc.start.line <= line && arg.loc.end.line >= line);
+				const lastNode = nodesOnLine[nodesOnLine.length - 1];
+				const lineStartIndex = getLineStartIndex(sourceCode, line);
+				const fixed = formatArgs(sourceCode, nodesOnLine, (sourceCode.getText().match(/^[\t ]*/)?.[0] ?? "") + "  ");
+				return fixer.replaceTextRange([lineStartIndex, lastNode.range[1]], fixed);
+			},
+			loc: {
+				end: {
+					column: lineLength,
+					line
+				},
+				start: {
+					column: 0,
+					line
+				}
+			},
+			messageId: "multipleOnSameLine"
+		});
+	}
+}
+//#endregion
+//#region src/rules/functionCallArgumentLineBreak/checkSingleLineArgs.ts
+function checkSingleLineArgs(sourceCode, context, args, parens, maxLength) {
+	const { closingParen, openingParen } = parens;
+	const lineLength = getLineLength(sourceCode, openingParen.loc.start.line);
+	if (lineLength <= maxLength) return;
+	if (args.length === 1) {
+		context.report({
+			data: { maxLength },
+			loc: {
+				end: {
+					column: lineLength,
+					line: closingParen.loc.end.line
+				},
+				start: {
+					column: 0,
+					line: openingParen.loc.start.line
+				}
+			},
+			messageId: "exceedsMaxLength"
+		});
+		return;
+	}
+	context.report({
+		data: { maxLength },
+		fix: (fixer) => {
+			const indent = sourceCode.getText().match(/^[\t ]*/)?.[0] ?? "";
+			const fixed = [
+				"(\n",
+				`${indent}  ${args.map((arg) => {
+					const argText = sourceCode.getText(arg);
+					const comma = sourceCode.getTokenAfter(arg, (token) => token.value === ",");
+					if (comma && comma.loc.end.line === arg.loc.end.line) return argText + ",";
+					return argText;
+				}).join(`\n${indent}  `)}\n`,
+				`${indent})`
+			].join("");
+			return fixer.replaceTextRange([openingParen.range[0], closingParen.range[1]], fixed);
+		},
+		loc: {
+			end: {
+				column: lineLength,
+				line: closingParen.loc.end.line
+			},
+			start: {
+				column: 0,
+				line: openingParen.loc.start.line
+			}
+		},
+		messageId: "multipleOnSameLine"
+	});
+}
+//#endregion
+//#region src/rules/functionCallArgumentLineBreak/defaultOptions.ts
+var defaultOptions$5 = { maxLength: 80 };
+//#endregion
+//#region src/rules/shared/getParens.ts
+function getParens$1(sourceCode, nodes) {
+	if (nodes.length === 0) return null;
+	const firstNode = nodes[0];
+	const lastNode = nodes[nodes.length - 1];
+	const openingParen = sourceCode.getTokenBefore(firstNode);
+	const closingParen = sourceCode.getTokenAfter(lastNode);
+	if (!openingParen || !closingParen) return null;
+	return {
+		closingParen,
+		openingParen
+	};
+}
+//#endregion
+//#region src/rules/shared/isValidParens.ts
+function isValidParens(parens) {
+	if (!parens) return false;
+	return parens.openingParen.value === "(" && parens.closingParen.value === ")";
+}
+//#endregion
+//#region src/rules/functionCallArgumentLineBreak/checkCall.ts
+function checkCall(sourceCode, context, node) {
+	const maxLength = (context.options[0] ?? {}).maxLength ?? defaultOptions$5.maxLength;
+	const args = node.arguments;
+	const parens = getParens$1(sourceCode, args);
+	if (!isValidParens(parens)) return;
+	if (parens.openingParen.loc.start.line === parens.closingParen.loc.end.line) checkSingleLineArgs(sourceCode, context, args, parens, maxLength);
+	else checkMultilineArgs(sourceCode, context, args, maxLength);
+}
+//#endregion
+//#region src/rules/functionCallArgumentLineBreak/index.ts
+var functionCallArgumentLineBreak = {
+	create(context) {
+		const sourceCode = context.sourceCode ?? context.getSourceCode();
+		return {
+			CallExpression(node) {
+				checkCall(sourceCode, context, node);
+			},
+			OptionalCallExpression(node) {
+				checkCall(sourceCode, context, node);
+			}
+		};
+	},
+	meta: {
+		docs: { description: "Enforce each function call argument to be on its own line when line exceeds max length." },
+		fixable: "code",
+		messages: {
+			exceedsMaxLength: "Refactor this function call as it exceeds {{maxLength}} characters",
+			multipleOnSameLine: "Each argument must be on its own line"
+		},
+		schema: [{
+			additionalProperties: false,
+			properties: { maxLength: { type: "number" } },
+			type: "object"
+		}],
+		type: "layout"
+	}
+};
+//#endregion
+//#region src/rules/functionCognitiveComplexity/isNodeWithType.ts
+function isNodeWithType(value) {
+	return value !== null && typeof value === "object" && "type" in value;
+}
+//#endregion
+//#region src/rules/functionCognitiveComplexity/getChildNodes.ts
+var SKIP_KEYS = new Set([
+	"loc",
+	"parent",
+	"range"
+]);
+function getChildNodes(node) {
+	const children = [];
+	for (const key of Object.keys(node)) {
+		if (SKIP_KEYS.has(key)) continue;
+		const value = node[key];
+		if (Array.isArray(value)) {
+			for (const item of value) if (isNodeWithType(item)) children.push(item);
+		} else if (isNodeWithType(value)) children.push(value);
+	}
+	return children;
+}
+//#endregion
+//#region src/rules/functionCognitiveComplexity/isIncrementableControlFlow.ts
+var INCREMENTABLE_TYPES = new Set([
+	"ConditionalExpression",
+	"DoWhileStatement",
+	"ForInStatement",
+	"ForOfStatement",
+	"ForStatement",
+	"IfStatement",
+	"LogicalExpression",
+	"SwitchStatement",
+	"TryStatement",
+	"WhileStatement"
+]);
+function isIncrementableControlFlow(node) {
+	return INCREMENTABLE_TYPES.has(node.type);
+}
+//#endregion
+//#region src/rules/functionCognitiveComplexity/traverse.ts
+function traverse(node, nestingLevel, state) {
+	if (isIncrementableControlFlow(node)) {
+		state.complexity += 1 + nestingLevel;
+		nestingLevel++;
+	}
+	const children = getChildNodes(node);
+	for (const child of children) traverse(child, nestingLevel, state);
+}
+//#endregion
+//#region src/rules/functionCognitiveComplexity/calculateCognitiveComplexity.ts
+function calculateCognitiveComplexity(node) {
+	const state = {
+		complexity: 0,
+		nestingLevel: 0
+	};
+	const children = getChildNodes(node);
+	for (const child of children) traverse(child, 0, state);
+	return state.complexity;
+}
+//#endregion
+//#region src/rules/functionCognitiveComplexity/getNameFromCallExpression.ts
+function getNameFromCallExpression(node) {
+	if (node?.type === "CallExpression" && node.callee?.type === "Identifier") return `${node.callee.name} callback`;
+	return null;
+}
+//#endregion
+//#region src/rules/functionCognitiveComplexity/getNameFromProperty.ts
+function getNameFromProperty(node) {
+	if (node?.type === "Property" && node.key?.type === "Identifier") return node.key.name;
+	return null;
+}
+//#endregion
+//#region src/rules/functionCognitiveComplexity/getNameFromVariableDeclarator.ts
+function getNameFromVariableDeclarator(node) {
+	if (node?.type === "VariableDeclarator" && node.id?.type === "Identifier") return node.id.name;
+	return null;
+}
+//#endregion
+//#region src/rules/functionCognitiveComplexity/getArrowFunctionExpressionName.ts
+function getArrowFunctionExpressionName(node) {
+	const parent = node.parent;
+	const nameFromVar = getNameFromVariableDeclarator(parent);
+	if (nameFromVar) return nameFromVar;
+	const nameFromProp = getNameFromProperty(parent);
+	if (nameFromProp) return nameFromProp;
+	const nameFromCall = getNameFromCallExpression(parent);
+	if (nameFromCall) return nameFromCall;
+	return null;
+}
+//#endregion
+//#region src/rules/functionCognitiveComplexity/getNameFromMethodDefinition.ts
+function getNameFromMethodDefinition(node) {
+	if (node?.type === "MethodDefinition" && node.key?.type === "Identifier") return node.key.name;
+	return null;
+}
+//#endregion
+//#region src/rules/functionCognitiveComplexity/getFunctionExpressionName.ts
+function getFunctionExpressionName(node) {
+	const parent = node.parent;
+	const nameFromVar = getNameFromVariableDeclarator(parent);
+	if (nameFromVar) return nameFromVar;
+	const nameFromProp = getNameFromProperty(parent);
+	if (nameFromProp) return nameFromProp;
+	const nameFromMethod = getNameFromMethodDefinition(parent);
+	if (nameFromMethod) return nameFromMethod;
+	return null;
+}
+//#endregion
+//#region src/rules/functionCognitiveComplexity/getFunctionName.ts
+function getFunctionName$1(node) {
+	if (node.type === "FunctionDeclaration" && node.id?.name) return node.id.name;
+	if (node.type === "FunctionExpression") return getFunctionExpressionName(node);
+	if (node.type === "ArrowFunctionExpression") return getArrowFunctionExpressionName(node);
+	return null;
+}
+//#endregion
+//#region src/rules/functionCognitiveComplexity/messageIds.ts
+var messageIds$8 = {
+	tooHighCognitiveComplexity: "Function '{{name}}' has cognitive complexity of {{actual}} (max: {{max}}). Consider extracting sub-functions.",
+	tooHighCognitiveComplexityAnonymous: "Anonymous function has cognitive complexity of {{actual}} (max: {{max}}). Consider extracting sub-functions."
+};
+//#endregion
+//#region src/rules/functionCognitiveComplexity/index.ts
+var DEFAULT_MAX_COGNITIVE_COMPLEXITY = 15;
+var functionCognitiveComplexity = {
+	create(context) {
+		const maxCognitiveComplexity = (context.options[0] ?? {}).maxCognitiveComplexity ?? DEFAULT_MAX_COGNITIVE_COMPLEXITY;
+		function checkFunction(node) {
+			const complexity = calculateCognitiveComplexity(node);
+			if (complexity > maxCognitiveComplexity) {
+				const name = getFunctionName$1(node);
+				if (name) context.report({
+					data: {
+						actual: complexity,
+						max: maxCognitiveComplexity,
+						name
+					},
+					messageId: "tooHighCognitiveComplexity",
+					node
+				});
+				else context.report({
+					data: {
+						actual: complexity,
+						max: maxCognitiveComplexity
+					},
+					messageId: "tooHighCognitiveComplexityAnonymous",
+					node
+				});
+			}
+		}
+		return {
+			ArrowFunctionExpression(node) {
+				checkFunction(node);
+			},
+			FunctionDeclaration(node) {
+				checkFunction(node);
+			},
+			FunctionExpression(node) {
+				checkFunction(node);
+			}
+		};
+	},
+	meta: {
+		docs: { description: "Enforce cognitive complexity threshold for functions." },
+		messages: messageIds$8,
+		schema: [{
+			additionalProperties: false,
+			properties: { maxCognitiveComplexity: { type: "number" } },
+			type: "object"
+		}],
+		type: "suggestion"
+	}
+};
+//#endregion
+//#region src/rules/functionParameterLineBreak/formatParams.ts
+function formatParams(sourceCode, nodes, indent) {
+	return nodes.map((param, index) => {
+		const paramText = sourceCode.getText(param);
+		if (index === nodes.length - 1) return paramText;
+		const comma = sourceCode.getTokenAfter(param, (token) => token.value === ",");
+		if (comma && comma.loc.end.line === param.loc.end.line) return paramText + ",";
+		return paramText;
+	}).map((text, index) => index === 0 ? `${indent}${text}` : `\n${indent}${text}`).join("");
+}
+//#endregion
+//#region src/rules/functionParameterLineBreak/checkMultilineParams.ts
+function checkMultilineParams(sourceCode, context, params, parens, maxLength) {
+	const linesWithMultipleParams = findLinesWithMultipleNodes(params);
+	for (const line of linesWithMultipleParams) {
+		const lineLength = getLineLength(sourceCode, line);
+		if (lineLength > maxLength) context.report({
+			data: { maxLength },
+			fix: (fixer) => {
+				const nodesOnLine = params.filter((param) => param.loc.start.line <= line && param.loc.end.line >= line);
+				const lastNode = nodesOnLine[nodesOnLine.length - 1];
+				const lineStartIndex = getLineStartIndex(sourceCode, line);
+				const fixed = formatParams(sourceCode, nodesOnLine, (sourceCode.getText().match(/^[\t ]*/)?.[0] ?? "") + "  ");
+				return fixer.replaceTextRange([lineStartIndex, lastNode.range[1]], fixed);
+			},
+			loc: {
+				end: {
+					column: lineLength,
+					line
+				},
+				start: {
+					column: 0,
+					line
+				}
+			},
+			messageId: "multipleOnSameLine"
+		});
+	}
+}
+//#endregion
+//#region src/rules/functionParameterLineBreak/checkSingleLineParams.ts
+function checkSingleLineParams(sourceCode, context, params, parens, maxLength) {
+	const { closingParen, openingParen } = parens;
+	const lineLength = getLineLength(sourceCode, openingParen.loc.start.line);
+	if (lineLength <= maxLength) return;
+	if (params.length === 1) {
+		context.report({
+			data: { maxLength },
+			loc: {
+				end: {
+					column: lineLength,
+					line: closingParen.loc.end.line
+				},
+				start: {
+					column: 0,
+					line: openingParen.loc.start.line
+				}
+			},
+			messageId: "exceedsMaxLength"
+		});
+		return;
+	}
+	context.report({
+		data: { maxLength },
+		fix: (fixer) => {
+			const indent = sourceCode.getText().match(/^[\t ]*/)?.[0] ?? "";
+			const fixed = [
+				"(\n",
+				`${indent}  ${params.map((param) => {
+					const paramText = sourceCode.getText(param);
+					const comma = sourceCode.getTokenAfter(param, (token) => token.value === ",");
+					if (comma && comma.loc.end.line === param.loc.end.line) return paramText + ",";
+					return paramText;
+				}).join(`\n${indent}  `)}\n`,
+				`${indent})`
+			].join("");
+			return fixer.replaceTextRange([openingParen.range[0], closingParen.range[1]], fixed);
+		},
+		loc: {
+			end: {
+				column: lineLength,
+				line: closingParen.loc.end.line
+			},
+			start: {
+				column: 0,
+				line: openingParen.loc.start.line
+			}
+		},
+		messageId: "multipleOnSameLine"
+	});
+}
+//#endregion
+//#region src/rules/functionParameterLineBreak/defaultOptions.ts
+var defaultOptions$4 = { maxLength: 80 };
+//#endregion
+//#region src/rules/functionParameterLineBreak/checkFunction.ts
+function checkFunction$1(sourceCode, context, node) {
+	const maxLength = (context.options[0] ?? {}).maxLength ?? defaultOptions$4.maxLength;
+	const params = node.params;
+	if (params.length === 0) return;
+	const parens = getParens$1(sourceCode, params);
+	if (!isValidParens(parens)) return;
+	if (parens.openingParen.loc.start.line === parens.closingParen.loc.end.line) checkSingleLineParams(sourceCode, context, params, parens, maxLength);
+	else checkMultilineParams(sourceCode, context, params, parens, maxLength);
+}
+//#endregion
+//#region src/rules/functionParameterLineBreak/index.ts
+var functionParameterLineBreak = {
+	create(context) {
+		const sourceCode = context.sourceCode ?? context.getSourceCode();
+		return {
+			ArrowFunctionExpression(node) {
+				if (node.expression) return;
+				checkFunction$1(sourceCode, context, node);
+			},
+			FunctionDeclaration(node) {
+				checkFunction$1(sourceCode, context, node);
+			},
+			FunctionExpression(node) {
+				checkFunction$1(sourceCode, context, node);
+			},
+			TSCallSignatureDeclaration(node) {
+				checkFunction$1(sourceCode, context, node);
+			},
+			TSFunctionType(node) {
+				checkFunction$1(sourceCode, context, node);
+			},
+			TSMethodSignature(node) {
+				checkFunction$1(sourceCode, context, node);
+			}
+		};
+	},
+	meta: {
+		docs: { description: "Enforce each function parameter to be on its own line when line exceeds max length." },
+		fixable: "code",
+		messages: {
+			exceedsMaxLength: "Refactor this function signature as it exceeds {{maxLength}} characters",
+			multipleOnSameLine: "Each parameter must be on its own line"
+		},
+		schema: [{
+			additionalProperties: false,
+			properties: { maxLength: { type: "number" } },
+			type: "object"
+		}],
+		type: "layout"
+	}
+};
+//#endregion
+//#region src/rules/importsAndReExportsAtTop/getStatementType.ts
+function getStatementType(statement) {
+	if (statement.type === "ImportDeclaration") return "import";
+	if (statement.type === "ExportAllDeclaration") return "re-export";
+	if (statement.type === "ExportNamedDeclaration") {
+		if (statement.source !== null) return "re-export";
+	}
+	return "other";
+}
+//#endregion
+//#region src/rules/importsAndReExportsAtTop/isImportDeclaration.ts
+function isImportDeclaration(statement) {
+	return statement.type === "ImportDeclaration";
+}
+//#endregion
+//#region src/rules/importsAndReExportsAtTop/isReExport.ts
+function isReExport(statement) {
+	if (statement.type === "ExportAllDeclaration") return true;
+	if (statement.type === "ExportNamedDeclaration") return statement.source !== null;
+	return false;
+}
+//#endregion
+//#region src/rules/importsAndReExportsAtTop/categorizeStatements.ts
+function categorizeStatements(statements) {
+	const result = {
+		imports: [],
+		other: [],
+		reExports: []
+	};
+	for (const statement of statements) {
+		const type = getStatementType(statement);
+		if (type === "import" && isImportDeclaration(statement)) result.imports.push(statement);
+		else if (type === "re-export" && isReExport(statement)) result.reExports.push(statement);
+		else result.other.push(statement);
+	}
+	return result;
+}
+//#endregion
+//#region src/rules/importsAndReExportsAtTop/findStatementIndices.ts
+function findStatementIndices(statements) {
+	let firstRegularStatement = -1;
+	let lastImport = -1;
+	let lastReExport = -1;
+	for (let i = 0; i < statements.length; i++) {
+		const type = getStatementType(statements[i]);
+		if (type === "import") lastImport = i;
+		else if (type === "re-export") lastReExport = i;
+		else if (type === "other" && firstRegularStatement === -1) firstRegularStatement = i;
+	}
+	return {
+		firstRegularStatement,
+		lastImport,
+		lastReExport
+	};
+}
+//#endregion
+//#region src/rules/importsAndReExportsAtTop/generateSortedText.ts
+function generateSortedText(context, categories) {
+	return [
+		...categories.imports,
+		...categories.reExports,
+		...categories.other
+	].map((node) => context.sourceCode.getText(node)).join("\n");
+}
+//#endregion
+//#region src/rules/importsAndReExportsAtTop/hasImportOrderViolation.ts
+function hasImportOrderViolation(indices, categories) {
+	const { firstRegularStatement, lastImport, lastReExport } = indices;
+	if (categories.imports.length === 0 && categories.reExports.length === 0) return false;
+	const hasImportAfterRegularStatement = categories.imports.length > 0 && firstRegularStatement !== -1 && lastImport > firstRegularStatement;
+	const hasReExportAfterRegularStatement = categories.reExports.length > 0 && firstRegularStatement !== -1 && lastReExport > firstRegularStatement;
+	return hasImportAfterRegularStatement || hasReExportAfterRegularStatement;
+}
+//#endregion
+//#region src/rules/importsAndReExportsAtTop/index.ts
+var importsAndReExportsAtTop = {
+	create(context) {
+		return { Program(node) {
+			const statements = node.body;
+			const categories = categorizeStatements(statements);
+			if (!hasImportOrderViolation(findStatementIndices(statements), categories)) return;
+			context.report({
+				fix(fixer) {
+					const sortedText = generateSortedText(context, categories);
+					return fixer.replaceText(node, sortedText);
+				},
+				messageId: "importsAndReExportsAtTop",
+				node
+			});
+		} };
+	},
+	meta: {
+		docs: { description: "Enforce imports and re-exports at the top of the file." },
+		fixable: "code",
+		messages: { importsAndReExportsAtTop: "Imports and re-exports should be at the top of the file." },
+		schema: [],
+		type: "suggestion"
+	}
+};
+//#endregion
+//#region src/rules/individualImports/index.ts
+var individualImports = {
+	create(context) {
+		return { ImportDeclaration(node) {
+			if (node.specifiers.length <= 1) return;
+			context.report({
+				fix(fixer) {
+					const source = node.source.raw;
+					const specifiers = node.specifiers.filter((s) => s.type === "ImportSpecifier").map((s) => `import {${s.local.name}} from ${source}`).join("\n");
+					return fixer.replaceText(node, specifiers);
+				},
+				messageId: "individualImports",
+				node
+			});
+		} };
+	},
+	meta: {
+		docs: { description: "Enforce individual imports instead of grouped imports." },
+		fixable: "code",
+		messages: { individualImports: "Use individual imports instead of grouped imports." },
+		schema: [],
+		type: "suggestion"
+	}
+};
+//#endregion
+//#region src/rules/individualReExports/index.ts
+var individualReExports = {
+	create(context) {
+		return { ExportNamedDeclaration(node) {
+			if (!node.source || node.specifiers.length <= 1) return;
+			context.report({
+				fix(fixer) {
+					const source = node.source.value;
+					const typeKeyword = node.exportKind === "type" ? "type " : "";
+					const specifiers = node.specifiers.map((s) => {
+						const localName = s.local.type === "Identifier" ? s.local.name : s.local.value;
+						const exportedName = s.exported.type === "Identifier" ? s.exported.name : s.exported.value;
+						return `export ${typeKeyword}{${localName === exportedName ? localName : `${localName} as ${exportedName}`}} from '${source}'`;
+					}).join("\n");
+					return fixer.replaceText(node, specifiers);
+				},
+				messageId: "individualReExports",
+				node
+			});
+		} };
+	},
+	meta: {
+		docs: { description: "Enforce individual exports instead of grouped exports." },
+		fixable: "code",
+		messages: { individualReExports: "Use individual exports instead of grouped exports." },
+		schema: [],
+		type: "suggestion"
+	}
+};
+//#endregion
+//#region src/rules/interfacePropertyLineBreak/formatTypeLiteral.ts
+function formatTypeLiteral(sourceCode, typeLiteral, baseIndent) {
+	const members = typeLiteral.members;
+	if (members.length === 0) return "{}";
+	const memberTexts = members.map((member) => {
+		if (member.type === "TSPropertySignature") return sourceCode.getText(member).replace(/,\s*$/, "");
+		return sourceCode.getText(member).replace(/,\s*$/, "");
+	});
+	const innerIndent = baseIndent + "  ";
+	return [
+		"{",
+		innerIndent + memberTexts.join(`\n${innerIndent}`),
+		`${baseIndent}}`
+	].join("\n");
+}
+//#endregion
+//#region src/rules/interfacePropertyLineBreak/checkMultilineMembers.ts
+function checkMultilineMembers(sourceCode, context, members, maxLength) {
+	for (const member of members) {
+		const memberLine = member.loc.start.line;
+		const lineLength = getLineLength(sourceCode, memberLine);
+		if (lineLength > maxLength) {
+			let fix;
+			if (member.type === "TSPropertySignature" && member.typeAnnotation && member.typeAnnotation.typeAnnotation.type === "TSTypeLiteral") {
+				const typeLiteral = member.typeAnnotation.typeAnnotation;
+				fix = (fixer) => {
+					const formatted = formatTypeLiteral(sourceCode, typeLiteral, getLineIndent(sourceCode, memberLine));
+					return fixer.replaceText(typeLiteral, formatted);
+				};
+			}
+			context.report({
+				data: { maxLength },
+				fix,
+				loc: {
+					end: {
+						column: lineLength,
+						line: memberLine
+					},
+					start: {
+						column: 0,
+						line: memberLine
+					}
+				},
+				messageId: "exceedsMaxLength"
+			});
+		}
+	}
+}
+//#endregion
+//#region src/rules/interfacePropertyLineBreak/checkSingleLineMembers.ts
+function checkSingleLineMembers(sourceCode, context, members, parens, maxLength) {
+	const { closingBrace, openingBrace } = parens;
+	const lineLength = getLineLength(sourceCode, openingBrace.loc.start.line);
+	if (lineLength <= maxLength) return;
+	if (members.length === 1) {
+		context.report({
+			data: { maxLength },
+			loc: {
+				end: {
+					column: lineLength,
+					line: closingBrace.loc.end.line
+				},
+				start: {
+					column: 0,
+					line: openingBrace.loc.start.line
+				}
+			},
+			messageId: "exceedsMaxLength"
+		});
+		return;
+	}
+	context.report({
+		data: { maxLength },
+		fix: (fixer) => {
+			const indent = sourceCode.getText().match(/^[\t ]*/)?.[0] ?? "";
+			const fixed = [
+				"{\n",
+				`${indent}  ${members.map((member, index) => {
+					const memberText = sourceCode.getText(member).replace(/,\s*$/, "");
+					if (!(index === members.length - 1)) return memberText + ",";
+					return memberText;
+				}).join(`\n${indent}  `)}\n`,
+				`${indent}}`
+			].join("");
+			return fixer.replaceTextRange([openingBrace.range[0], closingBrace.range[1]], fixed);
+		},
+		loc: {
+			end: {
+				column: lineLength,
+				line: closingBrace.loc.end.line
+			},
+			start: {
+				column: 0,
+				line: openingBrace.loc.start.line
+			}
+		},
+		messageId: "multipleOnSameLine"
+	});
+}
+//#endregion
+//#region src/rules/interfacePropertyLineBreak/defaultOptions.ts
+var defaultOptions$3 = { maxLength: 80 };
+//#endregion
+//#region src/rules/interfacePropertyLineBreak/getBraces.ts
+function getBraces$1(sourceCode, body) {
+	const openingBrace = sourceCode.getTokenBefore(body.body[0]);
+	const closingBrace = sourceCode.getTokenAfter(body.body[body.body.length - 1]);
+	if (!openingBrace || !closingBrace) return null;
+	return {
+		closingBrace,
+		openingBrace
+	};
+}
+//#endregion
+//#region src/rules/interfacePropertyLineBreak/checkInterface.ts
+function checkInterface(sourceCode, context, node) {
+	const maxLength = (context.options[0] ?? {}).maxLength ?? defaultOptions$3.maxLength;
+	const body = node.body;
+	if (!body || body.body.length === 0) return;
+	const braces = getBraces$1(sourceCode, body);
+	if (!braces) return;
+	if (braces.openingBrace.loc.start.line === braces.closingBrace.loc.end.line) checkSingleLineMembers(sourceCode, context, body.body, braces, maxLength);
+	else checkMultilineMembers(sourceCode, context, body.body, maxLength);
+}
+//#endregion
+//#region src/rules/interfacePropertyLineBreak/index.ts
+var interfacePropertyLineBreak = {
+	create(context) {
+		const sourceCode = context.sourceCode ?? context.getSourceCode();
+		return { TSInterfaceDeclaration(node) {
+			checkInterface(sourceCode, context, node);
+		} };
+	},
+	meta: {
+		docs: { description: "Enforce each interface member to be on its own line when line exceeds max length." },
+		fixable: "code",
+		messages: {
+			exceedsMaxLength: "Interface line exceeds {{maxLength}} characters",
+			multipleOnSameLine: "Interface members should each be on their own line when line exceeds {{maxLength}} characters"
+		},
+		schema: [{
+			additionalProperties: false,
+			properties: { maxLength: { type: "number" } },
+			type: "object"
+		}],
+		type: "layout"
+	}
+};
+//#endregion
+//#region src/rules/maxDeclarationsPerFile/collectVariableDeclarators.ts
+function collectVariableDeclarators(node, types) {
+	for (const declarator of node.declarations) if (declarator.id.type === "Identifier" && declarator.id.name) types.add(declarator.id.name);
+}
+//#endregion
+//#region src/rules/maxDeclarationsPerFile/isTopLevel.ts
+function isTopLevel(node) {
+	if (node.parent?.type === "Program") return true;
+	if (node.parent?.type === "ExportNamedDeclaration" && node.parent.parent?.type === "Program") return true;
+	return false;
+}
+//#endregion
+//#region src/rules/maxDeclarationsPerFile/handleClassDeclaration.ts
+function handleClassDeclaration(node, functions) {
+	if (isTopLevel(node) && node.id?.name) functions.add(node.id.name);
+}
+//#endregion
+//#region src/rules/maxDeclarationsPerFile/handleFunctionDeclaration.ts
+function handleFunctionDeclaration(node, functions) {
+	if (isTopLevel(node) && node.id?.name) functions.add(node.id.name);
+}
+//#endregion
+//#region src/rules/maxDeclarationsPerFile/handleTSDeclareFunction.ts
+function handleTSDeclareFunction(node, functions) {
+	if (isTopLevel(node) && node.id?.name) functions.add(node.id.name);
+}
+//#endregion
+//#region src/rules/maxDeclarationsPerFile/handleTSEnumDeclaration.ts
+function handleTSEnumDeclaration(node, types) {
+	if (isTopLevel(node) && node.id?.name) types.add(node.id.name);
+}
+//#endregion
+//#region src/rules/maxDeclarationsPerFile/handleTSInterfaceDeclaration.ts
+function handleTSInterfaceDeclaration(node, types) {
+	if (isTopLevel(node) && node.id?.name) types.add(node.id.name);
+}
+//#endregion
+//#region src/rules/maxDeclarationsPerFile/handleTSTypeAliasDeclaration.ts
+function handleTSTypeAliasDeclaration(node, types) {
+	if (isTopLevel(node) && node.id?.name) types.add(node.id.name);
+}
+//#endregion
+//#region src/rules/maxDeclarationsPerFile/isExempt.ts
+function isExempt$1(filename) {
+	const name = path.basename(filename, path.extname(filename));
+	const isTest = name.endsWith(".test");
+	const isSpec = name.endsWith(".spec");
+	const isConfig = name.endsWith(".config");
+	return isTest || isSpec || isConfig;
+}
+//#endregion
+//#region src/rules/maxDeclarationsPerFile/isExportedDeclaration.ts
+function isExportedDeclaration(parent) {
+	return parent?.type === "ExportNamedDeclaration";
+}
+//#endregion
+//#region src/rules/maxDeclarationsPerFile/index.ts
+var maxDeclarationsPerFile = {
+	create(context) {
+		const filename = context.filename;
+		if (isExempt$1(filename)) return {};
+		const functions = /* @__PURE__ */ new Set();
+		const types = /* @__PURE__ */ new Set();
+		return {
+			ClassDeclaration(node) {
+				handleClassDeclaration(node, functions);
+			},
+			FunctionDeclaration(node) {
+				handleFunctionDeclaration(node, functions);
+			},
+			"Program:exit"(_programNode) {
+				const totalDeclarations = functions.size + types.size;
+				if (totalDeclarations > 1) context.report({
+					data: {
+						count: totalDeclarations,
+						functions: functions.size,
+						types: types.size
+					},
+					messageId: "tooManyDeclarations",
+					node: _programNode
+				});
+			},
+			TSDeclareFunction(node) {
+				handleTSDeclareFunction(node, functions);
+			},
+			TSEnumDeclaration(node) {
+				handleTSEnumDeclaration(node, types);
+			},
+			TSInterfaceDeclaration(node) {
+				handleTSInterfaceDeclaration(node, types);
+			},
+			TSTypeAliasDeclaration(node) {
+				handleTSTypeAliasDeclaration(node, types);
+			},
+			VariableDeclaration(node) {
+				if (!isTopLevel(node)) return;
+				const parent = node.parent;
+				if (!isExportedDeclaration(parent) && !node.declare) return;
+				collectVariableDeclarators(node, types);
+			},
+			"VariableDeclaration > VariableDeclarator > ArrowFunctionExpression"(_node) {
+				if (!isTopLevel(_node.parent?.parent)) return;
+				const declarator = _node.parent;
+				if (declarator.id.type === "Identifier" && declarator.id.name) functions.add(declarator.id.name);
+			}
+		};
+	},
+	meta: {
+		docs: { description: "Enforce single top-level declaration per file." },
+		messages: { tooManyDeclarations: "File has {{count}} declarations. Put each function/class/const/type declaration in its own file." },
+		schema: [],
+		type: "suggestion"
+	}
+};
+//#endregion
+//#region src/rules/multilineUnionTypeAliases/createFix.ts
+function createFix(fixer, node, sourceCode) {
+	const result = `\n${node.types.map((t) => sourceCode.getText(t)).map((t) => `  | ${t}`).join("\n")}`;
+	return fixer.replaceText(node, result);
+}
+//#endregion
+//#region src/rules/multilineUnionTypeAliases/isMultiline.ts
+function isMultiline(unionType) {
+	const { end, start } = unionType.loc ?? {};
+	return start?.line !== end?.line;
+}
+//#endregion
+//#region src/rules/multilineUnionTypeAliases/index.ts
+var multilineUnionTypeAliases = {
+	create(context) {
+		return { TSUnionType(node) {
+			if (node.types.length < 2) return;
+			const parent = node.parent;
+			if (!parent || parent.type !== "TSTypeAliasDeclaration") return;
+			const sourceCode = context.sourceCode;
+			if (sourceCode.getText(node).trim().startsWith("|")) return;
+			if (!isMultiline(node)) {
+				context.report({
+					fix: (fixer) => createFix(fixer, node, sourceCode),
+					messageId: "singleLine",
+					node
+				});
+				return;
+			}
+			context.report({
+				fix: (fixer) => createFix(fixer, node, sourceCode),
+				messageId: "missingPipes",
+				node
+			});
+		} };
+	},
+	meta: {
+		docs: { description: "Enforce union type aliases with multiple members to be on multiple lines." },
+		fixable: "code",
+		messages: {
+			missingPipes: "Multiline union type aliases should have leading pipes on each member",
+			singleLine: "Union type aliases with multiple members should be on multiple lines"
+		},
+		schema: [],
+		type: "layout"
+	}
+};
+//#endregion
+//#region src/rules/namingConvention/isExempt.ts
+function isExempt(name) {
+	return name.startsWith("_");
+}
+//#endregion
+//#region src/rules/namingConvention/isPascalCase.ts
+function isPascalCase(name) {
+	if (!/^[A-Z]/.test(name)) return false;
+	return /^[A-Z][\dA-Za-z]*$/.test(name);
+}
+//#endregion
+//#region src/rules/namingConvention/isSeparator.ts
+function isSeparator(char) {
+	return char === "_" || char === "-" || char === " ";
+}
+//#endregion
+//#region src/rules/namingConvention/isWordBoundary.ts
+function isWordBoundary(char, currentWord, prevChar, nextChar) {
+	if (!currentWord) return false;
+	const isUpper = /[A-Z]/.test(char);
+	const prevIsUpper = /[A-Z]/.test(prevChar);
+	const nextIsLower = /[a-z]/.test(nextChar);
+	if (isUpper) return !prevIsUpper || prevIsUpper && nextIsLower;
+	return false;
+}
+//#endregion
+//#region src/rules/namingConvention/capitalize.ts
+function capitalize(word) {
+	return word.charAt(0).toUpperCase() + word.slice(1);
+}
+//#endregion
+//#region src/rules/namingConvention/wordsToCamelCase.ts
+function wordsToCamelCase(words) {
+	if (words.length === 0) return "";
+	if (words.length === 1) return words[0].toLowerCase();
+	return words[0].toLowerCase() + words.slice(1).map(capitalize).join("");
+}
+//#endregion
+//#region src/rules/namingConvention/toCamelCase.ts
+function toCamelCase(name) {
+	const words = [];
+	let currentWord = "";
+	for (let i = 0; i < name.length; i++) {
+		const char = name[i];
+		const prevChar = i > 0 ? name[i - 1] : "";
+		const nextChar = i < name.length - 1 ? name[i + 1] : "";
+		if (isSeparator(char)) {
+			if (currentWord) {
+				words.push(currentWord.toLowerCase());
+				currentWord = "";
+			}
+			continue;
+		}
+		if (isWordBoundary(char, currentWord, prevChar, nextChar)) {
+			words.push(currentWord.toLowerCase());
+			currentWord = char;
+			continue;
+		}
+		currentWord += char;
+	}
+	if (currentWord) words.push(currentWord.toLowerCase());
+	return wordsToCamelCase(words);
+}
+//#endregion
+//#region src/rules/namingConvention/toPascalCase.ts
+function toPascalCase$1(name) {
+	const camelCase = toCamelCase(name);
+	return camelCase.charAt(0).toUpperCase() + camelCase.slice(1);
+}
+//#endregion
+//#region src/rules/namingConvention/checkClass.ts
+function checkClass(id, context) {
+	if (!id) return;
+	const name = id.name;
+	if (isExempt(name)) return;
+	if (!isPascalCase(name)) context.report({
+		data: {
+			name,
+			type: "Class"
+		},
+		fix(fixer) {
+			return fixer.replaceText(id, toPascalCase$1(name));
+		},
+		messageId: "notPascalCase",
+		node: id
+	});
+}
+//#endregion
+//#region src/rules/namingConvention/checkNamedEntity.ts
+function checkNamedEntity(name, node, type, context) {
+	if (isExempt(name)) return;
+	if (!isPascalCase(name)) context.report({
+		data: {
+			name,
+			type
+		},
+		fix(fixer) {
+			return fixer.replaceText(node, toPascalCase$1(name));
+		},
+		messageId: "notPascalCase",
+		node
+	});
+}
+//#endregion
+//#region src/rules/namingConvention/isCamelCase.ts
+function isCamelCase(name) {
+	if (!/^[a-z]/.test(name)) return false;
+	return /^[a-z][\dA-Za-z]*$/.test(name);
+}
+//#endregion
+//#region src/rules/namingConvention/isUpperCase.ts
+function isUpperCase(name) {
+	return /^[A-Z][\dA-Z_]*$/.test(name);
+}
+//#endregion
+//#region src/rules/namingConvention/checkConstant.ts
+function checkConstant(name, node, context) {
+	if (!isCamelCase(name) && !isUpperCase(name)) context.report({
+		data: { name },
+		messageId: "notUpperCase",
+		node
+	});
+}
+//#endregion
+//#region src/rules/namingConvention/checkVariable.ts
+function checkVariable(name, node, context) {
+	if (!isCamelCase(name)) context.report({
+		data: { name },
+		fix(fixer) {
+			return fixer.replaceText(node, toCamelCase(name));
+		},
+		messageId: "notCamelCase",
+		node
+	});
+}
+//#endregion
+//#region src/rules/namingConvention/isFunction.ts
+function isFunction(init) {
+	if (!init) return false;
+	return init.type === "FunctionExpression" || init.type === "ArrowFunctionExpression";
+}
+//#endregion
+//#region src/rules/namingConvention/checkVariableDeclarator.ts
+function checkVariableDeclarator(node, context) {
+	const id = node.id;
+	const name = id.name;
+	if (isExempt(name)) return;
+	if (isFunction(node.init)) return;
+	const parent = node.parent;
+	if (parent?.type !== "VariableDeclaration") return;
+	if (parent.kind === "const") checkConstant(name, id, context);
+	else checkVariable(name, id, context);
+}
+//#endregion
+//#region src/rules/namingConvention/getFunctionName.ts
+function getFunctionName(node, parent) {
+	if (node.type === "FunctionDeclaration" && node.id) return node.id.name;
+	if ((node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") && parent?.type === "VariableDeclarator" && parent.id.type === "Identifier") return parent.id.name;
+	return null;
+}
+//#endregion
+//#region src/rules/namingConvention/getReturnTypeText.ts
+function getReturnTypeText(sourceCode, node) {
+	if (!node.returnType) return void 0;
+	return sourceCode.getText(node.returnType.typeAnnotation);
+}
+//#endregion
+//#region src/rules/namingConvention/isReactComponent.ts
+function isReactComponent(returnTypeText) {
+	if (!returnTypeText) return false;
+	return [
+		"JSX.Element",
+		"React.JSX.Element",
+		"ReactElement",
+		"ReactNode"
+	].some((pattern) => returnTypeText.includes(pattern));
+}
+//#endregion
+//#region src/rules/namingConvention/messageIds.ts
+var messageIds$4 = {
+	notCamelCase: "Function \"{{name}}\" should use camelCase",
+	notPascalCase: "{{type}} \"{{name}}\" should use PascalCase",
+	notUpperCase: "Constant \"{{name}}\" should use UPPER_CASE"
+};
+//#endregion
+//#region src/rules/namingConvention/getFunctionIdentifierNodeForFixer.ts
+function getFunctionIdentifierNodeForFixer(node, parent) {
+	if (node.type === "FunctionDeclaration") return node.id;
+	if (parent?.type === "VariableDeclarator") return parent.id;
+	return null;
+}
+//#endregion
+//#region src/rules/namingConvention/getFunctionNameForFixer.ts
+function getFunctionNameForFixer(node, parent) {
+	if (node.type === "FunctionDeclaration" && node.id) return node.id.name;
+	if (parent?.type === "VariableDeclarator" && parent.id.type === "Identifier") return parent.id.name;
+	return "";
+}
+//#endregion
+//#region src/rules/namingConvention/createFunctionFixer.ts
+function createFunctionFixer(node, parent, convert) {
+	return (fixer) => {
+		const fixedName = convert(getFunctionNameForFixer(node, parent));
+		const identifierNode = getFunctionIdentifierNodeForFixer(node, parent);
+		if (identifierNode) return fixer.replaceText(identifierNode, fixedName);
+		return null;
+	};
+}
+//#endregion
+//#region src/rules/namingConvention/getFunctionReportNode.ts
+function getFunctionReportNode(node, parent) {
+	if (node.type === "FunctionDeclaration") return node;
+	return parent ?? node;
+}
+//#endregion
+//#region src/rules/namingConvention/reportComponentViolation.ts
+function reportComponentViolation(node, parent, name, context) {
+	if (isPascalCase(name)) return;
+	context.report({
+		data: {
+			name,
+			type: "React component"
+		},
+		fix: createFunctionFixer(node, parent, toPascalCase$1),
+		messageId: "notPascalCase",
+		node: getFunctionReportNode(node, parent)
+	});
+}
+//#endregion
+//#region src/rules/namingConvention/reportFunctionViolation.ts
+function reportFunctionViolation(node, parent, name, context) {
+	if (isCamelCase(name)) return;
+	context.report({
+		data: { name },
+		fix: createFunctionFixer(node, parent, toCamelCase),
+		messageId: "notCamelCase",
+		node: getFunctionReportNode(node, parent)
+	});
+}
+//#endregion
+//#region src/rules/namingConvention/index.ts
+var namingConvention = {
+	create(context) {
+		const sourceCode = context.sourceCode ?? context.getSourceCode();
+		return {
+			ArrowFunctionExpression(node) {
+				checkFunction(node, node.parent);
+			},
+			ClassDeclaration(node) {
+				checkClass(node.id, context);
+			},
+			ClassExpression(node) {
+				checkClass(node.id, context);
+			},
+			FunctionDeclaration(node) {
+				checkFunction(node);
+			},
+			FunctionExpression(node) {
+				checkFunction(node, node.parent);
+			},
+			TSEnumDeclaration(node) {
+				checkNamedEntity(node.id.name, node.id, "Enum", context);
+			},
+			TSInterfaceDeclaration(node) {
+				checkNamedEntity(node.id.name, node.id, "Interface", context);
+			},
+			TSTypeAliasDeclaration(node) {
+				if (node.id.type !== "Identifier") return;
+				checkNamedEntity(node.id.name, node.id, "Type", context);
+			},
+			VariableDeclarator(node) {
+				if (node.id.type !== "Identifier") return;
+				checkVariableDeclarator(node, context);
+			}
+		};
+		function checkFunction(node, parent) {
+			const name = getFunctionName(node, parent);
+			if (!name || isExempt(name)) return;
+			if (isReactComponent(getReturnTypeText(sourceCode, node))) reportComponentViolation(node, parent, name, context);
+			else reportFunctionViolation(node, parent, name, context);
+		}
+	},
+	meta: {
+		docs: { description: "Enforce consistent naming conventions." },
+		fixable: "code",
+		messages: messageIds$4,
+		schema: [],
+		type: "suggestion"
+	}
+};
+//#endregion
+//#region src/rules/noInlineObjectTypes/checkTypeParameters.ts
+function checkTypeParameters(node, containsInline) {
+	if (!("typeParameters" in node) || !node.typeParameters) return null;
+	for (const param of node.typeParameters.params) {
+		const result = containsInline(param);
+		if (result) return result;
+	}
+	return null;
+}
+//#endregion
+//#region src/rules/noInlineObjectTypes/checkUnionOrIntersectionTypes.ts
+function checkUnionOrIntersectionTypes(node, containsInline) {
+	for (const type of node.types) {
+		const result = containsInline(type);
+		if (result) return result;
+	}
+	return null;
+}
+//#endregion
+//#region src/rules/noInlineObjectTypes/isInlineObjectType.ts
+function isInlineObjectType(node) {
+	return node.type === "TSTypeLiteral";
+}
+//#endregion
+//#region src/rules/noInlineObjectTypes/containsInlineObjectType.ts
+function containsInlineObjectType(node) {
+	if (isInlineObjectType(node)) return node;
+	if (node.type === "TSIntersectionType" || node.type === "TSUnionType") {
+		const result = checkUnionOrIntersectionTypes(node, containsInlineObjectType);
+		if (result) return result;
+	}
+	if (node.type === "TSArrayType") return containsInlineObjectType(node.elementType);
+	const typeParamResult = checkTypeParameters(node, containsInlineObjectType);
+	if (typeParamResult) return typeParamResult;
+	if (node.type === "TSTypeAnnotation") return containsInlineObjectType(node.typeAnnotation);
+	return null;
+}
+//#endregion
+//#region src/rules/noInlineObjectTypes/toPascalCase.ts
+function toPascalCase(str) {
+	return str.charAt(0).toUpperCase() + str.slice(1);
+}
+//#endregion
+//#region src/rules/noInlineObjectTypes/getInlineTypeName.ts
+function getInlineTypeName(usedNames, _existingInterfaces, parameterName) {
+	const baseName = parameterName ? toPascalCase(parameterName) : "InlineType";
+	if (!usedNames.has(baseName)) {
+		usedNames.add(baseName);
+		return baseName;
+	}
+	let counter = 2;
+	while (usedNames.has(`${baseName}${counter}`)) counter++;
+	const name = `${baseName}${counter}`;
+	usedNames.add(name);
+	return name;
+}
+//#endregion
+//#region src/rules/noInlineObjectTypes/getParameterNameFromFunction.ts
+function getParameterNameFromFunction(parent) {
+	if (parent.type === "ArrowFunctionExpression" || parent.type === "FunctionDeclaration" || parent.type === "FunctionExpression") return parent.id?.name;
+}
+//#endregion
+//#region src/rules/noInlineObjectTypes/getParameterNameFromIdentifier.ts
+function getParameterNameFromIdentifier(parent) {
+	const grandParent = parent.parent;
+	if (grandParent?.type === "ArrowFunctionExpression" || grandParent?.type === "FunctionDeclaration" || grandParent?.type === "FunctionExpression") return parent.name;
+}
+//#endregion
+//#region src/rules/noInlineObjectTypes/getParameterNameFromObjectPattern.ts
+function getParameterNameFromObjectPattern(parent) {
+	const grandParent = parent.parent;
+	if (grandParent?.type === "ArrowFunctionExpression" || grandParent?.type === "FunctionDeclaration" || grandParent?.type === "FunctionExpression") return "Options";
+}
+//#endregion
+//#region src/rules/noInlineObjectTypes/getTopLevelDeclaration.ts
+function getTopLevelDeclaration(node) {
+	let current = node;
+	const topLevelTypes = new Set([
+		"ArrowFunctionExpression",
+		"FunctionDeclaration",
+		"FunctionExpression",
+		"TSInterfaceDeclaration",
+		"TSTypeAliasDeclaration",
+		"VariableDeclaration"
+	]);
+	while (current) {
+		if (topLevelTypes.has(current.type)) {
+			const parent = current.parent;
+			if (parent?.type === "ExportNamedDeclaration" && parent) return {
+				insertLocation: parent,
+				isExported: true,
+				node: current
+			};
+			return {
+				insertLocation: current,
+				isExported: false,
+				node: current
+			};
+		}
+		current = current.parent;
+	}
+}
+//#endregion
+//#region src/rules/noInlineObjectTypes/handleInlineType.ts
+function handleInlineType(node, typeLiteral, inlineTypes) {
+	const result = getTopLevelDeclaration(node);
+	if (!result) return;
+	let parameterName;
+	const parent = node.parent;
+	if (parent?.type === "Identifier") parameterName = getParameterNameFromIdentifier(parent);
+	else if (parent?.type === "ObjectPattern") parameterName = getParameterNameFromObjectPattern(parent);
+	else parameterName = getParameterNameFromFunction(parent);
+	inlineTypes.push({
+		annotationNode: node,
+		insertLocation: result.insertLocation,
+		isExported: result.isExported,
+		location: result.node,
+		parameterName,
+		typeLiteral
+	});
+}
+//#endregion
+//#region src/rules/noInlineObjectTypes/isIdentifierInFunction.ts
+function isIdentifierInFunction(parent) {
+	return parent?.type === "Identifier" && (parent.parent?.type === "FunctionDeclaration" || parent.parent?.type === "FunctionExpression" || parent.parent?.type === "ArrowFunctionExpression");
+}
+//#endregion
+//#region src/rules/noInlineObjectTypes/isPropertySignatureInTypeLiteral.ts
+function isPropertySignatureInTypeLiteral(parent) {
+	return parent?.type === "TSPropertySignature" && (parent.parent?.type === "TSTypeLiteral" || parent.parent?.type === "TSInterfaceBody");
+}
+//#endregion
+//#region src/rules/noInlineObjectTypes/traverseUpForTypeLiteral.ts
+function traverseUpForTypeLiteral(current) {
+	const skipTypes = new Set([
+		"TSArrayType",
+		"TSIntersectionType",
+		"TSPropertySignature",
+		"TSTypeReference",
+		"TSUnionType"
+	]);
+	while (current) {
+		if (current.type === "TSTypeLiteral") return true;
+		if (skipTypes.has(current.type)) {
+			current = current.parent;
+			continue;
+		}
+		break;
+	}
+	return false;
+}
+//#endregion
+//#region src/rules/noInlineObjectTypes/isNestedTypeAnnotation.ts
+function isNestedTypeAnnotation(node) {
+	const parent = node.parent;
+	if (isPropertySignatureInTypeLiteral(parent)) return true;
+	if (isIdentifierInFunction(parent)) return false;
+	if (parent?.type === "ArrowFunctionExpression" || parent?.type === "FunctionDeclaration" || parent?.type === "FunctionExpression") return false;
+	return traverseUpForTypeLiteral(parent);
+}
+//#endregion
+//#region src/rules/noInlineObjectTypes/prepareFix.ts
+function prepareFix(sourceCode, inlineTypes) {
+	const interfaceBlock = inlineTypes.map(({ name, typeLiteral }) => {
+		return `interface ${name} ${sourceCode.getText(typeLiteral)}`;
+	}).join("\n");
+	const replacements = inlineTypes.map(({ name, typeLiteral }) => ({
+		name,
+		typeLiteral
+	}));
+	return {
+		firstUsageLocation: inlineTypes[0].typeLiteral,
+		interfaceBlock,
+		replacements
+	};
+}
+//#endregion
+//#region src/rules/noInlineObjectTypes/index.ts
+var noInlineObjectTypes = {
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const inlineTypes = [];
+		return {
+			TSTypeAnnotation(node) {
+				if (isNestedTypeAnnotation(node)) return;
+				const typeLiteral = containsInlineObjectType(node);
+				if (!typeLiteral) return;
+				handleInlineType(node, typeLiteral, inlineTypes);
+			},
+			"Program:exit"() {
+				if (inlineTypes.length === 0) return;
+				const usedNames = /* @__PURE__ */ new Set();
+				const locations = [...new Set(inlineTypes.map((t) => t.insertLocation))];
+				for (const loc of locations) {
+					const typesAtLocation = inlineTypes.filter((t) => t.insertLocation === loc);
+					const fixResult = prepareFix(sourceCode, typesAtLocation.map((entry) => {
+						return {
+							name: getInlineTypeName(usedNames, [], entry.parameterName),
+							parameterName: entry.parameterName,
+							typeLiteral: entry.typeLiteral
+						};
+					}));
+					context.report({
+						fix(fixer) {
+							const fixes = [];
+							for (const replacement of fixResult.replacements) fixes.push(fixer.replaceText(replacement.typeLiteral, replacement.name));
+							if (typesAtLocation[0].isExported && typesAtLocation[0].insertLocation.type === "ExportNamedDeclaration") fixes.push(fixer.insertTextAfter(typesAtLocation[0].insertLocation, `\n${fixResult.interfaceBlock}`));
+							else fixes.push(fixer.insertTextBefore(loc, `${fixResult.interfaceBlock}\n`));
+							return fixes;
+						},
+						messageId: "inlineObjectType",
+						node: typesAtLocation[0].annotationNode
+					});
+				}
+			}
+		};
+	},
+	meta: {
+		docs: { description: "Disallow inline object type literals in type annotations." },
+		fixable: "code",
+		messages: { inlineObjectType: "Inline object types are not allowed. Use a named interface or type instead." },
+		schema: [],
+		type: "suggestion"
+	}
+};
+//#endregion
+//#region src/rules/noUnnecessaryBraces/getReplacementText.ts
+function getReplacementText(statementText, baseIndent, hasElseAfter) {
+	const statementIndent = `${baseIndent}  `;
+	if (hasElseAfter) return `\n${statementIndent}${statementText}\n${baseIndent}`;
+	return `\n${statementIndent}${statementText}`;
+}
+//#endregion
+//#region src/rules/noUnnecessaryBraces/checkBlockStatement.ts
+function checkBlockStatement(node, context) {
+	if (node.body.length !== 1) return;
+	const statement = node.body[0];
+	const sourceCode = context.getSourceCode();
+	if (isSingleLineStatement(statement, sourceCode)) context.report({
+		fix(fixer) {
+			const statementText = sourceCode.getText(statement);
+			const tokenBefore = sourceCode.getTokenBefore(node);
+			const baseIndent = getLineIndent(sourceCode, tokenBefore?.loc?.start?.line ?? node.loc?.start?.line ?? 1);
+			const range = [tokenBefore ? tokenBefore.range[1] : node.range[0], node.range[1]];
+			const tokenAfter = sourceCode.getTokenAfter(node);
+			const replacementText = getReplacementText(statementText, baseIndent, tokenAfter && tokenAfter.value === "else");
+			return fixer.replaceTextRange(range, replacementText);
+		},
+		messageId: "unnecessaryBraces",
+		node
+	});
+}
+//#endregion
+//#region src/rules/shared/detectIndentStep.ts
+function detectIndentStep(sourceCode) {
+	const lines = sourceCode.getText().split("\n");
+	const indentCounts = /* @__PURE__ */ new Map();
+	for (const line of lines) {
+		const match = line.match(/^( *)/);
+		if (match) {
+			const spaces = match[1].length;
+			if (spaces > 0) indentCounts.set(spaces, (indentCounts.get(spaces) ?? 0) + 1);
+		}
+	}
+	const sortedIndents = Array.from(indentCounts.entries()).filter(([spaces]) => spaces > 0).sort((a, b) => a[0] - b[0]);
+	if (sortedIndents.length === 0) return 2;
+	const minIndent = sortedIndents[0][0];
+	for (const step of [2, 4]) if (sortedIndents.every(([n]) => n % step === 0)) return step;
+	return minIndent;
+}
+//#endregion
+//#region src/rules/shared/reindentText.ts
+function reindentText(text, newBaseIndent, indentStep) {
+	const lines = text.split("\n");
+	let minIndent = Infinity;
+	for (let i = 1; i < lines.length; i++) {
+		const line = lines[i];
+		if (line.trim() === "") continue;
+		const match = line.match(/^( *)/);
+		if (match) minIndent = Math.min(minIndent, match[1].length);
+	}
+	if (minIndent === Infinity) return lines.map((line) => {
+		if (line.trim() === "") return "";
+		return newBaseIndent + indentStep + line.trimStart();
+	}).join("\n");
+	return lines.map((line, index) => {
+		if (line.trim() === "") return "";
+		if (index === 0) return newBaseIndent + indentStep + line.trimStart();
+		const relativeIndent = line.slice(minIndent);
+		return newBaseIndent + indentStep + relativeIndent;
+	}).join("\n");
+}
+//#endregion
+//#region src/rules/noUnnecessaryBraces/checkNonBlockStatement.ts
+function checkNonBlockStatement(node, context) {
+	if (node.type === "BlockStatement") return;
+	const sourceCode = context.getSourceCode();
+	if (!isSingleLineStatement(node, sourceCode)) context.report({
+		fix(fixer) {
+			const statementText = sourceCode.getText(node);
+			const baseIndent = getLineIndent(sourceCode, node.parent?.loc?.start?.line ?? node.loc?.start?.line ?? 1);
+			const indentStepSize = detectIndentStep(sourceCode);
+			const fixed = `{\n${reindentText(statementText, baseIndent, " ".repeat(indentStepSize))}\n${baseIndent}}`;
+			return [fixer.replaceText(node, fixed)];
+		},
+		messageId: "missingBraces",
+		node
+	});
+}
+//#endregion
+//#region src/rules/noUnnecessaryBraces/checkDoWhileStatement.ts
+function checkDoWhileStatement(node, context) {
+	if (node.body.type === "BlockStatement") checkBlockStatement(node.body, context);
+	else checkNonBlockStatement(node.body, context);
+}
+//#endregion
+//#region src/rules/noUnnecessaryBraces/checkForInStatement.ts
+function checkForInStatement(node, context) {
+	if (node.body.type === "BlockStatement") checkBlockStatement(node.body, context);
+	else checkNonBlockStatement(node.body, context);
+}
+//#endregion
+//#region src/rules/noUnnecessaryBraces/checkForOfStatement.ts
+function checkForOfStatement(node, context) {
+	if (node.body.type === "BlockStatement") checkBlockStatement(node.body, context);
+	else checkNonBlockStatement(node.body, context);
+}
+//#endregion
+//#region src/rules/noUnnecessaryBraces/checkForStatement.ts
+function checkForStatement(node, context) {
+	if (node.body.type === "BlockStatement") checkBlockStatement(node.body, context);
+	else checkNonBlockStatement(node.body, context);
+}
+//#endregion
+//#region src/rules/noUnnecessaryBraces/checkIfStatement.ts
+function checkIfStatement(node, context) {
+	if (node.consequent.type === "BlockStatement") checkBlockStatement(node.consequent, context);
+	else checkNonBlockStatement(node.consequent, context);
+	if (!node.alternate) return;
+	if (node.alternate.type === "IfStatement") return;
+	if (node.alternate.type === "BlockStatement") checkBlockStatement(node.alternate, context);
+	else checkNonBlockStatement(node.alternate, context);
+}
+//#endregion
+//#region src/rules/noUnnecessaryBraces/checkWhileStatement.ts
+function checkWhileStatement(node, context) {
+	if (node.body.type === "BlockStatement") checkBlockStatement(node.body, context);
+	else checkNonBlockStatement(node.body, context);
+}
+//#endregion
+//#region src/rules/noUnnecessaryBraces/index.ts
+var noUnnecessaryBraces = {
+	create(context) {
+		return {
+			DoWhileStatement: (node) => checkDoWhileStatement(node, context),
+			ForInStatement: (node) => checkForInStatement(node, context),
+			ForOfStatement: (node) => checkForOfStatement(node, context),
+			ForStatement: (node) => checkForStatement(node, context),
+			IfStatement: (node) => checkIfStatement(node, context),
+			WhileStatement: (node) => checkWhileStatement(node, context)
+		};
+	},
+	meta: {
+		docs: { description: "Enforce consistent brace usage for single-statement control bodies." },
+		fixable: "code",
+		messages: {
+			missingBraces: "Multi-line statement must be wrapped in braces",
+			unnecessaryBraces: "Unnecessary braces around single-line statement"
+		},
+		schema: [],
+		type: "suggestion"
+	}
+};
+//#endregion
+//#region src/rules/objectPropertyLineBreak/isShorthandProperty.ts
+function isShorthandProperty(property) {
+	return property.shorthand;
+}
+//#endregion
+//#region src/rules/objectPropertyLineBreak/areAllShorthand.ts
+function areAllShorthand(properties) {
+	return properties.every(isShorthandProperty);
+}
+//#endregion
+//#region src/rules/objectPropertyLineBreak/getPropertyText.ts
+function getPropertyText(sourceCode, property) {
+	return sourceCode.getText(property);
+}
+//#endregion
+//#region src/rules/objectPropertyLineBreak/getInlineObjectLength.ts
+function getInlineObjectLength(sourceCode, properties) {
+	if (properties.length === 0) return 2;
+	const propsTotal = properties.map((p) => getPropertyText(sourceCode, p).length).reduce((a, b) => a + b, 0);
+	const commas = Math.max(0, properties.length - 1);
+	return 2 + propsTotal + commas;
+}
+//#endregion
+//#region src/rules/objectPropertyLineBreak/checkMultiline.ts
+function checkMultiline(sourceCode, context, node, braces, maxLength) {
+	const properties = node.properties;
+	if (!areAllShorthand(properties)) return;
+	if (getInlineObjectLength(sourceCode, properties) > maxLength) return;
+	context.report({
+		fix(fixer) {
+			const names = [];
+			for (const prop of properties) if (prop.key.type === "Identifier") names.push(prop.key.name);
+			else names.push(sourceCode.getText(prop));
+			return fixer.replaceText(node, `{${names.join(", ")}}`);
+		},
+		messageId: "multilineCanBeSingleLine",
+		node: properties[0]
+	});
+}
+//#endregion
+//#region src/rules/objectPropertyLineBreak/buildMultilineFix.ts
+function buildMultilineFix(fixer, braces, properties, sourceCode) {
+	const indentStep = detectIndentStep(sourceCode);
+	const lineIndent = sourceCode.getLines()[braces.openingBrace.loc.start.line - 1].match(/^\s*/)?.[0] ?? "";
+	const indent = lineIndent + " ".repeat(indentStep);
+	const lines = ["{"];
+	for (const prop of properties) {
+		const propText = sourceCode.getText(prop);
+		lines.push(`${indent}${propText},`);
+	}
+	lines.push(`${lineIndent}}`);
+	return fixer.replaceTextRange([braces.openingBrace.range[0], braces.closingBrace.range[1]], lines.join("\n"));
+}
+//#endregion
+//#region src/rules/objectPropertyLineBreak/getPropertyName.ts
+function getPropertyName(sourceCode, prop) {
+	if (prop.key.type === "Identifier") return prop.key.name;
+	return sourceCode.getText(prop);
+}
+//#endregion
+//#region src/rules/objectPropertyLineBreak/buildShorthandFix.ts
+function buildShorthandFix(fixer, braces, properties, sourceCode) {
+	const names = properties.map((p) => getPropertyName(sourceCode, p));
+	return fixer.replaceTextRange([braces.openingBrace.range[0], braces.closingBrace.range[1]], `{${names.join(", ")}}`);
+}
+//#endregion
+//#region src/rules/objectPropertyLineBreak/canConvertToShorthand.ts
+function canConvertToShorthand(property) {
+	if (property.shorthand) return true;
+	if (property.kind !== "init") return false;
+	if (property.key.type !== "Identifier") return false;
+	if (property.value.type !== "Identifier") return false;
+	return property.key.name === property.value.name;
+}
+//#endregion
+//#region src/rules/objectPropertyLineBreak/shouldCollapseToShorthand.ts
+function shouldCollapseToShorthand(properties, sourceCode, maxLength) {
+	const anyShorthand = properties.some((p) => p.shorthand);
+	const allCanConvert = properties.every(canConvertToShorthand);
+	const shorthandLength = allCanConvert ? getInlineObjectLength(sourceCode, properties) : Infinity;
+	return !anyShorthand && allCanConvert && shorthandLength <= maxLength;
+}
+//#endregion
+//#region src/rules/objectPropertyLineBreak/checkSingleLine.ts
+function checkSingleLine(sourceCode, context, properties, braces, maxLength) {
+	if (properties.length === 1) return;
+	const allShorthand = areAllShorthand(properties);
+	const inlineLength = getInlineObjectLength(sourceCode, properties);
+	if (allShorthand && inlineLength <= maxLength) return;
+	if (!allShorthand) {
+		if (shouldCollapseToShorthand(properties, sourceCode, maxLength)) {
+			context.report({
+				fix: (fixer) => buildShorthandFix(fixer, braces, properties, sourceCode),
+				messageId: "mixedPropertiesNotAllowed",
+				node: properties[0]
+			});
+			return;
+		}
+		context.report({
+			fix: (fixer) => buildMultilineFix(fixer, braces, properties, sourceCode),
+			messageId: "mixedPropertiesNotAllowed",
+			node: properties[0]
+		});
+		return;
+	}
+	context.report({
+		fix: (fixer) => buildMultilineFix(fixer, braces, properties, sourceCode),
+		messageId: "singleLineExceedsMaxLength",
+		node: properties[0]
+	});
+}
+//#endregion
+//#region src/rules/objectPropertyLineBreak/defaultOptions.ts
+var defaultOptions$2 = { maxLength: 80 };
+//#endregion
+//#region src/rules/objectPropertyLineBreak/getBraces.ts
+function getBraces(sourceCode, node) {
+	const properties = node.properties;
+	if (properties.length === 0) return null;
+	const firstProp = properties[0];
+	const lastProp = properties[properties.length - 1];
+	const openingBrace = sourceCode.getTokenBefore(firstProp);
+	const closingBrace = sourceCode.getTokenAfter(lastProp);
+	if (!openingBrace || !closingBrace) return null;
+	return {
+		closingBrace,
+		openingBrace
+	};
+}
+//#endregion
+//#region src/rules/objectPropertyLineBreak/checkObject.ts
+function checkObject(sourceCode, context, node) {
+	const maxLength = (context.options[0] ?? {}).maxLength ?? defaultOptions$2.maxLength;
+	const properties = node.properties;
+	if (properties.length === 0) return;
+	const braces = getBraces(sourceCode, node);
+	if (!braces) return;
+	if (braces.openingBrace.loc.start.line === braces.closingBrace.loc.end.line) checkSingleLine(sourceCode, context, properties, braces, maxLength);
+	else checkMultiline(sourceCode, context, node, braces, maxLength);
+}
+//#endregion
+//#region src/rules/objectPropertyLineBreak/index.ts
+var objectPropertyLineBreak = {
+	create(context) {
+		const sourceCode = context.sourceCode ?? context.getSourceCode();
+		return { ObjectExpression(node) {
+			checkObject(sourceCode, context, node);
+		} };
+	},
+	meta: {
+		docs: { description: "Enforce object literal formatting based on complexity and line length." },
+		fixable: "code",
+		messages: {
+			mixedPropertiesNotAllowed: "mixedPropertiesNotAllowed",
+			multilineCanBeSingleLine: "multilineCanBeSingleLine",
+			singleLineExceedsMaxLength: "singleLineExceedsMaxLength"
+		},
+		schema: [{
+			additionalProperties: false,
+			properties: { maxLength: { type: "number" } },
+			type: "object"
+		}],
+		type: "layout"
+	}
+};
+//#endregion
+//#region src/rules/oneExportPerFile/index.ts
+var oneExportPerFile = {
+	create(context) {
+		const filename = context.filename;
+		if (isExempt$2(filename)) return {};
+		let exportCount = 0;
+		return {
+			ExportDefaultDeclaration(_node) {
+				exportCount++;
+			},
+			ExportNamedDeclaration(_node) {
+				exportCount++;
+			},
+			"Program:exit"(programNode) {
+				if (exportCount > 1) context.report({
+					data: { count: exportCount },
+					messageId: "tooManyExports",
+					node: programNode
+				});
+			}
+		};
+	},
+	meta: {
+		docs: { description: "Enforce single export per file." },
+		messages: { tooManyExports: "Only one export is allowed per file. Found {{count}} exports." },
+		schema: [],
+		type: "suggestion"
+	}
+};
+//#endregion
+//#region src/rules/preferInlineExport/isValidExportSpecifier.ts
+function isValidExportSpecifier(specifier, localDeclarations) {
+	if (specifier.local.type !== "Identifier") return false;
+	if (specifier.exported.type !== "Identifier") return false;
+	if (specifier.local.name !== specifier.exported.name) return false;
+	return localDeclarations.has(specifier.local.name);
+}
+//#endregion
+//#region src/rules/preferInlineExport/canInlineSpecifiers.ts
+function canInlineSpecifiers(specifiers, localDeclarations) {
+	return specifiers.every((spec) => isValidExportSpecifier(spec, localDeclarations));
+}
+//#endregion
+//#region src/rules/preferInlineExport/getDeclarationName.ts
+function getDeclarationName(node) {
+	if (node.type !== "VariableDeclaration") return node.id?.name ?? null;
+	const declarations = node.declarations;
+	if (declarations.length === 1) {
+		const id = declarations[0].id;
+		if (id.type === "Identifier") return id.name;
+	}
+	return null;
+}
+//#endregion
+//#region src/rules/preferInlineExport/isExportableDeclaration.ts
+function isExportableDeclaration(node) {
+	const type = node.type;
+	return type === "TSInterfaceDeclaration" || type === "TSTypeAliasDeclaration" || type === "ClassDeclaration" || type === "FunctionDeclaration" || type === "VariableDeclaration";
+}
+//#endregion
+//#region src/rules/preferInlineExport/index.ts
+var preferInlineExport = {
+	create(context) {
+		const localDeclarations = /* @__PURE__ */ new Map();
+		function visitDeclaration(node) {
+			if (!isExportableDeclaration(node)) return;
+			const name = getDeclarationName(node);
+			if (name) localDeclarations.set(name, {
+				name,
+				node
+			});
+		}
+		return {
+			ClassDeclaration: visitDeclaration,
+			ExportNamedDeclaration(node) {
+				if (node.source) return;
+				if (!node.specifiers || node.specifiers.length === 0) return;
+				if (!canInlineSpecifiers(node.specifiers, localDeclarations)) return;
+				context.report({
+					fix(fixer) {
+						const fixes = [];
+						for (const specifier of node.specifiers) {
+							const name = specifier.local.name;
+							const decl = localDeclarations.get(name);
+							if (decl) fixes.push(fixer.insertTextBefore(decl.node, "export "));
+						}
+						fixes.push(fixer.remove(node));
+						return fixes;
+					},
+					messageId: "preferInline",
+					node
+				});
+			},
+			FunctionDeclaration: visitDeclaration,
+			TSInterfaceDeclaration: visitDeclaration,
+			TSTypeAliasDeclaration: visitDeclaration,
+			VariableDeclaration: visitDeclaration
+		};
+	},
+	meta: {
+		docs: { description: "Enforce using inline export syntax instead of separate export statements." },
+		fixable: "code",
+		messages: { preferInline: "Use inline export instead of separate export statement" },
+		schema: [],
+		type: "suggestion"
+	}
+};
+//#endregion
+//#region src/rules/singleLineArrowFunctionParameters/buildCollapsedParams.ts
+function buildCollapsedParams(sourceCode, params) {
+	return `(${params.map((param, index) => {
+		const text = sourceCode.getText(param);
+		return index === params.length - 1 ? text : text + ",";
+	}).join(" ")})`;
+}
+//#endregion
+//#region src/rules/singleLineArrowFunctionParameters/calculateCollapsedLength.ts
+function calculateCollapsedLength(sourceCode, openingParen, collapsedParams, returnType) {
+	let returnTypeText = "";
+	if (returnType) returnTypeText = sourceCode.getText(returnType);
+	const textAfterClosingParen = sourceCode.getText().split("\n")[openingParen.loc.start.line - 1].slice(openingParen.loc.start.column);
+	return openingParen.loc.start.column + collapsedParams.length + returnTypeText.length + textAfterClosingParen.length;
+}
+//#endregion
+//#region src/rules/singleLineArrowFunctionParameters/defaultOptions.ts
+var defaultOptions$1 = { maxLength: 80 };
+//#endregion
+//#region src/rules/singleLineArrowFunctionParameters/getArrowFunctionParens.ts
+function getArrowFunctionParens(sourceCode, params) {
+	if (params.length === 0) return null;
+	const firstParam = params[0];
+	const lastParam = params[params.length - 1];
+	const openingParen = sourceCode.getTokenBefore(firstParam);
+	let closingParen = sourceCode.getTokenAfter(lastParam);
+	while (closingParen && closingParen.value === ",") closingParen = sourceCode.getTokenAfter(closingParen);
+	if (!openingParen || !closingParen) return null;
+	if (openingParen.value !== "(" || closingParen.value !== ")") return null;
+	return {
+		closingParen,
+		openingParen
+	};
+}
+//#endregion
+//#region src/rules/singleLineArrowFunctionParameters/isShorthand.ts
+function isShorthand(sourceCode, node) {
+	if (node.params.length !== 1) return false;
+	const firstParam = node.params[0];
+	const tokenBefore = sourceCode.getTokenBefore(firstParam);
+	return !tokenBefore || tokenBefore.value !== "(";
+}
+//#endregion
+//#region src/rules/singleLineArrowFunctionParameters/reportViolation.ts
+function reportViolation(context, node, collapsedParams, returnTypeText, arrowToken, openingParen) {
+	context.report({
+		fix: (fixer) => fixer.replaceTextRange([openingParen.range[0], arrowToken.range[1]], collapsedParams + returnTypeText + " =>"),
+		messageId: "singleLine",
+		node
+	});
+}
+//#endregion
+//#region src/rules/singleLineArrowFunctionParameters/checkArrowFunction.ts
+function checkArrowFunction(sourceCode, context, node) {
+	const maxLength = (context.options[0] ?? {}).maxLength ?? defaultOptions$1.maxLength;
+	if (isShorthand(sourceCode, node)) return;
+	const parens = getArrowFunctionParens(sourceCode, node.params);
+	if (!parens) return;
+	const { closingParen, openingParen } = parens;
+	if (openingParen.loc.start.line === closingParen.loc.end.line) return;
+	const arrowToken = sourceCode.getTokenAfter(closingParen, (token) => token.value === "=>");
+	if (!arrowToken) return;
+	const collapsedParams = buildCollapsedParams(sourceCode, node.params);
+	if (calculateCollapsedLength(sourceCode, openingParen, collapsedParams, node.returnType) <= maxLength) reportViolation(context, node, collapsedParams, node.returnType ? sourceCode.getText(node.returnType) : "", arrowToken, openingParen);
+}
+//#endregion
+//#region src/rules/singleLineArrowFunctionParameters/index.ts
+var singleLineArrowFunctionParameters = {
+	create(context) {
+		const sourceCode = context.sourceCode ?? context.getSourceCode();
+		return { ArrowFunctionExpression(node) {
+			if (node.params.length === 0) return;
+			checkArrowFunction(sourceCode, context, node);
+		} };
+	},
+	meta: {
+		docs: { description: "Enforce arrow function parameters to be on a single line when they fit." },
+		fixable: "code",
+		messages: { singleLine: "Arrow function parameters can be on a single line" },
+		schema: [{
+			additionalProperties: false,
+			properties: { maxLength: { type: "number" } },
+			type: "object"
+		}],
+		type: "layout"
+	}
+};
+//#endregion
+//#region src/rules/singleLineFunctionParameters/defaultOptions.ts
+var defaultOptions = { maxLength: 80 };
+//#endregion
+//#region src/rules/singleLineFunctionParameters/getParens.ts
+function getParens(sourceCode, nodes) {
+	if (nodes.length === 0) return null;
+	const firstNode = nodes[0];
+	const lastNode = nodes[nodes.length - 1];
+	const openingParen = sourceCode.getTokenBefore(firstNode, (token) => token.value === "(");
+	const closingParen = sourceCode.getTokenAfter(lastNode, (token) => token.value === ")");
+	if (!openingParen || !closingParen) return null;
+	return {
+		closingParen,
+		openingParen
+	};
+}
+//#endregion
+//#region src/rules/singleLineFunctionParameters/checkFunction.ts
+function checkFunction(sourceCode, context, node) {
+	const maxLength = (context.options[0] ?? {}).maxLength ?? defaultOptions.maxLength;
+	const params = node.params;
+	if (params.length === 0) return;
+	const parens = getParens(sourceCode, params);
+	if (!isValidParens(parens)) return;
+	if (parens.openingParen.loc.start.line === parens.closingParen.loc.end.line) return;
+	const paramsText = params.map((param, index) => {
+		const text = sourceCode.getText(param);
+		if (index === params.length - 1) return text;
+		const comma = sourceCode.getTokenAfter(param, (token) => token.value === ",");
+		if (comma && comma.loc.end.line === param.loc.end.line) return text + ",";
+		return text;
+	}).join(" ");
+	const closingLine = parens.closingParen.loc.end.line;
+	const closingCol = parens.closingParen.loc.end.column;
+	const closingLineText = getLineLength(sourceCode, closingLine) > closingCol ? sourceCode.getText().split("\n")[closingLine - 1].slice(closingCol) : "";
+	if (parens.openingParen.loc.start.column + 1 + paramsText.length + 1 + closingLineText.length <= maxLength) context.report({
+		fix: (fixer) => fixer.replaceTextRange([parens.openingParen.range[0], parens.closingParen.range[1]], `(${paramsText})`),
+		messageId: "singleLine",
+		node
+	});
+}
+//#endregion
+//#region src/rules/singleLineFunctionParameters/index.ts
+var singleLineFunctionParameters = {
+	create(context) {
+		const sourceCode = context.sourceCode ?? context.getSourceCode();
+		return {
+			FunctionDeclaration(node) {
+				checkFunction(sourceCode, context, node);
+			},
+			FunctionExpression(node) {
+				checkFunction(sourceCode, context, node);
+			},
+			TSCallSignatureDeclaration(node) {
+				checkFunction(sourceCode, context, node);
+			},
+			TSFunctionType(node) {
+				checkFunction(sourceCode, context, node);
+			},
+			TSMethodSignature(node) {
+				checkFunction(sourceCode, context, node);
+			}
+		};
+	},
+	meta: {
+		docs: { description: "Enforce function parameters to be on a single line when they fit." },
+		fixable: "code",
+		messages: { singleLine: "Function parameters can be on a single line" },
+		schema: [{
+			additionalProperties: false,
+			properties: { maxLength: { type: "number" } },
+			type: "object"
+		}],
+		type: "layout"
+	}
+};
+//#endregion
+//#region src/rules/singleLineImports/formatAttributes.ts
+function formatAttributes(attributes) {
+	if (attributes.length === 0) return "";
+	return ` with {${attributes.map((attr) => {
+		return `${attr.key.type === "Identifier" ? attr.key.name : attr.key.value}: '${attr.value.value}'`;
+	}).join(", ")}}`;
+}
+//#endregion
+//#region src/rules/singleLineImports/formatNamed.ts
+function formatNamed(specifiers, sourceCode) {
+	return specifiers.map((s) => sourceCode.getText(s)).join(", ");
+}
+//#endregion
+//#region src/rules/singleLineImports/formatSpecifiers.ts
+function formatSpecifiers(declaration, sourceCode) {
+	const defaultSpecifier = declaration.specifiers.find((s) => s.type === "ImportDefaultSpecifier");
+	const namespaceSpecifier = declaration.specifiers.find((s) => s.type === "ImportNamespaceSpecifier");
+	const namedSpecifiers = declaration.specifiers.filter((s) => s.type === "ImportSpecifier");
+	if (namespaceSpecifier) return `* as ${namespaceSpecifier.local.name}`;
+	if (defaultSpecifier && namedSpecifiers.length > 0) return `${defaultSpecifier.local.name}, {${formatNamed(namedSpecifiers, sourceCode)}}`;
+	if (defaultSpecifier) return defaultSpecifier.local.name;
+	if (namedSpecifiers.length === 0) return "";
+	return `{${formatNamed(namedSpecifiers, sourceCode)}}`;
+}
+//#endregion
+//#region src/rules/singleLineImports/createImportFix.ts
+function createImportFix$1(fixer, declaration, sourceCode) {
+	const source = declaration.source.value;
+	const prefix = declaration.importKind === "type" ? "import type " : "import ";
+	const specifiers = formatSpecifiers(declaration, sourceCode);
+	const attributes = formatAttributes(declaration.attributes);
+	if (specifiers === "") {
+		const result = `${prefix}'${source}'${attributes}`;
+		return fixer.replaceText(declaration, result);
+	}
+	const result = `${prefix}${specifiers} from '${source}'${attributes}`;
+	return fixer.replaceText(declaration, result);
+}
+//#endregion
+//#region src/rules/singleLineImports/isMultilineImport.ts
+function isMultilineImport(declaration) {
+	const { end, start } = declaration.loc ?? {};
+	return start?.line !== end?.line;
+}
+//#endregion
+//#region src/rules/singleLineImports/index.ts
+var singleLineImports = {
+	create(context) {
+		return { ImportDeclaration(node) {
+			if (!isMultilineImport(node)) return;
+			context.report({
+				fix: (fixer) => createImportFix$1(fixer, node, context.sourceCode),
+				messageId: "multiline",
+				node
+			});
+		} };
+	},
+	meta: {
+		docs: { description: "Enforce imports to be on a single line." },
+		fixable: "code",
+		messages: { multiline: "Import should be on a single line" },
+		schema: [],
+		type: "layout"
+	}
+};
+//#endregion
+//#region src/rules/singleLineReExports/createReExportFix.ts
+function createReExportFix$1(fixer, declaration, sourceCode) {
+	const source = declaration.source.value;
+	if (declaration.type === "ExportAllDeclaration") {
+		const result = `export ${declaration.exported ? `* as ${sourceCode.getText(declaration.exported)}` : "*"} from '${source}'${formatAttributes(declaration.attributes)}`;
+		return fixer.replaceText(declaration, result);
+	}
+	const result = `${declaration.exportKind === "type" ? "export type " : "export "}{${declaration.specifiers.map((s) => sourceCode.getText(s)).join(", ")}} from '${source}'${formatAttributes(declaration.attributes)}`;
+	return fixer.replaceText(declaration, result);
+}
+//#endregion
+//#region src/rules/singleLineReExports/isMultilineReExport.ts
+function isMultilineReExport(declaration) {
+	const { end, start } = declaration.loc ?? {};
+	return start?.line !== end?.line;
+}
+//#endregion
+//#region src/rules/singleLineReExports/index.ts
+var singleLineReExports = {
+	create(context) {
+		const checkDeclaration = (node, declaration) => {
+			if (!declaration.source) return;
+			if (!isMultilineReExport(declaration)) return;
+			context.report({
+				fix: (fixer) => createReExportFix$1(fixer, declaration, context.sourceCode),
+				messageId: "multiline",
+				node
+			});
+		};
+		return {
+			ExportAllDeclaration: (node) => {
+				checkDeclaration(node, node);
+			},
+			ExportNamedDeclaration: (node) => {
+				checkDeclaration(node, node);
+			}
+		};
+	},
+	meta: {
+		docs: { description: "Enforce re-exports to be on a single line." },
+		fixable: "code",
+		messages: { multiline: "Re-export should be on a single line" },
+		schema: [],
+		type: "layout"
+	}
+};
+//#endregion
+//#region src/rules/sortedImports/categorizeImport.ts
+function categorizeImport(declaration) {
+	if (declaration.specifiers.some((s) => s.type === "ImportNamespaceSpecifier")) return declaration.importKind === "type" ? "type-namespace" : "namespace";
+	if (declaration.specifiers.some((s) => s.type === "ImportDefaultSpecifier")) return declaration.importKind === "type" ? "type-default" : "default";
+	if (declaration.importKind === "type") return "type-named";
+	if (declaration.specifiers.length === 0) return "side-effect";
+	return "named";
+}
+//#endregion
+//#region src/rules/sortedImports/getImportSortKey.ts
+function getImportSortKey(declaration) {
+	const group = categorizeImport(declaration);
+	if (group === "side-effect") return declaration.source.value;
+	if (group === "namespace" || group === "type-namespace") return `*${declaration.specifiers.find((s) => s.type === "ImportNamespaceSpecifier")?.local.name ?? ""}`;
+	if (group === "default" || group === "type-default") return declaration.specifiers.find((s) => s.type === "ImportDefaultSpecifier")?.local.name ?? "";
+	return declaration.specifiers[0].local.name;
+}
+//#endregion
+//#region src/rules/sortedImports/categorizeImports.ts
+function categorizeImports(declarations) {
+	return declarations.map((declaration) => ({
+		declaration,
+		group: categorizeImport(declaration),
+		sortKey: getImportSortKey(declaration)
+	}));
+}
+//#endregion
+//#region src/lib/compare.ts
+function compare(a, b) {
+	return a.localeCompare(b, "en", { sensitivity: "case" });
+}
+//#endregion
+//#region src/rules/sortedImports/importGroupOrder.ts
+var importGroupOrder = [
+	"side-effect",
+	"namespace",
+	"default",
+	"named",
+	"type-namespace",
+	"type-default",
+	"type-named"
+];
+//#endregion
+//#region src/rules/sortedImports/checkAlphabeticalSorting.ts
+function checkAlphabeticalSorting$1(categorizedImports) {
+	const errors = [];
+	for (const importGroup of importGroupOrder) {
+		const groupImports = categorizedImports.filter((c) => c.group === importGroup);
+		const expectedSortedImports = [...groupImports].sort((a, b) => compare(a.sortKey, b.sortKey));
+		for (let i = 0; i < groupImports.length; i++) if (groupImports[i] !== expectedSortedImports[i]) errors.push({
+			messageId: "sortedImports",
+			node: groupImports[i].declaration
+		});
+	}
+	return errors;
+}
+//#endregion
+//#region src/rules/sortedImports/checkGroupOrdering.ts
+function checkGroupOrdering$1(categorizedImports) {
+	const errors = [];
+	let currentGroupIndex = -1;
+	for (const { declaration, group: importGroup } of categorizedImports) {
+		const groupIndex = importGroupOrder.indexOf(importGroup);
+		if (groupIndex < currentGroupIndex) errors.push({
+			messageId: "wrongGroup",
+			node: declaration
+		});
+		else currentGroupIndex = groupIndex;
+	}
+	return errors;
+}
+//#endregion
+//#region src/rules/sortedImports/getImportSpecifierName.ts
+function getImportSpecifierName(specifier) {
+	return specifier.imported.type === "Identifier" ? specifier.imported.name : String(specifier.imported.value);
+}
+//#endregion
+//#region src/rules/sortedImports/areSpecifiersSorted.ts
+function areSpecifiersSorted$1(specifiers) {
+	const names = specifiers.map((s) => getImportSpecifierName(s));
+	const sorted = [...names].sort((a, b) => compare(a, b));
+	return names.every((name, i) => name === sorted[i]);
+}
+//#endregion
+//#region src/rules/sortedImports/getImportNamedSpecifiers.ts
+function getImportNamedSpecifiers(declaration) {
+	return declaration.specifiers.filter((s) => s.type === "ImportSpecifier");
+}
+//#endregion
+//#region src/rules/sortedImports/checkSpecifiersSorting.ts
+function checkSpecifiersSorting$1(categorized) {
+	const errors = [];
+	const namedImportDeclarations = categorized.filter((c) => c.group === "named");
+	for (const { declaration } of namedImportDeclarations) {
+		const namedSpecifiers = getImportNamedSpecifiers(declaration);
+		if (namedSpecifiers.length > 1 && !areSpecifiersSorted$1(namedSpecifiers)) errors.push({
+			messageId: "sortedNames",
+			node: declaration
+		});
+	}
+	return errors;
+}
+//#endregion
+//#region src/rules/sortedImports/sortImportSpecifiersText.ts
+function sortImportSpecifiersText(specifiers, sourceCode) {
+	return [...specifiers].sort((a, b) => {
+		return compare(getImportSpecifierName(a), getImportSpecifierName(b));
+	}).map((s) => sourceCode.getText(s)).join(", ");
+}
+//#endregion
+//#region src/rules/sortedImports/createFix/formatNamedImportSpecifiers.ts
+function formatNamedImportSpecifiers(declaration, sourceCode) {
+	const specifiers = getImportNamedSpecifiers(declaration);
+	if (specifiers.length > 1 && !areSpecifiersSorted$1(specifiers)) {
+		const sortedSpecifiers = sortImportSpecifiersText(specifiers, sourceCode);
+		const source = declaration.source.value;
+		return `${declaration.importKind === "type" ? "import type " : "import "}{${sortedSpecifiers}} from '${source}'`;
+	}
+	return sourceCode.getText(declaration);
+}
+//#endregion
+//#region src/rules/sortedImports/createFix/buildSortedImportCode.ts
+function buildSortedImportCode(grouped, sourceCode) {
+	const sortedCode = [];
+	for (const group of importGroupOrder) for (const { declaration } of grouped[group] ?? []) if (group === "named" || group === "type-named") sortedCode.push(formatNamedImportSpecifiers(declaration, sourceCode));
+	else sortedCode.push(sourceCode.getText(declaration));
+	return sortedCode;
+}
+//#endregion
+//#region src/rules/sortedImports/createFix/groupImportsByType.ts
+function groupImportsByType(categorized) {
+	const grouped = {
+		default: [],
+		named: [],
+		namespace: [],
+		"side-effect": [],
+		"type-default": [],
+		"type-named": [],
+		"type-namespace": []
+	};
+	for (const item of categorized) grouped[item.group].push(item);
+	return grouped;
+}
+//#endregion
+//#region src/rules/sortedImports/createFix/sortImportGroups.ts
+function sortImportGroups(grouped) {
+	grouped["side-effect"].sort((a, b) => compare(a.sortKey, b.sortKey));
+	grouped["namespace"].sort((a, b) => compare(a.sortKey, b.sortKey));
+	grouped["default"].sort((a, b) => compare(a.sortKey, b.sortKey));
+	grouped["named"].sort((a, b) => compare(a.sortKey, b.sortKey));
+	grouped["type-namespace"].sort((a, b) => compare(a.sortKey, b.sortKey));
+	grouped["type-default"].sort((a, b) => compare(a.sortKey, b.sortKey));
+	grouped["type-named"].sort((a, b) => compare(a.sortKey, b.sortKey));
+}
+//#endregion
+//#region src/rules/sortedImports/createFix/createFixForGroup.ts
+function createFixForGroup$1(fixer, importDeclarations, sourceCode) {
+	if (importDeclarations.length === 0) return null;
+	const grouped = groupImportsByType(categorizeImports(importDeclarations));
+	sortImportGroups(grouped);
+	const sortedCode = buildSortedImportCode(grouped, sourceCode).join("\n");
+	const firstImport = importDeclarations[0];
+	const lastImport = importDeclarations[importDeclarations.length - 1];
+	return fixer.replaceTextRange([firstImport.range[0], lastImport.range[1]], sortedCode);
+}
+//#endregion
+//#region src/rules/sortedImports/createFix/index.ts
+function createImportFix(fixer, importGroups, sourceCode) {
+	const fixes = [];
+	for (const group of importGroups) {
+		const fix = createFixForGroup$1(fixer, group, sourceCode);
+		if (fix) fixes.push(fix);
+	}
+	return fixes;
+}
+//#endregion
+//#region src/rules/sortedImports/getImportGroups.ts
+function getImportGroups(programBody) {
+	const groups = [];
+	let currentImportGroup = [];
+	for (const statement of programBody) {
+		if (statement.type === "ImportDeclaration") {
+			currentImportGroup.push(statement);
+			continue;
+		}
+		if (currentImportGroup.length > 0) {
+			groups.push(currentImportGroup);
+			currentImportGroup = [];
+		}
+	}
+	if (currentImportGroup.length > 0) groups.push(currentImportGroup);
+	return groups;
+}
+//#endregion
+//#region src/rules/sortedImports/index.ts
+var sortedImports = {
+	create(context) {
+		return { Program(node) {
+			const programBody = node.body;
+			const importGroups = getImportGroups(programBody);
+			if (importGroups.length === 0) return;
+			const allImportErrors = [];
+			for (const group of importGroups) {
+				const categorized = categorizeImports(group);
+				const errors = [
+					...checkGroupOrdering$1(categorized),
+					...checkAlphabeticalSorting$1(categorized),
+					...checkSpecifiersSorting$1(categorized)
+				];
+				allImportErrors.push(...errors);
+			}
+			for (const error of allImportErrors) context.report({
+				fix(fixer) {
+					const sourceCode = context.sourceCode;
+					return createImportFix(fixer, importGroups, sourceCode);
+				},
+				messageId: error.messageId,
+				node: error.node
+			});
+		} };
+	},
+	meta: {
+		docs: { description: "Enforce sorted imports alphabetically." },
+		fixable: "code",
+		messages: {
+			sortedImports: "Imports should be sorted alphabetically",
+			sortedNames: "Named imports should be sorted alphabetically",
+			wrongGroup: "Import is in wrong group"
+		},
+		schema: [],
+		type: "suggestion"
+	}
+};
+//#endregion
+//#region src/rules/sortedReExports/categorizeReExport.ts
+function categorizeReExport(declaration) {
+	if (declaration.type === "ExportAllDeclaration") {
+		if (declaration.exportKind === "type") {
+			if (declaration.exported) return "type-namespace";
+			return "type-all";
+		}
+		if (declaration.exported) return "re-export-namespace";
+		return "re-export-all";
+	}
+	if (declaration.exportKind === "type") return "type-named";
+	if (declaration.specifiers?.some((s) => s.exportKind === "type")) return "type-named";
+	return "re-export-named";
+}
+//#endregion
+//#region src/rules/sortedReExports/getReExportSortKey.ts
+function getReExportSortKey(declaration) {
+	const group = categorizeReExport(declaration);
+	if (declaration.type === "ExportAllDeclaration") {
+		if (group === "re-export-namespace") {
+			if (declaration.exported?.type === "Identifier") return `*${declaration.exported.name}`;
+		}
+		return declaration.source.value;
+	}
+	const specifier = declaration.specifiers[0];
+	if (!specifier) return "";
+	return specifier.local.type === "Identifier" ? specifier.local.name : specifier.local.value;
+}
+//#endregion
+//#region src/rules/sortedReExports/categorizeReExports.ts
+function categorizeReExports(declarations) {
+	return declarations.map((declaration) => {
+		return {
+			declaration,
+			group: categorizeReExport(declaration),
+			sortKey: getReExportSortKey(declaration)
+		};
+	});
+}
+//#endregion
+//#region src/rules/sortedReExports/reExportGroupOrder.ts
+var reExportGroupOrder = [
+	"re-export-all",
+	"re-export-namespace",
+	"re-export-named",
+	"type-all",
+	"type-namespace",
+	"type-named"
+];
+//#endregion
+//#region src/rules/sortedReExports/checkAlphabeticalSorting.ts
+function checkAlphabeticalSorting(categorized) {
+	const errors = [];
+	for (const group of reExportGroupOrder) {
+		const groupReExports = categorized.filter((c) => c.group === group);
+		const sorted = [...groupReExports].sort((a, b) => compare(a.sortKey, b.sortKey));
+		for (let i = 0; i < groupReExports.length; i++) if (groupReExports[i] !== sorted[i]) errors.push({
+			messageId: "sortedReExports",
+			node: groupReExports[i].declaration
+		});
+	}
+	return errors;
+}
+//#endregion
+//#region src/rules/sortedReExports/checkGroupOrdering.ts
+function checkGroupOrdering(categorized) {
+	const errors = [];
+	let currentGroupIndex = -1;
+	for (const { declaration, group } of categorized) {
+		const groupIndex = reExportGroupOrder.indexOf(group);
+		if (groupIndex < currentGroupIndex) errors.push({
+			messageId: "wrongGroup",
+			node: declaration
+		});
+		else currentGroupIndex = groupIndex;
+	}
+	return errors;
+}
+//#endregion
+//#region src/rules/sortedReExports/getSpecifierName.ts
+function getSpecifierName(specifier) {
+	return specifier.local.type === "Identifier" ? specifier.local.name : String(specifier.local.value);
+}
+//#endregion
+//#region src/rules/sortedReExports/areSpecifiersSorted.ts
+function areSpecifiersSorted(specifiers) {
+	const names = specifiers.map((s) => getSpecifierName(s));
+	const sorted = [...names].sort((a, b) => compare(a, b));
+	return names.every((name, i) => name === sorted[i]);
+}
+//#endregion
+//#region src/rules/sortedReExports/getReExportNamedSpecifiers.ts
+function getReExportNamedSpecifiers(declaration) {
+	return declaration.specifiers.filter((s) => s.type === "ExportSpecifier" && s.local.type === "Identifier");
+}
+//#endregion
+//#region src/rules/sortedReExports/isNamedReExport.ts
+function isNamedReExport(x) {
+	return x.group !== "re-export-all" && x.group !== "re-export-namespace";
+}
+//#endregion
+//#region src/rules/sortedReExports/checkSpecifiersSorting.ts
+function checkSpecifiersSorting(categorized) {
+	const errors = [];
+	const namedReExports = categorized.filter(isNamedReExport);
+	for (const { declaration } of namedReExports) {
+		const specifiers = getReExportNamedSpecifiers(declaration);
+		const isSorted = areSpecifiersSorted(specifiers);
+		if (specifiers.length > 1 && !isSorted) errors.push({
+			messageId: "sortedNames",
+			node: declaration
+		});
+	}
+	return errors;
+}
+//#endregion
+//#region src/rules/sortedReExports/sortSpecifiersText.ts
+function sortSpecifiersText(specifiers, sourceCode) {
+	return [...specifiers].sort((a, b) => {
+		return compare(getSpecifierName(a), getSpecifierName(b));
+	}).map((s) => sourceCode.getText(s)).join(", ");
+}
+//#endregion
+//#region src/rules/sortedReExports/createFix/formatNamedReExportSpecifiers.ts
+function formatNamedReExportSpecifiers(declaration, sourceCode) {
+	const specifiers = getReExportNamedSpecifiers(declaration);
+	if (specifiers.length > 1 && !areSpecifiersSorted(specifiers)) {
+		const sortedSpecifiers = sortSpecifiersText(specifiers, sourceCode);
+		const source = declaration.source.value;
+		return `${declaration.exportKind === "type" ? "export type " : "export "}{${sortedSpecifiers}} from '${source}'`;
+	}
+	return sourceCode.getText(declaration);
+}
+//#endregion
+//#region src/rules/sortedReExports/createFix/buildSortedReExportCode.ts
+function buildSortedReExportCode(grouped, sourceCode) {
+	const sortedCode = [];
+	for (const group of reExportGroupOrder) for (const item of grouped[group]) if (isNamedReExport(item)) sortedCode.push(formatNamedReExportSpecifiers(item.declaration, sourceCode));
+	else sortedCode.push(sourceCode.getText(item.declaration));
+	return sortedCode;
+}
+//#endregion
+//#region src/rules/sortedReExports/createFix/groupReExportsByType.ts
+function groupReExportsByType(categorized) {
+	const grouped = {
+		"re-export-all": [],
+		"re-export-named": [],
+		"re-export-namespace": [],
+		"type-all": [],
+		"type-named": [],
+		"type-namespace": []
+	};
+	for (const item of categorized) grouped[item.group].push(item);
+	return grouped;
+}
+//#endregion
+//#region src/rules/sortedReExports/createFix/sortExportGroups.ts
+function sortExportGroups(grouped) {
+	grouped["re-export-all"].sort((a, b) => compare(a.sortKey, b.sortKey));
+	grouped["re-export-namespace"].sort((a, b) => compare(a.sortKey, b.sortKey));
+	grouped["re-export-named"].sort((a, b) => compare(a.sortKey, b.sortKey));
+	grouped["type-all"].sort((a, b) => compare(a.sortKey, b.sortKey));
+	grouped["type-namespace"].sort((a, b) => compare(a.sortKey, b.sortKey));
+	grouped["type-named"].sort((a, b) => compare(a.sortKey, b.sortKey));
+}
+//#endregion
+//#region src/rules/sortedReExports/createFix/createFixForGroup.ts
+function createFixForGroup(fixer, reExportDeclarations, sourceCode) {
+	if (reExportDeclarations.length === 0) return null;
+	const grouped = groupReExportsByType(categorizeReExports(reExportDeclarations));
+	sortExportGroups(grouped);
+	const sortedCode = buildSortedReExportCode(grouped, sourceCode).join("\n");
+	const firstReExport = reExportDeclarations[0];
+	const lastReExport = reExportDeclarations[reExportDeclarations.length - 1];
+	return fixer.replaceTextRange([firstReExport.range[0], lastReExport.range[1]], sortedCode);
+}
+//#endregion
+//#region src/rules/sortedReExports/createFix/index.ts
+function createReExportFix(fixer, reExportGroups, sourceCode) {
+	const fixes = [];
+	for (const group of reExportGroups) {
+		const fix = createFixForGroup(fixer, group, sourceCode);
+		if (fix) fixes.push(fix);
+	}
+	return fixes;
+}
+//#endregion
+//#region src/rules/sortedReExports/isReExportDeclaration.ts
+function isReExportDeclaration(statement) {
+	return statement.type === "ExportNamedDeclaration" && statement.source !== null || statement.type === "ExportAllDeclaration";
+}
+//#endregion
+//#region src/rules/sortedReExports/getReExportGroups.ts
+function getReExportGroups(programBody) {
+	const groups = [];
+	let currentGroup = [];
+	for (const statement of programBody) {
+		if (isReExportDeclaration(statement)) {
+			currentGroup.push(statement);
+			continue;
+		}
+		if (currentGroup.length > 0) {
+			groups.push(currentGroup);
+			currentGroup = [];
+		}
+	}
+	if (currentGroup.length > 0) groups.push(currentGroup);
+	return groups;
+}
+//#endregion
+//#region src/main/customRules.ts
+var customRules = {
+	plugins: { "@borela-tech": { rules: {
+		"array-items-line-break": arrayItemsLineBreak,
+		"brace-style-control-statements": braceStyleControlStatements,
+		"brace-style-object-literal": braceStyleObjectLiteral,
+		"compact-array-items": compactArrayItems,
+		"export-filename-match": exportFilenameMatch,
+		"function-call-argument-line-break": functionCallArgumentLineBreak,
+		"function-cognitive-complexity": functionCognitiveComplexity,
+		"function-parameter-line-break": functionParameterLineBreak,
+		"imports-and-re-exports-at-top": importsAndReExportsAtTop,
+		"individual-imports": individualImports,
+		"individual-re-exports": individualReExports,
+		"interface-property-line-break": interfacePropertyLineBreak,
+		"max-declarations-per-file": maxDeclarationsPerFile,
+		"multiline-union-type-aliases": multilineUnionTypeAliases,
+		"naming-convention": namingConvention,
+		"no-inline-object-types": noInlineObjectTypes,
+		"no-unnecessary-braces": noUnnecessaryBraces,
+		"object-property-line-break": objectPropertyLineBreak,
+		"one-export-per-file": oneExportPerFile,
+		"prefer-inline-export": preferInlineExport,
+		"single-line-arrow-function-parameters": singleLineArrowFunctionParameters,
+		"single-line-function-parameters": singleLineFunctionParameters,
+		"single-line-imports": singleLineImports,
+		"single-line-re-exports": singleLineReExports,
+		"sorted-imports": sortedImports,
+		"sorted-re-exports": {
+			create(context) {
+				return { Program(node) {
+					const programBody = node.body;
+					const reExportGroups = getReExportGroups(programBody);
+					if (reExportGroups.length === 0) return;
+					const allReExportErrors = [];
+					for (const group of reExportGroups) {
+						const categorizedReExports = categorizeReExports(group);
+						const groupErrors = [
+							...checkGroupOrdering(categorizedReExports),
+							...checkAlphabeticalSorting(categorizedReExports),
+							...checkSpecifiersSorting(categorizedReExports)
+						];
+						allReExportErrors.push(...groupErrors);
+					}
+					for (const error of allReExportErrors) context.report({
+						fix(fixer) {
+							const sourceCode = context.sourceCode;
+							return createReExportFix(fixer, reExportGroups, sourceCode);
+						},
+						messageId: error.messageId,
+						node: error.node
+					});
+				} };
+			},
+			meta: {
+				docs: { description: "Enforce sorted exports alphabetically." },
+				fixable: "code",
+				messages: {
+					sortedNames: "Named exports should be sorted alphabetically",
+					sortedReExports: "Exports should be sorted alphabetically",
+					wrongGroup: "Export is in wrong group"
+				},
+				schema: [],
+				type: "suggestion"
+			}
+		}
+	} } },
+	rules: {
+		"@borela-tech/array-items-line-break": ["error", { maxLength: 80 }],
+		"@borela-tech/brace-style-control-statements": "error",
+		"@borela-tech/brace-style-object-literal": "error",
+		"@borela-tech/compact-array-items": "error",
+		"@borela-tech/export-filename-match": "error",
+		"@borela-tech/function-call-argument-line-break": ["error", { maxLength: 80 }],
+		"@borela-tech/function-cognitive-complexity": ["error", { maxCognitiveComplexity: 15 }],
+		"@borela-tech/function-parameter-line-break": ["error", { maxLength: 80 }],
+		"@borela-tech/imports-and-re-exports-at-top": "error",
+		"@borela-tech/individual-imports": "error",
+		"@borela-tech/individual-re-exports": "error",
+		"@borela-tech/interface-property-line-break": ["error", { maxLength: 80 }],
+		"@borela-tech/max-declarations-per-file": "error",
+		"@borela-tech/multiline-union-type-aliases": "error",
+		"@borela-tech/naming-convention": "error",
+		"@borela-tech/no-inline-object-types": "error",
+		"@borela-tech/no-unnecessary-braces": "error",
+		"@borela-tech/object-property-line-break": "error",
+		"@borela-tech/one-export-per-file": "error",
+		"@borela-tech/prefer-inline-export": "error",
+		"@borela-tech/single-line-arrow-function-parameters": ["error", { maxLength: 80 }],
+		"@borela-tech/single-line-function-parameters": ["error", { maxLength: 80 }],
+		"@borela-tech/single-line-imports": "error",
+		"@borela-tech/single-line-re-exports": "error",
+		"@borela-tech/sorted-imports": "error",
+		"@borela-tech/sorted-re-exports": "error"
+	}
+};
+//#endregion
+//#region src/main/generalRules.ts
+var generalRules = { rules: {
+	"capitalized-comments": [
+		"error",
+		"always",
+		{ ignoreConsecutiveComments: true }
+	],
+	complexity: ["error", 10],
+	"no-restricted-exports": ["error", { restrictDefaultExports: { direct: true } }],
+	"react/react-in-jsx-scope": "off"
+} };
+//#endregion
+//#region src/main/ignores.ts
+var ignores = { ignores: [
+	"src/graphql/sdk.ts",
+	"**/node_modules/**",
+	"**/dist/**"
+] };
+//#endregion
+//#region src/main/languageOptions.ts
+var languageOptions = {
+	languageOptions: { parserOptions: { projectService: true } },
+	settings: { react: { version: "19" } }
+};
+//#endregion
+//#region src/main/perfectionistRules.ts
+var perfectionistRules = {
+	plugins: { perfectionist },
+	rules: {
+		"perfectionist/sort-array-includes": ["error", {
+			order: "asc",
+			type: "natural"
+		}],
+		"perfectionist/sort-decorators": ["error", {
+			order: "asc",
+			type: "natural"
+		}],
+		"perfectionist/sort-enums": ["error", {
+			order: "asc",
+			type: "natural"
+		}],
+		"perfectionist/sort-heritage-clauses": ["error", {
+			order: "asc",
+			type: "natural"
+		}],
+		"perfectionist/sort-interfaces": ["error", {
+			order: "asc",
+			type: "natural"
+		}],
+		"perfectionist/sort-intersection-types": ["error", {
+			order: "asc",
+			type: "natural"
+		}],
+		"perfectionist/sort-jsx-props": ["error", {
+			order: "asc",
+			type: "natural"
+		}],
+		"perfectionist/sort-maps": ["error", {
+			order: "asc",
+			type: "natural"
+		}],
+		"perfectionist/sort-object-types": ["error", {
+			order: "asc",
+			type: "natural"
+		}],
+		"perfectionist/sort-objects": ["error", {
+			order: "asc",
+			type: "natural"
+		}],
+		"perfectionist/sort-sets": ["error", {
+			order: "asc",
+			type: "natural"
+		}],
+		"perfectionist/sort-switch-case": ["error", {
+			order: "asc",
+			type: "natural"
+		}],
+		"perfectionist/sort-union-types": ["error", {
+			order: "asc",
+			type: "natural"
+		}]
+	}
+};
+//#endregion
+//#region src/main/reactHooks.ts
+var reactHooks = {
+	plugins: { "react-hooks": rule },
+	rules: rule.configs.recommended.rules
+};
+//#endregion
+//#region src/main/stylisticRules.ts
+var stylisticRules = { rules: {
+	"@stylistic/array-bracket-spacing": ["error", "never"],
+	"@stylistic/arrow-parens": ["error", "as-needed"],
+	"@stylistic/block-spacing": "off",
+	"@stylistic/brace-style": [
+		"error",
+		"1tbs",
+		{ allowSingleLine: true }
+	],
+	"@stylistic/indent": [
+		"error",
+		2,
+		{ ignoredNodes: ["TSMappedType > *"] }
+	],
+	"@stylistic/jsx-tag-spacing": ["error", {
+		afterOpening: "never",
+		beforeClosing: "never",
+		beforeSelfClosing: "never",
+		closingSlash: "never"
+	}],
+	"@stylistic/jsx-wrap-multilines": "off",
+	"@stylistic/lines-between-class-members": "off",
+	"@stylistic/object-curly-newline": "off",
+	"@stylistic/object-curly-spacing": ["error", "never"],
+	"@stylistic/operator-linebreak": [
+		"error",
+		"before",
+		{ overrides: { "=": "after" } }
+	],
+	"@stylistic/quote-props": ["error", "as-needed"],
+	"@stylistic/quotes": [
+		"error",
+		"single",
+		{ avoidEscape: true }
+	],
+	"@stylistic/semi": [
+		"error",
+		"never",
+		{ beforeStatementContinuationChars: "always" }
+	]
+} };
+//#endregion
+//#region src/main/typescriptRules.ts
+var typescriptRules = { rules: {
+	"@typescript-eslint/consistent-indexed-object-style": "off",
+	"@typescript-eslint/consistent-type-imports": ["error", { fixStyle: "separate-type-imports" }],
+	"@typescript-eslint/explicit-function-return-type": ["error", { allowExpressions: true }],
+	"@typescript-eslint/no-empty-function": "off",
+	"@typescript-eslint/no-unused-vars": ["error", {
+		argsIgnorePattern: "^_",
+		caughtErrorsIgnorePattern: "^_",
+		varsIgnorePattern: "^_"
+	}]
+} };
+//#endregion
+//#region node_modules/globals/globals.json
+var globals_exports = /* @__PURE__ */ __exportAll({
+	amd: () => amd,
+	applescript: () => applescript,
+	atomtest: () => atomtest,
+	browser: () => browser,
+	builtin: () => builtin,
+	commonjs: () => commonjs,
+	couch: () => couch,
+	default: () => globals_default,
+	devtools: () => devtools,
+	embertest: () => embertest,
+	es2015: () => es2015,
+	es2017: () => es2017,
+	es2020: () => es2020,
+	es2021: () => es2021,
+	es5: () => es5,
+	greasemonkey: () => greasemonkey,
+	jasmine: () => jasmine,
+	jest: () => jest,
+	jquery: () => jquery,
+	meteor: () => meteor,
+	mocha: () => mocha,
+	mongo: () => mongo,
+	nashorn: () => nashorn,
+	node: () => node,
+	nodeBuiltin: () => nodeBuiltin,
+	phantomjs: () => phantomjs,
+	prototypejs: () => prototypejs,
+	protractor: () => protractor,
+	qunit: () => qunit,
+	rhino: () => rhino,
+	serviceworker: () => serviceworker,
+	shelljs: () => shelljs,
+	webextensions: () => webextensions,
+	worker: () => worker,
+	wsh: () => wsh,
+	yui: () => yui
+});
+var builtin, es5, es2015, es2017, es2020, es2021, browser, worker, node, nodeBuiltin, commonjs, amd, mocha, jasmine, jest, qunit, phantomjs, couch, rhino, nashorn, wsh, jquery, yui, shelljs, prototypejs, meteor, mongo, applescript, serviceworker, atomtest, embertest, protractor, webextensions, greasemonkey, devtools, globals_default;
+var init_globals = __esmMin((() => {
+	builtin = {
+		"AggregateError": false,
+		"Array": false,
+		"ArrayBuffer": false,
+		"Atomics": false,
+		"BigInt": false,
+		"BigInt64Array": false,
+		"BigUint64Array": false,
+		"Boolean": false,
+		"constructor": false,
+		"DataView": false,
+		"Date": false,
+		"decodeURI": false,
+		"decodeURIComponent": false,
+		"encodeURI": false,
+		"encodeURIComponent": false,
+		"Error": false,
+		"escape": false,
+		"eval": false,
+		"EvalError": false,
+		"FinalizationRegistry": false,
+		"Float32Array": false,
+		"Float64Array": false,
+		"Function": false,
+		"globalThis": false,
+		"hasOwnProperty": false,
+		"Infinity": false,
+		"Int16Array": false,
+		"Int32Array": false,
+		"Int8Array": false,
+		"isFinite": false,
+		"isNaN": false,
+		"isPrototypeOf": false,
+		"JSON": false,
+		"Map": false,
+		"Math": false,
+		"NaN": false,
+		"Number": false,
+		"Object": false,
+		"parseFloat": false,
+		"parseInt": false,
+		"Promise": false,
+		"propertyIsEnumerable": false,
+		"Proxy": false,
+		"RangeError": false,
+		"ReferenceError": false,
+		"Reflect": false,
+		"RegExp": false,
+		"Set": false,
+		"SharedArrayBuffer": false,
+		"String": false,
+		"Symbol": false,
+		"SyntaxError": false,
+		"toLocaleString": false,
+		"toString": false,
+		"TypeError": false,
+		"Uint16Array": false,
+		"Uint32Array": false,
+		"Uint8Array": false,
+		"Uint8ClampedArray": false,
+		"undefined": false,
+		"unescape": false,
+		"URIError": false,
+		"valueOf": false,
+		"WeakMap": false,
+		"WeakRef": false,
+		"WeakSet": false
+	};
+	es5 = {
+		"Array": false,
+		"Boolean": false,
+		"constructor": false,
+		"Date": false,
+		"decodeURI": false,
+		"decodeURIComponent": false,
+		"encodeURI": false,
+		"encodeURIComponent": false,
+		"Error": false,
+		"escape": false,
+		"eval": false,
+		"EvalError": false,
+		"Function": false,
+		"hasOwnProperty": false,
+		"Infinity": false,
+		"isFinite": false,
+		"isNaN": false,
+		"isPrototypeOf": false,
+		"JSON": false,
+		"Math": false,
+		"NaN": false,
+		"Number": false,
+		"Object": false,
+		"parseFloat": false,
+		"parseInt": false,
+		"propertyIsEnumerable": false,
+		"RangeError": false,
+		"ReferenceError": false,
+		"RegExp": false,
+		"String": false,
+		"SyntaxError": false,
+		"toLocaleString": false,
+		"toString": false,
+		"TypeError": false,
+		"undefined": false,
+		"unescape": false,
+		"URIError": false,
+		"valueOf": false
+	};
+	es2015 = {
+		"Array": false,
+		"ArrayBuffer": false,
+		"Boolean": false,
+		"constructor": false,
+		"DataView": false,
+		"Date": false,
+		"decodeURI": false,
+		"decodeURIComponent": false,
+		"encodeURI": false,
+		"encodeURIComponent": false,
+		"Error": false,
+		"escape": false,
+		"eval": false,
+		"EvalError": false,
+		"Float32Array": false,
+		"Float64Array": false,
+		"Function": false,
+		"hasOwnProperty": false,
+		"Infinity": false,
+		"Int16Array": false,
+		"Int32Array": false,
+		"Int8Array": false,
+		"isFinite": false,
+		"isNaN": false,
+		"isPrototypeOf": false,
+		"JSON": false,
+		"Map": false,
+		"Math": false,
+		"NaN": false,
+		"Number": false,
+		"Object": false,
+		"parseFloat": false,
+		"parseInt": false,
+		"Promise": false,
+		"propertyIsEnumerable": false,
+		"Proxy": false,
+		"RangeError": false,
+		"ReferenceError": false,
+		"Reflect": false,
+		"RegExp": false,
+		"Set": false,
+		"String": false,
+		"Symbol": false,
+		"SyntaxError": false,
+		"toLocaleString": false,
+		"toString": false,
+		"TypeError": false,
+		"Uint16Array": false,
+		"Uint32Array": false,
+		"Uint8Array": false,
+		"Uint8ClampedArray": false,
+		"undefined": false,
+		"unescape": false,
+		"URIError": false,
+		"valueOf": false,
+		"WeakMap": false,
+		"WeakSet": false
+	};
+	es2017 = {
+		"Array": false,
+		"ArrayBuffer": false,
+		"Atomics": false,
+		"Boolean": false,
+		"constructor": false,
+		"DataView": false,
+		"Date": false,
+		"decodeURI": false,
+		"decodeURIComponent": false,
+		"encodeURI": false,
+		"encodeURIComponent": false,
+		"Error": false,
+		"escape": false,
+		"eval": false,
+		"EvalError": false,
+		"Float32Array": false,
+		"Float64Array": false,
+		"Function": false,
+		"hasOwnProperty": false,
+		"Infinity": false,
+		"Int16Array": false,
+		"Int32Array": false,
+		"Int8Array": false,
+		"isFinite": false,
+		"isNaN": false,
+		"isPrototypeOf": false,
+		"JSON": false,
+		"Map": false,
+		"Math": false,
+		"NaN": false,
+		"Number": false,
+		"Object": false,
+		"parseFloat": false,
+		"parseInt": false,
+		"Promise": false,
+		"propertyIsEnumerable": false,
+		"Proxy": false,
+		"RangeError": false,
+		"ReferenceError": false,
+		"Reflect": false,
+		"RegExp": false,
+		"Set": false,
+		"SharedArrayBuffer": false,
+		"String": false,
+		"Symbol": false,
+		"SyntaxError": false,
+		"toLocaleString": false,
+		"toString": false,
+		"TypeError": false,
+		"Uint16Array": false,
+		"Uint32Array": false,
+		"Uint8Array": false,
+		"Uint8ClampedArray": false,
+		"undefined": false,
+		"unescape": false,
+		"URIError": false,
+		"valueOf": false,
+		"WeakMap": false,
+		"WeakSet": false
+	};
+	es2020 = {
+		"Array": false,
+		"ArrayBuffer": false,
+		"Atomics": false,
+		"BigInt": false,
+		"BigInt64Array": false,
+		"BigUint64Array": false,
+		"Boolean": false,
+		"constructor": false,
+		"DataView": false,
+		"Date": false,
+		"decodeURI": false,
+		"decodeURIComponent": false,
+		"encodeURI": false,
+		"encodeURIComponent": false,
+		"Error": false,
+		"escape": false,
+		"eval": false,
+		"EvalError": false,
+		"Float32Array": false,
+		"Float64Array": false,
+		"Function": false,
+		"globalThis": false,
+		"hasOwnProperty": false,
+		"Infinity": false,
+		"Int16Array": false,
+		"Int32Array": false,
+		"Int8Array": false,
+		"isFinite": false,
+		"isNaN": false,
+		"isPrototypeOf": false,
+		"JSON": false,
+		"Map": false,
+		"Math": false,
+		"NaN": false,
+		"Number": false,
+		"Object": false,
+		"parseFloat": false,
+		"parseInt": false,
+		"Promise": false,
+		"propertyIsEnumerable": false,
+		"Proxy": false,
+		"RangeError": false,
+		"ReferenceError": false,
+		"Reflect": false,
+		"RegExp": false,
+		"Set": false,
+		"SharedArrayBuffer": false,
+		"String": false,
+		"Symbol": false,
+		"SyntaxError": false,
+		"toLocaleString": false,
+		"toString": false,
+		"TypeError": false,
+		"Uint16Array": false,
+		"Uint32Array": false,
+		"Uint8Array": false,
+		"Uint8ClampedArray": false,
+		"undefined": false,
+		"unescape": false,
+		"URIError": false,
+		"valueOf": false,
+		"WeakMap": false,
+		"WeakSet": false
+	};
+	es2021 = {
+		"AggregateError": false,
+		"Array": false,
+		"ArrayBuffer": false,
+		"Atomics": false,
+		"BigInt": false,
+		"BigInt64Array": false,
+		"BigUint64Array": false,
+		"Boolean": false,
+		"constructor": false,
+		"DataView": false,
+		"Date": false,
+		"decodeURI": false,
+		"decodeURIComponent": false,
+		"encodeURI": false,
+		"encodeURIComponent": false,
+		"Error": false,
+		"escape": false,
+		"eval": false,
+		"EvalError": false,
+		"FinalizationRegistry": false,
+		"Float32Array": false,
+		"Float64Array": false,
+		"Function": false,
+		"globalThis": false,
+		"hasOwnProperty": false,
+		"Infinity": false,
+		"Int16Array": false,
+		"Int32Array": false,
+		"Int8Array": false,
+		"isFinite": false,
+		"isNaN": false,
+		"isPrototypeOf": false,
+		"JSON": false,
+		"Map": false,
+		"Math": false,
+		"NaN": false,
+		"Number": false,
+		"Object": false,
+		"parseFloat": false,
+		"parseInt": false,
+		"Promise": false,
+		"propertyIsEnumerable": false,
+		"Proxy": false,
+		"RangeError": false,
+		"ReferenceError": false,
+		"Reflect": false,
+		"RegExp": false,
+		"Set": false,
+		"SharedArrayBuffer": false,
+		"String": false,
+		"Symbol": false,
+		"SyntaxError": false,
+		"toLocaleString": false,
+		"toString": false,
+		"TypeError": false,
+		"Uint16Array": false,
+		"Uint32Array": false,
+		"Uint8Array": false,
+		"Uint8ClampedArray": false,
+		"undefined": false,
+		"unescape": false,
+		"URIError": false,
+		"valueOf": false,
+		"WeakMap": false,
+		"WeakRef": false,
+		"WeakSet": false
+	};
+	browser = /* @__PURE__ */ JSON.parse("{\"AbortController\":false,\"AbortSignal\":false,\"addEventListener\":false,\"alert\":false,\"AnalyserNode\":false,\"Animation\":false,\"AnimationEffectReadOnly\":false,\"AnimationEffectTiming\":false,\"AnimationEffectTimingReadOnly\":false,\"AnimationEvent\":false,\"AnimationPlaybackEvent\":false,\"AnimationTimeline\":false,\"applicationCache\":false,\"ApplicationCache\":false,\"ApplicationCacheErrorEvent\":false,\"atob\":false,\"Attr\":false,\"Audio\":false,\"AudioBuffer\":false,\"AudioBufferSourceNode\":false,\"AudioContext\":false,\"AudioDestinationNode\":false,\"AudioListener\":false,\"AudioNode\":false,\"AudioParam\":false,\"AudioProcessingEvent\":false,\"AudioScheduledSourceNode\":false,\"AudioWorkletGlobalScope\":false,\"AudioWorkletNode\":false,\"AudioWorkletProcessor\":false,\"BarProp\":false,\"BaseAudioContext\":false,\"BatteryManager\":false,\"BeforeUnloadEvent\":false,\"BiquadFilterNode\":false,\"Blob\":false,\"BlobEvent\":false,\"blur\":false,\"BroadcastChannel\":false,\"btoa\":false,\"BudgetService\":false,\"ByteLengthQueuingStrategy\":false,\"Cache\":false,\"caches\":false,\"CacheStorage\":false,\"cancelAnimationFrame\":false,\"cancelIdleCallback\":false,\"CanvasCaptureMediaStreamTrack\":false,\"CanvasGradient\":false,\"CanvasPattern\":false,\"CanvasRenderingContext2D\":false,\"ChannelMergerNode\":false,\"ChannelSplitterNode\":false,\"CharacterData\":false,\"clearInterval\":false,\"clearTimeout\":false,\"clientInformation\":false,\"ClipboardEvent\":false,\"ClipboardItem\":false,\"close\":false,\"closed\":false,\"CloseEvent\":false,\"Comment\":false,\"CompositionEvent\":false,\"CompressionStream\":false,\"confirm\":false,\"console\":false,\"ConstantSourceNode\":false,\"ConvolverNode\":false,\"CountQueuingStrategy\":false,\"createImageBitmap\":false,\"Credential\":false,\"CredentialsContainer\":false,\"crypto\":false,\"Crypto\":false,\"CryptoKey\":false,\"CSS\":false,\"CSSConditionRule\":false,\"CSSFontFaceRule\":false,\"CSSGroupingRule\":false,\"CSSImportRule\":false,\"CSSKeyframeRule\":false,\"CSSKeyframesRule\":false,\"CSSMatrixComponent\":false,\"CSSMediaRule\":false,\"CSSNamespaceRule\":false,\"CSSPageRule\":false,\"CSSPerspective\":false,\"CSSRotate\":false,\"CSSRule\":false,\"CSSRuleList\":false,\"CSSScale\":false,\"CSSSkew\":false,\"CSSSkewX\":false,\"CSSSkewY\":false,\"CSSStyleDeclaration\":false,\"CSSStyleRule\":false,\"CSSStyleSheet\":false,\"CSSSupportsRule\":false,\"CSSTransformValue\":false,\"CSSTranslate\":false,\"CustomElementRegistry\":false,\"customElements\":false,\"CustomEvent\":false,\"DataTransfer\":false,\"DataTransferItem\":false,\"DataTransferItemList\":false,\"DecompressionStream\":false,\"defaultstatus\":false,\"defaultStatus\":false,\"DelayNode\":false,\"DeviceMotionEvent\":false,\"DeviceOrientationEvent\":false,\"devicePixelRatio\":false,\"dispatchEvent\":false,\"document\":false,\"Document\":false,\"DocumentFragment\":false,\"DocumentType\":false,\"DOMError\":false,\"DOMException\":false,\"DOMImplementation\":false,\"DOMMatrix\":false,\"DOMMatrixReadOnly\":false,\"DOMParser\":false,\"DOMPoint\":false,\"DOMPointReadOnly\":false,\"DOMQuad\":false,\"DOMRect\":false,\"DOMRectList\":false,\"DOMRectReadOnly\":false,\"DOMStringList\":false,\"DOMStringMap\":false,\"DOMTokenList\":false,\"DragEvent\":false,\"DynamicsCompressorNode\":false,\"Element\":false,\"ErrorEvent\":false,\"event\":false,\"Event\":false,\"EventSource\":false,\"EventTarget\":false,\"external\":false,\"fetch\":false,\"File\":false,\"FileList\":false,\"FileReader\":false,\"find\":false,\"focus\":false,\"FocusEvent\":false,\"FontFace\":false,\"FontFaceSetLoadEvent\":false,\"FormData\":false,\"FormDataEvent\":false,\"frameElement\":false,\"frames\":false,\"GainNode\":false,\"Gamepad\":false,\"GamepadButton\":false,\"GamepadEvent\":false,\"getComputedStyle\":false,\"getSelection\":false,\"HashChangeEvent\":false,\"Headers\":false,\"history\":false,\"History\":false,\"HTMLAllCollection\":false,\"HTMLAnchorElement\":false,\"HTMLAreaElement\":false,\"HTMLAudioElement\":false,\"HTMLBaseElement\":false,\"HTMLBodyElement\":false,\"HTMLBRElement\":false,\"HTMLButtonElement\":false,\"HTMLCanvasElement\":false,\"HTMLCollection\":false,\"HTMLContentElement\":false,\"HTMLDataElement\":false,\"HTMLDataListElement\":false,\"HTMLDetailsElement\":false,\"HTMLDialogElement\":false,\"HTMLDirectoryElement\":false,\"HTMLDivElement\":false,\"HTMLDListElement\":false,\"HTMLDocument\":false,\"HTMLElement\":false,\"HTMLEmbedElement\":false,\"HTMLFieldSetElement\":false,\"HTMLFontElement\":false,\"HTMLFormControlsCollection\":false,\"HTMLFormElement\":false,\"HTMLFrameElement\":false,\"HTMLFrameSetElement\":false,\"HTMLHeadElement\":false,\"HTMLHeadingElement\":false,\"HTMLHRElement\":false,\"HTMLHtmlElement\":false,\"HTMLIFrameElement\":false,\"HTMLImageElement\":false,\"HTMLInputElement\":false,\"HTMLLabelElement\":false,\"HTMLLegendElement\":false,\"HTMLLIElement\":false,\"HTMLLinkElement\":false,\"HTMLMapElement\":false,\"HTMLMarqueeElement\":false,\"HTMLMediaElement\":false,\"HTMLMenuElement\":false,\"HTMLMetaElement\":false,\"HTMLMeterElement\":false,\"HTMLModElement\":false,\"HTMLObjectElement\":false,\"HTMLOListElement\":false,\"HTMLOptGroupElement\":false,\"HTMLOptionElement\":false,\"HTMLOptionsCollection\":false,\"HTMLOutputElement\":false,\"HTMLParagraphElement\":false,\"HTMLParamElement\":false,\"HTMLPictureElement\":false,\"HTMLPreElement\":false,\"HTMLProgressElement\":false,\"HTMLQuoteElement\":false,\"HTMLScriptElement\":false,\"HTMLSelectElement\":false,\"HTMLShadowElement\":false,\"HTMLSlotElement\":false,\"HTMLSourceElement\":false,\"HTMLSpanElement\":false,\"HTMLStyleElement\":false,\"HTMLTableCaptionElement\":false,\"HTMLTableCellElement\":false,\"HTMLTableColElement\":false,\"HTMLTableElement\":false,\"HTMLTableRowElement\":false,\"HTMLTableSectionElement\":false,\"HTMLTemplateElement\":false,\"HTMLTextAreaElement\":false,\"HTMLTimeElement\":false,\"HTMLTitleElement\":false,\"HTMLTrackElement\":false,\"HTMLUListElement\":false,\"HTMLUnknownElement\":false,\"HTMLVideoElement\":false,\"IDBCursor\":false,\"IDBCursorWithValue\":false,\"IDBDatabase\":false,\"IDBFactory\":false,\"IDBIndex\":false,\"IDBKeyRange\":false,\"IDBObjectStore\":false,\"IDBOpenDBRequest\":false,\"IDBRequest\":false,\"IDBTransaction\":false,\"IDBVersionChangeEvent\":false,\"IdleDeadline\":false,\"IIRFilterNode\":false,\"Image\":false,\"ImageBitmap\":false,\"ImageBitmapRenderingContext\":false,\"ImageCapture\":false,\"ImageData\":false,\"indexedDB\":false,\"innerHeight\":false,\"innerWidth\":false,\"InputEvent\":false,\"IntersectionObserver\":false,\"IntersectionObserverEntry\":false,\"Intl\":false,\"isSecureContext\":false,\"KeyboardEvent\":false,\"KeyframeEffect\":false,\"KeyframeEffectReadOnly\":false,\"length\":false,\"localStorage\":false,\"location\":true,\"Location\":false,\"locationbar\":false,\"matchMedia\":false,\"MediaDeviceInfo\":false,\"MediaDevices\":false,\"MediaElementAudioSourceNode\":false,\"MediaEncryptedEvent\":false,\"MediaError\":false,\"MediaKeyMessageEvent\":false,\"MediaKeySession\":false,\"MediaKeyStatusMap\":false,\"MediaKeySystemAccess\":false,\"MediaList\":false,\"MediaMetadata\":false,\"MediaQueryList\":false,\"MediaQueryListEvent\":false,\"MediaRecorder\":false,\"MediaSettingsRange\":false,\"MediaSource\":false,\"MediaStream\":false,\"MediaStreamAudioDestinationNode\":false,\"MediaStreamAudioSourceNode\":false,\"MediaStreamConstraints\":false,\"MediaStreamEvent\":false,\"MediaStreamTrack\":false,\"MediaStreamTrackEvent\":false,\"menubar\":false,\"MessageChannel\":false,\"MessageEvent\":false,\"MessagePort\":false,\"MIDIAccess\":false,\"MIDIConnectionEvent\":false,\"MIDIInput\":false,\"MIDIInputMap\":false,\"MIDIMessageEvent\":false,\"MIDIOutput\":false,\"MIDIOutputMap\":false,\"MIDIPort\":false,\"MimeType\":false,\"MimeTypeArray\":false,\"MouseEvent\":false,\"moveBy\":false,\"moveTo\":false,\"MutationEvent\":false,\"MutationObserver\":false,\"MutationRecord\":false,\"name\":false,\"NamedNodeMap\":false,\"NavigationPreloadManager\":false,\"navigator\":false,\"Navigator\":false,\"NavigatorUAData\":false,\"NetworkInformation\":false,\"Node\":false,\"NodeFilter\":false,\"NodeIterator\":false,\"NodeList\":false,\"Notification\":false,\"OfflineAudioCompletionEvent\":false,\"OfflineAudioContext\":false,\"offscreenBuffering\":false,\"OffscreenCanvas\":true,\"OffscreenCanvasRenderingContext2D\":false,\"onabort\":true,\"onafterprint\":true,\"onanimationend\":true,\"onanimationiteration\":true,\"onanimationstart\":true,\"onappinstalled\":true,\"onauxclick\":true,\"onbeforeinstallprompt\":true,\"onbeforeprint\":true,\"onbeforeunload\":true,\"onblur\":true,\"oncancel\":true,\"oncanplay\":true,\"oncanplaythrough\":true,\"onchange\":true,\"onclick\":true,\"onclose\":true,\"oncontextmenu\":true,\"oncuechange\":true,\"ondblclick\":true,\"ondevicemotion\":true,\"ondeviceorientation\":true,\"ondeviceorientationabsolute\":true,\"ondrag\":true,\"ondragend\":true,\"ondragenter\":true,\"ondragleave\":true,\"ondragover\":true,\"ondragstart\":true,\"ondrop\":true,\"ondurationchange\":true,\"onemptied\":true,\"onended\":true,\"onerror\":true,\"onfocus\":true,\"ongotpointercapture\":true,\"onhashchange\":true,\"oninput\":true,\"oninvalid\":true,\"onkeydown\":true,\"onkeypress\":true,\"onkeyup\":true,\"onlanguagechange\":true,\"onload\":true,\"onloadeddata\":true,\"onloadedmetadata\":true,\"onloadstart\":true,\"onlostpointercapture\":true,\"onmessage\":true,\"onmessageerror\":true,\"onmousedown\":true,\"onmouseenter\":true,\"onmouseleave\":true,\"onmousemove\":true,\"onmouseout\":true,\"onmouseover\":true,\"onmouseup\":true,\"onmousewheel\":true,\"onoffline\":true,\"ononline\":true,\"onpagehide\":true,\"onpageshow\":true,\"onpause\":true,\"onplay\":true,\"onplaying\":true,\"onpointercancel\":true,\"onpointerdown\":true,\"onpointerenter\":true,\"onpointerleave\":true,\"onpointermove\":true,\"onpointerout\":true,\"onpointerover\":true,\"onpointerup\":true,\"onpopstate\":true,\"onprogress\":true,\"onratechange\":true,\"onrejectionhandled\":true,\"onreset\":true,\"onresize\":true,\"onscroll\":true,\"onsearch\":true,\"onseeked\":true,\"onseeking\":true,\"onselect\":true,\"onstalled\":true,\"onstorage\":true,\"onsubmit\":true,\"onsuspend\":true,\"ontimeupdate\":true,\"ontoggle\":true,\"ontransitionend\":true,\"onunhandledrejection\":true,\"onunload\":true,\"onvolumechange\":true,\"onwaiting\":true,\"onwheel\":true,\"open\":false,\"openDatabase\":false,\"opener\":false,\"Option\":false,\"origin\":false,\"OscillatorNode\":false,\"outerHeight\":false,\"outerWidth\":false,\"OverconstrainedError\":false,\"PageTransitionEvent\":false,\"pageXOffset\":false,\"pageYOffset\":false,\"PannerNode\":false,\"parent\":false,\"Path2D\":false,\"PaymentAddress\":false,\"PaymentRequest\":false,\"PaymentRequestUpdateEvent\":false,\"PaymentResponse\":false,\"performance\":false,\"Performance\":false,\"PerformanceEntry\":false,\"PerformanceLongTaskTiming\":false,\"PerformanceMark\":false,\"PerformanceMeasure\":false,\"PerformanceNavigation\":false,\"PerformanceNavigationTiming\":false,\"PerformanceObserver\":false,\"PerformanceObserverEntryList\":false,\"PerformancePaintTiming\":false,\"PerformanceResourceTiming\":false,\"PerformanceTiming\":false,\"PeriodicWave\":false,\"Permissions\":false,\"PermissionStatus\":false,\"personalbar\":false,\"PhotoCapabilities\":false,\"Plugin\":false,\"PluginArray\":false,\"PointerEvent\":false,\"PopStateEvent\":false,\"postMessage\":false,\"Presentation\":false,\"PresentationAvailability\":false,\"PresentationConnection\":false,\"PresentationConnectionAvailableEvent\":false,\"PresentationConnectionCloseEvent\":false,\"PresentationConnectionList\":false,\"PresentationReceiver\":false,\"PresentationRequest\":false,\"print\":false,\"ProcessingInstruction\":false,\"ProgressEvent\":false,\"PromiseRejectionEvent\":false,\"prompt\":false,\"PushManager\":false,\"PushSubscription\":false,\"PushSubscriptionOptions\":false,\"queueMicrotask\":false,\"RadioNodeList\":false,\"Range\":false,\"ReadableByteStreamController\":false,\"ReadableStream\":false,\"ReadableStreamBYOBReader\":false,\"ReadableStreamBYOBRequest\":false,\"ReadableStreamDefaultController\":false,\"ReadableStreamDefaultReader\":false,\"registerProcessor\":false,\"RemotePlayback\":false,\"removeEventListener\":false,\"reportError\":false,\"Request\":false,\"requestAnimationFrame\":false,\"requestIdleCallback\":false,\"resizeBy\":false,\"ResizeObserver\":false,\"ResizeObserverEntry\":false,\"resizeTo\":false,\"Response\":false,\"RTCCertificate\":false,\"RTCDataChannel\":false,\"RTCDataChannelEvent\":false,\"RTCDtlsTransport\":false,\"RTCIceCandidate\":false,\"RTCIceGatherer\":false,\"RTCIceTransport\":false,\"RTCPeerConnection\":false,\"RTCPeerConnectionIceEvent\":false,\"RTCRtpContributingSource\":false,\"RTCRtpReceiver\":false,\"RTCRtpSender\":false,\"RTCSctpTransport\":false,\"RTCSessionDescription\":false,\"RTCStatsReport\":false,\"RTCTrackEvent\":false,\"screen\":false,\"Screen\":false,\"screenLeft\":false,\"ScreenOrientation\":false,\"screenTop\":false,\"screenX\":false,\"screenY\":false,\"ScriptProcessorNode\":false,\"scroll\":false,\"scrollbars\":false,\"scrollBy\":false,\"scrollTo\":false,\"scrollX\":false,\"scrollY\":false,\"SecurityPolicyViolationEvent\":false,\"Selection\":false,\"self\":false,\"ServiceWorker\":false,\"ServiceWorkerContainer\":false,\"ServiceWorkerRegistration\":false,\"sessionStorage\":false,\"setInterval\":false,\"setTimeout\":false,\"ShadowRoot\":false,\"SharedWorker\":false,\"SourceBuffer\":false,\"SourceBufferList\":false,\"speechSynthesis\":false,\"SpeechSynthesisEvent\":false,\"SpeechSynthesisUtterance\":false,\"StaticRange\":false,\"status\":false,\"statusbar\":false,\"StereoPannerNode\":false,\"stop\":false,\"Storage\":false,\"StorageEvent\":false,\"StorageManager\":false,\"structuredClone\":false,\"styleMedia\":false,\"StyleSheet\":false,\"StyleSheetList\":false,\"SubmitEvent\":false,\"SubtleCrypto\":false,\"SVGAElement\":false,\"SVGAngle\":false,\"SVGAnimatedAngle\":false,\"SVGAnimatedBoolean\":false,\"SVGAnimatedEnumeration\":false,\"SVGAnimatedInteger\":false,\"SVGAnimatedLength\":false,\"SVGAnimatedLengthList\":false,\"SVGAnimatedNumber\":false,\"SVGAnimatedNumberList\":false,\"SVGAnimatedPreserveAspectRatio\":false,\"SVGAnimatedRect\":false,\"SVGAnimatedString\":false,\"SVGAnimatedTransformList\":false,\"SVGAnimateElement\":false,\"SVGAnimateMotionElement\":false,\"SVGAnimateTransformElement\":false,\"SVGAnimationElement\":false,\"SVGCircleElement\":false,\"SVGClipPathElement\":false,\"SVGComponentTransferFunctionElement\":false,\"SVGDefsElement\":false,\"SVGDescElement\":false,\"SVGDiscardElement\":false,\"SVGElement\":false,\"SVGEllipseElement\":false,\"SVGFEBlendElement\":false,\"SVGFEColorMatrixElement\":false,\"SVGFEComponentTransferElement\":false,\"SVGFECompositeElement\":false,\"SVGFEConvolveMatrixElement\":false,\"SVGFEDiffuseLightingElement\":false,\"SVGFEDisplacementMapElement\":false,\"SVGFEDistantLightElement\":false,\"SVGFEDropShadowElement\":false,\"SVGFEFloodElement\":false,\"SVGFEFuncAElement\":false,\"SVGFEFuncBElement\":false,\"SVGFEFuncGElement\":false,\"SVGFEFuncRElement\":false,\"SVGFEGaussianBlurElement\":false,\"SVGFEImageElement\":false,\"SVGFEMergeElement\":false,\"SVGFEMergeNodeElement\":false,\"SVGFEMorphologyElement\":false,\"SVGFEOffsetElement\":false,\"SVGFEPointLightElement\":false,\"SVGFESpecularLightingElement\":false,\"SVGFESpotLightElement\":false,\"SVGFETileElement\":false,\"SVGFETurbulenceElement\":false,\"SVGFilterElement\":false,\"SVGForeignObjectElement\":false,\"SVGGElement\":false,\"SVGGeometryElement\":false,\"SVGGradientElement\":false,\"SVGGraphicsElement\":false,\"SVGImageElement\":false,\"SVGLength\":false,\"SVGLengthList\":false,\"SVGLinearGradientElement\":false,\"SVGLineElement\":false,\"SVGMarkerElement\":false,\"SVGMaskElement\":false,\"SVGMatrix\":false,\"SVGMetadataElement\":false,\"SVGMPathElement\":false,\"SVGNumber\":false,\"SVGNumberList\":false,\"SVGPathElement\":false,\"SVGPatternElement\":false,\"SVGPoint\":false,\"SVGPointList\":false,\"SVGPolygonElement\":false,\"SVGPolylineElement\":false,\"SVGPreserveAspectRatio\":false,\"SVGRadialGradientElement\":false,\"SVGRect\":false,\"SVGRectElement\":false,\"SVGScriptElement\":false,\"SVGSetElement\":false,\"SVGStopElement\":false,\"SVGStringList\":false,\"SVGStyleElement\":false,\"SVGSVGElement\":false,\"SVGSwitchElement\":false,\"SVGSymbolElement\":false,\"SVGTextContentElement\":false,\"SVGTextElement\":false,\"SVGTextPathElement\":false,\"SVGTextPositioningElement\":false,\"SVGTitleElement\":false,\"SVGTransform\":false,\"SVGTransformList\":false,\"SVGTSpanElement\":false,\"SVGUnitTypes\":false,\"SVGUseElement\":false,\"SVGViewElement\":false,\"TaskAttributionTiming\":false,\"Text\":false,\"TextDecoder\":false,\"TextDecoderStream\":false,\"TextEncoder\":false,\"TextEncoderStream\":false,\"TextEvent\":false,\"TextMetrics\":false,\"TextTrack\":false,\"TextTrackCue\":false,\"TextTrackCueList\":false,\"TextTrackList\":false,\"TimeRanges\":false,\"ToggleEvent\":false,\"toolbar\":false,\"top\":false,\"Touch\":false,\"TouchEvent\":false,\"TouchList\":false,\"TrackEvent\":false,\"TransformStream\":false,\"TransformStreamDefaultController\":false,\"TransitionEvent\":false,\"TreeWalker\":false,\"UIEvent\":false,\"URL\":false,\"URLSearchParams\":false,\"ValidityState\":false,\"visualViewport\":false,\"VisualViewport\":false,\"VTTCue\":false,\"WaveShaperNode\":false,\"WebAssembly\":false,\"WebGL2RenderingContext\":false,\"WebGLActiveInfo\":false,\"WebGLBuffer\":false,\"WebGLContextEvent\":false,\"WebGLFramebuffer\":false,\"WebGLProgram\":false,\"WebGLQuery\":false,\"WebGLRenderbuffer\":false,\"WebGLRenderingContext\":false,\"WebGLSampler\":false,\"WebGLShader\":false,\"WebGLShaderPrecisionFormat\":false,\"WebGLSync\":false,\"WebGLTexture\":false,\"WebGLTransformFeedback\":false,\"WebGLUniformLocation\":false,\"WebGLVertexArrayObject\":false,\"WebSocket\":false,\"WheelEvent\":false,\"window\":false,\"Window\":false,\"Worker\":false,\"WritableStream\":false,\"WritableStreamDefaultController\":false,\"WritableStreamDefaultWriter\":false,\"XMLDocument\":false,\"XMLHttpRequest\":false,\"XMLHttpRequestEventTarget\":false,\"XMLHttpRequestUpload\":false,\"XMLSerializer\":false,\"XPathEvaluator\":false,\"XPathExpression\":false,\"XPathResult\":false,\"XRAnchor\":false,\"XRBoundedReferenceSpace\":false,\"XRCPUDepthInformation\":false,\"XRDepthInformation\":false,\"XRFrame\":false,\"XRInputSource\":false,\"XRInputSourceArray\":false,\"XRInputSourceEvent\":false,\"XRInputSourcesChangeEvent\":false,\"XRPose\":false,\"XRReferenceSpace\":false,\"XRReferenceSpaceEvent\":false,\"XRRenderState\":false,\"XRRigidTransform\":false,\"XRSession\":false,\"XRSessionEvent\":false,\"XRSpace\":false,\"XRSystem\":false,\"XRView\":false,\"XRViewerPose\":false,\"XRViewport\":false,\"XRWebGLBinding\":false,\"XRWebGLDepthInformation\":false,\"XRWebGLLayer\":false,\"XSLTProcessor\":false}");
+	worker = {
+		"addEventListener": false,
+		"applicationCache": false,
+		"atob": false,
+		"Blob": false,
+		"BroadcastChannel": false,
+		"btoa": false,
+		"ByteLengthQueuingStrategy": false,
+		"Cache": false,
+		"caches": false,
+		"clearInterval": false,
+		"clearTimeout": false,
+		"close": true,
+		"CompressionStream": false,
+		"console": false,
+		"CountQueuingStrategy": false,
+		"crypto": false,
+		"Crypto": false,
+		"CryptoKey": false,
+		"CustomEvent": false,
+		"DecompressionStream": false,
+		"ErrorEvent": false,
+		"Event": false,
+		"fetch": false,
+		"File": false,
+		"FileReaderSync": false,
+		"FormData": false,
+		"Headers": false,
+		"IDBCursor": false,
+		"IDBCursorWithValue": false,
+		"IDBDatabase": false,
+		"IDBFactory": false,
+		"IDBIndex": false,
+		"IDBKeyRange": false,
+		"IDBObjectStore": false,
+		"IDBOpenDBRequest": false,
+		"IDBRequest": false,
+		"IDBTransaction": false,
+		"IDBVersionChangeEvent": false,
+		"ImageData": false,
+		"importScripts": true,
+		"indexedDB": false,
+		"location": false,
+		"MessageChannel": false,
+		"MessageEvent": false,
+		"MessagePort": false,
+		"name": false,
+		"navigator": false,
+		"Notification": false,
+		"onclose": true,
+		"onconnect": true,
+		"onerror": true,
+		"onlanguagechange": true,
+		"onmessage": true,
+		"onoffline": true,
+		"ononline": true,
+		"onrejectionhandled": true,
+		"onunhandledrejection": true,
+		"performance": false,
+		"Performance": false,
+		"PerformanceEntry": false,
+		"PerformanceMark": false,
+		"PerformanceMeasure": false,
+		"PerformanceNavigation": false,
+		"PerformanceObserver": false,
+		"PerformanceObserverEntryList": false,
+		"PerformanceResourceTiming": false,
+		"PerformanceTiming": false,
+		"postMessage": true,
+		"Promise": false,
+		"queueMicrotask": false,
+		"ReadableByteStreamController": false,
+		"ReadableStream": false,
+		"ReadableStreamBYOBReader": false,
+		"ReadableStreamBYOBRequest": false,
+		"ReadableStreamDefaultController": false,
+		"ReadableStreamDefaultReader": false,
+		"removeEventListener": false,
+		"reportError": false,
+		"Request": false,
+		"Response": false,
+		"self": true,
+		"ServiceWorkerRegistration": false,
+		"setInterval": false,
+		"setTimeout": false,
+		"SubtleCrypto": false,
+		"TextDecoder": false,
+		"TextDecoderStream": false,
+		"TextEncoder": false,
+		"TextEncoderStream": false,
+		"TransformStream": false,
+		"TransformStreamDefaultController": false,
+		"URL": false,
+		"URLSearchParams": false,
+		"WebAssembly": false,
+		"WebSocket": false,
+		"Worker": false,
+		"WorkerGlobalScope": false,
+		"WritableStream": false,
+		"WritableStreamDefaultController": false,
+		"WritableStreamDefaultWriter": false,
+		"XMLHttpRequest": false
+	};
+	node = {
+		"__dirname": false,
+		"__filename": false,
+		"AbortController": false,
+		"AbortSignal": false,
+		"atob": false,
+		"Blob": false,
+		"BroadcastChannel": false,
+		"btoa": false,
+		"Buffer": false,
+		"ByteLengthQueuingStrategy": false,
+		"clearImmediate": false,
+		"clearInterval": false,
+		"clearTimeout": false,
+		"CompressionStream": false,
+		"console": false,
+		"CountQueuingStrategy": false,
+		"crypto": false,
+		"Crypto": false,
+		"CryptoKey": false,
+		"CustomEvent": false,
+		"DecompressionStream": false,
+		"DOMException": false,
+		"Event": false,
+		"EventTarget": false,
+		"exports": true,
+		"fetch": false,
+		"File": false,
+		"FormData": false,
+		"global": false,
+		"Headers": false,
+		"Intl": false,
+		"MessageChannel": false,
+		"MessageEvent": false,
+		"MessagePort": false,
+		"module": false,
+		"performance": false,
+		"PerformanceEntry": false,
+		"PerformanceMark": false,
+		"PerformanceMeasure": false,
+		"PerformanceObserver": false,
+		"PerformanceObserverEntryList": false,
+		"PerformanceResourceTiming": false,
+		"process": false,
+		"queueMicrotask": false,
+		"ReadableByteStreamController": false,
+		"ReadableStream": false,
+		"ReadableStreamBYOBReader": false,
+		"ReadableStreamBYOBRequest": false,
+		"ReadableStreamDefaultController": false,
+		"ReadableStreamDefaultReader": false,
+		"Request": false,
+		"require": false,
+		"Response": false,
+		"setImmediate": false,
+		"setInterval": false,
+		"setTimeout": false,
+		"structuredClone": false,
+		"SubtleCrypto": false,
+		"TextDecoder": false,
+		"TextDecoderStream": false,
+		"TextEncoder": false,
+		"TextEncoderStream": false,
+		"TransformStream": false,
+		"TransformStreamDefaultController": false,
+		"URL": false,
+		"URLSearchParams": false,
+		"WebAssembly": false,
+		"WritableStream": false,
+		"WritableStreamDefaultController": false,
+		"WritableStreamDefaultWriter": false
+	};
+	nodeBuiltin = {
+		"AbortController": false,
+		"AbortSignal": false,
+		"atob": false,
+		"Blob": false,
+		"BroadcastChannel": false,
+		"btoa": false,
+		"Buffer": false,
+		"ByteLengthQueuingStrategy": false,
+		"clearImmediate": false,
+		"clearInterval": false,
+		"clearTimeout": false,
+		"CompressionStream": false,
+		"console": false,
+		"CountQueuingStrategy": false,
+		"crypto": false,
+		"Crypto": false,
+		"CryptoKey": false,
+		"CustomEvent": false,
+		"DecompressionStream": false,
+		"DOMException": false,
+		"Event": false,
+		"EventTarget": false,
+		"fetch": false,
+		"File": false,
+		"FormData": false,
+		"global": false,
+		"Headers": false,
+		"Intl": false,
+		"MessageChannel": false,
+		"MessageEvent": false,
+		"MessagePort": false,
+		"performance": false,
+		"PerformanceEntry": false,
+		"PerformanceMark": false,
+		"PerformanceMeasure": false,
+		"PerformanceObserver": false,
+		"PerformanceObserverEntryList": false,
+		"PerformanceResourceTiming": false,
+		"process": false,
+		"queueMicrotask": false,
+		"ReadableByteStreamController": false,
+		"ReadableStream": false,
+		"ReadableStreamBYOBReader": false,
+		"ReadableStreamBYOBRequest": false,
+		"ReadableStreamDefaultController": false,
+		"ReadableStreamDefaultReader": false,
+		"Request": false,
+		"Response": false,
+		"setImmediate": false,
+		"setInterval": false,
+		"setTimeout": false,
+		"structuredClone": false,
+		"SubtleCrypto": false,
+		"TextDecoder": false,
+		"TextDecoderStream": false,
+		"TextEncoder": false,
+		"TextEncoderStream": false,
+		"TransformStream": false,
+		"TransformStreamDefaultController": false,
+		"URL": false,
+		"URLSearchParams": false,
+		"WebAssembly": false,
+		"WritableStream": false,
+		"WritableStreamDefaultController": false,
+		"WritableStreamDefaultWriter": false
+	};
+	commonjs = {
+		"exports": true,
+		"global": false,
+		"module": false,
+		"require": false
+	};
+	amd = {
+		"define": false,
+		"require": false
+	};
+	mocha = {
+		"after": false,
+		"afterEach": false,
+		"before": false,
+		"beforeEach": false,
+		"context": false,
+		"describe": false,
+		"it": false,
+		"mocha": false,
+		"run": false,
+		"setup": false,
+		"specify": false,
+		"suite": false,
+		"suiteSetup": false,
+		"suiteTeardown": false,
+		"teardown": false,
+		"test": false,
+		"xcontext": false,
+		"xdescribe": false,
+		"xit": false,
+		"xspecify": false
+	};
+	jasmine = {
+		"afterAll": false,
+		"afterEach": false,
+		"beforeAll": false,
+		"beforeEach": false,
+		"describe": false,
+		"expect": false,
+		"expectAsync": false,
+		"fail": false,
+		"fdescribe": false,
+		"fit": false,
+		"it": false,
+		"jasmine": false,
+		"pending": false,
+		"runs": false,
+		"spyOn": false,
+		"spyOnAllFunctions": false,
+		"spyOnProperty": false,
+		"waits": false,
+		"waitsFor": false,
+		"xdescribe": false,
+		"xit": false
+	};
+	jest = {
+		"afterAll": false,
+		"afterEach": false,
+		"beforeAll": false,
+		"beforeEach": false,
+		"describe": false,
+		"expect": false,
+		"fdescribe": false,
+		"fit": false,
+		"it": false,
+		"jest": false,
+		"pit": false,
+		"require": false,
+		"test": false,
+		"xdescribe": false,
+		"xit": false,
+		"xtest": false
+	};
+	qunit = {
+		"asyncTest": false,
+		"deepEqual": false,
+		"equal": false,
+		"expect": false,
+		"module": false,
+		"notDeepEqual": false,
+		"notEqual": false,
+		"notOk": false,
+		"notPropEqual": false,
+		"notStrictEqual": false,
+		"ok": false,
+		"propEqual": false,
+		"QUnit": false,
+		"raises": false,
+		"start": false,
+		"stop": false,
+		"strictEqual": false,
+		"test": false,
+		"throws": false
+	};
+	phantomjs = {
+		"console": true,
+		"exports": true,
+		"phantom": true,
+		"require": true,
+		"WebPage": true
+	};
+	couch = {
+		"emit": false,
+		"exports": false,
+		"getRow": false,
+		"log": false,
+		"module": false,
+		"provides": false,
+		"require": false,
+		"respond": false,
+		"send": false,
+		"start": false,
+		"sum": false
+	};
+	rhino = {
+		"defineClass": false,
+		"deserialize": false,
+		"gc": false,
+		"help": false,
+		"importClass": false,
+		"importPackage": false,
+		"java": false,
+		"load": false,
+		"loadClass": false,
+		"Packages": false,
+		"print": false,
+		"quit": false,
+		"readFile": false,
+		"readUrl": false,
+		"runCommand": false,
+		"seal": false,
+		"serialize": false,
+		"spawn": false,
+		"sync": false,
+		"toint32": false,
+		"version": false
+	};
+	nashorn = {
+		"__DIR__": false,
+		"__FILE__": false,
+		"__LINE__": false,
+		"com": false,
+		"edu": false,
+		"exit": false,
+		"java": false,
+		"Java": false,
+		"javafx": false,
+		"JavaImporter": false,
+		"javax": false,
+		"JSAdapter": false,
+		"load": false,
+		"loadWithNewGlobal": false,
+		"org": false,
+		"Packages": false,
+		"print": false,
+		"quit": false
+	};
+	wsh = {
+		"ActiveXObject": false,
+		"CollectGarbage": false,
+		"Debug": false,
+		"Enumerator": false,
+		"GetObject": false,
+		"RuntimeObject": false,
+		"ScriptEngine": false,
+		"ScriptEngineBuildVersion": false,
+		"ScriptEngineMajorVersion": false,
+		"ScriptEngineMinorVersion": false,
+		"VBArray": false,
+		"WScript": false,
+		"WSH": false
+	};
+	jquery = {
+		"$": false,
+		"jQuery": false
+	};
+	yui = {
+		"YAHOO": false,
+		"YAHOO_config": false,
+		"YUI": false,
+		"YUI_config": false
+	};
+	shelljs = {
+		"cat": false,
+		"cd": false,
+		"chmod": false,
+		"config": false,
+		"cp": false,
+		"dirs": false,
+		"echo": false,
+		"env": false,
+		"error": false,
+		"exec": false,
+		"exit": false,
+		"find": false,
+		"grep": false,
+		"ln": false,
+		"ls": false,
+		"mkdir": false,
+		"mv": false,
+		"popd": false,
+		"pushd": false,
+		"pwd": false,
+		"rm": false,
+		"sed": false,
+		"set": false,
+		"target": false,
+		"tempdir": false,
+		"test": false,
+		"touch": false,
+		"which": false
+	};
+	prototypejs = {
+		"$": false,
+		"$$": false,
+		"$A": false,
+		"$break": false,
+		"$continue": false,
+		"$F": false,
+		"$H": false,
+		"$R": false,
+		"$w": false,
+		"Abstract": false,
+		"Ajax": false,
+		"Autocompleter": false,
+		"Builder": false,
+		"Class": false,
+		"Control": false,
+		"Draggable": false,
+		"Draggables": false,
+		"Droppables": false,
+		"Effect": false,
+		"Element": false,
+		"Enumerable": false,
+		"Event": false,
+		"Field": false,
+		"Form": false,
+		"Hash": false,
+		"Insertion": false,
+		"ObjectRange": false,
+		"PeriodicalExecuter": false,
+		"Position": false,
+		"Prototype": false,
+		"Scriptaculous": false,
+		"Selector": false,
+		"Sortable": false,
+		"SortableObserver": false,
+		"Sound": false,
+		"Template": false,
+		"Toggle": false,
+		"Try": false
+	};
+	meteor = {
+		"$": false,
+		"Accounts": false,
+		"AccountsClient": false,
+		"AccountsCommon": false,
+		"AccountsServer": false,
+		"App": false,
+		"Assets": false,
+		"Blaze": false,
+		"check": false,
+		"Cordova": false,
+		"DDP": false,
+		"DDPRateLimiter": false,
+		"DDPServer": false,
+		"Deps": false,
+		"EJSON": false,
+		"Email": false,
+		"HTTP": false,
+		"Log": false,
+		"Match": false,
+		"Meteor": false,
+		"Mongo": false,
+		"MongoInternals": false,
+		"Npm": false,
+		"Package": false,
+		"Plugin": false,
+		"process": false,
+		"Random": false,
+		"ReactiveDict": false,
+		"ReactiveVar": false,
+		"Router": false,
+		"ServiceConfiguration": false,
+		"Session": false,
+		"share": false,
+		"Spacebars": false,
+		"Template": false,
+		"Tinytest": false,
+		"Tracker": false,
+		"UI": false,
+		"Utils": false,
+		"WebApp": false,
+		"WebAppInternals": false
+	};
+	mongo = {
+		"_isWindows": false,
+		"_rand": false,
+		"BulkWriteResult": false,
+		"cat": false,
+		"cd": false,
+		"connect": false,
+		"db": false,
+		"getHostName": false,
+		"getMemInfo": false,
+		"hostname": false,
+		"ISODate": false,
+		"listFiles": false,
+		"load": false,
+		"ls": false,
+		"md5sumFile": false,
+		"mkdir": false,
+		"Mongo": false,
+		"NumberInt": false,
+		"NumberLong": false,
+		"ObjectId": false,
+		"PlanCache": false,
+		"print": false,
+		"printjson": false,
+		"pwd": false,
+		"quit": false,
+		"removeFile": false,
+		"rs": false,
+		"sh": false,
+		"UUID": false,
+		"version": false,
+		"WriteResult": false
+	};
+	applescript = {
+		"$": false,
+		"Application": false,
+		"Automation": false,
+		"console": false,
+		"delay": false,
+		"Library": false,
+		"ObjC": false,
+		"ObjectSpecifier": false,
+		"Path": false,
+		"Progress": false,
+		"Ref": false
+	};
+	serviceworker = {
+		"addEventListener": false,
+		"applicationCache": false,
+		"atob": false,
+		"Blob": false,
+		"BroadcastChannel": false,
+		"btoa": false,
+		"ByteLengthQueuingStrategy": false,
+		"Cache": false,
+		"caches": false,
+		"CacheStorage": false,
+		"clearInterval": false,
+		"clearTimeout": false,
+		"Client": false,
+		"clients": false,
+		"Clients": false,
+		"close": true,
+		"CompressionStream": false,
+		"console": false,
+		"CountQueuingStrategy": false,
+		"crypto": false,
+		"Crypto": false,
+		"CryptoKey": false,
+		"CustomEvent": false,
+		"DecompressionStream": false,
+		"ErrorEvent": false,
+		"Event": false,
+		"ExtendableEvent": false,
+		"ExtendableMessageEvent": false,
+		"fetch": false,
+		"FetchEvent": false,
+		"File": false,
+		"FileReaderSync": false,
+		"FormData": false,
+		"Headers": false,
+		"IDBCursor": false,
+		"IDBCursorWithValue": false,
+		"IDBDatabase": false,
+		"IDBFactory": false,
+		"IDBIndex": false,
+		"IDBKeyRange": false,
+		"IDBObjectStore": false,
+		"IDBOpenDBRequest": false,
+		"IDBRequest": false,
+		"IDBTransaction": false,
+		"IDBVersionChangeEvent": false,
+		"ImageData": false,
+		"importScripts": false,
+		"indexedDB": false,
+		"location": false,
+		"MessageChannel": false,
+		"MessageEvent": false,
+		"MessagePort": false,
+		"name": false,
+		"navigator": false,
+		"Notification": false,
+		"onclose": true,
+		"onconnect": true,
+		"onerror": true,
+		"onfetch": true,
+		"oninstall": true,
+		"onlanguagechange": true,
+		"onmessage": true,
+		"onmessageerror": true,
+		"onnotificationclick": true,
+		"onnotificationclose": true,
+		"onoffline": true,
+		"ononline": true,
+		"onpush": true,
+		"onpushsubscriptionchange": true,
+		"onrejectionhandled": true,
+		"onsync": true,
+		"onunhandledrejection": true,
+		"performance": false,
+		"Performance": false,
+		"PerformanceEntry": false,
+		"PerformanceMark": false,
+		"PerformanceMeasure": false,
+		"PerformanceNavigation": false,
+		"PerformanceObserver": false,
+		"PerformanceObserverEntryList": false,
+		"PerformanceResourceTiming": false,
+		"PerformanceTiming": false,
+		"postMessage": true,
+		"Promise": false,
+		"queueMicrotask": false,
+		"ReadableByteStreamController": false,
+		"ReadableStream": false,
+		"ReadableStreamBYOBReader": false,
+		"ReadableStreamBYOBRequest": false,
+		"ReadableStreamDefaultController": false,
+		"ReadableStreamDefaultReader": false,
+		"registration": false,
+		"removeEventListener": false,
+		"Request": false,
+		"Response": false,
+		"self": false,
+		"ServiceWorker": false,
+		"ServiceWorkerContainer": false,
+		"ServiceWorkerGlobalScope": false,
+		"ServiceWorkerMessageEvent": false,
+		"ServiceWorkerRegistration": false,
+		"setInterval": false,
+		"setTimeout": false,
+		"skipWaiting": false,
+		"SubtleCrypto": false,
+		"TextDecoder": false,
+		"TextDecoderStream": false,
+		"TextEncoder": false,
+		"TextEncoderStream": false,
+		"TransformStream": false,
+		"TransformStreamDefaultController": false,
+		"URL": false,
+		"URLSearchParams": false,
+		"WebAssembly": false,
+		"WebSocket": false,
+		"WindowClient": false,
+		"Worker": false,
+		"WorkerGlobalScope": false,
+		"WritableStream": false,
+		"WritableStreamDefaultController": false,
+		"WritableStreamDefaultWriter": false,
+		"XMLHttpRequest": false
+	};
+	atomtest = {
+		"advanceClock": false,
+		"atom": false,
+		"fakeClearInterval": false,
+		"fakeClearTimeout": false,
+		"fakeSetInterval": false,
+		"fakeSetTimeout": false,
+		"resetTimeouts": false,
+		"waitsForPromise": false
+	};
+	embertest = {
+		"andThen": false,
+		"click": false,
+		"currentPath": false,
+		"currentRouteName": false,
+		"currentURL": false,
+		"fillIn": false,
+		"find": false,
+		"findAll": false,
+		"findWithAssert": false,
+		"keyEvent": false,
+		"pauseTest": false,
+		"resumeTest": false,
+		"triggerEvent": false,
+		"visit": false,
+		"wait": false
+	};
+	protractor = {
+		"$": false,
+		"$$": false,
+		"browser": false,
+		"by": false,
+		"By": false,
+		"DartObject": false,
+		"element": false,
+		"protractor": false
+	};
+	webextensions = {
+		"browser": false,
+		"chrome": false,
+		"opr": false
+	};
+	greasemonkey = {
+		"cloneInto": false,
+		"createObjectIn": false,
+		"exportFunction": false,
+		"GM": false,
+		"GM_addElement": false,
+		"GM_addStyle": false,
+		"GM_addValueChangeListener": false,
+		"GM_deleteValue": false,
+		"GM_download": false,
+		"GM_getResourceText": false,
+		"GM_getResourceURL": false,
+		"GM_getTab": false,
+		"GM_getTabs": false,
+		"GM_getValue": false,
+		"GM_info": false,
+		"GM_listValues": false,
+		"GM_log": false,
+		"GM_notification": false,
+		"GM_openInTab": false,
+		"GM_registerMenuCommand": false,
+		"GM_removeValueChangeListener": false,
+		"GM_saveTab": false,
+		"GM_setClipboard": false,
+		"GM_setValue": false,
+		"GM_unregisterMenuCommand": false,
+		"GM_xmlhttpRequest": false,
+		"unsafeWindow": false
+	};
+	devtools = {
+		"$": false,
+		"$_": false,
+		"$$": false,
+		"$0": false,
+		"$1": false,
+		"$2": false,
+		"$3": false,
+		"$4": false,
+		"$x": false,
+		"chrome": false,
+		"clear": false,
+		"copy": false,
+		"debug": false,
+		"dir": false,
+		"dirxml": false,
+		"getEventListeners": false,
+		"inspect": false,
+		"keys": false,
+		"monitor": false,
+		"monitorEvents": false,
+		"profile": false,
+		"profileEnd": false,
+		"queryObjects": false,
+		"table": false,
+		"undebug": false,
+		"unmonitor": false,
+		"unmonitorEvents": false,
+		"values": false
+	};
+	globals_default = {
+		builtin,
+		es5,
+		es2015,
+		es2017,
+		es2020,
+		es2021,
+		browser,
+		worker,
+		node,
+		nodeBuiltin,
+		commonjs,
+		amd,
+		mocha,
+		jasmine,
+		jest,
+		qunit,
+		phantomjs,
+		couch,
+		rhino,
+		nashorn,
+		wsh,
+		jquery,
+		yui,
+		shelljs,
+		prototypejs,
+		meteor,
+		mongo,
+		applescript,
+		serviceworker,
+		atomtest,
+		embertest,
+		protractor,
+		"shared-node-browser": {
+			"AbortController": false,
+			"AbortSignal": false,
+			"atob": false,
+			"Blob": false,
+			"BroadcastChannel": false,
+			"btoa": false,
+			"ByteLengthQueuingStrategy": false,
+			"clearInterval": false,
+			"clearTimeout": false,
+			"CompressionStream": false,
+			"console": false,
+			"CountQueuingStrategy": false,
+			"crypto": false,
+			"Crypto": false,
+			"CryptoKey": false,
+			"CustomEvent": false,
+			"DecompressionStream": false,
+			"DOMException": false,
+			"Event": false,
+			"EventTarget": false,
+			"fetch": false,
+			"File": false,
+			"FormData": false,
+			"Headers": false,
+			"Intl": false,
+			"MessageChannel": false,
+			"MessageEvent": false,
+			"MessagePort": false,
+			"performance": false,
+			"PerformanceEntry": false,
+			"PerformanceMark": false,
+			"PerformanceMeasure": false,
+			"PerformanceObserver": false,
+			"PerformanceObserverEntryList": false,
+			"PerformanceResourceTiming": false,
+			"queueMicrotask": false,
+			"ReadableByteStreamController": false,
+			"ReadableStream": false,
+			"ReadableStreamBYOBReader": false,
+			"ReadableStreamBYOBRequest": false,
+			"ReadableStreamDefaultController": false,
+			"ReadableStreamDefaultReader": false,
+			"Request": false,
+			"Response": false,
+			"setInterval": false,
+			"setTimeout": false,
+			"structuredClone": false,
+			"SubtleCrypto": false,
+			"TextDecoder": false,
+			"TextDecoderStream": false,
+			"TextEncoder": false,
+			"TextEncoderStream": false,
+			"TransformStream": false,
+			"TransformStreamDefaultController": false,
+			"URL": false,
+			"URLSearchParams": false,
+			"WebAssembly": false,
+			"WritableStream": false,
+			"WritableStreamDefaultController": false,
+			"WritableStreamDefaultWriter": false
+		},
+		webextensions,
+		greasemonkey,
+		devtools
+	};
+}));
+var unicornRules = {
+	languageOptions: { globals: { ...(/* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+		module.exports = (init_globals(), __toCommonJS(globals_exports).default);
+	})))())).default.builtin } },
+	plugins: { unicorn: eslintPluginUnicorn },
+	rules: {
+		"unicorn/better-regex": "error",
+		"unicorn/catch-error-name": "error",
+		"unicorn/consistent-date-clone": "error",
+		"unicorn/consistent-destructuring": "error",
+		"unicorn/escape-case": "error",
+		"unicorn/no-array-for-each": "error",
+		"unicorn/no-array-reduce": "error",
+		"unicorn/no-await-in-promise-methods": "error",
+		"unicorn/no-invalid-remove-event-listener": "error",
+		"unicorn/no-new-array": "error",
+		"unicorn/no-new-buffer": "error",
+		"unicorn/no-object-as-default-parameter": "error",
+		"unicorn/no-single-promise-in-promise-methods": "error",
+		"unicorn/no-unnecessary-await": "error",
+		"unicorn/no-unreadable-iife": "error",
+		"unicorn/no-useless-collection-argument": "error",
+		"unicorn/no-useless-error-capture-stack-trace": "error",
+		"unicorn/no-useless-fallback-in-spread": "error",
+		"unicorn/no-useless-promise-resolve-reject": "error",
+		"unicorn/no-useless-spread": "error",
+		"unicorn/no-useless-switch-case": "error",
+		"unicorn/number-literal-case": "error",
+		"unicorn/numeric-separators-style": "error",
+		"unicorn/prefer-array-find": "error",
+		"unicorn/prefer-array-flat": "error",
+		"unicorn/prefer-array-flat-map": "error",
+		"unicorn/prefer-array-index-of": "error",
+		"unicorn/prefer-array-some": "error",
+		"unicorn/prefer-bigint-literals": "error",
+		"unicorn/prefer-blob-reading-methods": "error",
+		"unicorn/prefer-date-now": "error",
+		"unicorn/prefer-import-meta-properties": "error",
+		"unicorn/prefer-includes": "error",
+		"unicorn/prefer-logical-operator-over-ternary": "error",
+		"unicorn/prefer-number-properties": "error",
+		"unicorn/prefer-object-from-entries": "error",
+		"unicorn/prefer-optional-catch-binding": "error",
+		"unicorn/prefer-prototype-methods": "error",
+		"unicorn/prefer-response-static-json": "error",
+		"unicorn/prefer-set-has": "error",
+		"unicorn/prefer-set-size": "error",
+		"unicorn/prefer-string-raw": "error",
+		"unicorn/prefer-string-replace-all": "error",
+		"unicorn/prefer-string-starts-ends-with": "error",
+		"unicorn/prefer-string-trim-start-end": "error",
+		"unicorn/prefer-structured-clone": "error",
+		"unicorn/prefer-switch": "error",
+		"unicorn/require-module-attributes": "error",
+		"unicorn/require-module-specifiers": "error",
+		"unicorn/template-indent": "error"
+	}
+};
+//#endregion
+//#region src/index.ts
+/**
+* The ESLint flat config used by Borela Tech projects.
+* @public
+*/
+var config = [
+	ignores,
+	languageOptions,
+	eslint.configs.recommended,
+	react.configs.flat.recommended,
+	stylistic.configs.recommended,
+	...typescript.configs.recommended,
+	...typescript.configs.stylistic,
+	customRules,
+	generalRules,
+	perfectionistRules,
+	reactHooks,
+	stylisticRules,
+	typescriptRules,
+	unicornRules
+];
+//#endregion
+export { config };
+
+//# sourceMappingURL=index.esm.js.map