stylelint-plugin-grid 1.0.0 → 1.0.2

package/dist/plugin.cjs

@@ -40,7 +40,7 @@ __export(plugin_exports, {
   rules: () => rules
 });
 module.exports = __toCommonJS(plugin_exports);
-var import_ts_extras14 = require("ts-extras");
+var import_ts_extras22 = require("ts-extras");
 
 // dist/_internal/plugin-constants.js
 var import_package = __toESM(require("stylelint-plugin-grid/package.json"), 1);
@@ -60,11 +60,11 @@ function isUnknownRecord(pkg) {
   return typeof pkg === "object" && pkg !== null && !Array.isArray(pkg);
 }
 var PACKAGE_VERSION = getPackageVersion(import_package.default);
-function createRuleDocsUrl(ruleName14) {
-  return `${DOCS_RULES_BASE_URL}/${ruleName14}`;
+function createRuleDocsUrl(ruleName22) {
+  return `${DOCS_RULES_BASE_URL}/${ruleName22}`;
 }
-function createRuleName(ruleName14) {
-  return `${PLUGIN_NAMESPACE}/${ruleName14}`;
+function createRuleName(ruleName22) {
+  return `${PLUGIN_NAMESPACE}/${ruleName22}`;
 }
 
 // dist/rules/consistent-area-naming.js
@@ -74,31 +74,31 @@ var import_ts_extras3 = require("ts-extras");
 // dist/_internal/create-stylelint-rule.js
 var import_stylelint = __toESM(require("stylelint"), 1);
 var createStylelintRule = (options) => {
-  const { docs: docs14, messages: messages14, rule: rule14, ruleName: ruleName14 } = options;
+  const { docs: docs22, messages: messages22, rule: rule22, ruleName: ruleName22 } = options;
   const baseMeta = {
     ...options.meta,
-    url: options.meta?.url ?? docs14.url
+    url: options.meta?.url ?? docs22.url
   };
   const meta2 = {
     ...baseMeta,
-    docs: docs14
+    docs: docs22
   };
-  const typedRule = Object.assign(rule14, {
-    messages: messages14,
+  const typedRule = Object.assign(rule22, {
+    messages: messages22,
     meta: meta2,
-    ruleName: ruleName14
+    ruleName: ruleName22
   });
   if (options.primaryOptionArray === true) {
     typedRule.primaryOptionArray = true;
   }
-  const plugin = import_stylelint.default.createPlugin(ruleName14, typedRule);
+  const plugin = import_stylelint.default.createPlugin(ruleName22, typedRule);
   return {
     ...plugin,
-    docs: docs14,
-    messages: messages14,
+    docs: docs22,
+    messages: messages22,
     meta: meta2,
     rule: typedRule,
-    ruleName: ruleName14
+    ruleName: ruleName22
   };
 };
 
@@ -291,6 +291,9 @@ function parseGridTemplateAreas(declaration) {
 function splitTopLevelCommas(value) {
   return splitTopLevel(value, /,/v);
 }
+function splitTopLevelSlashes(value) {
+  return splitTopLevel(value, /\//v);
+}
 function splitTopLevelWhitespace(value) {
   return splitTopLevel(value, /\s/v);
 }
@@ -495,20 +498,137 @@ var rule = createStylelintRule({
 });
 var consistent_area_naming_default = rule;
 
-// dist/rules/no-dense-auto-flow.js
+// dist/rules/no-conflicting-placement.js
 var import_stylelint3 = __toESM(require("stylelint"), 1);
+var import_ts_extras5 = require("ts-extras");
+
+// dist/_internal/grid-placement-analysis.js
+var import_ts_extras4 = require("ts-extras");
+var gridPlacementProperties = /* @__PURE__ */ new Set([
+  "grid-area",
+  "grid-column",
+  "grid-column-end",
+  "grid-column-start",
+  "grid-row",
+  "grid-row-end",
+  "grid-row-start"
+]);
+var strictIntegerPattern = /^[+\-]?\d+$/v;
+function getDirectDeclarations(rule22) {
+  return rule22.nodes.filter((node) => node.type === "decl");
+}
+function getGridLineIntegerTokens(value) {
+  const integers = [];
+  for (const token of splitTopLevelWhitespace(value)) {
+    const integer = parseStrictInteger(token);
+    if ((0, import_ts_extras4.isDefined)(integer)) {
+      integers.push(integer);
+    }
+  }
+  return integers;
+}
+function getGridLineSpanCounts(value) {
+  const tokens = splitTopLevelWhitespace(value);
+  const hasSpan = tokens.some((token) => token.toLowerCase() === "span");
+  if (!hasSpan) {
+    return [];
+  }
+  return tokens.map((token) => parseStrictInteger(token)).filter(import_ts_extras4.isDefined);
+}
+function getGridPlacementSlots(value) {
+  return splitTopLevelSlashes(value);
+}
+function isGridPlacementDeclaration(declaration) {
+  return (0, import_ts_extras4.setHas)(gridPlacementProperties, declaration.prop.toLowerCase());
+}
+function parseStandaloneGridLineInteger(value) {
+  const tokens = splitTopLevelWhitespace(value);
+  return tokens.length === 1 ? parseStrictInteger((0, import_ts_extras4.arrayFirst)(tokens) ?? "") : void 0;
+}
+function parseStrictInteger(value) {
+  if (!strictIntegerPattern.test(value)) {
+    return void 0;
+  }
+  return Number.parseInt(value, 10);
+}
+
+// dist/rules/no-conflicting-placement.js
 var { report: report2, ruleMessages: ruleMessages2, validateOptions: validateOptions2 } = import_stylelint3.default.utils;
-var ruleName2 = createRuleName("no-dense-auto-flow");
+var ruleName2 = createRuleName("no-conflicting-placement");
 var messages2 = ruleMessages2(ruleName2, {
-  rejected: () => "Avoid `grid-auto-flow: dense`; dense packing can disconnect visual order from source order."
+  rejected: (propertyName, previousPropertyName) => `Avoid conflicting Grid placement declarations; \`${propertyName}\` writes the same placement slot as earlier \`${previousPropertyName}\` in this block.`
 });
 var docs2 = {
+  description: "Disallow same-block CSS Grid placement declarations that write the same placement slot.",
+  recommended: true,
+  url: createRuleDocsUrl("no-conflicting-placement")
+};
+var propertySlots = {
+  "grid-area": [
+    "row-start",
+    "column-start",
+    "row-end",
+    "column-end"
+  ],
+  "grid-column": ["column-start", "column-end"],
+  "grid-column-end": ["column-end"],
+  "grid-column-start": ["column-start"],
+  "grid-row": ["row-start", "row-end"],
+  "grid-row-end": ["row-end"],
+  "grid-row-start": ["row-start"]
+};
+var ruleFunction2 = (primary) => (root, result) => {
+  if (!validateOptions2(result, ruleName2, {
+    actual: primary,
+    possible: [true]
+  })) {
+    return;
+  }
+  root.walkRules((ruleNode) => {
+    const slotDeclarations = /* @__PURE__ */ new Map();
+    for (const declaration of getDirectDeclarations(ruleNode)) {
+      if (isGridPlacementDeclaration(declaration)) {
+        const propertyName = declaration.prop.toLowerCase();
+        const slots = propertySlots[propertyName] ?? [];
+        const previousDeclaration = slots.map((slot) => slotDeclarations.get(slot)).find(import_ts_extras5.isDefined);
+        if ((0, import_ts_extras5.isDefined)(previousDeclaration)) {
+          report2({
+            message: messages2.rejected(propertyName, previousDeclaration.prop),
+            node: declaration,
+            result,
+            ruleName: ruleName2,
+            word: declaration.prop
+          });
+        }
+        for (const slot of slots) {
+          slotDeclarations.set(slot, declaration);
+        }
+      }
+    }
+  });
+};
+var rule2 = createStylelintRule({
+  docs: docs2,
+  messages: messages2,
+  rule: ruleFunction2,
+  ruleName: ruleName2
+});
+var no_conflicting_placement_default = rule2;
+
+// dist/rules/no-dense-auto-flow.js
+var import_stylelint4 = __toESM(require("stylelint"), 1);
+var { report: report3, ruleMessages: ruleMessages3, validateOptions: validateOptions3 } = import_stylelint4.default.utils;
+var ruleName3 = createRuleName("no-dense-auto-flow");
+var messages3 = ruleMessages3(ruleName3, {
+  rejected: () => "Avoid `grid-auto-flow: dense`; dense packing can disconnect visual order from source order."
+});
+var docs3 = {
   description: "Disallow `grid-auto-flow: dense` because it can reorder auto-placed grid items visually.",
   recommended: false,
   url: createRuleDocsUrl("no-dense-auto-flow")
 };
-var ruleFunction2 = (primary) => (root, result) => {
-  if (!validateOptions2(result, ruleName2, {
+var ruleFunction3 = (primary) => (root, result) => {
+  if (!validateOptions3(result, ruleName3, {
     actual: primary,
     possible: [true]
   })) {
@@ -519,37 +639,122 @@ var ruleFunction2 = (primary) => (root, result) => {
     if (!hasDensePacking) {
       return;
     }
-    report2({
-      message: messages2.rejected(),
+    report3({
+      message: messages3.rejected(),
       node: declaration,
       result,
-      ruleName: ruleName2,
+      ruleName: ruleName3,
       word: "dense"
     });
   });
 };
-var rule2 = createStylelintRule({
-  docs: docs2,
-  messages: messages2,
-  rule: ruleFunction2,
-  ruleName: ruleName2
+var rule3 = createStylelintRule({
+  docs: docs3,
+  messages: messages3,
+  rule: ruleFunction3,
+  ruleName: ruleName3
+});
+var no_dense_auto_flow_default = rule3;
+
+// dist/rules/no-ineffective-container-properties.js
+var import_stylelint5 = __toESM(require("stylelint"), 1);
+var import_ts_extras6 = require("ts-extras");
+var { report: report4, ruleMessages: ruleMessages4, validateOptions: validateOptions4 } = import_stylelint5.default.utils;
+var ruleName4 = createRuleName("no-ineffective-container-properties");
+var messages4 = ruleMessages4(ruleName4, {
+  rejected: (propertyName, display) => `\`${propertyName}\` has no grid-container effect when the final same-block \`display\` value is \`${display}\`; use \`grid\` or \`inline-grid\`, or remove the grid container declaration.`
+});
+var docs4 = {
+  description: "Disallow CSS Grid container declarations in blocks whose final literal display value is not grid-capable.",
+  recommended: true,
+  url: createRuleDocsUrl("no-ineffective-container-properties")
+};
+var gridContainerProperties = /* @__PURE__ */ new Set([
+  "grid",
+  "grid-auto-columns",
+  "grid-auto-flow",
+  "grid-auto-rows",
+  "grid-template",
+  "grid-template-areas",
+  "grid-template-columns",
+  "grid-template-rows"
+]);
+var gridDisplayValues = /* @__PURE__ */ new Set(["grid", "inline-grid"]);
+var nonGridDisplayValues = /* @__PURE__ */ new Set([
+  "block",
+  "contents",
+  "flex",
+  "flow-root",
+  "inline",
+  "inline-block",
+  "inline-flex",
+  "inline-table",
+  "list-item",
+  "none",
+  "table"
+]);
+function getLastLiteralDisplay(declarations) {
+  return declarations.findLast((declaration) => declaration.prop.toLowerCase() === "display" && (0, import_ts_extras6.isDefined)(getLiteralDisplayValue(declaration.value)));
+}
+function getLiteralDisplayValue(value) {
+  const normalizedValue = value.trim().toLowerCase();
+  if (normalizedValue.includes("(") || normalizedValue.includes(")")) {
+    return void 0;
+  }
+  return normalizedValue;
+}
+var ruleFunction4 = (primary) => (root, result) => {
+  if (!validateOptions4(result, ruleName4, {
+    actual: primary,
+    possible: [true]
+  })) {
+    return;
+  }
+  root.walkRules((ruleNode) => {
+    const declarations = getDirectDeclarations(ruleNode);
+    const displayDeclaration = getLastLiteralDisplay(declarations);
+    const displayValue = (0, import_ts_extras6.isDefined)(displayDeclaration) ? getLiteralDisplayValue(displayDeclaration.value) : void 0;
+    const isGridCapableDisplay = (0, import_ts_extras6.isDefined)(displayValue) ? (0, import_ts_extras6.setHas)(gridDisplayValues, displayValue) : false;
+    const isKnownNonGridDisplay = (0, import_ts_extras6.isDefined)(displayValue) ? (0, import_ts_extras6.setHas)(nonGridDisplayValues, displayValue) : false;
+    if (!(0, import_ts_extras6.isDefined)(displayValue) || isGridCapableDisplay || !isKnownNonGridDisplay) {
+      return;
+    }
+    for (const declaration of declarations) {
+      const propertyName = declaration.prop.toLowerCase();
+      if ((0, import_ts_extras6.setHas)(gridContainerProperties, propertyName)) {
+        report4({
+          message: messages4.rejected(propertyName, displayValue),
+          node: declaration,
+          result,
+          ruleName: ruleName4,
+          word: declaration.prop
+        });
+      }
+    }
+  });
+};
+var rule4 = createStylelintRule({
+  docs: docs4,
+  messages: messages4,
+  rule: ruleFunction4,
+  ruleName: ruleName4
 });
-var no_dense_auto_flow_default = rule2;
+var no_ineffective_container_properties_default = rule4;
 
 // dist/rules/no-invalid-areas.js
-var import_stylelint4 = __toESM(require("stylelint"), 1);
-var { report: report3, ruleMessages: ruleMessages3, validateOptions: validateOptions3 } = import_stylelint4.default.utils;
-var ruleName3 = createRuleName("no-invalid-areas");
-var messages3 = ruleMessages3(ruleName3, {
+var import_stylelint6 = __toESM(require("stylelint"), 1);
+var { report: report5, ruleMessages: ruleMessages5, validateOptions: validateOptions5 } = import_stylelint6.default.utils;
+var ruleName5 = createRuleName("no-invalid-areas");
+var messages5 = ruleMessages5(ruleName5, {
   rejected: (message) => message
 });
-var docs3 = {
+var docs5 = {
   description: "Disallow malformed `grid-template-areas` declarations.",
   recommended: true,
   url: createRuleDocsUrl("no-invalid-areas")
 };
-var ruleFunction3 = (primary) => (root, result) => {
-  if (!validateOptions3(result, ruleName3, {
+var ruleFunction5 = (primary) => (root, result) => {
+  if (!validateOptions5(result, ruleName5, {
     actual: primary,
     possible: [true]
   })) {
@@ -557,33 +762,33 @@ var ruleFunction3 = (primary) => (root, result) => {
   }
   for (const template of collectGridTemplateAreas(root)) {
     for (const diagnostic of template.diagnostics) {
-      report3({
-        message: messages3.rejected(diagnostic.message),
+      report5({
+        message: messages5.rejected(diagnostic.message),
         node: template.declaration,
         result,
-        ruleName: ruleName3,
+        ruleName: ruleName5,
         word: diagnostic.token
       });
     }
   }
 };
-var rule3 = createStylelintRule({
-  docs: docs3,
-  messages: messages3,
-  rule: ruleFunction3,
-  ruleName: ruleName3
+var rule5 = createStylelintRule({
+  docs: docs5,
+  messages: messages5,
+  rule: ruleFunction5,
+  ruleName: ruleName5
 });
-var no_invalid_areas_default = rule3;
+var no_invalid_areas_default = rule5;
 
 // dist/rules/no-invalid-auto-repeat.js
-var import_stylelint5 = __toESM(require("stylelint"), 1);
-var import_ts_extras4 = require("ts-extras");
-var { report: report4, ruleMessages: ruleMessages4, validateOptions: validateOptions4 } = import_stylelint5.default.utils;
-var ruleName4 = createRuleName("no-invalid-auto-repeat");
-var messages4 = ruleMessages4(ruleName4, {
+var import_stylelint7 = __toESM(require("stylelint"), 1);
+var import_ts_extras7 = require("ts-extras");
+var { report: report6, ruleMessages: ruleMessages6, validateOptions: validateOptions6 } = import_stylelint7.default.utils;
+var ruleName6 = createRuleName("no-invalid-auto-repeat");
+var messages6 = ruleMessages6(ruleName6, {
   rejected: (token, repeatKeyword) => `Use a fixed track size inside \`repeat(${repeatKeyword}, ...)\`; \`${token}\` can make the grid template declaration invalid.`
 });
-var docs4 = {
+var docs6 = {
   description: "Disallow definitely invalid CSS Grid auto-repeat track sizes.",
   recommended: true,
   url: createRuleDocsUrl("no-invalid-auto-repeat")
@@ -651,7 +856,7 @@ function getInvalidAutoRepeatTrack(trackList) {
   for (const token of splitTopLevelWhitespace(trackList)) {
     const normalizedToken = token.toLowerCase();
     if (!isLineNameList2(token) && !containsRuntimeValue(token)) {
-      if ((0, import_ts_extras4.setHas)(invalidBareAutoRepeatTrackTokens, normalizedToken) || isFlexTrackBreadth(normalizedToken)) {
+      if ((0, import_ts_extras7.setHas)(invalidBareAutoRepeatTrackTokens, normalizedToken) || isFlexTrackBreadth(normalizedToken)) {
         return token;
       }
       if (hasStringPrefix(normalizedToken, "minmax(") && isInvalidAutoRepeatMinmax(token)) {
@@ -662,18 +867,18 @@ function getInvalidAutoRepeatTrack(trackList) {
   return void 0;
 }
 function getMinmaxArguments(token) {
-  const minmaxCall = (0, import_ts_extras4.arrayFirst)(findValueFunctionCalls(token, "minmax"));
-  if (!(0, import_ts_extras4.isDefined)(minmaxCall)) {
+  const minmaxCall = (0, import_ts_extras7.arrayFirst)(findValueFunctionCalls(token, "minmax"));
+  if (!(0, import_ts_extras7.isDefined)(minmaxCall)) {
     return void 0;
   }
   const [minimum, maximum] = splitTopLevelCommas(minmaxCall.body).map((argument) => argument.trim());
-  if (!(0, import_ts_extras4.isDefined)(minimum) || !(0, import_ts_extras4.isDefined)(maximum)) {
+  if (!(0, import_ts_extras7.isDefined)(minimum) || !(0, import_ts_extras7.isDefined)(maximum)) {
     return void 0;
   }
   return [minimum, maximum];
 }
 function getRepeatKeyword(repeatBody) {
-  const repeatCount = (0, import_ts_extras4.arrayFirst)(splitTopLevelCommas(repeatBody))?.trim().toLowerCase();
+  const repeatCount = (0, import_ts_extras7.arrayFirst)(splitTopLevelCommas(repeatBody))?.trim().toLowerCase();
   if (repeatCount === "auto-fill" || repeatCount === "auto-fit") {
     return repeatCount;
   }
@@ -692,18 +897,18 @@ function isFixedTrackBreadth(value) {
   }
   const match = lengthPercentagePattern.exec(normalizedValue);
   const unit = match?.groups?.["unit"];
-  return unit === "%" || (0, import_ts_extras4.isDefined)(unit) && (0, import_ts_extras4.setHas)(cssLengthUnits, unit);
+  return unit === "%" || (0, import_ts_extras7.isDefined)(unit) && (0, import_ts_extras7.setHas)(cssLengthUnits, unit);
 }
 function isFlexTrackBreadth(value) {
   return /^[+\-]?(?:\d+|\d*\.\d+)fr$/v.test(value);
 }
 function isIntrinsicTrackBreadth(value) {
   const normalizedValue = value.toLowerCase();
-  return (0, import_ts_extras4.setHas)(invalidBareAutoRepeatTrackTokens, normalizedValue);
+  return (0, import_ts_extras7.setHas)(invalidBareAutoRepeatTrackTokens, normalizedValue);
 }
 function isInvalidAutoRepeatMinmax(token) {
   const args = getMinmaxArguments(token);
-  if (!(0, import_ts_extras4.isDefined)(args)) {
+  if (!(0, import_ts_extras7.isDefined)(args)) {
     return false;
   }
   const [minimum, maximum] = args;
@@ -712,28 +917,28 @@ function isInvalidAutoRepeatMinmax(token) {
 function isLineNameList2(token) {
   return token.startsWith("[") && token.endsWith("]");
 }
-var ruleFunction4 = (primary) => (root, result) => {
-  if (!validateOptions4(result, ruleName4, {
+var ruleFunction6 = (primary) => (root, result) => {
+  if (!validateOptions6(result, ruleName6, {
     actual: primary,
     possible: [true]
   })) {
     return;
   }
   root.walkDecls((declaration) => {
-    if (!(0, import_ts_extras4.setHas)(trackTemplateProperties, declaration.prop.toLowerCase())) {
+    if (!(0, import_ts_extras7.setHas)(trackTemplateProperties, declaration.prop.toLowerCase())) {
       return;
     }
     for (const repeatCall of findValueFunctionCalls(declaration.value, "repeat")) {
       const repeatKeyword = getRepeatKeyword(repeatCall.body);
-      if ((0, import_ts_extras4.isDefined)(repeatKeyword)) {
+      if ((0, import_ts_extras7.isDefined)(repeatKeyword)) {
         const trackList = splitTopLevelCommas(repeatCall.body).slice(1).join(",");
         const invalidTrack = getInvalidAutoRepeatTrack(trackList);
-        if ((0, import_ts_extras4.isDefined)(invalidTrack)) {
-          report4({
-            message: messages4.rejected(invalidTrack, repeatKeyword),
+        if ((0, import_ts_extras7.isDefined)(invalidTrack)) {
+          report6({
+            message: messages6.rejected(invalidTrack, repeatKeyword),
             node: declaration,
             result,
-            ruleName: ruleName4,
+            ruleName: ruleName6,
             word: invalidTrack
           });
         }
@@ -741,23 +946,23 @@ var ruleFunction4 = (primary) => (root, result) => {
     }
   });
 };
-var rule4 = createStylelintRule({
-  docs: docs4,
-  messages: messages4,
-  rule: ruleFunction4,
-  ruleName: ruleName4
+var rule6 = createStylelintRule({
+  docs: docs6,
+  messages: messages6,
+  rule: ruleFunction6,
+  ruleName: ruleName6
 });
-var no_invalid_auto_repeat_default = rule4;
+var no_invalid_auto_repeat_default = rule6;
 
 // dist/rules/no-invalid-minmax.js
-var import_stylelint6 = __toESM(require("stylelint"), 1);
-var import_ts_extras5 = require("ts-extras");
-var { report: report5, ruleMessages: ruleMessages5, validateOptions: validateOptions5 } = import_stylelint6.default.utils;
-var ruleName5 = createRuleName("no-invalid-minmax");
-var messages5 = ruleMessages5(ruleName5, {
+var import_stylelint8 = __toESM(require("stylelint"), 1);
+var import_ts_extras8 = require("ts-extras");
+var { report: report7, ruleMessages: ruleMessages7, validateOptions: validateOptions7 } = import_stylelint8.default.utils;
+var ruleName7 = createRuleName("no-invalid-minmax");
+var messages7 = ruleMessages7(ruleName7, {
   rejected: (minimum) => `Do not use flexible track breadth \`${minimum}\` as the minimum in \`minmax()\`; use an inflexible minimum such as \`0\`, a length, or a percentage.`
 });
-var docs5 = {
+var docs7 = {
   description: "Disallow flexible `fr` values as the minimum argument in CSS Grid `minmax()` track sizes.",
   recommended: true,
   url: createRuleDocsUrl("no-invalid-minmax")
@@ -771,185 +976,423 @@ var gridTrackProperties = /* @__PURE__ */ new Set([
 function isFlexTrackBreadth2(value) {
   return /^[+\-]?(?:\d+|\d*\.\d+)fr$/v.test(value.toLowerCase());
 }
-var ruleFunction5 = (primary) => (root, result) => {
-  if (!validateOptions5(result, ruleName5, {
+var ruleFunction7 = (primary) => (root, result) => {
+  if (!validateOptions7(result, ruleName7, {
     actual: primary,
     possible: [true]
   })) {
     return;
   }
   root.walkDecls((declaration) => {
-    if (!(0, import_ts_extras5.setHas)(gridTrackProperties, declaration.prop.toLowerCase())) {
+    if (!(0, import_ts_extras8.setHas)(gridTrackProperties, declaration.prop.toLowerCase())) {
       return;
     }
     for (const minmaxCall of findValueFunctionCalls(declaration.value, "minmax")) {
-      const minimum = (0, import_ts_extras5.arrayFirst)(splitTopLevelCommas(minmaxCall.body))?.trim();
-      if ((0, import_ts_extras5.isDefined)(minimum) && isFlexTrackBreadth2(minimum)) {
-        report5({
-          message: messages5.rejected(minimum),
+      const minimum = (0, import_ts_extras8.arrayFirst)(splitTopLevelCommas(minmaxCall.body))?.trim();
+      if ((0, import_ts_extras8.isDefined)(minimum) && isFlexTrackBreadth2(minimum)) {
+        report7({
+          message: messages7.rejected(minimum),
           node: declaration,
           result,
-          ruleName: ruleName5,
+          ruleName: ruleName7,
           word: minimum
         });
       }
     }
   });
 };
-var rule5 = createStylelintRule({
-  docs: docs5,
-  messages: messages5,
-  rule: ruleFunction5,
-  ruleName: ruleName5
+var rule7 = createStylelintRule({
+  docs: docs7,
+  messages: messages7,
+  rule: ruleFunction7,
+  ruleName: ruleName7
 });
-var no_invalid_minmax_default = rule5;
+var no_invalid_minmax_default = rule7;
 
-// dist/rules/no-mismatched-template-rows.js
-var import_stylelint7 = __toESM(require("stylelint"), 1);
-var import_ts_extras6 = require("ts-extras");
-var { report: report6, ruleMessages: ruleMessages6, validateOptions: validateOptions6 } = import_stylelint7.default.utils;
-var ruleName6 = createRuleName("no-mismatched-template-rows");
-var messages6 = ruleMessages6(ruleName6, {
-  rejected: (areaRows, trackRows) => `\`grid-template-areas\` defines ${String(areaRows)} rows, but sibling \`grid-template-rows\` defines ${String(trackRows)} tracks.`
+// dist/rules/no-invalid-repeat-count.js
+var import_stylelint9 = __toESM(require("stylelint"), 1);
+var import_ts_extras9 = require("ts-extras");
+var { report: report8, ruleMessages: ruleMessages8, validateOptions: validateOptions8 } = import_stylelint9.default.utils;
+var ruleName8 = createRuleName("no-invalid-repeat-count");
+var messages8 = ruleMessages8(ruleName8, {
+  rejected: (count) => `Use a positive integer repeat count; \`${count}\` is not a valid fixed \`repeat()\` count.`
 });
-var docs6 = {
-  description: "Require `grid-template-rows` track count to match `grid-template-areas` row count.",
+var docs8 = {
+  description: "Disallow invalid fixed repeat counts in CSS Grid track templates.",
   recommended: true,
-  url: createRuleDocsUrl("no-mismatched-template-rows")
+  url: createRuleDocsUrl("no-invalid-repeat-count")
 };
-var ruleFunction6 = (primary) => (root, result) => {
-  if (!validateOptions6(result, ruleName6, {
+var trackTemplateProperties2 = /* @__PURE__ */ new Set([
+  "grid-template-columns",
+  "grid-template-rows"
+]);
+var nonFixedRepeatCounts = /* @__PURE__ */ new Set([
+  "auto-fill",
+  "auto-fit"
+]);
+var integerPattern = /^\+?\d+$/v;
+var numericPattern = /^[+\-]?(?:\d+|\d*\.\d+)$/v;
+function getInvalidRepeatCount(repeatBody) {
+  const count = (0, import_ts_extras9.arrayFirst)(splitTopLevelCommas(repeatBody))?.trim();
+  if (!(0, import_ts_extras9.isDefined)(count)) {
+    return void 0;
+  }
+  const normalizedCount = count.toLowerCase();
+  if ((0, import_ts_extras9.setHas)(nonFixedRepeatCounts, normalizedCount)) {
+    return void 0;
+  }
+  return numericPattern.test(count) && !isPositiveIntegerToken(count) ? count : void 0;
+}
+function isPositiveIntegerToken(value) {
+  return integerPattern.test(value) && Number.parseInt(value, 10) > 0;
+}
+var ruleFunction8 = (primary) => (root, result) => {
+  if (!validateOptions8(result, ruleName8, {
     actual: primary,
     possible: [true]
   })) {
     return;
   }
-  for (const template of collectGridTemplateAreas(root)) {
-    if ((0, import_ts_extras6.isEmpty)(template.diagnostics)) {
-      const rowsDeclaration = findSiblingDeclaration(template.declaration, "grid-template-rows");
-      const trackRows = (0, import_ts_extras6.isDefined)(rowsDeclaration) ? countGridTracks(rowsDeclaration.value) : void 0;
-      if ((0, import_ts_extras6.isDefined)(rowsDeclaration) && (0, import_ts_extras6.isDefined)(trackRows) && trackRows !== template.rows.length) {
-        report6({
-          message: messages6.rejected(template.rows.length, trackRows),
-          node: rowsDeclaration,
+  root.walkDecls((declaration) => {
+    if (!(0, import_ts_extras9.setHas)(trackTemplateProperties2, declaration.prop.toLowerCase())) {
+      return;
+    }
+    for (const repeatCall of findValueFunctionCalls(declaration.value, "repeat")) {
+      const invalidCount = getInvalidRepeatCount(repeatCall.body);
+      if ((0, import_ts_extras9.isDefined)(invalidCount)) {
+        report8({
+          message: messages8.rejected(invalidCount),
+          node: declaration,
           result,
-          ruleName: ruleName6
+          ruleName: ruleName8,
+          word: invalidCount
         });
       }
     }
-  }
+  });
 };
-var rule6 = createStylelintRule({
-  docs: docs6,
-  messages: messages6,
-  rule: ruleFunction6,
-  ruleName: ruleName6
+var rule8 = createStylelintRule({
+  docs: docs8,
+  messages: messages8,
+  rule: ruleFunction8,
+  ruleName: ruleName8
 });
-var no_mismatched_template_rows_default = rule6;
+var no_invalid_repeat_count_default = rule8;
 
-// dist/rules/no-overlapping-areas.js
-var import_stylelint8 = __toESM(require("stylelint"), 1);
-var import_ts_extras7 = require("ts-extras");
-var { report: report7, ruleMessages: ruleMessages7, validateOptions: validateOptions7 } = import_stylelint8.default.utils;
-var ruleName7 = createRuleName("no-overlapping-areas");
-var messages7 = ruleMessages7(ruleName7, {
-  rejected: (areaName, firstSelector) => `Grid area "${areaName}" is assigned by more than one selector; it may overlap the earlier "${firstSelector}" item at runtime.`
+// dist/rules/no-invalid-span.js
+var import_stylelint10 = __toESM(require("stylelint"), 1);
+var { report: report9, ruleMessages: ruleMessages9, validateOptions: validateOptions9 } = import_stylelint10.default.utils;
+var ruleName9 = createRuleName("no-invalid-span");
+var messages9 = ruleMessages9(ruleName9, {
+  rejected: (span) => `Use a positive Grid span count; \`span ${String(span)}\` cannot place a grid item.`
 });
-var docs7 = {
-  description: "Disallow multiple selectors assigning the same single-name `grid-area` value in one stylesheet.",
-  recommended: false,
-  url: createRuleDocsUrl("no-overlapping-areas")
+var docs9 = {
+  description: "Disallow non-positive `span` counts in CSS Grid placement declarations.",
+  recommended: true,
+  url: createRuleDocsUrl("no-invalid-span")
 };
-var ruleFunction7 = (primary) => (root, result) => {
-  if (!validateOptions7(result, ruleName7, {
+var ruleFunction9 = (primary) => (root, result) => {
+  if (!validateOptions9(result, ruleName9, {
     actual: primary,
     possible: [true]
   })) {
     return;
   }
-  const firstUsageByName = /* @__PURE__ */ new Map();
-  for (const usage of collectGridAreaUsages(root)) {
-    const firstUsage = firstUsageByName.get(usage.name);
-    if ((0, import_ts_extras7.isDefined)(firstUsage)) {
-      report7({
-        message: messages7.rejected(usage.name, firstUsage.selector ?? firstUsage.name),
-        node: usage.declaration,
-        result,
-        ruleName: ruleName7,
-        word: usage.name
-      });
-    } else {
-      firstUsageByName.set(usage.name, usage);
+  root.walkDecls((declaration) => {
+    if (!isGridPlacementDeclaration(declaration)) {
+      return;
+    }
+    for (const slot of getGridPlacementSlots(declaration.value)) {
+      for (const span of getGridLineSpanCounts(slot)) {
+        if (span <= 0) {
+          report9({
+            message: messages9.rejected(span),
+            node: declaration,
+            result,
+            ruleName: ruleName9,
+            word: String(span)
+          });
+        }
+      }
+    }
+  });
+};
+var rule9 = createStylelintRule({
+  docs: docs9,
+  messages: messages9,
+  rule: ruleFunction9,
+  ruleName: ruleName9
+});
+var no_invalid_span_default = rule9;
+
+// dist/rules/no-mismatched-template-rows.js
+var import_stylelint11 = __toESM(require("stylelint"), 1);
+var import_ts_extras10 = require("ts-extras");
+var { report: report10, ruleMessages: ruleMessages10, validateOptions: validateOptions10 } = import_stylelint11.default.utils;
+var ruleName10 = createRuleName("no-mismatched-template-rows");
+var messages10 = ruleMessages10(ruleName10, {
+  rejected: (areaRows, trackRows) => `\`grid-template-areas\` defines ${String(areaRows)} rows, but sibling \`grid-template-rows\` defines ${String(trackRows)} tracks.`
+});
+var docs10 = {
+  description: "Require `grid-template-rows` track count to match `grid-template-areas` row count.",
+  recommended: true,
+  url: createRuleDocsUrl("no-mismatched-template-rows")
+};
+var ruleFunction10 = (primary) => (root, result) => {
+  if (!validateOptions10(result, ruleName10, {
+    actual: primary,
+    possible: [true]
+  })) {
+    return;
+  }
+  for (const template of collectGridTemplateAreas(root)) {
+    if ((0, import_ts_extras10.isEmpty)(template.diagnostics)) {
+      const rowsDeclaration = findSiblingDeclaration(template.declaration, "grid-template-rows");
+      const trackRows = (0, import_ts_extras10.isDefined)(rowsDeclaration) ? countGridTracks(rowsDeclaration.value) : void 0;
+      if ((0, import_ts_extras10.isDefined)(rowsDeclaration) && (0, import_ts_extras10.isDefined)(trackRows) && trackRows !== template.rows.length) {
+        report10({
+          message: messages10.rejected(template.rows.length, trackRows),
+          node: rowsDeclaration,
+          result,
+          ruleName: ruleName10
+        });
+      }
     }
   }
 };
-var rule7 = createStylelintRule({
-  docs: docs7,
-  messages: messages7,
-  rule: ruleFunction7,
-  ruleName: ruleName7
+var rule10 = createStylelintRule({
+  docs: docs10,
+  messages: messages10,
+  rule: ruleFunction10,
+  ruleName: ruleName10
+});
+var no_mismatched_template_rows_default = rule10;
+
+// dist/rules/no-overlapping-areas.js
+var import_stylelint12 = __toESM(require("stylelint"), 1);
+var import_ts_extras11 = require("ts-extras");
+var { report: report11, ruleMessages: ruleMessages11, validateOptions: validateOptions11 } = import_stylelint12.default.utils;
+var ruleName11 = createRuleName("no-overlapping-areas");
+var messages11 = ruleMessages11(ruleName11, {
+  rejected: (areaName, firstSelector) => `Grid area "${areaName}" is assigned by more than one selector; it may overlap the earlier "${firstSelector}" item at runtime.`
+});
+var docs11 = {
+  description: "Disallow multiple selectors assigning the same single-name `grid-area` value in one stylesheet.",
+  recommended: false,
+  url: createRuleDocsUrl("no-overlapping-areas")
+};
+var ruleFunction11 = (primary) => (root, result) => {
+  if (!validateOptions11(result, ruleName11, {
+    actual: primary,
+    possible: [true]
+  })) {
+    return;
+  }
+  const firstUsageByName = /* @__PURE__ */ new Map();
+  for (const usage of collectGridAreaUsages(root)) {
+    const firstUsage = firstUsageByName.get(usage.name);
+    if ((0, import_ts_extras11.isDefined)(firstUsage)) {
+      report11({
+        message: messages11.rejected(usage.name, firstUsage.selector ?? firstUsage.name),
+        node: usage.declaration,
+        result,
+        ruleName: ruleName11,
+        word: usage.name
+      });
+    } else {
+      firstUsageByName.set(usage.name, usage);
+    }
+  }
+};
+var rule11 = createStylelintRule({
+  docs: docs11,
+  messages: messages11,
+  rule: ruleFunction11,
+  ruleName: ruleName11
+});
+var no_overlapping_areas_default = rule11;
+
+// dist/rules/no-reversed-placement-lines.js
+var import_stylelint13 = __toESM(require("stylelint"), 1);
+var import_ts_extras12 = require("ts-extras");
+var { report: report12, ruleMessages: ruleMessages12, validateOptions: validateOptions12 } = import_stylelint13.default.utils;
+var ruleName12 = createRuleName("no-reversed-placement-lines");
+var messages12 = ruleMessages12(ruleName12, {
+  rejected: (propertyName, start, end) => `Use an end line after the start line for \`${propertyName}\`; \`${String(end)}\` is not after \`${String(start)}\`.`
+});
+var docs12 = {
+  description: "Disallow reversed or zero-width numeric CSS Grid placement line ranges.",
+  recommended: true,
+  url: createRuleDocsUrl("no-reversed-placement-lines")
+};
+var shorthandProperties = /* @__PURE__ */ new Set([
+  "grid-column",
+  "grid-row"
+]);
+var gridAreaPropertyName = "grid-area";
+var longhandPairs = [
+  {
+    end: "grid-column-end",
+    name: "grid-column",
+    start: "grid-column-start"
+  },
+  {
+    end: "grid-row-end",
+    name: "grid-row",
+    start: "grid-row-start"
+  }
+];
+function getComparableLinePair(startValue, endValue) {
+  const start = parseStandaloneGridLineInteger(startValue);
+  const end = parseStandaloneGridLineInteger(endValue);
+  if (!(0, import_ts_extras12.isDefined)(start) || !(0, import_ts_extras12.isDefined)(end) || start === 0 || end === 0) {
+    return void 0;
+  }
+  if (Math.sign(start) !== Math.sign(end)) {
+    return void 0;
+  }
+  return [start, end];
+}
+function isReversedOrZeroWidth(pair) {
+  const [start, end] = pair;
+  return end <= start;
+}
+var ruleFunction12 = (primary) => (root, result) => {
+  if (!validateOptions12(result, ruleName12, {
+    actual: primary,
+    possible: [true]
+  })) {
+    return;
+  }
+  root.walkDecls((declaration) => {
+    const propertyName = declaration.prop.toLowerCase();
+    if (!(0, import_ts_extras12.setHas)(shorthandProperties, propertyName) && propertyName !== gridAreaPropertyName) {
+      return;
+    }
+    const slots = getGridPlacementSlots(declaration.value);
+    const shorthandPairs = propertyName === gridAreaPropertyName ? [
+      {
+        endValue: (0, import_ts_extras12.arrayAt)(slots, 2),
+        propertyName: "grid-row",
+        startValue: (0, import_ts_extras12.arrayFirst)(slots)
+      },
+      {
+        endValue: (0, import_ts_extras12.arrayAt)(slots, 3),
+        propertyName: "grid-column",
+        startValue: (0, import_ts_extras12.arrayAt)(slots, 1)
+      }
+    ] : [
+      {
+        endValue: (0, import_ts_extras12.arrayAt)(slots, 1),
+        propertyName,
+        startValue: (0, import_ts_extras12.arrayFirst)(slots)
+      }
+    ];
+    for (const shorthandPair of shorthandPairs) {
+      const { endValue, propertyName: pairName, startValue } = shorthandPair;
+      if ((0, import_ts_extras12.isDefined)(startValue) && (0, import_ts_extras12.isDefined)(endValue)) {
+        const pair = getComparableLinePair(startValue, endValue);
+        if ((0, import_ts_extras12.isDefined)(pair) && isReversedOrZeroWidth(pair)) {
+          const [start, end] = pair;
+          report12({
+            message: messages12.rejected(pairName, start, end),
+            node: declaration,
+            result,
+            ruleName: ruleName12,
+            word: endValue
+          });
+        }
+      }
+    }
+  });
+  root.walkRules((ruleNode) => {
+    const declarations = getDirectDeclarations(ruleNode);
+    for (const pair of longhandPairs) {
+      const startDeclaration = declarations.find((declaration) => declaration.prop.toLowerCase() === pair.start);
+      const endDeclaration = declarations.find((declaration) => declaration.prop.toLowerCase() === pair.end);
+      if ((0, import_ts_extras12.isDefined)(startDeclaration) && (0, import_ts_extras12.isDefined)(endDeclaration)) {
+        const linePair = getComparableLinePair(startDeclaration.value, endDeclaration.value);
+        if ((0, import_ts_extras12.isDefined)(linePair) && isReversedOrZeroWidth(linePair)) {
+          const [start, end] = linePair;
+          report12({
+            message: messages12.rejected(pair.name, start, end),
+            node: endDeclaration,
+            result,
+            ruleName: ruleName12,
+            word: endDeclaration.value
+          });
+        }
+      }
+    }
+  });
+};
+var rule12 = createStylelintRule({
+  docs: docs12,
+  messages: messages12,
+  rule: ruleFunction12,
+  ruleName: ruleName12
 });
-var no_overlapping_areas_default = rule7;
+var no_reversed_placement_lines_default = rule12;
 
 // dist/rules/no-unknown-areas.js
-var import_stylelint9 = __toESM(require("stylelint"), 1);
-var import_ts_extras8 = require("ts-extras");
-var { report: report8, ruleMessages: ruleMessages8, validateOptions: validateOptions8 } = import_stylelint9.default.utils;
-var ruleName8 = createRuleName("no-unknown-areas");
-var messages8 = ruleMessages8(ruleName8, {
+var import_stylelint14 = __toESM(require("stylelint"), 1);
+var import_ts_extras13 = require("ts-extras");
+var { report: report13, ruleMessages: ruleMessages13, validateOptions: validateOptions13 } = import_stylelint14.default.utils;
+var ruleName13 = createRuleName("no-unknown-areas");
+var messages13 = ruleMessages13(ruleName13, {
   rejected: (areaName) => `Grid area "${areaName}" is referenced by \`grid-area\` but is not declared in any \`grid-template-areas\` template in this stylesheet.`
 });
-var docs8 = {
+var docs13 = {
   description: "Disallow single-name `grid-area` references that do not match any named area declared in the same stylesheet.",
   recommended: true,
   url: createRuleDocsUrl("no-unknown-areas")
 };
-var ruleFunction8 = (primary) => (root, result) => {
-  if (!validateOptions8(result, ruleName8, {
+var ruleFunction13 = (primary) => (root, result) => {
+  if (!validateOptions13(result, ruleName13, {
     actual: primary,
     possible: [true]
   })) {
     return;
   }
-  const declaredAreaNames = new Set(collectGridTemplateAreas(root).flatMap((template) => (0, import_ts_extras8.isEmpty)(template.diagnostics) ? template.areaNames : []));
+  const declaredAreaNames = new Set(collectGridTemplateAreas(root).flatMap((template) => (0, import_ts_extras13.isEmpty)(template.diagnostics) ? template.areaNames : []));
   if (declaredAreaNames.size === 0) {
     return;
   }
   for (const usage of collectGridAreaUsages(root)) {
-    if (!(0, import_ts_extras8.setHas)(declaredAreaNames, usage.name)) {
-      report8({
-        message: messages8.rejected(usage.name),
+    if (!(0, import_ts_extras13.setHas)(declaredAreaNames, usage.name)) {
+      report13({
+        message: messages13.rejected(usage.name),
         node: usage.declaration,
         result,
-        ruleName: ruleName8,
+        ruleName: ruleName13,
         word: usage.name
       });
     }
   }
 };
-var rule8 = createStylelintRule({
-  docs: docs8,
-  messages: messages8,
-  rule: ruleFunction8,
-  ruleName: ruleName8
+var rule13 = createStylelintRule({
+  docs: docs13,
+  messages: messages13,
+  rule: ruleFunction13,
+  ruleName: ruleName13
 });
-var no_unknown_areas_default = rule8;
+var no_unknown_areas_default = rule13;
 
 // dist/rules/no-unused-areas.js
-var import_stylelint10 = __toESM(require("stylelint"), 1);
-var import_ts_extras9 = require("ts-extras");
-var { report: report9, ruleMessages: ruleMessages9, validateOptions: validateOptions9 } = import_stylelint10.default.utils;
-var ruleName9 = createRuleName("no-unused-areas");
-var messages9 = ruleMessages9(ruleName9, {
+var import_stylelint15 = __toESM(require("stylelint"), 1);
+var import_ts_extras14 = require("ts-extras");
+var { report: report14, ruleMessages: ruleMessages14, validateOptions: validateOptions14 } = import_stylelint15.default.utils;
+var ruleName14 = createRuleName("no-unused-areas");
+var messages14 = ruleMessages14(ruleName14, {
   rejected: (areaName) => `Grid template area "${areaName}" is declared but no single-name \`grid-area: ${areaName}\` declaration exists in this stylesheet.`
 });
-var docs9 = {
+var docs14 = {
   description: "Disallow named template areas that are never referenced by a single-name `grid-area` declaration in the same stylesheet.",
   recommended: false,
   url: createRuleDocsUrl("no-unused-areas")
 };
-var ruleFunction9 = (primary) => (root, result) => {
-  if (!validateOptions9(result, ruleName9, {
+var ruleFunction14 = (primary) => (root, result) => {
+  if (!validateOptions14(result, ruleName14, {
     actual: primary,
     possible: [true]
   })) {
@@ -957,14 +1400,14 @@ var ruleFunction9 = (primary) => (root, result) => {
   }
   const usedAreaNames = new Set(collectGridAreaUsages(root).map((usage) => usage.name));
   for (const template of collectGridTemplateAreas(root)) {
-    if ((0, import_ts_extras9.isEmpty)(template.diagnostics)) {
+    if ((0, import_ts_extras14.isEmpty)(template.diagnostics)) {
       for (const areaName of template.areaNames) {
-        if (!(0, import_ts_extras9.setHas)(usedAreaNames, areaName)) {
-          report9({
-            message: messages9.rejected(areaName),
+        if (!(0, import_ts_extras14.setHas)(usedAreaNames, areaName)) {
+          report14({
+            message: messages14.rejected(areaName),
             node: template.declaration,
             result,
-            ruleName: ruleName9,
+            ruleName: ruleName14,
             word: areaName
           });
         }
@@ -972,23 +1415,68 @@ var ruleFunction9 = (primary) => (root, result) => {
     }
   }
 };
-var rule9 = createStylelintRule({
-  docs: docs9,
-  messages: messages9,
-  rule: ruleFunction9,
-  ruleName: ruleName9
+var rule14 = createStylelintRule({
+  docs: docs14,
+  messages: messages14,
+  rule: ruleFunction14,
+  ruleName: ruleName14
+});
+var no_unused_areas_default = rule14;
+
+// dist/rules/no-zero-grid-lines.js
+var import_stylelint16 = __toESM(require("stylelint"), 1);
+var import_ts_extras15 = require("ts-extras");
+var { report: report15, ruleMessages: ruleMessages15, validateOptions: validateOptions15 } = import_stylelint16.default.utils;
+var ruleName15 = createRuleName("no-zero-grid-lines");
+var messages15 = ruleMessages15(ruleName15, {
+  rejected: () => "Do not use Grid line `0`; CSS Grid line numbering starts at `1` and `-1`."
 });
-var no_unused_areas_default = rule9;
+var docs15 = {
+  description: "Disallow line `0` in CSS Grid placement declarations.",
+  recommended: true,
+  url: createRuleDocsUrl("no-zero-grid-lines")
+};
+var ruleFunction15 = (primary) => (root, result) => {
+  if (!validateOptions15(result, ruleName15, {
+    actual: primary,
+    possible: [true]
+  })) {
+    return;
+  }
+  root.walkDecls((declaration) => {
+    if (!isGridPlacementDeclaration(declaration)) {
+      return;
+    }
+    for (const slot of getGridPlacementSlots(declaration.value)) {
+      if ((0, import_ts_extras15.arrayIncludes)(getGridLineIntegerTokens(slot), 0)) {
+        report15({
+          message: messages15.rejected(),
+          node: declaration,
+          result,
+          ruleName: ruleName15,
+          word: "0"
+        });
+      }
+    }
+  });
+};
+var rule15 = createStylelintRule({
+  docs: docs15,
+  messages: messages15,
+  rule: ruleFunction15,
+  ruleName: ruleName15
+});
+var no_zero_grid_lines_default = rule15;
 
 // dist/rules/prefer-gap-properties.js
-var import_stylelint11 = __toESM(require("stylelint"), 1);
-var import_ts_extras10 = require("ts-extras");
-var { report: report10, ruleMessages: ruleMessages10, validateOptions: validateOptions10 } = import_stylelint11.default.utils;
-var ruleName10 = createRuleName("prefer-gap-properties");
-var messages10 = ruleMessages10(ruleName10, {
+var import_stylelint17 = __toESM(require("stylelint"), 1);
+var import_ts_extras16 = require("ts-extras");
+var { report: report16, ruleMessages: ruleMessages16, validateOptions: validateOptions16 } = import_stylelint17.default.utils;
+var ruleName16 = createRuleName("prefer-gap-properties");
+var messages16 = ruleMessages16(ruleName16, {
   rejected: (propertyName, replacement) => `Prefer \`${replacement}\` over legacy \`${propertyName}\`.`
 });
-var docs10 = {
+var docs16 = {
   description: "Prefer modern `gap`, `row-gap`, and `column-gap` properties over legacy grid gap aliases.",
   recommended: true,
   url: createRuleDocsUrl("prefer-gap-properties")
@@ -1001,8 +1489,8 @@ var replacements = {
 function getReplacement(declaration) {
   return replacements[declaration.prop.toLowerCase()];
 }
-var ruleFunction10 = (primary) => (root, result) => {
-  if (!validateOptions10(result, ruleName10, {
+var ruleFunction16 = (primary) => (root, result) => {
+  if (!validateOptions16(result, ruleName16, {
     actual: primary,
     possible: [true]
   })) {
@@ -1010,41 +1498,93 @@ var ruleFunction10 = (primary) => (root, result) => {
   }
   root.walkDecls((declaration) => {
     const replacement = getReplacement(declaration);
-    if (!(0, import_ts_extras10.isDefined)(replacement)) {
+    if (!(0, import_ts_extras16.isDefined)(replacement)) {
       return;
     }
-    report10({
+    report16({
       fix: () => {
         declaration.prop = replacement;
       },
-      message: messages10.rejected(declaration.prop, replacement),
+      message: messages16.rejected(declaration.prop, replacement),
       node: declaration,
       result,
-      ruleName: ruleName10,
+      ruleName: ruleName16,
       word: declaration.prop
     });
   });
 };
-var rule10 = createStylelintRule({
-  docs: docs10,
-  messages: messages10,
+var rule16 = createStylelintRule({
+  docs: docs16,
+  messages: messages16,
   meta: {
     fixable: true
   },
-  rule: ruleFunction10,
-  ruleName: ruleName10
+  rule: ruleFunction16,
+  ruleName: ruleName16
 });
-var prefer_gap_properties_default = rule10;
+var prefer_gap_properties_default = rule16;
+
+// dist/rules/prefer-minmax-zero-fr.js
+var import_stylelint18 = __toESM(require("stylelint"), 1);
+var import_ts_extras17 = require("ts-extras");
+var { report: report17, ruleMessages: ruleMessages17, validateOptions: validateOptions17 } = import_stylelint18.default.utils;
+var ruleName17 = createRuleName("prefer-minmax-zero-fr");
+var messages17 = ruleMessages17(ruleName17, {
+  rejected: (track) => `Wrap bare flexible column track \`${track}\` in \`minmax(0, ${track})\` to avoid content-driven overflow.`
+});
+var docs17 = {
+  description: "Prefer `minmax(0, <flex>)` for bare flexible CSS Grid column tracks.",
+  recommended: false,
+  url: createRuleDocsUrl("prefer-minmax-zero-fr")
+};
+var ignoredTrackKeywords = /* @__PURE__ */ new Set([
+  "masonry",
+  "none",
+  "subgrid"
+]);
+var flexTrackPattern = /^\+?(?:\d+|\d*\.\d+)fr$/v;
+function isBareFlexibleTrack(token) {
+  const normalizedToken = token.toLowerCase();
+  return !(0, import_ts_extras17.setHas)(ignoredTrackKeywords, normalizedToken) && flexTrackPattern.test(normalizedToken);
+}
+var ruleFunction17 = (primary) => (root, result) => {
+  if (!validateOptions17(result, ruleName17, {
+    actual: primary,
+    possible: [true]
+  })) {
+    return;
+  }
+  root.walkDecls("grid-template-columns", (declaration) => {
+    for (const token of splitTopLevelWhitespace(declaration.value)) {
+      if (isBareFlexibleTrack(token)) {
+        report17({
+          message: messages17.rejected(token),
+          node: declaration,
+          result,
+          ruleName: ruleName17,
+          word: token
+        });
+      }
+    }
+  });
+};
+var rule17 = createStylelintRule({
+  docs: docs17,
+  messages: messages17,
+  rule: ruleFunction17,
+  ruleName: ruleName17
+});
+var prefer_minmax_zero_fr_default = rule17;
 
 // dist/rules/require-explicit-rows-with-column-flow.js
-var import_stylelint12 = __toESM(require("stylelint"), 1);
-var import_ts_extras11 = require("ts-extras");
-var { report: report11, ruleMessages: ruleMessages11, validateOptions: validateOptions11 } = import_stylelint12.default.utils;
-var ruleName11 = createRuleName("require-explicit-rows-with-column-flow");
-var messages11 = ruleMessages11(ruleName11, {
+var import_stylelint19 = __toESM(require("stylelint"), 1);
+var import_ts_extras18 = require("ts-extras");
+var { report: report18, ruleMessages: ruleMessages18, validateOptions: validateOptions18 } = import_stylelint19.default.utils;
+var ruleName18 = createRuleName("require-explicit-rows-with-column-flow");
+var messages18 = ruleMessages18(ruleName18, {
   rejected: () => "Pair `grid-auto-flow: column` with explicit row sizing in the same block, such as `grid-template-rows` or `grid-auto-rows`."
 });
-var docs11 = {
+var docs18 = {
   description: "Require explicit row sizing when a rule uses `grid-auto-flow: column`.",
   recommended: false,
   url: createRuleDocsUrl("require-explicit-rows-with-column-flow")
@@ -1052,8 +1592,8 @@ var docs11 = {
 function hasColumnFlow(value) {
   return splitTopLevelWhitespace(value).some((token) => token.toLowerCase() === "column");
 }
-var ruleFunction11 = (primary) => (root, result) => {
-  if (!validateOptions11(result, ruleName11, {
+var ruleFunction18 = (primary) => (root, result) => {
+  if (!validateOptions18(result, ruleName18, {
     actual: primary,
     possible: [true]
   })) {
@@ -1063,56 +1603,116 @@ var ruleFunction11 = (primary) => (root, result) => {
     if (!hasColumnFlow(declaration.value)) {
       return;
     }
-    const hasExplicitRows = (0, import_ts_extras11.isDefined)(findSiblingDeclaration(declaration, "grid-template-rows")) || (0, import_ts_extras11.isDefined)(findSiblingDeclaration(declaration, "grid-auto-rows"));
+    const hasExplicitRows = (0, import_ts_extras18.isDefined)(findSiblingDeclaration(declaration, "grid-template-rows")) || (0, import_ts_extras18.isDefined)(findSiblingDeclaration(declaration, "grid-auto-rows"));
     if (hasExplicitRows) {
       return;
     }
-    report11({
-      message: messages11.rejected(),
+    report18({
+      message: messages18.rejected(),
       node: declaration,
       result,
-      ruleName: ruleName11,
+      ruleName: ruleName18,
       word: "column"
     });
   });
 };
-var rule11 = createStylelintRule({
-  docs: docs11,
-  messages: messages11,
-  rule: ruleFunction11,
-  ruleName: ruleName11
+var rule18 = createStylelintRule({
+  docs: docs18,
+  messages: messages18,
+  rule: ruleFunction18,
+  ruleName: ruleName18
 });
-var require_explicit_rows_with_column_flow_default = rule11;
+var require_explicit_rows_with_column_flow_default = rule18;
+
+// dist/rules/require-explicit-tracks-with-areas.js
+var import_stylelint20 = __toESM(require("stylelint"), 1);
+var import_ts_extras19 = require("ts-extras");
+var { report: report19, ruleMessages: ruleMessages19, validateOptions: validateOptions19 } = import_stylelint20.default.utils;
+var ruleName19 = createRuleName("require-explicit-tracks-with-areas");
+var messages19 = ruleMessages19(ruleName19, {
+  rejected: (propertyName) => `Pair \`grid-template-areas\` with \`${propertyName}\` in the same block so named areas have explicit track sizing.`
+});
+var docs19 = {
+  description: "Require explicit track sizing alongside CSS Grid named area templates.",
+  recommended: false,
+  url: createRuleDocsUrl("require-explicit-tracks-with-areas")
+};
+var ruleFunction19 = (primary, secondary) => (root, result) => {
+  if (!validateOptions19(result, ruleName19, {
+    actual: primary,
+    possible: [true]
+  }, {
+    actual: secondary,
+    optional: true,
+    possible: {
+      columns: [true, false],
+      rows: [true, false]
+    }
+  })) {
+    return;
+  }
+  const requireColumns = secondary?.columns ?? true;
+  const requireRows = secondary?.rows ?? false;
+  for (const template of collectGridTemplateAreas(root)) {
+    if ((0, import_ts_extras19.isEmpty)(template.diagnostics)) {
+      if (requireColumns && !findSiblingDeclaration(template.declaration, "grid-template-columns")) {
+        report19({
+          message: messages19.rejected("grid-template-columns"),
+          node: template.declaration,
+          result,
+          ruleName: ruleName19,
+          word: template.declaration.prop
+        });
+      }
+      if (requireRows && !findSiblingDeclaration(template.declaration, "grid-template-rows")) {
+        report19({
+          message: messages19.rejected("grid-template-rows"),
+          node: template.declaration,
+          result,
+          ruleName: ruleName19,
+          word: template.declaration.prop
+        });
+      }
+    }
+  }
+};
+var rule19 = createStylelintRule({
+  docs: docs19,
+  messages: messages19,
+  rule: ruleFunction19,
+  ruleName: ruleName19
+});
+var require_explicit_tracks_with_areas_default = rule19;
 
 // dist/rules/validate-area-shapes.js
-var import_stylelint13 = __toESM(require("stylelint"), 1);
-var import_ts_extras12 = require("ts-extras");
-var { report: report12, ruleMessages: ruleMessages12, validateOptions: validateOptions12 } = import_stylelint13.default.utils;
-var ruleName12 = createRuleName("validate-area-shapes");
-var messages12 = ruleMessages12(ruleName12, {
+var import_stylelint21 = __toESM(require("stylelint"), 1);
+var import_ts_extras20 = require("ts-extras");
+var { report: report20, ruleMessages: ruleMessages20, validateOptions: validateOptions20 } = import_stylelint21.default.utils;
+var ruleName20 = createRuleName("validate-area-shapes");
+var messages20 = ruleMessages20(ruleName20, {
   rejected: (areaName) => `Grid area "${areaName}" must form one contiguous rectangle in \`grid-template-areas\`.`
 });
-var docs12 = {
+var docs20 = {
   description: "Require every named grid template area to form one contiguous rectangle.",
   recommended: true,
   url: createRuleDocsUrl("validate-area-shapes")
 };
-var ruleFunction12 = (primary) => (root, result) => {
-  if (!validateOptions12(result, ruleName12, {
+var ruleFunction20 = (primary) => (root, result) => {
+  if (!validateOptions20(result, ruleName20, {
     actual: primary,
     possible: [true]
   })) {
     return;
   }
   for (const template of collectGridTemplateAreas(root)) {
-    if ((0, import_ts_extras12.isEmpty)(template.diagnostics)) {
+    if ((0, import_ts_extras20.isEmpty)(template.diagnostics)) {
       for (const shape of getAreaShapes(template)) {
         if (!isRectangularArea(template, shape)) {
-          report12({
-            message: messages12.rejected(shape.name),
+          report20({
+            message: messages20.rejected(shape.name),
             node: template.declaration,
             result,
-            ruleName: ruleName12,
+            ruleName: ruleName20,
             word: shape.name
           });
         }
@@ -1120,83 +1720,91 @@ var ruleFunction12 = (primary) => (root, result) => {
     }
   }
 };
-var rule12 = createStylelintRule({
-  docs: docs12,
-  messages: messages12,
-  rule: ruleFunction12,
-  ruleName: ruleName12
+var rule20 = createStylelintRule({
+  docs: docs20,
+  messages: messages20,
+  rule: ruleFunction20,
+  ruleName: ruleName20
 });
-var validate_area_shapes_default = rule12;
+var validate_area_shapes_default = rule20;
 
 // dist/rules/validate-track-counts.js
-var import_stylelint14 = __toESM(require("stylelint"), 1);
-var import_ts_extras13 = require("ts-extras");
-var { report: report13, ruleMessages: ruleMessages13, validateOptions: validateOptions13 } = import_stylelint14.default.utils;
-var ruleName13 = createRuleName("validate-track-counts");
-var messages13 = ruleMessages13(ruleName13, {
+var import_stylelint22 = __toESM(require("stylelint"), 1);
+var import_ts_extras21 = require("ts-extras");
+var { report: report21, ruleMessages: ruleMessages21, validateOptions: validateOptions21 } = import_stylelint22.default.utils;
+var ruleName21 = createRuleName("validate-track-counts");
+var messages21 = ruleMessages21(ruleName21, {
   columns: (areaColumns, trackColumns) => `\`grid-template-areas\` defines ${String(areaColumns)} columns, but sibling \`grid-template-columns\` defines ${String(trackColumns)} tracks.`,
   rows: (areaRows, trackRows) => `\`grid-template-areas\` defines ${String(areaRows)} rows, but sibling \`grid-template-rows\` defines ${String(trackRows)} tracks.`
 });
-var docs13 = {
+var docs21 = {
   description: "Require template row and column track counts to match `grid-template-areas` dimensions.",
   recommended: true,
   url: createRuleDocsUrl("validate-track-counts")
 };
-var ruleFunction13 = (primary) => (root, result) => {
-  if (!validateOptions13(result, ruleName13, {
+var ruleFunction21 = (primary) => (root, result) => {
+  if (!validateOptions21(result, ruleName21, {
     actual: primary,
     possible: [true]
   })) {
     return;
   }
   for (const template of collectGridTemplateAreas(root)) {
-    const expectedColumns = (0, import_ts_extras13.arrayFirst)(template.rows)?.length;
-    if ((0, import_ts_extras13.isEmpty)(template.diagnostics) && (0, import_ts_extras13.isDefined)(expectedColumns)) {
+    const expectedColumns = (0, import_ts_extras21.arrayFirst)(template.rows)?.length;
+    if ((0, import_ts_extras21.isEmpty)(template.diagnostics) && (0, import_ts_extras21.isDefined)(expectedColumns)) {
       const expectedRows = template.rows.length;
       const rowsDeclaration = findSiblingDeclaration(template.declaration, "grid-template-rows");
       const columnsDeclaration = findSiblingDeclaration(template.declaration, "grid-template-columns");
-      const actualRows = (0, import_ts_extras13.isDefined)(rowsDeclaration) ? countGridTracks(rowsDeclaration.value) : void 0;
-      const actualColumns = (0, import_ts_extras13.isDefined)(columnsDeclaration) ? countGridTracks(columnsDeclaration.value) : void 0;
-      if ((0, import_ts_extras13.isDefined)(rowsDeclaration) && (0, import_ts_extras13.isDefined)(actualRows) && actualRows !== expectedRows) {
-        report13({
-          message: messages13.rows(expectedRows, actualRows),
+      const actualRows = (0, import_ts_extras21.isDefined)(rowsDeclaration) ? countGridTracks(rowsDeclaration.value) : void 0;
+      const actualColumns = (0, import_ts_extras21.isDefined)(columnsDeclaration) ? countGridTracks(columnsDeclaration.value) : void 0;
+      if ((0, import_ts_extras21.isDefined)(rowsDeclaration) && (0, import_ts_extras21.isDefined)(actualRows) && actualRows !== expectedRows) {
+        report21({
+          message: messages21.rows(expectedRows, actualRows),
           node: rowsDeclaration,
           result,
-          ruleName: ruleName13
+          ruleName: ruleName21
         });
       }
-      if ((0, import_ts_extras13.isDefined)(columnsDeclaration) && (0, import_ts_extras13.isDefined)(actualColumns) && actualColumns !== expectedColumns) {
-        report13({
-          message: messages13.columns(expectedColumns, actualColumns),
+      if ((0, import_ts_extras21.isDefined)(columnsDeclaration) && (0, import_ts_extras21.isDefined)(actualColumns) && actualColumns !== expectedColumns) {
+        report21({
+          message: messages21.columns(expectedColumns, actualColumns),
           node: columnsDeclaration,
           result,
-          ruleName: ruleName13
+          ruleName: ruleName21
         });
       }
     }
   }
 };
-var rule13 = createStylelintRule({
-  docs: docs13,
-  messages: messages13,
-  rule: ruleFunction13,
-  ruleName: ruleName13
+var rule21 = createStylelintRule({
+  docs: docs21,
+  messages: messages21,
+  rule: ruleFunction21,
+  ruleName: ruleName21
 });
-var validate_track_counts_default = rule13;
+var validate_track_counts_default = rule21;
 
 // dist/_internal/rules-registry.js
 var gridRules = {
   "consistent-area-naming": consistent_area_naming_default,
+  "no-conflicting-placement": no_conflicting_placement_default,
   "no-dense-auto-flow": no_dense_auto_flow_default,
+  "no-ineffective-container-properties": no_ineffective_container_properties_default,
   "no-invalid-areas": no_invalid_areas_default,
   "no-invalid-auto-repeat": no_invalid_auto_repeat_default,
   "no-invalid-minmax": no_invalid_minmax_default,
+  "no-invalid-repeat-count": no_invalid_repeat_count_default,
+  "no-invalid-span": no_invalid_span_default,
   "no-mismatched-template-rows": no_mismatched_template_rows_default,
   "no-overlapping-areas": no_overlapping_areas_default,
+  "no-reversed-placement-lines": no_reversed_placement_lines_default,
   "no-unknown-areas": no_unknown_areas_default,
   "no-unused-areas": no_unused_areas_default,
+  "no-zero-grid-lines": no_zero_grid_lines_default,
   "prefer-gap-properties": prefer_gap_properties_default,
+  "prefer-minmax-zero-fr": prefer_minmax_zero_fr_default,
   "require-explicit-rows-with-column-flow": require_explicit_rows_with_column_flow_default,
+  "require-explicit-tracks-with-areas": require_explicit_tracks_with_areas_default,
   "validate-area-shapes": validate_area_shapes_default,
   "validate-track-counts": validate_track_counts_default
 };
@@ -1213,29 +1821,29 @@ var meta = {
   version: packageMetaVersion
 };
 var rules = runtimeRules;
-var ruleNames = (0, import_ts_extras14.objectKeys)(rules).toSorted((left, right) => left.localeCompare(right));
+var ruleNames = (0, import_ts_extras22.objectKeys)(rules).toSorted((left, right) => left.localeCompare(right));
 var gridRuleEntries = (() => {
   const entries = [];
-  for (const ruleName14 of ruleNames) {
-    const rule14 = rules[ruleName14];
-    if ((0, import_ts_extras14.isDefined)(rule14)) {
-      entries.push([ruleName14, rule14]);
+  for (const ruleName22 of ruleNames) {
+    const rule22 = rules[ruleName22];
+    if ((0, import_ts_extras22.isDefined)(rule22)) {
+      entries.push([ruleName22, rule22]);
     }
   }
   return entries;
 })();
-function isGridRuleId(ruleName14) {
-  return ruleName14.startsWith(`${PLUGIN_NAMESPACE}/`);
+function isGridRuleId(ruleName22) {
+  return ruleName22.startsWith(`${PLUGIN_NAMESPACE}/`);
 }
-function toGridRuleId(ruleName14) {
-  if (!isGridRuleId(ruleName14)) {
-    throw new Error(`Unexpected Stylelint rule id "${ruleName14}".`);
+function toGridRuleId(ruleName22) {
+  if (!isGridRuleId(ruleName22)) {
+    throw new Error(`Unexpected Stylelint rule id "${ruleName22}".`);
   }
-  return ruleName14;
+  return ruleName22;
 }
-var plugins = gridRuleEntries.map(([, rule14]) => rule14);
-var ruleIds = gridRuleEntries.map(([, rule14]) => toGridRuleId(rule14.ruleName));
-var recommendedRuleIds = gridRuleEntries.filter(([, rule14]) => rule14.docs.recommended).map(([, rule14]) => toGridRuleId(rule14.ruleName));
+var plugins = gridRuleEntries.map(([, rule22]) => rule22);
+var ruleIds = gridRuleEntries.map(([, rule22]) => toGridRuleId(rule22.ruleName));
+var recommendedRuleIds = gridRuleEntries.filter(([, rule22]) => rule22.docs.recommended).map(([, rule22]) => toGridRuleId(rule22.ruleName));
 function createConfig(enabledRuleIds) {
   return {
     plugins: [...plugins],