npm - stylelint-config-silverwind - Versions diffs - 35.0.3 → 35.0.4 - Mend

stylelint-config-silverwind 35.0.3 → 35.0.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/dist/index.js +601 -1684
package/package.json +7 -7

package/dist/index.js CHANGED Viewed

@@ -9152,10 +9152,6 @@ ruleFunction.meta = meta$1d;
 const valueNoUnknownCustomProperties = stylelint.createPlugin(ruleName$1d, ruleFunction);
 const isMethodEnabled = (method) => method === true;
 const isMethodDisabled = (method) => method === null || method === false;
-let namespace$1 = `@stylistic`;
-function addNamespace(ruleName2) {
-  return `${namespace$1}/${ruleName2}`;
-}
 const rules = {
   get "at-rule-name-case"() {
     return Promise.resolve().then(() => index$1c).then((m2) => m2.default);
@@ -9389,6 +9385,10 @@ const rules = {
     return Promise.resolve().then(() => index).then((m2) => m2.default);
   }
 };
+let namespace$1 = `@stylistic`;
+function addNamespace(ruleName2) {
+  return `${namespace$1}/${ruleName2}`;
+}
 let rulesPlugins = Object.keys(rules).map((name) => stylelint.createPlugin(addNamespace(name), rules[name]));
 var lib$6 = {};
 var Parser = {};
@@ -14523,15 +14523,9 @@ function getRuleDocUrl(shortName2) {
   return `https://github.com/stylelint-stylistic/stylelint-stylistic/blob/main/lib/rules/${shortName2}/README.md`;
 }
 function isStandardSyntaxAtRule(atRule2) {
-  if (!atRule2.nodes && atRule2.params === ``) {
-    return false;
-  }
-  if (`mixin` in atRule2 && atRule2.mixin) {
-    return false;
-  }
-  if (`variable` in atRule2 && atRule2.variable || !atRule2.nodes && atRule2.raws.afterName === `` && atRule2.params[0] === `(`) {
-    return false;
-  }
+  if (!atRule2.nodes && atRule2.params === ``) return false;
+  if (`mixin` in atRule2 && atRule2.mixin) return false;
+  if (`variable` in atRule2 && atRule2.variable || !atRule2.nodes && atRule2.raws.afterName === `` && atRule2.params[0] === `(`) return false;
   return true;
 }
 let { utils: { report: report$X, ruleMessages: ruleMessages$1c, validateOptions: validateOptions$1c } } = stylelint;
@@ -14550,19 +14544,13 @@ function rule$1c(primary) {
       actual: primary,
       possible: [`lower`, `upper`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     let expectation = primary;
     root2.walkAtRules((atRule2) => {
-      if (!isStandardSyntaxAtRule(atRule2)) {
-        return;
-      }
+      if (!isStandardSyntaxAtRule(atRule2)) return;
       let name = atRule2.name;
       let expectedName = expectation === `lower` ? name.toLowerCase() : name.toUpperCase();
-      if (name === expectedName) {
-        return;
-      }
+      if (name === expectedName) return;
       report$X({
         message: messages$1c.expected,
         messageArgs: [name, expectedName],
@@ -14589,9 +14577,7 @@ const index$1c = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProp
 let { utils: { report: report$W } } = stylelint;
 function atRuleNameSpaceChecker(options) {
   options.root.walkAtRules((atRule2) => {
-    if (!isStandardSyntaxAtRule(atRule2)) {
-      return;
-    }
+    if (!isStandardSyntaxAtRule(atRule2)) return;
     checkColon(
       `@${atRule2.name}${atRule2.raws.afterName || ``}${atRule2.params}`,
       atRule2.name.length,
@@ -14655,11 +14641,8 @@ function isString(value) {
   return typeof value === `string` || value instanceof String;
 }
 function assert(value, message = void 0) {
-  if (message) {
-    console.assert(value, message);
-  } else {
-    console.assert(value);
-  }
+  if (message) console.assert(value, message);
+  else console.assert(value);
 }
 function assertFunction(value) {
   console.assert(isFunction(value), `"${value}" must be a function`);
@@ -14694,27 +14677,19 @@ function whitespaceChecker(targetWhitespace, expectation, messages2) {
         rejectBefore();
         break;
       case `always-single-line`:
-        if (!isSingleLineString(lineCheckStr || source)) {
-          return;
-        }
+        if (!isSingleLineString(lineCheckStr || source)) return;
         expectBefore(messages2.expectedBeforeSingleLine);
         break;
       case `never-single-line`:
-        if (!isSingleLineString(lineCheckStr || source)) {
-          return;
-        }
+        if (!isSingleLineString(lineCheckStr || source)) return;
         rejectBefore(messages2.rejectedBeforeSingleLine);
         break;
       case `always-multi-line`:
-        if (isSingleLineString(lineCheckStr || source)) {
-          return;
-        }
+        if (isSingleLineString(lineCheckStr || source)) return;
         expectBefore(messages2.expectedBeforeMultiLine);
         break;
       case `never-multi-line`:
-        if (isSingleLineString(lineCheckStr || source)) {
-          return;
-        }
+        if (isSingleLineString(lineCheckStr || source)) return;
         rejectBefore(messages2.rejectedBeforeMultiLine);
         break;
       default:
@@ -14731,27 +14706,19 @@ function whitespaceChecker(targetWhitespace, expectation, messages2) {
         rejectAfter();
         break;
       case `always-single-line`:
-        if (!isSingleLineString(lineCheckStr || source)) {
-          return;
-        }
+        if (!isSingleLineString(lineCheckStr || source)) return;
         expectAfter(messages2.expectedAfterSingleLine);
         break;
       case `never-single-line`:
-        if (!isSingleLineString(lineCheckStr || source)) {
-          return;
-        }
+        if (!isSingleLineString(lineCheckStr || source)) return;
         rejectAfter(messages2.rejectedAfterSingleLine);
         break;
       case `always-multi-line`:
-        if (isSingleLineString(lineCheckStr || source)) {
-          return;
-        }
+        if (isSingleLineString(lineCheckStr || source)) return;
         expectAfter(messages2.expectedAfterMultiLine);
         break;
       case `never-multi-line`:
-        if (isSingleLineString(lineCheckStr || source)) {
-          return;
-        }
+        if (isSingleLineString(lineCheckStr || source)) return;
         rejectAfter(messages2.rejectedAfterMultiLine);
         break;
       default:
@@ -14771,12 +14738,8 @@ function whitespaceChecker(targetWhitespace, expectation, messages2) {
     let index2 = _activeArgs.index;
     let oneCharBefore = source[index2 - 1];
     let twoCharsBefore = source[index2 - 2];
-    if (isNullish(oneCharBefore)) {
-      return;
-    }
-    if (targetWhitespace === `space` && oneCharBefore === ` ` && (activeArgs.onlyOneChar || isNullish(twoCharsBefore) || !isWhitespace$1(twoCharsBefore))) {
-      return;
-    }
+    if (isNullish(oneCharBefore)) return;
+    if (targetWhitespace === `space` && oneCharBefore === ` ` && (activeArgs.onlyOneChar || isNullish(twoCharsBefore) || !isWhitespace$1(twoCharsBefore))) return;
     assertFunction(messageFunc);
     activeArgs.err(messageFunc(activeArgs.errTarget || source.charAt(index2)));
   }
@@ -14818,22 +14781,14 @@ function whitespaceChecker(targetWhitespace, expectation, messages2) {
     let oneCharAfter = source[index2 + 1];
     let twoCharsAfter = source[index2 + 2];
     let threeCharsAfter = source[index2 + 3];
-    if (isNullish(oneCharAfter)) {
-      return;
-    }
+    if (isNullish(oneCharAfter)) return;
     if (targetWhitespace === `newline`) {
       if (oneCharAfter === `\r` && twoCharsAfter === `
-` && (activeArgs.onlyOneChar || isNullish(threeCharsAfter) || !isWhitespace$1(threeCharsAfter))) {
-        return;
-      }
+` && (activeArgs.onlyOneChar || isNullish(threeCharsAfter) || !isWhitespace$1(threeCharsAfter))) return;
       if (oneCharAfter === `
-` && (activeArgs.onlyOneChar || isNullish(twoCharsAfter) || !isWhitespace$1(twoCharsAfter))) {
-        return;
-      }
-    }
-    if (targetWhitespace === `space` && oneCharAfter === ` ` && (activeArgs.onlyOneChar || isNullish(twoCharsAfter) || !isWhitespace$1(twoCharsAfter))) {
-      return;
+` && (activeArgs.onlyOneChar || isNullish(twoCharsAfter) || !isWhitespace$1(twoCharsAfter))) return;
     }
+    if (targetWhitespace === `space` && oneCharAfter === ` ` && (activeArgs.onlyOneChar || isNullish(twoCharsAfter) || !isWhitespace$1(twoCharsAfter))) return;
     assertFunction(messageFunc);
     activeArgs.err(messageFunc(activeArgs.errTarget || source.charAt(index2)));
   }
@@ -14870,9 +14825,7 @@ function rule$1b(primary) {
       actual: primary,
       possible: [`always`, `always-multi-line`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     atRuleNameSpaceChecker({
       root: root2,
       result: result2,
@@ -14908,18 +14861,14 @@ function rule$1a(primary) {
       actual: primary,
       possible: [`always`, `always-single-line`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     atRuleNameSpaceChecker({
       root: root2,
       result: result2,
       locationChecker: checker.after,
       checkedRuleName: ruleName$1a,
       fix: (atRule2) => {
-        if (typeof atRule2.raws.afterName === `string`) {
-          atRule2.raws.afterName = atRule2.raws.afterName.replace(/^\s*/, ` `);
-        }
+        if (typeof atRule2.raws.afterName === `string`) atRule2.raws.afterName = atRule2.raws.afterName.replace(/^\s*/, ` `);
       }
     });
   };
@@ -14938,19 +14887,13 @@ function hasBlock(statement) {
   return statement.nodes !== void 0;
 }
 function nextNonCommentNode(startNode) {
-  if (!startNode || !startNode.next) {
-    return null;
-  }
-  if (startNode.type === `comment`) {
-    return nextNonCommentNode(startNode.next());
-  }
+  if (!startNode || !startNode.next) return null;
+  if (startNode.type === `comment`) return nextNonCommentNode(startNode.next());
   return startNode;
 }
 function rawNodeString(node2) {
   let result2 = ``;
-  if (node2.raws.before) {
-    result2 += node2.raws.before;
-  }
+  if (node2.raws.before) result2 += node2.raws.before;
   result2 += node2.toString();
   return result2;
 }
@@ -14971,24 +14914,14 @@ function rule$19(primary, _secondary, context) {
       actual: primary,
       possible: [`always`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     root2.walkAtRules((atRule2) => {
       let nextNode = atRule2.next();
-      if (!nextNode) {
-        return;
-      }
-      if (hasBlock(atRule2)) {
-        return;
-      }
-      if (!isStandardSyntaxAtRule(atRule2)) {
-        return;
-      }
+      if (!nextNode) return;
+      if (hasBlock(atRule2)) return;
+      if (!isStandardSyntaxAtRule(atRule2)) return;
       let nodeToCheck = nextNonCommentNode(nextNode);
-      if (!nodeToCheck) {
-        return;
-      }
+      if (!nodeToCheck) return;
       const problemIndex = atRule2.toString().length + 1;
       checker.afterOneOnly({
         source: rawNodeString(nodeToCheck),
@@ -15037,16 +14970,10 @@ function rule$18(primary) {
       actual: primary,
       possible: [`always`, `never`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     root2.walkAtRules((atRule2) => {
-      if (hasBlock(atRule2)) {
-        return;
-      }
-      if (!isStandardSyntaxAtRule(atRule2)) {
-        return;
-      }
+      if (hasBlock(atRule2)) return;
+      if (!isStandardSyntaxAtRule(atRule2)) return;
       const nodeString = rawNodeString(atRule2);
       const problemIndex = nodeString.length - 1;
       checker.before({
@@ -15078,16 +15005,11 @@ const index$18 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProp
 }, Symbol.toStringTag, { value: "Module" }));
 function addEmptyLineAfter(node2, newline) {
   let { raws } = node2;
-  if (typeof raws.after !== `string`) {
-    return node2;
-  }
+  if (typeof raws.after !== `string`) return node2;
   let spaces = raws.after.split(`;`);
   let after = spaces[spaces.length - 1] || ``;
-  if (!/\r?\n/.test(after)) {
-    raws.after += newline.repeat(2);
-  } else {
-    raws.after = raws.after.replace(/(\r?\n)/, `${newline}$1`);
-  }
+  if (!/\r?\n/.test(after)) raws.after += newline.repeat(2);
+  else raws.after = raws.after.replace(/(\r?\n)/, `${newline}$1`);
   return node2;
 }
 function isRoot(node2) {
@@ -15108,23 +15030,15 @@ function isDeclaration(node2) {
 function beforeBlockString(statement, { noRawBefore } = { noRawBefore: false }) {
   let result2 = ``;
   let before = statement.raws.before || ``;
-  if (!noRawBefore) {
-    result2 += before;
-  }
-  if (isRule(statement)) {
-    result2 += statement.selector;
-  } else if (isAtRule(statement)) {
-    result2 += `@${statement.name}${statement.raws.afterName || ``}${statement.params}`;
-  } else {
-    return ``;
-  }
+  if (!noRawBefore) result2 += before;
+  if (isRule(statement)) result2 += statement.selector;
+  else if (isAtRule(statement)) result2 += `@${statement.name}${statement.raws.afterName || ``}${statement.params}`;
+  else return ``;
   result2 += statement.raws.between || ``;
   return result2;
 }
 function blockString(statement) {
-  if (!hasBlock(statement)) {
-    return ``;
-  }
+  if (!hasBlock(statement)) return ``;
   return rawNodeString(statement).slice(beforeBlockString(statement).length);
 }
 function hasEmptyBlock(statement) {
@@ -15132,32 +15046,22 @@ function hasEmptyBlock(statement) {
 }
 const HAS_EMPTY_LINE = /\n[\r\t ]*\n/;
 function hasEmptyLine(string2) {
-  if (string2 === `` || string2 === void 0) {
-    return false;
-  }
+  if (string2 === `` || string2 === void 0) return false;
   return HAS_EMPTY_LINE.test(string2);
 }
 function matchesStringOrRegExp(input2, comparison) {
-  if (!Array.isArray(input2)) {
-    return testAgainstStringOrRegExpOrArray(input2, comparison);
-  }
+  if (!Array.isArray(input2)) return testAgainstStringOrRegExpOrArray(input2, comparison);
   for (let inputItem of input2) {
     let testResult = testAgainstStringOrRegExpOrArray(inputItem, comparison);
-    if (testResult) {
-      return testResult;
-    }
+    if (testResult) return testResult;
   }
   return false;
 }
 function testAgainstStringOrRegExpOrArray(value, comparison) {
-  if (!Array.isArray(comparison)) {
-    return testAgainstStringOrRegExp(value, comparison);
-  }
+  if (!Array.isArray(comparison)) return testAgainstStringOrRegExp(value, comparison);
   for (let comparisonItem of comparison) {
     let testResult = testAgainstStringOrRegExp(value, comparisonItem);
-    if (testResult) {
-      return testResult;
-    }
+    if (testResult) return testResult;
   }
   return false;
 }
@@ -15212,32 +15116,22 @@ function rule$17(primary, secondaryOptions, context) {
         optional: true
       }
     );
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     root2.walkRules(check);
     root2.walkAtRules(check);
     function check(statement) {
-      if (!hasBlock(statement) || hasEmptyBlock(statement)) {
-        return;
-      }
+      if (!hasBlock(statement) || hasEmptyBlock(statement)) return;
       let before = (statement.raws.after || ``).replace(/;+/, ``);
       let statementString = statement.toString();
       let index2 = statementString.length - 1;
-      if (statementString[index2 - 1] === `\r`) {
-        index2 -= 1;
-      }
+      if (statementString[index2 - 1] === `\r`) index2 -= 1;
       let expectEmptyLineBefore = (() => {
         let childNodeTypes = statement.nodes.map((item) => item.type);
-        if (optionsMatches(secondaryOptions, `except`, `after-closing-brace`) && !childNodeTypes.includes(`decl`)) {
-          return primary === `never`;
-        }
+        if (optionsMatches(secondaryOptions, `except`, `after-closing-brace`) && !childNodeTypes.includes(`decl`)) return primary === `never`;
         return primary === `always-multi-line` && !isSingleLineString(blockString(statement));
       })();
       let hasEmptyLineBefore = hasEmptyLine(before);
-      if (expectEmptyLineBefore === hasEmptyLineBefore) {
-        return;
-      }
+      if (expectEmptyLineBefore === hasEmptyLineBefore) return;
       let message = expectEmptyLineBefore ? messages$17.expected : messages$17.rejected;
       report$T({
         message,
@@ -15249,11 +15143,8 @@ function rule$17(primary, secondaryOptions, context) {
         fix() {
           let { newline } = context;
           if (typeof newline !== `string`) return;
-          if (expectEmptyLineBefore) {
-            addEmptyLineAfter(statement, newline);
-          } else {
-            removeEmptyLinesAfter(statement, newline);
-          }
+          if (expectEmptyLineBefore) addEmptyLineAfter(statement, newline);
+          else removeEmptyLinesAfter(statement, newline);
         }
       });
     }
@@ -15307,28 +15198,18 @@ function rule$16(primary, secondaryOptions, context) {
         optional: true
       }
     );
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     root2.walkRules(check);
     root2.walkAtRules(check);
     function check(statement) {
-      if (!hasBlock(statement)) {
-        return;
-      }
-      if (statement.type === `atrule` && optionsMatches(secondaryOptions, `ignoreAtRules`, statement.name)) {
-        return;
-      }
+      if (!hasBlock(statement)) return;
+      if (statement.type === `atrule` && optionsMatches(secondaryOptions, `ignoreAtRules`, statement.name)) return;
       let nextNode = statement.next();
-      if (!nextNode) {
-        return;
-      }
+      if (!nextNode) return;
       let nextNodeIsSingleLineComment = nextNode.type === `comment` && !/[^ ]/.test(nextNode.raws.before || ``) && !nextNode.toString().includes(`
 `);
       let nodeToCheck = nextNodeIsSingleLineComment ? nextNode.next() : nextNode;
-      if (!nodeToCheck) {
-        return;
-      }
+      if (!nodeToCheck) return;
       let reportIndex = statement.toString().length;
       let source = rawNodeString(nodeToCheck);
       if (source && source.startsWith(`;`)) {
@@ -15353,9 +15234,7 @@ function rule$16(primary, secondaryOptions, context) {
               if (primary.startsWith(`always`)) {
                 let index2 = nodeToCheckRaws.before.search(/\r?\n/);
                 nodeToCheckRaws.before = index2 >= 0 ? nodeToCheckRaws.before.slice(index2) : context.newline + nodeToCheckRaws.before;
-              } else if (primary.startsWith(`never`)) {
-                nodeToCheckRaws.before = ``;
-              }
+              } else if (primary.startsWith(`never`)) nodeToCheckRaws.before = ``;
             }
           });
         }
@@ -15391,37 +15270,24 @@ function rule$15(primary, _secondaryOptions, context) {
       actual: primary,
       possible: [`always`, `always-multi-line`, `never-multi-line`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     root2.walkRules(check);
     root2.walkAtRules(check);
     function check(statement) {
-      if (!hasBlock(statement) || hasEmptyBlock(statement)) {
-        return;
-      }
+      if (!hasBlock(statement) || hasEmptyBlock(statement)) return;
       let after = (statement.raws.after || ``).replace(/;+/, ``);
-      if (after === void 0) {
-        return;
-      }
+      if (after === void 0) return;
       let blockIsMultiLine = !isSingleLineString(blockString(statement));
       let statementString = statement.toString();
       let index2 = statementString.length - 2;
-      if (statementString[index2 - 1] === `\r`) {
-        index2 -= 1;
-      }
+      if (statementString[index2 - 1] === `\r`) index2 -= 1;
       if (!after.startsWith(`
 `) && !after.startsWith(`\r
 `)) {
-        if (primary === `always`) {
-          complain(messages$15.expectedBefore);
-        } else if (blockIsMultiLine && primary === `always-multi-line`) {
-          complain(messages$15.expectedBeforeMultiLine);
-        }
-      }
-      if (after !== `` && blockIsMultiLine && primary === `never-multi-line`) {
-        complain(messages$15.rejectedBeforeMultiLine);
+        if (primary === `always`) complain(messages$15.expectedBefore);
+        else if (blockIsMultiLine && primary === `always-multi-line`) complain(messages$15.expectedBeforeMultiLine);
       }
+      if (after !== `` && blockIsMultiLine && primary === `never-multi-line`) complain(messages$15.rejectedBeforeMultiLine);
       function complain(message) {
         report$R({
           message,
@@ -15439,9 +15305,7 @@ function rule$15(primary, _secondaryOptions, context) {
               let newlineAfter = firstWhitespaceIndex >= 0 ? statementRaws.after.slice(firstWhitespaceIndex) : ``;
               let newlineIndex = newlineAfter.search(/\r?\n/);
               statementRaws.after = newlineIndex >= 0 ? newlineBefore + newlineAfter.slice(newlineIndex) : newlineBefore + context.newline + newlineAfter;
-            } else if (primary === `never-multi-line`) {
-              statementRaws.after = statementRaws.after.replace(/\s/g, ``);
-            }
+            } else if (primary === `never-multi-line`) statementRaws.after = statementRaws.after.replace(/\s/g, ``);
           }
         });
       }
@@ -15486,19 +15350,13 @@ function rule$14(primary) {
         `never-multi-line`
       ]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     root2.walkRules(check);
     root2.walkAtRules(check);
     function check(statement) {
       let nextNode = statement.next();
-      if (!nextNode) {
-        return;
-      }
-      if (!hasBlock(statement)) {
-        return;
-      }
+      if (!nextNode) return;
+      if (!hasBlock(statement)) return;
       let reportIndex = statement.toString().length;
       let source = rawNodeString(nextNode);
       if (source && source.startsWith(`;`)) {
@@ -15562,21 +15420,15 @@ function rule$13(primary) {
         `never-multi-line`
       ]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     root2.walkRules(check);
     root2.walkAtRules(check);
     function check(statement) {
-      if (!hasBlock(statement) || hasEmptyBlock(statement)) {
-        return;
-      }
+      if (!hasBlock(statement) || hasEmptyBlock(statement)) return;
       let source = blockString(statement);
       let statementString = statement.toString();
       let index2 = statementString.length - 2;
-      if (statementString[index2 - 1] === `\r`) {
-        index2 -= 1;
-      }
+      if (statementString[index2 - 1] === `\r`) index2 -= 1;
       checker.before({
         source,
         index: source.length - 1,
@@ -15591,11 +15443,8 @@ function rule$13(primary) {
             fix() {
               let statementRaws = statement.raws;
               if (typeof statementRaws.after !== `string`) return;
-              if (primary.startsWith(`always`)) {
-                statementRaws.after = statementRaws.after.replace(/\s*$/, ` `);
-              } else if (primary.startsWith(`never`)) {
-                statementRaws.after = statementRaws.after.replace(/\s*$/, ``);
-              }
+              if (primary.startsWith(`always`)) statementRaws.after = statementRaws.after.replace(/\s*$/, ` `);
+              else if (primary.startsWith(`never`)) statementRaws.after = statementRaws.after.replace(/\s*$/, ``);
             }
           });
         }
@@ -15643,22 +15492,14 @@ function rule$12(primary, secondaryOptions, context) {
         optional: true
       }
     );
-    if (!validOptions) {
-      return;
-    }
-    if (!optionsMatches(secondaryOptions, `ignore`, `rules`)) {
-      root2.walkRules(check);
-    }
+    if (!validOptions) return;
+    if (!optionsMatches(secondaryOptions, `ignore`, `rules`)) root2.walkRules(check);
     root2.walkAtRules(check);
     function check(statement) {
-      if (!hasBlock(statement) || hasEmptyBlock(statement)) {
-        return;
-      }
+      if (!hasBlock(statement) || hasEmptyBlock(statement)) return;
       let backupCommentNextBefores = /* @__PURE__ */ new Map();
       function nextNode(startNode) {
-        if (!startNode || !startNode.next) {
-          return;
-        }
+        if (!startNode || !startNode.next) return;
         if (startNode.type === `comment`) {
           let reNewLine = /\r?\n/;
           let newLineMatch = reNewLine.test(startNode.raws.before || ``);
@@ -15672,9 +15513,7 @@ function rule$12(primary, secondaryOptions, context) {
         return startNode;
       }
       let nodeToCheck = nextNode(statement.first);
-      if (!nodeToCheck) {
-        return;
-      }
+      if (!nodeToCheck) return;
       const problemIndex = beforeBlockString(statement, { noRawBefore: true }).length + 1;
       checker.afterOneOnly({
         source: rawNodeString(nodeToCheck),
@@ -15690,9 +15529,7 @@ function rule$12(primary, secondaryOptions, context) {
             ruleName: ruleName$12,
             fix() {
               let nodeToCheckRaws = nodeToCheck.raws;
-              if (typeof nodeToCheckRaws.before !== `string`) {
-                return;
-              }
+              if (typeof nodeToCheckRaws.before !== `string`) return;
               if (primary.startsWith(`always`)) {
                 let index2 = nodeToCheckRaws.before.search(/\r?\n/);
                 nodeToCheckRaws.before = index2 >= 0 ? nodeToCheckRaws.before.slice(index2) : context.newline + nodeToCheckRaws.before;
@@ -15700,23 +15537,15 @@ function rule$12(primary, secondaryOptions, context) {
                 return;
               }
               if (primary === `never-multi-line`) {
-                for (let [node2, before] of backupCommentNextBefores.entries()) {
-                  node2.raws.before = before;
-                }
+                for (let [node2, before] of backupCommentNextBefores.entries()) node2.raws.before = before;
                 backupCommentNextBefores.clear();
                 let reNewLine = /\r?\n/;
                 let fixTarget = statement.first;
                 while (fixTarget) {
                   let fixTargetRaws = fixTarget.raws;
-                  if (typeof fixTargetRaws.before !== `string`) {
-                    continue;
-                  }
-                  if (reNewLine.test(fixTargetRaws.before || ``)) {
-                    fixTargetRaws.before = fixTargetRaws.before.replace(/\r?\n/g, ``);
-                  }
-                  if (fixTarget.type !== `comment`) {
-                    break;
-                  }
+                  if (typeof fixTargetRaws.before !== `string`) continue;
+                  if (reNewLine.test(fixTargetRaws.before || ``)) fixTargetRaws.before = fixTargetRaws.before.replace(/\r?\n/g, ``);
+                  if (fixTarget.type !== `comment`) break;
                   fixTarget = fixTarget.next();
                 }
                 nodeToCheckRaws.before = ``;
@@ -15725,9 +15554,7 @@ function rule$12(primary, secondaryOptions, context) {
           });
         }
       });
-      for (let [node2, before] of backupCommentNextBefores.entries()) {
-        node2.raws.before = before;
-      }
+      for (let [node2, before] of backupCommentNextBefores.entries()) node2.raws.before = before;
     }
   };
 }
@@ -15768,23 +15595,17 @@ function rule$11(primary, _secondaryOptions, context) {
         `never-multi-line`
       ]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     root2.walkRules(check);
     root2.walkAtRules(check);
     function check(statement) {
-      if (!hasBlock(statement) || hasEmptyBlock(statement)) {
-        return;
-      }
+      if (!hasBlock(statement) || hasEmptyBlock(statement)) return;
       let source = beforeBlockString(statement);
       let beforeBraceNoRaw = beforeBlockString(statement, {
         noRawBefore: true
       });
       let index2 = beforeBraceNoRaw.length - 1;
-      if (beforeBraceNoRaw[index2 - 1] === `\r`) {
-        index2 -= 1;
-      }
+      if (beforeBraceNoRaw[index2 - 1] === `\r`) index2 -= 1;
       checker.beforeAllowingIndentation({
         lineCheckStr: blockString(statement),
         source,
@@ -15801,14 +15622,9 @@ function rule$11(primary, _secondaryOptions, context) {
               if (typeof statement.raws.between !== `string`) return;
               if (primary.startsWith(`always`)) {
                 let spaceIndex = statement.raws.between.search(/\s+$/);
-                if (spaceIndex >= 0) {
-                  statement.raws.between = statement.raws.between.slice(0, spaceIndex) + context.newline + statement.raws.between.slice(spaceIndex);
-                } else {
-                  statement.raws.between += context.newline;
-                }
-              } else if (primary.startsWith(`never`)) {
-                statement.raws.between = statement.raws.between.replace(/\s*$/, ``);
-              }
+                if (spaceIndex >= 0) statement.raws.between = statement.raws.between.slice(0, spaceIndex) + context.newline + statement.raws.between.slice(spaceIndex);
+                else statement.raws.between += context.newline;
+              } else if (primary.startsWith(`never`)) statement.raws.between = statement.raws.between.replace(/\s*$/, ``);
             }
           });
         }
@@ -15866,17 +15682,11 @@ function rule$10(primary, secondaryOptions) {
         optional: true
       }
     );
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     root2.walkRules(check);
-    if (!optionsMatches(secondaryOptions, `ignore`, `at-rules`)) {
-      root2.walkAtRules(check);
-    }
+    if (!optionsMatches(secondaryOptions, `ignore`, `at-rules`)) root2.walkAtRules(check);
     function check(statement) {
-      if (!hasBlock(statement) || hasEmptyBlock(statement)) {
-        return;
-      }
+      if (!hasBlock(statement) || hasEmptyBlock(statement)) return;
       const problemIndex = beforeBlockString(statement, { noRawBefore: true }).length + 1;
       checker.after({
         source: blockString(statement),
@@ -15892,11 +15702,8 @@ function rule$10(primary, secondaryOptions) {
             fix() {
               let statementFirst = statement.first;
               if (statementFirst === null) return;
-              if (primary.startsWith(`always`)) {
-                statementFirst.raws.before = ` `;
-              } else if (primary.startsWith(`never`)) {
-                statementFirst.raws.before = ``;
-              }
+              if (primary.startsWith(`always`)) statementFirst.raws.before = ` `;
+              else if (primary.startsWith(`never`)) statementFirst.raws.before = ``;
             }
           });
         }
@@ -15955,29 +15762,19 @@ function rule$$(primary, secondaryOptions) {
         optional: true
       }
     );
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     root2.walkRules(check);
     root2.walkAtRules(check);
     function check(statement) {
-      if (!hasBlock(statement) || hasEmptyBlock(statement)) {
-        return;
-      }
-      if (statement.type === `atrule` && optionsMatches(secondaryOptions, `ignoreAtRules`, statement.name)) {
-        return;
-      }
-      if (statement.type === `rule` && optionsMatches(secondaryOptions, `ignoreSelectors`, statement.selector)) {
-        return;
-      }
+      if (!hasBlock(statement) || hasEmptyBlock(statement)) return;
+      if (statement.type === `atrule` && optionsMatches(secondaryOptions, `ignoreAtRules`, statement.name)) return;
+      if (statement.type === `rule` && optionsMatches(secondaryOptions, `ignoreSelectors`, statement.selector)) return;
       let source = beforeBlockString(statement);
       let beforeBraceNoRaw = beforeBlockString(statement, {
         noRawBefore: true
       });
       let index2 = beforeBraceNoRaw.length - 1;
-      if (beforeBraceNoRaw[index2 - 1] === `\r`) {
-        index2 -= 1;
-      }
+      if (beforeBraceNoRaw[index2 - 1] === `\r`) index2 -= 1;
       checker.before({
         source,
         index: source.length,
@@ -15995,9 +15792,7 @@ function rule$$(primary, secondaryOptions) {
                 statement.raws.between = ` `;
                 return;
               }
-              if (primary.startsWith(`never`)) {
-                statement.raws.between = ``;
-              }
+              if (primary.startsWith(`never`)) statement.raws.between = ``;
             }
           });
         }
@@ -16025,9 +15820,7 @@ function declarationValueIndex(decl) {
     raws.between || `:`,
     raws.value && `prefix` in raws.value && raws.value.prefix
   ].reduce((count, str) => {
-    if (isString(str)) {
-      return count + str.length;
-    }
+    if (isString(str)) return count + str.length;
     return count;
   }, 0);
 }
@@ -16037,11 +15830,8 @@ function getDeclarationValue(decl) {
 }
 function setDeclarationValue(decl, value) {
   let raws = decl.raws;
-  if (raws.value) {
-    raws.value.raw = value;
-  } else {
-    decl.value = value;
-  }
+  if (raws.value) raws.value.raw = value;
+  else decl.value = value;
   return decl;
 }
 let { utils: { report: report$K, ruleMessages: ruleMessages$_, validateOptions: validateOptions$_ } } = stylelint;
@@ -16063,27 +15853,17 @@ function rule$_(primary) {
       actual: primary,
       possible: [`lower`, `upper`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     root2.walkDecls((decl) => {
-      if (!CONTAINS_HEX.test(decl.value)) {
-        return;
-      }
+      if (!CONTAINS_HEX.test(decl.value)) return;
       let parsedValue = valueParser(getDeclarationValue(decl));
       let needsFix = false;
       parsedValue.walk((node2) => {
         let { value } = node2;
-        if (isIgnoredFunction(node2)) {
-          return false;
-        }
-        if (!isHexColor(node2)) {
-          return;
-        }
+        if (isIgnoredFunction(node2)) return false;
+        if (!isHexColor(node2)) return;
         let expected = primary === `lower` ? value.toLowerCase() : value.toUpperCase();
-        if (value === expected) {
-          return;
-        }
+        if (value === expected) return;
         const problemIndex = declarationValueIndex(decl) + node2.sourceIndex;
         report$K({
           message: messages$_.expected,
@@ -16099,9 +15879,7 @@ function rule$_(primary) {
           }
         });
       });
-      if (needsFix) {
-        setDeclarationValue(decl, parsedValue.toString());
-      }
+      if (needsFix) setDeclarationValue(decl, parsedValue.toString());
     });
   };
 }
@@ -16273,9 +16051,7 @@ function declarationBangSpaceChecker(opts) {
     let indexOffset = declarationValueIndex(decl);
     let declString = decl.toString();
     let valueString = decl.toString().slice(indexOffset);
-    if (!valueString.includes(`!`)) {
-      return;
-    }
+    if (!valueString.includes(`!`)) return;
     styleSearch({ source: valueString, target: `!` }, (match) => {
       check(declString, match.startIndex + indexOffset, decl);
     });
@@ -16316,9 +16092,7 @@ function rule$Z(primary) {
       actual: primary,
       possible: [`always`, `never`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     declarationBangSpaceChecker({
       root: root2,
       result: result2,
@@ -16340,9 +16114,7 @@ function rule$Z(primary) {
           setFixed = (value) => {
             decl.raws.important = value;
           };
-        } else {
-          return false;
-        }
+        } else return false;
         let targetBefore = target.slice(0, bangIndex + 1);
         let targetAfter = target.slice(bangIndex + 1);
         if (primary === `always`) {
@@ -16386,9 +16158,7 @@ function rule$Y(primary) {
       actual: primary,
       possible: [`always`, `never`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     declarationBangSpaceChecker({
       root: root2,
       result: result2,
@@ -16410,9 +16180,7 @@ function rule$Y(primary) {
           setFixed = (val) => {
             decl.raws.important = val;
           };
-        } else {
-          return false;
-        }
+        } else return false;
         let targetBefore = target.slice(0, bangIndex);
         let targetAfter = target.slice(bangIndex);
         if (primary === `always`) {
@@ -16457,28 +16225,16 @@ function rule$X(primary, _secondaryOptions, context) {
       actual: primary,
       possible: [`always`, `always-multi-line`, `never-multi-line`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     root2.walkDecls((decl) => {
       let parentRule = decl.parent;
-      if (!parentRule) {
-        throw new Error(`A parent node must be present`);
-      }
-      if (!isAtRule(parentRule) && !isRule(parentRule)) {
-        return;
-      }
-      if (!parentRule.raws.semicolon && parentRule.last === decl) {
-        return;
-      }
+      if (!parentRule) throw new Error(`A parent node must be present`);
+      if (!isAtRule(parentRule) && !isRule(parentRule)) return;
+      if (!parentRule.raws.semicolon && parentRule.last === decl) return;
       let nextNode = decl.next();
-      if (!nextNode) {
-        return;
-      }
+      if (!nextNode) return;
       let nodeToCheck = nextNonCommentNode(nextNode);
-      if (!nodeToCheck) {
-        return;
-      }
+      if (!nodeToCheck) return;
       const problemIndex = decl.toString().length + 1;
       checker.afterOneOnly({
         source: rawNodeString(nodeToCheck),
@@ -16498,9 +16254,7 @@ function rule$X(primary, _secondaryOptions, context) {
                 nodeToCheck.raws.before = index2 >= 0 ? nodeToCheck.raws.before.slice(index2) : context.newline + nodeToCheck.raws.before;
                 return;
               }
-              if (primary === `never-multi-line`) {
-                nodeToCheck.raws.before = ``;
-              }
+              if (primary === `never-multi-line`) nodeToCheck.raws.before = ``;
             }
           });
         }
@@ -16536,20 +16290,12 @@ function rule$W(primary) {
       actual: primary,
       possible: [`always`, `always-multi-line`, `never-multi-line`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     root2.walkDecls((decl) => {
       let parentRule = decl.parent;
-      if (!parentRule) {
-        throw new Error(`A parent node must be present`);
-      }
-      if (!isAtRule(parentRule) && !isRule(parentRule)) {
-        return;
-      }
-      if (!parentRule.raws.semicolon && parentRule.last === decl) {
-        return;
-      }
+      if (!parentRule) throw new Error(`A parent node must be present`);
+      if (!isAtRule(parentRule) && !isRule(parentRule)) return;
+      if (!parentRule.raws.semicolon && parentRule.last === decl) return;
       const declString = decl.toString();
       const problemIndex = decl.toString().length - 1;
       checker.beforeAllowingIndentation({
@@ -16600,24 +16346,14 @@ function rule$V(primary) {
       actual: primary,
       possible: [`always`, `never`, `always-single-line`, `never-single-line`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     root2.walkDecls((decl) => {
       let parentRule = decl.parent;
-      if (!parentRule) {
-        throw new Error(`A parent node must be present`);
-      }
-      if (!isAtRule(parentRule) && !isRule(parentRule)) {
-        return;
-      }
-      if (!parentRule.raws.semicolon && parentRule.last === decl) {
-        return;
-      }
+      if (!parentRule) throw new Error(`A parent node must be present`);
+      if (!isAtRule(parentRule) && !isRule(parentRule)) return;
+      if (!parentRule.raws.semicolon && parentRule.last === decl) return;
       let nextDecl = decl.next();
-      if (!nextDecl) {
-        return;
-      }
+      if (!nextDecl) return;
       const problemIndex = decl.toString().length + 1;
       checker.after({
         source: rawNodeString(nextDecl),
@@ -16636,9 +16372,7 @@ function rule$V(primary) {
                 nextDecl.raws.before = ` `;
                 return;
               }
-              if (primary.startsWith(`never`)) {
-                nextDecl.raws.before = ``;
-              }
+              if (primary.startsWith(`never`)) nextDecl.raws.before = ``;
             }
           });
         }
@@ -16679,27 +16413,17 @@ function rule$U(primary) {
       actual: primary,
       possible: [`always`, `never`, `always-single-line`, `never-single-line`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     root2.walkDecls((decl) => {
       let parentRule = decl.parent;
-      if (!parentRule) {
-        throw new Error(`A parent node must be present`);
-      }
-      if (!isAtRule(parentRule) && !isRule(parentRule)) {
-        return;
-      }
-      if (!parentRule.raws.semicolon && parentRule.last === decl) {
-        return;
-      }
+      if (!parentRule) throw new Error(`A parent node must be present`);
+      if (!isAtRule(parentRule) && !isRule(parentRule)) return;
+      if (!parentRule.raws.semicolon && parentRule.last === decl) return;
       const value = getDeclarationValue(decl);
       let isCustomPropertyWithOnlySpaces = false;
       if (isCustomProperty(decl.prop)) {
         isCustomPropertyWithOnlySpaces = /^\s+$/.test(value);
-        if (primary.startsWith(`never`) && value === ` `) {
-          return;
-        }
+        if (primary.startsWith(`never`) && value === ` `) return;
       }
       const declString = decl.toString();
       const problemIndex = decl.toString().length - 1;
@@ -16717,17 +16441,13 @@ function rule$U(primary) {
             ruleName: ruleName$U,
             fix() {
               if (primary.startsWith(`always`)) {
-                if (decl.important) {
-                  decl.raws.important = ` !important `;
-                } else {
-                  setDeclarationValue(decl, value.replace(/\s*$/, ` `));
-                }
+                if (decl.important) decl.raws.important = ` !important `;
+                else setDeclarationValue(decl, value.replace(/\s*$/, ` `));
                 return;
               }
               if (primary.startsWith(`never`)) {
-                if (decl.raws.important) {
-                  decl.raws.important = decl.raws.important.replace(/\s*$/, ``);
-                } else {
+                if (decl.raws.important) decl.raws.important = decl.raws.important.replace(/\s*$/, ``);
+                else {
                   const newValue = isCustomPropertyWithOnlySpaces ? ` ` : value.replace(/\s*$/, ``);
                   setDeclarationValue(decl, newValue);
                 }
@@ -16777,9 +16497,7 @@ function rule$T(primary, secondaryOptions) {
         optional: true
       }
     );
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     root2.walkAtRules((atRule2) => {
       if (!atRule2.parent) throw new Error(`A parent node must be present`);
       if (atRule2.parent === root2 || atRule2 !== atRule2.parent.last || hasBlock(atRule2)) return;
@@ -16791,9 +16509,7 @@ function rule$T(primary, secondaryOptions) {
       checkLastNode(decl);
     });
     function checkLastNode(node2) {
-      if (!node2.parent) {
-        throw new Error(`A parent node must be present`);
-      }
+      if (!node2.parent) throw new Error(`A parent node must be present`);
       let hasSemicolon = node2.parent.raws.semicolon;
       let ignoreSingleDeclaration = optionsMatches(
         secondaryOptions,
@@ -16803,11 +16519,8 @@ function rule$T(primary, secondaryOptions) {
       if (ignoreSingleDeclaration && node2.parent.first === node2) return;
       if (primary === `always` && primary === `never`) throw new Error(`Unexpected primary option: "${primary}"`);
       let message;
-      if (primary === `always` && !hasSemicolon) {
-        message = messages$T.expected;
-      } else if (primary === `never` && hasSemicolon) {
-        message = messages$T.rejected;
-      }
+      if (primary === `always` && !hasSemicolon) message = messages$T.expected;
+      else if (primary === `never` && hasSemicolon) message = messages$T.rejected;
       const problemIndex = node2.toString().trim().length - 1;
       if (message) {
         report$E({
@@ -16824,9 +16537,7 @@ function rule$T(primary, secondaryOptions) {
                 node2.raws.between = ``;
                 node2.parent.raws.after = ` `;
               }
-            } else if (primary === `never` && hasSemicolon) {
-              node2.parent.raws.semicolon = false;
-            }
+            } else if (primary === `never` && hasSemicolon) node2.parent.raws.semicolon = false;
           }
         });
       }
@@ -16844,35 +16555,19 @@ const index$T = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
   ruleName: ruleName$T
 }, Symbol.toStringTag, { value: "Module" }));
 function isScssVariable(property) {
-  if (property.startsWith(`$`)) {
-    return true;
-  }
-  if (property.includes(`.$`)) {
-    return true;
-  }
+  if (property.startsWith(`$`)) return true;
+  if (property.includes(`.$`)) return true;
   return false;
 }
 function isStandardSyntaxDeclaration(decl) {
   let prop = decl.prop;
   let parent = decl.parent;
-  if (isScssVariable(prop)) {
-    return false;
-  }
-  if (prop[0] === `@` && prop[1] !== `{`) {
-    return false;
-  }
-  if (parent && parent.type === `atrule` && parent.raws.afterName === `:`) {
-    return false;
-  }
-  if (parent && isRule(parent) && parent.selector && parent.selector.startsWith(`#`) && parent.selector.endsWith(`()`)) {
-    return false;
-  }
-  if (parent && isRule(parent) && parent.selector && parent.selector[parent.selector.length - 1] === `:` && parent.selector.substring(0, 2) !== `--`) {
-    return false;
-  }
-  if (`extend` in decl && decl.extend) {
-    return false;
-  }
+  if (isScssVariable(prop)) return false;
+  if (prop[0] === `@` && prop[1] !== `{`) return false;
+  if (parent && parent.type === `atrule` && parent.raws.afterName === `:`) return false;
+  if (parent && isRule(parent) && parent.selector && parent.selector.startsWith(`#`) && parent.selector.endsWith(`()`)) return false;
+  if (parent && isRule(parent) && parent.selector && parent.selector[parent.selector.length - 1] === `:` && parent.selector.substring(0, 2) !== `--`) return false;
+  if (`extend` in decl && decl.extend) return false;
   return true;
 }
 let { utils: { report: report$D, ruleMessages: ruleMessages$S, validateOptions: validateOptions$S } } = stylelint;
@@ -16893,19 +16588,13 @@ function rule$S(primary, _secondaryOptions, context) {
       actual: primary,
       possible: [`always`, `always-multi-line`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     root2.walkDecls((decl) => {
-      if (!isStandardSyntaxDeclaration(decl)) {
-        return;
-      }
+      if (!isStandardSyntaxDeclaration(decl)) return;
       let endOfPropIndex = declarationValueIndex(decl) + (decl.raws.between || ``).length - 1;
       let propPlusColon = `${decl.toString().slice(0, endOfPropIndex)}xxx`;
       for (let i2 = 0, l2 = propPlusColon.length; i2 < l2; i2++) {
-        if (propPlusColon[i2] !== `:`) {
-          continue;
-        }
+        if (propPlusColon[i2] !== `:`) continue;
         let indexToCheck = /^[^\S\r\n]*\/\*/.test(propPlusColon.slice(i2 + 1)) ? propPlusColon.indexOf(`*/`, i2) + 1 : i2;
         checker.afterOneOnly({
           source: propPlusColon,
@@ -16921,9 +16610,7 @@ function rule$S(primary, _secondaryOptions, context) {
               ruleName: ruleName$S,
               fix() {
                 let between = decl.raws.between;
-                if (between === null) {
-                  throw new Error(`\`between\` must be present`);
-                }
+                if (between === null) throw new Error(`\`between\` must be present`);
                 let betweenStart = declarationValueIndex(decl) - between.length;
                 let sliceIndex = indexToCheck - betweenStart + 1;
                 let betweenBefore = between.slice(0, sliceIndex);
@@ -16950,15 +16637,11 @@ const index$S = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
 let { utils: { report: report$C } } = stylelint;
 function declarationColonSpaceChecker(opts) {
   opts.root.walkDecls((decl) => {
-    if (!isStandardSyntaxDeclaration(decl)) {
-      return;
-    }
+    if (!isStandardSyntaxDeclaration(decl)) return;
     let endOfPropIndex = declarationValueIndex(decl) + (decl.raws.between || ``).length - 1;
     let propPlusColon = `${decl.toString().slice(0, endOfPropIndex)}xxx`;
     for (let i2 = 0, l2 = propPlusColon.length; i2 < l2; i2++) {
-      if (propPlusColon[i2] !== `:`) {
-        continue;
-      }
+      if (propPlusColon[i2] !== `:`) continue;
       const problemIndex = decl.prop.toString().length + 1;
       opts.locationChecker({
         source: propPlusColon,
@@ -16999,9 +16682,7 @@ function rule$R(primary) {
       actual: primary,
       possible: [`always`, `never`, `always-single-line`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     declarationColonSpaceChecker({
       root: root2,
       result: result2,
@@ -17010,9 +16691,7 @@ function rule$R(primary) {
       fix: (decl, index2) => {
         let colonIndex = index2 - declarationValueIndex(decl);
         let between = decl.raws.between;
-        if (between === null) {
-          throw new Error(`\`between\` must be present`);
-        }
+        if (between === null) throw new Error(`\`between\` must be present`);
         if (primary.startsWith(`always`)) {
           decl.raws.between = between.slice(0, colonIndex) + between.slice(colonIndex).replace(/^:\s*/, `: `);
           return true;
@@ -17054,9 +16733,7 @@ function rule$Q(primary) {
       actual: primary,
       possible: [`always`, `never`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     declarationColonSpaceChecker({
       root: root2,
       result: result2,
@@ -17065,9 +16742,7 @@ function rule$Q(primary) {
       fix: (decl, index2) => {
         let colonIndex = index2 - declarationValueIndex(decl);
         let between = decl.raws.between;
-        if (between === null) {
-          throw new Error(`\`between\` must be present`);
-        }
+        if (between === null) throw new Error(`\`between\` must be present`);
         if (primary === `always`) {
           decl.raws.between = between.slice(0, colonIndex).replace(/\s*$/, ` `) + between.slice(colonIndex);
           return true;
@@ -17091,45 +16766,11 @@ const index$Q = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
   meta: meta$Q,
   ruleName: ruleName$Q
 }, Symbol.toStringTag, { value: "Module" }));
-function functionCommaSpaceFix(params) {
-  let { div, index: index2, nodes, expectation, position, symb } = params;
-  if (expectation.startsWith(`always`)) {
-    div[position] = symb;
-    return true;
-  }
-  if (expectation.startsWith(`never`)) {
-    div[position] = ``;
-    for (let i2 = index2 + 1; i2 < nodes.length; i2++) {
-      let node2 = nodes[i2];
-      if (node2 === void 0) {
-        continue;
-      }
-      if (node2.type === `comment`) {
-        continue;
-      }
-      if (node2.type === `space`) {
-        node2.value = ``;
-        continue;
-      }
-      break;
-    }
-    return true;
-  }
-  return false;
-}
 function isStandardSyntaxFunction(node2) {
-  if (!node2.value) {
-    return false;
-  }
-  if (node2.value.startsWith(`#{`)) {
-    return false;
-  }
-  if (node2.value.startsWith(`\${`)) {
-    return false;
-  }
-  if (node2.value.startsWith(`\``)) {
-    return false;
-  }
+  if (!node2.value) return false;
+  if (node2.value.startsWith(`#{`)) return false;
+  if (node2.value.startsWith(`\${`)) return false;
+  if (node2.value.startsWith(`\``)) return false;
   return true;
 }
 let { utils: { report: report$B } } = stylelint;
@@ -17139,15 +16780,9 @@ function functionCommaSpaceChecker(opts) {
     let hasFixed;
     let parsedValue = valueParser(declValue);
     parsedValue.walk((valueNode) => {
-      if (valueNode.type !== `function`) {
-        return;
-      }
-      if (!isStandardSyntaxFunction(valueNode)) {
-        return;
-      }
-      if (valueNode.value.toLowerCase() === `url`) {
-        return;
-      }
+      if (valueNode.type !== `function`) return;
+      if (!isStandardSyntaxFunction(valueNode)) return;
+      if (valueNode.value.toLowerCase() === `url`) return;
       let argumentStrings = valueNode.nodes.map((node2) => valueParser.stringify(node2));
       let functionArguments = (() => {
         let result2 = valueNode.before + argumentStrings.join(``) + valueNode.after;
@@ -17161,9 +16796,7 @@ function functionCommaSpaceChecker(opts) {
       }
       let commaDataList = [];
       for (let [nodeIndex, node2] of valueNode.nodes.entries()) {
-        if (node2.type !== `div` || node2.value !== `,`) {
-          continue;
-        }
+        if (node2.type !== `div` || node2.value !== `,`) continue;
         let checkIndex = getCommaCheckIndex(node2, nodeIndex);
         commaDataList.push({
           commaNode: node2,
@@ -17193,11 +16826,31 @@ function functionCommaSpaceChecker(opts) {
         });
       }
     });
-    if (hasFixed) {
-      setDeclarationValue(decl, parsedValue.toString());
-    }
+    if (hasFixed) setDeclarationValue(decl, parsedValue.toString());
   });
 }
+function functionCommaSpaceFix(params) {
+  let { div, index: index2, nodes, expectation, position, symb } = params;
+  if (expectation.startsWith(`always`)) {
+    div[position] = symb;
+    return true;
+  }
+  if (expectation.startsWith(`never`)) {
+    div[position] = ``;
+    for (let i2 = index2 + 1; i2 < nodes.length; i2++) {
+      let node2 = nodes[i2];
+      if (node2 === void 0) continue;
+      if (node2.type === `comment`) continue;
+      if (node2.type === `space`) {
+        node2.value = ``;
+        continue;
+      }
+      break;
+    }
+    return true;
+  }
+  return false;
+}
 let { utils: { ruleMessages: ruleMessages$P, validateOptions: validateOptions$P } } = stylelint;
 let shortName$P = `function-comma-newline-after`;
 let ruleName$P = addNamespace(shortName$P);
@@ -17217,9 +16870,7 @@ function rule$P(primary, _secondaryOptions, context) {
       actual: primary,
       possible: [`always`, `always-multi-line`, `never-multi-line`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     functionCommaSpaceChecker({
       root: root2,
       result: result2,
@@ -17265,9 +16916,7 @@ function rule$O(primary, _secondaryOptions, context) {
       actual: primary,
       possible: [`always`, `always-multi-line`, `never-multi-line`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     functionCommaSpaceChecker({
       root: root2,
       result: result2,
@@ -17314,9 +16963,7 @@ function rule$N(primary) {
       actual: primary,
       possible: [`always`, `never`, `always-single-line`, `never-single-line`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     functionCommaSpaceChecker({
       root: root2,
       result: result2,
@@ -17363,9 +17010,7 @@ function rule$M(primary) {
       actual: primary,
       possible: [`always`, `never`, `always-single-line`, `never-single-line`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     functionCommaSpaceChecker({
       root: root2,
       result: result2,
@@ -17403,9 +17048,7 @@ let meta$L = {
   fixable: true
 };
 function placeIndexOnValueStart(decl) {
-  if (decl.raws.between === null) {
-    throw new Error(`\`between\` must be present`);
-  }
+  if (decl.raws.between === null) throw new Error(`\`between\` must be present`);
   return decl.prop.length + decl.raws.between.length - 1;
 }
 function rule$L(primary) {
@@ -17415,9 +17058,7 @@ function rule$L(primary) {
       actual: primary,
       possible: isNumber$1
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     let violatedCRLFNewLinesRegex = new RegExp(`(?:\r
 ){${maxAdjacentNewlines + 1},}`);
     let violatedLFNewLinesRegex = new RegExp(`
@@ -17427,20 +17068,14 @@ function rule$L(primary) {
     let allowedCRLFNewLinesString = `\r
 `.repeat(maxAdjacentNewlines);
     root2.walkDecls((decl) => {
-      if (!decl.value.includes(`(`)) {
-        return;
-      }
+      if (!decl.value.includes(`(`)) return;
       let stringValue = getDeclarationValue(decl);
       let splittedValue = [];
       let sourceIndexStart = 0;
       valueParser(stringValue).walk((node2) => {
-        if (node2.type !== `function` || node2.value.length === 0) {
-          return;
-        }
+        if (node2.type !== `function` || node2.value.length === 0) return;
         let stringifiedNode = valueParser.stringify(node2);
-        if (!violatedLFNewLinesRegex.test(stringifiedNode) && !violatedCRLFNewLinesRegex.test(stringifiedNode)) {
-          return;
-        }
+        if (!violatedLFNewLinesRegex.test(stringifiedNode) && !violatedCRLFNewLinesRegex.test(stringifiedNode)) return;
         const problemIndex = placeIndexOnValueStart(decl) + node2.sourceIndex;
         report$A({
           message: messages$L.expected,
@@ -17498,24 +17133,16 @@ function rule$K(primary, _secondaryOptions, context) {
       actual: primary,
       possible: [`always`, `always-multi-line`, `never-multi-line`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     root2.walkDecls((decl) => {
-      if (!decl.value.includes(`(`)) {
-        return;
-      }
+      if (!decl.value.includes(`(`)) return;
       let fix = null;
       let hasFixed = false;
       let declValue = getDeclarationValue(decl);
       let parsedValue = valueParser(declValue);
       parsedValue.walk((valueNode) => {
-        if (valueNode.type !== `function`) {
-          return;
-        }
-        if (!isStandardSyntaxFunction(valueNode)) {
-          return;
-        }
+        if (valueNode.type !== `function`) return;
+        if (!isStandardSyntaxFunction(valueNode)) return;
         let functionString = valueParser.stringify(valueNode);
         let isMultiLine = !isSingleLineString(functionString);
         function containsNewline(str) {
@@ -17569,9 +17196,7 @@ function rule$K(primary, _secondaryOptions, context) {
           complain(messages$K.rejectedClosingMultiLine, closingIndex);
         }
       });
-      if (hasFixed) {
-        setDeclarationValue(decl, parsedValue.toString());
-      }
+      if (hasFixed) setDeclarationValue(decl, parsedValue.toString());
       function complain(message, offset) {
         const problemIndex = declarationValueIndex(decl) + offset;
         report$z({
@@ -17590,9 +17215,7 @@ function rule$K(primary, _secondaryOptions, context) {
 function getCheckBefore(valueNode) {
   let before = valueNode.before;
   for (let node2 of valueNode.nodes) {
-    if (node2.type === `comment`) {
-      continue;
-    }
+    if (node2.type === `comment`) continue;
     if (node2.type === `space`) {
       before += node2.value;
       continue;
@@ -17604,9 +17227,7 @@ function getCheckBefore(valueNode) {
 function getCheckAfter(valueNode) {
   let after = ``;
   for (let node2 of [...valueNode.nodes].reverse()) {
-    if (node2.type === `comment`) {
-      continue;
-    }
+    if (node2.type === `comment`) continue;
     if (node2.type === `space`) {
       after = node2.value + after;
       continue;
@@ -17619,27 +17240,20 @@ function getCheckAfter(valueNode) {
 function fixBeforeForAlways(valueNode, newline) {
   let target;
   for (let node2 of valueNode.nodes) {
-    if (node2.type === `comment`) {
-      continue;
-    }
+    if (node2.type === `comment`) continue;
     if (node2.type === `space`) {
       target = node2;
       continue;
     }
     break;
   }
-  if (target) {
-    target.value = newline + target.value;
-  } else {
-    valueNode.before = newline + valueNode.before;
-  }
+  if (target) target.value = newline + target.value;
+  else valueNode.before = newline + valueNode.before;
 }
 function fixBeforeForNever(valueNode) {
   valueNode.before = ``;
   for (let node2 of valueNode.nodes) {
-    if (node2.type === `comment`) {
-      continue;
-    }
+    if (node2.type === `comment`) continue;
     if (node2.type === `space`) {
       node2.value = ``;
       continue;
@@ -17653,9 +17267,7 @@ function fixAfterForAlways(valueNode, newline) {
 function fixAfterForNever(valueNode) {
   valueNode.after = ``;
   for (let node2 of [...valueNode.nodes].reverse()) {
-    if (node2.type === `comment`) {
-      continue;
-    }
+    if (node2.type === `comment`) continue;
     if (node2.type === `space`) {
       node2.value = ``;
       continue;
@@ -17696,27 +17308,17 @@ function rule$J(primary) {
       actual: primary,
       possible: [`always`, `never`, `always-single-line`, `never-single-line`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     root2.walkDecls((decl) => {
-      if (!decl.value.includes(`(`)) {
-        return;
-      }
+      if (!decl.value.includes(`(`)) return;
       let fix = null;
       let hasFixed = false;
       let declValue = getDeclarationValue(decl);
       let parsedValue = valueParser(declValue);
       parsedValue.walk((valueNode) => {
-        if (valueNode.type !== `function`) {
-          return;
-        }
-        if (!isStandardSyntaxFunction(valueNode)) {
-          return;
-        }
-        if (!valueNode.nodes.length) {
-          return;
-        }
+        if (valueNode.type !== `function`) return;
+        if (!isStandardSyntaxFunction(valueNode)) return;
+        if (!valueNode.nodes.length) return;
         let functionString = valueParser.stringify(valueNode);
         let isSingleLine = isSingleLineString(functionString);
         let openingIndex = valueNode.sourceIndex + valueNode.value.length + 1;
@@ -17778,9 +17380,7 @@ function rule$J(primary) {
           complain(messages$J.rejectedClosingSingleLine, closingIndex);
         }
       });
-      if (hasFixed) {
-        setDeclarationValue(decl, parsedValue.toString());
-      }
+      if (hasFixed) setDeclarationValue(decl, parsedValue.toString());
       function complain(message, offset) {
         const problemIndex = declarationValueIndex(decl) + offset;
         report$y({
@@ -17808,9 +17408,7 @@ const index$J = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
 }, Symbol.toStringTag, { value: "Module" }));
 function atRuleParamIndex(atRule2) {
   let index2 = 1 + atRule2.name.length;
-  if (atRule2.raws.afterName) {
-    index2 += atRule2.raws.afterName.length;
-  }
+  if (atRule2.raws.afterName) index2 += atRule2.raws.afterName.length;
   return index2;
 }
 let { utils: { report: report$x, ruleMessages: ruleMessages$I, validateOptions: validateOptions$I } } = stylelint;
@@ -17831,9 +17429,7 @@ function rule$I(primary) {
       actual: primary,
       possible: [`always`, `never`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     function check(node2, value, nodeIndex, fix) {
       styleSearch(
         {
@@ -17848,25 +17444,15 @@ function rule$I(primary) {
     }
     function checkClosingParen(source, index2, node2, nodeIndex, fix) {
       let nextChar = source.charAt(index2);
-      if (!nextChar) {
-        return;
-      }
+      if (!nextChar) return;
       const problemIndex = nodeIndex + index2;
       if (primary === `always`) {
-        if (nextChar === ` `) {
-          return;
-        }
+        if (nextChar === ` `) return;
         if (nextChar === `
-`) {
-          return;
-        }
+`) return;
         if (source.slice(index2, index2 + 2) === `\r
-`) {
-          return;
-        }
-        if (ACCEPTABLE_AFTER_CLOSING_PAREN.has(nextChar)) {
-          return;
-        }
+`) return;
+        if (ACCEPTABLE_AFTER_CLOSING_PAREN.has(nextChar)) return;
         report$x({
           message: messages$I.expected,
           node: node2,
@@ -17904,15 +17490,11 @@ function rule$I(primary) {
       } else if (primary === `never`) {
         applyFix = (index2) => {
           let whitespaceEndIndex = index2 + 1;
-          while (whitespaceEndIndex < value.length && isWhitespace$1(value.charAt(whitespaceEndIndex))) {
-            whitespaceEndIndex++;
-          }
+          while (whitespaceEndIndex < value.length && isWhitespace$1(value.charAt(whitespaceEndIndex))) whitespaceEndIndex++;
           fixed += value.slice(lastIndex, index2);
           lastIndex = whitespaceEndIndex;
         };
-      } else {
-        throw new Error(`Unexpected option: "${primary}"`);
-      }
+      } else throw new Error(`Unexpected option: "${primary}"`);
       return {
         applyFix,
         get hasFixed() {
@@ -17928,20 +17510,15 @@ function rule$I(primary) {
       let fixer = createFixer(param);
       check(atRule2, param, atRuleParamIndex(atRule2), fixer ? fixer.applyFix : void 0);
       if (fixer && fixer.hasFixed) {
-        if (atRule2.raws.params) {
-          atRule2.raws.params.raw = fixer.fixed;
-        } else {
-          atRule2.params = fixer.fixed;
-        }
+        if (atRule2.raws.params) atRule2.raws.params.raw = fixer.fixed;
+        else atRule2.params = fixer.fixed;
       }
     });
     root2.walkDecls((decl) => {
       let value = getDeclarationValue(decl);
       let fixer = createFixer(value);
       check(decl, value, declarationValueIndex(decl), fixer ? fixer.applyFix : void 0);
-      if (fixer && fixer.hasFixed) {
-        setDeclarationValue(decl, fixer.fixed);
-      }
+      if (fixer && fixer.hasFixed) setDeclarationValue(decl, fixer.fixed);
     });
   };
 }
@@ -17958,9 +17535,7 @@ const index$I = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
 function isStyledSyntaxDeclaration(declaration2) {
   let parent = declaration2.parent;
   while (parent) {
-    if (parent.raws.styledSyntaxRangeStart !== void 0) {
-      return true;
-    }
+    if (parent.raws.styledSyntaxRangeStart !== void 0) return true;
     parent = parent.parent;
   }
   return false;
@@ -17999,9 +17574,7 @@ function rule$H(primary, secondaryOptions = {}) {
         optional: true
       }
     );
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     let spaceCount = isNumber$1(primary) ? primary : null;
     let indentChar = spaceCount === null ? `	` : ` `.repeat(spaceCount);
     let warningWord = primary === `tab` ? `tab` : `space`;
@@ -18021,9 +17594,7 @@ function rule$H(primary, secondaryOptions = {}) {
       let before = (node2.raws.before || ``).replace(/[*_]$/, ``);
       let after = typeof node2.raws.after === `string` ? node2.raws.after : ``;
       let parent = node2.parent;
-      if (!parent) {
-        throw new Error(`A parent node must be present`);
-      }
+      if (!parent) throw new Error(`A parent node must be present`);
       let expectedOpeningBraceIndentation = indentChar.repeat(nodeLevel);
       let isFirstChild = parent.type === `root` && parent.first === node2;
       let lastIndexOfNewline = before.lastIndexOf(`
@@ -18037,9 +17608,7 @@ function rule$H(primary, secondaryOptions = {}) {
           result: result2,
           ruleName: ruleName$H,
           fix() {
-            if (isFirstChild && isString(node2.raws.before)) {
-              node2.raws.before = node2.raws.before.replace(/^[ \t]*(?=\S|$)/, expectedOpeningBraceIndentation);
-            }
+            if (isFirstChild && isString(node2.raws.before)) node2.raws.before = node2.raws.before.replace(/^[ \t]*(?=\S|$)/, expectedOpeningBraceIndentation);
             node2.raws.before = fixIndentation(node2.raws.before, expectedOpeningBraceIndentation);
           }
         });
@@ -18063,15 +17632,9 @@ function rule$H(primary, secondaryOptions = {}) {
           }
         });
       }
-      if (isDeclaration(node2)) {
-        checkValue(node2, nodeLevel);
-      }
-      if (isRule(node2)) {
-        checkSelector(node2, nodeLevel);
-      }
-      if (isAtRule(node2)) {
-        checkAtRuleParams(node2, nodeLevel);
-      }
+      if (isDeclaration(node2)) checkValue(node2, nodeLevel);
+      if (isRule(node2)) checkSelector(node2, nodeLevel);
+      if (isAtRule(node2)) checkAtRuleParams(node2, nodeLevel);
     });
     function getStyledDeclarationLevel(node2) {
       const expressionStartLine = node2.parent.parent.source.input.css.split(`
@@ -18080,62 +17643,42 @@ function rule$H(primary, secondaryOptions = {}) {
       return Math.ceil(indentCharacters.length / indentChar.length);
     }
     function indentationLevel(node2, level = 0) {
-      if (!node2.parent) {
-        throw new Error(`A parent node must be present`);
-      }
+      if (!node2.parent) throw new Error(`A parent node must be present`);
       if (isStyledSyntaxNode(node2)) {
         const isMultilineDeclaration = !!node2.parent.source?.input.css.includes(`
 `);
         if (isMultilineDeclaration) level++;
         level += getStyledDeclarationLevel(node2);
       }
-      if (isRoot(node2.parent)) {
-        return level + getRootBaseIndentLevel(node2.parent, baseIndentLevel, primary);
-      }
+      if (isRoot(node2.parent)) return level + getRootBaseIndentLevel(node2.parent, baseIndentLevel, primary);
       let calculatedLevel;
       calculatedLevel = indentationLevel(node2.parent, level + 1);
-      if (optionsMatches(secondaryOptions, `except`, `block`) && (isRule(node2) || isAtRule(node2)) && hasBlock(node2)) {
-        calculatedLevel--;
-      }
+      if (optionsMatches(secondaryOptions, `except`, `block`) && (isRule(node2) || isAtRule(node2)) && hasBlock(node2)) calculatedLevel--;
       return calculatedLevel;
     }
     function checkValue(decl, declLevel) {
       if (!decl.value.includes(`
-`)) {
-        return;
-      }
-      if (isStyledSyntaxDeclaration(decl) && decl.value.includes(`\${`)) {
-        return;
-      }
-      if (optionsMatches(secondaryOptions, `ignore`, `value`)) {
-        return;
-      }
+`)) return;
+      if (isStyledSyntaxDeclaration(decl) && decl.value.includes(`\${`)) return;
+      if (optionsMatches(secondaryOptions, `ignore`, `value`)) return;
       let declString = decl.toString();
       let valueLevel = optionsMatches(secondaryOptions, `except`, `value`) ? declLevel : declLevel + 1;
       checkMultilineBit(declString, valueLevel, decl);
     }
     function checkSelector(ruleNode, ruleLevel) {
       let selector2 = ruleNode.selector;
-      if (ruleNode.params) {
-        ruleLevel += 1;
-      }
-      if (selector2.match(/:\w+\(\s*\r?\n/)) {
-        ruleLevel += 1;
-      }
+      if (ruleNode.params) ruleLevel += 1;
+      if (selector2.match(/:\w+\(\s*\r?\n/)) ruleLevel += 1;
       checkMultilineBit(selector2, ruleLevel, ruleNode);
     }
     function checkAtRuleParams(atRule2, ruleLevel) {
-      if (optionsMatches(secondaryOptions, `ignore`, `param`)) {
-        return;
-      }
+      if (optionsMatches(secondaryOptions, `ignore`, `param`)) return;
       let paramLevel = optionsMatches(secondaryOptions, `except`, `param`) || atRule2.name === `nest` || atRule2.name === `at-root` ? ruleLevel : ruleLevel + 1;
       checkMultilineBit(beforeBlockString(atRule2).trim(), paramLevel, atRule2);
     }
     function checkMultilineBit(source, newlineIndentLevel, node2) {
       if (!source.includes(`
-`)) {
-        return;
-      }
+`)) return;
       let fixPositions = [];
       let parentheticalDepth = 0;
       let ignoreInsideParans = optionsMatches(secondaryOptions, `ignore`, `inside-parens`);
@@ -18149,61 +17692,37 @@ function rule$H(primary, secondaryOptions = {}) {
         },
         (match, matchCount) => {
           let precedesClosingParenthesis = /^[ \t]*\)/.test(source.slice(match.startIndex + 1));
-          if (ignoreInsideParans && (precedesClosingParenthesis || match.insideParens)) {
-            return;
-          }
+          if (ignoreInsideParans && (precedesClosingParenthesis || match.insideParens)) return;
           let expectedIndentLevel = newlineIndentLevel;
           if (!ignoreInsideParans && match.insideParens) {
-            if (matchCount === 1) {
-              parentheticalDepth -= 1;
-            }
+            if (matchCount === 1) parentheticalDepth -= 1;
             let newlineIndex = match.startIndex;
-            if (source[match.startIndex - 1] === `\r`) {
-              newlineIndex--;
-            }
+            if (source[match.startIndex - 1] === `\r`) newlineIndex--;
             let followsOpeningParenthesis = /\([ \t]*$/.test(source.slice(0, newlineIndex));
-            if (followsOpeningParenthesis) {
-              parentheticalDepth += 1;
-            }
+            if (followsOpeningParenthesis) parentheticalDepth += 1;
             let followsOpeningBrace = /\{[ \t]*$/.test(source.slice(0, newlineIndex));
-            if (followsOpeningBrace) {
-              parentheticalDepth += 1;
-            }
+            if (followsOpeningBrace) parentheticalDepth += 1;
             let startingClosingBrace = /^[ \t]*\}/.test(source.slice(match.startIndex + 1));
-            if (startingClosingBrace) {
-              parentheticalDepth -= 1;
-            }
+            if (startingClosingBrace) parentheticalDepth -= 1;
             expectedIndentLevel += parentheticalDepth;
-            if (precedesClosingParenthesis) {
-              parentheticalDepth -= 1;
-            }
+            if (precedesClosingParenthesis) parentheticalDepth -= 1;
             switch (secondaryOptions.indentInsideParens) {
               case `twice`:
-                if (!precedesClosingParenthesis || indentClosingBrace) {
-                  expectedIndentLevel += 1;
-                }
+                if (!precedesClosingParenthesis || indentClosingBrace) expectedIndentLevel += 1;
                 break;
               case `once-at-root-twice-in-block`:
                 if (node2.parent === node2.root()) {
-                  if (precedesClosingParenthesis && !indentClosingBrace) {
-                    expectedIndentLevel -= 1;
-                  }
+                  if (precedesClosingParenthesis && !indentClosingBrace) expectedIndentLevel -= 1;
                   break;
                 }
-                if (!precedesClosingParenthesis || indentClosingBrace) {
-                  expectedIndentLevel += 1;
-                }
+                if (!precedesClosingParenthesis || indentClosingBrace) expectedIndentLevel += 1;
                 break;
               default:
-                if (precedesClosingParenthesis && !indentClosingBrace) {
-                  expectedIndentLevel -= 1;
-                }
+                if (precedesClosingParenthesis && !indentClosingBrace) expectedIndentLevel -= 1;
             }
           }
           let afterNewlineSpaceMatches = /^([ \t]*)\S/.exec(source.slice(match.startIndex + 1));
-          if (!afterNewlineSpaceMatches) {
-            return;
-          }
+          if (!afterNewlineSpaceMatches) return;
           let afterNewlineSpace = afterNewlineSpaceMatches[1] || ``;
           let expectedIndentation = indentChar.repeat(
             expectedIndentLevel > 0 ? expectedIndentLevel : 0
@@ -18243,9 +17762,7 @@ function rule$H(primary, secondaryOptions = {}) {
         if (isDeclaration(node2)) {
           let declProp = node2.prop;
           let declBetween = node2.raws.between;
-          if (!isString(declBetween)) {
-            throw new TypeError(`The \`between\` property must be a string`);
-          }
+          if (!isString(declBetween)) throw new TypeError(`The \`between\` property must be a string`);
           for (let fixPosition of fixPositions) {
             if (fixPosition.startIndex < declProp.length + declBetween.length) {
               node2.raws.between = replaceIndentation(
@@ -18268,9 +17785,7 @@ function rule$H(primary, secondaryOptions = {}) {
           let atRuleName = node2.name;
           let atRuleAfterName = node2.raws.afterName;
           let atRuleParams = node2.params;
-          if (!isString(atRuleAfterName)) {
-            throw new TypeError(`The \`afterName\` property must be a string`);
-          }
+          if (!isString(atRuleAfterName)) throw new TypeError(`The \`afterName\` property must be a string`);
           for (let fixPosition of fixPositions) {
             if (fixPosition.startIndex < 1 + atRuleName.length + atRuleAfterName.length) {
               node2.raws.afterName = replaceIndentation(
@@ -18295,38 +17810,26 @@ function rule$H(primary, secondaryOptions = {}) {
 }
 function getRootBaseIndentLevel(root2, baseIndentLevel, space) {
   let document2 = getDocument(root2);
-  if (!document2) {
-    return 0;
-  }
-  if (!root2.source) {
-    throw new Error(`The root node must have a source`);
-  }
+  if (!document2) return 0;
+  if (!root2.source) throw new Error(`The root node must have a source`);
   let source = root2.source;
   let indentLevel = source.baseIndentLevel;
-  if (isNumber$1(indentLevel) && Number.isSafeInteger(indentLevel)) {
-    return indentLevel;
-  }
+  if (isNumber$1(indentLevel) && Number.isSafeInteger(indentLevel)) return indentLevel;
   let newIndentLevel = inferRootIndentLevel(root2, baseIndentLevel, () => inferDocIndentSize(document2, space));
   source.baseIndentLevel = newIndentLevel;
   return newIndentLevel;
 }
 function getDocument(node2) {
   let document2 = node2.document;
-  if (document2) {
-    return document2;
-  }
+  if (document2) return document2;
   let root2 = node2.root();
   return root2 && root2.document;
 }
 function inferDocIndentSize(document2, space) {
-  if (!document2.source) {
-    throw new Error(`The document node must have a source`);
-  }
+  if (!document2.source) throw new Error(`The document node must have a source`);
   let docSource = document2.source;
   let indentSize = docSource.indentSize;
-  if (isNumber$1(indentSize) && Number.isSafeInteger(indentSize)) {
-    return indentSize;
-  }
+  if (isNumber$1(indentSize) && Number.isSafeInteger(indentSize)) return indentSize;
   let source = document2.source.input.css;
   let indents = source.match(/^ *(?=\S)/gm);
   if (indents) {
@@ -18335,23 +17838,16 @@ function inferDocIndentSize(document2, space) {
         lastIndentSize = Math.abs(leadingSpacesLength - lastLeadingSpacesLength) || lastIndentSize;
         if (lastIndentSize > 1) {
           let score = scores.get(lastIndentSize);
-          if (score) {
-            scores.set(lastIndentSize, score + 1);
-          } else {
-            scores.set(lastIndentSize, 1);
-          }
+          if (score) scores.set(lastIndentSize, score + 1);
+          else scores.set(lastIndentSize, 1);
         }
-      } else {
-        lastIndentSize = 0;
-      }
+      } else lastIndentSize = 0;
       lastLeadingSpacesLength = leadingSpacesLength;
     };
     let scores = /* @__PURE__ */ new Map();
     let lastIndentSize = 0;
     let lastLeadingSpacesLength = 0;
-    for (let leadingSpaces of indents) {
-      vote(leadingSpaces.length);
-    }
+    for (let leadingSpaces of indents) vote(leadingSpaces.length);
     let bestScore = 0;
     for (let [indentSizeDate, score] of scores.entries()) {
       if (score > bestScore) {
@@ -18374,25 +17870,17 @@ function inferRootIndentLevel(root2, baseIndentLevel, indentSize) {
   }
   let newBaseIndentLevel = 0;
   if (!isNumber$1(baseIndentLevel) || !Number.isSafeInteger(baseIndentLevel)) {
-    if (!root2.source) {
-      throw new Error(`The root node must have a source`);
-    }
+    if (!root2.source) throw new Error(`The root node must have a source`);
     let source = root2.source.input.css;
     source = source.replace(/^[^\r\n]+/, (firstLine) => {
       let match = root2.raws.codeBefore && /(?:^|\n)([ \t]*)$/.exec(root2.raws.codeBefore);
-      if (match) {
-        return match[1] + firstLine;
-      }
+      if (match) return match[1] + firstLine;
       return ``;
     });
     let indentions = source.match(/^[ \t]*(?=\S)/gm);
-    if (indentions) {
-      return Math.min(...indentions.map((indent) => getIndentLevel(indent)));
-    }
+    if (indentions) return Math.min(...indentions.map((indent) => getIndentLevel(indent)));
     newBaseIndentLevel = 1;
-  } else {
-    newBaseIndentLevel = baseIndentLevel;
-  }
+  } else newBaseIndentLevel = baseIndentLevel;
   let indents = [];
   let foundIndents = root2.raws.codeBefore?.match(/(?:^|\n)([\t ]*)\S/gm);
   if (foundIndents) {
@@ -18419,28 +17907,18 @@ function inferRootIndentLevel(root2, baseIndentLevel, indentSize) {
         afterEnd = nextRoot ? nextRoot.raws.codeBefore : document2.raws.codeAfter;
       } else {
         let parent = root2.parent;
-        if (!parent) {
-          throw new Error(`The root node must have a parent`);
-        }
+        if (!parent) throw new Error(`The root node must have a parent`);
         let nextRoot = parent.nodes[parent.nodes.indexOf(root2) + 1];
         afterEnd = nextRoot ? nextRoot.raws.codeBefore : root2.raws.codeAfter;
       }
-    } else {
-      afterEnd = after;
-    }
-    if (afterEnd) {
-      indents.push(afterEnd.match(/^[ \t]*/)[0]);
-    }
-  }
-  if (indents.length) {
-    return Math.max(...indents.map((indent) => getIndentLevel(indent))) + newBaseIndentLevel;
+    } else afterEnd = after;
+    if (afterEnd) indents.push(afterEnd.match(/^[ \t]*/)[0]);
   }
+  if (indents.length) return Math.max(...indents.map((indent) => getIndentLevel(indent))) + newBaseIndentLevel;
   return newBaseIndentLevel;
 }
 function fixIndentation(str, whitespace) {
-  if (!isString(str)) {
-    return str;
-  }
+  if (!isString(str)) return str;
   return str.replace(/\n[ \t]*(?=\S|$)/g, `
 ${whitespace}`);
 }
@@ -18476,42 +17954,24 @@ function rule$G(primary) {
       actual: primary,
       possible: [`unix`, `windows`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     let shouldHaveCR = primary === `windows`;
     function fix() {
       root2.walk((node2) => {
-        if (`selector` in node2) {
-          node2.selector = fixData(node2.selector);
-        }
-        if (`value` in node2) {
-          node2.value = fixData(node2.value);
-        }
-        if (`text` in node2) {
-          node2.text = fixData(node2.text);
-        }
-        if (node2.raws.before) {
-          node2.raws.before = fixData(node2.raws.before);
-        }
-        if (typeof node2.raws.after === `string`) {
-          node2.raws.after = fixData(node2.raws.after);
-        }
+        if (`selector` in node2) node2.selector = fixData(node2.selector);
+        if (`value` in node2) node2.value = fixData(node2.value);
+        if (`text` in node2) node2.text = fixData(node2.text);
+        if (node2.raws.before) node2.raws.before = fixData(node2.raws.before);
+        if (typeof node2.raws.after === `string`) node2.raws.after = fixData(node2.raws.after);
       });
-      if (typeof root2.raws.after === `string`) {
-        root2.raws.after = fixData(root2.raws.after);
-      }
-    }
-    if (root2.source === null) {
-      throw new Error(`The root node must have a source`);
+      if (typeof root2.raws.after === `string`) root2.raws.after = fixData(root2.raws.after);
     }
+    if (root2.source === null) throw new Error(`The root node must have a source`);
     let lines = root2.source.input.css.split(`
 `);
     for (let [i2, line] of lines.entries()) {
-      if (i2 < lines.length - 1 && !line.includes(`\r`)) {
-        line += `
+      if (i2 < lines.length - 1 && !line.includes(`\r`)) line += `
 `;
-      }
       if (hasError(line)) {
         let lineNum = i2 + 1;
         let colNum = line.length;
@@ -18526,10 +17986,8 @@ function rule$G(primary) {
     function fixData(data) {
       if (data) {
         let res = data.replace(/\r/g, ``);
-        if (shouldHaveCR) {
-          res = res.replace(/\n/g, `\r
+        if (shouldHaveCR) res = res.replace(/\n/g, `\r
 `);
-        }
         return res;
       }
       return data;
@@ -18591,9 +18049,7 @@ function rule$F(primary, secondaryOptions) {
         optional: true
       }
     );
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     let ignoreComments = optionsMatches(secondaryOptions, `ignore`, `comments`);
     let getChars = replaceEmptyLines.bind(null, primary);
     function fix() {
@@ -18602,16 +18058,12 @@ function rule$F(primary, secondaryOptions) {
           node2.raws.left = getChars(node2.raws.left);
           node2.raws.right = getChars(node2.raws.right);
         }
-        if (node2.raws.before) {
-          node2.raws.before = getChars(node2.raws.before);
-        }
+        if (node2.raws.before) node2.raws.before = getChars(node2.raws.before);
       });
       let firstNodeRawsBefore = root2.first && root2.first.raws.before;
       let rootRawsAfter = root2.raws.after;
       if ((root2.document && root2.document.constructor.name) !== `Document`) {
-        if (firstNodeRawsBefore) {
-          root2.first.raws.before = getChars(firstNodeRawsBefore, true);
-        }
+        if (firstNodeRawsBefore) root2.first.raws.before = getChars(firstNodeRawsBefore, true);
         if (rootRawsAfter) {
           root2.raws.after = replaceEmptyLines(primary === 0 ? 1 : primary, rootRawsAfter, true);
         }
@@ -18637,18 +18089,11 @@ function rule$F(primary, secondaryOptions) {
     function checkMatch(source, matchStartIndex, matchEndIndex, node2) {
       let eof = matchEndIndex === source.length;
       let problem = false;
-      if (!matchStartIndex || lastIndex === matchStartIndex) {
-        emptyLines++;
-      } else {
-        emptyLines = 0;
-      }
+      if (!matchStartIndex || lastIndex === matchStartIndex) emptyLines++;
+      else emptyLines = 0;
       lastIndex = matchEndIndex;
-      if (emptyLines > primary) {
-        problem = true;
-      }
-      if (!eof && !problem) {
-        return;
-      }
+      if (emptyLines > primary) problem = true;
+      if (!eof && !problem) return;
       if (problem) {
         report$u({
           message: messages$F.expected,
@@ -18679,35 +18124,26 @@ function rule$F(primary, secondaryOptions) {
     }
     function replaceEmptyLines(maxLines, str, isSpecialCase = false) {
       let repeatTimes = isSpecialCase ? maxLines : maxLines + 1;
-      if (repeatTimes === 0 || typeof str !== `string`) {
-        return ``;
-      }
+      if (repeatTimes === 0 || typeof str !== `string`) return ``;
       let emptyLFLines = `
 `.repeat(repeatTimes);
       let emptyCRLFLines = `\r
 `.repeat(repeatTimes);
       return /(?:\r\n)+/.test(str) ? str.replace(/(\r\n)+/g, ($1) => {
-        if ($1.length / 2 > repeatTimes) {
-          return emptyCRLFLines;
-        }
+        if ($1.length / 2 > repeatTimes) return emptyCRLFLines;
         return $1;
       }) : str.replace(/(\n)+/g, ($1) => {
-        if ($1.length > repeatTimes) {
-          return emptyLFLines;
-        }
+        if ($1.length > repeatTimes) return emptyLFLines;
         return $1;
       });
     }
   };
 }
 function isEofNode(document2, root2) {
-  if (!document2 || document2.constructor.name !== `Document` || !(`type` in document2)) {
-    return true;
-  }
+  if (!document2 || document2.constructor.name !== `Document` || !(`type` in document2)) return true;
   let after;
-  if (root2 === document2.last) {
-    after = document2.raws && document2.raws.codeAfter;
-  } else {
+  if (root2 === document2.last) after = document2.raws && document2.raws.codeAfter;
+  else {
     let rootIndex = document2.index(root2);
     let nextNode = document2.nodes[rootIndex + 1];
     after = nextNode && nextNode.raws && nextNode.raws.codeBefore;
@@ -18751,12 +18187,8 @@ function rule$E(primary, secondaryOptions) {
         optional: true
       }
     );
-    if (!validOptions) {
-      return;
-    }
-    if (root2.source === null) {
-      throw new Error(`The root node must have a source`);
-    }
+    if (!validOptions) return;
+    if (root2.source === null) throw new Error(`The root node must have a source`);
     let EXCLUDED_PATTERNS = [
       /url\(\s*(\S.*\S)\s*\)/gi,
       // allow tab, whitespace in url content
@@ -18793,57 +18225,35 @@ function rule$E(primary, secondaryOptions) {
       let skippedSubString = skippedSubStrings[skippedSubStringsIndex];
       assert(skippedSubString);
       let [startSubString, endSubString] = skippedSubString;
-      if (end < startSubString) {
-        return 0;
-      }
+      if (end < startSubString) return 0;
       let excluded = Math.min(end, endSubString) - Math.max(start, startSubString);
-      if (endSubString <= end) {
-        skippedSubStringsIndex++;
-      }
+      if (endSubString <= end) skippedSubStringsIndex++;
       return excluded;
     }
     function checkNewline(match) {
       let nextNewlineIndex = rootString.indexOf(`
 `, match.endIndex);
-      if (rootString[nextNewlineIndex - 1] === `\r`) {
-        nextNewlineIndex -= 1;
-      }
-      if (nextNewlineIndex === -1) {
-        nextNewlineIndex = rootString.length;
-      }
+      if (rootString[nextNewlineIndex - 1] === `\r`) nextNewlineIndex -= 1;
+      if (nextNewlineIndex === -1) nextNewlineIndex = rootString.length;
       let rawLineLength = nextNewlineIndex - match.endIndex;
       let excludedLength = skippedSubStrings[skippedSubStringsIndex] ? tryToPopSubString(match.endIndex, nextNewlineIndex) : 0;
       let lineText = rootString.slice(match.endIndex, nextNewlineIndex);
-      if (optionsMatches(secondaryOptions, `ignorePattern`, lineText)) {
-        return;
-      }
-      if (rawLineLength - excludedLength <= primary) {
-        return;
-      }
+      if (optionsMatches(secondaryOptions, `ignorePattern`, lineText)) return;
+      if (rawLineLength - excludedLength <= primary) return;
       let complaintIndex = nextNewlineIndex - 1;
       if (ignoreComments) {
-        if (`insideComment` in match && match.insideComment) {
-          return;
-        }
+        if (`insideComment` in match && match.insideComment) return;
         let nextTwoChars = rootString.slice(match.endIndex).trim().slice(0, 2);
-        if (nextTwoChars === `/*` || nextTwoChars === `//`) {
-          return;
-        }
+        if (nextTwoChars === `/*` || nextTwoChars === `//`) return;
       }
       if (ignoreNonComments) {
-        if (`insideComment` in match && match.insideComment) {
-          return complain(complaintIndex);
-        }
+        if (`insideComment` in match && match.insideComment) return complain(complaintIndex);
         let nextTwoChars = rootString.slice(match.endIndex).trim().slice(0, 2);
-        if (nextTwoChars !== `/*` && nextTwoChars !== `//`) {
-          return;
-        }
+        if (nextTwoChars !== `/*` && nextTwoChars !== `//`) return;
         return complain(complaintIndex);
       }
       let lineString = rootString.slice(match.endIndex, nextNewlineIndex);
-      if (!lineString.replace(/^\s+/, ``).includes(` `)) {
-        return;
-      }
+      if (!lineString.replace(/^\s+/, ``).includes(` `)) return;
       return complain(complaintIndex);
     }
   };
@@ -18903,9 +18313,7 @@ function rule$D(primary) {
       actual: primary,
       possible: [`always`, `never`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     let fixData;
     mediaFeatureColonSpaceChecker({
       root: root2,
@@ -18927,17 +18335,11 @@ function rule$D(primary) {
         for (let index2 of colonIndices.sort((a2, b2) => b2 - a2)) {
           let beforeColon = params.slice(0, index2 + 1);
           let afterColon = params.slice(index2 + 1);
-          if (primary === `always`) {
-            params = beforeColon + afterColon.replace(/^\s*/, ` `);
-          } else if (primary === `never`) {
-            params = beforeColon + afterColon.replace(/^\s*/, ``);
-          }
-        }
-        if (atRule2.raws.params) {
-          atRule2.raws.params.raw = params;
-        } else {
-          atRule2.params = params;
+          if (primary === `always`) params = beforeColon + afterColon.replace(/^\s*/, ` `);
+          else if (primary === `never`) params = beforeColon + afterColon.replace(/^\s*/, ``);
         }
+        if (atRule2.raws.params) atRule2.raws.params.raw = params;
+        else atRule2.params = params;
       }
     }
   };
@@ -18970,9 +18372,7 @@ function rule$C(primary) {
       actual: primary,
       possible: [`always`, `never`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     let fixData;
     mediaFeatureColonSpaceChecker({
       root: root2,
@@ -18994,17 +18394,11 @@ function rule$C(primary) {
         for (let index2 of colonIndices.sort((a2, b2) => b2 - a2)) {
           let beforeColon = params.slice(0, index2);
           let afterColon = params.slice(index2);
-          if (primary === `always`) {
-            params = beforeColon.replace(/\s*$/, ` `) + afterColon;
-          } else if (primary === `never`) {
-            params = beforeColon.replace(/\s*$/, ``) + afterColon;
-          }
-        }
-        if (atRule2.raws.params) {
-          atRule2.raws.params.raw = params;
-        } else {
-          atRule2.params = params;
+          if (primary === `always`) params = beforeColon.replace(/\s*$/, ` `) + afterColon;
+          else if (primary === `never`) params = beforeColon.replace(/\s*$/, ``) + afterColon;
         }
+        if (atRule2.raws.params) atRule2.raws.params.raw = params;
+        else atRule2.params = params;
       }
     }
   };
@@ -21010,9 +20404,7 @@ function findMediaFeatureNames(mediaQueryParams, callback) {
   let tokens = tokenize$1({ css: mediaQueryParams });
   let list = parseCommaSeparatedListOfComponentValues(tokens);
   let mediaQueryConditions = list.flatMap((listItem) => listItem.flatMap((componentValue) => {
-    if (!isSimpleBlockNode(componentValue) || componentValue.startToken[0] !== c.OpenParen) {
-      return [];
-    }
+    if (!isSimpleBlockNode(componentValue) || componentValue.startToken[0] !== c.OpenParen) return [];
     let blockTokens = componentValue.tokens();
     let mediaQueryList = parseFromTokens(blockTokens, {
       preserveInvalidMediaQueries: true
@@ -21023,24 +20415,18 @@ function findMediaFeatureNames(mediaQueryParams, callback) {
     mediaQuery.walk(({ node: node2 }) => {
       if (isMediaFeature(node2)) {
         let token = node2.getNameToken();
-        if (token[0] !== c.Ident) {
-          return;
-        }
+        if (token[0] !== c.Ident) return;
         callback(token);
       }
       if (isGeneralEnclosed(node2)) {
         topLevelTokenNodes(node2).forEach((token, i2, topLevelTokens) => {
-          if (token[0] !== c.Ident) {
-            return;
-          }
+          if (token[0] !== c.Ident) return;
           let nextToken = topLevelTokens[i2 + 1];
           let prevToken = topLevelTokens[i2 - 1];
           if (
             // Media Feature
             !prevToken && nextToken && nextToken[0] === c.Colon || nextToken && nextToken[0] === c.Delim && rangeFeatureOperator.test(nextToken[4].value) || prevToken && prevToken[0] === c.Delim && rangeFeatureOperator.test(prevToken[4].value)
-          ) {
-            callback(token);
-          }
+          ) callback(token);
         });
       }
     });
@@ -21053,9 +20439,7 @@ function findMediaFeatureNames(mediaQueryParams, callback) {
 }
 function topLevelTokenNodes(node2) {
   let components = node2.value.value;
-  if (isToken(components) || components.length === 0 || isToken(components[0])) {
-    return [];
-  }
+  if (isToken(components) || components.length === 0 || isToken(components[0])) return [];
   let relevantTokens = [];
   let lastWasDollarSign = false;
   components.forEach((component) => {
@@ -21092,22 +20476,16 @@ function rule$B(primary) {
       actual: primary,
       possible: [`lower`, `upper`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     root2.walkAtRules(/^media$/i, (atRule2) => {
       let hasComments = atRule2.raws.params?.raw;
       let mediaRule = hasComments ? hasComments : atRule2.params;
       let hasFixes = false;
       mediaRule = findMediaFeatureNames(mediaRule, (mediaFeatureNameToken) => {
         let [, , startIndex, endIndex, { value: featureName }] = mediaFeatureNameToken;
-        if (isCustomMediaQuery(featureName)) {
-          return;
-        }
+        if (isCustomMediaQuery(featureName)) return;
         let expectedFeatureName = primary === `lower` ? featureName.toLowerCase() : featureName.toUpperCase();
-        if (featureName === expectedFeatureName) {
-          return;
-        }
+        if (featureName === expectedFeatureName) return;
         let atRuleIndex = atRuleParamIndex(atRule2);
         report$r({
           message: messages$B.expected,
@@ -21125,13 +20503,9 @@ function rule$B(primary) {
       }).stringify();
       if (hasFixes) {
         if (hasComments) {
-          if (atRule2.raws.params === null) {
-            throw new Error(`The \`AtRuleRaws\` node must have a \`params\` property`);
-          }
+          if (atRule2.raws.params === null) throw new Error(`The \`AtRuleRaws\` node must have a \`params\` property`);
           atRule2.raws.params.raw = mediaRule;
-        } else {
-          atRule2.params = mediaRule;
-        }
+        } else atRule2.params = mediaRule;
       }
     });
   };
@@ -21165,9 +20539,7 @@ function rule$A(primary) {
       actual: primary,
       possible: [`always`, `never`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     root2.walkAtRules(/^media$/i, (atRule2) => {
       let params = atRule2.raws.params && atRule2.raws.params.raw || atRule2.params;
       let indexBoost = atRuleParamIndex(atRule2);
@@ -21228,9 +20600,7 @@ function rule$A(primary) {
             fix: err.fix
           });
         }
-        if (problems.some((problem) => problem.fix)) {
-          atRule2.params = parsedParams.toString();
-        }
+        if (problems.some((problem) => problem.fix)) atRule2.params = parsedParams.toString();
       }
     });
   };
@@ -21247,15 +20617,11 @@ const index$A = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
 }, Symbol.toStringTag, { value: "Module" }));
 let rangeOperators = [`>=`, `<=`, `>`, `<`, `=`];
 function findMediaOperator(atRule2, cb) {
-  if (atRule2.name.toLowerCase() !== `media`) {
-    return;
-  }
+  if (atRule2.name.toLowerCase() !== `media`) return;
   let params = atRule2.raws.params ? atRule2.raws.params.raw : atRule2.params;
   styleSearch({ source: params, target: rangeOperators }, (match) => {
     let before = params[match.startIndex - 1];
-    if (before === `>` || before === `<`) {
-      return;
-    }
+    if (before === `>` || before === `<`) return;
     cb(match, params, atRule2);
   });
 }
@@ -21277,9 +20643,7 @@ function rule$z(primary) {
       actual: primary,
       possible: [`always`, `never`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     root2.walkAtRules(/^media$/i, (atRule2) => {
       let fixOperatorIndices = [];
       findMediaOperator(atRule2, (match, params, node2) => {
@@ -21308,17 +20672,11 @@ function rule$z(primary) {
         for (let index2 of fixOperatorIndices.sort((a2, b2) => b2 - a2)) {
           let beforeOperator = params.slice(0, index2 + 1);
           let afterOperator = params.slice(index2 + 1);
-          if (primary === `always`) {
-            params = beforeOperator + afterOperator.replace(/^\s*/, ` `);
-          } else if (primary === `never`) {
-            params = beforeOperator + afterOperator.replace(/^\s*/, ``);
-          }
-        }
-        if (atRule2.raws.params) {
-          atRule2.raws.params.raw = params;
-        } else {
-          atRule2.params = params;
+          if (primary === `always`) params = beforeOperator + afterOperator.replace(/^\s*/, ` `);
+          else if (primary === `never`) params = beforeOperator + afterOperator.replace(/^\s*/, ``);
         }
+        if (atRule2.raws.params) atRule2.raws.params.raw = params;
+        else atRule2.params = params;
       }
     });
   };
@@ -21351,9 +20709,7 @@ function rule$y(primary) {
       actual: primary,
       possible: [`always`, `never`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     root2.walkAtRules(/^media$/i, (atRule2) => {
       let fixOperatorIndices = [];
       findMediaOperator(atRule2, (match, params, node2) => {
@@ -21381,17 +20737,11 @@ function rule$y(primary) {
         for (let index2 of fixOperatorIndices.sort((a2, b2) => b2 - a2)) {
           let beforeOperator = params.slice(0, index2);
           let afterOperator = params.slice(index2);
-          if (primary === `always`) {
-            params = beforeOperator.replace(/\s*$/, ` `) + afterOperator;
-          } else if (primary === `never`) {
-            params = beforeOperator.replace(/\s*$/, ``) + afterOperator;
-          }
-        }
-        if (atRule2.raws.params) {
-          atRule2.raws.params.raw = params;
-        } else {
-          atRule2.params = params;
+          if (primary === `always`) params = beforeOperator.replace(/\s*$/, ` `) + afterOperator;
+          else if (primary === `never`) params = beforeOperator.replace(/\s*$/, ``) + afterOperator;
         }
+        if (atRule2.raws.params) atRule2.raws.params.raw = params;
+        else atRule2.params = params;
       }
     });
   };
@@ -21466,9 +20816,7 @@ function rule$x(primary, _secondaryOptions, context) {
       actual: primary,
       possible: [`always`, `always-multi-line`, `never-multi-line`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     let fixData;
     mediaQueryListCommaWhitespaceChecker({
       root: root2,
@@ -21491,17 +20839,11 @@ function rule$x(primary, _secondaryOptions, context) {
         for (let index2 of commaIndices.sort((a2, b2) => b2 - a2)) {
           let beforeComma = params.slice(0, index2 + 1);
           let afterComma = params.slice(index2 + 1);
-          if (primary.startsWith(`always`)) {
-            params = /^\s*\n/.test(afterComma) ? beforeComma + afterComma.replace(/^[^\S\r\n]*/, ``) : beforeComma + context.newline + afterComma;
-          } else if (primary.startsWith(`never`)) {
-            params = beforeComma + afterComma.replace(/^\s*/, ``);
-          }
-        }
-        if (atRule2.raws.params) {
-          atRule2.raws.params.raw = params;
-        } else {
-          atRule2.params = params;
+          if (primary.startsWith(`always`)) params = /^\s*\n/.test(afterComma) ? beforeComma + afterComma.replace(/^[^\S\r\n]*/, ``) : beforeComma + context.newline + afterComma;
+          else if (primary.startsWith(`never`)) params = beforeComma + afterComma.replace(/^\s*/, ``);
         }
+        if (atRule2.raws.params) atRule2.raws.params.raw = params;
+        else atRule2.params = params;
       }
     }
   };
@@ -21534,9 +20876,7 @@ function rule$w(primary) {
       actual: primary,
       possible: [`always`, `always-multi-line`, `never-multi-line`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     mediaQueryListCommaWhitespaceChecker({
       root: root2,
       result: result2,
@@ -21575,9 +20915,7 @@ function rule$v(primary) {
       actual: primary,
       possible: [`always`, `never`, `always-single-line`, `never-single-line`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     let fixData;
     mediaQueryListCommaWhitespaceChecker({
       root: root2,
@@ -21599,17 +20937,11 @@ function rule$v(primary) {
         for (let index2 of commaIndices.sort((a2, b2) => b2 - a2)) {
           let beforeComma = params.slice(0, index2 + 1);
           let afterComma = params.slice(index2 + 1);
-          if (primary.startsWith(`always`)) {
-            params = beforeComma + afterComma.replace(/^\s*/, ` `);
-          } else if (primary.startsWith(`never`)) {
-            params = beforeComma + afterComma.replace(/^\s*/, ``);
-          }
-        }
-        if (atRule2.raws.params) {
-          atRule2.raws.params.raw = params;
-        } else {
-          atRule2.params = params;
+          if (primary.startsWith(`always`)) params = beforeComma + afterComma.replace(/^\s*/, ` `);
+          else if (primary.startsWith(`never`)) params = beforeComma + afterComma.replace(/^\s*/, ``);
         }
+        if (atRule2.raws.params) atRule2.raws.params.raw = params;
+        else atRule2.params = params;
       }
     }
   };
@@ -21644,9 +20976,7 @@ function rule$u(primary) {
       actual: primary,
       possible: [`always`, `never`, `always-single-line`, `never-single-line`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     let fixData;
     mediaQueryListCommaWhitespaceChecker({
       root: root2,
@@ -21668,17 +20998,11 @@ function rule$u(primary) {
         for (let index2 of commaIndices.sort((a2, b2) => b2 - a2)) {
           let beforeComma = params.slice(0, index2);
           let afterComma = params.slice(index2);
-          if (primary.startsWith(`always`)) {
-            params = beforeComma.replace(/\s*$/, ` `) + afterComma;
-          } else if (primary.startsWith(`never`)) {
-            params = beforeComma.replace(/\s*$/, ``) + afterComma;
-          }
-        }
-        if (atRule2.raws.params) {
-          atRule2.raws.params.raw = params;
-        } else {
-          atRule2.params = params;
+          if (primary.startsWith(`always`)) params = beforeComma.replace(/\s*$/, ` `) + afterComma;
+          else if (primary.startsWith(`never`)) params = beforeComma.replace(/\s*$/, ``) + afterComma;
         }
+        if (atRule2.raws.params) atRule2.raws.params.raw = params;
+        else atRule2.params = params;
       }
     }
   };
@@ -21718,9 +21042,7 @@ function rule$t(primary, secondaryOptions = {}) {
         optional: true
       }
     );
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     let gap = secondaryOptions.gap ?? 1;
     let alignQuotes = secondaryOptions.alignQuotes ?? false;
     let referenceGap = ` `.repeat(gap);
@@ -21752,17 +21074,13 @@ function rule$t(primary, secondaryOptions = {}) {
       });
       if (alignQuotes && isMultilineDeclaration) {
         formatted = formatted.map((row) => {
-          if (row.length === maxRowLength) {
-            return row;
-          }
+          if (row.length === maxRowLength) return row;
           let cleanRowValue = row.trimEnd();
           return `${cleanRowValue}${` `.repeat(maxRowLength - cleanRowValue.length)}`;
         });
       }
       let isValid = originalRows.every((row, index2) => row === formatted[index2]);
-      if (isValid) {
-        return;
-      }
+      if (isValid) return;
       let extraStartLines = declaration2.raws.between.match(/[\r\n?|\n]*/g)?.reduce((acc, newLineBlock) => acc + newLineBlock.length, 0);
       let extraStartColumns = extraStartLines === 0 ? declarationValueIndex(declaration2) + declaration2.source.start.column : declaration2.raws.between.match(/[^\r\n?|\n]+$/)?.[0].length + 1 || 0;
       report$m({
@@ -21821,13 +21139,9 @@ let meta$s = {
 function rule$s(primary) {
   return (root2, result2) => {
     let validOptions = validateOptions$s(result2, ruleName$s, { actual: primary });
-    if (!validOptions || root2.source.inline || root2.source.lang === `object-literal`) {
-      return;
-    }
+    if (!validOptions || root2.source.inline || root2.source.lang === `object-literal`) return;
     let rootString = root2.source && root2.source.input.css || ``;
-    if (!rootString.trim()) {
-      return;
-    }
+    if (!rootString.trim()) return;
     if (noEmptyFirstLineTest.test(rootString)) {
       report$l({
         message: messages$s.rejected,
@@ -21835,12 +21149,8 @@ function rule$s(primary) {
         result: result2,
         ruleName: ruleName$s,
         fix() {
-          if (root2.first === null) {
-            throw new Error(`The root node must have the first node.`);
-          }
-          if (root2.first.raws.before === null) {
-            throw new Error(`The first node must have spaces before.`);
-          }
+          if (root2.first === null) throw new Error(`The root node must have the first node.`);
+          if (root2.first.raws.before === null) throw new Error(`The first node must have spaces before.`);
           root2.first.raws.before = root2.first.raws.before.replace(noEmptyFirstLineTest, ``);
         }
       });
@@ -21858,20 +21168,12 @@ const index$s = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
   ruleName: ruleName$s
 }, Symbol.toStringTag, { value: "Module" }));
 function isOnlyWhitespace(input2) {
-  for (let element of input2) {
-    if (!isWhitespace$1(element)) {
-      return false;
-    }
-  }
+  for (let element of input2) if (!isWhitespace$1(element)) return false;
   return true;
 }
 function isStandardSyntaxComment(comment2) {
-  if (`inline` in comment2) {
-    return false;
-  }
-  if (`inline` in comment2.raws) {
-    return false;
-  }
+  if (`inline` in comment2) return false;
+  if (`inline` in comment2.raws) return false;
   return true;
 }
 let { utils: { report: report$k, ruleMessages: ruleMessages$r, validateOptions: validateOptions$r } } = stylelint;
@@ -21890,17 +21192,13 @@ function fixString(str) {
 }
 function findErrorStartIndex(lastEOLIndex, string2, { ignoreEmptyLines, isRootFirst }) {
   let eolWhitespaceIndex = lastEOLIndex - 1;
-  if (!whitespacesToReject.has(string2.charAt(eolWhitespaceIndex))) {
-    return -1;
-  }
+  if (!whitespacesToReject.has(string2.charAt(eolWhitespaceIndex))) return -1;
   if (ignoreEmptyLines) {
     let beforeNewlineIndex = string2.lastIndexOf(`
 `, eolWhitespaceIndex);
     if (beforeNewlineIndex >= 0 || isRootFirst) {
       let line = string2.substring(beforeNewlineIndex, eolWhitespaceIndex);
-      if (isOnlyWhitespace(line)) {
-        return -1;
-      }
+      if (isOnlyWhitespace(line)) return -1;
     }
   }
   return eolWhitespaceIndex;
@@ -21921,9 +21219,7 @@ function rule$r(primary, secondaryOptions) {
         }
       }
     );
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     let ignoreEmptyLines = optionsMatches(secondaryOptions, `ignore`, `empty-lines`);
     let rootString = root2.source && root2.source.input.css || ``;
     function reportFromIndex(index2) {
@@ -21942,9 +21238,7 @@ function rule$r(primary, secondaryOptions) {
       ignoreEmptyLines,
       isRootFirst: true
     });
-    if (errorIndex > -1) {
-      reportFromIndex(errorIndex);
-    }
+    if (errorIndex > -1) reportFromIndex(errorIndex);
     function eachEolWhitespace(string2, callback, isRootFirst) {
       styleSearch(
         {
@@ -21958,9 +21252,7 @@ function rule$r(primary, secondaryOptions) {
             ignoreEmptyLines,
             isRootFirst
           });
-          if (index2 > -1) {
-            callback(index2);
-          }
+          if (index2 > -1) callback(index2);
         }
       );
     }
@@ -22023,9 +21315,8 @@ function rule$r(primary, secondaryOptions) {
           fixText(node2.raws.left, (fixed) => {
             node2.raws.left = fixed;
           });
-          if (!isStandardSyntaxComment(node2)) {
-            node2.raws.right = node2.raws.right && fixString(node2.raws.right);
-          } else {
+          if (!isStandardSyntaxComment(node2)) node2.raws.right = node2.raws.right && fixString(node2.raws.right);
+          else {
             fixText(node2.raws.right, (fixed) => {
               node2.raws.right = fixed;
             });
@@ -22053,15 +21344,11 @@ function rule$r(primary, secondaryOptions) {
 `),
           root2.raws.after.lastIndexOf(`\r`)
         );
-        if (lastEOL !== root2.raws.after.length - 1) {
-          root2.raws.after = root2.raws.after.slice(0, lastEOL + 1) + fixString(root2.raws.after.slice(lastEOL + 1));
-        }
+        if (lastEOL !== root2.raws.after.length - 1) root2.raws.after = root2.raws.after.slice(0, lastEOL + 1) + fixString(root2.raws.after.slice(lastEOL + 1));
       }
     }
     function fixText(value, fixFn, isRootFirst = false) {
-      if (!value) {
-        return;
-      }
+      if (!value) return;
       let fixed = ``;
       let lastIndex = 0;
       eachEolWhitespace(
@@ -22107,51 +21394,25 @@ function hasTplInterpolation(string2) {
   return HAS_TPL_INTERPOLATION.test(string2);
 }
 function hasInterpolation(string2) {
-  if (hasLessInterpolation(string2) || hasScssInterpolation(string2) || hasTplInterpolation(string2) || hasPsvInterpolation(string2)) {
-    return true;
-  }
+  if (hasLessInterpolation(string2) || hasScssInterpolation(string2) || hasTplInterpolation(string2) || hasPsvInterpolation(string2)) return true;
   return false;
 }
 function isStandardSyntaxSelector(selector2) {
-  if (hasInterpolation(selector2)) {
-    return false;
-  }
-  if (selector2.startsWith(`%`)) {
-    return false;
-  }
-  if (selector2.endsWith(`:`)) {
-    return false;
-  }
-  if (/:extend(?:\(.*?\))?/.test(selector2)) {
-    return false;
-  }
-  if (/\.[\w-]+\(.*\).+/.test(selector2)) {
-    return false;
-  }
-  if (selector2.endsWith(`)`) && !selector2.includes(`:`)) {
-    return false;
-  }
-  if (/\(@.*\)$/.test(selector2)) {
-    return false;
-  }
-  if (selector2.includes(`<%`) || selector2.includes(`%>`)) {
-    return false;
-  }
-  if (selector2.includes(`//`)) {
-    return false;
-  }
+  if (hasInterpolation(selector2)) return false;
+  if (selector2.startsWith(`%`)) return false;
+  if (selector2.endsWith(`:`)) return false;
+  if (/:extend(?:\(.*?\))?/.test(selector2)) return false;
+  if (/\.[\w-]+\(.*\).+/.test(selector2)) return false;
+  if (selector2.endsWith(`)`) && !selector2.includes(`:`)) return false;
+  if (/\(@.*\)$/.test(selector2)) return false;
+  if (selector2.includes(`<%`) || selector2.includes(`%>`)) return false;
+  if (selector2.includes(`//`)) return false;
   return true;
 }
 function isStandardSyntaxRule(rule2) {
-  if (rule2.type !== `rule`) {
-    return false;
-  }
-  if (`extend` in rule2 && rule2.extend) {
-    return false;
-  }
-  if (!isStandardSyntaxSelector(rule2.selector)) {
-    return false;
-  }
+  if (rule2.type !== `rule`) return false;
+  if (`extend` in rule2 && rule2.extend) return false;
+  if (!isStandardSyntaxSelector(rule2.selector)) return false;
   return true;
 }
 let { utils: { report: report$j, ruleMessages: ruleMessages$q, validateOptions: validateOptions$q } } = stylelint;
@@ -22165,19 +21426,11 @@ let meta$q = {
   fixable: true
 };
 function getOffsetByNode(node2) {
-  if (node2.parent && node2.parent.document) {
-    return 0;
-  }
+  if (node2.parent && node2.parent.document) return 0;
   let root2 = node2.root();
-  if (!root2.source) {
-    throw new Error(`The root node must have a source`);
-  }
-  if (!node2.source) {
-    throw new Error(`The node must have a source`);
-  }
-  if (!node2.source.start) {
-    throw new Error(`The source must have a start position`);
-  }
+  if (!root2.source) throw new Error(`The root node must have a source`);
+  if (!node2.source) throw new Error(`The node must have a source`);
+  if (!node2.source.start) throw new Error(`The source must have a start position`);
   let string2 = root2.source.input.css;
   let nodeColumn = node2.source.start.column;
   let nodeLine = node2.source.start.line;
@@ -22193,18 +21446,14 @@ function getOffsetByNode(node2) {
 `) {
       column = 1;
       line += 1;
-    } else {
-      column += 1;
-    }
+    } else column += 1;
   }
   return index2;
 }
 function rule$q(primary) {
   return (root2, result2) => {
     let validOptions = validateOptions$q(result2, ruleName$q, { actual: primary });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     let fix = null;
     if (root2.raws.after && root2.raws.after.trim().length !== 0) {
       let rawAfterRoot = root2.raws.after;
@@ -22213,45 +21462,31 @@ function rule$q(primary) {
         fix = () => {
           fixSemiIndices.push(match.startIndex);
         };
-        if (!root2.source) {
-          throw new Error(`The root node must have a source`);
-        }
+        if (!root2.source) throw new Error(`The root node must have a source`);
         complain(root2.source.input.css.length - rawAfterRoot.length + match.startIndex);
       });
-      if (fixSemiIndices.length) {
-        root2.raws.after = removeIndices(rawAfterRoot, fixSemiIndices);
-      }
+      if (fixSemiIndices.length) root2.raws.after = removeIndices(rawAfterRoot, fixSemiIndices);
     }
     root2.walk((node2) => {
-      if (isAtRule(node2) && !isStandardSyntaxAtRule(node2)) {
-        return;
-      }
-      if (node2.type === `rule` && !isStandardSyntaxRule(node2)) {
-        return;
-      }
+      if (isAtRule(node2) && !isStandardSyntaxAtRule(node2)) return;
+      if (node2.type === `rule` && !isStandardSyntaxRule(node2)) return;
       if (node2.raws.before && node2.raws.before.trim().length !== 0) {
         let rawBeforeNode = node2.raws.before;
         let allowedSemi = 0;
         let rawBeforeIndexStart = 0;
         let fixSemiIndices = [];
         styleSearch({ source: rawBeforeNode, target: `;` }, (match, count) => {
-          if (count === allowedSemi) {
-            return;
-          }
+          if (count === allowedSemi) return;
           fix = () => {
             fixSemiIndices.push(match.startIndex - rawBeforeIndexStart);
           };
           complain(getOffsetByNode(node2) - rawBeforeNode.length + match.startIndex);
         });
-        if (fixSemiIndices.length) {
-          node2.raws.before = removeIndices(rawBeforeNode, fixSemiIndices);
-        }
+        if (fixSemiIndices.length) node2.raws.before = removeIndices(rawBeforeNode, fixSemiIndices);
       }
       if (typeof node2.raws.after === `string` && node2.raws.after.trim().length !== 0) {
         let rawAfterNode = node2.raws.after;
-        if (`last` in node2 && node2.last && node2.last.type === `atrule` && !isStandardSyntaxAtRule(node2.last)) {
-          return;
-        }
+        if (`last` in node2 && node2.last && node2.last.type === `atrule` && !isStandardSyntaxAtRule(node2.last)) return;
         let fixSemiIndices = [];
         styleSearch({ source: rawAfterNode, target: `;` }, (match) => {
           fix = () => {
@@ -22260,27 +21495,21 @@ function rule$q(primary) {
           let index2 = getOffsetByNode(node2) + node2.toString().length - 1 - rawAfterNode.length + match.startIndex;
           complain(index2);
         });
-        if (fixSemiIndices.length) {
-          node2.raws.after = removeIndices(rawAfterNode, fixSemiIndices);
-        }
+        if (fixSemiIndices.length) node2.raws.after = removeIndices(rawAfterNode, fixSemiIndices);
       }
       if (typeof node2.raws.ownSemicolon === `string`) {
         let rawOwnSemicolon = node2.raws.ownSemicolon;
         let allowedSemi = 0;
         let fixSemiIndices = [];
         styleSearch({ source: rawOwnSemicolon, target: `;` }, (match, count) => {
-          if (count === allowedSemi) {
-            return;
-          }
+          if (count === allowedSemi) return;
           fix = () => {
             fixSemiIndices.push(match.startIndex);
           };
           let index2 = getOffsetByNode(node2) + node2.toString().length - rawOwnSemicolon.length + match.startIndex;
           complain(index2);
         });
-        if (fixSemiIndices.length) {
-          node2.raws.ownSemicolon = removeIndices(rawOwnSemicolon, fixSemiIndices);
-        }
+        if (fixSemiIndices.length) node2.raws.ownSemicolon = removeIndices(rawOwnSemicolon, fixSemiIndices);
       }
     });
     function complain(index2) {
@@ -22295,9 +21524,7 @@ function rule$q(primary) {
       });
     }
     function removeIndices(str, indices) {
-      for (let index2 of indices.reverse()) {
-        str = str.slice(0, index2) + str.slice(index2 + 1);
-      }
+      for (let index2 of indices.reverse()) str = str.slice(0, index2) + str.slice(index2 + 1);
       return str;
     }
   };
@@ -22325,20 +21552,12 @@ let meta$p = {
 function rule$p(primary, _secondaryOptions, context) {
   return (root2, result2) => {
     let validOptions = validateOptions$p(result2, ruleName$p, { actual: primary });
-    if (!validOptions) {
-      return;
-    }
-    if (root2.source === null) {
-      throw new Error(`The root node must have a source property`);
-    }
-    if (root2.source.inline || root2.source.lang === `object-literal`) {
-      return;
-    }
+    if (!validOptions) return;
+    if (root2.source === null) throw new Error(`The root node must have a source property`);
+    if (root2.source.inline || root2.source.lang === `object-literal`) return;
     let rootString = root2.source.input.css;
     if (!rootString.trim() || rootString.endsWith(`
-`)) {
-      return;
-    }
+`)) return;
     const problemIndex = rootString.length - 1;
     report$i({
       message: messages$p.rejected,
@@ -22380,35 +21599,23 @@ function rule$o(primary) {
       actual: primary,
       possible: [`always`, `never`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     let fix = null;
     root2.walkAtRules((atRule2) => {
-      if (atRule2.name.toLowerCase() === `import`) {
-        return;
-      }
+      if (atRule2.name.toLowerCase() === `import`) return;
       check(atRule2, atRule2.params);
     });
     root2.walkDecls((decl) => check(decl, decl.value));
     function check(node2, value) {
       let neverFixPositions = [];
       let alwaysFixPositions = [];
-      if (!value.includes(`.`)) {
-        return;
-      }
+      if (!value.includes(`.`)) return;
       valueParser(value).walk((valueNode) => {
-        if (valueNode.type === `function` && valueNode.value.toLowerCase() === `url`) {
-          return false;
-        }
-        if (valueNode.type !== `word`) {
-          return;
-        }
+        if (valueNode.type === `function` && valueNode.value.toLowerCase() === `url`) return false;
+        if (valueNode.type !== `word`) return;
         if (primary === `always`) {
           let match = /(?:\D|^)(\.\d+)/.exec(valueNode.value);
-          if (match === null || match[0] === null || match[1] === null) {
-            return;
-          }
+          if (match === null || match[0] === null || match[1] === null) return;
           let capturingGroupIndex = match[0].length - match[1].length;
           let index2 = valueNode.sourceIndex + match.index + capturingGroupIndex;
           fix = () => {
@@ -22421,9 +21628,7 @@ function rule$o(primary) {
         }
         if (primary === `never`) {
           let match = /(?:\D|^)(0+)(\.\d+)/.exec(valueNode.value);
-          if (match === null || match[0] === null || match[1] === null || match[2] === null) {
-            return;
-          }
+          if (match === null || match[0] === null || match[1] === null || match[2] === null) return;
           let capturingGroupIndex = match[0].length - (match[1].length + match[2].length);
           let index2 = valueNode.sourceIndex + match.index + capturingGroupIndex;
           fix = () => {
@@ -22440,22 +21645,16 @@ function rule$o(primary) {
       if (alwaysFixPositions.length) {
         for (let fixPosition of alwaysFixPositions) {
           let index2 = fixPosition.index;
-          if (isAtRule(node2)) {
-            node2.params = addLeadingZero(node2.params, index2);
-          } else {
-            node2.value = addLeadingZero(node2.value, index2);
-          }
+          if (isAtRule(node2)) node2.params = addLeadingZero(node2.params, index2);
+          else node2.value = addLeadingZero(node2.value, index2);
         }
       }
       if (neverFixPositions.length) {
         for (let fixPosition of neverFixPositions) {
           let startIndex = fixPosition.startIndex;
           let endIndex = fixPosition.endIndex;
-          if (isAtRule(node2)) {
-            node2.params = removeLeadingZeros(node2.params, startIndex, endIndex);
-          } else {
-            node2.value = removeLeadingZeros(node2.value, startIndex, endIndex);
-          }
+          if (isAtRule(node2)) node2.params = removeLeadingZeros(node2.params, startIndex, endIndex);
+          else node2.value = removeLeadingZeros(node2.value, startIndex, endIndex);
         }
       }
     }
@@ -22501,32 +21700,20 @@ let meta$n = {
 function rule$n(primary) {
   return (root2, result2) => {
     let validOptions = validateOptions$n(result2, ruleName$n, { actual: primary });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     root2.walkAtRules((atRule2) => {
-      if (atRule2.name.toLowerCase() === `import`) {
-        return;
-      }
+      if (atRule2.name.toLowerCase() === `import`) return;
       check(atRule2, atRule2.params);
     });
     root2.walkDecls((decl) => check(decl, decl.value));
     function check(node2, value) {
       let fixPositions = [];
-      if (!value.includes(`.`)) {
-        return;
-      }
+      if (!value.includes(`.`)) return;
       valueParser(value).walk((valueNode) => {
-        if (valueNode.type === `function` && valueNode.value.toLowerCase() === `url`) {
-          return false;
-        }
-        if (valueNode.type !== `word`) {
-          return;
-        }
+        if (valueNode.type === `function` && valueNode.value.toLowerCase() === `url`) return false;
+        if (valueNode.type !== `word`) return;
         let match = /\.(\d{0,100}?)(0+)(?:\D|$)/.exec(valueNode.value);
-        if (match === null || match[1] === null || match[2] === null) {
-          return;
-        }
+        if (match === null || match[1] === null || match[2] === null) return;
         let index2 = valueNode.sourceIndex + match.index + 1 + match[1].length;
         let startIndex = match[1].length > 0 ? index2 : index2 - 1;
         let endIndex = index2 + match[2].length;
@@ -22551,11 +21738,8 @@ function rule$n(primary) {
         for (let fixPosition of fixPositions) {
           let startIndex = fixPosition.startIndex;
           let endIndex = fixPosition.endIndex;
-          if (isAtRule(node2)) {
-            node2.params = removeTrailingZeros(node2.params, startIndex, endIndex);
-          } else {
-            node2.value = removeTrailingZeros(node2.value, startIndex, endIndex);
-          }
+          if (isAtRule(node2)) node2.params = removeTrailingZeros(node2.params, startIndex, endIndex);
+          else node2.value = removeTrailingZeros(node2.value, startIndex, endIndex);
         }
       }
     }
@@ -22575,18 +21759,10 @@ const index$n = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
   ruleName: ruleName$n
 }, Symbol.toStringTag, { value: "Module" }));
 function isStandardSyntaxProperty(property) {
-  if (isScssVariable(property)) {
-    return false;
-  }
-  if (property.startsWith(`@`)) {
-    return false;
-  }
-  if (property.endsWith(`+`) || property.endsWith(`+_`)) {
-    return false;
-  }
-  if (hasInterpolation(property)) {
-    return false;
-  }
+  if (isScssVariable(property)) return false;
+  if (property.startsWith(`@`)) return false;
+  if (property.endsWith(`+`) || property.endsWith(`+_`)) return false;
+  if (hasInterpolation(property)) return false;
   return true;
 }
 let { utils: { report: report$f, ruleMessages: ruleMessages$m, validateOptions: validateOptions$m } } = stylelint;
@@ -22616,31 +21792,19 @@ function rule$m(primary, secondaryOptions) {
         optional: true
       }
     );
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     root2.walkDecls((decl) => {
       let prop = decl.prop;
-      if (!isStandardSyntaxProperty(prop)) {
-        return;
-      }
-      if (isCustomProperty(prop)) {
-        return;
-      }
+      if (!isStandardSyntaxProperty(prop)) return;
+      if (isCustomProperty(prop)) return;
       let { parent } = decl;
-      if (!parent) {
-        throw new Error(`A parent node must be present`);
-      }
+      if (!parent) throw new Error(`A parent node must be present`);
       if (isRule(parent)) {
         let { selector: selector2 } = parent;
-        if (selector2 && optionsMatches(secondaryOptions, `ignoreSelectors`, selector2)) {
-          return;
-        }
+        if (selector2 && optionsMatches(secondaryOptions, `ignoreSelectors`, selector2)) return;
       }
       let expectedProp = primary === `lower` ? prop.toLowerCase() : prop.toUpperCase();
-      if (prop === expectedProp) {
-        return;
-      }
+      if (prop === expectedProp) return;
       report$f({
         message: messages$m.expected,
         messageArgs: [prop, expectedProp],
@@ -26319,16 +25483,10 @@ function rule$l(primary) {
       actual: primary,
       possible: [`always`, `never`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     root2.walkRules((ruleNode) => {
-      if (!isStandardSyntaxRule(ruleNode)) {
-        return;
-      }
-      if (!ruleNode.selector.includes(`[`)) {
-        return;
-      }
+      if (!isStandardSyntaxRule(ruleNode)) return;
+      if (!ruleNode.selector.includes(`[`)) return;
       let selector2 = ruleNode.raws.selector ? ruleNode.raws.selector.raw : ruleNode.selector;
       let fix = null;
       let hasFixed;
@@ -26374,11 +25532,8 @@ function rule$l(primary) {
         });
       });
       if (hasFixed && fixedSelector) {
-        if (!ruleNode.raws.selector) {
-          ruleNode.selector = fixedSelector;
-        } else {
-          ruleNode.raws.selector.raw = fixedSelector;
-        }
+        if (!ruleNode.raws.selector) ruleNode.selector = fixedSelector;
+        else ruleNode.raws.selector.raw = fixedSelector;
       }
       function complain(message, index2) {
         report$e({
@@ -26404,17 +25559,12 @@ function rule$l(primary) {
     } : {
       attrBefore: attributeNode.spaces.attribute && attributeNode.spaces.attribute.before || ``,
       setAttrBefore(fixed) {
-        if (!attributeNode.spaces.attribute) {
-          attributeNode.spaces.attribute = {};
-        }
+        if (!attributeNode.spaces.attribute) attributeNode.spaces.attribute = {};
         attributeNode.spaces.attribute.before = fixed;
       }
     };
-    if (primary === `always`) {
-      setAttrBefore(attrBefore.replace(/^\s*/, ` `));
-    } else if (primary === `never`) {
-      setAttrBefore(attrBefore.replace(/^\s*/, ``));
-    }
+    if (primary === `always`) setAttrBefore(attrBefore.replace(/^\s*/, ` `));
+    else if (primary === `never`) setAttrBefore(attrBefore.replace(/^\s*/, ``));
   }
   function fixAfter(attributeNode) {
     let key = attributeNode.operator ? attributeNode.insensitive ? `insensitive` : `value` : `attribute`;
@@ -26429,17 +25579,12 @@ function rule$l(primary) {
     } : {
       after: spaces && spaces.after || ``,
       setAfter(fixed) {
-        if (!attributeNode.spaces[key]) {
-          attributeNode.spaces[key] = {};
-        }
+        if (!attributeNode.spaces[key]) attributeNode.spaces[key] = {};
         attributeNode.spaces[key].after = fixed;
       }
     };
-    if (primary === `always`) {
-      setAfter(after.replace(/\s*$/, ` `));
-    } else if (primary === `never`) {
-      setAfter(after.replace(/\s*$/, ``));
-    }
+    if (primary === `always`) setAfter(after.replace(/\s*$/, ` `));
+    else if (primary === `never`) setAfter(after.replace(/\s*$/, ``));
   }
 }
 rule$l.ruleName = ruleName$l;
@@ -26455,20 +25600,14 @@ const index$l = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
 let { utils: { report: report$d } } = stylelint;
 function selectorAttributeOperatorSpaceChecker(options) {
   options.root.walkRules((rule2) => {
-    if (!isStandardSyntaxRule(rule2)) {
-      return;
-    }
-    if (!rule2.selector.includes(`[`) || !rule2.selector.includes(`=`)) {
-      return;
-    }
+    if (!isStandardSyntaxRule(rule2)) return;
+    if (!rule2.selector.includes(`[`) || !rule2.selector.includes(`=`)) return;
     let hasFixed = false;
     let selector2 = rule2.raws.selector ? rule2.raws.selector.raw : rule2.selector;
     let fixedSelector = parseSelector(selector2, options.result, rule2, (selectorTree) => {
       selectorTree.walkAttributes((attributeNode) => {
         let operator = attributeNode.operator;
-        if (!operator) {
-          return;
-        }
+        if (!operator) return;
         let attributeNodeString = attributeNode.toString();
         styleSearch({ source: attributeNodeString, target: operator }, (match) => {
           let index2 = options.checkBeforeOperator ? match.startIndex : match.endIndex - 1;
@@ -26477,11 +25616,8 @@ function selectorAttributeOperatorSpaceChecker(options) {
       });
     });
     if (hasFixed && fixedSelector) {
-      if (!rule2.raws.selector) {
-        rule2.selector = fixedSelector;
-      } else {
-        rule2.raws.selector.raw = fixedSelector;
-      }
+      if (!rule2.raws.selector) rule2.selector = fixedSelector;
+      else rule2.raws.selector.raw = fixedSelector;
     }
     function checkOperator(source, index2, node2, attributeNode, operator) {
       options.locationChecker({
@@ -26527,9 +25663,7 @@ function rule$k(primary) {
       actual: primary,
       possible: [`always`, `never`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     selectorAttributeOperatorSpaceChecker({
       root: root2,
       result: result2,
@@ -26546,12 +25680,8 @@ function rule$k(primary) {
               ),
               setOperatorAfter(fixed) {
                 delete attributeNode.raws.operator;
-                if (!attributeNode.raws.spaces) {
-                  attributeNode.raws.spaces = {};
-                }
-                if (!attributeNode.raws.spaces.operator) {
-                  attributeNode.raws.spaces.operator = {};
-                }
+                if (!attributeNode.raws.spaces) attributeNode.raws.spaces = {};
+                if (!attributeNode.raws.spaces.operator) attributeNode.raws.spaces.operator = {};
                 attributeNode.raws.spaces.operator.after = fixed;
               }
             };
@@ -26569,9 +25699,7 @@ function rule$k(primary) {
           return {
             operatorAfter: attributeNode.spaces.operator && attributeNode.spaces.operator.after || ``,
             setOperatorAfter(fixed) {
-              if (!attributeNode.spaces.operator) {
-                attributeNode.spaces.operator = {};
-              }
+              if (!attributeNode.spaces.operator) attributeNode.spaces.operator = {};
               attributeNode.spaces.operator.after = fixed;
             }
           };
@@ -26617,9 +25745,7 @@ function rule$j(primary) {
       actual: primary,
       possible: [`always`, `never`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     selectorAttributeOperatorSpaceChecker({
       root: root2,
       result: result2,
@@ -26637,9 +25763,7 @@ function rule$j(primary) {
         } : {
           attrAfter: attributeNode.spaces.attribute && attributeNode.spaces.attribute.after || ``,
           setAttrAfter(fixed) {
-            if (!attributeNode.spaces.attribute) {
-              attributeNode.spaces.attribute = {};
-            }
+            if (!attributeNode.spaces.attribute) attributeNode.spaces.attribute = {};
             attributeNode.spaces.attribute.after = fixed;
           }
         };
@@ -26667,20 +25791,12 @@ const index$j = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
   ruleName: ruleName$j
 }, Symbol.toStringTag, { value: "Module" }));
 function isStandardSyntaxCombinator(node2) {
-  if (node2.type !== `combinator`) {
-    return false;
-  }
-  if (node2.value.startsWith(`/`) || node2.value.endsWith(`/`)) {
-    return false;
-  }
+  if (node2.type !== `combinator`) return false;
+  if (node2.value.startsWith(`/`) || node2.value.endsWith(`/`)) return false;
   if (node2.parent !== void 0 && node2.parent !== null) {
     let parent = node2.parent;
-    if (node2 === parent.first) {
-      return false;
-    }
-    if (node2 === parent.last) {
-      return false;
-    }
+    if (node2 === parent.first) return false;
+    if (node2 === parent.last) return false;
   }
   return true;
 }
@@ -26688,37 +25804,24 @@ let { utils: { report: report$c } } = stylelint;
 function selectorCombinatorSpaceChecker(opts) {
   let hasFixed;
   opts.root.walkRules((rule2) => {
-    if (!isStandardSyntaxRule(rule2)) {
-      return;
-    }
+    if (!isStandardSyntaxRule(rule2)) return;
     hasFixed = false;
     let selector2 = rule2.raws.selector ? rule2.raws.selector.raw : rule2.selector;
     let fixedSelector = parseSelector(selector2, opts.result, rule2, (selectorTree) => {
       selectorTree.walkCombinators((node2) => {
-        if (!isStandardSyntaxCombinator(node2)) {
-          return;
-        }
-        if (/\s/.test(node2.value)) {
-          return;
-        }
-        if (opts.locationType === `before` && !node2.prev()) {
-          return;
-        }
+        if (!isStandardSyntaxCombinator(node2)) return;
+        if (/\s/.test(node2.value)) return;
+        if (opts.locationType === `before` && !node2.prev()) return;
         let parentParentNode = node2.parent && node2.parent.parent;
-        if (parentParentNode && parentParentNode.type === `pseudo`) {
-          return;
-        }
+        if (parentParentNode && parentParentNode.type === `pseudo`) return;
         let sourceIndex = node2.sourceIndex;
         let index2 = node2.value.length > 1 && opts.locationType === `before` ? sourceIndex : sourceIndex + node2.value.length - 1;
         check(selector2, node2, index2, rule2, sourceIndex);
       });
     });
     if (hasFixed && fixedSelector) {
-      if (!rule2.raws.selector) {
-        rule2.selector = fixedSelector;
-      } else {
-        rule2.raws.selector.raw = fixedSelector;
-      }
+      if (!rule2.raws.selector) rule2.selector = fixedSelector;
+      else rule2.raws.selector.raw = fixedSelector;
     }
   });
   function check(source, combinator2, index2, node2, sourceIndex) {
@@ -26761,9 +25864,7 @@ function rule$i(primary) {
       actual: primary,
       possible: [`always`, `never`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     selectorCombinatorSpaceChecker({
       root: root2,
       result: result2,
@@ -26812,9 +25913,7 @@ function rule$h(primary) {
       actual: primary,
       possible: [`always`, `never`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     selectorCombinatorSpaceChecker({
       root: root2,
       result: result2,
@@ -26860,23 +25959,15 @@ function rule$g(primary) {
     let validOptions = validateOptions$g(result2, ruleName$g, {
       actual: primary
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     root2.walkRules((ruleNode) => {
-      if (!isStandardSyntaxRule(ruleNode)) {
-        return;
-      }
+      if (!isStandardSyntaxRule(ruleNode)) return;
       let hasFixed = false;
       let selector2 = ruleNode.raws.selector ? ruleNode.raws.selector.raw : ruleNode.selector;
-      if (selector2.includes(`/*`)) {
-        return;
-      }
+      if (selector2.includes(`/*`)) return;
       let fixedSelector = parseSelector(selector2, result2, ruleNode, (fullSelector) => {
         fullSelector.walkCombinators((combinatorNode) => {
-          if (combinatorNode.value !== ` `) {
-            return;
-          }
+          if (combinatorNode.value !== ` `) return;
           let value = combinatorNode.toString();
           if (value.includes(`  `) || value.includes(`	`) || value.includes(`
 `) || value.includes(`\r`)) {
@@ -26891,9 +25982,7 @@ function rule$g(primary) {
               fix() {
                 if (/^\s+$/.test(value)) {
                   hasFixed = true;
-                  if (!combinatorNode.raws) {
-                    combinatorNode.raws = {};
-                  }
+                  if (!combinatorNode.raws) combinatorNode.raws = {};
                   combinatorNode.raws.value = ` `;
                   combinatorNode.rawSpaceBefore = combinatorNode.rawSpaceBefore.replace(/^\s+/, ``);
                   combinatorNode.rawSpaceAfter = combinatorNode.rawSpaceAfter.replace(/\s+$/, ``);
@@ -26904,11 +25993,8 @@ function rule$g(primary) {
         });
       });
       if (hasFixed && fixedSelector) {
-        if (!ruleNode.raws.selector) {
-          ruleNode.selector = fixedSelector;
-        } else {
-          ruleNode.raws.selector.raw = fixedSelector;
-        }
+        if (!ruleNode.raws.selector) ruleNode.selector = fixedSelector;
+        else ruleNode.raws.selector.raw = fixedSelector;
       }
     });
   };
@@ -26942,13 +26028,9 @@ function rule$f(primary, _secondaryOptions, context) {
       actual: primary,
       possible: [`always`, `always-multi-line`, `never-multi-line`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     root2.walkRules((ruleNode) => {
-      if (!isStandardSyntaxRule(ruleNode)) {
-        return;
-      }
+      if (!isStandardSyntaxRule(ruleNode)) return;
       let selector2 = ruleNode.raws.selector ? ruleNode.raws.selector.raw : ruleNode.selector;
       let fixIndices = [];
       styleSearch(
@@ -26959,9 +26041,7 @@ function rule$f(primary, _secondaryOptions, context) {
         },
         (match) => {
           let nextChars = selector2.slice(match.endIndex);
-          if (/^\s+\/\//.test(nextChars)) {
-            return;
-          }
+          if (/^\s+\/\//.test(nextChars)) return;
           let indextoCheckAfter = /^\s+\/\*/.test(nextChars) ? selector2.indexOf(`*/`, match.endIndex) + 1 : match.startIndex;
           checker.afterOneOnly({
             source: selector2,
@@ -26987,18 +26067,12 @@ function rule$f(primary, _secondaryOptions, context) {
         for (let index2 of fixIndices.sort((a2, b2) => b2 - a2)) {
           let beforeSelector = fixedSelector.slice(0, index2);
           let afterSelector = fixedSelector.slice(index2);
-          if (primary.startsWith(`always`)) {
-            afterSelector = context.newline + afterSelector;
-          } else if (primary.startsWith(`never-multi-line`)) {
-            afterSelector = afterSelector.replace(/^\s*/, ``);
-          }
+          if (primary.startsWith(`always`)) afterSelector = context.newline + afterSelector;
+          else if (primary.startsWith(`never-multi-line`)) afterSelector = afterSelector.replace(/^\s*/, ``);
           fixedSelector = beforeSelector + afterSelector;
         }
-        if (ruleNode.raws.selector) {
-          ruleNode.raws.selector.raw = fixedSelector;
-        } else {
-          ruleNode.selector = fixedSelector;
-        }
+        if (ruleNode.raws.selector) ruleNode.raws.selector.raw = fixedSelector;
+        else ruleNode.selector = fixedSelector;
       }
     });
   };
@@ -27016,9 +26090,7 @@ const index$f = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
 let { utils: { report: report$9 } } = stylelint;
 function selectorListCommaWhitespaceChecker(opts) {
   opts.root.walkRules((rule2) => {
-    if (!isStandardSyntaxRule(rule2)) {
-      return;
-    }
+    if (!isStandardSyntaxRule(rule2)) return;
     let selector2 = rule2.raws.selector ? rule2.raws.selector.raw : rule2.selector;
     styleSearch(
       {
@@ -27068,9 +26140,7 @@ function rule$e(primary, _secondaryOptions, context) {
       actual: primary,
       possible: [`always`, `always-multi-line`, `never-multi-line`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     let fixData;
     selectorListCommaWhitespaceChecker({
       root: root2,
@@ -27094,16 +26164,11 @@ function rule$e(primary, _secondaryOptions, context) {
           if (primary.startsWith(`always`)) {
             let spaceIndex = beforeSelector.search(/\s+$/);
             beforeSelector = spaceIndex >= 0 ? beforeSelector.slice(0, spaceIndex) + context.newline + beforeSelector.slice(spaceIndex) : beforeSelector + context.newline;
-          } else if (primary === `never-multi-line`) {
-            beforeSelector = beforeSelector.replace(/\s*$/, ``);
-          }
+          } else if (primary === `never-multi-line`) beforeSelector = beforeSelector.replace(/\s*$/, ``);
           selector2 = beforeSelector + afterSelector;
         }
-        if (ruleNode.raws.selector) {
-          ruleNode.raws.selector.raw = selector2;
-        } else {
-          ruleNode.selector = selector2;
-        }
+        if (ruleNode.raws.selector) ruleNode.raws.selector.raw = selector2;
+        else ruleNode.selector = selector2;
       }
     }
   };
@@ -27138,9 +26203,7 @@ function rule$d(primary) {
       actual: primary,
       possible: [`always`, `never`, `always-single-line`, `never-single-line`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     let fixData;
     selectorListCommaWhitespaceChecker({
       root: root2,
@@ -27161,18 +26224,12 @@ function rule$d(primary) {
         for (let index2 of commaIndices.sort((a2, b2) => b2 - a2)) {
           let beforeSelector = selector2.slice(0, index2 + 1);
           let afterSelector = selector2.slice(index2 + 1);
-          if (primary.startsWith(`always`)) {
-            afterSelector = afterSelector.replace(/^\s*/, ` `);
-          } else if (primary.startsWith(`never`)) {
-            afterSelector = afterSelector.replace(/^\s*/, ``);
-          }
+          if (primary.startsWith(`always`)) afterSelector = afterSelector.replace(/^\s*/, ` `);
+          else if (primary.startsWith(`never`)) afterSelector = afterSelector.replace(/^\s*/, ``);
           selector2 = beforeSelector + afterSelector;
         }
-        if (ruleNode.raws.selector) {
-          ruleNode.raws.selector.raw = selector2;
-        } else {
-          ruleNode.selector = selector2;
-        }
+        if (ruleNode.raws.selector) ruleNode.raws.selector.raw = selector2;
+        else ruleNode.selector = selector2;
       }
     }
   };
@@ -27207,9 +26264,7 @@ function rule$c(primary) {
       actual: primary,
       possible: [`always`, `never`, `always-single-line`, `never-single-line`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     let fixData;
     selectorListCommaWhitespaceChecker({
       root: root2,
@@ -27230,18 +26285,12 @@ function rule$c(primary) {
         for (let index2 of commaIndices.sort((a2, b2) => b2 - a2)) {
           let beforeSelector = selector2.slice(0, index2);
           let afterSelector = selector2.slice(index2);
-          if (primary.includes(`always`)) {
-            beforeSelector = beforeSelector.replace(/\s*$/, ` `);
-          } else if (primary.includes(`never`)) {
-            beforeSelector = beforeSelector.replace(/\s*$/, ``);
-          }
+          if (primary.includes(`always`)) beforeSelector = beforeSelector.replace(/\s*$/, ` `);
+          else if (primary.includes(`never`)) beforeSelector = beforeSelector.replace(/\s*$/, ``);
           selector2 = beforeSelector + afterSelector;
         }
-        if (ruleNode.raws.selector) {
-          ruleNode.raws.selector.raw = selector2;
-        } else {
-          ruleNode.selector = selector2;
-        }
+        if (ruleNode.raws.selector) ruleNode.raws.selector.raw = selector2;
+        else ruleNode.selector = selector2;
       }
     }
   };
@@ -27273,9 +26322,7 @@ function rule$b(primary) {
       actual: primary,
       possible: isNumber$1
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     let violatedCRLFNewLinesRegex = new RegExp(`(?:\r
 ){${maxAdjacentNewlines + 1},}`);
     let violatedLFNewLinesRegex = new RegExp(`
@@ -27297,11 +26344,8 @@ function rule$b(primary) {
           ruleName: ruleName$b,
           fix() {
             let newSelectorString = selector2.replace(new RegExp(violatedLFNewLinesRegex, `gm`), allowedLFNewLinesString).replace(new RegExp(violatedCRLFNewLinesRegex, `gm`), allowedCRLFNewLinesString);
-            if (ruleNode.raws.selector) {
-              ruleNode.raws.selector.raw = newSelectorString;
-            } else {
-              ruleNode.selector = newSelectorString;
-            }
+            if (ruleNode.raws.selector) ruleNode.raws.selector.raw = newSelectorString;
+            else ruleNode.selector = newSelectorString;
           }
         });
       }
@@ -27340,17 +26384,11 @@ function rule$a(primary) {
       actual: primary,
       possible: [`lower`, `upper`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     root2.walkRules((ruleNode) => {
-      if (!isStandardSyntaxRule(ruleNode)) {
-        return;
-      }
+      if (!isStandardSyntaxRule(ruleNode)) return;
       let selector2 = ruleNode.selector;
-      if (!selector2.includes(`:`)) {
-        return;
-      }
+      if (!selector2.includes(`:`)) return;
       let fixedSelector = parseSelector(
         ruleNode.raws.selector ? ruleNode.raws.selector.raw : ruleNode.selector,
         result2,
@@ -27358,16 +26396,10 @@ function rule$a(primary) {
         (selectorTree) => {
           selectorTree.walkPseudos((pseudoNode) => {
             let pseudo2 = pseudoNode.value;
-            if (!isStandardSyntaxSelector(pseudo2)) {
-              return;
-            }
-            if (pseudo2.includes(`::`) || levelOneAndTwoPseudoElements.has(pseudo2.toLowerCase().slice(1))) {
-              return;
-            }
+            if (!isStandardSyntaxSelector(pseudo2)) return;
+            if (pseudo2.includes(`::`) || levelOneAndTwoPseudoElements.has(pseudo2.toLowerCase().slice(1))) return;
             let expectedPseudo = primary === `lower` ? pseudo2.toLowerCase() : pseudo2.toUpperCase();
-            if (pseudo2 === expectedPseudo) {
-              return;
-            }
+            if (pseudo2 === expectedPseudo) return;
             report$7({
               message: messages$a.expected,
               messageArgs: [pseudo2, expectedPseudo],
@@ -27384,11 +26416,8 @@ function rule$a(primary) {
         }
       );
       if (fixedSelector) {
-        if (ruleNode.raws.selector) {
-          ruleNode.raws.selector.raw = fixedSelector;
-        } else {
-          ruleNode.selector = fixedSelector;
-        }
+        if (ruleNode.raws.selector) ruleNode.raws.selector.raw = fixedSelector;
+        else ruleNode.selector = fixedSelector;
       }
     });
   };
@@ -27422,25 +26451,19 @@ function rule$9(primary) {
       actual: primary,
       possible: [`always`, `never`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     root2.walkRules((ruleNode) => {
-      if (!isStandardSyntaxRule(ruleNode)) {
-        return;
-      }
-      if (!ruleNode.selector.includes(`(`)) {
-        return;
-      }
+      if (!isStandardSyntaxRule(ruleNode)) return;
+      if (!ruleNode.selector.includes(`(`)) return;
       let fix = null;
       let hasFixed = false;
       let selector2 = ruleNode.raws.selector ? ruleNode.raws.selector.raw : ruleNode.selector;
       let fixedSelector = parseSelector(selector2, result2, ruleNode, (selectorTree) => {
         selectorTree.walkPseudos((pseudoNode) => {
-          if (!pseudoNode.length) {
-            return;
-          }
+          if (!pseudoNode.length) return;
           let paramString = pseudoNode.map((node2) => String(node2)).join(`,`);
+          let isParamStringMultiline = paramString.includes(`
+`);
           let nextCharIsSpace = paramString.startsWith(` `);
           let openIndex = pseudoNode.sourceIndex + pseudoNode.value.length + 1;
           if (nextCharIsSpace && primary === `never`) {
@@ -27459,7 +26482,7 @@ function rule$9(primary) {
           }
           let prevCharIsSpace = paramString.endsWith(` `);
           let closeIndex = openIndex + paramString.length - 1;
-          if (prevCharIsSpace && primary === `never`) {
+          if (prevCharIsSpace && primary === `never` && !isParamStringMultiline) {
             fix = () => {
               hasFixed = true;
               setLastNodeSpaceAfter(pseudoNode, ``);
@@ -27476,11 +26499,8 @@ function rule$9(primary) {
         });
       });
       if (hasFixed && fixedSelector) {
-        if (!ruleNode.raws.selector) {
-          ruleNode.selector = fixedSelector;
-        } else {
-          ruleNode.raws.selector.raw = fixedSelector;
-        }
+        if (!ruleNode.raws.selector) ruleNode.selector = fixedSelector;
+        else ruleNode.raws.selector.raw = fixedSelector;
       }
       function complain(message, index2) {
         report$6({
@@ -27498,19 +26518,13 @@ function rule$9(primary) {
 }
 function setFirstNodeSpaceBefore(node2, value) {
   let target = node2.first;
-  if (target.type === `selector`) {
-    setFirstNodeSpaceBefore(target, value);
-  } else {
-    target.spaces.before = value;
-  }
+  if (target.type === `selector`) setFirstNodeSpaceBefore(target, value);
+  else target.spaces.before = value;
 }
 function setLastNodeSpaceAfter(node2, value) {
   let target = node2.last;
-  if (target.type === `selector`) {
-    setLastNodeSpaceAfter(target, value);
-  } else {
-    target.spaces.after = value;
-  }
+  if (target.type === `selector`) setLastNodeSpaceAfter(target, value);
+  else target.spaces.after = value;
 }
 rule$9.ruleName = ruleName$9;
 rule$9.messages = messages$9;
@@ -27546,30 +26560,18 @@ function rule$8(primary) {
       actual: primary,
       possible: [`lower`, `upper`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     root2.walkRules((ruleNode) => {
-      if (!isStandardSyntaxRule(ruleNode)) {
-        return;
-      }
+      if (!isStandardSyntaxRule(ruleNode)) return;
       let selector2 = ruleNode.selector;
-      if (!selector2.includes(`:`)) {
-        return;
-      }
+      if (!selector2.includes(`:`)) return;
       transformSelector(result2, ruleNode, (selectorTree) => {
         selectorTree.walkPseudos((pseudoNode) => {
           let pseudoElement = pseudoNode.value;
-          if (!isStandardSyntaxSelector(pseudoElement)) {
-            return;
-          }
-          if (!pseudoElement.includes(`::`) && !levelOneAndTwoPseudoElements.has(pseudoElement.toLowerCase().slice(1))) {
-            return;
-          }
+          if (!isStandardSyntaxSelector(pseudoElement)) return;
+          if (!pseudoElement.includes(`::`) && !levelOneAndTwoPseudoElements.has(pseudoElement.toLowerCase().slice(1))) return;
           let expectedPseudoElement = primary === `lower` ? pseudoElement.toLowerCase() : pseudoElement.toUpperCase();
-          if (pseudoElement === expectedPseudoElement) {
-            return;
-          }
+          if (pseudoElement === expectedPseudoElement) return;
           report$5({
             message: messages$8.expected,
             messageArgs: [pseudoElement, expectedPseudoElement],
@@ -27628,9 +26630,7 @@ function rule$7(primary, secondaryOptions) {
         optional: true
       }
     );
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     let avoidEscape = secondaryOptions && secondaryOptions.avoidEscape !== void 0 ? secondaryOptions.avoidEscape : true;
     root2.walk((node2) => {
       switch (node2.type) {
@@ -27646,27 +26646,19 @@ function rule$7(primary, secondaryOptions) {
       }
     });
     function checkRule(ruleNode) {
-      if (!isStandardSyntaxRule(ruleNode)) {
-        return;
-      }
-      if (!ruleNode.selector.includes(`[`) || !ruleNode.selector.includes(`=`)) {
-        return;
-      }
+      if (!isStandardSyntaxRule(ruleNode)) return;
+      if (!ruleNode.selector.includes(`[`) || !ruleNode.selector.includes(`=`)) return;
       let fixPositions = [];
       parseSelector(ruleNode.selector, result2, ruleNode, (selectorTree) => {
         let selectorFixed = false;
         selectorTree.walkAttributes((attributeNode) => {
-          if (!attributeNode.quoted) {
-            return;
-          }
+          if (!attributeNode.quoted) return;
           const maybeProblemIndex = attributeNode.sourceIndex + attributeNode.offsetOf(`value`);
           if (attributeNode.quoteMark === correctQuote && avoidEscape) {
             assertString(attributeNode.value);
             let needsCorrectEscape = attributeNode.value.includes(correctQuote);
             let needsOtherEscape = attributeNode.value.includes(erroneousQuote);
-            if (needsOtherEscape) {
-              return;
-            }
+            if (needsOtherEscape) return;
             if (needsCorrectEscape) {
               report$4({
                 message: messages$7.expected,
@@ -27704,9 +26696,7 @@ function rule$7(primary, secondaryOptions) {
                 });
                 return;
               }
-              if (needsCorrectEscape) {
-                return;
-              }
+              if (needsCorrectEscape) return;
             }
             report$4({
               message: messages$7.expected,
@@ -27723,24 +26713,16 @@ function rule$7(primary, secondaryOptions) {
             });
           }
         });
-        if (selectorFixed) {
-          ruleNode.selector = selectorTree.toString();
-        }
+        if (selectorFixed) ruleNode.selector = selectorTree.toString();
       });
-      for (let fixIndex of fixPositions) {
-        ruleNode.selector = replaceQuote(ruleNode.selector, fixIndex, correctQuote);
-      }
+      for (let fixIndex of fixPositions) ruleNode.selector = replaceQuote(ruleNode.selector, fixIndex, correctQuote);
     }
     function checkDeclOrAtRule(node2, value, getIndex) {
       let fixPositions = [];
-      if (!value.includes(erroneousQuote)) {
-        return;
-      }
+      if (!value.includes(erroneousQuote)) return;
       if (isAtRule(node2) && node2.name === `charset`) {
         let hasValidQuotes = node2.params.startsWith(`"`) && node2.params.endsWith(`"`);
-        if (hasValidQuotes || correctQuote === `'`) {
-          return;
-        }
+        if (hasValidQuotes || correctQuote === `'`) return;
       }
       valueParser(value).walk((valueNode) => {
         if (valueNode.type === `string` && valueNode.quote === erroneousQuote) {
@@ -27768,11 +26750,8 @@ function rule$7(primary, secondaryOptions) {
         }
       });
       for (let fixIndex of fixPositions) {
-        if (isAtRule(node2)) {
-          node2.params = replaceQuote(node2.params, fixIndex, correctQuote);
-        } else {
-          node2.value = replaceQuote(node2.value, fixIndex, correctQuote);
-        }
+        if (isAtRule(node2)) node2.params = replaceQuote(node2.params, fixIndex, correctQuote);
+        else node2.value = replaceQuote(node2.value, fixIndex, correctQuote);
       }
     }
   };
@@ -27806,9 +26785,7 @@ function rule$6(primary) {
       actual: primary,
       possible: [`always`, `never`]
     });
-    if (!validOptions || !root2.source || root2.source.inline || root2.source.lang === `object-literal` || root2.document !== void 0) {
-      return;
-    }
+    if (!validOptions || !root2.source || root2.source.inline || root2.source.lang === `object-literal` || root2.document !== void 0) return;
     let { hasBOM } = root2.source.input;
     if (primary === `always` && !hasBOM) {
       report$3({
@@ -27843,27 +26820,13 @@ function blurInterpolation(source, blurChar = ` `) {
 }
 function isStandardSyntaxValue(value) {
   let normalizedValue = value;
-  if (/^[-+*/]/.test(value.charAt(0))) {
-    normalizedValue = normalizedValue.slice(1);
-  }
-  if (normalizedValue.startsWith(`$`)) {
-    return false;
-  }
-  if (/^.+\.\$/.test(value)) {
-    return false;
-  }
-  if (/^.+\.[-\w]+\(/.test(value)) {
-    return false;
-  }
-  if (normalizedValue.startsWith(`@`)) {
-    return false;
-  }
-  if (hasInterpolation(normalizedValue)) {
-    return false;
-  }
-  if (/__MSG_\S+__/.test(value)) {
-    return false;
-  }
+  if (/^[-+*/]/.test(value.charAt(0))) normalizedValue = normalizedValue.slice(1);
+  if (normalizedValue.startsWith(`$`)) return false;
+  if (/^.+\.\$/.test(value)) return false;
+  if (/^.+\.[-\w]+\(/.test(value)) return false;
+  if (normalizedValue.startsWith(`@`)) return false;
+  if (hasInterpolation(normalizedValue)) return false;
+  if (/__MSG_\S+__/.test(value)) return false;
   return true;
 }
 function getDimension(node2) {
@@ -27917,20 +26880,14 @@ function rule$5(primary) {
       actual: primary,
       possible: [`lower`, `upper`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     function check(node2, checkedValue, getIndex) {
       let problems = [];
       function processValue(valueNode) {
         let { number, unit: unit2 } = getDimension(valueNode);
-        if (!number || !unit2) {
-          return false;
-        }
+        if (!number || !unit2) return false;
         let expectedUnit = primary === `lower` ? unit2.toLowerCase() : unit2.toUpperCase();
-        if (unit2 === expectedUnit) {
-          return false;
-        }
+        if (unit2 === expectedUnit) return false;
         let index2 = getIndex(node2);
         problems.push({
           index: index2 + valueNode.sourceIndex + number.length,
@@ -27942,9 +26899,7 @@ function rule$5(primary) {
       }
       let parsedValue = valueParser(checkedValue).walk((valueNode) => {
         let value = valueNode.value;
-        if (valueNode.type === `function` && value.toLowerCase() === `url`) {
-          return false;
-        }
+        if (valueNode.type === `function` && value.toLowerCase() === `url`) return false;
         if (value.includes(`*`)) {
           value.split(`*`).some((val) => processValue({
             ...valueNode,
@@ -27952,9 +26907,7 @@ function rule$5(primary) {
             value: val
           }));
         }
-        if (processValue(valueNode)) {
-          valueNode.value = primary === `lower` ? value.toLowerCase() : value.toUpperCase();
-        }
+        if (processValue(valueNode)) valueNode.value = primary === `lower` ? value.toLowerCase() : value.toUpperCase();
       });
       if (problems.length) {
         for (let err of problems) {
@@ -27967,20 +26920,15 @@ function rule$5(primary) {
             result: result2,
             ruleName: ruleName$5,
             fix() {
-              if (`name` in node2 && node2.name === `media`) {
-                node2.params = parsedValue.toString();
-              } else if (`value` in node2) {
-                node2.value = parsedValue.toString();
-              }
+              if (`name` in node2 && node2.name === `media`) node2.params = parsedValue.toString();
+              else if (`value` in node2) node2.value = parsedValue.toString();
             }
           });
         }
       }
     }
     root2.walkAtRules((atRule2) => {
-      if (!/^media$/i.test(atRule2.name) && !(`variable` in atRule2)) {
-        return;
-      }
+      if (!/^media$/i.test(atRule2.name) && !(`variable` in atRule2)) return;
       check(atRule2, atRule2.params, atRuleParamIndex);
     });
     root2.walkDecls((decl) => check(decl, decl.value, declarationValueIndex));
@@ -27999,9 +26947,7 @@ const index$5 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
 let { utils: { report: report$1 } } = stylelint;
 function valueListCommaWhitespaceChecker(opts) {
   opts.root.walkDecls((decl) => {
-    if (!isStandardSyntaxDeclaration(decl) || !isStandardSyntaxProperty(decl.prop)) {
-      return;
-    }
+    if (!isStandardSyntaxDeclaration(decl) || !isStandardSyntaxProperty(decl.prop)) return;
     let declString = decl.toString();
     styleSearch(
       {
@@ -28011,9 +26957,7 @@ function valueListCommaWhitespaceChecker(opts) {
       },
       (match) => {
         let indexToCheckAfter = opts.determineIndex ? opts.determineIndex(declString, match) : match.startIndex;
-        if (indexToCheckAfter === false) {
-          return;
-        }
+        if (indexToCheckAfter === false) return;
         checkComma(declString, indexToCheckAfter, decl);
       }
     );
@@ -28055,9 +26999,7 @@ function rule$4(primary, _secondaryOptions, context) {
       actual: primary,
       possible: [`always`, `always-multi-line`, `never-multi-line`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     let fixData;
     valueListCommaWhitespaceChecker({
       root: root2,
@@ -28066,9 +27008,7 @@ function rule$4(primary, _secondaryOptions, context) {
       checkedRuleName: ruleName$4,
       fix: (declNode, index2) => {
         let valueIndex = declarationValueIndex(declNode);
-        if (index2 <= valueIndex) {
-          return false;
-        }
+        if (index2 <= valueIndex) return false;
         fixData = fixData || /* @__PURE__ */ new Map();
         let commaIndices = fixData.get(declNode) || [];
         commaIndices.push(index2);
@@ -28077,9 +27017,7 @@ function rule$4(primary, _secondaryOptions, context) {
       },
       determineIndex: (declString, match) => {
         let nextChars = declString.substring(match.endIndex, declString.length);
-        if (/^[ \t]*\/\//.test(nextChars)) {
-          return false;
-        }
+        if (/^[ \t]*\/\//.test(nextChars)) return false;
         return /^[ \t]*\/\*/.test(nextChars) ? declString.indexOf(`*/`, match.endIndex) + 1 : match.startIndex;
       }
     });
@@ -28090,11 +27028,8 @@ function rule$4(primary, _secondaryOptions, context) {
           let valueIndex = index2 - declarationValueIndex(decl);
           let beforeValue = value.slice(0, valueIndex + 1);
           let afterValue = value.slice(valueIndex + 1);
-          if (primary.startsWith(`always`)) {
-            afterValue = context.newline + afterValue;
-          } else if (primary.startsWith(`never-multi-line`)) {
-            afterValue = afterValue.replace(/^\s*/, ``);
-          }
+          if (primary.startsWith(`always`)) afterValue = context.newline + afterValue;
+          else if (primary.startsWith(`never-multi-line`)) afterValue = afterValue.replace(/^\s*/, ``);
           setDeclarationValue(decl, beforeValue + afterValue);
         }
       }
@@ -28129,9 +27064,7 @@ function rule$3(primary) {
       actual: primary,
       possible: [`always`, `always-multi-line`, `never-multi-line`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     valueListCommaWhitespaceChecker({
       root: root2,
       result: result2,
@@ -28170,9 +27103,7 @@ function rule$2(primary) {
       actual: primary,
       possible: [`always`, `never`, `always-single-line`, `never-single-line`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     let fixData;
     valueListCommaWhitespaceChecker({
       root: root2,
@@ -28181,9 +27112,7 @@ function rule$2(primary) {
       checkedRuleName: ruleName$2,
       fix: (declNode, index2) => {
         let valueIndex = declarationValueIndex(declNode);
-        if (index2 <= valueIndex) {
-          return false;
-        }
+        if (index2 <= valueIndex) return false;
         fixData = fixData || /* @__PURE__ */ new Map();
         let commaIndices = fixData.get(declNode) || [];
         commaIndices.push(index2);
@@ -28198,11 +27127,8 @@ function rule$2(primary) {
           let valueIndex = index2 - declarationValueIndex(decl);
           let beforeValue = value.slice(0, valueIndex + 1);
           let afterValue = value.slice(valueIndex + 1);
-          if (primary.startsWith(`always`)) {
-            afterValue = afterValue.replace(/^\s*/, ` `);
-          } else if (primary.startsWith(`never`)) {
-            afterValue = afterValue.replace(/^\s*/, ``);
-          }
+          if (primary.startsWith(`always`)) afterValue = afterValue.replace(/^\s*/, ` `);
+          else if (primary.startsWith(`never`)) afterValue = afterValue.replace(/^\s*/, ``);
           setDeclarationValue(decl, beforeValue + afterValue);
         }
       }
@@ -28239,9 +27165,7 @@ function rule$1(primary) {
       actual: primary,
       possible: [`always`, `never`, `always-single-line`, `never-single-line`]
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     let fixData;
     valueListCommaWhitespaceChecker({
       root: root2,
@@ -28250,9 +27174,7 @@ function rule$1(primary) {
       checkedRuleName: ruleName$1,
       fix: (declNode, index2) => {
         let valueIndex = declarationValueIndex(declNode);
-        if (index2 <= valueIndex) {
-          return false;
-        }
+        if (index2 <= valueIndex) return false;
         fixData = fixData || /* @__PURE__ */ new Map();
         let commaIndices = fixData.get(declNode) || [];
         commaIndices.push(index2);
@@ -28267,11 +27189,8 @@ function rule$1(primary) {
           let valueIndex = index2 - declarationValueIndex(decl);
           let beforeValue = value.slice(0, valueIndex);
           let afterValue = value.slice(valueIndex);
-          if (primary.startsWith(`always`)) {
-            beforeValue = beforeValue.replace(/\s*$/, ` `);
-          } else if (primary.startsWith(`never`)) {
-            beforeValue = beforeValue.replace(/\s*$/, ``);
-          }
+          if (primary.startsWith(`always`)) beforeValue = beforeValue.replace(/\s*$/, ` `);
+          else if (primary.startsWith(`never`)) beforeValue = beforeValue.replace(/\s*$/, ``);
           setDeclarationValue(decl, beforeValue + afterValue);
         }
       }
@@ -28305,9 +27224,7 @@ function rule(primary) {
       actual: primary,
       possible: isNumber$1
     });
-    if (!validOptions) {
-      return;
-    }
+    if (!validOptions) return;
     let violatedCRLFNewLinesRegex = new RegExp(`(?:\r
 ){${maxAdjacentNewlines + 1},}`);
     let violatedLFNewLinesRegex = new RegExp(`