initial commit

node_modules/csso/lib/clean/Atrule.js

@@ -0,0 +1,65 @@
+var resolveKeyword = require('css-tree').keyword;
+
+module.exports = 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 (node.block.children.isEmpty()) {
+            list.remove(item);
+            return;
+        }
+    }
+
+    switch (node.name) {
+        case 'charset':
+            if (!node.prelude || node.prelude.children.isEmpty()) {
+                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 (!node.prelude || node.prelude.children.isEmpty()) {
+                    list.remove(item);
+                }
+            }
+    }
+};

node_modules/csso/lib/clean/Comment.js

@@ -0,0 +1,3 @@
+module.exports = function cleanComment(data, item, list) {
+    list.remove(item);
+};

node_modules/csso/lib/clean/Declaration.js

@@ -0,0 +1,5 @@
+module.exports = function cleanDeclartion(node, item, list) {
+    if (node.value.children && node.value.children.isEmpty()) {
+        list.remove(item);
+    }
+};

node_modules/csso/lib/clean/Operator.js

@@ -0,0 +1,14 @@
+// remove white spaces around operators when safe
+module.exports = function cleanWhitespace(node, item, list) {
+    if (node.value === '+' || node.value === '-') {
+        return;
+    }
+
+    if (item.prev !== null && item.prev.data.type === 'WhiteSpace') {
+        list.remove(item.prev);
+    }
+
+    if (item.next !== null && item.next.data.type === 'WhiteSpace') {
+        list.remove(item.next);
+    }
+};

node_modules/csso/lib/clean/Rule.js

@@ -0,0 +1,87 @@
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var walk = require('css-tree').walk;
+
+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.call(usageData.whitelist.classes, node.name)) {
+                            shouldRemove = true;
+                        }
+                        if (usageData.blacklist !== null &&
+                            usageData.blacklist.classes !== null &&
+                            hasOwnProperty.call(usageData.blacklist.classes, node.name)) {
+                            shouldRemove = true;
+                        }
+                        break;
+
+                    case 'IdSelector':
+                        if (usageData.whitelist !== null &&
+                            usageData.whitelist.ids !== null &&
+                            !hasOwnProperty.call(usageData.whitelist.ids, node.name)) {
+                            shouldRemove = true;
+                        }
+                        if (usageData.blacklist !== null &&
+                            usageData.blacklist.ids !== null &&
+                            hasOwnProperty.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.call(usageData.whitelist.tags, node.name.toLowerCase())) {
+                                shouldRemove = true;
+                            }
+                            if (usageData.blacklist !== null &&
+                                usageData.blacklist.tags !== null &&
+                                hasOwnProperty.call(usageData.blacklist.tags, node.name.toLowerCase())) {
+                                shouldRemove = true;
+                            }
+                        }
+                        break;
+                }
+            }
+        });
+
+        if (shouldRemove) {
+            list.remove(item);
+        }
+    });
+
+    return selectorList.children.isEmpty();
+}
+
+module.exports = function cleanRuleset(node, item, list, options) {
+    var usageData = options.usage;
+
+    if (usageData && (usageData.whitelist !== null || usageData.blacklist !== null)) {
+        cleanUnused(node.prelude, usageData);
+    }
+
+    if (node.prelude.children.isEmpty() ||
+        node.block.children.isEmpty()) {
+        list.remove(item);
+    }
+};

node_modules/csso/lib/clean/TypeSelector.js

@@ -0,0 +1,19 @@
+// remove useless universal selector
+module.exports = function cleanType(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);
+    }
+};

node_modules/csso/lib/clean/WhiteSpace.js

@@ -0,0 +1,19 @@
+module.exports = function cleanWhitespace(node, item, list) {
+    // remove when first or last item in sequence
+    if (item.next === null || item.prev === null) {
+        list.remove(item);
+        return;
+    }
+
+    // remove when previous node is whitespace
+    if (item.prev.data.type === 'WhiteSpace') {
+        list.remove(item);
+        return;
+    }
+
+    if ((this.stylesheet !== null && this.stylesheet.children === list) ||
+        (this.block !== null && this.block.children === list)) {
+        list.remove(item);
+        return;
+    }
+};

node_modules/csso/lib/clean/index.js

@@ -0,0 +1,20 @@
+var walk = require('css-tree').walk;
+var handlers = {
+    Atrule: require('./Atrule'),
+    Rule: require('./Rule'),
+    Declaration: require('./Declaration'),
+    TypeSelector: require('./TypeSelector'),
+    Comment: require('./Comment'),
+    Operator: require('./Operator'),
+    WhiteSpace: require('./WhiteSpace')
+};
+
+module.exports = function(ast, options) {
+    walk(ast, {
+        leave: function(node, item, list) {
+            if (handlers.hasOwnProperty(node.type)) {
+                handlers[node.type].call(this, node, item, list, options);
+            }
+        }
+    });
+};