postcss-calc 7.0.4 → 8.2.0

package/dist/index.js

@@ -5,38 +5,60 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _postcss = require("postcss");
-
 var _transform = _interopRequireDefault(require("./lib/transform"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var _default = (0, _postcss.plugin)('postcss-calc', function (opts) {
-  var options = Object.assign({
+/**
+ * @typedef {{precision?: number | false,
+ *          preserve?: boolean, 
+ *          warnWhenCannotResolve?: boolean, 
+ *          mediaQueries?: boolean, 
+ *          selectors?: boolean}} PostCssCalcOptions
+ *
+ * @param {PostCssCalcOptions} opts
+ */
+function pluginCreator(opts) {
+  const options = Object.assign({
     precision: 5,
     preserve: false,
     warnWhenCannotResolve: false,
     mediaQueries: false,
     selectors: false
   }, opts);
-  return function (css, result) {
-    css.walk(function (node) {
-      var type = node.type;
-
-      if (type === 'decl') {
-        (0, _transform.default)(node, "value", options, result);
-      }
-
-      if (type === 'atrule' && options.mediaQueries) {
-        (0, _transform.default)(node, "params", options, result);
-      }
-
-      if (type === 'rule' && options.selectors) {
-        (0, _transform.default)(node, "selector", options, result);
-      }
-    });
+  return {
+    postcssPlugin: 'postcss-calc',
+
+    /**
+     * @param {import('postcss').Root} css
+     * @param {{result: import('postcss').Result}} helpers
+     */
+    OnceExit(css, {
+      result
+    }) {
+      css.walk(node => {
+        const {
+          type
+        } = node;
+
+        if (type === 'decl') {
+          (0, _transform.default)(node, "value", options, result);
+        }
+
+        if (type === 'atrule' && options.mediaQueries) {
+          (0, _transform.default)(node, "params", options, result);
+        }
+
+        if (type === 'rule' && options.selectors) {
+          (0, _transform.default)(node, "selector", options, result);
+        }
+      });
+    }
+
   };
-});
+}
 
+pluginCreator.postcss = true;
+var _default = pluginCreator;
 exports.default = _default;
 module.exports = exports.default;

package/dist/lib/convertUnit.js

@@ -4,7 +4,11 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-var conversions = {
+
+/**
+ * @type {{[key:string]: {[key:string]: number}}}
+ */
+const conversions = {
   // Absolute length units
   'px': {
     'px': 1,
@@ -129,10 +133,16 @@ var conversions = {
     'dppx': 1
   }
 };
+/**
+ * @param {number} value
+ * @param {string} sourceUnit
+ * @param {string} targetUnit
+ * @param {number|false} precision 
+ */
 
 function convertUnit(value, sourceUnit, targetUnit, precision) {
-  var sourceUnitNormalized = sourceUnit.toLowerCase();
-  var targetUnitNormalized = targetUnit.toLowerCase();
+  const sourceUnitNormalized = sourceUnit.toLowerCase();
+  const targetUnitNormalized = targetUnit.toLowerCase();
 
   if (!conversions[targetUnitNormalized]) {
     throw new Error("Cannot convert to " + targetUnit);
@@ -142,10 +152,10 @@ function convertUnit(value, sourceUnit, targetUnit, precision) {
     throw new Error("Cannot convert from " + sourceUnit + " to " + targetUnit);
   }
 
-  var converted = conversions[targetUnitNormalized][sourceUnitNormalized] * value;
+  const converted = conversions[targetUnitNormalized][sourceUnitNormalized] * value;
 
   if (precision !== false) {
-    precision = Math.pow(10, parseInt(precision) || 5);
+    precision = Math.pow(10, Math.ceil(precision) || 5);
     return Math.round(converted * precision) / precision;
   }
 

package/dist/lib/reducer.js

@@ -9,12 +9,12 @@ var _convertUnit = _interopRequireDefault(require("./convertUnit"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function isEqual(left, right) {
-  return left.type === right.type && left.value === right.value;
-}
-
-function isValueType(type) {
-  switch (type) {
+/**
+ * @param {import('../parser').CalcNode} node
+ * @return {node is import('../parser').ValueExpression}
+ */
+function isValueType(node) {
+  switch (node.type) {
     case 'LengthValue':
     case 'AngleValue':
     case 'TimeValue':
@@ -35,213 +35,168 @@ function isValueType(type) {
 
   return false;
 }
+/** @param {'-'|'+'} operator */
+
 
 function flip(operator) {
   return operator === '+' ? '-' : '+';
 }
+/**
+ * @param {string} operator
+ * @returns {operator is '+'|'-'}
+ */
 
-function flipValue(node) {
-  if (isValueType(node.type)) {
-    node.value = -node.value;
-  } else if (node.type === 'MathExpression') {
-    if (node.operator === '*' || node.operator === '/') {
-      node.left = flipValue(node.left);
-    } else {
-      node.left = flipValue(node.left);
-      node.right = flipValue(node.right);
-    }
-  }
 
-  return node;
+function isAddSubOperator(operator) {
+  return operator === '+' || operator === '-';
 }
+/**
+ * @typedef {{preOperator: '+'|'-', node: import('../parser').CalcNode}} Collectible
+*/
 
-function reduceAddSubExpression(node, precision) {
-  // something + 0 => something
-  // something - 0 => something
-  if (isValueType(node.right.type) && node.right.value === 0) {
-    return node.left;
-  } // 0 + something => something
-
+/**
+ * @param {'+'|'-'} preOperator
+ * @param {import('../parser').CalcNode} node
+ * @param {Collectible[]} collected 
+ * @param {number} precision
+ */
 
-  if (isValueType(node.left.type) && node.left.value === 0 && node.operator === "+") {
-    return node.right;
-  } // 0 - something => -something
 
+function collectAddSubItems(preOperator, node, collected, precision) {
+  if (!isAddSubOperator(preOperator)) {
+    throw new Error(`invalid operator ${preOperator}`);
+  }
 
-  if (isValueType(node.left.type) && node.left.value === 0 && node.operator === "-" && !isCSSFunction(node.right)) {
-    return flipValue(node.right);
-  } // value + value
-  // value - value
+  if (isValueType(node)) {
+    const itemIndex = collected.findIndex(x => x.node.type === node.type);
 
+    if (itemIndex >= 0) {
+      if (node.value === 0) {
+        return;
+      } // can cast because of the criterion used to find itemIndex
 
-  if (isValueType(node.left.type) && node.left.type === node.right.type) {
-    var operator = node.operator;
 
-    var _covertNodesUnits = covertNodesUnits(node.left, node.right, precision),
-        left = _covertNodesUnits.left,
-        right = _covertNodesUnits.right;
+      const otherValueNode =
+      /** @type import('../parser').ValueExpression*/
+      collected[itemIndex].node;
+      const {
+        left: reducedNode,
+        right: current
+      } = convertNodesUnits(otherValueNode, node, precision);
 
-    if (operator === "+") {
-      left.value += right.value;
-    } else {
-      left.value -= right.value;
-    }
-
-    return left;
-  } // value <op> (expr)
+      if (collected[itemIndex].preOperator === '-') {
+        collected[itemIndex].preOperator = '+';
+        reducedNode.value *= -1;
+      }
 
+      if (preOperator === "+") {
+        reducedNode.value += current.value;
+      } else {
+        reducedNode.value -= current.value;
+      } // make sure reducedNode.value >= 0
 
-  if (node.right.type === 'MathExpression' && (node.right.operator === '+' || node.right.operator === '-')) {
-    // something - (something + something) => something - something - something
-    // something - (something - something) => something - something + something
-    if ((node.right.operator === '+' || node.right.operator === '-') && node.operator === '-') {
-      node.right.operator = flip(node.right.operator);
-    }
 
-    if (isValueType(node.left.type)) {
-      // value + (value + something) => value + something
-      // value + (value - something) => value - something
-      // value - (value + something) => value - something
-      // value - (value - something) => value + something
-      if (node.left.type === node.right.left.type) {
-        var _left = node.left,
-            _operator = node.operator,
-            _right = node.right;
-        node.left = reduce({
-          type: 'MathExpression',
-          operator: _operator,
-          left: _left,
-          right: _right.left
+      if (reducedNode.value >= 0) {
+        collected[itemIndex] = {
+          node: reducedNode,
+          preOperator: '+'
+        };
+      } else {
+        reducedNode.value *= -1;
+        collected[itemIndex] = {
+          node: reducedNode,
+          preOperator: '-'
+        };
+      }
+    } else {
+      // make sure node.value >= 0
+      if (node.value >= 0) {
+        collected.push({
+          node,
+          preOperator
         });
-        node.operator = _right.operator;
-        node.right = _right.right;
-        return reduce(node, precision);
-      } // something + (something + value) => dimension + something
-      // something + (something - value) => dimension + something
-      // something - (something + value) => dimension - something
-      // something - (something - value) => dimension - something
-
-
-      if (node.left.type === node.right.right.type) {
-        var _left2 = node.left,
-            _right2 = node.right;
-        node.left = reduce({
-          type: 'MathExpression',
-          operator: _right2.operator,
-          left: _left2,
-          right: _right2.right
+      } else {
+        node.value *= -1;
+        collected.push({
+          node,
+          preOperator: flip(preOperator)
         });
-        node.right = _right2.left;
-        return reduce(node, precision);
       }
     }
-  } // (expr) <op> value
-
-
-  if (node.left.type === 'MathExpression' && (node.left.operator === '+' || node.left.operator === '-') && isValueType(node.right.type)) {
-    // (value + something) + value => value + something
-    // (value - something) + value => value - something
-    // (value + something) - value => value + something
-    // (value - something) - value => value - something
-    if (node.right.type === node.left.left.type) {
-      var _left3 = node.left,
-          _operator2 = node.operator,
-          _right3 = node.right;
-      _left3.left = reduce({
-        type: 'MathExpression',
-        operator: _operator2,
-        left: _left3.left,
-        right: _right3
-      }, precision);
-      return reduce(_left3, precision);
-    } // (something + dimension) + dimension => something + dimension
-    // (something - dimension) + dimension => something - dimension
-    // (something + dimension) - dimension => something + dimension
-    // (something - dimension) - dimension => something - dimension
-
-
-    if (node.right.type === node.left.right.type) {
-      var _left4 = node.left,
-          _operator3 = node.operator,
-          _right4 = node.right;
-
-      if (_left4.operator === '-') {
-        _left4.operator = _operator3 === '-' ? '-' : '+';
-        _left4.right = reduce({
-          type: 'MathExpression',
-          operator: _operator3 === '-' ? '+' : '-',
-          left: _right4,
-          right: _left4.right
-        }, precision);
+  } else if (node.type === "MathExpression") {
+    if (isAddSubOperator(node.operator)) {
+      collectAddSubItems(preOperator, node.left, collected, precision);
+      const collectRightOperator = preOperator === '-' ? flip(node.operator) : node.operator;
+      collectAddSubItems(collectRightOperator, node.right, collected, precision);
+    } else {
+      // * or /
+      const reducedNode = reduce(node, precision); // prevent infinite recursive call
+
+      if (reducedNode.type !== "MathExpression" || isAddSubOperator(reducedNode.operator)) {
+        collectAddSubItems(preOperator, reducedNode, collected, precision);
       } else {
-        _left4.right = reduce({
-          type: 'MathExpression',
-          operator: _operator3,
-          left: _left4.right,
-          right: _right4
-        }, precision);
+        collected.push({
+          node: reducedNode,
+          preOperator
+        });
       }
+    }
+  } else {
+    collected.push({
+      node,
+      preOperator
+    });
+  }
+}
+/**
+ * @param {import('../parser').CalcNode} node
+ * @param {number} precision
+ */
 
-      if (_left4.right.value < 0) {
-        _left4.right.value *= -1;
-        _left4.operator = _left4.operator === '-' ? '+' : '-';
-      }
 
-      _left4.parenthesized = node.parenthesized;
-      return reduce(_left4, precision);
-    }
-  } // (expr) + (expr) => number
-  // (expr) - (expr) => number
-
-
-  if (node.right.type === 'MathExpression' && node.left.type === 'MathExpression') {
-    if (node.left.operator === "-" && node.right.operator === "+" || node.right.operator === "-" && node.left.operator === "+") {
-      // (expr1 - something) + (expr2 + something) => expr1 + expr2
-      // (expr1 + something) + (expr2 - something) => expr1 + expr2
-      // (expr1 - something) - (expr2 + something) => expr1 + expr2
-      // (expr1 + something) - (expr2 - something) => expr1 + expr2
-      if (isEqual(node.left.right, node.right.right)) {
-        var newNodes = covertNodesUnits(node.left.left, node.right.left, precision);
-        node.left = newNodes.left;
-        node.right = newNodes.right;
-        return reduce(node, precision);
-      } // (expr1 - something) + (something + expr2) => expr1 + expr2
-      // (expr1 + something) + (something - expr2) => expr1 + expr2
-      // (expr1 - something) - (something + expr2) => expr1 + expr2
-      // (expr1 + something) - (something - expr2) => expr1 + expr2
-
-
-      if (isEqual(node.left.right, node.right.left)) {
-        var _newNodes = covertNodesUnits(node.left.left, node.right.right, precision);
-
-        node.left = _newNodes.left;
-        node.right = _newNodes.right;
-        return reduce(node, precision);
-      } // (expr1 / something) + (expr2 / something) => (expr1 + expr2) / something
-      // (expr1 * something) + (expr2 * something) => (expr1 + expr2) * something
-      // (expr1 / something) - (expr2 / something) => (expr1 - expr2) / something
-      // (expr1 * something) - (expr2 * something) => (expr1 - expr2) * something
-
-    } else if ((node.left.operator === "/" || node.left.operator === "*") && node.left.operator === node.right.operator && isEqual(node.left.right, node.right.right)) {
-      return reduce({
-        type: "MathExpression",
-        operator: node.left.operator,
-        left: {
-          type: "MathExpression",
-          operator: node.operator,
-          left: node.left.left,
-          right: node.right.left
-        },
-        right: node.left.right
-      }, precision);
+function reduceAddSubExpression(node, precision) {
+  /** @type Collectible[] */
+  const collected = [];
+  collectAddSubItems('+', node, collected, precision);
+  const withoutZeroItem = collected.filter(item => !(isValueType(item.node) && item.node.value === 0));
+  const firstNonZeroItem = withoutZeroItem[0]; // could be undefined
+  // prevent producing "calc(-var(--a))" or "calc()"
+  // which is invalid css
+
+  if (!firstNonZeroItem || firstNonZeroItem.preOperator === '-' && !isValueType(firstNonZeroItem.node)) {
+    const firstZeroItem = collected.find(item => isValueType(item.node) && item.node.value === 0);
+
+    if (firstZeroItem) {
+      withoutZeroItem.unshift(firstZeroItem);
     }
+  } // make sure the preOperator of the first item is +
+
+
+  if (withoutZeroItem[0].preOperator === '-' && isValueType(withoutZeroItem[0].node)) {
+    withoutZeroItem[0].node.value *= -1;
+    withoutZeroItem[0].preOperator = '+';
   }
 
-  return node;
+  let root = withoutZeroItem[0].node;
+
+  for (let i = 1; i < withoutZeroItem.length; i++) {
+    root = {
+      type: 'MathExpression',
+      operator: withoutZeroItem[i].preOperator,
+      left: root,
+      right: withoutZeroItem[i].node
+    };
+  }
+
+  return root;
 }
+/**
+ * @param {import('../parser').MathExpression} node
+ */
+
 
 function reduceDivisionExpression(node) {
-  if (!isValueType(node.right.type)) {
+  if (!isValueType(node.right)) {
     return node;
   }
 
@@ -249,54 +204,119 @@ function reduceDivisionExpression(node) {
     throw new Error(`Cannot divide by "${node.right.unit}", number expected`);
   }
 
-  if (node.right.value === 0) {
-    throw new Error('Cannot divide by zero');
-  } // something / value
+  return applyNumberDivision(node.left, node.right.value);
+}
+/**
+ * apply (expr) / number
+ *
+ * @param {import('../parser').CalcNode} node
+ * @param {number} divisor
+ * @return {import('../parser').CalcNode}
+*/
 
 
-  if (isValueType(node.left.type)) {
-    node.left.value /= node.right.value;
-    return node.left;
+function applyNumberDivision(node, divisor) {
+  if (divisor === 0) {
+    throw new Error('Cannot divide by zero');
   }
 
-  return node;
-}
+  if (isValueType(node)) {
+    node.value /= divisor;
+    return node;
+  }
 
-function reduceMultiplicationExpression(node) {
-  // (expr) * number
-  if (node.left.type === 'MathExpression' && node.right.type === 'Number') {
-    if (isValueType(node.left.left.type) && isValueType(node.left.right.type)) {
-      node.left.left.value *= node.right.value;
-      node.left.right.value *= node.right.value;
-      return node.left;
+  if (node.type === "MathExpression" && isAddSubOperator(node.operator)) {
+    // turn (a + b) / num into a/num + b/num
+    // is good for further reduction
+    // checkout the test case
+    // "should reduce division before reducing additions"
+    return {
+      type: "MathExpression",
+      operator: node.operator,
+      left: applyNumberDivision(node.left, divisor),
+      right: applyNumberDivision(node.right, divisor)
+    };
+  } // it is impossible to reduce it into a single value
+  // .e.g the node contains css variable
+  // so we just preserve the division and let browser do it
+
+
+  return {
+    type: "MathExpression",
+    operator: '/',
+    left: node,
+    right: {
+      type: "Number",
+      value: divisor
     }
-  } // something * number
+  };
+}
+/**
+ * @param {import('../parser').MathExpression} node
+ */
 
 
-  if (isValueType(node.left.type) && node.right.type === 'Number') {
-    node.left.value *= node.right.value;
-    return node.left;
+function reduceMultiplicationExpression(node) {
+  // (expr) * number
+  if (node.right.type === 'Number') {
+    return applyNumberMultiplication(node.left, node.right.value);
   } // number * (expr)
 
 
-  if (node.left.type === 'Number' && node.right.type === 'MathExpression') {
-    if (isValueType(node.right.left.type) && isValueType(node.right.right.type)) {
-      node.right.left.value *= node.left.value;
-      node.right.right.value *= node.left.value;
-      return node.right;
-    }
-  } // number * something
+  if (node.left.type === 'Number') {
+    return applyNumberMultiplication(node.right, node.left.value);
+  }
+
+  return node;
+}
+/**
+ * apply (expr) * number
+ * @param {number} multiplier
+ * @param {import('../parser').CalcNode} node
+ * @return {import('../parser').CalcNode}
+ */
 
 
-  if (node.left.type === 'Number' && isValueType(node.right.type)) {
-    node.right.value *= node.left.value;
-    return node.right;
+function applyNumberMultiplication(node, multiplier) {
+  if (isValueType(node)) {
+    node.value *= multiplier;
+    return node;
   }
 
-  return node;
+  if (node.type === "MathExpression" && isAddSubOperator(node.operator)) {
+    // turn (a + b) * num into a*num + b*num
+    // is good for further reduction
+    // checkout the test case
+    // "should reduce multiplication before reducing additions"
+    return {
+      type: "MathExpression",
+      operator: node.operator,
+      left: applyNumberMultiplication(node.left, multiplier),
+      right: applyNumberMultiplication(node.right, multiplier)
+    };
+  } // it is impossible to reduce it into a single value
+  // .e.g the node contains css variable
+  // so we just preserve the division and let browser do it
+
+
+  return {
+    type: "MathExpression",
+    operator: '*',
+    left: node,
+    right: {
+      type: "Number",
+      value: multiplier
+    }
+  };
 }
+/**
+ * @param {import('../parser').ValueExpression} left
+ * @param {import('../parser').ValueExpression} right
+ * @param {number} precision
+ */
+
 
-function covertNodesUnits(left, right, precision) {
+function convertNodesUnits(left, right, precision) {
   switch (left.type) {
     case 'LengthValue':
     case 'AngleValue':
@@ -304,7 +324,7 @@ function covertNodesUnits(left, right, precision) {
     case 'FrequencyValue':
     case 'ResolutionValue':
       if (right.type === left.type && right.unit && left.unit) {
-        var converted = (0, _convertUnit.default)(right.value, right.unit, left.unit, precision);
+        const converted = (0, _convertUnit.default)(right.value, right.unit, left.unit, precision);
         right = {
           type: left.type,
           value: converted,
@@ -324,22 +344,28 @@ function covertNodesUnits(left, right, precision) {
       };
   }
 }
+/**
+ * @param {import('../parser').CalcNode} node
+ * @param {number} precision
+ */
+
 
 function reduce(node, precision) {
   if (node.type === "MathExpression") {
+    if (isAddSubOperator(node.operator)) {
+      // reduceAddSubExpression will call reduce recursively
+      return reduceAddSubExpression(node, precision);
+    }
+
     node.left = reduce(node.left, precision);
     node.right = reduce(node.right, precision);
 
     switch (node.operator) {
-      case "+":
-      case "-":
-        return reduceAddSubExpression(node, precision);
-
       case "/":
-        return reduceDivisionExpression(node, precision);
+        return reduceDivisionExpression(node);
 
       case "*":
-        return reduceMultiplicationExpression(node, precision);
+        return reduceMultiplicationExpression(node);
     }
 
     return node;
@@ -350,17 +376,4 @@ function reduce(node, precision) {
 
 var _default = reduce;
 exports.default = _default;
-
-function isCSSFunction(node) {
-  if (node.type === "Function") {
-    return true;
-  }
-
-  if (node.type === "MathExpression") {
-    return isCSSFunction(node.left) || isCSSFunction(node.right);
-  }
-
-  return false;
-}
-
 module.exports = exports.default;

package/dist/lib/stringifier.js

@@ -4,30 +4,41 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = _default;
-var order = {
+const order = {
   "*": 0,
   "/": 0,
   "+": 1,
   "-": 1
 };
+/**
+ * @param {number} value
+ * @param {number | false} prec
+ */
 
 function round(value, prec) {
   if (prec !== false) {
-    var precision = Math.pow(10, prec);
+    const precision = Math.pow(10, prec);
     return Math.round(value * precision) / precision;
   }
 
   return value;
 }
+/**
+ * @param {number | false} prec
+ * @param {import('../parser').CalcNode} node
+ */
+
 
 function stringify(node, prec) {
   switch (node.type) {
     case "MathExpression":
       {
-        var left = node.left,
-            right = node.right,
-            op = node.operator;
-        var str = "";
+        const {
+          left,
+          right,
+          operator: op
+        } = node;
+        let str = "";
 
         if (left.type === 'MathExpression' && order[op] < order[left.operator]) {
           str += `(${stringify(left, prec)})`;
@@ -47,19 +58,30 @@ function stringify(node, prec) {
       }
 
     case 'Number':
-      return round(node.value, prec);
+      return round(node.value, prec).toString();
 
     case 'Function':
-      return node.value;
+      return node.value.toString();
 
     default:
       return round(node.value, prec) + node.unit;
   }
 }
+/**
+ * @param {string} calc
+ * @param {import('../parser').CalcNode} node
+ * @param {string} originalValue
+ * @param {{precision: number | false, warnWhenCannotResolve: boolean}} options
+ * @param {import("postcss").Result} result
+ * @param {import("postcss").ChildNode} item
+ *
+ * @returns {string}
+ */
+
 
 function _default(calc, node, originalValue, options, result, item) {
-  var str = stringify(node, options.precision);
-  var shouldPrintCalc = node.type === "MathExpression" || node.type === "Function";
+  let str = stringify(node, options.precision);
+  const shouldPrintCalc = node.type === "MathExpression" || node.type === "Function";
 
   if (shouldPrintCalc) {
     // if calc expression couldn't be resolved to a single value, re-wrap it as

package/dist/lib/transform.js

@@ -18,42 +18,56 @@ var _stringifier = _interopRequireDefault(require("./stringifier"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 // eslint-disable-next-line import/no-unresolved
-var MATCH_CALC = /((?:-(moz|webkit)-)?calc)/i;
+const MATCH_CALC = /((?:-(moz|webkit)-)?calc)/i;
+/**
+ * @param {string} value
+ * @param {{precision: number, warnWhenCannotResolve: boolean}} options
+ * @param {import("postcss").Result} result
+ * @param {import("postcss").ChildNode} item
+ */
 
 function transformValue(value, options, result, item) {
-  return (0, _postcssValueParser.default)(value).walk(function (node) {
+  return (0, _postcssValueParser.default)(value).walk(node => {
     // skip anything which isn't a calc() function
-    if (node.type !== 'function' || !MATCH_CALC.test(node.value)) {
-      return node;
+    if (node.type !== "function" || !MATCH_CALC.test(node.value)) {
+      return;
     } // stringify calc expression and produce an AST
 
 
-    var contents = _postcssValueParser.default.stringify(node.nodes);
+    const contents = _postcssValueParser.default.stringify(node.nodes);
 
-    var ast = _parser.parser.parse(contents); // reduce AST to its simplest form, that is, either to a single value
+    const ast = _parser.parser.parse(contents); // reduce AST to its simplest form, that is, either to a single value
     // or a simplified calc expression
 
 
-    var reducedAst = (0, _reducer.default)(ast, options.precision); // stringify AST and write it back
+    const reducedAst = (0, _reducer.default)(ast, options.precision); // stringify AST and write it back
 
-    node.type = 'word';
+    /** @type {valueParser.Node} */
+    node.type = "word";
     node.value = (0, _stringifier.default)(node.value, reducedAst, value, options, result, item);
     return false;
   }).toString();
 }
+/**
+ * @param {import("postcss-selector-parser").Selectors} value
+ * @param {{precision: number, warnWhenCannotResolve: boolean}} options
+ * @param {import("postcss").Result} result
+ * @param {import("postcss").ChildNode} item
+ */
+
 
 function transformSelector(value, options, result, item) {
-  return (0, _postcssSelectorParser.default)(function (selectors) {
-    selectors.walk(function (node) {
+  return (0, _postcssSelectorParser.default)(selectors => {
+    selectors.walk(node => {
       // attribute value
       // e.g. the "calc(3*3)" part of "div[data-size="calc(3*3)"]"
-      if (node.type === 'attribute' && node.value) {
+      if (node.type === "attribute" && node.value) {
         node.setValue(transformValue(node.value, options, result, item));
       } // tag value
       // e.g. the "calc(3*3)" part of "div:nth-child(2n + calc(3*3))"
 
 
-      if (node.type === 'tag') {
+      if (node.type === "tag") {
         node.value = transformValue(node.value, options, result, item);
       }
 
@@ -61,15 +75,39 @@ function transformSelector(value, options, result, item) {
     });
   }).processSync(value);
 }
-
-var _default = function _default(node, property, options, result) {
-  var value = property === "selector" ? transformSelector(node[property], options, result, node) : transformValue(node[property], options, result, node); // if the preserve option is enabled and the value has changed, write the
+/** 
+ * @param {any} node
+ * @param {{precision: number, preserve: boolean, warnWhenCannotResolve: boolean}} options
+ * @param {'value'|'params'|'selector'} property
+ * @param {import("postcss").Result} result
+ */
+
+
+var _default = (node, property, options, result) => {
+  let value = node[property];
+
+  try {
+    value = property === "selector" ? transformSelector(node[property], options, result, node) : transformValue(node[property], options, result, node);
+  } catch (error) {
+    if (error instanceof Error) {
+      result.warn(error.message, {
+        node
+      });
+    } else {
+      result.warn('Error', {
+        node
+      });
+    }
+
+    return;
+  } // if the preserve option is enabled and the value has changed, write the
   // transformed value into a cloned node which is inserted before the current
   // node, preserving the original value. Otherwise, overwrite the original
   // value.
 
+
   if (options.preserve && node[property] !== value) {
-    var clone = node.clone();
+    const clone = node.clone();
     clone[property] = value;
     node.parent.insertBefore(node, clone);
   } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postcss-calc",
-  "version": "7.0.4",
+  "version": "8.2.0",
   "description": "PostCSS plugin to reduce calc()",
   "keywords": [
     "css",
@@ -10,52 +10,50 @@
     "calc"
   ],
   "main": "dist/index.js",
+  "types": "types/index.d.ts",
   "files": [
     "dist",
+    "types",
     "LICENSE"
   ],
-  "scripts": {
-    "prepublish": "npm run build",
-    "build": "del-cli dist && cross-env BABEL_ENV=publish babel src --out-dir dist --ignore src/__tests__/**/*.js && jison src/parser.jison -o dist/parser.js",
-    "pretest": "npm run build && eslint src",
-    "test": "ava"
-  },
   "author": "Andy Jansson",
   "license": "MIT",
   "repository": "https://github.com/postcss/postcss-calc.git",
   "eslintConfig": {
-    "parser": "babel-eslint",
-    "extends": "eslint-config-i-am-meticulous",
+    "extends": [
+      "eslint:recommended",
+      "plugin:import/recommended"
+    ],
     "rules": {
       "curly": "error"
     }
   },
   "devDependencies": {
-    "@babel/cli": "^7.1.2",
-    "@babel/core": "^7.1.2",
-    "@babel/polyfill": "^7.0.0",
-    "@babel/preset-env": "^7.1.0",
-    "@babel/register": "^7.0.0",
-    "ava": "^1.4.1",
-    "babel-eslint": "^10.0.1",
+    "@babel/cli": "^7.16.0",
+    "@babel/core": "^7.16.5",
+    "@babel/plugin-transform-modules-commonjs": "^7.16.5",
+    "@babel/register": "^7.16.7",
     "babel-plugin-add-module-exports": "^1.0.0",
-    "cross-env": "^5.2.0",
-    "del-cli": "^1.1.0",
-    "eslint": "^5.7.0",
-    "eslint-config-i-am-meticulous": "^11.0.0",
-    "eslint-plugin-babel": "^5.2.1",
-    "eslint-plugin-import": "^2.14.0",
-    "jison-gho": "^0.6.1-215"
+    "eslint": "^8.5.0",
+    "eslint-plugin-import": "^2.25.3",
+    "jison-gho": "^0.6.1-216",
+    "postcss": "^8.2.2",
+    "rimraf": "^3.0.2",
+    "typescript": "^4.5.4",
+    "uvu": "^0.5.2"
   },
   "dependencies": {
-    "postcss": "^7.0.27",
     "postcss-selector-parser": "^6.0.2",
     "postcss-value-parser": "^4.0.2"
   },
-  "ava": {
-    "require": [
-      "@babel/register",
-      "@babel/polyfill"
-    ]
-  }
-}
+  "peerDependencies": {
+    "postcss": "^8.2.2"
+  },
+  "scripts": {
+    "build": "rimraf dist && babel src --out-dir dist --ignore src/__tests__/**/*.js && jison src/parser.jison -o dist/parser.js",
+    "lint": "eslint src && tsc",
+    "pretest": "pnpm run build",
+    "test": "uvu -r @babel/register src/__tests__"
+  },
+  "readme": "# PostCSS Calc [<img src=\"https://postcss.github.io/postcss/logo.svg\" alt=\"PostCSS\" width=\"90\" height=\"90\" align=\"right\">][PostCSS]\n\n[![NPM Version][npm-img]][npm-url]\n[![Build Status][cli-img]][cli-url]\n[![Support Chat][git-img]][git-url]\n\n[PostCSS Calc] lets you reduce `calc()` references whenever it's possible. This\ncan be particularly useful with the [PostCSS Custom Properties] plugin.\n\nWhen multiple units are mixed together in the same expression, the `calc()`\nstatement is left as is, to fallback to the [W3C calc() implementation].\n\n## Installation\n\n```bash\nnpm install postcss-calc\n```\n\n## Usage\n\n```js\n// dependencies\nvar fs = require(\"fs\")\nvar postcss = require(\"postcss\")\nvar calc = require(\"postcss-calc\")\n\n// css to be processed\nvar css = fs.readFileSync(\"input.css\", \"utf8\")\n\n// process css\nvar output = postcss()\n  .use(calc())\n  .process(css)\n  .css\n```\n\n**Example** (with [PostCSS Custom Properties] enabled as well):\n\n```js\n// dependencies\nvar fs = require(\"fs\")\nvar postcss = require(\"postcss\")\nvar customProperties = require(\"postcss-custom-properties\")\nvar calc = require(\"postcss-calc\")\n\n// css to be processed\nvar css = fs.readFileSync(\"input.css\", \"utf8\")\n\n// process css\nvar output = postcss()\n  .use(customProperties())\n  .use(calc())\n  .process(css)\n  .css\n```\n\nUsing this `input.css`:\n\n```css\n:root {\n  --main-font-size: 16px;\n}\n\nbody {\n  font-size: var(--main-font-size);\n}\n\nh1 {\n  font-size: calc(var(--main-font-size) * 2);\n  height: calc(100px - 2em);\n  margin-bottom: calc(\n      var(--main-font-size)\n      * 1.5\n    )\n}\n```\n\nyou will get:\n\n```css\nbody {\n  font-size: 16px\n}\n\nh1 {\n  font-size: 32px;\n  height: calc(100px - 2em);\n  margin-bottom: 24px\n}\n```\n\nCheckout [tests] for more examples.\n\n### Options\n\n#### `precision` (default: `5`)\n\nAllow you to define the precision for decimal numbers.\n\n```js\nvar out = postcss()\n  .use(calc({precision: 10}))\n  .process(css)\n  .css\n```\n\n#### `preserve` (default: `false`)\n\nAllow you to preserve calc() usage in output so browsers will handle decimal\nprecision themselves.\n\n```js\nvar out = postcss()\n  .use(calc({preserve: true}))\n  .process(css)\n  .css\n```\n\n#### `warnWhenCannotResolve` (default: `false`)\n\nAdds warnings when calc() are not reduced to a single value.\n\n```js\nvar out = postcss()\n  .use(calc({warnWhenCannotResolve: true}))\n  .process(css)\n  .css\n```\n\n#### `mediaQueries` (default: `false`)\n\nAllows calc() usage as part of media query declarations.\n\n```js\nvar out = postcss()\n  .use(calc({mediaQueries: true}))\n  .process(css)\n  .css\n```\n\n#### `selectors` (default: `false`)\n\nAllows calc() usage as part of selectors.\n\n```js\nvar out = postcss()\n  .use(calc({selectors: true}))\n  .process(css)\n  .css\n```\n\nExample:\n\n```css\ndiv[data-size=\"calc(3*3)\"] {\n  width: 100px;\n}\n```\n\n---\n\n## Contributing\n\nWork on a branch, install dev-dependencies, respect coding style & run tests\nbefore submitting a bug fix or a feature.\n\n```bash\ngit clone git@github.com:postcss/postcss-calc.git\ngit checkout -b patch-1\nnpm install\nnpm test\n```\n\n## [Changelog](CHANGELOG.md)\n\n## [License](LICENSE)\n\n[cli-img]: https://img.shields.io/travis/postcss/postcss-calc/master.svg\n[cli-url]: https://travis-ci.org/postcss/postcss-calc\n[git-img]: https://img.shields.io/badge/support-chat-blue.svg\n[git-url]: https://gitter.im/postcss/postcss\n[npm-img]: https://img.shields.io/npm/v/postcss-calc.svg\n[npm-url]: https://www.npmjs.com/package/postcss-calc\n\n[PostCSS]: https://github.com/postcss\n[PostCSS Calc]: https://github.com/postcss/postcss-calc\n[PostCSS Custom Properties]: https://github.com/postcss/postcss-custom-properties\n[tests]: src/__tests__/index.js\n[W3C calc() implementation]: https://www.w3.org/TR/css3-values/#calc-notation\n"
+}

package/types/index.d.ts

@@ -0,0 +1,30 @@
+export default pluginCreator;
+export type PostCssCalcOptions = {
+    precision?: number | false;
+    preserve?: boolean;
+    warnWhenCannotResolve?: boolean;
+    mediaQueries?: boolean;
+    selectors?: boolean;
+};
+/**
+ * @typedef {{precision?: number | false,
+ *          preserve?: boolean,
+ *          warnWhenCannotResolve?: boolean,
+ *          mediaQueries?: boolean,
+ *          selectors?: boolean}} PostCssCalcOptions
+ *
+ * @param {PostCssCalcOptions} opts
+ */
+declare function pluginCreator(opts: PostCssCalcOptions): {
+    postcssPlugin: string;
+    /**
+     * @param {import('postcss').Root} css
+     * @param {{result: import('postcss').Result}} helpers
+     */
+    OnceExit(css: import('postcss').Root, { result }: {
+        result: import('postcss').Result;
+    }): void;
+};
+declare namespace pluginCreator {
+    const postcss: boolean;
+}

package/types/lib/convertUnit.d.ts

@@ -0,0 +1,8 @@
+export default convertUnit;
+/**
+ * @param {number} value
+ * @param {string} sourceUnit
+ * @param {string} targetUnit
+ * @param {number|false} precision
+ */
+declare function convertUnit(value: number, sourceUnit: string, targetUnit: string, precision: number | false): number;

package/types/lib/reducer.d.ts

@@ -0,0 +1,10 @@
+export default reduce;
+export type Collectible = {
+    preOperator: '+' | '-';
+    node: import('../parser').CalcNode;
+};
+/**
+ * @param {import('../parser').CalcNode} node
+ * @param {number} precision
+ */
+declare function reduce(node: import('../parser').CalcNode, precision: number): import("../parser").MathExpression | import("../parser").DimensionExpression | import("../parser").NumberExpression | import("../parser").FunctionExpression;

package/types/lib/stringifier.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @param {string} calc
+ * @param {import('../parser').CalcNode} node
+ * @param {string} originalValue
+ * @param {{precision: number | false, warnWhenCannotResolve: boolean}} options
+ * @param {import("postcss").Result} result
+ * @param {import("postcss").ChildNode} item
+ *
+ * @returns {string}
+ */
+export default function _default(calc: string, node: import('../parser').CalcNode, originalValue: string, options: {
+    precision: number | false;
+    warnWhenCannotResolve: boolean;
+}, result: import("postcss").Result, item: import("postcss").ChildNode): string;

package/types/lib/transform.d.ts

@@ -0,0 +1,6 @@
+declare function _default(node: any, property: 'value' | 'params' | 'selector', options: {
+    precision: number;
+    preserve: boolean;
+    warnWhenCannotResolve: boolean;
+}, result: import("postcss").Result): void;
+export default _default;

package/CHANGELOG.md

@@ -1,118 +0,0 @@
-# 7.0.4
-
-- Fixed: strips away important factors from multiplications in calc() ([#107](https://github.com/postcss/postcss-calc/issues/107))
-
-# 7.0.3
-
-- Fixed: substracted css-variable from zero ([#111](https://github.com/postcss/postcss-calc/issues/111))
-
-# 7.0.2
-
-- Fixed: incorrect reduction of subtraction from zero ([#88](https://github.com/postcss/postcss-calc/issues/88))
-- Fixed: doesn't remove calc for single function
-- Fixed: relax parser on unknown units ([#76](https://github.com/postcss/postcss-calc/issues/76))
-- Fixed: handle numbers with exponen composed ([#83](https://github.com/postcss/postcss-calc/pull/83))
-- Fixed: handle plus sign before value ([#79](https://github.com/postcss/postcss-calc/pull/79))
-- Fixed: better handle precision for nested calc ([#75](https://github.com/postcss/postcss-calc/pull/75))
-- Fixed: properly handle nested add and sub expression inside sub expression ([#64](https://github.com/postcss/postcss-calc/issues/64))
-- Fixed: handle uppercase units and functions ([#71](https://github.com/postcss/postcss-calc/pull/71))
-- Fixed: do not break `calc` with single var ([cssnano/cssnano#725](https://github.com/cssnano/cssnano/issues/725))
-- Updated: `postcss` to 7.0.27 (patch)
-- Updated: `postcss-selector-parser` to 6.0.2
-- Updated: `postcss-value-parser` to 4.0.2
-
-# 7.0.1
-
-- Updated: `postcss` to 7.0.2 (patch)
-- Updated: `postcss-selector-parser` to 5.0.0-rc.4 (patch)
-- Updated: `postcss-value-parser` to 3.3.1 (patch)
-
-# 7.0.0
-
-- Changed: Updated postcss-selector-parser to version 5.0.0-rc.3
-- Changed: Dropped reduce-css-calc as a dependency
-- Fixed: Support constant() and env() ([#42](https://github.com/postcss/postcss-calc/issues/42), [#48](https://github.com/postcss/postcss-calc/issues/48))
-- Fixed: Support custom properties with "calc" in its name ([#50](https://github.com/postcss/postcss-calc/issues/50))
-- Fixed: Remove unnecessary whitespace around `*` and `/` ([cssnano#625](https://github.com/cssnano/cssnano/issues/625))
-- Fixed: Arithmetic bugs around subtraction ([#49](https://github.com/postcss/postcss-calc/issues/49))
-- Fixed: Handling of nested calc statements ([reduce-css-calc#49](https://github.com/MoOx/reduce-css-calc/issues/49))
-- Fixed: Bugs regarding complex calculations ([reduce-cs-calc#45](https://github.com/MoOx/reduce-css-calc/issues/45))
-- Fixed: `100%` incorrectly being transformed to `1` ([reduce-css-calc#44](https://github.com/MoOx/reduce-css-calc/issues/44))
-- Added: support for case-insensitive calc statements
-
-# 6.0.2 - 2018-09-25
-
-- Fixed: use PostCSS 7 (thanks to @douglasduteil)
-
-# 6.0.1 - 2017-10-10
-
-- Fixed: throwing error for attribute selectors without a value
-
-# 6.0.0 - 2017-05-08
-
-- Breaking: Updated PostCSS from v5.x to v6.x, and reduce-css-calc from v1.x
-  to v2.x (thanks to @andyjansson).
-
-# 5.3.1 - 2016-08-22
-
-- Fixed: avoid security issue related to ``reduce-css-calc@< 1.2.4``.
-
-# 5.3.0 - 2016-07-11
-
-- Added: support for selector transformation via `selectors` option.
-  ([#29](https://github.com/postcss/postcss-calc/pull/29) - @uniquegestaltung)
-
-# 5.2.1 - 2016-04-10
-
-- Fixed: support for multiline value
-  ([#27](https://github.com/postcss/postcss-calc/pull/27))
-
-# 5.2.0 - 2016-01-08
-
-- Added: "mediaQueries" option for `@media` support
-([#22](https://github.com/postcss/postcss-calc/pull/22))
-
-# 5.1.0 - 2016-01-07
-
-- Added: "warnWhenCannotResolve" option to warn when calc() are not reduced to a single value
-([#20](https://github.com/postcss/postcss-calc/pull/20))
-
-# 5.0.0 - 2015-08-25
-
-- Removed: compatibility with postcss v4.x
-- Added: compatibility with postcss v5.x
-
-# 4.1.0 - 2015-04-09
-
-- Added: compatibility with postcss v4.1.x ([#12](https://github.com/postcss/postcss-calc/pull/12))
-
-# 4.0.1 - 2015-04-09
-
-- Fixed: `preserve` option does not create duplicated values ([#7](https://github.com/postcss/postcss-calc/issues/7))
-
-# 4.0.0 - 2015-01-26
-
-- Added: compatibility with postcss v4.x
-- Changed: partial compatiblity with postcss v3.x (stack traces have lost filename)
-
-# 3.0.0 - 2014-11-24
-
-- Added: GNU like exceptions ([#4](https://github.com/postcss/postcss-calc/issues/4))
-- Added: `precision` option ([#5](https://github.com/postcss/postcss-calc/issues/5))
-- Added: `preserve` option ([#6](https://github.com/postcss/postcss-calc/issues/6))
-
-# 2.1.0 - 2014-10-15
-
-- Added: source of the error (gnu like message) (fix [#3](https://github.com/postcss/postcss-calc/issues/3))
-
-# 2.0.1 - 2014-08-10
-
-- Fixed: correctly ignore unrecognized values (fix [#2](https://github.com/postcss/postcss-calc/issues/2))
-
-# 2.0.0 - 2014-08-06
-
-- Changed: Plugin now return a function to have a consistent api. ([ref 1](https://github.com/ianstormtaylor/rework-color-function/issues/6), [ref 2](https://twitter.com/jongleberry/status/496552790416576513))
-
-# 1.0.0 - 2014-08-04
-
-✨ First release based on [rework-calc](https://github.com/reworkcss/rework-calc) v1.1.0 (code mainly exported to [`reduce-css-calc`](https://github.com/MoOx/reduce-css-calc))