nav tabs on admin dashboard

node_modules/postcss-merge-longhand/dist/lib/decl/borders.js

@@ -1,27 +1,13 @@
 'use strict';
 
-exports.__esModule = true;
-
-var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
-
-var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
 
 var _postcss = require('postcss');
 
 var _stylehacks = require('stylehacks');
 
-var _objectAssign = require('object-assign');
-
-var _objectAssign2 = _interopRequireDefault(_objectAssign);
-
-var _clone = require('../clone');
-
-var _clone2 = _interopRequireDefault(_clone);
-
-var _genericMerge = require('../genericMerge');
-
-var _genericMerge2 = _interopRequireDefault(_genericMerge);
-
 var _insertCloned = require('../insertCloned');
 
 var _insertCloned2 = _interopRequireDefault(_insertCloned);
@@ -34,10 +20,6 @@ var _hasAllProps = require('../hasAllProps');
 
 var _hasAllProps2 = _interopRequireDefault(_hasAllProps);
 
-var _getLastNode = require('../getLastNode');
-
-var _getLastNode2 = _interopRequireDefault(_getLastNode);
-
 var _getDecls = require('../getDecls');
 
 var _getDecls2 = _interopRequireDefault(_getDecls);
@@ -50,18 +32,22 @@ var _getValue = require('../getValue');
 
 var _getValue2 = _interopRequireDefault(_getValue);
 
+var _mergeRules = require('../mergeRules');
+
+var _mergeRules2 = _interopRequireDefault(_mergeRules);
+
 var _minifyTrbl = require('../minifyTrbl');
 
 var _minifyTrbl2 = _interopRequireDefault(_minifyTrbl);
 
+var _minifyWsc = require('../minifyWsc');
+
+var _minifyWsc2 = _interopRequireDefault(_minifyWsc);
+
 var _canMerge = require('../canMerge');
 
 var _canMerge2 = _interopRequireDefault(_canMerge);
 
-var _colorMerge = require('../colorMerge');
-
-var _colorMerge2 = _interopRequireDefault(_colorMerge);
-
 var _remove = require('../remove');
 
 var _remove2 = _interopRequireDefault(_remove);
@@ -70,39 +56,118 @@ var _trbl = require('../trbl');
 
 var _trbl2 = _interopRequireDefault(_trbl);
 
+var _isCustomProp = require('../isCustomProp');
+
+var _isCustomProp2 = _interopRequireDefault(_isCustomProp);
+
+var _canExplode = require('../canExplode');
+
+var _canExplode2 = _interopRequireDefault(_canExplode);
+
+var _getLastNode = require('../getLastNode');
+
+var _getLastNode2 = _interopRequireDefault(_getLastNode);
+
+var _parseWsc = require('../parseWsc');
+
+var _parseWsc2 = _interopRequireDefault(_parseWsc);
+
+var _validateWsc = require('../validateWsc');
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var wsc = ['width', 'style', 'color'];
-var defaults = ['medium', 'none', 'currentColor'];
+const wsc = ['width', 'style', 'color'];
+const defaults = ['medium', 'none', 'currentcolor'];
 
-var borderProperty = function borderProperty(property) {
-    return 'border-' + property;
-};
-var directions = _trbl2.default.map(borderProperty);
-var properties = wsc.map(borderProperty);
+function borderProperty(...parts) {
+    return `border-${parts.join('-')}`;
+}
 
-function mergeRedundant(_ref) {
-    var values = _ref.values;
-    var nextValues = _ref.nextValues;
-    var decl = _ref.decl;
-    var nextDecl = _ref.nextDecl;
-    var index = _ref.index;
-    var position = _ref.position;
-    var prop = _ref.prop;
+function mapBorderProperty(value) {
+    return borderProperty(value);
+}
+
+const directions = _trbl2.default.map(mapBorderProperty);
+const properties = wsc.map(mapBorderProperty);
+const directionalProperties = directions.reduce((prev, curr) => prev.concat(wsc.map(prop => `${curr}-${prop}`)), []);
+
+const precedence = [['border'], directions.concat(properties), directionalProperties];
+
+const allProperties = precedence.reduce((a, b) => a.concat(b));
+
+function getLevel(prop) {
+    for (let i = 0; i < precedence.length; i++) {
+        if (!!~precedence[i].indexOf(prop.toLowerCase())) {
+            return i;
+        }
+    }
+}
+
+const isValueCustomProp = value => value && !!~value.search(/var\s*\(\s*--/i);
+
+function canMergeValues(values) {
+    return !values.some(isValueCustomProp) || values.every(isValueCustomProp);
+}
+
+function getColorValue(decl) {
+    if (decl.prop.substr(-5) === 'color') {
+        return decl.value;
+    }
+
+    return (0, _parseWsc2.default)(decl.value)[2] || defaults[2];
+}
+
+function diffingProps(values, nextValues) {
+    return wsc.reduce((prev, curr, i) => {
+        if (values[i] === nextValues[i]) {
+            return prev;
+        }
+
+        return [...prev, curr];
+    }, []);
+}
+
+function mergeRedundant({ values, nextValues, decl, nextDecl, index }) {
+    if (!(0, _canMerge2.default)([decl, nextDecl])) {
+        return;
+    }
+
+    if ((0, _stylehacks.detect)(decl) || (0, _stylehacks.detect)(nextDecl)) {
+        return;
+    }
+
+    const diff = diffingProps(values, nextValues);
+
+    if (diff.length > 1) {
+        return;
+    }
+
+    const prop = diff.pop();
+    const position = wsc.indexOf(prop);
+
+    const prop1 = `${nextDecl.prop}-${prop}`;
+    const prop2 = `border-${prop}`;
+
+    let props = (0, _parseTrbl2.default)(values[position]);
 
-    var props = (0, _parseTrbl2.default)(values[position]);
     props[index] = nextValues[position];
-    values.splice(position, 1);
-    var borderValue = values.join(' ');
-    var propertyValue = (0, _minifyTrbl2.default)(props);
 
-    var origLength = (decl.value + nextDecl.prop + nextDecl.value).length;
-    var newLength = borderValue.length + 12 + propertyValue.length;
+    const borderValue2 = values.filter((e, i) => i !== position).join(' ');
+    const propValue2 = (0, _minifyTrbl2.default)(props);
 
-    if (newLength < origLength) {
-        decl.value = borderValue;
-        nextDecl.prop = prop;
-        nextDecl.value = propertyValue;
+    const origLength = ((0, _minifyWsc2.default)(decl.value) + nextDecl.prop + nextDecl.value).length;
+    const newLength1 = decl.value.length + prop1.length + (0, _minifyWsc2.default)(nextValues[position]).length;
+    const newLength2 = borderValue2.length + prop2.length + propValue2.length;
+
+    if (newLength1 < newLength2 && newLength1 < origLength) {
+        nextDecl.prop = prop1;
+        nextDecl.value = nextValues[position];
+    }
+
+    if (newLength2 < newLength1 && newLength2 < origLength) {
+        decl.value = borderValue2;
+        nextDecl.prop = prop2;
+        nextDecl.value = propValue2;
     }
 }
 
@@ -111,332 +176,528 @@ function isCloseEnough(mapped) {
 }
 
 function getDistinctShorthands(mapped) {
-    return mapped.reduce(function (a, b) {
+    return mapped.reduce((a, b) => {
         a = Array.isArray(a) ? a : [a];
+
         if (!~a.indexOf(b)) {
             a.push(b);
         }
+
         return a;
     });
 }
 
 function explode(rule) {
-    if (rule.nodes.some(_stylehacks.detect)) {
-        return false;
-    }
-    rule.walkDecls(/^border/, function (decl) {
-        // Don't explode inherit values as they cannot be merged together
-        if (decl.value === 'inherit') {
+    rule.walkDecls(/^border/i, decl => {
+        if (!(0, _canExplode2.default)(decl, false)) {
             return;
         }
-        var prop = decl.prop;
-        // border -> border-trbl
 
-        if (prop === 'border') {
-            directions.forEach(function (direction) {
-                (0, _insertCloned2.default)(rule, decl, { prop: direction });
-            });
-            return decl.remove();
+        if ((0, _stylehacks.detect)(decl)) {
+            return;
         }
+
+        const prop = decl.prop.toLowerCase();
+
+        // border -> border-trbl
+        if (prop === 'border') {
+            if ((0, _validateWsc.isValidWsc)((0, _parseWsc2.default)(decl.value))) {
+                directions.forEach(direction => {
+                    (0, _insertCloned2.default)(decl.parent, decl, { prop: direction });
+                });
+
+                return decl.remove();
+            }
+        }
+
         // border-trbl -> border-trbl-wsc
-        if (directions.some(function (direction) {
-            return prop === direction;
-        })) {
-            var _ret = function () {
-                var values = _postcss.list.space(decl.value);
-                wsc.forEach(function (d, i) {
-                    (0, _insertCloned2.default)(rule, decl, {
-                        prop: prop + '-' + d,
+        if (directions.some(direction => prop === direction)) {
+            let values = (0, _parseWsc2.default)(decl.value);
+
+            if ((0, _validateWsc.isValidWsc)(values)) {
+                wsc.forEach((d, i) => {
+                    (0, _insertCloned2.default)(decl.parent, decl, {
+                        prop: `${prop}-${d}`,
                         value: values[i] || defaults[i]
                     });
                 });
-                return {
-                    v: decl.remove()
-                };
-            }();
 
-            if ((typeof _ret === 'undefined' ? 'undefined' : _typeof(_ret)) === "object") return _ret.v;
+                return decl.remove();
+            }
         }
+
         // border-wsc -> border-trbl-wsc
-        wsc.some(function (style) {
-            if (prop !== 'border-' + style) {
+        wsc.some(style => {
+            if (prop !== borderProperty(style)) {
                 return false;
             }
-            (0, _parseTrbl2.default)(decl.value).forEach(function (value, i) {
-                (0, _insertCloned2.default)(rule, decl, {
-                    prop: 'border-' + _trbl2.default[i] + '-' + style,
-                    value: value
+
+            (0, _parseTrbl2.default)(decl.value).forEach((value, i) => {
+                (0, _insertCloned2.default)(decl.parent, decl, {
+                    prop: borderProperty(_trbl2.default[i], style),
+                    value
                 });
             });
+
             return decl.remove();
         });
     });
 }
 
-var borderProperties = _trbl2.default.reduce(function (props, direction) {
-    return [].concat(props, wsc.map(function (style) {
-        return 'border-' + direction + '-' + style;
-    }));
-}, []);
-
 function merge(rule) {
-    // Lift all inherit values from the rule, so that they don't
-    // interfere with the merging logic.
-    var inheritValues = (0, _getDecls2.default)(rule, borderProperties).reduce(function (values, decl) {
-        if (decl.value === 'inherit') {
-            decl.remove();
-            return [].concat(values, [decl]);
-        }
-        return values;
-    }, []);
     // border-trbl-wsc -> border-trbl
-    _trbl2.default.forEach(function (direction) {
-        var prop = borderProperty(direction);
-        (0, _genericMerge2.default)({
-            rule: rule,
-            prop: prop,
-            properties: wsc.map(function (style) {
-                return prop + '-' + style;
-            }),
-            value: function value(rules) {
-                return rules.map(_getValue2.default).join(' ');
+    _trbl2.default.forEach(direction => {
+        const prop = borderProperty(direction);
+
+        (0, _mergeRules2.default)(rule, wsc.map(style => borderProperty(direction, style)), (rules, lastNode) => {
+            if ((0, _canMerge2.default)(rules, false) && !rules.some(_stylehacks.detect)) {
+                (0, _insertCloned2.default)(lastNode.parent, lastNode, {
+                    prop,
+                    value: rules.map(_getValue2.default).join(' ')
+                });
+
+                rules.forEach(_remove2.default);
+
+                return true;
             }
         });
     });
 
     // border-trbl-wsc -> border-wsc
-    wsc.forEach(function (style) {
-        var prop = borderProperty(style);
-        if (style === 'color') {
-            return (0, _colorMerge2.default)({
-                rule: rule,
-                prop: prop,
-                properties: _trbl2.default.map(function (direction) {
-                    return 'border-' + direction + '-' + style;
-                }),
-                value: function value(rules) {
-                    return (0, _minifyTrbl2.default)(rules.map(_getValue2.default).join(' '));
-                }
-            });
-        }
-        return (0, _genericMerge2.default)({
-            rule: rule,
-            prop: prop,
-            properties: _trbl2.default.map(function (direction) {
-                return 'border-' + direction + '-' + style;
-            }),
-            value: function value(rules) {
-                return (0, _minifyTrbl2.default)(rules.map(_getValue2.default).join(' '));
-            },
-            sanitize: false
+    wsc.forEach(style => {
+        const prop = borderProperty(style);
+
+        (0, _mergeRules2.default)(rule, _trbl2.default.map(direction => borderProperty(direction, style)), (rules, lastNode) => {
+            if ((0, _canMerge2.default)(rules) && !rules.some(_stylehacks.detect)) {
+                (0, _insertCloned2.default)(lastNode.parent, lastNode, {
+                    prop,
+                    value: (0, _minifyTrbl2.default)(rules.map(_getValue2.default).join(' '))
+                });
+
+                rules.forEach(_remove2.default);
+
+                return true;
+            }
         });
     });
 
     // border-trbl -> border-wsc
-    var decls = (0, _getDecls2.default)(rule, directions);
-
-    var _loop = function _loop() {
-        var lastNode = decls[decls.length - 1];
-        var props = decls.filter(function (node) {
-            return node.important === lastNode.important;
-        });
-        var rules = (0, _getRules2.default)(props, directions);
-        if (_hasAllProps2.default.apply(undefined, [props].concat(directions))) {
-            wsc.forEach(function (d, i) {
-                (0, _insertCloned2.default)(rule, lastNode, {
-                    prop: borderProperty(d),
-                    value: (0, _minifyTrbl2.default)(rules.map(function (node) {
-                        return _postcss.list.space(node.value)[i];
-                    }))
-                });
-            });
-            props.forEach(_remove2.default);
+    (0, _mergeRules2.default)(rule, directions, (rules, lastNode) => {
+        if (rules.some(_stylehacks.detect)) {
+            return;
         }
-        decls = decls.filter(function (node) {
-            return !~rules.indexOf(node);
-        });
-    };
 
-    while (decls.length) {
-        _loop();
-    }
+        const values = rules.map(({ value }) => value);
+
+        if (!canMergeValues(values)) {
+            return;
+        }
+
+        const parsed = values.map(value => (0, _parseWsc2.default)(value));
+
+        if (!parsed.every(_validateWsc.isValidWsc)) {
+            return;
+        }
+
+        wsc.forEach((d, i) => {
+            const value = parsed.map(v => v[i] || defaults[i]);
+
+            if (canMergeValues(value)) {
+                (0, _insertCloned2.default)(lastNode.parent, lastNode, {
+                    prop: borderProperty(d),
+                    value: (0, _minifyTrbl2.default)(value)
+                });
+            } else {
+                (0, _insertCloned2.default)(lastNode.parent, lastNode);
+            }
+        });
+
+        rules.forEach(_remove2.default);
+
+        return true;
+    });
 
     // border-wsc -> border
     // border-wsc -> border + border-color
     // border-wsc -> border + border-dir
-    decls = (0, _getDecls2.default)(rule, properties);
-
-    var _loop2 = function _loop2() {
-        var lastNode = decls[decls.length - 1];
-        var props = decls.filter(function (node) {
-            return node.important === lastNode.important;
-        });
-        if (_hasAllProps2.default.apply(undefined, [props].concat(properties))) {
-            (function () {
-                var rules = properties.map(function (prop) {
-                    return (0, _getLastNode2.default)(props, prop);
-                });
-                var width = rules[0];
-                var style = rules[1];
-                var color = rules[2];
-
-                var values = rules.map(function (node) {
-                    return (0, _parseTrbl2.default)(node.value);
-                });
-                var mapped = [0, 1, 2, 3].map(function (i) {
-                    return [values[0][i], values[1][i], values[2][i]].join(' ');
-                });
-                var reduced = getDistinctShorthands(mapped);
-
-                if (isCloseEnough(mapped) && _canMerge2.default.apply(undefined, rules)) {
-                    var first = mapped.indexOf(reduced[0]) !== mapped.lastIndexOf(reduced[0]);
-
-                    var border = (0, _insertCloned2.default)(rule, lastNode, {
-                        prop: 'border',
-                        value: first ? reduced[0] : reduced[1]
-                    });
-
-                    if (reduced[1]) {
-                        var value = first ? reduced[1] : reduced[0];
-                        var prop = 'border-' + _trbl2.default[mapped.indexOf(value)];
-
-                        rule.insertAfter(border, (0, _objectAssign2.default)((0, _clone2.default)(lastNode), {
-                            prop: prop,
-                            value: value
-                        }));
-                    }
-                    props.forEach(_remove2.default);
-                } else if (reduced.length === 1) {
-                    rule.insertBefore(color, (0, _objectAssign2.default)((0, _clone2.default)(lastNode), {
-                        prop: 'border',
-                        value: [width, style].map(_getValue2.default).join(' ')
-                    }));
-                    props.filter(function (node) {
-                        return node.prop !== properties[2];
-                    }).forEach(_remove2.default);
-                }
-            })();
+    (0, _mergeRules2.default)(rule, properties, (rules, lastNode) => {
+        if (rules.some(_stylehacks.detect)) {
+            return;
         }
-        decls = decls.filter(function (node) {
-            return !~props.indexOf(node);
-        });
-    };
 
-    while (decls.length) {
-        _loop2();
-    }
+        const values = rules.map(node => (0, _parseTrbl2.default)(node.value));
+        const mapped = [0, 1, 2, 3].map(i => [values[0][i], values[1][i], values[2][i]].join(' '));
+
+        if (!canMergeValues(mapped)) {
+            return;
+        }
+
+        const [width, style, color] = rules;
+        const reduced = getDistinctShorthands(mapped);
+
+        if (isCloseEnough(mapped) && (0, _canMerge2.default)(rules, false)) {
+            const first = mapped.indexOf(reduced[0]) !== mapped.lastIndexOf(reduced[0]);
+
+            const border = (0, _insertCloned2.default)(lastNode.parent, lastNode, {
+                prop: 'border',
+                value: first ? reduced[0] : reduced[1]
+            });
+
+            if (reduced[1]) {
+                const value = first ? reduced[1] : reduced[0];
+                const prop = borderProperty(_trbl2.default[mapped.indexOf(value)]);
+
+                rule.insertAfter(border, Object.assign(lastNode.clone(), {
+                    prop,
+                    value
+                }));
+            }
+            rules.forEach(_remove2.default);
+
+            return true;
+        } else if (reduced.length === 1) {
+            rule.insertBefore(color, Object.assign(lastNode.clone(), {
+                prop: 'border',
+                value: [width, style].map(_getValue2.default).join(' ')
+            }));
+            rules.filter(node => node.prop.toLowerCase() !== properties[2]).forEach(_remove2.default);
+
+            return true;
+        }
+    });
+
+    // border-wsc -> border + border-trbl
+    (0, _mergeRules2.default)(rule, properties, (rules, lastNode) => {
+        if (rules.some(_stylehacks.detect)) {
+            return;
+        }
+
+        const values = rules.map(node => (0, _parseTrbl2.default)(node.value));
+        const mapped = [0, 1, 2, 3].map(i => [values[0][i], values[1][i], values[2][i]].join(' '));
+        const reduced = getDistinctShorthands(mapped);
+        const none = 'medium none currentcolor';
+
+        if (reduced.length > 1 && reduced.length < 4 && reduced.includes(none)) {
+            const filtered = mapped.filter(p => p !== none);
+            const mostCommon = reduced.sort((a, b) => mapped.filter(v => v === b).length - mapped.filter(v => v === a).length)[0];
+            const borderValue = reduced.length === 2 ? filtered[0] : mostCommon;
+
+            rule.insertBefore(lastNode, Object.assign(lastNode.clone(), {
+                prop: 'border',
+                value: borderValue
+            }));
+
+            directions.forEach((dir, i) => {
+                if (mapped[i] !== borderValue) {
+                    rule.insertBefore(lastNode, Object.assign(lastNode.clone(), {
+                        prop: dir,
+                        value: mapped[i]
+                    }));
+                }
+            });
+
+            rules.forEach(_remove2.default);
+
+            return true;
+        }
+    });
+
+    // border-trbl -> border
+    // border-trbl -> border + border-trbl
+    (0, _mergeRules2.default)(rule, directions, (rules, lastNode) => {
+        if (rules.some(_stylehacks.detect)) {
+            return;
+        }
+
+        const values = rules.map(node => {
+            const wscValue = (0, _parseWsc2.default)(node.value);
+
+            if (!(0, _validateWsc.isValidWsc)(wscValue)) {
+                return node.value;
+            }
+
+            return wscValue.map((value, i) => value || defaults[i]).join(' ');
+        });
+
+        const reduced = getDistinctShorthands(values);
+
+        if (isCloseEnough(values)) {
+            const first = values.indexOf(reduced[0]) !== values.lastIndexOf(reduced[0]);
+
+            rule.insertBefore(lastNode, Object.assign(lastNode.clone(), {
+                prop: 'border',
+                value: (0, _minifyWsc2.default)(first ? values[0] : values[1])
+            }));
+
+            if (reduced[1]) {
+                const value = first ? reduced[1] : reduced[0];
+                const prop = directions[values.indexOf(value)];
+                rule.insertBefore(lastNode, Object.assign(lastNode.clone(), {
+                    prop: prop,
+                    value: (0, _minifyWsc2.default)(value)
+                }));
+            }
+
+            rules.forEach(_remove2.default);
+
+            return true;
+        }
+    });
+
+    // border-trbl-wsc + border-trbl (custom prop) -> border-trbl + border-trbl-wsc (custom prop)
+    directions.forEach(direction => {
+        wsc.forEach((style, i) => {
+            const prop = `${direction}-${style}`;
+
+            (0, _mergeRules2.default)(rule, [direction, prop], (rules, lastNode) => {
+                if (lastNode.prop !== direction) {
+                    return;
+                }
+
+                const values = (0, _parseWsc2.default)(lastNode.value);
+
+                if (!(0, _validateWsc.isValidWsc)(values)) {
+                    return;
+                }
+
+                const wscProp = rules.filter(r => r !== lastNode)[0];
+
+                if (!isValueCustomProp(values[i]) || (0, _isCustomProp2.default)(wscProp)) {
+                    return;
+                }
+
+                const wscValue = values[i];
+
+                values[i] = wscProp.value;
+
+                if ((0, _canMerge2.default)(rules, false) && !rules.some(_stylehacks.detect)) {
+                    (0, _insertCloned2.default)(lastNode.parent, lastNode, {
+                        prop,
+                        value: wscValue
+                    });
+                    lastNode.value = (0, _minifyWsc2.default)(values);
+
+                    wscProp.remove();
+
+                    return true;
+                }
+            });
+        });
+    });
+
+    // border-wsc + border (custom prop) -> border + border-wsc (custom prop)
+    wsc.forEach((style, i) => {
+        const prop = borderProperty(style);
+        (0, _mergeRules2.default)(rule, ['border', prop], (rules, lastNode) => {
+            if (lastNode.prop !== 'border') {
+                return;
+            }
+
+            const values = (0, _parseWsc2.default)(lastNode.value);
+
+            if (!(0, _validateWsc.isValidWsc)(values)) {
+                return;
+            }
+
+            const wscProp = rules.filter(r => r !== lastNode)[0];
+
+            if (!isValueCustomProp(values[i]) || (0, _isCustomProp2.default)(wscProp)) {
+                return;
+            }
+
+            const wscValue = values[i];
+
+            values[i] = wscProp.value;
+
+            if ((0, _canMerge2.default)(rules, false) && !rules.some(_stylehacks.detect)) {
+                (0, _insertCloned2.default)(lastNode.parent, lastNode, {
+                    prop,
+                    value: wscValue
+                });
+                lastNode.value = (0, _minifyWsc2.default)(values);
+                wscProp.remove();
+
+                return true;
+            }
+        });
+    });
 
     // optimize border-trbl
-    decls = (0, _getDecls2.default)(rule, directions);
+    let decls = (0, _getDecls2.default)(rule, directions);
+
+    while (decls.length) {
+        const lastNode = decls[decls.length - 1];
+
+        wsc.forEach((d, i) => {
+            const names = directions.filter(name => name !== lastNode.prop).map(name => `${name}-${d}`);
+
+            let nodes = rule.nodes.slice(0, rule.nodes.indexOf(lastNode));
+
+            const border = (0, _getLastNode2.default)(nodes, 'border');
+
+            if (border) {
+                nodes = nodes.slice(nodes.indexOf(border));
+            }
+
+            const props = nodes.filter(node => node.prop && ~names.indexOf(node.prop) && node.important === lastNode.important);
+            const rules = (0, _getRules2.default)(props, names);
+
+            if ((0, _hasAllProps2.default)(rules, ...names) && !rules.some(_stylehacks.detect)) {
+                const values = rules.map(node => node ? node.value : null);
+                const filteredValues = values.filter(Boolean);
+                const lastNodeValue = _postcss.list.space(lastNode.value)[i];
 
-    var _loop3 = function _loop3() {
-        var lastNode = decls[decls.length - 1];
-        wsc.forEach(function (d, i) {
-            var names = directions.filter(function (name) {
-                return name !== lastNode.prop;
-            }).map(function (name) {
-                return name + '-' + d;
-            });
-            var props = rule.nodes.filter(function (node) {
-                return node.prop && ~names.indexOf(node.prop) && node.important === lastNode.important;
-            });
-            if (_hasAllProps2.default.apply(undefined, [props].concat(names))) {
-                var values = directions.map(function (prop) {
-                    return (0, _getLastNode2.default)(props, prop + '-' + d);
-                }).map(function (node) {
-                    return node ? node.value : null;
-                });
-                var filteredValues = values.filter(Boolean);
-                var lastNodeValue = _postcss.list.space(lastNode.value)[i];
                 values[directions.indexOf(lastNode.prop)] = lastNodeValue;
-                var value = (0, _minifyTrbl2.default)(values.join(' '));
+
+                let value = (0, _minifyTrbl2.default)(values.join(' '));
+
                 if (filteredValues[0] === filteredValues[1] && filteredValues[1] === filteredValues[2]) {
                     value = filteredValues[0];
                 }
-                var refNode = props[props.length - 1];
+
+                let refNode = props[props.length - 1];
+
                 if (value === lastNodeValue) {
                     refNode = lastNode;
-                    var valueArray = _postcss.list.space(lastNode.value);
+                    let valueArray = _postcss.list.space(lastNode.value);
                     valueArray.splice(i, 1);
                     lastNode.value = valueArray.join(' ');
                 }
-                (0, _insertCloned2.default)(rule, refNode, {
-                    prop: 'border-' + d,
-                    value: value
+
+                (0, _insertCloned2.default)(refNode.parent, refNode, {
+                    prop: borderProperty(d),
+                    value
                 });
-                props.forEach(_remove2.default);
+
+                decls = decls.filter(node => !~rules.indexOf(node));
+                rules.forEach(_remove2.default);
             }
         });
-        decls = decls.filter(function (node) {
-            return node !== lastNode;
-        });
-    };
 
-    while (decls.length) {
-        _loop3();
+        decls = decls.filter(node => node !== lastNode);
     }
 
-    rule.walkDecls('border', function (decl) {
-        var nextDecl = decl.next();
+    rule.walkDecls('border', decl => {
+        const nextDecl = decl.next();
+
         if (!nextDecl || nextDecl.type !== 'decl') {
             return;
         }
-        var index = directions.indexOf(nextDecl.prop);
+
+        const index = directions.indexOf(nextDecl.prop);
+
         if (!~index) {
             return;
         }
-        var values = _postcss.list.space(decl.value);
-        var nextValues = _postcss.list.space(nextDecl.value);
 
-        var config = {
-            values: values,
-            nextValues: nextValues,
-            decl: decl,
-            nextDecl: nextDecl,
-            index: index
+        const values = (0, _parseWsc2.default)(decl.value);
+        const nextValues = (0, _parseWsc2.default)(nextDecl.value);
+
+        if (!(0, _validateWsc.isValidWsc)(values) || !(0, _validateWsc.isValidWsc)(nextValues)) {
+            return;
+        }
+
+        const config = {
+            values,
+            nextValues,
+            decl,
+            nextDecl,
+            index
         };
 
-        if (values[0] === nextValues[0] && values[2] === nextValues[2]) {
-            return mergeRedundant(_extends({}, config, {
-                position: 1,
-                prop: 'border-style'
-            }));
+        return mergeRedundant(config);
+    });
+
+    rule.walkDecls(/^border($|-(top|right|bottom|left)$)/i, decl => {
+        let values = (0, _parseWsc2.default)(decl.value);
+
+        if (!(0, _validateWsc.isValidWsc)(values)) {
+            return;
         }
 
-        if (values[1] === nextValues[1] && values[2] === nextValues[2]) {
-            return mergeRedundant(_extends({}, config, {
-                position: 0,
-                prop: 'border-width'
-            }));
-        }
+        const position = directions.indexOf(decl.prop);
+        let dirs = [...directions];
 
-        if (values[0] === nextValues[0] && values[1] === nextValues[1] && values[2] && nextValues[2]) {
-            return mergeRedundant(_extends({}, config, {
-                position: 2,
-                prop: 'border-color'
-            }));
-        }
+        dirs.splice(position, 1);
+        wsc.forEach((d, i) => {
+            const props = dirs.map(dir => `${dir}-${d}`);
+
+            (0, _mergeRules2.default)(rule, [decl.prop, ...props], rules => {
+                if (!rules.includes(decl)) {
+                    return;
+                }
+
+                const longhands = rules.filter(p => p !== decl);
+
+                if (longhands[0].value.toLowerCase() === longhands[1].value.toLowerCase() && longhands[1].value.toLowerCase() === longhands[2].value.toLowerCase() && longhands[0].value.toLowerCase() === values[i].toLowerCase()) {
+                    longhands.forEach(_remove2.default);
+
+                    (0, _insertCloned2.default)(decl.parent, decl, {
+                        prop: borderProperty(d),
+                        value: values[i]
+                    });
+
+                    values[i] = null;
+                }
+            });
+
+            const newValue = values.join(' ');
+
+            if (newValue) {
+                decl.value = newValue;
+            } else {
+                decl.remove();
+            }
+        });
     });
 
     // clean-up values
-    rule.walkDecls(/^border($|-(top|right|bottom|left))/, function (decl) {
-        var value = [].concat(_postcss.list.space(decl.value), ['']).reduceRight(function (prev, cur, i) {
-            if (prev === '' && cur === defaults[i]) {
-                return prev;
-            }
-            return cur + ' ' + prev;
-        }).trim() || defaults[0];
-        decl.value = (0, _minifyTrbl2.default)(value);
+    rule.walkDecls(/^border($|-(top|right|bottom|left)$)/i, decl => {
+        decl.value = (0, _minifyWsc2.default)(decl.value);
     });
 
-    // Restore inherited values
-    inheritValues.forEach(function (decl) {
-        return rule.append(decl);
+    // border-spacing-hv -> border-spacing
+    rule.walkDecls(/^border-spacing$/i, decl => {
+        const value = _postcss.list.space(decl.value);
+
+        // merge vertical and horizontal dups
+        if (value.length > 1 && value[0] === value[1]) {
+            decl.value = value.slice(1).join(' ');
+        }
     });
+
+    // clean-up rules
+    decls = (0, _getDecls2.default)(rule, allProperties);
+
+    while (decls.length) {
+        const lastNode = decls[decls.length - 1];
+        const lastPart = lastNode.prop.split('-').pop();
+
+        // remove properties of lower precedence
+        const lesser = decls.filter(node => !(0, _stylehacks.detect)(lastNode) && !(0, _stylehacks.detect)(node) && !(0, _isCustomProp2.default)(lastNode) && node !== lastNode && node.important === lastNode.important && getLevel(node.prop) > getLevel(lastNode.prop) && (!!~node.prop.toLowerCase().indexOf(lastNode.prop) || node.prop.toLowerCase().endsWith(lastPart)));
+
+        lesser.forEach(_remove2.default);
+        decls = decls.filter(node => !~lesser.indexOf(node));
+
+        // get duplicate properties
+        let duplicates = decls.filter(node => !(0, _stylehacks.detect)(lastNode) && !(0, _stylehacks.detect)(node) && node !== lastNode && node.important === lastNode.important && node.prop === lastNode.prop && !(!(0, _isCustomProp2.default)(node) && (0, _isCustomProp2.default)(lastNode)));
+
+        if (duplicates.length) {
+            if (/hsla\(|rgba\(/i.test(getColorValue(lastNode))) {
+                const preserve = duplicates.filter(node => !/hsla\(|rgba\(/i.test(getColorValue(node))).pop();
+
+                duplicates = duplicates.filter(node => node !== preserve);
+            }
+
+            duplicates.forEach(_remove2.default);
+        }
+
+        decls = decls.filter(node => node !== lastNode && !~duplicates.indexOf(node));
+    }
 }
 
 exports.default = {
-    explode: explode,
-    merge: merge
+    explode,
+    merge
 };
 module.exports = exports['default'];

node_modules/postcss-merge-longhand/dist/lib/decl/boxBase.js

@@ -1,10 +1,18 @@
 'use strict';
 
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
 
 var _stylehacks = require('stylehacks');
 
-var _genericMerge = require('../genericMerge');
+var _canMerge = require('../canMerge');
+
+var _canMerge2 = _interopRequireDefault(_canMerge);
+
+var _getDecls = require('../getDecls');
+
+var _getDecls2 = _interopRequireDefault(_getDecls);
 
 var _minifyTrbl = require('../minifyTrbl');
 
@@ -18,47 +26,93 @@ var _insertCloned = require('../insertCloned');
 
 var _insertCloned2 = _interopRequireDefault(_insertCloned);
 
+var _mergeRules = require('../mergeRules');
+
+var _mergeRules2 = _interopRequireDefault(_mergeRules);
+
 var _mergeValues = require('../mergeValues');
 
 var _mergeValues2 = _interopRequireDefault(_mergeValues);
 
+var _remove = require('../remove');
+
+var _remove2 = _interopRequireDefault(_remove);
+
 var _trbl = require('../trbl');
 
 var _trbl2 = _interopRequireDefault(_trbl);
 
+var _isCustomProp = require('../isCustomProp');
+
+var _isCustomProp2 = _interopRequireDefault(_isCustomProp);
+
+var _canExplode = require('../canExplode');
+
+var _canExplode2 = _interopRequireDefault(_canExplode);
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-exports.default = function (prop) {
-    var properties = _trbl2.default.map(function (direction) {
-        return prop + '-' + direction;
-    });
+exports.default = prop => {
+    const properties = _trbl2.default.map(direction => `${prop}-${direction}`);
 
-    var processor = {
-        explode: function explode(rule) {
-            if (rule.nodes.some(_stylehacks.detect)) {
-                return false;
-            }
-            rule.walkDecls(prop, function (decl) {
-                if (~decl.value.indexOf('inherit')) {
+    const cleanup = rule => {
+        let decls = (0, _getDecls2.default)(rule, [prop].concat(properties));
+
+        while (decls.length) {
+            const lastNode = decls[decls.length - 1];
+
+            // remove properties of lower precedence
+            const lesser = decls.filter(node => !(0, _stylehacks.detect)(lastNode) && !(0, _stylehacks.detect)(node) && node !== lastNode && node.important === lastNode.important && lastNode.prop === prop && node.prop !== lastNode.prop);
+
+            lesser.forEach(_remove2.default);
+            decls = decls.filter(node => !~lesser.indexOf(node));
+
+            // get duplicate properties
+            let duplicates = decls.filter(node => !(0, _stylehacks.detect)(lastNode) && !(0, _stylehacks.detect)(node) && node !== lastNode && node.important === lastNode.important && node.prop === lastNode.prop && !(!(0, _isCustomProp2.default)(node) && (0, _isCustomProp2.default)(lastNode)));
+
+            duplicates.forEach(_remove2.default);
+            decls = decls.filter(node => node !== lastNode && !~duplicates.indexOf(node));
+        }
+    };
+
+    const processor = {
+        explode: rule => {
+            rule.walkDecls(new RegExp("^" + prop + "$", "i"), decl => {
+                if (!(0, _canExplode2.default)(decl)) {
                     return;
                 }
-                var values = (0, _parseTrbl2.default)(decl.value);
-                _trbl2.default.forEach(function (direction, index) {
-                    (0, _insertCloned2.default)(rule, decl, {
+
+                if ((0, _stylehacks.detect)(decl)) {
+                    return;
+                }
+
+                const values = (0, _parseTrbl2.default)(decl.value);
+
+                _trbl2.default.forEach((direction, index) => {
+                    (0, _insertCloned2.default)(decl.parent, decl, {
                         prop: properties[index],
                         value: values[index]
                     });
                 });
+
                 decl.remove();
             });
         },
-        merge: (0, _genericMerge.genericMergeFactory)({
-            prop: prop,
-            properties: properties,
-            value: function value(rules) {
-                return (0, _minifyTrbl2.default)(_mergeValues2.default.apply(undefined, rules));
-            }
-        })
+        merge: rule => {
+            (0, _mergeRules2.default)(rule, properties, (rules, lastNode) => {
+                if ((0, _canMerge2.default)(rules) && !rules.some(_stylehacks.detect)) {
+                    (0, _insertCloned2.default)(lastNode.parent, lastNode, {
+                        prop,
+                        value: (0, _minifyTrbl2.default)((0, _mergeValues2.default)(...rules))
+                    });
+                    rules.forEach(_remove2.default);
+
+                    return true;
+                }
+            });
+
+            cleanup(rule);
+        }
     };
 
     return processor;

node_modules/postcss-merge-longhand/dist/lib/decl/columns.js

@@ -1,6 +1,8 @@
 'use strict';
 
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
 
 var _postcss = require('postcss');
 
@@ -8,20 +10,43 @@ var _postcssValueParser = require('postcss-value-parser');
 
 var _stylehacks = require('stylehacks');
 
-var _genericMerge = require('../genericMerge');
+var _canMerge = require('../canMerge');
+
+var _canMerge2 = _interopRequireDefault(_canMerge);
+
+var _getDecls = require('../getDecls');
+
+var _getDecls2 = _interopRequireDefault(_getDecls);
 
 var _getValue = require('../getValue');
 
 var _getValue2 = _interopRequireDefault(_getValue);
 
+var _mergeRules = require('../mergeRules');
+
+var _mergeRules2 = _interopRequireDefault(_mergeRules);
+
 var _insertCloned = require('../insertCloned');
 
 var _insertCloned2 = _interopRequireDefault(_insertCloned);
 
+var _remove = require('../remove');
+
+var _remove2 = _interopRequireDefault(_remove);
+
+var _isCustomProp = require('../isCustomProp');
+
+var _isCustomProp2 = _interopRequireDefault(_isCustomProp);
+
+var _canExplode = require('../canExplode');
+
+var _canExplode2 = _interopRequireDefault(_canExplode);
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var properties = ['column-width', 'column-count'];
-var auto = 'auto';
+const properties = ['column-width', 'column-count'];
+const auto = 'auto';
+const inherit = 'inherit';
 
 /**
  * Normalize a columns shorthand definition. Both of the longhand
@@ -33,53 +58,95 @@ var auto = 'auto';
  */
 
 function normalize(values) {
-    if (values[0] === auto) {
+    if (values[0].toLowerCase() === auto) {
         return values[1];
     }
-    if (values[1] === auto) {
+
+    if (values[1].toLowerCase() === auto) {
         return values[0];
     }
+
+    if (values[0].toLowerCase() === inherit && values[1].toLowerCase() === inherit) {
+        return inherit;
+    }
+
     return values.join(' ');
 }
 
 function explode(rule) {
-    if (rule.nodes.some(_stylehacks.detect)) {
-        return false;
-    }
-    rule.walkDecls('columns', function (decl) {
-        var values = _postcss.list.space(decl.value);
+    rule.walkDecls(/^columns$/i, decl => {
+        if (!(0, _canExplode2.default)(decl)) {
+            return;
+        }
+
+        if ((0, _stylehacks.detect)(decl)) {
+            return;
+        }
+
+        let values = _postcss.list.space(decl.value);
+
         if (values.length === 1) {
             values.push(auto);
         }
 
-        values.forEach(function (value, i) {
-            var prop = properties[1];
+        values.forEach((value, i) => {
+            let prop = properties[1];
 
-            if (value === auto) {
+            if (value.toLowerCase() === auto) {
                 prop = properties[i];
             } else if ((0, _postcssValueParser.unit)(value).unit) {
                 prop = properties[0];
             }
 
-            (0, _insertCloned2.default)(rule, decl, {
-                prop: prop,
-                value: value
+            (0, _insertCloned2.default)(decl.parent, decl, {
+                prop,
+                value
             });
         });
+
         decl.remove();
     });
 }
 
-var merge = (0, _genericMerge.genericMergeFactory)({
-    prop: 'columns',
-    properties: properties,
-    value: function value(rules) {
-        return normalize(rules.map(_getValue2.default));
+function cleanup(rule) {
+    let decls = (0, _getDecls2.default)(rule, ['columns'].concat(properties));
+
+    while (decls.length) {
+        const lastNode = decls[decls.length - 1];
+
+        // remove properties of lower precedence
+        const lesser = decls.filter(node => !(0, _stylehacks.detect)(lastNode) && !(0, _stylehacks.detect)(node) && node !== lastNode && node.important === lastNode.important && lastNode.prop === 'columns' && node.prop !== lastNode.prop);
+
+        lesser.forEach(_remove2.default);
+        decls = decls.filter(node => !~lesser.indexOf(node));
+
+        // get duplicate properties
+        let duplicates = decls.filter(node => !(0, _stylehacks.detect)(lastNode) && !(0, _stylehacks.detect)(node) && node !== lastNode && node.important === lastNode.important && node.prop === lastNode.prop && !(!(0, _isCustomProp2.default)(node) && (0, _isCustomProp2.default)(lastNode)));
+
+        duplicates.forEach(_remove2.default);
+        decls = decls.filter(node => node !== lastNode && !~duplicates.indexOf(node));
     }
-});
+}
+
+function merge(rule) {
+    (0, _mergeRules2.default)(rule, properties, (rules, lastNode) => {
+        if ((0, _canMerge2.default)(rules) && !rules.some(_stylehacks.detect)) {
+            (0, _insertCloned2.default)(lastNode.parent, lastNode, {
+                prop: 'columns',
+                value: normalize(rules.map(_getValue2.default))
+            });
+
+            rules.forEach(_remove2.default);
+
+            return true;
+        }
+    });
+
+    cleanup(rule);
+}
 
 exports.default = {
-    explode: explode,
-    merge: merge
+    explode,
+    merge
 };
 module.exports = exports['default'];

node_modules/postcss-merge-longhand/dist/lib/decl/margin.js

@@ -1,6 +1,8 @@
 'use strict';
 
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
 var _boxBase = require('./boxBase');
 

node_modules/postcss-merge-longhand/dist/lib/decl/padding.js

@@ -1,6 +1,8 @@
 'use strict';
 
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
 var _boxBase = require('./boxBase');