postcss-normalize-positions 8.0.2 → 8.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postcss-normalize-positions",
-  "version": "8.0.2",
+  "version": "8.0.4",
   "description": "Normalize keyword values for position into length values.",
   "exports": {
     ".": {
@@ -31,7 +31,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "cssnano/cssnano"
+    "url": "git+https://github.com/cssnano/cssnano.git"
   },
   "dependencies": {
     "postcss-value-parser": "^4.2.0"
@@ -43,9 +43,12 @@
     "node": "^22.11.0 || ^24.11.0 || >=26.0"
   },
   "devDependencies": {
-    "postcss": "^8.5.25"
+    "postcss": "^8.5.26"
   },
   "peerDependencies": {
-    "postcss": "^8.5.25"
+    "postcss": "^8.5.26"
+  },
+  "scripts": {
+    "test": "node --test"
   }
 }

package/src/index.js

@@ -16,6 +16,7 @@ const mathFunctions = new Set(['calc', 'min', 'max', 'clamp']);
 const variableFunctions = new Set(['var', 'env', 'constant']);
 const propFilterRegex =
   /^(background(-position)?|(-\w+-)?perspective-origin)$/i;
+
 /**
  * @param {valueParser.Node} node
  * @return {boolean}
@@ -56,9 +57,9 @@ function isNumberNode(node) {
     return false;
   }
 
-  const value = parseFloat(node.value);
+  const value = Number.parseFloat(node.value);
 
-  return !isNaN(value);
+  return !Number.isNaN(value);
 }
 
 /**
@@ -85,22 +86,36 @@ function isDimensionNode(node) {
  */
 function transform(value) {
   const parsed = valueParser(value);
-  /** @type {({start: number, end: number} | {start: null, end: null})[]} */
+  const ranges = collectRanges(parsed.nodes);
+
+  for (const range of ranges) {
+    normalizeRange(parsed, range);
+  }
+
+  return parsed.toString();
+}
+
+/**
+ * @param {valueParser.Node[]} nodes
+ * @return {{start: number | null, end: number | null}[]}
+ */
+function collectRanges(nodes) {
+  /** @type {{start: number | null, end: number | null}[]} */
   const ranges = [];
   let rangeIndex = 0;
   let shouldContinue = true;
 
-  parsed.nodes.forEach((node, index) => {
+  for (const [index, node] of nodes.entries()) {
     // After comma (`,`) follows next background
     if (isCommaNode(node)) {
       rangeIndex += 1;
       shouldContinue = true;
 
-      return;
+      continue;
     }
 
     if (!shouldContinue) {
-      return;
+      continue;
     }
 
     // After separator (`/`) follows `background-size` values
@@ -108,7 +123,7 @@ function transform(value) {
     if (node.type === 'div' && node.value === '/') {
       shouldContinue = false;
 
-      return;
+      continue;
     }
 
     if (!ranges[rangeIndex]) {
@@ -124,7 +139,7 @@ function transform(value) {
       ranges[rangeIndex].start = null;
       ranges[rangeIndex].end = null;
 
-      return;
+      continue;
     }
 
     const isPositionKeyword =
@@ -138,7 +153,7 @@ function transform(value) {
       ranges[rangeIndex].start = index;
       ranges[rangeIndex].end = index;
 
-      return;
+      continue;
     }
 
     if (ranges[rangeIndex].start !== null) {
@@ -146,58 +161,84 @@ function transform(value) {
         ranges[rangeIndex].end = index;
       }
     }
-  });
+  }
 
-  ranges.forEach((range) => {
-    if (range.start === null) {
-      return;
-    }
+  return ranges;
+}
 
-    const nodes = parsed.nodes.slice(range.start, range.end + 1);
+/**
+ * @param {{nodes: valueParser.Node[]}} parsed
+ * @param {{start: number | null, end: number | null}} range
+ * @return {void}
+ */
+function normalizeRange(parsed, range) {
+  if (range.start === null || range.end === null) {
+    return;
+  }
 
-    if (nodes.length > 3) {
-      return;
-    }
+  const nodes = parsed.nodes.slice(range.start, range.end + 1);
+
+  if (nodes.length > 3) {
+    return;
+  }
 
-    const firstNode = nodes[0].value.toLowerCase();
-    const secondNode =
-      nodes[2] && nodes[2].value ? nodes[2].value.toLowerCase() : null;
+  const firstNode = nodes[0].value.toLowerCase();
+  const secondNode =
+    nodes[2] && nodes[2].value ? nodes[2].value.toLowerCase() : null;
 
-    if (nodes.length === 1 || secondNode === 'center') {
-      if (secondNode) {
-        nodes[2].value = nodes[1].value = '';
-      }
+  if (nodes.length === 1 || secondNode === 'center') {
+    normalizeSinglePosition(nodes, firstNode, secondNode);
+    return;
+  }
 
-      const map = new Map([...horizontal, ['center', center]]);
+  normalizePairPosition(nodes, firstNode, secondNode);
+}
 
-      if (map.has(firstNode)) {
-        nodes[0].value = /** @type {string}*/ (map.get(firstNode));
-      }
+/**
+ * @param {valueParser.Node[]} nodes
+ * @param {string} firstNode
+ * @param {string | null} secondNode
+ * @return {void}
+ */
+function normalizeSinglePosition(nodes, firstNode, secondNode) {
+  if (secondNode) {
+    nodes[2].value = nodes[1].value = '';
+  }
 
-      return;
-    }
+  const map = new Map([...horizontal, ['center', center]]);
 
-    if (secondNode !== null) {
-      if (firstNode === 'center' && directionKeywords.has(secondNode)) {
-        nodes[0].value = nodes[1].value = '';
+  if (map.has(firstNode)) {
+    nodes[0].value = /** @type {string}*/ (map.get(firstNode));
+  }
+}
 
-        if (horizontal.has(secondNode)) {
-          nodes[2].value = /** @type {string} */ (horizontal.get(secondNode));
-        }
-        return;
-      }
+/**
+ * @param {valueParser.Node[]} nodes
+ * @param {string} firstNode
+ * @param {string | null} secondNode
+ * @return {void}
+ */
+function normalizePairPosition(nodes, firstNode, secondNode) {
+  if (secondNode === null) {
+    return;
+  }
 
-      if (horizontal.has(firstNode) && verticalValue.has(secondNode)) {
-        nodes[0].value = /** @type {string} */ (horizontal.get(firstNode));
-        nodes[2].value = /** @type {string} */ (verticalValue.get(secondNode));
-      } else if (verticalValue.has(firstNode) && horizontal.has(secondNode)) {
-        nodes[0].value = /** @type {string} */ (horizontal.get(secondNode));
-        nodes[2].value = /** @type {string} */ (verticalValue.get(firstNode));
-      }
+  if (firstNode === 'center' && directionKeywords.has(secondNode)) {
+    nodes[0].value = nodes[1].value = '';
+
+    if (horizontal.has(secondNode)) {
+      nodes[2].value = /** @type {string} */ (horizontal.get(secondNode));
     }
-  });
+    return;
+  }
 
-  return parsed.toString();
+  if (horizontal.has(firstNode) && verticalValue.has(secondNode)) {
+    nodes[0].value = /** @type {string} */ (horizontal.get(firstNode));
+    nodes[2].value = /** @type {string} */ (verticalValue.get(secondNode));
+  } else if (verticalValue.has(firstNode) && horizontal.has(secondNode)) {
+    nodes[0].value = /** @type {string} */ (horizontal.get(secondNode));
+    nodes[2].value = /** @type {string} */ (verticalValue.get(firstNode));
+  }
 }
 
 /**