pleeease 0.0.2

data/node_modules/pleeease/node_modules/pixrem/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "pixrem",
+  "description": "A CSS post-processor that generates pixel fallbacks for rem units.",
+  "version": "0.1.4",
+  "homepage": "https://github.com/robwierzbowski/node-pixrem",
+  "author": {
+    "name": "Rob Wierzbowski",
+    "email": "hello@robwierzbowski.com",
+    "url": "http://robwierzbowski.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/robwierzbowski/node-pixrem.git"
+  },
+  "bugs": {
+    "url": "https://github.com/robwierzbowski/node-pixrem/issues"
+  },
+  "licenses": [
+    {
+      "type": "BSD-new"
+    }
+  ],
+  "main": "lib/pixrem.js",
+  "engines": {
+    "node": ">=0.10.0",
+    "npm": ">=1.2.10"
+  },
+  "scripts": {
+    "test": "jasmine-node spec"
+  },
+  "dependencies": {
+    "postcss": "~0.3.0"
+  },
+  "devDependencies": {
+    "jasmine-node": "~1.11.0"
+  },
+  "keywords": [
+    "css",
+    "parser",
+    "postproccessor",
+    "rem",
+    "responsive"
+  ],
+  "readme": "# Pixrem\n\n[![Build Status](https://travis-ci.org/robwierzbowski/node-pixrem.png?branch=master)](https://travis-ci.org/robwierzbowski/node-pixrem)\n\nA CSS post-processor that generates pixel fallbacks for rem units.  \nWritten with [PostCSS](https://github.com/ai/postcss).  \nAdd it to your build process with [grunt-pixrem](https://github.com/robwierzbowski/grunt-pixrem).  \n\n## Installation\n\n`npm install --save pixrem`\n\n## Usage\n\nPixrem is a CSS post-processor that, given CSS and a root em value, returns CSS with pixel unit fallbacks or replacements. Check the [browser data](http://caniuse.com/rem): if you want to use rem units and support < IE9, Opera Mini, or older Opera Mobile, this post-processor is for you.\n\n### Example\n\n```js\n'use strict';\nvar fs = require('fs');\nvar pixrem = require('pixrem');\nvar css = fs.readFileSync('main.css', 'utf8');\nvar processedCss = pixrem.process(css, '200%');\n\nfs.writeFile('main.with-fallbacks.css', processedCss, function (err) {\n  if (err) {\n    throw err;\n  }\n  console.log('IE8, you\\'re welcome.');\n});\n```\n\nPixrem takes this:\n\n```css\n.sky {\n  margin: 2.5rem 2px 3em 100%;\n  color: blue;\n}\n\n@media screen and (min-width: 20rem) {\n  .leaf {\n    margin-bottom: 1.333rem;\n    font-size: 1.5rem;\n  }\n}\n```\n\nAnd returns this:\n\n```css\n.sky {\n  margin: 80px 2px 3em 100%;\n  margin: 2.5rem 2px 3em 100%;\n  color: blue;\n}\n\n@media screen and (min-width: 20rem) {\n  .leaf {\n    margin-bottom: 42px;\n    margin-bottom: 1.333rem;\n    font-size: 48px;\n    font-size: 1.5rem;\n  }\n}\n```\n\n### Parameters\n\n#### css\n\nType: `String`  \n\nSome CSS to process.\n\n#### rootvalue\n\nType: `String | Null`  \nDefault: `16px`  \n\nThe root element font size. Can be px, rem, em, percent, or unitless pixel value.\n\n#### options\n\nType: `Object | Null`  \nDefault: `{ replace: false }`  \n\n- `replace` replaces rules containing rems instead of adding fallbacks.\n\n## Contribute\n\nReport bugs and feature proposals in the [Github issue tracker](https://github.com/robwierzbowski/node-pixrem/issues). Run tests with jasmine-node. In lieu of a formal styleguide, take care to maintain the existing coding style. \n\n## Release History\n\n0.1.4, March 6, 2014: Code optimization from AI.  \n0.1.3, Dec 14, 2013: Fix regex for < 0 values.  \n0.1.1, 0.1.2, Dec 14, 2013: Documentation improvements.  \n0.1.0, Dec 14, 2013: Initial release.  \n\n## License\n\n[MIT](http://en.wikipedia.org/wiki/MIT_License)\n\n\n[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/robwierzbowski/node-pixrem/trend.png)](https://bitdeli.com/free \"Bitdeli Badge\")\n\n",
+  "readmeFilename": "README.md",
+  "_id": "pixrem@0.1.4",
+  "_shasum": "d5a5fd72dcfe86301711372a602994fce442dd5e",
+  "_from": "https://github.com/iamvdo/node-pixrem/tarball/master",
+  "_resolved": "https://github.com/iamvdo/node-pixrem/tarball/master"
+}

data/node_modules/pleeease/node_modules/pixrem/spec/pixrem-spec.js

@@ -0,0 +1,78 @@
+// Jasmine unit tests
+// To run tests, run these commands from the project root:
+// 1. `npm install -g jasmine-node`
+// 2. `jasmine-node spec`
+
+'use strict';
+var fs = require('fs');
+var pixrem = require('../lib/pixrem');
+var css = '.rule { font-size: 2rem }';
+
+console.log(pixrem);
+
+describe('pixrem', function () {
+
+  it('should generate fallbacks using default settings', function () {
+    var expected = '.rule { font-size: 32px; font-size: 2rem }';
+    var processed = pixrem.process(css);
+
+    expect(processed).toBe(expected);
+  });
+
+  it('should generate fallbacks with a pixel root em value', function () {
+    var expected = '.rule { font-size: 40px; font-size: 2rem }';
+    var processed = pixrem.process(css, '20px');
+
+    expect(processed).toBe(expected);
+  });
+
+  it('should generate fallbacks with a em root em value', function () {
+    var expected = '.rule { font-size: 48px; font-size: 2rem }';
+    var processed = pixrem.process(css, '1.5em');
+
+    expect(processed).toBe(expected);
+  });
+
+  it('should generate fallbacks with a rem root em value', function () {
+    var expected = '.rule { font-size: 56px; font-size: 2rem }';
+    var processed = pixrem.process(css, '1.75rem');
+
+    expect(processed).toBe(expected);
+  });
+
+  it('should generate fallbacks with a percent root em value', function () {
+    var expected = '.rule { font-size: 48px; font-size: 2rem }';
+    var processed = pixrem.process(css, '150%');
+
+    expect(processed).toBe(expected);
+  });
+
+  it('should generate fallbacks with a unitless root em value', function () {
+    var expected = '.rule { font-size: 36px; font-size: 2rem }';
+    var processed = pixrem.process(css, '18');
+
+    expect(processed).toBe(expected);
+  });
+
+  it('should replace rules with fallbacks when option.replace is true', function () {
+    var expected = '.rule { font-size: 40px }';
+    var processed = pixrem.process(css, '20px', { replace: true });
+
+    expect(processed).toBe(expected);
+  });
+
+  it('should generate integer fallbacks, rounded down', function () {
+    var expected = '.rule { font-size: 49px; font-size: 2rem }';
+    var processed = pixrem.process(css, '155%');
+
+    expect(processed).toBe(expected);
+  });
+
+  it('should handle < 1 values and values without a leading 0', function () {
+    var css = '.rule { margin: 0.5rem .5rem 0rem -2rem }';
+    var expected = '.rule { margin: 8px 8px 0px -32px; margin: 0.5rem .5rem 0rem -2rem }';
+    var processed = pixrem.process(css);
+
+    expect(processed).toBe(expected);
+  });
+});

data/node_modules/pleeease/node_modules/postcss-vars/README.md

@@ -0,0 +1,84 @@
+postcss-vars
+============
+
+Add a "not so bad" CSS custom properties support to your CSS, using [PostCSS](https://github.com/ai/postcss). **This is not a polyfill**. Native custom properties are way more powerful, due to cascade and inheritance.
+
+Largely inspired by [rework-vars](https://github.com/reworkcss/rework-vars).
+
+##Install
+
+```js
+npm install postcss-vars
+```
+
+##Use
+
+Only variables defined in `:root` (and not in media-queries) will be used. Let's take this css:
+
+```css
+:root {
+	--color-one: blue;
+	--color-two: green;
+	--color-three: var(--color-two);
+}
+.elem {
+	color: var(--color-one);
+}
+.item {
+	background: linear-gradient(var(--color-two), red);
+}
+@media (min-width: 50em) {
+	.elem {
+		color: var(--color-two);
+	}
+}
+```
+
+Fix variables, and you will get the following output:
+
+```css
+:root {
+	--color-one: blue;
+	--color-two: green;
+	--color-three: var(--color-two);
+}
+.elem {
+	color: blue;
+}
+.item {
+	background: linear-gradient(green, red);
+}
+@media (min-width: 50em) {
+	.elem {
+		color: green;
+	}
+}
+```
+
+##API
+
+###processor
+
+This is the core function. Combine it with others PostCSS plugins, such as Autoprefixer:
+
+```js
+var autoprefixer = require('autoprefixer'),
+	postcssVars = require('postcss-vars'),
+	postcss = require('postcss');
+var fixed = postcss().
+			use(postcssVars.processor).
+			use(autoprefixer.postcss).
+			process(css).css;
+```
+
+###postcss
+
+This is the full process function. Pass the `css` as the first argument and grab your fixed CSS.
+
+```js
+var postcssVars = require('postcss-vars');
+var fixed = postcssVars.postcss(css).css;
+```
+
+##License
+MIT

data/node_modules/pleeease/node_modules/postcss-vars/lib/index.js

@@ -0,0 +1,91 @@
+var postcss = require('postcss');
+var variables = [];
+var varStartIdentifier = '--';
+var refStartIdentifier = 'var(';
+
+var _process = function (css) {
+
+	// for each rules
+	css.eachRule(function (rule) {
+
+		// if selector is :root
+		if (rule.selectors.length === 1 && rule.selectors[0] === ':root' && rule.parent.type === 'root') {
+
+			rule.each(function (decl) {
+				if (decl.type === 'decl' && decl.prop.indexOf(varStartIdentifier) === 0) {
+					// store all variables
+					variables[decl.prop] = decl.value;
+				}
+			});
+
+		// else, it's not :root
+		} else {
+
+			rule.each(function (decl) {
+				if (decl.type === 'decl' && decl.value.indexOf(refStartIdentifier) !== -1) {
+					decl.value = _replaceValue(decl.value);
+				}
+			});
+
+		}
+
+	});
+
+	return css;
+
+};
+
+var _replaceValue = function (value) {
+
+	// matches `var(name[, fallback])`, captures 'name' and 'fallback'
+	var regexpVar = /\bvar\(([\w-]+)(?:\s*,\s*)?(.*)?\)/;
+	// matches `var()`
+	var regexpEmptyVar = /\bvar\(\s*\)/;
+
+	var valueLen = value.length;
+	var beginSlice = value.indexOf(refStartIdentifier);
+	var endSlice = beginSlice + refStartIdentifier.length;
+	var depth = 1;
+	var currentChar;
+	var cssVariable;
+
+	// find the closing `)` of the CSS variable function,
+	// accounting for nested functions
+	while (endSlice < valueLen && depth > 0) {
+		currentChar = value.charAt(endSlice);
+		if (currentChar == '(') depth += 1;
+		if (currentChar == ')') depth -= 1;
+		endSlice += 1;
+	}
+
+	if (depth > 0) throw new Error('postcss-vars: missing closing ")" in the value "' + value + '"');
+
+	cssVariable = value.slice(beginSlice, endSlice);
+
+	if (regexpEmptyVar.test(cssVariable)) throw new Error('postcss-vars: var() must contain a non-whitespace string');
+
+	cssReplacement = cssVariable.replace(regexpVar, function(_, name, fallback){
+		var replacement = variables[name];
+		if (!replacement && !fallback) throw new Error('postcss-vars: variable "' + name + '" is undefined');
+		if (!replacement && fallback) return fallback;
+		return replacement;
+	});
+
+	// resolve the variable
+	value = value.split(cssVariable).join(cssReplacement);
+
+	// recursively resolve any remaining variables
+	if (/\bvar\(/.test(value)) {
+		value = _replaceValue(value);
+	}
+
+	return value;
+
+};
+
+var _postcss = function (css, opts) {
+	return postcss().use(this.processor).process(css, opts);
+};
+
+exports.processor = _process;
+exports.postcss = _postcss;

data/node_modules/pleeease/node_modules/postcss-vars/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "postcss-vars",
+  "version": "0.1.0",
+  "author": {
+    "name": "Vincent De Oliveira"
+  },
+  "description": "\"Not so bad\" CSS custom properties' postprocessor",
+  "main": "./lib/index",
+  "dependencies": {
+    "postcss": "0.3.4"
+  },
+  "readme": "postcss-vars\r\n============\r\n\r\nAdd a \"not so bad\" CSS custom properties support to your CSS, using [PostCSS](https://github.com/ai/postcss). **This is not a polyfill**. Native custom properties are way more powerful, due to cascade and inheritance.\r\n\r\nLargely inspired by [rework-vars](https://github.com/reworkcss/rework-vars).\r\n\r\n##Install\r\n\r\n```js\r\nnpm install postcss-vars\r\n```\r\n\r\n##Use\r\n\r\nOnly variables defined in `:root` (and not in media-queries) will be used. Let's take this css:\r\n\r\n```css\r\n:root {\r\n\t--color-one: blue;\r\n\t--color-two: green;\r\n\t--color-three: var(--color-two);\r\n}\r\n.elem {\r\n\tcolor: var(--color-one);\r\n}\r\n.item {\r\n\tbackground: linear-gradient(var(--color-two), red);\r\n}\r\n@media (min-width: 50em) {\r\n\t.elem {\r\n\t\tcolor: var(--color-two);\r\n\t}\r\n}\r\n```\r\n\r\nFix variables, and you will get the following output:\r\n\r\n```css\r\n:root {\r\n\t--color-one: blue;\r\n\t--color-two: green;\r\n\t--color-three: var(--color-two);\r\n}\r\n.elem {\r\n\tcolor: blue;\r\n}\r\n.item {\r\n\tbackground: linear-gradient(green, red);\r\n}\r\n@media (min-width: 50em) {\r\n\t.elem {\r\n\t\tcolor: green;\r\n\t}\r\n}\r\n```\r\n\r\n##API\r\n\r\n###processor\r\n\r\nThis is the core function. Combine it with others PostCSS plugins, such as Autoprefixer:\r\n\r\n```js\r\nvar autoprefixer = require('autoprefixer'),\r\n\tpostcssVars = require('postcss-vars'),\r\n\tpostcss = require('postcss');\r\nvar fixed = postcss().\r\n\t\t\tuse(postcssVars.processor).\r\n\t\t\tuse(autoprefixer.postcss).\r\n\t\t\tprocess(css).css;\r\n```\r\n\r\n###postcss\r\n\r\nThis is the full process function. Pass the `css` as the first argument and grab your fixed CSS.\r\n\r\n```js\r\nvar postcssVars = require('postcss-vars');\r\nvar fixed = postcssVars.postcss(css).css;\r\n```\r\n\r\n##License\r\nMIT",
+  "readmeFilename": "README.md",
+  "_id": "postcss-vars@0.1.0",
+  "_shasum": "f2f8ae314a471c852f9a9a64235208bf5dca75fa",
+  "_from": "postcss-vars@~0.1.0",
+  "_resolved": "https://registry.npmjs.org/postcss-vars/-/postcss-vars-0.1.0.tgz"
+}

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

@@ -0,0 +1,42 @@
+## 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/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/postcss/README.md

@@ -0,0 +1,732 @@
+# 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.
+
+[Autoprefixer]: https://github.com/ai/autoprefixer
+[grunt-pixrem]: https://github.com/robwierzbowski/grunt-pixrem
+[CSS MQPacker]: https://github.com/hail2u/node-css-mqpacker
+
+## 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
+
+### 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
+```
+
+### 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 ' + 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
+})
+```
+
+### 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' });
+```