0.2.0 - Mid migration

web/node_modules/clean-css/lib/optimizer/level-1/optimize.js

@@ -0,0 +1,691 @@
+var shortenHex = require('./shorten-hex');
+var shortenHsl = require('./shorten-hsl');
+var shortenRgb = require('./shorten-rgb');
+var sortSelectors = require('./sort-selectors');
+var tidyRules = require('./tidy-rules');
+var tidyBlock = require('./tidy-block');
+var tidyAtRule = require('./tidy-at-rule');
+
+var Hack = require('../hack');
+var removeUnused = require('../remove-unused');
+var restoreFromOptimizing = require('../restore-from-optimizing');
+var wrapForOptimizing = require('../wrap-for-optimizing').all;
+
+var OptimizationLevel = require('../../options/optimization-level').OptimizationLevel;
+
+var Token = require('../../tokenizer/token');
+var Marker = require('../../tokenizer/marker');
+
+var formatPosition = require('../../utils/format-position');
+var split = require('../../utils/split');
+
+var serializeRules = require('../../writer/one-time').rules;
+
+var IgnoreProperty = 'ignore-property';
+
+var CHARSET_TOKEN = '@charset';
+var CHARSET_REGEXP = new RegExp('^' + CHARSET_TOKEN, 'i');
+
+var DEFAULT_ROUNDING_PRECISION = require('../../options/rounding-precision').DEFAULT;
+
+var WHOLE_PIXEL_VALUE = /(?:^|\s|\()(-?\d+)px/;
+var TIME_VALUE = /^(\-?[\d\.]+)(m?s)$/;
+
+var HEX_VALUE_PATTERN = /[0-9a-f]/i;
+var PROPERTY_NAME_PATTERN = /^(?:\-chrome\-|\-[\w\-]+\w|\w[\w\-]+\w|\-\-\S+)$/;
+var IMPORT_PREFIX_PATTERN = /^@import/i;
+var QUOTED_PATTERN = /^('.*'|".*")$/;
+var QUOTED_BUT_SAFE_PATTERN = /^['"][a-zA-Z][a-zA-Z\d\-_]+['"]$/;
+var URL_PREFIX_PATTERN = /^url\(/i;
+var LOCAL_PREFIX_PATTERN = /^local\(/i;
+var VARIABLE_NAME_PATTERN = /^--\S+$/;
+
+function isLocal(value){
+  return LOCAL_PREFIX_PATTERN.test(value);
+}
+
+function isNegative(value) {
+  return value && value[1][0] == '-' && parseFloat(value[1]) < 0;
+}
+
+function isQuoted(value) {
+  return QUOTED_PATTERN.test(value);
+}
+
+function isUrl(value) {
+  return URL_PREFIX_PATTERN.test(value);
+}
+
+function normalizeUrl(value) {
+  return value
+    .replace(URL_PREFIX_PATTERN, 'url(')
+    .replace(/\\?\n|\\?\r\n/g, '');
+}
+
+function optimizeBackground(property) {
+  var values = property.value;
+
+  if (values.length == 1 && values[0][1] == 'none') {
+    values[0][1] = '0 0';
+  }
+
+  if (values.length == 1 && values[0][1] == 'transparent') {
+    values[0][1] = '0 0';
+  }
+}
+
+function optimizeBorderRadius(property) {
+  var values = property.value;
+  var spliceAt;
+
+  if (values.length == 3 && values[1][1] == '/' && values[0][1] == values[2][1]) {
+    spliceAt = 1;
+  } else if (values.length == 5 && values[2][1] == '/' && values[0][1] == values[3][1] && values[1][1] == values[4][1]) {
+    spliceAt = 2;
+  } else if (values.length == 7 && values[3][1] == '/' && values[0][1] == values[4][1] && values[1][1] == values[5][1] && values[2][1] == values[6][1]) {
+    spliceAt = 3;
+  } else if (values.length == 9 && values[4][1] == '/' && values[0][1] == values[5][1] && values[1][1] == values[6][1] && values[2][1] == values[7][1] && values[3][1] == values[8][1]) {
+    spliceAt = 4;
+  }
+
+  if (spliceAt) {
+    property.value.splice(spliceAt);
+    property.dirty = true;
+  }
+}
+
+/**
+ * @param {string} name
+ * @param {string} value
+ * @param {Object} compatibility
+ * @return {string}
+ */
+function optimizeColors(name, value, compatibility) {
+  if (!value.match(/#|rgb|hsl/gi)) {
+    return shortenHex(value);
+  }
+
+  value = value
+    .replace(/(rgb|hsl)a?\((\-?\d+),(\-?\d+\%?),(\-?\d+\%?),(0*[1-9]+[0-9]*(\.?\d*)?)\)/gi, function (match, colorFn, p1, p2, p3, alpha) {
+      return (parseInt(alpha, 10) >= 1 ? colorFn + '(' + [p1,p2,p3].join(',') + ')' : match);
+    })
+    .replace(/rgb\((\-?\d+),(\-?\d+),(\-?\d+)\)/gi, function (match, red, green, blue) {
+      return shortenRgb(red, green, blue);
+    })
+    .replace(/hsl\((-?\d+),(-?\d+)%?,(-?\d+)%?\)/gi, function (match, hue, saturation, lightness) {
+      return shortenHsl(hue, saturation, lightness);
+    })
+    .replace(/(^|[^='"])#([0-9a-f]{6})/gi, function (match, prefix, color, at, inputValue) {
+      var suffix = inputValue[at + match.length];
+
+      if (suffix && HEX_VALUE_PATTERN.test(suffix)) {
+        return match;
+      } else if (color[0] == color[1] && color[2] == color[3] && color[4] == color[5]) {
+        return (prefix + '#' + color[0] + color[2] + color[4]).toLowerCase();
+      } else {
+        return (prefix + '#' + color).toLowerCase();
+      }
+    })
+    .replace(/(^|[^='"])#([0-9a-f]{3})/gi, function (match, prefix, color) {
+      return prefix + '#' + color.toLowerCase();
+    })
+    .replace(/(rgb|rgba|hsl|hsla)\(([^\)]+)\)/gi, function (match, colorFunction, colorDef) {
+      var tokens = colorDef.split(',');
+      var colorFnLowercase = colorFunction && colorFunction.toLowerCase();
+      var applies = (colorFnLowercase == 'hsl' && tokens.length == 3) ||
+        (colorFnLowercase == 'hsla' && tokens.length == 4) ||
+        (colorFnLowercase == 'rgb' && tokens.length === 3 && colorDef.indexOf('%') > 0) ||
+        (colorFnLowercase == 'rgba' && tokens.length == 4 && colorDef.indexOf('%') > 0);
+
+      if (!applies) {
+        return match;
+      }
+
+      if (tokens[1].indexOf('%') == -1) {
+        tokens[1] += '%';
+      }
+
+      if (tokens[2].indexOf('%') == -1) {
+        tokens[2] += '%';
+      }
+
+      return colorFunction + '(' + tokens.join(',') + ')';
+    });
+
+  if (compatibility.colors.opacity && name.indexOf('background') == -1) {
+    value = value.replace(/(?:rgba|hsla)\(0,0%?,0%?,0\)/g, function (match) {
+      if (split(value, ',').pop().indexOf('gradient(') > -1) {
+        return match;
+      }
+
+      return 'transparent';
+    });
+  }
+
+  return shortenHex(value);
+}
+
+function optimizeFilter(property) {
+  if (property.value.length == 1) {
+    property.value[0][1] = property.value[0][1].replace(/progid:DXImageTransform\.Microsoft\.(Alpha|Chroma)(\W)/, function (match, filter, suffix) {
+      return filter.toLowerCase() + suffix;
+    });
+  }
+
+  property.value[0][1] = property.value[0][1]
+    .replace(/,(\S)/g, ', $1')
+    .replace(/ ?= ?/g, '=');
+}
+
+function optimizeFontWeight(property, atIndex) {
+  var value = property.value[atIndex][1];
+
+  if (value == 'normal') {
+    value = '400';
+  } else if (value == 'bold') {
+    value = '700';
+  }
+
+  property.value[atIndex][1] = value;
+}
+
+function optimizeMultipleZeros(property) {
+  var values = property.value;
+  var spliceAt;
+
+  if (values.length == 4 && values[0][1] === '0' && values[1][1] === '0' && values[2][1] === '0' && values[3][1] === '0') {
+    if (property.name.indexOf('box-shadow') > -1) {
+      spliceAt = 2;
+    } else {
+      spliceAt = 1;
+    }
+  }
+
+  if (spliceAt) {
+    property.value.splice(spliceAt);
+    property.dirty = true;
+  }
+}
+
+function optimizeOutline(property) {
+  var values = property.value;
+
+  if (values.length == 1 && values[0][1] == 'none') {
+    values[0][1] = '0';
+  }
+}
+
+function optimizePixelLengths(_, value, compatibility) {
+  if (!WHOLE_PIXEL_VALUE.test(value)) {
+    return value;
+  }
+
+  return value.replace(WHOLE_PIXEL_VALUE, function (match, val) {
+    var newValue;
+    var intVal = parseInt(val);
+
+    if (intVal === 0) {
+      return match;
+    }
+
+    if (compatibility.properties.shorterLengthUnits && compatibility.units.pt && intVal * 3 % 4 === 0) {
+      newValue = intVal * 3 / 4 + 'pt';
+    }
+
+    if (compatibility.properties.shorterLengthUnits && compatibility.units.pc && intVal % 16 === 0) {
+      newValue = intVal / 16 + 'pc';
+    }
+
+    if (compatibility.properties.shorterLengthUnits && compatibility.units.in && intVal % 96 === 0) {
+      newValue = intVal / 96 + 'in';
+    }
+
+    if (newValue) {
+      newValue = match.substring(0, match.indexOf(val)) + newValue;
+    }
+
+    return newValue && newValue.length < match.length ? newValue : match;
+  });
+}
+
+function optimizePrecision(_, value, precisionOptions) {
+  if (!precisionOptions.enabled || value.indexOf('.') === -1) {
+    return value;
+  }
+
+  return value
+    .replace(precisionOptions.decimalPointMatcher, '$1$2$3')
+    .replace(precisionOptions.zeroMatcher, function (match, integerPart, fractionPart, unit) {
+      var multiplier = precisionOptions.units[unit].multiplier;
+      var parsedInteger = parseInt(integerPart);
+      var integer = isNaN(parsedInteger) ? 0 : parsedInteger;
+      var fraction = parseFloat(fractionPart);
+
+      return Math.round((integer + fraction) * multiplier) / multiplier + unit;
+    });
+}
+
+function optimizeTimeUnits(_, value) {
+  if (!TIME_VALUE.test(value))
+    return value;
+
+  return value.replace(TIME_VALUE, function (match, val, unit) {
+    var newValue;
+
+    if (unit == 'ms') {
+      newValue = parseInt(val) / 1000 + 's';
+    } else if (unit == 's') {
+      newValue = parseFloat(val) * 1000 + 'ms';
+    }
+
+    return newValue.length < match.length ? newValue : match;
+  });
+}
+
+function optimizeUnits(name, value, unitsRegexp) {
+  if (/^(?:\-moz\-calc|\-webkit\-calc|calc|rgb|hsl|rgba|hsla)\(/.test(value)) {
+    return value;
+  }
+
+  if (name == 'flex' || name == '-ms-flex' || name == '-webkit-flex' || name == 'flex-basis' || name == '-webkit-flex-basis') {
+    return value;
+  }
+
+  if (value.indexOf('%') > 0 && (name == 'height' || name == 'max-height' || name == 'width' || name == 'max-width')) {
+    return value;
+  }
+
+  return value
+    .replace(unitsRegexp, '$1' + '0' + '$2')
+    .replace(unitsRegexp, '$1' + '0' + '$2');
+}
+
+function optimizeWhitespace(name, value) {
+  if (name.indexOf('filter') > -1 || value.indexOf(' ') == -1 || value.indexOf('expression') === 0) {
+    return value;
+  }
+
+  if (value.indexOf(Marker.SINGLE_QUOTE) > -1 || value.indexOf(Marker.DOUBLE_QUOTE) > -1) {
+    return value;
+  }
+
+  value = value.replace(/\s+/g, ' ');
+
+  if (value.indexOf('calc') > -1) {
+    value = value.replace(/\) ?\/ ?/g, ')/ ');
+  }
+
+  return value
+    .replace(/(\(;?)\s+/g, '$1')
+    .replace(/\s+(;?\))/g, '$1')
+    .replace(/, /g, ',');
+}
+
+function optimizeZeroDegUnit(_, value) {
+  if (value.indexOf('0deg') == -1) {
+    return value;
+  }
+
+  return value.replace(/\(0deg\)/g, '(0)');
+}
+
+function optimizeZeroUnits(name, value) {
+  if (value.indexOf('0') == -1) {
+    return value;
+  }
+
+  if (value.indexOf('-') > -1) {
+    value = value
+      .replace(/([^\w\d\-]|^)\-0([^\.]|$)/g, '$10$2')
+      .replace(/([^\w\d\-]|^)\-0([^\.]|$)/g, '$10$2');
+  }
+
+  return value
+    .replace(/(^|\s)0+([1-9])/g, '$1$2')
+    .replace(/(^|\D)\.0+(\D|$)/g, '$10$2')
+    .replace(/(^|\D)\.0+(\D|$)/g, '$10$2')
+    .replace(/\.([1-9]*)0+(\D|$)/g, function (match, nonZeroPart, suffix) {
+      return (nonZeroPart.length > 0 ? '.' : '') + nonZeroPart + suffix;
+    })
+    .replace(/(^|\D)0\.(\d)/g, '$1.$2');
+}
+
+function removeQuotes(name, value) {
+  if (name == 'content' || name.indexOf('font-variation-settings') > -1 || name.indexOf('font-feature-settings') > -1 || name == 'grid' || name.indexOf('grid-') > -1) {
+    return value;
+  }
+
+  return QUOTED_BUT_SAFE_PATTERN.test(value) ?
+    value.substring(1, value.length - 1) :
+    value;
+}
+
+function removeUrlQuotes(value) {
+  return /^url\(['"].+['"]\)$/.test(value) && !/^url\(['"].*[\*\s\(\)'"].*['"]\)$/.test(value) && !/^url\(['"]data:[^;]+;charset/.test(value) ?
+    value.replace(/["']/g, '') :
+    value;
+}
+
+function transformValue(propertyName, propertyValue, rule, transformCallback) {
+  var selector = serializeRules(rule);
+  var transformedValue = transformCallback(propertyName, propertyValue, selector);
+
+  if (transformedValue === undefined) {
+    return propertyValue;
+  } else if (transformedValue === false) {
+    return IgnoreProperty;
+  } else {
+    return transformedValue;
+  }
+}
+
+//
+
+function optimizeBody(rule, properties, context) {
+  var options = context.options;
+  var levelOptions = options.level[OptimizationLevel.One];
+  var property, name, type, value;
+  var valueIsUrl;
+  var propertyToken;
+  var _properties = wrapForOptimizing(properties, true);
+
+  propertyLoop:
+  for (var i = 0, l = _properties.length; i < l; i++) {
+    property = _properties[i];
+    name = property.name;
+
+    if (!PROPERTY_NAME_PATTERN.test(name)) {
+      propertyToken = property.all[property.position];
+      context.warnings.push('Invalid property name \'' + name + '\' at ' + formatPosition(propertyToken[1][2][0]) + '. Ignoring.');
+      property.unused = true;
+    }
+
+    if (property.value.length === 0) {
+      propertyToken = property.all[property.position];
+      context.warnings.push('Empty property \'' + name + '\' at ' + formatPosition(propertyToken[1][2][0]) + '. Ignoring.');
+      property.unused = true;
+    }
+
+    if (property.hack && (
+        (property.hack[0] == Hack.ASTERISK || property.hack[0] == Hack.UNDERSCORE) && !options.compatibility.properties.iePrefixHack ||
+        property.hack[0] == Hack.BACKSLASH && !options.compatibility.properties.ieSuffixHack ||
+        property.hack[0] == Hack.BANG && !options.compatibility.properties.ieBangHack)) {
+      property.unused = true;
+    }
+
+    if (levelOptions.removeNegativePaddings && name.indexOf('padding') === 0 && (isNegative(property.value[0]) || isNegative(property.value[1]) || isNegative(property.value[2]) || isNegative(property.value[3]))) {
+      property.unused = true;
+    }
+
+    if (!options.compatibility.properties.ieFilters && isLegacyFilter(property)) {
+      property.unused = true;
+    }
+
+    if (property.unused) {
+      continue;
+    }
+
+    if (property.block) {
+      optimizeBody(rule, property.value[0][1], context);
+      continue;
+    }
+
+    if (VARIABLE_NAME_PATTERN.test(name)) {
+      continue;
+    }
+
+    for (var j = 0, m = property.value.length; j < m; j++) {
+      type = property.value[j][0];
+      value = property.value[j][1];
+      valueIsUrl = isUrl(value);
+
+      if (type == Token.PROPERTY_BLOCK) {
+        property.unused = true;
+        context.warnings.push('Invalid value token at ' + formatPosition(value[0][1][2][0]) + '. Ignoring.');
+        break;
+      }
+
+      if (valueIsUrl && !context.validator.isUrl(value)) {
+        property.unused = true;
+        context.warnings.push('Broken URL \'' + value + '\' at ' + formatPosition(property.value[j][2][0]) + '. Ignoring.');
+        break;
+      }
+
+      if (valueIsUrl) {
+        value = levelOptions.normalizeUrls ?
+          normalizeUrl(value) :
+          value;
+        value = !options.compatibility.properties.urlQuotes ?
+          removeUrlQuotes(value) :
+          value;
+      } else if (isQuoted(value) || isLocal(value)) {
+        value = levelOptions.removeQuotes ?
+          removeQuotes(name, value) :
+          value;
+      } else {
+        value = levelOptions.removeWhitespace ?
+          optimizeWhitespace(name, value) :
+          value;
+        value = optimizePrecision(name, value, options.precision);
+        value = optimizePixelLengths(name, value, options.compatibility);
+        value = levelOptions.replaceTimeUnits ?
+          optimizeTimeUnits(name, value) :
+          value;
+        value = levelOptions.replaceZeroUnits ?
+          optimizeZeroUnits(name, value) :
+          value;
+
+        if (options.compatibility.properties.zeroUnits) {
+          value = optimizeZeroDegUnit(name, value);
+          value = optimizeUnits(name, value, options.unitsRegexp);
+        }
+
+        if (options.compatibility.properties.colors) {
+          value = optimizeColors(name, value, options.compatibility);
+        }
+      }
+
+      value = transformValue(name, value, rule, levelOptions.transform);
+
+      if (value === IgnoreProperty) {
+        property.unused = true;
+        continue propertyLoop;
+      }
+
+      property.value[j][1] = value;
+    }
+
+    if (levelOptions.replaceMultipleZeros) {
+      optimizeMultipleZeros(property);
+    }
+
+    if (name == 'background' && levelOptions.optimizeBackground) {
+      optimizeBackground(property);
+    } else if (name.indexOf('border') === 0 && name.indexOf('radius') > 0 && levelOptions.optimizeBorderRadius) {
+      optimizeBorderRadius(property);
+    } else if (name == 'filter'&& levelOptions.optimizeFilter && options.compatibility.properties.ieFilters) {
+      optimizeFilter(property);
+    } else if (name == 'font-weight' && levelOptions.optimizeFontWeight) {
+      optimizeFontWeight(property, 0);
+    } else if (name == 'outline' && levelOptions.optimizeOutline) {
+      optimizeOutline(property);
+    }
+  }
+
+  restoreFromOptimizing(_properties);
+  removeUnused(_properties);
+  removeComments(properties, options);
+}
+
+function removeComments(tokens, options) {
+  var token;
+  var i;
+
+  for (i = 0; i < tokens.length; i++) {
+    token = tokens[i];
+
+    if (token[0] != Token.COMMENT) {
+      continue;
+    }
+
+    optimizeComment(token, options);
+
+    if (token[1].length === 0) {
+      tokens.splice(i, 1);
+      i--;
+    }
+  }
+}
+
+function optimizeComment(token, options) {
+  if (token[1][2] == Marker.EXCLAMATION && (options.level[OptimizationLevel.One].specialComments == 'all' || options.commentsKept < options.level[OptimizationLevel.One].specialComments)) {
+    options.commentsKept++;
+    return;
+  }
+
+  token[1] = [];
+}
+
+function cleanupCharsets(tokens) {
+  var hasCharset = false;
+
+  for (var i = 0, l = tokens.length; i < l; i++) {
+    var token = tokens[i];
+
+    if (token[0] != Token.AT_RULE)
+      continue;
+
+    if (!CHARSET_REGEXP.test(token[1]))
+      continue;
+
+    if (hasCharset || token[1].indexOf(CHARSET_TOKEN) == -1) {
+      tokens.splice(i, 1);
+      i--;
+      l--;
+    } else {
+      hasCharset = true;
+      tokens.splice(i, 1);
+      tokens.unshift([Token.AT_RULE, token[1].replace(CHARSET_REGEXP, CHARSET_TOKEN)]);
+    }
+  }
+}
+
+function buildUnitRegexp(options) {
+  var units = ['px', 'em', 'ex', 'cm', 'mm', 'in', 'pt', 'pc', '%'];
+  var otherUnits = ['ch', 'rem', 'vh', 'vm', 'vmax', 'vmin', 'vw'];
+
+  otherUnits.forEach(function (unit) {
+    if (options.compatibility.units[unit]) {
+      units.push(unit);
+    }
+  });
+
+  return new RegExp('(^|\\s|\\(|,)0(?:' + units.join('|') + ')(\\W|$)', 'g');
+}
+
+function buildPrecisionOptions(roundingPrecision) {
+  var precisionOptions = {
+    matcher: null,
+    units: {},
+  };
+  var optimizable = [];
+  var unit;
+  var value;
+
+  for (unit in roundingPrecision) {
+    value = roundingPrecision[unit];
+
+    if (value != DEFAULT_ROUNDING_PRECISION) {
+      precisionOptions.units[unit] = {};
+      precisionOptions.units[unit].value = value;
+      precisionOptions.units[unit].multiplier = Math.pow(10, value);
+
+      optimizable.push(unit);
+    }
+  }
+
+  if (optimizable.length > 0) {
+    precisionOptions.enabled = true;
+    precisionOptions.decimalPointMatcher = new RegExp('(\\d)\\.($|' + optimizable.join('|') + ')($|\W)', 'g');
+    precisionOptions.zeroMatcher = new RegExp('(\\d*)(\\.\\d+)(' + optimizable.join('|') + ')', 'g');
+  }
+
+  return precisionOptions;
+}
+
+function isImport(token) {
+  return IMPORT_PREFIX_PATTERN.test(token[1]);
+}
+
+function isLegacyFilter(property) {
+  var value;
+
+  if (property.name == 'filter' || property.name == '-ms-filter') {
+    value = property.value[0][1];
+
+    return value.indexOf('progid') > -1 ||
+      value.indexOf('alpha') === 0 ||
+      value.indexOf('chroma') === 0;
+  } else {
+    return false;
+  }
+}
+
+function level1Optimize(tokens, context) {
+  var options = context.options;
+  var levelOptions = options.level[OptimizationLevel.One];
+  var ie7Hack = options.compatibility.selectors.ie7Hack;
+  var adjacentSpace = options.compatibility.selectors.adjacentSpace;
+  var spaceAfterClosingBrace = options.compatibility.properties.spaceAfterClosingBrace;
+  var format = options.format;
+  var mayHaveCharset = false;
+  var afterRules = false;
+
+  options.unitsRegexp = options.unitsRegexp || buildUnitRegexp(options);
+  options.precision = options.precision || buildPrecisionOptions(levelOptions.roundingPrecision);
+  options.commentsKept = options.commentsKept || 0;
+
+  for (var i = 0, l = tokens.length; i < l; i++) {
+    var token = tokens[i];
+
+    switch (token[0]) {
+      case Token.AT_RULE:
+        token[1] = isImport(token) && afterRules ? '' : token[1];
+        token[1] = levelOptions.tidyAtRules ? tidyAtRule(token[1]) : token[1];
+        mayHaveCharset = true;
+        break;
+      case Token.AT_RULE_BLOCK:
+        optimizeBody(token[1], token[2], context);
+        afterRules = true;
+        break;
+      case Token.NESTED_BLOCK:
+        token[1] = levelOptions.tidyBlockScopes ? tidyBlock(token[1], spaceAfterClosingBrace) : token[1];
+        level1Optimize(token[2], context);
+        afterRules = true;
+        break;
+      case Token.COMMENT:
+        optimizeComment(token, options);
+        break;
+      case Token.RULE:
+        token[1] = levelOptions.tidySelectors ? tidyRules(token[1], !ie7Hack, adjacentSpace, format, context.warnings) : token[1];
+        token[1] = token[1].length > 1 ? sortSelectors(token[1], levelOptions.selectorsSortingMethod) : token[1];
+        optimizeBody(token[1], token[2], context);
+        afterRules = true;
+        break;
+    }
+
+    if (token[0] == Token.COMMENT && token[1].length === 0 || levelOptions.removeEmpty && (token[1].length === 0 || (token[2] && token[2].length === 0))) {
+      tokens.splice(i, 1);
+      i--;
+      l--;
+    }
+  }
+
+  if (levelOptions.cleanupCharsets && mayHaveCharset) {
+    cleanupCharsets(tokens);
+  }
+
+  return tokens;
+}
+
+module.exports = level1Optimize;

web/node_modules/clean-css/lib/optimizer/level-1/shorten-hex.js

@@ -0,0 +1,189 @@
+var COLORS = {
+  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',
+  darkgreen: '#006400',
+  darkgrey: '#a9a9a9',
+  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',
+  green: '#008000',
+  greenyellow: '#adff2f',
+  grey: '#808080',
+  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',
+  lightgreen: '#90ee90',
+  lightgrey: '#d3d3d3',
+  lightpink: '#ffb6c1',
+  lightsalmon: '#ffa07a',
+  lightseagreen: '#20b2aa',
+  lightskyblue: '#87cefa',
+  lightslategray: '#778899',
+  lightslategrey: '#778899',
+  lightsteelblue: '#b0c4de',
+  lightyellow: '#ffffe0',
+  lime: '#0f0',
+  limegreen: '#32cd32',
+  linen: '#faf0e6',
+  magenta: '#ff00ff',
+  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: '#663399',
+  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 toHex = {};
+var toName = {};
+
+for (var name in COLORS) {
+  var hex = COLORS[name];
+
+  if (name.length < hex.length) {
+    toName[hex] = name;
+  } else {
+    toHex[name] = hex;
+  }
+}
+
+var toHexPattern = new RegExp('(^| |,|\\))(' + Object.keys(toHex).join('|') + ')( |,|\\)|$)', 'ig');
+var toNamePattern = new RegExp('(' + Object.keys(toName).join('|') + ')([^a-f0-9]|$)', 'ig');
+
+function hexConverter(match, prefix, colorValue, suffix) {
+  return prefix + toHex[colorValue.toLowerCase()] + suffix;
+}
+
+function nameConverter(match, colorValue, suffix) {
+  return toName[colorValue.toLowerCase()] + suffix;
+}
+
+function shortenHex(value) {
+  var hasHex = value.indexOf('#') > -1;
+  var shortened = value.replace(toHexPattern, hexConverter);
+
+  if (shortened != value) {
+    shortened = shortened.replace(toHexPattern, hexConverter);
+  }
+
+  return hasHex ?
+    shortened.replace(toNamePattern, nameConverter) :
+    shortened;
+}
+
+module.exports = shortenHex;

web/node_modules/clean-css/lib/optimizer/level-1/shorten-hsl.js

@@ -0,0 +1,61 @@
+// HSL to RGB converter. Both methods adapted from:
+// http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript
+
+function hslToRgb(h, s, l) {
+  var r, g, b;
+
+  // normalize hue orientation b/w 0 and 360 degrees
+  h = h % 360;
+  if (h < 0)
+    h += 360;
+  h = ~~h / 360;
+
+  if (s < 0)
+    s = 0;
+  else if (s > 100)
+    s = 100;
+  s = ~~s / 100;
+
+  if (l < 0)
+    l = 0;
+  else if (l > 100)
+    l = 100;
+  l = ~~l / 100;
+
+  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 [~~(r * 255), ~~(g * 255), ~~(b * 255)];
+}
+
+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 shortenHsl(hue, saturation, lightness) {
+  var asRgb = hslToRgb(hue, saturation, lightness);
+  var redAsHex = asRgb[0].toString(16);
+  var greenAsHex = asRgb[1].toString(16);
+  var blueAsHex = asRgb[2].toString(16);
+
+  return '#' +
+    ((redAsHex.length == 1 ? '0' : '') + redAsHex) +
+    ((greenAsHex.length == 1 ? '0' : '') + greenAsHex) +
+    ((blueAsHex.length == 1 ? '0' : '') + blueAsHex);
+}
+
+module.exports = shortenHsl;

web/node_modules/clean-css/lib/optimizer/level-1/shorten-rgb.js

@@ -0,0 +1,10 @@
+function shortenRgb(red, green, blue) {
+  var normalizedRed = Math.max(0, Math.min(parseInt(red), 255));
+  var normalizedGreen = Math.max(0, Math.min(parseInt(green), 255));
+  var normalizedBlue = Math.max(0, Math.min(parseInt(blue), 255));
+
+  // Credit: Asen  http://jsbin.com/UPUmaGOc/2/edit?js,console
+  return '#' + ('00000' + (normalizedRed << 16 | normalizedGreen << 8 | normalizedBlue).toString(16)).slice(-6);
+}
+
+module.exports = shortenRgb;

web/node_modules/clean-css/lib/optimizer/level-1/sort-selectors.js

@@ -0,0 +1,23 @@
+var naturalCompare = require('../../utils/natural-compare');
+
+function naturalSorter(scope1, scope2) {
+  return naturalCompare(scope1[1], scope2[1]);
+}
+
+function standardSorter(scope1, scope2) {
+  return scope1[1] > scope2[1] ? 1 : -1;
+}
+
+function sortSelectors(selectors, method) {
+  switch (method) {
+    case 'natural':
+      return selectors.sort(naturalSorter);
+    case 'standard':
+      return selectors.sort(standardSorter);
+    case 'none':
+    case false:
+      return selectors;
+  }
+}
+
+module.exports = sortSelectors;

web/node_modules/clean-css/lib/optimizer/level-1/tidy-at-rule.js

@@ -0,0 +1,9 @@
+function tidyAtRule(value) {
+  return value
+    .replace(/\s+/g, ' ')
+    .replace(/url\(\s+/g, 'url(')
+    .replace(/\s+\)/g, ')')
+    .trim();
+}
+
+module.exports = tidyAtRule;

web/node_modules/clean-css/lib/optimizer/level-1/tidy-block.js

@@ -0,0 +1,23 @@
+var SUPPORTED_COMPACT_BLOCK_MATCHER = /^@media\W/;
+
+function tidyBlock(values, spaceAfterClosingBrace) {
+  var withoutSpaceAfterClosingBrace;
+  var i;
+
+  for (i = values.length - 1; i >= 0; i--) {
+    withoutSpaceAfterClosingBrace = !spaceAfterClosingBrace && SUPPORTED_COMPACT_BLOCK_MATCHER.test(values[i][1]);
+
+    values[i][1] = values[i][1]
+      .replace(/\n|\r\n/g, ' ')
+      .replace(/\s+/g, ' ')
+      .replace(/(,|:|\() /g, '$1')
+      .replace(/ \)/g, ')')
+      .replace(/'([a-zA-Z][a-zA-Z\d\-_]+)'/, '$1')
+      .replace(/"([a-zA-Z][a-zA-Z\d\-_]+)"/, '$1')
+      .replace(withoutSpaceAfterClosingBrace ? /\) /g : null, ')');
+  }
+
+  return values;
+}
+
+module.exports = tidyBlock;

web/node_modules/clean-css/lib/optimizer/level-1/tidy-rules.js

@@ -0,0 +1,213 @@
+var Spaces = require('../../options/format').Spaces;
+var Marker = require('../../tokenizer/marker');
+var formatPosition = require('../../utils/format-position');
+
+var CASE_ATTRIBUTE_PATTERN = /[\s"'][iI]\s*\]/;
+var CASE_RESTORE_PATTERN = /([\d\w])([iI])\]/g;
+var DOUBLE_QUOTE_CASE_PATTERN = /="([a-zA-Z][a-zA-Z\d\-_]+)"([iI])/g;
+var DOUBLE_QUOTE_PATTERN = /="([a-zA-Z][a-zA-Z\d\-_]+)"(\s|\])/g;
+var HTML_COMMENT_PATTERN = /^(?:(?:<!--|-->)\s*)+/;
+var SINGLE_QUOTE_CASE_PATTERN = /='([a-zA-Z][a-zA-Z\d\-_]+)'([iI])/g;
+var SINGLE_QUOTE_PATTERN = /='([a-zA-Z][a-zA-Z\d\-_]+)'(\s|\])/g;
+var RELATION_PATTERN = /[>\+~]/;
+var WHITESPACE_PATTERN = /\s/;
+
+var ASTERISK_PLUS_HTML_HACK = '*+html ';
+var ASTERISK_FIRST_CHILD_PLUS_HTML_HACK = '*:first-child+html ';
+var LESS_THAN = '<';
+
+function hasInvalidCharacters(value) {
+  var isEscaped;
+  var isInvalid = false;
+  var character;
+  var isQuote = false;
+  var i, l;
+
+  for (i = 0, l = value.length; i < l; i++) {
+    character = value[i];
+
+    if (isEscaped) {
+      // continue as always
+    } else if (character == Marker.SINGLE_QUOTE || character == Marker.DOUBLE_QUOTE) {
+      isQuote = !isQuote;
+    } else if (!isQuote && (character == Marker.CLOSE_CURLY_BRACKET || character == Marker.EXCLAMATION || character == LESS_THAN || character == Marker.SEMICOLON)) {
+      isInvalid = true;
+      break;
+    } else if (!isQuote && i === 0 && RELATION_PATTERN.test(character)) {
+      isInvalid = true;
+      break;
+    }
+
+    isEscaped = character == Marker.BACK_SLASH;
+  }
+
+  return isInvalid;
+}
+
+function removeWhitespace(value, format) {
+  var stripped = [];
+  var character;
+  var isNewLineNix;
+  var isNewLineWin;
+  var isEscaped;
+  var wasEscaped;
+  var isQuoted;
+  var isSingleQuoted;
+  var isDoubleQuoted;
+  var isAttribute;
+  var isRelation;
+  var isWhitespace;
+  var roundBracketLevel = 0;
+  var wasRelation = false;
+  var wasWhitespace = false;
+  var withCaseAttribute = CASE_ATTRIBUTE_PATTERN.test(value);
+  var spaceAroundRelation = format && format.spaces[Spaces.AroundSelectorRelation];
+  var i, l;
+
+  for (i = 0, l = value.length; i < l; i++) {
+    character = value[i];
+
+    isNewLineNix = character == Marker.NEW_LINE_NIX;
+    isNewLineWin = character == Marker.NEW_LINE_NIX && value[i - 1] == Marker.CARRIAGE_RETURN;
+    isQuoted = isSingleQuoted || isDoubleQuoted;
+    isRelation = !isAttribute && !isEscaped && roundBracketLevel === 0 && RELATION_PATTERN.test(character);
+    isWhitespace = WHITESPACE_PATTERN.test(character);
+
+    if (wasEscaped && isQuoted && isNewLineWin) {
+      // swallow escaped new windows lines in comments
+      stripped.pop();
+      stripped.pop();
+    } else if (isEscaped && isQuoted && isNewLineNix) {
+      // swallow escaped new *nix lines in comments
+      stripped.pop();
+    } else if (isEscaped) {
+      stripped.push(character);
+    } else if (character == Marker.OPEN_SQUARE_BRACKET && !isQuoted) {
+      stripped.push(character);
+      isAttribute = true;
+    } else if (character == Marker.CLOSE_SQUARE_BRACKET && !isQuoted) {
+      stripped.push(character);
+      isAttribute = false;
+    } else if (character == Marker.OPEN_ROUND_BRACKET && !isQuoted) {
+      stripped.push(character);
+      roundBracketLevel++;
+    } else if (character == Marker.CLOSE_ROUND_BRACKET && !isQuoted) {
+      stripped.push(character);
+      roundBracketLevel--;
+    } else if (character == Marker.SINGLE_QUOTE && !isQuoted) {
+      stripped.push(character);
+      isSingleQuoted = true;
+    } else if (character == Marker.DOUBLE_QUOTE && !isQuoted) {
+      stripped.push(character);
+      isDoubleQuoted = true;
+    } else if (character == Marker.SINGLE_QUOTE && isQuoted) {
+      stripped.push(character);
+      isSingleQuoted = false;
+    } else if (character == Marker.DOUBLE_QUOTE && isQuoted) {
+      stripped.push(character);
+      isDoubleQuoted = false;
+    } else if (isWhitespace && wasRelation && !spaceAroundRelation) {
+      continue;
+    } else if (!isWhitespace && wasRelation && spaceAroundRelation) {
+      stripped.push(Marker.SPACE);
+      stripped.push(character);
+    } else if (isWhitespace && (isAttribute || roundBracketLevel > 0) && !isQuoted) {
+      // skip space
+    } else if (isWhitespace && wasWhitespace && !isQuoted) {
+      // skip extra space
+    } else if ((isNewLineWin || isNewLineNix) && (isAttribute || roundBracketLevel > 0) && isQuoted) {
+      // skip newline
+    } else if (isRelation && wasWhitespace && !spaceAroundRelation) {
+      stripped.pop();
+      stripped.push(character);
+    } else if (isRelation && !wasWhitespace && spaceAroundRelation) {
+      stripped.push(Marker.SPACE);
+      stripped.push(character);
+    } else if (isWhitespace) {
+      stripped.push(Marker.SPACE);
+    } else {
+      stripped.push(character);
+    }
+
+    wasEscaped = isEscaped;
+    isEscaped = character == Marker.BACK_SLASH;
+    wasRelation = isRelation;
+    wasWhitespace = isWhitespace;
+  }
+
+  return withCaseAttribute ?
+    stripped.join('').replace(CASE_RESTORE_PATTERN, '$1 $2]') :
+    stripped.join('');
+}
+
+function removeQuotes(value) {
+  if (value.indexOf('\'') == -1 && value.indexOf('"') == -1) {
+    return value;
+  }
+
+  return value
+    .replace(SINGLE_QUOTE_CASE_PATTERN, '=$1 $2')
+    .replace(SINGLE_QUOTE_PATTERN, '=$1$2')
+    .replace(DOUBLE_QUOTE_CASE_PATTERN, '=$1 $2')
+    .replace(DOUBLE_QUOTE_PATTERN, '=$1$2');
+}
+
+function tidyRules(rules, removeUnsupported, adjacentSpace, format, warnings) {
+  var list = [];
+  var repeated = [];
+
+  function removeHTMLComment(rule, match) {
+    warnings.push('HTML comment \'' + match + '\' at ' + formatPosition(rule[2][0]) + '. Removing.');
+    return '';
+  }
+
+  for (var i = 0, l = rules.length; i < l; i++) {
+    var rule = rules[i];
+    var reduced = rule[1];
+
+    reduced = reduced.replace(HTML_COMMENT_PATTERN, removeHTMLComment.bind(null, rule));
+
+    if (hasInvalidCharacters(reduced)) {
+      warnings.push('Invalid selector \'' + rule[1] + '\' at ' + formatPosition(rule[2][0]) + '. Ignoring.');
+      continue;
+    }
+
+    reduced = removeWhitespace(reduced, format);
+    reduced = removeQuotes(reduced);
+
+    if (adjacentSpace && reduced.indexOf('nav') > 0) {
+      reduced = reduced.replace(/\+nav(\S|$)/, '+ nav$1');
+    }
+
+    if (removeUnsupported && reduced.indexOf(ASTERISK_PLUS_HTML_HACK) > -1) {
+      continue;
+    }
+
+    if (removeUnsupported && reduced.indexOf(ASTERISK_FIRST_CHILD_PLUS_HTML_HACK) > -1) {
+      continue;
+    }
+
+    if (reduced.indexOf('*') > -1) {
+      reduced = reduced
+        .replace(/\*([:#\.\[])/g, '$1')
+        .replace(/^(\:first\-child)?\+html/, '*$1+html');
+    }
+
+    if (repeated.indexOf(reduced) > -1) {
+      continue;
+    }
+
+    rule[1] = reduced;
+    repeated.push(reduced);
+    list.push(rule);
+  }
+
+  if (list.length == 1 && list[0][1].length === 0) {
+    warnings.push('Empty selector \'' + list[0][1] + '\' at ' + formatPosition(list[0][2][0]) + '. Ignoring.');
+    list = [];
+  }
+
+  return list;
+}
+
+module.exports = tidyRules;