postcss-calc 7.0.5 → 8.2.1

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,8 +9,12 @@ var _convertUnit = _interopRequireDefault(require("./convertUnit"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-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':
@@ -31,35 +35,54 @@ function isValueType(type) {
 
   return false;
 }
+/** @param {'-'|'+'} operator */
+
 
 function flip(operator) {
   return operator === '+' ? '-' : '+';
 }
+/**
+ * @param {string} operator
+ * @returns {operator is '+'|'-'}
+ */
+
 
 function isAddSubOperator(operator) {
   return operator === '+' || operator === '-';
 }
+/**
+ * @typedef {{preOperator: '+'|'-', node: import('../parser').CalcNode}} Collectible
+*/
+
+/**
+ * @param {'+'|'-'} preOperator
+ * @param {import('../parser').CalcNode} node
+ * @param {Collectible[]} collected 
+ * @param {number} precision
+ */
+
 
 function collectAddSubItems(preOperator, node, collected, precision) {
   if (!isAddSubOperator(preOperator)) {
     throw new Error(`invalid operator ${preOperator}`);
   }
 
-  var type = node.type;
-
-  if (isValueType(type)) {
-    var itemIndex = collected.findIndex(function (x) {
-      return x.node.type === type;
-    });
+  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
+
 
-      var _covertNodesUnits = covertNodesUnits(collected[itemIndex].node, node, precision),
-          reducedNode = _covertNodesUnits.left,
-          current = _covertNodesUnits.right;
+      const otherValueNode =
+      /** @type import('../parser').ValueExpression*/
+      collected[itemIndex].node;
+      const {
+        left: reducedNode,
+        right: current
+      } = convertNodesUnits(otherValueNode, node, precision);
 
       if (collected[itemIndex].preOperator === '-') {
         collected[itemIndex].preOperator = '+';
@@ -100,25 +123,26 @@ function collectAddSubItems(preOperator, node, collected, precision) {
         });
       }
     }
-  } else if (type === "MathExpression") {
+  } else if (node.type === "MathExpression") {
     if (isAddSubOperator(node.operator)) {
       collectAddSubItems(preOperator, node.left, collected, precision);
-      var collectRightOperator = preOperator === '-' ? flip(node.operator) : node.operator;
+      const collectRightOperator = preOperator === '-' ? flip(node.operator) : node.operator;
       collectAddSubItems(collectRightOperator, node.right, collected, precision);
     } else {
       // * or /
-      var _reducedNode = reduce(node, precision); // prevent infinite recursive call
-
+      const reducedNode = reduce(node, precision); // prevent infinite recursive call
 
-      if (_reducedNode.type !== "MathExpression" || isAddSubOperator(_reducedNode.operator)) {
-        collectAddSubItems(preOperator, _reducedNode, collected, precision);
+      if (reducedNode.type !== "MathExpression" || isAddSubOperator(reducedNode.operator)) {
+        collectAddSubItems(preOperator, reducedNode, collected, precision);
       } else {
         collected.push({
-          node: _reducedNode,
+          node: reducedNode,
           preOperator
         });
       }
     }
+  } else if (node.type === 'ParenthesizedExpression') {
+    collectAddSubItems(preOperator, node.content, collected, precision);
   } else {
     collected.push({
       node,
@@ -126,33 +150,38 @@ function collectAddSubItems(preOperator, node, collected, precision) {
     });
   }
 }
+/**
+ * @param {import('../parser').CalcNode} node
+ * @param {number} precision
+ */
+
 
 function reduceAddSubExpression(node, precision) {
-  var collected = [];
+  /** @type Collectible[] */
+  const collected = [];
   collectAddSubItems('+', node, collected, precision);
-  var withoutZeroItem = collected.filter(function (item) {
-    return !(isValueType(item.node.type) && item.node.value === 0);
-  });
-  var firstNonZeroItem = withoutZeroItem[0]; // could be undefined
+  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.type)) {
-    var firstZeroItem = collected.find(function (item) {
-      return isValueType(item.node.type) && item.node.value === 0;
-    });
-    withoutZeroItem.unshift(firstZeroItem);
+  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.type)) {
+  if (withoutZeroItem[0].preOperator === '-' && isValueType(withoutZeroItem[0].node)) {
     withoutZeroItem[0].node.value *= -1;
     withoutZeroItem[0].preOperator = '+';
   }
 
-  var root = withoutZeroItem[0].node;
+  let root = withoutZeroItem[0].node;
 
-  for (var i = 1; i < withoutZeroItem.length; i++) {
+  for (let i = 1; i < withoutZeroItem.length; i++) {
     root = {
       type: 'MathExpression',
       operator: withoutZeroItem[i].preOperator,
@@ -163,9 +192,13 @@ function reduceAddSubExpression(node, precision) {
 
   return root;
 }
+/**
+ * @param {import('../parser').MathExpression} node
+ */
+
 
 function reduceDivisionExpression(node) {
-  if (!isValueType(node.right.type)) {
+  if (!isValueType(node.right)) {
     return node;
   }
 
@@ -174,7 +207,14 @@ function reduceDivisionExpression(node) {
   }
 
   return applyNumberDivision(node.left, node.right.value);
-} // apply (expr) / number
+}
+/**
+ * apply (expr) / number
+ *
+ * @param {import('../parser').CalcNode} node
+ * @param {number} divisor
+ * @return {import('../parser').CalcNode}
+*/
 
 
 function applyNumberDivision(node, divisor) {
@@ -182,7 +222,7 @@ function applyNumberDivision(node, divisor) {
     throw new Error('Cannot divide by zero');
   }
 
-  if (isValueType(node.type)) {
+  if (isValueType(node)) {
     node.value /= divisor;
     return node;
   }
@@ -213,6 +253,10 @@ function applyNumberDivision(node, divisor) {
     }
   };
 }
+/**
+ * @param {import('../parser').MathExpression} node
+ */
+
 
 function reduceMultiplicationExpression(node) {
   // (expr) * number
@@ -226,11 +270,17 @@ function reduceMultiplicationExpression(node) {
   }
 
   return node;
-} // apply (expr) / number
+}
+/**
+ * apply (expr) * number
+ * @param {number} multiplier
+ * @param {import('../parser').CalcNode} node
+ * @return {import('../parser').CalcNode}
+ */
 
 
 function applyNumberMultiplication(node, multiplier) {
-  if (isValueType(node.type)) {
+  if (isValueType(node)) {
     node.value *= multiplier;
     return node;
   }
@@ -261,8 +311,14 @@ function applyNumberMultiplication(node, 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':
@@ -270,7 +326,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,
@@ -290,6 +346,12 @@ function covertNodesUnits(left, right, precision) {
       };
   }
 }
+/**
+ * @param {import('../parser').CalcNode} node
+ * @param {number} precision
+ * @return {import('../parser').CalcNode}
+ */
+
 
 function reduce(node, precision) {
   if (node.type === "MathExpression") {
@@ -303,15 +365,21 @@ function reduce(node, precision) {
 
     switch (node.operator) {
       case "/":
-        return reduceDivisionExpression(node, precision);
+        return reduceDivisionExpression(node);
 
       case "*":
-        return reduceMultiplicationExpression(node, precision);
+        return reduceMultiplicationExpression(node);
     }
 
     return node;
   }
 
+  if (node.type === 'ParenthesizedExpression') {
+    if (node.content.type !== 'Function') {
+      return reduce(node.content, precision);
+    }
+  }
+
   return node;
 }
 

package/dist/lib/stringifier.js

@@ -4,30 +4,43 @@ 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
+ *
+ * @return {string}
+ */
+
 
 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 +60,33 @@ 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();
+
+    case 'ParenthesizedExpression':
+      return `(${stringify(node.content, prec)})`;
 
     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/dist/parser.js

@@ -828,8 +828,6 @@ case 1:
 
 case 2:
     /*! Production::    math_expression : CALC LPAREN math_expression RPAREN */
-case 7:
-    /*! Production::    math_expression : LPAREN math_expression RPAREN */
 
     this.$ = yyvstack[yysp - 1];
     break;
@@ -846,6 +844,12 @@ case 6:
     this.$ = { type: 'MathExpression', operator: yyvstack[yysp - 1], left: yyvstack[yysp - 2], right: yyvstack[yysp] };
     break;
 
+case 7:
+    /*! Production::    math_expression : LPAREN math_expression RPAREN */
+
+    this.$ = { type: 'ParenthesizedExpression', content: yyvstack[yysp - 1] };
+    break;
+
 case 8:
     /*! Production::    math_expression : function */
 case 9:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postcss-calc",
-  "version": "7.0.5",
+  "version": "8.2.1",
   "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.3"
   },
   "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,11 @@
+export default reduce;
+export type Collectible = {
+    preOperator: '+' | '-';
+    node: import('../parser').CalcNode;
+};
+/**
+ * @param {import('../parser').CalcNode} node
+ * @param {number} precision
+ * @return {import('../parser').CalcNode}
+ */
+declare function reduce(node: import('../parser').CalcNode, precision: number): import('../parser').CalcNode;

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,122 +0,0 @@
-# 7.0.5
-
-- Fixed: reduction
-
-# 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))