Last commit july 5th

spa/node_modules/postcss-calc/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Maxime Thirouin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

spa/node_modules/postcss-calc/README.md

@@ -0,0 +1,153 @@
+# PostCSS Calc [<img src="https://postcss.github.io/postcss/logo.svg" alt="PostCSS" width="90" height="90" align="right">][PostCSS]
+
+[![NPM Version][npm-img]][npm-url]
+[![Support Chat][git-img]][git-url]
+
+[PostCSS Calc] lets you reduce `calc()` references whenever it's possible.
+When multiple units are mixed together in the same expression, the `calc()`
+statement is left as is, to fallback to the [W3C calc() implementation].
+
+## Installation
+
+```bash
+npm install postcss-calc
+```
+
+## Usage
+
+```js
+// dependencies
+var fs = require("fs")
+var postcss = require("postcss")
+var calc = require("postcss-calc")
+
+// css to be processed
+var css = fs.readFileSync("input.css", "utf8")
+
+// process css
+var output = postcss()
+  .use(calc())
+  .process(css)
+  .css
+```
+
+Using this `input.css`:
+
+```css
+h1 {
+  font-size: calc(16px * 2);
+  height: calc(100px - 2em);
+  width: calc(2*var(--base-width));
+  margin-bottom: calc(16px * 1.5);
+}
+```
+
+you will get:
+
+```css
+h1 {
+  font-size: 32px;
+  height: calc(100px - 2em);
+  width: calc(2*var(--base-width));
+  margin-bottom: 24px
+}
+```
+Checkout [tests] for more examples.
+
+### Options
+
+#### `precision` (default: `5`)
+
+Allow you to define the precision for decimal numbers.
+
+```js
+var out = postcss()
+  .use(calc({precision: 10}))
+  .process(css)
+  .css
+```
+
+#### `preserve` (default: `false`)
+
+Allow you to preserve calc() usage in output so browsers will handle decimal
+precision themselves.
+
+```js
+var out = postcss()
+  .use(calc({preserve: true}))
+  .process(css)
+  .css
+```
+
+#### `warnWhenCannotResolve` (default: `false`)
+
+Adds warnings when calc() are not reduced to a single value.
+
+```js
+var out = postcss()
+  .use(calc({warnWhenCannotResolve: true}))
+  .process(css)
+  .css
+```
+
+#### `mediaQueries` (default: `false`)
+
+Allows calc() usage as part of media query declarations.
+
+```js
+var out = postcss()
+  .use(calc({mediaQueries: true}))
+  .process(css)
+  .css
+```
+
+#### `selectors` (default: `false`)
+
+Allows calc() usage as part of selectors.
+
+```js
+var out = postcss()
+  .use(calc({selectors: true}))
+  .process(css)
+  .css
+```
+
+Example:
+
+```css
+div[data-size="calc(3*3)"] {
+  width: 100px;
+}
+```
+
+---
+
+## Related PostCSS plugins
+To replace the value of CSS custom properties at build time, try [PostCSS Custom Properties].
+
+## Contributing
+
+Work on a branch, install dev-dependencies, respect coding style & run tests
+before submitting a bug fix or a feature.
+
+```bash
+git clone git@github.com:postcss/postcss-calc.git
+git checkout -b patch-1
+npm install
+npm test
+```
+
+## [Changelog](CHANGELOG.md)
+
+## [License](LICENSE)
+
+[git-img]: https://img.shields.io/badge/support-chat-blue.svg
+[git-url]: https://gitter.im/postcss/postcss
+[npm-img]: https://img.shields.io/npm/v/postcss-calc.svg
+[npm-url]: https://www.npmjs.com/package/postcss-calc
+
+[PostCSS]: https://github.com/postcss
+[PostCSS Calc]: https://github.com/postcss/postcss-calc
+[PostCSS Custom Properties]: https://github.com/postcss/postcss-custom-properties
+[tests]: src/__tests__/index.js
+[W3C calc() implementation]: https://www.w3.org/TR/css3-values/#calc-notation

spa/node_modules/postcss-calc/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "postcss-calc",
+  "version": "9.0.1",
+  "description": "PostCSS plugin to reduce calc()",
+  "keywords": [
+    "css",
+    "postcss",
+    "postcss-plugin",
+    "calculation",
+    "calc"
+  ],
+  "homepage": "https://github.com/postcss/postcss-calc",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/postcss/postcss-calc.git"
+  },
+  "main": "src/index.js",
+  "types": "types/index.d.ts",
+  "files": [
+    "src",
+    "types",
+    "LICENSE"
+  ],
+  "scripts": {
+    "prepare": "pnpm run build && tsc",
+    "build": "jison ./parser.jison -o src/parser.js",
+    "lint": "eslint . && tsc",
+    "test": "uvu test"
+  },
+  "author": "Andy Jansson",
+  "license": "MIT",
+  "eslintConfig": {
+    "extends": [
+      "eslint:recommended",
+      "prettier"
+    ],
+    "env": {
+      "node": true,
+      "es2017": true
+    },
+    "ignorePatterns": [
+      "src/parser.js"
+    ],
+    "rules": {
+      "curly": "error"
+    }
+  },
+  "engines": {
+    "node": "^14 || ^16 || >=18.0"
+  },
+  "devDependencies": {
+    "@types/node": "^18.16.2",
+    "eslint": "^8.39.0",
+    "eslint-config-prettier": "^8.8.0",
+    "jison-gho": "^0.6.1-216",
+    "postcss": "^8.2.2",
+    "prettier": "^2.8.8",
+    "typescript": "~5.0.4",
+    "uvu": "^0.5.6"
+  },
+  "dependencies": {
+    "postcss-selector-parser": "^6.0.11",
+    "postcss-value-parser": "^4.2.0"
+  },
+  "peerDependencies": {
+    "postcss": "^8.2.2"
+  }
+}

spa/node_modules/postcss-calc/src/index.js

@@ -0,0 +1,51 @@
+'use strict';
+const transform = require('./lib/transform.js');
+
+/**
+ * @typedef {{precision?: number | false,
+ *          preserve?: boolean,
+ *          warnWhenCannotResolve?: boolean,
+ *          mediaQueries?: boolean,
+ *          selectors?: boolean}} PostCssCalcOptions
+ */
+/**
+ * @type {import('postcss').PluginCreator<PostCssCalcOptions>}
+ * @param {PostCssCalcOptions} opts
+ * @return {import('postcss').Plugin}
+ */
+function pluginCreator(opts) {
+  const options = Object.assign(
+    {
+      precision: 5,
+      preserve: false,
+      warnWhenCannotResolve: false,
+      mediaQueries: false,
+      selectors: false,
+    },
+    opts
+  );
+
+  return {
+    postcssPlugin: 'postcss-calc',
+    OnceExit(css, { result }) {
+      css.walk((node) => {
+        const { type } = node;
+        if (type === 'decl') {
+          transform(node, 'value', options, result);
+        }
+
+        if (type === 'atrule' && options.mediaQueries) {
+          transform(node, 'params', options, result);
+        }
+
+        if (type === 'rule' && options.selectors) {
+          transform(node, 'selector', options, result);
+        }
+      });
+    },
+  };
+}
+
+pluginCreator.postcss = true;
+
+module.exports = pluginCreator;

spa/node_modules/postcss-calc/src/lib/convertUnit.js

@@ -0,0 +1,160 @@
+'use strict';
+/**
+ * @type {{[key:string]: {[key:string]: number}}}
+ */
+const conversions = {
+  // Absolute length units
+  px: {
+    px: 1,
+    cm: 96 / 2.54,
+    mm: 96 / 25.4,
+    q: 96 / 101.6,
+    in: 96,
+    pt: 96 / 72,
+    pc: 16,
+  },
+  cm: {
+    px: 2.54 / 96,
+    cm: 1,
+    mm: 0.1,
+    q: 0.025,
+    in: 2.54,
+    pt: 2.54 / 72,
+    pc: 2.54 / 6,
+  },
+  mm: {
+    px: 25.4 / 96,
+    cm: 10,
+    mm: 1,
+    q: 0.25,
+    in: 25.4,
+    pt: 25.4 / 72,
+    pc: 25.4 / 6,
+  },
+  q: {
+    px: 101.6 / 96,
+    cm: 40,
+    mm: 4,
+    q: 1,
+    in: 101.6,
+    pt: 101.6 / 72,
+    pc: 101.6 / 6,
+  },
+  in: {
+    px: 1 / 96,
+    cm: 1 / 2.54,
+    mm: 1 / 25.4,
+    q: 1 / 101.6,
+    in: 1,
+    pt: 1 / 72,
+    pc: 1 / 6,
+  },
+  pt: {
+    px: 0.75,
+    cm: 72 / 2.54,
+    mm: 72 / 25.4,
+    q: 72 / 101.6,
+    in: 72,
+    pt: 1,
+    pc: 12,
+  },
+  pc: {
+    px: 0.0625,
+    cm: 6 / 2.54,
+    mm: 6 / 25.4,
+    q: 6 / 101.6,
+    in: 6,
+    pt: 6 / 72,
+    pc: 1,
+  },
+  // Angle units
+  deg: {
+    deg: 1,
+    grad: 0.9,
+    rad: 180 / Math.PI,
+    turn: 360,
+  },
+  grad: {
+    deg: 400 / 360,
+    grad: 1,
+    rad: 200 / Math.PI,
+    turn: 400,
+  },
+  rad: {
+    deg: Math.PI / 180,
+    grad: Math.PI / 200,
+    rad: 1,
+    turn: Math.PI * 2,
+  },
+  turn: {
+    deg: 1 / 360,
+    grad: 0.0025,
+    rad: 0.5 / Math.PI,
+    turn: 1,
+  },
+  // Duration units
+  s: {
+    s: 1,
+    ms: 0.001,
+  },
+  ms: {
+    s: 1000,
+    ms: 1,
+  },
+  // Frequency units
+  hz: {
+    hz: 1,
+    khz: 1000,
+  },
+  khz: {
+    hz: 0.001,
+    khz: 1,
+  },
+  // Resolution units
+  dpi: {
+    dpi: 1,
+    dpcm: 1 / 2.54,
+    dppx: 1 / 96,
+  },
+  dpcm: {
+    dpi: 2.54,
+    dpcm: 1,
+    dppx: 2.54 / 96,
+  },
+  dppx: {
+    dpi: 96,
+    dpcm: 96 / 2.54,
+    dppx: 1,
+  },
+};
+/**
+ * @param {number} value
+ * @param {string} sourceUnit
+ * @param {string} targetUnit
+ * @param {number|false} precision
+ */
+function convertUnit(value, sourceUnit, targetUnit, precision) {
+  const sourceUnitNormalized = sourceUnit.toLowerCase();
+  const targetUnitNormalized = targetUnit.toLowerCase();
+
+  if (!conversions[targetUnitNormalized]) {
+    throw new Error('Cannot convert to ' + targetUnit);
+  }
+
+  if (!conversions[targetUnitNormalized][sourceUnitNormalized]) {
+    throw new Error('Cannot convert from ' + sourceUnit + ' to ' + targetUnit);
+  }
+
+  const converted =
+    conversions[targetUnitNormalized][sourceUnitNormalized] * value;
+
+  if (precision !== false) {
+    precision = Math.pow(10, Math.ceil(precision) || 5);
+
+    return Math.round(converted * precision) / precision;
+  }
+
+  return converted;
+}
+
+module.exports = convertUnit;

spa/node_modules/postcss-calc/src/lib/reducer.js

@@ -0,0 +1,362 @@
+'use strict';
+const convertUnit = require('./convertUnit.js');
+
+/**
+ * @param {import('../parser').CalcNode} node
+ * @return {node is import('../parser').ValueExpression}
+ */
+function isValueType(node) {
+  switch (node.type) {
+    case 'LengthValue':
+    case 'AngleValue':
+    case 'TimeValue':
+    case 'FrequencyValue':
+    case 'ResolutionValue':
+    case 'EmValue':
+    case 'ExValue':
+    case 'ChValue':
+    case 'RemValue':
+    case 'VhValue':
+    case 'VwValue':
+    case 'VminValue':
+    case 'VmaxValue':
+    case 'PercentageValue':
+    case 'Number':
+      return true;
+  }
+  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}`);
+  }
+  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
+      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 = '+';
+        reducedNode.value *= -1;
+      }
+      if (preOperator === '+') {
+        reducedNode.value += current.value;
+      } else {
+        reducedNode.value -= current.value;
+      }
+      // make sure reducedNode.value >= 0
+      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 });
+      } else {
+        node.value *= -1;
+        collected.push({ node, preOperator: flip(preOperator) });
+      }
+    }
+  } 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 {
+        collected.push({ node: reducedNode, preOperator });
+      }
+    }
+  } else if (node.type === 'ParenthesizedExpression') {
+    collectAddSubItems(preOperator, node.content, collected, precision);
+  } else {
+    collected.push({ node, preOperator });
+  }
+}
+
+/**
+ * @param {import('../parser').CalcNode} node
+ * @param {number} 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 = '+';
+  }
+
+  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)) {
+    return node;
+  }
+
+  if (node.right.type !== 'Number') {
+    throw new Error(`Cannot divide by "${node.right.unit}", number expected`);
+  }
+
+  return applyNumberDivision(node.left, node.right.value);
+}
+
+/**
+ * apply (expr) / number
+ *
+ * @param {import('../parser').CalcNode} node
+ * @param {number} divisor
+ * @return {import('../parser').CalcNode}
+ */
+function applyNumberDivision(node, divisor) {
+  if (divisor === 0) {
+    throw new Error('Cannot divide by zero');
+  }
+  if (isValueType(node)) {
+    node.value /= divisor;
+    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 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,
+    },
+  };
+}
+/**
+ * @param {import('../parser').MathExpression} node
+ */
+function reduceMultiplicationExpression(node) {
+  // (expr) * number
+  if (node.right.type === 'Number') {
+    return applyNumberMultiplication(node.left, node.right.value);
+  }
+  // number * (expr)
+  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}
+ */
+function applyNumberMultiplication(node, multiplier) {
+  if (isValueType(node)) {
+    node.value *= multiplier;
+    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 convertNodesUnits(left, right, precision) {
+  switch (left.type) {
+    case 'LengthValue':
+    case 'AngleValue':
+    case 'TimeValue':
+    case 'FrequencyValue':
+    case 'ResolutionValue':
+      if (right.type === left.type && right.unit && left.unit) {
+        const converted = convertUnit(
+          right.value,
+          right.unit,
+          left.unit,
+          precision
+        );
+
+        right = {
+          type: left.type,
+          value: converted,
+          unit: left.unit,
+        };
+      }
+
+      return { left, right };
+    default:
+      return { left, right };
+  }
+}
+
+/**
+ * @param {import('../parser').ParenthesizedExpression} node
+ */
+function includesNoCssProperties(node) {
+  return (
+    node.content.type !== 'Function' &&
+    (node.content.type !== 'MathExpression' ||
+      (node.content.right.type !== 'Function' &&
+        node.content.left.type !== 'Function'))
+  );
+}
+/**
+ * @param {import('../parser').CalcNode} node
+ * @param {number} precision
+ * @return {import('../parser').CalcNode}
+ */
+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 '/':
+        return reduceDivisionExpression(node);
+      case '*':
+        return reduceMultiplicationExpression(node);
+    }
+
+    return node;
+  }
+
+  if (node.type === 'ParenthesizedExpression') {
+    if (includesNoCssProperties(node)) {
+      return reduce(node.content, precision);
+    }
+  }
+
+  return node;
+}
+
+module.exports = reduce;

spa/node_modules/postcss-calc/src/lib/stringifier.js

@@ -0,0 +1,98 @@
+'use strict';
+const order = {
+  '*': 0,
+  '/': 0,
+  '+': 1,
+  '-': 1,
+};
+
+/**
+ * @param {number} value
+ * @param {number | false} prec
+ */
+function round(value, prec) {
+  if (prec !== false) {
+    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': {
+      const { left, right, operator: op } = node;
+      let str = '';
+      if (left.type === 'MathExpression' && order[op] < order[left.operator]) {
+        str += `(${stringify(left, prec)})`;
+      } else {
+        str += stringify(left, prec);
+      }
+
+      str += order[op] ? ` ${node.operator} ` : node.operator;
+
+      if (
+        right.type === 'MathExpression' &&
+        order[op] < order[right.operator]
+      ) {
+        str += `(${stringify(right, prec)})`;
+      } else {
+        str += stringify(right, prec);
+      }
+
+      return str;
+    }
+    case 'Number':
+      return round(node.value, prec).toString();
+    case 'Function':
+      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}
+ */
+module.exports = function (calc, node, originalValue, options, result, item) {
+  let str = stringify(node, options.precision);
+
+  const shouldPrintCalc =
+    node.type === 'MathExpression' || node.type === 'Function' ||
+    node.type === 'ParenthesizedExpression';
+
+  if (shouldPrintCalc) {
+    // if calc expression couldn't be resolved to a single value, re-wrap it as
+    // a calc()
+    if (node.type === 'ParenthesizedExpression') {
+      str = `${calc}${str}`;
+    } else {
+      str = `${calc}(${str})`;
+    }
+
+    // if the warnWhenCannotResolve option is on, inform the user that the calc
+    // expression could not be resolved to a single value
+    if (options.warnWhenCannotResolve) {
+      result.warn('Could not reduce expression: ' + originalValue, {
+        plugin: 'postcss-calc',
+        node: item,
+      });
+    }
+  }
+  return str;
+};

spa/node_modules/postcss-calc/src/lib/transform.js

@@ -0,0 +1,109 @@
+'use strict';
+const selectorParser = require('postcss-selector-parser');
+const valueParser = require('postcss-value-parser');
+
+const { parser } = require('../parser.js');
+
+const reducer = require('./reducer.js');
+const stringifier = require('./stringifier.js');
+
+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 valueParser(value)
+    .walk((node) => {
+      // skip anything which isn't a calc() function
+      if (node.type !== 'function' || !MATCH_CALC.test(node.value)) {
+        return;
+      }
+
+      // stringify calc expression and produce an AST
+      const contents = valueParser.stringify(node.nodes);
+      const ast = parser.parse(contents);
+
+      // reduce AST to its simplest form, that is, either to a single value
+      // or a simplified calc expression
+      const reducedAst = reducer(ast, options.precision);
+
+      // stringify AST and write it back
+      /** @type {valueParser.Node} */ (node).type = 'word';
+      node.value = stringifier(
+        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 selectorParser((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) {
+        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') {
+        node.value = transformValue(node.value, options, result, item);
+      }
+
+      return;
+    });
+  }).processSync(value);
+}
+
+/**
+ * @param {any} node
+ * @param {{precision: number, preserve: boolean, warnWhenCannotResolve: boolean}} options
+ * @param {'value'|'params'|'selector'} property
+ * @param {import("postcss").Result} result
+ */
+module.exports = (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) {
+    const clone = node.clone();
+    clone[property] = value;
+    node.parent.insertBefore(node, clone);
+  } else {
+    node[property] = value;
+  }
+};

spa/node_modules/postcss-calc/src/parser.d.ts

@@ -0,0 +1,51 @@
+export interface MathExpression {
+  type: 'MathExpression';
+  right: CalcNode;
+  left: CalcNode;
+  operator: '*' | '+' | '-' | '/';
+}
+
+export interface ParenthesizedExpression {
+  type: 'ParenthesizedExpression';
+  content: CalcNode;
+}
+
+export interface DimensionExpression {
+  type:
+    | 'LengthValue'
+    | 'AngleValue'
+    | 'TimeValue'
+    | 'FrequencyValue'
+    | 'PercentageValue'
+    | 'ResolutionValue'
+    | 'EmValue'
+    | 'ExValue'
+    | 'ChValue'
+    | 'RemValue'
+    | 'VhValue'
+    | 'VwValue'
+    | 'VminValue'
+    | 'VmaxValue';
+  value: number;
+  unit: string;
+}
+
+export interface NumberExpression {
+  type: 'Number';
+  value: number;
+}
+
+export interface FunctionExpression {
+  type: 'Function';
+  value: string;
+}
+
+export type ValueExpression = DimensionExpression | NumberExpression;
+
+export type CalcNode = MathExpression | ValueExpression | FunctionExpression | ParenthesizedExpression;
+
+export interface Parser {
+  parse: (arg: string) => CalcNode;
+}
+
+export const parser: Parser;

spa/node_modules/postcss-calc/types/index.d.ts

@@ -0,0 +1,25 @@
+export = pluginCreator;
+/**
+ * @typedef {{precision?: number | false,
+ *          preserve?: boolean,
+ *          warnWhenCannotResolve?: boolean,
+ *          mediaQueries?: boolean,
+ *          selectors?: boolean}} PostCssCalcOptions
+ */
+/**
+ * @type {import('postcss').PluginCreator<PostCssCalcOptions>}
+ * @param {PostCssCalcOptions} opts
+ * @return {import('postcss').Plugin}
+ */
+declare function pluginCreator(opts: PostCssCalcOptions): import('postcss').Plugin;
+declare namespace pluginCreator {
+    export { postcss, PostCssCalcOptions };
+}
+type PostCssCalcOptions = {
+    precision?: number | false;
+    preserve?: boolean;
+    warnWhenCannotResolve?: boolean;
+    mediaQueries?: boolean;
+    selectors?: boolean;
+};
+declare var postcss: true;

spa/node_modules/postcss-calc/types/lib/convertUnit.d.ts

@@ -0,0 +1,8 @@
+export = 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;

spa/node_modules/postcss-calc/types/lib/reducer.d.ts

@@ -0,0 +1,14 @@
+export = reduce;
+/**
+ * @param {import('../parser').CalcNode} node
+ * @param {number} precision
+ * @return {import('../parser').CalcNode}
+ */
+declare function reduce(node: import('../parser').CalcNode, precision: number): import('../parser').CalcNode;
+declare namespace reduce {
+    export { Collectible };
+}
+type Collectible = {
+    preOperator: '+' | '-';
+    node: import('../parser').CalcNode;
+};

spa/node_modules/postcss-calc/types/lib/stringifier.d.ts

@@ -0,0 +1,5 @@
+declare function _exports(calc: string, node: import('../parser').CalcNode, originalValue: string, options: {
+    precision: number | false;
+    warnWhenCannotResolve: boolean;
+}, result: import("postcss").Result, item: import("postcss").ChildNode): string;
+export = _exports;

spa/node_modules/postcss-calc/types/lib/transform.d.ts

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