@borela-tech/eslint-config 2.2.2 → 2.4.0

package/dist/index.mjs

@@ -1,872 +1,3925 @@
 import eslint from "@eslint/js";
 import react from "eslint-plugin-react";
-import reactHooks from "eslint-plugin-react-hooks";
 import stylistic from "@stylistic/eslint-plugin";
 import typescript from "typescript-eslint";
-//#region src/rules/importsAndReExportsAtTop/getStatementType.ts
+import * as path from "path";
+import perfectionist from "eslint-plugin-perfectionist";
+import rule from "eslint-plugin-react-hooks";
+import eslintPluginUnicorn from "eslint-plugin-unicorn";
+function getLineIndent$1(sourceCode, line) {
+  const text = sourceCode.getText();
+  const lines = text.split("\n");
+  const lineText = lines[line - 1] ?? "";
+  const match = lineText.match(/^(\s*)/);
+  return match?.[1] ?? "";
+}
+function buildMultilineFix$1(fixer, brackets, elements, sourceCode) {
+  const openingLine = brackets.openingBracket.loc.start.line;
+  const baseIndent = getLineIndent$1(sourceCode, openingLine);
+  const itemIndent = baseIndent + "  ";
+  const nonNullElements = elements.filter((el) => el !== null);
+  const formattedItems = nonNullElements.map((element) => {
+    const text = sourceCode.getText(element);
+    return `${itemIndent}${text}`;
+  }).join(",\n");
+  const newText = `
+${formattedItems},
+${baseIndent}`;
+  return fixer.replaceTextRange(
+    [brackets.openingBracket.range[1], brackets.closingBracket.range[0]],
+    newText
+  );
+}
+const defaultOptions$6 = {
+  maxLength: 80
+};
+function getBrackets(sourceCode, node2) {
+  const elements = node2.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 };
+}
+function getLineLength(sourceCode, lineNumber) {
+  const line = sourceCode.getLines()[lineNumber - 1];
+  return line?.length ?? 0;
+}
+function checkArray(sourceCode, context, node2) {
+  const options = context.options[0] ?? {};
+  const maxLength = options.maxLength ?? defaultOptions$6.maxLength;
+  const elements = node2.elements;
+  if (elements.length <= 1)
+    return;
+  const brackets = getBrackets(sourceCode, node2);
+  if (!brackets)
+    return;
+  const firstLine = brackets.openingBracket.loc.start.line;
+  const lastLine = brackets.closingBracket.loc.end.line;
+  if (firstLine !== lastLine)
+    return;
+  const lineLength = getLineLength(sourceCode, firstLine);
+  if (lineLength <= maxLength)
+    return;
+  context.report({
+    fix: (fixer) => buildMultilineFix$1(
+      fixer,
+      brackets,
+      elements,
+      sourceCode
+    ),
+    messageId: "arrayItemsOnNewLine",
+    node: elements[0]
+  });
+}
+const messageIds$d = {
+  arrayItemsOnNewLine: "arrayItemsOnNewLine"
+};
+const arrayItemsLineBreak = {
+  create(context) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    return {
+      ArrayExpression(node2) {
+        checkArray(sourceCode, context, node2);
+      }
+    };
+  },
+  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: messageIds$d,
+    schema: [{
+      additionalProperties: false,
+      properties: {
+        maxLength: {
+          type: "number"
+        }
+      },
+      type: "object"
+    }],
+    type: "layout"
+  }
+};
+function getIndentation(node2, sourceCode) {
+  const tokenBeforeBody = sourceCode.getTokenBefore(node2);
+  if (!tokenBeforeBody)
+    return "";
+  const line = sourceCode.getText().split("\n")[tokenBeforeBody.loc.start.line - 1];
+  if (!line)
+    return "";
+  const match = line.match(/^(\s*)/);
+  return match?.[1] ?? "";
+}
+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 = `{
+${indentation}  ${bodyText}
+${indentation}}`;
+  return fixer.replaceText(body, fixedText);
+}
+function isOnSameLineAsCondition(node2, sourceCode) {
+  const tokenBeforeBody = sourceCode.getTokenBefore(node2);
+  if (!tokenBeforeBody)
+    return false;
+  const firstToken = sourceCode.getFirstToken(node2);
+  if (!firstToken)
+    return false;
+  return tokenBeforeBody.loc.end.line === firstToken.loc.start.line;
+}
+function isSingleLineStatement$1(node2, sourceCode) {
+  const firstToken = sourceCode.getFirstToken(node2);
+  if (!firstToken)
+    return false;
+  const lastToken = sourceCode.getLastToken(node2);
+  if (!lastToken)
+    return false;
+  return firstToken.loc.start.line === lastToken.loc.end.line;
+}
+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$1(body, sourceCode);
+    if (isOnSameLine && isSingleLine) {
+      context.report({
+        fix: (fixer) => createBraceStyleFix(fixer, body, sourceCode),
+        messageId: "singleLine",
+        node: body
+      });
+    }
+  }
+}
+function checkDoWhileStatementBraceStyle(node2, context) {
+  reportBodyOnSameLineAsCondition(context, node2.body);
+}
+function checkForStatementBraceStyle(node2, context) {
+  reportBodyOnSameLineAsCondition(context, node2.body);
+}
+function checkIfStatementBraceStyle(node2, context) {
+  const sourceCode = context.sourceCode;
+  reportBodyOnSameLineAsCondition(context, node2.consequent);
+  if (!node2.alternate)
+    return;
+  if (node2.alternate.type === "BlockStatement") {
+    reportBodyOnSameLineAsCondition(context, node2.alternate);
+    return;
+  }
+  if (node2.alternate.type !== "IfStatement") {
+    const alternate = node2.alternate;
+    if (isOnSameLineAsCondition(alternate, sourceCode)) {
+      context.report({
+        fix: (fixer) => createBraceStyleFix(fixer, alternate, sourceCode),
+        messageId: "singleLine",
+        node: alternate
+      });
+    }
+  }
+}
+function checkWhileStatementBraceStyle(node2, context) {
+  reportBodyOnSameLineAsCondition(context, node2.body);
+}
+const braceStyleControlStatements = {
+  create(context) {
+    return {
+      DoWhileStatement: (node2) => checkDoWhileStatementBraceStyle(node2, context),
+      ForStatement: (node2) => checkForStatementBraceStyle(node2, context),
+      IfStatement: (node2) => checkIfStatementBraceStyle(node2, context),
+      WhileStatement: (node2) => checkWhileStatementBraceStyle(node2, 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"
+  }
+};
+function checkClosingBrace(sourceCode, context, node2, closingBrace) {
+  const lastProperty = node2.properties[node2.properties.length - 1];
+  const closingLine = closingBrace.loc.end.line;
+  const closingBraceOnOwnLine = lastProperty.loc.end.line < closingLine;
+  if (!closingBraceOnOwnLine) {
+    context.report({
+      fix(fixer) {
+        return fixer.replaceTextRange(
+          [lastProperty.range[1], closingBrace.range[0]],
+          ",\n" + getLineIndent$1(sourceCode, lastProperty.loc.end.line)
+        );
+      },
+      loc: closingBrace.loc,
+      messageId: "braceOnPropertyLine"
+    });
+  }
+}
+function checkNestedObjects(sourceCode, context, node2, checkObjectExpression2) {
+  for (const property of node2.properties) {
+    if (property.type === "Property" && property.value.type === "ObjectExpression")
+      checkObjectExpression2(sourceCode, context, property.value);
+    else if (property.type === "SpreadElement" && property.argument.type === "ObjectExpression")
+      checkObjectExpression2(sourceCode, context, property.argument);
+  }
+}
+function checkOpeningBrace(sourceCode, context, node2, openingBrace) {
+  const firstProperty = node2.properties[0];
+  const openingLine = openingBrace.loc.start.line;
+  const openingBraceOnOwnLine = firstProperty.loc.start.line > openingLine;
+  if (!openingBraceOnOwnLine) {
+    context.report({
+      fix(fixer) {
+        return fixer.replaceTextRange(
+          [openingBrace.range[1], firstProperty.range[0]],
+          "\n" + getLineIndent$1(sourceCode, firstProperty.loc.start.line)
+        );
+      },
+      loc: openingBrace.loc,
+      messageId: "braceOnPropertyLine"
+    });
+  }
+}
+function checkPropertyOnOwnLine(sourceCode, context, prevPropertyEndLine, property) {
+  const propStartLine = property.loc.start.line;
+  if (propStartLine === prevPropertyEndLine) {
+    context.report({
+      fix(fixer) {
+        const lastNewLineIndex = sourceCode.getText().lastIndexOf("\n", property.range[0] - 1);
+        return fixer.replaceTextRange(
+          [lastNewLineIndex, property.range[0]],
+          "\n" + getLineIndent$1(sourceCode, property.loc.start.line)
+        );
+      },
+      loc: property.loc,
+      messageId: "propertiesOnSameLine"
+    });
+  }
+}
+function checkObjectExpression(sourceCode, context, node2) {
+  if (node2.properties.length === 0)
+    return;
+  const openingBrace = sourceCode.getFirstToken(node2);
+  const closingBrace = sourceCode.getLastToken(node2);
+  if (!openingBrace || !closingBrace)
+    return;
+  const openingLine = openingBrace.loc.start.line;
+  const closingLine = closingBrace.loc.end.line;
+  if (openingLine === closingLine)
+    return;
+  checkOpeningBrace(sourceCode, context, node2, openingBrace);
+  let prevPropertyEndLine = node2.properties[0].loc.start.line;
+  for (const property of node2.properties) {
+    if (property !== node2.properties[0])
+      checkPropertyOnOwnLine(sourceCode, context, prevPropertyEndLine, property);
+    prevPropertyEndLine = property.loc.end.line;
+  }
+  checkClosingBrace(sourceCode, context, node2, closingBrace);
+  checkNestedObjects(sourceCode, context, node2, checkObjectExpression);
+}
+const messageIds$c = {
+  braceOnPropertyLine: "Opening brace should be on its own line",
+  propertiesOnSameLine: "Multi-line objects must have each property on its own line"
+};
+const braceStyleObjectLiteral = {
+  create(context) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    return {
+      ObjectExpression(node2) {
+        checkObjectExpression(sourceCode, context, node2);
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Enforce consistent brace positioning for object literals."
+    },
+    fixable: "code",
+    messages: messageIds$c,
+    schema: [{
+      additionalProperties: false,
+      properties: {},
+      type: "object"
+    }],
+    type: "layout"
+  }
+};
+function buildCompactFix(fixer, openingBracket, closingBracket, elements, sourceCode) {
+  const nonNullElements = elements.filter(
+    (el) => el !== null
+  );
+  const formattedItems = nonNullElements.map((element) => sourceCode.getText(element)).join(", ");
+  const newText = `[${formattedItems}]`;
+  return fixer.replaceTextRange(
+    [openingBracket.range[0], closingBracket.range[1]],
+    newText
+  );
+}
+function findBracketByRange(tokens, range, value) {
+  return tokens?.find(
+    (t) => t.range[0] === range[0] && t.value === value
+  );
+}
+function findClosingBracketByRange(tokens, range) {
+  return tokens?.find(
+    (t) => t.range[1] === range[1] && t.value === "]"
+  );
+}
+function hasElements(elements) {
+  const nonNull = elements.filter(
+    (el) => el !== null
+  );
+  return nonNull.length >= 1;
+}
+function hasMultilineItems(nonNullElements) {
+  return nonNullElements.some(
+    (el) => el.loc.start.line !== el.loc.end.line
+  );
+}
+function isBracketOnOwnLine(sourceCode, openingBracket) {
+  const nextToken = sourceCode.getTokenAfter(openingBracket, {
+    includeComments: false
+  });
+  if (!nextToken)
+    return false;
+  const text = sourceCode.getText();
+  const openingBracketEndIndex = openingBracket.range[1];
+  const textBetween = text.slice(
+    openingBracketEndIndex,
+    nextToken.range[0]
+  );
+  return textBetween.includes("\n");
+}
+const messageIds$b = {
+  compactItems: "Array items should be compact when the array spans multiple lines."
+};
+const compactArrayItems = {
+  create(context) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    return {
+      ArrayExpression(node2) {
+        if (!hasElements(node2.elements))
+          return;
+        const tokens = sourceCode.ast.tokens;
+        const openingBracket = findBracketByRange(tokens, node2.range, "[");
+        const closingBracket = findClosingBracketByRange(
+          tokens,
+          node2.range
+        );
+        if (!openingBracket || !closingBracket)
+          return;
+        if (!isBracketOnOwnLine(sourceCode, openingBracket))
+          return;
+        const nonNullElements = node2.elements.filter(
+          (el) => el !== null
+        );
+        if (!hasMultilineItems(nonNullElements))
+          return;
+        context.report({
+          fix: (fixer) => buildCompactFix(
+            fixer,
+            openingBracket,
+            closingBracket,
+            node2.elements,
+            sourceCode
+          ),
+          messageId: "compactItems",
+          node: node2
+        });
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Enforce arrays with multiline items to have a compact, inline bracket style."
+    },
+    fixable: "code",
+    messages: messageIds$b,
+    schema: [],
+    type: "layout"
+  }
+};
+function getNameFromDeclaration(node2) {
+  const names = [];
+  switch (node2.type) {
+    case "ClassDeclaration":
+      if (node2.id)
+        names.push(node2.id.name);
+      break;
+    case "FunctionDeclaration":
+      if (node2.id)
+        names.push(node2.id.name);
+      break;
+    case "TSInterfaceDeclaration":
+      names.push(node2.id.name);
+      break;
+    case "TSTypeAliasDeclaration":
+      names.push(node2.id.name);
+      break;
+    case "VariableDeclaration":
+      for (const d of node2.declarations) {
+        if (d.id.type === "Identifier")
+          names.push(d.id.name);
+      }
+      break;
+  }
+  return names;
+}
+function getNamesFromSpecifiers(node2) {
+  if (!node2.specifiers?.length)
+    return [];
+  const names = [];
+  for (const specifier of node2.specifiers) {
+    if (specifier.exported.type === "Identifier")
+      names.push(specifier.exported.name);
+  }
+  return names;
+}
+function getExportedNames(node2) {
+  const specifierNames = getNamesFromSpecifiers(node2);
+  if (!node2.declaration)
+    return specifierNames;
+  const declarationNames = getNameFromDeclaration(node2.declaration);
+  return [...specifierNames, ...declarationNames];
+}
+function stripExtension(filename) {
+  return path.basename(filename, path.extname(filename));
+}
+function isExempt$2(filename) {
+  const name = stripExtension(filename);
+  return name === "index" || name.endsWith(".test") || name.endsWith(".spec") || name.endsWith(".config");
+}
+const messageIds$a = {
+  filenameMismatch: "File name must be '{{expectedName}}' instead of '{{currentName}}'."
+};
+const 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(node2) {
+        const names = getExportedNames(node2);
+        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: messageIds$a,
+    schema: [],
+    type: "suggestion"
+  }
+};
+function findLinesWithMultipleNodes(nodes) {
+  const lines = [];
+  for (let i = 0; i < nodes.length; i++) {
+    const node2 = nodes[i];
+    const nodeLine = node2.loc.start.line;
+    if (i < nodes.length - 1) {
+      const nextNode = nodes[i + 1];
+      if (nextNode.loc.start.line === nodeLine)
+        lines.push(nodeLine);
+    }
+  }
+  return lines;
+}
+function formatArgs(sourceCode, nodes, indent) {
+  return nodes.map((arg, index) => {
+    const argText = sourceCode.getText(arg);
+    const isLast = index === nodes.length - 1;
+    if (isLast)
+      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}` : `
+${indent}${text}`
+  ).join("");
+}
+function getLineStartIndex(sourceCode, line) {
+  const lines = sourceCode.getLines();
+  return lines.slice(0, line - 1).reduce(
+    (acc, l) => acc + l.length + 1,
+    0
+  );
+}
+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 baseIndent = sourceCode.getText().match(/^[\t ]*/)?.[0] ?? "";
+          const indent = baseIndent + "  ";
+          const fixed = formatArgs(sourceCode, nodesOnLine, indent);
+          return fixer.replaceTextRange(
+            [lineStartIndex, lastNode.range[1]],
+            fixed
+          );
+        },
+        loc: {
+          end: {
+            column: lineLength,
+            line
+          },
+          start: {
+            column: 0,
+            line
+          }
+        },
+        messageId: "multipleOnSameLine"
+      });
+    }
+  }
+}
+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 argTexts = 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;
+      });
+      const fixed = [
+        "(\n",
+        `${indent}  ${argTexts.join(`
+${indent}  `)}
+`,
+        `${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"
+  });
+}
+const defaultOptions$5 = {
+  maxLength: 80
+};
+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 };
+}
+function isValidParens(parens) {
+  if (!parens)
+    return false;
+  return parens.openingParen.value === "(" && parens.closingParen.value === ")";
+}
+function checkCall(sourceCode, context, node2) {
+  const options = context.options[0] ?? {};
+  const maxLength = options.maxLength ?? defaultOptions$5.maxLength;
+  const args = node2.arguments;
+  const parens = getParens$1(sourceCode, args);
+  if (!isValidParens(parens))
+    return;
+  const firstLine = parens.openingParen.loc.start.line;
+  const lastLine = parens.closingParen.loc.end.line;
+  if (firstLine === lastLine)
+    checkSingleLineArgs(sourceCode, context, args, parens, maxLength);
+  else
+    checkMultilineArgs(sourceCode, context, args, maxLength);
+}
+const messageIds$9 = {
+  exceedsMaxLength: "Refactor this function call as it exceeds {{maxLength}} characters",
+  multipleOnSameLine: "Each argument must be on its own line"
+};
+const functionCallArgumentLineBreak = {
+  create(context) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    return {
+      CallExpression(node2) {
+        checkCall(sourceCode, context, node2);
+      },
+      OptionalCallExpression(node2) {
+        checkCall(sourceCode, context, node2);
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Enforce each function call argument to be on its own line when line exceeds max length."
+    },
+    fixable: "code",
+    messages: messageIds$9,
+    schema: [{
+      additionalProperties: false,
+      properties: {
+        maxLength: {
+          type: "number"
+        }
+      },
+      type: "object"
+    }],
+    type: "layout"
+  }
+};
+function isNodeWithType(value) {
+  return value !== null && typeof value === "object" && "type" in value;
+}
+const SKIP_KEYS = /* @__PURE__ */ new Set(["loc", "parent", "range"]);
+function getChildNodes(node2) {
+  const children = [];
+  for (const key of Object.keys(node2)) {
+    if (SKIP_KEYS.has(key))
+      continue;
+    const value = node2[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;
+}
+const INCREMENTABLE_TYPES = /* @__PURE__ */ new Set([
+  "ConditionalExpression",
+  "DoWhileStatement",
+  "ForInStatement",
+  "ForOfStatement",
+  "ForStatement",
+  "IfStatement",
+  "LogicalExpression",
+  "SwitchStatement",
+  "TryStatement",
+  "WhileStatement"
+]);
+function isIncrementableControlFlow(node2) {
+  return INCREMENTABLE_TYPES.has(node2.type);
+}
+function traverse(node2, nestingLevel, state) {
+  if (isIncrementableControlFlow(node2)) {
+    state.complexity += 1 + nestingLevel;
+    nestingLevel++;
+  }
+  const children = getChildNodes(node2);
+  for (const child of children)
+    traverse(child, nestingLevel, state);
+}
+function calculateCognitiveComplexity(node2) {
+  const state = {
+    complexity: 0
+  };
+  const children = getChildNodes(node2);
+  for (const child of children)
+    traverse(child, 0, state);
+  return state.complexity;
+}
+function getNameFromCallExpression(node2) {
+  if (node2?.type === "CallExpression" && node2.callee?.type === "Identifier")
+    return `${node2.callee.name} callback`;
+  return null;
+}
+function getNameFromProperty(node2) {
+  if (node2?.type === "Property" && node2.key?.type === "Identifier")
+    return node2.key.name;
+  return null;
+}
+function getNameFromVariableDeclarator(node2) {
+  if (node2?.type === "VariableDeclarator" && node2.id?.type === "Identifier")
+    return node2.id.name;
+  return null;
+}
+function getArrowFunctionExpressionName(node2) {
+  const parent = node2.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;
+}
+function getNameFromMethodDefinition(node2) {
+  if (node2?.type === "MethodDefinition" && node2.key?.type === "Identifier")
+    return node2.key.name;
+  return null;
+}
+function getFunctionExpressionName(node2) {
+  const parent = node2.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;
+}
+function getFunctionName$1(node2) {
+  if (node2.type === "FunctionDeclaration" && node2.id?.name)
+    return node2.id.name;
+  if (node2.type === "FunctionExpression")
+    return getFunctionExpressionName(node2);
+  if (node2.type === "ArrowFunctionExpression")
+    return getArrowFunctionExpressionName(node2);
+  return null;
+}
+const 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."
+};
+const DEFAULT_MAX_COGNITIVE_COMPLEXITY = 15;
+const functionCognitiveComplexity = {
+  create(context) {
+    const options = context.options[0] ?? {};
+    const maxCognitiveComplexity = options.maxCognitiveComplexity ?? DEFAULT_MAX_COGNITIVE_COMPLEXITY;
+    function checkFunction2(node2) {
+      const complexity = calculateCognitiveComplexity(node2);
+      if (complexity > maxCognitiveComplexity) {
+        const name = getFunctionName$1(node2);
+        if (name) {
+          context.report({
+            data: {
+              actual: complexity,
+              max: maxCognitiveComplexity,
+              name
+            },
+            messageId: "tooHighCognitiveComplexity",
+            node: node2
+          });
+        } else {
+          context.report({
+            data: {
+              actual: complexity,
+              max: maxCognitiveComplexity
+            },
+            messageId: "tooHighCognitiveComplexityAnonymous",
+            node: node2
+          });
+        }
+      }
+    }
+    return {
+      ArrowFunctionExpression(node2) {
+        checkFunction2(node2);
+      },
+      FunctionDeclaration(node2) {
+        checkFunction2(node2);
+      },
+      FunctionExpression(node2) {
+        checkFunction2(node2);
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Enforce cognitive complexity threshold for functions."
+    },
+    messages: messageIds$8,
+    schema: [{
+      additionalProperties: false,
+      properties: {
+        maxCognitiveComplexity: {
+          type: "number"
+        }
+      },
+      type: "object"
+    }],
+    type: "suggestion"
+  }
+};
+function formatParams(sourceCode, nodes, indent) {
+  return nodes.map((param, index) => {
+    const paramText = sourceCode.getText(param);
+    const isLast = index === nodes.length - 1;
+    if (isLast)
+      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}` : `
+${indent}${text}`
+  ).join("");
+}
+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 baseIndent = sourceCode.getText().match(/^[\t ]*/)?.[0] ?? "";
+          const indent = baseIndent + "  ";
+          const fixed = formatParams(sourceCode, nodesOnLine, indent);
+          return fixer.replaceTextRange(
+            [lineStartIndex, lastNode.range[1]],
+            fixed
+          );
+        },
+        loc: {
+          end: {
+            column: lineLength,
+            line
+          },
+          start: {
+            column: 0,
+            line
+          }
+        },
+        messageId: "multipleOnSameLine"
+      });
+    }
+  }
+}
+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 paramTexts = 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;
+      });
+      const fixed = [
+        "(\n",
+        `${indent}  ${paramTexts.join(`
+${indent}  `)}
+`,
+        `${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"
+  });
+}
+const defaultOptions$4 = {
+  maxLength: 80
+};
+function checkFunction$1(sourceCode, context, node2) {
+  const options = context.options[0] ?? {};
+  const maxLength = options.maxLength ?? defaultOptions$4.maxLength;
+  const params = node2.params;
+  if (params.length === 0)
+    return;
+  const parens = getParens$1(sourceCode, params);
+  if (!isValidParens(parens))
+    return;
+  const firstLine = parens.openingParen.loc.start.line;
+  const lastLine = parens.closingParen.loc.end.line;
+  if (firstLine === lastLine)
+    checkSingleLineParams(sourceCode, context, params, parens, maxLength);
+  else
+    checkMultilineParams(sourceCode, context, params, parens, maxLength);
+}
+const messageIds$7 = {
+  exceedsMaxLength: "Refactor this function signature as it exceeds {{maxLength}} characters",
+  multipleOnSameLine: "Each parameter must be on its own line"
+};
+const functionParameterLineBreak = {
+  create(context) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    return {
+      ArrowFunctionExpression(node2) {
+        if (node2.expression)
+          return;
+        checkFunction$1(sourceCode, context, node2);
+      },
+      FunctionDeclaration(node2) {
+        checkFunction$1(sourceCode, context, node2);
+      },
+      FunctionExpression(node2) {
+        checkFunction$1(sourceCode, context, node2);
+      },
+      TSCallSignatureDeclaration(node2) {
+        checkFunction$1(sourceCode, context, node2);
+      },
+      TSFunctionType(node2) {
+        checkFunction$1(sourceCode, context, node2);
+      },
+      TSMethodSignature(node2) {
+        checkFunction$1(sourceCode, context, node2);
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Enforce each function parameter to be on its own line when line exceeds max length."
+    },
+    fixable: "code",
+    messages: messageIds$7,
+    schema: [{
+      additionalProperties: false,
+      properties: {
+        maxLength: {
+          type: "number"
+        }
+      },
+      type: "object"
+    }],
+    type: "layout"
+  }
+};
 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
+  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";
+}
 function isImportDeclaration(statement) {
-	return statement.type === "ImportDeclaration";
+  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;
+  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: [],
-		reExports: [],
-		other: []
-	};
-	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
+  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;
+}
 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
+  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 };
+}
 function generateSortedText(context, categories) {
-	return [
-		...categories.imports,
-		...categories.reExports,
-		...categories.other
-	].map((node) => context.sourceCode.getText(node)).join("\n");
-}
-//#endregion
-//#region src/rules/importsAndReExportsAtTop/hasViolation.ts
-function hasViolation(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
+  const allStatements = [
+    ...categories.imports,
+    ...categories.reExports,
+    ...categories.other
+  ];
+  return allStatements.map(
+    (node2) => context.sourceCode.getText(node2)
+  ).join("\n");
+}
+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;
+}
 const importsAndReExportsAtTop = {
-	meta: {
-		type: "suggestion",
-		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: []
-	},
-	create(context) {
-		return { Program(node) {
-			const statements = node.body;
-			const categories = categorizeStatements(statements);
-			if (!hasViolation(findStatementIndices(statements), categories)) return;
-			context.report({
-				node,
-				messageId: "importsAndReExportsAtTop",
-				fix(fixer) {
-					const sortedText = generateSortedText(context, categories);
-					return fixer.replaceText(node, sortedText);
-				}
-			});
-		} };
-	}
-};
-//#endregion
-//#region src/rules/individualImports.ts
+  create(context) {
+    return {
+      Program(node2) {
+        const statements = node2.body;
+        const categories = categorizeStatements(statements);
+        const indices = findStatementIndices(statements);
+        if (!hasImportOrderViolation(indices, categories))
+          return;
+        context.report({
+          fix(fixer) {
+            const sortedText = generateSortedText(context, categories);
+            return fixer.replaceText(node2, sortedText);
+          },
+          messageId: "importsAndReExportsAtTop",
+          node: node2
+        });
+      }
+    };
+  },
+  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"
+  }
+};
 const individualImports = {
-	meta: {
-		docs: { description: "Enforce individual imports instead of grouped imports" },
-		fixable: "code",
-		messages: { individualImports: "Use individual imports instead of grouped imports." },
-		schema: [],
-		type: "suggestion"
-	},
-	create(context) {
-		return { ImportDeclaration(node) {
-			if (node.specifiers.length <= 1) return;
-			context.report({
-				node,
-				messageId: "individualImports",
-				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);
-				}
-			});
-		} };
-	}
-};
-//#endregion
-//#region src/rules/individualReExports.ts
+  create(context) {
+    return {
+      ImportDeclaration(node2) {
+        if (node2.specifiers.length <= 1)
+          return;
+        context.report({
+          fix(fixer) {
+            const source = node2.source.raw;
+            const specifiers = node2.specifiers.filter((s) => s.type === "ImportSpecifier").map((s) => `import {${s.local.name}} from ${source}`).join("\n");
+            return fixer.replaceText(node2, specifiers);
+          },
+          messageId: "individualImports",
+          node: node2
+        });
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Enforce individual imports instead of grouped imports."
+    },
+    fixable: "code",
+    messages: {
+      individualImports: "Use individual imports instead of grouped imports."
+    },
+    schema: [],
+    type: "suggestion"
+  }
+};
 const individualReExports = {
-	meta: {
-		docs: { description: "Enforce individual exports instead of grouped exports" },
-		fixable: "code",
-		messages: { individualReExports: "Use individual exports instead of grouped exports." },
-		schema: [],
-		type: "suggestion"
-	},
-	create(context) {
-		return { ExportNamedDeclaration(node) {
-			if (!node.source || node.specifiers.length <= 1) return;
-			context.report({
-				node,
-				messageId: "individualReExports",
-				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);
-				}
-			});
-		} };
-	}
-};
-//#endregion
-//#region src/rules/multilineUnionTypes/createFix.ts
-function createFix$4(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/multilineUnionTypes/isMultiline.ts
-function isMultiline$2(unionType) {
-	const { start, end } = unionType.loc ?? {};
-	return start?.line !== end?.line;
-}
-//#endregion
-//#region src/rules/multilineUnionTypes/index.ts
-const multilineUnionTypes = {
-	meta: {
-		docs: { description: "Enforce union types with multiple members to be on multiple lines" },
-		fixable: "code",
-		messages: {
-			singleLine: "Union types with multiple members should be on multiple lines",
-			missingPipes: "Multiline union types should have leading pipes on each member"
-		},
-		schema: [],
-		type: "layout"
-	},
-	create(context) {
-		return { TSUnionType(node) {
-			if (node.types.length < 2) return;
-			const sourceCode = context.sourceCode;
-			if (sourceCode.getText(node).trim().startsWith("|")) return;
-			if (!isMultiline$2(node)) {
-				context.report({
-					node,
-					messageId: "singleLine",
-					fix: (fixer) => createFix$4(fixer, node, sourceCode)
-				});
-				return;
-			}
-			context.report({
-				node,
-				messageId: "missingPipes",
-				fix: (fixer) => createFix$4(fixer, node, sourceCode)
-			});
-		} };
-	}
-};
-//#endregion
-//#region src/rules/singleLineImports/formatAttributes.ts
+  create(context) {
+    return {
+      ExportNamedDeclaration(node2) {
+        if (!node2.source || node2.specifiers.length <= 1)
+          return;
+        context.report({
+          fix(fixer) {
+            const source = node2.source.value;
+            const typeKeyword = node2.exportKind === "type" ? "type " : "";
+            const specifiers = node2.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;
+              const name = localName === exportedName ? localName : `${localName} as ${exportedName}`;
+              return `export ${typeKeyword}{${name}} from '${source}'`;
+            }).join("\n");
+            return fixer.replaceText(node2, specifiers);
+          },
+          messageId: "individualReExports",
+          node: node2
+        });
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Enforce individual exports instead of grouped exports."
+    },
+    fixable: "code",
+    messages: {
+      individualReExports: "Use individual exports instead of grouped exports."
+    },
+    schema: [],
+    type: "suggestion"
+  }
+};
+function formatTypeLiteral(sourceCode, typeLiteral, baseIndent) {
+  const members = typeLiteral.members;
+  if (members.length === 0)
+    return "{}";
+  const memberTexts = members.map((member) => {
+    if (member.type === "TSPropertySignature") {
+      const memberText = sourceCode.getText(member);
+      return memberText.replace(/,\s*$/, "");
+    }
+    return sourceCode.getText(member).replace(/,\s*$/, "");
+  });
+  const innerIndent = baseIndent + "  ";
+  const lines = [
+    "{",
+    innerIndent + memberTexts.join(`
+${innerIndent}`),
+    `${baseIndent}}`
+  ];
+  return lines.join("\n");
+}
+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 baseIndent = getLineIndent$1(sourceCode, memberLine);
+          const formatted = formatTypeLiteral(
+            sourceCode,
+            typeLiteral,
+            baseIndent
+          );
+          return fixer.replaceText(typeLiteral, formatted);
+        };
+      }
+      context.report({
+        data: { maxLength },
+        fix,
+        loc: {
+          end: {
+            column: lineLength,
+            line: memberLine
+          },
+          start: {
+            column: 0,
+            line: memberLine
+          }
+        },
+        messageId: "exceedsMaxLength"
+      });
+    }
+  }
+}
+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 memberTexts = members.map((member, index) => {
+        const memberText = sourceCode.getText(member).replace(/,\s*$/, "");
+        const isLast = index === members.length - 1;
+        if (!isLast)
+          return memberText + ",";
+        return memberText;
+      });
+      const fixed = [
+        "{\n",
+        `${indent}  ${memberTexts.join(`
+${indent}  `)}
+`,
+        `${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"
+  });
+}
+const defaultOptions$3 = {
+  maxLength: 80
+};
+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 };
+}
+function checkInterface(sourceCode, context, node2) {
+  const options = context.options[0] ?? {};
+  const maxLength = options.maxLength ?? defaultOptions$3.maxLength;
+  const body = node2.body;
+  if (!body || body.body.length === 0)
+    return;
+  const braces = getBraces$1(sourceCode, body);
+  if (!braces)
+    return;
+  const firstLine = braces.openingBrace.loc.start.line;
+  const lastLine = braces.closingBrace.loc.end.line;
+  if (firstLine === lastLine)
+    checkSingleLineMembers(sourceCode, context, body.body, braces, maxLength);
+  else
+    checkMultilineMembers(sourceCode, context, body.body, maxLength);
+}
+const messageIds$6 = {
+  exceedsMaxLength: "Interface line exceeds {{maxLength}} characters",
+  multipleOnSameLine: "Interface members should each be on their own line when line exceeds {{maxLength}} characters"
+};
+const interfacePropertyLineBreak = {
+  create(context) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    return {
+      TSInterfaceDeclaration(node2) {
+        checkInterface(sourceCode, context, node2);
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Enforce each interface member to be on its own line when line exceeds max length."
+    },
+    fixable: "code",
+    messages: messageIds$6,
+    schema: [{
+      additionalProperties: false,
+      properties: {
+        maxLength: {
+          type: "number"
+        }
+      },
+      type: "object"
+    }],
+    type: "layout"
+  }
+};
+function collectVariableDeclarators(node2, types) {
+  for (const declarator of node2.declarations) {
+    if (declarator.id.type === "Identifier" && declarator.id.name)
+      types.add(declarator.id.name);
+  }
+}
+function isTopLevel(node2) {
+  if (node2.parent?.type === "Program")
+    return true;
+  if (node2.parent?.type === "ExportNamedDeclaration" && node2.parent.parent?.type === "Program")
+    return true;
+  return false;
+}
+function handleClassDeclaration(node2, functions) {
+  if (isTopLevel(node2) && node2.id?.name)
+    functions.add(node2.id.name);
+}
+function handleFunctionDeclaration(node2, functions) {
+  if (isTopLevel(node2) && node2.id?.name)
+    functions.add(node2.id.name);
+}
+function handleTSDeclareFunction(node2, functions) {
+  if (isTopLevel(node2) && node2.id?.name)
+    functions.add(node2.id.name);
+}
+function handleTSEnumDeclaration(node2, types) {
+  if (isTopLevel(node2) && node2.id?.name)
+    types.add(node2.id.name);
+}
+function handleTSInterfaceDeclaration(node2, types) {
+  if (isTopLevel(node2) && node2.id?.name)
+    types.add(node2.id.name);
+}
+function handleTSTypeAliasDeclaration(node2, types) {
+  if (isTopLevel(node2) && node2.id?.name)
+    types.add(node2.id.name);
+}
+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;
+}
+function isExportedDeclaration(parent) {
+  return parent?.type === "ExportNamedDeclaration";
+}
+const messageIds$5 = {
+  tooManyDeclarations: "File has {{count}} declarations. Put each function/class/const/type declaration in its own file."
+};
+const maxDeclarationsPerFile = {
+  create(context) {
+    const filename = context.filename;
+    if (isExempt$1(filename))
+      return {};
+    const functions = /* @__PURE__ */ new Set();
+    const types = /* @__PURE__ */ new Set();
+    return {
+      ClassDeclaration(node2) {
+        handleClassDeclaration(node2, functions);
+      },
+      FunctionDeclaration(node2) {
+        handleFunctionDeclaration(node2, 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(node2) {
+        handleTSDeclareFunction(node2, functions);
+      },
+      TSEnumDeclaration(node2) {
+        handleTSEnumDeclaration(node2, types);
+      },
+      TSInterfaceDeclaration(node2) {
+        handleTSInterfaceDeclaration(node2, types);
+      },
+      TSTypeAliasDeclaration(node2) {
+        handleTSTypeAliasDeclaration(node2, types);
+      },
+      VariableDeclaration(node2) {
+        if (!isTopLevel(node2))
+          return;
+        const parent = node2.parent;
+        if (!isExportedDeclaration(parent) && !node2.declare)
+          return;
+        collectVariableDeclarators(node2, 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: messageIds$5,
+    schema: [],
+    type: "suggestion"
+  }
+};
+function createFix(fixer, node2, sourceCode) {
+  const types = node2.types.map((t) => sourceCode.getText(t));
+  const formattedTypes = types.map((t) => `  | ${t}`).join("\n");
+  const result = `
+${formattedTypes}`;
+  return fixer.replaceText(node2, result);
+}
+function isMultiline(unionType) {
+  const { end, start } = unionType.loc ?? {};
+  return start?.line !== end?.line;
+}
+const multilineUnionTypeAliases = {
+  create(context) {
+    return {
+      TSUnionType(node2) {
+        if (node2.types.length < 2)
+          return;
+        const parent = node2.parent;
+        if (!parent || parent.type !== "TSTypeAliasDeclaration")
+          return;
+        const sourceCode = context.sourceCode;
+        const text = sourceCode.getText(node2);
+        if (text.trim().startsWith("|"))
+          return;
+        if (!isMultiline(node2)) {
+          context.report({
+            fix: (fixer) => createFix(fixer, node2, sourceCode),
+            messageId: "singleLine",
+            node: node2
+          });
+          return;
+        }
+        context.report({
+          fix: (fixer) => createFix(fixer, node2, sourceCode),
+          messageId: "missingPipes",
+          node: node2
+        });
+      }
+    };
+  },
+  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"
+  }
+};
+function isExempt(name) {
+  return name.startsWith("_");
+}
+function isPascalCase(name) {
+  if (!/^[A-Z]/.test(name))
+    return false;
+  return /^[A-Z][\dA-Za-z]*$/.test(name);
+}
+function isSeparator(char) {
+  return char === "_" || char === "-" || char === " ";
+}
+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) {
+    const isStartOfNewWord = !prevIsUpper || prevIsUpper && nextIsLower;
+    return isStartOfNewWord;
+  }
+  return false;
+}
+function capitalize(word) {
+  return word.charAt(0).toUpperCase() + word.slice(1);
+}
+function wordsToCamelCase(words) {
+  if (words.length === 0)
+    return "";
+  if (words.length === 1)
+    return words[0].toLowerCase();
+  const firstWord = words[0].toLowerCase();
+  const restWords = words.slice(1).map(capitalize);
+  return firstWord + restWords.join("");
+}
+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);
+}
+function toPascalCase$1(name) {
+  const camelCase = toCamelCase(name);
+  return camelCase.charAt(0).toUpperCase() + camelCase.slice(1);
+}
+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
+    });
+  }
+}
+function checkNamedEntity(name, node2, type, context) {
+  if (isExempt(name))
+    return;
+  if (!isPascalCase(name)) {
+    context.report({
+      data: { name, type },
+      fix(fixer) {
+        return fixer.replaceText(node2, toPascalCase$1(name));
+      },
+      messageId: "notPascalCase",
+      node: node2
+    });
+  }
+}
+function isCamelCase(name) {
+  if (!/^[a-z]/.test(name))
+    return false;
+  return /^[a-z][\dA-Za-z]*$/.test(name);
+}
+function isUpperCase(name) {
+  return /^[A-Z][\dA-Z_]*$/.test(name);
+}
+function checkConstant(name, node2, context) {
+  if (!isCamelCase(name) && !isUpperCase(name)) {
+    context.report({
+      data: { name },
+      messageId: "notUpperCase",
+      node: node2
+    });
+  }
+}
+function checkVariable(name, node2, context) {
+  if (!isCamelCase(name)) {
+    context.report({
+      data: { name },
+      fix(fixer) {
+        return fixer.replaceText(node2, toCamelCase(name));
+      },
+      messageId: "notCamelCase",
+      node: node2
+    });
+  }
+}
+function isFunction(init) {
+  if (!init)
+    return false;
+  return init.type === "FunctionExpression" || init.type === "ArrowFunctionExpression";
+}
+function checkVariableDeclarator(node2, context) {
+  const id = node2.id;
+  const name = id.name;
+  if (isExempt(name))
+    return;
+  if (isFunction(node2.init))
+    return;
+  const parent = node2.parent;
+  if (parent?.type !== "VariableDeclaration")
+    return;
+  const kind = parent.kind;
+  if (kind === "const")
+    checkConstant(name, id, context);
+  else
+    checkVariable(name, id, context);
+}
+function getFunctionName(node2, parent) {
+  if (node2.type === "FunctionDeclaration" && node2.id)
+    return node2.id.name;
+  if ((node2.type === "FunctionExpression" || node2.type === "ArrowFunctionExpression") && parent?.type === "VariableDeclarator" && parent.id.type === "Identifier")
+    return parent.id.name;
+  return null;
+}
+function getReturnTypeText(sourceCode, node2) {
+  if (!node2.returnType)
+    return void 0;
+  return sourceCode.getText(node2.returnType.typeAnnotation);
+}
+function isReactComponent(returnTypeText) {
+  if (!returnTypeText)
+    return false;
+  const patterns = [
+    "JSX.Element",
+    "React.JSX.Element",
+    "ReactElement",
+    "ReactNode"
+  ];
+  return patterns.some((pattern) => returnTypeText.includes(pattern));
+}
+const messageIds$4 = {
+  notCamelCase: 'Function "{{name}}" should use camelCase',
+  notPascalCase: '{{type}} "{{name}}" should use PascalCase',
+  notUpperCase: 'Constant "{{name}}" should use UPPER_CASE'
+};
+function getFunctionIdentifierNodeForFixer(node2, parent) {
+  if (node2.type === "FunctionDeclaration")
+    return node2.id;
+  if (parent?.type === "VariableDeclarator")
+    return parent.id;
+  return null;
+}
+function getFunctionNameForFixer(node2, parent) {
+  if (node2.type === "FunctionDeclaration" && node2.id)
+    return node2.id.name;
+  if (parent?.type === "VariableDeclarator" && parent.id.type === "Identifier")
+    return parent.id.name;
+  return "";
+}
+function createFunctionFixer(node2, parent, convert) {
+  return (fixer) => {
+    const fixedName = convert(getFunctionNameForFixer(node2, parent));
+    const identifierNode = getFunctionIdentifierNodeForFixer(node2, parent);
+    if (identifierNode)
+      return fixer.replaceText(identifierNode, fixedName);
+    return null;
+  };
+}
+function getFunctionReportNode(node2, parent) {
+  if (node2.type === "FunctionDeclaration")
+    return node2;
+  return parent ?? node2;
+}
+function reportComponentViolation(node2, parent, name, context) {
+  if (isPascalCase(name))
+    return;
+  context.report({
+    data: {
+      name,
+      type: "React component"
+    },
+    fix: createFunctionFixer(node2, parent, toPascalCase$1),
+    messageId: "notPascalCase",
+    node: getFunctionReportNode(node2, parent)
+  });
+}
+function reportFunctionViolation(node2, parent, name, context) {
+  if (isCamelCase(name))
+    return;
+  context.report({
+    data: { name },
+    fix: createFunctionFixer(node2, parent, toCamelCase),
+    messageId: "notCamelCase",
+    node: getFunctionReportNode(node2, parent)
+  });
+}
+const namingConvention = {
+  create(context) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    return {
+      ArrowFunctionExpression(node2) {
+        checkFunction2(node2, node2.parent);
+      },
+      ClassDeclaration(node2) {
+        checkClass(node2.id, context);
+      },
+      ClassExpression(node2) {
+        checkClass(node2.id, context);
+      },
+      FunctionDeclaration(node2) {
+        checkFunction2(node2);
+      },
+      FunctionExpression(node2) {
+        checkFunction2(node2, node2.parent);
+      },
+      TSEnumDeclaration(node2) {
+        checkNamedEntity(
+          node2.id.name,
+          node2.id,
+          "Enum",
+          context
+        );
+      },
+      TSInterfaceDeclaration(node2) {
+        checkNamedEntity(
+          node2.id.name,
+          node2.id,
+          "Interface",
+          context
+        );
+      },
+      TSTypeAliasDeclaration(node2) {
+        if (node2.id.type !== "Identifier")
+          return;
+        checkNamedEntity(
+          node2.id.name,
+          node2.id,
+          "Type",
+          context
+        );
+      },
+      VariableDeclarator(node2) {
+        if (node2.id.type !== "Identifier")
+          return;
+        checkVariableDeclarator(node2, context);
+      }
+    };
+    function checkFunction2(node2, parent) {
+      const name = getFunctionName(node2, parent);
+      if (!name || isExempt(name))
+        return;
+      const returnTypeText = getReturnTypeText(sourceCode, node2);
+      const isComponent = isReactComponent(returnTypeText);
+      if (isComponent)
+        reportComponentViolation(node2, parent, name, context);
+      else
+        reportFunctionViolation(node2, parent, name, context);
+    }
+  },
+  meta: {
+    docs: {
+      description: "Enforce consistent naming conventions."
+    },
+    fixable: "code",
+    messages: messageIds$4,
+    schema: [],
+    type: "suggestion"
+  }
+};
+function checkTypeParameters(node2, containsInline) {
+  if (!("typeParameters" in node2) || !node2.typeParameters)
+    return null;
+  for (const param of node2.typeParameters.params) {
+    const result = containsInline(param);
+    if (result)
+      return result;
+  }
+  return null;
+}
+function checkUnionOrIntersectionTypes(node2, containsInline) {
+  for (const type of node2.types) {
+    const result = containsInline(type);
+    if (result)
+      return result;
+  }
+  return null;
+}
+function isInlineObjectType(node2) {
+  return node2.type === "TSTypeLiteral";
+}
+function containsInlineObjectType(node2) {
+  if (isInlineObjectType(node2))
+    return node2;
+  if (node2.type === "TSIntersectionType" || node2.type === "TSUnionType") {
+    const result = checkUnionOrIntersectionTypes(
+      node2,
+      containsInlineObjectType
+    );
+    if (result)
+      return result;
+  }
+  if (node2.type === "TSArrayType")
+    return containsInlineObjectType(node2.elementType);
+  const typeParamResult = checkTypeParameters(node2, containsInlineObjectType);
+  if (typeParamResult)
+    return typeParamResult;
+  if (node2.type === "TSTypeAnnotation")
+    return containsInlineObjectType(node2.typeAnnotation);
+  return null;
+}
+function toPascalCase(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+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;
+}
+function getParameterNameFromFunction(parent) {
+  if (parent.type === "ArrowFunctionExpression" || parent.type === "FunctionDeclaration" || parent.type === "FunctionExpression") {
+    const funcNode = parent;
+    return funcNode.id?.name;
+  }
+  return void 0;
+}
+function getParameterNameFromIdentifier(parent) {
+  const grandParent = parent.parent;
+  if (grandParent?.type === "ArrowFunctionExpression" || grandParent?.type === "FunctionDeclaration" || grandParent?.type === "FunctionExpression")
+    return parent.name;
+  return void 0;
+}
+function getParameterNameFromObjectPattern(parent) {
+  const grandParent = parent.parent;
+  if (grandParent?.type === "ArrowFunctionExpression" || grandParent?.type === "FunctionDeclaration" || grandParent?.type === "FunctionExpression")
+    return "Options";
+  return void 0;
+}
+function getTopLevelDeclaration(node2) {
+  let current = node2;
+  const topLevelTypes = /* @__PURE__ */ new Set([
+    "ArrowFunctionExpression",
+    "FunctionDeclaration",
+    "FunctionExpression",
+    "TSInterfaceDeclaration",
+    "TSTypeAliasDeclaration",
+    "VariableDeclaration"
+  ]);
+  while (current) {
+    if (topLevelTypes.has(current.type)) {
+      const parent = current.parent;
+      const exported = parent?.type === "ExportNamedDeclaration";
+      if (exported && parent) {
+        return {
+          insertLocation: parent,
+          isExported: true,
+          node: current
+        };
+      }
+      return {
+        insertLocation: current,
+        isExported: false,
+        node: current
+      };
+    }
+    current = current.parent;
+  }
+  return void 0;
+}
+function handleInlineType(node2, typeLiteral, inlineTypes) {
+  const result = getTopLevelDeclaration(node2);
+  if (!result)
+    return;
+  let parameterName;
+  const parent = node2.parent;
+  if (parent?.type === "Identifier")
+    parameterName = getParameterNameFromIdentifier(parent);
+  else if (parent?.type === "ObjectPattern")
+    parameterName = getParameterNameFromObjectPattern(parent);
+  else
+    parameterName = getParameterNameFromFunction(parent);
+  inlineTypes.push({
+    annotationNode: node2,
+    insertLocation: result.insertLocation,
+    isExported: result.isExported,
+    location: result.node,
+    parameterName,
+    typeLiteral
+  });
+}
+function isIdentifierInFunction(parent) {
+  return parent?.type === "Identifier" && (parent.parent?.type === "FunctionDeclaration" || parent.parent?.type === "FunctionExpression" || parent.parent?.type === "ArrowFunctionExpression");
+}
+function isPropertySignatureInTypeLiteral(parent) {
+  return parent?.type === "TSPropertySignature" && (parent.parent?.type === "TSTypeLiteral" || parent.parent?.type === "TSInterfaceBody");
+}
+function traverseUpForTypeLiteral(current) {
+  const skipTypes = /* @__PURE__ */ 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;
+}
+function isNestedTypeAnnotation(node2) {
+  const parent = node2.parent;
+  if (isPropertySignatureInTypeLiteral(parent))
+    return true;
+  if (isIdentifierInFunction(parent))
+    return false;
+  if (parent?.type === "ArrowFunctionExpression" || parent?.type === "FunctionDeclaration" || parent?.type === "FunctionExpression")
+    return false;
+  const foundTypeLiteral = traverseUpForTypeLiteral(parent);
+  return foundTypeLiteral;
+}
+function prepareFix(sourceCode, inlineTypes) {
+  const interfaceDeclarations = inlineTypes.map(({ name, typeLiteral }) => {
+    const typeText = sourceCode.getText(typeLiteral);
+    return `interface ${name} ${typeText}`;
+  });
+  const interfaceBlock = interfaceDeclarations.join("\n");
+  const replacements = inlineTypes.map(
+    ({ name, typeLiteral }) => ({ name, typeLiteral })
+  );
+  return {
+    firstUsageLocation: inlineTypes[0].typeLiteral,
+    interfaceBlock,
+    replacements
+  };
+}
+const noInlineObjectTypes = {
+  create(context) {
+    const sourceCode = context.sourceCode;
+    const inlineTypes = [];
+    const listener = {
+      TSTypeAnnotation(node2) {
+        if (isNestedTypeAnnotation(node2))
+          return;
+        const typeLiteral = containsInlineObjectType(node2);
+        if (!typeLiteral)
+          return;
+        handleInlineType(node2, typeLiteral, inlineTypes);
+      }
+    };
+    return {
+      ...listener,
+      "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 typesForLocation = typesAtLocation.map((entry) => {
+            const name = getInlineTypeName(usedNames, [], entry.parameterName);
+            return {
+              name,
+              parameterName: entry.parameterName,
+              typeLiteral: entry.typeLiteral
+            };
+          });
+          const fixResult = prepareFix(
+            sourceCode,
+            typesForLocation
+          );
+          context.report({
+            fix(fixer) {
+              const fixes = [];
+              for (const replacement of fixResult.replacements) {
+                fixes.push(
+                  fixer.replaceText(
+                    replacement.typeLiteral,
+                    replacement.name
+                  )
+                );
+              }
+              const isExported = typesAtLocation[0].isExported;
+              if (isExported && typesAtLocation[0].insertLocation.type === "ExportNamedDeclaration") {
+                fixes.push(
+                  fixer.insertTextAfter(
+                    typesAtLocation[0].insertLocation,
+                    `
+${fixResult.interfaceBlock}`
+                  )
+                );
+              } else {
+                fixes.push(
+                  fixer.insertTextBefore(
+                    loc,
+                    `${fixResult.interfaceBlock}
+`
+                  )
+                );
+              }
+              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"
+  }
+};
+function getLineIndent(sourceCode, line) {
+  const text = sourceCode.getText();
+  const lines = text.split("\n");
+  const lineText = lines[line - 1] ?? "";
+  const match = lineText.match(/^(\s*)/);
+  return match?.[1] ?? "";
+}
+function getReplacementText(statementText, baseIndent, hasElseAfter) {
+  const statementIndent = `${baseIndent}  `;
+  if (hasElseAfter)
+    return `
+${statementIndent}${statementText}
+${baseIndent}`;
+  return `
+${statementIndent}${statementText}`;
+}
+function isSingleLineStatement(node2, sourceCode) {
+  const firstToken = sourceCode.getFirstToken(node2);
+  const lastToken = sourceCode.getLastToken(node2);
+  if (!firstToken || !lastToken)
+    return false;
+  return firstToken.loc.start.line === lastToken.loc.end.line;
+}
+function checkBlockStatement(node2, context) {
+  if (node2.body.length !== 1)
+    return;
+  const statement = node2.body[0];
+  const sourceCode = context.getSourceCode();
+  if (isSingleLineStatement(statement, sourceCode)) {
+    context.report({
+      fix(fixer) {
+        const statementText = sourceCode.getText(statement);
+        const tokenBefore = sourceCode.getTokenBefore(node2);
+        const tokenBeforeLine = tokenBefore?.loc?.start?.line ?? node2.loc?.start?.line ?? 1;
+        const baseIndent = getLineIndent(sourceCode, tokenBeforeLine);
+        const rangeStart = tokenBefore ? tokenBefore.range[1] : node2.range[0];
+        const range = [rangeStart, node2.range[1]];
+        const tokenAfter = sourceCode.getTokenAfter(node2);
+        const hasElseAfter = tokenAfter && tokenAfter.value === "else";
+        const replacementText = getReplacementText(
+          statementText,
+          baseIndent,
+          hasElseAfter
+        );
+        return fixer.replaceTextRange(range, replacementText);
+      },
+      messageId: "unnecessaryBraces",
+      node: node2
+    });
+  }
+}
+function detectIndentStep(sourceCode) {
+  const text = sourceCode.getText();
+  const lines = text.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]) {
+    const isMultipleOfStep = sortedIndents.every(([n]) => n % step === 0);
+    if (isMultipleOfStep)
+      return step;
+  }
+  return minIndent;
+}
+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");
+}
+function checkNonBlockStatement(node2, context) {
+  if (node2.type === "BlockStatement")
+    return;
+  const sourceCode = context.getSourceCode();
+  if (!isSingleLineStatement(node2, sourceCode)) {
+    context.report({
+      fix(fixer) {
+        const statementText = sourceCode.getText(node2);
+        const parent = node2.parent;
+        const parentLine = parent?.loc?.start?.line ?? node2.loc?.start?.line ?? 1;
+        const baseIndent = getLineIndent$1(sourceCode, parentLine);
+        const indentStepSize = detectIndentStep(sourceCode);
+        const indentStep = " ".repeat(indentStepSize);
+        const reindentedText = reindentText(
+          statementText,
+          baseIndent,
+          indentStep
+        );
+        const fixed = `{
+${reindentedText}
+${baseIndent}}`;
+        return [fixer.replaceText(node2, fixed)];
+      },
+      messageId: "missingBraces",
+      node: node2
+    });
+  }
+}
+function checkDoWhileStatement(node2, context) {
+  if (node2.body.type === "BlockStatement")
+    checkBlockStatement(node2.body, context);
+  else
+    checkNonBlockStatement(node2.body, context);
+}
+function checkForInStatement(node2, context) {
+  if (node2.body.type === "BlockStatement")
+    checkBlockStatement(node2.body, context);
+  else
+    checkNonBlockStatement(node2.body, context);
+}
+function checkForOfStatement(node2, context) {
+  if (node2.body.type === "BlockStatement")
+    checkBlockStatement(node2.body, context);
+  else
+    checkNonBlockStatement(node2.body, context);
+}
+function checkForStatement(node2, context) {
+  if (node2.body.type === "BlockStatement")
+    checkBlockStatement(node2.body, context);
+  else
+    checkNonBlockStatement(node2.body, context);
+}
+function checkIfStatement(node2, context) {
+  if (node2.consequent.type === "BlockStatement")
+    checkBlockStatement(node2.consequent, context);
+  else
+    checkNonBlockStatement(node2.consequent, context);
+  if (!node2.alternate)
+    return;
+  if (node2.alternate.type === "IfStatement")
+    return;
+  if (node2.alternate.type === "BlockStatement")
+    checkBlockStatement(node2.alternate, context);
+  else
+    checkNonBlockStatement(node2.alternate, context);
+}
+function checkWhileStatement(node2, context) {
+  if (node2.body.type === "BlockStatement")
+    checkBlockStatement(node2.body, context);
+  else
+    checkNonBlockStatement(node2.body, context);
+}
+const noUnnecessaryBraces = {
+  create(context) {
+    return {
+      DoWhileStatement: (node2) => checkDoWhileStatement(node2, context),
+      ForInStatement: (node2) => checkForInStatement(node2, context),
+      ForOfStatement: (node2) => checkForOfStatement(node2, context),
+      ForStatement: (node2) => checkForStatement(node2, context),
+      IfStatement: (node2) => checkIfStatement(node2, context),
+      WhileStatement: (node2) => checkWhileStatement(node2, 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"
+  }
+};
+function isShorthandProperty(property) {
+  return property.shorthand;
+}
+function areAllShorthand(properties) {
+  return properties.every(isShorthandProperty);
+}
+function getPropertyText(sourceCode, property) {
+  return sourceCode.getText(property);
+}
+function getInlineObjectLength(sourceCode, properties) {
+  if (properties.length === 0)
+    return 2;
+  const propLengths = properties.map((p) => getPropertyText(sourceCode, p).length);
+  const propsTotal = propLengths.reduce((a, b) => a + b, 0);
+  const commas = Math.max(0, properties.length - 1);
+  return 2 + propsTotal + commas;
+}
+function checkMultiline(sourceCode, context, node2, braces, maxLength) {
+  const properties = node2.properties;
+  const allShorthand = areAllShorthand(properties);
+  if (!allShorthand)
+    return;
+  const inlineLength = getInlineObjectLength(sourceCode, properties);
+  if (inlineLength > 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(node2, `{${names.join(", ")}}`);
+    },
+    messageId: "multilineCanBeSingleLine",
+    node: properties[0]
+  });
+}
+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")
+  );
+}
+function getPropertyName(sourceCode, prop) {
+  if (prop.key.type === "Identifier")
+    return prop.key.name;
+  return sourceCode.getText(prop);
+}
+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(", ")}}`
+  );
+}
+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;
+}
+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;
+}
+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]
+  });
+}
+const defaultOptions$2 = {
+  maxLength: 80
+};
+function getBraces(sourceCode, node2) {
+  const properties = node2.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 };
+}
+function checkObject(sourceCode, context, node2) {
+  const options = context.options[0] ?? {};
+  const maxLength = options.maxLength ?? defaultOptions$2.maxLength;
+  const properties = node2.properties;
+  if (properties.length === 0)
+    return;
+  const braces = getBraces(sourceCode, node2);
+  if (!braces)
+    return;
+  const firstLine = braces.openingBrace.loc.start.line;
+  const lastLine = braces.closingBrace.loc.end.line;
+  if (firstLine === lastLine)
+    checkSingleLine(sourceCode, context, properties, braces, maxLength);
+  else
+    checkMultiline(sourceCode, context, node2, braces, maxLength);
+}
+const messageIds$3 = {
+  mixedPropertiesNotAllowed: "mixedPropertiesNotAllowed",
+  multilineCanBeSingleLine: "multilineCanBeSingleLine",
+  singleLineExceedsMaxLength: "singleLineExceedsMaxLength"
+};
+const objectPropertyLineBreak = {
+  create(context) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    return {
+      ObjectExpression(node2) {
+        checkObject(sourceCode, context, node2);
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Enforce object literal formatting based on complexity and line length."
+    },
+    fixable: "code",
+    messages: messageIds$3,
+    schema: [{
+      additionalProperties: false,
+      properties: {
+        maxLength: {
+          type: "number"
+        }
+      },
+      type: "object"
+    }],
+    type: "layout"
+  }
+};
+const messageIds$2 = {
+  tooManyExports: "Only one export is allowed per file. Found {{count}} exports."
+};
+const 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: messageIds$2,
+    schema: [],
+    type: "suggestion"
+  }
+};
+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);
+}
+function canInlineSpecifiers(specifiers, localDeclarations) {
+  return specifiers.every(
+    (spec) => isValidExportSpecifier(spec, localDeclarations)
+  );
+}
+function getDeclarationName(node2) {
+  if (node2.type !== "VariableDeclaration")
+    return node2.id?.name ?? null;
+  const declarations = node2.declarations;
+  if (declarations.length === 1) {
+    const id = declarations[0].id;
+    if (id.type === "Identifier")
+      return id.name;
+  }
+  return null;
+}
+function isExportableDeclaration(node2) {
+  const type = node2.type;
+  return type === "TSInterfaceDeclaration" || type === "TSTypeAliasDeclaration" || type === "ClassDeclaration" || type === "FunctionDeclaration" || type === "VariableDeclaration";
+}
+const preferInlineExport = {
+  create(context) {
+    const localDeclarations = /* @__PURE__ */ new Map();
+    function visitDeclaration(node2) {
+      if (!isExportableDeclaration(node2))
+        return;
+      const name = getDeclarationName(node2);
+      if (name)
+        localDeclarations.set(name, { name, node: node2 });
+    }
+    return {
+      ClassDeclaration: visitDeclaration,
+      ExportNamedDeclaration(node2) {
+        if (node2.source)
+          return;
+        if (!node2.specifiers || node2.specifiers.length === 0)
+          return;
+        if (!canInlineSpecifiers(node2.specifiers, localDeclarations))
+          return;
+        context.report({
+          fix(fixer) {
+            const fixes = [];
+            for (const specifier of node2.specifiers) {
+              const name = specifier.local.name;
+              const decl = localDeclarations.get(name);
+              if (decl)
+                fixes.push(fixer.insertTextBefore(decl.node, "export "));
+            }
+            fixes.push(fixer.remove(node2));
+            return fixes;
+          },
+          messageId: "preferInline",
+          node: node2
+        });
+      },
+      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"
+  }
+};
+function buildCollapsedParams(sourceCode, params) {
+  const paramsText = params.map((param, index) => {
+    const text = sourceCode.getText(param);
+    const isLastParam = index === params.length - 1;
+    return isLastParam ? text : text + ",";
+  }).join(" ");
+  return `(${paramsText})`;
+}
+function calculateCollapsedLength(sourceCode, openingParen, collapsedParams, returnType) {
+  let returnTypeText = "";
+  if (returnType)
+    returnTypeText = sourceCode.getText(returnType);
+  const allLines = sourceCode.getText().split("\n");
+  const closingLine = allLines[openingParen.loc.start.line - 1];
+  const textAfterClosingParen = closingLine.slice(openingParen.loc.start.column);
+  return openingParen.loc.start.column + collapsedParams.length + returnTypeText.length + textAfterClosingParen.length;
+}
+const defaultOptions$1 = {
+  maxLength: 80
+};
+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 };
+}
+function isShorthand(sourceCode, node2) {
+  if (node2.params.length !== 1)
+    return false;
+  const firstParam = node2.params[0];
+  const tokenBefore = sourceCode.getTokenBefore(firstParam);
+  return !tokenBefore || tokenBefore.value !== "(";
+}
+function reportViolation(context, node2, collapsedParams, returnTypeText, arrowToken, openingParen) {
+  context.report({
+    fix: (fixer) => fixer.replaceTextRange(
+      [openingParen.range[0], arrowToken.range[1]],
+      collapsedParams + returnTypeText + " =>"
+    ),
+    messageId: "singleLine",
+    node: node2
+  });
+}
+function checkArrowFunction(sourceCode, context, node2) {
+  const options = context.options[0] ?? {};
+  const maxLength = options.maxLength ?? defaultOptions$1.maxLength;
+  if (isShorthand(sourceCode, node2))
+    return;
+  const parens = getArrowFunctionParens(sourceCode, node2.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, node2.params);
+  const collapsedLength = calculateCollapsedLength(
+    sourceCode,
+    openingParen,
+    collapsedParams,
+    node2.returnType
+  );
+  if (collapsedLength <= maxLength) {
+    const returnTypeText = node2.returnType ? sourceCode.getText(node2.returnType) : "";
+    reportViolation(
+      context,
+      node2,
+      collapsedParams,
+      returnTypeText,
+      arrowToken,
+      openingParen
+    );
+  }
+}
+const messageIds$1 = {
+  singleLine: "Arrow function parameters can be on a single line"
+};
+const singleLineArrowFunctionParameters = {
+  create(context) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    return {
+      ArrowFunctionExpression(node2) {
+        if (node2.params.length === 0)
+          return;
+        checkArrowFunction(sourceCode, context, node2);
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Enforce arrow function parameters to be on a single line when they fit."
+    },
+    fixable: "code",
+    messages: messageIds$1,
+    schema: [{
+      additionalProperties: false,
+      properties: {
+        maxLength: {
+          type: "number"
+        }
+      },
+      type: "object"
+    }],
+    type: "layout"
+  }
+};
+const defaultOptions = {
+  maxLength: 80
+};
+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 };
+}
+function checkFunction(sourceCode, context, node2) {
+  const options = context.options[0] ?? {};
+  const maxLength = options.maxLength ?? defaultOptions.maxLength;
+  const params = node2.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);
+    const isLastParam = index === params.length - 1;
+    if (isLastParam)
+      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) : "";
+  const singleLineLength = parens.openingParen.loc.start.column + 1 + paramsText.length + 1 + closingLineText.length;
+  if (singleLineLength <= maxLength) {
+    context.report({
+      fix: (fixer) => fixer.replaceTextRange(
+        [parens.openingParen.range[0], parens.closingParen.range[1]],
+        `(${paramsText})`
+      ),
+      messageId: "singleLine",
+      node: node2
+    });
+  }
+}
+const messageIds = {
+  singleLine: "Function parameters can be on a single line"
+};
+const singleLineFunctionParameters = {
+  create(context) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    return {
+      FunctionDeclaration(node2) {
+        checkFunction(sourceCode, context, node2);
+      },
+      FunctionExpression(node2) {
+        checkFunction(sourceCode, context, node2);
+      },
+      TSCallSignatureDeclaration(node2) {
+        checkFunction(sourceCode, context, node2);
+      },
+      TSFunctionType(node2) {
+        checkFunction(sourceCode, context, node2);
+      },
+      TSMethodSignature(node2) {
+        checkFunction(sourceCode, context, node2);
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Enforce function parameters to be on a single line when they fit."
+    },
+    fixable: "code",
+    messages: messageIds,
+    schema: [{
+      additionalProperties: false,
+      properties: {
+        maxLength: {
+          type: "number"
+        }
+      },
+      type: "object"
+    }],
+    type: "layout"
+  }
+};
 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(", ")}}`;
+  if (attributes.length === 0)
+    return "";
+  const formatted = attributes.map(
+    (attr) => {
+      const key = attr.key.type === "Identifier" ? attr.key.name : attr.key.value;
+      const value = attr.value.value;
+      return `${key}: '${value}'`;
+    }
+  ).join(", ");
+  return ` with {${formatted}}`;
 }
-//#endregion
-//#region src/rules/singleLineImports/formatNamed.ts
 function formatNamed(specifiers, sourceCode) {
-	return specifiers.map((s) => sourceCode.getText(s)).join(", ");
+  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/createFix.ts
-function createFix$3(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/isMultiline.ts
-function isMultiline$1(declaration) {
-	const { start, end } = declaration.loc ?? {};
-	return start?.line !== end?.line;
-}
-//#endregion
-//#region src/rules/singleLineImports/index.ts
+  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)}}`;
+}
+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 result2 = `${prefix}'${source}'${attributes}`;
+    return fixer.replaceText(declaration, result2);
+  }
+  const result = `${prefix}${specifiers} from '${source}'${attributes}`;
+  return fixer.replaceText(declaration, result);
+}
+function isMultilineImport(declaration) {
+  const { end, start } = declaration.loc ?? {};
+  return start?.line !== end?.line;
+}
 const singleLineImports = {
-	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"
-	},
-	create(context) {
-		return { ImportDeclaration(node) {
-			if (!isMultiline$1(node)) return;
-			context.report({
-				node,
-				messageId: "multiline",
-				fix: (fixer) => createFix$3(fixer, node, context.sourceCode)
-			});
-		} };
-	}
-};
-//#endregion
-//#region src/rules/singleLineReExports/createFix.ts
-function createFix$2(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/isMultiline.ts
-function isMultiline(declaration) {
-	const { start, end } = declaration.loc ?? {};
-	return start?.line !== end?.line;
-}
-//#endregion
-//#region src/rules/singleLineReExports/index.ts
+  create(context) {
+    return {
+      ImportDeclaration(node2) {
+        if (!isMultilineImport(node2))
+          return;
+        context.report({
+          fix: (fixer) => createImportFix$1(fixer, node2, context.sourceCode),
+          messageId: "multiline",
+          node: node2
+        });
+      }
+    };
+  },
+  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"
+  }
+};
+function createReExportFix$1(fixer, declaration, sourceCode) {
+  const source = declaration.source.value;
+  if (declaration.type === "ExportAllDeclaration") {
+    const exported = declaration.exported ? `* as ${sourceCode.getText(declaration.exported)}` : "*";
+    const attributes2 = formatAttributes(declaration.attributes);
+    const result2 = `export ${exported} from '${source}'${attributes2}`;
+    return fixer.replaceText(declaration, result2);
+  }
+  const prefix = declaration.exportKind === "type" ? "export type " : "export ";
+  const specifiers = declaration.specifiers.map(
+    (s) => sourceCode.getText(s)
+  ).join(", ");
+  const attributes = formatAttributes(declaration.attributes);
+  const result = `${prefix}{${specifiers}} from '${source}'${attributes}`;
+  return fixer.replaceText(declaration, result);
+}
+function isMultilineReExport(declaration) {
+  const { end, start } = declaration.loc ?? {};
+  return start?.line !== end?.line;
+}
 const singleLineReExports = {
-	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"
-	},
-	create(context) {
-		const checkDeclaration = (node, declaration) => {
-			if (!declaration.source) return;
-			if (!isMultiline(declaration)) return;
-			context.report({
-				node,
-				messageId: "multiline",
-				fix: (fixer) => createFix$2(fixer, declaration, context.sourceCode)
-			});
-		};
-		return {
-			ExportNamedDeclaration: (node) => checkDeclaration(node, node),
-			ExportAllDeclaration: (node) => checkDeclaration(node, node)
-		};
-	}
-};
-//#endregion
-//#region src/rules/sortedImports/categorizeImport.ts
+  create(context) {
+    const checkDeclaration = (node2, declaration) => {
+      if (!declaration.source)
+        return;
+      if (!isMultilineReExport(declaration))
+        return;
+      context.report({
+        fix: (fixer) => createReExportFix$1(fixer, declaration, context.sourceCode),
+        messageId: "multiline",
+        node: node2
+      });
+    };
+    return {
+      ExportAllDeclaration: (node2) => {
+        checkDeclaration(node2, node2);
+      },
+      ExportNamedDeclaration: (node2) => {
+        checkDeclaration(node2, node2);
+      }
+    };
+  },
+  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"
+  }
+};
 function categorizeImport(declaration) {
-	if (declaration.importKind === "type") return "type";
-	if (declaration.specifiers.length === 0) return "side-effect";
-	if (declaration.specifiers.some((s) => s.type === "ImportNamespaceSpecifier")) return "namespace";
-	if (declaration.specifiers.some((s) => s.type === "ImportDefaultSpecifier")) return "default";
-	return "named";
-}
-//#endregion
-//#region src/rules/sortedImports/getSortKey.ts
-function getSortKey$1(declaration) {
-	const group = categorizeImport(declaration);
-	if (group === "side-effect") return declaration.source.value;
-	if (group === "namespace") return `*${declaration.specifiers.find((s) => s.type === "ImportNamespaceSpecifier")?.local.name ?? ""}`;
-	if (group === "default") return declaration.specifiers.find((s) => s.type === "ImportDefaultSpecifier")?.local.name ?? "";
-	return declaration.specifiers[0].local.name;
-}
-//#endregion
-//#region src/rules/sortedImports/categorizeImports.ts
+  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";
+}
+function getImportSortKey(declaration) {
+  const group = categorizeImport(declaration);
+  if (group === "side-effect")
+    return declaration.source.value;
+  if (group === "namespace" || group === "type-namespace") {
+    const namespaceSpecifier = declaration.specifiers.find(
+      (s) => s.type === "ImportNamespaceSpecifier"
+    );
+    return `*${namespaceSpecifier?.local.name ?? ""}`;
+  }
+  if (group === "default" || group === "type-default") {
+    const defaultSpecifier = declaration.specifiers.find(
+      (s) => s.type === "ImportDefaultSpecifier"
+    );
+    return defaultSpecifier?.local.name ?? "";
+  }
+  const specifier = declaration.specifiers[0];
+  return specifier.local.name;
+}
 function categorizeImports(declarations) {
-	return declarations.map((declaration) => ({
-		declaration,
-		group: categorizeImport(declaration),
-		sortKey: getSortKey$1(declaration)
-	}));
-}
-//#endregion
-//#region src/lib/compare.ts
+  return declarations.map((declaration) => ({
+    declaration,
+    group: categorizeImport(declaration),
+    sortKey: getImportSortKey(declaration)
+  }));
+}
 function compare(a, b) {
-	return a.localeCompare(b, "en", { sensitivity: "case" });
+  return a.localeCompare(b, "en", { sensitivity: "case" });
 }
-//#endregion
-//#region src/rules/sortedImports/ImportGroupOrder.ts
 const importGroupOrder = [
-	"side-effect",
-	"namespace",
-	"default",
-	"named",
-	"type"
+  "side-effect",
+  "namespace",
+  "default",
+  "named",
+  "type-namespace",
+  "type-default",
+  "type-named"
 ];
-//#endregion
-//#region src/rules/sortedImports/checkAlphabeticalSorting.ts
-function checkAlphabeticalSorting$1(categorized) {
-	const errors = [];
-	for (const group of importGroupOrder) {
-		const groupImports = categorized.filter((c) => c.group === group);
-		const sorted = [...groupImports].sort((a, b) => compare(a.sortKey, b.sortKey));
-		for (let i = 0; i < groupImports.length; i++) if (groupImports[i] !== sorted[i]) errors.push({
-			node: groupImports[i].declaration,
-			messageId: "sortedImports"
-		});
-	}
-	return errors;
-}
-//#endregion
-//#region src/rules/sortedImports/checkGroupOrdering.ts
-function checkGroupOrdering$1(categorized) {
-	const errors = [];
-	let currentGroupIndex = -1;
-	for (const { declaration, group } of categorized) {
-		const groupIndex = importGroupOrder.indexOf(group);
-		if (groupIndex < currentGroupIndex) errors.push({
-			node: declaration,
-			messageId: "wrongGroup"
-		});
-		else currentGroupIndex = groupIndex;
-	}
-	return errors;
-}
-//#endregion
-//#region src/rules/sortedImports/getSpecifierName.ts
-function getSpecifierName$1(specifier) {
-	return specifier.imported.type === "Identifier" ? specifier.imported.name : String(specifier.imported.value);
-}
-//#endregion
-//#region src/rules/sortedImports/areSpecifiersSorted.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;
+}
+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;
+}
+function getImportSpecifierName(specifier) {
+  return specifier.imported.type === "Identifier" ? specifier.imported.name : String(specifier.imported.value);
+}
 function areSpecifiersSorted$1(specifiers) {
-	const names = specifiers.map((s) => getSpecifierName$1(s));
-	const sorted = [...names].sort((a, b) => compare(a, b));
-	return names.every((name, i) => name === sorted[i]);
+  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/getNamedSpecifiers.ts
-function getNamedSpecifiers$1(declaration) {
-	return declaration.specifiers.filter((s) => s.type === "ImportSpecifier");
+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 namedImports = categorized.filter((c) => c.group === "named");
-	for (const { declaration } of namedImports) {
-		const specifiers = getNamedSpecifiers$1(declaration);
-		if (specifiers.length > 1 && !areSpecifiersSorted$1(specifiers)) errors.push({
-			node: declaration,
-			messageId: "sortedNames"
-		});
-	}
-	return errors;
-}
-//#endregion
-//#region src/rules/sortedImports/sortSpecifiersText.ts
-function sortSpecifiersText$1(specifiers, sourceCode) {
-	return [...specifiers].sort((a, b) => {
-		return compare(getSpecifierName$1(a), getSpecifierName$1(b));
-	}).map((s) => sourceCode.getText(s)).join(", ");
-}
-//#endregion
-//#region src/rules/sortedImports/createFix/formatNamedImport.ts
-function formatNamedImport(declaration, sourceCode) {
-	const specifiers = getNamedSpecifiers$1(declaration);
-	if (specifiers.length > 1 && !areSpecifiersSorted$1(specifiers)) {
-		const sortedSpecifiers = sortSpecifiersText$1(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/buildSortedCode.ts
-function buildSortedCode$1(grouped, sourceCode) {
-	const sortedCode = [];
-	for (const group of importGroupOrder) for (const { declaration } of grouped[group]) if (group === "named" || group === "type") sortedCode.push(formatNamedImport(declaration, sourceCode));
-	else sortedCode.push(sourceCode.getText(declaration));
-	return sortedCode;
-}
-//#endregion
-//#region src/rules/sortedImports/createFix/groupImportsByType.ts
+  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;
+}
+function sortImportSpecifiersText(specifiers, sourceCode) {
+  const sorted = [...specifiers].sort((a, b) => {
+    const nameA = getImportSpecifierName(a);
+    const nameB = getImportSpecifierName(b);
+    return compare(nameA, nameB);
+  });
+  return sorted.map((s) => sourceCode.getText(s)).join(", ");
+}
+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;
+    const prefix = declaration.importKind === "type" ? "import type " : "import ";
+    return `${prefix}{${sortedSpecifiers}} from '${source}'`;
+  }
+  return sourceCode.getText(declaration);
+}
+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;
+}
 function groupImportsByType(categorized) {
-	const grouped = {
-		"side-effect": [],
-		namespace: [],
-		default: [],
-		named: [],
-		type: []
-	};
-	for (const item of categorized) grouped[item.group].push(item);
-	return grouped;
-}
-//#endregion
-//#region src/rules/sortedImports/createFix/sortImportGroups.ts
+  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;
+}
 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"].sort((a, b) => compare(a.sortKey, b.sortKey));
-}
-//#endregion
-//#region src/rules/sortedImports/createFix/index.ts
+  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));
+}
 function createFixForGroup$1(fixer, importDeclarations, sourceCode) {
-	if (importDeclarations.length === 0) return null;
-	const grouped = groupImportsByType(categorizeImports(importDeclarations));
-	sortImportGroups(grouped);
-	const sortedCode = buildSortedCode$1(grouped, sourceCode).join("\n");
-	const firstImport = importDeclarations[0];
-	const lastImport = importDeclarations[importDeclarations.length - 1];
-	return fixer.replaceTextRange([firstImport.range[0], lastImport.range[1]], sortedCode);
-}
-function createFix$1(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
+  if (importDeclarations.length === 0)
+    return null;
+  const categorized = categorizeImports(importDeclarations);
+  const grouped = groupImportsByType(categorized);
+  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
+  );
+}
+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;
+}
 function getImportGroups(programBody) {
-	const groups = [];
-	let currentGroup = [];
-	for (const statement of programBody) {
-		if (statement.type === "ImportDeclaration") {
-			currentGroup.push(statement);
-			continue;
-		}
-		if (currentGroup.length > 0) {
-			groups.push(currentGroup);
-			currentGroup = [];
-		}
-	}
-	if (currentGroup.length > 0) groups.push(currentGroup);
-	return groups;
-}
-//#endregion
-//#region src/rules/sortedImports/index.ts
+  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;
+}
 const sortedImports = {
-	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"
-	},
-	create(context) {
-		return { Program(node) {
-			const body = node.body;
-			const importGroups = getImportGroups(body);
-			if (importGroups.length === 0) return;
-			const allErrors = [];
-			for (const group of importGroups) {
-				const categorized = categorizeImports(group);
-				const errors = [
-					...checkGroupOrdering$1(categorized),
-					...checkAlphabeticalSorting$1(categorized),
-					...checkSpecifiersSorting$1(categorized)
-				];
-				allErrors.push(...errors);
-			}
-			for (const error of allErrors) context.report({
-				node: error.node,
-				messageId: error.messageId,
-				fix(fixer) {
-					const sourceCode = context.sourceCode;
-					return createFix$1(fixer, importGroups, sourceCode);
-				}
-			});
-		} };
-	}
-};
-//#endregion
-//#region src/rules/sortedReExports/categorizeReExport.ts
+  create(context) {
+    return {
+      Program(node2) {
+        const programBody = node2.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"
+  }
+};
 function categorizeReExport(declaration) {
-	if (declaration.type === "ExportAllDeclaration") {
-		if (declaration.exported) return "re-export-namespace";
-		return "re-export-all";
-	}
-	if (declaration.exportKind === "type") return "re-export-type";
-	return "re-export-named";
-}
-//#endregion
-//#region src/rules/sortedReExports/getSortKey.ts
-function getSortKey(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
+  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";
+}
+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;
+}
 function categorizeReExports(declarations) {
-	return declarations.map((declaration) => {
-		return {
-			declaration,
-			group: categorizeReExport(declaration),
-			sortKey: getSortKey(declaration)
-		};
-	});
-}
-//#endregion
-//#region src/rules/sortedReExports/ReExportGroupOrder.ts
+  return declarations.map((declaration) => {
+    return {
+      declaration,
+      group: categorizeReExport(declaration),
+      sortKey: getReExportSortKey(declaration)
+    };
+  });
+}
 const reExportGroupOrder = [
-	"re-export-all",
-	"re-export-namespace",
-	"re-export-named",
-	"re-export-type"
+  "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({
-			node: groupReExports[i].declaration,
-			messageId: "sortedReExports"
-		});
-	}
-	return errors;
-}
-//#endregion
-//#region src/rules/sortedReExports/checkGroupOrdering.ts
+  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;
+}
 function checkGroupOrdering(categorized) {
-	const errors = [];
-	let currentGroupIndex = -1;
-	for (const { declaration, group } of categorized) {
-		const groupIndex = reExportGroupOrder.indexOf(group);
-		if (groupIndex < currentGroupIndex) errors.push({
-			node: declaration,
-			messageId: "wrongGroup"
-		});
-		else currentGroupIndex = groupIndex;
-	}
-	return errors;
-}
-//#endregion
-//#region src/rules/sortedReExports/getSpecifierName.ts
+  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;
+}
 function getSpecifierName(specifier) {
-	return specifier.local.type === "Identifier" ? specifier.local.name : String(specifier.local.value);
+  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]);
+  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/getNamedSpecifiers.ts
-function getNamedSpecifiers(declaration) {
-	return declaration.specifiers.filter((s) => s.type === "ExportSpecifier" && s.local.type === "Identifier");
+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";
+  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 = getNamedSpecifiers(declaration);
-		const isSorted = areSpecifiersSorted(specifiers);
-		if (specifiers.length > 1 && !isSorted) errors.push({
-			node: declaration,
-			messageId: "sortedNames"
-		});
-	}
-	return errors;
-}
-//#endregion
-//#region src/rules/sortedReExports/sortSpecifiersText.ts
+  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;
+}
 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/formatNamedReExport.ts
-function formatNamedReExport(declaration, sourceCode) {
-	const specifiers = getNamedSpecifiers(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/buildSortedCode.ts
-function buildSortedCode(grouped, sourceCode) {
-	const sortedCode = [];
-	for (const group of reExportGroupOrder) for (const item of grouped[group]) if (isNamedReExport(item)) sortedCode.push(formatNamedReExport(item.declaration, sourceCode));
-	else sortedCode.push(sourceCode.getText(item.declaration));
-	return sortedCode;
-}
-//#endregion
-//#region src/rules/sortedReExports/createFix/groupReExportsByType.ts
+  const sorted = [...specifiers].sort((a, b) => {
+    const nameA = getSpecifierName(a);
+    const nameB = getSpecifierName(b);
+    return compare(nameA, nameB);
+  });
+  return sorted.map((s) => sourceCode.getText(s)).join(", ");
+}
+function formatNamedReExportSpecifiers(declaration, sourceCode) {
+  const specifiers = getReExportNamedSpecifiers(declaration);
+  if (specifiers.length > 1 && !areSpecifiersSorted(specifiers)) {
+    const sortedSpecifiers = sortSpecifiersText(specifiers, sourceCode);
+    const source = declaration.source.value;
+    const prefix = declaration.exportKind === "type" ? "export type " : "export ";
+    return `${prefix}{${sortedSpecifiers}} from '${source}'`;
+  }
+  return sourceCode.getText(declaration);
+}
+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;
+}
 function groupReExportsByType(categorized) {
-	const grouped = {
-		"re-export-all": [],
-		"re-export-namespace": [],
-		"re-export-named": [],
-		"re-export-type": []
-	};
-	for (const item of categorized) grouped[item.group].push(item);
-	return grouped;
-}
-//#endregion
-//#region src/rules/sortedReExports/createFix/sortExportGroups.ts
+  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;
+}
 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["re-export-type"].sort((a, b) => compare(a.sortKey, b.sortKey));
+  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/index.ts
 function createFixForGroup(fixer, reExportDeclarations, sourceCode) {
-	if (reExportDeclarations.length === 0) return null;
-	const grouped = groupReExportsByType(categorizeReExports(reExportDeclarations));
-	sortExportGroups(grouped);
-	const sortedCode = buildSortedCode(grouped, sourceCode).join("\n");
-	const firstReExport = reExportDeclarations[0];
-	const lastReExport = reExportDeclarations[reExportDeclarations.length - 1];
-	return fixer.replaceTextRange([firstReExport.range[0], lastReExport.range[1]], sortedCode);
-}
-function createFix(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/getReExportGroups.ts
+  if (reExportDeclarations.length === 0)
+    return null;
+  const categorized = categorizeReExports(reExportDeclarations);
+  const grouped = groupReExportsByType(categorized);
+  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
+  );
+}
+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;
+}
 function isReExportDeclaration(statement) {
-	return statement.type === "ExportNamedDeclaration" && statement.source !== null || statement.type === "ExportAllDeclaration";
+  return statement.type === "ExportNamedDeclaration" && statement.source !== null || statement.type === "ExportAllDeclaration";
 }
 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/rules/sortedReExports/index.ts
+  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;
+}
 const sortedReExports = {
-	meta: {
-		docs: { description: "Enforce sorted exports alphabetically" },
-		fixable: "code",
-		messages: {
-			sortedReExports: "Exports should be sorted alphabetically",
-			sortedNames: "Named exports should be sorted alphabetically",
-			wrongGroup: "Export is in wrong group"
-		},
-		schema: [],
-		type: "suggestion"
-	},
-	create(context) {
-		return { Program(node) {
-			const body = node.body;
-			const reExportGroups = getReExportGroups(body);
-			if (reExportGroups.length === 0) return;
-			const allErrors = [];
-			for (const group of reExportGroups) {
-				const categorized = categorizeReExports(group);
-				const errors = [
-					...checkGroupOrdering(categorized),
-					...checkAlphabeticalSorting(categorized),
-					...checkSpecifiersSorting(categorized)
-				];
-				allErrors.push(...errors);
-			}
-			for (const error of allErrors) context.report({
-				node: error.node,
-				messageId: error.messageId,
-				fix(fixer) {
-					const sourceCode = context.sourceCode;
-					return createFix(fixer, reExportGroups, sourceCode);
-				}
-			});
-		} };
-	}
-};
-//#endregion
-//#region src/index.ts
-const CONFIG = [
-	{ ignores: [
-		"src/graphql/sdk.ts",
-		"**/node_modules/**",
-		"**/dist/**"
-	] },
-	{ settings: { react: { version: "19" } } },
-	eslint.configs.recommended,
-	react.configs.flat.recommended,
-	stylistic.configs.recommended,
-	...typescript.configs.recommended,
-	...typescript.configs.stylistic,
-	{
-		plugins: { "react-hooks": reactHooks },
-		rules: reactHooks.configs.recommended.rules
-	},
-	{
-		plugins: { "@borela-tech": { rules: {
-			"imports-and-re-exports-at-top": importsAndReExportsAtTop,
-			"individual-imports": individualImports,
-			"individual-re-exports": individualReExports,
-			"multiline-union-types": multilineUnionTypes,
-			"single-line-imports": singleLineImports,
-			"single-line-re-exports": singleLineReExports,
-			"sorted-imports": sortedImports,
-			"sorted-re-exports": sortedReExports
-		} } },
-		rules: {
-			"@borela-tech/imports-and-re-exports-at-top": "error",
-			"@borela-tech/individual-imports": "error",
-			"@borela-tech/individual-re-exports": "error",
-			"@borela-tech/multiline-union-types": "error",
-			"@borela-tech/single-line-imports": "error",
-			"@borela-tech/single-line-re-exports": "error",
-			"@borela-tech/sorted-imports": "error",
-			"@borela-tech/sorted-re-exports": "error"
-		}
-	},
-	{ rules: {
-		"capitalized-comments": [
-			"error",
-			"always",
-			{ ignoreConsecutiveComments: true }
-		],
-		"react/react-in-jsx-scope": "off",
-		"@stylistic/arrow-parens": ["error", "as-needed"],
-		"@stylistic/array-bracket-newline": ["error", "consistent"],
-		"@stylistic/array-bracket-spacing": ["error", "never"],
-		"@stylistic/array-element-newline": ["error", "consistent"],
-		"@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": ["error", { consistent: true }],
-		"@stylistic/object-curly-spacing": ["error", "never"],
-		"@stylistic/operator-linebreak": [
-			"error",
-			"before",
-			{ overrides: { "=": "after" } }
-		],
-		"@stylistic/quotes": [
-			"error",
-			"single",
-			{ avoidEscape: true }
-		],
-		"@stylistic/quote-props": ["error", "as-needed"],
-		"@stylistic/semi": [
-			"error",
-			"never",
-			{ beforeStatementContinuationChars: "always" }
-		],
-		"@typescript-eslint/no-empty-function": "off",
-		"@typescript-eslint/consistent-indexed-object-style": "off",
-		"@typescript-eslint/consistent-type-imports": ["error", { fixStyle: "separate-type-imports" }]
-	} }
+  create(context) {
+    return {
+      Program(node2) {
+        const programBody = node2.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"
+  }
+};
+const 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": sortedReExports
+      }
+    }
+  },
+  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"
+  }
+};
+const generalRules = {
+  rules: {
+    "capitalized-comments": [
+      "error",
+      "always",
+      { ignoreConsecutiveComments: true }
+    ],
+    complexity: ["error", 10],
+    "no-restricted-exports": ["error", {
+      restrictDefaultExports: {
+        direct: true
+      }
+    }],
+    "react/react-in-jsx-scope": "off"
+  }
+};
+const ignores = {
+  ignores: [
+    "src/graphql/sdk.ts",
+    "**/node_modules/**",
+    "**/dist/**"
+  ]
+};
+const languageOptions = {
+  languageOptions: {
+    parserOptions: {
+      projectService: true
+    }
+  },
+  settings: {
+    react: {
+      version: "19"
+    }
+  }
+};
+const 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"
+    }]
+  }
+};
+const reactHooks = {
+  plugins: {
+    "react-hooks": rule
+  },
+  rules: rule.configs.recommended.rules
+};
+const 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" }
+    ]
+  }
+};
+const 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",
+    "@typescript-eslint/no-empty-function": "off",
+    "@typescript-eslint/no-unused-vars": ["error", {
+      argsIgnorePattern: "^_",
+      caughtErrorsIgnorePattern: "^_",
+      varsIgnorePattern: "^_"
+    }]
+  }
+};
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+const 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 };
+const 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 };
+const 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 };
+const 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 };
+const 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 };
+const 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 };
+const 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}');
+const 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 };
+const 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 };
+const 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 };
+const commonjs = { "exports": true, "global": false, "module": false, "require": false };
+const amd = { "define": false, "require": false };
+const 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 };
+const 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 };
+const 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 };
+const 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 };
+const phantomjs = { "console": true, "exports": true, "phantom": true, "require": true, "WebPage": true };
+const couch = { "emit": false, "exports": false, "getRow": false, "log": false, "module": false, "provides": false, "require": false, "respond": false, "send": false, "start": false, "sum": false };
+const 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 };
+const 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 };
+const 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 };
+const jquery = { "$": false, "jQuery": false };
+const yui = { "YAHOO": false, "YAHOO_config": false, "YUI": false, "YUI_config": false };
+const 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 };
+const 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 };
+const 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 };
+const 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 };
+const applescript = { "$": false, "Application": false, "Automation": false, "console": false, "delay": false, "Library": false, "ObjC": false, "ObjectSpecifier": false, "Path": false, "Progress": false, "Ref": false };
+const 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 };
+const atomtest = { "advanceClock": false, "atom": false, "fakeClearInterval": false, "fakeClearTimeout": false, "fakeSetInterval": false, "fakeSetTimeout": false, "resetTimeouts": false, "waitsForPromise": false };
+const 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 };
+const protractor = { "$": false, "$$": false, "browser": false, "by": false, "By": false, "DartObject": false, "element": false, "protractor": false };
+const webextensions = { "browser": false, "chrome": false, "opr": false };
+const 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 };
+const 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 };
+const require$$0 = {
+  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 globals$1;
+var hasRequiredGlobals;
+function requireGlobals() {
+  if (hasRequiredGlobals) return globals$1;
+  hasRequiredGlobals = 1;
+  globals$1 = require$$0;
+  return globals$1;
+}
+var globalsExports = /* @__PURE__ */ requireGlobals();
+const globals = /* @__PURE__ */ getDefaultExportFromCjs(globalsExports);
+const unicornRules = {
+  languageOptions: {
+    globals: {
+      ...globals.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"
+  }
+};
+const 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.mjs.map
+export {
+  config
+};
+//# sourceMappingURL=index.mjs.map