switch to vuepress

21 files changed, 2009 insertions, 0 deletions

diff --git a/node_modules/postcss-selector-parser/dist/index.js b/node_modules/postcss-selector-parser/dist/index.js
new file mode 100644
index 00000000..62400258
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/index.js
@@ -0,0 +1,114 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _processor = require('./processor');
+
+var _processor2 = _interopRequireDefault(_processor);
+
+var _attribute = require('./selectors/attribute');
+
+var _attribute2 = _interopRequireDefault(_attribute);
+
+var _className = require('./selectors/className');
+
+var _className2 = _interopRequireDefault(_className);
+
+var _combinator = require('./selectors/combinator');
+
+var _combinator2 = _interopRequireDefault(_combinator);
+
+var _comment = require('./selectors/comment');
+
+var _comment2 = _interopRequireDefault(_comment);
+
+var _id = require('./selectors/id');
+
+var _id2 = _interopRequireDefault(_id);
+
+var _nesting = require('./selectors/nesting');
+
+var _nesting2 = _interopRequireDefault(_nesting);
+
+var _pseudo = require('./selectors/pseudo');
+
+var _pseudo2 = _interopRequireDefault(_pseudo);
+
+var _root = require('./selectors/root');
+
+var _root2 = _interopRequireDefault(_root);
+
+var _selector = require('./selectors/selector');
+
+var _selector2 = _interopRequireDefault(_selector);
+
+var _string = require('./selectors/string');
+
+var _string2 = _interopRequireDefault(_string);
+
+var _tag = require('./selectors/tag');
+
+var _tag2 = _interopRequireDefault(_tag);
+
+var _universal = require('./selectors/universal');
+
+var _universal2 = _interopRequireDefault(_universal);
+
+var _types = require('./selectors/types');
+
+var types = _interopRequireWildcard(_types);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var parser = function parser(processor) {
+    return new _processor2.default(processor);
+};
+
+parser.attribute = function (opts) {
+    return new _attribute2.default(opts);
+};
+parser.className = function (opts) {
+    return new _className2.default(opts);
+};
+parser.combinator = function (opts) {
+    return new _combinator2.default(opts);
+};
+parser.comment = function (opts) {
+    return new _comment2.default(opts);
+};
+parser.id = function (opts) {
+    return new _id2.default(opts);
+};
+parser.nesting = function (opts) {
+    return new _nesting2.default(opts);
+};
+parser.pseudo = function (opts) {
+    return new _pseudo2.default(opts);
+};
+parser.root = function (opts) {
+    return new _root2.default(opts);
+};
+parser.selector = function (opts) {
+    return new _selector2.default(opts);
+};
+parser.string = function (opts) {
+    return new _string2.default(opts);
+};
+parser.tag = function (opts) {
+    return new _tag2.default(opts);
+};
+parser.universal = function (opts) {
+    return new _universal2.default(opts);
+};
+
+Object.keys(types).forEach(function (type) {
+    if (type === '__esModule') {
+        return;
+    }
+    parser[type] = types[type]; // eslint-disable-line
+});
+
+exports.default = parser;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/parser.js b/node_modules/postcss-selector-parser/dist/parser.js
new file mode 100644
index 00000000..18beadbb
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/parser.js
@@ -0,0 +1,643 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _flatten = require('flatten');
+
+var _flatten2 = _interopRequireDefault(_flatten);
+
+var _indexesOf = require('indexes-of');
+
+var _indexesOf2 = _interopRequireDefault(_indexesOf);
+
+var _uniq = require('uniq');
+
+var _uniq2 = _interopRequireDefault(_uniq);
+
+var _root = require('./selectors/root');
+
+var _root2 = _interopRequireDefault(_root);
+
+var _selector = require('./selectors/selector');
+
+var _selector2 = _interopRequireDefault(_selector);
+
+var _className = require('./selectors/className');
+
+var _className2 = _interopRequireDefault(_className);
+
+var _comment = require('./selectors/comment');
+
+var _comment2 = _interopRequireDefault(_comment);
+
+var _id = require('./selectors/id');
+
+var _id2 = _interopRequireDefault(_id);
+
+var _tag = require('./selectors/tag');
+
+var _tag2 = _interopRequireDefault(_tag);
+
+var _string = require('./selectors/string');
+
+var _string2 = _interopRequireDefault(_string);
+
+var _pseudo = require('./selectors/pseudo');
+
+var _pseudo2 = _interopRequireDefault(_pseudo);
+
+var _attribute = require('./selectors/attribute');
+
+var _attribute2 = _interopRequireDefault(_attribute);
+
+var _universal = require('./selectors/universal');
+
+var _universal2 = _interopRequireDefault(_universal);
+
+var _combinator = require('./selectors/combinator');
+
+var _combinator2 = _interopRequireDefault(_combinator);
+
+var _nesting = require('./selectors/nesting');
+
+var _nesting2 = _interopRequireDefault(_nesting);
+
+var _sortAscending = require('./sortAscending');
+
+var _sortAscending2 = _interopRequireDefault(_sortAscending);
+
+var _tokenize = require('./tokenize');
+
+var _tokenize2 = _interopRequireDefault(_tokenize);
+
+var _types = require('./selectors/types');
+
+var types = _interopRequireWildcard(_types);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var Parser = function () {
+    function Parser(input) {
+        _classCallCheck(this, Parser);
+
+        this.input = input;
+        this.lossy = input.options.lossless === false;
+        this.position = 0;
+        this.root = new _root2.default();
+
+        var selectors = new _selector2.default();
+        this.root.append(selectors);
+
+        this.current = selectors;
+        if (this.lossy) {
+            this.tokens = (0, _tokenize2.default)({ safe: input.safe, css: input.css.trim() });
+        } else {
+            this.tokens = (0, _tokenize2.default)(input);
+        }
+
+        return this.loop();
+    }
+
+    Parser.prototype.attribute = function attribute() {
+        var str = '';
+        var attr = void 0;
+        var startingToken = this.currToken;
+        this.position++;
+        while (this.position < this.tokens.length && this.currToken[0] !== ']') {
+            str += this.tokens[this.position][1];
+            this.position++;
+        }
+        if (this.position === this.tokens.length && !~str.indexOf(']')) {
+            this.error('Expected a closing square bracket.');
+        }
+        var parts = str.split(/((?:[*~^$|]?=))([^]*)/);
+        var namespace = parts[0].split(/(\|)/g);
+        var attributeProps = {
+            operator: parts[1],
+            value: parts[2],
+            source: {
+                start: {
+                    line: startingToken[2],
+                    column: startingToken[3]
+                },
+                end: {
+                    line: this.currToken[2],
+                    column: this.currToken[3]
+                }
+            },
+            sourceIndex: startingToken[4]
+        };
+        if (namespace.length > 1) {
+            if (namespace[0] === '') {
+                namespace[0] = true;
+            }
+            attributeProps.attribute = this.parseValue(namespace[2]);
+            attributeProps.namespace = this.parseNamespace(namespace[0]);
+        } else {
+            attributeProps.attribute = this.parseValue(parts[0]);
+        }
+        attr = new _attribute2.default(attributeProps);
+
+        if (parts[2]) {
+            var insensitive = parts[2].split(/(\s+i\s*?)$/);
+            var trimmedValue = insensitive[0].trim();
+            attr.value = this.lossy ? trimmedValue : insensitive[0];
+            if (insensitive[1]) {
+                attr.insensitive = true;
+                if (!this.lossy) {
+                    attr.raws.insensitive = insensitive[1];
+                }
+            }
+            attr.quoted = trimmedValue[0] === '\'' || trimmedValue[0] === '"';
+            attr.raws.unquoted = attr.quoted ? trimmedValue.slice(1, -1) : trimmedValue;
+        }
+        this.newNode(attr);
+        this.position++;
+    };
+
+    Parser.prototype.combinator = function combinator() {
+        if (this.currToken[1] === '|') {
+            return this.namespace();
+        }
+        var node = new _combinator2.default({
+            value: '',
+            source: {
+                start: {
+                    line: this.currToken[2],
+                    column: this.currToken[3]
+                },
+                end: {
+                    line: this.currToken[2],
+                    column: this.currToken[3]
+                }
+            },
+            sourceIndex: this.currToken[4]
+        });
+        while (this.position < this.tokens.length && this.currToken && (this.currToken[0] === 'space' || this.currToken[0] === 'combinator')) {
+            if (this.nextToken && this.nextToken[0] === 'combinator') {
+                node.spaces.before = this.parseSpace(this.currToken[1]);
+                node.source.start.line = this.nextToken[2];
+                node.source.start.column = this.nextToken[3];
+                node.source.end.column = this.nextToken[3];
+                node.source.end.line = this.nextToken[2];
+                node.sourceIndex = this.nextToken[4];
+            } else if (this.prevToken && this.prevToken[0] === 'combinator') {
+                node.spaces.after = this.parseSpace(this.currToken[1]);
+            } else if (this.currToken[0] === 'combinator') {
+                node.value = this.currToken[1];
+            } else if (this.currToken[0] === 'space') {
+                node.value = this.parseSpace(this.currToken[1], ' ');
+            }
+            this.position++;
+        }
+        return this.newNode(node);
+    };
+
+    Parser.prototype.comma = function comma() {
+        if (this.position === this.tokens.length - 1) {
+            this.root.trailingComma = true;
+            this.position++;
+            return;
+        }
+        var selectors = new _selector2.default();
+        this.current.parent.append(selectors);
+        this.current = selectors;
+        this.position++;
+    };
+
+    Parser.prototype.comment = function comment() {
+        var node = new _comment2.default({
+            value: this.currToken[1],
+            source: {
+                start: {
+                    line: this.currToken[2],
+                    column: this.currToken[3]
+                },
+                end: {
+                    line: this.currToken[4],
+                    column: this.currToken[5]
+                }
+            },
+            sourceIndex: this.currToken[6]
+        });
+        this.newNode(node);
+        this.position++;
+    };
+
+    Parser.prototype.error = function error(message) {
+        throw new this.input.error(message); // eslint-disable-line new-cap
+    };
+
+    Parser.prototype.missingBackslash = function missingBackslash() {
+        return this.error('Expected a backslash preceding the semicolon.');
+    };
+
+    Parser.prototype.missingParenthesis = function missingParenthesis() {
+        return this.error('Expected opening parenthesis.');
+    };
+
+    Parser.prototype.missingSquareBracket = function missingSquareBracket() {
+        return this.error('Expected opening square bracket.');
+    };
+
+    Parser.prototype.namespace = function namespace() {
+        var before = this.prevToken && this.prevToken[1] || true;
+        if (this.nextToken[0] === 'word') {
+            this.position++;
+            return this.word(before);
+        } else if (this.nextToken[0] === '*') {
+            this.position++;
+            return this.universal(before);
+        }
+    };
+
+    Parser.prototype.nesting = function nesting() {
+        this.newNode(new _nesting2.default({
+            value: this.currToken[1],
+            source: {
+                start: {
+                    line: this.currToken[2],
+                    column: this.currToken[3]
+                },
+                end: {
+                    line: this.currToken[2],
+                    column: this.currToken[3]
+                }
+            },
+            sourceIndex: this.currToken[4]
+        }));
+        this.position++;
+    };
+
+    Parser.prototype.parentheses = function parentheses() {
+        var last = this.current.last;
+        if (last && last.type === types.PSEUDO) {
+            var selector = new _selector2.default();
+            var cache = this.current;
+            last.append(selector);
+            this.current = selector;
+            var balanced = 1;
+            this.position++;
+            while (this.position < this.tokens.length && balanced) {
+                if (this.currToken[0] === '(') {
+                    balanced++;
+                }
+                if (this.currToken[0] === ')') {
+                    balanced--;
+                }
+                if (balanced) {
+                    this.parse();
+                } else {
+                    selector.parent.source.end.line = this.currToken[2];
+                    selector.parent.source.end.column = this.currToken[3];
+                    this.position++;
+                }
+            }
+            if (balanced) {
+                this.error('Expected closing parenthesis.');
+            }
+            this.current = cache;
+        } else {
+            var _balanced = 1;
+            this.position++;
+            last.value += '(';
+            while (this.position < this.tokens.length && _balanced) {
+                if (this.currToken[0] === '(') {
+                    _balanced++;
+                }
+                if (this.currToken[0] === ')') {
+                    _balanced--;
+                }
+                last.value += this.parseParenthesisToken(this.currToken);
+                this.position++;
+            }
+            if (_balanced) {
+                this.error('Expected closing parenthesis.');
+            }
+        }
+    };
+
+    Parser.prototype.pseudo = function pseudo() {
+        var _this = this;
+
+        var pseudoStr = '';
+        var startingToken = this.currToken;
+        while (this.currToken && this.currToken[0] === ':') {
+            pseudoStr += this.currToken[1];
+            this.position++;
+        }
+        if (!this.currToken) {
+            return this.error('Expected pseudo-class or pseudo-element');
+        }
+        if (this.currToken[0] === 'word') {
+            var pseudo = void 0;
+            this.splitWord(false, function (first, length) {
+                pseudoStr += first;
+                pseudo = new _pseudo2.default({
+                    value: pseudoStr,
+                    source: {
+                        start: {
+                            line: startingToken[2],
+                            column: startingToken[3]
+                        },
+                        end: {
+                            line: _this.currToken[4],
+                            column: _this.currToken[5]
+                        }
+                    },
+                    sourceIndex: startingToken[4]
+                });
+                _this.newNode(pseudo);
+                if (length > 1 && _this.nextToken && _this.nextToken[0] === '(') {
+                    _this.error('Misplaced parenthesis.');
+                }
+            });
+        } else {
+            this.error('Unexpected "' + this.currToken[0] + '" found.');
+        }
+    };
+
+    Parser.prototype.space = function space() {
+        var token = this.currToken;
+        // Handle space before and after the selector
+        if (this.position === 0 || this.prevToken[0] === ',' || this.prevToken[0] === '(') {
+            this.spaces = this.parseSpace(token[1]);
+            this.position++;
+        } else if (this.position === this.tokens.length - 1 || this.nextToken[0] === ',' || this.nextToken[0] === ')') {
+            this.current.last.spaces.after = this.parseSpace(token[1]);
+            this.position++;
+        } else {
+            this.combinator();
+        }
+    };
+
+    Parser.prototype.string = function string() {
+        var token = this.currToken;
+        this.newNode(new _string2.default({
+            value: this.currToken[1],
+            source: {
+                start: {
+                    line: token[2],
+                    column: token[3]
+                },
+                end: {
+                    line: token[4],
+                    column: token[5]
+                }
+            },
+            sourceIndex: token[6]
+        }));
+        this.position++;
+    };
+
+    Parser.prototype.universal = function universal(namespace) {
+        var nextToken = this.nextToken;
+        if (nextToken && nextToken[1] === '|') {
+            this.position++;
+            return this.namespace();
+        }
+        this.newNode(new _universal2.default({
+            value: this.currToken[1],
+            source: {
+                start: {
+                    line: this.currToken[2],
+                    column: this.currToken[3]
+                },
+                end: {
+                    line: this.currToken[2],
+                    column: this.currToken[3]
+                }
+            },
+            sourceIndex: this.currToken[4]
+        }), namespace);
+        this.position++;
+    };
+
+    Parser.prototype.splitWord = function splitWord(namespace, firstCallback) {
+        var _this2 = this;
+
+        var nextToken = this.nextToken;
+        var word = this.currToken[1];
+        while (nextToken && nextToken[0] === 'word') {
+            this.position++;
+            var current = this.currToken[1];
+            word += current;
+            if (current.lastIndexOf('\\') === current.length - 1) {
+                var next = this.nextToken;
+                if (next && next[0] === 'space') {
+                    word += this.parseSpace(next[1], ' ');
+                    this.position++;
+                }
+            }
+            nextToken = this.nextToken;
+        }
+        var hasClass = (0, _indexesOf2.default)(word, '.');
+        var hasId = (0, _indexesOf2.default)(word, '#');
+        // Eliminate Sass interpolations from the list of id indexes
+        var interpolations = (0, _indexesOf2.default)(word, '#{');
+        if (interpolations.length) {
+            hasId = hasId.filter(function (hashIndex) {
+                return !~interpolations.indexOf(hashIndex);
+            });
+        }
+        var indices = (0, _sortAscending2.default)((0, _uniq2.default)((0, _flatten2.default)([[0], hasClass, hasId])));
+        indices.forEach(function (ind, i) {
+            var index = indices[i + 1] || word.length;
+            var value = word.slice(ind, index);
+            if (i === 0 && firstCallback) {
+                return firstCallback.call(_this2, value, indices.length);
+            }
+            var node = void 0;
+            if (~hasClass.indexOf(ind)) {
+                node = new _className2.default({
+                    value: value.slice(1),
+                    source: {
+                        start: {
+                            line: _this2.currToken[2],
+                            column: _this2.currToken[3] + ind
+                        },
+                        end: {
+                            line: _this2.currToken[4],
+                            column: _this2.currToken[3] + (index - 1)
+                        }
+                    },
+                    sourceIndex: _this2.currToken[6] + indices[i]
+                });
+            } else if (~hasId.indexOf(ind)) {
+                node = new _id2.default({
+                    value: value.slice(1),
+                    source: {
+                        start: {
+                            line: _this2.currToken[2],
+                            column: _this2.currToken[3] + ind
+                        },
+                        end: {
+                            line: _this2.currToken[4],
+                            column: _this2.currToken[3] + (index - 1)
+                        }
+                    },
+                    sourceIndex: _this2.currToken[6] + indices[i]
+                });
+            } else {
+                node = new _tag2.default({
+                    value: value,
+                    source: {
+                        start: {
+                            line: _this2.currToken[2],
+                            column: _this2.currToken[3] + ind
+                        },
+                        end: {
+                            line: _this2.currToken[4],
+                            column: _this2.currToken[3] + (index - 1)
+                        }
+                    },
+                    sourceIndex: _this2.currToken[6] + indices[i]
+                });
+            }
+            _this2.newNode(node, namespace);
+        });
+        this.position++;
+    };
+
+    Parser.prototype.word = function word(namespace) {
+        var nextToken = this.nextToken;
+        if (nextToken && nextToken[1] === '|') {
+            this.position++;
+            return this.namespace();
+        }
+        return this.splitWord(namespace);
+    };
+
+    Parser.prototype.loop = function loop() {
+        while (this.position < this.tokens.length) {
+            this.parse(true);
+        }
+        return this.root;
+    };
+
+    Parser.prototype.parse = function parse(throwOnParenthesis) {
+        switch (this.currToken[0]) {
+            case 'space':
+                this.space();
+                break;
+            case 'comment':
+                this.comment();
+                break;
+            case '(':
+                this.parentheses();
+                break;
+            case ')':
+                if (throwOnParenthesis) {
+                    this.missingParenthesis();
+                }
+                break;
+            case '[':
+                this.attribute();
+                break;
+            case ']':
+                this.missingSquareBracket();
+                break;
+            case 'at-word':
+            case 'word':
+                this.word();
+                break;
+            case ':':
+                this.pseudo();
+                break;
+            case ';':
+                this.missingBackslash();
+                break;
+            case ',':
+                this.comma();
+                break;
+            case '*':
+                this.universal();
+                break;
+            case '&':
+                this.nesting();
+                break;
+            case 'combinator':
+                this.combinator();
+                break;
+            case 'string':
+                this.string();
+                break;
+        }
+    };
+
+    /**
+     * Helpers
+     */
+
+    Parser.prototype.parseNamespace = function parseNamespace(namespace) {
+        if (this.lossy && typeof namespace === 'string') {
+            var trimmed = namespace.trim();
+            if (!trimmed.length) {
+                return true;
+            }
+
+            return trimmed;
+        }
+
+        return namespace;
+    };
+
+    Parser.prototype.parseSpace = function parseSpace(space, replacement) {
+        return this.lossy ? replacement || '' : space;
+    };
+
+    Parser.prototype.parseValue = function parseValue(value) {
+        return this.lossy && value && typeof value === 'string' ? value.trim() : value;
+    };
+
+    Parser.prototype.parseParenthesisToken = function parseParenthesisToken(token) {
+        if (!this.lossy) {
+            return token[1];
+        }
+
+        if (token[0] === 'space') {
+            return this.parseSpace(token[1], ' ');
+        }
+
+        return this.parseValue(token[1]);
+    };
+
+    Parser.prototype.newNode = function newNode(node, namespace) {
+        if (namespace) {
+            node.namespace = this.parseNamespace(namespace);
+        }
+        if (this.spaces) {
+            node.spaces.before = this.spaces;
+            this.spaces = '';
+        }
+        return this.current.append(node);
+    };
+
+    _createClass(Parser, [{
+        key: 'currToken',
+        get: function get() {
+            return this.tokens[this.position];
+        }
+    }, {
+        key: 'nextToken',
+        get: function get() {
+            return this.tokens[this.position + 1];
+        }
+    }, {
+        key: 'prevToken',
+        get: function get() {
+            return this.tokens[this.position - 1];
+        }
+    }]);
+
+    return Parser;
+}();
+
+exports.default = Parser;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/processor.js b/node_modules/postcss-selector-parser/dist/processor.js
new file mode 100644
index 00000000..087618ce
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/processor.js
@@ -0,0 +1,49 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _parser = require('./parser');
+
+var _parser2 = _interopRequireDefault(_parser);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var Processor = function () {
+    function Processor(func) {
+        _classCallCheck(this, Processor);
+
+        this.func = func || function noop() {};
+        return this;
+    }
+
+    Processor.prototype.process = function process(selectors) {
+        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+        var input = new _parser2.default({
+            css: selectors,
+            error: function error(e) {
+                throw new Error(e);
+            },
+            options: options
+        });
+        this.res = input;
+        this.func(input);
+        return this;
+    };
+
+    _createClass(Processor, [{
+        key: 'result',
+        get: function get() {
+            return String(this.res);
+        }
+    }]);
+
+    return Processor;
+}();
+
+exports.default = Processor;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/attribute.js b/node_modules/postcss-selector-parser/dist/selectors/attribute.js
new file mode 100644
index 00000000..4ea74c12
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/attribute.js
@@ -0,0 +1,54 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _namespace = require('./namespace');
+
+var _namespace2 = _interopRequireDefault(_namespace);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Attribute = function (_Namespace) {
+    _inherits(Attribute, _Namespace);
+
+    function Attribute(opts) {
+        _classCallCheck(this, Attribute);
+
+        var _this = _possibleConstructorReturn(this, _Namespace.call(this, opts));
+
+        _this.type = _types.ATTRIBUTE;
+        _this.raws = {};
+        return _this;
+    }
+
+    Attribute.prototype.toString = function toString() {
+        var selector = [this.spaces.before, '[', this.ns, this.attribute];
+
+        if (this.operator) {
+            selector.push(this.operator);
+        }
+        if (this.value) {
+            selector.push(this.value);
+        }
+        if (this.raws.insensitive) {
+            selector.push(this.raws.insensitive);
+        } else if (this.insensitive) {
+            selector.push(' i');
+        }
+        selector.push(']');
+        return selector.concat(this.spaces.after).join('');
+    };
+
+    return Attribute;
+}(_namespace2.default);
+
+exports.default = Attribute;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/className.js b/node_modules/postcss-selector-parser/dist/selectors/className.js
new file mode 100644
index 00000000..d7bff16b
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/className.js
@@ -0,0 +1,39 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _namespace = require('./namespace');
+
+var _namespace2 = _interopRequireDefault(_namespace);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var ClassName = function (_Namespace) {
+    _inherits(ClassName, _Namespace);
+
+    function ClassName(opts) {
+        _classCallCheck(this, ClassName);
+
+        var _this = _possibleConstructorReturn(this, _Namespace.call(this, opts));
+
+        _this.type = _types.CLASS;
+        return _this;
+    }
+
+    ClassName.prototype.toString = function toString() {
+        return [this.spaces.before, this.ns, String('.' + this.value), this.spaces.after].join('');
+    };
+
+    return ClassName;
+}(_namespace2.default);
+
+exports.default = ClassName;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/combinator.js b/node_modules/postcss-selector-parser/dist/selectors/combinator.js
new file mode 100644
index 00000000..673dc750
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/combinator.js
@@ -0,0 +1,35 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _node = require('./node');
+
+var _node2 = _interopRequireDefault(_node);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Combinator = function (_Node) {
+    _inherits(Combinator, _Node);
+
+    function Combinator(opts) {
+        _classCallCheck(this, Combinator);
+
+        var _this = _possibleConstructorReturn(this, _Node.call(this, opts));
+
+        _this.type = _types.COMBINATOR;
+        return _this;
+    }
+
+    return Combinator;
+}(_node2.default);
+
+exports.default = Combinator;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/comment.js b/node_modules/postcss-selector-parser/dist/selectors/comment.js
new file mode 100644
index 00000000..6d96556e
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/comment.js
@@ -0,0 +1,35 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _node = require('./node');
+
+var _node2 = _interopRequireDefault(_node);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Comment = function (_Node) {
+    _inherits(Comment, _Node);
+
+    function Comment(opts) {
+        _classCallCheck(this, Comment);
+
+        var _this = _possibleConstructorReturn(this, _Node.call(this, opts));
+
+        _this.type = _types.COMMENT;
+        return _this;
+    }
+
+    return Comment;
+}(_node2.default);
+
+exports.default = Comment;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/container.js b/node_modules/postcss-selector-parser/dist/selectors/container.js
new file mode 100644
index 00000000..bc9ec00c
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/container.js
@@ -0,0 +1,338 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _node = require('./node');
+
+var _node2 = _interopRequireDefault(_node);
+
+var _types = require('./types');
+
+var types = _interopRequireWildcard(_types);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Container = function (_Node) {
+    _inherits(Container, _Node);
+
+    function Container(opts) {
+        _classCallCheck(this, Container);
+
+        var _this = _possibleConstructorReturn(this, _Node.call(this, opts));
+
+        if (!_this.nodes) {
+            _this.nodes = [];
+        }
+        return _this;
+    }
+
+    Container.prototype.append = function append(selector) {
+        selector.parent = this;
+        this.nodes.push(selector);
+        return this;
+    };
+
+    Container.prototype.prepend = function prepend(selector) {
+        selector.parent = this;
+        this.nodes.unshift(selector);
+        return this;
+    };
+
+    Container.prototype.at = function at(index) {
+        return this.nodes[index];
+    };
+
+    Container.prototype.index = function index(child) {
+        if (typeof child === 'number') {
+            return child;
+        }
+        return this.nodes.indexOf(child);
+    };
+
+    Container.prototype.removeChild = function removeChild(child) {
+        child = this.index(child);
+        this.at(child).parent = undefined;
+        this.nodes.splice(child, 1);
+
+        var index = void 0;
+        for (var id in this.indexes) {
+            index = this.indexes[id];
+            if (index >= child) {
+                this.indexes[id] = index - 1;
+            }
+        }
+
+        return this;
+    };
+
+    Container.prototype.removeAll = function removeAll() {
+        for (var _iterator = this.nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+            var _ref;
+
+            if (_isArray) {
+                if (_i >= _iterator.length) break;
+                _ref = _iterator[_i++];
+            } else {
+                _i = _iterator.next();
+                if (_i.done) break;
+                _ref = _i.value;
+            }
+
+            var node = _ref;
+
+            node.parent = undefined;
+        }
+        this.nodes = [];
+        return this;
+    };
+
+    Container.prototype.empty = function empty() {
+        return this.removeAll();
+    };
+
+    Container.prototype.insertAfter = function insertAfter(oldNode, newNode) {
+        var oldIndex = this.index(oldNode);
+        this.nodes.splice(oldIndex + 1, 0, newNode);
+
+        var index = void 0;
+        for (var id in this.indexes) {
+            index = this.indexes[id];
+            if (oldIndex <= index) {
+                this.indexes[id] = index + this.nodes.length;
+            }
+        }
+
+        return this;
+    };
+
+    Container.prototype.insertBefore = function insertBefore(oldNode, newNode) {
+        var oldIndex = this.index(oldNode);
+        this.nodes.splice(oldIndex, 0, newNode);
+
+        var index = void 0;
+        for (var id in this.indexes) {
+            index = this.indexes[id];
+            if (oldIndex <= index) {
+                this.indexes[id] = index + this.nodes.length;
+            }
+        }
+
+        return this;
+    };
+
+    Container.prototype.each = function each(callback) {
+        if (!this.lastEach) {
+            this.lastEach = 0;
+        }
+        if (!this.indexes) {
+            this.indexes = {};
+        }
+
+        this.lastEach++;
+        var id = this.lastEach;
+        this.indexes[id] = 0;
+
+        if (!this.length) {
+            return undefined;
+        }
+
+        var index = void 0,
+            result = void 0;
+        while (this.indexes[id] < this.length) {
+            index = this.indexes[id];
+            result = callback(this.at(index), index);
+            if (result === false) {
+                break;
+            }
+
+            this.indexes[id] += 1;
+        }
+
+        delete this.indexes[id];
+
+        if (result === false) {
+            return false;
+        }
+    };
+
+    Container.prototype.walk = function walk(callback) {
+        return this.each(function (node, i) {
+            var result = callback(node, i);
+
+            if (result !== false && node.length) {
+                result = node.walk(callback);
+            }
+
+            if (result === false) {
+                return false;
+            }
+        });
+    };
+
+    Container.prototype.walkAttributes = function walkAttributes(callback) {
+        var _this2 = this;
+
+        return this.walk(function (selector) {
+            if (selector.type === types.ATTRIBUTE) {
+                return callback.call(_this2, selector);
+            }
+        });
+    };
+
+    Container.prototype.walkClasses = function walkClasses(callback) {
+        var _this3 = this;
+
+        return this.walk(function (selector) {
+            if (selector.type === types.CLASS) {
+                return callback.call(_this3, selector);
+            }
+        });
+    };
+
+    Container.prototype.walkCombinators = function walkCombinators(callback) {
+        var _this4 = this;
+
+        return this.walk(function (selector) {
+            if (selector.type === types.COMBINATOR) {
+                return callback.call(_this4, selector);
+            }
+        });
+    };
+
+    Container.prototype.walkComments = function walkComments(callback) {
+        var _this5 = this;
+
+        return this.walk(function (selector) {
+            if (selector.type === types.COMMENT) {
+                return callback.call(_this5, selector);
+            }
+        });
+    };
+
+    Container.prototype.walkIds = function walkIds(callback) {
+        var _this6 = this;
+
+        return this.walk(function (selector) {
+            if (selector.type === types.ID) {
+                return callback.call(_this6, selector);
+            }
+        });
+    };
+
+    Container.prototype.walkNesting = function walkNesting(callback) {
+        var _this7 = this;
+
+        return this.walk(function (selector) {
+            if (selector.type === types.NESTING) {
+                return callback.call(_this7, selector);
+            }
+        });
+    };
+
+    Container.prototype.walkPseudos = function walkPseudos(callback) {
+        var _this8 = this;
+
+        return this.walk(function (selector) {
+            if (selector.type === types.PSEUDO) {
+                return callback.call(_this8, selector);
+            }
+        });
+    };
+
+    Container.prototype.walkTags = function walkTags(callback) {
+        var _this9 = this;
+
+        return this.walk(function (selector) {
+            if (selector.type === types.TAG) {
+                return callback.call(_this9, selector);
+            }
+        });
+    };
+
+    Container.prototype.walkUniversals = function walkUniversals(callback) {
+        var _this10 = this;
+
+        return this.walk(function (selector) {
+            if (selector.type === types.UNIVERSAL) {
+                return callback.call(_this10, selector);
+            }
+        });
+    };
+
+    Container.prototype.split = function split(callback) {
+        var _this11 = this;
+
+        var current = [];
+        return this.reduce(function (memo, node, index) {
+            var split = callback.call(_this11, node);
+            current.push(node);
+            if (split) {
+                memo.push(current);
+                current = [];
+            } else if (index === _this11.length - 1) {
+                memo.push(current);
+            }
+            return memo;
+        }, []);
+    };
+
+    Container.prototype.map = function map(callback) {
+        return this.nodes.map(callback);
+    };
+
+    Container.prototype.reduce = function reduce(callback, memo) {
+        return this.nodes.reduce(callback, memo);
+    };
+
+    Container.prototype.every = function every(callback) {
+        return this.nodes.every(callback);
+    };
+
+    Container.prototype.some = function some(callback) {
+        return this.nodes.some(callback);
+    };
+
+    Container.prototype.filter = function filter(callback) {
+        return this.nodes.filter(callback);
+    };
+
+    Container.prototype.sort = function sort(callback) {
+        return this.nodes.sort(callback);
+    };
+
+    Container.prototype.toString = function toString() {
+        return this.map(String).join('');
+    };
+
+    _createClass(Container, [{
+        key: 'first',
+        get: function get() {
+            return this.at(0);
+        }
+    }, {
+        key: 'last',
+        get: function get() {
+            return this.at(this.length - 1);
+        }
+    }, {
+        key: 'length',
+        get: function get() {
+            return this.nodes.length;
+        }
+    }]);
+
+    return Container;
+}(_node2.default);
+
+exports.default = Container;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/id.js b/node_modules/postcss-selector-parser/dist/selectors/id.js
new file mode 100644
index 00000000..4538dcf8
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/id.js
@@ -0,0 +1,39 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _namespace = require('./namespace');
+
+var _namespace2 = _interopRequireDefault(_namespace);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var ID = function (_Namespace) {
+    _inherits(ID, _Namespace);
+
+    function ID(opts) {
+        _classCallCheck(this, ID);
+
+        var _this = _possibleConstructorReturn(this, _Namespace.call(this, opts));
+
+        _this.type = _types.ID;
+        return _this;
+    }
+
+    ID.prototype.toString = function toString() {
+        return [this.spaces.before, this.ns, String('#' + this.value), this.spaces.after].join('');
+    };
+
+    return ID;
+}(_namespace2.default);
+
+exports.default = ID;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/namespace.js b/node_modules/postcss-selector-parser/dist/selectors/namespace.js
new file mode 100644
index 00000000..5121b2d4
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/namespace.js
@@ -0,0 +1,45 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _node = require('./node');
+
+var _node2 = _interopRequireDefault(_node);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Namespace = function (_Node) {
+    _inherits(Namespace, _Node);
+
+    function Namespace() {
+        _classCallCheck(this, Namespace);
+
+        return _possibleConstructorReturn(this, _Node.apply(this, arguments));
+    }
+
+    Namespace.prototype.toString = function toString() {
+        return [this.spaces.before, this.ns, String(this.value), this.spaces.after].join('');
+    };
+
+    _createClass(Namespace, [{
+        key: 'ns',
+        get: function get() {
+            var n = this.namespace;
+            return n ? (typeof n === 'string' ? n : '') + '|' : '';
+        }
+    }]);
+
+    return Namespace;
+}(_node2.default);
+
+exports.default = Namespace;
+;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/nesting.js b/node_modules/postcss-selector-parser/dist/selectors/nesting.js
new file mode 100644
index 00000000..c3264b07
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/nesting.js
@@ -0,0 +1,36 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _node = require('./node');
+
+var _node2 = _interopRequireDefault(_node);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Nesting = function (_Node) {
+    _inherits(Nesting, _Node);
+
+    function Nesting(opts) {
+        _classCallCheck(this, Nesting);
+
+        var _this = _possibleConstructorReturn(this, _Node.call(this, opts));
+
+        _this.type = _types.NESTING;
+        _this.value = '&';
+        return _this;
+    }
+
+    return Nesting;
+}(_node2.default);
+
+exports.default = Nesting;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/node.js b/node_modules/postcss-selector-parser/dist/selectors/node.js
new file mode 100644
index 00000000..30f45fd4
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/node.js
@@ -0,0 +1,102 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var cloneNode = function cloneNode(obj, parent) {
+    if ((typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) !== 'object') {
+        return obj;
+    }
+
+    var cloned = new obj.constructor();
+
+    for (var i in obj) {
+        if (!obj.hasOwnProperty(i)) {
+            continue;
+        }
+        var value = obj[i];
+        var type = typeof value === 'undefined' ? 'undefined' : _typeof(value);
+
+        if (i === 'parent' && type === 'object') {
+            if (parent) {
+                cloned[i] = parent;
+            }
+        } else if (value instanceof Array) {
+            cloned[i] = value.map(function (j) {
+                return cloneNode(j, cloned);
+            });
+        } else {
+            cloned[i] = cloneNode(value, cloned);
+        }
+    }
+
+    return cloned;
+};
+
+var _class = function () {
+    function _class() {
+        var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+        _classCallCheck(this, _class);
+
+        for (var key in opts) {
+            this[key] = opts[key];
+        }
+        var _opts$spaces = opts.spaces;
+        _opts$spaces = _opts$spaces === undefined ? {} : _opts$spaces;
+        var _opts$spaces$before = _opts$spaces.before,
+            before = _opts$spaces$before === undefined ? '' : _opts$spaces$before,
+            _opts$spaces$after = _opts$spaces.after,
+            after = _opts$spaces$after === undefined ? '' : _opts$spaces$after;
+
+        this.spaces = { before: before, after: after };
+    }
+
+    _class.prototype.remove = function remove() {
+        if (this.parent) {
+            this.parent.removeChild(this);
+        }
+        this.parent = undefined;
+        return this;
+    };
+
+    _class.prototype.replaceWith = function replaceWith() {
+        if (this.parent) {
+            for (var index in arguments) {
+                this.parent.insertBefore(this, arguments[index]);
+            }
+            this.remove();
+        }
+        return this;
+    };
+
+    _class.prototype.next = function next() {
+        return this.parent.at(this.parent.index(this) + 1);
+    };
+
+    _class.prototype.prev = function prev() {
+        return this.parent.at(this.parent.index(this) - 1);
+    };
+
+    _class.prototype.clone = function clone() {
+        var overrides = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+        var cloned = cloneNode(this);
+        for (var name in overrides) {
+            cloned[name] = overrides[name];
+        }
+        return cloned;
+    };
+
+    _class.prototype.toString = function toString() {
+        return [this.spaces.before, String(this.value), this.spaces.after].join('');
+    };
+
+    return _class;
+}();
+
+exports.default = _class;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/pseudo.js b/node_modules/postcss-selector-parser/dist/selectors/pseudo.js
new file mode 100644
index 00000000..709cc224
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/pseudo.js
@@ -0,0 +1,40 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _container = require('./container');
+
+var _container2 = _interopRequireDefault(_container);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Pseudo = function (_Container) {
+    _inherits(Pseudo, _Container);
+
+    function Pseudo(opts) {
+        _classCallCheck(this, Pseudo);
+
+        var _this = _possibleConstructorReturn(this, _Container.call(this, opts));
+
+        _this.type = _types.PSEUDO;
+        return _this;
+    }
+
+    Pseudo.prototype.toString = function toString() {
+        var params = this.length ? '(' + this.map(String).join(',') + ')' : '';
+        return [this.spaces.before, String(this.value), params, this.spaces.after].join('');
+    };
+
+    return Pseudo;
+}(_container2.default);
+
+exports.default = Pseudo;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/root.js b/node_modules/postcss-selector-parser/dist/selectors/root.js
new file mode 100644
index 00000000..d8865b5b
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/root.js
@@ -0,0 +1,43 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _container = require('./container');
+
+var _container2 = _interopRequireDefault(_container);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Root = function (_Container) {
+    _inherits(Root, _Container);
+
+    function Root(opts) {
+        _classCallCheck(this, Root);
+
+        var _this = _possibleConstructorReturn(this, _Container.call(this, opts));
+
+        _this.type = _types.ROOT;
+        return _this;
+    }
+
+    Root.prototype.toString = function toString() {
+        var str = this.reduce(function (memo, selector) {
+            var sel = String(selector);
+            return sel ? memo + sel + ',' : '';
+        }, '').slice(0, -1);
+        return this.trailingComma ? str + ',' : str;
+    };
+
+    return Root;
+}(_container2.default);
+
+exports.default = Root;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/selector.js b/node_modules/postcss-selector-parser/dist/selectors/selector.js
new file mode 100644
index 00000000..e2187662
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/selector.js
@@ -0,0 +1,35 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _container = require('./container');
+
+var _container2 = _interopRequireDefault(_container);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Selector = function (_Container) {
+    _inherits(Selector, _Container);
+
+    function Selector(opts) {
+        _classCallCheck(this, Selector);
+
+        var _this = _possibleConstructorReturn(this, _Container.call(this, opts));
+
+        _this.type = _types.SELECTOR;
+        return _this;
+    }
+
+    return Selector;
+}(_container2.default);
+
+exports.default = Selector;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/string.js b/node_modules/postcss-selector-parser/dist/selectors/string.js
new file mode 100644
index 00000000..d644e7d1
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/string.js
@@ -0,0 +1,35 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _node = require('./node');
+
+var _node2 = _interopRequireDefault(_node);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var String = function (_Node) {
+    _inherits(String, _Node);
+
+    function String(opts) {
+        _classCallCheck(this, String);
+
+        var _this = _possibleConstructorReturn(this, _Node.call(this, opts));
+
+        _this.type = _types.STRING;
+        return _this;
+    }
+
+    return String;
+}(_node2.default);
+
+exports.default = String;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/tag.js b/node_modules/postcss-selector-parser/dist/selectors/tag.js
new file mode 100644
index 00000000..a1f2848a
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/tag.js
@@ -0,0 +1,35 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _namespace = require('./namespace');
+
+var _namespace2 = _interopRequireDefault(_namespace);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Tag = function (_Namespace) {
+    _inherits(Tag, _Namespace);
+
+    function Tag(opts) {
+        _classCallCheck(this, Tag);
+
+        var _this = _possibleConstructorReturn(this, _Namespace.call(this, opts));
+
+        _this.type = _types.TAG;
+        return _this;
+    }
+
+    return Tag;
+}(_namespace2.default);
+
+exports.default = Tag;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/types.js b/node_modules/postcss-selector-parser/dist/selectors/types.js
new file mode 100644
index 00000000..aa73ac9a
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/types.js
@@ -0,0 +1,15 @@
+'use strict';
+
+exports.__esModule = true;
+var TAG = exports.TAG = 'tag';
+var STRING = exports.STRING = 'string';
+var SELECTOR = exports.SELECTOR = 'selector';
+var ROOT = exports.ROOT = 'root';
+var PSEUDO = exports.PSEUDO = 'pseudo';
+var NESTING = exports.NESTING = 'nesting';
+var ID = exports.ID = 'id';
+var COMMENT = exports.COMMENT = 'comment';
+var COMBINATOR = exports.COMBINATOR = 'combinator';
+var CLASS = exports.CLASS = 'class';
+var ATTRIBUTE = exports.ATTRIBUTE = 'attribute';
+var UNIVERSAL = exports.UNIVERSAL = 'universal';
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/universal.js b/node_modules/postcss-selector-parser/dist/selectors/universal.js
new file mode 100644
index 00000000..f4a35ff5
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/universal.js
@@ -0,0 +1,36 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _namespace = require('./namespace');
+
+var _namespace2 = _interopRequireDefault(_namespace);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Universal = function (_Namespace) {
+    _inherits(Universal, _Namespace);
+
+    function Universal(opts) {
+        _classCallCheck(this, Universal);
+
+        var _this = _possibleConstructorReturn(this, _Namespace.call(this, opts));
+
+        _this.type = _types.UNIVERSAL;
+        _this.value = '*';
+        return _this;
+    }
+
+    return Universal;
+}(_namespace2.default);
+
+exports.default = Universal;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/sortAscending.js b/node_modules/postcss-selector-parser/dist/sortAscending.js
new file mode 100644
index 00000000..17a2eb4e
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/sortAscending.js
@@ -0,0 +1,10 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = sortAscending;
+function sortAscending(list) {
+    return list.sort(function (a, b) {
+        return a - b;
+    });
+};
+module.exports = exports["default"];
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/tokenize.js b/node_modules/postcss-selector-parser/dist/tokenize.js
new file mode 100644
index 00000000..acc73b05
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/tokenize.js
@@ -0,0 +1,231 @@
+'use strict';
+
+exports.__esModule = true;
+exports.default = tokenize;
+var singleQuote = 39,
+    doubleQuote = 34,
+    backslash = 92,
+    slash = 47,
+    newline = 10,
+    space = 32,
+    feed = 12,
+    tab = 9,
+    cr = 13,
+    plus = 43,
+    gt = 62,
+    tilde = 126,
+    pipe = 124,
+    comma = 44,
+    openBracket = 40,
+    closeBracket = 41,
+    openSq = 91,
+    closeSq = 93,
+    semicolon = 59,
+    asterisk = 42,
+    colon = 58,
+    ampersand = 38,
+    at = 64,
+    atEnd = /[ \n\t\r\{\(\)'"\\;/]/g,
+    wordEnd = /[ \n\t\r\(\)\*:;@!&'"\+\|~>,\[\]\\]|\/(?=\*)/g;
+
+function tokenize(input) {
+    var tokens = [];
+    var css = input.css.valueOf();
+
+    var code = void 0,
+        next = void 0,
+        quote = void 0,
+        lines = void 0,
+        last = void 0,
+        content = void 0,
+        escape = void 0,
+        nextLine = void 0,
+        nextOffset = void 0,
+        escaped = void 0,
+        escapePos = void 0;
+
+    var length = css.length;
+    var offset = -1;
+    var line = 1;
+    var pos = 0;
+
+    var unclosed = function unclosed(what, end) {
+        if (input.safe) {
+            css += end;
+            next = css.length - 1;
+        } else {
+            throw input.error('Unclosed ' + what, line, pos - offset, pos);
+        }
+    };
+
+    while (pos < length) {
+        code = css.charCodeAt(pos);
+
+        if (code === newline) {
+            offset = pos;
+            line += 1;
+        }
+
+        switch (code) {
+            case newline:
+            case space:
+            case tab:
+            case cr:
+            case feed:
+                next = pos;
+                do {
+                    next += 1;
+                    code = css.charCodeAt(next);
+                    if (code === newline) {
+                        offset = next;
+                        line += 1;
+                    }
+                } while (code === space || code === newline || code === tab || code === cr || code === feed);
+
+                tokens.push(['space', css.slice(pos, next), line, pos - offset, pos]);
+                pos = next - 1;
+                break;
+
+            case plus:
+            case gt:
+            case tilde:
+            case pipe:
+                next = pos;
+                do {
+                    next += 1;
+                    code = css.charCodeAt(next);
+                } while (code === plus || code === gt || code === tilde || code === pipe);
+                tokens.push(['combinator', css.slice(pos, next), line, pos - offset, pos]);
+                pos = next - 1;
+                break;
+
+            case asterisk:
+                tokens.push(['*', '*', line, pos - offset, pos]);
+                break;
+
+            case ampersand:
+                tokens.push(['&', '&', line, pos - offset, pos]);
+                break;
+
+            case comma:
+                tokens.push([',', ',', line, pos - offset, pos]);
+                break;
+
+            case openSq:
+                tokens.push(['[', '[', line, pos - offset, pos]);
+                break;
+
+            case closeSq:
+                tokens.push([']', ']', line, pos - offset, pos]);
+                break;
+
+            case colon:
+                tokens.push([':', ':', line, pos - offset, pos]);
+                break;
+
+            case semicolon:
+                tokens.push([';', ';', line, pos - offset, pos]);
+                break;
+
+            case openBracket:
+                tokens.push(['(', '(', line, pos - offset, pos]);
+                break;
+
+            case closeBracket:
+                tokens.push([')', ')', line, pos - offset, pos]);
+                break;
+
+            case singleQuote:
+            case doubleQuote:
+                quote = code === singleQuote ? "'" : '"';
+                next = pos;
+                do {
+                    escaped = false;
+                    next = css.indexOf(quote, next + 1);
+                    if (next === -1) {
+                        unclosed('quote', quote);
+                    }
+                    escapePos = next;
+                    while (css.charCodeAt(escapePos - 1) === backslash) {
+                        escapePos -= 1;
+                        escaped = !escaped;
+                    }
+                } while (escaped);
+
+                tokens.push(['string', css.slice(pos, next + 1), line, pos - offset, line, next - offset, pos]);
+                pos = next;
+                break;
+
+            case at:
+                atEnd.lastIndex = pos + 1;
+                atEnd.test(css);
+                if (atEnd.lastIndex === 0) {
+                    next = css.length - 1;
+                } else {
+                    next = atEnd.lastIndex - 2;
+                }
+                tokens.push(['at-word', css.slice(pos, next + 1), line, pos - offset, line, next - offset, pos]);
+                pos = next;
+                break;
+
+            case backslash:
+                next = pos;
+                escape = true;
+                while (css.charCodeAt(next + 1) === backslash) {
+                    next += 1;
+                    escape = !escape;
+                }
+                code = css.charCodeAt(next + 1);
+                if (escape && code !== slash && code !== space && code !== newline && code !== tab && code !== cr && code !== feed) {
+                    next += 1;
+                }
+                tokens.push(['word', css.slice(pos, next + 1), line, pos - offset, line, next - offset, pos]);
+                pos = next;
+                break;
+
+            default:
+                if (code === slash && css.charCodeAt(pos + 1) === asterisk) {
+                    next = css.indexOf('*/', pos + 2) + 1;
+                    if (next === 0) {
+                        unclosed('comment', '*/');
+                    }
+
+                    content = css.slice(pos, next + 1);
+                    lines = content.split('\n');
+                    last = lines.length - 1;
+
+                    if (last > 0) {
+                        nextLine = line + last;
+                        nextOffset = next - lines[last].length;
+                    } else {
+                        nextLine = line;
+                        nextOffset = offset;
+                    }
+
+                    tokens.push(['comment', content, line, pos - offset, nextLine, next - nextOffset, pos]);
+
+                    offset = nextOffset;
+                    line = nextLine;
+                    pos = next;
+                } else {
+                    wordEnd.lastIndex = pos + 1;
+                    wordEnd.test(css);
+                    if (wordEnd.lastIndex === 0) {
+                        next = css.length - 1;
+                    } else {
+                        next = wordEnd.lastIndex - 2;
+                    }
+
+                    tokens.push(['word', css.slice(pos, next + 1), line, pos - offset, line, next - offset, pos]);
+                    pos = next;
+                }
+
+                break;
+        }
+
+        pos++;
+    }
+
+    return tokens;
+}
+module.exports = exports['default'];
\ No newline at end of file