initial commit

node_modules/postcss-merge-longhand/LICENSE-MIT

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

node_modules/postcss-merge-longhand/README.md

@@ -0,0 +1,50 @@
+# [postcss][postcss]-merge-longhand
+
+> Merge longhand properties into shorthand with PostCSS.
+
+## Install
+
+With [npm](https://npmjs.org/package/postcss-merge-longhand) do:
+
+```
+npm install postcss-merge-longhand --save
+```
+
+## Example
+
+Merge longhand properties into shorthand; works with `margin`, `padding` &
+`border`. For more examples see the [tests](src/__tests__/index.js).
+
+### Input
+
+```css
+h1 {
+    margin-top: 10px;
+    margin-right: 20px;
+    margin-bottom: 10px;
+    margin-left: 20px;
+}
+```
+
+### Output
+
+```css
+h1 {
+    margin: 10px 20px;
+}
+```
+
+## Usage
+
+See the [PostCSS documentation](https://github.com/postcss/postcss#usage) for
+examples for your environment.
+
+## Contributors
+
+See [CONTRIBUTORS.md](https://github.com/cssnano/cssnano/blob/master/CONTRIBUTORS.md).
+
+## License
+
+MIT © [Ben Briggs](http://beneb.info)
+
+[postcss]: https://github.com/postcss/postcss

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

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: 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', () => {
+    return css => {
+        css.walkRules(rule => {
+            _decl2.default.forEach(p => {
+                p.explode(rule);
+                p.merge(rule);
+            });
+        });
+    };
+});
+module.exports = exports['default'];

node_modules/postcss-merge-longhand/dist/lib/canExplode.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+var _isCustomProp = require("./isCustomProp");
+
+var _isCustomProp2 = _interopRequireDefault(_isCustomProp);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const hasInherit = node => node.value.toLowerCase().includes("inherit");
+const hasInitial = node => node.value.toLowerCase().includes("initial");
+const hasUnset = node => node.value.toLowerCase().includes("unset");
+
+exports.default = (prop, includeCustomProps = true) => {
+    if (includeCustomProps && (0, _isCustomProp2.default)(prop)) {
+        return false;
+    }
+
+    return !hasInherit(prop) && !hasInitial(prop) && !hasUnset(prop);
+};
+
+module.exports = exports["default"];

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

@@ -0,0 +1,40 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+var _isCustomProp = require('./isCustomProp');
+
+var _isCustomProp2 = _interopRequireDefault(_isCustomProp);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const important = node => node.important;
+const unimportant = node => !node.important;
+
+const hasInherit = node => node.value.toLowerCase() === 'inherit';
+const hasInitial = node => node.value.toLowerCase() === 'initial';
+const hasUnset = node => node.value.toLowerCase() === 'unset';
+
+exports.default = (props, includeCustomProps = true) => {
+    if (props.some(hasInherit) && !props.every(hasInherit)) {
+        return false;
+    }
+
+    if (props.some(hasInitial) && !props.every(hasInitial)) {
+        return false;
+    }
+
+    if (props.some(hasUnset) && !props.every(hasUnset)) {
+        return false;
+    }
+
+    if (includeCustomProps && props.some(_isCustomProp2.default) && !props.every(_isCustomProp2.default)) {
+        return false;
+    }
+
+    return props.every(unimportant) || props.every(important);
+};
+
+module.exports = exports['default'];

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

@@ -0,0 +1,56 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: 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((list, property) => {
+        props.filter(n => n.prop && ~n.prop.indexOf(property)).forEach((result, index) => {
+            if (!list[index]) {
+                list.push([]);
+            }
+            list[index].push(result);
+        });
+        return list;
+    }, [[]]);
+}
+
+function colorMerge({ rule, properties, prop, value }) {
+    let decls = (0, _getDecls2.default)(rule, properties);
+
+    while (decls.length) {
+        const lastNode = decls[decls.length - 1];
+        const props = decls.filter(node => node.important === lastNode.important);
+        if ((0, _hasAllProps2.default)(props, ...properties)) {
+            getAllRules(props, properties).reverse().forEach(group => {
+                (0, _insertCloned2.default)(rule, lastNode, {
+                    prop,
+                    value: value(group)
+                });
+            });
+            props.forEach(_remove2.default);
+        }
+        decls = decls.filter(node => !~props.indexOf(node));
+    }
+}
+module.exports = exports['default'];

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

@@ -0,0 +1,703 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+var _postcss = require('postcss');
+
+var _stylehacks = require('stylehacks');
+
+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 _minifyWsc = require('../minifyWsc');
+
+var _minifyWsc2 = _interopRequireDefault(_minifyWsc);
+
+var _canMerge = require('../canMerge');
+
+var _canMerge2 = _interopRequireDefault(_canMerge);
+
+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);
+
+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 }; }
+
+const wsc = ['width', 'style', 'color'];
+const defaults = ['medium', 'none', 'currentcolor'];
+
+function borderProperty(...parts) {
+    return `border-${parts.join('-')}`;
+}
+
+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]);
+
+    props[index] = nextValues[position];
+
+    const borderValue2 = values.filter((e, i) => i !== position).join(' ');
+    const propValue2 = (0, _minifyTrbl2.default)(props);
+
+    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;
+    }
+}
+
+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((a, b) => {
+        a = Array.isArray(a) ? a : [a];
+
+        if (!~a.indexOf(b)) {
+            a.push(b);
+        }
+
+        return a;
+    });
+}
+
+function explode(rule) {
+    rule.walkDecls(/^border/i, decl => {
+        if (!(0, _canExplode2.default)(decl, false)) {
+            return;
+        }
+
+        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(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 decl.remove();
+            }
+        }
+
+        // border-wsc -> border-trbl-wsc
+        wsc.some(style => {
+            if (prop !== borderProperty(style)) {
+                return false;
+            }
+
+            (0, _parseTrbl2.default)(decl.value).forEach((value, i) => {
+                (0, _insertCloned2.default)(decl.parent, decl, {
+                    prop: borderProperty(_trbl2.default[i], style),
+                    value
+                });
+            });
+
+            return decl.remove();
+        });
+    });
+}
+
+function merge(rule) {
+    // border-trbl-wsc -> border-trbl
+    _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(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
+    (0, _mergeRules2.default)(rule, directions, (rules, lastNode) => {
+        if (rules.some(_stylehacks.detect)) {
+            return;
+        }
+
+        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
+    (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(' '));
+
+        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
+    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];
+
+                values[directions.indexOf(lastNode.prop)] = lastNodeValue;
+
+                let value = (0, _minifyTrbl2.default)(values.join(' '));
+
+                if (filteredValues[0] === filteredValues[1] && filteredValues[1] === filteredValues[2]) {
+                    value = filteredValues[0];
+                }
+
+                let refNode = props[props.length - 1];
+
+                if (value === lastNodeValue) {
+                    refNode = lastNode;
+                    let valueArray = _postcss.list.space(lastNode.value);
+                    valueArray.splice(i, 1);
+                    lastNode.value = valueArray.join(' ');
+                }
+
+                (0, _insertCloned2.default)(refNode.parent, refNode, {
+                    prop: borderProperty(d),
+                    value
+                });
+
+                decls = decls.filter(node => !~rules.indexOf(node));
+                rules.forEach(_remove2.default);
+            }
+        });
+
+        decls = decls.filter(node => node !== lastNode);
+    }
+
+    rule.walkDecls('border', decl => {
+        const nextDecl = decl.next();
+
+        if (!nextDecl || nextDecl.type !== 'decl') {
+            return;
+        }
+
+        const index = directions.indexOf(nextDecl.prop);
+
+        if (!~index) {
+            return;
+        }
+
+        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
+        };
+
+        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;
+        }
+
+        const position = directions.indexOf(decl.prop);
+        let dirs = [...directions];
+
+        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)$)/i, decl => {
+        decl.value = (0, _minifyWsc2.default)(decl.value);
+    });
+
+    // 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,
+    merge
+};
+module.exports = exports['default'];

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

@@ -0,0 +1,121 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: 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);
+
+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 = prop => {
+    const properties = _trbl2.default.map(direction => `${prop}-${direction}`);
+
+    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;
+                }
+
+                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: 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;
+};
+
+module.exports = exports['default'];

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

@@ -0,0 +1,152 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: 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);
+
+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 }; }
+
+const properties = ['column-width', 'column-count'];
+const auto = 'auto';
+const 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].toLowerCase() === auto) {
+        return values[1];
+    }
+
+    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) {
+    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((value, i) => {
+            let prop = properties[1];
+
+            if (value.toLowerCase() === auto) {
+                prop = properties[i];
+            } else if ((0, _postcssValueParser.unit)(value).unit) {
+                prop = properties[0];
+            }
+
+            (0, _insertCloned2.default)(decl.parent, decl, {
+                prop,
+                value
+            });
+        });
+
+        decl.remove();
+    });
+}
+
+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,
+    merge
+};
+module.exports = exports['default'];

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

@@ -0,0 +1,26 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: 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'];

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

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: 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'];

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

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: 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'];

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

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.default = getDecls;
+function getDecls(rule, properties) {
+    return rule.nodes.filter(({ prop }) => prop && ~properties.indexOf(prop.toLowerCase()));
+}
+module.exports = exports["default"];

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

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+exports.default = (rule, prop) => {
+    return rule.filter(n => n.prop && n.prop.toLowerCase() === prop).pop();
+};
+
+module.exports = exports["default"];

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

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: 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(property => {
+        return (0, _getLastNode2.default)(props, property);
+    }).filter(Boolean);
+}
+module.exports = exports["default"];

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

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

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

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+exports.default = (rule, ...props) => {
+    return props.every(p => rule.some(({ prop }) => prop && ~prop.toLowerCase().indexOf(p)));
+};
+
+module.exports = exports["default"];

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

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+exports.default = (...rules) => {
+    const candidate = rules[0].value;
+    return rules.every(({ value }) => value === candidate);
+};
+
+module.exports = exports["default"];

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

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.default = insertCloned;
+function insertCloned(rule, decl, props) {
+    const newNode = Object.assign(decl.clone(), props);
+
+    rule.insertAfter(decl, newNode);
+
+    return newNode;
+};
+module.exports = exports["default"];

node_modules/postcss-merge-longhand/dist/lib/isCustomProp.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+exports.default = node => ~node.value.search(/var\s*\(\s*--/i);
+
+module.exports = exports["default"];

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

@@ -0,0 +1,61 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: 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 isConflictingProp(propA, propB) {
+    if (!propB.prop || propB.important !== propA.important) {
+        return;
+    }
+
+    const parts = propA.prop.split('-');
+
+    return parts.some(() => {
+        parts.pop();
+
+        return parts.join('-') === propB.prop;
+    });
+}
+
+function hasConflicts(match, nodes) {
+    const firstNode = Math.min.apply(null, match.map(n => nodes.indexOf(n)));
+    const lastNode = Math.max.apply(null, match.map(n => nodes.indexOf(n)));
+    const between = nodes.slice(firstNode + 1, lastNode);
+
+    return match.some(a => between.some(b => isConflictingProp(a, b)));
+}
+
+function mergeRules(rule, properties, callback) {
+    let decls = (0, _getDecls2.default)(rule, properties);
+
+    while (decls.length) {
+        const last = decls[decls.length - 1];
+        const props = decls.filter(node => node.important === last.important);
+        const rules = (0, _getRules2.default)(props, properties);
+
+        if ((0, _hasAllProps2.default)(rules, ...properties) && !hasConflicts(rules, rule.nodes)) {
+            if (callback(rules, last, props)) {
+                decls = decls.filter(node => !~rules.indexOf(node));
+            }
+        }
+
+        decls = decls.filter(node => node !== last);
+    }
+}
+module.exports = exports['default'];

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

@@ -0,0 +1,15 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _getValue = require('./getValue');
+
+var _getValue2 = _interopRequireDefault(_getValue);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = (...rules) => rules.map(_getValue2.default).join(' ');
+
+module.exports = exports['default'];

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

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+var _parseTrbl = require('./parseTrbl');
+
+var _parseTrbl2 = _interopRequireDefault(_parseTrbl);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = v => {
+    const 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'];

node_modules/postcss-merge-longhand/dist/lib/minifyWsc.js

@@ -0,0 +1,39 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+var _parseWsc = require('./parseWsc');
+
+var _parseWsc2 = _interopRequireDefault(_parseWsc);
+
+var _minifyTrbl = require('./minifyTrbl');
+
+var _minifyTrbl2 = _interopRequireDefault(_minifyTrbl);
+
+var _validateWsc = require('./validateWsc');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const defaults = ['medium', 'none', 'currentcolor'];
+
+exports.default = v => {
+    const values = (0, _parseWsc2.default)(v);
+
+    if (!(0, _validateWsc.isValidWsc)(values)) {
+        return (0, _minifyTrbl2.default)(v);
+    }
+
+    const value = [...values, ''].reduceRight((prev, cur, i, arr) => {
+        if (cur === undefined || cur.toLowerCase() === defaults[i] && (!i || (arr[i - 1] || '').toLowerCase() !== cur.toLowerCase())) {
+            return prev;
+        }
+
+        return cur + ' ' + prev;
+    }).trim();
+
+    return (0, _minifyTrbl2.default)(value || 'none');
+};
+
+module.exports = exports['default'];

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

@@ -0,0 +1,15 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+var _postcss = require('postcss');
+
+const { space } = _postcss.list;
+
+exports.default = (...rules) => {
+    return rules.reduce((memo, rule) => memo += space(rule.value).length, 0);
+};
+
+module.exports = exports['default'];

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

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+var _postcss = require('postcss');
+
+exports.default = v => {
+    const 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'];

node_modules/postcss-merge-longhand/dist/lib/parseWsc.js

@@ -0,0 +1,65 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.default = parseWsc;
+
+var _postcss = require('postcss');
+
+var _validateWsc = require('./validateWsc');
+
+const none = /^\s*(none|medium)(\s+none(\s+(none|currentcolor))?)?\s*$/i;
+
+const varRE = /(^.*var)(.*\(.*--.*\))(.*)/i;
+const varPreserveCase = p => `${p[1].toLowerCase()}${p[2]}${p[3].toLowerCase()}`;
+const toLower = v => {
+    const match = varRE.exec(v);
+    return match ? varPreserveCase(match) : v.toLowerCase();
+};
+
+function parseWsc(value) {
+    if (none.test(value)) {
+        return ['medium', 'none', 'currentcolor'];
+    }
+
+    let width, style, color;
+
+    const values = _postcss.list.space(value);
+
+    if (values.length > 1 && (0, _validateWsc.isStyle)(values[1]) && values[0].toLowerCase() === 'none') {
+        values.unshift();
+        width = '0';
+    }
+
+    const unknown = [];
+
+    values.forEach(v => {
+        if ((0, _validateWsc.isStyle)(v)) {
+            style = toLower(v);
+        } else if ((0, _validateWsc.isWidth)(v)) {
+            width = toLower(v);
+        } else if ((0, _validateWsc.isColor)(v)) {
+            color = toLower(v);
+        } else {
+            unknown.push(v);
+        }
+    });
+
+    if (unknown.length) {
+        if (!width && style && color) {
+            width = unknown.pop();
+        }
+
+        if (width && !style && color) {
+            style = unknown.pop();
+        }
+
+        if (width && style && !color) {
+            color = unknown.pop();
+        }
+    }
+
+    return [width, style, color];
+}
+module.exports = exports['default'];

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

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

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

@@ -0,0 +1,7 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = ['top', 'right', 'bottom', 'left'];
+module.exports = exports['default'];

node_modules/postcss-merge-longhand/dist/lib/validateWsc.js

@@ -0,0 +1,65 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.isStyle = isStyle;
+exports.isWidth = isWidth;
+exports.isColor = isColor;
+exports.isValidWsc = isValidWsc;
+
+var _cssColorNames = require("css-color-names");
+
+var _cssColorNames2 = _interopRequireDefault(_cssColorNames);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const widths = ["thin", "medium", "thick"];
+const styles = ["none", "hidden", "dotted", "dashed", "solid", "double", "groove", "ridge", "inset", "outset"];
+const colors = Object.keys(_cssColorNames2.default);
+
+function isStyle(value) {
+    return value && !!~styles.indexOf(value.toLowerCase());
+}
+
+function isWidth(value) {
+    return value && !!~widths.indexOf(value.toLowerCase()) || /^(\d+(\.\d+)?|\.\d+)(\w+)?$/.test(value);
+}
+
+function isColor(value) {
+    if (!value) {
+        return false;
+    }
+
+    value = value.toLowerCase();
+
+    if (/rgba?\(/.test(value)) {
+        return true;
+    }
+
+    if (/hsla?\(/.test(value)) {
+        return true;
+    }
+
+    if (/#([0-9a-z]{6}|[0-9a-z]{3})/.test(value)) {
+        return true;
+    }
+
+    if (value === "transparent") {
+        return true;
+    }
+
+    if (value === "currentcolor") {
+        return true;
+    }
+
+    return !!~colors.indexOf(value);
+}
+
+function isValidWsc(wscs) {
+    const validWidth = isWidth(wscs[0]);
+    const validStyle = isStyle(wscs[1]);
+    const validColor = isColor(wscs[2]);
+
+    return validWidth && validStyle || validWidth && validColor || validStyle && validColor;
+}

node_modules/postcss-merge-longhand/node_modules/postcss-value-parser/LICENSE

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

node_modules/postcss-merge-longhand/node_modules/postcss-value-parser/README.md

@@ -0,0 +1,253 @@
+# postcss-value-parser
+
+[![Travis CI](https://travis-ci.org/TrySound/postcss-value-parser.svg)](https://travis-ci.org/TrySound/postcss-value-parser)
+
+Transforms CSS declaration values and at-rule parameters into a tree of nodes, and provides a simple traversal API.
+
+## Usage
+
+```js
+var valueParser = require('postcss-value-parser');
+var cssBackgroundValue = 'url(foo.png) no-repeat 40px 73%';
+var parsedValue = valueParser(cssBackgroundValue);
+// parsedValue exposes an API described below,
+// e.g. parsedValue.walk(..), parsedValue.toString(), etc.
+```
+
+For example, parsing the value `rgba(233, 45, 66, .5)` will return the following:
+
+```js
+{
+  nodes: [
+    {
+      type: 'function',
+      value: 'rgba',
+      before: '',
+      after: '',
+      nodes: [
+        { type: 'word', value: '233' },
+        { type: 'div', value: ',', before: '', after: ' ' },
+        { type: 'word', value: '45' },
+        { type: 'div', value: ',', before: '', after: ' ' },
+        { type: 'word', value: '66' },
+        { type: 'div', value: ',', before: ' ', after: '' },
+        { type: 'word', value: '.5' }
+      ]
+    }
+  ]
+}
+```
+
+If you wanted to convert each `rgba()` value in `sourceCSS` to a hex value, you could do so like this:
+
+```js
+var valueParser = require('postcss-value-parser');
+
+var parsed = valueParser(sourceCSS);
+
+// walk() will visit all the of the nodes in the tree,
+// invoking the callback for each.
+parsed.walk(function (node) {
+
+  // Since we only want to transform rgba() values,
+  // we can ignore anything else.
+  if (node.type !== 'function' && node.value !== 'rgba') return;
+
+  // We can make an array of the rgba() arguments to feed to a
+  // convertToHex() function
+  var color = node.nodes.filter(function (node) {
+    return node.type === 'word';
+  }).map(function (node) {
+    return Number(node.value);
+  }); // [233, 45, 66, .5]
+
+  // Now we will transform the existing rgba() function node
+  // into a word node with the hex value
+  node.type = 'word';
+  node.value = convertToHex(color);
+})
+
+parsed.toString(); // #E92D42
+```
+
+## Nodes
+
+Each node is an object with these common properties:
+
+- **type**: The type of node (`word`, `string`, `div`, `space`, `comment`, or `function`).
+  Each type is documented below.
+- **value**: Each node has a `value` property; but what exactly `value` means
+  is specific to the node type. Details are documented for each type below.
+- **sourceIndex**: The starting index of the node within the original source
+  string. For example, given the source string `10px 20px`, the `word` node
+  whose value is `20px` will have a `sourceIndex` of `5`.
+
+### word
+
+The catch-all node type that includes keywords (e.g. `no-repeat`),
+quantities (e.g. `20px`, `75%`, `1.5`), and hex colors (e.g. `#e6e6e6`).
+
+Node-specific properties:
+
+- **value**: The "word" itself.
+
+### string
+
+A quoted string value, e.g. `"something"` in `content: "something";`.
+
+Node-specific properties:
+
+- **value**: The text content of the string.
+- **quote**: The quotation mark surrounding the string, either `"` or `'`.
+- **unclosed**: `true` if the string was not closed properly. e.g. `"unclosed string  `.
+
+### div
+
+A divider, for example
+
+- `,` in `animation-duration: 1s, 2s, 3s`
+- `/` in `border-radius: 10px / 23px`
+- `:` in `(min-width: 700px)`
+
+Node-specific properties:
+
+- **value**: The divider character. Either `,`, `/`, or `:` (see examples above).
+- **before**: Whitespace before the divider.
+- **after**: Whitespace after the divider.
+
+### space
+
+Whitespace used as a separator, e.g. ` ` occurring twice in `border: 1px solid black;`.
+
+Node-specific properties:
+
+- **value**: The whitespace itself.
+
+### comment
+
+A CSS comment starts with `/*` and ends with `*/`
+
+Node-specific properties:
+
+- **value**: The comment value without `/*` and `*/`
+- **unclosed**: `true` if the comment was not closed properly. e.g. `/* comment without an end  `.
+
+### function
+
+A CSS function, e.g. `rgb(0,0,0)` or `url(foo.bar)`.
+
+Function nodes have nodes nested within them: the function arguments.
+
+Additional properties:
+
+- **value**: The name of the function, e.g. `rgb` in `rgb(0,0,0)`.
+- **before**: Whitespace after the opening parenthesis and before the first argument,
+  e.g. `  ` in `rgb(  0,0,0)`.
+- **after**: Whitespace before the closing parenthesis and after the last argument,
+  e.g. `  ` in `rgb(0,0,0  )`.
+- **nodes**: More nodes representing the arguments to the function.
+- **unclosed**: `true` if the parentheses was not closed properly. e.g. `( unclosed-function  `.
+
+Media features surrounded by parentheses are considered functions with an
+empty value. For example, `(min-width: 700px)` parses to these nodes:
+
+```js
+[
+  {
+    type: 'function', value: '', before: '', after: '',
+    nodes: [
+      { type: 'word', value: 'min-width' },
+      { type: 'div', value: ':', before: '', after: ' ' },
+      { type: 'word', value: '700px' }
+    ]
+  }
+]
+```
+
+`url()` functions can be parsed a little bit differently depending on
+whether the first character in the argument is a quotation mark.
+
+`url( /gfx/img/bg.jpg )` parses to:
+
+```js
+{ type: 'function', sourceIndex: 0, value: 'url', before: ' ', after: ' ', nodes: [
+    { type: 'word', sourceIndex: 5, value: '/gfx/img/bg.jpg' }
+] }
+```
+
+`url( "/gfx/img/bg.jpg" )`, on the other hand, parses to:
+
+```js
+{ type: 'function', sourceIndex: 0, value: 'url', before: ' ', after: ' ', nodes: [
+     type: 'string', sourceIndex: 5, quote: '"', value: '/gfx/img/bg.jpg' },
+] }
+```
+
+## API
+
+```
+var valueParser = require('postcss-value-parser');
+```
+
+### valueParser.unit(quantity)
+
+Parses `quantity`, distinguishing the number from the unit. Returns an object like the following:
+
+```js
+// Given 2rem
+{
+  number: '2',
+  unit: 'rem'
+}
+```
+
+If the `quantity` argument cannot be parsed as a number, returns `false`.
+
+*This function does not parse complete values*: you cannot pass it `1px solid black` and expect `px` as
+the unit. Instead, you should pass it single quantities only. Parse `1px solid black`, then pass it
+the stringified `1px` node (a `word` node) to parse the number and unit.
+
+### valueParser.stringify(nodes[, custom])
+
+Stringifies a node or array of nodes.
+
+The `custom` function is called for each `node`; return a string to override the default behaviour.
+
+### valueParser.walk(nodes, callback[, bubble])
+
+Walks each provided node, recursively walking all descendent nodes within functions.
+
+Returning `false` in the `callback` will prevent traversal of descendent nodes (within functions).
+You can use this feature to for shallow iteration, walking over only the *immediate* children.
+*Note: This only applies if `bubble` is `false` (which is the default).*
+
+By default, the tree is walked from the outermost node inwards.
+To reverse the direction, pass `true` for the `bubble` argument.
+
+The `callback` is invoked with three arguments: `callback(node, index, nodes)`.
+
+- `node`: The current node.
+- `index`: The index of the current node.
+- `nodes`: The complete nodes array passed to `walk()`.
+
+Returns the `valueParser` instance.
+
+### var parsed = valueParser(value)
+
+Returns the parsed node tree.
+
+### parsed.nodes
+
+The array of nodes.
+
+### parsed.toString()
+
+Stringifies the node tree.
+
+### parsed.walk(callback[, bubble])
+
+Walks each node inside `parsed.nodes`. See the documentation for `valueParser.walk()` above.
+
+# License
+
+MIT © [Bogdan Chadkin](mailto:trysound@yandex.ru)

node_modules/postcss-merge-longhand/node_modules/postcss-value-parser/lib/index.js

@@ -0,0 +1,28 @@
+var parse = require("./parse");
+var walk = require("./walk");
+var stringify = require("./stringify");
+
+function ValueParser(value) {
+  if (this instanceof ValueParser) {
+    this.nodes = parse(value);
+    return this;
+  }
+  return new ValueParser(value);
+}
+
+ValueParser.prototype.toString = function() {
+  return Array.isArray(this.nodes) ? stringify(this.nodes) : "";
+};
+
+ValueParser.prototype.walk = function(cb, bubble) {
+  walk(this.nodes, cb, bubble);
+  return this;
+};
+
+ValueParser.unit = require("./unit");
+
+ValueParser.walk = walk;
+
+ValueParser.stringify = stringify;
+
+module.exports = ValueParser;

node_modules/postcss-merge-longhand/node_modules/postcss-value-parser/lib/parse.js

@@ -0,0 +1,251 @@
+var openParentheses = "(".charCodeAt(0);
+var closeParentheses = ")".charCodeAt(0);
+var singleQuote = "'".charCodeAt(0);
+var doubleQuote = '"'.charCodeAt(0);
+var backslash = "\\".charCodeAt(0);
+var slash = "/".charCodeAt(0);
+var comma = ",".charCodeAt(0);
+var colon = ":".charCodeAt(0);
+var star = "*".charCodeAt(0);
+
+module.exports = function(input) {
+  var tokens = [];
+  var value = input;
+
+  var next, quote, prev, token, escape, escapePos, whitespacePos;
+  var pos = 0;
+  var code = value.charCodeAt(pos);
+  var max = value.length;
+  var stack = [{ nodes: tokens }];
+  var balanced = 0;
+  var parent;
+
+  var name = "";
+  var before = "";
+  var after = "";
+
+  while (pos < max) {
+    // Whitespaces
+    if (code <= 32) {
+      next = pos;
+      do {
+        next += 1;
+        code = value.charCodeAt(next);
+      } while (code <= 32);
+      token = value.slice(pos, next);
+
+      prev = tokens[tokens.length - 1];
+      if (code === closeParentheses && balanced) {
+        after = token;
+      } else if (prev && prev.type === "div") {
+        prev.after = token;
+      } else if (
+        code === comma ||
+        code === colon ||
+        (code === slash && value.charCodeAt(next + 1) !== star)
+      ) {
+        before = token;
+      } else {
+        tokens.push({
+          type: "space",
+          sourceIndex: pos,
+          value: token
+        });
+      }
+
+      pos = next;
+
+      // Quotes
+    } else if (code === singleQuote || code === doubleQuote) {
+      next = pos;
+      quote = code === singleQuote ? "'" : '"';
+      token = {
+        type: "string",
+        sourceIndex: pos,
+        quote: quote
+      };
+      do {
+        escape = false;
+        next = value.indexOf(quote, next + 1);
+        if (~next) {
+          escapePos = next;
+          while (value.charCodeAt(escapePos - 1) === backslash) {
+            escapePos -= 1;
+            escape = !escape;
+          }
+        } else {
+          value += quote;
+          next = value.length - 1;
+          token.unclosed = true;
+        }
+      } while (escape);
+      token.value = value.slice(pos + 1, next);
+
+      tokens.push(token);
+      pos = next + 1;
+      code = value.charCodeAt(pos);
+
+      // Comments
+    } else if (code === slash && value.charCodeAt(pos + 1) === star) {
+      token = {
+        type: "comment",
+        sourceIndex: pos
+      };
+
+      next = value.indexOf("*/", pos);
+      if (next === -1) {
+        token.unclosed = true;
+        next = value.length;
+      }
+
+      token.value = value.slice(pos + 2, next);
+      tokens.push(token);
+
+      pos = next + 2;
+      code = value.charCodeAt(pos);
+
+      // Dividers
+    } else if (code === slash || code === comma || code === colon) {
+      token = value[pos];
+
+      tokens.push({
+        type: "div",
+        sourceIndex: pos - before.length,
+        value: token,
+        before: before,
+        after: ""
+      });
+      before = "";
+
+      pos += 1;
+      code = value.charCodeAt(pos);
+
+      // Open parentheses
+    } else if (openParentheses === code) {
+      // Whitespaces after open parentheses
+      next = pos;
+      do {
+        next += 1;
+        code = value.charCodeAt(next);
+      } while (code <= 32);
+      token = {
+        type: "function",
+        sourceIndex: pos - name.length,
+        value: name,
+        before: value.slice(pos + 1, next)
+      };
+      pos = next;
+
+      if (name === "url" && code !== singleQuote && code !== doubleQuote) {
+        next -= 1;
+        do {
+          escape = false;
+          next = value.indexOf(")", next + 1);
+          if (~next) {
+            escapePos = next;
+            while (value.charCodeAt(escapePos - 1) === backslash) {
+              escapePos -= 1;
+              escape = !escape;
+            }
+          } else {
+            value += ")";
+            next = value.length - 1;
+            token.unclosed = true;
+          }
+        } while (escape);
+        // Whitespaces before closed
+        whitespacePos = next;
+        do {
+          whitespacePos -= 1;
+          code = value.charCodeAt(whitespacePos);
+        } while (code <= 32);
+        if (pos !== whitespacePos + 1) {
+          token.nodes = [
+            {
+              type: "word",
+              sourceIndex: pos,
+              value: value.slice(pos, whitespacePos + 1)
+            }
+          ];
+        } else {
+          token.nodes = [];
+        }
+        if (token.unclosed && whitespacePos + 1 !== next) {
+          token.after = "";
+          token.nodes.push({
+            type: "space",
+            sourceIndex: whitespacePos + 1,
+            value: value.slice(whitespacePos + 1, next)
+          });
+        } else {
+          token.after = value.slice(whitespacePos + 1, next);
+        }
+        pos = next + 1;
+        code = value.charCodeAt(pos);
+        tokens.push(token);
+      } else {
+        balanced += 1;
+        token.after = "";
+        tokens.push(token);
+        stack.push(token);
+        tokens = token.nodes = [];
+        parent = token;
+      }
+      name = "";
+
+      // Close parentheses
+    } else if (closeParentheses === code && balanced) {
+      pos += 1;
+      code = value.charCodeAt(pos);
+
+      parent.after = after;
+      after = "";
+      balanced -= 1;
+      stack.pop();
+      parent = stack[balanced];
+      tokens = parent.nodes;
+
+      // Words
+    } else {
+      next = pos;
+      do {
+        if (code === backslash) {
+          next += 1;
+        }
+        next += 1;
+        code = value.charCodeAt(next);
+      } while (
+        next < max &&
+        !(
+          code <= 32 ||
+          code === singleQuote ||
+          code === doubleQuote ||
+          code === comma ||
+          code === colon ||
+          code === slash ||
+          code === openParentheses ||
+          (code === closeParentheses && balanced)
+        )
+      );
+      token = value.slice(pos, next);
+
+      if (openParentheses === code) {
+        name = token;
+      } else {
+        tokens.push({
+          type: "word",
+          sourceIndex: pos,
+          value: token
+        });
+      }
+
+      pos = next;
+    }
+  }
+
+  for (pos = stack.length - 1; pos; pos -= 1) {
+    stack[pos].unclosed = true;
+  }
+
+  return stack[0].nodes;
+};

node_modules/postcss-merge-longhand/node_modules/postcss-value-parser/lib/stringify.js

@@ -0,0 +1,48 @@
+function stringifyNode(node, custom) {
+  var type = node.type;
+  var value = node.value;
+  var buf;
+  var customResult;
+
+  if (custom && (customResult = custom(node)) !== undefined) {
+    return customResult;
+  } else if (type === "word" || type === "space") {
+    return value;
+  } else if (type === "string") {
+    buf = node.quote || "";
+    return buf + value + (node.unclosed ? "" : buf);
+  } else if (type === "comment") {
+    return "/*" + value + (node.unclosed ? "" : "*/");
+  } else if (type === "div") {
+    return (node.before || "") + value + (node.after || "");
+  } else if (Array.isArray(node.nodes)) {
+    buf = stringify(node.nodes);
+    if (type !== "function") {
+      return buf;
+    }
+    return (
+      value +
+      "(" +
+      (node.before || "") +
+      buf +
+      (node.after || "") +
+      (node.unclosed ? "" : ")")
+    );
+  }
+  return value;
+}
+
+function stringify(nodes, custom) {
+  var result, i;
+
+  if (Array.isArray(nodes)) {
+    result = "";
+    for (i = nodes.length - 1; ~i; i -= 1) {
+      result = stringifyNode(nodes[i], custom) + result;
+    }
+    return result;
+  }
+  return stringifyNode(nodes, custom);
+}
+
+module.exports = stringify;

node_modules/postcss-merge-longhand/node_modules/postcss-value-parser/lib/unit.js

@@ -0,0 +1,49 @@
+var minus = "-".charCodeAt(0);
+var plus = "+".charCodeAt(0);
+var dot = ".".charCodeAt(0);
+var exp = "e".charCodeAt(0);
+var EXP = "E".charCodeAt(0);
+
+module.exports = function(value) {
+  var pos = 0;
+  var length = value.length;
+  var dotted = false;
+  var sciPos = -1;
+  var containsNumber = false;
+  var code;
+
+  while (pos < length) {
+    code = value.charCodeAt(pos);
+
+    if (code >= 48 && code <= 57) {
+      containsNumber = true;
+    } else if (code === exp || code === EXP) {
+      if (sciPos > -1) {
+        break;
+      }
+      sciPos = pos;
+    } else if (code === dot) {
+      if (dotted) {
+        break;
+      }
+      dotted = true;
+    } else if (code === plus || code === minus) {
+      if (pos !== 0) {
+        break;
+      }
+    } else {
+      break;
+    }
+
+    pos += 1;
+  }
+
+  if (sciPos + 1 === pos) pos--;
+
+  return containsNumber
+    ? {
+        number: value.slice(0, pos),
+        unit: value.slice(pos)
+      }
+    : false;
+};

node_modules/postcss-merge-longhand/node_modules/postcss-value-parser/lib/walk.js

@@ -0,0 +1,22 @@
+module.exports = function walk(nodes, cb, bubble) {
+  var i, max, node, result;
+
+  for (i = 0, max = nodes.length; i < max; i += 1) {
+    node = nodes[i];
+    if (!bubble) {
+      result = cb(node, i, nodes);
+    }
+
+    if (
+      result !== false &&
+      node.type === "function" &&
+      Array.isArray(node.nodes)
+    ) {
+      walk(node.nodes, cb, bubble);
+    }
+
+    if (bubble) {
+      cb(node, i, nodes);
+    }
+  }
+};

node_modules/postcss-merge-longhand/node_modules/postcss-value-parser/package.json

@@ -0,0 +1,86 @@
+{
+  "_from": "postcss-value-parser@^3.0.0",
+  "_id": "postcss-value-parser@3.3.1",
+  "_inBundle": false,
+  "_integrity": "sha512-pISE66AbVkp4fDQ7VHBwRNXzAAKJjw4Vw7nWI/+Q3vuly7SNfgYXvm6i5IgFylHGK5sP/xHAbB7N49OS4gWNyQ==",
+  "_location": "/postcss-merge-longhand/postcss-value-parser",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "postcss-value-parser@^3.0.0",
+    "name": "postcss-value-parser",
+    "escapedName": "postcss-value-parser",
+    "rawSpec": "^3.0.0",
+    "saveSpec": null,
+    "fetchSpec": "^3.0.0"
+  },
+  "_requiredBy": [
+    "/postcss-merge-longhand"
+  ],
+  "_resolved": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-3.3.1.tgz",
+  "_shasum": "9ff822547e2893213cf1c30efa51ac5fd1ba8281",
+  "_spec": "postcss-value-parser@^3.0.0",
+  "_where": "D:\\Air66 Files\\dev_sites\\www.airurl.dev.cc\\user\\plugins\\air66Theme\\node_modules\\postcss-merge-longhand",
+  "author": {
+    "name": "Bogdan Chadkin",
+    "email": "trysound@yandex.ru"
+  },
+  "bugs": {
+    "url": "https://github.com/TrySound/postcss-value-parser/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "Transforms css values and at-rule params into the tree",
+  "devDependencies": {
+    "eslint": "^5.6.1",
+    "husky": "^1.0.0",
+    "lint-staged": "^7.3.0",
+    "prettier": "^1.4.4",
+    "tap-spec": "^5.0.0",
+    "tape": "^4.2.0"
+  },
+  "eslintConfig": {
+    "env": {
+      "es6": true,
+      "node": true
+    },
+    "extends": "eslint:recommended"
+  },
+  "files": [
+    "lib"
+  ],
+  "homepage": "https://github.com/TrySound/postcss-value-parser",
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged"
+    }
+  },
+  "keywords": [
+    "postcss",
+    "value",
+    "parser"
+  ],
+  "license": "MIT",
+  "lint-staged": {
+    "*.js": [
+      "eslint",
+      "prettier --write",
+      "git add"
+    ]
+  },
+  "main": "lib/index.js",
+  "name": "postcss-value-parser",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TrySound/postcss-value-parser.git"
+  },
+  "scripts": {
+    "lint": "yarn lint:js && yarn lint:prettier",
+    "lint:js": "eslint . --cache",
+    "lint:prettier": "prettier '**/*.js' --list-different",
+    "pretest": "yarn lint",
+    "test": "tape test/*.js | tap-spec"
+  },
+  "version": "3.3.1"
+}

node_modules/postcss-merge-longhand/package.json

@@ -0,0 +1,72 @@
+{
+  "_from": "postcss-merge-longhand@^4.0.11",
+  "_id": "postcss-merge-longhand@4.0.11",
+  "_inBundle": false,
+  "_integrity": "sha512-alx/zmoeXvJjp7L4mxEMjh8lxVlDFX1gqWHzaaQewwMZiVhLo42TEClKaeHbRf6J7j82ZOdTJ808RtN0ZOZwvw==",
+  "_location": "/postcss-merge-longhand",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "postcss-merge-longhand@^4.0.11",
+    "name": "postcss-merge-longhand",
+    "escapedName": "postcss-merge-longhand",
+    "rawSpec": "^4.0.11",
+    "saveSpec": null,
+    "fetchSpec": "^4.0.11"
+  },
+  "_requiredBy": [
+    "/cssnano-preset-default"
+  ],
+  "_resolved": "https://registry.npmjs.org/postcss-merge-longhand/-/postcss-merge-longhand-4.0.11.tgz",
+  "_shasum": "62f49a13e4a0ee04e7b98f42bb16062ca2549e24",
+  "_spec": "postcss-merge-longhand@^4.0.11",
+  "_where": "D:\\Air66 Files\\dev_sites\\www.airurl.dev.cc\\user\\plugins\\air66Theme\\node_modules\\cssnano-preset-default",
+  "author": {
+    "name": "Ben Briggs",
+    "email": "beneb.info@gmail.com",
+    "url": "http://beneb.info"
+  },
+  "bugs": {
+    "url": "https://github.com/cssnano/cssnano/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "css-color-names": "0.0.4",
+    "postcss": "^7.0.0",
+    "postcss-value-parser": "^3.0.0",
+    "stylehacks": "^4.0.0"
+  },
+  "deprecated": false,
+  "description": "Merge longhand properties into shorthand with PostCSS.",
+  "devDependencies": {
+    "babel-cli": "^6.0.0",
+    "cross-env": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "files": [
+    "LICENSE-MIT",
+    "dist"
+  ],
+  "homepage": "https://github.com/cssnano/cssnano",
+  "keywords": [
+    "css",
+    "minify",
+    "optimise",
+    "postcss",
+    "postcss-plugin"
+  ],
+  "license": "MIT",
+  "main": "dist/index.js",
+  "name": "postcss-merge-longhand",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cssnano/cssnano.git"
+  },
+  "scripts": {
+    "prepublish": "cross-env BABEL_ENV=publish babel src --out-dir dist --ignore /__tests__/"
+  },
+  "version": "4.0.11"
+}