pleeease 0.0.2

data/node_modules/pleeease/node_modules/autoprefixer/node_modules/fs-extra/node_modules/rimraf/test/run.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+set -e
+code=0
+for i in test-*.js; do
+  echo -n $i ...
+  bash setup.sh
+  node $i
+  if [ -d target ]; then
+    echo "fail"
+    code=1
+  else
+    echo "pass"
+  fi
+done
+rm -rf target
+exit $code

data/node_modules/pleeease/node_modules/autoprefixer/node_modules/fs-extra/node_modules/rimraf/test/setup.sh

@@ -0,0 +1,47 @@
+#!/bin/bash
+
+set -e
+
+files=10
+folders=2
+depth=4
+target="$PWD/target"
+
+rm -rf target
+
+fill () {
+  local depth=$1
+  local files=$2
+  local folders=$3
+  local target=$4
+
+  if ! [ -d $target ]; then
+    mkdir -p $target
+  fi
+
+  local f
+
+  f=$files
+  while [ $f -gt 0 ]; do
+    touch "$target/f-$depth-$f"
+    let f--
+  done
+
+  let depth--
+
+  if [ $depth -le 0 ]; then
+    return 0
+  fi
+
+  f=$folders
+  while [ $f -gt 0 ]; do
+    mkdir "$target/folder-$depth-$f"
+    fill $depth $files $folders "$target/d-$depth-$f"
+    let f--
+  done
+}
+
+fill $depth $files $folders $target
+
+# sanity assert
+[ -d $target ]

data/node_modules/pleeease/node_modules/autoprefixer/node_modules/fs-extra/node_modules/rimraf/test/test-async.js

@@ -0,0 +1,5 @@
+var rimraf = require("../rimraf")
+  , path = require("path")
+rimraf(path.join(__dirname, "target"), function (er) {
+  if (er) throw er
+})

data/node_modules/pleeease/node_modules/autoprefixer/node_modules/fs-extra/node_modules/rimraf/test/test-sync.js

@@ -0,0 +1,3 @@
+var rimraf = require("../rimraf")
+  , path = require("path")
+rimraf.sync(path.join(__dirname, "target"))

data/node_modules/pleeease/node_modules/autoprefixer/node_modules/fs-extra/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "fs-extra",
+  "version": "0.9.1",
+  "description": "fs-extra contains methods that aren't included in the vanilla Node.js fs package. Such as mkdir -p, cp -r, and rm -rf.",
+  "homepage": "https://github.com/jprichardson/node-fs-extra",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jprichardson/node-fs-extra"
+  },
+  "keywords": [
+    "fs",
+    "file",
+    "file system",
+    "copy",
+    "directory",
+    "extra",
+    "mkdirp",
+    "mkdir",
+    "mkdirs",
+    "recursive",
+    "json",
+    "read",
+    "write",
+    "extra",
+    "delete",
+    "remove",
+    "touch",
+    "create",
+    "text",
+    "output",
+    "move"
+  ],
+  "author": {
+    "name": "JP Richardson",
+    "email": "jprichardson@gmail.com"
+  },
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "http://github.com/jprichardson/node-fs-extra/raw/master/LICENSE"
+    }
+  ],
+  "dependencies": {
+    "ncp": "^0.5.1",
+    "mkdirp": "^0.5.0",
+    "jsonfile": "~1.1.0",
+    "rimraf": "^2.2.8"
+  },
+  "devDependencies": {
+    "mocha": "*",
+    "path-extra": "0.0.x",
+    "testutil": "~0.5.0",
+    "userid": "~0.1.1"
+  },
+  "main": "./lib/index",
+  "scripts": {
+    "test": "mocha test"
+  },
+  "readme": "Node.js: fs-extra\n=================\n\n[![build status](https://secure.travis-ci.org/jprichardson/node-fs-extra.png)](http://travis-ci.org/jprichardson/node-fs-extra)\n\nThis module adds a few extra file system methods that aren't included in the native `fs` module. It is a drop in replacement for `fs`.\n\n\n\nWhy?\n----\n\nI got tired of including `mkdirp`, `rimraf`, and `cp -r` in most of my projects. \n\n\n\n\nInstallation\n------------\n\n    npm install --save fs-extra\n\n\n\nUsage\n-----\n\n`fs-extra` is a drop in replacement for native `fs`. All methods in `fs` are unmodified and attached to `fs-extra`.\n\nYou don't ever need to include the original `fs` module again:\n\n```javascript\nvar fs = require('fs') //this is no longer necessary\n```\n\nyou can now do this:\n\n```javascript\nvar fs = require('fs-extra'); //var fs = require('fs')\n```\n\nor if you prefer to make it clear that you're using `fs-extra` and not `fs`, you may want \nto do this:\n\n```javascript\n//var fs = require('fs')\nvar fse = require('fs-extra')\n```\n\nyou can also keep both, but it's redundant:\n\n```javascript\nvar fs = require('fs')\nvar fse = require('fs-extra')\n```\n\n\n\nMethods\n-------\n\n**NOTE:** You can still use the native Node.js methods. They are copied over to `fs-extra`.\n\n\n### copy(src, dest, [filter], callback)\n\nCopy a file or directory. The directory can have contents. Like `cp -r`.\n\nSync: `copySync()`\n\n\nExamples:\n\n```javascript\nvar fs = require('fs-extra');\n\nfs.copy('/tmp/myfile', '/tmp/mynewfile', function(err){\n  if (err) return console.error(err);\n  console.log(\"success!\")\n}); //copies file\n\nfs.copy('/tmp/mydir', '/tmp/mynewdir', function(err){\n  if (err) return console.error(err);\n  console.log(\"success!\")\n}); //copies directory, even if it has subdirectories or files\n```\n\n\n### ensureFile(file, callback) \n\nEnsures that the file exists. If the file that is requested to be created is in directories that do not exist, these directories are created. If the file already exists, it is **NOT MODIFIED**.\n\nAlias: `createFile()`\n\nSync: `createFileSync()`,`ensureFileSync()`\n\n\nExample:\n\n```javascript\nvar fs = require('fs-extra')\n\nvar file = '/tmp/this/path/does/not/exist/file.txt'\nfs.ensureFile(file, function(err) {\n  console.log(err); //null\n  //file has now been created, including the directory it is to be placed in\n})\n```\n\n\n### ensureDir(dir, callback) \n\nEnsures that the directory exists. If the directory structure does not exist, it is created.\n\nSync: `ensureDirSync()`\n\n\nExample:\n\n```javascript\nvar fs = require('fs-extra')\n\nvar dir = '/tmp/this/path/does/not/exist'\nfs.ensureDir(dir, function(err) {\n  console.log(err); //null\n  //dir has now been created, including the directory it is to be placed in\n})\n```\n\n\n\n### mkdirs(dir, callback) \n\nCreates a directory. If the parent hierarchy doesn't exist, it's created. Like `mkdir -p`.\n\nAlias: `mkdirp()`\n\nSync: `mkdirsSync()` / `mkdirpSync()`\n\n\nExamples:\n\n```javascript\nvar fs = require('fs-extra');\n\nfs.mkdirs('/tmp/some/long/path/that/prob/doesnt/exist', function(err){\n  if (err) return console.error(err);\n  console.log(\"success!\")\n});\n\nfs.mkdirsSync('/tmp/another/path');\n```\n\n\n### move(src, dest, callback)\n\nMoves a file or directory, even across devices.\n\nExample:\n\n```javascript\nvar fs = require('fs-extra');\n\nfs.move('/tmp/somefile', '/tmp/does/not/exist/yet/somefile', function(err){\n  if (err) return console.error(err);\n  console.log(\"success!\")\n});\n```\n\n\n### outputFile(file, data, callback)\n\nAlmost the same as `writeFile` (i.e. it [overwrites](http://pages.citebite.com/v2o5n8l2f5reb)), except that if the parent directory does not exist, it's created.\n\nSync: `outputFileSync()`\n\n\nExample:\n\n```javascript\nvar fs = require('fs-extra')\nvar file = '/tmp/this/path/does/not/exist/file.txt'\n\nfs.outputFile(file, 'hello!', function(err) {\n  console.log(err); //null\n\n  fs.readFile(file, 'utf8', function(err, data) {\n    console.log(data); //hello!\n  })\n})\n```\n\n\n\n### outputJson(file, data, callback)\n\nAlmost the same as `writeJson`, except that if the directory does not exist, it's created.\n\nAlias: `outputJSON()\n\nSync: `outputJsonSync()`, `outputJSONSync()`\n\n\nExample:\n\n```javascript\nvar fs = require('fs-extra')\nvar file = '/tmp/this/path/does/not/exist/file.txt'\n\nfs.outputJson(file, {name: 'JP'}, function(err) {\n  console.log(err); //null\n\n  fs.readJson(file, function(err, data) {\n    console.log(data.name); //'JP\n  })\n})\n```\n\n\n\n### readJson(file, [options], callback) \n\nReads a JSON file and then parses it into an object. `options` are the same that you'd pass to `fs.readFile`.\n\nAlias: `readJSON()`\n\nSync: `readJsonSync()`, `readJSONSync()`\n\n\nExample:\n\n```javascript\nvar fs = require('fs-extra');\n\nfs.readJson('./package.json', function(err, packageObj) {\n  console.log(packageObj.version); //0.1.3\n});\n```\n\n\n### remove(dir, callback)\n\nRemoves a file or directory. The directory can have contents. Like `rm -rf`.\n\nAlias: `delete()`\n\nSync: `removeSync()` / `deleteSync()`\n\n\nExamples:\n\n```javascript\nvar fs = require('fs-extra');\n\nfs.remove('/tmp/myfile', function(err){\n  if (err) return console.error(err);\n  \n  console.log(\"success!\")\n});\n\nfs.removeSync('/home/jprichardson'); //I just deleted my entire HOME directory. \n```\n\n\n\n### writeJson(file, object, [options], callback) \n\nWrites an object to a JSON file. `options` are the same that you'd pass to `fs.readFile`.\n\nAlias: `writeJSON()`\n\nSync: `writeJsonSync()`, `writeJSONSync()`\n\nExample:\n\n```javascript\nvar fs = require('fs-extra');\nfs.writeJson('./package.json', {name: 'fs-extra'}, function(err){\n  console.log(err);\n});\n```\n\n\n\nRoadmap\n--------\n\nThis contains items that I'm considering doing. I'd love community feedback.\n\n* File system walker. I really like this one: https://github.com/daaku/nodejs-walker ... this might be adding too much. Thoughts?\n* File/directory tree watcher. There are quite a few. ... this also might be adding too much. I like this one: https://github.com/paulmillr/chokidar, thoughts?\n* Thinking about moving `rimraf`, `ncp`, and `mkdirps` code into this library. I'd like fs-extra to be a stable library that module authors\ncan depend upon. A bunch of other dependencies kinda sucks for modules/libraries. (I'm leaning against this now.)\n* Change documentation to use the `fse` prefix instead of `fs`. This may encourage people to start using `fse` as a prefix and hence make their code clearer that they're not using the native `fs`. I'm very undecided on this one since `fs-extra` is a drop in replacement for the native `fs`. (I'm leaning against this now.)\n\n\n\nNaming\n------\n\nI put a lot of thought into the naming of these functions. Inspired by @coolaj86's request. So he deserves much of the credit for raising the issue. See discussion(s) here:\n\n* https://github.com/jprichardson/node-fs-extra/issues/2\n* https://github.com/flatiron/utile/issues/11\n* https://github.com/ryanmcgrath/wrench-js/issues/29\n* https://github.com/substack/node-mkdirp/issues/17\n\nFirst, I believe that in as many cases as possible, the [Node.js naming schemes](http://nodejs.org/api/fs.html) should be chosen. However, there are problems with the Node.js own naming schemes.\n\nFor example, `fs.readFile()` and `fs.readdir()`: the **F** is capitalized in *File* and the **d** is not capitalized in *dir*. Perhaps a bit pedantic, but they should still be consistent. Also, Node.js has chosen a lot of POSIX naming schemes, which I believe is great. See: `fs.mkdir()`, `fs.rmdir()`, `fs.chown()`, etc.\n\nWe have a dilemma though. How do you consistently name methods that perform the following POSIX commands: `cp`, `cp -r`, `mkdir -p`, and `rm -rf`?\n\nMy perspective: when in doubt, err on the side of simplicity. A directory is just a hierarchical grouping of directories and files. Consider that for a moment. So when you want to copy it or remove it, in most cases you'll want to copy or remove all of its contents. When you want to create a directory, if the directory that it's suppose to be contained in does not exist, then in most cases you'll want to create that too. \n\nSo, if you want to remove a file or a directory regardless of whether it has contents, just call `fs.remove(path)` or its alias `fs.delete(path)`. If you want to copy a file or a directory whether it has contents, just call `fs.copy(source, destination)`. If you want to create a directory regardless of whether its parent directories exist, just call `fs.mkdirs(path)` or `fs.mkdirp(path)`. \n\n\nCredit\n------\n\n`fs-extra` wouldn't be possible without using the modules from the following authors:\n\n- [Isaac Shlueter](https://github.com/isaacs)\n- [Charlie McConnel](https://github.com/avianflu)\n- [James Halliday](https://github.com/substack)\n- [Andrew Kelley](https://github.com/andrewrk)\n\n\nContributions\n-------------\n\nIf you want to contribute, please add a test. Also, don't change the version in `package.json`.\n\n\n### Contributors\n\n- [*] [JP Richardson](https://github.com/jprichardson)\n- [*] [Mike McNeil](https://github.com/mikermcneil)\n- [*] [Ian Crowther](https://github.com/iancrowther)\n- [*] [Stephen Mathieson](https://github.com/stephenmathieson)\n- [*] [Srirangan](https://github.com/Srirangan)\n- [*] [Uli Köhler](https://github.com/ulikoehler)\n- [1] [Jim Higson](https://github.com/jimhigson)\n- [1] [PatrickJS](https://github.com/gdi2290)\n- [1] [Michael Tiller](https://github.com/xogeny)\n- `<your name here>`\n\n\n\n\nLicense\n-------\n\n\nLicensed under MIT\n\nCopyright (c) 2011-2014 JP Richardson\n\n[1]: http://nodejs.org/docs/latest/api/fs.html \n\n\n[jsonfile]: https://github.com/jprichardson/node-jsonfile\n\n\n\n\n\n\n\n\n",
+  "readmeFilename": "README.md",
+  "bugs": {
+    "url": "https://github.com/jprichardson/node-fs-extra/issues"
+  },
+  "_id": "fs-extra@0.9.1",
+  "_shasum": "87dbfc01383a8ddce7d9d5496f3608564889f156",
+  "_from": "fs-extra@~0.9.1",
+  "_resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-0.9.1.tgz"
+}

data/node_modules/pleeease/node_modules/autoprefixer/node_modules/postcss/ChangeLog.md

@@ -0,0 +1,46 @@
+## 0.3.5
+* Allow to use `Root` or `Result` as first argument in `process()`.
+* Save parsed AST to `Result#root`.
+
+## 0.3.4
+* Better space symbol detect to read UTF-8 BOM correctly.
+
+## 0.3.3
+* Remove source map hacks by using new Mozilla’s `source-map` (by Simon Lydell).
+
+## 0.3.2
+* Add URI encoding support for inline source maps.
+
+## 0.3.1
+* Fix relative paths from previous source map.
+* Safer space split in `Rule#selectors` (by Simon Lydell).
+
+## 0.3 “Prince Seere”
+* Add `Comment` node for comments between declarations or rules.
+* Add source map annotation comment to output CSS.
+* Allow to inline source map to annotation comment by data:uri.
+* Fix source maps on Windows.
+* Fix source maps for styles in subdirectory (by @nDmitry and @lydell).
+* Autodetect previous source map.
+* Add `first` and `last` shortcuts to container nodes.
+* Parse `!important` to separated property in `Declaration`.
+* Allow to break iteration by returning `false`.
+* Copy code style to new nodes.
+* Add `eachInside` method to recursivelly iterate all nodes.
+* Add `selectors` shortcut to get selectors array.
+* Add `toResult` method to `Rule` to simplify work with several input files.
+* Clean declaration’s `value`, rule’s `selector` and at-rule’s `params`
+  by storing spaces in `between` property.
+
+## 0.2 “Duke Dantalion”
+* Add source map support.
+* Add shortcuts to create nodes.
+* Method `process()` now returns object with `css` and `map` keys.
+* Origin CSS file option was renamed from `file` to `from`.
+* Rename `Node#remove()` method to `removeSelf()` to fix name conflict.
+* Node source was moved to `source` property with origin file
+  and node end position.
+* You can set own stringify function.
+
+## 0.1 “Count Andromalius”
+* Initial release.

data/node_modules/pleeease/node_modules/autoprefixer/node_modules/postcss/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright 2013 Andrey Sitnik <andrey@sitnik.ru>
+
+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/node_modules/pleeease/node_modules/autoprefixer/node_modules/postcss/README.md

@@ -0,0 +1,784 @@
+# PostCSS
+
+PostCSS is a framework for CSS postprocessors,
+to modify CSS with JavaScript.
+
+It takes care of most common CSS tool tasks:
+
+1. parses CSS;
+2. gives you usable JS API to edit CSS node tree;
+3. dumps modified node tree into CSS string;
+4. generates (or modifies existent) source map for your changes;
+
+You can use this framework to write you own:
+
+* CSS minifier or beautifizer.
+* CSS polyfills.
+* Grunt plugin to generate sprites, include `data-uri` images
+  or any other works.
+* Text editor plugin to automate CSS routine.
+* Command-line CSS tool.
+
+Sponsored by [Evil Martians](http://evilmartians.com/).
+
+## Built with PostCSS
+
+* [Autoprefixer] adds vendor prefixes by Can I Use data.
+* [grunt-pixrem], `rem` unit polyfill.
+* [CSS MQPacker] joins same media queries.
+* [RTLCSS] mirrors styles for right-to-left locales.
+* [CSSWring] and [grunt-csswring] CSS minifier with full source map support.
+* [Grunt-webpcss] to duplicate images in CSS to WebP for supported browsers.
+* [Pleeease] is a pack of various postprocessors.
+
+[grunt-csswring]: https://github.com/princed/grunt-csswring
+[Grunt-webpcss]:  https://github.com/lexich/grunt-webpcss
+[Autoprefixer]:   https://github.com/ai/autoprefixer
+[grunt-pixrem]:   https://github.com/robwierzbowski/grunt-pixrem
+[CSS MQPacker]:   https://github.com/hail2u/node-css-mqpacker
+[Pleeease]:       http://pleeease.io/
+[CSSWring]:       https://github.com/hail2u/node-csswring
+[RTLCSS]:         https://github.com/MohammadYounes/rtlcss
+
+## Quick Example
+
+Let’s fix forgotten `content` property in `::before` and `::after`:
+
+```js
+var postcss = require('postcss');
+
+var contenter = postcss(function (css) {
+    css.eachRule(function (rule) {
+        if ( rule.selector.match(/::(before|after)/) ) {
+            // In every ::before/::after rule
+
+            // Did we forget content property?
+            var good = rule.some(function (i) { return i.prop == 'content'; });
+
+            if ( !good ) {
+                // Add content: "" if we forget it
+                rule.prepend({ prop: 'content', value: '""' });
+            }
+
+        }
+    });
+});
+```
+
+And then CSS with forgotten `content`:
+
+```css
+a::before {
+    width: 10px;
+    height: 10px
+}
+```
+
+will be fixed by our new `contenter`:
+
+```js
+var fixed = contenter.process(css).css;
+```
+
+to:
+
+```css
+a::before {
+    content: "";
+    width: 10px;
+    height: 10px
+}
+```
+
+## Features
+
+### Source Map
+
+PostCSS generates source map for its changes:
+
+```js
+result = processor.process(css, { map: true, from: 'from.css', to: 'to.css' });
+result.css // String with processed CSS
+result.map // Source map
+```
+
+And modifies source map from previous step (like Sass preprocessor):
+
+```js
+var sassMap = fs.readFileSync('from.sass.css.map');
+processor.process(css, { map: sassMap, from: 'from.sass.css', to: 'to.css' });
+```
+
+### Preserves code formatting and indentations
+
+PostCSS will not change any byte of a rule if you don’t modify its node:
+
+```js
+postcss(function (css) { }).process(css).css == css;
+```
+
+And when you modify CSS nodes, PostCSS will try to copy coding style:
+
+```js
+contenter.process("a::before{color:black}")
+// a::before{content:'';color:black}
+
+contenter.process("a::before {\n  color: black;\n  }")
+// a::before {
+//   content: '';
+//   color: black;
+//   }
+```
+
+## Why PostCSS Better Than …
+
+### Preprocessors
+
+Preprocessors (like Sass or Stylus) give us special language with variables,
+mixins, statements and compile it to CSS. Compass, nib and other mixins
+libraries use these languages to work with prefixes, sprites and inline images.
+
+But Sass and Stylus languages were created to be syntax-sugar for CSS.
+Writing really complicated programs using preporcessor languages
+is very difficult. [Autoprefixer] is absolutely impossible to implement
+on top of Sass.
+
+PostCSS gives you comfort and power of JS or CoffeeScript to working with CSS.
+You can do really magic things with wide range of [npm] libraries.
+
+But postprocessors are not enemies for preprocessors. Sass and Stylus are still
+the best way to improve readability and add some syntax sugar to CSS.
+You can easily combine preprocessors and postprocessors
+(and PostCSS will also update source map from Sass or Stylus).
+
+[Autoprefixer]: https://github.com/ai/autoprefixer
+[npm]:          https://npmjs.org/
+
+### RegExp
+
+Some Grunt plugins modify CSS with regular expressions but using a CSS parser
+and a node tree is a much safer way to edit CSS. Also, regexps will break
+source maps generated by preprocessors.
+
+### CSS Parsers
+
+There are a lot of good CSS parsers, like [Gonzales]. But they help you only
+with first step.
+
+Unlike them PostCSS gives you full source map support and useful high level API
+(for example, safe iterators).
+
+[Gonzales]: https://github.com/css/gonzales
+
+### Rework
+
+[Rework] and PostCSS are very similar, but they has different targets.
+
+Rework was created to build new CSS sublanguage to replace Stylus (like [Myth]).
+PostCSS was created for CSS tools, which works in chain with legacy CSS code
+(like Autoprefixer).
+
+Because of this background difference, PostCSS:
+
+* better works with source map, because it should update map from previous step
+  (like Sass compiling)
+* saves all your spaces and code style, because it can be worked in text editor
+  plugins
+* has safer parser, because it can be used for legacy code
+* has high level API to clean your processor from common tasks
+
+[Myth]:   http://www.myth.io/
+[Rework]: https://github.com/visionmedia/rework
+
+## Usage
+
+You can parse CSS by `postcss.parse()` method, which returns CSS AST:
+
+```js
+var postcss = require('postcss');
+
+var css = postcss.parse('a { color: black }');
+```
+
+Then you can change this AST. Use `css.list` to get childs.
+Properties `rule.selector`, `decl.prop`, `decl.value`, `atrule.name`
+and `atrule.params` contain data.
+
+Don’t use underscore properties (like `_selector`, `_params` and `_value`),
+because they are only for comments save magic
+(See [Raw Properties](#Raw Properties) below). Use getters and setters instead
+(like `selector`, `selectors`, `params` and `value`).
+
+```js
+css.list[0].value = 'white';
+```
+
+After changes you can get new CSS and modification’s source map:
+
+```js
+var result = css.toResult(options);
+
+result.css //=> 'a { color: white }'
+result.map //=> '{"version":3, … }'
+```
+
+Methods `postcss.parse()` and `CSS#toResult()` are low level API, for most cases
+it will be better to create processors with simplier API and chaining.
+
+### Processor
+
+The function `postcss(fn)` creates a processor from your function:
+
+```js
+var postcss = require('postcss');
+
+var processor = postcss(function (css) {
+    // Code to modify CSS
+});
+```
+
+If you want to combine multiple processors (and parse CSS only once),
+you can add several functions using the `use(fn)` method:
+
+```js
+var all = postcss().
+          use(prefixer).
+          use(minifing);
+```
+
+Processor function can change the current CSS node tree:
+
+```js
+postcss(function (css) {
+    css.append( /* new rule */ )
+});
+```
+
+or create a completely new CSS root node and return it instead:
+
+```js
+postcss(function (css) {
+    var newCSS = postcss.root()
+    // Add rules and declarations
+    return newCSS;
+});
+```
+
+This generated processor transforms some CSS using `process(css, opts)` method:
+
+```js
+var doubler = postcss(function (css) {
+    // Clone each declaration
+    css.eachDecl(function (decl) {
+        decl.parent.prepend( decl.clone() );
+    });
+});
+
+var css    = "a { color: black; }";
+var result = doubler.process(css);
+
+result.css //=> "a { color: black; color: black; }"
+```
+
+You can set the original CSS filename via `from` option and make syntax error
+messages much more helpful:
+
+```js
+var wrong = "a {";
+processor.process(wrong, { from: 'main.css' });
+//=> Can't parse CSS: Unclosed block at line 1:1 in main.css
+```
+
+You can also use result from previous postprocessor or already parsed `Root`
+as argument in next one:
+
+```js
+result = processor1.process(css)
+processor2.process(result)
+```
+
+### Multiple Inputs
+
+The function `postcss()` generates processor only for one input.
+If you need to process several inputs (like in files concatenation) you can use
+`postcss.parse()`.
+
+Let’s join two CSS with source map support in 5 lines of code:
+
+```js
+var file1 = postcss.parse(css1, { from: 'a.css' });
+var file2 = postcss.parse(css2, { from: 'b.css' });
+
+file1.rules = file1.rules.concat( file2.rules );
+
+var result = file1.toResult({ to: 'app.css', map: true });
+```
+
+### Source Map
+
+PostCSS will generate a source map, if you set `map` option to `true`
+in the `process(css, opts)` method.
+
+You must set input and output CSS files paths (using `from` and `to`
+options respectively) to generate correct source map.
+
+```js
+var result = processor.process(css, {
+    map:  true,
+    from: 'main.css',
+    to:   'main.out.css'
+});
+
+result.map //=> '{"version":3,"file":"main.out.css","sources":["main.css"],"names":[],"mappings":"AAAA,KAAI"}'
+
+fs.writeFileSync('main.out.css.map', result.map);
+```
+
+PostCSS can also modify previous source map (for example, from Sass
+compilation). So if you compile Sass to CSS and then minify this CSS
+by postprocessor, final source map will contain mapping from Sass code
+to minified CSS.
+
+Just set `map` option with an original source map (a string or a JS object):
+
+```js
+var result = minifier.process(css, {
+    map:   fs.readFileSync('main.sass.css.map'),
+    from: 'main.sass.css',
+    to:   'main.min.css'
+});
+
+result.map //=> Source map from main.sass to main.min.css
+```
+
+PostCSS try to autodetect previous map file. For example, if you process `a.css`
+and `a.css.map` is placed in same dir, PostCSS will read previous map and
+generate new one. You can disable autodetection by `map: false`.
+
+PostCSS, by default, will add annotation comment with path to new source map
+file:
+
+```css
+a { }
+/*# sourceMappingURL=main.out.css.map */
+```
+
+If you want to remove annotation, set `mapAnnotation` option to `false`.
+
+Inline maps are also supported. If input CSS will contain annotation
+from previous step with map in `data:uri`, PostCSS will update source map
+with yours changes and inine new map back to output CSS.
+
+Option `inlineMap` will force PostCSS to inline new map to CSS:
+
+```js
+var result = minifier.process(css, {
+    from:     'main.css',
+    to:       'main.min.css',
+    inlineMap: true
+});
+
+result.map //=> undefined, because map is in CSS
+result.css //=> "a{}\n/*# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFpbi5taW4uY3NzIiwic291cmNlcyI6WyJtYWluLmNzcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxJQUFLIn0= */"
+```
+
+### Helpers
+
+#### Vendor
+
+PostCSS contains heigh optimized code to split vendor prefix:
+
+```js
+var vendor = require('postcss/lib/vendor');
+
+vendor.prefix('-moz-tab-size')     //=> '-moz-'
+vendor.unprefixed('-moz-tab-size') //=> 'tab-size'
+```
+
+#### List
+
+To safely split comma- or space-separated values (like in `background-image`
+or `transform` ) with brackets and quotes support you can use `list` helper:
+
+```js
+var list = require('postcss/lib/list');
+
+list.space(image.value)     //=> ['linear-gradient(white, black)', 'blue']
+list.comma(transform.value) //=> ['color 200ms', 'background 200ms']
+```
+
+### Nodes
+
+Processor function receives `Root` node with CSS node tree inside.
+
+```js
+var processor = postcss(function (cssRoot) {
+});
+```
+
+There are 4 types of child nodes: `Comment`, `AtRule`, `Rule` and `Declaration`.
+All nodes have `toString()` and `clone()` methods.
+
+You can parse CSS and get a `Root` node by `postcss.parse(css, opts)` method:
+
+```js
+var cssRoot = postcss.parse('a { }');
+```
+
+All node‘s methods return current node, so you can build nice method chains:
+
+```js
+root.append( rule1 ).append( rule2 ).toString();
+```
+
+### Node Source
+
+Every node stores its origin file (if you set `from` option to `process`
+or `parse` method) and position:
+
+```js
+var root = postcss.parse(css, { from: 'main.css' });
+var rule = root.rules[0];
+
+rule.source.file  //=> 'main.css'
+rule.source.start //=> { line: 5,  position: 1 }
+rule.source.end   //=> { line: 10, position: 5 }
+```
+
+### Whitespaces
+
+All nodes (exclude `Root`) have `before` property with indentation
+and all earlier spaces.
+
+Nodes with children (`Root`, `AtRule` and `Rule`) contain also `after` property
+with spaces after last child and before `}` or end of file.
+
+Every `Declaration` has `between` property with colon, spaces and comments
+between property name and value. `Rule` stores spaces and comments between
+selector and `{` in `between` property. `AtRule` uses `between` also to store
+spaces and comments before `{` or `;` for bodiless at-rule.
+
+```js
+var root = postcss.parse("a {\n  color: black;\n}\n");
+
+root.rules[0].between          //=> " " between selector and {
+root.rules[0].decls[0].before  //=> "\n  " before color: black
+root.rules[0].decls[0].between //=> ": " between property name and value
+root.rules[0].after            //=> "\n" before }
+root.after                     //=> "\n" from end of file
+```
+
+The simplest way to minify CSS is to set `before`, `between` and `after`
+properties to an empty string:
+
+```js
+var minifier = postcss(function (css) {
+    css.eachDecl(function (decl) {
+        decl.before  = '';
+        decl.between = ':';
+    });
+    css.eachRule(function (rule) {
+        rule.before  = '';
+        rule.between = '';
+        rule.after   = '';
+    });
+    css.eachAtRule(function (atRule) {
+        atRule.before  = '';
+        atRule.between = '';
+        atRule.after   = '';
+    });
+    css.eachComment(function (comment) {
+        comment.removeSelf();
+    });
+});
+
+var css = "a {\n  color:black\n}\n";
+minifier.process(css).css //=> "a{color:black}"
+```
+
+### Raw Properties
+
+Some CSS values (selectors, comment text, at-rule params and declaration values)
+can contain comments. PostCSS will clean them from trailing spaces for you:
+
+```js
+var root = postcss.parse("a /**/ b {}");
+var rule  = root.rules[0];
+
+rule.selector      //=> 'a  b' trimmed and cleaned from comments
+rule._selector.raw //=> 'a /**/ b' original raw value
+```
+
+But PostCSS saves raw content to be able to stringify it to CSS, if you don’t
+change origin value. As you can remember, PostCSS tries to save origin CSS
+byte-to-byte, when it’s possible:
+
+```js
+rule.toString() //=> 'a /**/ b {}' with comment
+
+rule.selector = '.link b';
+rule.toString() //=> '.link b {}' you change value and origin comment was gone
+```
+
+### Containers
+
+`Root`, `AtRule` and `Rule` nodes can contain children in `rules` or `decls`
+property.
+
+There are common method to work with children:
+
+* `append(newChild)` to add child at the end of children list.
+* `prepend(newChild)` to add child at the beginning of children list.
+* `insertBefore(existsChild, newChild)` to insert new child before some
+   existent child.
+* `insertAfter(existsChild, newChild)` to insert new child after some
+   existent child.
+* `remove(existsChild)` to remove child.
+* `index(existsChild)` to return child index.
+* `some(fn)` to return true if `fn` returns true on any child.
+* `every(fn)` to return true if `fn` returns true on all children.
+
+Methods `insertBefore`, `insertAfter` and `remove` can receive child node
+or child index as an `existsChild` argument. Have in mind that child index works
+much faster.
+
+There are two shorcuts to get first and last child:
+
+```js
+rule.first //=> First declaration in rule
+rule.last  //=> Last declaration in rule
+```
+
+### Children
+
+`Comment`, `AtRule`, `Rule` and `Declaration` nodes should be wrapped
+in other nodes.
+
+All children contain `parent` property with parent node:
+
+```js
+rule.decls[0].parent == rule;
+```
+
+All children has `removeSelf()` method:
+
+```js
+rule.decls[0].removeSelf();
+```
+
+But `remove(index)` in parent with child index is much faster:
+
+```js
+rule.each(function (decl, i) {
+    rule.remove(i);
+});
+```
+
+### Iterators
+
+All parent nodes have `each` method to iterate over children nodes:
+
+```js
+root = postcss.parse('a { color: black; display: none }');
+
+root.each(function (rule, i) {
+    if ( rule.type == 'rule' ) {
+        console.log(rule.selector, i); // Will log "a 0"
+    }
+});
+
+root.rules[0].each(function (decl, i) {
+    if ( rule.type != 'comment' ) {
+        console.log(decl.prop, i); // Will log "color 0" and "display 1"
+    }
+});
+```
+
+Unlike `for {}`-cycle construct or `Array#forEach()` this iterator is safe.
+You can mutate children while iteration and it will fix current index:
+
+```js
+rule.rules.forEach(function (decl, i) {
+    rule.prepend( decl.clone() );
+    // Will be infinity cycle, because on prepend current declaration become
+    // second and next index will go to current declaration again
+});
+
+rule.each(function (decl, i) {
+    rule.prepend( decl.clone() );
+    // Will work correct (once clone each declaration), because after prepend
+    // iterator index will be recalculated
+});
+```
+
+Because CSS have nested structure, PostCSS also contains recursive iterator
+`eachInside`:
+
+```js
+root.eachInside(function (node, i) {
+    console.log(node.type + ' inside ' + node.parent.type);
+});
+```
+
+There are also shortcuts to recursive iterate all nodes of specific type:
+
+```js
+root.eachDecl(function (decl, i) {
+    // Each declaration inside root
+});
+
+root.eachRule(function (rule, i) {
+    // Each rule inside root and any nested at-rules
+});
+
+root.eachAtRule(function (atRule, i) {
+    // Each at-rule inside root and any nested at-rules
+});
+
+root.eachComment(function (comment, i) {
+    // Each comment inside root
+})
+```
+
+You can break iteration by `return false`.
+
+### Root Node
+
+`Root` node contains entire CSS tree. Its children can be only `Comment`,
+`AtRule` or `Rule` nodes in `rules` property.
+
+You can create a new root using shortcut:
+
+```js
+var root = postcss.root();
+```
+
+Method `toString()` stringifies entire node tree to CSS string:
+
+```js
+root = postcss.parse(css);
+root.toString() == css;
+```
+
+### Comment Node
+
+```css
+/* Block comment */
+```
+
+PostCSS creates `Comment` nodes only for comments between rules or declarations.
+Comments inside selectors, at-rules params, declaration values will be stored
+in Raw property.
+
+`Comment` has only one property: `text` with trimmed text inside comment.
+
+```js
+comment.text //=> "Block comment"
+```
+
+You can create a new comment using shortcut:
+
+```js
+var comment = postcss.comment({ text: 'New comment' });
+```
+
+### AtRule Node
+
+```css
+@charset 'utf-8';
+
+@font-face {
+    font-family: 'Cool'
+}
+
+@media print {
+    img { display: none }
+}
+```
+
+`AtRule` has two own properties: `name` and `params`.
+
+As you see, some at-rules don’t contain any children (like `@charset`
+or `@import`), some of at-rules can contain only declarations
+(like `@font-face` or `@page`), but most of them can contain rules
+and nested at-rules (like `@media`, `@keyframes` and others).
+
+Parser selects `AtRule` content type by its name. If you create `AtRule`
+node manually, it will detect own content type with new child type on first
+`append` or other add method call:
+
+```js
+var atRule = postcss.atRule({ name: '-x-animations' });
+atRule.rules        //=> undefined
+atRule.decls        //=> undefined
+
+atRule.append( postcss.rule({ selector: 'from' }) );
+atRule.rules.length //=> 1
+atRule.decls        //=> undefined
+```
+
+You can create a new at-rule using shortcut:
+
+```js
+var atRule = postcss.atRule({ name: 'charset', params: 'utf-8' });
+```
+
+### Rule Node
+
+```css
+a {
+    color: black;
+}
+```
+
+`Rule` node has `selector` property and contains `Declaration` and `Comment`
+children in `decls` property.
+
+There is `selectors` shortcut, which return array:
+
+```js
+rule.selector  //=> "a, b"
+rule.selectors //=> ['a', 'b']
+```
+
+You can miss `Declaration` constructor in `append` and other insert methods:
+
+```js
+rule.append({ prop: 'color', value: 'black' });
+```
+
+Property `semicolon` indicates if last declaration in rule has semicolon or not:
+
+```js
+var root = postcss.parse('a { color: black }');
+root.rules[0].semicolon //=> false
+
+var root = postcss.parse('a { color: black; }');
+root.rules[0].semicolon //=> true
+```
+
+You can create a new rule using shortcut:
+
+```js
+var rule = postcss.rule({ selector: 'a' });
+```
+
+### Declaration Node
+
+```css
+color: black
+```
+
+`Declaration` node has `prop`, `value` and `important` properties.
+
+You can create a new declaration using this shortcut:
+
+```js
+var decl = postcss.decl({ prop: 'color', value: 'black' });
+```
+
+Or use short form in rule’s `append()` and other add methods:
+
+```js
+rule.append({ prop: 'color', value: 'black' });
+```