Initial commit

node_modules/postcss-value-parser/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) Bogdan Chadkin <trysound@yandex.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.

node_modules/postcss-value-parser/README.md

@@ -0,0 +1,253 @@
+# postcss-value-parser
+
+[![Travis CI](https://travis-ci.org/TrySound/postcss-value-parser.svg)](https://travis-ci.org/TrySound/postcss-value-parser)
+
+Transforms CSS declaration values and at-rule parameters into a tree of nodes, and provides a simple traversal API.
+
+## Usage
+
+```js
+var valueParser = require('postcss-value-parser');
+var cssBackgroundValue = 'url(foo.png) no-repeat 40px 73%';
+var parsedValue = valueParser(cssBackgroundValue);
+// parsedValue exposes an API described below,
+// e.g. parsedValue.walk(..), parsedValue.toString(), etc.
+```
+
+For example, parsing the value `rgba(233, 45, 66, .5)` will return the following:
+
+```js
+{
+  nodes: [
+    {
+      type: 'function',
+      value: 'rgba',
+      before: '',
+      after: '',
+      nodes: [
+        { type: 'word', value: '233' },
+        { type: 'div', value: ',', before: '', after: ' ' },
+        { type: 'word', value: '45' },
+        { type: 'div', value: ',', before: '', after: ' ' },
+        { type: 'word', value: '66' },
+        { type: 'div', value: ',', before: ' ', after: '' },
+        { type: 'word', value: '.5' }
+      ]
+    }
+  ]
+}
+```
+
+If you wanted to convert each `rgba()` value in `sourceCSS` to a hex value, you could do so like this:
+
+```js
+var valueParser = require('postcss-value-parser');
+
+var parsed = valueParser(sourceCSS);
+
+// walk() will visit all the of the nodes in the tree,
+// invoking the callback for each.
+parsed.walk(function (node) {
+
+  // Since we only want to transform rgba() values,
+  // we can ignore anything else.
+  if (node.type !== 'function' && node.value !== 'rgba') return;
+
+  // We can make an array of the rgba() arguments to feed to a
+  // convertToHex() function
+  var color = node.nodes.filter(function (node) {
+    return node.type === 'word';
+  }).map(function (node) {
+    return Number(node.value);
+  }); // [233, 45, 66, .5]
+
+  // Now we will transform the existing rgba() function node
+  // into a word node with the hex value
+  node.type = 'word';
+  node.value = convertToHex(color);
+})
+
+parsed.toString(); // #E92D42
+```
+
+## Nodes
+
+Each node is an object with these common properties:
+
+- **type**: The type of node (`word`, `string`, `div`, `space`, `comment`, or `function`).
+  Each type is documented below.
+- **value**: Each node has a `value` property; but what exactly `value` means
+  is specific to the node type. Details are documented for each type below.
+- **sourceIndex**: The starting index of the node within the original source
+  string. For example, given the source string `10px 20px`, the `word` node
+  whose value is `20px` will have a `sourceIndex` of `5`.
+
+### word
+
+The catch-all node type that includes keywords (e.g. `no-repeat`),
+quantities (e.g. `20px`, `75%`, `1.5`), and hex colors (e.g. `#e6e6e6`).
+
+Node-specific properties:
+
+- **value**: The "word" itself.
+
+### string
+
+A quoted string value, e.g. `"something"` in `content: "something";`.
+
+Node-specific properties:
+
+- **value**: The text content of the string.
+- **quote**: The quotation mark surrounding the string, either `"` or `'`.
+- **unclosed**: `true` if the string was not closed properly. e.g. `"unclosed string  `.
+
+### div
+
+A divider, for example
+
+- `,` in `animation-duration: 1s, 2s, 3s`
+- `/` in `border-radius: 10px / 23px`
+- `:` in `(min-width: 700px)`
+
+Node-specific properties:
+
+- **value**: The divider character. Either `,`, `/`, or `:` (see examples above).
+- **before**: Whitespace before the divider.
+- **after**: Whitespace after the divider.
+
+### space
+
+Whitespace used as a separator, e.g. ` ` occurring twice in `border: 1px solid black;`.
+
+Node-specific properties:
+
+- **value**: The whitespace itself.
+
+### comment
+
+A CSS comment starts with `/*` and ends with `*/`
+
+Node-specific properties:
+
+- **value**: The comment value without `/*` and `*/`
+- **unclosed**: `true` if the comment was not closed properly. e.g. `/* comment without an end  `.
+
+### function
+
+A CSS function, e.g. `rgb(0,0,0)` or `url(foo.bar)`.
+
+Function nodes have nodes nested within them: the function arguments.
+
+Additional properties:
+
+- **value**: The name of the function, e.g. `rgb` in `rgb(0,0,0)`.
+- **before**: Whitespace after the opening parenthesis and before the first argument,
+  e.g. `  ` in `rgb(  0,0,0)`.
+- **after**: Whitespace before the closing parenthesis and after the last argument,
+  e.g. `  ` in `rgb(0,0,0  )`.
+- **nodes**: More nodes representing the arguments to the function.
+- **unclosed**: `true` if the parentheses was not closed properly. e.g. `( unclosed-function  `.
+
+Media features surrounded by parentheses are considered functions with an
+empty value. For example, `(min-width: 700px)` parses to these nodes:
+
+```js
+[
+  {
+    type: 'function', value: '', before: '', after: '',
+    nodes: [
+      { type: 'word', value: 'min-width' },
+      { type: 'div', value: ':', before: '', after: ' ' },
+      { type: 'word', value: '700px' }
+    ]
+  }
+]
+```
+
+`url()` functions can be parsed a little bit differently depending on
+whether the first character in the argument is a quotation mark.
+
+`url( /gfx/img/bg.jpg )` parses to:
+
+```js
+{ type: 'function', sourceIndex: 0, value: 'url', before: ' ', after: ' ', nodes: [
+    { type: 'word', sourceIndex: 5, value: '/gfx/img/bg.jpg' }
+] }
+```
+
+`url( "/gfx/img/bg.jpg" )`, on the other hand, parses to:
+
+```js
+{ type: 'function', sourceIndex: 0, value: 'url', before: ' ', after: ' ', nodes: [
+     type: 'string', sourceIndex: 5, quote: '"', value: '/gfx/img/bg.jpg' },
+] }
+```
+
+## API
+
+```
+var valueParser = require('postcss-value-parser');
+```
+
+### valueParser.unit(quantity)
+
+Parses `quantity`, distinguishing the number from the unit. Returns an object like the following:
+
+```js
+// Given 2rem
+{
+  number: '2',
+  unit: 'rem'
+}
+```
+
+If the `quantity` argument cannot be parsed as a number, returns `false`.
+
+*This function does not parse complete values*: you cannot pass it `1px solid black` and expect `px` as
+the unit. Instead, you should pass it single quantities only. Parse `1px solid black`, then pass it
+the stringified `1px` node (a `word` node) to parse the number and unit.
+
+### valueParser.stringify(nodes[, custom])
+
+Stringifies a node or array of nodes.
+
+The `custom` function is called for each `node`; return a string to override the default behaviour.
+
+### valueParser.walk(nodes, callback[, bubble])
+
+Walks each provided node, recursively walking all descendent nodes within functions.
+
+Returning `false` in the `callback` will prevent traversal of descendent nodes (within functions).
+You can use this feature to for shallow iteration, walking over only the *immediate* children.
+*Note: This only applies if `bubble` is `false` (which is the default).*
+
+By default, the tree is walked from the outermost node inwards.
+To reverse the direction, pass `true` for the `bubble` argument.
+
+The `callback` is invoked with three arguments: `callback(node, index, nodes)`.
+
+- `node`: The current node.
+- `index`: The index of the current node.
+- `nodes`: The complete nodes array passed to `walk()`.
+
+Returns the `valueParser` instance.
+
+### var parsed = valueParser(value)
+
+Returns the parsed node tree.
+
+### parsed.nodes
+
+The array of nodes.
+
+### parsed.toString()
+
+Stringifies the node tree.
+
+### parsed.walk(callback[, bubble])
+
+Walks each node inside `parsed.nodes`. See the documentation for `valueParser.walk()` above.
+
+# License
+
+MIT © [Bogdan Chadkin](mailto:trysound@yandex.ru)

node_modules/postcss-value-parser/lib/index.js

@@ -0,0 +1,28 @@
+var parse = require('./parse');
+var walk = require('./walk');
+var stringify = require('./stringify');
+
+function ValueParser(value) {
+    if (this instanceof ValueParser) {
+        this.nodes = parse(value);
+        return this;
+    }
+    return new ValueParser(value);
+}
+
+ValueParser.prototype.toString = function () {
+    return Array.isArray(this.nodes) ? stringify(this.nodes) : '';
+};
+
+ValueParser.prototype.walk = function (cb, bubble) {
+    walk(this.nodes, cb, bubble);
+    return this;
+};
+
+ValueParser.unit = require('./unit');
+
+ValueParser.walk = walk;
+
+ValueParser.stringify = stringify;
+
+module.exports = ValueParser;

node_modules/postcss-value-parser/lib/parse.js

@@ -0,0 +1,242 @@
+var openParentheses = '('.charCodeAt(0);
+var closeParentheses = ')'.charCodeAt(0);
+var singleQuote = '\''.charCodeAt(0);
+var doubleQuote = '"'.charCodeAt(0);
+var backslash = '\\'.charCodeAt(0);
+var slash = '/'.charCodeAt(0);
+var comma = ','.charCodeAt(0);
+var colon = ':'.charCodeAt(0);
+var star = '*'.charCodeAt(0);
+
+module.exports = function (input) {
+    var tokens = [];
+    var value = input;
+
+    var next, quote, prev, token, escape, escapePos, whitespacePos;
+    var pos = 0;
+    var code = value.charCodeAt(pos);
+    var max = value.length;
+    var stack = [{ nodes: tokens }];
+    var balanced = 0;
+    var parent;
+
+    var name = '';
+    var before = '';
+    var after = '';
+
+    while (pos < max) {
+        // Whitespaces
+        if (code <= 32) {
+            next = pos;
+            do {
+                next += 1;
+                code = value.charCodeAt(next);
+            } while (code <= 32);
+            token = value.slice(pos, next);
+
+            prev = tokens[tokens.length - 1];
+            if (code === closeParentheses && balanced) {
+                after = token;
+            } else if (prev && prev.type === 'div') {
+                prev.after = token;
+            } else if (code === comma || code === colon || code === slash && value.charCodeAt(next + 1) !== star) {
+                before = token;
+            } else {
+                tokens.push({
+                    type: 'space',
+                    sourceIndex: pos,
+                    value: token
+                });
+            }
+
+            pos = next;
+
+        // Quotes
+        } else if (code === singleQuote || code === doubleQuote) {
+            next = pos;
+            quote = code === singleQuote ? '\'' : '"';
+            token = {
+                type: 'string',
+                sourceIndex: pos,
+                quote: quote
+            };
+            do {
+                escape = false;
+                next = value.indexOf(quote, next + 1);
+                if (~next) {
+                    escapePos = next;
+                    while (value.charCodeAt(escapePos - 1) === backslash) {
+                        escapePos -= 1;
+                        escape = !escape;
+                    }
+                } else {
+                    value += quote;
+                    next = value.length - 1;
+                    token.unclosed = true;
+                }
+            } while (escape);
+            token.value = value.slice(pos + 1, next);
+
+            tokens.push(token);
+            pos = next + 1;
+            code = value.charCodeAt(pos);
+
+        // Comments
+        } else if (code === slash && value.charCodeAt(pos + 1) === star) {
+            token = {
+                type: 'comment',
+                sourceIndex: pos
+            };
+
+            next = value.indexOf('*/', pos);
+            if (next === -1) {
+                token.unclosed = true;
+                next = value.length;
+            }
+
+            token.value = value.slice(pos + 2, next);
+            tokens.push(token);
+
+            pos = next + 2;
+            code = value.charCodeAt(pos);
+
+        // Dividers
+        } else if (code === slash || code === comma || code === colon) {
+            token = value[pos];
+
+            tokens.push({
+                type: 'div',
+                sourceIndex: pos - before.length,
+                value: token,
+                before: before,
+                after: ''
+            });
+            before = '';
+
+            pos += 1;
+            code = value.charCodeAt(pos);
+
+        // Open parentheses
+        } else if (openParentheses === code) {
+            // Whitespaces after open parentheses
+            next = pos;
+            do {
+                next += 1;
+                code = value.charCodeAt(next);
+            } while (code <= 32);
+            token = {
+                type: 'function',
+                sourceIndex: pos - name.length,
+                value: name,
+                before: value.slice(pos + 1, next)
+            };
+            pos = next;
+
+            if (name === 'url' && code !== singleQuote && code !== doubleQuote) {
+                next -= 1;
+                do {
+                    escape = false;
+                    next = value.indexOf(')', next + 1);
+                    if (~next) {
+                        escapePos = next;
+                        while (value.charCodeAt(escapePos - 1) === backslash) {
+                            escapePos -= 1;
+                            escape = !escape;
+                        }
+                    } else {
+                        value += ')';
+                        next = value.length - 1;
+                        token.unclosed = true;
+                    }
+                } while (escape);
+                // Whitespaces before closed
+                whitespacePos = next;
+                do {
+                    whitespacePos -= 1;
+                    code = value.charCodeAt(whitespacePos);
+                } while (code <= 32);
+                if (pos !== whitespacePos + 1) {
+                    token.nodes = [{
+                        type: 'word',
+                        sourceIndex: pos,
+                        value: value.slice(pos, whitespacePos + 1)
+                    }];
+                } else {
+                    token.nodes = [];
+                }
+                if (token.unclosed && whitespacePos + 1 !== next) {
+                    token.after = '';
+                    token.nodes.push({
+                        type: 'space',
+                        sourceIndex: whitespacePos + 1,
+                        value: value.slice(whitespacePos + 1, next)
+                    });
+                } else {
+                    token.after = value.slice(whitespacePos + 1, next);
+                }
+                pos = next + 1;
+                code = value.charCodeAt(pos);
+                tokens.push(token);
+            } else {
+                balanced += 1;
+                token.after = '';
+                tokens.push(token);
+                stack.push(token);
+                tokens = token.nodes = [];
+                parent = token;
+            }
+            name = '';
+
+        // Close parentheses
+        } else if (closeParentheses === code && balanced) {
+            pos += 1;
+            code = value.charCodeAt(pos);
+
+            parent.after = after;
+            after = '';
+            balanced -= 1;
+            stack.pop();
+            parent = stack[balanced];
+            tokens = parent.nodes;
+
+        // Words
+        } else {
+            next = pos;
+            do {
+                if (code === backslash) {
+                    next += 1;
+                }
+                next += 1;
+                code = value.charCodeAt(next);
+            } while (next < max && !(
+                code <= 32 ||
+                code === singleQuote ||
+                code === doubleQuote ||
+                code === comma ||
+                code === colon ||
+                code === slash ||
+                code === openParentheses ||
+                code === closeParentheses && balanced
+            ));
+            token = value.slice(pos, next);
+
+            if (openParentheses === code) {
+                name = token;
+            } else {
+                tokens.push({
+                    type: 'word',
+                    sourceIndex: pos,
+                    value: token
+                });
+            }
+
+            pos = next;
+        }
+    }
+
+    for (pos = stack.length - 1; pos; pos -= 1) {
+        stack[pos].unclosed = true;
+    }
+
+    return stack[0].nodes;
+};

node_modules/postcss-value-parser/lib/stringify.js

@@ -0,0 +1,41 @@
+function stringifyNode(node, custom) {
+    var type = node.type;
+    var value = node.value;
+    var buf;
+    var customResult;
+
+    if (custom && (customResult = custom(node)) !== undefined) {
+        return customResult;
+    } else if (type === 'word' || type === 'space') {
+        return value;
+    } else if (type === 'string') {
+        buf = node.quote || '';
+        return buf + value + (node.unclosed ? '' : buf);
+    } else if (type === 'comment') {
+        return '/*' + value + (node.unclosed ? '' : '*/');
+    } else if (type === 'div') {
+        return (node.before || '') + value + (node.after || '');
+    } else if (Array.isArray(node.nodes)) {
+        buf = stringify(node.nodes);
+        if (type !== 'function') {
+            return buf;
+        }
+        return value + '(' + (node.before || '') + buf + (node.after || '') + (node.unclosed ? '' : ')');
+    }
+    return value;
+}
+
+function stringify(nodes, custom) {
+    var result, i;
+
+    if (Array.isArray(nodes)) {
+        result = '';
+        for (i = nodes.length - 1; ~i; i -= 1) {
+            result = stringifyNode(nodes[i], custom) + result;
+        }
+        return result;
+    }
+    return stringifyNode(nodes, custom);
+}
+
+module.exports = stringify;

node_modules/postcss-value-parser/lib/unit.js

@@ -0,0 +1,41 @@
+var minus = '-'.charCodeAt(0);
+var plus  = '+'.charCodeAt(0);
+var dot   = '.'.charCodeAt(0);
+
+module.exports = function (value) {
+    var pos = 0;
+    var length = value.length;
+    var dotted = false;
+    var containsNumber = false;
+    var code;
+    var number = '';
+
+    while (pos < length) {
+        code = value.charCodeAt(pos);
+
+        if (code >= 48 && code <= 57) {
+            number += value[pos];
+            containsNumber = true;
+        } else if (code === dot) {
+            if (dotted) {
+                break;
+            }
+            dotted = true;
+            number += value[pos];
+        } else if (code === plus || code === minus) {
+            if (pos !== 0) {
+                break;
+            }
+            number += value[pos];
+        } else {
+            break;
+        }
+
+        pos += 1;
+    }
+
+    return containsNumber ? {
+        number: number,
+        unit: value.slice(pos)
+    } : false;
+};

node_modules/postcss-value-parser/lib/walk.js

@@ -0,0 +1,18 @@
+module.exports = function walk(nodes, cb, bubble) {
+    var i, max, node, result;
+
+    for (i = 0, max = nodes.length; i < max; i += 1) {
+        node = nodes[i];
+        if (!bubble) {
+            result = cb(node, i, nodes);
+        }
+
+        if (result !== false && node.type === 'function' && Array.isArray(node.nodes)) {
+            walk(node.nodes, cb, bubble);
+        }
+
+        if (bubble) {
+            cb(node, i, nodes);
+        }
+    }
+};

node_modules/postcss-value-parser/package.json

@@ -0,0 +1,105 @@
+{
+  "_args": [
+    [
+      "postcss-value-parser@^3.1.1",
+      "/Users/pmarsceill/_projects/just-the-docs/node_modules/stylelint"
+    ]
+  ],
+  "_from": "postcss-value-parser@>=3.1.1 <4.0.0",
+  "_id": "postcss-value-parser@3.3.0",
+  "_inCache": true,
+  "_installable": true,
+  "_location": "/postcss-value-parser",
+  "_nodeVersion": "0.12.7",
+  "_npmOperationalInternal": {
+    "host": "packages-6-west.internal.npmjs.com",
+    "tmp": "tmp/postcss-value-parser-3.3.0.tgz_1455817254522_0.1339812579099089"
+  },
+  "_npmUser": {
+    "email": "trysound@yandex.ru",
+    "name": "trysound"
+  },
+  "_npmVersion": "3.7.2",
+  "_phantomChildren": {},
+  "_requested": {
+    "name": "postcss-value-parser",
+    "raw": "postcss-value-parser@^3.1.1",
+    "rawSpec": "^3.1.1",
+    "scope": null,
+    "spec": ">=3.1.1 <4.0.0",
+    "type": "range"
+  },
+  "_requiredBy": [
+    "/autoprefixer",
+    "/stylelint"
+  ],
+  "_resolved": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-3.3.0.tgz",
+  "_shasum": "87f38f9f18f774a4ab4c8a232f5c5ce8872a9d15",
+  "_shrinkwrap": null,
+  "_spec": "postcss-value-parser@^3.1.1",
+  "_where": "/Users/pmarsceill/_projects/just-the-docs/node_modules/stylelint",
+  "author": {
+    "email": "trysound@yandex.ru",
+    "name": "Bogdan Chadkin"
+  },
+  "bugs": {
+    "url": "https://github.com/TrySound/postcss-value-parser/issues"
+  },
+  "dependencies": {},
+  "description": "Transforms css values and at-rule params into the tree",
+  "devDependencies": {
+    "eslint": "^2.1.0",
+    "eslint-config-postcss": "^2.0.0",
+    "tap-spec": "^4.1.0",
+    "tape": "^4.2.0"
+  },
+  "directories": {},
+  "dist": {
+    "shasum": "87f38f9f18f774a4ab4c8a232f5c5ce8872a9d15",
+    "tarball": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-3.3.0.tgz"
+  },
+  "eslintConfig": {
+    "extends": "postcss/es5",
+    "rules": {
+      "complexity": 0,
+      "consistent-return": 0,
+      "max-len": 0,
+      "no-bitwise": 0,
+      "no-use-before-define": 0
+    }
+  },
+  "files": [
+    "lib"
+  ],
+  "gitHead": "c2738fbc73bf1162481862ddce7d011cc0a57b15",
+  "homepage": "https://github.com/TrySound/postcss-value-parser",
+  "keywords": [
+    "parser",
+    "postcss",
+    "value"
+  ],
+  "license": "MIT",
+  "main": "lib/index.js",
+  "maintainers": [
+    {
+      "name": "trysound",
+      "email": "trysound@yandex.ru"
+    },
+    {
+      "name": "beneb",
+      "email": "beneb.info@gmail.com"
+    }
+  ],
+  "name": "postcss-value-parser",
+  "optionalDependencies": {},
+  "readme": "ERROR: No README data found!",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TrySound/postcss-value-parser.git"
+  },
+  "scripts": {
+    "posttest": "eslint .",
+    "test": "tape test/*.js | tap-spec"
+  },
+  "version": "3.3.0"
+}