@salesforce-ux/eslint-plugin-slds 1.0.0 → 1.0.2-internal

package/build/index.js

@@ -183,7 +183,7 @@ var require_rule_messages = __commonJS({
       },
       "no-hardcoded-values-slds2": {
         "description": "Replace static values with SLDS 2 styling hooks. For more information, look up design tokens on lightningdesignsystem.com.",
-        "url": "https://developer.salesforce.com/docs/platform/slds-linter/guide/reference-rules.html#no-hardcoded-value",
+        "url": "https://developer.salesforce.com/docs/platform/slds-linter/guide/reference-rules.html#no-hardcoded-values-slds2",
         "type": "suggestion",
         "messages": {
           "hardcodedValue": "Consider replacing the {{oldValue}} static value with an SLDS 2 styling hook that has a similar value: {{newValue}}.",
@@ -203,13 +203,13 @@ var require_rule_messages = __commonJS({
 });
 
 // src/rules/v9/enforce-bem-usage.ts
-var import_sds_metadata, import_rule_messages, type, description, url, messages, bemMapping, enforce_bem_usage_default;
+var import_next, import_rule_messages, type, description, url, messages, bemMapping, enforce_bem_usage_default;
 var init_enforce_bem_usage = __esm({
   "src/rules/v9/enforce-bem-usage.ts"() {
-    import_sds_metadata = __toESM(require("@salesforce-ux/sds-metadata"));
+    import_next = __toESM(require("@salesforce-ux/sds-metadata/next"));
     import_rule_messages = __toESM(require_rule_messages());
     ({ type, description, url, messages } = import_rule_messages.default["enforce-bem-usage"]);
-    bemMapping = import_sds_metadata.default.bemNaming;
+    bemMapping = import_next.default.bemNaming;
     enforce_bem_usage_default = {
       meta: {
         type,
@@ -254,11 +254,11 @@ var init_enforce_bem_usage = __esm({
 var require_enforce_bem_usage = __commonJS({
   "src/rules/enforce-bem-usage.ts"(exports2, module2) {
     init_node();
-    var import_sds_metadata14 = __toESM(require("@salesforce-ux/sds-metadata"));
+    var import_next14 = __toESM(require("@salesforce-ux/sds-metadata/next"));
     var import_rule_messages16 = __toESM(require_rule_messages());
     init_enforce_bem_usage();
-    var bemMapping2 = import_sds_metadata14.default.bemNaming;
-    var deprecatedClasses2 = import_sds_metadata14.default.deprecatedClasses;
+    var bemMapping2 = import_next14.default.bemNaming;
+    var deprecatedClasses2 = import_next14.default.deprecatedClasses;
     var ruleConfig14 = import_rule_messages16.default["enforce-bem-usage"];
     var { type: type15, description: description15, url: url15, messages: messages15 } = ruleConfig14;
     var isDeprecatedClass = (className) => {
@@ -349,9 +349,9 @@ var require_enforce_bem_usage = __commonJS({
 var require_no_deprecated_classes_slds2 = __commonJS({
   "src/rules/no-deprecated-classes-slds2.ts"(exports2, module2) {
     init_node();
-    var import_sds_metadata14 = __toESM(require("@salesforce-ux/sds-metadata"));
+    var import_next14 = __toESM(require("@salesforce-ux/sds-metadata/next"));
     var import_rule_messages16 = __toESM(require_rule_messages());
-    var deprecatedClasses2 = import_sds_metadata14.default.deprecatedClasses;
+    var deprecatedClasses2 = import_next14.default.deprecatedClasses;
     var ruleConfig14 = import_rule_messages16.default["no-deprecated-classes-slds2"];
     module2.exports = {
       meta: {
@@ -555,10 +555,10 @@ var import_no_deprecated_classes_slds2 = __toESM(require_no_deprecated_classes_s
 var import_modal_close_button_issue = __toESM(require_modal_close_button_issue());
 
 // src/rules/v9/no-slds-class-overrides.ts
-var import_sds_metadata2 = __toESM(require("@salesforce-ux/sds-metadata"));
+var import_next2 = __toESM(require("@salesforce-ux/sds-metadata/next"));
 var import_rule_messages2 = __toESM(require_rule_messages());
 var ruleConfig = import_rule_messages2.default["no-slds-class-overrides"];
-var sldsClasses = import_sds_metadata2.default.sldsPlusClasses;
+var sldsClasses = import_next2.default.sldsPlusClasses;
 var sldsClassesSet = new Set(sldsClasses);
 var no_slds_class_overrides_default = {
   meta: {
@@ -595,10 +595,10 @@ var no_slds_class_overrides_default = {
 };
 
 // src/rules/v9/no-deprecated-slds-classes.ts
-var import_sds_metadata3 = __toESM(require("@salesforce-ux/sds-metadata"));
+var import_next3 = __toESM(require("@salesforce-ux/sds-metadata/next"));
 var import_rule_messages3 = __toESM(require_rule_messages());
 var { type: type2, description: description2, url: url2, messages: messages2 } = import_rule_messages3.default["no-deprecated-slds-classes"];
-var deprecatedClasses = import_sds_metadata3.default.deprecatedClasses;
+var deprecatedClasses = import_next3.default.deprecatedClasses;
 var deprecatedClassesSet = new Set(deprecatedClasses);
 var no_deprecated_slds_classes_default = {
   meta: {
@@ -629,11 +629,11 @@ var no_deprecated_slds_classes_default = {
 };
 
 // src/rules/v9/no-deprecated-tokens-slds1.ts
-var import_sds_metadata4 = __toESM(require("@salesforce-ux/sds-metadata"));
+var import_next4 = __toESM(require("@salesforce-ux/sds-metadata/next"));
 var import_rule_messages4 = __toESM(require_rule_messages());
 var ruleConfig2 = import_rule_messages4.default["no-deprecated-tokens-slds1"];
 var { type: type3, description: description3, url: url3, messages: messages3 } = ruleConfig2;
-var tokenMapping = import_sds_metadata4.default.auraToLwcTokensMapping;
+var tokenMapping = import_next4.default.auraToLwcTokensMapping;
 var no_deprecated_tokens_slds1_default = {
   meta: {
     type: type3,
@@ -706,171 +706,458 @@ var no_deprecated_tokens_slds1_default = {
 };
 
 // src/rules/v9/lwc-token-to-slds-hook.ts
-var import_sds_metadata5 = __toESM(require("@salesforce-ux/sds-metadata"));
+var import_next5 = __toESM(require("@salesforce-ux/sds-metadata/next"));
 var import_rule_messages5 = __toESM(require_rule_messages());
-var ruleConfig3 = import_rule_messages5.default["lwc-token-to-slds-hook"];
-var { type: type4, description: description4, url: url4, messages: messages4 } = ruleConfig3;
-var lwcToSlds = import_sds_metadata5.default.lwcToSlds;
-function shouldIgnoreDetection(lwcToken) {
-  return !lwcToken.startsWith("--lwc-") || !(lwcToken in lwcToSlds) || lwcToSlds[lwcToken].continueToUse;
+
+// src/utils/hardcoded-shared-utils.ts
+var import_css_tree2 = require("@eslint/css-tree");
+
+// src/utils/value-utils.ts
+var ALLOWED_UNITS = ["px", "em", "rem", "%", "ch"];
+function parseUnitValue(value) {
+  if (!value) return null;
+  const unitsPattern = ALLOWED_UNITS.join("|");
+  const regex = new RegExp(`^(-?\\d*\\.?\\d+)(${unitsPattern})?$`);
+  const match = value.match(regex);
+  if (!match) return null;
+  const number = parseFloat(match[1]);
+  const unit = match[2] ? match[2] : null;
+  if (isNaN(number)) return null;
+  return { number, unit };
 }
-function categorizeReplacement(recommendation) {
-  if (!recommendation || recommendation === "--") {
-    return "empty" /* EMPTY */;
-  }
-  if (Array.isArray(recommendation)) {
-    return "array" /* ARRAY */;
-  }
-  if (typeof recommendation === "string" && recommendation.startsWith("--slds-")) {
-    return "slds_token" /* SLDS_TOKEN */;
+function toAlternateUnitValue(numberVal, unitType) {
+  if (unitType === "px") {
+    let floatValue = parseFloat(`${numberVal / 16}`);
+    if (!isNaN(floatValue)) {
+      return {
+        unit: "rem",
+        number: parseFloat(floatValue.toFixed(4))
+      };
+    }
+  } else if (unitType === "rem") {
+    const intValue = parseInt(`${numberVal * 16}`);
+    if (!isNaN(intValue)) {
+      return {
+        unit: "px",
+        number: intValue
+      };
+    }
   }
-  return "raw_value" /* RAW_VALUE */;
+  return null;
 }
-function getRecommendation(lwcToken) {
-  const oldValue = lwcToken;
-  const recommendation = lwcToSlds[oldValue]?.replacement || "";
-  const replacementCategory = categorizeReplacement(recommendation);
-  const hasRecommendation = oldValue in lwcToSlds && replacementCategory !== "empty" /* EMPTY */;
-  return { hasRecommendation, recommendation, replacementCategory };
+
+// src/utils/color-lib-utils.ts
+var import_chroma_js = __toESM(require("chroma-js"));
+var import_css_tree = require("@eslint/css-tree");
+
+// src/utils/css-functions.ts
+var CSS_FUNCTIONS = [
+  "attr",
+  "calc",
+  "color-mix",
+  "conic-gradient",
+  "counter",
+  "cubic-bezier",
+  "linear-gradient",
+  "max",
+  "min",
+  "radial-gradient",
+  "repeating-conic-gradient",
+  "repeating-linear-gradient",
+  "repeating-radial-gradient",
+  "var"
+];
+var CSS_MATH_FUNCTIONS = ["calc", "min", "max"];
+var RGB_COLOR_FUNCTIONS = ["rgb", "rgba", "hsl", "hsla"];
+var cssFunctionsRegex = new RegExp(`(?:${CSS_FUNCTIONS.join("|")})`);
+var cssFunctionsExactRegex = new RegExp(`^(?:${CSS_FUNCTIONS.join("|")})$`);
+var cssMathFunctionsRegex = new RegExp(`^(?:${CSS_MATH_FUNCTIONS.join("|")})$`);
+function isCssFunction(value) {
+  return cssFunctionsExactRegex.test(value);
 }
-function getReportMessage(cssVar, replacementCategory, recommendation) {
-  if (!recommendation) {
-    return {
-      messageId: "errorWithNoRecommendation",
-      data: { oldValue: cssVar }
-    };
-  } else if (replacementCategory === "array" /* ARRAY */) {
-    return {
-      messageId: "errorWithStyleHooks",
-      data: { oldValue: cssVar, newValue: recommendation.join(" or ") }
-    };
-  } else if (replacementCategory === "slds_token" /* SLDS_TOKEN */) {
-    return {
-      messageId: "errorWithStyleHooks",
-      data: { oldValue: cssVar, newValue: recommendation }
-    };
-  } else {
-    return {
-      messageId: "errorWithReplacement",
-      data: { oldValue: cssVar, newValue: recommendation }
-    };
-  }
+function isCssColorFunction(value) {
+  return RGB_COLOR_FUNCTIONS.includes(value);
 }
-var lwc_token_to_slds_hook_default = {
-  meta: {
-    type: type4,
-    docs: {
-      description: description4,
-      recommended: true,
-      url: url4
-    },
-    fixable: "code",
-    messages: messages4
-  },
-  create(context) {
-    function reportAndFix(node, oldValue, suggestedMatch, messageId, data) {
-      let fixFunction = null;
-      if (suggestedMatch) {
-        fixFunction = (fixer) => {
-          if (node.type === "Declaration") {
-            const sourceCode = context.sourceCode;
-            const fullText = sourceCode.getText();
-            const nodeOffset = node.loc.start.offset;
-            const propertyStart = nodeOffset;
-            const propertyEnd = propertyStart + oldValue.length;
-            const textAtPosition = fullText.substring(propertyStart, propertyEnd);
-            if (textAtPosition === oldValue) {
-              return fixer.replaceTextRange([propertyStart, propertyEnd], suggestedMatch);
-            }
-          } else {
-            const sourceCode = context.sourceCode;
-            const fullText = sourceCode.getText();
-            const varFunctionCall = `var(${oldValue})`;
-            const nodeOffset = node.loc.start.offset;
-            const searchStart = Math.max(0, nodeOffset - 4);
-            const searchEnd = nodeOffset + oldValue.length + 1;
-            const searchArea = fullText.substring(searchStart, searchEnd);
-            const functionCallIndex = searchArea.indexOf(varFunctionCall);
-            if (functionCallIndex !== -1) {
-              const actualStart = searchStart + functionCallIndex;
-              const actualEnd = actualStart + varFunctionCall.length;
-              return fixer.replaceTextRange([actualStart, actualEnd], suggestedMatch);
-            }
+
+// src/utils/color-lib-utils.ts
+var LAB_THRESHOLD = 25;
+var isHexCode = (color) => {
+  const hexPattern = /^#(?:[0-9a-fA-F]{3}){1,2}$/;
+  return hexPattern.test(color);
+};
+var convertToHex = (color) => {
+  try {
+    return (0, import_chroma_js.default)(color).hex();
+  } catch (e) {
+    return null;
+  }
+};
+var findClosestColorHook = (color, supportedColors, cssProperty) => {
+  const returnStylingHooks = [];
+  const closestHooksWithSameProperty = [];
+  const closestHooksWithoutSameProperty = [];
+  const closestHooksWithAllProperty = [];
+  const labColor = (0, import_chroma_js.default)(color).lab();
+  Object.entries(supportedColors).forEach(([sldsValue, data]) => {
+    if (sldsValue && isHexCode(sldsValue)) {
+      const hooks = data;
+      hooks.forEach((hook) => {
+        const labSupportedColor = (0, import_chroma_js.default)(sldsValue).lab();
+        const distance = JSON.stringify(labColor) === JSON.stringify(labSupportedColor) ? 0 : import_chroma_js.default.distance(import_chroma_js.default.lab(...labColor), import_chroma_js.default.lab(...labSupportedColor), "lab");
+        if (hook.properties.includes(cssProperty)) {
+          if (distance <= LAB_THRESHOLD) {
+            closestHooksWithSameProperty.push({ name: hook.name, distance });
           }
-          return null;
-        };
-      }
-      context.report({
-        node,
-        messageId,
-        data,
-        fix: fixFunction
-      });
-    }
-    return {
-      // CSS custom property declarations: --lwc-* properties
-      "Declaration[property=/^--lwc-/]"(node) {
-        const property = node.property;
-        if (shouldIgnoreDetection(property)) {
-          return;
-        }
-        const { hasRecommendation, recommendation, replacementCategory } = getRecommendation(property);
-        const { messageId, data } = getReportMessage(property, replacementCategory, recommendation);
-        const suggestedMatch = hasRecommendation && replacementCategory === "slds_token" /* SLDS_TOKEN */ ? recommendation : null;
-        reportAndFix(node, property, suggestedMatch, messageId, data);
-      },
-      // LWC tokens inside var() functions: var(--lwc-*)
-      "Function[name='var'] Identifier[name=/^--lwc-/]"(node) {
-        const tokenName = node.name;
-        if (shouldIgnoreDetection(tokenName)) {
-          return;
-        }
-        const { hasRecommendation, recommendation, replacementCategory } = getRecommendation(tokenName);
-        const { messageId, data } = getReportMessage(tokenName, replacementCategory, recommendation);
-        let suggestedMatch = null;
-        if (hasRecommendation) {
-          if (replacementCategory === "slds_token" /* SLDS_TOKEN */) {
-            const originalVarCall = `var(${tokenName})`;
-            suggestedMatch = `var(${recommendation}, ${originalVarCall})`;
-          } else if (replacementCategory === "raw_value" /* RAW_VALUE */) {
-            suggestedMatch = recommendation;
+        } else if (hook.properties.includes("*")) {
+          if (distance <= LAB_THRESHOLD) {
+            closestHooksWithAllProperty.push({ name: hook.name, distance });
+          }
+        } else {
+          if (distance <= LAB_THRESHOLD) {
+            closestHooksWithoutSameProperty.push({ name: hook.name, distance });
           }
         }
-        reportAndFix(node, tokenName, suggestedMatch, messageId, data);
+      });
+    }
+  });
+  const closesthookGroups = [
+    { hooks: closestHooksWithSameProperty, distance: 0 },
+    { hooks: closestHooksWithAllProperty, distance: 0 },
+    { hooks: closestHooksWithSameProperty, distance: Infinity },
+    // For hooks with distance > 0
+    { hooks: closestHooksWithAllProperty, distance: Infinity },
+    { hooks: closestHooksWithoutSameProperty, distance: Infinity }
+  ];
+  for (const group of closesthookGroups) {
+    const filteredHooks = group.hooks.filter(
+      (h) => group.distance === 0 ? h.distance === 0 : h.distance > 0
+    );
+    if (returnStylingHooks.length < 1 && filteredHooks.length > 0) {
+      filteredHooks.sort((a, b) => a.distance - b.distance);
+      returnStylingHooks.push(...filteredHooks.slice(0, 5).map((h) => h.name));
+    }
+  }
+  return Array.from(new Set(returnStylingHooks));
+};
+var isValidColor = (val) => import_chroma_js.default.valid(val);
+var extractColorValue = (node) => {
+  let colorValue = null;
+  switch (node.type) {
+    case "Hash":
+      colorValue = `#${node.value}`;
+      break;
+    case "Identifier":
+      colorValue = node.name;
+      break;
+    case "Function":
+      if (isCssColorFunction(node.name)) {
+        colorValue = (0, import_css_tree.generate)(node);
       }
-    };
+      break;
   }
+  return colorValue && isValidColor(colorValue) ? colorValue : null;
 };
 
-// src/rules/v9/enforce-sds-to-slds-hooks.ts
-var import_sds_metadata6 = __toESM(require("@salesforce-ux/sds-metadata"));
-var import_rule_messages6 = __toESM(require_rule_messages());
-var ruleConfig4 = import_rule_messages6.default["enforce-sds-to-slds-hooks"];
-var { type: type5, description: description5, url: url5, messages: messages5 } = ruleConfig4;
-var sldsPlusStylingHooks = import_sds_metadata6.default.sldsPlusStylingHooks;
-var allSldsHooks = [...sldsPlusStylingHooks.global, ...sldsPlusStylingHooks.component];
-var toSldsToken = (sdsToken) => sdsToken.replace("--sds-", "--slds-");
-function shouldIgnoreDetection2(sdsToken) {
-  return !sdsToken.startsWith("--sds-") || !allSldsHooks.includes(toSldsToken(sdsToken));
+// src/utils/hardcoded-shared-utils.ts
+var FONT_WEIGHTS = [
+  "normal",
+  "bold",
+  "bolder",
+  "lighter",
+  "100",
+  "200",
+  "300",
+  "400",
+  "500",
+  "600",
+  "700",
+  "800",
+  "900"
+];
+function isKnownFontWeight(value) {
+  const stringValue = value.toString();
+  return FONT_WEIGHTS.includes(stringValue.toLowerCase());
 }
-var enforce_sds_to_slds_hooks_default = {
+function handleShorthandAutoFix(declarationNode, context, valueText, replacements) {
+  const sortedReplacements = replacements.sort((a, b) => a.start - b.start);
+  const hasAnyHooks = sortedReplacements.some((r) => r.hasHook);
+  const canAutoFix = hasAnyHooks;
+  sortedReplacements.forEach(({ start, end, replacement, displayValue, hasHook }) => {
+    const originalValue = valueText.substring(start, end);
+    const valueStartColumn = declarationNode.value.loc.start.column;
+    const valueColumn = valueStartColumn + start;
+    const { loc: { start: locStart, end: locEnd } } = declarationNode.value;
+    const reportNode = {
+      ...declarationNode.value,
+      loc: {
+        ...declarationNode.value.loc,
+        start: {
+          ...locStart,
+          column: valueColumn
+        },
+        end: {
+          ...locEnd,
+          column: valueColumn + originalValue.length
+        }
+      }
+    };
+    if (hasHook) {
+      const fix = canAutoFix ? (fixer) => {
+        let newValue = valueText;
+        for (let i = sortedReplacements.length - 1; i >= 0; i--) {
+          const { start: rStart, end: rEnd, replacement: rReplacement } = sortedReplacements[i];
+          newValue = newValue.substring(0, rStart) + rReplacement + newValue.substring(rEnd);
+        }
+        return fixer.replaceText(declarationNode.value, newValue);
+      } : void 0;
+      context.context.report({
+        node: reportNode,
+        messageId: "hardcodedValue",
+        data: {
+          oldValue: originalValue,
+          newValue: displayValue
+        },
+        fix
+      });
+    } else {
+      context.context.report({
+        node: reportNode,
+        messageId: "noReplacement",
+        data: {
+          oldValue: originalValue
+        }
+      });
+    }
+  });
+}
+function forEachValue(valueText, extractValue, shouldSkipNode, callback) {
+  if (!valueText || typeof valueText !== "string") {
+    return;
+  }
+  try {
+    const ast = (0, import_css_tree2.parse)(valueText, { context: "value", positions: true });
+    (0, import_css_tree2.walk)(ast, {
+      enter(node) {
+        if (shouldSkipNode(node)) {
+          return this.skip;
+        }
+        const value = extractValue(node);
+        if (value !== null) {
+          const positionInfo = {
+            start: node.loc?.start,
+            end: node.loc?.end
+          };
+          callback(value, positionInfo);
+        }
+      }
+    });
+  } catch (error) {
+    return;
+  }
+}
+function shouldSkipColorNode(node) {
+  return node.type === "Function" && isCssFunction(node.name);
+}
+function shouldSkipDimensionNode(node) {
+  return node.type === "Function";
+}
+function extractDimensionValue(valueNode, cssProperty) {
+  if (!valueNode) return null;
+  switch (valueNode.type) {
+    case "Dimension":
+      const numValue = Number(valueNode.value);
+      if (numValue === 0) return null;
+      const unit = valueNode.unit.toLowerCase();
+      if (!ALLOWED_UNITS.includes(unit)) return null;
+      return {
+        number: numValue,
+        unit
+      };
+    case "Number":
+      const numberValue = Number(valueNode.value);
+      if (numberValue === 0) return null;
+      return {
+        number: numberValue,
+        unit: null
+      };
+    case "Percentage":
+      const percentValue = Number(valueNode.value);
+      if (percentValue === 0) return null;
+      return {
+        number: percentValue,
+        unit: "%"
+      };
+    case "Value":
+      return valueNode.children?.[0] ? extractDimensionValue(valueNode.children[0], cssProperty) : null;
+  }
+  return null;
+}
+function forEachColorValue(valueText, callback) {
+  forEachValue(valueText, extractColorValue, shouldSkipColorNode, callback);
+}
+function forEachDensityValue(valueText, cssProperty, callback) {
+  forEachValue(
+    valueText,
+    (node) => extractDimensionValue(node, cssProperty),
+    shouldSkipDimensionNode,
+    callback
+  );
+}
+function extractFontValue(node) {
+  if (!node) return null;
+  switch (node.type) {
+    case "Dimension":
+      const numValue = Number(node.value);
+      if (numValue <= 0) return null;
+      const unit = node.unit.toLowerCase();
+      if (!ALLOWED_UNITS.includes(unit)) return null;
+      return {
+        number: numValue,
+        unit
+      };
+    case "Number":
+      const numberValue = Number(node.value);
+      if (numberValue <= 0) {
+        return null;
+      }
+      if (!isKnownFontWeight(numberValue)) {
+        return null;
+      }
+      return {
+        number: numberValue,
+        unit: null
+      };
+    case "Identifier":
+      const namedValue = node.name.toLowerCase();
+      if (!isKnownFontWeight(namedValue)) {
+        return null;
+      }
+      if (namedValue === "normal") {
+        return { number: 400, unit: null };
+      }
+      return { number: namedValue, unit: null };
+    case "Percentage":
+      const percentValue = Number(node.value);
+      if (percentValue === 0) return null;
+      return {
+        number: percentValue,
+        unit: "%"
+      };
+    case "Value":
+      return node.children?.[0] ? extractFontValue(node.children[0]) : null;
+  }
+  return null;
+}
+function shouldSkipFontNode(node) {
+  return node.type === "Function";
+}
+function forEachFontValue(valueText, callback) {
+  forEachValue(valueText, extractFontValue, shouldSkipFontNode, callback);
+}
+
+// src/utils/css-utils.ts
+function extractSldsVariable(node) {
+  if (!node || node.type !== "Function" || node.name !== "var") {
+    return null;
+  }
+  if (!node.children) {
+    return null;
+  }
+  const childrenArray = Array.from(node.children);
+  if (childrenArray.length === 0) {
+    return null;
+  }
+  const firstChild = childrenArray[0];
+  if (!firstChild || firstChild.type !== "Identifier") {
+    return null;
+  }
+  const variableName = firstChild.name;
+  if (!variableName || !variableName.startsWith("--slds-")) {
+    return null;
+  }
+  const hasFallback = childrenArray.some(
+    (child) => child.type === "Operator" && child.value === ","
+  );
+  return {
+    name: variableName,
+    hasFallback
+  };
+}
+function forEachSldsVariable(valueText, callback) {
+  forEachValue(valueText, extractSldsVariable, () => false, callback);
+}
+function formatSuggestionHooks(hooks) {
+  if (hooks.length === 1) {
+    return `${hooks[0]}`;
+  }
+  return "\n" + hooks.map((hook, index) => `${index + 1}. ${hook}`).join("\n");
+}
+
+// src/rules/v9/lwc-token-to-slds-hook.ts
+var ruleConfig3 = import_rule_messages5.default["lwc-token-to-slds-hook"];
+var { type: type4, description: description4, url: url4, messages: messages4 } = ruleConfig3;
+var lwcToSlds = import_next5.default.lwcToSlds;
+function shouldIgnoreDetection(lwcToken) {
+  return !lwcToken.startsWith("--lwc-") || !(lwcToken in lwcToSlds) || lwcToSlds[lwcToken].continueToUse;
+}
+function categorizeReplacement(recommendation) {
+  if (!recommendation || recommendation === "--") {
+    return "empty" /* EMPTY */;
+  }
+  if (Array.isArray(recommendation)) {
+    return "array" /* ARRAY */;
+  }
+  if (typeof recommendation === "string" && recommendation.startsWith("--slds-")) {
+    return "slds_token" /* SLDS_TOKEN */;
+  }
+  return "raw_value" /* RAW_VALUE */;
+}
+function getRecommendation(lwcToken) {
+  const oldValue = lwcToken;
+  const recommendation = lwcToSlds[oldValue]?.replacement || "";
+  const replacementCategory = categorizeReplacement(recommendation);
+  const hasRecommendation = oldValue in lwcToSlds && replacementCategory !== "empty" /* EMPTY */;
+  return { hasRecommendation, recommendation, replacementCategory };
+}
+function getReportMessage(cssVar, replacementCategory, recommendation) {
+  if (!recommendation) {
+    return {
+      messageId: "errorWithNoRecommendation",
+      data: { oldValue: cssVar }
+    };
+  } else if (replacementCategory === "array" /* ARRAY */) {
+    return {
+      messageId: "errorWithStyleHooks",
+      data: { oldValue: cssVar, newValue: formatSuggestionHooks(recommendation) }
+    };
+  } else if (replacementCategory === "slds_token" /* SLDS_TOKEN */) {
+    return {
+      messageId: "errorWithStyleHooks",
+      data: { oldValue: cssVar, newValue: recommendation }
+    };
+  } else {
+    return {
+      messageId: "errorWithReplacement",
+      data: { oldValue: cssVar, newValue: recommendation }
+    };
+  }
+}
+var lwc_token_to_slds_hook_default = {
   meta: {
-    type: type5,
+    type: type4,
     docs: {
-      description: description5,
+      description: description4,
       recommended: true,
-      url: url5
+      url: url4
     },
     fixable: "code",
-    messages: messages5
+    messages: messages4
   },
   create(context) {
-    function reportAndFix(node, oldValue, suggestedMatch) {
-      context.report({
-        node,
-        messageId: "replaceSdsWithSlds",
-        data: { oldValue, suggestedMatch },
-        fix(fixer) {
+    function reportAndFix(node, oldValue, suggestedMatch, messageId, data) {
+      let fixFunction = null;
+      if (suggestedMatch) {
+        fixFunction = (fixer) => {
           if (node.type === "Declaration") {
             const sourceCode = context.sourceCode;
             const fullText = sourceCode.getText();
@@ -881,496 +1168,249 @@ var enforce_sds_to_slds_hooks_default = {
             if (textAtPosition === oldValue) {
               return fixer.replaceTextRange([propertyStart, propertyEnd], suggestedMatch);
             }
+          } else {
+            const sourceCode = context.sourceCode;
+            const fullText = sourceCode.getText();
+            const varFunctionCall = `var(${oldValue})`;
+            const nodeOffset = node.loc.start.offset;
+            const searchStart = Math.max(0, nodeOffset - 4);
+            const searchEnd = nodeOffset + oldValue.length + 1;
+            const searchArea = fullText.substring(searchStart, searchEnd);
+            const functionCallIndex = searchArea.indexOf(varFunctionCall);
+            if (functionCallIndex !== -1) {
+              const actualStart = searchStart + functionCallIndex;
+              const actualEnd = actualStart + varFunctionCall.length;
+              return fixer.replaceTextRange([actualStart, actualEnd], suggestedMatch);
+            }
           }
-          return fixer.replaceText(node, suggestedMatch);
-        }
+          return null;
+        };
+      }
+      context.report({
+        node,
+        messageId,
+        data,
+        fix: fixFunction
       });
     }
     return {
-      // CSS custom property declarations: --sds-* properties
-      "Declaration[property=/^--sds-/]"(node) {
+      // CSS custom property declarations: --lwc-* properties
+      "Declaration[property=/^--lwc-/]"(node) {
         const property = node.property;
-        if (shouldIgnoreDetection2(property)) {
+        if (shouldIgnoreDetection(property)) {
           return;
         }
-        const suggestedMatch = toSldsToken(property);
-        reportAndFix(node, property, suggestedMatch);
+        const { hasRecommendation, recommendation, replacementCategory } = getRecommendation(property);
+        const { messageId, data } = getReportMessage(property, replacementCategory, recommendation);
+        const suggestedMatch = hasRecommendation && replacementCategory === "slds_token" /* SLDS_TOKEN */ ? recommendation : null;
+        reportAndFix(node, property, suggestedMatch, messageId, data);
       },
-      // SDS tokens inside var() functions: var(--sds-*)
-      "Function[name='var'] Identifier[name=/^--sds-/]"(node) {
+      // LWC tokens inside var() functions: var(--lwc-*)
+      "Function[name='var'] Identifier[name=/^--lwc-/]"(node) {
         const tokenName = node.name;
-        if (shouldIgnoreDetection2(tokenName)) {
+        if (shouldIgnoreDetection(tokenName)) {
           return;
         }
-        const suggestedMatch = toSldsToken(tokenName);
-        reportAndFix(node, tokenName, suggestedMatch);
-      }
-    };
-  }
-};
-
-// src/rules/v9/no-sldshook-fallback-for-lwctoken.ts
-var import_sds_metadata7 = __toESM(require("@salesforce-ux/sds-metadata"));
-var import_rule_messages7 = __toESM(require_rule_messages());
-var ruleConfig5 = import_rule_messages7.default["no-sldshook-fallback-for-lwctoken"];
-var { type: type6, description: description6, url: url6, messages: messages6 } = ruleConfig5;
-var sldsPlusStylingHooks2 = import_sds_metadata7.default.sldsPlusStylingHooks;
-var allSldsHooks2 = [...sldsPlusStylingHooks2.global, ...sldsPlusStylingHooks2.component];
-var allSldsHooksSet = new Set(allSldsHooks2);
-function hasUnsupportedFallback(lwcToken, sldsToken) {
-  const normalizedSldsToken = sldsToken.replace("--sds-", "--slds-");
-  return lwcToken.startsWith("--lwc-") && normalizedSldsToken.startsWith("--slds-") && allSldsHooksSet.has(normalizedSldsToken);
-}
-var no_sldshook_fallback_for_lwctoken_default = {
-  meta: {
-    type: type6,
-    docs: {
-      description: description6,
-      recommended: true,
-      url: url6
-    },
-    messages: messages6
-  },
-  create(context) {
-    return {
-      // Handle LWC tokens inside var() functions: var(--lwc-*, ...)
-      "Function[name='var'] Identifier[name=/^--lwc-/]"(node) {
-        const lwcToken = node.name;
-        const varFunctionNode = context.sourceCode.getAncestors(node).at(-1);
-        if (!varFunctionNode) return;
-        const varFunctionChildren = varFunctionNode.children;
-        if (!varFunctionChildren) return;
-        let foundComma = false;
-        let fallbackRawNode = null;
-        for (const child of varFunctionChildren) {
-          if (child.type === "Operator" && child.value === ",") {
-            foundComma = true;
-            continue;
-          }
-          if (foundComma && child.type === "Raw") {
-            fallbackRawNode = child;
-            break;
+        const { hasRecommendation, recommendation, replacementCategory } = getRecommendation(tokenName);
+        const { messageId, data } = getReportMessage(tokenName, replacementCategory, recommendation);
+        let suggestedMatch = null;
+        if (hasRecommendation) {
+          if (replacementCategory === "slds_token" /* SLDS_TOKEN */) {
+            const originalVarCall = `var(${tokenName})`;
+            suggestedMatch = `var(${recommendation}, ${originalVarCall})`;
+          } else if (replacementCategory === "raw_value" /* RAW_VALUE */) {
+            suggestedMatch = recommendation;
           }
         }
-        if (!fallbackRawNode) return;
-        const fallbackValue = fallbackRawNode.value.trim();
-        const varMatch = fallbackValue.match(/var\(([^,)]+)/);
-        if (!varMatch) return;
-        const sldsToken = varMatch[1];
-        if (hasUnsupportedFallback(lwcToken, sldsToken)) {
-          context.report({
-            node,
-            messageId: "unsupportedFallback",
-            data: { lwcToken, sldsToken }
-          });
-        }
+        reportAndFix(node, tokenName, suggestedMatch, messageId, data);
       }
     };
   }
 };
 
-// src/rules/v9/no-unsupported-hooks-slds2.ts
-var import_sds_metadata8 = __toESM(require("@salesforce-ux/sds-metadata"));
-var import_rule_messages8 = __toESM(require_rule_messages());
-var ruleConfig6 = import_rule_messages8.default["no-unsupported-hooks-slds2"];
-var { type: type7, description: description7, url: url7, messages: messages7 } = ruleConfig6;
-var deprecatedHooks = new Set(import_sds_metadata8.default.deprecatedStylingHooks);
-function shouldIgnoreDetection3(sldsHook) {
-  return !deprecatedHooks.has(sldsHook);
+// src/rules/v9/enforce-sds-to-slds-hooks.ts
+var import_next6 = __toESM(require("@salesforce-ux/sds-metadata/next"));
+var import_rule_messages6 = __toESM(require_rule_messages());
+var ruleConfig4 = import_rule_messages6.default["enforce-sds-to-slds-hooks"];
+var { type: type5, description: description5, url: url5, messages: messages5 } = ruleConfig4;
+var sldsPlusStylingHooks = import_next6.default.sldsPlusStylingHooks;
+var allSldsHooks = [...sldsPlusStylingHooks.global, ...sldsPlusStylingHooks.component];
+var toSldsToken = (sdsToken) => sdsToken.replace("--sds-", "--slds-");
+function shouldIgnoreDetection2(sdsToken) {
+  return !sdsToken.startsWith("--sds-") || !allSldsHooks.includes(toSldsToken(sdsToken));
 }
-var no_unsupported_hooks_slds2_default = {
+var enforce_sds_to_slds_hooks_default = {
   meta: {
-    type: type7,
+    type: type5,
     docs: {
-      description: description7,
+      description: description5,
       recommended: true,
-      url: url7
+      url: url5
     },
-    messages: messages7
+    fixable: "code",
+    messages: messages5
   },
   create(context) {
-    function reportDeprecatedHook(node, token) {
+    function reportAndFix(node, oldValue, suggestedMatch) {
       context.report({
         node,
-        messageId: "deprecated",
-        data: { token }
+        messageId: "replaceSdsWithSlds",
+        data: { oldValue, suggestedMatch },
+        fix(fixer) {
+          if (node.type === "Declaration") {
+            const sourceCode = context.sourceCode;
+            const fullText = sourceCode.getText();
+            const nodeOffset = node.loc.start.offset;
+            const propertyStart = nodeOffset;
+            const propertyEnd = propertyStart + oldValue.length;
+            const textAtPosition = fullText.substring(propertyStart, propertyEnd);
+            if (textAtPosition === oldValue) {
+              return fixer.replaceTextRange([propertyStart, propertyEnd], suggestedMatch);
+            }
+          }
+          return fixer.replaceText(node, suggestedMatch);
+        }
       });
     }
     return {
-      // Handle CSS custom property declarations (left-side usage): --slds-* properties
-      // Example: .THIS { --slds-g-link-color: #f73650; }
-      "Declaration[property=/^--s(lds|ds)-/]"(node) {
+      // CSS custom property declarations: --sds-* properties
+      "Declaration[property=/^--sds-/]"(node) {
         const property = node.property;
-        if (shouldIgnoreDetection3(property)) {
+        if (shouldIgnoreDetection2(property)) {
           return;
         }
-        reportDeprecatedHook(node, property);
+        const suggestedMatch = toSldsToken(property);
+        reportAndFix(node, property, suggestedMatch);
       },
-      // Handle SLDS/SDS hooks inside var() functions (right-side usage): var(--slds-*)
-      // Example: .THIS .demo { border-top: 1px solid var(--slds-g-color-border-brand-1); }
-      "Function[name='var'] Identifier[name=/^--s(lds|ds)-/]"(node) {
+      // SDS tokens inside var() functions: var(--sds-*)
+      "Function[name='var'] Identifier[name=/^--sds-/]"(node) {
         const tokenName = node.name;
-        if (shouldIgnoreDetection3(tokenName)) {
+        if (shouldIgnoreDetection2(tokenName)) {
           return;
         }
-        reportDeprecatedHook(node, tokenName);
+        const suggestedMatch = toSldsToken(tokenName);
+        reportAndFix(node, tokenName, suggestedMatch);
       }
     };
   }
 };
 
-// src/rules/v9/no-slds-var-without-fallback.ts
-var import_sds_metadata9 = __toESM(require("@salesforce-ux/sds-metadata"));
-var import_rule_messages9 = __toESM(require_rule_messages());
-
-// src/utils/hardcoded-shared-utils.ts
-var import_css_tree2 = require("@eslint/css-tree");
-
-// src/utils/color-lib-utils.ts
-var import_chroma_js = __toESM(require("chroma-js"));
-var import_css_tree = require("@eslint/css-tree");
-
-// src/utils/css-functions.ts
-var CSS_FUNCTIONS = [
-  "attr",
-  "calc",
-  "color-mix",
-  "conic-gradient",
-  "counter",
-  "cubic-bezier",
-  "linear-gradient",
-  "max",
-  "min",
-  "radial-gradient",
-  "repeating-conic-gradient",
-  "repeating-linear-gradient",
-  "repeating-radial-gradient",
-  "var"
-];
-var CSS_MATH_FUNCTIONS = ["calc", "min", "max"];
-var RGB_COLOR_FUNCTIONS = ["rgb", "rgba", "hsl", "hsla"];
-var cssFunctionsRegex = new RegExp(`(?:${CSS_FUNCTIONS.join("|")})`);
-var cssFunctionsExactRegex = new RegExp(`^(?:${CSS_FUNCTIONS.join("|")})$`);
-var cssMathFunctionsRegex = new RegExp(`^(?:${CSS_MATH_FUNCTIONS.join("|")})$`);
-function isCssFunction(value) {
-  return cssFunctionsExactRegex.test(value);
-}
-function isCssColorFunction(value) {
-  return RGB_COLOR_FUNCTIONS.includes(value);
+// src/rules/v9/no-sldshook-fallback-for-lwctoken.ts
+var import_next7 = __toESM(require("@salesforce-ux/sds-metadata/next"));
+var import_rule_messages7 = __toESM(require_rule_messages());
+var ruleConfig5 = import_rule_messages7.default["no-sldshook-fallback-for-lwctoken"];
+var { type: type6, description: description6, url: url6, messages: messages6 } = ruleConfig5;
+var sldsPlusStylingHooks2 = import_next7.default.sldsPlusStylingHooks;
+var allSldsHooks2 = [...sldsPlusStylingHooks2.global, ...sldsPlusStylingHooks2.component];
+var allSldsHooksSet = new Set(allSldsHooks2);
+function hasUnsupportedFallback(lwcToken, sldsToken) {
+  const normalizedSldsToken = sldsToken.replace("--sds-", "--slds-");
+  return lwcToken.startsWith("--lwc-") && normalizedSldsToken.startsWith("--slds-") && allSldsHooksSet.has(normalizedSldsToken);
 }
-
-// src/utils/color-lib-utils.ts
-var LAB_THRESHOLD = 25;
-var isHexCode = (color) => {
-  const hexPattern = /^#(?:[0-9a-fA-F]{3}){1,2}$/;
-  return hexPattern.test(color);
-};
-var convertToHex = (color) => {
-  try {
-    return (0, import_chroma_js.default)(color).hex();
-  } catch (e) {
-    return null;
-  }
-};
-var findClosestColorHook = (color, supportedColors, cssProperty) => {
-  const returnStylingHooks = [];
-  const closestHooksWithSameProperty = [];
-  const closestHooksWithoutSameProperty = [];
-  const closestHooksWithAllProperty = [];
-  const labColor = (0, import_chroma_js.default)(color).lab();
-  Object.entries(supportedColors).forEach(([sldsValue, data]) => {
-    if (sldsValue && isHexCode(sldsValue)) {
-      const hooks = data;
-      hooks.forEach((hook) => {
-        const labSupportedColor = (0, import_chroma_js.default)(sldsValue).lab();
-        const distance = JSON.stringify(labColor) === JSON.stringify(labSupportedColor) ? 0 : import_chroma_js.default.distance(import_chroma_js.default.lab(...labColor), import_chroma_js.default.lab(...labSupportedColor), "lab");
-        if (hook.properties.includes(cssProperty)) {
-          if (distance <= LAB_THRESHOLD) {
-            closestHooksWithSameProperty.push({ name: hook.name, distance });
-          }
-        } else if (hook.properties.includes("*")) {
-          if (distance <= LAB_THRESHOLD) {
-            closestHooksWithAllProperty.push({ name: hook.name, distance });
+var no_sldshook_fallback_for_lwctoken_default = {
+  meta: {
+    type: type6,
+    docs: {
+      description: description6,
+      recommended: true,
+      url: url6
+    },
+    messages: messages6
+  },
+  create(context) {
+    return {
+      // Handle LWC tokens inside var() functions: var(--lwc-*, ...)
+      "Function[name='var'] Identifier[name=/^--lwc-/]"(node) {
+        const lwcToken = node.name;
+        const varFunctionNode = context.sourceCode.getAncestors(node).at(-1);
+        if (!varFunctionNode) return;
+        const varFunctionChildren = varFunctionNode.children;
+        if (!varFunctionChildren) return;
+        let foundComma = false;
+        let fallbackRawNode = null;
+        for (const child of varFunctionChildren) {
+          if (child.type === "Operator" && child.value === ",") {
+            foundComma = true;
+            continue;
           }
-        } else {
-          if (distance <= LAB_THRESHOLD) {
-            closestHooksWithoutSameProperty.push({ name: hook.name, distance });
+          if (foundComma && child.type === "Raw") {
+            fallbackRawNode = child;
+            break;
           }
         }
-      });
-    }
-  });
-  const closesthookGroups = [
-    { hooks: closestHooksWithSameProperty, distance: 0 },
-    { hooks: closestHooksWithAllProperty, distance: 0 },
-    { hooks: closestHooksWithSameProperty, distance: Infinity },
-    // For hooks with distance > 0
-    { hooks: closestHooksWithAllProperty, distance: Infinity },
-    { hooks: closestHooksWithoutSameProperty, distance: Infinity }
-  ];
-  for (const group of closesthookGroups) {
-    const filteredHooks = group.hooks.filter(
-      (h) => group.distance === 0 ? h.distance === 0 : h.distance > 0
-    );
-    if (returnStylingHooks.length < 1 && filteredHooks.length > 0) {
-      filteredHooks.sort((a, b) => a.distance - b.distance);
-      returnStylingHooks.push(...filteredHooks.slice(0, 5).map((h) => h.name));
-    }
-  }
-  return Array.from(new Set(returnStylingHooks));
-};
-var isValidColor = (val) => import_chroma_js.default.valid(val);
-var extractColorValue = (node) => {
-  let colorValue = null;
-  switch (node.type) {
-    case "Hash":
-      colorValue = `#${node.value}`;
-      break;
-    case "Identifier":
-      colorValue = node.name;
-      break;
-    case "Function":
-      if (isCssColorFunction(node.name)) {
-        colorValue = (0, import_css_tree.generate)(node);
-      }
-      break;
-  }
-  return colorValue && isValidColor(colorValue) ? colorValue : null;
-};
-
-// src/utils/hardcoded-shared-utils.ts
-var FONT_WEIGHTS = [
-  "normal",
-  "bold",
-  "bolder",
-  "lighter",
-  "100",
-  "200",
-  "300",
-  "400",
-  "500",
-  "600",
-  "700",
-  "800",
-  "900"
-];
-function isKnownFontWeight(value) {
-  const stringValue = value.toString();
-  return FONT_WEIGHTS.includes(stringValue.toLowerCase());
-}
-function handleShorthandAutoFix(declarationNode, context, valueText, replacements) {
-  const sortedReplacements = replacements.sort((a, b) => a.start - b.start);
-  const hasAnyHooks = sortedReplacements.some((r) => r.hasHook);
-  const canAutoFix = hasAnyHooks;
-  sortedReplacements.forEach(({ start, end, replacement, displayValue, hasHook }) => {
-    const originalValue = valueText.substring(start, end);
-    const valueStartColumn = declarationNode.value.loc.start.column;
-    const valueColumn = valueStartColumn + start;
-    const { loc: { start: locStart, end: locEnd } } = declarationNode.value;
-    const reportNode = {
-      ...declarationNode.value,
-      loc: {
-        ...declarationNode.value.loc,
-        start: {
-          ...locStart,
-          column: valueColumn
-        },
-        end: {
-          ...locEnd,
-          column: valueColumn + originalValue.length
-        }
-      }
-    };
-    if (hasHook) {
-      const fix = canAutoFix ? (fixer) => {
-        let newValue = valueText;
-        for (let i = sortedReplacements.length - 1; i >= 0; i--) {
-          const { start: rStart, end: rEnd, replacement: rReplacement } = sortedReplacements[i];
-          newValue = newValue.substring(0, rStart) + rReplacement + newValue.substring(rEnd);
-        }
-        return fixer.replaceText(declarationNode.value, newValue);
-      } : void 0;
-      context.context.report({
-        node: reportNode,
-        messageId: "hardcodedValue",
-        data: {
-          oldValue: originalValue,
-          newValue: displayValue
-        },
-        fix
-      });
-    } else {
-      context.context.report({
-        node: reportNode,
-        messageId: "noReplacement",
-        data: {
-          oldValue: originalValue
-        }
-      });
-    }
-  });
-}
-function forEachValue(valueText, extractValue, shouldSkipNode, callback) {
-  if (!valueText || typeof valueText !== "string") {
-    return;
-  }
-  try {
-    const ast = (0, import_css_tree2.parse)(valueText, { context: "value", positions: true });
-    (0, import_css_tree2.walk)(ast, {
-      enter(node) {
-        if (shouldSkipNode(node)) {
-          return this.skip;
-        }
-        const value = extractValue(node);
-        if (value !== null) {
-          const positionInfo = {
-            start: node.loc?.start,
-            end: node.loc?.end
-          };
-          callback(value, positionInfo);
+        if (!fallbackRawNode) return;
+        const fallbackValue = fallbackRawNode.value.trim();
+        const varMatch = fallbackValue.match(/var\(([^,)]+)/);
+        if (!varMatch) return;
+        const sldsToken = varMatch[1];
+        if (hasUnsupportedFallback(lwcToken, sldsToken)) {
+          context.report({
+            node,
+            messageId: "unsupportedFallback",
+            data: { lwcToken, sldsToken }
+          });
         }
       }
-    });
-  } catch (error) {
-    return;
-  }
-}
-function shouldSkipColorNode(node) {
-  return node.type === "Function" && isCssFunction(node.name);
-}
-function shouldSkipDimensionNode(node) {
-  return node.type === "Function";
-}
-function extractDimensionValue(valueNode, cssProperty) {
-  if (!valueNode) return null;
-  switch (valueNode.type) {
-    case "Dimension":
-      const numValue = Number(valueNode.value);
-      if (numValue === 0) return null;
-      const unit = valueNode.unit.toLowerCase();
-      if (unit !== "px" && unit !== "rem" && unit !== "%") return null;
-      return {
-        number: numValue,
-        unit
-      };
-    case "Number":
-      const numberValue = Number(valueNode.value);
-      if (numberValue === 0) return null;
-      return {
-        number: numberValue,
-        unit: null
-      };
-    case "Percentage":
-      const percentValue = Number(valueNode.value);
-      if (percentValue === 0) return null;
-      return {
-        number: percentValue,
-        unit: "%"
-      };
-    case "Value":
-      return valueNode.children?.[0] ? extractDimensionValue(valueNode.children[0], cssProperty) : null;
+    };
   }
-  return null;
-}
-function forEachColorValue(valueText, callback) {
-  forEachValue(valueText, extractColorValue, shouldSkipColorNode, callback);
-}
-function forEachDensityValue(valueText, cssProperty, callback) {
-  forEachValue(
-    valueText,
-    (node) => extractDimensionValue(node, cssProperty),
-    shouldSkipDimensionNode,
-    callback
-  );
+};
+
+// src/rules/v9/no-unsupported-hooks-slds2.ts
+var import_next8 = __toESM(require("@salesforce-ux/sds-metadata/next"));
+var import_rule_messages8 = __toESM(require_rule_messages());
+var ruleConfig6 = import_rule_messages8.default["no-unsupported-hooks-slds2"];
+var { type: type7, description: description7, url: url7, messages: messages7 } = ruleConfig6;
+var deprecatedHooks = new Set(import_next8.default.deprecatedStylingHooks);
+function shouldIgnoreDetection3(sldsHook) {
+  return !deprecatedHooks.has(sldsHook);
 }
-function extractFontValue(node) {
-  if (!node) return null;
-  switch (node.type) {
-    case "Dimension":
-      const numValue = Number(node.value);
-      if (numValue <= 0) return null;
-      const unit = node.unit.toLowerCase();
-      if (unit !== "px" && unit !== "rem" && unit !== "%") return null;
-      return {
-        number: numValue,
-        unit
-      };
-    case "Number":
-      const numberValue = Number(node.value);
-      if (numberValue <= 0) {
-        return null;
-      }
-      if (!isKnownFontWeight(numberValue)) {
-        return null;
-      }
-      return {
-        number: numberValue,
-        unit: null
-      };
-    case "Identifier":
-      const namedValue = node.name.toLowerCase();
-      if (!isKnownFontWeight(namedValue)) {
-        return null;
-      }
-      if (namedValue === "normal") {
-        return { number: 400, unit: null };
+var no_unsupported_hooks_slds2_default = {
+  meta: {
+    type: type7,
+    docs: {
+      description: description7,
+      recommended: true,
+      url: url7
+    },
+    messages: messages7
+  },
+  create(context) {
+    function reportDeprecatedHook(node, token) {
+      context.report({
+        node,
+        messageId: "deprecated",
+        data: { token }
+      });
+    }
+    return {
+      // Handle CSS custom property declarations (left-side usage): --slds-* properties
+      // Example: .THIS { --slds-g-link-color: #f73650; }
+      "Declaration[property=/^--s(lds|ds)-/]"(node) {
+        const property = node.property;
+        if (shouldIgnoreDetection3(property)) {
+          return;
+        }
+        reportDeprecatedHook(node, property);
+      },
+      // Handle SLDS/SDS hooks inside var() functions (right-side usage): var(--slds-*)
+      // Example: .THIS .demo { border-top: 1px solid var(--slds-g-color-border-brand-1); }
+      "Function[name='var'] Identifier[name=/^--s(lds|ds)-/]"(node) {
+        const tokenName = node.name;
+        if (shouldIgnoreDetection3(tokenName)) {
+          return;
+        }
+        reportDeprecatedHook(node, tokenName);
       }
-      return { number: namedValue, unit: null };
-    case "Percentage":
-      const percentValue = Number(node.value);
-      if (percentValue === 0) return null;
-      return {
-        number: percentValue,
-        unit: "%"
-      };
-    case "Value":
-      return node.children?.[0] ? extractFontValue(node.children[0]) : null;
-  }
-  return null;
-}
-function shouldSkipFontNode(node) {
-  return node.type === "Function";
-}
-function forEachFontValue(valueText, callback) {
-  forEachValue(valueText, extractFontValue, shouldSkipFontNode, callback);
-}
-
-// src/utils/css-utils.ts
-function extractSldsVariable(node) {
-  if (!node || node.type !== "Function" || node.name !== "var") {
-    return null;
-  }
-  if (!node.children) {
-    return null;
-  }
-  const childrenArray = Array.from(node.children);
-  if (childrenArray.length === 0) {
-    return null;
-  }
-  const firstChild = childrenArray[0];
-  if (!firstChild || firstChild.type !== "Identifier") {
-    return null;
-  }
-  const variableName = firstChild.name;
-  if (!variableName || !variableName.startsWith("--slds-")) {
-    return null;
+    };
   }
-  const hasFallback = childrenArray.some(
-    (child) => child.type === "Operator" && child.value === ","
-  );
-  return {
-    name: variableName,
-    hasFallback
-  };
-}
-function forEachSldsVariable(valueText, callback) {
-  forEachValue(valueText, extractSldsVariable, () => false, callback);
-}
+};
 
 // src/rules/v9/no-slds-var-without-fallback.ts
+var import_next9 = __toESM(require("@salesforce-ux/sds-metadata/next"));
+var import_rule_messages9 = __toESM(require_rule_messages());
 var ruleConfig7 = import_rule_messages9.default["no-slds-var-without-fallback"];
 var { type: type8, description: description8, url: url8, messages: messages8 } = ruleConfig7;
-var sldsVariables = import_sds_metadata9.default.slds1ExcludedVars || {};
+var sldsVariables = import_next9.default.slds1ExcludedVars || {};
 var no_slds_var_without_fallback_default = {
   meta: {
     type: type8,
@@ -1422,11 +1462,11 @@ var no_slds_var_without_fallback_default = {
 };
 
 // src/rules/v9/no-slds-namespace-for-custom-hooks.ts
-var import_sds_metadata10 = __toESM(require("@salesforce-ux/sds-metadata"));
+var import_next10 = __toESM(require("@salesforce-ux/sds-metadata/next"));
 var import_rule_messages10 = __toESM(require_rule_messages());
 var ruleConfig8 = import_rule_messages10.default["no-slds-namespace-for-custom-hooks"];
 var { type: type9, description: description9, url: url9, messages: messages9 } = ruleConfig8;
-var sldsPlusStylingHooks3 = import_sds_metadata10.default.sldsPlusStylingHooks;
+var sldsPlusStylingHooks3 = import_next10.default.sldsPlusStylingHooks;
 var allSldsHooks3 = [...sldsPlusStylingHooks3.global, ...sldsPlusStylingHooks3.component];
 var toSldsToken2 = (sdsToken) => sdsToken.replace("--sds-", "--slds-");
 function shouldIgnoreDetection4(sdsToken) {
@@ -1479,11 +1519,11 @@ var no_slds_namespace_for_custom_hooks_default = {
 };
 
 // src/rules/v9/enforce-component-hook-naming-convention.ts
-var import_sds_metadata11 = __toESM(require("@salesforce-ux/sds-metadata"));
+var import_next11 = __toESM(require("@salesforce-ux/sds-metadata/next"));
 var import_rule_messages11 = __toESM(require_rule_messages());
 var ruleConfig9 = import_rule_messages11.default["enforce-component-hook-naming-convention"];
 var { type: type10, description: description10, url: url10, messages: messages10 } = ruleConfig9;
-var slds1DeprecatedComponentHooks = import_sds_metadata11.default.slds1DeprecatedComponentHooks;
+var slds1DeprecatedComponentHooks = import_next11.default.slds1DeprecatedComponentHooks;
 function shouldIgnoreDetection5(hook) {
   return !hook.startsWith("--slds-c-") || !(hook in slds1DeprecatedComponentHooks);
 }
@@ -1626,7 +1666,7 @@ var no_slds_private_var_default = {
 };
 
 // src/rules/v9/no-hardcoded-values/no-hardcoded-values-slds1.ts
-var import_sds_metadata12 = __toESM(require("@salesforce-ux/sds-metadata"));
+var import_next12 = __toESM(require("@salesforce-ux/sds-metadata/next"));
 var import_rule_messages14 = __toESM(require_rule_messages());
 
 // src/utils/property-matcher.ts
@@ -1700,7 +1740,7 @@ function toSelector(properties) {
   const selectorParts = properties.map((prop) => {
     if (prop.includes("*")) {
       const regexPattern = prop.replace(/\*/g, ".*");
-      return `Declaration[property=/${regexPattern}$/]`;
+      return `Declaration[property=/^${regexPattern}$/]`;
     } else {
       return `Declaration[property='${prop}']`;
     }
@@ -1771,9 +1811,8 @@ function createColorReplacement(colorValue, cssProperty, context, positionInfo,
       end,
       replacement: originalValue,
       // Use original value to preserve spacing
-      displayValue: closestHooks.join(", "),
+      displayValue: formatSuggestionHooks(closestHooks),
       hasHook: true
-      // ← THE FIX: Multiple hooks still means "has hooks"
     };
   } else {
     return {
@@ -1787,37 +1826,6 @@ function createColorReplacement(colorValue, cssProperty, context, positionInfo,
   }
 }
 
-// src/utils/value-utils.ts
-function parseUnitValue(value) {
-  if (!value) return null;
-  const match = value.match(/^(-?\d*\.?\d+)(px|rem|%)?$/);
-  if (!match) return null;
-  const number = parseFloat(match[1]);
-  const unit = match[2] ? match[2] : null;
-  if (isNaN(number)) return null;
-  return { number, unit };
-}
-function toAlternateUnitValue(numberVal, unitType) {
-  if (unitType === "px") {
-    let floatValue = parseFloat(`${numberVal / 16}`);
-    if (!isNaN(floatValue)) {
-      return {
-        unit: "rem",
-        number: parseFloat(floatValue.toFixed(4))
-      };
-    }
-  } else if (unitType === "rem") {
-    const intValue = parseInt(`${numberVal * 16}`);
-    if (!isNaN(intValue)) {
-      return {
-        unit: "px",
-        number: intValue
-      };
-    }
-  }
-  return null;
-}
-
 // src/utils/styling-hook-utils.ts
 function isValueMatch(valueToMatch, sldsValue) {
   if (!valueToMatch || !sldsValue) {
@@ -1875,7 +1883,7 @@ function createDimensionReplacement(parsedDimension, cssProperty, context, posit
       start,
       end,
       replacement: rawValue,
-      displayValue: closestHooks.join(", "),
+      displayValue: formatSuggestionHooks(closestHooks),
       hasHook: true
     };
   } else {
@@ -1942,7 +1950,7 @@ function createFontReplacement(fontValue, cssProperty, context, positionInfo) {
       start,
       end,
       replacement: rawValue,
-      displayValue: closestHooks.join(", "),
+      displayValue: formatSuggestionHooks(closestHooks),
       hasHook: true
     };
   } else {
@@ -2069,59 +2077,51 @@ function isBoxShadowMatch(parsedCssValue, parsedValueHook) {
 }
 
 // src/rules/v9/no-hardcoded-values/handlers/boxShadowHandler.ts
-function containsCssVariable(valueText) {
-  return valueText.includes("var(");
-}
-var handleBoxShadowDeclaration = (node, context) => {
-  const cssProperty = node.property.toLowerCase();
-  const valueText = context.sourceCode.getText(node.value);
-  if (containsCssVariable(valueText)) {
-    return;
-  }
-  const replacements = [];
-  const parsedCssValue = parseAndValidateBoxShadow(valueText);
-  if (parsedCssValue) {
-    const shadowHooks = getBoxShadowHooks(context.valueToStylinghook);
-    const closestHooks = findMatchingBoxShadowHooks(parsedCssValue, shadowHooks);
-    const positionInfo = {
-      start: { offset: 0, line: 1, column: 1 },
-      end: { offset: valueText.length, line: 1, column: valueText.length + 1 }
-    };
-    const replacement = createBoxShadowReplacement(
-      valueText,
-      closestHooks,
-      context,
-      positionInfo
-    );
-    if (replacement) {
-      replacements.push(replacement);
-    }
+function toBoxShadowValue(cssValue) {
+  const parsedCssValue = parseBoxShadowValue(cssValue).filter((shadow) => Object.keys(shadow).length > 0);
+  if (parsedCssValue.length === 0) {
+    return null;
   }
-  handleShorthandAutoFix(node, context, valueText, replacements);
-};
-function getBoxShadowHooks(supportedStylinghooks) {
+  return parsedCssValue;
+}
+function shadowValueToHookEntries(supportedStylinghooks) {
   return Object.entries(supportedStylinghooks).filter(([key, value]) => {
     return value.some((hook) => hook.properties.includes("box-shadow"));
   }).map(([key, value]) => {
     return [key, value.map((hook) => hook.name)];
   });
 }
-function parseAndValidateBoxShadow(cssValue) {
-  const parsedCssValue = parseBoxShadowValue(cssValue).filter((shadow) => Object.keys(shadow).length > 0);
-  if (parsedCssValue.length === 0) {
-    return null;
+var handleBoxShadowDeclaration = (node, context) => {
+  const cssProperty = node.property.toLowerCase();
+  const valueText = context.sourceCode.getText(node.value);
+  const shadowHooks = shadowValueToHookEntries(context.valueToStylinghook);
+  const parsedCssValue = toBoxShadowValue(valueText);
+  if (!parsedCssValue) {
+    return;
   }
-  return parsedCssValue;
-}
-function findMatchingBoxShadowHooks(parsedCssValue, shadowHooks) {
-  for (const [shadowHookValue, closestHooks] of shadowHooks) {
-    const parsedHookValue = parseAndValidateBoxShadow(shadowHookValue);
-    if (parsedHookValue && isBoxShadowMatch(parsedCssValue, parsedHookValue)) {
-      return closestHooks;
+  for (const [shadow, closestHooks] of shadowHooks) {
+    const parsedValueHook = toBoxShadowValue(shadow);
+    if (parsedValueHook && isBoxShadowMatch(parsedCssValue, parsedValueHook)) {
+      if (closestHooks.length > 0) {
+        const positionInfo = {
+          start: { offset: 0, line: 1, column: 1 },
+          end: { offset: valueText.length, line: 1, column: valueText.length + 1 }
+        };
+        const replacement = createBoxShadowReplacement(
+          valueText,
+          closestHooks,
+          context,
+          positionInfo
+        );
+        if (replacement) {
+          const replacements = [replacement];
+          handleShorthandAutoFix(node, context, valueText, replacements);
+        }
+      }
+      return;
     }
   }
-  return [];
-}
+};
 function createBoxShadowReplacement(originalValue, hooks, context, positionInfo) {
   if (!positionInfo?.start) {
     return null;
@@ -2136,21 +2136,13 @@ function createBoxShadowReplacement(originalValue, hooks, context, positionInfo)
       displayValue: hooks[0],
       hasHook: true
     };
-  } else if (hooks.length > 1) {
-    return {
-      start,
-      end,
-      replacement: originalValue,
-      displayValue: hooks.join(", "),
-      hasHook: true
-    };
   } else {
     return {
       start,
       end,
       replacement: originalValue,
-      displayValue: originalValue,
-      hasHook: false
+      displayValue: formatSuggestionHooks(hooks),
+      hasHook: true
     };
   }
 }
@@ -2251,7 +2243,7 @@ function defineNoHardcodedValueRule(config) {
 var ruleName = "no-hardcoded-values-slds1";
 var ruleConfig12 = import_rule_messages14.default[ruleName];
 var { type: type13, description: description13, url: url13, messages: messages13 } = ruleConfig12;
-var valueToStylinghook = import_sds_metadata12.default.valueToStylingHooksSlds;
+var valueToStylinghook = import_next12.default.valueToStylingHooksSlds;
 var no_hardcoded_values_slds1_default = defineNoHardcodedValueRule({
   ruleConfig: ruleConfig12,
   valueToStylinghook,
@@ -2259,12 +2251,12 @@ var no_hardcoded_values_slds1_default = defineNoHardcodedValueRule({
 });
 
 // src/rules/v9/no-hardcoded-values/no-hardcoded-values-slds2.ts
-var import_sds_metadata13 = __toESM(require("@salesforce-ux/sds-metadata"));
+var import_next13 = __toESM(require("@salesforce-ux/sds-metadata/next"));
 var import_rule_messages15 = __toESM(require_rule_messages());
 var ruleName2 = "no-hardcoded-values-slds2";
 var ruleConfig13 = import_rule_messages15.default[ruleName2];
 var { type: type14, description: description14, url: url14, messages: messages14 } = ruleConfig13;
-var valueToStylinghook2 = import_sds_metadata13.default.valueToStylingHooksCosmos;
+var valueToStylinghook2 = import_next13.default.valueToStylingHooksCosmos;
 var no_hardcoded_values_slds2_default = defineNoHardcodedValueRule({
   ruleConfig: ruleConfig13,
   valueToStylinghook: valueToStylinghook2,
@@ -2275,11 +2267,14 @@ var no_hardcoded_values_slds2_default = defineNoHardcodedValueRule({
 var import_parser2 = __toESM(require("@html-eslint/parser"));
 var import_css = __toESM(require("@eslint/css"));
 
-// eslint.rules.json
-var eslint_rules_default = {
+// eslint.rules.internal.json
+var eslint_rules_internal_default = {
   css: {
+    "@salesforce-ux/slds/enforce-bem-usage": "warn",
     "@salesforce-ux/slds/no-slds-class-overrides": "warn",
     "@salesforce-ux/slds/no-deprecated-slds-classes": "warn",
+    "@salesforce-ux/slds/no-deprecated-tokens-slds1": "error",
+    "@salesforce-ux/slds/lwc-token-to-slds-hook": "error",
     "@salesforce-ux/slds/enforce-sds-to-slds-hooks": "warn",
     "@salesforce-ux/slds/no-sldshook-fallback-for-lwctoken": "warn",
     "@salesforce-ux/slds/no-unsupported-hooks-slds2": "warn",
@@ -2287,6 +2282,7 @@ var eslint_rules_default = {
     "@salesforce-ux/slds/no-slds-namespace-for-custom-hooks": "warn",
     "@salesforce-ux/slds/enforce-component-hook-naming-convention": "error",
     "@salesforce-ux/slds/no-slds-private-var": "warn",
+    "@salesforce-ux/slds/no-hardcoded-values-slds1": "error",
     "@salesforce-ux/slds/no-hardcoded-values-slds2": "warn",
     "@salesforce-ux/slds/reduce-annotations": "warn"
   },
@@ -2320,7 +2316,7 @@ var rules = {
 var plugin = {
   meta: {
     name: "@salesforce-ux/eslint-plugin-slds",
-    version: "1.0.0"
+    version: "1.0.2-internal"
   },
   rules,
   configs: {}
@@ -2339,10 +2335,10 @@ var cssConfigArray = [
       css: import_css.default,
       "@salesforce-ux/slds": plugin
     },
-    rules: eslint_rules_default.css,
+    rules: eslint_rules_internal_default.css,
     settings: {
       // Pass rules configuration to context for runtime access
-      sldsRules: { ...eslint_rules_default.css }
+      sldsRules: { ...eslint_rules_internal_default.css }
     }
   }
 ];
@@ -2358,7 +2354,7 @@ var htmlConfigArray = [
     plugins: {
       "@salesforce-ux/slds": plugin
     },
-    rules: eslint_rules_default.html
+    rules: eslint_rules_internal_default.html
   }
 ];
 Object.assign(plugin.configs, {
@@ -2369,7 +2365,7 @@ Object.assign(plugin.configs, {
   // legacy config for ESLint v8-
   recommended: {
     plugins: ["@salesforce-ux/slds"],
-    rules: eslint_rules_default.html,
+    rules: eslint_rules_internal_default.html,
     parser: import_parser2.default,
     parserOptions: {
       ecmaVersion: 2021,