@saasmakers/eslint 0.1.12 → 0.1.13

package/dist/index.mjs

@@ -1,1161 +1,3 @@
-import { AST_NODE_TYPES } from '@typescript-eslint/utils';
-
-const rule$e = {
-  meta: {
-    docs: {
-      category: "Stylistic Issues",
-      description: "Enforce one-line ternaries if under a character limit, multiline otherwise",
-      recommended: true
-    },
-    fixable: "whitespace",
-    messages: {
-      multiline: "Ternary expression should be multiline when it exceeds max characters.",
-      singleLine: "Ternary expression should be single-line when it is under max characters."
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: { maxCharacters: { type: "number" } },
-        type: "object"
-      }
-    ],
-    type: "layout"
-  },
-  create(context) {
-    const maxCharacters = context.options[0]?.maxCharacters ?? 100;
-    return {
-      ConditionalExpression(node) {
-        if (node.type !== AST_NODE_TYPES.ConditionalExpression) {
-          return;
-        }
-        const sourceCode = context.sourceCode;
-        const ternaryText = sourceCode.getText(node);
-        const isMultiline = ternaryText.includes("\n");
-        const isOverMaxLength = ternaryText.length > maxCharacters;
-        if (isOverMaxLength && !isMultiline) {
-          context.report({
-            fix: (fixer) => {
-              const [
-                test,
-                consequent,
-                alternate
-              ] = [
-                node.test,
-                node.consequent,
-                node.alternate
-              ].map((part) => sourceCode.getText(part));
-              return fixer.replaceText(node, `${test} ?
-  ${consequent} :
-  ${alternate}`);
-            },
-            messageId: "multiline",
-            node
-          });
-        } else if (!isOverMaxLength && isMultiline) {
-          context.report({
-            fix: (fixer) => fixer.replaceText(node, ternaryText.replace(/\s+/g, " ")),
-            messageId: "singleLine",
-            node
-          });
-        }
-      }
-    };
-  }
-};
-
-const rule$d = {
-  meta: {
-    docs: {
-      category: "Stylistic Issues",
-      description: "Enforce multiline formatting for union types with more than N items",
-      recommended: false
-    },
-    fixable: "whitespace",
-    messages: {
-      multiline: "Union type should be multiline when it exceeds max length or has too many items.",
-      singleLine: "Union type should be single-line when it is under max length and has few items."
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          maxLineLength: { type: "number" },
-          minItems: { type: "number" }
-        },
-        type: "object"
-      }
-    ],
-    type: "layout"
-  },
-  create(context) {
-    const minItems = context.options[0]?.minItems ?? 5;
-    const maxLineLength = context.options[0]?.maxLineLength ?? 100;
-    function reportAndFix(node, messageId, fixFunction) {
-      context.report({
-        fix: fixFunction,
-        messageId,
-        node
-      });
-    }
-    return {
-      // @ts-expect-error TSUnionType is not the right type
-      TSUnionType(node) {
-        const sourceCode = context.sourceCode;
-        const unionText = sourceCode.getText(node);
-        const isMultiline = unionText.includes("\n");
-        const isOverMaxLength = unionText.length > maxLineLength;
-        const hasEnoughItems = node.types.length >= minItems;
-        if ((isOverMaxLength || hasEnoughItems) && !isMultiline) {
-          reportAndFix(
-            node,
-            "multiline",
-            (fixer) => {
-              const types = node.types.map((type) => {
-                return sourceCode.getText(type);
-              });
-              return fixer.replaceText(node, `
-  | ${types.join("\n  | ")}`);
-            }
-          );
-        } else if (!isOverMaxLength && !hasEnoughItems && isMultiline) {
-          reportAndFix(
-            node,
-            "singleLine",
-            (fixer) => fixer.replaceText(node, unionText.replace(/\s+\|\s+/g, " | "))
-          );
-        }
-      }
-    };
-  }
-};
-
-const rule$c = {
-  meta: {
-    docs: {
-      category: "Best Practices",
-      description: "Enforce sorted test functions grouped by method with sorted errors, exceptions and middlewares",
-      recommended: true
-    },
-    fixable: "code",
-    messages: { sortError: "Test functions should be grouped by method with sorted errors, exceptions and middlewares." },
-    schema: [],
-    type: "suggestion"
-  },
-  create(context) {
-    if (!context.filename.endsWith(".spec.ts")) {
-      return {};
-    }
-    function getTestName(node) {
-      if (node.arguments && node.arguments[0] && node.arguments[0].type === "Literal") {
-        return node.arguments[0].value;
-      }
-      return "";
-    }
-    function getTestPriority(testName) {
-      if (testName.includes(".middlewares.")) {
-        return 4;
-      }
-      if (testName.includes(".exceptions.")) {
-        return 3;
-      }
-      if (testName.includes(".errors.")) {
-        return 2;
-      }
-      return 1;
-    }
-    function getFunctionName(testName) {
-      const parts = testName.split(".");
-      return parts.slice(0, 2).join(".");
-    }
-    function getSpecificName(testName) {
-      const parts = testName.split(".");
-      const specialIndex = parts.findIndex(
-        (part) => part === "errors" || part === "exceptions" || part === "middlewares"
-      );
-      if (specialIndex === -1) {
-        return parts.slice(2).join(".");
-      }
-      return parts.slice(specialIndex + 1).join(".");
-    }
-    function compareTests(testA, testB) {
-      const functionA = getFunctionName(testA);
-      const functionB = getFunctionName(testB);
-      if (functionA !== functionB) {
-        return functionA.localeCompare(functionB);
-      }
-      const priorityA = getTestPriority(testA);
-      const priorityB = getTestPriority(testB);
-      if (priorityA !== priorityB) {
-        return priorityA - priorityB;
-      }
-      const specificNameA = getSpecificName(testA);
-      const specificNameB = getSpecificName(testB);
-      return specificNameA.localeCompare(specificNameB);
-    }
-    function handleTestGroup(node) {
-      const testGroup = node.arguments[0];
-      if (!testGroup || !node.arguments[1]) {
-        return;
-      }
-      const groupCallback = node.arguments[1];
-      if (groupCallback.type !== "FunctionExpression" && groupCallback.type !== "ArrowFunctionExpression") {
-        return;
-      }
-      const callbackBody = groupCallback.body;
-      if (callbackBody.type !== "BlockStatement" || !callbackBody.body) {
-        return;
-      }
-      const tests = callbackBody.body.filter((statement) => {
-        return statement.type === "ExpressionStatement" && statement.expression.type === "CallExpression" && statement.expression.callee.type === "Identifier" && (statement.expression.callee.name === "test" || statement.expression.callee.name === "it");
-      });
-      const testNames = tests.map((test) => getTestName(test.expression));
-      const sortedTestNames = [...testNames].sort(compareTests);
-      const isSorted = testNames.every(
-        (name, index) => name === sortedTestNames[index]
-      );
-      if (!isSorted) {
-        context.report({
-          fix(fixer) {
-            const testMap = new Map(
-              tests.map((test) => [getTestName(test.expression), test])
-            );
-            const sortedTests = sortedTestNames.map((name) => testMap.get(name));
-            const fixes = [];
-            for (let index = 0; index < tests.length; index++) {
-              const originalTest = tests[index];
-              const sortedTest = sortedTests[index];
-              if (originalTest !== sortedTest) {
-                fixes.push(fixer.replaceText(
-                  originalTest,
-                  context.sourceCode.getText(sortedTest)
-                ));
-              }
-            }
-            return fixes;
-          },
-          loc: node.loc ?? void 0,
-          messageId: "sortError",
-          node
-        });
-      }
-    }
-    return {
-      'CallExpression[callee.name="describe"]': handleTestGroup,
-      'CallExpression[callee.object.name="describe"][callee.property.name="concurrent"]': handleTestGroup,
-      'CallExpression[callee.object.name="test"][callee.property.name="group"]': handleTestGroup
-    };
-  }
-};
-
-const rule$b = {
-  meta: {
-    docs: {
-      category: "Possible Errors",
-      description: "Enforce consistent i18n locale keys across translations",
-      recommended: true
-    },
-    messages: {
-      invalidJson: "Invalid JSON in i18n block: {{error}}",
-      invalidLocale: "Invalid locale: {{locale}}. Allowed locales are: {{allowed}}",
-      missingLocale: "Missing required locale: {{locale}}",
-      missingTranslations: 'Missing translations in "{{locale}}" locale: {{missing}}'
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          locales: {
-            items: { type: "string" },
-            type: "array"
-          }
-        },
-        type: "object"
-      }
-    ],
-    type: "problem"
-  },
-  create(context) {
-    if (!context.filename.endsWith(".vue")) {
-      return {};
-    }
-    const locales = context.options[0]?.locales || ["en", "fr"];
-    return {
-      Program() {
-        const source = context.sourceCode.getText();
-        const i18nMatch = source.match(/(<i18n\s+lang=["']json["']>)([\s\S]*?)(<\/i18n>)/i);
-        if (i18nMatch) {
-          const startOffset = i18nMatch.index + i18nMatch[1].length;
-          const i18nContent = i18nMatch[2].trim();
-          try {
-            const parsed = JSON.parse(i18nContent);
-            for (const locale of locales) {
-              if (!parsed[locale]) {
-                context.report({
-                  data: { locale },
-                  loc: {
-                    end: context.sourceCode.getLocFromIndex(startOffset + i18nContent.length),
-                    start: context.sourceCode.getLocFromIndex(startOffset)
-                  },
-                  messageId: "missingLocale"
-                });
-              }
-            }
-            for (const locale of Object.keys(parsed)) {
-              if (!locales.includes(locale)) {
-                const localeMatch = new RegExp(`"${locale}"\\s*:`, "g").exec(i18nContent);
-                if (localeMatch) {
-                  const localeOffset = startOffset + localeMatch.index;
-                  context.report({
-                    data: {
-                      allowed: locales.join(", "),
-                      locale
-                    },
-                    loc: {
-                      end: context.sourceCode.getLocFromIndex(localeOffset + locale.length + 2),
-                      start: context.sourceCode.getLocFromIndex(localeOffset)
-                    },
-                    messageId: "invalidLocale"
-                  });
-                }
-              }
-            }
-            const allKeys = /* @__PURE__ */ new Set();
-            for (const locale of locales) {
-              if (parsed[locale]) {
-                const keys = getAllKeys(parsed[locale]);
-                keys.forEach((key) => allKeys.add(key));
-              }
-            }
-            for (const locale of locales) {
-              if (parsed[locale]) {
-                const localeKeys = getAllKeys(parsed[locale]);
-                const missingKeys = [...allKeys].filter((key) => !localeKeys.includes(key));
-                if (missingKeys.length > 0) {
-                  const localeMatch = new RegExp(`"${locale}"\\s*:\\s*{`, "g").exec(i18nContent);
-                  if (localeMatch) {
-                    const localeOffset = startOffset + localeMatch.index;
-                    context.report({
-                      data: {
-                        locale,
-                        missing: missingKeys.join(", ")
-                      },
-                      loc: {
-                        end: context.sourceCode.getLocFromIndex(localeOffset + locale.length + 2),
-                        start: context.sourceCode.getLocFromIndex(localeOffset)
-                      },
-                      messageId: "missingTranslations"
-                    });
-                  }
-                }
-              }
-            }
-          } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            context.report({
-              data: { error: errorMessage },
-              loc: {
-                end: context.sourceCode.getLocFromIndex(startOffset + i18nContent.length),
-                start: context.sourceCode.getLocFromIndex(startOffset)
-              },
-              messageId: "invalidJson"
-            });
-          }
-        }
-        function getAllKeys(object, prefix = "") {
-          let keys = [];
-          for (const key in object) {
-            const newPrefix = prefix ? `${prefix}.${key}` : key;
-            if (typeof object[key] === "object" && object[key] !== null) {
-              keys = [...keys, ...getAllKeys(object[key], newPrefix)];
-            } else {
-              keys.push(newPrefix);
-            }
-          }
-          return keys;
-        }
-      }
-    };
-  }
-};
-
-const rule$a = {
-  meta: {
-    docs: {
-      category: "Best Practices",
-      description: "Enforce using t() instead of $t() in Vue templates",
-      recommended: true
-    },
-    fixable: "code",
-    messages: { useT: "Use t() instead of $t() in Vue templates as it does not work with <i18n> tags." },
-    schema: [],
-    type: "problem"
-  },
-  create(context) {
-    if (!context.filename.endsWith(".vue")) {
-      return {};
-    }
-    return {
-      Program() {
-        const sourceCode = context.sourceCode;
-        const source = sourceCode.getText();
-        const templateMatch = source.match(/<template>([\s\S]*)<\/template>/i);
-        if (!templateMatch || templateMatch.index === void 0) {
-          return;
-        }
-        const templateContent = templateMatch[1];
-        const tPatterns = [
-          {
-            pattern: / \$t\(/g,
-            quote: " "
-          },
-          {
-            pattern: /"\$t\(/g,
-            quote: '"'
-          },
-          {
-            pattern: /`\$t\(/g,
-            quote: "`"
-          },
-          {
-            pattern: /\{\$t\(/g,
-            quote: "{"
-          },
-          {
-            pattern: /\[\$t\(/g,
-            quote: "["
-          }
-        ];
-        for (const { pattern, quote } of tPatterns) {
-          let match;
-          while ((match = pattern.exec(templateContent)) !== null) {
-            const templateStart = templateMatch.index + templateMatch[0].indexOf(templateContent);
-            const start = templateStart + match.index;
-            const end = start + 4;
-            context.report({
-              fix(fixer) {
-                return fixer.replaceTextRange([start, end], `${quote}t(`);
-              },
-              loc: {
-                end: sourceCode.getLocFromIndex(end),
-                start: sourceCode.getLocFromIndex(start)
-              },
-              messageId: "useT"
-            });
-          }
-        }
-      }
-    };
-  }
-};
-
-const rule$9 = {
-  meta: {
-    docs: {
-      category: "Best Practices",
-      description: "Enforce consistent indentation and sorted keys in i18n blocks",
-      recommended: true
-    },
-    fixable: "whitespace",
-    messages: {
-      indentError: "Invalid indentation for i18n content. Expected {{expected}} spaces.",
-      invalidJson: "Invalid JSON in i18n block: {{error}}",
-      sortError: "Keys in i18n block should be sorted alphabetically."
-    },
-    schema: [],
-    type: "problem"
-  },
-  create(context) {
-    if (!context.filename.endsWith(".vue")) {
-      return {};
-    }
-    function sortObjectKeys(object) {
-      if (Array.isArray(object)) {
-        return object.map(sortObjectKeys);
-      }
-      if (object && typeof object === "object") {
-        const sortedKeys = Object.keys(object).sort();
-        const result = {};
-        const obj = object;
-        for (const key of sortedKeys) {
-          result[key] = sortObjectKeys(obj[key]);
-        }
-        return result;
-      }
-      return object;
-    }
-    return {
-      Program() {
-        const source = context.sourceCode.getText();
-        const i18nMatch = source.match(/(<i18n\s+lang=["']json["']>)([\s\S]*?)(<\/i18n>)/i);
-        if (i18nMatch) {
-          const startOffset = i18nMatch.index + i18nMatch[1].length;
-          const i18nContent = i18nMatch[2];
-          try {
-            const parsed = JSON.parse(i18nContent.trim());
-            const totalSpaces = 2;
-            const sortedParsed = sortObjectKeys(parsed);
-            const formattedContent = `
-${JSON.stringify(sortedParsed, null, totalSpaces).replace(/\n\n+/g, "\n")}
-`;
-            if (formattedContent.trim() !== i18nContent.trim()) {
-              const currentKeys = JSON.stringify(parsed, null, totalSpaces).trim();
-              const sortedKeys = JSON.stringify(sortedParsed, null, totalSpaces).trim();
-              context.report({
-                data: { expected: String(totalSpaces) },
-                fix(fixer) {
-                  return fixer.replaceTextRange(
-                    [startOffset, startOffset + i18nContent.length],
-                    formattedContent
-                  );
-                },
-                loc: {
-                  end: context.sourceCode.getLocFromIndex(startOffset + i18nContent.length),
-                  start: context.sourceCode.getLocFromIndex(startOffset)
-                },
-                messageId: currentKeys !== sortedKeys ? "sortError" : "indentError"
-              });
-            }
-          } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            context.report({
-              data: { error: errorMessage },
-              loc: {
-                end: context.sourceCode.getLocFromIndex(startOffset + i18nContent.length),
-                start: context.sourceCode.getLocFromIndex(startOffset)
-              },
-              messageId: "invalidJson"
-            });
-          }
-        }
-      }
-    };
-  }
-};
-
-const rule$8 = {
-  meta: {
-    docs: {
-      category: "Best Practices",
-      description: "Detect unused strings in the English locale",
-      recommended: true
-    },
-    messages: {
-      invalidJson: "Invalid JSON in i18n block: {{error}}",
-      unusedString: 'Unused string in English locale: "{{key}}"'
-    },
-    schema: [],
-    type: "problem"
-  },
-  create(context) {
-    if (!context.filename.endsWith(".vue")) {
-      return {};
-    }
-    return {
-      Program() {
-        const source = context.sourceCode.getText();
-        const i18nMatch = source.match(/(<i18n\s+lang=["']json["']>)([\s\S]*?)(<\/i18n>)/i);
-        if (!i18nMatch) {
-          return;
-        }
-        const startOffset = i18nMatch.index + i18nMatch[1].length;
-        const i18nContent = i18nMatch[2].trim();
-        try {
-          const parsed = JSON.parse(i18nContent);
-          if (!parsed.en) {
-            return;
-          }
-          const templateMatch = source.match(/<template>([\s\S]*)<\/template>/i);
-          const templateContent = templateMatch ? templateMatch[1] : "";
-          const scriptMatch = source.match(/<script[^>]*>([\s\S]*?)<\/script>/i);
-          const scriptContent = scriptMatch ? scriptMatch[1] : "";
-          const enKeys = getAllKeys(parsed.en);
-          for (const key of enKeys) {
-            const isUsed = templateContent.includes(key) || scriptContent.includes(key);
-            if (!isUsed) {
-              const keyMatch = new RegExp(`"${key}"\\s*:`, "g").exec(i18nContent);
-              if (keyMatch) {
-                const keyOffset = startOffset + keyMatch.index;
-                context.report({
-                  data: { key },
-                  loc: {
-                    end: context.sourceCode.getLocFromIndex(keyOffset + key.length + 2),
-                    start: context.sourceCode.getLocFromIndex(keyOffset)
-                  },
-                  messageId: "unusedString"
-                });
-              }
-            }
-          }
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          context.report({
-            data: { error: errorMessage },
-            loc: {
-              end: context.sourceCode.getLocFromIndex(startOffset + i18nContent.length),
-              start: context.sourceCode.getLocFromIndex(startOffset)
-            },
-            messageId: "invalidJson"
-          });
-        }
-      }
-    };
-    function getAllKeys(object, prefix = "") {
-      let keys = [];
-      for (const key in object) {
-        const newPrefix = prefix ? `${prefix}.${key}` : key;
-        if (typeof object[key] === "object" && object[key] !== null) {
-          keys = [...keys, ...getAllKeys(object[key], newPrefix)];
-        } else {
-          keys.push(newPrefix);
-        }
-      }
-      return keys;
-    }
-  }
-};
-
-const rule$7 = {
-  defaultOptions: [],
-  meta: {
-    docs: { description: "Enforce multiline style for Vue computed properties" },
-    fixable: "code",
-    messages: { multilineComputed: "Computed properties should use explicit return with blocks" },
-    schema: [],
-    type: "layout"
-  },
-  create(context) {
-    return {
-      CallExpression(node) {
-        if (node.callee.type === AST_NODE_TYPES.Identifier && node.callee.name === "computed") {
-          const [argument] = node.arguments;
-          if (argument?.type === AST_NODE_TYPES.ArrowFunctionExpression) {
-            const sourceCode = context.sourceCode;
-            const functionBody = sourceCode.getText(argument.body);
-            if (!functionBody.startsWith("{")) {
-              const bodyText = functionBody.startsWith("(") && functionBody.endsWith(")") ? functionBody.slice(1, -1) : functionBody;
-              context.report({
-                fix(fixer) {
-                  return fixer.replaceText(
-                    argument.body,
-                    `{
-  return ${bodyText}
-}`
-                  );
-                },
-                messageId: "multilineComputed",
-                node
-              });
-            }
-          }
-        }
-      }
-    };
-  }
-};
-
-const rule$6 = {
-  meta: {
-    docs: {
-      category: "Best Practices",
-      description: "Enforce typed emits in Vue components",
-      recommended: true
-    },
-    fixable: "code",
-    messages: { untypedEmits: "Use typed emits instead of untyped emits" },
-    schema: [],
-    type: "problem"
-  },
-  create(context) {
-    if (!context.filename.endsWith(".vue")) {
-      return {};
-    }
-    return {
-      Program(node) {
-        const source = context.sourceCode.getText();
-        const untypedEmitsRegex = /const\s+emit\s*=\s*defineEmits\(\[([^\]]+)\]\)/g;
-        let match = untypedEmitsRegex.exec(source);
-        while (match !== null) {
-          const [fullMatch, eventsString] = match;
-          const matchIndex = match.index;
-          const events = eventsString.split(",").map((event) => event.trim().replace(/['"]/g, "")).filter(Boolean);
-          const typedEvents = events.map((event) => `  ${event}: []`).join(",\n");
-          const typedEmits = `const emit = defineEmits<{
-${typedEvents}
-}>()`;
-          context.report({
-            fix: (fixer) => {
-              return fixer.replaceTextRange(
-                [matchIndex, matchIndex + fullMatch.length],
-                typedEmits
-              );
-            },
-            loc: {
-              end: context.sourceCode.getLocFromIndex(matchIndex + fullMatch.length),
-              start: context.sourceCode.getLocFromIndex(matchIndex)
-            },
-            messageId: "untypedEmits",
-            node
-          });
-          match = untypedEmitsRegex.exec(source);
-        }
-      }
-    };
-  }
-};
-
-const rule$5 = {
-  meta: {
-    docs: {
-      category: "Best Practices",
-      description: "Prevent comments, empty lines, redundant required: false, enforce default: undefined for single-key props, and detect unused props inside defineProps",
-      recommended: true
-    },
-    fixable: "code",
-    messages: {
-      noCommentsInProps: "Comments are not allowed inside defineProps.",
-      noEmptyLinesInProps: "Empty lines are not allowed between props in defineProps.",
-      noRedundantRequired: "required: false is redundant in props. Props are optional by default.",
-      singleKeyProp: "Props with only one key should have default: undefined for better readability.",
-      unusedProp: 'Unused prop: "{{propName}}"'
-    },
-    schema: [],
-    type: "problem"
-  },
-  create(context) {
-    if (!context.filename.endsWith(".vue")) {
-      return {};
-    }
-    return {
-      CallExpression(node) {
-        if (node.callee.type !== "Identifier" || node.callee.name !== "defineProps") {
-          return;
-        }
-        const sourceCode = context.sourceCode;
-        const propsArg = node.arguments[0];
-        if (!propsArg?.range) {
-          return;
-        }
-        const propsArgRange = propsArg.range;
-        const commentsInProps = [
-          ...sourceCode.getCommentsBefore(propsArg),
-          ...sourceCode.getCommentsInside(propsArg)
-        ].filter((comment) => {
-          return comment.range !== void 0 && comment.range[0] >= propsArgRange[0] && comment.range[1] <= propsArgRange[1];
-        });
-        for (const comment of commentsInProps) {
-          context.report({
-            fix: (fixer) => {
-              return fixer.removeRange(comment.range);
-            },
-            loc: comment.loc ?? node.loc ?? {
-              end: {
-                column: 0,
-                line: 0
-              },
-              start: {
-                column: 0,
-                line: 0
-              }
-            },
-            messageId: "noCommentsInProps"
-          });
-        }
-        const propsText = sourceCode.getText(propsArg);
-        const emptyLineRegex = /(?:{\s*\n\s*\n|,\s*\n\s*\n)\s*(?:([a-zA-Z])|(?:\s*}))/g;
-        let emptyLineMatch = emptyLineRegex.exec(propsText);
-        while (emptyLineMatch !== null) {
-          const matchIndex = emptyLineMatch.index;
-          const matchLength = emptyLineMatch[0].length;
-          const lastChar = emptyLineMatch[0].trim().charAt(0);
-          const isEndBrace = emptyLineMatch[0].trim().endsWith("}");
-          const firstLetter = emptyLineMatch[1];
-          const startIndex = propsArg.range[0] + matchIndex;
-          const endIndex = startIndex + matchLength;
-          context.report({
-            fix: (fixer) => {
-              let replacement;
-              if (isEndBrace) {
-                replacement = "\n}";
-              } else {
-                replacement = (lastChar === "{" ? "{\n  " : ",\n  ") + firstLetter;
-              }
-              return fixer.replaceTextRange([startIndex, endIndex], replacement);
-            },
-            loc: {
-              end: sourceCode.getLocFromIndex(endIndex),
-              start: sourceCode.getLocFromIndex(startIndex)
-            },
-            messageId: "noEmptyLinesInProps"
-          });
-          emptyLineMatch = emptyLineRegex.exec(propsText);
-        }
-        const redundantRequiredRegex = /required:\s*false\s*,?/g;
-        let redundantMatch = redundantRequiredRegex.exec(propsText);
-        while (redundantMatch !== null) {
-          const matchIndex = redundantMatch.index;
-          const matchLength = redundantMatch[0].length;
-          const startIndex = propsArg.range[0] + matchIndex;
-          const endIndex = startIndex + matchLength;
-          context.report({
-            fix: (fixer) => {
-              return fixer.removeRange([startIndex, endIndex]);
-            },
-            loc: {
-              end: sourceCode.getLocFromIndex(endIndex),
-              start: sourceCode.getLocFromIndex(startIndex)
-            },
-            messageId: "noRedundantRequired"
-          });
-          redundantMatch = redundantRequiredRegex.exec(propsText);
-        }
-        const source = sourceCode.getText();
-        const templateMatch = source.match(/<template>([\s\S]*)<\/template>/i);
-        const templateContent = templateMatch ? templateMatch[1] : "";
-        const scriptMatch = source.match(/<script[^>]*>([\s\S]*?)<\/script>/i);
-        const scriptContent = scriptMatch ? scriptMatch[1] : "";
-        const propDefinitions = propsText.match(/(\w+):\s*{([^}]+)}/g) ?? [];
-        for (const propDef of propDefinitions) {
-          const propNameMatch = propDef.match(/^(\w+):\s*{([^}]+)}/);
-          if (!propNameMatch) {
-            continue;
-          }
-          const propName = propNameMatch[1];
-          const propContent = propNameMatch[2].trim();
-          const hasDefault = propContent.includes("default:");
-          const hasRequired = propContent.includes("required:");
-          if (!hasDefault && !hasRequired && propContent.includes("type:")) {
-            const fullPropRegex = new RegExp(`${propName}:\\s*{[^}]+}`, "g");
-            const fullMatch = propsText.match(fullPropRegex);
-            if (!fullMatch) {
-              continue;
-            }
-            const fullPropDef = fullMatch[0];
-            const matchIndex = propsText.indexOf(fullPropDef);
-            const matchLength = fullPropDef.length;
-            const startIndex = propsArg.range[0] + matchIndex;
-            const endIndex = startIndex + matchLength;
-            context.report({
-              fix: (fixer) => {
-                const newText = fullPropDef.replace(/{\s*type:/, "{\n  default: undefined,\n  type:").replace(/,\s*\n\s*}/, "}");
-                return fixer.replaceTextRange([startIndex, endIndex], newText);
-              },
-              loc: {
-                end: sourceCode.getLocFromIndex(endIndex),
-                start: sourceCode.getLocFromIndex(startIndex)
-              },
-              messageId: "singleKeyProp"
-            });
-          }
-          const isUsedInTemplate = templateContent.includes(propName);
-          const isUsedInScript = scriptContent.replace(propsText, "").includes(propName);
-          if (!isUsedInTemplate && !isUsedInScript) {
-            const propStartIndex = propsArg.range[0] + propsText.indexOf(propDef);
-            const propEndIndex = propStartIndex + propDef.length;
-            context.report({
-              data: { propName },
-              loc: {
-                end: sourceCode.getLocFromIndex(propEndIndex),
-                start: sourceCode.getLocFromIndex(propStartIndex)
-              },
-              messageId: "unusedProp"
-            });
-          }
-        }
-      }
-    };
-  }
-};
-
-const rule$4 = {
-  meta: {
-    docs: {
-      category: "Best Practices",
-      description: "enforce order of compiler macros (`defineProps`, `defineEmits`, etc.)",
-      recommended: true
-    },
-    fixable: "code",
-    hasSuggestions: true,
-    messages: {
-      defineExposeNotTheLast: "`defineExpose` should be the last statement in `<script setup>`.",
-      macrosNotOnTop: "{{macro}} should be the first statement in `<script setup>` (after any potential import statements or type definitions).",
-      putExposeAtTheLast: "Put `defineExpose` as the last statement in `<script setup>`."
-    },
-    schema: [],
-    type: "problem"
-  },
-  create(context) {
-    if (!context.filename.endsWith(".vue")) {
-      return {};
-    }
-    return { Program() {
-    } };
-  }
-};
-
-const rule$3 = {
-  meta: {
-    docs: {
-      category: "Best Practices",
-      description: 'Prevent empty lines inside :class="{ bindings in Vue template tags',
-      recommended: true
-    },
-    fixable: "code",
-    messages: { noEmptyLinesInClass: 'Empty lines are not allowed inside :class="{ bindings.' },
-    schema: [],
-    type: "problem"
-  },
-  create(context) {
-    if (!context.filename.endsWith(".vue")) {
-      return {};
-    }
-    return {
-      Program() {
-        const sourceCode = context.sourceCode;
-        const source = sourceCode.getText();
-        const templateMatch = source.match(/<template>([\s\S]*)<\/template>/i);
-        if (!templateMatch) {
-          return;
-        }
-        const templateContent = templateMatch[1];
-        const classBindingRegex = /:class="\{([\s\S]*?)\}"/g;
-        let classBindingMatch;
-        while ((classBindingMatch = classBindingRegex.exec(templateContent)) !== null) {
-          const classContent = classBindingMatch[1];
-          const emptyLineRegex = /\n\s*\n/g;
-          let emptyLineMatch;
-          while ((emptyLineMatch = emptyLineRegex.exec(classContent)) !== null) {
-            const matchIndex = emptyLineMatch.index;
-            const matchLength = emptyLineMatch[0].length;
-            const templateStartIndex = source.indexOf(templateContent);
-            const classBindingStartIndex = templateStartIndex + classBindingMatch.index;
-            const classContentStartIndex = classBindingStartIndex + 8;
-            const startIndex = classContentStartIndex + matchIndex;
-            const endIndex = startIndex + matchLength;
-            context.report({
-              // TODO: Uncomment this when we want to fix the issue
-              // fix: (fixer) => {
-              //   // Replace consecutive newlines with a single newline
-              //   return fixer.replaceTextRange([startIndex, endIndex], '\n')
-              // },
-              loc: {
-                end: sourceCode.getLocFromIndex(endIndex),
-                start: sourceCode.getLocFromIndex(startIndex)
-              },
-              messageId: "noEmptyLinesInClass"
-            });
-          }
-        }
-      }
-    };
-  }
-};
-
-const rule$2 = {
-  meta: {
-    docs: {
-      category: "Best Practices",
-      description: "Prevent unnecessary props. and $props. prefixes in Vue templates",
-      recommended: true
-    },
-    fixable: "code",
-    messages: { noPropsPrefix: "Unnecessary props/$props prefix in template. Props are automatically available in template scope." },
-    schema: [],
-    type: "problem"
-  },
-  create(context) {
-    if (!context.filename.endsWith(".vue")) {
-      return {};
-    }
-    return {
-      CallExpression(node) {
-        if (node.callee.type !== "Identifier" || node.callee.name !== "defineProps") {
-          return;
-        }
-        const sourceCode = context.sourceCode;
-        const source = sourceCode.getText();
-        const templateMatch = source.match(/<template>([\s\S]*)<\/template>/i);
-        if (!templateMatch) {
-          return;
-        }
-        const templateContent = templateMatch[1];
-        const propsPrefixRegex = /(?:\$)?props\.(\w+)/g;
-        let prefixMatch = propsPrefixRegex.exec(templateContent);
-        while (prefixMatch !== null) {
-          const propName = prefixMatch[1];
-          const fullMatch = prefixMatch[0];
-          const matchIndex = templateMatch.index + 10 + prefixMatch.index;
-          context.report({
-            fix: (fixer) => {
-              return fixer.replaceTextRange(
-                [matchIndex, matchIndex + fullMatch.length],
-                propName
-              );
-            },
-            loc: {
-              end: sourceCode.getLocFromIndex(matchIndex + fullMatch.length),
-              start: sourceCode.getLocFromIndex(matchIndex)
-            },
-            messageId: "noPropsPrefix"
-          });
-          prefixMatch = propsPrefixRegex.exec(templateContent);
-        }
-      }
-    };
-  }
-};
-
-const rule$1 = {
-  meta: {
-    docs: {
-      category: "Best Practices",
-      description: "Remove comments inside Vue template tags",
-      recommended: true
-    },
-    fixable: "code",
-    messages: { removeComment: "Comments should be removed from template tags" },
-    schema: [],
-    type: "problem"
-  },
-  create(context) {
-    if (!context.filename.endsWith(".vue")) {
-      return {};
-    }
-    return {
-      Program() {
-        const sourceCode = context.sourceCode;
-        const source = sourceCode.getText();
-        const templateMatch = source.match(/<template>([\s\S]*)<\/template>/i);
-        if (!templateMatch) {
-          return;
-        }
-        const templateContent = templateMatch[1];
-        const templateStartIndex = templateMatch.index + 10;
-        const htmlCommentRegex = /<!--[\s\S]*?-->/g;
-        let htmlCommentMatch = htmlCommentRegex.exec(templateContent);
-        while (htmlCommentMatch !== null) {
-          const fullMatch = htmlCommentMatch[0];
-          const matchIndex = templateStartIndex + htmlCommentMatch.index;
-          context.report({
-            fix: (fixer) => {
-              return fixer.removeRange([
-                matchIndex,
-                matchIndex + fullMatch.length
-              ]);
-            },
-            loc: {
-              end: sourceCode.getLocFromIndex(matchIndex + fullMatch.length),
-              start: sourceCode.getLocFromIndex(matchIndex)
-            },
-            messageId: "removeComment"
-          });
-          htmlCommentMatch = htmlCommentRegex.exec(templateContent);
-        }
-        const jsCommentRegex = /(?:^|\s)\/\/[^\n]*/g;
-        let jsCommentMatch = jsCommentRegex.exec(templateContent);
-        while (jsCommentMatch !== null) {
-          const fullMatch = jsCommentMatch[0];
-          const matchIndex = templateStartIndex + jsCommentMatch.index;
-          const lineBeforeMatch = templateContent.substring(0, jsCommentMatch.index).split("\n").pop() ?? "";
-          const isInAttribute = lineBeforeMatch.includes('="') && !lineBeforeMatch.includes('"');
-          if (isInAttribute) {
-            jsCommentMatch = jsCommentRegex.exec(templateContent);
-            continue;
-          }
-          context.report({
-            fix: (fixer) => {
-              return fixer.removeRange([
-                matchIndex,
-                matchIndex + fullMatch.length
-              ]);
-            },
-            loc: {
-              end: sourceCode.getLocFromIndex(matchIndex + fullMatch.length),
-              start: sourceCode.getLocFromIndex(matchIndex)
-            },
-            messageId: "removeComment"
-          });
-          jsCommentMatch = jsCommentRegex.exec(templateContent);
-        }
-      }
-    };
-  }
-};
-
-const rule = {
-  meta: {
-    docs: {
-      category: "Best Practices",
-      description: 'Remove unnecessary ="true" attributes in Vue templates, except for aria- attributes',
-      recommended: true
-    },
-    fixable: "code",
-    messages: { removeTrueAttribute: 'Unnecessary ="true" attribute. Use the attribute name directly instead.' },
-    schema: [],
-    type: "problem"
-  },
-  create(context) {
-    if (!context.filename.endsWith(".vue")) {
-      return {};
-    }
-    return {
-      Program() {
-        const sourceCode = context.sourceCode;
-        const source = sourceCode.getText();
-        const templateMatch = source.match(/<template>([\s\S]*)<\/template>/i);
-        if (!templateMatch) {
-          return;
-        }
-        const templateContent = templateMatch[1];
-        const templateStartIndex = templateMatch.index + 10;
-        const trueAttributeRegex = /(?:^|\s)(?::)?(?!aria-)([a-zA-Z0-9-]+)="true"/g;
-        let trueAttributeMatch = trueAttributeRegex.exec(templateContent);
-        while (trueAttributeMatch !== null) {
-          const fullMatch = trueAttributeMatch[0];
-          const attributeName = trueAttributeMatch[1];
-          const matchIndex = templateStartIndex + trueAttributeMatch.index;
-          const lineBeforeMatch = templateContent.substring(0, trueAttributeMatch.index).split("\n").pop() ?? "";
-          if (lineBeforeMatch.includes("{{") && !lineBeforeMatch.includes("}}")) {
-            trueAttributeMatch = trueAttributeRegex.exec(templateContent);
-            continue;
-          }
-          context.report({
-            fix: (fixer) => {
-              return fixer.replaceTextRange(
-                [matchIndex, matchIndex + fullMatch.length],
-                ` ${attributeName}`
-              );
-            },
-            loc: {
-              end: sourceCode.getLocFromIndex(matchIndex + fullMatch.length),
-              start: sourceCode.getLocFromIndex(matchIndex)
-            },
-            messageId: "removeTrueAttribute"
-          });
-          trueAttributeMatch = trueAttributeRegex.exec(templateContent);
-        }
-      }
-    };
-  }
-};
-
-const index = {
-  rules: {
-    "ts-multiline-ternary": rule$e,
-    "ts-multiline-union": rule$d,
-    "ts-sort-tests": rule$c,
-    "vue-i18n-consistent-locales": rule$b,
-    "vue-i18n-consistent-t": rule$a,
-    "vue-i18n-sort-keys": rule$9,
-    "vue-i18n-unused-strings": rule$8,
-    "vue-script-format-computed": rule$7,
-    "vue-script-format-emits": rule$6,
-    "vue-script-format-props": rule$5,
-    "vue-script-order": rule$4,
-    "vue-template-format-classes": rule$3,
-    "vue-template-format-props": rule$2,
-    "vue-template-remove-comments": rule$1,
-    "vue-template-remove-true-attributes": rule
-  }
-};
-
-export { index as default };
+export { s as default } from './shared/eslint.poN7Ld_I.mjs';
+import 'eslint/use-at-your-own-risk';
+import 'eslint';