first commit

build/node_modules/postcss-merge-longhand/dist/index.js

@@ -0,0 +1,25 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _postcss = require('postcss');
+
+var _postcss2 = _interopRequireDefault(_postcss);
+
+var _decl = require('./lib/decl');
+
+var _decl2 = _interopRequireDefault(_decl);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = _postcss2.default.plugin('postcss-merge-longhand', function () {
+    return function (css) {
+        css.walkRules(function (rule) {
+            _decl2.default.forEach(function (p) {
+                p.explode(rule);
+                p.merge(rule);
+            });
+        });
+    };
+});
+module.exports = exports['default'];

build/node_modules/postcss-merge-longhand/dist/lib/canMerge.js

@@ -0,0 +1,28 @@
+'use strict';
+
+exports.__esModule = true;
+var important = function important(node) {
+    return node.important;
+};
+var unimportant = function unimportant(node) {
+    return !node.important;
+};
+var hasInherit = function hasInherit(node) {
+    return node.value && ~node.value.indexOf('inherit');
+};
+var hasInitial = function hasInitial(node) {
+    return ~node.value.indexOf('initial');
+};
+
+exports.default = function () {
+    for (var _len = arguments.length, props = Array(_len), _key = 0; _key < _len; _key++) {
+        props[_key] = arguments[_key];
+    }
+
+    if (props.some(hasInherit) || props.some(hasInitial)) {
+        return props.every(hasInherit) || props.every(hasInitial);
+    }
+    return props.every(unimportant) || props.every(important);
+};
+
+module.exports = exports['default'];

build/node_modules/postcss-merge-longhand/dist/lib/clone.js

@@ -0,0 +1,34 @@
+'use strict';
+
+exports.__esModule = true;
+
+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; };
+
+exports.default = clone;
+function clone(obj, parent) {
+    if (obj === null || (typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) !== 'object') {
+        return obj;
+    }
+    var cloned = new obj.constructor();
+    for (var i in obj) {
+        if (!{}.hasOwnProperty.call(obj, i)) {
+            continue;
+        }
+        var value = obj[i];
+        if (i === 'parent' && (typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object') {
+            if (parent) {
+                cloned[i] = parent;
+            }
+        } else if (i === 'source') {
+            cloned[i] = value;
+        } else if (value instanceof Array) {
+            cloned[i] = value.map(function (j) {
+                return clone(j, cloned);
+            });
+        } else {
+            cloned[i] = clone(value, cloned);
+        }
+    }
+    return cloned;
+};
+module.exports = exports['default'];

build/node_modules/postcss-merge-longhand/dist/lib/colorMerge.js

@@ -0,0 +1,69 @@
+'use strict';
+
+exports.__esModule = true;
+exports.default = colorMerge;
+
+var _getDecls = require('./getDecls');
+
+var _getDecls2 = _interopRequireDefault(_getDecls);
+
+var _hasAllProps = require('./hasAllProps');
+
+var _hasAllProps2 = _interopRequireDefault(_hasAllProps);
+
+var _insertCloned = require('./insertCloned');
+
+var _insertCloned2 = _interopRequireDefault(_insertCloned);
+
+var _remove = require('./remove');
+
+var _remove2 = _interopRequireDefault(_remove);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function getAllRules(props, properties) {
+    return properties.reduce(function (list, property) {
+        props.filter(function (n) {
+            return n.prop && ~n.prop.indexOf(property);
+        }).forEach(function (result, index) {
+            if (!list[index]) {
+                list.push([]);
+            }
+            list[index].push(result);
+        });
+        return list;
+    }, [[]]);
+}
+
+function colorMerge(_ref) {
+    var rule = _ref.rule,
+        properties = _ref.properties,
+        prop = _ref.prop,
+        value = _ref.value;
+
+    var decls = (0, _getDecls2.default)(rule, properties);
+
+    var _loop = function _loop() {
+        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))) {
+            getAllRules(props, properties).reverse().forEach(function (group) {
+                (0, _insertCloned2.default)(rule, lastNode, {
+                    prop: prop,
+                    value: value(group)
+                });
+            });
+            props.forEach(_remove2.default);
+        }
+        decls = decls.filter(function (node) {
+            return !~props.indexOf(node);
+        });
+    };
+
+    while (decls.length) {
+        _loop();
+    }
+}
+module.exports = exports['default'];

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

@@ -0,0 +1,507 @@
+'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 _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 _insertCloned = require('../insertCloned');
+
+var _insertCloned2 = _interopRequireDefault(_insertCloned);
+
+var _parseTrbl = require('../parseTrbl');
+
+var _parseTrbl2 = _interopRequireDefault(_parseTrbl);
+
+var _hasAllProps = require('../hasAllProps');
+
+var _hasAllProps2 = _interopRequireDefault(_hasAllProps);
+
+var _getDecls = require('../getDecls');
+
+var _getDecls2 = _interopRequireDefault(_getDecls);
+
+var _getRules = require('../getRules');
+
+var _getRules2 = _interopRequireDefault(_getRules);
+
+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 _canMerge = require('../canMerge');
+
+var _canMerge2 = _interopRequireDefault(_canMerge);
+
+var _remove = require('../remove');
+
+var _remove2 = _interopRequireDefault(_remove);
+
+var _trbl = require('../trbl');
+
+var _trbl2 = _interopRequireDefault(_trbl);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var wsc = ['width', 'style', 'color'];
+var defaults = ['medium', 'none', 'currentColor'];
+
+function borderProperty() {
+    for (var _len = arguments.length, parts = Array(_len), _key = 0; _key < _len; _key++) {
+        parts[_key] = arguments[_key];
+    }
+
+    return 'border-' + parts.join('-');
+}
+
+function mapBorderProperty(value) {
+    return borderProperty(value);
+}
+
+var directions = _trbl2.default.map(mapBorderProperty);
+var properties = wsc.map(mapBorderProperty);
+var directionalProperties = directions.reduce(function (prev, curr) {
+    return prev.concat(wsc.map(function (prop) {
+        return curr + '-' + prop;
+    }));
+}, []);
+
+var precedence = [['border'], directions.concat(properties), directionalProperties];
+
+var allProperties = precedence.reduce(function (a, b) {
+    return a.concat(b);
+});
+
+function getLevel(prop) {
+    for (var i = 0; i < precedence.length; i++) {
+        if (!!~precedence[i].indexOf(prop)) {
+            return i;
+        }
+    }
+}
+
+function getColorValue(decl) {
+    var values = _postcss.list.space(decl.value);
+
+    if (decl.prop === 'border') {
+        return values[2];
+    }
+
+    if (!!~directions.indexOf(decl.prop)) {
+        return values[2];
+    }
+
+    if (decl.prop.substr(-5) === 'color') {
+        return decl.value;
+    }
+
+    return null;
+}
+
+function mergeRedundant(_ref) {
+    var values = _ref.values,
+        nextValues = _ref.nextValues,
+        decl = _ref.decl,
+        nextDecl = _ref.nextDecl,
+        index = _ref.index,
+        position = _ref.position,
+        prop = _ref.prop;
+
+    if ((0, _stylehacks.detect)(decl) || (0, _stylehacks.detect)(nextDecl)) {
+        return;
+    }
+    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;
+
+    if (newLength < origLength) {
+        decl.value = borderValue;
+        nextDecl.prop = prop;
+        nextDecl.value = propertyValue;
+    }
+}
+
+function isCloseEnough(mapped) {
+    return mapped[0] === mapped[1] && mapped[1] === mapped[2] || mapped[1] === mapped[2] && mapped[2] === mapped[3] || mapped[2] === mapped[3] && mapped[3] === mapped[0] || mapped[3] === mapped[0] && mapped[0] === mapped[1];
+}
+
+function getDistinctShorthands(mapped) {
+    return mapped.reduce(function (a, b) {
+        a = Array.isArray(a) ? a : [a];
+        if (!~a.indexOf(b)) {
+            a.push(b);
+        }
+        return a;
+    });
+}
+
+function explode(rule) {
+    rule.walkDecls(/^border/, function (decl) {
+        // Don't explode inherit values as they cannot be merged together
+        if (decl.value === 'inherit') {
+            return;
+        }
+
+        if ((0, _stylehacks.detect)(decl)) {
+            return;
+        }
+
+        var prop = decl.prop;
+        // border -> border-trbl
+
+        if (prop === 'border') {
+            directions.forEach(function (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 values = _postcss.list.space(decl.value);
+            wsc.forEach(function (d, i) {
+                (0, _insertCloned2.default)(decl.parent, decl, {
+                    prop: prop + '-' + d,
+                    value: values[i] || defaults[i]
+                });
+            });
+            return decl.remove();
+        }
+        // border-wsc -> border-trbl-wsc
+        wsc.some(function (style) {
+            if (prop !== borderProperty(style)) {
+                return false;
+            }
+            (0, _parseTrbl2.default)(decl.value).forEach(function (value, i) {
+                (0, _insertCloned2.default)(decl.parent, decl, {
+                    prop: borderProperty(_trbl2.default[i], style),
+                    value: value
+                });
+            });
+            return decl.remove();
+        });
+    });
+}
+
+function merge(rule) {
+    // border-trbl-wsc -> border-trbl
+    _trbl2.default.forEach(function (direction) {
+        var prop = borderProperty(direction);
+        (0, _mergeRules2.default)(rule, wsc.map(function (style) {
+            return borderProperty(direction, style);
+        }), function (rules, lastNode) {
+            if (_canMerge2.default.apply(undefined, rules) && !rules.some(_stylehacks.detect)) {
+                (0, _insertCloned2.default)(lastNode.parent, lastNode, {
+                    prop: 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);
+        (0, _mergeRules2.default)(rule, _trbl2.default.map(function (direction) {
+            return borderProperty(direction, style);
+        }), function (rules, lastNode) {
+            if (!rules.some(_stylehacks.detect)) {
+                (0, _insertCloned2.default)(lastNode.parent, lastNode, {
+                    prop: prop,
+                    value: (0, _minifyTrbl2.default)(rules.map(_getValue2.default).join(' '))
+                });
+                rules.forEach(_remove2.default);
+                return true;
+            }
+        });
+    });
+
+    // border-trbl -> border-wsc
+    (0, _mergeRules2.default)(rule, directions, function (rules, lastNode) {
+        if (rules.some(_stylehacks.detect)) {
+            return;
+        }
+        wsc.forEach(function (d, i) {
+            (0, _insertCloned2.default)(lastNode.parent, lastNode, {
+                prop: borderProperty(d),
+                value: (0, _minifyTrbl2.default)(rules.map(function (node) {
+                    return _postcss.list.space(node.value)[i];
+                }))
+            });
+        });
+        rules.forEach(_remove2.default);
+        return true;
+    });
+
+    // border-wsc -> border
+    // border-wsc -> border + border-color
+    // border-wsc -> border + border-dir
+    (0, _mergeRules2.default)(rule, properties, function (rules, lastNode) {
+        if (rules.some(_stylehacks.detect)) {
+            return;
+        }
+        var width = rules[0],
+            style = rules[1],
+            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)(lastNode.parent, lastNode, {
+                prop: 'border',
+                value: first ? reduced[0] : reduced[1]
+            });
+
+            if (reduced[1]) {
+                var value = first ? reduced[1] : reduced[0];
+                var prop = borderProperty(_trbl2.default[mapped.indexOf(value)]);
+
+                rule.insertAfter(border, (0, _objectAssign2.default)((0, _clone2.default)(lastNode), {
+                    prop: prop,
+                    value: value
+                }));
+            }
+            rules.forEach(_remove2.default);
+            return true;
+        } else if (reduced.length === 1) {
+            rule.insertBefore(color, (0, _objectAssign2.default)((0, _clone2.default)(lastNode), {
+                prop: 'border',
+                value: [width, style].map(_getValue2.default).join(' ')
+            }));
+            rules.filter(function (node) {
+                return node.prop !== properties[2];
+            }).forEach(_remove2.default);
+            return true;
+        }
+    });
+
+    // border-wsc -> border + border-trbl
+    (0, _mergeRules2.default)(rule, properties, function (rules, lastNode) {
+        if (rules.some(_stylehacks.detect)) {
+            return;
+        }
+        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);
+        var none = 'none none currentColor';
+
+        if (reduced.length === 2 && reduced[0] === none || reduced[1] === none) {
+            var noOfNones = mapped.filter(function (value) {
+                return value === none;
+            }).length;
+            rule.insertBefore(lastNode, (0, _objectAssign2.default)((0, _clone2.default)(lastNode), {
+                prop: 'border',
+                value: noOfNones > 2 ? 'none' : mapped.filter(function (value) {
+                    return value !== none;
+                })[0]
+            }));
+            directions.forEach(function (dir, i) {
+                if (noOfNones > 2 && mapped[i] !== none) {
+                    rule.insertBefore(lastNode, (0, _objectAssign2.default)((0, _clone2.default)(lastNode), {
+                        prop: dir,
+                        value: mapped[i]
+                    }));
+                }
+                if (noOfNones <= 2 && mapped[i] === none) {
+                    rule.insertBefore(lastNode, (0, _objectAssign2.default)((0, _clone2.default)(lastNode), {
+                        prop: dir,
+                        value: 'none'
+                    }));
+                }
+            });
+            rules.forEach(_remove2.default);
+            return true;
+        }
+    });
+
+    // optimize border-trbl
+    var decls = (0, _getDecls2.default)(rule, directions);
+
+    var _loop = function _loop() {
+        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;
+            });
+            var rules = (0, _getRules2.default)(props, names);
+            if (_hasAllProps2.default.apply(undefined, [rules].concat(names)) && !rules.some(_stylehacks.detect)) {
+                var values = rules.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(' '));
+                if (filteredValues[0] === filteredValues[1] && filteredValues[1] === filteredValues[2]) {
+                    value = filteredValues[0];
+                }
+                var refNode = props[props.length - 1];
+                if (value === lastNodeValue) {
+                    refNode = lastNode;
+                    var valueArray = _postcss.list.space(lastNode.value);
+                    valueArray.splice(i, 1);
+                    lastNode.value = valueArray.join(' ');
+                }
+                (0, _insertCloned2.default)(refNode.parent, refNode, {
+                    prop: borderProperty(d),
+                    value: value
+                });
+                decls = decls.filter(function (node) {
+                    return !~rules.indexOf(node);
+                });
+                rules.forEach(_remove2.default);
+            }
+        });
+        decls = decls.filter(function (node) {
+            return node !== lastNode;
+        });
+    };
+
+    while (decls.length) {
+        _loop();
+    }
+
+    rule.walkDecls('border', function (decl) {
+        var nextDecl = decl.next();
+        if (!nextDecl || nextDecl.type !== 'decl') {
+            return;
+        }
+        var 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
+        };
+
+        if (values[0] === nextValues[0] && values[2] === nextValues[2]) {
+            return mergeRedundant(_extends({}, config, {
+                position: 1,
+                prop: 'border-style'
+            }));
+        }
+
+        if (values[1] === nextValues[1] && values[2] === nextValues[2]) {
+            return mergeRedundant(_extends({}, config, {
+                position: 0,
+                prop: 'border-width'
+            }));
+        }
+
+        if (values[0] === nextValues[0] && values[1] === nextValues[1] && values[2] && nextValues[2]) {
+            return mergeRedundant(_extends({}, config, {
+                position: 2,
+                prop: 'border-color'
+            }));
+        }
+    });
+
+    // 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);
+    });
+
+    // clean-up rules
+    decls = (0, _getDecls2.default)(rule, allProperties);
+
+    var _loop2 = function _loop2() {
+        var lastNode = decls[decls.length - 1];
+
+        // remove properties of lower precedence
+        var lesser = decls.filter(function (node) {
+            return !(0, _stylehacks.detect)(lastNode) && !(0, _stylehacks.detect)(node) && node !== lastNode && node.important === lastNode.important && getLevel(node.prop) > getLevel(lastNode.prop);
+        });
+
+        lesser.forEach(_remove2.default);
+        decls = decls.filter(function (node) {
+            return !~lesser.indexOf(node);
+        });
+
+        // get duplicate properties
+        var duplicates = decls.filter(function (node) {
+            return !(0, _stylehacks.detect)(lastNode) && !(0, _stylehacks.detect)(node) && node !== lastNode && node.important === lastNode.important && node.prop === lastNode.prop;
+        });
+
+        if (duplicates.length) {
+            if (/hsla|rgba/.test(getColorValue(lastNode))) {
+                var preserve = duplicates.filter(function (node) {
+                    return !/hsla|rgba/.test(getColorValue(node));
+                }).pop();
+                duplicates = duplicates.filter(function (node) {
+                    return node !== preserve;
+                });
+            }
+            duplicates.forEach(_remove2.default);
+        }
+        decls = decls.filter(function (node) {
+            return node !== lastNode && !~duplicates.indexOf(node);
+        });
+    };
+
+    while (decls.length) {
+        _loop2();
+    }
+}
+
+exports.default = {
+    explode: explode,
+    merge: merge
+};
+module.exports = exports['default'];

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

@@ -0,0 +1,119 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _stylehacks = require('stylehacks');
+
+var _canMerge = require('../canMerge');
+
+var _canMerge2 = _interopRequireDefault(_canMerge);
+
+var _getDecls = require('../getDecls');
+
+var _getDecls2 = _interopRequireDefault(_getDecls);
+
+var _minifyTrbl = require('../minifyTrbl');
+
+var _minifyTrbl2 = _interopRequireDefault(_minifyTrbl);
+
+var _parseTrbl = require('../parseTrbl');
+
+var _parseTrbl2 = _interopRequireDefault(_parseTrbl);
+
+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);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = function (prop) {
+    var properties = _trbl2.default.map(function (direction) {
+        return prop + '-' + direction;
+    });
+
+    var cleanup = function cleanup(rule) {
+        var decls = (0, _getDecls2.default)(rule, [prop].concat(properties));
+
+        var _loop = function _loop() {
+            var lastNode = decls[decls.length - 1];
+
+            // remove properties of lower precedence
+            var lesser = decls.filter(function (node) {
+                return !(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(function (node) {
+                return !~lesser.indexOf(node);
+            });
+
+            // get duplicate properties
+            var duplicates = decls.filter(function (node) {
+                return !(0, _stylehacks.detect)(lastNode) && !(0, _stylehacks.detect)(node) && node !== lastNode && node.important === lastNode.important && node.prop === lastNode.prop;
+            });
+
+            duplicates.forEach(_remove2.default);
+            decls = decls.filter(function (node) {
+                return node !== lastNode && !~duplicates.indexOf(node);
+            });
+        };
+
+        while (decls.length) {
+            _loop();
+        }
+    };
+
+    var processor = {
+        explode: function explode(rule) {
+            rule.walkDecls(prop, function (decl) {
+                if (~decl.value.indexOf('inherit')) {
+                    return;
+                }
+                if ((0, _stylehacks.detect)(decl)) {
+                    return;
+                }
+                var values = (0, _parseTrbl2.default)(decl.value);
+                _trbl2.default.forEach(function (direction, index) {
+                    (0, _insertCloned2.default)(decl.parent, decl, {
+                        prop: properties[index],
+                        value: values[index]
+                    });
+                });
+                decl.remove();
+            });
+        },
+        merge: function merge(rule) {
+            (0, _mergeRules2.default)(rule, properties, function (rules, lastNode) {
+                if (_canMerge2.default.apply(undefined, rules) && !rules.some(_stylehacks.detect)) {
+                    (0, _insertCloned2.default)(lastNode.parent, lastNode, {
+                        prop: prop,
+                        value: (0, _minifyTrbl2.default)(_mergeValues2.default.apply(undefined, rules))
+                    });
+                    rules.forEach(_remove2.default);
+                    return true;
+                }
+            });
+            cleanup(rule);
+        }
+    };
+
+    return processor;
+};
+
+module.exports = exports['default'];

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

@@ -0,0 +1,141 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _postcss = require('postcss');
+
+var _postcssValueParser = require('postcss-value-parser');
+
+var _stylehacks = require('stylehacks');
+
+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);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var properties = ['column-width', 'column-count'];
+var auto = 'auto';
+var inherit = 'inherit';
+
+/**
+ * Normalize a columns shorthand definition. Both of the longhand
+ * properties' initial values are 'auto', and as per the spec,
+ * omitted values are set to their initial values. Thus, we can
+ * remove any 'auto' definition when there are two values.
+ *
+ * Specification link: https://www.w3.org/TR/css3-multicol/
+ */
+
+function normalize(values) {
+    if (values[0] === auto) {
+        return values[1];
+    }
+    if (values[1] === auto) {
+        return values[0];
+    }
+    if (values[0] === inherit && values[1] === inherit) {
+        return inherit;
+    }
+    return values.join(' ');
+}
+
+function explode(rule) {
+    rule.walkDecls('columns', function (decl) {
+        if ((0, _stylehacks.detect)(decl)) {
+            return;
+        }
+        var values = _postcss.list.space(decl.value);
+        if (values.length === 1) {
+            values.push(auto);
+        }
+
+        values.forEach(function (value, i) {
+            var prop = properties[1];
+
+            if (value === auto) {
+                prop = properties[i];
+            } else if ((0, _postcssValueParser.unit)(value).unit) {
+                prop = properties[0];
+            }
+
+            (0, _insertCloned2.default)(decl.parent, decl, {
+                prop: prop,
+                value: value
+            });
+        });
+        decl.remove();
+    });
+}
+
+function cleanup(rule) {
+    var decls = (0, _getDecls2.default)(rule, ['columns'].concat(properties));
+
+    var _loop = function _loop() {
+        var lastNode = decls[decls.length - 1];
+
+        // remove properties of lower precedence
+        var lesser = decls.filter(function (node) {
+            return !(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(function (node) {
+            return !~lesser.indexOf(node);
+        });
+
+        // get duplicate properties
+        var duplicates = decls.filter(function (node) {
+            return !(0, _stylehacks.detect)(lastNode) && !(0, _stylehacks.detect)(node) && node !== lastNode && node.important === lastNode.important && node.prop === lastNode.prop;
+        });
+
+        duplicates.forEach(_remove2.default);
+        decls = decls.filter(function (node) {
+            return node !== lastNode && !~duplicates.indexOf(node);
+        });
+    };
+
+    while (decls.length) {
+        _loop();
+    }
+}
+
+function merge(rule) {
+    (0, _mergeRules2.default)(rule, properties, function (rules, lastNode) {
+        if (_canMerge2.default.apply(undefined, 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
+};
+module.exports = exports['default'];

build/node_modules/postcss-merge-longhand/dist/lib/decl/index.js

@@ -0,0 +1,24 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _borders = require('./borders');
+
+var _borders2 = _interopRequireDefault(_borders);
+
+var _columns = require('./columns');
+
+var _columns2 = _interopRequireDefault(_columns);
+
+var _margin = require('./margin');
+
+var _margin2 = _interopRequireDefault(_margin);
+
+var _padding = require('./padding');
+
+var _padding2 = _interopRequireDefault(_padding);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = [_borders2.default, _columns2.default, _margin2.default, _padding2.default];
+module.exports = exports['default'];

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

@@ -0,0 +1,12 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _boxBase = require('./boxBase');
+
+var _boxBase2 = _interopRequireDefault(_boxBase);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = (0, _boxBase2.default)('margin');
+module.exports = exports['default'];

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

@@ -0,0 +1,12 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _boxBase = require('./boxBase');
+
+var _boxBase2 = _interopRequireDefault(_boxBase);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = (0, _boxBase2.default)('padding');
+module.exports = exports['default'];

build/node_modules/postcss-merge-longhand/dist/lib/getDecls.js

@@ -0,0 +1,11 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = getDecls;
+function getDecls(rule, properties) {
+    return rule.nodes.filter(function (_ref) {
+        var prop = _ref.prop;
+        return prop && ~properties.indexOf(prop);
+    });
+}
+module.exports = exports["default"];

build/node_modules/postcss-merge-longhand/dist/lib/getLastNode.js

@@ -0,0 +1,11 @@
+"use strict";
+
+exports.__esModule = true;
+
+exports.default = function (rule, prop) {
+    return rule.filter(function (n) {
+        return n.prop && ~n.prop.indexOf(prop);
+    }).pop();
+};
+
+module.exports = exports["default"];

build/node_modules/postcss-merge-longhand/dist/lib/getRules.js

@@ -0,0 +1,17 @@
+'use strict';
+
+exports.__esModule = true;
+exports.default = getRules;
+
+var _getLastNode = require('./getLastNode');
+
+var _getLastNode2 = _interopRequireDefault(_getLastNode);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function getRules(props, properties) {
+    return properties.map(function (property) {
+        return (0, _getLastNode2.default)(props, property);
+    }).filter(Boolean);
+}
+module.exports = exports['default'];

build/node_modules/postcss-merge-longhand/dist/lib/getValue.js

@@ -0,0 +1,10 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = getValue;
+function getValue(_ref) {
+    var value = _ref.value;
+
+    return value;
+}
+module.exports = exports["default"];

build/node_modules/postcss-merge-longhand/dist/lib/hasAllProps.js

@@ -0,0 +1,18 @@
+"use strict";
+
+exports.__esModule = true;
+
+exports.default = function (rule) {
+    for (var _len = arguments.length, props = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        props[_key - 1] = arguments[_key];
+    }
+
+    return props.every(function (p) {
+        return rule.some(function (_ref) {
+            var prop = _ref.prop;
+            return prop && ~prop.indexOf(p);
+        });
+    });
+};
+
+module.exports = exports["default"];

build/node_modules/postcss-merge-longhand/dist/lib/identical.js

@@ -0,0 +1,17 @@
+"use strict";
+
+exports.__esModule = true;
+
+exports.default = function () {
+    for (var _len = arguments.length, rules = Array(_len), _key = 0; _key < _len; _key++) {
+        rules[_key] = arguments[_key];
+    }
+
+    var candidate = rules[0].value;
+    return rules.every(function (_ref) {
+        var value = _ref.value;
+        return value === candidate;
+    });
+};
+
+module.exports = exports["default"];

build/node_modules/postcss-merge-longhand/dist/lib/insertCloned.js

@@ -0,0 +1,21 @@
+'use strict';
+
+exports.__esModule = true;
+exports.default = insertCloned;
+
+var _objectAssign = require('object-assign');
+
+var _objectAssign2 = _interopRequireDefault(_objectAssign);
+
+var _clone = require('./clone');
+
+var _clone2 = _interopRequireDefault(_clone);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function insertCloned(rule, decl, props) {
+    var newNode = (0, _objectAssign2.default)((0, _clone2.default)(decl), props);
+    rule.insertAfter(decl, newNode);
+    return newNode;
+};
+module.exports = exports['default'];

build/node_modules/postcss-merge-longhand/dist/lib/mergeRules.js

@@ -0,0 +1,46 @@
+'use strict';
+
+exports.__esModule = true;
+exports.default = mergeRules;
+
+var _hasAllProps = require('./hasAllProps');
+
+var _hasAllProps2 = _interopRequireDefault(_hasAllProps);
+
+var _getDecls = require('./getDecls');
+
+var _getDecls2 = _interopRequireDefault(_getDecls);
+
+var _getRules = require('./getRules');
+
+var _getRules2 = _interopRequireDefault(_getRules);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function mergeRules(rule, properties, callback) {
+    var decls = (0, _getDecls2.default)(rule, properties);
+
+    var _loop = function _loop() {
+        var last = decls[decls.length - 1];
+        var props = decls.filter(function (node) {
+            return node.important === last.important;
+        });
+        var rules = (0, _getRules2.default)(props, properties);
+
+        if (_hasAllProps2.default.apply(undefined, [rules].concat(properties))) {
+            if (callback(rules, last, props)) {
+                decls = decls.filter(function (node) {
+                    return !~rules.indexOf(node);
+                });
+            }
+        }
+        decls = decls.filter(function (node) {
+            return node !== last;
+        });
+    };
+
+    while (decls.length) {
+        _loop();
+    }
+}
+module.exports = exports['default'];

build/node_modules/postcss-merge-longhand/dist/lib/mergeValues.js

@@ -0,0 +1,19 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _getValue = require('./getValue');
+
+var _getValue2 = _interopRequireDefault(_getValue);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = function () {
+  for (var _len = arguments.length, rules = Array(_len), _key = 0; _key < _len; _key++) {
+    rules[_key] = arguments[_key];
+  }
+
+  return rules.map(_getValue2.default).join(' ');
+};
+
+module.exports = exports['default'];

build/node_modules/postcss-merge-longhand/dist/lib/minifyTrbl.js

@@ -0,0 +1,25 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _parseTrbl = require('./parseTrbl');
+
+var _parseTrbl2 = _interopRequireDefault(_parseTrbl);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = function (v) {
+    var value = (0, _parseTrbl2.default)(v);
+    if (value[3] === value[1]) {
+        value.pop();
+        if (value[2] === value[0]) {
+            value.pop();
+            if (value[0] === value[1]) {
+                value.pop();
+            }
+        }
+    }
+    return value.join(' ');
+};
+
+module.exports = exports['default'];

build/node_modules/postcss-merge-longhand/dist/lib/numValues.js

@@ -0,0 +1,19 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _postcss = require('postcss');
+
+var space = _postcss.list.space;
+
+exports.default = function () {
+    for (var _len = arguments.length, rules = Array(_len), _key = 0; _key < _len; _key++) {
+        rules[_key] = arguments[_key];
+    }
+
+    return rules.reduce(function (memo, rule) {
+        return memo += space(rule.value).length;
+    }, 0);
+};
+
+module.exports = exports['default'];

build/node_modules/postcss-merge-longhand/dist/lib/parseTrbl.js

@@ -0,0 +1,15 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _postcss = require('postcss');
+
+exports.default = function (v) {
+    var s = typeof v === 'string' ? _postcss.list.space(v) : v;
+    return [s[0], // top
+    s[1] || s[0], // right
+    s[2] || s[0], // bottom
+    s[3] || s[1] || s[0]];
+};
+
+module.exports = exports['default'];

build/node_modules/postcss-merge-longhand/dist/lib/remove.js

@@ -0,0 +1,8 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = remove;
+function remove(node) {
+    return node.remove();
+}
+module.exports = exports["default"];

build/node_modules/postcss-merge-longhand/dist/lib/trbl.js

@@ -0,0 +1,5 @@
+'use strict';
+
+exports.__esModule = true;
+exports.default = ['top', 'right', 'bottom', 'left'];
+module.exports = exports['default'];