updates

3 files changed, 374 insertions, 0 deletions

diff --git a/node_modules/reduce-css-calc/dist/lib/convert.js b/node_modules/reduce-css-calc/dist/lib/convert.js
new file mode 100644
index 00000000..3e5815ff
--- /dev/null
+++ b/node_modules/reduce-css-calc/dist/lib/convert.js
@@ -0,0 +1,38 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _cssUnitConverter = require('css-unit-converter');
+
+var _cssUnitConverter2 = _interopRequireDefault(_cssUnitConverter);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function convertNodes(left, right, precision) {
+  switch (left.type) {
+    case 'LengthValue':
+    case 'AngleValue':
+    case 'TimeValue':
+    case 'FrequencyValue':
+    case 'ResolutionValue':
+      return convertAbsoluteLength(left, right, precision);
+    default:
+      return { left: left, right: right };
+  }
+}
+
+function convertAbsoluteLength(left, right, precision) {
+  if (right.type === left.type) {
+    right = {
+      type: left.type,
+      value: (0, _cssUnitConverter2.default)(right.value, right.unit, left.unit, precision),
+      unit: left.unit
+    };
+  }
+  return { left: left, right: right };
+}
+
+exports.default = convertNodes;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/reduce-css-calc/dist/lib/reducer.js b/node_modules/reduce-css-calc/dist/lib/reducer.js
new file mode 100644
index 00000000..a3d6cce9
--- /dev/null
+++ b/node_modules/reduce-css-calc/dist/lib/reducer.js
@@ -0,0 +1,258 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.flip = flip;
+
+var _convert = require("./convert");
+
+var _convert2 = _interopRequireDefault(_convert);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function reduce(node, precision) {
+  if (node.type === "MathExpression") return reduceMathExpression(node, precision);
+  if (node.type === "Calc") return reduce(node.value, precision);
+
+  return node;
+}
+
+function isEqual(left, right) {
+  return left.type === right.type && left.value === right.value;
+}
+
+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 'Value':
+      return true;
+  }
+  return false;
+}
+
+function convertMathExpression(node, precision) {
+  var nodes = (0, _convert2.default)(node.left, node.right, precision);
+  var left = reduce(nodes.left, precision);
+  var right = reduce(nodes.right, precision);
+
+  if (left.type === "MathExpression" && right.type === "MathExpression") {
+
+    if (left.operator === '/' && right.operator === '*' || left.operator === '-' && right.operator === '+' || left.operator === '*' && right.operator === '/' || left.operator === '+' && right.operator === '-') {
+
+      if (isEqual(left.right, right.right)) nodes = (0, _convert2.default)(left.left, right.left, precision);else if (isEqual(left.right, right.left)) nodes = (0, _convert2.default)(left.left, right.right, precision);
+
+      left = reduce(nodes.left, precision);
+      right = reduce(nodes.right, precision);
+    }
+  }
+
+  node.left = left;
+  node.right = right;
+  return node;
+}
+
+function flip(operator) {
+  return operator === '+' ? '-' : '+';
+}
+
+function flipValue(node) {
+  if (isValueType(node.type)) node.value = -node.value;else if (node.type == 'MathExpression') {
+    node.left = flipValue(node.left);
+    node.right = flipValue(node.right);
+  }
+  return node;
+}
+
+function reduceAddSubExpression(node, precision) {
+  var _node = node,
+      left = _node.left,
+      right = _node.right,
+      op = _node.operator;
+
+
+  if (left.type === 'CssVariable' || right.type === 'CssVariable') return node;
+
+  // something + 0 => something
+  // something - 0 => something
+  if (right.value === 0) return left;
+
+  // 0 + something => something
+  if (left.value === 0 && op === "+") return right;
+
+  // 0 - something => -something
+  if (left.value === 0 && op === "-") return flipValue(right);
+
+  // value + value
+  // value - value
+  if (left.type === right.type && isValueType(left.type)) {
+    node = Object.assign({}, left);
+    if (op === "+") node.value = left.value + right.value;else node.value = left.value - right.value;
+  }
+
+  // value <op> (expr)
+  if (isValueType(left.type) && (right.operator === '+' || right.operator === '-') && right.type === 'MathExpression') {
+    // value + (value + something) => (value + value) + something
+    // value + (value - something) => (value + value) - something
+    // value - (value + something) => (value - value) - something
+    // value - (value - something) => (value - value) + something
+    if (left.type === right.left.type) {
+      node = Object.assign({}, node);
+      node.left = reduce({
+        type: 'MathExpression',
+        operator: op,
+        left: left,
+        right: right.left
+      }, precision);
+      node.right = right.right;
+      node.operator = op === '-' ? flip(right.operator) : right.operator;
+      return reduce(node, precision);
+    }
+    // value + (something + value) => (value + value) + something
+    // value + (something - value) => (value - value) + something
+    // value - (something + value) => (value - value) - something
+    // value - (something - value) => (value + value) - something
+    else if (left.type === right.right.type) {
+        node = Object.assign({}, node);
+        node.left = reduce({
+          type: 'MathExpression',
+          operator: op === '-' ? flip(right.operator) : right.operator,
+          left: left,
+          right: right.right
+        }, precision);
+        node.right = right.left;
+        return reduce(node, precision);
+      }
+  }
+
+  // (expr) <op> value
+  if (left.type === 'MathExpression' && (left.operator === '+' || left.operator === '-') && isValueType(right.type)) {
+    // (value + something) + value => (value + value) + something
+    // (value - something) + value => (value + value) - something
+    // (value + something) - value => (value - value) + something
+    // (value - something) - value => (value - value) - something
+    if (right.type === left.left.type) {
+      node = Object.assign({}, left);
+      node.left = reduce({
+        type: 'MathExpression',
+        operator: op,
+        left: left.left,
+        right: right
+      }, precision);
+      return reduce(node, precision);
+    }
+    // (something + value) + value => something + (value + value)
+    // (something - value1) + value2 => something - (value2 - value1)
+    // (something + value) - value => something + (value - value)
+    // (something - value) - value => something - (value + value)
+    else if (right.type === left.right.type) {
+        node = Object.assign({}, left);
+        if (left.operator === '-') {
+          node.right = reduce({
+            type: 'MathExpression',
+            operator: op === '-' ? '+' : '-',
+            left: right,
+            right: left.right
+          }, precision);
+          node.operator = op === '-' ? '-' : '+';
+        } else {
+          node.right = reduce({
+            type: 'MathExpression',
+            operator: op,
+            left: left.right,
+            right: right
+          }, precision);
+        }
+        if (node.right.value < 0) {
+          node.right.value *= -1;
+          node.operator = node.operator === '-' ? '+' : '-';
+        }
+        return reduce(node, precision);
+      }
+  }
+  return node;
+}
+
+function reduceDivisionExpression(node, precision) {
+  if (!isValueType(node.right.type)) return node;
+
+  if (node.right.type !== 'Value') throw new Error("Cannot divide by \"" + node.right.unit + "\", number expected");
+
+  if (node.right.value === 0) throw new Error('Cannot divide by zero');
+
+  // (expr) / value
+  if (node.left.type === 'MathExpression') {
+    if (isValueType(node.left.left.type) && isValueType(node.left.right.type)) {
+      node.left.left.value /= node.right.value;
+      node.left.right.value /= node.right.value;
+      return reduce(node.left, precision);
+    }
+    return node;
+  }
+  // something / value
+  else if (isValueType(node.left.type)) {
+      node.left.value /= node.right.value;
+      return node.left;
+    }
+  return node;
+}
+
+function reduceMultiplicationExpression(node) {
+  // (expr) * value
+  if (node.left.type === 'MathExpression' && node.right.type === 'Value') {
+    if (isValueType(node.left.left.type) && isValueType(node.left.right.type)) {
+      node.left.left.value *= node.right.value;
+      node.left.right.value *= node.right.value;
+      return node.left;
+    }
+  }
+  // something * value
+  else if (isValueType(node.left.type) && node.right.type === 'Value') {
+      node.left.value *= node.right.value;
+      return node.left;
+    }
+    // value * (expr)
+    else if (node.left.type === 'Value' && node.right.type === 'MathExpression') {
+        if (isValueType(node.right.left.type) && isValueType(node.right.right.type)) {
+          node.right.left.value *= node.left.value;
+          node.right.right.value *= node.left.value;
+          return node.right;
+        }
+      }
+      // value * something
+      else if (node.left.type === 'Value' && isValueType(node.right.type)) {
+          node.right.value *= node.left.value;
+          return node.right;
+        }
+  return node;
+}
+
+function reduceMathExpression(node, precision) {
+  node = convertMathExpression(node, precision);
+
+  switch (node.operator) {
+    case "+":
+    case "-":
+      return reduceAddSubExpression(node, precision);
+    case "/":
+      return reduceDivisionExpression(node, precision);
+    case "*":
+      return reduceMultiplicationExpression(node);
+  }
+  return node;
+}
+
+exports.default = reduce;
\ No newline at end of file
diff --git a/node_modules/reduce-css-calc/dist/lib/stringifier.js b/node_modules/reduce-css-calc/dist/lib/stringifier.js
new file mode 100644
index 00000000..92e76326
--- /dev/null
+++ b/node_modules/reduce-css-calc/dist/lib/stringifier.js
@@ -0,0 +1,78 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = function (calc, node, precision) {
+  var str = stringify(node, precision);
+
+  if (node.type === "MathExpression") {
+    // if calc expression couldn't be resolved to a single value, re-wrap it as
+    // a calc()
+    str = calc + "(" + str + ")";
+  }
+  return str;
+};
+
+var _reducer = require("./reducer");
+
+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 += " " + node.operator + " ";
+
+        if (right.type === 'MathExpression' && order[op] < order[right.operator]) {
+          str += "(" + stringify(right, prec) + ")";
+        } else if (right.type === 'MathExpression' && op === "-" && ["+", "-"].includes(right.operator)) {
+          // fix #52 : a-(b+c) = a-b-c
+          right.operator = (0, _reducer.flip)(right.operator);
+          str += stringify(right, prec);
+        } else {
+          str += stringify(right, prec);
+        }
+
+        return str;
+      }
+    case "Value":
+      return round(node.value, prec);
+    case 'CssVariable':
+      if (node.fallback) {
+        return "var(" + node.value + ", " + stringify(node.fallback, prec, true) + ")";
+      }
+      return "var(" + node.value + ")";
+    case 'Calc':
+      if (node.prefix) {
+        return "-" + node.prefix + "-calc(" + stringify(node.value, prec) + ")";
+      }
+      return "calc(" + stringify(node.value, prec) + ")";
+    default:
+      return round(node.value, prec) + node.unit;
+  }
+}
+
+module.exports = exports["default"];
\ No newline at end of file