Demo for query storing
Change-Id: I947bcac841992c3f6cfd01ab337c265b0d01cb70
diff --git a/node_modules/csso/lib/clean/Atrule.js b/node_modules/csso/lib/clean/Atrule.js
new file mode 100644
index 0000000..9d2ba92
--- /dev/null
+++ b/node_modules/csso/lib/clean/Atrule.js
@@ -0,0 +1,66 @@
+var resolveKeyword = require('css-tree').keyword;
+var { hasNoChildren } = require('./utils');
+
+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 (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);
+ }
+ }
+ }
+};
diff --git a/node_modules/csso/lib/clean/Comment.js b/node_modules/csso/lib/clean/Comment.js
new file mode 100644
index 0000000..aa80108
--- /dev/null
+++ b/node_modules/csso/lib/clean/Comment.js
@@ -0,0 +1,3 @@
+module.exports = function cleanComment(data, item, list) {
+ list.remove(item);
+};
diff --git a/node_modules/csso/lib/clean/Declaration.js b/node_modules/csso/lib/clean/Declaration.js
new file mode 100644
index 0000000..f3cac37
--- /dev/null
+++ b/node_modules/csso/lib/clean/Declaration.js
@@ -0,0 +1,14 @@
+var property = require('css-tree').property;
+
+module.exports = 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();
+ }
+ }
+};
diff --git a/node_modules/csso/lib/clean/Raw.js b/node_modules/csso/lib/clean/Raw.js
new file mode 100644
index 0000000..490f23d
--- /dev/null
+++ b/node_modules/csso/lib/clean/Raw.js
@@ -0,0 +1,9 @@
+var { isNodeChildrenList } = require('./utils');
+
+module.exports = function cleanRaw(node, item, list) {
+ // raw in stylesheet or block children
+ if (isNodeChildrenList(this.stylesheet, list) ||
+ isNodeChildrenList(this.block, list)) {
+ list.remove(item);
+ }
+};
diff --git a/node_modules/csso/lib/clean/Rule.js b/node_modules/csso/lib/clean/Rule.js
new file mode 100644
index 0000000..ec14257
--- /dev/null
+++ b/node_modules/csso/lib/clean/Rule.js
@@ -0,0 +1,93 @@
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var walk = require('css-tree').walk;
+var { hasNoChildren } = require('./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.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 cleanRule(node, item, list, options) {
+ if (hasNoChildren(node.prelude) || hasNoChildren(node.block)) {
+ list.remove(item);
+ return;
+ }
+
+ var usageData = options.usage;
+
+ if (usageData && (usageData.whitelist !== null || usageData.blacklist !== null)) {
+ cleanUnused(node.prelude, usageData);
+
+ if (hasNoChildren(node.prelude)) {
+ list.remove(item);
+ return;
+ }
+ }
+};
diff --git a/node_modules/csso/lib/clean/TypeSelector.js b/node_modules/csso/lib/clean/TypeSelector.js
new file mode 100644
index 0000000..5d40090
--- /dev/null
+++ b/node_modules/csso/lib/clean/TypeSelector.js
@@ -0,0 +1,19 @@
+// remove useless universal selector
+module.exports = 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);
+ }
+};
diff --git a/node_modules/csso/lib/clean/WhiteSpace.js b/node_modules/csso/lib/clean/WhiteSpace.js
new file mode 100644
index 0000000..f3df6e5
--- /dev/null
+++ b/node_modules/csso/lib/clean/WhiteSpace.js
@@ -0,0 +1,30 @@
+var { isNodeChildrenList } = require('./utils');
+
+function isSafeOperator(node) {
+ return node.type === 'Operator' && node.value !== '+' && node.value !== '-';
+}
+
+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;
+ }
+
+ // white space in stylesheet or block children
+ if (isNodeChildrenList(this.stylesheet, list) ||
+ isNodeChildrenList(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;
+ }
+};
diff --git a/node_modules/csso/lib/clean/index.js b/node_modules/csso/lib/clean/index.js
new file mode 100644
index 0000000..9f6e21a
--- /dev/null
+++ b/node_modules/csso/lib/clean/index.js
@@ -0,0 +1,20 @@
+var walk = require('css-tree').walk;
+var handlers = {
+ Atrule: require('./Atrule'),
+ Comment: require('./Comment'),
+ Declaration: require('./Declaration'),
+ Raw: require('./Raw'),
+ Rule: require('./Rule'),
+ TypeSelector: require('./TypeSelector'),
+ 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);
+ }
+ }
+ });
+};
diff --git a/node_modules/csso/lib/clean/utils.js b/node_modules/csso/lib/clean/utils.js
new file mode 100644
index 0000000..976fb0e
--- /dev/null
+++ b/node_modules/csso/lib/clean/utils.js
@@ -0,0 +1,8 @@
+module.exports = {
+ hasNoChildren: function(node) {
+ return !node || !node.children || node.children.isEmpty();
+ },
+ isNodeChildrenList: function(node, list) {
+ return node !== null && node.children === list;
+ }
+};
diff --git a/node_modules/csso/lib/compress.js b/node_modules/csso/lib/compress.js
new file mode 100644
index 0000000..17be39b
--- /dev/null
+++ b/node_modules/csso/lib/compress.js
@@ -0,0 +1,197 @@
+var List = require('css-tree').List;
+var clone = require('css-tree').clone;
+var usageUtils = require('./usage');
+var clean = require('./clean');
+var replace = require('./replace');
+var restructure = require('./restructure');
+var walk = require('css-tree').walk;
+
+function readChunk(children, specialComments) {
+ var buffer = new List();
+ 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(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);
+ 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().appendData({
+ type: 'Rule',
+ loc: null,
+ prelude: {
+ type: 'SelectorList',
+ loc: null,
+ children: new List().appendData({
+ type: 'Selector',
+ loc: null,
+ children: new List().appendData({
+ type: 'TypeSelector',
+ loc: null,
+ name: 'x'
+ })
+ })
+ },
+ block: block
+ });
+}
+
+module.exports = function compress(ast, options) {
+ ast = ast || { type: 'StyleSheet', loc: null, children: new List() };
+ options = options || {};
+
+ var compressOptions = {
+ logger: typeof options.logger === 'function' ? options.logger : function() {},
+ restructuring: getRestructureOption(options),
+ forceMediaMerge: Boolean(options.forceMediaMerge),
+ usage: options.usage ? usageUtils.buildIndex(options.usage) : false
+ };
+ var specialComments = getCommentsOption(options);
+ var firstAtrulesAllowed = true;
+ var input;
+ var output = new List();
+ 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.createItem({
+ type: 'Raw',
+ value: '\n'
+ }));
+ }
+
+ output.insert(List.createItem(chunk.comment));
+
+ // add \n after comment if chunk is not empty
+ if (!chunkChildren.isEmpty()) {
+ output.insert(List.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
+ };
+};
diff --git a/node_modules/csso/lib/index.js b/node_modules/csso/lib/index.js
new file mode 100644
index 0000000..2322e5e
--- /dev/null
+++ b/node_modules/csso/lib/index.js
@@ -0,0 +1,141 @@
+var csstree = require('css-tree');
+var parse = csstree.parse;
+var compress = require('./compress');
+var generate = csstree.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(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(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(compressResult.ast),
+ map: null
+ });
+ }
+
+ return result;
+}
+
+function minifyStylesheet(source, options) {
+ return minify('stylesheet', source, options);
+}
+
+function minifyBlock(source, options) {
+ return minify('declarationList', source, options);
+}
+
+module.exports = {
+ version: require('../package.json').version,
+
+ // main methods
+ minify: minifyStylesheet,
+ minifyBlock: minifyBlock,
+
+ // css syntax parser/walkers/generator/etc
+ syntax: Object.assign({
+ compress: compress
+ }, csstree)
+};
diff --git a/node_modules/csso/lib/replace/Atrule.js b/node_modules/csso/lib/replace/Atrule.js
new file mode 100644
index 0000000..b64245c
--- /dev/null
+++ b/node_modules/csso/lib/replace/Atrule.js
@@ -0,0 +1,9 @@
+var resolveKeyword = require('css-tree').keyword;
+var compressKeyframes = require('./atrule/keyframes');
+
+module.exports = function(node) {
+ // compress @keyframe selectors
+ if (resolveKeyword(node.name).basename === 'keyframes') {
+ compressKeyframes(node);
+ }
+};
diff --git a/node_modules/csso/lib/replace/AttributeSelector.js b/node_modules/csso/lib/replace/AttributeSelector.js
new file mode 100644
index 0000000..72ad9e0
--- /dev/null
+++ b/node_modules/csso/lib/replace/AttributeSelector.js
@@ -0,0 +1,33 @@
+// 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);
+}
+
+module.exports = 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
+ };
+ }
+};
diff --git a/node_modules/csso/lib/replace/Dimension.js b/node_modules/csso/lib/replace/Dimension.js
new file mode 100644
index 0000000..036a94c
--- /dev/null
+++ b/node_modules/csso/lib/replace/Dimension.js
@@ -0,0 +1,62 @@
+var packNumber = require('./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
+};
+
+module.exports = function compressDimension(node, item) {
+ var value = packNumber(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
+ };
+ }
+};
diff --git a/node_modules/csso/lib/replace/Number.js b/node_modules/csso/lib/replace/Number.js
new file mode 100644
index 0000000..f3bd526
--- /dev/null
+++ b/node_modules/csso/lib/replace/Number.js
@@ -0,0 +1,39 @@
+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;
+}
+
+module.exports = function(node, item) {
+ node.value = packNumber(node.value, item);
+};
+module.exports.pack = packNumber;
diff --git a/node_modules/csso/lib/replace/Percentage.js b/node_modules/csso/lib/replace/Percentage.js
new file mode 100644
index 0000000..2382b15
--- /dev/null
+++ b/node_modules/csso/lib/replace/Percentage.js
@@ -0,0 +1,36 @@
+var lexer = require('css-tree').lexer;
+var packNumber = require('./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'
+]);
+
+module.exports = function compressPercentage(node, item) {
+ node.value = packNumber(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;
+ }
+ }
+};
diff --git a/node_modules/csso/lib/replace/String.js b/node_modules/csso/lib/replace/String.js
new file mode 100644
index 0000000..ca9e60d
--- /dev/null
+++ b/node_modules/csso/lib/replace/String.js
@@ -0,0 +1,12 @@
+module.exports = 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;
+};
diff --git a/node_modules/csso/lib/replace/Url.js b/node_modules/csso/lib/replace/Url.js
new file mode 100644
index 0000000..af7f937
--- /dev/null
+++ b/node_modules/csso/lib/replace/Url.js
@@ -0,0 +1,33 @@
+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');
+
+module.exports = 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;
+ }
+};
diff --git a/node_modules/csso/lib/replace/Value.js b/node_modules/csso/lib/replace/Value.js
new file mode 100644
index 0000000..52e3b65
--- /dev/null
+++ b/node_modules/csso/lib/replace/Value.js
@@ -0,0 +1,20 @@
+var resolveName = require('css-tree').property;
+var handlers = {
+ 'font': require('./property/font'),
+ 'font-weight': require('./property/font-weight'),
+ 'background': require('./property/background'),
+ 'border': require('./property/border'),
+ 'outline': require('./property/border')
+};
+
+module.exports = function compressValue(node) {
+ if (!this.declaration) {
+ return;
+ }
+
+ var property = resolveName(this.declaration.property);
+
+ if (handlers.hasOwnProperty(property.basename)) {
+ handlers[property.basename](node);
+ }
+};
diff --git a/node_modules/csso/lib/replace/atrule/keyframes.js b/node_modules/csso/lib/replace/atrule/keyframes.js
new file mode 100644
index 0000000..229d6d1
--- /dev/null
+++ b/node_modules/csso/lib/replace/atrule/keyframes.js
@@ -0,0 +1,21 @@
+module.exports = function(node) {
+ node.block.children.each(function(rule) {
+ rule.prelude.children.each(function(simpleselector) {
+ simpleselector.children.each(function(data, item) {
+ if (data.type === 'Percentage' && data.value === '100') {
+ item.data = {
+ type: 'TypeSelector',
+ loc: data.loc,
+ name: 'to'
+ };
+ } else if (data.type === 'TypeSelector' && data.name === 'from') {
+ item.data = {
+ type: 'Percentage',
+ loc: data.loc,
+ value: '0'
+ };
+ }
+ });
+ });
+ });
+};
diff --git a/node_modules/csso/lib/replace/color.js b/node_modules/csso/lib/replace/color.js
new file mode 100644
index 0000000..da3ae01
--- /dev/null
+++ b/node_modules/csso/lib/replace/color.js
@@ -0,0 +1,510 @@
+var lexer = require('css-tree').lexer;
+var packNumber = require('./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 hueToRgb(p, q, t) {
+ if (t < 0) {
+ t += 1;
+ }
+ if (t > 1) {
+ t -= 1;
+ }
+ if (t < 1 / 6) {
+ return p + (q - p) * 6 * t;
+ }
+ if (t < 1 / 2) {
+ return q;
+ }
+ if (t < 2 / 3) {
+ return p + (q - p) * (2 / 3 - t) * 6;
+ }
+ return p;
+}
+
+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(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.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;
+ }
+}
+
+module.exports = {
+ compressFunction: compressFunction,
+ compressIdent: compressIdent,
+ compressHex: compressHex
+};
diff --git a/node_modules/csso/lib/replace/index.js b/node_modules/csso/lib/replace/index.js
new file mode 100644
index 0000000..2e2c5f6
--- /dev/null
+++ b/node_modules/csso/lib/replace/index.js
@@ -0,0 +1,24 @@
+var walk = require('css-tree').walk;
+var handlers = {
+ Atrule: require('./Atrule'),
+ AttributeSelector: require('./AttributeSelector'),
+ Value: require('./Value'),
+ Dimension: require('./Dimension'),
+ Percentage: require('./Percentage'),
+ Number: require('./Number'),
+ String: require('./String'),
+ Url: require('./Url'),
+ Hash: require('./color').compressHex,
+ Identifier: require('./color').compressIdent,
+ Function: require('./color').compressFunction
+};
+
+module.exports = function(ast) {
+ walk(ast, {
+ leave: function(node, item, list) {
+ if (handlers.hasOwnProperty(node.type)) {
+ handlers[node.type].call(this, node, item, list);
+ }
+ }
+ });
+};
diff --git a/node_modules/csso/lib/replace/property/background.js b/node_modules/csso/lib/replace/property/background.js
new file mode 100644
index 0000000..a17ed4f
--- /dev/null
+++ b/node_modules/csso/lib/replace/property/background.js
@@ -0,0 +1,69 @@
+var List = require('css-tree').List;
+
+module.exports = 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);
+};
diff --git a/node_modules/csso/lib/replace/property/border.js b/node_modules/csso/lib/replace/property/border.js
new file mode 100644
index 0000000..09a32c3
--- /dev/null
+++ b/node_modules/csso/lib/replace/property/border.js
@@ -0,0 +1,31 @@
+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);
+}
+
+module.exports = function compressBorder(node) {
+ node.children.each(function(node, item, list) {
+ if (node.type === 'Identifier' && node.name.toLowerCase() === 'none') {
+ if (list.head === list.tail) {
+ // replace `none` for zero when `none` is a single term
+ item.data = {
+ type: 'Number',
+ loc: node.loc,
+ value: '0'
+ };
+ } else {
+ removeItemAndRedundantWhiteSpace(list, item);
+ }
+ }
+ });
+};
diff --git a/node_modules/csso/lib/replace/property/font-weight.js b/node_modules/csso/lib/replace/property/font-weight.js
new file mode 100644
index 0000000..6f2d34c
--- /dev/null
+++ b/node_modules/csso/lib/replace/property/font-weight.js
@@ -0,0 +1,22 @@
+module.exports = 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;
+ }
+ }
+};
diff --git a/node_modules/csso/lib/replace/property/font.js b/node_modules/csso/lib/replace/property/font.js
new file mode 100644
index 0000000..043ca5c
--- /dev/null
+++ b/node_modules/csso/lib/replace/property/font.js
@@ -0,0 +1,45 @@
+module.exports = 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'
+ }));
+ }
+};
diff --git a/node_modules/csso/lib/restructure/1-mergeAtrule.js b/node_modules/csso/lib/restructure/1-mergeAtrule.js
new file mode 100644
index 0000000..2239f69
--- /dev/null
+++ b/node_modules/csso/lib/restructure/1-mergeAtrule.js
@@ -0,0 +1,107 @@
+var List = require('css-tree').List;
+var resolveKeyword = require('css-tree').keyword;
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var walk = require('css-tree').walk;
+
+function addRuleToMap(map, item, list, single) {
+ var node = item.data;
+ var name = resolveKeyword(node.name).basename;
+ var id = node.name.toLowerCase() + '/' + (node.prelude ? node.prelude.id : null);
+
+ if (!hasOwnProperty.call(map, name)) {
+ map[name] = Object.create(null);
+ }
+
+ if (single) {
+ delete map[name][id];
+ }
+
+ if (!hasOwnProperty.call(map[name], id)) {
+ map[name][id] = new List();
+ }
+
+ 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(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
+ // };
+ }
+}
+
+module.exports = function rejoinAtrule(ast, options) {
+ relocateAtrules(ast, options);
+
+ walk(ast, {
+ visit: 'Atrule',
+ reverse: true,
+ enter: processAtrule
+ });
+};
diff --git a/node_modules/csso/lib/restructure/2-initialMergeRuleset.js b/node_modules/csso/lib/restructure/2-initialMergeRuleset.js
new file mode 100644
index 0000000..9ed0718
--- /dev/null
+++ b/node_modules/csso/lib/restructure/2-initialMergeRuleset.js
@@ -0,0 +1,47 @@
+var walk = require('css-tree').walk;
+var utils = require('./utils');
+
+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.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.isEqualSelectors(prevSelectors, selectors)) {
+ prevDeclarations.appendList(declarations);
+ list.remove(item);
+ return true;
+ }
+
+ // try to join by declarations
+ if (utils.isEqualDeclarations(declarations, prevDeclarations)) {
+ utils.addSelectors(prevSelectors, selectors);
+ list.remove(item);
+ return true;
+ }
+ }
+
+ // go to prev ruleset if has no selector similarities
+ return utils.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
+module.exports = function initialMergeRule(ast) {
+ walk(ast, {
+ visit: 'Rule',
+ enter: processRule
+ });
+};
diff --git a/node_modules/csso/lib/restructure/3-disjoinRuleset.js b/node_modules/csso/lib/restructure/3-disjoinRuleset.js
new file mode 100644
index 0000000..0c56964
--- /dev/null
+++ b/node_modules/csso/lib/restructure/3-disjoinRuleset.js
@@ -0,0 +1,42 @@
+var List = require('css-tree').List;
+var walk = require('css-tree').walk;
+
+function processRule(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();
+ 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);
+ }
+}
+
+module.exports = function disjoinRule(ast) {
+ walk(ast, {
+ visit: 'Rule',
+ reverse: true,
+ enter: processRule
+ });
+};
diff --git a/node_modules/csso/lib/restructure/4-restructShorthand.js b/node_modules/csso/lib/restructure/4-restructShorthand.js
new file mode 100644
index 0000000..f95889e
--- /dev/null
+++ b/node_modules/csso/lib/restructure/4-restructShorthand.js
@@ -0,0 +1,432 @@
+var List = require('css-tree').List;
+var generate = require('css-tree').generate;
+var walk = require('css-tree').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();
+ var sides = this.sides;
+ var values = [
+ sides.top,
+ sides.right,
+ sides.bottom,
+ sides.left
+ ];
+ var stringValues = [
+ generate(sides.top.node),
+ generate(sides.right.node),
+ generate(sides.bottom.node),
+ generate(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(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);
+ }
+ });
+}
+
+module.exports = function restructBlock(ast, indexer) {
+ var stylesheetMap = {};
+ var shortDeclarations = [];
+
+ walk(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.call(this, node, shorts, shortDeclarations, ruleMap.lastShortSelector);
+ }
+ });
+
+ processShorthands(shortDeclarations, indexer.declaration);
+};
diff --git a/node_modules/csso/lib/restructure/6-restructBlock.js b/node_modules/csso/lib/restructure/6-restructBlock.js
new file mode 100644
index 0000000..3864516
--- /dev/null
+++ b/node_modules/csso/lib/restructure/6-restructBlock.js
@@ -0,0 +1,300 @@
+var resolveProperty = require('css-tree').property;
+var resolveKeyword = require('css-tree').keyword;
+var walk = require('css-tree').walk;
+var generate = require('css-tree').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(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(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(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(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(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);
+ }
+}
+
+module.exports = function restructBlock(ast) {
+ var stylesheetMap = {};
+ var fingerprints = Object.create(null);
+
+ walk(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.call(this, node, item, list, props, fingerprints);
+ }
+ });
+};
diff --git a/node_modules/csso/lib/restructure/7-mergeRuleset.js b/node_modules/csso/lib/restructure/7-mergeRuleset.js
new file mode 100644
index 0000000..575e959
--- /dev/null
+++ b/node_modules/csso/lib/restructure/7-mergeRuleset.js
@@ -0,0 +1,86 @@
+var walk = require('css-tree').walk;
+var utils = require('./utils');
+
+/*
+ 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(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.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.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;
+ });
+}
+
+module.exports = function mergeRule(ast) {
+ walk(ast, {
+ visit: 'Rule',
+ enter: processRule
+ });
+};
diff --git a/node_modules/csso/lib/restructure/8-restructRuleset.js b/node_modules/csso/lib/restructure/8-restructRuleset.js
new file mode 100644
index 0000000..111ae98
--- /dev/null
+++ b/node_modules/csso/lib/restructure/8-restructRuleset.js
@@ -0,0 +1,177 @@
+var List = require('css-tree').List;
+var walk = require('css-tree').walk;
+var utils = require('./utils');
+
+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(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.unsafeToSkipNode.call(selectors, prev);
+
+ if (!unsafe && prevType === 'Atrule' && prevBlock) {
+ walk(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.isEqualSelectors(prevSelectors, selectors)) {
+ prevBlock.children.appendList(block.children);
+ list.remove(item);
+ return true;
+ }
+
+ // try to join by properties
+ var diff = utils.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.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.addSelectors(prevSelectors, selectors);
+ block.children = new List().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.addSelectors(selectors, prevSelectors);
+ prevBlock.children = new List().fromArray(diff.ne2);
+ }
+ } else {
+ // diff.ne1.length && diff.ne2.length
+ // extract equal block
+ var newSelector = {
+ type: 'SelectorList',
+ loc: null,
+ children: utils.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().fromArray(diff.eq)
+ },
+ pseudoSignature: node.pseudoSignature
+ });
+
+ block.children = new List().fromArray(diff.ne1);
+ prevBlock.children = new List().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;
+ });
+ });
+}
+
+module.exports = function restructRule(ast) {
+ walk(ast, {
+ visit: 'Rule',
+ reverse: true,
+ enter: processRule
+ });
+};
diff --git a/node_modules/csso/lib/restructure/index.js b/node_modules/csso/lib/restructure/index.js
new file mode 100644
index 0000000..e00f6cb
--- /dev/null
+++ b/node_modules/csso/lib/restructure/index.js
@@ -0,0 +1,35 @@
+var prepare = require('./prepare/index');
+var mergeAtrule = require('./1-mergeAtrule');
+var initialMergeRuleset = require('./2-initialMergeRuleset');
+var disjoinRuleset = require('./3-disjoinRuleset');
+var restructShorthand = require('./4-restructShorthand');
+var restructBlock = require('./6-restructBlock');
+var mergeRuleset = require('./7-mergeRuleset');
+var restructRuleset = require('./8-restructRuleset');
+
+module.exports = function(ast, options) {
+ // prepare ast for restructing
+ var indexer = prepare(ast, options);
+ options.logger('prepare', ast);
+
+ mergeAtrule(ast, options);
+ options.logger('mergeAtrule', ast);
+
+ initialMergeRuleset(ast);
+ options.logger('initialMergeRuleset', ast);
+
+ disjoinRuleset(ast);
+ options.logger('disjoinRuleset', ast);
+
+ restructShorthand(ast, indexer);
+ options.logger('restructShorthand', ast);
+
+ restructBlock(ast);
+ options.logger('restructBlock', ast);
+
+ mergeRuleset(ast);
+ options.logger('mergeRuleset', ast);
+
+ restructRuleset(ast);
+ options.logger('restructRuleset', ast);
+};
diff --git a/node_modules/csso/lib/restructure/prepare/createDeclarationIndexer.js b/node_modules/csso/lib/restructure/prepare/createDeclarationIndexer.js
new file mode 100644
index 0000000..80c551d
--- /dev/null
+++ b/node_modules/csso/lib/restructure/prepare/createDeclarationIndexer.js
@@ -0,0 +1,31 @@
+var generate = require('css-tree').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;
+};
+
+module.exports = 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;
+ };
+};
diff --git a/node_modules/csso/lib/restructure/prepare/index.js b/node_modules/csso/lib/restructure/prepare/index.js
new file mode 100644
index 0000000..a1fd335
--- /dev/null
+++ b/node_modules/csso/lib/restructure/prepare/index.js
@@ -0,0 +1,43 @@
+var resolveKeyword = require('css-tree').keyword;
+var walk = require('css-tree').walk;
+var generate = require('css-tree').generate;
+var createDeclarationIndexer = require('./createDeclarationIndexer');
+var processSelector = require('./processSelector');
+
+module.exports = function prepare(ast, options) {
+ var markDeclaration = createDeclarationIndexer();
+
+ walk(ast, {
+ visit: 'Rule',
+ enter: function processRule(node) {
+ node.block.children.each(markDeclaration);
+ processSelector(node, options.usage);
+ }
+ });
+
+ walk(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(node.prelude);
+ }
+
+ // compare keyframe selectors by its values
+ // NOTE: still no clarification about problems with keyframes selector grouping (issue #197)
+ if (resolveKeyword(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
+ };
+};
diff --git a/node_modules/csso/lib/restructure/prepare/processSelector.js b/node_modules/csso/lib/restructure/prepare/processSelector.js
new file mode 100644
index 0000000..3db19ab
--- /dev/null
+++ b/node_modules/csso/lib/restructure/prepare/processSelector.js
@@ -0,0 +1,94 @@
+var generate = require('css-tree').generate;
+var specificity = require('./specificity');
+
+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
+};
+
+module.exports = 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(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(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(',');
+};
diff --git a/node_modules/csso/lib/restructure/prepare/specificity.js b/node_modules/csso/lib/restructure/prepare/specificity.js
new file mode 100644
index 0000000..104a18a
--- /dev/null
+++ b/node_modules/csso/lib/restructure/prepare/specificity.js
@@ -0,0 +1,56 @@
+module.exports = 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];
+};
diff --git a/node_modules/csso/lib/restructure/utils.js b/node_modules/csso/lib/restructure/utils.js
new file mode 100644
index 0000000..bdc3471
--- /dev/null
+++ b/node_modules/csso/lib/restructure/utils.js
@@ -0,0 +1,151 @@
+var hasOwnProperty = 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.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;
+}
+
+module.exports = {
+ isEqualSelectors: isEqualSelectors,
+ isEqualDeclarations: isEqualDeclarations,
+ compareDeclarations: compareDeclarations,
+ addSelectors: addSelectors,
+ hasSimilarSelectors: hasSimilarSelectors,
+ unsafeToSkipNode: unsafeToSkipNode
+};
diff --git a/node_modules/csso/lib/usage.js b/node_modules/csso/lib/usage.js
new file mode 100644
index 0000000..40b3ddb
--- /dev/null
+++ b/node_modules/csso/lib/usage.js
@@ -0,0 +1,79 @@
+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
+ };
+}
+
+module.exports = {
+ buildIndex: buildIndex
+};