0.2.0 - Mid migration

web/node_modules/postcss-calc/dist/index.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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({
+    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);
+      }
+    });
+  };
+});
+
+exports.default = _default;
+module.exports = exports.default;

web/node_modules/postcss-calc/dist/lib/convertUnit.js

@@ -0,0 +1,157 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var 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
+  }
+};
+
+function convertUnit(value, sourceUnit, targetUnit, precision) {
+  var sourceUnitNormalized = sourceUnit.toLowerCase();
+  var 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);
+  }
+
+  var converted = conversions[targetUnitNormalized][sourceUnitNormalized] * value;
+
+  if (precision !== false) {
+    precision = Math.pow(10, parseInt(precision) || 5);
+    return Math.round(converted * precision) / precision;
+  }
+
+  return converted;
+}
+
+var _default = convertUnit;
+exports.default = _default;
+module.exports = exports.default;

web/node_modules/postcss-calc/dist/lib/reducer.js

@@ -0,0 +1,320 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _convertUnit = _interopRequireDefault(require("./convertUnit"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function isValueType(type) {
+  switch (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;
+}
+
+function flip(operator) {
+  return operator === '+' ? '-' : '+';
+}
+
+function isAddSubOperator(operator) {
+  return operator === '+' || operator === '-';
+}
+
+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 (itemIndex >= 0) {
+      if (node.value === 0) {
+        return;
+      }
+
+      var _covertNodesUnits = covertNodesUnits(collected[itemIndex].node, node, precision),
+          reducedNode = _covertNodesUnits.left,
+          current = _covertNodesUnits.right;
+
+      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 (type === "MathExpression") {
+    if (isAddSubOperator(node.operator)) {
+      collectAddSubItems(preOperator, node.left, collected, precision);
+      var collectRightOperator = preOperator === '-' ? flip(node.operator) : node.operator;
+      collectAddSubItems(collectRightOperator, node.right, collected, precision);
+    } else {
+      // * or /
+      var _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 {
+    collected.push({
+      node,
+      preOperator
+    });
+  }
+}
+
+function reduceAddSubExpression(node, precision) {
+  var 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
+  // 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);
+  } // make sure the preOperator of the first item is +
+
+
+  if (withoutZeroItem[0].preOperator === '-' && isValueType(withoutZeroItem[0].node.type)) {
+    withoutZeroItem[0].node.value *= -1;
+    withoutZeroItem[0].preOperator = '+';
+  }
+
+  var root = withoutZeroItem[0].node;
+
+  for (var i = 1; i < withoutZeroItem.length; i++) {
+    root = {
+      type: 'MathExpression',
+      operator: withoutZeroItem[i].preOperator,
+      left: root,
+      right: withoutZeroItem[i].node
+    };
+  }
+
+  return root;
+}
+
+function reduceDivisionExpression(node) {
+  if (!isValueType(node.right.type)) {
+    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
+
+
+function applyNumberDivision(node, divisor) {
+  if (divisor === 0) {
+    throw new Error('Cannot divide by zero');
+  }
+
+  if (isValueType(node.type)) {
+    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
+    }
+  };
+}
+
+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
+
+
+function applyNumberMultiplication(node, multiplier) {
+  if (isValueType(node.type)) {
+    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
+    }
+  };
+}
+
+function covertNodesUnits(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) {
+        var converted = (0, _convertUnit.default)(right.value, right.unit, left.unit, precision);
+        right = {
+          type: left.type,
+          value: converted,
+          unit: left.unit
+        };
+      }
+
+      return {
+        left,
+        right
+      };
+
+    default:
+      return {
+        left,
+        right
+      };
+  }
+}
+
+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, precision);
+
+      case "*":
+        return reduceMultiplicationExpression(node, precision);
+    }
+
+    return node;
+  }
+
+  return node;
+}
+
+var _default = reduce;
+exports.default = _default;
+module.exports = exports.default;

web/node_modules/postcss-calc/dist/lib/stringifier.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var order = {
+  "*": 0,
+  "/": 0,
+  "+": 1,
+  "-": 1
+};
+
+function round(value, prec) {
+  if (prec !== false) {
+    var precision = Math.pow(10, prec);
+    return Math.round(value * precision) / precision;
+  }
+
+  return value;
+}
+
+function stringify(node, prec) {
+  switch (node.type) {
+    case "MathExpression":
+      {
+        var left = node.left,
+            right = node.right,
+            op = node.operator;
+        var 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);
+
+    case 'Function':
+      return node.value;
+
+    default:
+      return round(node.value, prec) + node.unit;
+  }
+}
+
+function _default(calc, node, originalValue, options, result, item) {
+  var str = stringify(node, options.precision);
+  var shouldPrintCalc = node.type === "MathExpression" || node.type === "Function";
+
+  if (shouldPrintCalc) {
+    // if calc expression couldn't be resolved to a single value, re-wrap it as
+    // a calc()
+    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;
+}
+
+module.exports = exports.default;

web/node_modules/postcss-calc/dist/lib/transform.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _postcssSelectorParser = _interopRequireDefault(require("postcss-selector-parser"));
+
+var _postcssValueParser = _interopRequireDefault(require("postcss-value-parser"));
+
+var _parser = require("../parser");
+
+var _reducer = _interopRequireDefault(require("./reducer"));
+
+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;
+
+function transformValue(value, options, result, item) {
+  return (0, _postcssValueParser.default)(value).walk(function (node) {
+    // skip anything which isn't a calc() function
+    if (node.type !== 'function' || !MATCH_CALC.test(node.value)) {
+      return node;
+    } // stringify calc expression and produce an AST
+
+
+    var 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
+    // or a simplified calc expression
+
+
+    var reducedAst = (0, _reducer.default)(ast, options.precision); // stringify AST and write it back
+
+    node.type = 'word';
+    node.value = (0, _stringifier.default)(node.value, reducedAst, value, options, result, item);
+    return false;
+  }).toString();
+}
+
+function transformSelector(value, options, result, item) {
+  return (0, _postcssSelectorParser.default)(function (selectors) {
+    selectors.walk(function (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);
+}
+
+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
+  // 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();
+    clone[property] = value;
+    node.parent.insertBefore(node, clone);
+  } else {
+    node[property] = value;
+  }
+};
+
+exports.default = _default;
+module.exports = exports.default;