stylelint-plugin-grid 1.0.0

package/dist/plugin.cjs

@@ -0,0 +1,1268 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// dist/plugin.js
+var plugin_exports = {};
+__export(plugin_exports, {
+  configNames: () => configNames,
+  default: () => plugin_default,
+  gridPluginConfigs: () => gridPluginConfigs,
+  meta: () => meta,
+  plugins: () => plugins,
+  ruleIds: () => ruleIds,
+  ruleNames: () => ruleNames,
+  rules: () => rules
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_ts_extras14 = require("ts-extras");
+
+// dist/_internal/plugin-constants.js
+var import_package = __toESM(require("stylelint-plugin-grid/package.json"), 1);
+var import_ts_extras = require("ts-extras");
+var PACKAGE_NAME = "stylelint-plugin-grid";
+var PLUGIN_NAMESPACE = "grid";
+var DOCS_SITE_URL = "https://nick2bad4u.github.io/stylelint-plugin-grid";
+var DOCS_RULES_BASE_URL = `${DOCS_SITE_URL}/docs/rules`;
+var CONFIG_NAMES = ["grid-all", "grid-recommended"];
+function getPackageVersion(pkg) {
+  return hasStringVersion(pkg) ? pkg.version : "0.0.0";
+}
+function hasStringVersion(pkg) {
+  return isUnknownRecord(pkg) && (0, import_ts_extras.keyIn)(pkg, "version") && typeof pkg["version"] === "string";
+}
+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 createRuleName(ruleName14) {
+  return `${PLUGIN_NAMESPACE}/${ruleName14}`;
+}
+
+// dist/rules/consistent-area-naming.js
+var import_stylelint2 = __toESM(require("stylelint"), 1);
+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 baseMeta = {
+    ...options.meta,
+    url: options.meta?.url ?? docs14.url
+  };
+  const meta2 = {
+    ...baseMeta,
+    docs: docs14
+  };
+  const typedRule = Object.assign(rule14, {
+    messages: messages14,
+    meta: meta2,
+    ruleName: ruleName14
+  });
+  if (options.primaryOptionArray === true) {
+    typedRule.primaryOptionArray = true;
+  }
+  const plugin = import_stylelint.default.createPlugin(ruleName14, typedRule);
+  return {
+    ...plugin,
+    docs: docs14,
+    messages: messages14,
+    meta: meta2,
+    rule: typedRule,
+    ruleName: ruleName14
+  };
+};
+
+// dist/_internal/grid-template-analysis.js
+var import_ts_extras2 = require("ts-extras");
+var cssWideKeywords = /* @__PURE__ */ new Set([
+  "inherit",
+  "initial",
+  "revert",
+  "revert-layer",
+  "unset"
+]);
+var reservedGridAreaIdents = /* @__PURE__ */ new Set(["auto", "span"]);
+var customIdentPattern = /^-?[A-Z_a-z][\w\-]*$/v;
+var blankAreaPattern = /^\.+$/v;
+function collectGridAreaUsages(root) {
+  const usages = [];
+  root.walkDecls("grid-area", (declaration) => {
+    const name = parseSingleGridAreaName(declaration.value);
+    if (!(0, import_ts_extras2.isDefined)(name)) {
+      return;
+    }
+    const selector = getOwningRule(declaration)?.selector;
+    usages.push({
+      declaration,
+      name,
+      ...(0, import_ts_extras2.isDefined)(selector) ? { selector } : {}
+    });
+  });
+  return usages;
+}
+function collectGridTemplateAreas(root) {
+  const templates = [];
+  root.walkDecls("grid-template-areas", (declaration) => {
+    const template = parseGridTemplateAreas(declaration);
+    if (template.rows.length > 0 || template.diagnostics.length > 0) {
+      templates.push(template);
+    }
+  });
+  return templates;
+}
+function countGridTracks(value) {
+  const tokens = [];
+  let count = 0;
+  for (const token of splitTopLevelWhitespace(value)) {
+    if (!isLineNameList(token)) {
+      tokens.push(token);
+    }
+  }
+  for (const token of tokens) {
+    const repeatCount = countRepeatTracks(token);
+    if (!(0, import_ts_extras2.isDefined)(repeatCount) && token.startsWith("repeat(")) {
+      return void 0;
+    }
+    count += repeatCount ?? 1;
+  }
+  return count;
+}
+function findSiblingDeclaration(declaration, propertyName) {
+  const parent = (0, import_ts_extras2.safeCastTo)(declaration.parent);
+  let match;
+  parent?.walkDecls(propertyName, (candidate) => {
+    if (candidate.parent === parent) {
+      match = candidate;
+    }
+  });
+  return match;
+}
+function findValueFunctionCalls(value, functionName) {
+  const calls = [];
+  const normalizedFunctionName = functionName.toLowerCase();
+  let index = 0;
+  while (index < value.length) {
+    const openParenthesisIndex = value.indexOf("(", index);
+    if (openParenthesisIndex === -1) {
+      break;
+    }
+    const nameStartIndex = findFunctionNameStart(value, openParenthesisIndex);
+    const name = value.slice(nameStartIndex, openParenthesisIndex);
+    const closeParenthesisIndex = findMatchingParenthesis(value, openParenthesisIndex);
+    if (closeParenthesisIndex < 0) {
+      break;
+    }
+    if (name.toLowerCase() === normalizedFunctionName) {
+      calls.push({
+        body: value.slice(openParenthesisIndex + 1, closeParenthesisIndex),
+        name,
+        source: value.slice(nameStartIndex, closeParenthesisIndex + 1)
+      });
+    }
+    index = closeParenthesisIndex + 1;
+  }
+  return calls;
+}
+function getAreaShapes(template) {
+  const shapes = /* @__PURE__ */ new Map();
+  for (const [rowIndex, row] of template.rows.entries()) {
+    for (const [columnIndex, token] of row.entries()) {
+      if (!isBlankAreaToken(token) && isGridAreaName(token)) {
+        const current = shapes.get(token);
+        shapes.set(token, (0, import_ts_extras2.isDefined)(current) ? {
+          ...current,
+          bottom: Math.max(current.bottom, rowIndex),
+          left: Math.min(current.left, columnIndex),
+          right: Math.max(current.right, columnIndex),
+          top: Math.min(current.top, rowIndex)
+        } : {
+          bottom: rowIndex,
+          left: columnIndex,
+          name: token,
+          right: columnIndex,
+          top: rowIndex
+        });
+      }
+    }
+  }
+  return [...shapes.values()].toSorted((left, right) => left.name.localeCompare(right.name));
+}
+function isBlankAreaToken(token) {
+  return blankAreaPattern.test(token);
+}
+function isGridAreaName(token) {
+  return customIdentPattern.test(token) && !(0, import_ts_extras2.setHas)(cssWideKeywords, token.toLowerCase()) && !(0, import_ts_extras2.setHas)(reservedGridAreaIdents, token.toLowerCase());
+}
+function isRectangularArea(template, shape) {
+  for (let rowIndex = shape.top; rowIndex <= shape.bottom; rowIndex += 1) {
+    const row = template.rows[rowIndex];
+    if (!(0, import_ts_extras2.isDefined)(row)) {
+      return false;
+    }
+    for (let columnIndex = shape.left; columnIndex <= shape.right; columnIndex += 1) {
+      if (row[columnIndex] !== shape.name) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function parseGridTemplateAreas(declaration) {
+  const trimmedValue = declaration.value.trim();
+  if (trimmedValue === "" || trimmedValue.toLowerCase() === "none") {
+    return {
+      areaNames: [],
+      declaration,
+      diagnostics: [],
+      rows: []
+    };
+  }
+  const rowTexts = extractCssStringLiterals(trimmedValue);
+  const diagnostics = [];
+  if ((0, import_ts_extras2.isEmpty)(rowTexts)) {
+    diagnostics.push({
+      message: "`grid-template-areas` must contain one or more quoted row strings."
+    });
+  }
+  const rows = rowTexts.map((rowText) => rowText.trim().match(/\S+/gv) ?? [""]);
+  for (const [rowIndex, row] of rows.entries()) {
+    if (row.length === 1 && (0, import_ts_extras2.arrayFirst)(row) === "") {
+      diagnostics.push({
+        message: `Grid template row ${String(rowIndex + 1)} is empty.`
+      });
+    } else {
+      for (const token of row) {
+        if (!isBlankAreaToken(token) && !isGridAreaName(token)) {
+          diagnostics.push({
+            message: `Grid area token "${token}" is not a valid area name or blank "." marker.`,
+            token
+          });
+        }
+      }
+    }
+  }
+  const expectedWidth = (0, import_ts_extras2.arrayFirst)(rows)?.length;
+  if ((0, import_ts_extras2.isDefined)(expectedWidth)) {
+    for (const [rowIndex, row] of rows.entries()) {
+      if (row.length !== expectedWidth) {
+        diagnostics.push({
+          message: `Grid template row ${String(rowIndex + 1)} has ${String(row.length)} columns, but row 1 has ${String(expectedWidth)}.`
+        });
+      }
+    }
+  }
+  return {
+    areaNames: getAreaNames(rows),
+    declaration,
+    diagnostics,
+    rows
+  };
+}
+function splitTopLevelCommas(value) {
+  return splitTopLevel(value, /,/v);
+}
+function splitTopLevelWhitespace(value) {
+  return splitTopLevel(value, /\s/v);
+}
+function countRepeatTracks(token) {
+  if (!token.startsWith("repeat(") || !token.endsWith(")")) {
+    return void 0;
+  }
+  const body = token.slice("repeat(".length, -1);
+  const [repeatText, trackListText] = splitTopLevelCommas(body);
+  const repeat = Number.parseInt(repeatText?.trim() ?? "", 10);
+  if (!(0, import_ts_extras2.isInteger)(repeat) || repeat < 0 || String(repeat) !== repeatText?.trim() || !(0, import_ts_extras2.isDefined)(trackListText)) {
+    return void 0;
+  }
+  const innerTrackCount = countGridTracks(trackListText);
+  return (0, import_ts_extras2.isDefined)(innerTrackCount) ? repeat * innerTrackCount : void 0;
+}
+function extractCssStringLiterals(value) {
+  const rows = [];
+  const stringPattern = /"(?<doubleQuotedRow>(?:\\.|[^"\\])*)"|'(?<singleQuotedRow>(?:\\.|[^'\\])*)'/vy;
+  let index = 0;
+  while (index < value.length) {
+    while (/\s/v.test(value[index] ?? "")) {
+      index += 1;
+    }
+    stringPattern.lastIndex = index;
+    const match = stringPattern.exec(value);
+    if (match === null) {
+      return rows;
+    }
+    rows.push(match.groups?.["doubleQuotedRow"] ?? match.groups?.["singleQuotedRow"] ?? "");
+    index = stringPattern.lastIndex;
+  }
+  return rows;
+}
+function findFunctionNameStart(value, openParenthesisIndex) {
+  let index = openParenthesisIndex - 1;
+  while (index >= 0 && isFunctionNameCharacter(value[index] ?? "")) {
+    index -= 1;
+  }
+  return index + 1;
+}
+function findMatchingParenthesis(value, openParenthesisIndex) {
+  let parenthesisDepth = 0;
+  for (let index = openParenthesisIndex; index < value.length; index += 1) {
+    const character = value[index];
+    if (character === "(") {
+      parenthesisDepth += 1;
+    } else if (character === ")") {
+      parenthesisDepth -= 1;
+      if (parenthesisDepth === 0) {
+        return index;
+      }
+    }
+  }
+  return -1;
+}
+function getAreaNames(rows) {
+  const names = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    for (const token of row) {
+      if (!isBlankAreaToken(token) && isGridAreaName(token)) {
+        names.add(token);
+      }
+    }
+  }
+  return [...names].toSorted((left, right) => left.localeCompare(right));
+}
+function getOwningRule(declaration) {
+  return declaration.parent?.type === "rule" ? declaration.parent : void 0;
+}
+function isFunctionNameCharacter(character) {
+  return character === "-" || character === "_" || character >= "0" && character <= "9" || character >= "A" && character <= "Z" || character >= "a" && character <= "z";
+}
+function isLineNameList(token) {
+  return token.startsWith("[") && token.endsWith("]");
+}
+function parseSingleGridAreaName(value) {
+  const name = value.trim();
+  if (name.includes("/") || name.includes("(") || name.includes(")") || !isGridAreaName(name)) {
+    return void 0;
+  }
+  return name;
+}
+function splitTopLevel(value, separatorPattern) {
+  const tokens = [];
+  let bracketDepth = 0;
+  let parenthesisDepth = 0;
+  let tokenStart = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    const character = value[index] ?? "";
+    switch (character) {
+      case "(": {
+        parenthesisDepth += 1;
+        break;
+      }
+      case ")": {
+        parenthesisDepth = Math.max(0, parenthesisDepth - 1);
+        break;
+      }
+      case "[": {
+        bracketDepth += 1;
+        break;
+      }
+      case "]": {
+        bracketDepth = Math.max(0, bracketDepth - 1);
+        break;
+      }
+    }
+    if (bracketDepth === 0 && parenthesisDepth === 0 && separatorPattern.test(character)) {
+      const token = value.slice(tokenStart, index).trim();
+      if (token.length > 0) {
+        tokens.push(token);
+      }
+      tokenStart = index + 1;
+    }
+  }
+  const finalToken = value.slice(tokenStart).trim();
+  if (finalToken.length > 0) {
+    tokens.push(finalToken);
+  }
+  return tokens;
+}
+
+// dist/rules/consistent-area-naming.js
+var { report, ruleMessages, validateOptions } = import_stylelint2.default.utils;
+var ruleName = createRuleName("consistent-area-naming");
+var messages = ruleMessages(ruleName, {
+  rejected: (areaName, style) => `Grid area name "${areaName}" must use ${style}.`
+});
+var docs = {
+  description: "Require consistent naming for `grid-template-areas` and single-name `grid-area` identifiers.",
+  recommended: false,
+  url: createRuleDocsUrl("consistent-area-naming")
+};
+var patterns = {
+  "camel-case": /^[a-z][0-9A-Za-z]*$/v,
+  // eslint-disable-next-line security/detect-unsafe-regex -- Anchored naming-style pattern over short CSS identifiers.
+  "kebab-case": /^[a-z][0-9a-z]*(?:-[0-9a-z]+)*$/v,
+  // eslint-disable-next-line security/detect-unsafe-regex -- Anchored naming-style pattern over short CSS identifiers.
+  "snake-case": /^[a-z][0-9a-z]*(?:_[0-9a-z]+)*$/v
+};
+var allowedStyles = [
+  "camel-case",
+  "kebab-case",
+  "snake-case"
+];
+function reportRejectedAreaName(input) {
+  const { areaName, node, result, style } = input;
+  report({
+    message: messages.rejected(areaName, style),
+    node,
+    result,
+    ruleName,
+    word: areaName
+  });
+}
+var ruleFunction = (primary, secondary) => (root, result) => {
+  if (!validateOptions(result, ruleName, {
+    actual: primary,
+    possible: [true]
+  }, {
+    actual: secondary,
+    optional: true,
+    possible: {
+      style: allowedStyles
+    }
+  })) {
+    return;
+  }
+  const style = secondary?.style ?? "kebab-case";
+  const pattern = patterns[style];
+  for (const template of collectGridTemplateAreas(root)) {
+    if ((0, import_ts_extras3.isEmpty)(template.diagnostics)) {
+      for (const areaName of template.areaNames) {
+        if (!pattern.test(areaName)) {
+          reportRejectedAreaName({
+            areaName,
+            node: template.declaration,
+            result,
+            style
+          });
+        }
+      }
+    }
+  }
+  for (const usage of collectGridAreaUsages(root)) {
+    if (!pattern.test(usage.name)) {
+      reportRejectedAreaName({
+        areaName: usage.name,
+        node: usage.declaration,
+        result,
+        style
+      });
+    }
+  }
+};
+var rule = createStylelintRule({
+  docs,
+  messages,
+  rule: ruleFunction,
+  ruleName
+});
+var consistent_area_naming_default = rule;
+
+// dist/rules/no-dense-auto-flow.js
+var import_stylelint3 = __toESM(require("stylelint"), 1);
+var { report: report2, ruleMessages: ruleMessages2, validateOptions: validateOptions2 } = import_stylelint3.default.utils;
+var ruleName2 = createRuleName("no-dense-auto-flow");
+var messages2 = ruleMessages2(ruleName2, {
+  rejected: () => "Avoid `grid-auto-flow: dense`; dense packing can disconnect visual order from source order."
+});
+var docs2 = {
+  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, {
+    actual: primary,
+    possible: [true]
+  })) {
+    return;
+  }
+  root.walkDecls("grid-auto-flow", (declaration) => {
+    const hasDensePacking = splitTopLevelWhitespace(declaration.value).some((token) => token.toLowerCase() === "dense");
+    if (!hasDensePacking) {
+      return;
+    }
+    report2({
+      message: messages2.rejected(),
+      node: declaration,
+      result,
+      ruleName: ruleName2,
+      word: "dense"
+    });
+  });
+};
+var rule2 = createStylelintRule({
+  docs: docs2,
+  messages: messages2,
+  rule: ruleFunction2,
+  ruleName: ruleName2
+});
+var no_dense_auto_flow_default = rule2;
+
+// 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, {
+  rejected: (message) => message
+});
+var docs3 = {
+  description: "Disallow malformed `grid-template-areas` declarations.",
+  recommended: true,
+  url: createRuleDocsUrl("no-invalid-areas")
+};
+var ruleFunction3 = (primary) => (root, result) => {
+  if (!validateOptions3(result, ruleName3, {
+    actual: primary,
+    possible: [true]
+  })) {
+    return;
+  }
+  for (const template of collectGridTemplateAreas(root)) {
+    for (const diagnostic of template.diagnostics) {
+      report3({
+        message: messages3.rejected(diagnostic.message),
+        node: template.declaration,
+        result,
+        ruleName: ruleName3,
+        word: diagnostic.token
+      });
+    }
+  }
+};
+var rule3 = createStylelintRule({
+  docs: docs3,
+  messages: messages3,
+  rule: ruleFunction3,
+  ruleName: ruleName3
+});
+var no_invalid_areas_default = rule3;
+
+// 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, {
+  rejected: (token, repeatKeyword) => `Use a fixed track size inside \`repeat(${repeatKeyword}, ...)\`; \`${token}\` can make the grid template declaration invalid.`
+});
+var docs4 = {
+  description: "Disallow definitely invalid CSS Grid auto-repeat track sizes.",
+  recommended: true,
+  url: createRuleDocsUrl("no-invalid-auto-repeat")
+};
+var trackTemplateProperties = /* @__PURE__ */ new Set([
+  "grid-template-columns",
+  "grid-template-rows"
+]);
+var invalidBareAutoRepeatTrackTokens = /* @__PURE__ */ new Set([
+  "auto",
+  "max-content",
+  "min-content"
+]);
+var cssLengthUnits = /* @__PURE__ */ new Set([
+  "cap",
+  "ch",
+  "cm",
+  "dvb",
+  "dvh",
+  "dvi",
+  "dvmax",
+  "dvmin",
+  "dvw",
+  "em",
+  "ex",
+  "ic",
+  "in",
+  "lh",
+  "lvb",
+  "lvh",
+  "lvi",
+  "lvmax",
+  "lvmin",
+  "lvw",
+  "mm",
+  "pc",
+  "pt",
+  "px",
+  "q",
+  "rch",
+  "rem",
+  "rex",
+  "ric",
+  "rlh",
+  "svb",
+  "svh",
+  "svi",
+  "svmax",
+  "svmin",
+  "svw",
+  "vb",
+  "vh",
+  "vi",
+  "vmax",
+  "vmin",
+  "vw"
+]);
+var lengthPercentagePattern = /^[+\-]?(?:\d+|\d*\.\d+)(?<unit>%|[A-Za-z]+)$/v;
+var zeroPattern = /^[+\-]?(?:0|0?\.0+)$/v;
+function containsRuntimeValue(token) {
+  const normalizedToken = token.toLowerCase();
+  return normalizedToken.includes("var(") || normalizedToken.includes("env(");
+}
+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)) {
+        return token;
+      }
+      if (hasStringPrefix(normalizedToken, "minmax(") && isInvalidAutoRepeatMinmax(token)) {
+        return token;
+      }
+    }
+  }
+  return void 0;
+}
+function getMinmaxArguments(token) {
+  const minmaxCall = (0, import_ts_extras4.arrayFirst)(findValueFunctionCalls(token, "minmax"));
+  if (!(0, import_ts_extras4.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)) {
+    return void 0;
+  }
+  return [minimum, maximum];
+}
+function getRepeatKeyword(repeatBody) {
+  const repeatCount = (0, import_ts_extras4.arrayFirst)(splitTopLevelCommas(repeatBody))?.trim().toLowerCase();
+  if (repeatCount === "auto-fill" || repeatCount === "auto-fit") {
+    return repeatCount;
+  }
+  return void 0;
+}
+function hasStringPrefix(value, prefix) {
+  return value.slice(0, prefix.length) === prefix;
+}
+function isFixedTrackBreadth(value) {
+  const normalizedValue = value.toLowerCase();
+  if (zeroPattern.test(normalizedValue)) {
+    return true;
+  }
+  if (hasStringPrefix(normalizedValue, "calc(") || hasStringPrefix(normalizedValue, "clamp(") || hasStringPrefix(normalizedValue, "max(") || hasStringPrefix(normalizedValue, "min(")) {
+    return true;
+  }
+  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);
+}
+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);
+}
+function isInvalidAutoRepeatMinmax(token) {
+  const args = getMinmaxArguments(token);
+  if (!(0, import_ts_extras4.isDefined)(args)) {
+    return false;
+  }
+  const [minimum, maximum] = args;
+  return isFlexTrackBreadth(minimum) || isIntrinsicTrackBreadth(minimum) && !isFixedTrackBreadth(maximum);
+}
+function isLineNameList2(token) {
+  return token.startsWith("[") && token.endsWith("]");
+}
+var ruleFunction4 = (primary) => (root, result) => {
+  if (!validateOptions4(result, ruleName4, {
+    actual: primary,
+    possible: [true]
+  })) {
+    return;
+  }
+  root.walkDecls((declaration) => {
+    if (!(0, import_ts_extras4.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)) {
+        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),
+            node: declaration,
+            result,
+            ruleName: ruleName4,
+            word: invalidTrack
+          });
+        }
+      }
+    }
+  });
+};
+var rule4 = createStylelintRule({
+  docs: docs4,
+  messages: messages4,
+  rule: ruleFunction4,
+  ruleName: ruleName4
+});
+var no_invalid_auto_repeat_default = rule4;
+
+// 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, {
+  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 = {
+  description: "Disallow flexible `fr` values as the minimum argument in CSS Grid `minmax()` track sizes.",
+  recommended: true,
+  url: createRuleDocsUrl("no-invalid-minmax")
+};
+var gridTrackProperties = /* @__PURE__ */ new Set([
+  "grid-auto-columns",
+  "grid-auto-rows",
+  "grid-template-columns",
+  "grid-template-rows"
+]);
+function isFlexTrackBreadth2(value) {
+  return /^[+\-]?(?:\d+|\d*\.\d+)fr$/v.test(value.toLowerCase());
+}
+var ruleFunction5 = (primary) => (root, result) => {
+  if (!validateOptions5(result, ruleName5, {
+    actual: primary,
+    possible: [true]
+  })) {
+    return;
+  }
+  root.walkDecls((declaration) => {
+    if (!(0, import_ts_extras5.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),
+          node: declaration,
+          result,
+          ruleName: ruleName5,
+          word: minimum
+        });
+      }
+    }
+  });
+};
+var rule5 = createStylelintRule({
+  docs: docs5,
+  messages: messages5,
+  rule: ruleFunction5,
+  ruleName: ruleName5
+});
+var no_invalid_minmax_default = rule5;
+
+// 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.`
+});
+var docs6 = {
+  description: "Require `grid-template-rows` track count to match `grid-template-areas` row count.",
+  recommended: true,
+  url: createRuleDocsUrl("no-mismatched-template-rows")
+};
+var ruleFunction6 = (primary) => (root, result) => {
+  if (!validateOptions6(result, ruleName6, {
+    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,
+          result,
+          ruleName: ruleName6
+        });
+      }
+    }
+  }
+};
+var rule6 = createStylelintRule({
+  docs: docs6,
+  messages: messages6,
+  rule: ruleFunction6,
+  ruleName: ruleName6
+});
+var no_mismatched_template_rows_default = rule6;
+
+// 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.`
+});
+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 ruleFunction7 = (primary) => (root, result) => {
+  if (!validateOptions7(result, ruleName7, {
+    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);
+    }
+  }
+};
+var rule7 = createStylelintRule({
+  docs: docs7,
+  messages: messages7,
+  rule: ruleFunction7,
+  ruleName: ruleName7
+});
+var no_overlapping_areas_default = rule7;
+
+// 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, {
+  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 = {
+  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, {
+    actual: primary,
+    possible: [true]
+  })) {
+    return;
+  }
+  const declaredAreaNames = new Set(collectGridTemplateAreas(root).flatMap((template) => (0, import_ts_extras8.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),
+        node: usage.declaration,
+        result,
+        ruleName: ruleName8,
+        word: usage.name
+      });
+    }
+  }
+};
+var rule8 = createStylelintRule({
+  docs: docs8,
+  messages: messages8,
+  rule: ruleFunction8,
+  ruleName: ruleName8
+});
+var no_unknown_areas_default = rule8;
+
+// 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, {
+  rejected: (areaName) => `Grid template area "${areaName}" is declared but no single-name \`grid-area: ${areaName}\` declaration exists in this stylesheet.`
+});
+var docs9 = {
+  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, {
+    actual: primary,
+    possible: [true]
+  })) {
+    return;
+  }
+  const usedAreaNames = new Set(collectGridAreaUsages(root).map((usage) => usage.name));
+  for (const template of collectGridTemplateAreas(root)) {
+    if ((0, import_ts_extras9.isEmpty)(template.diagnostics)) {
+      for (const areaName of template.areaNames) {
+        if (!(0, import_ts_extras9.setHas)(usedAreaNames, areaName)) {
+          report9({
+            message: messages9.rejected(areaName),
+            node: template.declaration,
+            result,
+            ruleName: ruleName9,
+            word: areaName
+          });
+        }
+      }
+    }
+  }
+};
+var rule9 = createStylelintRule({
+  docs: docs9,
+  messages: messages9,
+  rule: ruleFunction9,
+  ruleName: ruleName9
+});
+var no_unused_areas_default = rule9;
+
+// 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, {
+  rejected: (propertyName, replacement) => `Prefer \`${replacement}\` over legacy \`${propertyName}\`.`
+});
+var docs10 = {
+  description: "Prefer modern `gap`, `row-gap`, and `column-gap` properties over legacy grid gap aliases.",
+  recommended: true,
+  url: createRuleDocsUrl("prefer-gap-properties")
+};
+var replacements = {
+  "grid-column-gap": "column-gap",
+  "grid-gap": "gap",
+  "grid-row-gap": "row-gap"
+};
+function getReplacement(declaration) {
+  return replacements[declaration.prop.toLowerCase()];
+}
+var ruleFunction10 = (primary) => (root, result) => {
+  if (!validateOptions10(result, ruleName10, {
+    actual: primary,
+    possible: [true]
+  })) {
+    return;
+  }
+  root.walkDecls((declaration) => {
+    const replacement = getReplacement(declaration);
+    if (!(0, import_ts_extras10.isDefined)(replacement)) {
+      return;
+    }
+    report10({
+      fix: () => {
+        declaration.prop = replacement;
+      },
+      message: messages10.rejected(declaration.prop, replacement),
+      node: declaration,
+      result,
+      ruleName: ruleName10,
+      word: declaration.prop
+    });
+  });
+};
+var rule10 = createStylelintRule({
+  docs: docs10,
+  messages: messages10,
+  meta: {
+    fixable: true
+  },
+  rule: ruleFunction10,
+  ruleName: ruleName10
+});
+var prefer_gap_properties_default = rule10;
+
+// 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, {
+  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 = {
+  description: "Require explicit row sizing when a rule uses `grid-auto-flow: column`.",
+  recommended: false,
+  url: createRuleDocsUrl("require-explicit-rows-with-column-flow")
+};
+function hasColumnFlow(value) {
+  return splitTopLevelWhitespace(value).some((token) => token.toLowerCase() === "column");
+}
+var ruleFunction11 = (primary) => (root, result) => {
+  if (!validateOptions11(result, ruleName11, {
+    actual: primary,
+    possible: [true]
+  })) {
+    return;
+  }
+  root.walkDecls("grid-auto-flow", (declaration) => {
+    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"));
+    if (hasExplicitRows) {
+      return;
+    }
+    report11({
+      message: messages11.rejected(),
+      node: declaration,
+      result,
+      ruleName: ruleName11,
+      word: "column"
+    });
+  });
+};
+var rule11 = createStylelintRule({
+  docs: docs11,
+  messages: messages11,
+  rule: ruleFunction11,
+  ruleName: ruleName11
+});
+var require_explicit_rows_with_column_flow_default = rule11;
+
+// 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, {
+  rejected: (areaName) => `Grid area "${areaName}" must form one contiguous rectangle in \`grid-template-areas\`.`
+});
+var docs12 = {
+  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, {
+    actual: primary,
+    possible: [true]
+  })) {
+    return;
+  }
+  for (const template of collectGridTemplateAreas(root)) {
+    if ((0, import_ts_extras12.isEmpty)(template.diagnostics)) {
+      for (const shape of getAreaShapes(template)) {
+        if (!isRectangularArea(template, shape)) {
+          report12({
+            message: messages12.rejected(shape.name),
+            node: template.declaration,
+            result,
+            ruleName: ruleName12,
+            word: shape.name
+          });
+        }
+      }
+    }
+  }
+};
+var rule12 = createStylelintRule({
+  docs: docs12,
+  messages: messages12,
+  rule: ruleFunction12,
+  ruleName: ruleName12
+});
+var validate_area_shapes_default = rule12;
+
+// 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, {
+  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 = {
+  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, {
+    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 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),
+          node: rowsDeclaration,
+          result,
+          ruleName: ruleName13
+        });
+      }
+      if ((0, import_ts_extras13.isDefined)(columnsDeclaration) && (0, import_ts_extras13.isDefined)(actualColumns) && actualColumns !== expectedColumns) {
+        report13({
+          message: messages13.columns(expectedColumns, actualColumns),
+          node: columnsDeclaration,
+          result,
+          ruleName: ruleName13
+        });
+      }
+    }
+  }
+};
+var rule13 = createStylelintRule({
+  docs: docs13,
+  messages: messages13,
+  rule: ruleFunction13,
+  ruleName: ruleName13
+});
+var validate_track_counts_default = rule13;
+
+// dist/_internal/rules-registry.js
+var gridRules = {
+  "consistent-area-naming": consistent_area_naming_default,
+  "no-dense-auto-flow": no_dense_auto_flow_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-mismatched-template-rows": no_mismatched_template_rows_default,
+  "no-overlapping-areas": no_overlapping_areas_default,
+  "no-unknown-areas": no_unknown_areas_default,
+  "no-unused-areas": no_unused_areas_default,
+  "prefer-gap-properties": prefer_gap_properties_default,
+  "require-explicit-rows-with-column-flow": require_explicit_rows_with_column_flow_default,
+  "validate-area-shapes": validate_area_shapes_default,
+  "validate-track-counts": validate_track_counts_default
+};
+
+// dist/plugin.js
+var packageMetaName = PACKAGE_NAME;
+var packageMetaNamespace = PLUGIN_NAMESPACE;
+var packageMetaVersion = PACKAGE_VERSION;
+var runtimeRules = gridRules;
+var publicConfigNames = CONFIG_NAMES;
+var meta = {
+  name: packageMetaName,
+  namespace: packageMetaNamespace,
+  version: packageMetaVersion
+};
+var rules = runtimeRules;
+var ruleNames = (0, import_ts_extras14.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]);
+    }
+  }
+  return entries;
+})();
+function isGridRuleId(ruleName14) {
+  return ruleName14.startsWith(`${PLUGIN_NAMESPACE}/`);
+}
+function toGridRuleId(ruleName14) {
+  if (!isGridRuleId(ruleName14)) {
+    throw new Error(`Unexpected Stylelint rule id "${ruleName14}".`);
+  }
+  return ruleName14;
+}
+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));
+function createConfig(enabledRuleIds) {
+  return {
+    plugins: [...plugins],
+    rules: (() => {
+      const rulesConfig = {};
+      for (const ruleId of enabledRuleIds) {
+        rulesConfig[ruleId] = true;
+      }
+      return rulesConfig;
+    })()
+  };
+}
+var gridPluginConfigs = {
+  "grid-all": createConfig(ruleIds),
+  "grid-recommended": createConfig(recommendedRuleIds)
+};
+var configNames = publicConfigNames;
+var plugin_default = plugins;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  configNames,
+  gridPluginConfigs,
+  meta,
+  plugins,
+  ruleIds,
+  ruleNames,
+  rules
+});
+module.exports = Object.assign(module.exports.default, module.exports);
+//# sourceMappingURL=plugin.cjs.map