pleeease 0.0.2

data/node_modules/pleeease/node_modules/autoprefixer/node_modules/postcss/node_modules/source-map/test/source-map/test-util.js

@@ -0,0 +1,127 @@
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2014 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+if (typeof define !== 'function') {
+    var define = require('amdefine')(module, require);
+}
+define(function (require, exports, module) {
+
+  var libUtil = require('../../lib/source-map/util');
+
+  exports['test urls'] = function (assert, util) {
+    var assertUrl = function (url) {
+      assert.equal(url, libUtil.urlGenerate(libUtil.urlParse(url)));
+    };
+    assertUrl('http://');
+    assertUrl('http://www.example.com');
+    assertUrl('http://user:pass@www.example.com');
+    assertUrl('http://www.example.com:80');
+    assertUrl('http://www.example.com/');
+    assertUrl('http://www.example.com/foo/bar');
+    assertUrl('http://www.example.com/foo/bar/');
+    assertUrl('http://user:pass@www.example.com:80/foo/bar/');
+
+    assertUrl('//');
+    assertUrl('//www.example.com');
+    assertUrl('file:///www.example.com');
+
+    assert.equal(libUtil.urlParse('a//b'), null);
+  };
+
+  exports['test normalize()'] = function (assert, util) {
+    assert.equal(libUtil.normalize('/..'), '/');
+    assert.equal(libUtil.normalize('/../'), '/');
+    assert.equal(libUtil.normalize('/../../../..'), '/');
+    assert.equal(libUtil.normalize('/../../../../a/b/c'), '/a/b/c');
+    assert.equal(libUtil.normalize('/a/b/c/../../../d/../../e'), '/e');
+
+    assert.equal(libUtil.normalize('..'), '..');
+    assert.equal(libUtil.normalize('../'), '../');
+    assert.equal(libUtil.normalize('../../a/'), '../../a/');
+    assert.equal(libUtil.normalize('a/..'), '.');
+    assert.equal(libUtil.normalize('a/../../..'), '../..');
+
+    assert.equal(libUtil.normalize('/.'), '/');
+    assert.equal(libUtil.normalize('/./'), '/');
+    assert.equal(libUtil.normalize('/./././.'), '/');
+    assert.equal(libUtil.normalize('/././././a/b/c'), '/a/b/c');
+    assert.equal(libUtil.normalize('/a/b/c/./././d/././e'), '/a/b/c/d/e');
+
+    assert.equal(libUtil.normalize('.'), '.');
+    assert.equal(libUtil.normalize('./'), '.');
+    assert.equal(libUtil.normalize('././a'), 'a');
+    assert.equal(libUtil.normalize('a/./'), 'a/');
+    assert.equal(libUtil.normalize('a/././.'), 'a');
+
+    assert.equal(libUtil.normalize('/a/b//c////d/////'), '/a/b/c/d/');
+    assert.equal(libUtil.normalize('///a/b//c////d/////'), '///a/b/c/d/');
+    assert.equal(libUtil.normalize('a/b//c////d'), 'a/b/c/d');
+
+    assert.equal(libUtil.normalize('.///.././../a/b//./..'), '../../a')
+
+    assert.equal(libUtil.normalize('http://www.example.com'), 'http://www.example.com');
+    assert.equal(libUtil.normalize('http://www.example.com/'), 'http://www.example.com/');
+    assert.equal(libUtil.normalize('http://www.example.com/./..//a/b/c/.././d//'), 'http://www.example.com/a/b/d/');
+  };
+
+  exports['test join()'] = function (assert, util) {
+    assert.equal(libUtil.join('a', 'b'), 'a/b');
+    assert.equal(libUtil.join('a/', 'b'), 'a/b');
+    assert.equal(libUtil.join('a//', 'b'), 'a/b');
+    assert.equal(libUtil.join('a', 'b/'), 'a/b/');
+    assert.equal(libUtil.join('a', 'b//'), 'a/b/');
+    assert.equal(libUtil.join('a/', '/b'), '/b');
+    assert.equal(libUtil.join('a//', '//b'), '//b');
+
+    assert.equal(libUtil.join('a', '..'), '.');
+    assert.equal(libUtil.join('a', '../b'), 'b');
+    assert.equal(libUtil.join('a/b', '../c'), 'a/c');
+
+    assert.equal(libUtil.join('a', '.'), 'a');
+    assert.equal(libUtil.join('a', './b'), 'a/b');
+    assert.equal(libUtil.join('a/b', './c'), 'a/b/c');
+
+    assert.equal(libUtil.join('a', 'http://www.example.com'), 'http://www.example.com');
+    assert.equal(libUtil.join('a', 'data:foo,bar'), 'data:foo,bar');
+
+
+    assert.equal(libUtil.join('http://foo.org/a', 'b'), 'http://foo.org/a/b');
+    assert.equal(libUtil.join('http://foo.org/a/', 'b'), 'http://foo.org/a/b');
+    assert.equal(libUtil.join('http://foo.org/a//', 'b'), 'http://foo.org/a/b');
+    assert.equal(libUtil.join('http://foo.org/a', 'b/'), 'http://foo.org/a/b/');
+    assert.equal(libUtil.join('http://foo.org/a', 'b//'), 'http://foo.org/a/b/');
+    assert.equal(libUtil.join('http://foo.org/a/', '/b'), 'http://foo.org/b');
+    assert.equal(libUtil.join('http://foo.org/a//', '//b'), 'http://b');
+
+    assert.equal(libUtil.join('http://foo.org/a', '..'), 'http://foo.org/');
+    assert.equal(libUtil.join('http://foo.org/a', '../b'), 'http://foo.org/b');
+    assert.equal(libUtil.join('http://foo.org/a/b', '../c'), 'http://foo.org/a/c');
+
+    assert.equal(libUtil.join('http://foo.org/a', '.'), 'http://foo.org/a');
+    assert.equal(libUtil.join('http://foo.org/a', './b'), 'http://foo.org/a/b');
+    assert.equal(libUtil.join('http://foo.org/a/b', './c'), 'http://foo.org/a/b/c');
+
+    assert.equal(libUtil.join('http://foo.org/a', 'http://www.example.com'), 'http://www.example.com');
+    assert.equal(libUtil.join('http://foo.org/a', 'data:foo,bar'), 'data:foo,bar');
+
+
+    assert.equal(libUtil.join('http://foo.org', 'a'), 'http://foo.org/a');
+    assert.equal(libUtil.join('http://foo.org/', 'a'), 'http://foo.org/a');
+    assert.equal(libUtil.join('http://foo.org//', 'a'), 'http://foo.org/a');
+    assert.equal(libUtil.join('http://foo.org', '/a'), 'http://foo.org/a');
+    assert.equal(libUtil.join('http://foo.org/', '/a'), 'http://foo.org/a');
+    assert.equal(libUtil.join('http://foo.org//', '/a'), 'http://foo.org/a');
+
+
+    assert.equal(libUtil.join('http://', 'www.example.com'), 'http://www.example.com');
+    assert.equal(libUtil.join('file:///', 'www.example.com'), 'file:///www.example.com');
+    assert.equal(libUtil.join('http://', 'ftp://example.com'), 'ftp://example.com');
+
+    assert.equal(libUtil.join('http://www.example.com', '//foo.org/bar'), 'http://foo.org/bar');
+    assert.equal(libUtil.join('//www.example.com', '//foo.org/bar'), '//foo.org/bar');
+  };
+
+});

data/node_modules/pleeease/node_modules/autoprefixer/node_modules/postcss/node_modules/source-map/test/source-map/util.js

@@ -0,0 +1,161 @@
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+if (typeof define !== 'function') {
+    var define = require('amdefine')(module, require);
+}
+define(function (require, exports, module) {
+
+  var util = require('../../lib/source-map/util');
+
+  // This is a test mapping which maps functions from two different files
+  // (one.js and two.js) to a minified generated source.
+  //
+  // Here is one.js:
+  //
+  //   ONE.foo = function (bar) {
+  //     return baz(bar);
+  //   };
+  //
+  // Here is two.js:
+  //
+  //   TWO.inc = function (n) {
+  //     return n + 1;
+  //   };
+  //
+  // And here is the generated code (min.js):
+  //
+  //   ONE.foo=function(a){return baz(a);};
+  //   TWO.inc=function(a){return a+1;};
+  exports.testGeneratedCode = " ONE.foo=function(a){return baz(a);};\n"+
+                              " TWO.inc=function(a){return a+1;};";
+  exports.testMap = {
+    version: 3,
+    file: 'min.js',
+    names: ['bar', 'baz', 'n'],
+    sources: ['one.js', 'two.js'],
+    sourceRoot: '/the/root',
+    mappings: 'CAAC,IAAI,IAAM,SAAUA,GAClB,OAAOC,IAAID;CCDb,IAAI,IAAM,SAAUE,GAClB,OAAOA'
+  };
+  exports.testMapWithSourcesContent = {
+    version: 3,
+    file: 'min.js',
+    names: ['bar', 'baz', 'n'],
+    sources: ['one.js', 'two.js'],
+    sourcesContent: [
+      ' ONE.foo = function (bar) {\n' +
+      '   return baz(bar);\n' +
+      ' };',
+      ' TWO.inc = function (n) {\n' +
+      '   return n + 1;\n' +
+      ' };'
+    ],
+    sourceRoot: '/the/root',
+    mappings: 'CAAC,IAAI,IAAM,SAAUA,GAClB,OAAOC,IAAID;CCDb,IAAI,IAAM,SAAUE,GAClB,OAAOA'
+  };
+  exports.emptyMap = {
+    version: 3,
+    file: 'min.js',
+    names: [],
+    sources: [],
+    mappings: ''
+  };
+
+
+  function assertMapping(generatedLine, generatedColumn, originalSource,
+                         originalLine, originalColumn, name, map, assert,
+                         dontTestGenerated, dontTestOriginal) {
+    if (!dontTestOriginal) {
+      var origMapping = map.originalPositionFor({
+        line: generatedLine,
+        column: generatedColumn
+      });
+      assert.equal(origMapping.name, name,
+                   'Incorrect name, expected ' + JSON.stringify(name)
+                   + ', got ' + JSON.stringify(origMapping.name));
+      assert.equal(origMapping.line, originalLine,
+                   'Incorrect line, expected ' + JSON.stringify(originalLine)
+                   + ', got ' + JSON.stringify(origMapping.line));
+      assert.equal(origMapping.column, originalColumn,
+                   'Incorrect column, expected ' + JSON.stringify(originalColumn)
+                   + ', got ' + JSON.stringify(origMapping.column));
+
+      var expectedSource;
+
+      if (originalSource && map.sourceRoot && originalSource.indexOf(map.sourceRoot) === 0) {
+        expectedSource = originalSource;
+      } else if (originalSource) {
+        expectedSource = map.sourceRoot
+          ? util.join(map.sourceRoot, originalSource)
+          : originalSource;
+      } else {
+        expectedSource = null;
+      }
+
+      assert.equal(origMapping.source, expectedSource,
+                   'Incorrect source, expected ' + JSON.stringify(expectedSource)
+                   + ', got ' + JSON.stringify(origMapping.source));
+    }
+
+    if (!dontTestGenerated) {
+      var genMapping = map.generatedPositionFor({
+        source: originalSource,
+        line: originalLine,
+        column: originalColumn
+      });
+      assert.equal(genMapping.line, generatedLine,
+                   'Incorrect line, expected ' + JSON.stringify(generatedLine)
+                   + ', got ' + JSON.stringify(genMapping.line));
+      assert.equal(genMapping.column, generatedColumn,
+                   'Incorrect column, expected ' + JSON.stringify(generatedColumn)
+                   + ', got ' + JSON.stringify(genMapping.column));
+    }
+  }
+  exports.assertMapping = assertMapping;
+
+  function assertEqualMaps(assert, actualMap, expectedMap) {
+    assert.equal(actualMap.version, expectedMap.version, "version mismatch");
+    assert.equal(actualMap.file, expectedMap.file, "file mismatch");
+    assert.equal(actualMap.names.length,
+                 expectedMap.names.length,
+                 "names length mismatch: " +
+                   actualMap.names.join(", ") + " != " + expectedMap.names.join(", "));
+    for (var i = 0; i < actualMap.names.length; i++) {
+      assert.equal(actualMap.names[i],
+                   expectedMap.names[i],
+                   "names[" + i + "] mismatch: " +
+                     actualMap.names.join(", ") + " != " + expectedMap.names.join(", "));
+    }
+    assert.equal(actualMap.sources.length,
+                 expectedMap.sources.length,
+                 "sources length mismatch: " +
+                   actualMap.sources.join(", ") + " != " + expectedMap.sources.join(", "));
+    for (var i = 0; i < actualMap.sources.length; i++) {
+      assert.equal(actualMap.sources[i],
+                   expectedMap.sources[i],
+                   "sources[" + i + "] length mismatch: " +
+                   actualMap.sources.join(", ") + " != " + expectedMap.sources.join(", "));
+    }
+    assert.equal(actualMap.sourceRoot,
+                 expectedMap.sourceRoot,
+                 "sourceRoot mismatch: " +
+                   actualMap.sourceRoot + " != " + expectedMap.sourceRoot);
+    assert.equal(actualMap.mappings, expectedMap.mappings,
+                 "mappings mismatch:\nActual:   " + actualMap.mappings + "\nExpected: " + expectedMap.mappings);
+    if (actualMap.sourcesContent) {
+      assert.equal(actualMap.sourcesContent.length,
+                   expectedMap.sourcesContent.length,
+                   "sourcesContent length mismatch");
+      for (var i = 0; i < actualMap.sourcesContent.length; i++) {
+        assert.equal(actualMap.sourcesContent[i],
+                     expectedMap.sourcesContent[i],
+                     "sourcesContent[" + i + "] mismatch");
+      }
+    }
+  }
+  exports.assertEqualMaps = assertEqualMaps;
+
+});

data/node_modules/pleeease/node_modules/autoprefixer/node_modules/postcss/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "postcss",
+  "version": "0.3.5",
+  "description": "Framework for CSS postprocessors",
+  "keywords": [
+    "css",
+    "parser",
+    "postproccessor"
+  ],
+  "author": {
+    "name": "Andrey Sitnik",
+    "email": "andrey@sitnik.ru"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ai/postcss.git"
+  },
+  "dependencies": {
+    "source-map": "~0.1.33",
+    "base64-js": "~0.0.6"
+  },
+  "devDependencies": {
+    "coffee-script": "1.7.1",
+    "fs-extra": "0.9.1",
+    "gonzales": "1.0.7",
+    "rework": "0.20.3",
+    "should": "4.0.0",
+    "mocha": "1.20.0",
+    "cssom": "0.3.0"
+  },
+  "main": "lib/postcss",
+  "scripts": {
+    "test": "mocha"
+  },
+  "readme": "# PostCSS\n\nPostCSS is a framework for CSS postprocessors,\nto modify CSS with JavaScript.\n\nIt takes care of most common CSS tool tasks:\n\n1. parses CSS;\n2. gives you usable JS API to edit CSS node tree;\n3. dumps modified node tree into CSS string;\n4. generates (or modifies existent) source map for your changes;\n\nYou can use this framework to write you own:\n\n* CSS minifier or beautifizer.\n* CSS polyfills.\n* Grunt plugin to generate sprites, include `data-uri` images\n  or any other works.\n* Text editor plugin to automate CSS routine.\n* Command-line CSS tool.\n\nSponsored by [Evil Martians](http://evilmartians.com/).\n\n## Built with PostCSS\n\n* [Autoprefixer] adds vendor prefixes by Can I Use data.\n* [grunt-pixrem], `rem` unit polyfill.\n* [CSS MQPacker] joins same media queries.\n* [RTLCSS] mirrors styles for right-to-left locales.\n* [CSSWring] and [grunt-csswring] CSS minifier with full source map support.\n* [Grunt-webpcss] to duplicate images in CSS to WebP for supported browsers.\n* [Pleeease] is a pack of various postprocessors.\n\n[grunt-csswring]: https://github.com/princed/grunt-csswring\n[Grunt-webpcss]:  https://github.com/lexich/grunt-webpcss\n[Autoprefixer]:   https://github.com/ai/autoprefixer\n[grunt-pixrem]:   https://github.com/robwierzbowski/grunt-pixrem\n[CSS MQPacker]:   https://github.com/hail2u/node-css-mqpacker\n[Pleeease]:       http://pleeease.io/\n[CSSWring]:       https://github.com/hail2u/node-csswring\n[RTLCSS]:         https://github.com/MohammadYounes/rtlcss\n\n## Quick Example\n\nLet’s fix forgotten `content` property in `::before` and `::after`:\n\n```js\nvar postcss = require('postcss');\n\nvar contenter = postcss(function (css) {\n    css.eachRule(function (rule) {\n        if ( rule.selector.match(/::(before|after)/) ) {\n            // In every ::before/::after rule\n\n            // Did we forget content property?\n            var good = rule.some(function (i) { return i.prop == 'content'; });\n\n            if ( !good ) {\n                // Add content: \"\" if we forget it\n                rule.prepend({ prop: 'content', value: '\"\"' });\n            }\n\n        }\n    });\n});\n```\n\nAnd then CSS with forgotten `content`:\n\n```css\na::before {\n    width: 10px;\n    height: 10px\n}\n```\n\nwill be fixed by our new `contenter`:\n\n```js\nvar fixed = contenter.process(css).css;\n```\n\nto:\n\n```css\na::before {\n    content: \"\";\n    width: 10px;\n    height: 10px\n}\n```\n\n## Features\n\n### Source Map\n\nPostCSS generates source map for its changes:\n\n```js\nresult = processor.process(css, { map: true, from: 'from.css', to: 'to.css' });\nresult.css // String with processed CSS\nresult.map // Source map\n```\n\nAnd modifies source map from previous step (like Sass preprocessor):\n\n```js\nvar sassMap = fs.readFileSync('from.sass.css.map');\nprocessor.process(css, { map: sassMap, from: 'from.sass.css', to: 'to.css' });\n```\n\n### Preserves code formatting and indentations\n\nPostCSS will not change any byte of a rule if you don’t modify its node:\n\n```js\npostcss(function (css) { }).process(css).css == css;\n```\n\nAnd when you modify CSS nodes, PostCSS will try to copy coding style:\n\n```js\ncontenter.process(\"a::before{color:black}\")\n// a::before{content:'';color:black}\n\ncontenter.process(\"a::before {\\n  color: black;\\n  }\")\n// a::before {\n//   content: '';\n//   color: black;\n//   }\n```\n\n## Why PostCSS Better Than …\n\n### Preprocessors\n\nPreprocessors (like Sass or Stylus) give us special language with variables,\nmixins, statements and compile it to CSS. Compass, nib and other mixins\nlibraries use these languages to work with prefixes, sprites and inline images.\n\nBut Sass and Stylus languages were created to be syntax-sugar for CSS.\nWriting really complicated programs using preporcessor languages\nis very difficult. [Autoprefixer] is absolutely impossible to implement\non top of Sass.\n\nPostCSS gives you comfort and power of JS or CoffeeScript to working with CSS.\nYou can do really magic things with wide range of [npm] libraries.\n\nBut postprocessors are not enemies for preprocessors. Sass and Stylus are still\nthe best way to improve readability and add some syntax sugar to CSS.\nYou can easily combine preprocessors and postprocessors\n(and PostCSS will also update source map from Sass or Stylus).\n\n[Autoprefixer]: https://github.com/ai/autoprefixer\n[npm]:          https://npmjs.org/\n\n### RegExp\n\nSome Grunt plugins modify CSS with regular expressions but using a CSS parser\nand a node tree is a much safer way to edit CSS. Also, regexps will break\nsource maps generated by preprocessors.\n\n### CSS Parsers\n\nThere are a lot of good CSS parsers, like [Gonzales]. But they help you only\nwith first step.\n\nUnlike them PostCSS gives you full source map support and useful high level API\n(for example, safe iterators).\n\n[Gonzales]: https://github.com/css/gonzales\n\n### Rework\n\n[Rework] and PostCSS are very similar, but they has different targets.\n\nRework was created to build new CSS sublanguage to replace Stylus (like [Myth]).\nPostCSS was created for CSS tools, which works in chain with legacy CSS code\n(like Autoprefixer).\n\nBecause of this background difference, PostCSS:\n\n* better works with source map, because it should update map from previous step\n  (like Sass compiling)\n* saves all your spaces and code style, because it can be worked in text editor\n  plugins\n* has safer parser, because it can be used for legacy code\n* has high level API to clean your processor from common tasks\n\n[Myth]:   http://www.myth.io/\n[Rework]: https://github.com/visionmedia/rework\n\n## Usage\n\nYou can parse CSS by `postcss.parse()` method, which returns CSS AST:\n\n```js\nvar postcss = require('postcss');\n\nvar css = postcss.parse('a { color: black }');\n```\n\nThen you can change this AST. Use `css.list` to get childs.\nProperties `rule.selector`, `decl.prop`, `decl.value`, `atrule.name`\nand `atrule.params` contain data.\n\nDon’t use underscore properties (like `_selector`, `_params` and `_value`),\nbecause they are only for comments save magic\n(See [Raw Properties](#Raw Properties) below). Use getters and setters instead\n(like `selector`, `selectors`, `params` and `value`).\n\n```js\ncss.list[0].value = 'white';\n```\n\nAfter changes you can get new CSS and modification’s source map:\n\n```js\nvar result = css.toResult(options);\n\nresult.css //=> 'a { color: white }'\nresult.map //=> '{\"version\":3, … }'\n```\n\nMethods `postcss.parse()` and `CSS#toResult()` are low level API, for most cases\nit will be better to create processors with simplier API and chaining.\n\n### Processor\n\nThe function `postcss(fn)` creates a processor from your function:\n\n```js\nvar postcss = require('postcss');\n\nvar processor = postcss(function (css) {\n    // Code to modify CSS\n});\n```\n\nIf you want to combine multiple processors (and parse CSS only once),\nyou can add several functions using the `use(fn)` method:\n\n```js\nvar all = postcss().\n          use(prefixer).\n          use(minifing);\n```\n\nProcessor function can change the current CSS node tree:\n\n```js\npostcss(function (css) {\n    css.append( /* new rule */ )\n});\n```\n\nor create a completely new CSS root node and return it instead:\n\n```js\npostcss(function (css) {\n    var newCSS = postcss.root()\n    // Add rules and declarations\n    return newCSS;\n});\n```\n\nThis generated processor transforms some CSS using `process(css, opts)` method:\n\n```js\nvar doubler = postcss(function (css) {\n    // Clone each declaration\n    css.eachDecl(function (decl) {\n        decl.parent.prepend( decl.clone() );\n    });\n});\n\nvar css    = \"a { color: black; }\";\nvar result = doubler.process(css);\n\nresult.css //=> \"a { color: black; color: black; }\"\n```\n\nYou can set the original CSS filename via `from` option and make syntax error\nmessages much more helpful:\n\n```js\nvar wrong = \"a {\";\nprocessor.process(wrong, { from: 'main.css' });\n//=> Can't parse CSS: Unclosed block at line 1:1 in main.css\n```\n\nYou can also use result from previous postprocessor or already parsed `Root`\nas argument in next one:\n\n```js\nresult = processor1.process(css)\nprocessor2.process(result)\n```\n\n### Multiple Inputs\n\nThe function `postcss()` generates processor only for one input.\nIf you need to process several inputs (like in files concatenation) you can use\n`postcss.parse()`.\n\nLet’s join two CSS with source map support in 5 lines of code:\n\n```js\nvar file1 = postcss.parse(css1, { from: 'a.css' });\nvar file2 = postcss.parse(css2, { from: 'b.css' });\n\nfile1.rules = file1.rules.concat( file2.rules );\n\nvar result = file1.toResult({ to: 'app.css', map: true });\n```\n\n### Source Map\n\nPostCSS will generate a source map, if you set `map` option to `true`\nin the `process(css, opts)` method.\n\nYou must set input and output CSS files paths (using `from` and `to`\noptions respectively) to generate correct source map.\n\n```js\nvar result = processor.process(css, {\n    map:  true,\n    from: 'main.css',\n    to:   'main.out.css'\n});\n\nresult.map //=> '{\"version\":3,\"file\":\"main.out.css\",\"sources\":[\"main.css\"],\"names\":[],\"mappings\":\"AAAA,KAAI\"}'\n\nfs.writeFileSync('main.out.css.map', result.map);\n```\n\nPostCSS can also modify previous source map (for example, from Sass\ncompilation). So if you compile Sass to CSS and then minify this CSS\nby postprocessor, final source map will contain mapping from Sass code\nto minified CSS.\n\nJust set `map` option with an original source map (a string or a JS object):\n\n```js\nvar result = minifier.process(css, {\n    map:   fs.readFileSync('main.sass.css.map'),\n    from: 'main.sass.css',\n    to:   'main.min.css'\n});\n\nresult.map //=> Source map from main.sass to main.min.css\n```\n\nPostCSS try to autodetect previous map file. For example, if you process `a.css`\nand `a.css.map` is placed in same dir, PostCSS will read previous map and\ngenerate new one. You can disable autodetection by `map: false`.\n\nPostCSS, by default, will add annotation comment with path to new source map\nfile:\n\n```css\na { }\n/*# sourceMappingURL=main.out.css.map */\n```\n\nIf you want to remove annotation, set `mapAnnotation` option to `false`.\n\nInline maps are also supported. If input CSS will contain annotation\nfrom previous step with map in `data:uri`, PostCSS will update source map\nwith yours changes and inine new map back to output CSS.\n\nOption `inlineMap` will force PostCSS to inline new map to CSS:\n\n```js\nvar result = minifier.process(css, {\n    from:     'main.css',\n    to:       'main.min.css',\n    inlineMap: true\n});\n\nresult.map //=> undefined, because map is in CSS\nresult.css //=> \"a{}\\n/*# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFpbi5taW4uY3NzIiwic291cmNlcyI6WyJtYWluLmNzcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxJQUFLIn0= */\"\n```\n\n### Helpers\n\n#### Vendor\n\nPostCSS contains heigh optimized code to split vendor prefix:\n\n```js\nvar vendor = require('postcss/lib/vendor');\n\nvendor.prefix('-moz-tab-size')     //=> '-moz-'\nvendor.unprefixed('-moz-tab-size') //=> 'tab-size'\n```\n\n#### List\n\nTo safely split comma- or space-separated values (like in `background-image`\nor `transform` ) with brackets and quotes support you can use `list` helper:\n\n```js\nvar list = require('postcss/lib/list');\n\nlist.space(image.value)     //=> ['linear-gradient(white, black)', 'blue']\nlist.comma(transform.value) //=> ['color 200ms', 'background 200ms']\n```\n\n### Nodes\n\nProcessor function receives `Root` node with CSS node tree inside.\n\n```js\nvar processor = postcss(function (cssRoot) {\n});\n```\n\nThere are 4 types of child nodes: `Comment`, `AtRule`, `Rule` and `Declaration`.\nAll nodes have `toString()` and `clone()` methods.\n\nYou can parse CSS and get a `Root` node by `postcss.parse(css, opts)` method:\n\n```js\nvar cssRoot = postcss.parse('a { }');\n```\n\nAll node‘s methods return current node, so you can build nice method chains:\n\n```js\nroot.append( rule1 ).append( rule2 ).toString();\n```\n\n### Node Source\n\nEvery node stores its origin file (if you set `from` option to `process`\nor `parse` method) and position:\n\n```js\nvar root = postcss.parse(css, { from: 'main.css' });\nvar rule = root.rules[0];\n\nrule.source.file  //=> 'main.css'\nrule.source.start //=> { line: 5,  position: 1 }\nrule.source.end   //=> { line: 10, position: 5 }\n```\n\n### Whitespaces\n\nAll nodes (exclude `Root`) have `before` property with indentation\nand all earlier spaces.\n\nNodes with children (`Root`, `AtRule` and `Rule`) contain also `after` property\nwith spaces after last child and before `}` or end of file.\n\nEvery `Declaration` has `between` property with colon, spaces and comments\nbetween property name and value. `Rule` stores spaces and comments between\nselector and `{` in `between` property. `AtRule` uses `between` also to store\nspaces and comments before `{` or `;` for bodiless at-rule.\n\n```js\nvar root = postcss.parse(\"a {\\n  color: black;\\n}\\n\");\n\nroot.rules[0].between          //=> \" \" between selector and {\nroot.rules[0].decls[0].before  //=> \"\\n  \" before color: black\nroot.rules[0].decls[0].between //=> \": \" between property name and value\nroot.rules[0].after            //=> \"\\n\" before }\nroot.after                     //=> \"\\n\" from end of file\n```\n\nThe simplest way to minify CSS is to set `before`, `between` and `after`\nproperties to an empty string:\n\n```js\nvar minifier = postcss(function (css) {\n    css.eachDecl(function (decl) {\n        decl.before  = '';\n        decl.between = ':';\n    });\n    css.eachRule(function (rule) {\n        rule.before  = '';\n        rule.between = '';\n        rule.after   = '';\n    });\n    css.eachAtRule(function (atRule) {\n        atRule.before  = '';\n        atRule.between = '';\n        atRule.after   = '';\n    });\n    css.eachComment(function (comment) {\n        comment.removeSelf();\n    });\n});\n\nvar css = \"a {\\n  color:black\\n}\\n\";\nminifier.process(css).css //=> \"a{color:black}\"\n```\n\n### Raw Properties\n\nSome CSS values (selectors, comment text, at-rule params and declaration values)\ncan contain comments. PostCSS will clean them from trailing spaces for you:\n\n```js\nvar root = postcss.parse(\"a /**/ b {}\");\nvar rule  = root.rules[0];\n\nrule.selector      //=> 'a  b' trimmed and cleaned from comments\nrule._selector.raw //=> 'a /**/ b' original raw value\n```\n\nBut PostCSS saves raw content to be able to stringify it to CSS, if you don’t\nchange origin value. As you can remember, PostCSS tries to save origin CSS\nbyte-to-byte, when it’s possible:\n\n```js\nrule.toString() //=> 'a /**/ b {}' with comment\n\nrule.selector = '.link b';\nrule.toString() //=> '.link b {}' you change value and origin comment was gone\n```\n\n### Containers\n\n`Root`, `AtRule` and `Rule` nodes can contain children in `rules` or `decls`\nproperty.\n\nThere are common method to work with children:\n\n* `append(newChild)` to add child at the end of children list.\n* `prepend(newChild)` to add child at the beginning of children list.\n* `insertBefore(existsChild, newChild)` to insert new child before some\n   existent child.\n* `insertAfter(existsChild, newChild)` to insert new child after some\n   existent child.\n* `remove(existsChild)` to remove child.\n* `index(existsChild)` to return child index.\n* `some(fn)` to return true if `fn` returns true on any child.\n* `every(fn)` to return true if `fn` returns true on all children.\n\nMethods `insertBefore`, `insertAfter` and `remove` can receive child node\nor child index as an `existsChild` argument. Have in mind that child index works\nmuch faster.\n\nThere are two shorcuts to get first and last child:\n\n```js\nrule.first //=> First declaration in rule\nrule.last  //=> Last declaration in rule\n```\n\n### Children\n\n`Comment`, `AtRule`, `Rule` and `Declaration` nodes should be wrapped\nin other nodes.\n\nAll children contain `parent` property with parent node:\n\n```js\nrule.decls[0].parent == rule;\n```\n\nAll children has `removeSelf()` method:\n\n```js\nrule.decls[0].removeSelf();\n```\n\nBut `remove(index)` in parent with child index is much faster:\n\n```js\nrule.each(function (decl, i) {\n    rule.remove(i);\n});\n```\n\n### Iterators\n\nAll parent nodes have `each` method to iterate over children nodes:\n\n```js\nroot = postcss.parse('a { color: black; display: none }');\n\nroot.each(function (rule, i) {\n    if ( rule.type == 'rule' ) {\n        console.log(rule.selector, i); // Will log \"a 0\"\n    }\n});\n\nroot.rules[0].each(function (decl, i) {\n    if ( rule.type != 'comment' ) {\n        console.log(decl.prop, i); // Will log \"color 0\" and \"display 1\"\n    }\n});\n```\n\nUnlike `for {}`-cycle construct or `Array#forEach()` this iterator is safe.\nYou can mutate children while iteration and it will fix current index:\n\n```js\nrule.rules.forEach(function (decl, i) {\n    rule.prepend( decl.clone() );\n    // Will be infinity cycle, because on prepend current declaration become\n    // second and next index will go to current declaration again\n});\n\nrule.each(function (decl, i) {\n    rule.prepend( decl.clone() );\n    // Will work correct (once clone each declaration), because after prepend\n    // iterator index will be recalculated\n});\n```\n\nBecause CSS have nested structure, PostCSS also contains recursive iterator\n`eachInside`:\n\n```js\nroot.eachInside(function (node, i) {\n    console.log(node.type + ' inside ' + node.parent.type);\n});\n```\n\nThere are also shortcuts to recursive iterate all nodes of specific type:\n\n```js\nroot.eachDecl(function (decl, i) {\n    // Each declaration inside root\n});\n\nroot.eachRule(function (rule, i) {\n    // Each rule inside root and any nested at-rules\n});\n\nroot.eachAtRule(function (atRule, i) {\n    // Each at-rule inside root and any nested at-rules\n});\n\nroot.eachComment(function (comment, i) {\n    // Each comment inside root\n})\n```\n\nYou can break iteration by `return false`.\n\n### Root Node\n\n`Root` node contains entire CSS tree. Its children can be only `Comment`,\n`AtRule` or `Rule` nodes in `rules` property.\n\nYou can create a new root using shortcut:\n\n```js\nvar root = postcss.root();\n```\n\nMethod `toString()` stringifies entire node tree to CSS string:\n\n```js\nroot = postcss.parse(css);\nroot.toString() == css;\n```\n\n### Comment Node\n\n```css\n/* Block comment */\n```\n\nPostCSS creates `Comment` nodes only for comments between rules or declarations.\nComments inside selectors, at-rules params, declaration values will be stored\nin Raw property.\n\n`Comment` has only one property: `text` with trimmed text inside comment.\n\n```js\ncomment.text //=> \"Block comment\"\n```\n\nYou can create a new comment using shortcut:\n\n```js\nvar comment = postcss.comment({ text: 'New comment' });\n```\n\n### AtRule Node\n\n```css\n@charset 'utf-8';\n\n@font-face {\n    font-family: 'Cool'\n}\n\n@media print {\n    img { display: none }\n}\n```\n\n`AtRule` has two own properties: `name` and `params`.\n\nAs you see, some at-rules don’t contain any children (like `@charset`\nor `@import`), some of at-rules can contain only declarations\n(like `@font-face` or `@page`), but most of them can contain rules\nand nested at-rules (like `@media`, `@keyframes` and others).\n\nParser selects `AtRule` content type by its name. If you create `AtRule`\nnode manually, it will detect own content type with new child type on first\n`append` or other add method call:\n\n```js\nvar atRule = postcss.atRule({ name: '-x-animations' });\natRule.rules        //=> undefined\natRule.decls        //=> undefined\n\natRule.append( postcss.rule({ selector: 'from' }) );\natRule.rules.length //=> 1\natRule.decls        //=> undefined\n```\n\nYou can create a new at-rule using shortcut:\n\n```js\nvar atRule = postcss.atRule({ name: 'charset', params: 'utf-8' });\n```\n\n### Rule Node\n\n```css\na {\n    color: black;\n}\n```\n\n`Rule` node has `selector` property and contains `Declaration` and `Comment`\nchildren in `decls` property.\n\nThere is `selectors` shortcut, which return array:\n\n```js\nrule.selector  //=> \"a, b\"\nrule.selectors //=> ['a', 'b']\n```\n\nYou can miss `Declaration` constructor in `append` and other insert methods:\n\n```js\nrule.append({ prop: 'color', value: 'black' });\n```\n\nProperty `semicolon` indicates if last declaration in rule has semicolon or not:\n\n```js\nvar root = postcss.parse('a { color: black }');\nroot.rules[0].semicolon //=> false\n\nvar root = postcss.parse('a { color: black; }');\nroot.rules[0].semicolon //=> true\n```\n\nYou can create a new rule using shortcut:\n\n```js\nvar rule = postcss.rule({ selector: 'a' });\n```\n\n### Declaration Node\n\n```css\ncolor: black\n```\n\n`Declaration` node has `prop`, `value` and `important` properties.\n\nYou can create a new declaration using this shortcut:\n\n```js\nvar decl = postcss.decl({ prop: 'color', value: 'black' });\n```\n\nOr use short form in rule’s `append()` and other add methods:\n\n```js\nrule.append({ prop: 'color', value: 'black' });\n```\n",
+  "readmeFilename": "README.md",
+  "bugs": {
+    "url": "https://github.com/ai/postcss/issues"
+  },
+  "homepage": "https://github.com/ai/postcss",
+  "_id": "postcss@0.3.5",
+  "_shasum": "5073a3d062ef3ce592ac4a5fe6b8c2862ab83ceb",
+  "_from": "postcss@~0.3.5",
+  "_resolved": "https://registry.npmjs.org/postcss/-/postcss-0.3.5.tgz"
+}

data/node_modules/pleeease/node_modules/autoprefixer/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "autoprefixer",
+  "version": "1.1.20140605",
+  "description": "Parse CSS and add vendor prefixes to CSS rules using values from the Can I Use website",
+  "keywords": [
+    "css",
+    "prefix",
+    "postprocessor",
+    "postcss"
+  ],
+  "author": {
+    "name": "Andrey Sitnik",
+    "email": "andrey@sitnik.ru"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ai/autoprefixer.git"
+  },
+  "dependencies": {
+    "postcss": "~0.3.5",
+    "fs-extra": "~0.9.1"
+  },
+  "devDependencies": {
+    "coffee-script": "1.7.1",
+    "browserify": "4.1.8",
+    "should": "4.0.1",
+    "stylus": "0.46.2",
+    "mocha": "1.20.1",
+    "nib": "1.0.2"
+  },
+  "bin": {
+    "autoprefixer": "./bin/autoprefixer"
+  },
+  "main": "lib/autoprefixer",
+  "scripts": {
+    "test": "mocha"
+  },
+  "readme": "# Autoprefixer\n\n<img align=\"right\" width=\"94\" src=\"http://ai.github.io/autoprefixer/logo.svg\" title=\"Autoprefixer logo by Anton Lovchikov\">\n\nParse CSS and add vendor prefixes to CSS rules using values\nfrom [Can I Use](http://caniuse.com/).\n\nWrite your CSS rules without vendor prefixes (in fact, forget about them\nentirely):\n\n```css\n:fullscreen a {\n    transition: transform 1s\n}\n```\n\nProcess your CSS by Autoprefixer:\n\n```js\nvar prefixed = autoprefixer.process(css).css;\n```\n\nIt will use the data on current browser popularity and properties support\nto apply prefixes for you:\n\n```css\n:-webkit-full-screen a {\n    -webkit-transition: -webkit-transform 1s;\n    transition: transform 1s\n}\n:-moz-full-screen a {\n    transition: transform 1s\n}\n:-ms-fullscreen a {\n    transition: transform 1s\n}\n:fullscreen a {\n    -webkit-transition: -webkit-transform 1s;\n    transition: transform 1s\n}\n```\n\nYou can play with your CSS in the [interactive demo] of Autoprefixer.\n\nTwitter account for news and releases: [@autoprefixer].\n\nSponsored by [Evil Martians]. Based on [PostCSS] framework.\n\n[interactive demo]: http://jsfiddle.net/simevidas/udyTs/show/light/\n[@autoprefixer]:    https://twitter.com/autoprefixer\n[Evil Martians]:    http://evilmartians.com/\n[PostCSS]:          https://github.com/ai/postcss\n\n## Features\n\n### Forget about prefixes\n\nThe best tool is a tool you can't see and one that does the work for you.\nThis is the main idea behind Autoprefixer.\n\nAutoprefixer interface is simple: just forget about vendor prefixes\nand write normal CSS according to the latest W3C specs. You don’t need\na special language (like Sass) or special mixins.\n\nBecause Autoprefixer is a postprocessor for CSS,\nyou can also use it with preprocessors, such as Sass, Stylus or LESS.\n\n### Actual data from Can I Use\n\nAutoprefixer uses the most recent data from [Can I Use](http://caniuse.com/),\nunderstands which browsers are actual and popular and adds only the necessary\nvendor prefixes.\n\nIt also cleans your CSS from old prefixes (like prefixed `border-radius`,\nproduced by many CSS libraries):\n\n```css\na {\n    -webkit-border-radius: 5px;\n    border-radius: 5px\n}\n```\n\ncompiles to:\n\n```css\na {\n    border-radius: 5px\n}\n```\n\nNote, that Autoprefixer doesn’t load Can I Use data every time. This data\nis already packed in the release, so the same Autoprefixer version will always\nhave same output.\n\n### Flexbox, Gradients, etc.\n\nFlexbox or gradients have different syntaxes in different browsers\n(sometimes you need to recalculate angles, sometimes you need 2 old properties\ninstead of new one), but Autoprefixer hides this from you.\n\nJust code by latest W3C specs and Autoprefixer will produce the code\nfor old browsers:\n\n```css\na {\n    display: flex;\n}\n```\n\ncompiles to:\n\n```css\na {\n    display: -webkit-box;\n    display: -webkit-flex;\n    display: -moz-box;\n    display: -ms-flexbox;\n    display: flex\n}\n```\n\nAutoprefixer has [22 special hacks] to fix browser’s differences.\n\n[22 special hacks]: https://github.com/ai/autoprefixer/tree/master/lib/hacks\n\n### Fast\n\nAutoprefixer is about several times faster than Compass and Stylus.\n\nOn a Core i7 with 10 GB of RAM and SSD, benchmark with GitHub styles is:\n\n```\n~/Dev/autoprefixer$ ./node_modules/.bin/cake bench\nLoad GitHub styles\nAutoprefixer: 466 ms\nCompass:      2828 ms (6.1 times slower)\nStylus:       1491 ms (3.2 times slower)\n```\n\nUnlike [-prefix-free](http://leaverou.github.io/prefixfree/), Autoprefixer\ncompiles CSS once on deploy and doesn’t hurt client-side performance.\n\n## Browsers\n\nYou can specify the browsers you want to target in your project:\n\n```js\nautoprefixer(\"last 1 version\", \"> 1%\", \"Explorer 7\").process(css).css;\n```\n\n* `last 2 versions` is last versions for each browser. Like “last 2 versions”\n  [strategy](http://support.google.com/a/bin/answer.py?answer=33864) in\n  Google.\n* `last 2 Chrome versions` is last versions of the specified browser.\n* `> 5%` is browser versions, selected by global usage statistics.\n* `Firefox > 20` is Firefox versions newer than 20.\n* `Firefox >= 20` is Firefox version 20 or newer.\n* `Firefox ESR` is the latest [Firefox ESR] version.\n* `none` don’t set any browsers to clean CSS from any vendor prefixes.\n* `ios 7` to set browser version directly.\n\nBlackberry and stock Android browsers will not be used in `last n versions`.\nYou can add them by name:\n\n```js\nautoprefixer(\"last 1 version\", \"BlackBerry 10\", \"Android 4\").process(css).css;\n```\n\nBrowsers names (case insensitive):\n* `Android` for old Android stock browser.\n* `BlackBerry` or `bb` for Blackberry browser.\n* `Chrome` for Google Chrome.\n* `Firefox` or `ff` for Mozilla Firefox.\n* `Explorer` or `ie` for Internet Explorer.\n* `iOS` for iOS Safari.\n* `Opera` for Opera.\n* `Safari` for desktop Safari.\n\nBy default, Autoprefixer uses `> 1%, last 2 versions, Firefox ESR, Opera 12.1`:\n* Latest [Firefox ESR] is a 24 version.\n* Opera 12.1 will be in list until Opera supports non-Blink 12.x branch.\n\n[Firefox ESR]: http://www.mozilla.org/en/firefox/organizations/faq/\n\n## Source Map\n\nYou must set input and output CSS files paths (by `from` and `to` options)\nto generate a correct map.\n\nAutoprefixer can modify previous source maps (for example, from Sass):\nit will autodetect a previous map if it is listed in an annotation comment or\nin a file near the input CSS. You can disable source map with `map: false` or\nset the previous source map content manually to `map` option (as a string or a\nJS object).\n\n```js\nvar result = autoprefixer.process(css, {\n    map:   fs.readFileSync('main.sass.css.map'),\n    from: 'main.sass.css',\n    to:   'main.min.css'\n});\n\nresult.css //=> CSS with source map annotation comment\nresult.map //=> Source map from main.sass to main.min.css\n\nfs.writeFileSync('main.min.css.map', result.map);\n```\n\nAutoprefixer supports inline source maps too. If input CSS contains annotation\nfrom the previous step with map in `data:uri`, Autoprefixer will update the\nsource map with prefixes changes and inine the new map back into the output CSS.\n\nYou can read more about source map options in\n[PostCSS documentation](https://github.com/ai/postcss#source-map-1).\n\n## Visual Cascade\n\nAutoprefixer can change CSS indentation to create a nice visual cascade\nof prefixes. You need to send `cascade: true` option to processor constructor:\n\n```js\nautoprefixer(\"> 1 %\", \"last 2 version\", { cascade: true }).process(css).css\n```\n\nand, if CSS will be uncompressed, output would be like:\n\n```css\na {\n    -webkit-box-sizing: border-box;\n       -moz-box-sizing: border-box;\n            box-sizing: border-box\n}\n```\n\n## Debug\n\nYou can check which browsers are selected and which properties will be prefixed:\n\n```js\ninfo = autoprefixer(\"last 1 version\").info();\nconsole.log(info);\n```\n\nOr by CLI command:\n\n```sh\nautoprefixer -i\n```\n\n## FAQ\n\n### Does it add polyfills for old browsers?\n\nNo. Autoprefixer only adds prefixes, not polyfills. There are two reasons:\n\n1. Prefixes and polyfills are very different and need a different API.\n   Two separate libraries would be much better.\n2. Most of IE polyfills are very bad for client perfomance. They use slow hacks\n   and old IEs is mostly used on old hardware. Most CSS3 features used only\n   for styling should be ignored in old IEs as is recommended for\n   Graceful Degradation.\n\n### Why don’t gradients work in Firefox?\n\nCheck that you use correct [direction syntax]. For example, you should use\n`to bottom` instead of `top`:\n\n```css\na {\n  background: linear-gradient(to bottom, white, black)\n}\n```\n\nUnfortunately, unprefixed gradients use a different direction syntax and most\nexamples you find use an old gradient syntax, so be careful and use always the\nlatest W3C specs with Autoprefixer.\n\n[direction syntax]: https://developer.mozilla.org/en-US/docs/Web/CSS/linear-gradient\n\n### Why doesn’t Autoprefixer add prefixes to `border-radius`?\n\nDevelopers are often surprised by how few prefixes are required today.\nIf Autoprefixer doesn’t add prefixes to your CSS, check if they’re still\nrequired on [Can I Use](http://caniuse.com/).\n\nIf a prefix is required, but Autoprefixer doesn’t add it or adds it\nincorrectly, please\n[report an issue](https://github.com/ai/autoprefixer/issues/new)\nand include your source CSS and expected output.\n\n### Why doesn’t Autoprefixer support `appearance`?\n\nUnlike `transition`, the `appearance` property is not a part of\nany specification. So there is no `appearance`, only `-moz-appearance`\nand `-webkit-appearance`. Quote from [MDN](https://developer.mozilla.org/en-US/docs/Web/CSS/-moz-appearance):\n\n> Do not use this property on Web sites: not only is it non-standard, but its\n> behavior changes from one browser to another. Even the keyword `none` does not\n> have the same behavior on each form element across different browsers, and\n> some do not support it at all.\n\n### Why does Autoprefixer use CoffeeScript?\n\nJavaScript is very popular, but this is the same reason why its syntax does not\nevolve. There is an entire Internet with a lot of legacy code which should\nbe supported by browsers. If developers add an inappropriate feature then\nit can’t be removed in then next versions but must be supported for a very\nlong time. This is very bad for innovation. To create new, we need to experiment\nand to choose.\n\nAs a result JavaScript doesn’t have even basic syntax features, which are\npresent in other languages like Ruby or Python. There are no string\ninterpolation, short lambda syntax, foreach statement for arrays, string and\narrays slicing, etc. This features are really important and they will be in\nECMAScript 6 (first update of JS syntax after 15 years), but this\nnew specification is still not released and, of course, we must wait until\nall browsers support it.\n\nWith JavaScript preprocessors like CoffeeScript or TypeScript we can bring\ninnovation back. We can add a new operator and use it right now, without waiting\nfor support in all browsers.\n\nAutoprefixer was written in pure JavaScript before. But CoffeeScript made\nAutoprefixer code much cleaner and more readable. Often, 2 lines of code\nbecame 1.\n\nDon’t be afraid of CoffeeScript. It is just a new syntax, not another language\n(like ClojureScript). You can open [examples on CoffeeScript.org] and start\nto code. After a week your eyes will adjust and you will see that CoffeeScript\nis cleaner and more readable.\n\nSituation with CoffeeScript and JavaScript is absolutely the same as with\nCSS preprocessors and postprocessors. How can we develop a CSS postprocessor\nand avoid using a JS preproccesor :).\n\n[examples on CoffeeScript.org]: http://coffeescript.org/\n\n## Usage\n\n### Grunt\n\nYou can use the\n[grunt-autoprefixer](https://github.com/nDmitry/grunt-autoprefixer)\nplugin for Grunt. Install the npm package and add it to Gruntfile:\n\n```js\ngrunt.loadNpmTasks('grunt-autoprefixer');\n```\n\n### Gulp\n\nYou can use [gulp-autoprefixer](https://github.com/Metrime/gulp-autoprefixer)\nto use Autoprefixer in your Gulp build configuration.\n\n```js\nvar prefix = require('gulp-autoprefixer');\ngulp.src('./css/*.css')\n  .pipe(prefix([\"last 1 version\", \"> 1%\", \"ie 8\", \"ie 7\"], { cascade: true }))\n  .pipe(gulp.dest('./dist/'));\n```\n\n### Brunch\n\nYou can use the\n[autoprefixer-brunch](https://github.com/lydell/autoprefixer-brunch)\nplugin for [Brunch](http://brunch.io/).\n\n### Compass\n\nIf you use Compass binary to compile your styles, you can easily integrate\nAutoprefixer with it. Install `autoprefixer-rails` gem:\n\n```\ngem install autoprefixer-rails\n```\n\nand add post-compile hook to `config.rb`:\n\n```ruby\nrequire 'autoprefixer-rails'\n\non_stylesheet_saved do |file|\n  css = File.read(file)\n  File.open(file, 'w') do |io|\n    io << AutoprefixerRails.process(css)\n  end\nend\n```\n\nYou can set the browsers option as the second argument in `process` method:\n\n```ruby\nio << AutoprefixerRails.process(css, browsers: [\"last 1 version\", \"> 1%\"])\n```\n\n### Stylus\n\nIf you use Stylus CLI, you can add Autoprefixer by\n[autoprefixer-stylus](https://github.com/jenius/autoprefixer-stylus) plugin.\n\nJust install npm package and use it in `-u` option:\n\n```\nstylus -u autoprefixer-stylus -w file.styl\n```\n\n### Ruby on Rails\n\nAdd [autoprefixer-rails](https://github.com/ai/autoprefixer-rails) gem\nto `Gemfile` and write CSS in a usual way:\n\n```ruby\ngem \"autoprefixer-rails\"\n```\n\n### Ruby\n\nYou can integrate Autoprefixer into your Sprockets environment\nby `autoprefixer-rails` gem:\n\n```ruby\nAutoprefixerRails.install(sprockets_env)\n```\n\nor process CSS from plain Ruby:\n\n```ruby\nprefixed = AutoprefixerRails.process(css)\n```\n\n### CodeKit\n\nCodeKit, since the 2.0 version, contains Autoprefixer. In the After Compiling\nsection, there is a checkbox to enable Autoprefixer.\nRead [CodeKit docs](https://incident57.com/codekit/help.html#autoprefixer)\nfor more inforamtion.\n\n### Prepros\n\nIf you want to build your assets with a GUI, try\n[Prepros](http://alphapixels.com/prepros/). Just set “Auto Prefix CSS”\n[checkbox](https://f.cloud.github.com/assets/3478693/930798/faa29892-0016-11e3-8901-87850de7aed2.jpg)\nin right panel.\n\n<img src=\"http://alphapixels.com/prepros/static/img/prepros.jpg\" width=\"550\" height=\"340\" />\n\n### Broccoli\n\nYou can use the\n[broccoli-autoprefixer](https://github.com/sindresorhus/broccoli-autoprefixer)\nplugin for [Broccoli](https://github.com/joliss/broccoli).\n\n### Mincer\n\nTo use Autoprefixer in [Mincer](https://github.com/nodeca/mincer),\ninstall `autoprefixer` npm package and enable it:\n\n```js\nenvironment.enable('autoprefixer');\n```\n\n### Middleman\n\nAdd [middleman-autoprefixer](https://github.com/porada/middleman-autoprefixer)\ngem to `Gemfile`:\n\n```ruby\ngem \"middleman-autoprefixer\"\n```\n\nand activate the extension in your project’s `config.rb`:\n\n```ruby\nactivate :autoprefixer\n```\n\n### Node.js\n\nUse `autoprefixer` npm package:\n\n```js\nvar autoprefixer = require('autoprefixer');\nvar css          = 'a { transition: transform 1s }';\nvar prefixed     = autoprefixer.process(css).css;\n```\n\n### PHP\n\nYou can use Autoprefixer in PHP by\n[autoprefixer-php](https://github.com/vladkens/autoprefixer-php) library:\n\n\n```php\n$autoprefixer = new Autoprefixer();\n$css          = 'a { transition: transform 1s }';\n$prefixed     = $autoprefixer->compile($css);\n```\n\n### .NET\n\nYou can use Autoprefixer from .NET and BundleTransformer with the\n[Autoprefixer](https://github.com/digitalcreations/autoprefixer) NuGet package.\n\n### JavaScript\n\nYou can use Autoprefixer in the browser or as a non-Node.js runtime\nwith [standalone version](https://raw.github.com/ai/autoprefixer-rails/master/vendor/autoprefixer.js).\n\n### PostCSS\n\nAutoprefixer can be also used as a [PostCSS](https://github.com/ai/postcss)\nprocessor, so you can combine it with other processors and parse CSS only once:\n\n```js\npostcss().\n    use( autoprefixer(['> 1%', 'opera 12.5']).postcss ).\n    use( compressor ).\n    process(css);\n```\n\n### Sublime Text\n\nYou can process your styles directly in Sublime Text with the\n[sublime-autoprefixer](https://github.com/sindresorhus/sublime-autoprefixer)\nplugin.\n\n### Brackets\n\nStyles can processed automatically in Brackets using the\n[brackets-autoprefixer](https://github.com/mikaeljorhult/brackets-autoprefixer)\nextension.\n\n### Atom Editor\n\nYou can process your styles directly in Atom with the\n[atom-autoprefixer](https://github.com/sindresorhus/atom-autoprefixer)\npackage.\n\n### Others\n\nYou can use the `autoprefixer` binary to process CSS files using\nany assets manager:\n\n```\nsudo npm install --global autoprefixer\nautoprefixer *.css\n```\n\nSee `autoprefixer -h` for help.\n\n## In-package Update\n\nIt’s highly recommended that you always use the latest version of Autoprefixer.\nIf by any chance you or your company are not able to update the package\n(e.g. in case of long test periods before any library updates), you can still\nupdate the very browser data that Autoprefixer fetches from Can I Use:\n\n```\nautoprefixer --update\n```\n\nNote that the in-package update doesn’t get any code fixes nor the\nimplementation of new features. It just keeps the browser popularity and\nsupport data up to date, and adds new browser versions.\n",
+  "readmeFilename": "README.md",
+  "bugs": {
+    "url": "https://github.com/ai/autoprefixer/issues"
+  },
+  "homepage": "https://github.com/ai/autoprefixer",
+  "_id": "autoprefixer@1.1.20140605",
+  "_shasum": "2534cd5d041709ba221187713b81b3862b67db7f",
+  "_from": "autoprefixer@~1.1.20140410",
+  "_resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-1.1.20140605.tgz"
+}

data/node_modules/pleeease/node_modules/autoprefixer/updaters/browsers.js

@@ -0,0 +1,65 @@
+(function() {
+  module.exports = function() {
+    var minor;
+    minor = ['bb', 'android'];
+    return this.github('Fyrd/caniuse/master/data.json', (function(_this) {
+      return function(data) {
+        var agent, browsers, caniuse, internal, intervals, normalize, _ref;
+        normalize = function(array) {
+          return array.reverse().filter(function(i) {
+            return i;
+          });
+        };
+        intervals = function(array) {
+          var i, interval, result, splited, sub, _i, _len;
+          result = [];
+          for (_i = 0, _len = array.length; _i < _len; _i++) {
+            interval = array[_i];
+            splited = interval.split('-');
+            splited = splited.sort().reverse();
+            sub = (function() {
+              var _j, _len1, _results;
+              _results = [];
+              for (_j = 0, _len1 = splited.length; _j < _len1; _j++) {
+                i = splited[_j];
+                _results.push([i, interval, splited.length]);
+              }
+              return _results;
+            })();
+            result = result.concat(sub);
+          }
+          return result;
+        };
+        agent = function(name) {
+          var future, info, result, versions;
+          info = data.agents[name];
+          future = normalize(info.versions.slice(-3));
+          versions = intervals(normalize(info.versions.slice(0, -3)));
+          result = {};
+          result.prefix = name === 'opera' ? '-o-' : "-" + info.prefix + "-";
+          if (minor.indexOf(name) !== -1) {
+            result.minor = true;
+          }
+          if (future.length) {
+            result.future = future;
+          }
+          result.versions = versions.map(function(i) {
+            return i[0];
+          });
+          result.popularity = versions.map(function(i) {
+            return info.usage_global[i[1]] / i[2];
+          });
+          return result;
+        };
+        browsers = {};
+        _ref = _this.browsers;
+        for (caniuse in _ref) {
+          internal = _ref[caniuse];
+          browsers[internal] = agent(caniuse);
+        }
+        return _this.save('browsers', browsers);
+      };
+    })(this));
+  };
+
+}).call(this);