1 files changed, 180 insertions, 0 deletions
diff --git a/node_modules/clean-css/lib/optimizer/level-2/reduce-non-adjacent.js b/node_modules/clean-css/lib/optimizer/level-2/reduce-non-adjacent.js
new file mode 100644
index 00000000..6ce0902b
--- /dev/null
+++ b/node_modules/clean-css/lib/optimizer/level-2/reduce-non-adjacent.js
@@ -0,0 +1,180 @@
+var isMergeable = require('./is-mergeable');
+
+var optimizeProperties = require('./properties/optimize');
+
+var cloneArray = require('../../utils/clone-array');
+
+var Token = require('../../tokenizer/token');
+
+var serializeBody = require('../../writer/one-time').body;
+var serializeRules = require('../../writer/one-time').rules;
+
+function reduceNonAdjacent(tokens, context) {
+  var options = context.options;
+  var mergeablePseudoClasses = options.compatibility.selectors.mergeablePseudoClasses;
+  var mergeablePseudoElements = options.compatibility.selectors.mergeablePseudoElements;
+  var multiplePseudoMerging = options.compatibility.selectors.multiplePseudoMerging;
+  var candidates = {};
+  var repeated = [];
+
+  for (var i = tokens.length - 1; i >= 0; i--) {
+    var token = tokens[i];
+
+    if (token[0] != Token.RULE) {
+      continue;
+    } else if (token[2].length === 0) {
+      continue;
+    }
+
+    var selectorAsString = serializeRules(token[1]);
+    var isComplexAndNotSpecial = token[1].length > 1 &&
+      isMergeable(selectorAsString, mergeablePseudoClasses, mergeablePseudoElements, multiplePseudoMerging);
+    var wrappedSelectors = wrappedSelectorsFrom(token[1]);
+    var selectors = isComplexAndNotSpecial ?
+      [selectorAsString].concat(wrappedSelectors) :
+      [selectorAsString];
+
+    for (var j = 0, m = selectors.length; j < m; j++) {
+      var selector = selectors[j];
+
+      if (!candidates[selector])
+        candidates[selector] = [];
+      else
+        repeated.push(selector);
+
+      candidates[selector].push({
+        where: i,
+        list: wrappedSelectors,
+        isPartial: isComplexAndNotSpecial && j > 0,
+        isComplex: isComplexAndNotSpecial && j === 0
+      });
+    }
+  }
+
+  reduceSimpleNonAdjacentCases(tokens, repeated, candidates, options, context);
+  reduceComplexNonAdjacentCases(tokens, candidates, options, context);
+}
+
+function wrappedSelectorsFrom(list) {
+  var wrapped = [];
+
+  for (var i = 0; i < list.length; i++) {
+    wrapped.push([list[i][1]]);
+  }
+
+  return wrapped;
+}
+
+function reduceSimpleNonAdjacentCases(tokens, repeated, candidates, options, context) {
+  function filterOut(idx, bodies) {
+    return data[idx].isPartial && bodies.length === 0;
+  }
+
+  function reduceBody(token, newBody, processedCount, tokenIdx) {
+    if (!data[processedCount - tokenIdx - 1].isPartial)
+      token[2] = newBody;
+  }
+
+  for (var i = 0, l = repeated.length; i < l; i++) {
+    var selector = repeated[i];
+    var data = candidates[selector];
+
+    reduceSelector(tokens, data, {
+      filterOut: filterOut,
+      callback: reduceBody
+    }, options, context);
+  }
+}
+
+function reduceComplexNonAdjacentCases(tokens, candidates, options, context) {
+  var mergeablePseudoClasses = options.compatibility.selectors.mergeablePseudoClasses;
+  var mergeablePseudoElements = options.compatibility.selectors.mergeablePseudoElements;
+  var multiplePseudoMerging = options.compatibility.selectors.multiplePseudoMerging;
+  var localContext = {};
+
+  function filterOut(idx) {
+    return localContext.data[idx].where < localContext.intoPosition;
+  }
+
+  function collectReducedBodies(token, newBody, processedCount, tokenIdx) {
+    if (tokenIdx === 0)
+      localContext.reducedBodies.push(newBody);
+  }
+
+  allSelectors:
+  for (var complexSelector in candidates) {
+    var into = candidates[complexSelector];
+    if (!into[0].isComplex)
+      continue;
+
+    var intoPosition = into[into.length - 1].where;
+    var intoToken = tokens[intoPosition];
+    var reducedBodies = [];
+
+    var selectors = isMergeable(complexSelector, mergeablePseudoClasses, mergeablePseudoElements, multiplePseudoMerging) ?
+      into[0].list :
+      [complexSelector];
+
+    localContext.intoPosition = intoPosition;
+    localContext.reducedBodies = reducedBodies;
+
+    for (var j = 0, m = selectors.length; j < m; j++) {
+      var selector = selectors[j];
+      var data = candidates[selector];
+
+      if (data.length < 2)
+        continue allSelectors;
+
+      localContext.data = data;
+
+      reduceSelector(tokens, data, {
+        filterOut: filterOut,
+        callback: collectReducedBodies
+      }, options, context);
+
+      if (serializeBody(reducedBodies[reducedBodies.length - 1]) != serializeBody(reducedBodies[0]))
+        continue allSelectors;
+    }
+
+    intoToken[2] = reducedBodies[0];
+  }
+}
+
+function reduceSelector(tokens, data, context, options, outerContext) {
+  var bodies = [];
+  var bodiesAsList = [];
+  var processedTokens = [];
+
+  for (var j = data.length - 1; j >= 0; j--) {
+    if (context.filterOut(j, bodies))
+      continue;
+
+    var where = data[j].where;
+    var token = tokens[where];
+    var clonedBody = cloneArray(token[2]);
+
+    bodies = bodies.concat(clonedBody);
+    bodiesAsList.push(clonedBody);
+    processedTokens.push(where);
+  }
+
+  optimizeProperties(bodies, true, false, outerContext);
+
+  var processedCount = processedTokens.length;
+  var propertyIdx = bodies.length - 1;
+  var tokenIdx = processedCount - 1;
+
+  while (tokenIdx >= 0) {
+     if ((tokenIdx === 0 || (bodies[propertyIdx] && bodiesAsList[tokenIdx].indexOf(bodies[propertyIdx]) > -1)) && propertyIdx > -1) {
+      propertyIdx--;
+      continue;
+    }
+
+    var newBody = bodies.splice(propertyIdx + 1);
+    context.callback(tokens[processedTokens[tokenIdx]], newBody, processedCount, tokenIdx);
+
+    tokenIdx--;
+  }
+}
+
+module.exports = reduceNonAdjacent;