ruby-clean-css 0.0.2

data/lib/javascript/clean-css/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2011-2014 GoalSmashers.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished
+to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

data/lib/javascript/clean-css/README.md

@@ -0,0 +1,218 @@
+[![NPM version](https://badge.fury.io/js/clean-css.svg)](https://badge.fury.io/js/clean-css)
+[![Build Status](https://secure.travis-ci.org/GoalSmashers/clean-css.svg)](https://travis-ci.org/GoalSmashers/clean-css)
+[![Dependency Status](https://david-dm.org/GoalSmashers/clean-css.svg?theme=shields.io)](https://david-dm.org/GoalSmashers/clean-css)
+[![devDependency Status](https://david-dm.org/GoalSmashers/clean-css/dev-status.svg?theme=shields.io)](https://david-dm.org/GoalSmashers/clean-css#info=devDependencies)
+
+## What is clean-css?
+
+Clean-css is a fast and efficient [Node.js](http://nodejs.org/) library for minifying CSS files.
+
+According to [tests](http://goalsmashers.github.io/css-minification-benchmark/) it is one of the best available.
+
+
+## Usage
+
+### What are the requirements?
+
+```
+Node.js 0.8.0+ (tested on CentOS, Ubuntu, OS X 10.6+, and Windows 7+)
+```
+
+### How to install clean-css?
+
+```
+npm install clean-css
+```
+
+### How to upgrade clean-css from 1.x to 2.x?
+
+#### Command-line interface (CLI)
+
+```
+npm update clean-css
+```
+
+or point `package.json` to version 2.x. That's it!
+
+#### Node.js module
+
+Update `clean-css` as for CLI above.
+Then change your JavaScript code from:
+
+```js
+var minimized = CleanCSS.process(source, options);
+```
+
+into
+
+```js
+var minimized = new CleanCSS(options).minify(source);
+```
+
+And you are done.
+
+### How to use clean-css CLI?
+
+Clean-css accepts the following command line arguments (please make sure
+you use `<source-file>` as the very last argument to avoid potential issues):
+
+```
+cleancss [options] source-file, [source-file, ...]
+
+-h, --help                      Output usage information
+-v, --version                   Output the version number
+-b, --keep-line-breaks          Keep line breaks
+--s0                            Remove all special comments, i.e. /*! comment */
+--s1                            Remove all special comments but the first one
+-r, --root [root-path]          A root path to which resolve absolute @import rules
+                                and rebase relative URLs
+-o, --output [output-file]      Use [output-file] as output instead of STDOUT
+-s, --skip-import               Disable @import processing
+--skip-rebase                   Disable URLs rebasing
+--skip-advanced                 Disable advanced optimizations - selector & property merging,
+                                reduction, etc.
+--skip-aggressive-merging       Disable properties merging based on their order
+--rounding-precision [value]    Rounding precision, defaults to 2
+-c, --compatibility [ie7|ie8]   Force compatibility mode
+-d, --debug                     Shows debug information (minification time & compression efficiency)
+```
+
+#### Examples:
+
+To minify a **public.css** file into **public-min.css** do:
+
+```
+cleancss -o public-min.css public.css
+```
+
+To minify the same **public.css** into the standard output skip the `-o` parameter:
+
+```
+cleancss public.css
+```
+
+More likely you would like to concatenate a couple of files.
+If you are on a Unix-like system:
+
+```bash
+cat one.css two.css three.css | cleancss -o merged-and-minified.css
+```
+
+On Windows:
+
+```bat
+type one.css two.css three.css | cleancss -o merged-and-minified.css
+```
+
+Or even gzip the result at once:
+
+```bash
+cat one.css two.css three.css | cleancss | gzip -9 -c > merged-minified-and-gzipped.css.gz
+```
+
+### How to use clean-css programmatically?
+
+```js
+var CleanCSS = require('clean-css');
+var source = 'a{font-weight:bold;}';
+var minimized = new CleanCSS().minify(source);
+```
+
+CleanCSS constructor accepts a hash as a parameter, i.e.,
+`new CleanCSS(options).minify(source)` with the following options available:
+
+* `keepSpecialComments` - `*` for keeping all (default), `1` for keeping first one only, `0` for removing all
+* `keepBreaks` - whether to keep line breaks (default is false)
+* `benchmark` - turns on benchmarking mode measuring time spent on cleaning up
+  (run `npm run bench` to see example)
+* `root` - path to resolve absolute `@import` rules and rebase relative URLs
+* `relativeTo` - path with which to resolve relative `@import` rules and URLs
+* `processImport` - whether to process `@import` rules
+* `noRebase` - whether to skip URLs rebasing
+* `noAdvanced` - set to true to disable advanced optimizations - selector & property merging, reduction, etc.
+* `roundingPrecision` - Rounding precision, defaults to 2.
+* `compatibility` - Force compatibility mode to `ie7` or `ie8`. Defaults to not set.
+* `debug` - set to true to get minification statistics under `stats` property (see `test/custom-test.js` for examples)
+
+### How to use clean-css with build tools?
+
+* [Broccoli](https://github.com/broccolijs/broccoli#broccoli) : [broccoli-clean-css](https://github.com/shinnn/broccoli-clean-css)
+* [Brunch](http://brunch.io/) : [clean-css-brunch](https://github.com/brunch/clean-css-brunch)
+* [Grunt](http://gruntjs.com) : [grunt-contrib-cssmin](https://github.com/gruntjs/grunt-contrib-cssmin)
+* [Gulp](http://gulpjs.com/) : [gulp-minify-css](https://github.com/jonathanepollack/gulp-minify-css)
+* [component-builder2](https://github.com/component/builder2.js) : [builder-clean-css](https://github.com/poying/builder-clean-css)
+* [Metalsmith](http://metalsmith.io) : [metalsmith-clean-css](https://github.com/aymericbeaumet/metalsmith-clean-css)
+
+### What are the clean-css' dev commands?
+
+First clone the source, then run:
+
+* `npm run bench` for clean-css benchmarks (see [test/bench.js](https://github.com/GoalSmashers/clean-css/blob/master/test/bench.js) for details)
+* `npm run check` to check JS sources with [JSHint](https://github.com/jshint/jshint/)
+* `npm test` for the test suite
+
+## How to contribute to clean-css?
+
+1. Fork it.
+2. Add test(s) veryfying the problem.
+3. Fix the problem.
+4. Make sure all tests still pass (`npm test`).
+5. Make sure your code doesn't break style rules (`npm run check`) and follow all [other ones](https://github.com/GoalSmashers/clean-css/wiki/Style-Guide) too.
+6. Send a PR.
+
+If you wonder where to add tests, go for:
+
+* `test/unit-test.js` if it's a simple scenario
+* `test/data/...` if it's a complex scenario (just add two files, input and expected output)
+* `test/binary-test.js` if it's related to `bin/cleancss` binary
+* `test/module-test.js` if it's related to importing `clean-css` as a module
+* `test/protocol-imports-test.js` if it fixes anything related to protocol `@import`s
+
+## Tips & Tricks
+
+### How to preserve a comment block?
+
+Use the `/*!` notation instead of the standard one `/*`:
+
+```css
+/*!
+  Important comments included in minified output.
+*/
+```
+
+### How to rebase relative image URLs
+
+Clean-css will handle it automatically for you (since version 1.1) in the following cases:
+
+* When using the CLI:
+  1. Use an output path via `-o`/`--output` to rebase URLs as relative to the output file.
+  2. Use a root path via `-r`/`--root` to rebase URLs as absolute from the given root path.
+  3. If you specify both then `-r`/`--root` takes precendence.
+* When using clean-css as a library:
+  1. Use a combination of `relativeTo` and `target` options for relative rebase (same as 1 in CLI).
+  2. Use a combination of `relativeTo` and `root` options for absolute rebase (same as 2 in CLI).
+  3. `root` takes precendence over `target` as in CLI.
+
+## Acknowledgments (sorted alphabetically)
+
+* Anthony Barre ([@abarre](https://github.com/abarre)) for improvements to
+  `@import` processing, namely introducing the `--skip-import` /
+  `processImport` options.
+* Simon Altschuler ([@altschuler](https://github.com/altschuler)) for fixing
+  `@import` processing inside comments.
+* Isaac ([@facelessuser](https://github.com/facelessuser)) for pointing out
+  a flaw in clean-css' stateless mode.
+* Jan Michael Alonzo ([@jmalonzo](https://github.com/jmalonzo)) for a patch
+  removing node.js' old `sys` package.
+* Timur Kristóf ([@Venemo](https://github.com/Venemo)) for an outstanding
+  contribution of advanced property optimizer for 2.2 release.
+* Vincent Voyer ([@vvo](https://github.com/vvo)) for a patch with better
+  empty element regex and for inspiring us to do many performance improvements
+  in 0.4 release.
+* [@XhmikosR](https://github.com/XhmikosR) for suggesting new features
+  (option to remove special comments and strip out URLs quotation) and
+  pointing out numerous improvements (JSHint, media queries).
+
+## License
+
+Clean-css is released under the [MIT License](https://github.com/GoalSmashers/clean-css/blob/master/LICENSE).

data/lib/javascript/clean-css/bin/cleancss

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+
+var util = require('util');
+var fs = require('fs');
+var path = require('path');
+var CleanCSS = require('../index');
+
+var commands = require('commander');
+
+var packageConfig = fs.readFileSync(path.join(path.dirname(fs.realpathSync(process.argv[1])), '../package.json'));
+var buildVersion = JSON.parse(packageConfig).version;
+
+var isWindows = process.platform == 'win32';
+
+// Specify commander options to parse command line params correctly
+commands
+  .version(buildVersion, '-v, --version')
+  .usage('[options] source-file, [source-file, ...]')
+  .option('-b, --keep-line-breaks', 'Keep line breaks')
+  .option('--s0', 'Remove all special comments, i.e. /*! comment */')
+  .option('--s1', 'Remove all special comments but the first one')
+  .option('-r, --root [root-path]', 'Set a root path to which resolve absolute @import rules')
+  .option('-o, --output [output-file]', 'Use [output-file] as output instead of STDOUT')
+  .option('-s, --skip-import', 'Disable @import processing')
+  .option('--skip-rebase', 'Disable URLs rebasing')
+  .option('--skip-advanced', 'Disable advanced optimizations - selector & property merging, reduction, etc.')
+  .option('--skip-aggressive-merging', 'Disable properties merging based on their order')
+  .option('--rounding-precision [value]', 'Rounding precision, defaults to 2', parseInt)
+  .option('-c, --compatibility [ie7|ie8]', 'Force compatibility mode')
+  .option('-t, --timeout [seconds]', 'Per connection timeout when fetching remote @imports (defaults to 5 seconds)')
+  .option('-d, --debug', 'Shows debug information (minification time & compression efficiency)');
+
+commands.on('--help', function() {
+  util.puts('  Examples:\n');
+  util.puts('    %> cleancss one.css');
+  util.puts('    %> cleancss -o one-min.css one.css');
+  if (isWindows) {
+    util.puts('    %> type one.css two.css three.css | cleancss -o merged-and-minified.css');
+  } else {
+    util.puts('    %> cat one.css two.css three.css | cleancss -o merged-and-minified.css');
+    util.puts('    %> cat one.css two.css three.css | cleancss | gzip -9 -c > merged-minified-and-gzipped.css.gz');
+  }
+  util.puts('');
+  process.exit();
+});
+
+commands.parse(process.argv);
+
+var options = {
+  sources: null,
+  target: null
+};
+var cleanOptions = {};
+var fromStdin = !process.env.__DIRECT__ && !process.stdin.isTTY;
+
+// If no sensible data passed in just print help and exit
+if (!fromStdin && commands.args.length === 0) {
+  commands.outputHelp();
+  return 0;
+}
+
+// Now coerce commands into CleanCSS configuration...
+if (commands.output)
+  cleanOptions.target = options.target = commands.output;
+if (commands.keepLineBreaks)
+  cleanOptions.keepBreaks = true;
+if (commands.s1)
+  cleanOptions.keepSpecialComments = 1;
+if (commands.s0)
+  cleanOptions.keepSpecialComments = 0;
+if (commands.root)
+  cleanOptions.root = commands.root;
+if (commands.skipImport)
+  cleanOptions.processImport = false;
+if (commands.skipRebase)
+  cleanOptions.noRebase = true;
+if (commands.skipAdvanced)
+  cleanOptions.noAdvanced = true;
+if (commands.skipAggressiveMerging)
+  cleanOptions.noAggressiveMerging = true;
+if (commands.compatibility)
+  cleanOptions.compatibility = commands.compatibility;
+if (commands.roundingPrecision !== undefined)
+  cleanOptions.roundingPrecision = commands.roundingPrecision;
+if (commands.debug)
+  cleanOptions.debug = true;
+if (commands.timeout)
+  cleanOptions.inliner = { timeout: parseFloat(commands.timeout) * 1000 };
+if (commands.args.length > 0) {
+  var relativeTo = (cleanOptions.noRebase ? false : cleanOptions.root) || commands.args[0];
+  cleanOptions.relativeTo = path.dirname(path.resolve(relativeTo));
+
+  options.sources = commands.args.map(function(source) {
+    var isRemote = /^https?:\/\//.test(source);
+
+    if (cleanOptions.processImport === false)
+      source += '@shallow';
+
+    return isRemote ?
+      source :
+      path.relative(cleanOptions.relativeTo, path.resolve(source));
+  });
+}
+
+// ... and do the magic!
+if (options.sources) {
+  var data = options.sources
+    .map(function(source) {
+      return '@import url(' + source + ');';
+    })
+    .join('');
+  minify(data);
+} else {
+  var stdin = process.openStdin();
+  stdin.setEncoding('utf-8');
+  var data = '';
+  stdin.on('data', function(chunk) {
+    data += chunk;
+  });
+  stdin.on('end', function() {
+    minify(data);
+  });
+}
+
+function minify(data) {
+  new CleanCSS(cleanOptions).minify(data, function(errors, minified) {
+    if (cleanOptions.debug) {
+      console.error('Original: %d bytes', this.stats.originalSize);
+      console.error('Minified: %d bytes', this.stats.minifiedSize);
+      console.error('Efficiency: %d%', ~~(this.stats.efficiency * 10000) / 100.0);
+      console.error('Time spent: %dms', this.stats.timeSpent);
+    }
+
+    outputFeedback(this.errors, true);
+    outputFeedback(this.warnings);
+
+    if (this.errors.length > 0)
+      process.exit(1);
+
+    output(minified);
+  });
+}
+
+function output(minified) {
+  if (options.target)
+    fs.writeFileSync(options.target, minified, 'utf8');
+  else
+    process.stdout.write(minified);
+}
+
+function outputFeedback(messages, isError) {
+  var prefix = isError ? '\x1B[31mERROR\x1B[39m:' : 'WARNING:';
+
+  messages.forEach(function(message) {
+    console.error('%s %s', prefix, message);
+  });
+}

data/lib/javascript/clean-css/index.js

@@ -0,0 +1 @@
+module.exports = require('./lib/clean');

data/lib/javascript/clean-css/lib/clean.js

@@ -0,0 +1,426 @@
+/**
+ * Clean-css - https://github.com/GoalSmashers/clean-css
+ * Released under the terms of MIT license
+ *
+ * Copyright (C) 2011-2014 GoalSmashers.com
+ */
+
+var ColorShortener = require('./colors/shortener');
+var ColorHSLToHex = require('./colors/hsl-to-hex');
+var ColorRGBToHex = require('./colors/rgb-to-hex');
+var ColorLongToShortHex = require('./colors/long-to-short-hex');
+
+var ImportInliner = require('./imports/inliner');
+var UrlRebase = require('./images/url-rebase');
+var EmptyRemoval = require('./selectors/empty-removal');
+
+var CommentsProcessor = require('./text/comments');
+var ExpressionsProcessor = require('./text/expressions');
+var FreeTextProcessor = require('./text/free');
+var UrlsProcessor = require('./text/urls');
+var NameQuotesProcessor = require('./text/name-quotes');
+var Splitter = require('./text/splitter');
+
+var SelectorsOptimizer = require('./selectors/optimizer');
+
+var CleanCSS = module.exports = function CleanCSS(options) {
+  options = options || {};
+
+  // back compat
+  if (!(this instanceof CleanCSS))
+    return new CleanCSS(options);
+
+  options.keepBreaks = options.keepBreaks || false;
+
+  //active by default
+  if (undefined === options.processImport)
+    options.processImport = true;
+
+  this.options = options;
+  this.stats = {};
+  this.context = {
+    errors: [],
+    warnings: [],
+    debug: options.debug
+  };
+  this.errors = this.context.errors;
+  this.warnings = this.context.warnings;
+  this.lineBreak = process.platform == 'win32' ? '\r\n' : '\n';
+};
+
+CleanCSS.prototype.minify = function(data, callback) {
+  var options = this.options;
+
+  if (Buffer.isBuffer(data))
+    data = data.toString();
+
+  if (options.processImport || data.indexOf('@shallow') > 0) {
+    // inline all imports
+    var self = this;
+    var runner = callback ?
+      process.nextTick :
+      function(callback) { return callback(); };
+
+    return runner(function() {
+      return new ImportInliner(self.context, options.inliner).process(data, {
+        localOnly: !callback,
+        root: options.root || process.cwd(),
+        relativeTo: options.relativeTo,
+        whenDone: function(data) {
+          return minify.call(self, data, callback);
+        }
+      });
+    });
+  } else {
+    return minify.call(this, data, callback);
+  }
+};
+
+var minify = function(data, callback) {
+  var startedAt;
+  var stats = this.stats;
+  var options = this.options;
+  var context = this.context;
+  var lineBreak = this.lineBreak;
+
+  var commentsProcessor = new CommentsProcessor(
+    'keepSpecialComments' in options ? options.keepSpecialComments : '*',
+    options.keepBreaks,
+    lineBreak
+  );
+  var expressionsProcessor = new ExpressionsProcessor();
+  var freeTextProcessor = new FreeTextProcessor();
+  var urlsProcessor = new UrlsProcessor();
+  var nameQuotesProcessor = new NameQuotesProcessor();
+
+  if (options.debug) {
+    this.startedAt = process.hrtime();
+    this.stats.originalSize = data.length;
+  }
+
+  var replace = function() {
+    if (typeof arguments[0] == 'function')
+      arguments[0]();
+    else
+      data = data.replace.apply(data, arguments);
+  };
+
+  // replace function
+  if (options.benchmark) {
+    var originalReplace = replace;
+    replace = function(pattern, replacement) {
+      var name = typeof pattern == 'function' ?
+        /function (\w+)\(/.exec(pattern.toString())[1] :
+        pattern;
+
+      var start = process.hrtime();
+      originalReplace(pattern, replacement);
+
+      var itTook = process.hrtime(start);
+      console.log('%d ms: ' + name, 1000 * itTook[0] + itTook[1] / 1000000);
+    };
+  }
+
+  if (options.debug) {
+    startedAt = process.hrtime();
+    stats.originalSize = data.length;
+  }
+
+  replace(function escapeComments() {
+    data = commentsProcessor.escape(data);
+  });
+
+  // replace all escaped line breaks
+  replace(/\\(\r\n|\n)/gm, '');
+
+  // strip parentheses in urls if possible (no spaces inside)
+  replace(/url\((['"])([^\)]+)['"]\)/g, function(match, quote, url) {
+    var unsafeDataURI = url.indexOf('data:') === 0 && url.match(/data:\w+\/[^;]+;base64,/) === null;
+    if (url.match(/[ \t]/g) !== null || unsafeDataURI)
+      return 'url(' + quote + url + quote + ')';
+    else
+      return 'url(' + url + ')';
+  });
+
+  // strip parentheses in animation & font names
+  replace(function removeQuotes() {
+    data = nameQuotesProcessor.process(data);
+  });
+
+  // strip parentheses in @keyframes
+  replace(/@(\-moz\-|\-o\-|\-webkit\-)?keyframes ([^{]+)/g, function(match, prefix, name) {
+    prefix = prefix || '';
+    return '@' + prefix + 'keyframes ' + (name.indexOf(' ') > -1 ? name : name.replace(/['"]/g, ''));
+  });
+
+  // IE shorter filters, but only if single (IE 7 issue)
+  replace(/progid:DXImageTransform\.Microsoft\.(Alpha|Chroma)(\([^\)]+\))([;}'"])/g, function(match, filter, args, suffix) {
+    return filter.toLowerCase() + args + suffix;
+  });
+
+  replace(function escapeExpressions() {
+    data = expressionsProcessor.escape(data);
+  });
+
+  // strip parentheses in attribute values
+  replace(/\[([^\]]+)\]/g, function(match, content) {
+    var eqIndex = content.indexOf('=');
+    var singleQuoteIndex = content.indexOf('\'');
+    var doubleQuoteIndex = content.indexOf('"');
+    if (eqIndex < 0 && singleQuoteIndex < 0 && doubleQuoteIndex < 0)
+      return match;
+    if (singleQuoteIndex === 0 || doubleQuoteIndex === 0)
+      return match;
+
+    var key = content.substring(0, eqIndex);
+    var value = content.substring(eqIndex + 1, content.length);
+
+    if (/^['"](?:[a-zA-Z][a-zA-Z\d\-_]+)['"]$/.test(value))
+      return '[' + key + '=' + value.substring(1, value.length - 1) + ']';
+    else
+      return match;
+  });
+
+  replace(function escapeFreeText() {
+    data = freeTextProcessor.escape(data);
+  });
+
+  replace(function escapeUrls() {
+    data = urlsProcessor.escape(data);
+  });
+
+  // remove invalid special declarations
+  replace(/@charset [^;]+;/ig, function (match) {
+    return match.indexOf('@charset') > -1 ? match : '';
+  });
+
+  // whitespace inside attribute selectors brackets
+  replace(/\[([^\]]+)\]/g, function(match) {
+    return match.replace(/\s/g, '');
+  });
+
+  // line breaks
+  replace(/[\r]?\n/g, ' ');
+
+  // multiple whitespace
+  replace(/[\t ]+/g, ' ');
+
+  // multiple semicolons (with optional whitespace)
+  replace(/;[ ]?;+/g, ';');
+
+  // multiple line breaks to one
+  replace(/ (?:\r\n|\n)/g, lineBreak);
+  replace(/(?:\r\n|\n)+/g, lineBreak);
+
+  // remove spaces around selectors
+  replace(/ ([+~>]) /g, '$1');
+
+  // remove extra spaces inside content
+  replace(/([!\(\{\}:;=,\n]) /g, '$1');
+  replace(/ ([!\)\{\};=,\n])/g, '$1');
+  replace(/(?:\r\n|\n)\}/g, '}');
+  replace(/([\{;,])(?:\r\n|\n)/g, '$1');
+  replace(/ :([^\{\};]+)([;}])/g, ':$1$2');
+
+  // restore spaces inside IE filters (IE 7 issue)
+  replace(/progid:[^(]+\(([^\)]+)/g, function(match) {
+    return match.replace(/,/g, ', ');
+  });
+
+  // trailing semicolons
+  replace(/;\}/g, '}');
+
+  replace(function hsl2Hex() {
+    data = new ColorHSLToHex(data).process();
+  });
+
+  replace(function rgb2Hex() {
+    data = new ColorRGBToHex(data).process();
+  });
+
+  replace(function longToShortHex() {
+    data = new ColorLongToShortHex(data).process();
+  });
+
+  replace(function shortenColors() {
+    data = new ColorShortener(data).process();
+  });
+
+  // replace font weight with numerical value
+  replace(/(font\-weight|font):(normal|bold)([ ;\}!])(\w*)/g, function(match, property, weight, suffix, next) {
+    if (suffix == ' ' && (next.indexOf('/') > -1 || next == 'normal' || /[1-9]00/.test(next)))
+      return match;
+
+    if (weight == 'normal')
+      return property + ':400' + suffix + next;
+    else if (weight == 'bold')
+      return property + ':700' + suffix + next;
+    else
+      return match;
+  });
+
+  // minus zero to zero
+  // repeated twice on purpose as if not it doesn't process rgba(-0,-0,-0,-0) correctly
+  var zerosRegexp = /(\s|:|,|\()\-0([^\.])/g;
+  replace(zerosRegexp, '$10$2');
+  replace(zerosRegexp, '$10$2');
+
+  // zero(s) + value to value
+  replace(/(\s|:|,)0+([1-9])/g, '$1$2');
+
+  // round pixels to 2nd decimal place
+  var precision = 'roundingPrecision' in options ? options.roundingPrecision : 2;
+  var decimalMultiplier = Math.pow(10, precision);
+  replace(new RegExp('\\.(\\d{' + (precision + 1) + ',})px', 'g'), function(match, decimalPlaces) {
+    return precision === 0 ?
+      'px' :
+      '.' + Math.round(parseFloat('.' + decimalPlaces) * decimalMultiplier) / decimalMultiplier + 'px';
+  });
+
+  // .0 to 0
+  // repeated twice on purpose as if not it doesn't process {padding: .0 .0 .0 .0} correctly
+  var leadingDecimalRegexp = /(\D)\.0+(\D)/g;
+  replace(leadingDecimalRegexp, '$10$2');
+  replace(leadingDecimalRegexp, '$10$2');
+
+  // fraction zeros removal
+  replace(/\.([1-9]*)0+(\D)/g, function(match, nonZeroPart, suffix) {
+    return (nonZeroPart.length > 0 ? '.' : '') + nonZeroPart + suffix;
+  });
+
+  // zero + unit to zero
+  var units = ['px', 'em', 'ex', 'cm', 'mm', 'in', 'pt', 'pc', '%'];
+  if (['ie7', 'ie8'].indexOf(options.compatibility) == -1)
+    units.push('rem');
+
+  replace(new RegExp('(\\s|:|,)\\-?0(?:' + units.join('|') + ')', 'g'), '$1' + '0');
+  replace(new RegExp('(\\s|:|,)\\-?(\\d+)\\.(\\D)', 'g'), '$1$2$3');
+  replace(new RegExp('rect\\(0(?:' + units.join('|') + ')', 'g'), 'rect(0');
+
+  // restore % in rgb/rgba and hsl/hsla
+  replace(/(rgb|rgba|hsl|hsla)\(([^\)]+)\)/g, function(match, colorFunction, colorDef) {
+    var tokens = colorDef.split(',');
+    var applies = colorFunction == 'hsl' || colorFunction == 'hsla' || tokens[0].indexOf('%') > -1;
+    if (!applies)
+      return match;
+
+    if (tokens[1].indexOf('%') == -1)
+      tokens[1] += '%';
+    if (tokens[2].indexOf('%') == -1)
+      tokens[2] += '%';
+    return colorFunction + '(' + tokens.join(',') + ')';
+  });
+
+  // transparent rgba/hsla to 'transparent' unless in compatibility mode
+  if (!options.compatibility) {
+    replace(/:([^;]*)(?:rgba|hsla)\(\d+,\d+%?,\d+%?,0\)/g, function (match, prefix) {
+      if (new Splitter(',').split(match).pop().indexOf('gradient(') > -1)
+        return match;
+
+      return ':' + prefix + 'transparent';
+    });
+  }
+
+  // none to 0
+  replace(/outline:none/g, 'outline:0');
+
+  // background:none to background:0 0
+  replace(/background:(?:none|transparent)([;}])/g, 'background:0 0$1');
+
+  // multiple zeros into one
+  replace(/box-shadow:0 0 0 0([^\.])/g, 'box-shadow:0 0$1');
+  replace(/:0 0 0 0([^\.])/g, ':0$1');
+  replace(/([: ,=\-])0\.(\d)/g, '$1.$2');
+
+  // restore rect(...) zeros syntax for 4 zeros
+  replace(/rect\(\s?0(\s|,)0[ ,]0[ ,]0\s?\)/g, 'rect(0$10$10$10)');
+
+  // remove universal selector when not needed (*#id, *.class etc)
+  replace(/\*([\.#:\[])/g, '$1');
+
+  // Restore spaces inside calc back
+  replace(/calc\([^\}]+\}/g, function(match) {
+    return match.replace(/\+/g, ' + ');
+  });
+
+  // get rid of IE hacks if not in compatibility mode
+  if (!options.compatibility)
+    replace(/([;\{])[\*_][\w\-]+:[^;\}]+/g, '$1');
+
+  if (options.noAdvanced) {
+    if (options.keepBreaks)
+      replace(/\}/g, '}' + lineBreak);
+  } else {
+    replace(function optimizeSelectors() {
+      data = new SelectorsOptimizer(data, context, {
+        keepBreaks: options.keepBreaks,
+        lineBreak: lineBreak,
+        compatibility: options.compatibility,
+        aggressiveMerging: !options.noAggressiveMerging
+      }).process();
+    });
+  }
+
+  // replace ' / ' in border-*-radius with '/'
+  replace(/(border-\w+-\w+-radius:\S+)\s+\/\s+/g, '$1/');
+
+  // replace same H/V values in border-radius
+  replace(/(border-\w+-\w+-radius):([^;\}]+)/g, function (match, property, value) {
+    var parts = value.split('/');
+
+    if (parts.length > 1 && parts[0] == parts[1])
+      return property + ':' + parts[0];
+    else
+      return match;
+  });
+
+  replace(function restoreUrls() {
+    data = urlsProcessor.restore(data);
+  });
+  replace(function rebaseUrls() {
+    data = options.noRebase ? data : new UrlRebase(options, context).process(data);
+  });
+  replace(function restoreFreeText() {
+    data = freeTextProcessor.restore(data);
+  });
+  replace(function restoreComments() {
+    data = commentsProcessor.restore(data);
+  });
+  replace(function restoreExpressions() {
+    data = expressionsProcessor.restore(data);
+  });
+
+  // move first charset to the beginning
+  replace(function moveCharset() {
+    // get first charset in stylesheet
+    var match = data.match(/@charset [^;]+;/);
+    var firstCharset = match ? match[0] : null;
+    if (!firstCharset)
+      return;
+
+    // reattach first charset and remove all subsequent
+    data = firstCharset +
+      (options.keepBreaks ? lineBreak : '') +
+      data.replace(new RegExp('@charset [^;]+;(' + lineBreak + ')?', 'g'), '').trim();
+  });
+
+  if (options.noAdvanced) {
+    replace(function removeEmptySelectors() {
+      data = new EmptyRemoval(data).process();
+    });
+  }
+
+  // trim spaces at beginning and end
+  data = data.trim();
+
+  if (options.debug) {
+    var elapsed = process.hrtime(startedAt);
+    stats.timeSpent = ~~(elapsed[0] * 1e3 + elapsed[1] / 1e6);
+    stats.efficiency = 1 - data.length / stats.originalSize;
+    stats.minifiedSize = data.length;
+  }
+
+  return callback ?
+    callback.call(this, this.context.errors.length > 0 ? this.context.errors : null, data) :
+    data;
+};