postcss-calc 11.0.0 → 11.0.2

package/README.md

@@ -206,6 +206,8 @@ when changing parsing/simplification behavior:
 pnpm test:corpus:full
 ```
 
+Profile long arithmetic parser chains with `pnpm benchmark:arithmetic-chains`.
+
 ## [Changelog](CHANGELOG.md)
 
 ## [License](LICENSE)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postcss-calc",
-  "version": "11.0.0",
+  "version": "11.0.2",
   "type": "module",
   "description": "PostCSS plugin to reduce calc()",
   "keywords": [
@@ -13,7 +13,7 @@
   "homepage": "https://github.com/postcss/postcss-calc",
   "repository": {
     "type": "git",
-    "url": "https://github.com/postcss/postcss-calc.git"
+    "url": "git+https://github.com/postcss/postcss-calc.git"
   },
   "exports": {
     ".": {
@@ -34,16 +34,16 @@
   "devEngines": {
     "packageManager": {
       "name": "pnpm",
-      "version": "11.22.0"
+      "version": "11.25.0"
     }
   },
   "devDependencies": {
     "@csstools/css-calc": "^3.3.0",
     "@rmenke/css-tokenizer-tests": "^1.2.0",
-    "@types/node": "^26.2.0",
+    "@types/node": "^26.4.0",
     "fast-check": "^4.9.0",
-    "oxfmt": "^0.64.0",
-    "oxlint": "^1.79.0",
+    "oxfmt": "^0.65.0",
+    "oxlint": "^1.80.0",
     "postcss": "^8.5.26",
     "typescript": "~7.0.2"
   },
@@ -57,6 +57,7 @@
   "scripts": {
     "lint": "oxlint . && tsc && oxfmt --check",
     "fmt": "oxfmt",
+    "benchmark:arithmetic-chains": "node scripts/benchmark-arithmetic-chains.mjs",
     "test": "node --test --test-reporter=dot 'test/**/*.test.mjs' test/index.cjs test/convertUnit.cjs",
     "test:mutation:corpus": "node test/mutation/corpus-selection.mjs",
     "test:corpus:full": "POSTCSS_CALC_FULL_CORPUS=1 node --test test/conformance/corpus.test.mjs"

package/src/lib/parser.js

@@ -1,14 +1,13 @@
 // Pratt parser. +/- emit Sum nodes; */÷ emit Product nodes. node.js
 // constructors flatten and normalize on construction, while parenthesized
 // sums retain a grouping marker for the opaque-subtraction invariant.
-import { mkSum, mkProduct, negate, ident, call } from './node.js';
+import { mkSum, mkProduct, negate, num, dim, ident, call } from './node.js';
 
 /**
  * @typedef {import('./tokenizer.js').Token} Token
  * @typedef {import('./tokenizer.js').TokenType} TokenType
  * @typedef {import('./node.js').Node} Node
  * @typedef {(p: Parser, token: Token) => Node} PrefixParselet
- * @typedef {{lbp: number, parse: (p: Parser, left: Node, token: Token) => Node}} InfixParselet
  */
 
 /**
@@ -30,17 +29,17 @@ function foldCalcKeyword(name) {
   // form arrives as a single ident because CSS Syntax tokenizes leading
   // `-` + ident-start as one ident-token.
   if (name === 'NaN' || name === '-NaN') {
-    return { type: 'Num', value: Number.NaN };
+    return num(Number.NaN);
   }
   switch (name.toLowerCase()) {
     case 'pi':
-      return { type: 'Num', value: Math.PI };
+      return num(Math.PI);
     case 'e':
-      return { type: 'Num', value: Math.E };
+      return num(Math.E);
     case 'infinity':
-      return { type: 'Num', value: Infinity };
+      return num(Infinity);
     case '-infinity':
-      return { type: 'Num', value: -Infinity };
+      return num(-Infinity);
   }
   return null;
 }
@@ -102,40 +101,58 @@ class Parser {
       if (!rule || rule.lbp < minBp) {
         break;
       }
-      this.next();
-      left = rule.parse(this, left, nxt);
+      if (infixKey === '+' || infixKey === '-') {
+        /** @type {import('./node.js').SumTerm[]} */
+        const terms = [{ sign: /** @type {1} */ (1), node: left }];
+        do {
+          const token = this.next();
+          requireSurroundingWs(this, token);
+          terms.push({
+            sign: /** @type {1 | -1} */ (token.value === '+' ? 1 : -1),
+            node: this.parseExpr(ADD_BP + 1),
+          });
+          const next = this.peek();
+          if (
+            next.type !== 'punct' ||
+            (next.value !== '+' && next.value !== '-')
+          ) {
+            break;
+          }
+        } while (ADD_BP >= minBp);
+        left = mkSum(terms);
+        continue;
+      }
+
+      if (infixKey === '*' || infixKey === '/') {
+        /** @type {import('./node.js').ProductFactor[]} */
+        const factors = [{ exponent: /** @type {1} */ (1), node: left }];
+        do {
+          const token = this.next();
+          factors.push({
+            exponent: /** @type {1 | -1} */ (token.value === '*' ? 1 : -1),
+            node: this.parseExpr(MUL_BP + 1),
+          });
+          const next = this.peek();
+          if (
+            next.type !== 'punct' ||
+            (next.value !== '*' && next.value !== '/')
+          ) {
+            break;
+          }
+        } while (MUL_BP >= minBp);
+        left = mkProduct(factors);
+        continue;
+      }
+
+      // Every infix operator is handled above. Keep this defensive exit in
+      // case a future parselet is added without a chain implementation.
+      break;
     }
 
     return left;
   }
 }
 
-/**
- * @param {Node} left
- * @param {Node} right
- * @param {1 | -1} rightSign
- * @return {Node}
- */
-function addTerm(left, right, rightSign) {
-  return mkSum([
-    { sign: 1, node: left },
-    { sign: rightSign, node: right },
-  ]);
-}
-
-/**
- * @param {Node} left
- * @param {Node} right
- * @param {1 | -1} rightExp
- * @return {Node}
- */
-function mulFactor(left, right, rightExp) {
-  return mkProduct([
-    { exponent: 1, node: left },
-    { exponent: rightExp, node: right },
-  ]);
-}
-
 const ADD_BP = 1;
 const MUL_BP = 3;
 const UNARY_BP = 7;
@@ -228,14 +245,14 @@ function requireSurroundingWs(p, token) {
 
 /** @type {Record<string, PrefixParselet>} */
 const PREFIX = {
-  number: (_p, t) => ({ type: 'Num', value: Number.parseFloat(t.value) }),
+  number: (_p, t) => num(Number.parseFloat(t.value)),
 
   // Unit case normalization per §10.12: `1PX` serializes as `1px`.
-  dimension: (_p, t) => ({
-    type: 'Dim',
-    value: Number.parseFloat(t.value),
-    unit: t.unit === '%' ? '%' : /** @type {string} */ (t.unit).toLowerCase(),
-  }),
+  dimension: (_p, t) =>
+    dim(
+      Number.parseFloat(t.value),
+      t.unit === '%' ? '%' : /** @type {string} */ (t.unit).toLowerCase()
+    ),
 
   ident: (p, t) => {
     const nxt = p.peek();
@@ -273,30 +290,12 @@ const PREFIX = {
   '+': (p) => p.parseExpr(UNARY_BP),
 };
 
-/** @type {Record<string, InfixParselet>} */
+/** @type {Record<string, {lbp: number}>} */
 const INFIX = {
-  '+': {
-    lbp: ADD_BP,
-    parse: (p, left, token) => {
-      requireSurroundingWs(p, token);
-      return addTerm(left, p.parseExpr(ADD_BP + 1), 1);
-    },
-  },
-  '-': {
-    lbp: ADD_BP,
-    parse: (p, left, token) => {
-      requireSurroundingWs(p, token);
-      return addTerm(left, p.parseExpr(ADD_BP + 1), -1);
-    },
-  },
-  '*': {
-    lbp: MUL_BP,
-    parse: (p, left) => mulFactor(left, p.parseExpr(MUL_BP + 1), 1),
-  },
-  '/': {
-    lbp: MUL_BP,
-    parse: (p, left) => mulFactor(left, p.parseExpr(MUL_BP + 1), -1),
-  },
+  '+': { lbp: ADD_BP },
+  '-': { lbp: ADD_BP },
+  '*': { lbp: MUL_BP },
+  '/': { lbp: MUL_BP },
 };
 
 /**

package/src/lib/serialize.js

@@ -59,6 +59,25 @@ function degenerateKeyword(v) {
   return v > 0 ? 'infinity' : '-infinity';
 }
 
+/**
+ * Serialize a finite CSS number. CSS numbers may omit the zero before a
+ * fractional value between -1 and 1 (`.5`, `-.5`). Scientific notation is
+ * left untouched because it already has no leading zero to remove.
+ *
+ * @param {number} v
+ * @return {string}
+ */
+function serializeNumber(v) {
+  const text = String(v);
+  if (text.startsWith('0.')) {
+    return text.slice(1);
+  }
+  if (text.startsWith('-0.')) {
+    return `-${text.slice(2)}`;
+  }
+  return text;
+}
+
 /**
  * @param {Node} node
  * @param {SerializeOptions} [opts]
@@ -127,7 +146,7 @@ function serializeExpr(node, prec) {
       if (isDegenerate(node.value)) {
         return degenerateKeyword(node.value);
       }
-      return String(round(node.value, prec));
+      return serializeNumber(round(node.value, prec));
     case 'Dim':
       if (isDegenerate(node.value)) {
         // Nested degenerate Dim wraps in calc() so the `<kw> * 1<unit>` form
@@ -135,7 +154,7 @@ function serializeExpr(node, prec) {
         // inside a Product — `0 * Dim(Infinity, px)` would re-fold as NaN.
         return `calc(${degenerateKeyword(node.value)} * 1${node.unit})`;
       }
-      return `${round(node.value, prec)}${node.unit}`;
+      return `${serializeNumber(round(node.value, prec))}${node.unit}`;
     case 'Ident':
       return node.name;
     case 'Call': {

package/types/lib/parser.d.ts

@@ -2,10 +2,6 @@ export type Token = import('./tokenizer.js').Token;
 export type TokenType = import('./tokenizer.js').TokenType;
 export type Node = import('./node.js').Node;
 export type PrefixParselet = (p: Parser, token: Token) => Node;
-export type InfixParselet = {
-    lbp: number;
-    parse: (p: Parser, left: Node, token: Token) => Node;
-};
 declare class Parser {
     /** @private */
     i;