0.2.0 - Mid migration

web/node_modules/postcss-convert-values/CHANGELOG.md

@@ -0,0 +1,152 @@
+# 4.0.0-rc.0
+
+* Breaking: Drops support for Node 0.12, we now require at least Node 4.
+* Breaking: Update PostCSS to 6.0.0.
+* Breaking: Removes the deprecated options from version 2.2.0.
+
+# 2.6.1
+
+* Resolves an issue where IE hacks were being removed from `0` values
+  (thanks to @Justineo).
+
+# 2.6.0
+
+* Added clamping of the values for the `shape-image-threshold` property, using
+  the same logic as introduced in version `2.5.0`.
+
+# 2.5.0
+
+* Added clamping of the values for the `opacity` property to the `0-1` range.
+  For example, this will convert `opacity: 1.1` to `opacity: 1`.
+
+# 2.4.1
+
+* Resolves an issue where the units would be stripped from zero values in
+  custom properties (thanks to @jgerigmeyer).
+
+# 2.4.0
+
+* Added a `precision` option to enable rounding of decimal places for
+  `px` values.
+
+# 2.3.6
+
+* Resolves an issue with the last patch where `height: 0em` was not being
+  converted to `height: 0`.
+
+# 2.3.5
+
+* Resolves an issue where certain properties inside `@keyframes` rules would
+  break animation in IE due to the percentage being stripped. Now, the
+  percentage is preserved for these properties.
+
+# 2.3.4
+
+* Does not convert `height:0%` to `height:0` (and the same for `max-height`), as
+  they produce different results.
+
+# 2.3.3
+
+* Updates postcss-value-parser to version 3 (thanks to @TrySound).
+
+# 2.3.2
+
+* Fixed a regression where `0%` in color functions was being transformed to `0`
+  (thanks to @TrySound).
+
+# 2.3.1
+
+* Fixed a behaviour where `0deg` was being converted to `0`.
+
+# 2.3.0
+
+* Added an option to convert between `turn` & `deg` (thanks to @TrySound).
+
+# 2.2.1
+
+* Fixes a behaviour where the module would remove units from zero values inside
+  calc functions (thanks to @marek-saji & @TrySound).
+
+# 2.2.0
+
+* Renames `opts.convertLength` & `opts.convertTime` to
+  `opts.length` & `opts.time`; the old options will now print deprecation
+  warnings (thanks to @TrySound).
+
+# 2.1.0
+
+* Adds options to enable/disable unit conversion for time & length values.
+
+# 2.0.1
+
+* Bump postcss-value-parser to `2.0.2`.
+
+# 2.0.0
+
+* Upgraded to PostCSS 5.
+
+# 1.3.1
+
+* Fixes an issue where the module would convert values in gradient/url functions
+  since 1.3.0.
+
+# 1.3.0
+
+* Converted the module to use ES6.
+* balanced-match, css-list & some integrated code has been replaced with
+  postcss-value-parser; reducing the number of moving parts in this module, and
+  providing a more futureproof way of parsing CSS numeric values.
+
+# 1.2.5
+
+* Fixes an issue where uppercase units (such as PX) were being deleted.
+
+# 1.2.4
+
+* Fixes convert not px or ms
+
+# 1.2.3
+
+* Adds support for `ch` units; previously they were removed.
+* Upgrades css-list to `0.1.0`, code tidied up.
+
+# 1.2.2
+
+* Added support for viewport units (thanks to @TrySound).
+
+# 1.2.1
+
+* Fixes regressions introduced by the previous patch. Better support for
+  negative value transforms.
+
+# 1.2.0
+
+* Adds support for slash/comma separated values (thanks to @TrySound).
+
+# 1.1.1
+
+* Fixes an issue where trailing zeroes were not being removed in
+  values that were not `0` (thanks to @TrySound).
+
+# 1.1.0
+
+* Adds support for removing leading zeroes from `rem` values
+  (thanks to @tunnckoCore).
+
+# 1.0.3
+
+* Fixed a bug where filenames were being incorrectly transformed.
+
+# 1.0.2
+
+* Fixed a bug where `1.` and `.0` were not being optimised to `1` and `0`,
+  respectively.
+
+# 1.0.1
+
+* Fixed a bug where `undefined` would be stringified as the unit value, if the
+  value did not have a unit.
+
+# 1.0.0
+
+* Initial release.

web/node_modules/postcss-convert-values/LICENSE-MIT

@@ -0,0 +1,22 @@
+Copyright (c) Ben Briggs <beneb.info@gmail.com> (http://beneb.info)
+
+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.

web/node_modules/postcss-convert-values/README.md

@@ -0,0 +1,98 @@
+# [postcss][postcss]-convert-values
+
+> Convert values with PostCSS (e.g. ms -> s)
+
+## Install
+
+With [npm](https://npmjs.org/package/postcss-convert-values) do:
+
+```
+npm install postcss-convert-values --save
+```
+
+## Example
+
+This plugin reduces CSS size by converting values to use different units
+where possible; for example, `500ms` can be represented as `.5s`. You can
+read more about these units in [this article][csstricks].
+
+### Input
+
+```css
+h1 {
+    font-size: 16px;
+    width: 0em
+}
+```
+
+### Output
+
+```css
+h1 {
+    font-size: 1pc;
+    width: 0
+}
+```
+
+Note that this plugin only covers conversions for duration and absolute length
+values. For color conversions, use [postcss-colormin][colormin].
+
+## API
+
+### convertValues([options])
+
+#### options
+
+##### length
+
+Type: `boolean`
+Default: `true`
+
+Pass `false` to disable conversion from `px` to other absolute length units,
+such as `pc` & `pt` & vice versa.
+
+##### time
+
+Type: `boolean`
+Default: `true`
+
+Pass `false` to disable conversion from `ms` to `s` & vice versa.
+
+##### angle
+
+Type: `boolean`
+Default: `true`
+
+Pass `false` to disable conversion from `deg` to `turn` & vice versa.
+
+##### precision
+
+Type: `boolean|number`
+Default: `false`
+
+Specify any numeric value here to round `px` values to that many decimal places;
+for example, using `{precision: 2}` will round `6.66667px` to `6.67px`, and
+`{precision: 0}` will round it to `7px`. Passing `false` (the default) will
+leave these values as is.
+
+It is recommended for most use cases to set this option to `2`.
+
+
+## Usage
+
+See the [PostCSS documentation](https://github.com/postcss/postcss#usage) for
+examples for your environment.
+
+
+## Contributors
+
+See [CONTRIBUTORS.md](https://github.com/cssnano/cssnano/blob/master/CONTRIBUTORS.md).
+
+
+## License
+
+MIT © [Ben Briggs](http://beneb.info)
+
+
+[postcss]: https://github.com/postcss/postcss
+[csstricks]: https://css-tricks.com/the-lengths-of-css/

web/node_modules/postcss-convert-values/dist/index.js

@@ -0,0 +1,95 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+var _postcss = require('postcss');
+
+var _postcss2 = _interopRequireDefault(_postcss);
+
+var _postcssValueParser = require('postcss-value-parser');
+
+var _postcssValueParser2 = _interopRequireDefault(_postcssValueParser);
+
+var _convert = require('./lib/convert');
+
+var _convert2 = _interopRequireDefault(_convert);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const LENGTH_UNITS = ['em', 'ex', 'ch', 'rem', 'vw', 'vh', 'vmin', 'vmax', 'cm', 'mm', 'q', 'in', 'pt', 'pc', 'px'];
+
+function parseWord(node, opts, keepZeroUnit) {
+    const pair = (0, _postcssValueParser.unit)(node.value);
+    if (pair) {
+        const num = Number(pair.number);
+        const u = pair.unit;
+        if (num === 0) {
+            node.value = keepZeroUnit || !~LENGTH_UNITS.indexOf(u.toLowerCase()) && u !== '%' ? 0 + u : 0;
+        } else {
+            node.value = (0, _convert2.default)(num, u, opts);
+
+            if (typeof opts.precision === 'number' && u.toLowerCase() === 'px' && ~pair.number.indexOf('.')) {
+                const precision = Math.pow(10, opts.precision);
+                node.value = Math.round(parseFloat(node.value) * precision) / precision + u;
+            }
+        }
+    }
+}
+
+function clampOpacity(node) {
+    const pair = (0, _postcssValueParser.unit)(node.value);
+    if (!pair) {
+        return;
+    }
+    let num = Number(pair.number);
+    if (num > 1) {
+        node.value = 1 + pair.unit;
+    } else if (num < 0) {
+        node.value = 0 + pair.unit;
+    }
+}
+
+function shouldStripPercent(decl) {
+    const { parent } = decl;
+    const lowerCasedProp = decl.prop.toLowerCase();
+    return ~decl.value.indexOf('%') && (lowerCasedProp === 'max-height' || lowerCasedProp === 'height') || parent.parent && parent.parent.name && parent.parent.name.toLowerCase() === 'keyframes' && lowerCasedProp === 'stroke-dasharray' || lowerCasedProp === 'stroke-dashoffset' || lowerCasedProp === 'stroke-width';
+}
+
+function transform(opts, decl) {
+    const lowerCasedProp = decl.prop.toLowerCase();
+    if (~lowerCasedProp.indexOf('flex') || lowerCasedProp.indexOf('--') === 0) {
+        return;
+    }
+
+    decl.value = (0, _postcssValueParser2.default)(decl.value).walk(node => {
+        const lowerCasedValue = node.value.toLowerCase();
+
+        if (node.type === 'word') {
+            parseWord(node, opts, shouldStripPercent(decl));
+            if (lowerCasedProp === 'opacity' || lowerCasedProp === 'shape-image-threshold') {
+                clampOpacity(node);
+            }
+        } else if (node.type === 'function') {
+            if (lowerCasedValue === 'calc' || lowerCasedValue === 'hsl' || lowerCasedValue === 'hsla') {
+                (0, _postcssValueParser.walk)(node.nodes, n => {
+                    if (n.type === 'word') {
+                        parseWord(n, opts, true);
+                    }
+                });
+                return false;
+            }
+            if (lowerCasedValue === 'url') {
+                return false;
+            }
+        }
+    }).toString();
+}
+
+const plugin = 'postcss-convert-values';
+
+exports.default = _postcss2.default.plugin(plugin, (opts = { precision: false }) => {
+    return css => css.walkDecls(transform.bind(null, opts));
+});
+module.exports = exports['default'];

web/node_modules/postcss-convert-values/dist/lib/convert.js

@@ -0,0 +1,82 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+exports.default = function (number, unit, { time, length, angle }) {
+    let value = dropLeadingZero(number) + (unit ? unit : '');
+    let converted;
+
+    if (length !== false && unit.toLowerCase() in lengthConv) {
+        converted = transform(number, unit, lengthConv);
+    }
+
+    if (time !== false && unit.toLowerCase() in timeConv) {
+        converted = transform(number, unit, timeConv);
+    }
+
+    if (angle !== false && unit.toLowerCase() in angleConv) {
+        converted = transform(number, unit, angleConv);
+    }
+
+    if (converted && converted.length < value.length) {
+        value = converted;
+    }
+
+    return value;
+};
+
+const lengthConv = {
+    in: 96,
+    px: 1,
+    pt: 4 / 3,
+    pc: 16
+};
+
+const timeConv = {
+    s: 1000,
+    ms: 1
+};
+
+const angleConv = {
+    turn: 360,
+    deg: 1
+};
+
+function dropLeadingZero(number) {
+    const value = String(number);
+
+    if (number % 1) {
+        if (value[0] === '0') {
+            return value.slice(1);
+        }
+
+        if (value[0] === '-' && value[1] === '0') {
+            return '-' + value.slice(2);
+        }
+    }
+
+    return value;
+}
+
+function transform(number, unit, conversion) {
+    const lowerCasedUnit = unit.toLowerCase();
+    let one, base;
+    let convertionUnits = Object.keys(conversion).filter(u => {
+        if (conversion[u] === 1) {
+            one = u;
+        }
+        return lowerCasedUnit !== u;
+    });
+
+    if (lowerCasedUnit === one) {
+        base = number / conversion[lowerCasedUnit];
+    } else {
+        base = number * conversion[lowerCasedUnit];
+    }
+
+    return convertionUnits.map(u => dropLeadingZero(base / conversion[u]) + u).reduce((a, b) => a.length < b.length ? a : b);
+}
+
+module.exports = exports['default'];

web/node_modules/postcss-convert-values/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.

web/node_modules/postcss-convert-values/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)

web/node_modules/postcss-convert-values/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;

web/node_modules/postcss-convert-values/node_modules/postcss-value-parser/lib/parse.js

@@ -0,0 +1,251 @@
+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;
+};

web/node_modules/postcss-convert-values/node_modules/postcss-value-parser/lib/stringify.js

@@ -0,0 +1,48 @@
+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;

web/node_modules/postcss-convert-values/node_modules/postcss-value-parser/lib/unit.js

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

web/node_modules/postcss-convert-values/node_modules/postcss-value-parser/lib/walk.js

@@ -0,0 +1,22 @@
+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);
+    }
+  }
+};

web/node_modules/postcss-convert-values/node_modules/postcss-value-parser/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "postcss-value-parser",
+  "version": "3.3.1",
+  "description": "Transforms css values and at-rule params into the tree",
+  "main": "lib/index.js",
+  "files": [
+    "lib"
+  ],
+  "devDependencies": {
+    "eslint": "^5.6.1",
+    "husky": "^1.0.0",
+    "lint-staged": "^7.3.0",
+    "prettier": "^1.4.4",
+    "tap-spec": "^5.0.0",
+    "tape": "^4.2.0"
+  },
+  "scripts": {
+    "lint:prettier": "prettier '**/*.js' --list-different",
+    "lint:js": "eslint . --cache",
+    "lint": "yarn lint:js && yarn lint:prettier",
+    "pretest": "yarn lint",
+    "test": "tape test/*.js | tap-spec"
+  },
+  "eslintConfig": {
+    "env": {
+      "es6": true,
+      "node": true
+    },
+    "extends": "eslint:recommended"
+  },
+  "lint-staged": {
+    "*.js": [
+      "eslint",
+      "prettier --write",
+      "git add"
+    ]
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged"
+    }
+  },
+  "author": "Bogdan Chadkin <trysound@yandex.ru>",
+  "license": "MIT",
+  "homepage": "https://github.com/TrySound/postcss-value-parser",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TrySound/postcss-value-parser.git"
+  },
+  "keywords": [
+    "postcss",
+    "value",
+    "parser"
+  ],
+  "bugs": {
+    "url": "https://github.com/TrySound/postcss-value-parser/issues"
+  }
+}

web/node_modules/postcss-convert-values/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "postcss-convert-values",
+  "version": "4.0.1",
+  "description": "Convert values with PostCSS (e.g. ms -> s)",
+  "main": "dist/index.js",
+  "files": [
+    "LICENSE-MIT",
+    "dist"
+  ],
+  "scripts": {
+    "prepublish": "cross-env BABEL_ENV=publish babel src --out-dir dist --ignore /__tests__/"
+  },
+  "keywords": [
+    "css",
+    "optimisation",
+    "postcss",
+    "postcss-plugin"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "babel-cli": "^6.0.0",
+    "cross-env": "^5.0.0"
+  },
+  "homepage": "https://github.com/cssnano/cssnano",
+  "author": {
+    "name": "Ben Briggs",
+    "email": "beneb.info@gmail.com",
+    "url": "http://beneb.info"
+  },
+  "repository": "cssnano/cssnano",
+  "dependencies": {
+    "postcss": "^7.0.0",
+    "postcss-value-parser": "^3.0.0"
+  },
+  "bugs": {
+    "url": "https://github.com/cssnano/cssnano/issues"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  }
+}