oxlint-plugin-arch 0.6.1 → 0.6.3

package/dist/index.js

@@ -1,7 +1,7 @@
 // src/index.ts
 import { eslintCompatPlugin } from "@oxlint/plugins";
 
-// src/rules/call-array-multiline.ts
+// src/rules/call-arguments-multiline.ts
 import { defineRule } from "@oxlint/plugins";
 
 // src/utils/helpers/ast.ts
@@ -121,7 +121,7 @@ function trivialExpression(node) {
   }
   if (!node.body || node.body.type !== "BlockStatement")
     return null;
-  const statements = node.body.body.filter((statement) => statement.type !== "EmptyStatement" && !(statement.type === "ExpressionStatement" && statement.directive));
+  const statements = node.body.body.filter((statement2) => statement2.type !== "EmptyStatement" && !(statement2.type === "ExpressionStatement" && statement2.directive));
   if (statements.length !== 1)
     return null;
   const statement = statements[0];
@@ -264,7 +264,7 @@ function declarationsIsTrivialFunction(node) {
   if (!node.body || node.body.type !== "BlockStatement") {
     return false;
   }
-  const statements = node.body.body.filter((statement) => statement.type !== "EmptyStatement" && !(statement.type === "ExpressionStatement" && statement.directive));
+  const statements = node.body.body.filter((statement2) => statement2.type !== "EmptyStatement" && !(statement2.type === "ExpressionStatement" && statement2.directive));
   if (statements.length === 0) {
     return true;
   }
@@ -326,8 +326,8 @@ function declarationsInsideForLoop(node) {
 }
 function declarationsNamedFromNode(node) {
   if (node.type === "VariableDeclarator") {
-    const kind = declarationsNamedKind(node, [node.parent]);
-    return kind && node.id.type === "Identifier" && !declarationsInsideForLoop(node) ? { name: node.id.name, node, kind } : undefined;
+    const kind2 = declarationsNamedKind(node, [node.parent]);
+    return kind2 && node.id.type === "Identifier" && !declarationsInsideForLoop(node) ? { name: node.id.name, node, kind: kind2 } : undefined;
   }
   const kind = declarationsNamedKind(node, []);
   const name = "id" in node && node.id && "name" in node.id ? node.id.name : undefined;
@@ -981,7 +981,91 @@ function boundaryResolveTarget(options, file, source) {
   const alias = Object.entries(options.aliases).sort(([a], [b]) => b.length - a.length).find(([prefix]) => source === prefix || source.startsWith(`${prefix}/`));
   return alias ? resolve(alias[1], source.slice(alias[0].length).replace(/^\//, "")).replaceAll("\\", "/") : source.startsWith(".") ? resolve(dirname(file), source).replaceAll("\\", "/") : source.startsWith("@/") && web ? `${web}/${source.slice(2)}` : source.startsWith("#/") && owner ? `${owner}/${source.slice(2)}` : source.startsWith("#services/") && owner ? `${owner}/services/${source.slice(10)}` : source;
 }
+// src/rules/call-arguments-multiline.ts
+function callArgumentsIsCallback(node) {
+  return (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") && node.loc.start.line !== node.loc.end.line;
+}
+var callArgumentsMultiline = defineRule({
+  meta: {
+    type: "layout",
+    fixable: "code",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          minArguments: {
+            type: "integer",
+            minimum: 2,
+            default: 3
+          },
+          indent: {
+            type: "integer",
+            minimum: 1,
+            default: 2
+          }
+        }
+      }
+    ],
+    messages: {
+      multiline: "A call with {{min}}+ arguments puts each argument on its own line."
+    }
+  },
+  createOnce(context) {
+    let minArguments = 3;
+    let indent = 2;
+    const check = (node) => {
+      const args = node.arguments;
+      if (args.length < minArguments || args.some(callArgumentsIsCallback) || context.sourceCode.getCommentsInside(node).length > 0) {
+        return;
+      }
+      const text = context.sourceCode.text;
+      const open = text.indexOf("(", (node.typeArguments ?? node.callee).range[1]);
+      const close = node.range[1] - 1;
+      const first = args[0];
+      const last = args[args.length - 1];
+      const gaps = [[open + 1, first.range[0]]];
+      for (let index = 1;index < args.length; index++) {
+        gaps.push([args[index - 1].range[1], args[index].range[0]]);
+      }
+      gaps.push([last.range[1], close]);
+      const between = gaps.map(([start, end]) => text.slice(start, end));
+      if (text[open] !== "(" || text[close] !== ")" || !/^\s*$/.test(between[0]) || between.slice(1, -1).some((gap) => !/^\s*,\s*$/.test(gap)) || !/^\s*,?\s*$/.test(between[between.length - 1])) {
+        return;
+      }
+      if (between.every((gap) => gap.includes(`
+`))) {
+        return;
+      }
+      const baseIndent = layoutLineIndent(text, open);
+      const newline = layoutNewline(text);
+      const argumentIndent = `${baseIndent}${" ".repeat(indent)}`;
+      context.report({
+        node,
+        messageId: "multiline",
+        data: { min: String(minArguments) },
+        fix: (fixer) => gaps.map((gap, index) => {
+          if (index === 0) {
+            return fixer.replaceTextRange(gap, `${newline}${argumentIndent}`);
+          }
+          return fixer.replaceTextRange(gap, index === gaps.length - 1 ? `,${newline}${baseIndent}` : `,${newline}${argumentIndent}`);
+        })
+      });
+    };
+    return {
+      before() {
+        const options2 = optionsFirst(context, {});
+        minArguments = options2.minArguments ?? 3;
+        indent = options2.indent ?? 2;
+      },
+      CallExpression: check,
+      NewExpression: check
+    };
+  }
+});
+
 // src/rules/call-array-multiline.ts
+import { defineRule as defineRule2 } from "@oxlint/plugins";
 function callArrayMultilineCallee(node) {
   if (node.type === "Identifier")
     return { name: node.name, root: node };
@@ -1048,7 +1132,7 @@ function callArrayMultilineEdits(array, source, text, elementIndent, baseIndent,
   });
   return edits;
 }
-var callArrayMultiline = defineRule({
+var callArrayMultiline = defineRule2({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -1075,10 +1159,10 @@ var callArrayMultiline = defineRule({
 `;
     return {
       before() {
-        const options = optionsFirst(context, {});
-        callees = new Set(options.callees ?? ["Promise.all", "Promise.allSettled"]);
-        minElements = options.minElements ?? 2;
-        indentUnit = layoutIndentUnit(options.indent);
+        const options2 = optionsFirst(context, {});
+        callees = new Set(options2.callees ?? ["Promise.all", "Promise.allSettled"]);
+        minElements = options2.minElements ?? 2;
+        indentUnit = layoutIndentUnit(options2.indent);
         newline = layoutNewline(context.sourceCode.text);
         if (callees.size === 0)
           return false;
@@ -1110,7 +1194,7 @@ var callArrayMultiline = defineRule({
 });
 
 // src/rules/chain-newline.ts
-import { defineRule as defineRule2 } from "@oxlint/plugins";
+import { defineRule as defineRule3 } from "@oxlint/plugins";
 function chainNewlineCollect(node) {
   const links = [];
   let current = node;
@@ -1147,7 +1231,7 @@ function chainNewlineMatches(root, links, group) {
   const rootName = chainNewlineRootIdentifier(root);
   return rootName !== null && optionsPatternsTest(group.rootPatterns, rootName);
 }
-var chainNewline = defineRule2({
+var chainNewline = defineRule3({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -1187,14 +1271,14 @@ var chainNewline = defineRule2({
     let processed = new WeakSet;
     return {
       before() {
-        const options = optionsFirst(context, { groups: [] });
-        groups = (options.groups ?? []).map((group) => ({
+        const options2 = optionsFirst(context, { groups: [] });
+        groups = (options2.groups ?? []).map((group) => ({
           minDepth: group.minDepth,
           methods: group.methods ? new Set(group.methods) : undefined,
           onlyMethods: group.onlyMethods ? new Set(group.onlyMethods) : undefined,
           rootPatterns: optionsPatterns(group.rootPattern)
         }));
-        indentUnit = layoutIndentUnit(options.indent);
+        indentUnit = layoutIndentUnit(options2.indent);
         newline = layoutNewline(context.sourceCode.text);
         processed = new WeakSet;
         if (groups.length === 0)
@@ -1253,7 +1337,7 @@ var chainNewline = defineRule2({
 });
 
 // src/rules/component-props.ts
-import { defineRule as defineRule3 } from "@oxlint/plugins";
+import { defineRule as defineRule4 } from "@oxlint/plugins";
 function unwrapExport(statement) {
   return statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" ? statement.declaration : statement;
 }
@@ -1303,7 +1387,7 @@ function isPassThrough(type) {
   const argument = type.typeArguments?.params.length === 1 ? type.typeArguments.params[0] : undefined;
   return name === "ComponentProps" && (argument?.type === "TSTypeQuery" || argument?.type === "TSLiteralType" && argument.literal.type === "Literal" && typeof argument.literal.value === "string");
 }
-var componentProps = defineRule3({
+var componentProps = defineRule4({
   meta: {
     type: "problem",
     schema: [
@@ -1374,8 +1458,8 @@ var componentProps = defineRule3({
 });
 
 // src/rules/declaration-name.ts
-import { defineRule as defineRule4 } from "@oxlint/plugins";
-var declarationName = defineRule4({
+import { defineRule as defineRule5 } from "@oxlint/plugins";
+var declarationName = defineRule5({
   meta: {
     type: "problem",
     schema: [
@@ -1404,7 +1488,7 @@ var declarationName = defineRule4({
     }
   },
   createOnce(context) {
-    let options = {};
+    let options2 = {};
     let kinds = null;
     let allowed = [];
     let expected = [];
@@ -1414,7 +1498,7 @@ var declarationName = defineRule4({
       if (!item || kinds && !kinds.has(item.kind) || optionsPatternsTest(allowed, item.name)) {
         return;
       }
-      const comparableName = options.normalize === "none" ? item.name : item.name.replaceAll("_", "").toLowerCase();
+      const comparableName = options2.normalize === "none" ? item.name : item.name.replaceAll("_", "").toLowerCase();
       const matches = expected.length > 0 ? optionsPatternsTest(expected, item.name) : prefixes.some((prefix) => comparableName.startsWith(prefix));
       if (matches) {
         return;
@@ -1424,22 +1508,22 @@ var declarationName = defineRule4({
         messageId: expected.length > 0 ? "pattern" : "prefix",
         data: expected.length > 0 ? {
           name: item.name,
-          pattern: optionsPatternLabel([options.pattern ?? []].flat().filter((source) => source !== ""))
+          pattern: optionsPatternLabel([options2.pattern ?? []].flat().filter((source) => source !== ""))
         } : { name: item.name, prefix: prefixes.join(" or ") }
       });
     }
     return {
       before() {
-        options = optionsFirst(context, {
+        options2 = optionsFirst(context, {
           stem: "before-first-dot",
           normalize: "remove-separators"
         });
-        kinds = options.kinds && options.kinds.length > 0 ? new Set(options.kinds) : null;
-        allowed = optionsOptionalPatterns(options.allowPattern);
-        expected = optionsOptionalPatterns(options.pattern, options.flags);
+        kinds = options2.kinds && options2.kinds.length > 0 ? new Set(options2.kinds) : null;
+        allowed = optionsOptionalPatterns(options2.allowPattern);
+        expected = optionsOptionalPatterns(options2.pattern, options2.flags);
         const basename = namingFileBasename(context.filename).replace(/\.(tsx?|jsx?)$/, "");
-        const stem = namingFileStem(basename, options.stem, options.trailingRoles, options.roleSeparators);
-        prefixes = namingFilePrefixes(stem, options.normalize ?? "remove-separators", options.singularize ?? "none");
+        const stem = namingFileStem(basename, options2.stem, options2.trailingRoles, options2.roleSeparators);
+        prefixes = namingFilePrefixes(stem, options2.normalize ?? "remove-separators", options2.singularize ?? "none");
       },
       FunctionDeclaration: check,
       ClassDeclaration: check,
@@ -1452,8 +1536,8 @@ var declarationName = defineRule4({
 });
 
 // src/rules/export-file-prefix.ts
-import { defineRule as defineRule5 } from "@oxlint/plugins";
-var exportFilePrefix = defineRule5({
+import { defineRule as defineRule6 } from "@oxlint/plugins";
+var exportFilePrefix = defineRule6({
   meta: {
     type: "problem",
     schema: [
@@ -1480,28 +1564,28 @@ var exportFilePrefix = defineRule5({
   createOnce(context) {
     return {
       Program(program) {
-        const options = optionsFirst(context, {
+        const options2 = optionsFirst(context, {
           stem: "before-first-dot",
           normalize: "remove-separators"
         });
         const basename = namingFileBasename(context.filename).replace(/\.(tsx?|jsx?)$/, "");
-        const stem = namingFileStem(basename, options.stem, options.trailingRoles, options.roleSeparators);
-        const prefixes = namingFilePrefixes(stem, options.normalize ?? "remove-separators", options.singularize ?? "none");
-        const allowed = optionsOptionalPatterns(options.allowPattern);
-        const names = options.allDeclarations ? declarationsCollectNamed(program) : exportsCollect(program).map((binding) => ({
+        const stem = namingFileStem(basename, options2.stem, options2.trailingRoles, options2.roleSeparators);
+        const prefixes = namingFilePrefixes(stem, options2.normalize ?? "remove-separators", options2.singularize ?? "none");
+        const allowed = optionsOptionalPatterns(options2.allowPattern);
+        const names = options2.allDeclarations ? declarationsCollectNamed(program) : exportsCollect(program).map((binding) => ({
           name: binding.localName ?? binding.exportedName,
           node: binding.node
         }));
-        if (options.allFunctions && !options.allDeclarations) {
+        if (options2.allFunctions && !options2.allDeclarations) {
           const exportedNames = new Set(names.map((item) => item.name));
           names.push(...declarationsCollectNamed(program).filter((item) => !exportedNames.has(item.name) && (item.node.type === "FunctionDeclaration" || item.node.type === "VariableDeclarator" && (item.node.init?.type === "ArrowFunctionExpression" || item.node.init?.type === "FunctionExpression"))));
         }
-        if (options.serviceMethods)
+        if (options2.serviceMethods)
           names.push(...declarationsPublicServiceMethods(program));
         const seen = new Set;
         for (const item of names) {
           const key = `${item.name}:${item.node.start}:${item.node.end}`;
-          const comparableName = options.normalize === "none" ? item.name : item.name.replaceAll("_", "").toLowerCase();
+          const comparableName = options2.normalize === "none" ? item.name : item.name.replaceAll("_", "").toLowerCase();
           if (seen.has(key) || optionsPatternsTest(allowed, item.name) || prefixes.some((prefix) => comparableName.startsWith(prefix))) {
             continue;
           }
@@ -1518,8 +1602,8 @@ var exportFilePrefix = defineRule5({
 });
 
 // src/rules/export-name-pattern.ts
-import { defineRule as defineRule6 } from "@oxlint/plugins";
-var exportNamePattern = defineRule6({
+import { defineRule as defineRule7 } from "@oxlint/plugins";
+var exportNamePattern = defineRule7({
   meta: {
     type: "problem",
     schema: [
@@ -1572,8 +1656,8 @@ var exportNamePattern = defineRule6({
 });
 
 // src/rules/filename-export-name.ts
-import { defineRule as defineRule7 } from "@oxlint/plugins";
-var filenameExportName = defineRule7({
+import { defineRule as defineRule8 } from "@oxlint/plugins";
+var filenameExportName = defineRule8({
   meta: {
     type: "problem",
     schema: [
@@ -1638,8 +1722,8 @@ var filenameExportName = defineRule7({
 });
 
 // src/rules/filename-match.ts
-import { defineRule as defineRule8 } from "@oxlint/plugins";
-var filenameMatch = defineRule8({
+import { defineRule as defineRule9 } from "@oxlint/plugins";
+var filenameMatch = defineRule9({
   meta: {
     type: "problem",
     schema: [
@@ -1676,8 +1760,8 @@ var filenameMatch = defineRule8({
 });
 
 // src/rules/folder-prefix.ts
-import { defineRule as defineRule9 } from "@oxlint/plugins";
-var folderPrefix = defineRule9({
+import { defineRule as defineRule10 } from "@oxlint/plugins";
+var folderPrefix = defineRule10({
   meta: {
     type: "problem",
     schema: [
@@ -1735,7 +1819,7 @@ var folderPrefix = defineRule9({
 });
 
 // src/rules/jsx-attributes-multiline.ts
-import { defineRule as defineRule10 } from "@oxlint/plugins";
+import { defineRule as defineRule11 } from "@oxlint/plugins";
 function jsxAttributesMultilineEdits(node, text, attributeIndent, baseIndent, newline) {
   const first = node.attributes[0];
   const last = node.attributes.at(-1);
@@ -1766,7 +1850,7 @@ function jsxAttributesMultilineEdits(node, text, attributeIndent, baseIndent, ne
   edits.push({ range: closingRange, text: `${newline}${baseIndent}` });
   return edits;
 }
-var jsxAttributesMultiline = defineRule10({
+var jsxAttributesMultiline = defineRule11({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -1791,9 +1875,9 @@ var jsxAttributesMultiline = defineRule10({
 `;
     return {
       before() {
-        const options = optionsFirst(context, {});
-        minAttributes = options.minAttributes ?? 3;
-        indentUnit = layoutIndentUnit(options.indent);
+        const options2 = optionsFirst(context, {});
+        minAttributes = options2.minAttributes ?? 3;
+        indentUnit = layoutIndentUnit(options2.indent);
         newline = layoutNewline(context.sourceCode.text);
       },
       JSXOpeningElement(node) {
@@ -1815,8 +1899,8 @@ var jsxAttributesMultiline = defineRule10({
 });
 
 // src/rules/key-value-same-line.ts
-import { defineRule as defineRule11 } from "@oxlint/plugins";
-var keyValueSameLine = defineRule11({
+import { defineRule as defineRule12 } from "@oxlint/plugins";
+var keyValueSameLine = defineRule12({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -1865,7 +1949,7 @@ var keyValueSameLine = defineRule11({
 });
 
 // src/rules/no-comments.ts
-import { defineRule as defineRule12 } from "@oxlint/plugins";
+import { defineRule as defineRule13 } from "@oxlint/plugins";
 var NO_COMMENTS_LINE_GAP = /^[\t \r\n\u2028\u2029]*$/;
 var NO_COMMENTS_LINE_TERMINATOR = /\r\n|[\n\r\u2028\u2029]/;
 var NO_COMMENTS_TRAILING_LINES = /^[\t ]*(?:\r\n|[\n\r\u2028\u2029])(?:[\t ]*(?:\r\n|[\n\r\u2028\u2029]))*/;
@@ -1928,9 +2012,9 @@ function noCommentsFollowsOpeningBrace(text, offset) {
   }
   return false;
 }
-function noCommentsGroups(comments, text) {
+function noCommentsGroups(comments2, text) {
   const groups = [];
-  for (const comment of comments) {
+  for (const comment of comments2) {
     const current = groups.at(-1);
     const previous = current?.at(-1);
     if (current && previous) {
@@ -1957,7 +2041,7 @@ function noCommentsJsxEmptyContainer(containers, start, end) {
   const container = containers[low - 1];
   return container?.range[1] >= end ? container : undefined;
 }
-var noComments = defineRule12({
+var noComments = defineRule13({
   meta: {
     type: "suggestion",
     fixable: "code",
@@ -1982,21 +2066,21 @@ var noComments = defineRule12({
     let allowed = [];
     return {
       before() {
-        const options = optionsFirst(context, {});
-        allowWhy = options.allowWhy ?? true;
-        allowJsdoc = options.allowJsdoc ?? false;
-        allowed = (options.allowPatterns ?? []).map((pattern) => new RegExp(pattern));
+        const options2 = optionsFirst(context, {});
+        allowWhy = options2.allowWhy ?? true;
+        allowJsdoc = options2.allowJsdoc ?? false;
+        allowed = (options2.allowPatterns ?? []).map((pattern) => new RegExp(pattern));
       },
       Program(program) {
         const source = context.sourceCode;
         const text = source.text;
-        const comments = source.getAllComments().filter((comment) => comment.type !== "Shebang");
+        const comments2 = source.getAllComments().filter((comment) => comment.type !== "Shebang");
         const removable = [];
         const protectedTargetLines = [];
         let mightContainJsxComment = false;
         let whyContinuation = false;
         let previousComment;
-        for (const comment of comments) {
+        for (const comment of comments2) {
           const value = commentsNormalizedValue(comment);
           if (!mightContainJsxComment && comment.type === "Block" && noCommentsFollowsOpeningBrace(text, comment.range[0])) {
             mightContainJsxComment = true;
@@ -2089,8 +2173,8 @@ var noComments = defineRule12({
 });
 
 // src/rules/no-extra-exports.ts
-import { defineRule as defineRule13 } from "@oxlint/plugins";
-var noExtraExports = defineRule13({
+import { defineRule as defineRule14 } from "@oxlint/plugins";
+var noExtraExports = defineRule14({
   meta: {
     type: "problem",
     schema: [
@@ -2115,20 +2199,20 @@ var noExtraExports = defineRule13({
   createOnce(context) {
     return {
       Program(program) {
-        const options = optionsFirst(context);
+        const options2 = optionsFirst(context);
         const basename = namingFileBasename(context.filename).replace(/\.(tsx?|jsx?)$/, "");
-        const domain = namingFileStem(basename, options.domainStem, options.trailingRoles, options.roleSeparators);
+        const domain = namingFileStem(basename, options2.domainStem, options2.trailingRoles, options2.roleSeparators);
         const replacements = {
           Domain: namingPascalCase(domain),
           domain: namingCamelCase(domain)
         };
-        const allowed = options.names.map((template) => template.replaceAll("{Domain}", replacements.Domain).replaceAll("{domain}", replacements.domain));
-        const patterns = (options.patterns ?? []).map((template) => {
+        const allowed = options2.names.map((template) => template.replaceAll("{Domain}", replacements.Domain).replaceAll("{domain}", replacements.domain));
+        const patterns = (options2.patterns ?? []).map((template) => {
           const source = template.replaceAll("{Domain}", replacements.Domain.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&")).replaceAll("{domain}", replacements.domain.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&"));
           return new RegExp(`^(?:${source})$`);
         });
         for (const binding of exportsCollect(program)) {
-          if (options.allowTypeExports && binding.typeOnly) {
+          if (options2.allowTypeExports && binding.typeOnly) {
             continue;
           }
           const name = binding.localName ?? binding.exportedName;
@@ -2149,7 +2233,7 @@ var noExtraExports = defineRule13({
 });
 
 // src/rules/no-extra-factory-keys.ts
-import { defineRule as defineRule14 } from "@oxlint/plugins";
+import { defineRule as defineRule15 } from "@oxlint/plugins";
 function compileFactoryKeys(pattern, keys, requireKeys) {
   const allowedList = keys.concat(requireKeys.filter((key) => !keys.includes(key)));
   return {
@@ -2159,7 +2243,7 @@ function compileFactoryKeys(pattern, keys, requireKeys) {
     requireKeys
   };
 }
-var noExtraFactoryKeys = defineRule14({
+var noExtraFactoryKeys = defineRule15({
   meta: {
     type: "problem",
     schema: [
@@ -2206,8 +2290,8 @@ var noExtraFactoryKeys = defineRule14({
     }
     return {
       before() {
-        const options = optionsFirst(context, {});
-        const { keys, factoryPattern = "^make[A-Z]", requireKeys = [], keySets: configured } = options;
+        const options2 = optionsFirst(context, {});
+        const { keys, factoryPattern = "^make[A-Z]", requireKeys = [], keySets: configured } = options2;
         if (!keys && !configured) {
           return false;
         }
@@ -2263,8 +2347,8 @@ var noExtraFactoryKeys = defineRule14({
 });
 
 // src/rules/no-file-level-helpers.ts
-import { defineRule as defineRule15 } from "@oxlint/plugins";
-var noFileLevelHelpers = defineRule15({
+import { defineRule as defineRule16 } from "@oxlint/plugins";
+var noFileLevelHelpers = defineRule16({
   meta: {
     type: "problem",
     schema: [
@@ -2310,7 +2394,7 @@ var noFileLevelHelpers = defineRule15({
 });
 
 // src/rules/no-imported-type-alias.ts
-import { defineRule as defineRule16 } from "@oxlint/plugins";
+import { defineRule as defineRule17 } from "@oxlint/plugins";
 function importedAliasTarget(declaration, imports) {
   if (declaration?.type !== "TSTypeAliasDeclaration" || declaration.typeAnnotation.type !== "TSTypeReference" || declaration.typeAnnotation.typeName.type !== "Identifier" || Boolean(declaration.typeAnnotation.typeArguments?.params.length) || !imports.has(declaration.typeAnnotation.typeName.name)) {
     return;
@@ -2320,7 +2404,7 @@ function importedAliasTarget(declaration, imports) {
 function specifierLocalName(specifier) {
   return specifier.local.type === "Identifier" ? specifier.local.name : specifier.local.value;
 }
-var noImportedTypeAlias = defineRule16({
+var noImportedTypeAlias = defineRule17({
   meta: {
     type: "problem",
     schema: [],
@@ -2394,8 +2478,8 @@ var noImportedTypeAlias = defineRule16({
 });
 
 // src/rules/no-inline-schema-elements.ts
-import { defineRule as defineRule17 } from "@oxlint/plugins";
-var noInlineSchemaElements = defineRule17({
+import { defineRule as defineRule18 } from "@oxlint/plugins";
+var noInlineSchemaElements = defineRule18({
   meta: {
     type: "problem",
     schema: [
@@ -2435,14 +2519,14 @@ var noInlineSchemaElements = defineRule17({
         if (node.callee.type !== "MemberExpression") {
           return;
         }
-        const options = optionsFirst(context);
-        const namespaces = new Set(options.namespaces);
+        const options2 = optionsFirst(context);
+        const namespaces = new Set(options2.namespaces);
         const method = astStaticMemberName(node.callee);
-        if (!schemasIsCall(node, namespaces) || !method || !options.methods.includes(method)) {
+        if (!schemasIsCall(node, namespaces) || !method || !options2.methods.includes(method)) {
           return;
         }
         for (const element of schemasElements(node)) {
-          if (!schemasIsAllowedElement(element, options.allowZodScalars, namespaces, new Set(options.structuralMethods))) {
+          if (!schemasIsAllowedElement(element, options2.allowZodScalars, namespaces, new Set(options2.structuralMethods))) {
             context.report({
               node: element,
               messageId: "inline",
@@ -2456,7 +2540,7 @@ var noInlineSchemaElements = defineRule17({
 });
 
 // src/rules/no-inline-types.ts
-import { defineRule as defineRule18 } from "@oxlint/plugins";
+import { defineRule as defineRule19 } from "@oxlint/plugins";
 function parameterAnnotation(parameter) {
   if (parameter.type === "TSParameterProperty") {
     return parameterAnnotation(parameter.parameter);
@@ -2466,7 +2550,7 @@ function parameterAnnotation(parameter) {
   }
   return parameter.typeAnnotation;
 }
-var noInlineTypes = defineRule18({
+var noInlineTypes = defineRule19({
   meta: {
     type: "problem",
     schema: [
@@ -2517,11 +2601,11 @@ var noInlineTypes = defineRule18({
     }
     return {
       before() {
-        const options = optionsFirst(context, {});
-        checkParameters = options.parameters ?? true;
-        checkReturns = options.returns ?? true;
-        checkFunctionTypes = options.functionTypes ?? true;
-        minMembers = options.minMembers ?? 1;
+        const options2 = optionsFirst(context, {});
+        checkParameters = options2.parameters ?? true;
+        checkReturns = options2.returns ?? true;
+        checkFunctionTypes = options2.functionTypes ?? true;
+        minMembers = options2.minMembers ?? 1;
         if (!checkParameters && !checkReturns) {
           return false;
         }
@@ -2536,7 +2620,7 @@ var noInlineTypes = defineRule18({
 });
 
 // src/rules/no-literal-in.ts
-import { defineRule as defineRule19 } from "@oxlint/plugins";
+import { defineRule as defineRule20 } from "@oxlint/plugins";
 function literalKey(node) {
   if (node.type === "Literal" && typeof node.value === "string") {
     return node.value;
@@ -2545,7 +2629,7 @@ function literalKey(node) {
     return node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw;
   }
 }
-var noLiteralIn = defineRule19({
+var noLiteralIn = defineRule20({
   meta: {
     type: "suggestion",
     schema: [
@@ -2586,13 +2670,13 @@ var noLiteralIn = defineRule19({
 });
 
 // src/rules/no-local-schema-construction.ts
-import { defineRule as defineRule20 } from "@oxlint/plugins";
+import { defineRule as defineRule21 } from "@oxlint/plugins";
 var defaultRuntimeImportMessage = "Do not import runtime schema constructors from {{source}}; import a named schema instead.";
 var defaultConstructionMessage = "Do not construct schemas locally; import a named schema instead.";
 function formatMessage(template, data) {
   return Object.entries(data).reduce((result, [key, value]) => result.replaceAll(`{{${key}}}`, value), template);
 }
-var noLocalSchemaConstruction = defineRule20({
+var noLocalSchemaConstruction = defineRule21({
   meta: {
     type: "problem",
     schema: [
@@ -2714,8 +2798,8 @@ var noLocalSchemaConstruction = defineRule20({
 });
 
 // src/rules/no-member-comments.ts
-import { defineRule as defineRule21 } from "@oxlint/plugins";
-var noMemberComments = defineRule21({
+import { defineRule as defineRule22 } from "@oxlint/plugins";
+var noMemberComments = defineRule22({
   meta: {
     type: "suggestion",
     fixable: "code",
@@ -2741,14 +2825,14 @@ var noMemberComments = defineRule21({
       const source = context.sourceCode;
       const { allowWhy = true } = optionsFirst(context, {});
       const previousToken = source.getTokenBefore(node);
-      const comments = [
+      const comments2 = [
         ...source.getCommentsBefore(node).filter((comment) => !previousToken || previousToken.range[0] === parent.range[0] || previousToken.loc.end.line !== comment.loc.start.line),
         ...source.getCommentsAfter(node).filter((comment) => comment.loc.start.line === node.loc.end.line)
       ].filter((comment) => comment.range[0] > parent.range[0] && comment.range[1] < parent.range[1]);
       let whyContinuation = false;
       let previousLine = -1;
       const removable = [];
-      for (const comment of comments) {
+      for (const comment of comments2) {
         const value = commentsNormalizedValue(comment);
         const isWhy = commentsIsWhy(value) || comment.type === "Line" && whyContinuation && comment.loc.start.line === previousLine + 1;
         whyContinuation = comment.type === "Line" && isWhy;
@@ -2811,7 +2895,7 @@ var noMemberComments = defineRule21({
 });
 
 // src/rules/no-module-mutable-state.ts
-import { defineRule as defineRule22 } from "@oxlint/plugins";
+import { defineRule as defineRule23 } from "@oxlint/plugins";
 function moduleMutableStateBindings(pattern) {
   if (pattern.type === "Identifier") {
     return [{ name: pattern.name, node: pattern }];
@@ -2850,7 +2934,7 @@ function moduleMutableStateInsideAmbient(node) {
   }
   return false;
 }
-var noModuleMutableState = defineRule22({
+var noModuleMutableState = defineRule23({
   meta: {
     type: "problem",
     schema: [
@@ -2902,7 +2986,7 @@ var noModuleMutableState = defineRule22({
 });
 
 // src/rules/no-promise-all-mutation.ts
-import { defineRule as defineRule23 } from "@oxlint/plugins";
+import { defineRule as defineRule24 } from "@oxlint/plugins";
 function mutationBinding(node) {
   if (node.type === "Identifier") {
     return node;
@@ -2930,7 +3014,7 @@ function mutationBindings(node) {
     }
   }
 }
-var noPromiseAllMutation = defineRule23({
+var noPromiseAllMutation = defineRule24({
   meta: {
     type: "problem",
     schema: [
@@ -2990,10 +3074,10 @@ var noPromiseAllMutation = defineRule23({
     }
     return {
       before() {
-        const options = optionsFirst(context);
-        combinators = new Set(options.combinators);
-        methods = new Set(options.methods);
-        checkAssignments = options.checkAssignments;
+        const options2 = optionsFirst(context);
+        combinators = new Set(options2.combinators);
+        methods = new Set(options2.methods);
+        checkAssignments = options2.checkAssignments;
         references.clear();
         reported.clear();
         referencesReady = false;
@@ -3030,8 +3114,8 @@ var noPromiseAllMutation = defineRule23({
 });
 
 // src/rules/no-rederive-schema.ts
-import { defineRule as defineRule24 } from "@oxlint/plugins";
-var noRederiveSchema = defineRule24({
+import { defineRule as defineRule25 } from "@oxlint/plugins";
+var noRederiveSchema = defineRule25({
   meta: {
     type: "problem",
     schema: [
@@ -3075,7 +3159,7 @@ var noRederiveSchema = defineRule24({
 });
 
 // src/rules/no-restricted-constructor.ts
-import { defineRule as defineRule25 } from "@oxlint/plugins";
+import { defineRule as defineRule26 } from "@oxlint/plugins";
 function restrictedConstructorEntries(constructors) {
   const entries = new Map;
   for (const item of constructors) {
@@ -3091,7 +3175,7 @@ function restrictedConstructorEntries(constructors) {
   }
   return entries;
 }
-var noRestrictedConstructor = defineRule25({
+var noRestrictedConstructor = defineRule26({
   meta: {
     type: "problem",
     schema: [
@@ -3145,10 +3229,10 @@ var noRestrictedConstructor = defineRule25({
     }
     return {
       before() {
-        const options = optionsFirst(context);
-        entries = restrictedConstructorEntries(options.constructors);
-        checkCalls = options.checkCalls === true;
-        fallbackMessage = options.message;
+        const options2 = optionsFirst(context);
+        entries = restrictedConstructorEntries(options2.constructors);
+        checkCalls = options2.checkCalls === true;
+        fallbackMessage = options2.message;
         if (entries.size === 0) {
           return false;
         }
@@ -3166,8 +3250,8 @@ var noRestrictedConstructor = defineRule25({
 });
 
 // src/rules/no-restricted-files.ts
-import { defineRule as defineRule26 } from "@oxlint/plugins";
-var noRestrictedFiles = defineRule26({
+import { defineRule as defineRule27 } from "@oxlint/plugins";
+var noRestrictedFiles = defineRule27({
   meta: {
     type: "problem",
     schema: [
@@ -3199,7 +3283,7 @@ var noRestrictedFiles = defineRule26({
 });
 
 // src/rules/no-restricted-token.ts
-import { defineRule as defineRule27 } from "@oxlint/plugins";
+import { defineRule as defineRule28 } from "@oxlint/plugins";
 function tokenIsTypeOnlyImport(node) {
   const parent = node.parent;
   if (parent?.type === "ImportSpecifier") {
@@ -3210,7 +3294,7 @@ function tokenIsTypeOnlyImport(node) {
 function memberMatches(node, restriction) {
   return restriction.startsWith("*.") ? astStaticMemberName(node) === restriction.slice(2) : astDottedName(node) === restriction;
 }
-var noRestrictedToken = defineRule27({
+var noRestrictedToken = defineRule28({
   meta: {
     type: "problem",
     schema: [
@@ -3259,16 +3343,16 @@ var noRestrictedToken = defineRule27({
     }
     return {
       before() {
-        const options = optionsFirst(context);
+        const options2 = optionsFirst(context);
         const configured = [
-          ...options.token ? [
+          ...options2.token ? [
             {
-              token: options.token,
-              allowIn: options.allowIn,
-              allowPathPatterns: options.allowPathPatterns
+              token: options2.token,
+              allowIn: options2.allowIn,
+              allowPathPatterns: options2.allowPathPatterns
             }
           ] : [],
-          ...options.restrictions ?? []
+          ...options2.restrictions ?? []
         ];
         const filename = namingPosixPath(context.filename);
         restrictions = configured.flatMap((restriction) => {
@@ -3307,7 +3391,7 @@ var noRestrictedToken = defineRule27({
 });
 
 // src/rules/no-runtime-in-types.ts
-import { defineRule as defineRule28 } from "@oxlint/plugins";
+import { defineRule as defineRule29 } from "@oxlint/plugins";
 function isTypeOnlyImport(statement) {
   return statement.importKind === "type" || statement.specifiers.length > 0 && statement.specifiers.every((specifier) => specifier.type === "ImportSpecifier" && specifier.importKind === "type");
 }
@@ -3524,7 +3608,7 @@ function isRuntimeReExport(statement, runtimeImportLocals, valueNames, isAmbient
   }
   return statement.specifiers.some((specifier) => specifier.exportKind !== "type" && runtimeImportLocals.has(exportLocalName(specifier)));
 }
-var noRuntimeInTypes = defineRule28({
+var noRuntimeInTypes = defineRule29({
   meta: {
     type: "problem",
     schema: [
@@ -3556,11 +3640,11 @@ var noRuntimeInTypes = defineRule28({
     let isAmbientFile = false;
     return {
       before() {
-        const options = optionsFirst(context, {});
-        allow = options.allow ?? [];
-        runtimeImports = options.runtimeImports ?? "allow";
-        allowedImportSources = (options.allowImportSources ?? []).map((pattern) => new RegExp(pattern));
-        banReExports = options.banReExports === true;
+        const options2 = optionsFirst(context, {});
+        allow = options2.allow ?? [];
+        runtimeImports = options2.runtimeImports ?? "allow";
+        allowedImportSources = (options2.allowImportSources ?? []).map((pattern) => new RegExp(pattern));
+        banReExports = options2.banReExports === true;
         isAmbientFile = runtimeInTypesIsAmbientFile(context.filename);
       },
       Program(program) {
@@ -3576,12 +3660,12 @@ var noRuntimeInTypes = defineRule28({
                 runtimeImportLocals.add(specifier.local.name);
               }
             }
-            const source = String(statement.source.value);
-            if (runtimeImports === "ban" && !isAllowedSource(source, allowedImportSources)) {
+            const source2 = String(statement.source.value);
+            if (runtimeImports === "ban" && !isAllowedSource(source2, allowedImportSources)) {
               context.report({
                 node: statement,
                 messageId: "runtimeImport",
-                data: { source }
+                data: { source: source2 }
               });
             }
             continue;
@@ -3668,7 +3752,7 @@ var noRuntimeInTypes = defineRule28({
 });
 
 // src/rules/no-single-use-scalar-schema.ts
-import { defineRule as defineRule29 } from "@oxlint/plugins";
+import { defineRule as defineRule30 } from "@oxlint/plugins";
 function isScalarSchema(node, namespaces, structuralMethods) {
   if (node.type !== "CallExpression" || node.callee.type !== "MemberExpression") {
     return false;
@@ -3690,8 +3774,8 @@ function isDirectObjectField(identifier, ancestors, namespaces, structuralMethod
   const method = call.callee.type === "MemberExpression" ? astStaticMemberName(call.callee) : undefined;
   return Boolean(method === "object" && structuralMethods.has(method) && call.arguments.includes(object));
 }
-function isAllowedStructuralElement(identifier, initializer, ancestors, options, namespaces, structuralMethods) {
-  if (!options.allowZodScalars || !schemasIsAllowedElement(initializer, true, namespaces, structuralMethods)) {
+function isAllowedStructuralElement(identifier, initializer, ancestors, options2, namespaces, structuralMethods) {
+  if (!options2.allowZodScalars || !schemasIsAllowedElement(initializer, true, namespaces, structuralMethods)) {
     return false;
   }
   const parent = ancestors.at(-1);
@@ -3700,9 +3784,9 @@ function isAllowedStructuralElement(identifier, initializer, ancestors, options,
     return false;
   }
   const method = call.callee.type === "MemberExpression" ? astStaticMemberName(call.callee) : undefined;
-  return Boolean(method && options.methods.includes(method) && schemasElements(call).includes(identifier));
+  return Boolean(method && options2.methods.includes(method) && schemasElements(call).includes(identifier));
 }
-var noSingleUseScalarSchema = defineRule29({
+var noSingleUseScalarSchema = defineRule30({
   meta: {
     type: "suggestion",
     schema: [
@@ -3754,9 +3838,9 @@ var noSingleUseScalarSchema = defineRule29({
         }
       },
       "Program:exit"(program) {
-        const options = optionsFirst(context);
-        const namespaces = new Set(options.namespaces);
-        const structuralMethods = new Set(options.structuralMethods);
+        const options2 = optionsFirst(context);
+        const namespaces = new Set(options2.namespaces);
+        const structuralMethods = new Set(options2.structuralMethods);
         const exportedNames = new Set(exportsCollect(program).flatMap((binding) => binding.localName ? [binding.localName] : []));
         for (const declarator of candidates) {
           const name = declarator.id.type === "Identifier" ? declarator.id.name : undefined;
@@ -3765,14 +3849,14 @@ var noSingleUseScalarSchema = defineRule29({
             continue;
           }
           const variable = context.sourceCode.getDeclaredVariables(declarator).find((candidate) => candidate.name === name);
-          const references = variable?.references.filter((reference) => reference.isRead()) ?? [];
+          const references = variable?.references.filter((reference2) => reference2.isRead()) ?? [];
           if (references.length !== 1) {
             continue;
           }
           const reference = references[0];
           const identifier = reference.identifier;
           const ancestors = context.sourceCode.getAncestors(identifier);
-          const inlineable = isDirectObjectField(identifier, ancestors, namespaces, structuralMethods) || isAllowedStructuralElement(identifier, initializer, ancestors, options, namespaces, structuralMethods);
+          const inlineable = isDirectObjectField(identifier, ancestors, namespaces, structuralMethods) || isAllowedStructuralElement(identifier, initializer, ancestors, options2, namespaces, structuralMethods);
           if (inlineable) {
             context.report({
               node: declarator.id,
@@ -3787,8 +3871,8 @@ var noSingleUseScalarSchema = defineRule29({
 });
 
 // src/rules/no-top-level-functions.ts
-import { defineRule as defineRule30 } from "@oxlint/plugins";
-var noTopLevelFunctions = defineRule30({
+import { defineRule as defineRule31 } from "@oxlint/plugins";
+var noTopLevelFunctions = defineRule31({
   meta: {
     type: "problem",
     schema: [
@@ -3847,7 +3931,7 @@ var noTopLevelFunctions = defineRule30({
 });
 
 // src/rules/no-trivial-functions.ts
-import { defineRule as defineRule31 } from "@oxlint/plugins";
+import { defineRule as defineRule32 } from "@oxlint/plugins";
 
 // src/constants/trivial.constants.ts
 var trivialBannedNames = [
@@ -3863,7 +3947,7 @@ var trivialBannedNames = [
 ];
 
 // src/rules/no-trivial-functions.ts
-var noTrivialFunctions = defineRule31({
+var noTrivialFunctions = defineRule32({
   meta: {
     type: "problem",
     schema: [
@@ -3927,12 +4011,12 @@ var noTrivialFunctions = defineRule31({
     }
     return {
       before() {
-        const options = optionsFirst(context, {});
-        const { allowPattern, allowCallees: calleePatterns = [], allowAsync: asyncAllowed = false } = options;
-        mode = options.mode ?? "legacy";
-        checkServiceMethods = options.checkServiceMethods ?? false;
-        bannedNames = new Set(options.bannedNames ?? (mode === "precise" ? trivialBannedNames : []));
-        checkGenericGuards = options.checkGenericGuards ?? mode === "precise";
+        const options2 = optionsFirst(context, {});
+        const { allowPattern, allowCallees: calleePatterns = [], allowAsync: asyncAllowed = false } = options2;
+        mode = options2.mode ?? "legacy";
+        checkServiceMethods = options2.checkServiceMethods ?? false;
+        bannedNames = new Set(options2.bannedNames ?? (mode === "precise" ? trivialBannedNames : []));
+        checkGenericGuards = options2.checkGenericGuards ?? mode === "precise";
         reported.clear();
         checked.clear();
         allowed = optionsOptionalPatterns(allowPattern);
@@ -3958,8 +4042,8 @@ var noTrivialFunctions = defineRule31({
           if (reported.has(item.node.start))
             continue;
           const expression = trivialExpression(item.node);
-          const trivial = mode === "legacy" ? declarationsIsTrivialFunction(item.node) : expression ? trivialIsForwarder(item.node, expression) : declarationsIsTrivialFunction(item.node);
-          if (!trivial)
+          const trivial2 = mode === "legacy" ? declarationsIsTrivialFunction(item.node) : expression ? trivialIsForwarder(item.node, expression) : declarationsIsTrivialFunction(item.node);
+          if (!trivial2)
             continue;
           const value = expression && trivialUnwrap(expression);
           const call = value?.type === "CallExpression" ? value : null;
@@ -3980,8 +4064,8 @@ var noTrivialFunctions = defineRule31({
 });
 
 // src/rules/no-type-declarations.ts
-import { defineRule as defineRule32 } from "@oxlint/plugins";
-var noTypeDeclarations = defineRule32({
+import { defineRule as defineRule33 } from "@oxlint/plugins";
+var noTypeDeclarations = defineRule33({
   meta: {
     type: "problem",
     schema: [
@@ -4026,8 +4110,8 @@ var noTypeDeclarations = defineRule32({
 });
 
 // src/rules/no-unescaped-like.ts
-import { defineRule as defineRule33 } from "@oxlint/plugins";
-var noUnescapedLike = defineRule33({
+import { defineRule as defineRule34 } from "@oxlint/plugins";
+var noUnescapedLike = defineRule34({
   meta: {
     type: "problem",
     schema: [
@@ -4049,14 +4133,14 @@ var noUnescapedLike = defineRule33({
     let sanitized = new Set;
     return {
       Program(program) {
-        const { sanitizers, allowSanitizedBindings = true } = optionsFirst(context);
-        sanitized = allowSanitizedBindings ? sanitizersConfiguredBindings(program, new Set(sanitizers)) : new Set;
+        const { sanitizers: sanitizers2, allowSanitizedBindings = true } = optionsFirst(context);
+        sanitized = allowSanitizedBindings ? sanitizersConfiguredBindings(program, new Set(sanitizers2)) : new Set;
       },
       CallExpression(node) {
         if (node.callee.type !== "MemberExpression") {
           return;
         }
-        const { methods, sanitizers, operatorMethods = [] } = optionsFirst(context);
+        const { methods, sanitizers: sanitizers2, operatorMethods = [] } = optionsFirst(context);
         const method = astStaticMemberName(node.callee);
         const operator = node.arguments[1];
         const operatorCall = method && operatorMethods.includes(method) && operator?.type === "Literal" && typeof operator.value === "string" && methods.includes(operator.value);
@@ -4065,7 +4149,7 @@ var noUnescapedLike = defineRule33({
         }
         const value = node.arguments.at(-1);
         const allowedIdentifier = value?.type === "Identifier" && sanitized.has(value.name);
-        if (!sanitizersCallsConfigured(value, new Set(sanitizers)) && !allowedIdentifier) {
+        if (!sanitizersCallsConfigured(value, new Set(sanitizers2)) && !allowedIdentifier) {
           context.report({
             node: value ?? node,
             messageId: "unescaped",
@@ -4078,7 +4162,7 @@ var noUnescapedLike = defineRule33({
 });
 
 // src/rules/object-multiline.ts
-import { defineRule as defineRule34 } from "@oxlint/plugins";
+import { defineRule as defineRule35 } from "@oxlint/plugins";
 function objectMultilineIsCallArg(node) {
   const parent = node.parent;
   return (parent.type === "CallExpression" || parent.type === "NewExpression") && parent.arguments.includes(node);
@@ -4111,14 +4195,14 @@ function objectMultilineGaps(text, node) {
     if (!objectMultilineIsWhitespace(between.slice(0, comma)) || !objectMultilineIsWhitespace(between.slice(comma + 1))) {
       return null;
     }
-    gaps.push([after + comma + 1, limit]);
+    gaps.push([next ? after + comma + 1 : after, limit]);
   }
   return gaps;
 }
-var objectMultiline = defineRule34({
+var objectMultiline = defineRule35({
   meta: {
     type: "layout",
-    fixable: "whitespace",
+    fixable: "code",
     schema: [
       {
         type: "object",
@@ -4143,10 +4227,10 @@ var objectMultiline = defineRule34({
 `;
     return {
       before() {
-        const options = optionsFirst(context, {});
-        minProperties = options.minProperties ?? 3;
-        scope = options.scope ?? "call-args";
-        indentUnit = layoutIndentUnit(options.indent);
+        const options2 = optionsFirst(context, {});
+        minProperties = options2.minProperties ?? 3;
+        scope = options2.scope ?? "call-args";
+        indentUnit = layoutIndentUnit(options2.indent);
         newline = layoutNewline(context.sourceCode.text);
       },
       ObjectExpression(node) {
@@ -4168,7 +4252,7 @@ var objectMultiline = defineRule34({
             if (!gaps) {
               return null;
             }
-            return gaps.map((gap, index) => fixer.replaceTextRange(gap, `${newline}${index === gaps.length - 1 ? baseIndent : propIndent}`));
+            return gaps.map((gap, index) => fixer.replaceTextRange(gap, index === gaps.length - 1 ? `,${newline}${baseIndent}` : `${newline}${propIndent}`));
           }
         });
       }
@@ -4177,8 +4261,8 @@ var objectMultiline = defineRule34({
 });
 
 // src/rules/only-export-components.ts
-import { defineRule as defineRule35 } from "@oxlint/plugins";
-var onlyExportComponents = defineRule35({
+import { defineRule as defineRule36 } from "@oxlint/plugins";
+var onlyExportComponents = defineRule36({
   meta: {
     type: "problem",
     schema: [
@@ -4258,7 +4342,7 @@ var onlyExportComponents = defineRule35({
 });
 
 // src/rules/only-export-constants.ts
-import { defineRule as defineRule36 } from "@oxlint/plugins";
+import { defineRule as defineRule37 } from "@oxlint/plugins";
 function bindingNames(pattern) {
   switch (pattern.type) {
     case "Identifier":
@@ -4313,7 +4397,7 @@ function collectBindings(program) {
   }
   return bindings;
 }
-var onlyExportConstants = defineRule36({
+var onlyExportConstants = defineRule37({
   meta: {
     type: "problem",
     schema: [
@@ -4401,7 +4485,7 @@ var onlyExportConstants = defineRule36({
 });
 
 // src/rules/padding-between-statements.ts
-import { defineRule as defineRule37 } from "@oxlint/plugins";
+import { defineRule as defineRule38 } from "@oxlint/plugins";
 function paddingKind(node) {
   if (node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration") {
     return node.declaration ? paddingKind(node.declaration) : "other";
@@ -4437,7 +4521,7 @@ function paddingHasBlankLine(gap) {
   }
   return false;
 }
-function paddingBlankLineFix(sourceText, comments, prev, curr, newline) {
+function paddingBlankLineFix(sourceText, comments2, prev, curr, newline) {
   const gap = sourceText.slice(prev.range[1], curr.range[0]);
   const match = /\r?\n/.exec(gap);
   if (!match) {
@@ -4445,15 +4529,15 @@ function paddingBlankLineFix(sourceText, comments, prev, curr, newline) {
   }
   const newlineStart = prev.range[1] + match.index;
   const newlineEnd = newlineStart + match[0].length;
-  if (comments.some((comment) => comment.range[0] < newlineEnd && comment.range[1] > newlineStart)) {
+  if (comments2.some((comment) => comment.range[0] < newlineEnd && comment.range[1] > newlineStart)) {
     return null;
   }
-  if (comments.some((comment) => comment.loc.start.line === prev.loc.end.line && /^\s*[A-Za-z][\w-]*-disable-next-line\b/.test(commentsNormalizedValue(comment)))) {
+  if (comments2.some((comment) => comment.loc.start.line === prev.loc.end.line && /^\s*[A-Za-z][\w-]*-disable-next-line\b/.test(commentsNormalizedValue(comment)))) {
     return null;
   }
   return { newlineEnd, newline };
 }
-var paddingBetweenStatements = defineRule37({
+var paddingBetweenStatements = defineRule38({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -4499,8 +4583,8 @@ var paddingBetweenStatements = defineRule37({
         if (!messageId) {
           continue;
         }
-        const comments = source.getCommentsAfter(prev).filter((comment) => comment.range[1] <= curr.range[0]);
-        const insert = paddingBlankLineFix(source.text, comments, prev, curr, newline);
+        const comments2 = source.getCommentsAfter(prev).filter((comment) => comment.range[1] <= curr.range[0]);
+        const insert = paddingBlankLineFix(source.text, comments2, prev, curr, newline);
         context.report({
           node: curr,
           messageId,
@@ -4510,9 +4594,9 @@ var paddingBetweenStatements = defineRule37({
     }
     return {
       before() {
-        const options = optionsFirst(context, {});
-        returnMinStatements = options.returnMinStatements ?? 3;
-        multilineVariables = options.multilineVariables ?? false;
+        const options2 = optionsFirst(context, {});
+        returnMinStatements = options2.returnMinStatements ?? 3;
+        multilineVariables = options2.multilineVariables ?? false;
         source = context.sourceCode;
         newline = layoutNewline(source.text);
       },
@@ -4527,7 +4611,7 @@ var paddingBetweenStatements = defineRule37({
 });
 
 // src/rules/prefer-namespace-type-import.ts
-import { defineRule as defineRule38 } from "@oxlint/plugins";
+import { defineRule as defineRule39 } from "@oxlint/plugins";
 var bindingName = /^[A-Za-z_$][\w$]*$/;
 var reservedNames = new Set("await break case catch class const continue debugger default delete do else enum export extends false finally for function if import in instanceof new null return super switch this throw true try typeof var void while with yield implements interface let package private protected public static arguments eval".split(" "));
 function namespaceName(source, names) {
@@ -4551,7 +4635,7 @@ function safeReference(node) {
   }
   return parent?.type === "TSTypeReference" && parent.typeName === current || parent?.type === "TSTypeQuery" && parent.exprName === current || (parent?.type === "TSInterfaceHeritage" || parent?.type === "TSClassImplements") && parent.expression === current;
 }
-var preferNamespaceTypeImport = defineRule38({
+var preferNamespaceTypeImport = defineRule39({
   meta: {
     type: "suggestion",
     fixable: "code",
@@ -4596,7 +4680,7 @@ var preferNamespaceTypeImport = defineRule38({
           }
         }
         const proposed = candidates.map((node) => namespaceName(node.source.value, names));
-        const comments = sourceCode.getAllComments();
+        const comments2 = sourceCode.getAllComments();
         const reports = [];
         const edits = [];
         for (const [index, node] of candidates.entries()) {
@@ -4609,7 +4693,7 @@ var preferNamespaceTypeImport = defineRule38({
             reason = "existing namespace import from this module";
           } else if (occupied.has(name) || proposed.some((other, otherIndex) => otherIndex !== index && other === name)) {
             reason = "namespace name collides with a binding, reference, or another proposed namespace";
-          } else if (comments.some((comment) => comment.range[0] >= node.range[0] && comment.range[1] <= node.range[1])) {
+          } else if (comments2.some((comment) => comment.range[0] >= node.range[0] && comment.range[1] <= node.range[1])) {
             reason = "comment inside import";
           } else {
             const variables = sourceCode.getDeclaredVariables(node);
@@ -4668,8 +4752,8 @@ var preferNamespaceTypeImport = defineRule38({
 });
 
 // src/rules/require-file-factory.ts
-import { defineRule as defineRule39 } from "@oxlint/plugins";
-var requireFileFactory = defineRule39({
+import { defineRule as defineRule40 } from "@oxlint/plugins";
+var requireFileFactory = defineRule40({
   meta: {
     type: "problem",
     schema: [
@@ -4717,8 +4801,8 @@ var requireFileFactory = defineRule39({
 });
 
 // src/rules/require-object-params.ts
-import { defineRule as defineRule40 } from "@oxlint/plugins";
-var requireObjectParams = defineRule40({
+import { defineRule as defineRule41 } from "@oxlint/plugins";
+var requireObjectParams = defineRule41({
   meta: {
     type: "problem",
     schema: [
@@ -4776,8 +4860,8 @@ var requireObjectParams = defineRule40({
 });
 
 // src/rules/require-orpc-output.ts
-import { defineRule as defineRule41 } from "@oxlint/plugins";
-var requireOrpcOutput = defineRule41({
+import { defineRule as defineRule42 } from "@oxlint/plugins";
+var requireOrpcOutput = defineRule42({
   meta: {
     type: "problem",
     schema: [
@@ -4825,8 +4909,8 @@ var requireOrpcOutput = defineRule41({
 });
 
 // src/rules/require-paired-call.ts
-import { defineRule as defineRule42 } from "@oxlint/plugins";
-var requirePairedCall = defineRule42({
+import { defineRule as defineRule43 } from "@oxlint/plugins";
+var requirePairedCall = defineRule43({
   meta: {
     type: "problem",
     schema: [
@@ -4861,10 +4945,10 @@ var requirePairedCall = defineRule42({
     let pairs = [];
     return {
       before() {
-        const options = optionsFirst(context);
+        const options2 = optionsFirst(context);
         const configured = [
-          ...options.when && options.require ? [{ when: options.when, require: options.require }] : [],
-          ...options.pairs ?? []
+          ...options2.when && options2.require ? [{ when: options2.when, require: options2.require }] : [],
+          ...options2.pairs ?? []
         ];
         aliases = new Map;
         pairs = configured.map((pair) => ({ ...pair, firstWhen: null, sawRequired: false }));
@@ -4900,8 +4984,8 @@ var requirePairedCall = defineRule42({
 });
 
 // src/rules/route-surface.ts
-import { defineRule as defineRule43 } from "@oxlint/plugins";
-var routeSurface = defineRule43({
+import { defineRule as defineRule44 } from "@oxlint/plugins";
+var routeSurface = defineRule44({
   meta: {
     type: "problem",
     schema: [
@@ -4946,8 +5030,102 @@ var routeSurface = defineRule43({
   }
 });
 
+// src/rules/ternary-layout.ts
+import { defineRule as defineRule45 } from "@oxlint/plugins";
+function ternaryLayoutLineStart(text, offset) {
+  return text.lastIndexOf(`
+`, offset - 1) + 1;
+}
+function ternaryLayoutLineEnd(text, offset) {
+  const end = text.indexOf(`
+`, offset);
+  if (end === -1) {
+    return text.length;
+  }
+  return text[end - 1] === "\r" ? end - 1 : end;
+}
+function ternaryLayoutBreak(between, operator, newline) {
+  const at = between.indexOf(operator);
+  return `${between.slice(0, at).trimEnd()}${newline}${operator} ${between.slice(at + 1).trimStart()}`;
+}
+var ternaryLayout = defineRule45({
+  meta: {
+    type: "layout",
+    fixable: "whitespace",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          maxLength: {
+            type: "integer",
+            minimum: 1,
+            default: 160
+          },
+          indent: {
+            type: "integer",
+            minimum: 1,
+            default: 2
+          }
+        }
+      }
+    ],
+    messages: {
+      join: "Keep this conditional on one line ({{length}} columns; limit {{max}}, except in template literals).",
+      split: "This conditional does not fit on one line ({{length}} of {{max}} columns); break before `?` and `:`."
+    }
+  },
+  createOnce(context) {
+    let maxLength = 160;
+    let indent = 2;
+    return {
+      before() {
+        const options2 = optionsFirst(context, {});
+        maxLength = options2.maxLength ?? 160;
+        indent = options2.indent ?? 2;
+      },
+      ConditionalExpression(node) {
+        const source = context.sourceCode;
+        const text = source.text;
+        const operands = [node.test, node.consequent, node.alternate];
+        if (node.parent.type === "ConditionalExpression" || operands.some((operand) => operand.type === "ConditionalExpression" || operand.loc.start.line !== operand.loc.end.line) || source.getCommentsInside(node).length > 0) {
+          return;
+        }
+        const prefix = text.slice(ternaryLayoutLineStart(text, node.range[0]), node.range[0]);
+        const suffix = text.slice(node.range[1], ternaryLayoutLineEnd(text, node.range[1]));
+        const joined = text.slice(node.range[0], node.range[1]).replace(/\s*\n\s*/g, " ");
+        const length = prefix.length + joined.length + suffix.length;
+        const onOneLine = node.loc.start.line === node.loc.end.line;
+        const interpolated = node.parent.type === "TemplateLiteral";
+        if (!onOneLine && (interpolated || length <= maxLength)) {
+          context.report({
+            node,
+            messageId: "join",
+            data: { length: String(length), max: String(maxLength) },
+            fix: (fixer) => fixer.replaceTextRange(node.range, joined)
+          });
+        }
+        if (onOneLine && !interpolated && length > maxLength) {
+          const newline = `${layoutNewline(text)}${layoutLineIndent(text, node.range[0])}${" ".repeat(indent)}`;
+          const question = [node.test.range[1], node.consequent.range[0]];
+          const colon = [node.consequent.range[1], node.alternate.range[0]];
+          context.report({
+            node,
+            messageId: "split",
+            data: { length: String(length), max: String(maxLength) },
+            fix: (fixer) => [
+              fixer.replaceTextRange(question, ternaryLayoutBreak(text.slice(...question), "?", newline)),
+              fixer.replaceTextRange(colon, ternaryLayoutBreak(text.slice(...colon), ":", newline))
+            ]
+          });
+        }
+      }
+    };
+  }
+});
+
 // src/rules/test-title-pattern.ts
-import { defineRule as defineRule44 } from "@oxlint/plugins";
+import { defineRule as defineRule46 } from "@oxlint/plugins";
 var TEST_MODIFIERS = new Set(["only", "skip", "concurrent", "sequential", "todo", "each", "for"]);
 function isConfiguredName(name, callees) {
   if (!name) {
@@ -4987,7 +5165,7 @@ function regexMatches(regex, value) {
 function titlePatterns(pattern, flags) {
   return pattern === undefined ? [] : [pattern].flat().map((source) => ({ regex: new RegExp(source, flags), pattern: source }));
 }
-var testTitlePattern = defineRule44({
+var testTitlePattern = defineRule46({
   meta: {
     type: "suggestion",
     schema: [
@@ -5020,12 +5198,12 @@ var testTitlePattern = defineRule44({
     let requiredLabel = "";
     return {
       before() {
-        const options = optionsFirst(context);
-        callees = options.callees;
-        const flags = options.flags ?? "";
-        forbid = titlePatterns(options.forbid, flags);
-        required = titlePatterns(options.require, flags);
-        requiredLabel = optionsPatternLabel(options.require);
+        const options2 = optionsFirst(context);
+        callees = options2.callees;
+        const flags = options2.flags ?? "";
+        forbid = titlePatterns(options2.forbid, flags);
+        required = titlePatterns(options2.require, flags);
+        requiredLabel = optionsPatternLabel(options2.require);
         if (forbid.length === 0 && required.length === 0) {
           return false;
         }
@@ -5066,6 +5244,7 @@ var testTitlePattern = defineRule44({
 var src_default = eslintCompatPlugin({
   meta: { name: "arch" },
   rules: {
+    "call-arguments-multiline": callArgumentsMultiline,
     "call-array-multiline": callArrayMultiline,
     "chain-newline": chainNewline,
     "component-props": componentProps,
@@ -5109,6 +5288,7 @@ var src_default = eslintCompatPlugin({
     "require-orpc-output": requireOrpcOutput,
     "require-paired-call": requirePairedCall,
     "route-surface": routeSurface,
+    "ternary-layout": ternaryLayout,
     "test-title-pattern": testTitlePattern
   }
 });