Edit

Editing: /lib/node_modules/svgo/node_modules_prod/csso/dist/csso.js

(function (global, factory) {
	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
	typeof define === 'function' && define.amd ? define(['exports'], factory) :
	(global = global || self, factory(global.csso = {}));
}(this, (function (exports) { 'use strict';

var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

function createCommonjsModule(fn, module) {
		return module = { exports: {} }, fn(module, module.exports), module.exports;
	}

function getCjsExportFromNamespace (n) {
		return n && n['default'] || n;
	}

var hasOwnProperty = Object.prototype.hasOwnProperty;

function buildMap(list, caseInsensitive) {
	    var map = Object.create(null);

if (!Array.isArray(list)) {
	        return null;
	    }

for (var i = 0; i < list.length; i++) {
	        var name = list[i];

if (caseInsensitive) {
	            name = name.toLowerCase();
	        }

map[name] = true;
	    }

return map;
	}

function buildList(data) {
	    if (!data) {
	        return null;
	    }

var tags = buildMap(data.tags, true);
	    var ids = buildMap(data.ids);
	    var classes = buildMap(data.classes);

if (tags === null &&
	        ids === null &&
	        classes === null) {
	        return null;
	    }

return {
	        tags: tags,
	        ids: ids,
	        classes: classes
	    };
	}

function buildIndex(data) {
	    var scopes = false;

if (data.scopes && Array.isArray(data.scopes)) {
	        scopes = Object.create(null);

for (var i = 0; i < data.scopes.length; i++) {
	            var list = data.scopes[i];

if (!list || !Array.isArray(list)) {
	                throw new Error('Wrong usage format');
	            }

for (var j = 0; j < list.length; j++) {
	                var name = list[j];

if (hasOwnProperty.call(scopes, name)) {
	                    throw new Error('Class can\'t be used for several scopes: ' + name);
	                }

scopes[name] = i + 1;
	            }
	        }
	    }

return {
	        whitelist: buildList(data),
	        blacklist: buildList(data.blacklist),
	        scopes: scopes
	    };
	}

var usage = {
	    buildIndex: buildIndex
	};

var resolveKeyword = csstree_min.keyword;
	var { hasNoChildren } = utils;

var Atrule = function cleanAtrule(node, item, list) {
	    if (node.block) {
	        // otherwise removed at-rule don't prevent @import for removal
	        if (this.stylesheet !== null) {
	            this.stylesheet.firstAtrulesAllowed = false;
	        }

if (hasNoChildren(node.block)) {
	            list.remove(item);
	            return;
	        }
	    }

switch (node.name) {
	        case 'charset':
	            if (hasNoChildren(node.prelude)) {
	                list.remove(item);
	                return;
	            }

// if there is any rule before @charset -> remove it
	            if (item.prev) {
	                list.remove(item);
	                return;
	            }

break;

case 'import':
	            if (this.stylesheet === null || !this.stylesheet.firstAtrulesAllowed) {
	                list.remove(item);
	                return;
	            }

// if there are some rules that not an @import or @charset before @import
	            // remove it
	            list.prevUntil(item.prev, function(rule) {
	                if (rule.type === 'Atrule') {
	                    if (rule.name === 'import' || rule.name === 'charset') {
	                        return;
	                    }
	                }

this.root.firstAtrulesAllowed = false;
	                list.remove(item);
	                return true;
	            }, this);

break;

default:
	            var name = resolveKeyword(node.name).basename;
	            if (name === 'keyframes' ||
	                name === 'media' ||
	                name === 'supports') {

// drop at-rule with no prelude
	                if (hasNoChildren(node.prelude) || hasNoChildren(node.block)) {
	                    list.remove(item);
	                }
	            }
	    }
	};

var Comment = function cleanComment(data, item, list) {
	    list.remove(item);
	};

var property = csstree_min.property;

var Declaration = function cleanDeclartion(node, item, list) {
	    if (node.value.children && node.value.children.isEmpty()) {
	        list.remove(item);
	        return;
	    }

if (property(node.property).custom) {
	        if (/\S/.test(node.value.value)) {
	            node.value.value = node.value.value.trim();
	        }
	    }
	};

var { isNodeChildrenList } = utils;

var Raw = function cleanRaw(node, item, list) {
	    // raw in stylesheet or block children
	    if (isNodeChildrenList(this.stylesheet, list) ||
	        isNodeChildrenList(this.block, list)) {
	        list.remove(item);
	    }
	};

var hasOwnProperty$1 = Object.prototype.hasOwnProperty;
	var walk = csstree_min.walk;
	var { hasNoChildren: hasNoChildren$1 } = utils;

function cleanUnused(selectorList, usageData) {
	    selectorList.children.each(function(selector, item, list) {
	        var shouldRemove = false;

walk(selector, function(node) {
	            // ignore nodes in nested selectors
	            if (this.selector === null || this.selector === selectorList) {
	                switch (node.type) {
	                    case 'SelectorList':
	                        // TODO: remove toLowerCase when pseudo selectors will be normalized
	                        // ignore selectors inside :not()
	                        if (this.function === null || this.function.name.toLowerCase() !== 'not') {
	                            if (cleanUnused(node, usageData)) {
	                                shouldRemove = true;
	                            }
	                        }
	                        break;

case 'ClassSelector':
	                        if (usageData.whitelist !== null &&
	                            usageData.whitelist.classes !== null &&
	                            !hasOwnProperty$1.call(usageData.whitelist.classes, node.name)) {
	                            shouldRemove = true;
	                        }
	                        if (usageData.blacklist !== null &&
	                            usageData.blacklist.classes !== null &&
	                            hasOwnProperty$1.call(usageData.blacklist.classes, node.name)) {
	                            shouldRemove = true;
	                        }
	                        break;

case 'IdSelector':
	                        if (usageData.whitelist !== null &&
	                            usageData.whitelist.ids !== null &&
	                            !hasOwnProperty$1.call(usageData.whitelist.ids, node.name)) {
	                            shouldRemove = true;
	                        }
	                        if (usageData.blacklist !== null &&
	                            usageData.blacklist.ids !== null &&
	                            hasOwnProperty$1.call(usageData.blacklist.ids, node.name)) {
	                            shouldRemove = true;
	                        }
	                        break;

case 'TypeSelector':
	                        // TODO: remove toLowerCase when type selectors will be normalized
	                        // ignore universal selectors
	                        if (node.name.charAt(node.name.length - 1) !== '*') {
	                            if (usageData.whitelist !== null &&
	                                usageData.whitelist.tags !== null &&
	                                !hasOwnProperty$1.call(usageData.whitelist.tags, node.name.toLowerCase())) {
	                                shouldRemove = true;
	                            }
	                            if (usageData.blacklist !== null &&
	                                usageData.blacklist.tags !== null &&
	                                hasOwnProperty$1.call(usageData.blacklist.tags, node.name.toLowerCase())) {
	                                shouldRemove = true;
	                            }
	                        }
	                        break;
	                }
	            }
	        });

if (shouldRemove) {
	            list.remove(item);
	        }
	    });

return selectorList.children.isEmpty();
	}

var Rule = function cleanRule(node, item, list, options) {
	    if (hasNoChildren$1(node.prelude) || hasNoChildren$1(node.block)) {
	        list.remove(item);
	        return;
	    }

var usageData = options.usage;

if (usageData && (usageData.whitelist !== null || usageData.blacklist !== null)) {
	        cleanUnused(node.prelude, usageData);

if (hasNoChildren$1(node.prelude)) {
	            list.remove(item);
	            return;
	        }
	    }
	};

// remove useless universal selector
	var TypeSelector = function cleanTypeSelector(node, item, list) {
	    var name = item.data.name;

// check it's a non-namespaced universal selector
	    if (name !== '*') {
	        return;
	    }

// remove when universal selector before other selectors
	    var nextType = item.next && item.next.data.type;
	    if (nextType === 'IdSelector' ||
	        nextType === 'ClassSelector' ||
	        nextType === 'AttributeSelector' ||
	        nextType === 'PseudoClassSelector' ||
	        nextType === 'PseudoElementSelector') {
	        list.remove(item);
	    }
	};

var { isNodeChildrenList: isNodeChildrenList$1 } = utils;

function isSafeOperator(node) {
	    return node.type === 'Operator' && node.value !== '+' && node.value !== '-';
	}

var WhiteSpace = function cleanWhitespace(node, item, list) {
	    // remove when first or last item in sequence
	    if (item.next === null || item.prev === null) {
	        list.remove(item);
	        return;
	    }

// white space in stylesheet or block children
	    if (isNodeChildrenList$1(this.stylesheet, list) ||
	        isNodeChildrenList$1(this.block, list)) {
	        list.remove(item);
	        return;
	    }

if (item.next.data.type === 'WhiteSpace') {
	        list.remove(item);
	        return;
	    }

if (isSafeOperator(item.prev.data) || isSafeOperator(item.next.data)) {
	        list.remove(item);
	        return;
	    }
	};

var walk$1 = csstree_min.walk;
	var handlers = {
	    Atrule: Atrule,
	    Comment: Comment,
	    Declaration: Declaration,
	    Raw: Raw,
	    Rule: Rule,
	    TypeSelector: TypeSelector,
	    WhiteSpace: WhiteSpace
	};

var resolveKeyword$1 = csstree_min.keyword;

var Atrule$1 = function(node) {
	    // compress @keyframe selectors
	    if (resolveKeyword$1(node.name).basename === 'keyframes') {
	        keyframes(node);
	    }
	};

// Can unquote attribute detection
	// Adopted implementation of Mathias Bynens
	// https://github.com/mathiasbynens/mothereff.in/blob/master/unquoted-attributes/eff.js
	var escapesRx = /\\([0-9A-Fa-f]{1,6})(\r\n|[ \t\n\f\r])?|\\./g;
	var blockUnquoteRx = /^(-?\d|--)|[\u0000-\u002c\u002e\u002f\u003A-\u0040\u005B-\u005E\u0060\u007B-\u009f]/;

function canUnquote(value) {
	    if (value === '' || value === '-') {
	        return;
	    }

// Escapes are valid, so replace them with a valid non-empty string
	    value = value.replace(escapesRx, 'a');

return !blockUnquoteRx.test(value);
	}

var AttributeSelector = function(node) {
	    var attrValue = node.value;

if (!attrValue || attrValue.type !== 'String') {
	        return;
	    }

var unquotedValue = attrValue.value.replace(/^(.)(.*)\1$/, '$2');
	    if (canUnquote(unquotedValue)) {
	        node.value = {
	            type: 'Identifier',
	            loc: attrValue.loc,
	            name: unquotedValue
	        };
	    }
	};

var font = function compressFont(node) {
	    var list = node.children;

list.eachRight(function(node, item) {
	        if (node.type === 'Identifier') {
	            if (node.name === 'bold') {
	                item.data = {
	                    type: 'Number',
	                    loc: node.loc,
	                    value: '700'
	                };
	            } else if (node.name === 'normal') {
	                var prev = item.prev;

if (prev && prev.data.type === 'Operator' && prev.data.value === '/') {
	                    this.remove(prev);
	                }

this.remove(item);
	            } else if (node.name === 'medium') {
	                var next = item.next;

if (!next || next.data.type !== 'Operator') {
	                    this.remove(item);
	                }
	            }
	        }
	    });

// remove redundant spaces
	    list.each(function(node, item) {
	        if (node.type === 'WhiteSpace') {
	            if (!item.prev || !item.next || item.next.data.type === 'WhiteSpace') {
	                this.remove(item);
	            }
	        }
	    });

if (list.isEmpty()) {
	        list.insert(list.createItem({
	            type: 'Identifier',
	            name: 'normal'
	        }));
	    }
	};

var fontWeight = function compressFontWeight(node) {
	    var value = node.children.head.data;

if (value.type === 'Identifier') {
	        switch (value.name) {
	            case 'normal':
	                node.children.head.data = {
	                    type: 'Number',
	                    loc: value.loc,
	                    value: '400'
	                };
	                break;
	            case 'bold':
	                node.children.head.data = {
	                    type: 'Number',
	                    loc: value.loc,
	                    value: '700'
	                };
	                break;
	        }
	    }
	};

var List = csstree_min.List;

var background = function compressBackground(node) {
	    function lastType() {
	        if (buffer.length) {
	            return buffer[buffer.length - 1].type;
	        }
	    }

function flush() {
	        if (lastType() === 'WhiteSpace') {
	            buffer.pop();
	        }

if (!buffer.length) {
	            buffer.unshift(
	                {
	                    type: 'Number',
	                    loc: null,
	                    value: '0'
	                },
	                {
	                    type: 'WhiteSpace',
	                    value: ' '
	                },
	                {
	                    type: 'Number',
	                    loc: null,
	                    value: '0'
	                }
	            );
	        }

newValue.push.apply(newValue, buffer);

buffer = [];
	    }

var newValue = [];
	    var buffer = [];

node.children.each(function(node) {
	        if (node.type === 'Operator' && node.value === ',') {
	            flush();
	            newValue.push(node);
	            return;
	        }

// remove defaults
	        if (node.type === 'Identifier') {
	            if (node.name === 'transparent' ||
	                node.name === 'none' ||
	                node.name === 'repeat' ||
	                node.name === 'scroll') {
	                return;
	            }
	        }

// don't add redundant spaces
	        if (node.type === 'WhiteSpace' && (!buffer.length || lastType() === 'WhiteSpace')) {
	            return;
	        }

buffer.push(node);
	    });

flush();
	    node.children = new List().fromArray(newValue);
	};

function removeItemAndRedundantWhiteSpace(list, item) {
	    var prev = item.prev;
	    var next = item.next;

if (next !== null) {
	        if (next.data.type === 'WhiteSpace' && (prev === null || prev.data.type === 'WhiteSpace')) {
	            list.remove(next);
	        }
	    } else if (prev !== null && prev.data.type === 'WhiteSpace') {
	        list.remove(prev);
	    }

list.remove(item);
	}

var resolveName = csstree_min.property;
	var handlers$1 = {
	    'font': font,
	    'font-weight': fontWeight,
	    'background': background,
	    'border': border,
	    'outline': border
	};

var Value = function compressValue(node) {
	    if (!this.declaration) {
	        return;
	    }

var property = resolveName(this.declaration.property);

if (handlers$1.hasOwnProperty(property.basename)) {
	        handlers$1[property.basename](node);
	    }
	};

var OMIT_PLUSSIGN = /^(?:\+|(-))?0*(\d*)(?:\.0*|(\.\d*?)0*)?$/;
	var KEEP_PLUSSIGN = /^([\+\-])?0*(\d*)(?:\.0*|(\.\d*?)0*)?$/;
	var unsafeToRemovePlusSignAfter = {
	    Dimension: true,
	    Hash: true,
	    Identifier: true,
	    Number: true,
	    Raw: true,
	    UnicodeRange: true
	};

function packNumber(value, item) {
	    // omit plus sign only if no prev or prev is safe type
	    var regexp = item && item.prev !== null && unsafeToRemovePlusSignAfter.hasOwnProperty(item.prev.data.type)
	        ? KEEP_PLUSSIGN
	        : OMIT_PLUSSIGN;

// 100 -> '100'
	    // 00100 -> '100'
	    // +100 -> '100' (only when safe, e.g. omitting plus sign for 1px+1px leads to single dimension instead of two)
	    // -100 -> '-100'
	    // 0.123 -> '.123'
	    // 0.12300 -> '.123'
	    // 0.0 -> ''
	    // 0 -> ''
	    // -0 -> '-'
	    value = String(value).replace(regexp, '$1$2$3');

if (value === '' || value === '-') {
	        value = '0';
	    }

return value;
	}

var _Number = function(node, item) {
	    node.value = packNumber(node.value, item);
	};
	var pack = packNumber;
	_Number.pack = pack;

var packNumber$1 = _Number.pack;
	var MATH_FUNCTIONS = {
	    'calc': true,
	    'min': true,
	    'max': true,
	    'clamp': true
	};
	var LENGTH_UNIT = {
	    // absolute length units
	    'px': true,
	    'mm': true,
	    'cm': true,
	    'in': true,
	    'pt': true,
	    'pc': true,

// relative length units
	    'em': true,
	    'ex': true,
	    'ch': true,
	    'rem': true,

// viewport-percentage lengths
	    'vh': true,
	    'vw': true,
	    'vmin': true,
	    'vmax': true,
	    'vm': true
	};

var Dimension = function compressDimension(node, item) {
	    var value = packNumber$1(node.value, item);

node.value = value;

if (value === '0' && this.declaration !== null && this.atrulePrelude === null) {
	        var unit = node.unit.toLowerCase();

// only length values can be compressed
	        if (!LENGTH_UNIT.hasOwnProperty(unit)) {
	            return;
	        }

// issue #362: shouldn't remove unit in -ms-flex since it breaks flex in IE10/11
	        // issue #200: shouldn't remove unit in flex since it breaks flex in IE10/11
	        if (this.declaration.property === '-ms-flex' ||
	            this.declaration.property === 'flex') {
	            return;
	        }

// issue #222: don't remove units inside calc
	        if (this.function && MATH_FUNCTIONS.hasOwnProperty(this.function.name)) {
	            return;
	        }

item.data = {
	            type: 'Number',
	            loc: node.loc,
	            value: value
	        };
	    }
	};

var lexer = csstree_min.lexer;
	var packNumber$2 = _Number.pack;
	var blacklist = new Set([
	    // see https://github.com/jakubpawlowicz/clean-css/issues/957
	    'width',
	    'min-width',
	    'max-width',
	    'height',
	    'min-height',
	    'max-height',

// issue #410: Don’t remove units in flex-basis value for (-ms-)flex shorthand
	    // issue #362: shouldn't remove unit in -ms-flex since it breaks flex in IE10/11
	    // issue #200: shouldn't remove unit in flex since it breaks flex in IE10/11
	    'flex',
	    '-ms-flex'
	]);

var Percentage = function compressPercentage(node, item) {
	    node.value = packNumber$2(node.value, item);

if (node.value === '0' && this.declaration && !blacklist.has(this.declaration.property)) {
	        // try to convert a number
	        item.data = {
	            type: 'Number',
	            loc: node.loc,
	            value: node.value
	        };

// that's ok only when new value matches on length
	        if (!lexer.matchDeclaration(this.declaration).isType(item.data, 'length')) {
	            // otherwise rollback changes
	            item.data = node;
	        }
	    }
	};

var _String = function(node) {
	    var value = node.value;

// remove escaped newlines, i.e.
	    // .a { content: "foo\
	    // bar"}
	    // ->
	    // .a { content: "foobar" }
	    value = value.replace(/\\(\r\n|\r|\n|\f)/g, '');

node.value = value;
	};

var UNICODE = '\\\\[0-9a-f]{1,6}(\\r\\n|[ \\n\\r\\t\\f])?';
	var ESCAPE = '(' + UNICODE + '|\\\\[^\\n\\r\\f0-9a-fA-F])';
	var NONPRINTABLE = '\u0000\u0008\u000b\u000e-\u001f\u007f';
	var SAFE_URL = new RegExp('^(' + ESCAPE + '|[^\"\'\$\$\\\\\\s' + NONPRINTABLE + '])*$', 'i');

var Url = function(node) {
	    var value = node.value;

if (value.type !== 'String') {
	        return;
	    }

var quote = value.value[0];
	    var url = value.value.substr(1, value.value.length - 2);

// convert `\\` to `/`
	    url = url.replace(/\\\\/g, '/');

// remove quotes when safe
	    // https://www.w3.org/TR/css-syntax-3/#url-unquoted-diagram
	    if (SAFE_URL.test(url)) {
	        node.value = {
	            type: 'Raw',
	            loc: node.value.loc,
	            value: url
	        };
	    } else {
	        // use double quotes if string has no double quotes
	        // otherwise use original quotes
	        // TODO: make better quote type selection
	        node.value.value = url.indexOf('"') === -1 ? '"' + url + '"' : quote + url + quote;
	    }
	};

var lexer$1 = csstree_min.lexer;
	var packNumber$3 = _Number.pack;

// http://www.w3.org/TR/css3-color/#svg-color
	var NAME_TO_HEX = {
	    'aliceblue': 'f0f8ff',
	    'antiquewhite': 'faebd7',
	    'aqua': '0ff',
	    'aquamarine': '7fffd4',
	    'azure': 'f0ffff',
	    'beige': 'f5f5dc',
	    'bisque': 'ffe4c4',
	    'black': '000',
	    'blanchedalmond': 'ffebcd',
	    'blue': '00f',
	    'blueviolet': '8a2be2',
	    'brown': 'a52a2a',
	    'burlywood': 'deb887',
	    'cadetblue': '5f9ea0',
	    'chartreuse': '7fff00',
	    'chocolate': 'd2691e',
	    'coral': 'ff7f50',
	    'cornflowerblue': '6495ed',
	    'cornsilk': 'fff8dc',
	    'crimson': 'dc143c',
	    'cyan': '0ff',
	    'darkblue': '00008b',
	    'darkcyan': '008b8b',
	    'darkgoldenrod': 'b8860b',
	    'darkgray': 'a9a9a9',
	    'darkgrey': 'a9a9a9',
	    'darkgreen': '006400',
	    'darkkhaki': 'bdb76b',
	    'darkmagenta': '8b008b',
	    'darkolivegreen': '556b2f',
	    'darkorange': 'ff8c00',
	    'darkorchid': '9932cc',
	    'darkred': '8b0000',
	    'darksalmon': 'e9967a',
	    'darkseagreen': '8fbc8f',
	    'darkslateblue': '483d8b',
	    'darkslategray': '2f4f4f',
	    'darkslategrey': '2f4f4f',
	    'darkturquoise': '00ced1',
	    'darkviolet': '9400d3',
	    'deeppink': 'ff1493',
	    'deepskyblue': '00bfff',
	    'dimgray': '696969',
	    'dimgrey': '696969',
	    'dodgerblue': '1e90ff',
	    'firebrick': 'b22222',
	    'floralwhite': 'fffaf0',
	    'forestgreen': '228b22',
	    'fuchsia': 'f0f',
	    'gainsboro': 'dcdcdc',
	    'ghostwhite': 'f8f8ff',
	    'gold': 'ffd700',
	    'goldenrod': 'daa520',
	    'gray': '808080',
	    'grey': '808080',
	    'green': '008000',
	    'greenyellow': 'adff2f',
	    'honeydew': 'f0fff0',
	    'hotpink': 'ff69b4',
	    'indianred': 'cd5c5c',
	    'indigo': '4b0082',
	    'ivory': 'fffff0',
	    'khaki': 'f0e68c',
	    'lavender': 'e6e6fa',
	    'lavenderblush': 'fff0f5',
	    'lawngreen': '7cfc00',
	    'lemonchiffon': 'fffacd',
	    'lightblue': 'add8e6',
	    'lightcoral': 'f08080',
	    'lightcyan': 'e0ffff',
	    'lightgoldenrodyellow': 'fafad2',
	    'lightgray': 'd3d3d3',
	    'lightgrey': 'd3d3d3',
	    'lightgreen': '90ee90',
	    'lightpink': 'ffb6c1',
	    'lightsalmon': 'ffa07a',
	    'lightseagreen': '20b2aa',
	    'lightskyblue': '87cefa',
	    'lightslategray': '789',
	    'lightslategrey': '789',
	    'lightsteelblue': 'b0c4de',
	    'lightyellow': 'ffffe0',
	    'lime': '0f0',
	    'limegreen': '32cd32',
	    'linen': 'faf0e6',
	    'magenta': 'f0f',
	    'maroon': '800000',
	    'mediumaquamarine': '66cdaa',
	    'mediumblue': '0000cd',
	    'mediumorchid': 'ba55d3',
	    'mediumpurple': '9370db',
	    'mediumseagreen': '3cb371',
	    'mediumslateblue': '7b68ee',
	    'mediumspringgreen': '00fa9a',
	    'mediumturquoise': '48d1cc',
	    'mediumvioletred': 'c71585',
	    'midnightblue': '191970',
	    'mintcream': 'f5fffa',
	    'mistyrose': 'ffe4e1',
	    'moccasin': 'ffe4b5',
	    'navajowhite': 'ffdead',
	    'navy': '000080',
	    'oldlace': 'fdf5e6',
	    'olive': '808000',
	    'olivedrab': '6b8e23',
	    'orange': 'ffa500',
	    'orangered': 'ff4500',
	    'orchid': 'da70d6',
	    'palegoldenrod': 'eee8aa',
	    'palegreen': '98fb98',
	    'paleturquoise': 'afeeee',
	    'palevioletred': 'db7093',
	    'papayawhip': 'ffefd5',
	    'peachpuff': 'ffdab9',
	    'peru': 'cd853f',
	    'pink': 'ffc0cb',
	    'plum': 'dda0dd',
	    'powderblue': 'b0e0e6',
	    'purple': '800080',
	    'rebeccapurple': '639',
	    'red': 'f00',
	    'rosybrown': 'bc8f8f',
	    'royalblue': '4169e1',
	    'saddlebrown': '8b4513',
	    'salmon': 'fa8072',
	    'sandybrown': 'f4a460',
	    'seagreen': '2e8b57',
	    'seashell': 'fff5ee',
	    'sienna': 'a0522d',
	    'silver': 'c0c0c0',
	    'skyblue': '87ceeb',
	    'slateblue': '6a5acd',
	    'slategray': '708090',
	    'slategrey': '708090',
	    'snow': 'fffafa',
	    'springgreen': '00ff7f',
	    'steelblue': '4682b4',
	    'tan': 'd2b48c',
	    'teal': '008080',
	    'thistle': 'd8bfd8',
	    'tomato': 'ff6347',
	    'turquoise': '40e0d0',
	    'violet': 'ee82ee',
	    'wheat': 'f5deb3',
	    'white': 'fff',
	    'whitesmoke': 'f5f5f5',
	    'yellow': 'ff0',
	    'yellowgreen': '9acd32'
	};

var HEX_TO_NAME = {
	    '800000': 'maroon',
	    '800080': 'purple',
	    '808000': 'olive',
	    '808080': 'gray',
	    '00ffff': 'cyan',
	    'f0ffff': 'azure',
	    'f5f5dc': 'beige',
	    'ffe4c4': 'bisque',
	    '000000': 'black',
	    '0000ff': 'blue',
	    'a52a2a': 'brown',
	    'ff7f50': 'coral',
	    'ffd700': 'gold',
	    '008000': 'green',
	    '4b0082': 'indigo',
	    'fffff0': 'ivory',
	    'f0e68c': 'khaki',
	    '00ff00': 'lime',
	    'faf0e6': 'linen',
	    '000080': 'navy',
	    'ffa500': 'orange',
	    'da70d6': 'orchid',
	    'cd853f': 'peru',
	    'ffc0cb': 'pink',
	    'dda0dd': 'plum',
	    'f00': 'red',
	    'ff0000': 'red',
	    'fa8072': 'salmon',
	    'a0522d': 'sienna',
	    'c0c0c0': 'silver',
	    'fffafa': 'snow',
	    'd2b48c': 'tan',
	    '008080': 'teal',
	    'ff6347': 'tomato',
	    'ee82ee': 'violet',
	    'f5deb3': 'wheat',
	    'ffffff': 'white',
	    'ffff00': 'yellow'
	};

function hslToRgb(h, s, l, a) {
	    var r;
	    var g;
	    var b;

if (s === 0) {
	        r = g = b = l; // achromatic
	    } else {
	        var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
	        var p = 2 * l - q;

r = hueToRgb(p, q, h + 1 / 3);
	        g = hueToRgb(p, q, h);
	        b = hueToRgb(p, q, h - 1 / 3);
	    }

return [
	        Math.round(r * 255),
	        Math.round(g * 255),
	        Math.round(b * 255),
	        a
	    ];
	}

function toHex(value) {
	    value = value.toString(16);
	    return value.length === 1 ? '0' + value : value;
	}

function parseFunctionArgs(functionArgs, count, rgb) {
	    var cursor = functionArgs.head;
	    var args = [];
	    var wasValue = false;

while (cursor !== null) {
	        var node = cursor.data;
	        var type = node.type;

switch (type) {
	            case 'Number':
	            case 'Percentage':
	                if (wasValue) {
	                    return;
	                }

wasValue = true;
	                args.push({
	                    type: type,
	                    value: Number(node.value)
	                });
	                break;

case 'Operator':
	                if (node.value === ',') {
	                    if (!wasValue) {
	                        return;
	                    }
	                    wasValue = false;
	                } else if (wasValue || node.value !== '+') {
	                    return;
	                }
	                break;

default:
	                // something we couldn't understand
	                return;
	        }

cursor = cursor.next;
	    }

if (args.length !== count) {
	        // invalid arguments count
	        // TODO: remove those tokens
	        return;
	    }

if (args.length === 4) {
	        if (args[3].type !== 'Number') {
	            // 4th argument should be a number
	            // TODO: remove those tokens
	            return;
	        }

args[3].type = 'Alpha';
	    }

if (rgb) {
	        if (args[0].type !== args[1].type || args[0].type !== args[2].type) {
	            // invalid color, numbers and percentage shouldn't be mixed
	            // TODO: remove those tokens
	            return;
	        }
	    } else {
	        if (args[0].type !== 'Number' ||
	            args[1].type !== 'Percentage' ||
	            args[2].type !== 'Percentage') {
	            // invalid color, for hsl values should be: number, percentage, percentage
	            // TODO: remove those tokens
	            return;
	        }

args[0].type = 'Angle';
	    }

return args.map(function(arg) {
	        var value = Math.max(0, arg.value);

switch (arg.type) {
	            case 'Number':
	                // fit value to [0..255] range
	                value = Math.min(value, 255);
	                break;

case 'Percentage':
	                // convert 0..100% to value in [0..255] range
	                value = Math.min(value, 100) / 100;

if (!rgb) {
	                    return value;
	                }

value = 255 * value;
	                break;

case 'Angle':
	                // fit value to (-360..360) range
	                return (((value % 360) + 360) % 360) / 360;

case 'Alpha':
	                // fit value to [0..1] range
	                return Math.min(value, 1);
	        }

return Math.round(value);
	    });
	}

function compressFunction(node, item, list) {
	    var functionName = node.name;
	    var args;

if (functionName === 'rgba' || functionName === 'hsla') {
	        args = parseFunctionArgs(node.children, 4, functionName === 'rgba');

if (!args) {
	            // something went wrong
	            return;
	        }

if (functionName === 'hsla') {
	            args = hslToRgb.apply(null, args);
	            node.name = 'rgba';
	        }

if (args[3] === 0) {
	            // try to replace `rgba(x, x, x, 0)` to `transparent`
	            // always replace `rgba(0, 0, 0, 0)` to `transparent`
	            // otherwise avoid replacement in gradients since it may break color transition
	            // http://stackoverflow.com/questions/11829410/css3-gradient-rendering-issues-from-transparent-to-white
	            var scopeFunctionName = this.function && this.function.name;
	            if ((args[0] === 0 && args[1] === 0 && args[2] === 0) ||
	                !/^(?:to|from|color-stop)$|gradient$/i.test(scopeFunctionName)) {

item.data = {
	                    type: 'Identifier',
	                    loc: node.loc,
	                    name: 'transparent'
	                };

return;
	            }
	        }

if (args[3] !== 1) {
	            // replace argument values for normalized/interpolated
	            node.children.each(function(node, item, list) {
	                if (node.type === 'Operator') {
	                    if (node.value !== ',') {
	                        list.remove(item);
	                    }
	                    return;
	                }

item.data = {
	                    type: 'Number',
	                    loc: node.loc,
	                    value: packNumber$3(args.shift(), null)
	                };
	            });

return;
	        }

// otherwise convert to rgb, i.e. rgba(255, 0, 0, 1) -> rgb(255, 0, 0)
	        functionName = 'rgb';
	    }

if (functionName === 'hsl') {
	        args = args || parseFunctionArgs(node.children, 3, false);

if (!args) {
	            // something went wrong
	            return;
	        }

// convert to rgb
	        args = hslToRgb.apply(null, args);
	        functionName = 'rgb';
	    }

if (functionName === 'rgb') {
	        args = args || parseFunctionArgs(node.children, 3, true);

if (!args) {
	            // something went wrong
	            return;
	        }

// check if color is not at the end and not followed by space
	        var next = item.next;
	        if (next && next.data.type !== 'WhiteSpace') {
	            list.insert(list.createItem({
	                type: 'WhiteSpace',
	                value: ' '
	            }), next);
	        }

item.data = {
	            type: 'Hash',
	            loc: node.loc,
	            value: toHex(args[0]) + toHex(args[1]) + toHex(args[2])
	        };

compressHex(item.data, item);
	    }
	}

function compressIdent(node, item) {
	    if (this.declaration === null) {
	        return;
	    }

var color = node.name.toLowerCase();

if (NAME_TO_HEX.hasOwnProperty(color) &&
	        lexer$1.matchDeclaration(this.declaration).isType(node, 'color')) {
	        var hex = NAME_TO_HEX[color];

if (hex.length + 1 <= color.length) {
	            // replace for shorter hex value
	            item.data = {
	                type: 'Hash',
	                loc: node.loc,
	                value: hex
	            };
	        } else {
	            // special case for consistent colors
	            if (color === 'grey') {
	                color = 'gray';
	            }

// just replace value for lower cased name
	            node.name = color;
	        }
	    }
	}

function compressHex(node, item) {
	    var color = node.value.toLowerCase();

// #112233 -> #123
	    if (color.length === 6 &&
	        color[0] === color[1] &&
	        color[2] === color[3] &&
	        color[4] === color[5]) {
	        color = color[0] + color[2] + color[4];
	    }

if (HEX_TO_NAME[color]) {
	        item.data = {
	            type: 'Identifier',
	            loc: node.loc,
	            name: HEX_TO_NAME[color]
	        };
	    } else {
	        node.value = color;
	    }
	}

var color = {
	    compressFunction: compressFunction,
	    compressIdent: compressIdent,
	    compressHex: compressHex
	};

var walk$2 = csstree_min.walk;
	var handlers$2 = {
	    Atrule: Atrule$1,
	    AttributeSelector: AttributeSelector,
	    Value: Value,
	    Dimension: Dimension,
	    Percentage: Percentage,
	    Number: _Number,
	    String: _String,
	    Url: Url,
	    Hash: color.compressHex,
	    Identifier: color.compressIdent,
	    Function: color.compressFunction
	};

var generate = csstree_min.generate;

function Index() {
	    this.seed = 0;
	    this.map = Object.create(null);
	}

Index.prototype.resolve = function(str) {
	    var index = this.map[str];

if (!index) {
	        index = ++this.seed;
	        this.map[str] = index;
	    }

return index;
	};

var createDeclarationIndexer = function createDeclarationIndexer() {
	    var ids = new Index();

return function markDeclaration(node) {
	        var id = generate(node);

node.id = ids.resolve(id);
	        node.length = id.length;
	        node.fingerprint = null;

return node;
	    };
	};

var specificity = function specificity(simpleSelector) {
	    var A = 0;
	    var B = 0;
	    var C = 0;

simpleSelector.children.each(function walk(node) {
	        switch (node.type) {
	            case 'SelectorList':
	            case 'Selector':
	                node.children.each(walk);
	                break;

case 'IdSelector':
	                A++;
	                break;

case 'ClassSelector':
	            case 'AttributeSelector':
	                B++;
	                break;

case 'PseudoClassSelector':
	                switch (node.name.toLowerCase()) {
	                    case 'not':
	                        node.children.each(walk);
	                        break;

case 'before':
	                    case 'after':
	                    case 'first-line':
	                    case 'first-letter':
	                        C++;
	                        break;

// TODO: support for :nth-*(.. of <SelectorList>), :matches(), :has()
	                    default:
	                        B++;
	                }
	                break;

case 'PseudoElementSelector':
	                C++;
	                break;

case 'TypeSelector':
	                // ignore universal selector
	                if (node.name.charAt(node.name.length - 1) !== '*') {
	                    C++;
	                }
	                break;

}
	    });

return [A, B, C];
	};

var generate$1 = csstree_min.generate;

var nonFreezePseudoElements = {
	    'first-letter': true,
	    'first-line': true,
	    'after': true,
	    'before': true
	};
	var nonFreezePseudoClasses = {
	    'link': true,
	    'visited': true,
	    'hover': true,
	    'active': true,
	    'first-letter': true,
	    'first-line': true,
	    'after': true,
	    'before': true
	};

var processSelector = function freeze(node, usageData) {
	    var pseudos = Object.create(null);
	    var hasPseudo = false;

node.prelude.children.each(function(simpleSelector) {
	        var tagName = '*';
	        var scope = 0;

simpleSelector.children.each(function(node) {
	            switch (node.type) {
	                case 'ClassSelector':
	                    if (usageData && usageData.scopes) {
	                        var classScope = usageData.scopes[node.name] || 0;

if (scope !== 0 && classScope !== scope) {
	                            throw new Error('Selector can\'t has classes from different scopes: ' + generate$1(simpleSelector));
	                        }

scope = classScope;
	                    }
	                    break;

case 'PseudoClassSelector':
	                    var name = node.name.toLowerCase();

if (!nonFreezePseudoClasses.hasOwnProperty(name)) {
	                        pseudos[':' + name] = true;
	                        hasPseudo = true;
	                    }
	                    break;

case 'PseudoElementSelector':
	                    var name = node.name.toLowerCase();

if (!nonFreezePseudoElements.hasOwnProperty(name)) {
	                        pseudos['::' + name] = true;
	                        hasPseudo = true;
	                    }
	                    break;

case 'TypeSelector':
	                    tagName = node.name.toLowerCase();
	                    break;

case 'AttributeSelector':
	                    if (node.flags) {
	                        pseudos['[' + node.flags.toLowerCase() + ']'] = true;
	                        hasPseudo = true;
	                    }
	                    break;

case 'WhiteSpace':
	                case 'Combinator':
	                    tagName = '*';
	                    break;
	            }
	        });

simpleSelector.compareMarker = specificity(simpleSelector).toString();
	        simpleSelector.id = null; // pre-init property to avoid multiple hidden class
	        simpleSelector.id = generate$1(simpleSelector);

if (scope) {
	            simpleSelector.compareMarker += ':' + scope;
	        }

if (tagName !== '*') {
	            simpleSelector.compareMarker += ',' + tagName;
	        }
	    });

// add property to all rule nodes to avoid multiple hidden class
	    node.pseudoSignature = hasPseudo && Object.keys(pseudos).sort().join(',');
	};

var resolveKeyword$2 = csstree_min.keyword;
	var walk$3 = csstree_min.walk;
	var generate$2 = csstree_min.generate;

var prepare = function prepare(ast, options) {
	    var markDeclaration = createDeclarationIndexer();

walk$3(ast, {
	        visit: 'Rule',
	        enter: function processRule(node) {
	            node.block.children.each(markDeclaration);
	            processSelector(node, options.usage);
	        }
	    });

walk$3(ast, {
	        visit: 'Atrule',
	        enter: function(node) {
	            if (node.prelude) {
	                node.prelude.id = null; // pre-init property to avoid multiple hidden class for generate
	                node.prelude.id = generate$2(node.prelude);
	            }

// compare keyframe selectors by its values
	            // NOTE: still no clarification about problems with keyframes selector grouping (issue #197)
	            if (resolveKeyword$2(node.name).basename === 'keyframes') {
	                node.block.avoidRulesMerge = true;  /* probably we don't need to prevent those merges for @keyframes
	                                                       TODO: need to be checked */
	                node.block.children.each(function(rule) {
	                    rule.prelude.children.each(function(simpleselector) {
	                        simpleselector.compareMarker = simpleselector.id;
	                    });
	                });
	            }
	        }
	    });

return {
	        declaration: markDeclaration
	    };
	};

var List$1 = csstree_min.List;
	var resolveKeyword$3 = csstree_min.keyword;
	var hasOwnProperty$2 = Object.prototype.hasOwnProperty;
	var walk$4 = csstree_min.walk;

function addRuleToMap(map, item, list, single) {
	    var node = item.data;
	    var name = resolveKeyword$3(node.name).basename;
	    var id = node.name.toLowerCase() + '/' + (node.prelude ? node.prelude.id : null);

if (!hasOwnProperty$2.call(map, name)) {
	        map[name] = Object.create(null);
	    }

if (single) {
	        delete map[name][id];
	    }

if (!hasOwnProperty$2.call(map[name], id)) {
	        map[name][id] = new List$1();
	    }

map[name][id].append(list.remove(item));
	}

function relocateAtrules(ast, options) {
	    var collected = Object.create(null);
	    var topInjectPoint = null;

ast.children.each(function(node, item, list) {
	        if (node.type === 'Atrule') {
	            var name = resolveKeyword$3(node.name).basename;

switch (name) {
	                case 'keyframes':
	                    addRuleToMap(collected, item, list, true);
	                    return;

case 'media':
	                    if (options.forceMediaMerge) {
	                        addRuleToMap(collected, item, list, false);
	                        return;
	                    }
	                    break;
	            }

if (topInjectPoint === null &&
	                name !== 'charset' &&
	                name !== 'import') {
	                topInjectPoint = item;
	            }
	        } else {
	            if (topInjectPoint === null) {
	                topInjectPoint = item;
	            }
	        }
	    });

for (var atrule in collected) {
	        for (var id in collected[atrule]) {
	            ast.children.insertList(
	                collected[atrule][id],
	                atrule === 'media' ? null : topInjectPoint
	            );
	        }
	    }
	}
	function isMediaRule(node) {
	    return node.type === 'Atrule' && node.name === 'media';
	}

function processAtrule(node, item, list) {
	    if (!isMediaRule(node)) {
	        return;
	    }

var prev = item.prev && item.prev.data;

if (!prev || !isMediaRule(prev)) {
	        return;
	    }

// merge @media with same query
	    if (node.prelude &&
	        prev.prelude &&
	        node.prelude.id === prev.prelude.id) {
	        prev.block.children.appendList(node.block.children);
	        list.remove(item);

// TODO: use it when we can refer to several points in source
	        // prev.loc = {
	        //     primary: prev.loc,
	        //     merged: node.loc
	        // };
	    }
	}

var _1MergeAtrule = function rejoinAtrule(ast, options) {
	    relocateAtrules(ast, options);

walk$4(ast, {
	        visit: 'Atrule',
	        reverse: true,
	        enter: processAtrule
	    });
	};

var hasOwnProperty$3 = Object.prototype.hasOwnProperty;

function isEqualSelectors(a, b) {
	    var cursor1 = a.head;
	    var cursor2 = b.head;

while (cursor1 !== null && cursor2 !== null && cursor1.data.id === cursor2.data.id) {
	        cursor1 = cursor1.next;
	        cursor2 = cursor2.next;
	    }

return cursor1 === null && cursor2 === null;
	}

function isEqualDeclarations(a, b) {
	    var cursor1 = a.head;
	    var cursor2 = b.head;

while (cursor1 !== null && cursor2 !== null && cursor1.data.id === cursor2.data.id) {
	        cursor1 = cursor1.next;
	        cursor2 = cursor2.next;
	    }

return cursor1 === null && cursor2 === null;
	}

function compareDeclarations(declarations1, declarations2) {
	    var result = {
	        eq: [],
	        ne1: [],
	        ne2: [],
	        ne2overrided: []
	    };

var fingerprints = Object.create(null);
	    var declarations2hash = Object.create(null);

for (var cursor = declarations2.head; cursor; cursor = cursor.next)  {
	        declarations2hash[cursor.data.id] = true;
	    }

for (var cursor = declarations1.head; cursor; cursor = cursor.next)  {
	        var data = cursor.data;

if (data.fingerprint) {
	            fingerprints[data.fingerprint] = data.important;
	        }

if (declarations2hash[data.id]) {
	            declarations2hash[data.id] = false;
	            result.eq.push(data);
	        } else {
	            result.ne1.push(data);
	        }
	    }

for (var cursor = declarations2.head; cursor; cursor = cursor.next)  {
	        var data = cursor.data;

if (declarations2hash[data.id]) {
	            // when declarations1 has an overriding declaration, this is not a difference
	            // unless no !important is used on prev and !important is used on the following
	            if (!hasOwnProperty$3.call(fingerprints, data.fingerprint) ||
	                (!fingerprints[data.fingerprint] && data.important)) {
	                result.ne2.push(data);
	            }

result.ne2overrided.push(data);
	        }
	    }

return result;
	}

function addSelectors(dest, source) {
	    source.each(function(sourceData) {
	        var newStr = sourceData.id;
	        var cursor = dest.head;

while (cursor) {
	            var nextStr = cursor.data.id;

if (nextStr === newStr) {
	                return;
	            }

if (nextStr > newStr) {
	                break;
	            }

cursor = cursor.next;
	        }

dest.insert(dest.createItem(sourceData), cursor);
	    });

return dest;
	}

// check if simpleselectors has no equal specificity and element selector
	function hasSimilarSelectors(selectors1, selectors2) {
	    var cursor1 = selectors1.head;

while (cursor1 !== null) {
	        var cursor2 = selectors2.head;

while (cursor2 !== null) {
	            if (cursor1.data.compareMarker === cursor2.data.compareMarker) {
	                return true;
	            }

cursor2 = cursor2.next;
	        }

cursor1 = cursor1.next;
	    }

return false;
	}

// test node can't to be skipped
	function unsafeToSkipNode(node) {
	    switch (node.type) {
	        case 'Rule':
	            // unsafe skip ruleset with selector similarities
	            return hasSimilarSelectors(node.prelude.children, this);

case 'Atrule':
	            // can skip at-rules with blocks
	            if (node.block) {
	                // unsafe skip at-rule if block contains something unsafe to skip
	                return node.block.children.some(unsafeToSkipNode, this);
	            }
	            break;

case 'Declaration':
	            return false;
	    }

// unsafe by default
	    return true;
	}

var utils$1 = {
	    isEqualSelectors: isEqualSelectors,
	    isEqualDeclarations: isEqualDeclarations,
	    compareDeclarations: compareDeclarations,
	    addSelectors: addSelectors,
	    hasSimilarSelectors: hasSimilarSelectors,
	    unsafeToSkipNode: unsafeToSkipNode
	};

var walk$5 = csstree_min.walk;

function processRule(node, item, list) {
	    var selectors = node.prelude.children;
	    var declarations = node.block.children;

list.prevUntil(item.prev, function(prev) {
	        // skip non-ruleset node if safe
	        if (prev.type !== 'Rule') {
	            return utils$1.unsafeToSkipNode.call(selectors, prev);
	        }

var prevSelectors = prev.prelude.children;
	        var prevDeclarations = prev.block.children;

// try to join rulesets with equal pseudo signature
	        if (node.pseudoSignature === prev.pseudoSignature) {
	            // try to join by selectors
	            if (utils$1.isEqualSelectors(prevSelectors, selectors)) {
	                prevDeclarations.appendList(declarations);
	                list.remove(item);
	                return true;
	            }

// try to join by declarations
	            if (utils$1.isEqualDeclarations(declarations, prevDeclarations)) {
	                utils$1.addSelectors(prevSelectors, selectors);
	                list.remove(item);
	                return true;
	            }
	        }

// go to prev ruleset if has no selector similarities
	        return utils$1.hasSimilarSelectors(selectors, prevSelectors);
	    });
	}

// NOTE: direction should be left to right, since rulesets merge to left
	// ruleset. When direction right to left unmerged rulesets may prevent lookup
	// TODO: remove initial merge
	var _2InitialMergeRuleset = function initialMergeRule(ast) {
	    walk$5(ast, {
	        visit: 'Rule',
	        enter: processRule
	    });
	};

var List$2 = csstree_min.List;
	var walk$6 = csstree_min.walk;

function processRule$1(node, item, list) {
	    var selectors = node.prelude.children;

// generate new rule sets:
	    // .a, .b { color: red; }
	    // ->
	    // .a { color: red; }
	    // .b { color: red; }

// while there are more than 1 simple selector split for rulesets
	    while (selectors.head !== selectors.tail) {
	        var newSelectors = new List$2();
	        newSelectors.insert(selectors.remove(selectors.head));

list.insert(list.createItem({
	            type: 'Rule',
	            loc: node.loc,
	            prelude: {
	                type: 'SelectorList',
	                loc: node.prelude.loc,
	                children: newSelectors
	            },
	            block: {
	                type: 'Block',
	                loc: node.block.loc,
	                children: node.block.children.copy()
	            },
	            pseudoSignature: node.pseudoSignature
	        }), item);
	    }
	}

var _3DisjoinRuleset = function disjoinRule(ast) {
	    walk$6(ast, {
	        visit: 'Rule',
	        reverse: true,
	        enter: processRule$1
	    });
	};

var List$3 = csstree_min.List;
	var generate$3 = csstree_min.generate;
	var walk$7 = csstree_min.walk;

var REPLACE = 1;
	var REMOVE = 2;
	var TOP = 0;
	var RIGHT = 1;
	var BOTTOM = 2;
	var LEFT = 3;
	var SIDES = ['top', 'right', 'bottom', 'left'];
	var SIDE = {
	    'margin-top': 'top',
	    'margin-right': 'right',
	    'margin-bottom': 'bottom',
	    'margin-left': 'left',

'padding-top': 'top',
	    'padding-right': 'right',
	    'padding-bottom': 'bottom',
	    'padding-left': 'left',

'border-top-color': 'top',
	    'border-right-color': 'right',
	    'border-bottom-color': 'bottom',
	    'border-left-color': 'left',
	    'border-top-width': 'top',
	    'border-right-width': 'right',
	    'border-bottom-width': 'bottom',
	    'border-left-width': 'left',
	    'border-top-style': 'top',
	    'border-right-style': 'right',
	    'border-bottom-style': 'bottom',
	    'border-left-style': 'left'
	};
	var MAIN_PROPERTY = {
	    'margin': 'margin',
	    'margin-top': 'margin',
	    'margin-right': 'margin',
	    'margin-bottom': 'margin',
	    'margin-left': 'margin',

'padding': 'padding',
	    'padding-top': 'padding',
	    'padding-right': 'padding',
	    'padding-bottom': 'padding',
	    'padding-left': 'padding',

'border-color': 'border-color',
	    'border-top-color': 'border-color',
	    'border-right-color': 'border-color',
	    'border-bottom-color': 'border-color',
	    'border-left-color': 'border-color',
	    'border-width': 'border-width',
	    'border-top-width': 'border-width',
	    'border-right-width': 'border-width',
	    'border-bottom-width': 'border-width',
	    'border-left-width': 'border-width',
	    'border-style': 'border-style',
	    'border-top-style': 'border-style',
	    'border-right-style': 'border-style',
	    'border-bottom-style': 'border-style',
	    'border-left-style': 'border-style'
	};

function TRBL(name) {
	    this.name = name;
	    this.loc = null;
	    this.iehack = undefined;
	    this.sides = {
	        'top': null,
	        'right': null,
	        'bottom': null,
	        'left': null
	    };
	}

TRBL.prototype.getValueSequence = function(declaration, count) {
	    var values = [];
	    var iehack = '';
	    var hasBadValues = declaration.value.type !== 'Value' || declaration.value.children.some(function(child) {
	        var special = false;

switch (child.type) {
	            case 'Identifier':
	                switch (child.name) {
	                    case '\\0':
	                    case '\\9':
	                        iehack = child.name;
	                        return;

case 'inherit':
	                    case 'initial':
	                    case 'unset':
	                    case 'revert':
	                        special = child.name;
	                        break;
	                }
	                break;

case 'Dimension':
	                switch (child.unit) {
	                    // is not supported until IE11
	                    case 'rem':

// v* units is too buggy across browsers and better
	                    // don't merge values with those units
	                    case 'vw':
	                    case 'vh':
	                    case 'vmin':
	                    case 'vmax':
	                    case 'vm': // IE9 supporting "vm" instead of "vmin".
	                        special = child.unit;
	                        break;
	                }
	                break;

case 'Hash': // color
	            case 'Number':
	            case 'Percentage':
	                break;

case 'Function':
	                if (child.name === 'var') {
	                    return true;
	                }

special = child.name;
	                break;

case 'WhiteSpace':
	                return false; // ignore space

default:
	                return true;  // bad value
	        }

values.push({
	            node: child,
	            special: special,
	            important: declaration.important
	        });
	    });

if (hasBadValues || values.length > count) {
	        return false;
	    }

if (typeof this.iehack === 'string' && this.iehack !== iehack) {
	        return false;
	    }

this.iehack = iehack; // move outside

return values;
	};

TRBL.prototype.canOverride = function(side, value) {
	    var currentValue = this.sides[side];

return !currentValue || (value.important && !currentValue.important);
	};

TRBL.prototype.add = function(name, declaration) {
	    function attemptToAdd() {
	        var sides = this.sides;
	        var side = SIDE[name];

if (side) {
	            if (side in sides === false) {
	                return false;
	            }

var values = this.getValueSequence(declaration, 1);

if (!values || !values.length) {
	                return false;
	            }

// can mix only if specials are equal
	            for (var key in sides) {
	                if (sides[key] !== null && sides[key].special !== values[0].special) {
	                    return false;
	                }
	            }

if (!this.canOverride(side, values[0])) {
	                return true;
	            }

sides[side] = values[0];
	            return true;
	        } else if (name === this.name) {
	            var values = this.getValueSequence(declaration, 4);

if (!values || !values.length) {
	                return false;
	            }

switch (values.length) {
	                case 1:
	                    values[RIGHT] = values[TOP];
	                    values[BOTTOM] = values[TOP];
	                    values[LEFT] = values[TOP];
	                    break;

case 2:
	                    values[BOTTOM] = values[TOP];
	                    values[LEFT] = values[RIGHT];
	                    break;

case 3:
	                    values[LEFT] = values[RIGHT];
	                    break;
	            }

// can mix only if specials are equal
	            for (var i = 0; i < 4; i++) {
	                for (var key in sides) {
	                    if (sides[key] !== null && sides[key].special !== values[i].special) {
	                        return false;
	                    }
	                }
	            }

for (var i = 0; i < 4; i++) {
	                if (this.canOverride(SIDES[i], values[i])) {
	                    sides[SIDES[i]] = values[i];
	                }
	            }

return true;
	        }
	    }

if (!attemptToAdd.call(this)) {
	        return false;
	    }

// TODO: use it when we can refer to several points in source
	    // if (this.loc) {
	    //     this.loc = {
	    //         primary: this.loc,
	    //         merged: declaration.loc
	    //     };
	    // } else {
	    //     this.loc = declaration.loc;
	    // }
	    if (!this.loc) {
	        this.loc = declaration.loc;
	    }

return true;
	};

TRBL.prototype.isOkToMinimize = function() {
	    var top = this.sides.top;
	    var right = this.sides.right;
	    var bottom = this.sides.bottom;
	    var left = this.sides.left;

if (top && right && bottom && left) {
	        var important =
	            top.important +
	            right.important +
	            bottom.important +
	            left.important;

return important === 0 || important === 4;
	    }

return false;
	};

TRBL.prototype.getValue = function() {
	    var result = new List$3();
	    var sides = this.sides;
	    var values = [
	        sides.top,
	        sides.right,
	        sides.bottom,
	        sides.left
	    ];
	    var stringValues = [
	        generate$3(sides.top.node),
	        generate$3(sides.right.node),
	        generate$3(sides.bottom.node),
	        generate$3(sides.left.node)
	    ];

if (stringValues[LEFT] === stringValues[RIGHT]) {
	        values.pop();
	        if (stringValues[BOTTOM] === stringValues[TOP]) {
	            values.pop();
	            if (stringValues[RIGHT] === stringValues[TOP]) {
	                values.pop();
	            }
	        }
	    }

for (var i = 0; i < values.length; i++) {
	        if (i) {
	            result.appendData({ type: 'WhiteSpace', value: ' ' });
	        }

result.appendData(values[i].node);
	    }

if (this.iehack) {
	        result.appendData({ type: 'WhiteSpace', value: ' ' });
	        result.appendData({
	            type: 'Identifier',
	            loc: null,
	            name: this.iehack
	        });
	    }

return {
	        type: 'Value',
	        loc: null,
	        children: result
	    };
	};

TRBL.prototype.getDeclaration = function() {
	    return {
	        type: 'Declaration',
	        loc: this.loc,
	        important: this.sides.top.important,
	        property: this.name,
	        value: this.getValue()
	    };
	};

function processRule$2(rule, shorts, shortDeclarations, lastShortSelector) {
	    var declarations = rule.block.children;
	    var selector = rule.prelude.children.first().id;

rule.block.children.eachRight(function(declaration, item) {
	        var property = declaration.property;

if (!MAIN_PROPERTY.hasOwnProperty(property)) {
	            return;
	        }

var key = MAIN_PROPERTY[property];
	        var shorthand;
	        var operation;

if (!lastShortSelector || selector === lastShortSelector) {
	            if (key in shorts) {
	                operation = REMOVE;
	                shorthand = shorts[key];
	            }
	        }

if (!shorthand || !shorthand.add(property, declaration)) {
	            operation = REPLACE;
	            shorthand = new TRBL(key);

// if can't parse value ignore it and break shorthand children
	            if (!shorthand.add(property, declaration)) {
	                lastShortSelector = null;
	                return;
	            }
	        }

shorts[key] = shorthand;
	        shortDeclarations.push({
	            operation: operation,
	            block: declarations,
	            item: item,
	            shorthand: shorthand
	        });

lastShortSelector = selector;
	    });

return lastShortSelector;
	}

function processShorthands(shortDeclarations, markDeclaration) {
	    shortDeclarations.forEach(function(item) {
	        var shorthand = item.shorthand;

if (!shorthand.isOkToMinimize()) {
	            return;
	        }

if (item.operation === REPLACE) {
	            item.item.data = markDeclaration(shorthand.getDeclaration());
	        } else {
	            item.block.remove(item.item);
	        }
	    });
	}

var _4RestructShorthand = function restructBlock(ast, indexer) {
	    var stylesheetMap = {};
	    var shortDeclarations = [];

walk$7(ast, {
	        visit: 'Rule',
	        reverse: true,
	        enter: function(node) {
	            var stylesheet = this.block || this.stylesheet;
	            var ruleId = (node.pseudoSignature || '') + '|' + node.prelude.children.first().id;
	            var ruleMap;
	            var shorts;

if (!stylesheetMap.hasOwnProperty(stylesheet.id)) {
	                ruleMap = {
	                    lastShortSelector: null
	                };
	                stylesheetMap[stylesheet.id] = ruleMap;
	            } else {
	                ruleMap = stylesheetMap[stylesheet.id];
	            }

if (ruleMap.hasOwnProperty(ruleId)) {
	                shorts = ruleMap[ruleId];
	            } else {
	                shorts = {};
	                ruleMap[ruleId] = shorts;
	            }

ruleMap.lastShortSelector = processRule$2.call(this, node, shorts, shortDeclarations, ruleMap.lastShortSelector);
	        }
	    });

processShorthands(shortDeclarations, indexer.declaration);
	};

var resolveProperty = csstree_min.property;
	var resolveKeyword$4 = csstree_min.keyword;
	var walk$8 = csstree_min.walk;
	var generate$4 = csstree_min.generate;
	var fingerprintId = 1;
	var dontRestructure = {
	    'src': 1 // https://github.com/afelix/csso/issues/50
	};

var DONT_MIX_VALUE = {
	    // https://developer.mozilla.org/en-US/docs/Web/CSS/display#Browser_compatibility
	    'display': /table|ruby|flex|-(flex)?box$|grid|contents|run-in/i,
	    // https://developer.mozilla.org/en/docs/Web/CSS/text-align
	    'text-align': /^(start|end|match-parent|justify-all)$/i
	};

var SAFE_VALUES = {
	    cursor: [
	        'auto', 'crosshair', 'default', 'move', 'text', 'wait', 'help',
	        'n-resize', 'e-resize', 's-resize', 'w-resize',
	        'ne-resize', 'nw-resize', 'se-resize', 'sw-resize',
	        'pointer', 'progress', 'not-allowed', 'no-drop', 'vertical-text', 'all-scroll',
	        'col-resize', 'row-resize'
	    ],
	    overflow: [
	        'hidden', 'visible', 'scroll', 'auto'
	    ],
	    position: [
	        'static', 'relative', 'absolute', 'fixed'
	    ]
	};

var NEEDLESS_TABLE = {
	    'border-width': ['border'],
	    'border-style': ['border'],
	    'border-color': ['border'],
	    'border-top': ['border'],
	    'border-right': ['border'],
	    'border-bottom': ['border'],
	    'border-left': ['border'],
	    'border-top-width': ['border-top', 'border-width', 'border'],
	    'border-right-width': ['border-right', 'border-width', 'border'],
	    'border-bottom-width': ['border-bottom', 'border-width', 'border'],
	    'border-left-width': ['border-left', 'border-width', 'border'],
	    'border-top-style': ['border-top', 'border-style', 'border'],
	    'border-right-style': ['border-right', 'border-style', 'border'],
	    'border-bottom-style': ['border-bottom', 'border-style', 'border'],
	    'border-left-style': ['border-left', 'border-style', 'border'],
	    'border-top-color': ['border-top', 'border-color', 'border'],
	    'border-right-color': ['border-right', 'border-color', 'border'],
	    'border-bottom-color': ['border-bottom', 'border-color', 'border'],
	    'border-left-color': ['border-left', 'border-color', 'border'],
	    'margin-top': ['margin'],
	    'margin-right': ['margin'],
	    'margin-bottom': ['margin'],
	    'margin-left': ['margin'],
	    'padding-top': ['padding'],
	    'padding-right': ['padding'],
	    'padding-bottom': ['padding'],
	    'padding-left': ['padding'],
	    'font-style': ['font'],
	    'font-variant': ['font'],
	    'font-weight': ['font'],
	    'font-size': ['font'],
	    'font-family': ['font'],
	    'list-style-type': ['list-style'],
	    'list-style-position': ['list-style'],
	    'list-style-image': ['list-style']
	};

function getPropertyFingerprint(propertyName, declaration, fingerprints) {
	    var realName = resolveProperty(propertyName).basename;

if (realName === 'background') {
	        return propertyName + ':' + generate$4(declaration.value);
	    }

var declarationId = declaration.id;
	    var fingerprint = fingerprints[declarationId];

if (!fingerprint) {
	        switch (declaration.value.type) {
	            case 'Value':
	                var vendorId = '';
	                var iehack = '';
	                var special = {};
	                var raw = false;

declaration.value.children.each(function walk(node) {
	                    switch (node.type) {
	                        case 'Value':
	                        case 'Brackets':
	                        case 'Parentheses':
	                            node.children.each(walk);
	                            break;

case 'Raw':
	                            raw = true;
	                            break;

case 'Identifier':
	                            var name = node.name;

if (!vendorId) {
	                                vendorId = resolveKeyword$4(name).vendor;
	                            }

if (/\\[09]/.test(name)) {
	                                iehack = RegExp.lastMatch;
	                            }

if (SAFE_VALUES.hasOwnProperty(realName)) {
	                                if (SAFE_VALUES[realName].indexOf(name) === -1) {
	                                    special[name] = true;
	                                }
	                            } else if (DONT_MIX_VALUE.hasOwnProperty(realName)) {
	                                if (DONT_MIX_VALUE[realName].test(name)) {
	                                    special[name] = true;
	                                }
	                            }

break;

case 'Function':
	                            var name = node.name;

if (!vendorId) {
	                                vendorId = resolveKeyword$4(name).vendor;
	                            }

if (name === 'rect') {
	                                // there are 2 forms of rect:
	                                //   rect(<top>, <right>, <bottom>, <left>) - standart
	                                //   rect(<top> <right> <bottom> <left>) – backwards compatible syntax
	                                // only the same form values can be merged
	                                var hasComma = node.children.some(function(node) {
	                                    return node.type === 'Operator' && node.value === ',';
	                                });
	                                if (!hasComma) {
	                                    name = 'rect-backward';
	                                }
	                            }

special[name + '()'] = true;

// check nested tokens too
	                            node.children.each(walk);

break;

case 'Dimension':
	                            var unit = node.unit;

if (/\\[09]/.test(unit)) {
	                                iehack = RegExp.lastMatch;
	                            }

switch (unit) {
	                                // is not supported until IE11
	                                case 'rem':

// v* units is too buggy across browsers and better
	                                // don't merge values with those units
	                                case 'vw':
	                                case 'vh':
	                                case 'vmin':
	                                case 'vmax':
	                                case 'vm': // IE9 supporting "vm" instead of "vmin".
	                                    special[unit] = true;
	                                    break;
	                            }
	                            break;
	                    }
	                });

fingerprint = raw
	                    ? '!' + fingerprintId++
	                    : '!' + Object.keys(special).sort() + '|' + iehack + vendorId;
	                break;

case 'Raw':
	                fingerprint = '!' + declaration.value.value;
	                break;

default:
	                fingerprint = generate$4(declaration.value);
	        }

fingerprints[declarationId] = fingerprint;
	    }

return propertyName + fingerprint;
	}

function needless(props, declaration, fingerprints) {
	    var property = resolveProperty(declaration.property);

if (NEEDLESS_TABLE.hasOwnProperty(property.basename)) {
	        var table = NEEDLESS_TABLE[property.basename];

for (var i = 0; i < table.length; i++) {
	            var ppre = getPropertyFingerprint(property.prefix + table[i], declaration, fingerprints);
	            var prev = props.hasOwnProperty(ppre) ? props[ppre] : null;

if (prev && (!declaration.important || prev.item.data.important)) {
	                return prev;
	            }
	        }
	    }
	}

function processRule$3(rule, item, list, props, fingerprints) {
	    var declarations = rule.block.children;

declarations.eachRight(function(declaration, declarationItem) {
	        var property = declaration.property;
	        var fingerprint = getPropertyFingerprint(property, declaration, fingerprints);
	        var prev = props[fingerprint];

if (prev && !dontRestructure.hasOwnProperty(property)) {
	            if (declaration.important && !prev.item.data.important) {
	                props[fingerprint] = {
	                    block: declarations,
	                    item: declarationItem
	                };

prev.block.remove(prev.item);

// TODO: use it when we can refer to several points in source
	                // declaration.loc = {
	                //     primary: declaration.loc,
	                //     merged: prev.item.data.loc
	                // };
	            } else {
	                declarations.remove(declarationItem);

// TODO: use it when we can refer to several points in source
	                // prev.item.data.loc = {
	                //     primary: prev.item.data.loc,
	                //     merged: declaration.loc
	                // };
	            }
	        } else {
	            var prev = needless(props, declaration, fingerprints);

if (prev) {
	                declarations.remove(declarationItem);

// TODO: use it when we can refer to several points in source
	                // prev.item.data.loc = {
	                //     primary: prev.item.data.loc,
	                //     merged: declaration.loc
	                // };
	            } else {
	                declaration.fingerprint = fingerprint;

props[fingerprint] = {
	                    block: declarations,
	                    item: declarationItem
	                };
	            }
	        }
	    });

if (declarations.isEmpty()) {
	        list.remove(item);
	    }
	}

var _6RestructBlock = function restructBlock(ast) {
	    var stylesheetMap = {};
	    var fingerprints = Object.create(null);

walk$8(ast, {
	        visit: 'Rule',
	        reverse: true,
	        enter: function(node, item, list) {
	            var stylesheet = this.block || this.stylesheet;
	            var ruleId = (node.pseudoSignature || '') + '|' + node.prelude.children.first().id;
	            var ruleMap;
	            var props;

if (!stylesheetMap.hasOwnProperty(stylesheet.id)) {
	                ruleMap = {};
	                stylesheetMap[stylesheet.id] = ruleMap;
	            } else {
	                ruleMap = stylesheetMap[stylesheet.id];
	            }

if (ruleMap.hasOwnProperty(ruleId)) {
	                props = ruleMap[ruleId];
	            } else {
	                props = {};
	                ruleMap[ruleId] = props;
	            }

processRule$3.call(this, node, item, list, props, fingerprints);
	        }
	    });
	};

var walk$9 = csstree_min.walk;

/*
	    At this step all rules has single simple selector. We try to join by equal
	    declaration blocks to first rule, e.g.

.a { color: red }
	    b { ... }
	    .b { color: red }
	    ->
	    .a, .b { color: red }
	    b { ... }
	*/

function processRule$4(node, item, list) {
	    var selectors = node.prelude.children;
	    var declarations = node.block.children;
	    var nodeCompareMarker = selectors.first().compareMarker;
	    var skippedCompareMarkers = {};

list.nextUntil(item.next, function(next, nextItem) {
	        // skip non-ruleset node if safe
	        if (next.type !== 'Rule') {
	            return utils$1.unsafeToSkipNode.call(selectors, next);
	        }

if (node.pseudoSignature !== next.pseudoSignature) {
	            return true;
	        }

var nextFirstSelector = next.prelude.children.head;
	        var nextDeclarations = next.block.children;
	        var nextCompareMarker = nextFirstSelector.data.compareMarker;

// if next ruleset has same marked as one of skipped then stop joining
	        if (nextCompareMarker in skippedCompareMarkers) {
	            return true;
	        }

// try to join by selectors
	        if (selectors.head === selectors.tail) {
	            if (selectors.first().id === nextFirstSelector.data.id) {
	                declarations.appendList(nextDeclarations);
	                list.remove(nextItem);
	                return;
	            }
	        }

// try to join by properties
	        if (utils$1.isEqualDeclarations(declarations, nextDeclarations)) {
	            var nextStr = nextFirstSelector.data.id;

selectors.some(function(data, item) {
	                var curStr = data.id;

if (nextStr < curStr) {
	                    selectors.insert(nextFirstSelector, item);
	                    return true;
	                }

if (!item.next) {
	                    selectors.insert(nextFirstSelector);
	                    return true;
	                }
	            });

list.remove(nextItem);
	            return;
	        }

// go to next ruleset if current one can be skipped (has no equal specificity nor element selector)
	        if (nextCompareMarker === nodeCompareMarker) {
	            return true;
	        }

skippedCompareMarkers[nextCompareMarker] = true;
	    });
	}

var _7MergeRuleset = function mergeRule(ast) {
	    walk$9(ast, {
	        visit: 'Rule',
	        enter: processRule$4
	    });
	};

var List$4 = csstree_min.List;
	var walk$a = csstree_min.walk;

function calcSelectorLength(list) {
	    var length = 0;

list.each(function(data) {
	        length += data.id.length + 1;
	    });

return length - 1;
	}

function calcDeclarationsLength(tokens) {
	    var length = 0;

for (var i = 0; i < tokens.length; i++) {
	        length += tokens[i].length;
	    }

return (
	        length +          // declarations
	        tokens.length - 1 // delimeters
	    );
	}

function processRule$5(node, item, list) {
	    var avoidRulesMerge = this.block !== null ? this.block.avoidRulesMerge : false;
	    var selectors = node.prelude.children;
	    var block = node.block;
	    var disallowDownMarkers = Object.create(null);
	    var allowMergeUp = true;
	    var allowMergeDown = true;

list.prevUntil(item.prev, function(prev, prevItem) {
	        var prevBlock = prev.block;
	        var prevType = prev.type;

if (prevType !== 'Rule') {
	            var unsafe = utils$1.unsafeToSkipNode.call(selectors, prev);

if (!unsafe && prevType === 'Atrule' && prevBlock) {
	                walk$a(prevBlock, {
	                    visit: 'Rule',
	                    enter: function(node) {
	                        node.prelude.children.each(function(data) {
	                            disallowDownMarkers[data.compareMarker] = true;
	                        });
	                    }
	                });
	            }

return unsafe;
	        }

var prevSelectors = prev.prelude.children;

if (node.pseudoSignature !== prev.pseudoSignature) {
	            return true;
	        }

allowMergeDown = !prevSelectors.some(function(selector) {
	            return selector.compareMarker in disallowDownMarkers;
	        });

// try prev ruleset if simpleselectors has no equal specifity and element selector
	        if (!allowMergeDown && !allowMergeUp) {
	            return true;
	        }

// try to join by selectors
	        if (allowMergeUp && utils$1.isEqualSelectors(prevSelectors, selectors)) {
	            prevBlock.children.appendList(block.children);
	            list.remove(item);
	            return true;
	        }

// try to join by properties
	        var diff = utils$1.compareDeclarations(block.children, prevBlock.children);

// console.log(diff.eq, diff.ne1, diff.ne2);

if (diff.eq.length) {
	            if (!diff.ne1.length && !diff.ne2.length) {
	                // equal blocks
	                if (allowMergeDown) {
	                    utils$1.addSelectors(selectors, prevSelectors);
	                    list.remove(prevItem);
	                }

return true;
	            } else if (!avoidRulesMerge) { /* probably we don't need to prevent those merges for @keyframes
	                                              TODO: need to be checked */

if (diff.ne1.length && !diff.ne2.length) {
	                    // prevBlock is subset block
	                    var selectorLength = calcSelectorLength(selectors);
	                    var blockLength = calcDeclarationsLength(diff.eq); // declarations length

if (allowMergeUp && selectorLength < blockLength) {
	                        utils$1.addSelectors(prevSelectors, selectors);
	                        block.children = new List$4().fromArray(diff.ne1);
	                    }
	                } else if (!diff.ne1.length && diff.ne2.length) {
	                    // node is subset of prevBlock
	                    var selectorLength = calcSelectorLength(prevSelectors);
	                    var blockLength = calcDeclarationsLength(diff.eq); // declarations length

if (allowMergeDown && selectorLength < blockLength) {
	                        utils$1.addSelectors(selectors, prevSelectors);
	                        prevBlock.children = new List$4().fromArray(diff.ne2);
	                    }
	                } else {
	                    // diff.ne1.length && diff.ne2.length
	                    // extract equal block
	                    var newSelector = {
	                        type: 'SelectorList',
	                        loc: null,
	                        children: utils$1.addSelectors(prevSelectors.copy(), selectors)
	                    };
	                    var newBlockLength = calcSelectorLength(newSelector.children) + 2; // selectors length + curly braces length
	                    var blockLength = calcDeclarationsLength(diff.eq); // declarations length

// create new ruleset if declarations length greater than
	                    // ruleset description overhead
	                    if (blockLength >= newBlockLength) {
	                        var newItem = list.createItem({
	                            type: 'Rule',
	                            loc: null,
	                            prelude: newSelector,
	                            block: {
	                                type: 'Block',
	                                loc: null,
	                                children: new List$4().fromArray(diff.eq)
	                            },
	                            pseudoSignature: node.pseudoSignature
	                        });

block.children = new List$4().fromArray(diff.ne1);
	                        prevBlock.children = new List$4().fromArray(diff.ne2overrided);

if (allowMergeUp) {
	                            list.insert(newItem, prevItem);
	                        } else {
	                            list.insert(newItem, item);
	                        }

return true;
	                    }
	                }
	            }
	        }

if (allowMergeUp) {
	            // TODO: disallow up merge only if any property interception only (i.e. diff.ne2overrided.length > 0);
	            // await property families to find property interception correctly
	            allowMergeUp = !prevSelectors.some(function(prevSelector) {
	                return selectors.some(function(selector) {
	                    return selector.compareMarker === prevSelector.compareMarker;
	                });
	            });
	        }

prevSelectors.each(function(data) {
	            disallowDownMarkers[data.compareMarker] = true;
	        });
	    });
	}

var _8RestructRuleset = function restructRule(ast) {
	    walk$a(ast, {
	        visit: 'Rule',
	        reverse: true,
	        enter: processRule$5
	    });
	};

var restructure = function(ast, options) {
	    // prepare ast for restructing
	    var indexer = prepare(ast, options);
	    options.logger('prepare', ast);

_1MergeAtrule(ast, options);
	    options.logger('mergeAtrule', ast);

_2InitialMergeRuleset(ast);
	    options.logger('initialMergeRuleset', ast);

_3DisjoinRuleset(ast);
	    options.logger('disjoinRuleset', ast);

_4RestructShorthand(ast, indexer);
	    options.logger('restructShorthand', ast);

_6RestructBlock(ast);
	    options.logger('restructBlock', ast);

_7MergeRuleset(ast);
	    options.logger('mergeRuleset', ast);

_8RestructRuleset(ast);
	    options.logger('restructRuleset', ast);
	};

var List$5 = csstree_min.List;
	var clone = csstree_min.clone;

var walk$b = csstree_min.walk;

function readChunk(children, specialComments) {
	    var buffer = new List$5();
	    var nonSpaceTokenInBuffer = false;
	    var protectedComment;

children.nextUntil(children.head, function(node, item, list) {
	        if (node.type === 'Comment') {
	            if (!specialComments || node.value.charAt(0) !== '!') {
	                list.remove(item);
	                return;
	            }

if (nonSpaceTokenInBuffer || protectedComment) {
	                return true;
	            }

list.remove(item);
	            protectedComment = node;
	            return;
	        }

if (node.type !== 'WhiteSpace') {
	            nonSpaceTokenInBuffer = true;
	        }

buffer.insert(list.remove(item));
	    });

return {
	        comment: protectedComment,
	        stylesheet: {
	            type: 'StyleSheet',
	            loc: null,
	            children: buffer
	        }
	    };
	}

function compressChunk(ast, firstAtrulesAllowed, num, options) {
	    options.logger('Compress block #' + num, null, true);

var seed = 1;

if (ast.type === 'StyleSheet') {
	        ast.firstAtrulesAllowed = firstAtrulesAllowed;
	        ast.id = seed++;
	    }

walk$b(ast, {
	        visit: 'Atrule',
	        enter: function markScopes(node) {
	            if (node.block !== null) {
	                node.block.id = seed++;
	            }
	        }
	    });
	    options.logger('init', ast);

// remove redundant
	    clean(ast, options);
	    options.logger('clean', ast);

// replace nodes for shortened forms
	    replace(ast);
	    options.logger('replace', ast);

// structure optimisations
	    if (options.restructuring) {
	        restructure(ast, options);
	    }

return ast;
	}

function getCommentsOption(options) {
	    var comments = 'comments' in options ? options.comments : 'exclamation';

if (typeof comments === 'boolean') {
	        comments = comments ? 'exclamation' : false;
	    } else if (comments !== 'exclamation' && comments !== 'first-exclamation') {
	        comments = false;
	    }

return comments;
	}

function getRestructureOption(options) {
	    if ('restructure' in options) {
	        return options.restructure;
	    }

return 'restructuring' in options ? options.restructuring : true;
	}

function wrapBlock(block) {
	    return new List$5().appendData({
	        type: 'Rule',
	        loc: null,
	        prelude: {
	            type: 'SelectorList',
	            loc: null,
	            children: new List$5().appendData({
	                type: 'Selector',
	                loc: null,
	                children: new List$5().appendData({
	                    type: 'TypeSelector',
	                    loc: null,
	                    name: 'x'
	                })
	            })
	        },
	        block: block
	    });
	}

var compress = function compress(ast, options) {
	    ast = ast || { type: 'StyleSheet', loc: null, children: new List$5() };
	    options = options || {};

var compressOptions = {
	        logger: typeof options.logger === 'function' ? options.logger : function() {},
	        restructuring: getRestructureOption(options),
	        forceMediaMerge: Boolean(options.forceMediaMerge),
	        usage: options.usage ? usage.buildIndex(options.usage) : false
	    };
	    var specialComments = getCommentsOption(options);
	    var firstAtrulesAllowed = true;
	    var input;
	    var output = new List$5();
	    var chunk;
	    var chunkNum = 1;
	    var chunkChildren;

if (options.clone) {
	        ast = clone(ast);
	    }

if (ast.type === 'StyleSheet') {
	        input = ast.children;
	        ast.children = output;
	    } else {
	        input = wrapBlock(ast);
	    }

do {
	        chunk = readChunk(input, Boolean(specialComments));
	        compressChunk(chunk.stylesheet, firstAtrulesAllowed, chunkNum++, compressOptions);
	        chunkChildren = chunk.stylesheet.children;

if (chunk.comment) {
	            // add \n before comment if there is another content in output
	            if (!output.isEmpty()) {
	                output.insert(List$5.createItem({
	                    type: 'Raw',
	                    value: '\n'
	                }));
	            }

output.insert(List$5.createItem(chunk.comment));

// add \n after comment if chunk is not empty
	            if (!chunkChildren.isEmpty()) {
	                output.insert(List$5.createItem({
	                    type: 'Raw',
	                    value: '\n'
	                }));
	            }
	        }

if (firstAtrulesAllowed && !chunkChildren.isEmpty()) {
	            var lastRule = chunkChildren.last();

if (lastRule.type !== 'Atrule' ||
	               (lastRule.name !== 'import' && lastRule.name !== 'charset')) {
	                firstAtrulesAllowed = false;
	            }
	        }

if (specialComments !== 'exclamation') {
	            specialComments = false;
	        }

output.appendList(chunkChildren);
	    } while (!input.isEmpty());

return {
	        ast: ast
	    };
	};

var version = "4.2.0";
	var _package = {
		version: version
	};

var _package$1 = /*#__PURE__*/Object.freeze({
		__proto__: null,
		version: version,
		'default': _package
	});

var require$$0 = getCjsExportFromNamespace(_package$1);

var parse = csstree_min.parse;

var generate$5 = csstree_min.generate;

function debugOutput(name, options, startTime, data) {
	    if (options.debug) {
	        console.error('## ' + name + ' done in %d ms\n', Date.now() - startTime);
	    }

return data;
	}

function createDefaultLogger(level) {
	    var lastDebug;

return function logger(title, ast) {
	        var line = title;

if (ast) {
	            line = '[' + ((Date.now() - lastDebug) / 1000).toFixed(3) + 's] ' + line;
	        }

if (level > 1 && ast) {
	            var css = generate$5(ast);

// when level 2, limit css to 256 symbols
	            if (level === 2 && css.length > 256) {
	                css = css.substr(0, 256) + '...';
	            }

line += '\n  ' + css + '\n';
	        }

console.error(line);
	        lastDebug = Date.now();
	    };
	}

function copy(obj) {
	    var result = {};

for (var key in obj) {
	        result[key] = obj[key];
	    }

return result;
	}

function buildCompressOptions(options) {
	    options = copy(options);

if (typeof options.logger !== 'function' && options.debug) {
	        options.logger = createDefaultLogger(options.debug);
	    }

return options;
	}

function runHandler(ast, options, handlers) {
	    if (!Array.isArray(handlers)) {
	        handlers = [handlers];
	    }

handlers.forEach(function(fn) {
	        fn(ast, options);
	    });
	}

function minify(context, source, options) {
	    options = options || {};

var filename = options.filename || '<unknown>';
	    var result;

// parse
	    var ast = debugOutput('parsing', options, Date.now(),
	        parse(source, {
	            context: context,
	            filename: filename,
	            positions: Boolean(options.sourceMap)
	        })
	    );

// before compress handlers
	    if (options.beforeCompress) {
	        debugOutput('beforeCompress', options, Date.now(),
	            runHandler(ast, options, options.beforeCompress)
	        );
	    }

// compress
	    var compressResult = debugOutput('compress', options, Date.now(),
	        compress(ast, buildCompressOptions(options))
	    );

// after compress handlers
	    if (options.afterCompress) {
	        debugOutput('afterCompress', options, Date.now(),
	            runHandler(compressResult, options, options.afterCompress)
	        );
	    }

// generate
	    if (options.sourceMap) {
	        result = debugOutput('generate(sourceMap: true)', options, Date.now(), (function() {
	            var tmp = generate$5(compressResult.ast, { sourceMap: true });
	            tmp.map._file = filename; // since other tools can relay on file in source map transform chain
	            tmp.map.setSourceContent(filename, source);
	            return tmp;
	        }()));
	    } else {
	        result = debugOutput('generate', options, Date.now(), {
	            css: generate$5(compressResult.ast),
	            map: null
	        });
	    }

return result;
	}

function minifyStylesheet(source, options) {
	    return minify('stylesheet', source, options);
	}

function minifyBlock(source, options) {
	    return minify('declarationList', source, options);
	}

var lib = {
	    version: require$$0.version,

// main methods
	    minify: minifyStylesheet,
	    minifyBlock: minifyBlock,

// css syntax parser/walkers/generator/etc
	    syntax: Object.assign({
	        compress: compress
	    }, csstree_min)
	};
	var lib_1 = lib.version;
	var lib_2 = lib.minify;
	var lib_3 = lib.minifyBlock;
	var lib_4 = lib.syntax;

exports.default = lib;
	exports.minify = lib_2;
	exports.minifyBlock = lib_3;
	exports.syntax = lib_4;
	exports.version = lib_1;

Object.defineProperty(exports, '__esModule', { value: true });

})));