evilebottnawi

jonathantneal

moox

beneb

andyjansson

ludovicofischer

semigradsky

postcss-calc

Object.defineProperty(exports, "__esModule", {

var _convertUnit = _interopRequireDefault(require("./convertUnit"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 * @param {import('../parser').CalcNode} node

 * @return {node is import('../parser').ValueExpression}

  return operator === '+' || operator === '-';

 * @typedef {{preOperator: '+'|'-', node: import('../parser').CalcNode}} Collectible

function collectAddSubItems(preOperator, node, collected, precision) {

    throw new Error(`invalid operator ${preOperator}`);

    const itemIndex = collected.findIndex(x => x.node.type === node.type);

      } // can cast because of the criterion used to find itemIndex

      /** @type import('../parser').ValueExpression*/

      } = convertNodesUnits(otherValueNode, node, precision);

      if (collected[itemIndex].preOperator === '-') {

        collected[itemIndex].preOperator = '+';

        reducedNode.value += current.value;

        reducedNode.value -= current.value;

      } // make sure reducedNode.value >= 0

  } else if (node.type === 'ParenthesizedExpression') {

    collectAddSubItems(preOperator, node.content, collected, precision);

function reduceAddSubExpression(node, precision) {

  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()"

  if (!firstNonZeroItem || firstNonZeroItem.preOperator === '-' && !isValueType(firstNonZeroItem.node)) {

    const firstZeroItem = collected.find(item => isValueType(item.node) && item.node.value === 0);

      withoutZeroItem.unshift(firstZeroItem);

  } // make sure the preOperator of the first item is +

  if (withoutZeroItem[0].preOperator === '-' && isValueType(withoutZeroItem[0].node)) {

    withoutZeroItem[0].preOperator = '+';

  for (let i = 1; i < withoutZeroItem.length; i++) {

      operator: withoutZeroItem[i].preOperator,

 * @param {import('../parser').MathExpression} node

function reduceDivisionExpression(node) {

    throw new Error(`Cannot divide by "${node.right.unit}", number expected`);

  return applyNumberDivision(node.left, node.right.value);

 * @return {import('../parser').CalcNode}

function applyNumberDivision(node, divisor) {

    throw new Error('Cannot divide by zero');

  if (node.type === "MathExpression" && isAddSubOperator(node.operator)) {

    // turn (a + b) / num into a/num + b/num

    // "should reduce division before reducing additions"

      left: applyNumberDivision(node.left, divisor),

      right: applyNumberDivision(node.right, divisor)

  } // it is impossible to reduce it into a single value

  // so we just preserve the division and let browser do it

    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);

        return reduceDivisionExpression(node);

        return reduceMultiplicationExpression(node);

  if (node.type === 'ParenthesizedExpression') {

    if (node.content.type !== 'Function') {

      return reduce(node.content, precision);

    const precision = Math.pow(10, prec);

    return Math.round(value * precision) / precision;

        if (left.type === 'MathExpression' && order[op] < order[left.operator]) {

          str += `(${stringify(left, prec)})`;

        str += order[op] ? ` ${node.operator} ` : node.operator;

        if (right.type === 'MathExpression' && order[op] < order[right.operator]) {

          str += `(${stringify(right, prec)})`;

      return round(node.value, prec).toString();

      return `(${stringify(node.content, prec)})`;

      return round(node.value, prec) + node.unit;

 * @param {{precision: number | false, warnWhenCannotResolve: boolean}} options

 * @param {import("postcss").Result} result

 * @param {import("postcss").ChildNode} item

function _default(calc, node, originalValue, options, result, item) {

  let str = stringify(node, options.precision);

  const shouldPrintCalc = node.type === "MathExpression" || node.type === "Function";

    // if calc expression couldn't be resolved to a single value, re-wrap it as

    str = `${calc}(${str})`; // if the warnWhenCannotResolve option is on, inform the user that the calc

    // expression could not be resolved to a single value

      result.warn("Could not reduce expression: " + originalValue, {

  "description": "PostCSS plugin to reduce calc()",

  "repository": "https://github.com/postcss/postcss-calc.git",

    "@babel/plugin-transform-modules-commonjs": "^7.16.5",

    "babel-plugin-add-module-exports": "^1.0.0",

    "build": "rimraf dist && babel src --out-dir dist --ignore src/__tests__/**/*.js && jison src/parser.jison -o dist/parser.js",

    "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"

declare function reduce(node: import('../parser').CalcNode, precision: number): import("../parser").MathExpression | import("../parser").DimensionExpression | import("../parser").NumberExpression | import("../parser").FunctionExpression;

declare function reduce(node: import('../parser').CalcNode, precision: number): import('../parser').CalcNode;

		@@ -29,2 +29,4 @@ "use strict";
		* @param {import('../parser').CalcNode} node
		*
		* @return {string}
		*/
		@@ -67,2 +69,5 @@

		case 'ParenthesizedExpression':
		return `(${stringify(node.content, prec)})`;

		default:
		@@ -69,0 +74,0 @@ return round(node.value, prec) + node.unit;

		{
		"name": "postcss-calc",
		"version": "8.2.0",
		"version": "8.2.1",
		"description": "PostCSS plugin to reduce calc()",
		@@ -43,3 +43,3 @@ "keywords": [
		"typescript": "^4.5.4",
		"uvu": "^0.5.2"
		"uvu": "^0.5.3"
		},
		@@ -46,0 +46,0 @@ "dependencies": {

		@@ -144,2 +144,4 @@ "use strict";
		}
		} else if (node.type === 'ParenthesizedExpression') {
		collectAddSubItems(preOperator, node.content, collected, precision);
		} else {
		@@ -351,2 +353,3 @@ collected.push({
		* @param {number} precision
		* @return {import('../parser').CalcNode}
		*/
		@@ -376,2 +379,8 @@

		if (node.type === 'ParenthesizedExpression') {
		if (node.content.type !== 'Function') {
		return reduce(node.content, precision);
		}
		}

		return node;
		@@ -378,0 +387,0 @@ }

		@@ -9,3 +9,4 @@ export default reduce;
		* @param {number} precision
		* @return {import('../parser').CalcNode}
		*/
		declare function reduce(node: import('../parser').CalcNode, precision: number): import("../parser").MathExpression \| import("../parser").DimensionExpression \| import("../parser").NumberExpression \| import("../parser").FunctionExpression;
		declare function reduce(node: import('../parser').CalcNode, precision: number): import('../parser').CalcNode;

Improved metrics