ignore node_modules

.gitignore

@@ -1 +1,2 @@
 *.min.*
+node_modules/

node_modules/.bin/css-b64-images

@@ -1 +0,0 @@
-../css-b64-images/bin/css-b64-images

node_modules/.bin/he

@@ -1 +0,0 @@
-../he/bin/he

node_modules/.bin/html-minifier-terser

@@ -1 +0,0 @@
-../html-minifier-terser/cli.js

node_modules/.bin/minify

@@ -1 +0,0 @@
-../minify/bin/minify.js

node_modules/.bin/terser

@@ -1 +0,0 @@
-../terser/bin/terser

node_modules/buffer-from/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2016, 2018 Linus Unnebäck
-
-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/buffer-from/index.js

@@ -1,69 +0,0 @@
-var toString = Object.prototype.toString
-
-var isModern = (
-  typeof Buffer.alloc === 'function' &&
-  typeof Buffer.allocUnsafe === 'function' &&
-  typeof Buffer.from === 'function'
-)
-
-function isArrayBuffer (input) {
-  return toString.call(input).slice(8, -1) === 'ArrayBuffer'
-}
-
-function fromArrayBuffer (obj, byteOffset, length) {
-  byteOffset >>>= 0
-
-  var maxLength = obj.byteLength - byteOffset
-
-  if (maxLength < 0) {
-    throw new RangeError("'offset' is out of bounds")
-  }
-
-  if (length === undefined) {
-    length = maxLength
-  } else {
-    length >>>= 0
-
-    if (length > maxLength) {
-      throw new RangeError("'length' is out of bounds")
-    }
-  }
-
-  return isModern
-    ? Buffer.from(obj.slice(byteOffset, byteOffset + length))
-    : new Buffer(new Uint8Array(obj.slice(byteOffset, byteOffset + length)))
-}
-
-function fromString (string, encoding) {
-  if (typeof encoding !== 'string' || encoding === '') {
-    encoding = 'utf8'
-  }
-
-  if (!Buffer.isEncoding(encoding)) {
-    throw new TypeError('"encoding" must be a valid string encoding')
-  }
-
-  return isModern
-    ? Buffer.from(string, encoding)
-    : new Buffer(string, encoding)
-}
-
-function bufferFrom (value, encodingOrOffset, length) {
-  if (typeof value === 'number') {
-    throw new TypeError('"value" argument must not be a number')
-  }
-
-  if (isArrayBuffer(value)) {
-    return fromArrayBuffer(value, encodingOrOffset, length)
-  }
-
-  if (typeof value === 'string') {
-    return fromString(value, encodingOrOffset)
-  }
-
-  return isModern
-    ? Buffer.from(value)
-    : new Buffer(value)
-}
-
-module.exports = bufferFrom

node_modules/buffer-from/package.json

@@ -1,52 +0,0 @@
-{
-  "_from": "buffer-from@^1.0.0",
-  "_id": "buffer-from@1.1.1",
-  "_inBundle": false,
-  "_integrity": "sha512-MQcXEUbCKtEo7bhqEs6560Hyd4XaovZlO/k9V3hjVUF/zwW7KBVdSK4gIt/bzwS9MbR5qob+F5jusZsb0YQK2A==",
-  "_location": "/buffer-from",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "range",
-    "registry": true,
-    "raw": "buffer-from@^1.0.0",
-    "name": "buffer-from",
-    "escapedName": "buffer-from",
-    "rawSpec": "^1.0.0",
-    "saveSpec": null,
-    "fetchSpec": "^1.0.0"
-  },
-  "_requiredBy": [
-    "/source-map-support"
-  ],
-  "_resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.1.tgz",
-  "_shasum": "32713bc028f75c02fdb710d7c7bcec1f2c6070ef",
-  "_spec": "buffer-from@^1.0.0",
-  "_where": "/home/specter/repos/gmi-web/node_modules/source-map-support",
-  "bugs": {
-    "url": "https://github.com/LinusU/buffer-from/issues"
-  },
-  "bundleDependencies": false,
-  "deprecated": false,
-  "description": "A [ponyfill](https://ponyfill.com) for `Buffer.from`, uses native implementation if available.",
-  "devDependencies": {
-    "standard": "^7.1.2"
-  },
-  "files": [
-    "index.js"
-  ],
-  "homepage": "https://github.com/LinusU/buffer-from#readme",
-  "keywords": [
-    "buffer",
-    "buffer from"
-  ],
-  "license": "MIT",
-  "name": "buffer-from",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/LinusU/buffer-from.git"
-  },
-  "scripts": {
-    "test": "standard && node test"
-  },
-  "version": "1.1.1"
-}

node_modules/buffer-from/readme.md

@@ -1,69 +0,0 @@
-# Buffer From
-
-A [ponyfill](https://ponyfill.com) for `Buffer.from`, uses native implementation if available.
-
-## Installation
-
-```sh
-npm install --save buffer-from
-```
-
-## Usage
-
-```js
-const bufferFrom = require('buffer-from')
-
-console.log(bufferFrom([1, 2, 3, 4]))
-//=> <Buffer 01 02 03 04>
-
-const arr = new Uint8Array([1, 2, 3, 4])
-console.log(bufferFrom(arr.buffer, 1, 2))
-//=> <Buffer 02 03>
-
-console.log(bufferFrom('test', 'utf8'))
-//=> <Buffer 74 65 73 74>
-
-const buf = bufferFrom('test')
-console.log(bufferFrom(buf))
-//=> <Buffer 74 65 73 74>
-```
-
-## API
-
-### bufferFrom(array)
-
-- `array` &lt;Array&gt;
-
-Allocates a new `Buffer` using an `array` of octets.
-
-### bufferFrom(arrayBuffer[, byteOffset[, length]])
-
-- `arrayBuffer` &lt;ArrayBuffer&gt; The `.buffer` property of a TypedArray or ArrayBuffer
-- `byteOffset` &lt;Integer&gt; Where to start copying from `arrayBuffer`. **Default:** `0`
-- `length` &lt;Integer&gt; How many bytes to copy from `arrayBuffer`. **Default:** `arrayBuffer.length - byteOffset`
-
-When passed a reference to the `.buffer` property of a TypedArray instance, the
-newly created `Buffer` will share the same allocated memory as the TypedArray.
-
-The optional `byteOffset` and `length` arguments specify a memory range within
-the `arrayBuffer` that will be shared by the `Buffer`.
-
-### bufferFrom(buffer)
-
-- `buffer` &lt;Buffer&gt; An existing `Buffer` to copy data from
-
-Copies the passed `buffer` data onto a new `Buffer` instance.
-
-### bufferFrom(string[, encoding])
-
-- `string` &lt;String&gt; A string to encode.
-- `encoding` &lt;String&gt; The encoding of `string`. **Default:** `'utf8'`
-
-Creates a new `Buffer` containing the given JavaScript string `string`. If
-provided, the `encoding` parameter identifies the character encoding of
-`string`.
-
-## See also
-
-- [buffer-alloc](https://github.com/LinusU/buffer-alloc) A ponyfill for `Buffer.alloc`
-- [buffer-alloc-unsafe](https://github.com/LinusU/buffer-alloc-unsafe) A ponyfill for `Buffer.allocUnsafe`

node_modules/camel-case/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2014 Blake Embrey (hello@blakeembrey.com)
-
-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/camel-case/README.md

@@ -1,47 +0,0 @@
-# Camel Case
-
-[![NPM version][npm-image]][npm-url]
-[![NPM downloads][downloads-image]][downloads-url]
-[![Bundle size][bundlephobia-image]][bundlephobia-url]
-
-> Transform into a string with the separator denoted by the next word capitalized.
-
-## Installation
-
-```
-npm install camel-case --save
-```
-
-## Usage
-
-```js
-import { camelCase } from "camel-case";
-
-camelCase("string"); //=> "string"
-camelCase("dot.case"); //=> "dotCase"
-camelCase("PascalCase"); //=> "pascalCase"
-camelCase("version 1.2.10"); //=> "version_1_2_10"
-```
-
-The function also accepts [`options`](https://github.com/blakeembrey/change-case#options).
-
-### Merge Numbers
-
-If you'd like to remove the behavior prefixing `_` before numbers, you can use `camelCaseTransformMerge`:
-
-```js
-import { camelCaseTransformMerge } from "camel-case";
-
-camelCase("version 12", { transform: camelCaseTransformMerge }); //=> "version12"
-```
-
-## License
-
-MIT
-
-[npm-image]: https://img.shields.io/npm/v/camel-case.svg?style=flat
-[npm-url]: https://npmjs.org/package/camel-case
-[downloads-image]: https://img.shields.io/npm/dm/camel-case.svg?style=flat
-[downloads-url]: https://npmjs.org/package/camel-case
-[bundlephobia-image]: https://img.shields.io/bundlephobia/minzip/camel-case.svg
-[bundlephobia-url]: https://bundlephobia.com/result?p=camel-case

node_modules/camel-case/dist.es2015/index.d.ts

@@ -1,5 +0,0 @@
-import { Options } from "pascal-case";
-export { Options };
-export declare function camelCaseTransform(input: string, index: number): string;
-export declare function camelCaseTransformMerge(input: string, index: number): string;
-export declare function camelCase(input: string, options?: Options): string;

node_modules/camel-case/dist.es2015/index.js

@@ -1,17 +0,0 @@
-import { __assign } from "tslib";
-import { pascalCase, pascalCaseTransform, pascalCaseTransformMerge, } from "pascal-case";
-export function camelCaseTransform(input, index) {
-    if (index === 0)
-        return input.toLowerCase();
-    return pascalCaseTransform(input, index);
-}
-export function camelCaseTransformMerge(input, index) {
-    if (index === 0)
-        return input.toLowerCase();
-    return pascalCaseTransformMerge(input);
-}
-export function camelCase(input, options) {
-    if (options === void 0) { options = {}; }
-    return pascalCase(input, __assign({ transform: camelCaseTransform }, options));
-}
-//# sourceMappingURL=index.js.map

node_modules/camel-case/dist.es2015/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA,OAAO,EACL,UAAU,EACV,mBAAmB,EACnB,wBAAwB,GAEzB,MAAM,aAAa,CAAC;AAIrB,MAAM,UAAU,kBAAkB,CAAC,KAAa,EAAE,KAAa;IAC7D,IAAI,KAAK,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC,WAAW,EAAE,CAAC;IAC5C,OAAO,mBAAmB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;AAC3C,CAAC;AAED,MAAM,UAAU,uBAAuB,CAAC,KAAa,EAAE,KAAa;IAClE,IAAI,KAAK,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC,WAAW,EAAE,CAAC;IAC5C,OAAO,wBAAwB,CAAC,KAAK,CAAC,CAAC;AACzC,CAAC;AAED,MAAM,UAAU,SAAS,CAAC,KAAa,EAAE,OAAqB;IAArB,wBAAA,EAAA,YAAqB;IAC5D,OAAO,UAAU,CAAC,KAAK,aACrB,SAAS,EAAE,kBAAkB,IAC1B,OAAO,EACV,CAAC;AACL,CAAC","sourcesContent":["import {\n  pascalCase,\n  pascalCaseTransform,\n  pascalCaseTransformMerge,\n  Options,\n} from \"pascal-case\";\n\nexport { Options };\n\nexport function camelCaseTransform(input: string, index: number) {\n  if (index === 0) return input.toLowerCase();\n  return pascalCaseTransform(input, index);\n}\n\nexport function camelCaseTransformMerge(input: string, index: number) {\n  if (index === 0) return input.toLowerCase();\n  return pascalCaseTransformMerge(input);\n}\n\nexport function camelCase(input: string, options: Options = {}) {\n  return pascalCase(input, {\n    transform: camelCaseTransform,\n    ...options,\n  });\n}\n"]}

node_modules/camel-case/dist.es2015/index.spec.d.ts

@@ -1 +0,0 @@
-export {};

node_modules/camel-case/dist.es2015/index.spec.js

@@ -1,24 +0,0 @@
-import { camelCase, camelCaseTransformMerge } from ".";
-var TEST_CASES = [
-    ["", ""],
-    ["test", "test"],
-    ["test string", "testString"],
-    ["Test String", "testString"],
-    ["TestV2", "testV2"],
-    ["_foo_bar_", "fooBar"],
-    ["version 1.2.10", "version_1_2_10"],
-    ["version 1.21.0", "version_1_21_0"],
-    ["version 1.2.10", "version1210", { transform: camelCaseTransformMerge }],
-];
-describe("camel case", function () {
-    var _loop_1 = function (input, result, options) {
-        it(input + " -> " + result, function () {
-            expect(camelCase(input, options)).toEqual(result);
-        });
-    };
-    for (var _i = 0, TEST_CASES_1 = TEST_CASES; _i < TEST_CASES_1.length; _i++) {
-        var _a = TEST_CASES_1[_i], input = _a[0], result = _a[1], options = _a[2];
-        _loop_1(input, result, options);
-    }
-});
-//# sourceMappingURL=index.spec.js.map

node_modules/camel-case/dist.es2015/index.spec.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.spec.js","sourceRoot":"","sources":["../src/index.spec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,uBAAuB,EAAW,MAAM,GAAG,CAAC;AAEhE,IAAM,UAAU,GAAiC;IAC/C,CAAC,EAAE,EAAE,EAAE,CAAC;IACR,CAAC,MAAM,EAAE,MAAM,CAAC;IAChB,CAAC,aAAa,EAAE,YAAY,CAAC;IAC7B,CAAC,aAAa,EAAE,YAAY,CAAC;IAC7B,CAAC,QAAQ,EAAE,QAAQ,CAAC;IACpB,CAAC,WAAW,EAAE,QAAQ,CAAC;IACvB,CAAC,gBAAgB,EAAE,gBAAgB,CAAC;IACpC,CAAC,gBAAgB,EAAE,gBAAgB,CAAC;IACpC,CAAC,gBAAgB,EAAE,aAAa,EAAE,EAAE,SAAS,EAAE,uBAAuB,EAAE,CAAC;CAC1E,CAAC;AAEF,QAAQ,CAAC,YAAY,EAAE;4BACT,KAAK,EAAE,MAAM,EAAE,OAAO;QAChC,EAAE,CAAI,KAAK,YAAO,MAAQ,EAAE;YAC1B,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QACpD,CAAC,CAAC,CAAC;;IAHL,KAAuC,UAAU,EAAV,yBAAU,EAAV,wBAAU,EAAV,IAAU;QAAtC,IAAA,qBAAwB,EAAvB,KAAK,QAAA,EAAE,MAAM,QAAA,EAAE,OAAO,QAAA;gBAAtB,KAAK,EAAE,MAAM,EAAE,OAAO;KAIjC;AACH,CAAC,CAAC,CAAC","sourcesContent":["import { camelCase, camelCaseTransformMerge, Options } from \".\";\n\nconst TEST_CASES: [string, string, Options?][] = [\n  [\"\", \"\"],\n  [\"test\", \"test\"],\n  [\"test string\", \"testString\"],\n  [\"Test String\", \"testString\"],\n  [\"TestV2\", \"testV2\"],\n  [\"_foo_bar_\", \"fooBar\"],\n  [\"version 1.2.10\", \"version_1_2_10\"],\n  [\"version 1.21.0\", \"version_1_21_0\"],\n  [\"version 1.2.10\", \"version1210\", { transform: camelCaseTransformMerge }],\n];\n\ndescribe(\"camel case\", () => {\n  for (const [input, result, options] of TEST_CASES) {\n    it(`${input} -> ${result}`, () => {\n      expect(camelCase(input, options)).toEqual(result);\n    });\n  }\n});\n"]}

node_modules/camel-case/dist/index.d.ts

@@ -1,5 +0,0 @@
-import { Options } from "pascal-case";
-export { Options };
-export declare function camelCaseTransform(input: string, index: number): string;
-export declare function camelCaseTransformMerge(input: string, index: number): string;
-export declare function camelCase(input: string, options?: Options): string;

node_modules/camel-case/dist/index.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.camelCase = exports.camelCaseTransformMerge = exports.camelCaseTransform = void 0;
-var tslib_1 = require("tslib");
-var pascal_case_1 = require("pascal-case");
-function camelCaseTransform(input, index) {
-    if (index === 0)
-        return input.toLowerCase();
-    return pascal_case_1.pascalCaseTransform(input, index);
-}
-exports.camelCaseTransform = camelCaseTransform;
-function camelCaseTransformMerge(input, index) {
-    if (index === 0)
-        return input.toLowerCase();
-    return pascal_case_1.pascalCaseTransformMerge(input);
-}
-exports.camelCaseTransformMerge = camelCaseTransformMerge;
-function camelCase(input, options) {
-    if (options === void 0) { options = {}; }
-    return pascal_case_1.pascalCase(input, tslib_1.__assign({ transform: camelCaseTransform }, options));
-}
-exports.camelCase = camelCase;
-//# sourceMappingURL=index.js.map

node_modules/camel-case/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;AAAA,2CAKqB;AAIrB,SAAgB,kBAAkB,CAAC,KAAa,EAAE,KAAa;IAC7D,IAAI,KAAK,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC,WAAW,EAAE,CAAC;IAC5C,OAAO,iCAAmB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;AAC3C,CAAC;AAHD,gDAGC;AAED,SAAgB,uBAAuB,CAAC,KAAa,EAAE,KAAa;IAClE,IAAI,KAAK,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC,WAAW,EAAE,CAAC;IAC5C,OAAO,sCAAwB,CAAC,KAAK,CAAC,CAAC;AACzC,CAAC;AAHD,0DAGC;AAED,SAAgB,SAAS,CAAC,KAAa,EAAE,OAAqB;IAArB,wBAAA,EAAA,YAAqB;IAC5D,OAAO,wBAAU,CAAC,KAAK,qBACrB,SAAS,EAAE,kBAAkB,IAC1B,OAAO,EACV,CAAC;AACL,CAAC;AALD,8BAKC","sourcesContent":["import {\n  pascalCase,\n  pascalCaseTransform,\n  pascalCaseTransformMerge,\n  Options,\n} from \"pascal-case\";\n\nexport { Options };\n\nexport function camelCaseTransform(input: string, index: number) {\n  if (index === 0) return input.toLowerCase();\n  return pascalCaseTransform(input, index);\n}\n\nexport function camelCaseTransformMerge(input: string, index: number) {\n  if (index === 0) return input.toLowerCase();\n  return pascalCaseTransformMerge(input);\n}\n\nexport function camelCase(input: string, options: Options = {}) {\n  return pascalCase(input, {\n    transform: camelCaseTransform,\n    ...options,\n  });\n}\n"]}

node_modules/camel-case/dist/index.spec.d.ts

@@ -1 +0,0 @@
-export {};

node_modules/camel-case/dist/index.spec.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var _1 = require(".");
-var TEST_CASES = [
-    ["", ""],
-    ["test", "test"],
-    ["test string", "testString"],
-    ["Test String", "testString"],
-    ["TestV2", "testV2"],
-    ["_foo_bar_", "fooBar"],
-    ["version 1.2.10", "version_1_2_10"],
-    ["version 1.21.0", "version_1_21_0"],
-    ["version 1.2.10", "version1210", { transform: _1.camelCaseTransformMerge }],
-];
-describe("camel case", function () {
-    var _loop_1 = function (input, result, options) {
-        it(input + " -> " + result, function () {
-            expect(_1.camelCase(input, options)).toEqual(result);
-        });
-    };
-    for (var _i = 0, TEST_CASES_1 = TEST_CASES; _i < TEST_CASES_1.length; _i++) {
-        var _a = TEST_CASES_1[_i], input = _a[0], result = _a[1], options = _a[2];
-        _loop_1(input, result, options);
-    }
-});
-//# sourceMappingURL=index.spec.js.map

node_modules/camel-case/dist/index.spec.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.spec.js","sourceRoot":"","sources":["../src/index.spec.ts"],"names":[],"mappings":";;AAAA,sBAAgE;AAEhE,IAAM,UAAU,GAAiC;IAC/C,CAAC,EAAE,EAAE,EAAE,CAAC;IACR,CAAC,MAAM,EAAE,MAAM,CAAC;IAChB,CAAC,aAAa,EAAE,YAAY,CAAC;IAC7B,CAAC,aAAa,EAAE,YAAY,CAAC;IAC7B,CAAC,QAAQ,EAAE,QAAQ,CAAC;IACpB,CAAC,WAAW,EAAE,QAAQ,CAAC;IACvB,CAAC,gBAAgB,EAAE,gBAAgB,CAAC;IACpC,CAAC,gBAAgB,EAAE,gBAAgB,CAAC;IACpC,CAAC,gBAAgB,EAAE,aAAa,EAAE,EAAE,SAAS,EAAE,0BAAuB,EAAE,CAAC;CAC1E,CAAC;AAEF,QAAQ,CAAC,YAAY,EAAE;4BACT,KAAK,EAAE,MAAM,EAAE,OAAO;QAChC,EAAE,CAAI,KAAK,YAAO,MAAQ,EAAE;YAC1B,MAAM,CAAC,YAAS,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QACpD,CAAC,CAAC,CAAC;;IAHL,KAAuC,UAAU,EAAV,yBAAU,EAAV,wBAAU,EAAV,IAAU;QAAtC,IAAA,qBAAwB,EAAvB,KAAK,QAAA,EAAE,MAAM,QAAA,EAAE,OAAO,QAAA;gBAAtB,KAAK,EAAE,MAAM,EAAE,OAAO;KAIjC;AACH,CAAC,CAAC,CAAC","sourcesContent":["import { camelCase, camelCaseTransformMerge, Options } from \".\";\n\nconst TEST_CASES: [string, string, Options?][] = [\n  [\"\", \"\"],\n  [\"test\", \"test\"],\n  [\"test string\", \"testString\"],\n  [\"Test String\", \"testString\"],\n  [\"TestV2\", \"testV2\"],\n  [\"_foo_bar_\", \"fooBar\"],\n  [\"version 1.2.10\", \"version_1_2_10\"],\n  [\"version 1.21.0\", \"version_1_21_0\"],\n  [\"version 1.2.10\", \"version1210\", { transform: camelCaseTransformMerge }],\n];\n\ndescribe(\"camel case\", () => {\n  for (const [input, result, options] of TEST_CASES) {\n    it(`${input} -> ${result}`, () => {\n      expect(camelCase(input, options)).toEqual(result);\n    });\n  }\n});\n"]}

node_modules/camel-case/package.json

@@ -1,114 +0,0 @@
-{
-  "_from": "camel-case@^4.1.1",
-  "_id": "camel-case@4.1.2",
-  "_inBundle": false,
-  "_integrity": "sha512-gxGWBrTT1JuMx6R+o5PTXMmUnhnVzLQ9SNutD4YqKtI6ap897t3tKECYla6gCWEkplXnlNybEkZg9GEGxKFCgw==",
-  "_location": "/camel-case",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "range",
-    "registry": true,
-    "raw": "camel-case@^4.1.1",
-    "name": "camel-case",
-    "escapedName": "camel-case",
-    "rawSpec": "^4.1.1",
-    "saveSpec": null,
-    "fetchSpec": "^4.1.1"
-  },
-  "_requiredBy": [
-    "/html-minifier-terser"
-  ],
-  "_resolved": "https://registry.npmjs.org/camel-case/-/camel-case-4.1.2.tgz",
-  "_shasum": "9728072a954f805228225a6deea6b38461e1bd5a",
-  "_spec": "camel-case@^4.1.1",
-  "_where": "/home/specter/repos/gmi-web/node_modules/html-minifier-terser",
-  "author": {
-    "name": "Blake Embrey",
-    "email": "hello@blakeembrey.com",
-    "url": "http://blakeembrey.me"
-  },
-  "bugs": {
-    "url": "https://github.com/blakeembrey/change-case/issues"
-  },
-  "bundleDependencies": false,
-  "dependencies": {
-    "pascal-case": "^3.1.2",
-    "tslib": "^2.0.3"
-  },
-  "deprecated": false,
-  "description": "Transform into a string with the separator denoted by the next word capitalized",
-  "devDependencies": {
-    "@size-limit/preset-small-lib": "^2.2.1",
-    "@types/jest": "^24.0.23",
-    "@types/node": "^12.12.14",
-    "jest": "^24.9.0",
-    "rimraf": "^3.0.0",
-    "ts-jest": "^24.2.0",
-    "tslint": "^5.20.1",
-    "tslint-config-prettier": "^1.18.0",
-    "tslint-config-standard": "^9.0.0",
-    "typescript": "^4.1.2"
-  },
-  "files": [
-    "dist/",
-    "dist.es2015/",
-    "LICENSE"
-  ],
-  "gitHead": "76a21a7f6f2a226521ef6abd345ff309cbd01fb0",
-  "homepage": "https://github.com/blakeembrey/change-case/tree/master/packages/camel-case#readme",
-  "jest": {
-    "roots": [
-      "<rootDir>/src/"
-    ],
-    "transform": {
-      "\\.tsx?$": "ts-jest"
-    },
-    "testRegex": "(/__tests__/.*|\\.(test|spec))\\.(tsx?|jsx?)$",
-    "moduleFileExtensions": [
-      "ts",
-      "tsx",
-      "js",
-      "jsx",
-      "json",
-      "node"
-    ]
-  },
-  "jsnext:main": "dist.es2015/index.js",
-  "keywords": [
-    "camel",
-    "case",
-    "camelcase",
-    "camel-case",
-    "convert",
-    "transform",
-    "identifier"
-  ],
-  "license": "MIT",
-  "main": "dist/index.js",
-  "module": "dist.es2015/index.js",
-  "name": "camel-case",
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/blakeembrey/change-case.git"
-  },
-  "scripts": {
-    "build": "rimraf dist/ dist.es2015/ && tsc && tsc -P tsconfig.es2015.json",
-    "lint": "tslint \"src/**/*\" --project tsconfig.json",
-    "prepare": "npm run build",
-    "size": "size-limit",
-    "specs": "jest --coverage",
-    "test": "npm run build && npm run lint && npm run specs"
-  },
-  "sideEffects": false,
-  "size-limit": [
-    {
-      "path": "dist/index.js",
-      "limit": "450 B"
-    }
-  ],
-  "typings": "dist/index.d.ts",
-  "version": "4.1.2"
-}

node_modules/clean-css/LICENSE

@@ -1,19 +0,0 @@
-Copyright (C) 2017 JakubPawlowicz.com
-
-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/clean-css/README.md

@@ -1,764 +0,0 @@
-<h1 align="center">
-  <br/>
-  <img src="https://cdn.rawgit.com/jakubpawlowicz/clean-css/master/logo.v2.svg" alt="clean-css logo" width="525px"/>
-  <br/>
-  <br/>
-</h1>
-
-[![NPM version](https://img.shields.io/npm/v/clean-css.svg?style=flat)](https://www.npmjs.com/package/clean-css)
-[![Linux Build Status](https://img.shields.io/travis/jakubpawlowicz/clean-css/master.svg?style=flat&label=Linux%20build)](https://travis-ci.org/jakubpawlowicz/clean-css)
-[![Windows Build status](https://img.shields.io/appveyor/ci/jakubpawlowicz/clean-css/master.svg?style=flat&label=Windows%20build)](https://ci.appveyor.com/project/jakubpawlowicz/clean-css/branch/master)
-[![Dependency Status](https://img.shields.io/david/jakubpawlowicz/clean-css.svg?style=flat)](https://david-dm.org/jakubpawlowicz/clean-css)
-[![NPM Downloads](https://img.shields.io/npm/dm/clean-css.svg)](https://npmcharts.com/compare/clean-css?minimal=true)
-[![Twitter](https://img.shields.io/badge/Twitter-@cleancss-blue.svg)](https://twitter.com/cleancss)
-
-clean-css is a fast and efficient CSS optimizer for [Node.js](http://nodejs.org/) platform and [any modern browser](https://jakubpawlowicz.github.io/clean-css).
-
-According to [tests](http://goalsmashers.github.io/css-minification-benchmark/) it is one of the best available.
-
-**Table of Contents**
-
-- [Node.js version support](#nodejs-version-support)
-- [Install](#install)
-- [Use](#use)
-  * [Important: 4.0 breaking changes](#important-40-breaking-changes)
-  * [What's new in version 4.1](#whats-new-in-version-41)
-  * [What's new in version 4.2](#whats-new-in-version-42)
-  * [Constructor options](#constructor-options)
-  * [Compatibility modes](#compatibility-modes)
-  * [Fetch option](#fetch-option)
-  * [Formatting options](#formatting-options)
-  * [Inlining options](#inlining-options)
-  * [Optimization levels](#optimization-levels)
-    + [Level 0 optimizations](#level-0-optimizations)
-    + [Level 1 optimizations](#level-1-optimizations)
-    + [Level 2 optimizations](#level-2-optimizations)
-  * [Minify method](#minify-method)
-  * [Promise interface](#promise-interface)
-  * [CLI utility](#cli-utility)
-- [FAQ](#faq)
-  * [How to optimize multiple files?](#how-to-optimize-multiple-files)
-  * [How to process remote `@import`s correctly?](#how-to-process-remote-imports-correctly)
-  * [How to apply arbitrary transformations to CSS properties?](#how-to-apply-arbitrary-transformations-to-css-properties)
-  * [How to specify a custom rounding precision?](#how-to-specify-a-custom-rounding-precision)
-  * [How to keep a CSS fragment intact?](#how-to-keep-a-css-fragment-intact)
-  * [How to preserve a comment block?](#how-to-preserve-a-comment-block)
-  * [How to rebase relative image URLs?](#how-to-rebase-relative-image-urls)
-  * [How to work with source maps?](#how-to-work-with-source-maps)
-  * [How to apply level 1 & 2 optimizations at the same time?](#how-to-apply-level-1--2-optimizations-at-the-same-time)
-  * [What level 2 optimizations do?](#what-level-2-optimizations-do)
-  * [How to use clean-css with build tools?](#how-to-use-clean-css-with-build-tools)
-  * [How to use clean-css from web browser?](#how-to-use-clean-css-from-web-browser)
-- [Contributing](#contributing)
-  * [How to get started?](#how-to-get-started)
-- [Acknowledgments](#acknowledgments)
-- [License](#license)
-
-# Node.js version support
-
-clean-css requires Node.js 4.0+ (tested on Linux, OS X, and Windows)
-
-# Install
-
-```
-npm install --save-dev clean-css
-```
-
-# Use
-
-```js
-var CleanCSS = require('clean-css');
-var input = 'a{font-weight:bold;}';
-var options = { /* options */ };
-var output = new CleanCSS(options).minify(input);
-```
-
-## Important: 4.0 breaking changes
-
-clean-css 4.0 introduces some breaking changes:
-
-* API and CLI interfaces are split, so API stays in this repository while CLI moves to [clean-css-cli](https://github.com/jakubpawlowicz/clean-css-cli);
-* `root`, `relativeTo`, and `target` options are replaced by a single `rebaseTo` option - this means that rebasing URLs and import inlining is much simpler but may not be (YMMV) as powerful as in 3.x;
-* `debug` option is gone as stats are always provided in output object under `stats` property;
-* `roundingPrecision` is disabled by default;
-* `roundingPrecision` applies to **all** units now, not only `px` as in 3.x;
-* `processImport` and `processImportFrom` are merged into `inline` option which defaults to `local`. Remote `@import` rules are **NOT** inlined by default anymore;
-* splits `inliner: { request: ..., timeout: ... }` option into `inlineRequest` and `inlineTimeout` options;
-* remote resources without a protocol, e.g. `//fonts.googleapis.com/css?family=Domine:700`, are not inlined anymore;
-* changes default Internet Explorer compatibility from 9+ to 10+, to revert the old default use `{ compatibility: 'ie9' }` flag;
-* renames `keepSpecialComments` to `specialComments`;
-* moves `roundingPrecision` and `specialComments` to level 1 optimizations options, see examples;
-* moves `mediaMerging`, `restructuring`, `semanticMerging`, and `shorthandCompacting` to level 2 optimizations options, see examples below;
-* renames `shorthandCompacting` option to `mergeIntoShorthands`;
-* level 1 optimizations are the new default, up to 3.x it was level 2;
-* `keepBreaks` option is replaced with `{ format: 'keep-breaks' }` to ease transition;
-* `sourceMap` option has to be a boolean from now on - to specify an input source map pass it a 2nd argument to `minify` method or via a hash instead;
-* `aggressiveMerging` option is removed as aggressive merging is replaced by smarter override merging.
-
-## What's new in version 4.1
-
-clean-css 4.1 introduces the following changes / features:
-
-* `inline: false` as an alias to `inline: ['none']`;
-* `multiplePseudoMerging` compatibility flag controlling merging of rules with multiple pseudo classes / elements;
-* `removeEmpty` flag in level 1 optimizations controlling removal of rules and nested blocks;
-* `removeEmpty` flag in level 2 optimizations controlling removal of rules and nested blocks;
-* `compatibility: { selectors: { mergeLimit: <number> } }` flag in compatibility settings controlling maximum number of selectors in a single rule;
-* `minify` method improved signature accepting a list of hashes for a predictable traversal;
-* `selectorsSortingMethod` level 1 optimization allows `false` or `'none'` for disabling selector sorting;
-* `fetch` option controlling a function for handling remote requests;
-* new `font` shorthand and `font-*` longhand optimizers;
-* removal of `optimizeFont` flag in level 1 optimizations due to new `font` shorthand optimizer;
-* `skipProperties` flag in level 2 optimizations controlling which properties won't be optimized;
-* new `animation` shorthand and `animation-*` longhand optimizers;
-* `removeUnusedAtRules` level 2 optimization controlling removal of unused `@counter-style`, `@font-face`, `@keyframes`, and `@namespace` at rules;
-* the [web interface](https://jakubpawlowicz.github.io/clean-css) gets an improved settings panel with "reset to defaults", instant option changes, and settings being persisted across sessions.
-
-## What's new in version 4.2
-
-clean-css 4.2 introduces the following changes / features:
-
-* Adds `process` method for compatibility with optimize-css-assets-webpack-plugin;
-* new `transition` property optimizer;
-* preserves any CSS content between `/* clean-css ignore:start */` and `/* clean-css ignore:end */` comments;
-* allows filtering based on selector in `transform` callback, see [example](#how-to-apply-arbitrary-transformations-to-css-properties);
-* adds configurable line breaks via `format: { breakWith: 'lf' }` option.
-
-## Constructor options
-
-clean-css constructor accepts a hash as a parameter with the following options available:
-
-* `compatibility` - controls compatibility mode used; defaults to `ie10+`; see [compatibility modes](#compatibility-modes) for examples;
-* `fetch` - controls a function for handling remote requests; see [fetch option](#fetch-option) for examples (since 4.1.0);
-* `format` - controls output CSS formatting; defaults to `false`; see [formatting options](#formatting-options) for examples;
-* `inline` - controls `@import` inlining rules; defaults to `'local'`; see [inlining options](#inlining-options) for examples;
-* `inlineRequest` - controls extra options for inlining remote `@import` rules, can be any of [HTTP(S) request options](https://nodejs.org/api/http.html#http_http_request_options_callback);
-* `inlineTimeout` - controls number of milliseconds after which inlining a remote `@import` fails; defaults to 5000;
-* `level` - controls optimization level used; defaults to `1`; see [optimization levels](#optimization-levels) for examples;
-* `rebase` - controls URL rebasing; defaults to `true`;
-* `rebaseTo` - controls a directory to which all URLs are rebased, most likely the directory under which the output file will live; defaults to the current directory;
-* `returnPromise` - controls whether `minify` method returns a Promise object or not; defaults to `false`; see [promise interface](#promise-interface) for examples;
-* `sourceMap` - controls whether an output source map is built; defaults to `false`;
-* `sourceMapInlineSources` - controls embedding sources inside a source map's `sourcesContent` field; defaults to false.
-
-## Compatibility modes
-
-There is a certain number of compatibility mode shortcuts, namely:
-
-* `new CleanCSS({ compatibility: '*' })` (default) - Internet Explorer 10+ compatibility mode
-* `new CleanCSS({ compatibility: 'ie9' })` - Internet Explorer 9+ compatibility mode
-* `new CleanCSS({ compatibility: 'ie8' })` - Internet Explorer 8+ compatibility mode
-* `new CleanCSS({ compatibility: 'ie7' })` - Internet Explorer 7+ compatibility mode
-
-Each of these modes is an alias to a [fine grained configuration](https://github.com/jakubpawlowicz/clean-css/blob/master/lib/options/compatibility.js), with the following options available:
-
-```js
-new CleanCSS({
-  compatibility: {
-    colors: {
-      opacity: true // controls `rgba()` / `hsla()` color support
-    },
-    properties: {
-      backgroundClipMerging: true, // controls background-clip merging into shorthand
-      backgroundOriginMerging: true, // controls background-origin merging into shorthand
-      backgroundSizeMerging: true, // controls background-size merging into shorthand
-      colors: true, // controls color optimizations
-      ieBangHack: false, // controls keeping IE bang hack
-      ieFilters: false, // controls keeping IE `filter` / `-ms-filter`
-      iePrefixHack: false, // controls keeping IE prefix hack
-      ieSuffixHack: false, // controls keeping IE suffix hack
-      merging: true, // controls property merging based on understandability
-      shorterLengthUnits: false, // controls shortening pixel units into `pc`, `pt`, or `in` units
-      spaceAfterClosingBrace: true, // controls keeping space after closing brace - `url() no-repeat` into `url()no-repeat`
-      urlQuotes: false, // controls keeping quoting inside `url()`
-      zeroUnits: true // controls removal of units `0` value
-    },
-    selectors: {
-      adjacentSpace: false, // controls extra space before `nav` element
-      ie7Hack: true, // controls removal of IE7 selector hacks, e.g. `*+html...`
-      mergeablePseudoClasses: [':active', ...], // controls a whitelist of mergeable pseudo classes
-      mergeablePseudoElements: ['::after', ...], // controls a whitelist of mergeable pseudo elements
-      mergeLimit: 8191, // controls maximum number of selectors in a single rule (since 4.1.0)
-      multiplePseudoMerging: true // controls merging of rules with multiple pseudo classes / elements (since 4.1.0)
-    },
-    units: {
-      ch: true, // controls treating `ch` as a supported unit
-      in: true, // controls treating `in` as a supported unit
-      pc: true, // controls treating `pc` as a supported unit
-      pt: true, // controls treating `pt` as a supported unit
-      rem: true, // controls treating `rem` as a supported unit
-      vh: true, // controls treating `vh` as a supported unit
-      vm: true, // controls treating `vm` as a supported unit
-      vmax: true, // controls treating `vmax` as a supported unit
-      vmin: true // controls treating `vmin` as a supported unit
-    }
-  }
-})
-```
-
-You can also use a string when setting a compatibility mode, e.g.
-
-```js
-new CleanCSS({
-  compatibility: 'ie9,-properties.merging' // sets compatibility to IE9 mode with disabled property merging
-})
-```
-
-## Fetch option
-
-The `fetch` option accepts a function which handles remote resource fetching, e.g.
-
-```js
-var request = require('request');
-var source = '@import url(http://example.com/path/to/stylesheet.css);';
-new CleanCSS({
-  fetch: function (uri, inlineRequest, inlineTimeout, callback) {
-    request(uri, function (error, response, body) {
-      if (error) {
-        callback(error, null);
-      } else if (response && response.statusCode != 200) {
-        callback(response.statusCode, null);
-      } else {
-        callback(null, body);
-      }
-    });
-  }
-}).minify(source);
-```
-
-This option provides a convenient way of overriding the default fetching logic if it doesn't support a particular feature, say CONNECT proxies.
-
-Unless given, the default [loadRemoteResource](https://github.com/jakubpawlowicz/clean-css/blob/master/lib/reader/load-remote-resource.js) logic is used.
-
-## Formatting options
-
-By default output CSS is formatted without any whitespace unless a `format` option is given.
-First of all there are two shorthands:
-
-```js
-new CleanCSS({
-  format: 'beautify' // formats output in a really nice way
-})
-```
-
-and
-
-```js
-new CleanCSS({
-  format: 'keep-breaks' // formats output the default way but adds line breaks for improved readability
-})
-```
-
-however `format` option also accept a fine-grained set of options:
-
-```js
-new CleanCSS({
-  format: {
-    breaks: { // controls where to insert breaks
-      afterAtRule: false, // controls if a line break comes after an at-rule; e.g. `@charset`; defaults to `false`
-      afterBlockBegins: false, // controls if a line break comes after a block begins; e.g. `@media`; defaults to `false`
-      afterBlockEnds: false, // controls if a line break comes after a block ends, defaults to `false`
-      afterComment: false, // controls if a line break comes after a comment; defaults to `false`
-      afterProperty: false, // controls if a line break comes after a property; defaults to `false`
-      afterRuleBegins: false, // controls if a line break comes after a rule begins; defaults to `false`
-      afterRuleEnds: false, // controls if a line break comes after a rule ends; defaults to `false`
-      beforeBlockEnds: false, // controls if a line break comes before a block ends; defaults to `false`
-      betweenSelectors: false // controls if a line break comes between selectors; defaults to `false`
-    },
-    breakWith: '\n', // controls the new line character, can be `'\r\n'` or `'\n'` (aliased as `'windows'` and `'unix'` or `'crlf'` and `'lf'`); defaults to system one, so former on Windows and latter on Unix
-    indentBy: 0, // controls number of characters to indent with; defaults to `0`
-    indentWith: 'space', // controls a character to indent with, can be `'space'` or `'tab'`; defaults to `'space'`
-    spaces: { // controls where to insert spaces
-      aroundSelectorRelation: false, // controls if spaces come around selector relations; e.g. `div > a`; defaults to `false`
-      beforeBlockBegins: false, // controls if a space comes before a block begins; e.g. `.block {`; defaults to `false`
-      beforeValue: false // controls if a space comes before a value; e.g. `width: 1rem`; defaults to `false`
-    },
-    wrapAt: false // controls maximum line length; defaults to `false`
-  }
-})
-```
-
-## Inlining options
-
-`inline` option whitelists which `@import` rules will be processed, e.g.
-
-```js
-new CleanCSS({
-  inline: ['local'] // default; enables local inlining only
-})
-```
-
-```js
-new CleanCSS({
-  inline: ['none'] // disables all inlining
-})
-```
-
-```js
-// introduced in clean-css 4.1.0
-
-new CleanCSS({
-  inline: false // disables all inlining (alias to `['none']`)
-})
-```
-
-```js
-new CleanCSS({
-  inline: ['all'] // enables all inlining, same as ['local', 'remote']
-})
-```
-
-```js
-new CleanCSS({
-  inline: ['local', 'mydomain.example.com'] // enables local inlining plus given remote source
-})
-```
-
-```js
-new CleanCSS({
-  inline: ['local', 'remote', '!fonts.googleapis.com'] // enables all inlining but from given remote source
-})
-```
-
-## Optimization levels
-
-The `level` option can be either `0`, `1` (default), or `2`, e.g.
-
-```js
-new CleanCSS({
-  level: 2
-})
-```
-
-or a fine-grained configuration given via a hash.
-
-Please note that level 1 optimization options are generally safe while level 2 optimizations should be safe for most users.
-
-### Level 0 optimizations
-
-Level 0 optimizations simply means "no optimizations". Use it when you'd like to inline imports and / or rebase URLs but skip everything else.
-
-### Level 1 optimizations
-
-Level 1 optimizations (default) operate on single properties only, e.g. can remove units when not required, turn rgb colors to a shorter hex representation, remove comments, etc
-
-Here is a full list of available options:
-
-```js
-new CleanCSS({
-  level: {
-    1: {
-      cleanupCharsets: true, // controls `@charset` moving to the front of a stylesheet; defaults to `true`
-      normalizeUrls: true, // controls URL normalization; defaults to `true`
-      optimizeBackground: true, // controls `background` property optimizations; defaults to `true`
-      optimizeBorderRadius: true, // controls `border-radius` property optimizations; defaults to `true`
-      optimizeFilter: true, // controls `filter` property optimizations; defaults to `true`
-      optimizeFont: true, // controls `font` property optimizations; defaults to `true`
-      optimizeFontWeight: true, // controls `font-weight` property optimizations; defaults to `true`
-      optimizeOutline: true, // controls `outline` property optimizations; defaults to `true`
-      removeEmpty: true, // controls removing empty rules and nested blocks; defaults to `true`
-      removeNegativePaddings: true, // controls removing negative paddings; defaults to `true`
-      removeQuotes: true, // controls removing quotes when unnecessary; defaults to `true`
-      removeWhitespace: true, // controls removing unused whitespace; defaults to `true`
-      replaceMultipleZeros: true, // contols removing redundant zeros; defaults to `true`
-      replaceTimeUnits: true, // controls replacing time units with shorter values; defaults to `true`
-      replaceZeroUnits: true, // controls replacing zero values with units; defaults to `true`
-      roundingPrecision: false, // rounds pixel values to `N` decimal places; `false` disables rounding; defaults to `false`
-      selectorsSortingMethod: 'standard', // denotes selector sorting method; can be `'natural'` or `'standard'`, `'none'`, or false (the last two since 4.1.0); defaults to `'standard'`
-      specialComments: 'all', // denotes a number of /*! ... */ comments preserved; defaults to `all`
-      tidyAtRules: true, // controls at-rules (e.g. `@charset`, `@import`) optimizing; defaults to `true`
-      tidyBlockScopes: true, // controls block scopes (e.g. `@media`) optimizing; defaults to `true`
-      tidySelectors: true, // controls selectors optimizing; defaults to `true`,
-      semicolonAfterLastProperty: false, // controls removing trailing semicolons in rule; defaults to `false` - means remove
-      transform: function () {} // defines a callback for fine-grained property optimization; defaults to no-op
-    }
-  }
-});
-```
-
-There is an `all` shortcut for toggling all options at the same time, e.g.
-
-```js
-new CleanCSS({
-  level: {
-    1: {
-      all: false, // set all values to `false`
-      tidySelectors: true // turns on optimizing selectors
-    }
-  }
-});
-```
-
-### Level 2 optimizations
-
-Level 2 optimizations operate at rules or multiple properties level, e.g. can remove duplicate rules, remove properties redefined further down a stylesheet, or restructure rules by moving them around.
-
-Please note that if level 2 optimizations are turned on then, unless explicitely disabled, level 1 optimizations are applied as well.
-
-Here is a full list of available options:
-
-```js
-new CleanCSS({
-  level: {
-    2: {
-      mergeAdjacentRules: true, // controls adjacent rules merging; defaults to true
-      mergeIntoShorthands: true, // controls merging properties into shorthands; defaults to true
-      mergeMedia: true, // controls `@media` merging; defaults to true
-      mergeNonAdjacentRules: true, // controls non-adjacent rule merging; defaults to true
-      mergeSemantically: false, // controls semantic merging; defaults to false
-      overrideProperties: true, // controls property overriding based on understandability; defaults to true
-      removeEmpty: true, // controls removing empty rules and nested blocks; defaults to `true`
-      reduceNonAdjacentRules: true, // controls non-adjacent rule reducing; defaults to true
-      removeDuplicateFontRules: true, // controls duplicate `@font-face` removing; defaults to true
-      removeDuplicateMediaBlocks: true, // controls duplicate `@media` removing; defaults to true
-      removeDuplicateRules: true, // controls duplicate rules removing; defaults to true
-      removeUnusedAtRules: false, // controls unused at rule removing; defaults to false (available since 4.1.0)
-      restructureRules: false, // controls rule restructuring; defaults to false
-      skipProperties: [] // controls which properties won't be optimized, defaults to `[]` which means all will be optimized (since 4.1.0)
-    }
-  }
-});
-```
-
-There is an `all` shortcut for toggling all options at the same time, e.g.
-
-```js
-new CleanCSS({
-  level: {
-    2: {
-      all: false, // sets all values to `false`
-      removeDuplicateRules: true // turns on removing duplicate rules
-    }
-  }
-});
-```
-
-## Minify method
-
-Once configured clean-css provides a `minify` method to optimize a given CSS, e.g.
-
-```js
-var output = new CleanCSS(options).minify(source);
-```
-
-The output of the `minify` method is a hash with following fields:
-
-```js
-console.log(output.styles); // optimized output CSS as a string
-console.log(output.sourceMap); // output source map if requested with `sourceMap` option
-console.log(output.errors); // a list of errors raised
-console.log(output.warnings); // a list of warnings raised
-console.log(output.stats.originalSize); // original content size after import inlining
-console.log(output.stats.minifiedSize); // optimized content size
-console.log(output.stats.timeSpent); // time spent on optimizations in milliseconds
-console.log(output.stats.efficiency); // `(originalSize - minifiedSize) / originalSize`, e.g. 0.25 if size is reduced from 100 bytes to 75 bytes
-```
-
-The `minify` method also accepts an input source map, e.g.
-
-```js
-var output = new CleanCSS(options).minify(source, inputSourceMap);
-```
-
-or a callback invoked when optimizations are finished, e.g.
-
-```js
-new CleanCSS(options).minify(source, function (error, output) {
-  // `output` is the same as in the synchronous call above
-});
-```
-
-## Promise interface
-
-If you prefer clean-css to return a Promise object then you need to explicitely ask for it, e.g.
-
-```js
-new CleanCSS({ returnPromise: true })
-  .minify(source)
-  .then(function (output) { console.log(output.styles); })
-  .catch(function (error) { // deal with errors });
-```
-
-## CLI utility
-
-Clean-css has an associated command line utility that can be installed separately using `npm install clean-css-cli`. For more detailed information, please visit https://github.com/jakubpawlowicz/clean-css-cli.
-
-# FAQ
-
-## How to optimize multiple files?
-
-It can be done either by passing an array of paths, or, when sources are already available, a hash or an array of hashes:
-
-```js
-new CleanCSS().minify(['path/to/file/one', 'path/to/file/two']);
-```
-
-```js
-new CleanCSS().minify({
-  'path/to/file/one': {
-    styles: 'contents of file one'
-  },
-  'path/to/file/two': {
-    styles: 'contents of file two'
-  }
-});
-```
-
-```js
-new CleanCSS().minify([
-  {'path/to/file/one': {styles: 'contents of file one'}},
-  {'path/to/file/two': {styles: 'contents of file two'}}
-]);
-```
-
-Passing an array of hashes allows you to explicitly specify the order in which the input files are concatenated. Whereas when you use a single hash the order is determined by the [traversal order of object properties](http://2ality.com/2015/10/property-traversal-order-es6.html) - available since 4.1.0.
-
-Important note - any `@import` rules already present in the hash will be resolved in memory.
-
-## How to process remote `@import`s correctly?
-
-In order to inline remote `@import` statements you need to provide a callback to minify method as fetching remote assets is an asynchronous operation, e.g.:
-
-```js
-var source = '@import url(http://example.com/path/to/remote/styles);';
-new CleanCSS({ inline: ['remote'] }).minify(source, function (error, output) {
-  // output.styles
-});
-```
-
-If you don't provide a callback, then remote `@import`s will be left as is.
-
-## How to apply arbitrary transformations to CSS properties?
-
-If clean-css doesn't perform a particular property optimization, you can use `transform` callback to apply it:
-
-```js
-var source = '.block{background-image:url(/path/to/image.png)}';
-var output = new CleanCSS({
-  level: {
-    1: {
-      transform: function (propertyName, propertyValue, selector /* `selector` available since 4.2.0-pre */) {
-        if (propertyName == 'background-image' && propertyValue.indexOf('/path/to') > -1) {
-          return propertyValue.replace('/path/to', '../valid/path/to');
-        }
-      }
-    }
-  }
-}).minify(source);
-
-console.log(output.styles); # => .block{background-image:url(../valid/path/to/image.png)}
-```
-
-Note: returning `false` from `transform` callback will drop a property.
-
-## How to specify a custom rounding precision?
-
-The level 1 `roundingPrecision` optimization option accept a string with per-unit rounding precision settings, e.g.
-
-```js
-new CleanCSS({
-  level: {
-    1: {
-      roundingPrecision: 'all=3,px=5'
-    }
-  }
-}).minify(source)
-```
-
-which sets all units rounding precision to 3 digits except `px` unit precision of 5 digits.
-
-## How to keep a CSS fragment intact?
-
-Note: available in the current master, to be released in 4.2.0.
-
-Wrap the CSS fragment in special comments which instruct clean-css to preserve it, e.g.
-
-```css
-.block-1 {
-  color: red
-}
-/* clean-css ignore:start */
-.block-special {
-  color: transparent
-}
-/* clean-css ignore:end */
-.block-2 {
-  margin: 0
-}
-```
-
-Optimizing this CSS will result in the following output:
-
-```css
-.block-1{color:red}
-.block-special {
-  color: transparent
-}
-.block-2{margin:0}
-```
-
-## How to preserve a comment block?
-
-Use the `/*!` notation instead of the standard one `/*`:
-
-```css
-/*!
-  Important comments included in optimized output.
-*/
-```
-
-## How to rebase relative image URLs?
-
-clean-css will handle it automatically for you in the following cases:
-
-* when full paths to input files are passed in as options;
-* when correct paths are passed in via a hash;
-* when `rebaseTo` is used with any of above two.
-
-## How to work with source maps?
-
-To generate a source map, use `sourceMap: true` option, e.g.:
-
-```js
-new CleanCSS({ sourceMap: true, rebaseTo: pathToOutputDirectory })
-  .minify(source, function (error, output) {
-    // access output.sourceMap for SourceMapGenerator object
-    // see https://github.com/mozilla/source-map/#sourcemapgenerator for more details
-});
-```
-
-You can also pass an input source map directly as a 2nd argument to `minify` method:
-
-```js
-new CleanCSS({ sourceMap: true, rebaseTo: pathToOutputDirectory })
-  .minify(source, inputSourceMap, function (error, output) {
-    // access output.sourceMap to access SourceMapGenerator object
-    // see https://github.com/mozilla/source-map/#sourcemapgenerator for more details
-});
-```
-
-or even multiple input source maps at once:
-
-```js
-new CleanCSS({ sourceMap: true, rebaseTo: pathToOutputDirectory }).minify({
-  'path/to/source/1': {
-    styles: '...styles...',
-    sourceMap: '...source-map...'
-  },
-  'path/to/source/2': {
-    styles: '...styles...',
-    sourceMap: '...source-map...'
-  }
-}, function (error, output) {
-  // access output.sourceMap as above
-});
-```
-
-## How to apply level 1 & 2 optimizations at the same time?
-
-Using the hash configuration specifying both optimization levels, e.g.
-
-```js
-new CleanCSS({
-  level: {
-    1: {
-      all: true,
-      normalizeUrls: false
-    },
-    2: {
-      restructureRules: true
-    }
-  }
-})
-```
-
-will apply level 1 optimizations, except url normalization, and default level 2 optimizations with rule restructuring.
-
-## What level 2 optimizations do?
-
-All level 2 optimizations are dispatched [here](https://github.com/jakubpawlowicz/clean-css/blob/master/lib/optimizer/level-2/optimize.js#L67), and this is what they do:
-
-* `recursivelyOptimizeBlocks` - does all the following operations on a nested block, like `@media` or `@keyframe`;
-* `recursivelyOptimizeProperties` - optimizes properties in rulesets and flat at-rules, like @font-face, by splitting them into components (e.g. `margin` into `margin-(bottom|left|right|top)`), optimizing, and restoring them back. You may want to use `mergeIntoShorthands` option to control whether you want to turn multiple components into shorthands;
-* `removeDuplicates` - gets rid of duplicate rulesets with exactly the same set of properties, e.g. when including a Sass / Less partial twice for no good reason;
-* `mergeAdjacent` - merges adjacent rulesets with the same selector or rules;
-* `reduceNonAdjacent` - identifies which properties are overridden in same-selector non-adjacent rulesets, and removes them;
-* `mergeNonAdjacentBySelector` - identifies same-selector non-adjacent rulesets which can be moved (!) to be merged, requires all intermediate rulesets to not redefine the moved properties, or if redefined to have the same value;
-* `mergeNonAdjacentByBody` - same as the one above but for same-selector non-adjacent rulesets;
-* `restructure` - tries to reorganize different-selector different-rules rulesets so they take less space, e.g. `.one{padding:0}.two{margin:0}.one{margin-bottom:3px}` into `.two{margin:0}.one{padding:0;margin-bottom:3px}`;
-* `removeDuplicateFontAtRules` - removes duplicated `@font-face` rules;
-* `removeDuplicateMediaQueries` - removes duplicated `@media` nested blocks;
-* `mergeMediaQueries` - merges non-adjacent `@media` at-rules by the same rules as `mergeNonAdjacentBy*` above;
-
-## How to use clean-css with build tools?
-
-There is a number of 3rd party plugins to popular build tools:
-
-* [Broccoli](https://github.com/broccolijs/broccoli#broccoli): [broccoli-clean-css](https://github.com/shinnn/broccoli-clean-css)
-* [Brunch](http://brunch.io/): [clean-css-brunch](https://github.com/brunch/clean-css-brunch)
-* [Grunt](http://gruntjs.com): [grunt-contrib-cssmin](https://github.com/gruntjs/grunt-contrib-cssmin)
-* [Gulp](http://gulpjs.com/): [gulp-clean-css](https://github.com/scniro/gulp-clean-css)
-* [Gulp](http://gulpjs.com/): [using vinyl-map as a wrapper - courtesy of @sogko](https://github.com/jakubpawlowicz/clean-css/issues/342)
-* [component-builder2](https://github.com/component/builder2.js): [builder-clean-css](https://github.com/poying/builder-clean-css)
-* [Metalsmith](http://metalsmith.io): [metalsmith-clean-css](https://github.com/aymericbeaumet/metalsmith-clean-css)
-* [Lasso](https://github.com/lasso-js/lasso): [lasso-clean-css](https://github.com/yomed/lasso-clean-css)
-* [Start](https://github.com/start-runner/start): [start-clean-css](https://github.com/start-runner/clean-css)
-
-## How to use clean-css from web browser?
-
-* https://jakubpawlowicz.github.io/clean-css/ (official web interface)
-* http://refresh-sf.com/
-* http://adamburgess.github.io/clean-css-online/
-
-# Contributing
-
-See [CONTRIBUTING.md](https://github.com/jakubpawlowicz/clean-css/blob/master/CONTRIBUTING.md).
-
-## How to get started?
-
-First clone the sources:
-
-```bash
-git clone git@github.com:jakubpawlowicz/clean-css.git
-```
-
-then install dependencies:
-
-```bash
-cd clean-css
-npm install
-```
-
-then use any of the following commands to verify your copy:
-
-```bash
-npm run bench # for clean-css benchmarks (see [test/bench.js](https://github.com/jakubpawlowicz/clean-css/blob/master/test/bench.js) for details)
-npm run browserify # to create the browser-ready clean-css version
-npm run check # to lint JS sources with [JSHint](https://github.com/jshint/jshint/)
-npm test # to run all tests
-```
-
-# Acknowledgments
-
-Sorted alphabetically by GitHub handle:
-
-* [@abarre](https://github.com/abarre) (Anthony Barre) for improvements to `@import` processing;
-* [@alexlamsl](https://github.com/alexlamsl) (Alex Lam S.L.) for testing early clean-css 4 versions, reporting bugs, and suggesting numerous improvements.
-* [@altschuler](https://github.com/altschuler) (Simon Altschuler) for fixing `@import` processing inside comments;
-* [@ben-eb](https://github.com/ben-eb) (Ben Briggs) for sharing ideas about CSS optimizations;
-* [@davisjam](https://github.com/davisjam) (Jamie Davis) for disclosing ReDOS vulnerabilities;
-* [@facelessuser](https://github.com/facelessuser) (Isaac) for pointing out a flaw in clean-css' stateless mode;
-* [@grandrath](https://github.com/grandrath) (Martin Grandrath) for improving `minify` method source traversal in ES6;
-* [@jmalonzo](https://github.com/jmalonzo) (Jan Michael Alonzo) for a patch removing node.js' old `sys` package;
-* [@lukeapage](https://github.com/lukeapage) (Luke Page) for suggestions and testing the source maps feature;
-  Plus everyone else involved in [#125](https://github.com/jakubpawlowicz/clean-css/issues/125) for pushing it forward;
-* [@madwizard-thomas](https://github.com/madwizard-thomas) for sharing ideas about `@import` inlining and URL rebasing.
-* [@ngyikp](https://github.com/ngyikp) (Ng Yik Phang) for testing early clean-css 4 versions, reporting bugs, and suggesting numerous improvements.
-* [@wagenet](https://github.com/wagenet) (Peter Wagenet) for suggesting improvements to `@import` inlining behavior;
-* [@venemo](https://github.com/venemo) (Timur Kristóf) for an outstanding contribution of advanced property optimizer for 2.2 release;
-* [@vvo](https://github.com/vvo) (Vincent Voyer) for a patch with better empty element regex and for inspiring us to do many performance improvements in 0.4 release;
-* [@xhmikosr](https://github.com/xhmikosr) for suggesting new features, like option to remove special comments and strip out URLs quotation, and pointing out numerous improvements like JSHint, media queries, etc.
-
-# License
-
-clean-css is released under the [MIT License](https://github.com/jakubpawlowicz/clean-css/blob/master/LICENSE).

node_modules/clean-css/index.js

@@ -1 +0,0 @@
-module.exports = require('./lib/clean');

node_modules/clean-css/lib/clean.js

@@ -1,172 +0,0 @@
-/**
- * Clean-css - https://github.com/jakubpawlowicz/clean-css
- * Released under the terms of MIT license
- *
- * Copyright (C) 2017 JakubPawlowicz.com
- */
-
-var level0Optimize = require('./optimizer/level-0/optimize');
-var level1Optimize = require('./optimizer/level-1/optimize');
-var level2Optimize = require('./optimizer/level-2/optimize');
-var validator = require('./optimizer/validator');
-
-var compatibilityFrom = require('./options/compatibility');
-var fetchFrom = require('./options/fetch');
-var formatFrom = require('./options/format').formatFrom;
-var inlineFrom = require('./options/inline');
-var inlineRequestFrom = require('./options/inline-request');
-var inlineTimeoutFrom = require('./options/inline-timeout');
-var OptimizationLevel = require('./options/optimization-level').OptimizationLevel;
-var optimizationLevelFrom = require('./options/optimization-level').optimizationLevelFrom;
-var rebaseFrom = require('./options/rebase');
-var rebaseToFrom = require('./options/rebase-to');
-
-var inputSourceMapTracker = require('./reader/input-source-map-tracker');
-var readSources = require('./reader/read-sources');
-
-var serializeStyles = require('./writer/simple');
-var serializeStylesAndSourceMap = require('./writer/source-maps');
-
-var CleanCSS = module.exports = function CleanCSS(options) {
-  options = options || {};
-
-  this.options = {
-    compatibility: compatibilityFrom(options.compatibility),
-    fetch: fetchFrom(options.fetch),
-    format: formatFrom(options.format),
-    inline: inlineFrom(options.inline),
-    inlineRequest: inlineRequestFrom(options.inlineRequest),
-    inlineTimeout: inlineTimeoutFrom(options.inlineTimeout),
-    level: optimizationLevelFrom(options.level),
-    rebase: rebaseFrom(options.rebase),
-    rebaseTo: rebaseToFrom(options.rebaseTo),
-    returnPromise: !!options.returnPromise,
-    sourceMap: !!options.sourceMap,
-    sourceMapInlineSources: !!options.sourceMapInlineSources
-  };
-};
-
-
-// for compatibility with optimize-css-assets-webpack-plugin
-CleanCSS.process = function (input, opts) {
-  var cleanCss;
-  var optsTo = opts.to;
-
-  delete opts.to;
-  cleanCss = new CleanCSS(Object.assign({ returnPromise: true, rebaseTo: optsTo }, opts));
-
-  return cleanCss.minify(input)
-    .then(function(output) {
-      return { css: output.styles };
-    });
-};
-
-
-CleanCSS.prototype.minify = function (input, maybeSourceMap, maybeCallback) {
-  var options = this.options;
-
-  if (options.returnPromise) {
-    return new Promise(function (resolve, reject) {
-      minify(input, options, maybeSourceMap, function (errors, output) {
-        return errors ?
-          reject(errors) :
-          resolve(output);
-      });
-    });
-  } else {
-    return minify(input, options, maybeSourceMap, maybeCallback);
-  }
-};
-
-function minify(input, options, maybeSourceMap, maybeCallback) {
-  var sourceMap = typeof maybeSourceMap != 'function' ?
-    maybeSourceMap :
-    null;
-  var callback = typeof maybeCallback == 'function' ?
-    maybeCallback :
-    (typeof maybeSourceMap == 'function' ? maybeSourceMap : null);
-  var context = {
-    stats: {
-      efficiency: 0,
-      minifiedSize: 0,
-      originalSize: 0,
-      startedAt: Date.now(),
-      timeSpent: 0
-    },
-    cache: {
-      specificity: {}
-    },
-    errors: [],
-    inlinedStylesheets: [],
-    inputSourceMapTracker: inputSourceMapTracker(),
-    localOnly: !callback,
-    options: options,
-    source: null,
-    sourcesContent: {},
-    validator: validator(options.compatibility),
-    warnings: []
-  };
-
-  if (sourceMap) {
-    context.inputSourceMapTracker.track(undefined, sourceMap);
-  }
-
-  return runner(context.localOnly)(function () {
-    return readSources(input, context, function (tokens) {
-      var serialize = context.options.sourceMap ?
-        serializeStylesAndSourceMap :
-        serializeStyles;
-
-      var optimizedTokens = optimize(tokens, context);
-      var optimizedStyles = serialize(optimizedTokens, context);
-      var output = withMetadata(optimizedStyles, context);
-
-      return callback ?
-        callback(context.errors.length > 0 ? context.errors : null, output) :
-        output;
-    });
-  });
-}
-
-function runner(localOnly) {
-  // to always execute code asynchronously when a callback is given
-  // more at blog.izs.me/post/59142742143/designing-apis-for-asynchrony
-  return localOnly ?
-    function (callback) { return callback(); } :
-    process.nextTick;
-}
-
-function optimize(tokens, context) {
-  var optimized;
-
-  optimized = level0Optimize(tokens, context);
-  optimized = OptimizationLevel.One in context.options.level ?
-    level1Optimize(tokens, context) :
-    tokens;
-  optimized = OptimizationLevel.Two in context.options.level ?
-    level2Optimize(tokens, context, true) :
-    optimized;
-
-  return optimized;
-}
-
-function withMetadata(output, context) {
-  output.stats = calculateStatsFrom(output.styles, context);
-  output.errors = context.errors;
-  output.inlinedStylesheets = context.inlinedStylesheets;
-  output.warnings = context.warnings;
-
-  return output;
-}
-
-function calculateStatsFrom(styles, context) {
-  var finishedAt = Date.now();
-  var timeSpent = finishedAt - context.stats.startedAt;
-
-  delete context.stats.startedAt;
-  context.stats.timeSpent = timeSpent;
-  context.stats.efficiency = 1 - styles.length / context.stats.originalSize;
-  context.stats.minifiedSize = styles.length;
-
-  return context.stats;
-}

node_modules/clean-css/lib/optimizer/hack.js

@@ -1,8 +0,0 @@
-var Hack = {
-  ASTERISK: 'asterisk',
-  BANG: 'bang',
-  BACKSLASH: 'backslash',
-  UNDERSCORE: 'underscore'
-};
-
-module.exports = Hack;

node_modules/clean-css/lib/optimizer/level-0/optimize.js

@@ -1,6 +0,0 @@
-function level0Optimize(tokens) {
-  // noop as level 0 means no optimizations!
-  return tokens;
-}
-
-module.exports = level0Optimize;

node_modules/clean-css/lib/optimizer/level-1/optimize.js

@@ -1,691 +0,0 @@
-var shortenHex = require('./shorten-hex');
-var shortenHsl = require('./shorten-hsl');
-var shortenRgb = require('./shorten-rgb');
-var sortSelectors = require('./sort-selectors');
-var tidyRules = require('./tidy-rules');
-var tidyBlock = require('./tidy-block');
-var tidyAtRule = require('./tidy-at-rule');
-
-var Hack = require('../hack');
-var removeUnused = require('../remove-unused');
-var restoreFromOptimizing = require('../restore-from-optimizing');
-var wrapForOptimizing = require('../wrap-for-optimizing').all;
-
-var OptimizationLevel = require('../../options/optimization-level').OptimizationLevel;
-
-var Token = require('../../tokenizer/token');
-var Marker = require('../../tokenizer/marker');
-
-var formatPosition = require('../../utils/format-position');
-var split = require('../../utils/split');
-
-var serializeRules = require('../../writer/one-time').rules;
-
-var IgnoreProperty = 'ignore-property';
-
-var CHARSET_TOKEN = '@charset';
-var CHARSET_REGEXP = new RegExp('^' + CHARSET_TOKEN, 'i');
-
-var DEFAULT_ROUNDING_PRECISION = require('../../options/rounding-precision').DEFAULT;
-
-var WHOLE_PIXEL_VALUE = /(?:^|\s|\()(-?\d+)px/;
-var TIME_VALUE = /^(\-?[\d\.]+)(m?s)$/;
-
-var HEX_VALUE_PATTERN = /[0-9a-f]/i;
-var PROPERTY_NAME_PATTERN = /^(?:\-chrome\-|\-[\w\-]+\w|\w[\w\-]+\w|\-\-\S+)$/;
-var IMPORT_PREFIX_PATTERN = /^@import/i;
-var QUOTED_PATTERN = /^('.*'|".*")$/;
-var QUOTED_BUT_SAFE_PATTERN = /^['"][a-zA-Z][a-zA-Z\d\-_]+['"]$/;
-var URL_PREFIX_PATTERN = /^url\(/i;
-var LOCAL_PREFIX_PATTERN = /^local\(/i;
-var VARIABLE_NAME_PATTERN = /^--\S+$/;
-
-function isLocal(value){
-  return LOCAL_PREFIX_PATTERN.test(value);
-}
-
-function isNegative(value) {
-  return value && value[1][0] == '-' && parseFloat(value[1]) < 0;
-}
-
-function isQuoted(value) {
-  return QUOTED_PATTERN.test(value);
-}
-
-function isUrl(value) {
-  return URL_PREFIX_PATTERN.test(value);
-}
-
-function normalizeUrl(value) {
-  return value
-    .replace(URL_PREFIX_PATTERN, 'url(')
-    .replace(/\\?\n|\\?\r\n/g, '');
-}
-
-function optimizeBackground(property) {
-  var values = property.value;
-
-  if (values.length == 1 && values[0][1] == 'none') {
-    values[0][1] = '0 0';
-  }
-
-  if (values.length == 1 && values[0][1] == 'transparent') {
-    values[0][1] = '0 0';
-  }
-}
-
-function optimizeBorderRadius(property) {
-  var values = property.value;
-  var spliceAt;
-
-  if (values.length == 3 && values[1][1] == '/' && values[0][1] == values[2][1]) {
-    spliceAt = 1;
-  } else if (values.length == 5 && values[2][1] == '/' && values[0][1] == values[3][1] && values[1][1] == values[4][1]) {
-    spliceAt = 2;
-  } else if (values.length == 7 && values[3][1] == '/' && values[0][1] == values[4][1] && values[1][1] == values[5][1] && values[2][1] == values[6][1]) {
-    spliceAt = 3;
-  } else if (values.length == 9 && values[4][1] == '/' && values[0][1] == values[5][1] && values[1][1] == values[6][1] && values[2][1] == values[7][1] && values[3][1] == values[8][1]) {
-    spliceAt = 4;
-  }
-
-  if (spliceAt) {
-    property.value.splice(spliceAt);
-    property.dirty = true;
-  }
-}
-
-/**
- * @param {string} name
- * @param {string} value
- * @param {Object} compatibility
- * @return {string}
- */
-function optimizeColors(name, value, compatibility) {
-  if (!value.match(/#|rgb|hsl/gi)) {
-    return shortenHex(value);
-  }
-
-  value = value
-    .replace(/(rgb|hsl)a?\((\-?\d+),(\-?\d+\%?),(\-?\d+\%?),(0*[1-9]+[0-9]*(\.?\d*)?)\)/gi, function (match, colorFn, p1, p2, p3, alpha) {
-      return (parseInt(alpha, 10) >= 1 ? colorFn + '(' + [p1,p2,p3].join(',') + ')' : match);
-    })
-    .replace(/rgb\((\-?\d+),(\-?\d+),(\-?\d+)\)/gi, function (match, red, green, blue) {
-      return shortenRgb(red, green, blue);
-    })
-    .replace(/hsl\((-?\d+),(-?\d+)%?,(-?\d+)%?\)/gi, function (match, hue, saturation, lightness) {
-      return shortenHsl(hue, saturation, lightness);
-    })
-    .replace(/(^|[^='"])#([0-9a-f]{6})/gi, function (match, prefix, color, at, inputValue) {
-      var suffix = inputValue[at + match.length];
-
-      if (suffix && HEX_VALUE_PATTERN.test(suffix)) {
-        return match;
-      } else if (color[0] == color[1] && color[2] == color[3] && color[4] == color[5]) {
-        return (prefix + '#' + color[0] + color[2] + color[4]).toLowerCase();
-      } else {
-        return (prefix + '#' + color).toLowerCase();
-      }
-    })
-    .replace(/(^|[^='"])#([0-9a-f]{3})/gi, function (match, prefix, color) {
-      return prefix + '#' + color.toLowerCase();
-    })
-    .replace(/(rgb|rgba|hsl|hsla)\(([^\)]+)\)/gi, function (match, colorFunction, colorDef) {
-      var tokens = colorDef.split(',');
-      var colorFnLowercase = colorFunction && colorFunction.toLowerCase();
-      var applies = (colorFnLowercase == 'hsl' && tokens.length == 3) ||
-        (colorFnLowercase == 'hsla' && tokens.length == 4) ||
-        (colorFnLowercase == 'rgb' && tokens.length === 3 && colorDef.indexOf('%') > 0) ||
-        (colorFnLowercase == 'rgba' && tokens.length == 4 && colorDef.indexOf('%') > 0);
-
-      if (!applies) {
-        return match;
-      }
-
-      if (tokens[1].indexOf('%') == -1) {
-        tokens[1] += '%';
-      }
-
-      if (tokens[2].indexOf('%') == -1) {
-        tokens[2] += '%';
-      }
-
-      return colorFunction + '(' + tokens.join(',') + ')';
-    });
-
-  if (compatibility.colors.opacity && name.indexOf('background') == -1) {
-    value = value.replace(/(?:rgba|hsla)\(0,0%?,0%?,0\)/g, function (match) {
-      if (split(value, ',').pop().indexOf('gradient(') > -1) {
-        return match;
-      }
-
-      return 'transparent';
-    });
-  }
-
-  return shortenHex(value);
-}
-
-function optimizeFilter(property) {
-  if (property.value.length == 1) {
-    property.value[0][1] = property.value[0][1].replace(/progid:DXImageTransform\.Microsoft\.(Alpha|Chroma)(\W)/, function (match, filter, suffix) {
-      return filter.toLowerCase() + suffix;
-    });
-  }
-
-  property.value[0][1] = property.value[0][1]
-    .replace(/,(\S)/g, ', $1')
-    .replace(/ ?= ?/g, '=');
-}
-
-function optimizeFontWeight(property, atIndex) {
-  var value = property.value[atIndex][1];
-
-  if (value == 'normal') {
-    value = '400';
-  } else if (value == 'bold') {
-    value = '700';
-  }
-
-  property.value[atIndex][1] = value;
-}
-
-function optimizeMultipleZeros(property) {
-  var values = property.value;
-  var spliceAt;
-
-  if (values.length == 4 && values[0][1] === '0' && values[1][1] === '0' && values[2][1] === '0' && values[3][1] === '0') {
-    if (property.name.indexOf('box-shadow') > -1) {
-      spliceAt = 2;
-    } else {
-      spliceAt = 1;
-    }
-  }
-
-  if (spliceAt) {
-    property.value.splice(spliceAt);
-    property.dirty = true;
-  }
-}
-
-function optimizeOutline(property) {
-  var values = property.value;
-
-  if (values.length == 1 && values[0][1] == 'none') {
-    values[0][1] = '0';
-  }
-}
-
-function optimizePixelLengths(_, value, compatibility) {
-  if (!WHOLE_PIXEL_VALUE.test(value)) {
-    return value;
-  }
-
-  return value.replace(WHOLE_PIXEL_VALUE, function (match, val) {
-    var newValue;
-    var intVal = parseInt(val);
-
-    if (intVal === 0) {
-      return match;
-    }
-
-    if (compatibility.properties.shorterLengthUnits && compatibility.units.pt && intVal * 3 % 4 === 0) {
-      newValue = intVal * 3 / 4 + 'pt';
-    }
-
-    if (compatibility.properties.shorterLengthUnits && compatibility.units.pc && intVal % 16 === 0) {
-      newValue = intVal / 16 + 'pc';
-    }
-
-    if (compatibility.properties.shorterLengthUnits && compatibility.units.in && intVal % 96 === 0) {
-      newValue = intVal / 96 + 'in';
-    }
-
-    if (newValue) {
-      newValue = match.substring(0, match.indexOf(val)) + newValue;
-    }
-
-    return newValue && newValue.length < match.length ? newValue : match;
-  });
-}
-
-function optimizePrecision(_, value, precisionOptions) {
-  if (!precisionOptions.enabled || value.indexOf('.') === -1) {
-    return value;
-  }
-
-  return value
-    .replace(precisionOptions.decimalPointMatcher, '$1$2$3')
-    .replace(precisionOptions.zeroMatcher, function (match, integerPart, fractionPart, unit) {
-      var multiplier = precisionOptions.units[unit].multiplier;
-      var parsedInteger = parseInt(integerPart);
-      var integer = isNaN(parsedInteger) ? 0 : parsedInteger;
-      var fraction = parseFloat(fractionPart);
-
-      return Math.round((integer + fraction) * multiplier) / multiplier + unit;
-    });
-}
-
-function optimizeTimeUnits(_, value) {
-  if (!TIME_VALUE.test(value))
-    return value;
-
-  return value.replace(TIME_VALUE, function (match, val, unit) {
-    var newValue;
-
-    if (unit == 'ms') {
-      newValue = parseInt(val) / 1000 + 's';
-    } else if (unit == 's') {
-      newValue = parseFloat(val) * 1000 + 'ms';
-    }
-
-    return newValue.length < match.length ? newValue : match;
-  });
-}
-
-function optimizeUnits(name, value, unitsRegexp) {
-  if (/^(?:\-moz\-calc|\-webkit\-calc|calc|rgb|hsl|rgba|hsla)\(/.test(value)) {
-    return value;
-  }
-
-  if (name == 'flex' || name == '-ms-flex' || name == '-webkit-flex' || name == 'flex-basis' || name == '-webkit-flex-basis') {
-    return value;
-  }
-
-  if (value.indexOf('%') > 0 && (name == 'height' || name == 'max-height' || name == 'width' || name == 'max-width')) {
-    return value;
-  }
-
-  return value
-    .replace(unitsRegexp, '$1' + '0' + '$2')
-    .replace(unitsRegexp, '$1' + '0' + '$2');
-}
-
-function optimizeWhitespace(name, value) {
-  if (name.indexOf('filter') > -1 || value.indexOf(' ') == -1 || value.indexOf('expression') === 0) {
-    return value;
-  }
-
-  if (value.indexOf(Marker.SINGLE_QUOTE) > -1 || value.indexOf(Marker.DOUBLE_QUOTE) > -1) {
-    return value;
-  }
-
-  value = value.replace(/\s+/g, ' ');
-
-  if (value.indexOf('calc') > -1) {
-    value = value.replace(/\) ?\/ ?/g, ')/ ');
-  }
-
-  return value
-    .replace(/(\(;?)\s+/g, '$1')
-    .replace(/\s+(;?\))/g, '$1')
-    .replace(/, /g, ',');
-}
-
-function optimizeZeroDegUnit(_, value) {
-  if (value.indexOf('0deg') == -1) {
-    return value;
-  }
-
-  return value.replace(/\(0deg\)/g, '(0)');
-}
-
-function optimizeZeroUnits(name, value) {
-  if (value.indexOf('0') == -1) {
-    return value;
-  }
-
-  if (value.indexOf('-') > -1) {
-    value = value
-      .replace(/([^\w\d\-]|^)\-0([^\.]|$)/g, '$10$2')
-      .replace(/([^\w\d\-]|^)\-0([^\.]|$)/g, '$10$2');
-  }
-
-  return value
-    .replace(/(^|\s)0+([1-9])/g, '$1$2')
-    .replace(/(^|\D)\.0+(\D|$)/g, '$10$2')
-    .replace(/(^|\D)\.0+(\D|$)/g, '$10$2')
-    .replace(/\.([1-9]*)0+(\D|$)/g, function (match, nonZeroPart, suffix) {
-      return (nonZeroPart.length > 0 ? '.' : '') + nonZeroPart + suffix;
-    })
-    .replace(/(^|\D)0\.(\d)/g, '$1.$2');
-}
-
-function removeQuotes(name, value) {
-  if (name == 'content' || name.indexOf('font-variation-settings') > -1 || name.indexOf('font-feature-settings') > -1 || name == 'grid' || name.indexOf('grid-') > -1) {
-    return value;
-  }
-
-  return QUOTED_BUT_SAFE_PATTERN.test(value) ?
-    value.substring(1, value.length - 1) :
-    value;
-}
-
-function removeUrlQuotes(value) {
-  return /^url\(['"].+['"]\)$/.test(value) && !/^url\(['"].*[\*\s\(\)'"].*['"]\)$/.test(value) && !/^url\(['"]data:[^;]+;charset/.test(value) ?
-    value.replace(/["']/g, '') :
-    value;
-}
-
-function transformValue(propertyName, propertyValue, rule, transformCallback) {
-  var selector = serializeRules(rule);
-  var transformedValue = transformCallback(propertyName, propertyValue, selector);
-
-  if (transformedValue === undefined) {
-    return propertyValue;
-  } else if (transformedValue === false) {
-    return IgnoreProperty;
-  } else {
-    return transformedValue;
-  }
-}
-
-//
-
-function optimizeBody(rule, properties, context) {
-  var options = context.options;
-  var levelOptions = options.level[OptimizationLevel.One];
-  var property, name, type, value;
-  var valueIsUrl;
-  var propertyToken;
-  var _properties = wrapForOptimizing(properties, true);
-
-  propertyLoop:
-  for (var i = 0, l = _properties.length; i < l; i++) {
-    property = _properties[i];
-    name = property.name;
-
-    if (!PROPERTY_NAME_PATTERN.test(name)) {
-      propertyToken = property.all[property.position];
-      context.warnings.push('Invalid property name \'' + name + '\' at ' + formatPosition(propertyToken[1][2][0]) + '. Ignoring.');
-      property.unused = true;
-    }
-
-    if (property.value.length === 0) {
-      propertyToken = property.all[property.position];
-      context.warnings.push('Empty property \'' + name + '\' at ' + formatPosition(propertyToken[1][2][0]) + '. Ignoring.');
-      property.unused = true;
-    }
-
-    if (property.hack && (
-        (property.hack[0] == Hack.ASTERISK || property.hack[0] == Hack.UNDERSCORE) && !options.compatibility.properties.iePrefixHack ||
-        property.hack[0] == Hack.BACKSLASH && !options.compatibility.properties.ieSuffixHack ||
-        property.hack[0] == Hack.BANG && !options.compatibility.properties.ieBangHack)) {
-      property.unused = true;
-    }
-
-    if (levelOptions.removeNegativePaddings && name.indexOf('padding') === 0 && (isNegative(property.value[0]) || isNegative(property.value[1]) || isNegative(property.value[2]) || isNegative(property.value[3]))) {
-      property.unused = true;
-    }
-
-    if (!options.compatibility.properties.ieFilters && isLegacyFilter(property)) {
-      property.unused = true;
-    }
-
-    if (property.unused) {
-      continue;
-    }
-
-    if (property.block) {
-      optimizeBody(rule, property.value[0][1], context);
-      continue;
-    }
-
-    if (VARIABLE_NAME_PATTERN.test(name)) {
-      continue;
-    }
-
-    for (var j = 0, m = property.value.length; j < m; j++) {
-      type = property.value[j][0];
-      value = property.value[j][1];
-      valueIsUrl = isUrl(value);
-
-      if (type == Token.PROPERTY_BLOCK) {
-        property.unused = true;
-        context.warnings.push('Invalid value token at ' + formatPosition(value[0][1][2][0]) + '. Ignoring.');
-        break;
-      }
-
-      if (valueIsUrl && !context.validator.isUrl(value)) {
-        property.unused = true;
-        context.warnings.push('Broken URL \'' + value + '\' at ' + formatPosition(property.value[j][2][0]) + '. Ignoring.');
-        break;
-      }
-
-      if (valueIsUrl) {
-        value = levelOptions.normalizeUrls ?
-          normalizeUrl(value) :
-          value;
-        value = !options.compatibility.properties.urlQuotes ?
-          removeUrlQuotes(value) :
-          value;
-      } else if (isQuoted(value) || isLocal(value)) {
-        value = levelOptions.removeQuotes ?
-          removeQuotes(name, value) :
-          value;
-      } else {
-        value = levelOptions.removeWhitespace ?
-          optimizeWhitespace(name, value) :
-          value;
-        value = optimizePrecision(name, value, options.precision);
-        value = optimizePixelLengths(name, value, options.compatibility);
-        value = levelOptions.replaceTimeUnits ?
-          optimizeTimeUnits(name, value) :
-          value;
-        value = levelOptions.replaceZeroUnits ?
-          optimizeZeroUnits(name, value) :
-          value;
-
-        if (options.compatibility.properties.zeroUnits) {
-          value = optimizeZeroDegUnit(name, value);
-          value = optimizeUnits(name, value, options.unitsRegexp);
-        }
-
-        if (options.compatibility.properties.colors) {
-          value = optimizeColors(name, value, options.compatibility);
-        }
-      }
-
-      value = transformValue(name, value, rule, levelOptions.transform);
-
-      if (value === IgnoreProperty) {
-        property.unused = true;
-        continue propertyLoop;
-      }
-
-      property.value[j][1] = value;
-    }
-
-    if (levelOptions.replaceMultipleZeros) {
-      optimizeMultipleZeros(property);
-    }
-
-    if (name == 'background' && levelOptions.optimizeBackground) {
-      optimizeBackground(property);
-    } else if (name.indexOf('border') === 0 && name.indexOf('radius') > 0 && levelOptions.optimizeBorderRadius) {
-      optimizeBorderRadius(property);
-    } else if (name == 'filter'&& levelOptions.optimizeFilter && options.compatibility.properties.ieFilters) {
-      optimizeFilter(property);
-    } else if (name == 'font-weight' && levelOptions.optimizeFontWeight) {
-      optimizeFontWeight(property, 0);
-    } else if (name == 'outline' && levelOptions.optimizeOutline) {
-      optimizeOutline(property);
-    }
-  }
-
-  restoreFromOptimizing(_properties);
-  removeUnused(_properties);
-  removeComments(properties, options);
-}
-
-function removeComments(tokens, options) {
-  var token;
-  var i;
-
-  for (i = 0; i < tokens.length; i++) {
-    token = tokens[i];
-
-    if (token[0] != Token.COMMENT) {
-      continue;
-    }
-
-    optimizeComment(token, options);
-
-    if (token[1].length === 0) {
-      tokens.splice(i, 1);
-      i--;
-    }
-  }
-}
-
-function optimizeComment(token, options) {
-  if (token[1][2] == Marker.EXCLAMATION && (options.level[OptimizationLevel.One].specialComments == 'all' || options.commentsKept < options.level[OptimizationLevel.One].specialComments)) {
-    options.commentsKept++;
-    return;
-  }
-
-  token[1] = [];
-}
-
-function cleanupCharsets(tokens) {
-  var hasCharset = false;
-
-  for (var i = 0, l = tokens.length; i < l; i++) {
-    var token = tokens[i];
-
-    if (token[0] != Token.AT_RULE)
-      continue;
-
-    if (!CHARSET_REGEXP.test(token[1]))
-      continue;
-
-    if (hasCharset || token[1].indexOf(CHARSET_TOKEN) == -1) {
-      tokens.splice(i, 1);
-      i--;
-      l--;
-    } else {
-      hasCharset = true;
-      tokens.splice(i, 1);
-      tokens.unshift([Token.AT_RULE, token[1].replace(CHARSET_REGEXP, CHARSET_TOKEN)]);
-    }
-  }
-}
-
-function buildUnitRegexp(options) {
-  var units = ['px', 'em', 'ex', 'cm', 'mm', 'in', 'pt', 'pc', '%'];
-  var otherUnits = ['ch', 'rem', 'vh', 'vm', 'vmax', 'vmin', 'vw'];
-
-  otherUnits.forEach(function (unit) {
-    if (options.compatibility.units[unit]) {
-      units.push(unit);
-    }
-  });
-
-  return new RegExp('(^|\\s|\\(|,)0(?:' + units.join('|') + ')(\\W|$)', 'g');
-}
-
-function buildPrecisionOptions(roundingPrecision) {
-  var precisionOptions = {
-    matcher: null,
-    units: {},
-  };
-  var optimizable = [];
-  var unit;
-  var value;
-
-  for (unit in roundingPrecision) {
-    value = roundingPrecision[unit];
-
-    if (value != DEFAULT_ROUNDING_PRECISION) {
-      precisionOptions.units[unit] = {};
-      precisionOptions.units[unit].value = value;
-      precisionOptions.units[unit].multiplier = Math.pow(10, value);
-
-      optimizable.push(unit);
-    }
-  }
-
-  if (optimizable.length > 0) {
-    precisionOptions.enabled = true;
-    precisionOptions.decimalPointMatcher = new RegExp('(\\d)\\.($|' + optimizable.join('|') + ')($|\W)', 'g');
-    precisionOptions.zeroMatcher = new RegExp('(\\d*)(\\.\\d+)(' + optimizable.join('|') + ')', 'g');
-  }
-
-  return precisionOptions;
-}
-
-function isImport(token) {
-  return IMPORT_PREFIX_PATTERN.test(token[1]);
-}
-
-function isLegacyFilter(property) {
-  var value;
-
-  if (property.name == 'filter' || property.name == '-ms-filter') {
-    value = property.value[0][1];
-
-    return value.indexOf('progid') > -1 ||
-      value.indexOf('alpha') === 0 ||
-      value.indexOf('chroma') === 0;
-  } else {
-    return false;
-  }
-}
-
-function level1Optimize(tokens, context) {
-  var options = context.options;
-  var levelOptions = options.level[OptimizationLevel.One];
-  var ie7Hack = options.compatibility.selectors.ie7Hack;
-  var adjacentSpace = options.compatibility.selectors.adjacentSpace;
-  var spaceAfterClosingBrace = options.compatibility.properties.spaceAfterClosingBrace;
-  var format = options.format;
-  var mayHaveCharset = false;
-  var afterRules = false;
-
-  options.unitsRegexp = options.unitsRegexp || buildUnitRegexp(options);
-  options.precision = options.precision || buildPrecisionOptions(levelOptions.roundingPrecision);
-  options.commentsKept = options.commentsKept || 0;
-
-  for (var i = 0, l = tokens.length; i < l; i++) {
-    var token = tokens[i];
-
-    switch (token[0]) {
-      case Token.AT_RULE:
-        token[1] = isImport(token) && afterRules ? '' : token[1];
-        token[1] = levelOptions.tidyAtRules ? tidyAtRule(token[1]) : token[1];
-        mayHaveCharset = true;
-        break;
-      case Token.AT_RULE_BLOCK:
-        optimizeBody(token[1], token[2], context);
-        afterRules = true;
-        break;
-      case Token.NESTED_BLOCK:
-        token[1] = levelOptions.tidyBlockScopes ? tidyBlock(token[1], spaceAfterClosingBrace) : token[1];
-        level1Optimize(token[2], context);
-        afterRules = true;
-        break;
-      case Token.COMMENT:
-        optimizeComment(token, options);
-        break;
-      case Token.RULE:
-        token[1] = levelOptions.tidySelectors ? tidyRules(token[1], !ie7Hack, adjacentSpace, format, context.warnings) : token[1];
-        token[1] = token[1].length > 1 ? sortSelectors(token[1], levelOptions.selectorsSortingMethod) : token[1];
-        optimizeBody(token[1], token[2], context);
-        afterRules = true;
-        break;
-    }
-
-    if (token[0] == Token.COMMENT && token[1].length === 0 || levelOptions.removeEmpty && (token[1].length === 0 || (token[2] && token[2].length === 0))) {
-      tokens.splice(i, 1);
-      i--;
-      l--;
-    }
-  }
-
-  if (levelOptions.cleanupCharsets && mayHaveCharset) {
-    cleanupCharsets(tokens);
-  }
-
-  return tokens;
-}
-
-module.exports = level1Optimize;

node_modules/clean-css/lib/optimizer/level-1/shorten-hex.js

@@ -1,189 +0,0 @@
-var COLORS = {
-  aliceblue: '#f0f8ff',
-  antiquewhite: '#faebd7',
-  aqua: '#0ff',
-  aquamarine: '#7fffd4',
-  azure: '#f0ffff',
-  beige: '#f5f5dc',
-  bisque: '#ffe4c4',
-  black: '#000',
-  blanchedalmond: '#ffebcd',
-  blue: '#00f',
-  blueviolet: '#8a2be2',
-  brown: '#a52a2a',
-  burlywood: '#deb887',
-  cadetblue: '#5f9ea0',
-  chartreuse: '#7fff00',
-  chocolate: '#d2691e',
-  coral: '#ff7f50',
-  cornflowerblue: '#6495ed',
-  cornsilk: '#fff8dc',
-  crimson: '#dc143c',
-  cyan: '#0ff',
-  darkblue: '#00008b',
-  darkcyan: '#008b8b',
-  darkgoldenrod: '#b8860b',
-  darkgray: '#a9a9a9',
-  darkgreen: '#006400',
-  darkgrey: '#a9a9a9',
-  darkkhaki: '#bdb76b',
-  darkmagenta: '#8b008b',
-  darkolivegreen: '#556b2f',
-  darkorange: '#ff8c00',
-  darkorchid: '#9932cc',
-  darkred: '#8b0000',
-  darksalmon: '#e9967a',
-  darkseagreen: '#8fbc8f',
-  darkslateblue: '#483d8b',
-  darkslategray: '#2f4f4f',
-  darkslategrey: '#2f4f4f',
-  darkturquoise: '#00ced1',
-  darkviolet: '#9400d3',
-  deeppink: '#ff1493',
-  deepskyblue: '#00bfff',
-  dimgray: '#696969',
-  dimgrey: '#696969',
-  dodgerblue: '#1e90ff',
-  firebrick: '#b22222',
-  floralwhite: '#fffaf0',
-  forestgreen: '#228b22',
-  fuchsia: '#f0f',
-  gainsboro: '#dcdcdc',
-  ghostwhite: '#f8f8ff',
-  gold: '#ffd700',
-  goldenrod: '#daa520',
-  gray: '#808080',
-  green: '#008000',
-  greenyellow: '#adff2f',
-  grey: '#808080',
-  honeydew: '#f0fff0',
-  hotpink: '#ff69b4',
-  indianred: '#cd5c5c',
-  indigo: '#4b0082',
-  ivory: '#fffff0',
-  khaki: '#f0e68c',
-  lavender: '#e6e6fa',
-  lavenderblush: '#fff0f5',
-  lawngreen: '#7cfc00',
-  lemonchiffon: '#fffacd',
-  lightblue: '#add8e6',
-  lightcoral: '#f08080',
-  lightcyan: '#e0ffff',
-  lightgoldenrodyellow: '#fafad2',
-  lightgray: '#d3d3d3',
-  lightgreen: '#90ee90',
-  lightgrey: '#d3d3d3',
-  lightpink: '#ffb6c1',
-  lightsalmon: '#ffa07a',
-  lightseagreen: '#20b2aa',
-  lightskyblue: '#87cefa',
-  lightslategray: '#778899',
-  lightslategrey: '#778899',
-  lightsteelblue: '#b0c4de',
-  lightyellow: '#ffffe0',
-  lime: '#0f0',
-  limegreen: '#32cd32',
-  linen: '#faf0e6',
-  magenta: '#ff00ff',
-  maroon: '#800000',
-  mediumaquamarine: '#66cdaa',
-  mediumblue: '#0000cd',
-  mediumorchid: '#ba55d3',
-  mediumpurple: '#9370db',
-  mediumseagreen: '#3cb371',
-  mediumslateblue: '#7b68ee',
-  mediumspringgreen: '#00fa9a',
-  mediumturquoise: '#48d1cc',
-  mediumvioletred: '#c71585',
-  midnightblue: '#191970',
-  mintcream: '#f5fffa',
-  mistyrose: '#ffe4e1',
-  moccasin: '#ffe4b5',
-  navajowhite: '#ffdead',
-  navy: '#000080',
-  oldlace: '#fdf5e6',
-  olive: '#808000',
-  olivedrab: '#6b8e23',
-  orange: '#ffa500',
-  orangered: '#ff4500',
-  orchid: '#da70d6',
-  palegoldenrod: '#eee8aa',
-  palegreen: '#98fb98',
-  paleturquoise: '#afeeee',
-  palevioletred: '#db7093',
-  papayawhip: '#ffefd5',
-  peachpuff: '#ffdab9',
-  peru: '#cd853f',
-  pink: '#ffc0cb',
-  plum: '#dda0dd',
-  powderblue: '#b0e0e6',
-  purple: '#800080',
-  rebeccapurple: '#663399',
-  red: '#f00',
-  rosybrown: '#bc8f8f',
-  royalblue: '#4169e1',
-  saddlebrown: '#8b4513',
-  salmon: '#fa8072',
-  sandybrown: '#f4a460',
-  seagreen: '#2e8b57',
-  seashell: '#fff5ee',
-  sienna: '#a0522d',
-  silver: '#c0c0c0',
-  skyblue: '#87ceeb',
-  slateblue: '#6a5acd',
-  slategray: '#708090',
-  slategrey: '#708090',
-  snow: '#fffafa',
-  springgreen: '#00ff7f',
-  steelblue: '#4682b4',
-  tan: '#d2b48c',
-  teal: '#008080',
-  thistle: '#d8bfd8',
-  tomato: '#ff6347',
-  turquoise: '#40e0d0',
-  violet: '#ee82ee',
-  wheat: '#f5deb3',
-  white: '#fff',
-  whitesmoke: '#f5f5f5',
-  yellow: '#ff0',
-  yellowgreen: '#9acd32'
-};
-
-var toHex = {};
-var toName = {};
-
-for (var name in COLORS) {
-  var hex = COLORS[name];
-
-  if (name.length < hex.length) {
-    toName[hex] = name;
-  } else {
-    toHex[name] = hex;
-  }
-}
-
-var toHexPattern = new RegExp('(^| |,|\\))(' + Object.keys(toHex).join('|') + ')( |,|\\)|$)', 'ig');
-var toNamePattern = new RegExp('(' + Object.keys(toName).join('|') + ')([^a-f0-9]|$)', 'ig');
-
-function hexConverter(match, prefix, colorValue, suffix) {
-  return prefix + toHex[colorValue.toLowerCase()] + suffix;
-}
-
-function nameConverter(match, colorValue, suffix) {
-  return toName[colorValue.toLowerCase()] + suffix;
-}
-
-function shortenHex(value) {
-  var hasHex = value.indexOf('#') > -1;
-  var shortened = value.replace(toHexPattern, hexConverter);
-
-  if (shortened != value) {
-    shortened = shortened.replace(toHexPattern, hexConverter);
-  }
-
-  return hasHex ?
-    shortened.replace(toNamePattern, nameConverter) :
-    shortened;
-}
-
-module.exports = shortenHex;

node_modules/clean-css/lib/optimizer/level-1/shorten-hsl.js

@@ -1,61 +0,0 @@
-// HSL to RGB converter. Both methods adapted from:
-// http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript
-
-function hslToRgb(h, s, l) {
-  var r, g, b;
-
-  // normalize hue orientation b/w 0 and 360 degrees
-  h = h % 360;
-  if (h < 0)
-    h += 360;
-  h = ~~h / 360;
-
-  if (s < 0)
-    s = 0;
-  else if (s > 100)
-    s = 100;
-  s = ~~s / 100;
-
-  if (l < 0)
-    l = 0;
-  else if (l > 100)
-    l = 100;
-  l = ~~l / 100;
-
-  if (s === 0) {
-    r = g = b = l; // achromatic
-  } else {
-    var q = l < 0.5 ?
-      l * (1 + s) :
-      l + s - l * s;
-    var p = 2 * l - q;
-    r = hueToRgb(p, q, h + 1/3);
-    g = hueToRgb(p, q, h);
-    b = hueToRgb(p, q, h - 1/3);
-  }
-
-  return [~~(r * 255), ~~(g * 255), ~~(b * 255)];
-}
-
-function hueToRgb(p, q, t) {
-  if (t < 0) t += 1;
-  if (t > 1) t -= 1;
-  if (t < 1/6) return p + (q - p) * 6 * t;
-  if (t < 1/2) return q;
-  if (t < 2/3) return p + (q - p) * (2/3 - t) * 6;
-  return p;
-}
-
-function shortenHsl(hue, saturation, lightness) {
-  var asRgb = hslToRgb(hue, saturation, lightness);
-  var redAsHex = asRgb[0].toString(16);
-  var greenAsHex = asRgb[1].toString(16);
-  var blueAsHex = asRgb[2].toString(16);
-
-  return '#' +
-    ((redAsHex.length == 1 ? '0' : '') + redAsHex) +
-    ((greenAsHex.length == 1 ? '0' : '') + greenAsHex) +
-    ((blueAsHex.length == 1 ? '0' : '') + blueAsHex);
-}
-
-module.exports = shortenHsl;

node_modules/clean-css/lib/optimizer/level-1/shorten-rgb.js

@@ -1,10 +0,0 @@
-function shortenRgb(red, green, blue) {
-  var normalizedRed = Math.max(0, Math.min(parseInt(red), 255));
-  var normalizedGreen = Math.max(0, Math.min(parseInt(green), 255));
-  var normalizedBlue = Math.max(0, Math.min(parseInt(blue), 255));
-
-  // Credit: Asen  http://jsbin.com/UPUmaGOc/2/edit?js,console
-  return '#' + ('00000' + (normalizedRed << 16 | normalizedGreen << 8 | normalizedBlue).toString(16)).slice(-6);
-}
-
-module.exports = shortenRgb;

node_modules/clean-css/lib/optimizer/level-1/sort-selectors.js

@@ -1,23 +0,0 @@
-var naturalCompare = require('../../utils/natural-compare');
-
-function naturalSorter(scope1, scope2) {
-  return naturalCompare(scope1[1], scope2[1]);
-}
-
-function standardSorter(scope1, scope2) {
-  return scope1[1] > scope2[1] ? 1 : -1;
-}
-
-function sortSelectors(selectors, method) {
-  switch (method) {
-    case 'natural':
-      return selectors.sort(naturalSorter);
-    case 'standard':
-      return selectors.sort(standardSorter);
-    case 'none':
-    case false:
-      return selectors;
-  }
-}
-
-module.exports = sortSelectors;

node_modules/clean-css/lib/optimizer/level-1/tidy-at-rule.js

@@ -1,9 +0,0 @@
-function tidyAtRule(value) {
-  return value
-    .replace(/\s+/g, ' ')
-    .replace(/url\(\s+/g, 'url(')
-    .replace(/\s+\)/g, ')')
-    .trim();
-}
-
-module.exports = tidyAtRule;

node_modules/clean-css/lib/optimizer/level-1/tidy-block.js

@@ -1,23 +0,0 @@
-var SUPPORTED_COMPACT_BLOCK_MATCHER = /^@media\W/;
-
-function tidyBlock(values, spaceAfterClosingBrace) {
-  var withoutSpaceAfterClosingBrace;
-  var i;
-
-  for (i = values.length - 1; i >= 0; i--) {
-    withoutSpaceAfterClosingBrace = !spaceAfterClosingBrace && SUPPORTED_COMPACT_BLOCK_MATCHER.test(values[i][1]);
-
-    values[i][1] = values[i][1]
-      .replace(/\n|\r\n/g, ' ')
-      .replace(/\s+/g, ' ')
-      .replace(/(,|:|\() /g, '$1')
-      .replace(/ \)/g, ')')
-      .replace(/'([a-zA-Z][a-zA-Z\d\-_]+)'/, '$1')
-      .replace(/"([a-zA-Z][a-zA-Z\d\-_]+)"/, '$1')
-      .replace(withoutSpaceAfterClosingBrace ? /\) /g : null, ')');
-  }
-
-  return values;
-}
-
-module.exports = tidyBlock;

node_modules/clean-css/lib/optimizer/level-1/tidy-rules.js

@@ -1,213 +0,0 @@
-var Spaces = require('../../options/format').Spaces;
-var Marker = require('../../tokenizer/marker');
-var formatPosition = require('../../utils/format-position');
-
-var CASE_ATTRIBUTE_PATTERN = /[\s"'][iI]\s*\]/;
-var CASE_RESTORE_PATTERN = /([\d\w])([iI])\]/g;
-var DOUBLE_QUOTE_CASE_PATTERN = /="([a-zA-Z][a-zA-Z\d\-_]+)"([iI])/g;
-var DOUBLE_QUOTE_PATTERN = /="([a-zA-Z][a-zA-Z\d\-_]+)"(\s|\])/g;
-var HTML_COMMENT_PATTERN = /^(?:(?:<!--|-->)\s*)+/;
-var SINGLE_QUOTE_CASE_PATTERN = /='([a-zA-Z][a-zA-Z\d\-_]+)'([iI])/g;
-var SINGLE_QUOTE_PATTERN = /='([a-zA-Z][a-zA-Z\d\-_]+)'(\s|\])/g;
-var RELATION_PATTERN = /[>\+~]/;
-var WHITESPACE_PATTERN = /\s/;
-
-var ASTERISK_PLUS_HTML_HACK = '*+html ';
-var ASTERISK_FIRST_CHILD_PLUS_HTML_HACK = '*:first-child+html ';
-var LESS_THAN = '<';
-
-function hasInvalidCharacters(value) {
-  var isEscaped;
-  var isInvalid = false;
-  var character;
-  var isQuote = false;
-  var i, l;
-
-  for (i = 0, l = value.length; i < l; i++) {
-    character = value[i];
-
-    if (isEscaped) {
-      // continue as always
-    } else if (character == Marker.SINGLE_QUOTE || character == Marker.DOUBLE_QUOTE) {
-      isQuote = !isQuote;
-    } else if (!isQuote && (character == Marker.CLOSE_CURLY_BRACKET || character == Marker.EXCLAMATION || character == LESS_THAN || character == Marker.SEMICOLON)) {
-      isInvalid = true;
-      break;
-    } else if (!isQuote && i === 0 && RELATION_PATTERN.test(character)) {
-      isInvalid = true;
-      break;
-    }
-
-    isEscaped = character == Marker.BACK_SLASH;
-  }
-
-  return isInvalid;
-}
-
-function removeWhitespace(value, format) {
-  var stripped = [];
-  var character;
-  var isNewLineNix;
-  var isNewLineWin;
-  var isEscaped;
-  var wasEscaped;
-  var isQuoted;
-  var isSingleQuoted;
-  var isDoubleQuoted;
-  var isAttribute;
-  var isRelation;
-  var isWhitespace;
-  var roundBracketLevel = 0;
-  var wasRelation = false;
-  var wasWhitespace = false;
-  var withCaseAttribute = CASE_ATTRIBUTE_PATTERN.test(value);
-  var spaceAroundRelation = format && format.spaces[Spaces.AroundSelectorRelation];
-  var i, l;
-
-  for (i = 0, l = value.length; i < l; i++) {
-    character = value[i];
-
-    isNewLineNix = character == Marker.NEW_LINE_NIX;
-    isNewLineWin = character == Marker.NEW_LINE_NIX && value[i - 1] == Marker.CARRIAGE_RETURN;
-    isQuoted = isSingleQuoted || isDoubleQuoted;
-    isRelation = !isAttribute && !isEscaped && roundBracketLevel === 0 && RELATION_PATTERN.test(character);
-    isWhitespace = WHITESPACE_PATTERN.test(character);
-
-    if (wasEscaped && isQuoted && isNewLineWin) {
-      // swallow escaped new windows lines in comments
-      stripped.pop();
-      stripped.pop();
-    } else if (isEscaped && isQuoted && isNewLineNix) {
-      // swallow escaped new *nix lines in comments
-      stripped.pop();
-    } else if (isEscaped) {
-      stripped.push(character);
-    } else if (character == Marker.OPEN_SQUARE_BRACKET && !isQuoted) {
-      stripped.push(character);
-      isAttribute = true;
-    } else if (character == Marker.CLOSE_SQUARE_BRACKET && !isQuoted) {
-      stripped.push(character);
-      isAttribute = false;
-    } else if (character == Marker.OPEN_ROUND_BRACKET && !isQuoted) {
-      stripped.push(character);
-      roundBracketLevel++;
-    } else if (character == Marker.CLOSE_ROUND_BRACKET && !isQuoted) {
-      stripped.push(character);
-      roundBracketLevel--;
-    } else if (character == Marker.SINGLE_QUOTE && !isQuoted) {
-      stripped.push(character);
-      isSingleQuoted = true;
-    } else if (character == Marker.DOUBLE_QUOTE && !isQuoted) {
-      stripped.push(character);
-      isDoubleQuoted = true;
-    } else if (character == Marker.SINGLE_QUOTE && isQuoted) {
-      stripped.push(character);
-      isSingleQuoted = false;
-    } else if (character == Marker.DOUBLE_QUOTE && isQuoted) {
-      stripped.push(character);
-      isDoubleQuoted = false;
-    } else if (isWhitespace && wasRelation && !spaceAroundRelation) {
-      continue;
-    } else if (!isWhitespace && wasRelation && spaceAroundRelation) {
-      stripped.push(Marker.SPACE);
-      stripped.push(character);
-    } else if (isWhitespace && (isAttribute || roundBracketLevel > 0) && !isQuoted) {
-      // skip space
-    } else if (isWhitespace && wasWhitespace && !isQuoted) {
-      // skip extra space
-    } else if ((isNewLineWin || isNewLineNix) && (isAttribute || roundBracketLevel > 0) && isQuoted) {
-      // skip newline
-    } else if (isRelation && wasWhitespace && !spaceAroundRelation) {
-      stripped.pop();
-      stripped.push(character);
-    } else if (isRelation && !wasWhitespace && spaceAroundRelation) {
-      stripped.push(Marker.SPACE);
-      stripped.push(character);
-    } else if (isWhitespace) {
-      stripped.push(Marker.SPACE);
-    } else {
-      stripped.push(character);
-    }
-
-    wasEscaped = isEscaped;
-    isEscaped = character == Marker.BACK_SLASH;
-    wasRelation = isRelation;
-    wasWhitespace = isWhitespace;
-  }
-
-  return withCaseAttribute ?
-    stripped.join('').replace(CASE_RESTORE_PATTERN, '$1 $2]') :
-    stripped.join('');
-}
-
-function removeQuotes(value) {
-  if (value.indexOf('\'') == -1 && value.indexOf('"') == -1) {
-    return value;
-  }
-
-  return value
-    .replace(SINGLE_QUOTE_CASE_PATTERN, '=$1 $2')
-    .replace(SINGLE_QUOTE_PATTERN, '=$1$2')
-    .replace(DOUBLE_QUOTE_CASE_PATTERN, '=$1 $2')
-    .replace(DOUBLE_QUOTE_PATTERN, '=$1$2');
-}
-
-function tidyRules(rules, removeUnsupported, adjacentSpace, format, warnings) {
-  var list = [];
-  var repeated = [];
-
-  function removeHTMLComment(rule, match) {
-    warnings.push('HTML comment \'' + match + '\' at ' + formatPosition(rule[2][0]) + '. Removing.');
-    return '';
-  }
-
-  for (var i = 0, l = rules.length; i < l; i++) {
-    var rule = rules[i];
-    var reduced = rule[1];
-
-    reduced = reduced.replace(HTML_COMMENT_PATTERN, removeHTMLComment.bind(null, rule));
-
-    if (hasInvalidCharacters(reduced)) {
-      warnings.push('Invalid selector \'' + rule[1] + '\' at ' + formatPosition(rule[2][0]) + '. Ignoring.');
-      continue;
-    }
-
-    reduced = removeWhitespace(reduced, format);
-    reduced = removeQuotes(reduced);
-
-    if (adjacentSpace && reduced.indexOf('nav') > 0) {
-      reduced = reduced.replace(/\+nav(\S|$)/, '+ nav$1');
-    }
-
-    if (removeUnsupported && reduced.indexOf(ASTERISK_PLUS_HTML_HACK) > -1) {
-      continue;
-    }
-
-    if (removeUnsupported && reduced.indexOf(ASTERISK_FIRST_CHILD_PLUS_HTML_HACK) > -1) {
-      continue;
-    }
-
-    if (reduced.indexOf('*') > -1) {
-      reduced = reduced
-        .replace(/\*([:#\.\[])/g, '$1')
-        .replace(/^(\:first\-child)?\+html/, '*$1+html');
-    }
-
-    if (repeated.indexOf(reduced) > -1) {
-      continue;
-    }
-
-    rule[1] = reduced;
-    repeated.push(reduced);
-    list.push(rule);
-  }
-
-  if (list.length == 1 && list[0][1].length === 0) {
-    warnings.push('Empty selector \'' + list[0][1] + '\' at ' + formatPosition(list[0][2][0]) + '. Ignoring.');
-    list = [];
-  }
-
-  return list;
-}
-
-module.exports = tidyRules;

node_modules/clean-css/lib/optimizer/level-2/break-up.js

@@ -1,644 +0,0 @@
-var InvalidPropertyError = require('./invalid-property-error');
-
-var wrapSingle = require('../wrap-for-optimizing').single;
-
-var Token = require('../../tokenizer/token');
-var Marker = require('../../tokenizer/marker');
-
-var formatPosition = require('../../utils/format-position');
-
-function _anyIsInherit(values) {
-  var i, l;
-
-  for (i = 0, l = values.length; i < l; i++) {
-    if (values[i][1] == 'inherit') {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-function _colorFilter(validator) {
-  return function (value) {
-    return value[1] == 'invert' || validator.isColor(value[1]) || validator.isPrefixed(value[1]);
-  };
-}
-
-function _styleFilter(validator) {
-  return function (value) {
-    return value[1] != 'inherit' && validator.isStyleKeyword(value[1]) && !validator.isColorFunction(value[1]);
-  };
-}
-
-function _wrapDefault(name, property, compactable) {
-  var descriptor = compactable[name];
-  if (descriptor.doubleValues && descriptor.defaultValue.length == 2) {
-    return wrapSingle([
-      Token.PROPERTY,
-      [Token.PROPERTY_NAME, name],
-      [Token.PROPERTY_VALUE, descriptor.defaultValue[0]],
-      [Token.PROPERTY_VALUE, descriptor.defaultValue[1]]
-    ]);
-  } else if (descriptor.doubleValues && descriptor.defaultValue.length == 1) {
-    return wrapSingle([
-      Token.PROPERTY,
-      [Token.PROPERTY_NAME, name],
-      [Token.PROPERTY_VALUE, descriptor.defaultValue[0]]
-    ]);
-  } else {
-    return wrapSingle([
-      Token.PROPERTY,
-      [Token.PROPERTY_NAME, name],
-      [Token.PROPERTY_VALUE, descriptor.defaultValue]
-    ]);
-  }
-}
-
-function _widthFilter(validator) {
-  return function (value) {
-    return value[1] != 'inherit' &&
-      (validator.isWidth(value[1]) || validator.isUnit(value[1]) && !validator.isDynamicUnit(value[1])) &&
-      !validator.isStyleKeyword(value[1]) &&
-      !validator.isColorFunction(value[1]);
-  };
-}
-
-function animation(property, compactable, validator) {
-  var duration = _wrapDefault(property.name + '-duration', property, compactable);
-  var timing = _wrapDefault(property.name + '-timing-function', property, compactable);
-  var delay = _wrapDefault(property.name + '-delay', property, compactable);
-  var iteration = _wrapDefault(property.name + '-iteration-count', property, compactable);
-  var direction = _wrapDefault(property.name + '-direction', property, compactable);
-  var fill = _wrapDefault(property.name + '-fill-mode', property, compactable);
-  var play = _wrapDefault(property.name + '-play-state', property, compactable);
-  var name = _wrapDefault(property.name + '-name', property, compactable);
-  var components = [duration, timing, delay, iteration, direction, fill, play, name];
-  var values = property.value;
-  var value;
-  var durationSet = false;
-  var timingSet = false;
-  var delaySet = false;
-  var iterationSet = false;
-  var directionSet = false;
-  var fillSet = false;
-  var playSet = false;
-  var nameSet = false;
-  var i;
-  var l;
-
-  if (property.value.length == 1 && property.value[0][1] == 'inherit') {
-    duration.value = timing.value = delay.value = iteration.value = direction.value = fill.value = play.value = name.value = property.value;
-    return components;
-  }
-
-  if (values.length > 1 && _anyIsInherit(values)) {
-    throw new InvalidPropertyError('Invalid animation values at ' + formatPosition(values[0][2][0]) + '. Ignoring.');
-  }
-
-  for (i = 0, l = values.length; i < l; i++) {
-    value = values[i];
-
-    if (validator.isTime(value[1]) && !durationSet) {
-      duration.value = [value];
-      durationSet = true;
-    } else if (validator.isTime(value[1]) && !delaySet) {
-      delay.value = [value];
-      delaySet = true;
-    } else if ((validator.isGlobal(value[1]) || validator.isTimingFunction(value[1])) && !timingSet) {
-      timing.value = [value];
-      timingSet = true;
-    } else if ((validator.isAnimationIterationCountKeyword(value[1]) || validator.isPositiveNumber(value[1])) && !iterationSet) {
-      iteration.value = [value];
-      iterationSet = true;
-    } else if (validator.isAnimationDirectionKeyword(value[1]) && !directionSet) {
-      direction.value = [value];
-      directionSet = true;
-    } else if (validator.isAnimationFillModeKeyword(value[1]) && !fillSet) {
-      fill.value = [value];
-      fillSet = true;
-    } else if (validator.isAnimationPlayStateKeyword(value[1]) && !playSet) {
-      play.value = [value];
-      playSet = true;
-    } else if ((validator.isAnimationNameKeyword(value[1]) || validator.isIdentifier(value[1])) && !nameSet) {
-      name.value = [value];
-      nameSet = true;
-    } else {
-      throw new InvalidPropertyError('Invalid animation value at ' + formatPosition(value[2][0]) + '. Ignoring.');
-    }
-  }
-
-  return components;
-}
-
-function background(property, compactable, validator) {
-  var image = _wrapDefault('background-image', property, compactable);
-  var position = _wrapDefault('background-position', property, compactable);
-  var size = _wrapDefault('background-size', property, compactable);
-  var repeat = _wrapDefault('background-repeat', property, compactable);
-  var attachment = _wrapDefault('background-attachment', property, compactable);
-  var origin = _wrapDefault('background-origin', property, compactable);
-  var clip = _wrapDefault('background-clip', property, compactable);
-  var color = _wrapDefault('background-color', property, compactable);
-  var components = [image, position, size, repeat, attachment, origin, clip, color];
-  var values = property.value;
-
-  var positionSet = false;
-  var clipSet = false;
-  var originSet = false;
-  var repeatSet = false;
-
-  var anyValueSet = false;
-
-  if (property.value.length == 1 && property.value[0][1] == 'inherit') {
-    // NOTE: 'inherit' is not a valid value for background-attachment
-    color.value = image.value =  repeat.value = position.value = size.value = origin.value = clip.value = property.value;
-    return components;
-  }
-
-  if (property.value.length == 1 && property.value[0][1] == '0 0') {
-    return components;
-  }
-
-  for (var i = values.length - 1; i >= 0; i--) {
-    var value = values[i];
-
-    if (validator.isBackgroundAttachmentKeyword(value[1])) {
-      attachment.value = [value];
-      anyValueSet = true;
-    } else if (validator.isBackgroundClipKeyword(value[1]) || validator.isBackgroundOriginKeyword(value[1])) {
-      if (clipSet) {
-        origin.value = [value];
-        originSet = true;
-      } else {
-        clip.value = [value];
-        clipSet = true;
-      }
-      anyValueSet = true;
-    } else if (validator.isBackgroundRepeatKeyword(value[1])) {
-      if (repeatSet) {
-        repeat.value.unshift(value);
-      } else {
-        repeat.value = [value];
-        repeatSet = true;
-      }
-      anyValueSet = true;
-    } else if (validator.isBackgroundPositionKeyword(value[1]) || validator.isBackgroundSizeKeyword(value[1]) || validator.isUnit(value[1]) || validator.isDynamicUnit(value[1])) {
-      if (i > 0) {
-        var previousValue = values[i - 1];
-
-        if (previousValue[1] == Marker.FORWARD_SLASH) {
-          size.value = [value];
-        } else if (i > 1 && values[i - 2][1] == Marker.FORWARD_SLASH) {
-          size.value = [previousValue, value];
-          i -= 2;
-        } else {
-          if (!positionSet)
-            position.value = [];
-
-          position.value.unshift(value);
-          positionSet = true;
-        }
-      } else {
-        if (!positionSet)
-          position.value = [];
-
-        position.value.unshift(value);
-        positionSet = true;
-      }
-      anyValueSet = true;
-    } else if ((color.value[0][1] == compactable[color.name].defaultValue || color.value[0][1] == 'none') && (validator.isColor(value[1]) || validator.isPrefixed(value[1]))) {
-      color.value = [value];
-      anyValueSet = true;
-    } else if (validator.isUrl(value[1]) || validator.isFunction(value[1])) {
-      image.value = [value];
-      anyValueSet = true;
-    }
-  }
-
-  if (clipSet && !originSet)
-    origin.value = clip.value.slice(0);
-
-  if (!anyValueSet) {
-    throw new InvalidPropertyError('Invalid background value at ' + formatPosition(values[0][2][0]) + '. Ignoring.');
-  }
-
-  return components;
-}
-
-function borderRadius(property, compactable) {
-  var values = property.value;
-  var splitAt = -1;
-
-  for (var i = 0, l = values.length; i < l; i++) {
-    if (values[i][1] == Marker.FORWARD_SLASH) {
-      splitAt = i;
-      break;
-    }
-  }
-
-  if (splitAt === 0 || splitAt === values.length - 1) {
-    throw new InvalidPropertyError('Invalid border-radius value at ' + formatPosition(values[0][2][0]) + '. Ignoring.');
-  }
-
-  var target = _wrapDefault(property.name, property, compactable);
-  target.value = splitAt > -1 ?
-    values.slice(0, splitAt) :
-    values.slice(0);
-  target.components = fourValues(target, compactable);
-
-  var remainder = _wrapDefault(property.name, property, compactable);
-  remainder.value = splitAt > -1 ?
-    values.slice(splitAt + 1) :
-    values.slice(0);
-  remainder.components = fourValues(remainder, compactable);
-
-  for (var j = 0; j < 4; j++) {
-    target.components[j].multiplex = true;
-    target.components[j].value = target.components[j].value.concat(remainder.components[j].value);
-  }
-
-  return target.components;
-}
-
-function font(property, compactable, validator) {
-  var style = _wrapDefault('font-style', property, compactable);
-  var variant = _wrapDefault('font-variant', property, compactable);
-  var weight = _wrapDefault('font-weight', property, compactable);
-  var stretch = _wrapDefault('font-stretch', property, compactable);
-  var size = _wrapDefault('font-size', property, compactable);
-  var height = _wrapDefault('line-height', property, compactable);
-  var family = _wrapDefault('font-family', property, compactable);
-  var components = [style, variant, weight, stretch, size, height, family];
-  var values = property.value;
-  var fuzzyMatched = 4; // style, variant, weight, and stretch
-  var index = 0;
-  var isStretchSet = false;
-  var isStretchValid;
-  var isStyleSet = false;
-  var isStyleValid;
-  var isVariantSet = false;
-  var isVariantValid;
-  var isWeightSet = false;
-  var isWeightValid;
-  var isSizeSet = false;
-  var appendableFamilyName = false;
-
-  if (!values[index]) {
-    throw new InvalidPropertyError('Missing font values at ' + formatPosition(property.all[property.position][1][2][0]) + '. Ignoring.');
-  }
-
-  if (values.length == 1 && values[0][1] == 'inherit') {
-    style.value = variant.value = weight.value = stretch.value = size.value = height.value = family.value = values;
-    return components;
-  }
-
-  if (values.length == 1 && (validator.isFontKeyword(values[0][1]) || validator.isGlobal(values[0][1]) || validator.isPrefixed(values[0][1]))) {
-    values[0][1] = Marker.INTERNAL + values[0][1];
-    style.value = variant.value = weight.value = stretch.value = size.value = height.value = family.value = values;
-    return components;
-  }
-
-  if (values.length < 2 || !_anyIsFontSize(values, validator) || !_anyIsFontFamily(values, validator)) {
-    throw new InvalidPropertyError('Invalid font values at ' + formatPosition(property.all[property.position][1][2][0]) + '. Ignoring.');
-  }
-
-  if (values.length > 1 && _anyIsInherit(values)) {
-    throw new InvalidPropertyError('Invalid font values at ' + formatPosition(values[0][2][0]) + '. Ignoring.');
-  }
-
-  // fuzzy match style, variant, weight, and stretch on first elements
-  while (index < fuzzyMatched) {
-    isStretchValid = validator.isFontStretchKeyword(values[index][1]) || validator.isGlobal(values[index][1]);
-    isStyleValid = validator.isFontStyleKeyword(values[index][1]) || validator.isGlobal(values[index][1]);
-    isVariantValid = validator.isFontVariantKeyword(values[index][1]) || validator.isGlobal(values[index][1]);
-    isWeightValid = validator.isFontWeightKeyword(values[index][1]) || validator.isGlobal(values[index][1]);
-
-    if (isStyleValid && !isStyleSet) {
-      style.value = [values[index]];
-      isStyleSet = true;
-    } else if (isVariantValid && !isVariantSet) {
-      variant.value = [values[index]];
-      isVariantSet = true;
-    } else if (isWeightValid && !isWeightSet) {
-      weight.value = [values[index]];
-      isWeightSet = true;
-    } else if (isStretchValid && !isStretchSet) {
-      stretch.value = [values[index]];
-      isStretchSet = true;
-    } else if (isStyleValid && isStyleSet || isVariantValid && isVariantSet || isWeightValid && isWeightSet || isStretchValid && isStretchSet) {
-      throw new InvalidPropertyError('Invalid font style / variant / weight / stretch value at ' + formatPosition(values[0][2][0]) + '. Ignoring.');
-    } else {
-      break;
-    }
-
-    index++;
-  }
-
-  // now comes font-size ...
-  if (validator.isFontSizeKeyword(values[index][1]) || validator.isUnit(values[index][1]) && !validator.isDynamicUnit(values[index][1])) {
-    size.value = [values[index]];
-    isSizeSet = true;
-    index++;
-  } else {
-    throw new InvalidPropertyError('Missing font size at ' + formatPosition(values[0][2][0]) + '. Ignoring.');
-  }
-
-  if (!values[index]) {
-    throw new InvalidPropertyError('Missing font family at ' + formatPosition(values[0][2][0]) + '. Ignoring.');
-  }
-
-  // ... and perhaps line-height
-  if (isSizeSet && values[index] && values[index][1] == Marker.FORWARD_SLASH && values[index + 1] && (validator.isLineHeightKeyword(values[index + 1][1]) || validator.isUnit(values[index + 1][1]) || validator.isNumber(values[index + 1][1]))) {
-    height.value = [values[index + 1]];
-    index++;
-    index++;
-  }
-
-  // ... and whatever comes next is font-family
-  family.value = [];
-
-  while (values[index]) {
-    if (values[index][1] == Marker.COMMA) {
-      appendableFamilyName = false;
-    } else {
-      if (appendableFamilyName) {
-        family.value[family.value.length - 1][1] += Marker.SPACE + values[index][1];
-      } else {
-        family.value.push(values[index]);
-      }
-
-      appendableFamilyName = true;
-    }
-
-    index++;
-  }
-
-  if (family.value.length === 0) {
-    throw new InvalidPropertyError('Missing font family at ' + formatPosition(values[0][2][0]) + '. Ignoring.');
-  }
-
-  return components;
-}
-
-function _anyIsFontSize(values, validator) {
-  var value;
-  var i, l;
-
-  for (i = 0, l = values.length; i < l; i++) {
-    value = values[i];
-
-    if (validator.isFontSizeKeyword(value[1]) || validator.isUnit(value[1]) && !validator.isDynamicUnit(value[1]) || validator.isFunction(value[1])) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-function _anyIsFontFamily(values, validator) {
-  var value;
-  var i, l;
-
-  for (i = 0, l = values.length; i < l; i++) {
-    value = values[i];
-
-    if (validator.isIdentifier(value[1])) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-function fourValues(property, compactable) {
-  var componentNames = compactable[property.name].components;
-  var components = [];
-  var value = property.value;
-
-  if (value.length < 1)
-    return [];
-
-  if (value.length < 2)
-    value[1] = value[0].slice(0);
-  if (value.length < 3)
-    value[2] = value[0].slice(0);
-  if (value.length < 4)
-    value[3] = value[1].slice(0);
-
-  for (var i = componentNames.length - 1; i >= 0; i--) {
-    var component = wrapSingle([
-      Token.PROPERTY,
-      [Token.PROPERTY_NAME, componentNames[i]]
-    ]);
-    component.value = [value[i]];
-    components.unshift(component);
-  }
-
-  return components;
-}
-
-function multiplex(splitWith) {
-  return function (property, compactable, validator) {
-    var splitsAt = [];
-    var values = property.value;
-    var i, j, l, m;
-
-    // find split commas
-    for (i = 0, l = values.length; i < l; i++) {
-      if (values[i][1] == ',')
-        splitsAt.push(i);
-    }
-
-    if (splitsAt.length === 0)
-      return splitWith(property, compactable, validator);
-
-    var splitComponents = [];
-
-    // split over commas, and into components
-    for (i = 0, l = splitsAt.length; i <= l; i++) {
-      var from = i === 0 ? 0 : splitsAt[i - 1] + 1;
-      var to = i < l ? splitsAt[i] : values.length;
-
-      var _property = _wrapDefault(property.name, property, compactable);
-      _property.value = values.slice(from, to);
-
-      splitComponents.push(splitWith(_property, compactable, validator));
-    }
-
-    var components = splitComponents[0];
-
-    // group component values from each split
-    for (i = 0, l = components.length; i < l; i++) {
-      components[i].multiplex = true;
-
-      for (j = 1, m = splitComponents.length; j < m; j++) {
-        components[i].value.push([Token.PROPERTY_VALUE, Marker.COMMA]);
-        Array.prototype.push.apply(components[i].value, splitComponents[j][i].value);
-      }
-    }
-
-    return components;
-  };
-}
-
-function listStyle(property, compactable, validator) {
-  var type = _wrapDefault('list-style-type', property, compactable);
-  var position = _wrapDefault('list-style-position', property, compactable);
-  var image = _wrapDefault('list-style-image', property, compactable);
-  var components = [type, position, image];
-
-  if (property.value.length == 1 && property.value[0][1] == 'inherit') {
-    type.value = position.value = image.value = [property.value[0]];
-    return components;
-  }
-
-  var values = property.value.slice(0);
-  var total = values.length;
-  var index = 0;
-
-  // `image` first...
-  for (index = 0, total = values.length; index < total; index++) {
-    if (validator.isUrl(values[index][1]) || values[index][1] == '0') {
-      image.value = [values[index]];
-      values.splice(index, 1);
-      break;
-    }
-  }
-
-  // ... then `position`
-  for (index = 0, total = values.length; index < total; index++) {
-    if (validator.isListStylePositionKeyword(values[index][1])) {
-      position.value = [values[index]];
-      values.splice(index, 1);
-      break;
-    }
-  }
-
-  // ... and what's left is a `type`
-  if (values.length > 0 && (validator.isListStyleTypeKeyword(values[0][1]) || validator.isIdentifier(values[0][1]))) {
-    type.value = [values[0]];
-  }
-
-  return components;
-}
-
-function transition(property, compactable, validator) {
-  var prop = _wrapDefault(property.name + '-property', property, compactable);
-  var duration = _wrapDefault(property.name + '-duration', property, compactable);
-  var timing = _wrapDefault(property.name + '-timing-function', property, compactable);
-  var delay = _wrapDefault(property.name + '-delay', property, compactable);
-  var components = [prop, duration, timing, delay];
-  var values = property.value;
-  var value;
-  var durationSet = false;
-  var delaySet = false;
-  var propSet = false;
-  var timingSet = false;
-  var i;
-  var l;
-
-  if (property.value.length == 1 && property.value[0][1] == 'inherit') {
-    prop.value = duration.value = timing.value = delay.value = property.value;
-    return components;
-  }
-
-  if (values.length > 1 && _anyIsInherit(values)) {
-    throw new InvalidPropertyError('Invalid animation values at ' + formatPosition(values[0][2][0]) + '. Ignoring.');
-  }
-
-  for (i = 0, l = values.length; i < l; i++) {
-    value = values[i];
-
-    if (validator.isTime(value[1]) && !durationSet) {
-      duration.value = [value];
-      durationSet = true;
-    } else if (validator.isTime(value[1]) && !delaySet) {
-      delay.value = [value];
-      delaySet = true;
-    } else if ((validator.isGlobal(value[1]) || validator.isTimingFunction(value[1])) && !timingSet) {
-      timing.value = [value];
-      timingSet = true;
-    } else if (validator.isIdentifier(value[1]) && !propSet) {
-      prop.value = [value];
-      propSet = true;
-    } else {
-      throw new InvalidPropertyError('Invalid animation value at ' + formatPosition(value[2][0]) + '. Ignoring.');
-    }
-  }
-
-  return components;
-}
-
-function widthStyleColor(property, compactable, validator) {
-  var descriptor = compactable[property.name];
-  var components = [
-    _wrapDefault(descriptor.components[0], property, compactable),
-    _wrapDefault(descriptor.components[1], property, compactable),
-    _wrapDefault(descriptor.components[2], property, compactable)
-  ];
-  var color, style, width;
-
-  for (var i = 0; i < 3; i++) {
-    var component = components[i];
-
-    if (component.name.indexOf('color') > 0)
-      color = component;
-    else if (component.name.indexOf('style') > 0)
-      style = component;
-    else
-      width = component;
-  }
-
-  if ((property.value.length == 1 && property.value[0][1] == 'inherit') ||
-      (property.value.length == 3 && property.value[0][1] == 'inherit' && property.value[1][1] == 'inherit' && property.value[2][1] == 'inherit')) {
-    color.value = style.value = width.value = [property.value[0]];
-    return components;
-  }
-
-  var values = property.value.slice(0);
-  var match, matches;
-
-  // NOTE: usually users don't follow the required order of parts in this shorthand,
-  // so we'll try to parse it caring as little about order as possible
-
-  if (values.length > 0) {
-    matches = values.filter(_widthFilter(validator));
-    match = matches.length > 1 && (matches[0][1] == 'none' || matches[0][1] == 'auto') ? matches[1] : matches[0];
-    if (match) {
-      width.value = [match];
-      values.splice(values.indexOf(match), 1);
-    }
-  }
-
-  if (values.length > 0) {
-    match = values.filter(_styleFilter(validator))[0];
-    if (match) {
-      style.value = [match];
-      values.splice(values.indexOf(match), 1);
-    }
-  }
-
-  if (values.length > 0) {
-    match = values.filter(_colorFilter(validator))[0];
-    if (match) {
-      color.value = [match];
-      values.splice(values.indexOf(match), 1);
-    }
-  }
-
-  return components;
-}
-
-module.exports = {
-  animation: animation,
-  background: background,
-  border: widthStyleColor,
-  borderRadius: borderRadius,
-  font: font,
-  fourValues: fourValues,
-  listStyle: listStyle,
-  multiplex: multiplex,
-  outline: widthStyleColor,
-  transition: transition
-};

node_modules/clean-css/lib/optimizer/level-2/can-override.js

@@ -1,283 +0,0 @@
-var understandable = require('./properties/understandable');
-
-function animationIterationCount(validator, value1, value2) {
-  if (!understandable(validator, value1, value2, 0, true) && !(validator.isAnimationIterationCountKeyword(value2) || validator.isPositiveNumber(value2))) {
-    return false;
-  } else if (validator.isVariable(value1) && validator.isVariable(value2)) {
-    return true;
-  }
-
-  return validator.isAnimationIterationCountKeyword(value2) || validator.isPositiveNumber(value2);
-}
-
-function animationName(validator, value1, value2) {
-  if (!understandable(validator, value1, value2, 0, true) && !(validator.isAnimationNameKeyword(value2) || validator.isIdentifier(value2))) {
-    return false;
-  } else if (validator.isVariable(value1) && validator.isVariable(value2)) {
-    return true;
-  }
-
-  return validator.isAnimationNameKeyword(value2) || validator.isIdentifier(value2);
-}
-
-function areSameFunction(validator, value1, value2) {
-  if (!validator.isFunction(value1) || !validator.isFunction(value2)) {
-    return false;
-  }
-
-  var function1Name = value1.substring(0, value1.indexOf('('));
-  var function2Name = value2.substring(0, value2.indexOf('('));
-
-  return function1Name === function2Name;
-}
-
-function backgroundPosition(validator, value1, value2) {
-  if (!understandable(validator, value1, value2, 0, true) && !(validator.isBackgroundPositionKeyword(value2) || validator.isGlobal(value2))) {
-    return false;
-  } else if (validator.isVariable(value1) && validator.isVariable(value2)) {
-    return true;
-  } else if (validator.isBackgroundPositionKeyword(value2) || validator.isGlobal(value2)) {
-    return true;
-  }
-
-  return unit(validator, value1, value2);
-}
-
-function backgroundSize(validator, value1, value2) {
-  if (!understandable(validator, value1, value2, 0, true) && !(validator.isBackgroundSizeKeyword(value2) || validator.isGlobal(value2))) {
-    return false;
-  } else if (validator.isVariable(value1) && validator.isVariable(value2)) {
-    return true;
-  } else if (validator.isBackgroundSizeKeyword(value2) || validator.isGlobal(value2)) {
-    return true;
-  }
-
-  return unit(validator, value1, value2);
-}
-
-function color(validator, value1, value2) {
-  if (!understandable(validator, value1, value2, 0, true) && !validator.isColor(value2)) {
-    return false;
-  } else if (validator.isVariable(value1) && validator.isVariable(value2)) {
-    return true;
-  } else if (!validator.colorOpacity && (validator.isRgbColor(value1) || validator.isHslColor(value1))) {
-    return false;
-  } else if (!validator.colorOpacity && (validator.isRgbColor(value2) || validator.isHslColor(value2))) {
-    return false;
-  } else if (validator.isColor(value1) && validator.isColor(value2)) {
-    return true;
-  }
-
-  return sameFunctionOrValue(validator, value1, value2);
-}
-
-function components(overrideCheckers) {
-  return function (validator, value1, value2, position) {
-    return overrideCheckers[position](validator, value1, value2);
-  };
-}
-
-function fontFamily(validator, value1, value2) {
-  return understandable(validator, value1, value2, 0, true);
-}
-
-function image(validator, value1, value2) {
-  if (!understandable(validator, value1, value2, 0, true) && !validator.isImage(value2)) {
-    return false;
-  } else if (validator.isVariable(value1) && validator.isVariable(value2)) {
-    return true;
-  } else if (validator.isImage(value2)) {
-    return true;
-  } else if (validator.isImage(value1)) {
-    return false;
-  }
-
-  return sameFunctionOrValue(validator, value1, value2);
-}
-
-function keyword(propertyName) {
-  return function(validator, value1, value2) {
-    if (!understandable(validator, value1, value2, 0, true) && !validator.isKeyword(propertyName)(value2)) {
-      return false;
-    } else if (validator.isVariable(value1) && validator.isVariable(value2)) {
-      return true;
-    }
-
-    return validator.isKeyword(propertyName)(value2);
-  };
-}
-
-function keywordWithGlobal(propertyName) {
-  return function(validator, value1, value2) {
-    if (!understandable(validator, value1, value2, 0, true) && !(validator.isKeyword(propertyName)(value2) || validator.isGlobal(value2))) {
-      return false;
-    } else if (validator.isVariable(value1) && validator.isVariable(value2)) {
-      return true;
-    }
-
-    return validator.isKeyword(propertyName)(value2) || validator.isGlobal(value2);
-  };
-}
-
-function propertyName(validator, value1, value2) {
-  if (!understandable(validator, value1, value2, 0, true) && !validator.isIdentifier(value2)) {
-    return false;
-  } else if (validator.isVariable(value1) && validator.isVariable(value2)) {
-    return true;
-  }
-
-  return validator.isIdentifier(value2);
-}
-
-function sameFunctionOrValue(validator, value1, value2) {
-  return areSameFunction(validator, value1, value2) ?
-    true :
-    value1 === value2;
-}
-
-function textShadow(validator, value1, value2) {
-  if (!understandable(validator, value1, value2, 0, true) && !(validator.isUnit(value2) || validator.isColor(value2) || validator.isGlobal(value2))) {
-    return false;
-  } else if (validator.isVariable(value1) && validator.isVariable(value2)) {
-    return true;
-  }
-
-  return validator.isUnit(value2) || validator.isColor(value2) || validator.isGlobal(value2);
-}
-
-function time(validator, value1, value2) {
-  if (!understandable(validator, value1, value2, 0, true) && !validator.isTime(value2)) {
-    return false;
-  } else if (validator.isVariable(value1) && validator.isVariable(value2)) {
-    return true;
-  } else if (validator.isTime(value1) && !validator.isTime(value2)) {
-    return false;
-  } else if (validator.isTime(value2)) {
-    return true;
-  } else if (validator.isTime(value1)) {
-    return false;
-  } else if (validator.isFunction(value1) && !validator.isPrefixed(value1) && validator.isFunction(value2) && !validator.isPrefixed(value2)) {
-    return true;
-  }
-
-  return sameFunctionOrValue(validator, value1, value2);
-}
-
-function timingFunction(validator, value1, value2) {
-  if (!understandable(validator, value1, value2, 0, true) && !(validator.isTimingFunction(value2) || validator.isGlobal(value2))) {
-    return false;
-  } else if (validator.isVariable(value1) && validator.isVariable(value2)) {
-    return true;
-  }
-
-  return validator.isTimingFunction(value2) || validator.isGlobal(value2);
-}
-
-function unit(validator, value1, value2) {
-  if (!understandable(validator, value1, value2, 0, true) && !validator.isUnit(value2)) {
-    return false;
-  } else if (validator.isVariable(value1) && validator.isVariable(value2)) {
-    return true;
-  } else if (validator.isUnit(value1) && !validator.isUnit(value2)) {
-    return false;
-  } else if (validator.isUnit(value2)) {
-    return true;
-  } else if (validator.isUnit(value1)) {
-    return false;
-  } else if (validator.isFunction(value1) && !validator.isPrefixed(value1) && validator.isFunction(value2) && !validator.isPrefixed(value2)) {
-    return true;
-  }
-
-  return sameFunctionOrValue(validator, value1, value2);
-}
-
-function unitOrKeywordWithGlobal(propertyName) {
-  var byKeyword = keywordWithGlobal(propertyName);
-
-  return function(validator, value1, value2) {
-    return unit(validator, value1, value2) || byKeyword(validator, value1, value2);
-  };
-}
-
-function unitOrNumber(validator, value1, value2) {
-  if (!understandable(validator, value1, value2, 0, true) && !(validator.isUnit(value2) || validator.isNumber(value2))) {
-    return false;
-  } else if (validator.isVariable(value1) && validator.isVariable(value2)) {
-    return true;
-  } else if ((validator.isUnit(value1) || validator.isNumber(value1)) && !(validator.isUnit(value2) || validator.isNumber(value2))) {
-    return false;
-  } else if (validator.isUnit(value2) || validator.isNumber(value2)) {
-    return true;
-  } else if (validator.isUnit(value1) || validator.isNumber(value1)) {
-    return false;
-  } else if (validator.isFunction(value1) && !validator.isPrefixed(value1) && validator.isFunction(value2) && !validator.isPrefixed(value2)) {
-    return true;
-  }
-
-  return sameFunctionOrValue(validator, value1, value2);
-}
-
-function zIndex(validator, value1, value2) {
-  if (!understandable(validator, value1, value2, 0, true) && !validator.isZIndex(value2)) {
-    return false;
-  } else if (validator.isVariable(value1) && validator.isVariable(value2)) {
-    return true;
-  }
-
-  return validator.isZIndex(value2);
-}
-
-module.exports = {
-  generic: {
-    color: color,
-    components: components,
-    image: image,
-    propertyName: propertyName,
-    time: time,
-    timingFunction: timingFunction,
-    unit: unit,
-    unitOrNumber: unitOrNumber
-  },
-  property: {
-    animationDirection: keywordWithGlobal('animation-direction'),
-    animationFillMode: keyword('animation-fill-mode'),
-    animationIterationCount: animationIterationCount,
-    animationName: animationName,
-    animationPlayState: keywordWithGlobal('animation-play-state'),
-    backgroundAttachment: keyword('background-attachment'),
-    backgroundClip: keywordWithGlobal('background-clip'),
-    backgroundOrigin: keyword('background-origin'),
-    backgroundPosition: backgroundPosition,
-    backgroundRepeat: keyword('background-repeat'),
-    backgroundSize: backgroundSize,
-    bottom: unitOrKeywordWithGlobal('bottom'),
-    borderCollapse: keyword('border-collapse'),
-    borderStyle: keywordWithGlobal('*-style'),
-    clear: keywordWithGlobal('clear'),
-    cursor: keywordWithGlobal('cursor'),
-    display: keywordWithGlobal('display'),
-    float: keywordWithGlobal('float'),
-    left: unitOrKeywordWithGlobal('left'),
-    fontFamily: fontFamily,
-    fontStretch: keywordWithGlobal('font-stretch'),
-    fontStyle: keywordWithGlobal('font-style'),
-    fontVariant: keywordWithGlobal('font-variant'),
-    fontWeight: keywordWithGlobal('font-weight'),
-    listStyleType: keywordWithGlobal('list-style-type'),
-    listStylePosition: keywordWithGlobal('list-style-position'),
-    outlineStyle: keywordWithGlobal('*-style'),
-    overflow: keywordWithGlobal('overflow'),
-    position: keywordWithGlobal('position'),
-    right: unitOrKeywordWithGlobal('right'),
-    textAlign: keywordWithGlobal('text-align'),
-    textDecoration: keywordWithGlobal('text-decoration'),
-    textOverflow: keywordWithGlobal('text-overflow'),
-    textShadow: textShadow,
-    top: unitOrKeywordWithGlobal('top'),
-    transform: sameFunctionOrValue,
-    verticalAlign: unitOrKeywordWithGlobal('vertical-align'),
-    visibility: keywordWithGlobal('visibility'),
-    whiteSpace: keywordWithGlobal('white-space'),
-    zIndex: zIndex
-  }
-};

node_modules/clean-css/lib/optimizer/level-2/clone.js

@@ -1,33 +0,0 @@
-var wrapSingle = require('../wrap-for-optimizing').single;
-
-var Token = require('../../tokenizer/token');
-
-function deep(property) {
-  var cloned = shallow(property);
-  for (var i = property.components.length - 1; i >= 0; i--) {
-    var component = shallow(property.components[i]);
-    component.value = property.components[i].value.slice(0);
-    cloned.components.unshift(component);
-  }
-
-  cloned.dirty = true;
-  cloned.value = property.value.slice(0);
-
-  return cloned;
-}
-
-function shallow(property) {
-  var cloned = wrapSingle([
-    Token.PROPERTY,
-    [Token.PROPERTY_NAME, property.name]
-  ]);
-  cloned.important = property.important;
-  cloned.hack = property.hack;
-  cloned.unused = false;
-  return cloned;
-}
-
-module.exports = {
-  deep: deep,
-  shallow: shallow
-};

node_modules/clean-css/lib/optimizer/level-2/extract-properties.js

@@ -1,73 +0,0 @@
-// This extractor is used in level 2 optimizations
-// IMPORTANT: Mind Token class and this code is not related!
-// Properties will be tokenized in one step, see #429
-
-var Token = require('../../tokenizer/token');
-var serializeRules = require('../../writer/one-time').rules;
-var serializeValue = require('../../writer/one-time').value;
-
-function extractProperties(token) {
-  var properties = [];
-  var inSpecificSelector;
-  var property;
-  var name;
-  var value;
-  var i, l;
-
-  if (token[0] == Token.RULE) {
-    inSpecificSelector = !/[\.\+>~]/.test(serializeRules(token[1]));
-
-    for (i = 0, l = token[2].length; i < l; i++) {
-      property = token[2][i];
-
-      if (property[0] != Token.PROPERTY)
-        continue;
-
-      name = property[1][1];
-      if (name.length === 0)
-        continue;
-
-      if (name.indexOf('--') === 0)
-        continue;
-
-      value = serializeValue(property, i);
-
-      properties.push([
-        name,
-        value,
-        findNameRoot(name),
-        token[2][i],
-        name + ':' + value,
-        token[1],
-        inSpecificSelector
-      ]);
-    }
-  } else if (token[0] == Token.NESTED_BLOCK) {
-    for (i = 0, l = token[2].length; i < l; i++) {
-      properties = properties.concat(extractProperties(token[2][i]));
-    }
-  }
-
-  return properties;
-}
-
-function findNameRoot(name) {
-  if (name == 'list-style')
-    return name;
-  if (name.indexOf('-radius') > 0)
-    return 'border-radius';
-  if (name == 'border-collapse' || name == 'border-spacing' || name == 'border-image')
-    return name;
-  if (name.indexOf('border-') === 0 && /^border\-\w+\-\w+$/.test(name))
-    return name.match(/border\-\w+/)[0];
-  if (name.indexOf('border-') === 0 && /^border\-\w+$/.test(name))
-    return 'border';
-  if (name.indexOf('text-') === 0)
-    return name;
-  if (name == '-chrome-')
-    return name;
-
-  return name.replace(/^\-\w+\-/, '').match(/([a-zA-Z]+)/)[0].toLowerCase();
-}
-
-module.exports = extractProperties;

node_modules/clean-css/lib/optimizer/level-2/invalid-property-error.js

@@ -1,10 +0,0 @@
-function InvalidPropertyError(message) {
-  this.name = 'InvalidPropertyError';
-  this.message = message;
-  this.stack = (new Error()).stack;
-}
-
-InvalidPropertyError.prototype = Object.create(Error.prototype);
-InvalidPropertyError.prototype.constructor = InvalidPropertyError;
-
-module.exports = InvalidPropertyError;

node_modules/clean-css/lib/optimizer/level-2/is-mergeable.js

@@ -1,259 +0,0 @@
-var Marker = require('../../tokenizer/marker');
-var split = require('../../utils/split');
-
-var DEEP_SELECTOR_PATTERN = /\/deep\//;
-var DOUBLE_COLON_PATTERN = /^::/;
-var NOT_PSEUDO = ':not';
-var PSEUDO_CLASSES_WITH_ARGUMENTS = [
-  ':dir',
-  ':lang',
-  ':not',
-  ':nth-child',
-  ':nth-last-child',
-  ':nth-last-of-type',
-  ':nth-of-type'
-];
-var RELATION_PATTERN = /[>\+~]/;
-var UNMIXABLE_PSEUDO_CLASSES = [
-  ':after',
-  ':before',
-  ':first-letter',
-  ':first-line',
-  ':lang'
-];
-var UNMIXABLE_PSEUDO_ELEMENTS = [
-  '::after',
-  '::before',
-  '::first-letter',
-  '::first-line'
-];
-
-var Level = {
-  DOUBLE_QUOTE: 'double-quote',
-  SINGLE_QUOTE: 'single-quote',
-  ROOT: 'root'
-};
-
-function isMergeable(selector, mergeablePseudoClasses, mergeablePseudoElements, multiplePseudoMerging) {
-  var singleSelectors = split(selector, Marker.COMMA);
-  var singleSelector;
-  var i, l;
-
-  for (i = 0, l = singleSelectors.length; i < l; i++) {
-    singleSelector = singleSelectors[i];
-
-    if (singleSelector.length === 0 ||
-        isDeepSelector(singleSelector) ||
-        (singleSelector.indexOf(Marker.COLON) > -1 && !areMergeable(singleSelector, extractPseudoFrom(singleSelector), mergeablePseudoClasses, mergeablePseudoElements, multiplePseudoMerging))) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-function isDeepSelector(selector) {
-  return DEEP_SELECTOR_PATTERN.test(selector);
-}
-
-function extractPseudoFrom(selector) {
-  var list = [];
-  var character;
-  var buffer = [];
-  var level = Level.ROOT;
-  var roundBracketLevel = 0;
-  var isQuoted;
-  var isEscaped;
-  var isPseudo = false;
-  var isRelation;
-  var wasColon = false;
-  var index;
-  var len;
-
-  for (index = 0, len = selector.length; index < len; index++) {
-    character = selector[index];
-
-    isRelation = !isEscaped && RELATION_PATTERN.test(character);
-    isQuoted = level == Level.DOUBLE_QUOTE || level == Level.SINGLE_QUOTE;
-
-    if (isEscaped) {
-      buffer.push(character);
-    } else if (character == Marker.DOUBLE_QUOTE && level == Level.ROOT) {
-      buffer.push(character);
-      level = Level.DOUBLE_QUOTE;
-    } else if (character == Marker.DOUBLE_QUOTE && level == Level.DOUBLE_QUOTE) {
-      buffer.push(character);
-      level = Level.ROOT;
-    } else if (character == Marker.SINGLE_QUOTE && level == Level.ROOT) {
-      buffer.push(character);
-      level = Level.SINGLE_QUOTE;
-    } else if (character == Marker.SINGLE_QUOTE && level == Level.SINGLE_QUOTE) {
-      buffer.push(character);
-      level = Level.ROOT;
-    } else if (isQuoted) {
-      buffer.push(character);
-    } else if (character == Marker.OPEN_ROUND_BRACKET) {
-      buffer.push(character);
-      roundBracketLevel++;
-    } else if (character == Marker.CLOSE_ROUND_BRACKET && roundBracketLevel == 1 && isPseudo) {
-      buffer.push(character);
-      list.push(buffer.join(''));
-      roundBracketLevel--;
-      buffer = [];
-      isPseudo = false;
-    } else if (character == Marker.CLOSE_ROUND_BRACKET) {
-      buffer.push(character);
-      roundBracketLevel--;
-    } else if (character == Marker.COLON && roundBracketLevel === 0 && isPseudo && !wasColon) {
-      list.push(buffer.join(''));
-      buffer = [];
-      buffer.push(character);
-    } else if (character == Marker.COLON && roundBracketLevel === 0 && !wasColon) {
-      buffer = [];
-      buffer.push(character);
-      isPseudo = true;
-    } else if (character == Marker.SPACE && roundBracketLevel === 0 && isPseudo) {
-      list.push(buffer.join(''));
-      buffer = [];
-      isPseudo = false;
-    } else if (isRelation && roundBracketLevel === 0 && isPseudo) {
-      list.push(buffer.join(''));
-      buffer = [];
-      isPseudo = false;
-    } else {
-      buffer.push(character);
-    }
-
-    isEscaped = character == Marker.BACK_SLASH;
-    wasColon = character == Marker.COLON;
-  }
-
-  if (buffer.length > 0 && isPseudo) {
-    list.push(buffer.join(''));
-  }
-
-  return list;
-}
-
-function areMergeable(selector, matches, mergeablePseudoClasses, mergeablePseudoElements, multiplePseudoMerging) {
-  return areAllowed(matches, mergeablePseudoClasses, mergeablePseudoElements) &&
-    needArguments(matches) &&
-    (matches.length < 2 || !someIncorrectlyChained(selector, matches)) &&
-    (matches.length < 2 || multiplePseudoMerging && allMixable(matches));
-}
-
-function areAllowed(matches, mergeablePseudoClasses, mergeablePseudoElements) {
-  var match;
-  var name;
-  var i, l;
-
-  for (i = 0, l = matches.length; i < l; i++) {
-    match = matches[i];
-    name = match.indexOf(Marker.OPEN_ROUND_BRACKET) > -1 ?
-      match.substring(0, match.indexOf(Marker.OPEN_ROUND_BRACKET)) :
-      match;
-
-    if (mergeablePseudoClasses.indexOf(name) === -1 && mergeablePseudoElements.indexOf(name) === -1) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-function needArguments(matches) {
-  var match;
-  var name;
-  var bracketOpensAt;
-  var hasArguments;
-  var i, l;
-
-  for (i = 0, l = matches.length; i < l; i++) {
-    match = matches[i];
-
-    bracketOpensAt = match.indexOf(Marker.OPEN_ROUND_BRACKET);
-    hasArguments = bracketOpensAt > -1;
-    name = hasArguments ?
-      match.substring(0, bracketOpensAt) :
-      match;
-
-    if (hasArguments && PSEUDO_CLASSES_WITH_ARGUMENTS.indexOf(name) == -1) {
-      return false;
-    }
-
-    if (!hasArguments && PSEUDO_CLASSES_WITH_ARGUMENTS.indexOf(name) > -1) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-function someIncorrectlyChained(selector, matches) {
-  var positionInSelector = 0;
-  var match;
-  var matchAt;
-  var nextMatch;
-  var nextMatchAt;
-  var name;
-  var nextName;
-  var areChained;
-  var i, l;
-
-  for (i = 0, l = matches.length; i < l; i++) {
-    match = matches[i];
-    nextMatch = matches[i + 1];
-
-    if (!nextMatch) {
-      break;
-    }
-
-    matchAt = selector.indexOf(match, positionInSelector);
-    nextMatchAt = selector.indexOf(match, matchAt + 1);
-    positionInSelector = nextMatchAt;
-    areChained = matchAt + match.length == nextMatchAt;
-
-    if (areChained) {
-      name = match.indexOf(Marker.OPEN_ROUND_BRACKET) > -1 ?
-        match.substring(0, match.indexOf(Marker.OPEN_ROUND_BRACKET)) :
-        match;
-      nextName = nextMatch.indexOf(Marker.OPEN_ROUND_BRACKET) > -1 ?
-        nextMatch.substring(0, nextMatch.indexOf(Marker.OPEN_ROUND_BRACKET)) :
-        nextMatch;
-
-      if (name != NOT_PSEUDO || nextName != NOT_PSEUDO) {
-        return true;
-      }
-    }
-  }
-
-  return false;
-}
-
-function allMixable(matches) {
-  var unmixableMatches = 0;
-  var match;
-  var i, l;
-
-  for (i = 0, l = matches.length; i < l; i++) {
-    match = matches[i];
-
-    if (isPseudoElement(match)) {
-      unmixableMatches += UNMIXABLE_PSEUDO_ELEMENTS.indexOf(match) > -1 ? 1 : 0;
-    } else {
-      unmixableMatches += UNMIXABLE_PSEUDO_CLASSES.indexOf(match) > -1 ? 1 : 0;
-    }
-
-    if (unmixableMatches > 1) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-function isPseudoElement(pseudo) {
-  return DOUBLE_COLON_PATTERN.test(pseudo);
-}
-
-module.exports = isMergeable;

node_modules/clean-css/lib/optimizer/level-2/merge-adjacent.js

@@ -1,50 +0,0 @@
-var isMergeable = require('./is-mergeable');
-
-var optimizeProperties = require('./properties/optimize');
-
-var sortSelectors = require('../level-1/sort-selectors');
-var tidyRules = require('../level-1/tidy-rules');
-
-var OptimizationLevel = require('../../options/optimization-level').OptimizationLevel;
-
-var serializeBody = require('../../writer/one-time').body;
-var serializeRules = require('../../writer/one-time').rules;
-
-var Token = require('../../tokenizer/token');
-
-function mergeAdjacent(tokens, context) {
-  var lastToken = [null, [], []];
-  var options = context.options;
-  var adjacentSpace = options.compatibility.selectors.adjacentSpace;
-  var selectorsSortingMethod = options.level[OptimizationLevel.One].selectorsSortingMethod;
-  var mergeablePseudoClasses = options.compatibility.selectors.mergeablePseudoClasses;
-  var mergeablePseudoElements = options.compatibility.selectors.mergeablePseudoElements;
-  var mergeLimit = options.compatibility.selectors.mergeLimit;
-  var multiplePseudoMerging = options.compatibility.selectors.multiplePseudoMerging;
-
-  for (var i = 0, l = tokens.length; i < l; i++) {
-    var token = tokens[i];
-
-    if (token[0] != Token.RULE) {
-      lastToken = [null, [], []];
-      continue;
-    }
-
-    if (lastToken[0] == Token.RULE && serializeRules(token[1]) == serializeRules(lastToken[1])) {
-      Array.prototype.push.apply(lastToken[2], token[2]);
-      optimizeProperties(lastToken[2], true, true, context);
-      token[2] = [];
-    } else if (lastToken[0] == Token.RULE && serializeBody(token[2]) == serializeBody(lastToken[2]) &&
-        isMergeable(serializeRules(token[1]), mergeablePseudoClasses, mergeablePseudoElements, multiplePseudoMerging) &&
-        isMergeable(serializeRules(lastToken[1]), mergeablePseudoClasses, mergeablePseudoElements, multiplePseudoMerging) &&
-        lastToken[1].length < mergeLimit) {
-      lastToken[1] = tidyRules(lastToken[1].concat(token[1]), false, adjacentSpace, false, context.warnings);
-      lastToken[1] = lastToken.length > 1 ? sortSelectors(lastToken[1], selectorsSortingMethod) : lastToken[1];
-      token[2] = [];
-    } else {
-      lastToken = token;
-    }
-  }
-}
-
-module.exports = mergeAdjacent;

node_modules/clean-css/lib/optimizer/level-2/merge-media-queries.js

@@ -1,103 +0,0 @@
-var canReorder = require('./reorderable').canReorder;
-var canReorderSingle = require('./reorderable').canReorderSingle;
-var extractProperties = require('./extract-properties');
-var rulesOverlap = require('./rules-overlap');
-
-var serializeRules = require('../../writer/one-time').rules;
-var OptimizationLevel = require('../../options/optimization-level').OptimizationLevel;
-var Token = require('../../tokenizer/token');
-
-function mergeMediaQueries(tokens, context) {
-  var mergeSemantically = context.options.level[OptimizationLevel.Two].mergeSemantically;
-  var specificityCache = context.cache.specificity;
-  var candidates = {};
-  var reduced = [];
-
-  for (var i = tokens.length - 1; i >= 0; i--) {
-    var token = tokens[i];
-    if (token[0] != Token.NESTED_BLOCK) {
-      continue;
-    }
-
-    var key = serializeRules(token[1]);
-    var candidate = candidates[key];
-    if (!candidate) {
-      candidate = [];
-      candidates[key] = candidate;
-    }
-
-    candidate.push(i);
-  }
-
-  for (var name in candidates) {
-    var positions = candidates[name];
-
-    positionLoop:
-    for (var j = positions.length - 1; j > 0; j--) {
-      var positionOne = positions[j];
-      var tokenOne = tokens[positionOne];
-      var positionTwo = positions[j - 1];
-      var tokenTwo = tokens[positionTwo];
-
-      directionLoop:
-      for (var direction = 1; direction >= -1; direction -= 2) {
-        var topToBottom = direction == 1;
-        var from = topToBottom ? positionOne + 1 : positionTwo - 1;
-        var to = topToBottom ? positionTwo : positionOne;
-        var delta = topToBottom ? 1 : -1;
-        var source = topToBottom ? tokenOne : tokenTwo;
-        var target = topToBottom ? tokenTwo : tokenOne;
-        var movedProperties = extractProperties(source);
-
-        while (from != to) {
-          var traversedProperties = extractProperties(tokens[from]);
-          from += delta;
-
-          if (mergeSemantically && allSameRulePropertiesCanBeReordered(movedProperties, traversedProperties, specificityCache)) {
-            continue;
-          }
-
-          if (!canReorder(movedProperties, traversedProperties, specificityCache))
-            continue directionLoop;
-        }
-
-        target[2] = topToBottom ?
-          source[2].concat(target[2]) :
-          target[2].concat(source[2]);
-        source[2] = [];
-
-        reduced.push(target);
-        continue positionLoop;
-      }
-    }
-  }
-
-  return reduced;
-}
-
-function allSameRulePropertiesCanBeReordered(movedProperties, traversedProperties, specificityCache) {
-  var movedProperty;
-  var movedRule;
-  var traversedProperty;
-  var traversedRule;
-  var i, l;
-  var j, m;
-
-  for (i = 0, l = movedProperties.length; i < l; i++) {
-    movedProperty = movedProperties[i];
-    movedRule = movedProperty[5];
-
-    for (j = 0, m = traversedProperties.length; j < m; j++) {
-      traversedProperty = traversedProperties[j];
-      traversedRule = traversedProperty[5];
-
-      if (rulesOverlap(movedRule, traversedRule, true) && !canReorderSingle(movedProperty, traversedProperty, specificityCache)) {
-        return false;
-      }
-    }
-  }
-
-  return true;
-}
-
-module.exports = mergeMediaQueries;

node_modules/clean-css/lib/optimizer/level-2/merge-non-adjacent-by-body.js

@@ -1,80 +0,0 @@
-var isMergeable = require('./is-mergeable');
-
-var sortSelectors = require('../level-1/sort-selectors');
-var tidyRules = require('../level-1/tidy-rules');
-
-var OptimizationLevel = require('../../options/optimization-level').OptimizationLevel;
-
-var serializeBody = require('../../writer/one-time').body;
-var serializeRules = require('../../writer/one-time').rules;
-
-var Token = require('../../tokenizer/token');
-
-function unsafeSelector(value) {
-  return /\.|\*| :/.test(value);
-}
-
-function isBemElement(token) {
-  var asString = serializeRules(token[1]);
-  return asString.indexOf('__') > -1 || asString.indexOf('--') > -1;
-}
-
-function withoutModifier(selector) {
-  return selector.replace(/--[^ ,>\+~:]+/g, '');
-}
-
-function removeAnyUnsafeElements(left, candidates) {
-  var leftSelector = withoutModifier(serializeRules(left[1]));
-
-  for (var body in candidates) {
-    var right = candidates[body];
-    var rightSelector = withoutModifier(serializeRules(right[1]));
-
-    if (rightSelector.indexOf(leftSelector) > -1 || leftSelector.indexOf(rightSelector) > -1)
-      delete candidates[body];
-  }
-}
-
-function mergeNonAdjacentByBody(tokens, context) {
-  var options = context.options;
-  var mergeSemantically = options.level[OptimizationLevel.Two].mergeSemantically;
-  var adjacentSpace = options.compatibility.selectors.adjacentSpace;
-  var selectorsSortingMethod = options.level[OptimizationLevel.One].selectorsSortingMethod;
-  var mergeablePseudoClasses = options.compatibility.selectors.mergeablePseudoClasses;
-  var mergeablePseudoElements = options.compatibility.selectors.mergeablePseudoElements;
-  var multiplePseudoMerging = options.compatibility.selectors.multiplePseudoMerging;
-  var candidates = {};
-
-  for (var i = tokens.length - 1; i >= 0; i--) {
-    var token = tokens[i];
-    if (token[0] != Token.RULE)
-      continue;
-
-    if (token[2].length > 0 && (!mergeSemantically && unsafeSelector(serializeRules(token[1]))))
-      candidates = {};
-
-    if (token[2].length > 0 && mergeSemantically && isBemElement(token))
-      removeAnyUnsafeElements(token, candidates);
-
-    var candidateBody = serializeBody(token[2]);
-    var oldToken = candidates[candidateBody];
-    if (oldToken &&
-        isMergeable(serializeRules(token[1]), mergeablePseudoClasses, mergeablePseudoElements, multiplePseudoMerging) &&
-        isMergeable(serializeRules(oldToken[1]), mergeablePseudoClasses, mergeablePseudoElements, multiplePseudoMerging)) {
-
-      if (token[2].length > 0) {
-        token[1] = tidyRules(oldToken[1].concat(token[1]), false, adjacentSpace, false, context.warnings);
-        token[1] = token[1].length > 1 ? sortSelectors(token[1], selectorsSortingMethod) : token[1];
-      } else {
-        token[1] = oldToken[1].concat(token[1]);
-      }
-
-      oldToken[2] = [];
-      candidates[candidateBody] = null;
-    }
-
-    candidates[serializeBody(token[2])] = token;
-  }
-}
-
-module.exports = mergeNonAdjacentByBody;

node_modules/clean-css/lib/optimizer/level-2/merge-non-adjacent-by-selector.js

@@ -1,78 +0,0 @@
-var canReorder = require('./reorderable').canReorder;
-var extractProperties = require('./extract-properties');
-
-var optimizeProperties = require('./properties/optimize');
-
-var serializeRules = require('../../writer/one-time').rules;
-
-var Token = require('../../tokenizer/token');
-
-function mergeNonAdjacentBySelector(tokens, context) {
-  var specificityCache = context.cache.specificity;
-  var allSelectors = {};
-  var repeatedSelectors = [];
-  var i;
-
-  for (i = tokens.length - 1; i >= 0; i--) {
-    if (tokens[i][0] != Token.RULE)
-      continue;
-    if (tokens[i][2].length === 0)
-      continue;
-
-    var selector = serializeRules(tokens[i][1]);
-    allSelectors[selector] = [i].concat(allSelectors[selector] || []);
-
-    if (allSelectors[selector].length == 2)
-      repeatedSelectors.push(selector);
-  }
-
-  for (i = repeatedSelectors.length - 1; i >= 0; i--) {
-    var positions = allSelectors[repeatedSelectors[i]];
-
-    selectorIterator:
-    for (var j = positions.length - 1; j > 0; j--) {
-      var positionOne = positions[j - 1];
-      var tokenOne = tokens[positionOne];
-      var positionTwo = positions[j];
-      var tokenTwo = tokens[positionTwo];
-
-      directionIterator:
-      for (var direction = 1; direction >= -1; direction -= 2) {
-        var topToBottom = direction == 1;
-        var from = topToBottom ? positionOne + 1 : positionTwo - 1;
-        var to = topToBottom ? positionTwo : positionOne;
-        var delta = topToBottom ? 1 : -1;
-        var moved = topToBottom ? tokenOne : tokenTwo;
-        var target = topToBottom ? tokenTwo : tokenOne;
-        var movedProperties = extractProperties(moved);
-
-        while (from != to) {
-          var traversedProperties = extractProperties(tokens[from]);
-          from += delta;
-
-          // traversed then moved as we move selectors towards the start
-          var reorderable = topToBottom ?
-            canReorder(movedProperties, traversedProperties, specificityCache) :
-            canReorder(traversedProperties, movedProperties, specificityCache);
-
-          if (!reorderable && !topToBottom)
-            continue selectorIterator;
-          if (!reorderable && topToBottom)
-            continue directionIterator;
-        }
-
-        if (topToBottom) {
-          Array.prototype.push.apply(moved[2], target[2]);
-          target[2] = moved[2];
-        } else {
-          Array.prototype.push.apply(target[2], moved[2]);
-        }
-
-        optimizeProperties(target[2], true, true, context);
-        moved[2] = [];
-      }
-    }
-  }
-}
-
-module.exports = mergeNonAdjacentBySelector;

node_modules/clean-css/lib/optimizer/level-2/optimize.js

@@ -1,134 +0,0 @@
-var mergeAdjacent = require('./merge-adjacent');
-var mergeMediaQueries = require('./merge-media-queries');
-var mergeNonAdjacentByBody = require('./merge-non-adjacent-by-body');
-var mergeNonAdjacentBySelector = require('./merge-non-adjacent-by-selector');
-var reduceNonAdjacent = require('./reduce-non-adjacent');
-var removeDuplicateFontAtRules = require('./remove-duplicate-font-at-rules');
-var removeDuplicateMediaQueries = require('./remove-duplicate-media-queries');
-var removeDuplicates = require('./remove-duplicates');
-var removeUnusedAtRules = require('./remove-unused-at-rules');
-var restructure = require('./restructure');
-
-var optimizeProperties = require('./properties/optimize');
-
-var OptimizationLevel = require('../../options/optimization-level').OptimizationLevel;
-
-var Token = require('../../tokenizer/token');
-
-function removeEmpty(tokens) {
-  for (var i = 0, l = tokens.length; i < l; i++) {
-    var token = tokens[i];
-    var isEmpty = false;
-
-    switch (token[0]) {
-      case Token.RULE:
-        isEmpty = token[1].length === 0 || token[2].length === 0;
-        break;
-      case Token.NESTED_BLOCK:
-        removeEmpty(token[2]);
-        isEmpty = token[2].length === 0;
-        break;
-      case Token.AT_RULE:
-        isEmpty = token[1].length === 0;
-        break;
-      case Token.AT_RULE_BLOCK:
-        isEmpty = token[2].length === 0;
-    }
-
-    if (isEmpty) {
-      tokens.splice(i, 1);
-      i--;
-      l--;
-    }
-  }
-}
-
-function recursivelyOptimizeBlocks(tokens, context) {
-  for (var i = 0, l = tokens.length; i < l; i++) {
-    var token = tokens[i];
-
-    if (token[0] == Token.NESTED_BLOCK) {
-      var isKeyframes = /@(-moz-|-o-|-webkit-)?keyframes/.test(token[1][0][1]);
-      level2Optimize(token[2], context, !isKeyframes);
-    }
-  }
-}
-
-function recursivelyOptimizeProperties(tokens, context) {
-  for (var i = 0, l = tokens.length; i < l; i++) {
-    var token = tokens[i];
-
-    switch (token[0]) {
-      case Token.RULE:
-        optimizeProperties(token[2], true, true, context);
-        break;
-      case Token.NESTED_BLOCK:
-        recursivelyOptimizeProperties(token[2], context);
-    }
-  }
-}
-
-function level2Optimize(tokens, context, withRestructuring) {
-  var levelOptions = context.options.level[OptimizationLevel.Two];
-  var reduced;
-  var i;
-
-  recursivelyOptimizeBlocks(tokens, context);
-  recursivelyOptimizeProperties(tokens, context);
-
-  if (levelOptions.removeDuplicateRules) {
-    removeDuplicates(tokens, context);
-  }
-
-  if (levelOptions.mergeAdjacentRules) {
-    mergeAdjacent(tokens, context);
-  }
-
-  if (levelOptions.reduceNonAdjacentRules) {
-    reduceNonAdjacent(tokens, context);
-  }
-
-  if (levelOptions.mergeNonAdjacentRules && levelOptions.mergeNonAdjacentRules != 'body') {
-    mergeNonAdjacentBySelector(tokens, context);
-  }
-
-  if (levelOptions.mergeNonAdjacentRules && levelOptions.mergeNonAdjacentRules != 'selector') {
-    mergeNonAdjacentByBody(tokens, context);
-  }
-
-  if (levelOptions.restructureRules && levelOptions.mergeAdjacentRules && withRestructuring) {
-    restructure(tokens, context);
-    mergeAdjacent(tokens, context);
-  }
-
-  if (levelOptions.restructureRules && !levelOptions.mergeAdjacentRules && withRestructuring) {
-    restructure(tokens, context);
-  }
-
-  if (levelOptions.removeDuplicateFontRules) {
-    removeDuplicateFontAtRules(tokens, context);
-  }
-
-  if (levelOptions.removeDuplicateMediaBlocks) {
-    removeDuplicateMediaQueries(tokens, context);
-  }
-
-  if (levelOptions.removeUnusedAtRules) {
-    removeUnusedAtRules(tokens, context);
-  }
-
-  if (levelOptions.mergeMedia) {
-    reduced = mergeMediaQueries(tokens, context);
-    for (i = reduced.length - 1; i >= 0; i--) {
-      level2Optimize(reduced[i][2], context, false);
-    }
-  }
-
-  if (levelOptions.removeEmpty) {
-    removeEmpty(tokens);
-  }
-
-  return tokens;
-}
-
-module.exports = level2Optimize;

node_modules/clean-css/lib/optimizer/level-2/properties/every-values-pair.js

@@ -1,28 +0,0 @@
-var Marker = require('../../../tokenizer/marker');
-
-function everyValuesPair(fn, left, right) {
-  var leftSize = left.value.length;
-  var rightSize = right.value.length;
-  var total = Math.max(leftSize, rightSize);
-  var lowerBound = Math.min(leftSize, rightSize) - 1;
-  var leftValue;
-  var rightValue;
-  var position;
-
-  for (position = 0; position < total; position++) {
-    leftValue = left.value[position] && left.value[position][1] || leftValue;
-    rightValue = right.value[position] && right.value[position][1] || rightValue;
-
-    if (leftValue == Marker.COMMA || rightValue == Marker.COMMA) {
-      continue;
-    }
-
-    if (!fn(leftValue, rightValue, position, position <= lowerBound)) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-module.exports = everyValuesPair;

node_modules/clean-css/lib/optimizer/level-2/properties/find-component-in.js

@@ -1,40 +0,0 @@
-var compactable = require('../compactable');
-
-function findComponentIn(shorthand, longhand) {
-  var comparator = nameComparator(longhand);
-
-  return findInDirectComponents(shorthand, comparator) || findInSubComponents(shorthand, comparator);
-}
-
-function nameComparator(to) {
-  return function (property) {
-    return to.name === property.name;
-  };
-}
-
-function findInDirectComponents(shorthand, comparator) {
-  return shorthand.components.filter(comparator)[0];
-}
-
-function findInSubComponents(shorthand, comparator) {
-  var shorthandComponent;
-  var longhandMatch;
-  var i, l;
-
-  if (!compactable[shorthand.name].shorthandComponents) {
-    return;
-  }
-
-  for (i = 0, l = shorthand.components.length; i < l; i++) {
-    shorthandComponent = shorthand.components[i];
-    longhandMatch = findInDirectComponents(shorthandComponent, comparator);
-
-    if (longhandMatch) {
-      return longhandMatch;
-    }
-  }
-
-  return;
-}
-
-module.exports = findComponentIn;

node_modules/clean-css/lib/optimizer/level-2/properties/has-inherit.js

@@ -1,10 +0,0 @@
-function hasInherit(property) {
-  for (var i = property.value.length - 1; i >= 0; i--) {
-    if (property.value[i][1] == 'inherit')
-      return true;
-  }
-
-  return false;
-}
-
-module.exports = hasInherit;

node_modules/clean-css/lib/optimizer/level-2/properties/is-component-of.js

@@ -1,22 +0,0 @@
-var compactable = require('../compactable');
-
-function isComponentOf(property1, property2, shallow) {
-  return isDirectComponentOf(property1, property2) ||
-    !shallow && !!compactable[property1.name].shorthandComponents && isSubComponentOf(property1, property2);
-}
-
-function isDirectComponentOf(property1, property2) {
-  var descriptor = compactable[property1.name];
-
-  return 'components' in descriptor && descriptor.components.indexOf(property2.name) > -1;
-}
-
-function isSubComponentOf(property1, property2) {
-  return property1
-    .components
-    .some(function (component) {
-      return isDirectComponentOf(component, property2);
-    });
-}
-
-module.exports = isComponentOf;

node_modules/clean-css/lib/optimizer/level-2/properties/is-mergeable-shorthand.js

@@ -1,11 +0,0 @@
-var Marker = require('../../../tokenizer/marker');
-
-function isMergeableShorthand(shorthand) {
-  if (shorthand.name != 'font') {
-    return true;
-  }
-
-  return shorthand.value[0][1].indexOf(Marker.INTERNAL) == -1;
-}
-
-module.exports = isMergeableShorthand;

node_modules/clean-css/lib/optimizer/level-2/properties/merge-into-shorthands.js

@@ -1,445 +0,0 @@
-var everyValuesPair = require('./every-values-pair');
-var hasInherit = require('./has-inherit');
-var populateComponents = require('./populate-components');
-
-var compactable = require('../compactable');
-var deepClone = require('../clone').deep;
-var restoreWithComponents = require('../restore-with-components');
-
-var restoreFromOptimizing = require('../../restore-from-optimizing');
-var wrapSingle = require('../../wrap-for-optimizing').single;
-
-var serializeBody = require('../../../writer/one-time').body;
-var Token = require('../../../tokenizer/token');
-
-function mergeIntoShorthands(properties, validator) {
-  var candidates = {};
-  var descriptor;
-  var componentOf;
-  var property;
-  var i, l;
-  var j, m;
-
-  // there is no shorthand property made up of less than 3 longhands
-  if (properties.length < 3) {
-    return;
-  }
-
-  for (i = 0, l = properties.length; i < l; i++) {
-    property = properties[i];
-    descriptor = compactable[property.name];
-
-    if (property.unused) {
-      continue;
-    }
-
-    if (property.hack) {
-      continue;
-    }
-
-    if (property.block) {
-      continue;
-    }
-
-    invalidateOrCompact(properties, i, candidates, validator);
-
-    if (descriptor && descriptor.componentOf) {
-      for (j = 0, m = descriptor.componentOf.length; j < m; j++) {
-        componentOf = descriptor.componentOf[j];
-
-        candidates[componentOf] = candidates[componentOf] || {};
-        candidates[componentOf][property.name] = property;
-      }
-    }
-  }
-
-  invalidateOrCompact(properties, i, candidates, validator);
-}
-
-function invalidateOrCompact(properties, position, candidates, validator) {
-  var invalidatedBy = properties[position];
-  var shorthandName;
-  var shorthandDescriptor;
-  var candidateComponents;
-
-  for (shorthandName in candidates) {
-    if (undefined !== invalidatedBy && shorthandName == invalidatedBy.name) {
-      continue;
-    }
-
-    shorthandDescriptor = compactable[shorthandName];
-    candidateComponents = candidates[shorthandName];
-    if (invalidatedBy && invalidates(candidates, shorthandName, invalidatedBy)) {
-      delete candidates[shorthandName];
-      continue;
-    }
-
-    if (shorthandDescriptor.components.length > Object.keys(candidateComponents).length) {
-      continue;
-    }
-
-    if (mixedImportance(candidateComponents)) {
-      continue;
-    }
-
-    if (!overridable(candidateComponents, shorthandName, validator)) {
-      continue;
-    }
-
-    if (!mergeable(candidateComponents)) {
-      continue;
-    }
-
-    if (mixedInherit(candidateComponents)) {
-      replaceWithInheritBestFit(properties, candidateComponents, shorthandName, validator);
-    } else {
-      replaceWithShorthand(properties, candidateComponents, shorthandName, validator);
-    }
-  }
-}
-
-function invalidates(candidates, shorthandName, invalidatedBy) {
-  var shorthandDescriptor = compactable[shorthandName];
-  var invalidatedByDescriptor = compactable[invalidatedBy.name];
-  var componentName;
-
-  if ('overridesShorthands' in shorthandDescriptor && shorthandDescriptor.overridesShorthands.indexOf(invalidatedBy.name) > -1) {
-    return true;
-  }
-
-  if (invalidatedByDescriptor && 'componentOf' in invalidatedByDescriptor) {
-    for (componentName in candidates[shorthandName]) {
-      if (invalidatedByDescriptor.componentOf.indexOf(componentName) > -1) {
-        return true;
-      }
-    }
-  }
-
-  return false;
-}
-
-function mixedImportance(components) {
-  var important;
-  var componentName;
-
-  for (componentName in components) {
-    if (undefined !== important && components[componentName].important != important) {
-      return true;
-    }
-
-    important = components[componentName].important;
-  }
-
-  return false;
-}
-
-function overridable(components, shorthandName, validator) {
-  var descriptor = compactable[shorthandName];
-  var newValuePlaceholder = [
-    Token.PROPERTY,
-    [Token.PROPERTY_NAME, shorthandName],
-    [Token.PROPERTY_VALUE, descriptor.defaultValue]
-  ];
-  var newProperty = wrapSingle(newValuePlaceholder);
-  var component;
-  var mayOverride;
-  var i, l;
-
-  populateComponents([newProperty], validator, []);
-
-  for (i = 0, l = descriptor.components.length; i < l; i++) {
-    component = components[descriptor.components[i]];
-    mayOverride = compactable[component.name].canOverride;
-
-    if (!everyValuesPair(mayOverride.bind(null, validator), newProperty.components[i], component)) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-function mergeable(components) {
-  var lastCount = null;
-  var currentCount;
-  var componentName;
-  var component;
-  var descriptor;
-  var values;
-
-  for (componentName in components) {
-    component = components[componentName];
-    descriptor = compactable[componentName];
-
-    if (!('restore' in descriptor)) {
-      continue;
-    }
-
-    restoreFromOptimizing([component.all[component.position]], restoreWithComponents);
-    values = descriptor.restore(component, compactable);
-
-    currentCount = values.length;
-
-    if (lastCount !== null && currentCount !== lastCount) {
-      return false;
-    }
-
-    lastCount = currentCount;
-  }
-
-  return true;
-}
-
-function mixedInherit(components) {
-  var componentName;
-  var lastValue = null;
-  var currentValue;
-
-  for (componentName in components) {
-    currentValue = hasInherit(components[componentName]);
-
-    if (lastValue !== null && lastValue !== currentValue) {
-      return true;
-    }
-
-    lastValue = currentValue;
-  }
-
-  return false;
-}
-
-function replaceWithInheritBestFit(properties, candidateComponents, shorthandName, validator) {
-  var viaLonghands = buildSequenceWithInheritLonghands(candidateComponents, shorthandName, validator);
-  var viaShorthand = buildSequenceWithInheritShorthand(candidateComponents, shorthandName, validator);
-  var longhandTokensSequence = viaLonghands[0];
-  var shorthandTokensSequence = viaShorthand[0];
-  var isLonghandsShorter = serializeBody(longhandTokensSequence).length < serializeBody(shorthandTokensSequence).length;
-  var newTokensSequence = isLonghandsShorter ? longhandTokensSequence : shorthandTokensSequence;
-  var newProperty = isLonghandsShorter ? viaLonghands[1] : viaShorthand[1];
-  var newComponents = isLonghandsShorter ? viaLonghands[2] : viaShorthand[2];
-  var all = candidateComponents[Object.keys(candidateComponents)[0]].all;
-  var componentName;
-  var oldComponent;
-  var newComponent;
-  var newToken;
-
-  newProperty.position = all.length;
-  newProperty.shorthand = true;
-  newProperty.dirty = true;
-  newProperty.all = all;
-  newProperty.all.push(newTokensSequence[0]);
-
-  properties.push(newProperty);
-
-  for (componentName in candidateComponents) {
-    oldComponent = candidateComponents[componentName];
-    oldComponent.unused = true;
-
-    if (oldComponent.name in newComponents) {
-      newComponent = newComponents[oldComponent.name];
-      newToken = findTokenIn(newTokensSequence, componentName);
-
-      newComponent.position = all.length;
-      newComponent.all = all;
-      newComponent.all.push(newToken);
-
-      properties.push(newComponent);
-    }
-  }
-}
-
-function buildSequenceWithInheritLonghands(components, shorthandName, validator) {
-  var tokensSequence = [];
-  var inheritComponents = {};
-  var nonInheritComponents = {};
-  var descriptor = compactable[shorthandName];
-  var shorthandToken = [
-    Token.PROPERTY,
-    [Token.PROPERTY_NAME, shorthandName],
-    [Token.PROPERTY_VALUE, descriptor.defaultValue]
-  ];
-  var newProperty = wrapSingle(shorthandToken);
-  var component;
-  var longhandToken;
-  var newComponent;
-  var nameMetadata;
-  var i, l;
-
-  populateComponents([newProperty], validator, []);
-
-  for (i = 0, l = descriptor.components.length; i < l; i++) {
-    component = components[descriptor.components[i]];
-
-    if (hasInherit(component)) {
-      longhandToken = component.all[component.position].slice(0, 2);
-      Array.prototype.push.apply(longhandToken, component.value);
-      tokensSequence.push(longhandToken);
-
-      newComponent = deepClone(component);
-      newComponent.value = inferComponentValue(components, newComponent.name);
-
-      newProperty.components[i] = newComponent;
-      inheritComponents[component.name] = deepClone(component);
-    } else {
-      newComponent = deepClone(component);
-      newComponent.all = component.all;
-      newProperty.components[i] = newComponent;
-
-      nonInheritComponents[component.name] = component;
-    }
-  }
-
-  nameMetadata = joinMetadata(nonInheritComponents, 1);
-  shorthandToken[1].push(nameMetadata);
-
-  restoreFromOptimizing([newProperty], restoreWithComponents);
-
-  shorthandToken = shorthandToken.slice(0, 2);
-  Array.prototype.push.apply(shorthandToken, newProperty.value);
-
-  tokensSequence.unshift(shorthandToken);
-
-  return [tokensSequence, newProperty, inheritComponents];
-}
-
-function inferComponentValue(components, propertyName) {
-  var descriptor = compactable[propertyName];
-
-  if ('oppositeTo' in descriptor) {
-    return components[descriptor.oppositeTo].value;
-  } else {
-    return [[Token.PROPERTY_VALUE, descriptor.defaultValue]];
-  }
-}
-
-function joinMetadata(components, at) {
-  var metadata = [];
-  var component;
-  var originalValue;
-  var componentMetadata;
-  var componentName;
-
-  for (componentName in components) {
-    component = components[componentName];
-    originalValue = component.all[component.position];
-    componentMetadata = originalValue[at][originalValue[at].length - 1];
-
-    Array.prototype.push.apply(metadata, componentMetadata);
-  }
-
-  return metadata.sort(metadataSorter);
-}
-
-function metadataSorter(metadata1, metadata2) {
-  var line1 = metadata1[0];
-  var line2 = metadata2[0];
-  var column1 = metadata1[1];
-  var column2 = metadata2[1];
-
-  if (line1 < line2) {
-    return -1;
-  } else if (line1 === line2) {
-    return column1 < column2 ? -1 : 1;
-  } else {
-    return 1;
-  }
-}
-
-function buildSequenceWithInheritShorthand(components, shorthandName, validator) {
-  var tokensSequence = [];
-  var inheritComponents = {};
-  var nonInheritComponents = {};
-  var descriptor = compactable[shorthandName];
-  var shorthandToken = [
-    Token.PROPERTY,
-    [Token.PROPERTY_NAME, shorthandName],
-    [Token.PROPERTY_VALUE, 'inherit']
-  ];
-  var newProperty = wrapSingle(shorthandToken);
-  var component;
-  var longhandToken;
-  var nameMetadata;
-  var valueMetadata;
-  var i, l;
-
-  populateComponents([newProperty], validator, []);
-
-  for (i = 0, l = descriptor.components.length; i < l; i++) {
-    component = components[descriptor.components[i]];
-
-    if (hasInherit(component)) {
-      inheritComponents[component.name] = component;
-    } else {
-      longhandToken = component.all[component.position].slice(0, 2);
-      Array.prototype.push.apply(longhandToken, component.value);
-      tokensSequence.push(longhandToken);
-
-      nonInheritComponents[component.name] = deepClone(component);
-    }
-  }
-
-  nameMetadata = joinMetadata(inheritComponents, 1);
-  shorthandToken[1].push(nameMetadata);
-
-  valueMetadata = joinMetadata(inheritComponents, 2);
-  shorthandToken[2].push(valueMetadata);
-
-  tokensSequence.unshift(shorthandToken);
-
-  return [tokensSequence, newProperty, nonInheritComponents];
-}
-
-function findTokenIn(tokens, componentName) {
-  var i, l;
-
-  for (i = 0, l = tokens.length; i < l; i++) {
-    if (tokens[i][1][1] == componentName) {
-      return tokens[i];
-    }
-  }
-}
-
-function replaceWithShorthand(properties, candidateComponents, shorthandName, validator) {
-  var descriptor = compactable[shorthandName];
-  var nameMetadata;
-  var valueMetadata;
-  var newValuePlaceholder = [
-    Token.PROPERTY,
-    [Token.PROPERTY_NAME, shorthandName],
-    [Token.PROPERTY_VALUE, descriptor.defaultValue]
-  ];
-  var all;
-
-  var newProperty = wrapSingle(newValuePlaceholder);
-  newProperty.shorthand = true;
-  newProperty.dirty = true;
-
-  populateComponents([newProperty], validator, []);
-
-  for (var i = 0, l = descriptor.components.length; i < l; i++) {
-    var component = candidateComponents[descriptor.components[i]];
-
-    newProperty.components[i] = deepClone(component);
-    newProperty.important = component.important;
-
-    all = component.all;
-  }
-
-  for (var componentName in candidateComponents) {
-    candidateComponents[componentName].unused = true;
-  }
-
-  nameMetadata = joinMetadata(candidateComponents, 1);
-  newValuePlaceholder[1].push(nameMetadata);
-
-  valueMetadata = joinMetadata(candidateComponents, 2);
-  newValuePlaceholder[2].push(valueMetadata);
-
-  newProperty.position = all.length;
-  newProperty.all = all;
-  newProperty.all.push(newValuePlaceholder);
-
-  properties.push(newProperty);
-}
-
-module.exports = mergeIntoShorthands;

node_modules/clean-css/lib/optimizer/level-2/properties/optimize.js

@@ -1,40 +0,0 @@
-var mergeIntoShorthands = require('./merge-into-shorthands');
-var overrideProperties = require('./override-properties');
-var populateComponents = require('./populate-components');
-
-var restoreWithComponents = require('../restore-with-components');
-
-var wrapForOptimizing = require('../../wrap-for-optimizing').all;
-var removeUnused = require('../../remove-unused');
-var restoreFromOptimizing = require('../../restore-from-optimizing');
-
-var OptimizationLevel = require('../../../options/optimization-level').OptimizationLevel;
-
-function optimizeProperties(properties, withOverriding, withMerging, context) {
-  var levelOptions = context.options.level[OptimizationLevel.Two];
-  var _properties = wrapForOptimizing(properties, false, levelOptions.skipProperties);
-  var _property;
-  var i, l;
-
-  populateComponents(_properties, context.validator, context.warnings);
-
-  for (i = 0, l = _properties.length; i < l; i++) {
-    _property = _properties[i];
-    if (_property.block) {
-      optimizeProperties(_property.value[0][1], withOverriding, withMerging, context);
-    }
-  }
-
-  if (withMerging && levelOptions.mergeIntoShorthands) {
-    mergeIntoShorthands(_properties, context.validator);
-  }
-
-  if (withOverriding && levelOptions.overrideProperties) {
-    overrideProperties(_properties, withMerging, context.options.compatibility, context.validator);
-  }
-
-  restoreFromOptimizing(_properties, restoreWithComponents);
-  removeUnused(_properties);
-}
-
-module.exports = optimizeProperties;

node_modules/clean-css/lib/optimizer/level-2/properties/override-properties.js

@@ -1,484 +0,0 @@
-var hasInherit = require('./has-inherit');
-var everyValuesPair = require('./every-values-pair');
-var findComponentIn = require('./find-component-in');
-var isComponentOf = require('./is-component-of');
-var isMergeableShorthand = require('./is-mergeable-shorthand');
-var overridesNonComponentShorthand = require('./overrides-non-component-shorthand');
-var sameVendorPrefixesIn = require('./vendor-prefixes').same;
-
-var compactable = require('../compactable');
-var deepClone = require('../clone').deep;
-var restoreWithComponents = require('../restore-with-components');
-var shallowClone = require('../clone').shallow;
-
-var restoreFromOptimizing = require('../../restore-from-optimizing');
-
-var Token = require('../../../tokenizer/token');
-var Marker = require('../../../tokenizer/marker');
-
-var serializeProperty = require('../../../writer/one-time').property;
-
-function wouldBreakCompatibility(property, validator) {
-  for (var i = 0; i < property.components.length; i++) {
-    var component = property.components[i];
-    var descriptor = compactable[component.name];
-    var canOverride = descriptor && descriptor.canOverride || canOverride.sameValue;
-
-    var _component = shallowClone(component);
-    _component.value = [[Token.PROPERTY_VALUE, descriptor.defaultValue]];
-
-    if (!everyValuesPair(canOverride.bind(null, validator), _component, component)) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-function overrideIntoMultiplex(property, by) {
-  by.unused = true;
-
-  turnIntoMultiplex(by, multiplexSize(property));
-  property.value = by.value;
-}
-
-function overrideByMultiplex(property, by) {
-  by.unused = true;
-  property.multiplex = true;
-  property.value = by.value;
-}
-
-function overrideSimple(property, by) {
-  by.unused = true;
-  property.value = by.value;
-}
-
-function override(property, by) {
-  if (by.multiplex)
-    overrideByMultiplex(property, by);
-  else if (property.multiplex)
-    overrideIntoMultiplex(property, by);
-  else
-    overrideSimple(property, by);
-}
-
-function overrideShorthand(property, by) {
-  by.unused = true;
-
-  for (var i = 0, l = property.components.length; i < l; i++) {
-    override(property.components[i], by.components[i], property.multiplex);
-  }
-}
-
-function turnIntoMultiplex(property, size) {
-  property.multiplex = true;
-
-  if (compactable[property.name].shorthand) {
-    turnShorthandValueIntoMultiplex(property, size);
-  } else {
-    turnLonghandValueIntoMultiplex(property, size);
-  }
-}
-
-function turnShorthandValueIntoMultiplex(property, size) {
-  var component;
-  var i, l;
-
-  for (i = 0, l = property.components.length; i < l; i++) {
-    component = property.components[i];
-
-    if (!component.multiplex) {
-      turnLonghandValueIntoMultiplex(component, size);
-    }
-  }
-}
-
-function turnLonghandValueIntoMultiplex(property, size) {
-  var descriptor = compactable[property.name];
-  var withRealValue = descriptor.intoMultiplexMode == 'real';
-  var withValue = descriptor.intoMultiplexMode == 'real' ?
-    property.value.slice(0) :
-    (descriptor.intoMultiplexMode == 'placeholder' ? descriptor.placeholderValue : descriptor.defaultValue);
-  var i = multiplexSize(property);
-  var j;
-  var m = withValue.length;
-
-  for (; i < size; i++) {
-    property.value.push([Token.PROPERTY_VALUE, Marker.COMMA]);
-
-    if (Array.isArray(withValue)) {
-      for (j = 0; j < m; j++) {
-        property.value.push(withRealValue ? withValue[j] : [Token.PROPERTY_VALUE, withValue[j]]);
-      }
-    } else {
-      property.value.push(withRealValue ? withValue : [Token.PROPERTY_VALUE, withValue]);
-    }
-  }
-}
-
-function multiplexSize(component) {
-  var size = 0;
-
-  for (var i = 0, l = component.value.length; i < l; i++) {
-    if (component.value[i][1] == Marker.COMMA)
-      size++;
-  }
-
-  return size + 1;
-}
-
-function lengthOf(property) {
-  var fakeAsArray = [
-    Token.PROPERTY,
-    [Token.PROPERTY_NAME, property.name]
-  ].concat(property.value);
-  return serializeProperty([fakeAsArray], 0).length;
-}
-
-function moreSameShorthands(properties, startAt, name) {
-  // Since we run the main loop in `compactOverrides` backwards, at this point some
-  // properties may not be marked as unused.
-  // We should consider reverting the order if possible
-  var count = 0;
-
-  for (var i = startAt; i >= 0; i--) {
-    if (properties[i].name == name && !properties[i].unused)
-      count++;
-    if (count > 1)
-      break;
-  }
-
-  return count > 1;
-}
-
-function overridingFunction(shorthand, validator) {
-  for (var i = 0, l = shorthand.components.length; i < l; i++) {
-    if (!anyValue(validator.isUrl, shorthand.components[i]) && anyValue(validator.isFunction, shorthand.components[i])) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-function anyValue(fn, property) {
-  for (var i = 0, l = property.value.length; i < l; i++) {
-    if (property.value[i][1] == Marker.COMMA)
-      continue;
-
-    if (fn(property.value[i][1]))
-      return true;
-  }
-
-  return false;
-}
-
-function wouldResultInLongerValue(left, right) {
-  if (!left.multiplex && !right.multiplex || left.multiplex && right.multiplex)
-    return false;
-
-  var multiplex = left.multiplex ? left : right;
-  var simple = left.multiplex ? right : left;
-  var component;
-
-  var multiplexClone = deepClone(multiplex);
-  restoreFromOptimizing([multiplexClone], restoreWithComponents);
-
-  var simpleClone = deepClone(simple);
-  restoreFromOptimizing([simpleClone], restoreWithComponents);
-
-  var lengthBefore = lengthOf(multiplexClone) + 1 + lengthOf(simpleClone);
-
-  if (left.multiplex) {
-    component = findComponentIn(multiplexClone, simpleClone);
-    overrideIntoMultiplex(component, simpleClone);
-  } else {
-    component = findComponentIn(simpleClone, multiplexClone);
-    turnIntoMultiplex(simpleClone, multiplexSize(multiplexClone));
-    overrideByMultiplex(component, multiplexClone);
-  }
-
-  restoreFromOptimizing([simpleClone], restoreWithComponents);
-
-  var lengthAfter = lengthOf(simpleClone);
-
-  return lengthBefore <= lengthAfter;
-}
-
-function isCompactable(property) {
-  return property.name in compactable;
-}
-
-function noneOverrideHack(left, right) {
-  return !left.multiplex &&
-    (left.name == 'background' || left.name == 'background-image') &&
-    right.multiplex &&
-    (right.name == 'background' || right.name == 'background-image') &&
-    anyLayerIsNone(right.value);
-}
-
-function anyLayerIsNone(values) {
-  var layers = intoLayers(values);
-
-  for (var i = 0, l = layers.length; i < l; i++) {
-    if (layers[i].length == 1 && layers[i][0][1] == 'none')
-      return true;
-  }
-
-  return false;
-}
-
-function intoLayers(values) {
-  var layers = [];
-
-  for (var i = 0, layer = [], l = values.length; i < l; i++) {
-    var value = values[i];
-    if (value[1] == Marker.COMMA) {
-      layers.push(layer);
-      layer = [];
-    } else {
-      layer.push(value);
-    }
-  }
-
-  layers.push(layer);
-  return layers;
-}
-
-function overrideProperties(properties, withMerging, compatibility, validator) {
-  var mayOverride, right, left, component;
-  var overriddenComponents;
-  var overriddenComponent;
-  var overridingComponent;
-  var overridable;
-  var i, j, k;
-
-  propertyLoop:
-  for (i = properties.length - 1; i >= 0; i--) {
-    right = properties[i];
-
-    if (!isCompactable(right))
-      continue;
-
-    if (right.block)
-      continue;
-
-    mayOverride = compactable[right.name].canOverride;
-
-    traverseLoop:
-    for (j = i - 1; j >= 0; j--) {
-      left = properties[j];
-
-      if (!isCompactable(left))
-        continue;
-
-      if (left.block)
-        continue;
-
-      if (left.unused || right.unused)
-        continue;
-
-      if (left.hack && !right.hack && !right.important || !left.hack && !left.important && right.hack)
-        continue;
-
-      if (left.important == right.important && left.hack[0] != right.hack[0])
-        continue;
-
-      if (left.important == right.important && (left.hack[0] != right.hack[0] || (left.hack[1] && left.hack[1] != right.hack[1])))
-        continue;
-
-      if (hasInherit(right))
-        continue;
-
-      if (noneOverrideHack(left, right))
-        continue;
-
-      if (right.shorthand && isComponentOf(right, left)) {
-        // maybe `left` can be overridden by `right` which is a shorthand?
-        if (!right.important && left.important)
-          continue;
-
-        if (!sameVendorPrefixesIn([left], right.components))
-          continue;
-
-        if (!anyValue(validator.isFunction, left) && overridingFunction(right, validator))
-          continue;
-
-        if (!isMergeableShorthand(right)) {
-          left.unused = true;
-          continue;
-        }
-
-        component = findComponentIn(right, left);
-        mayOverride = compactable[left.name].canOverride;
-        if (everyValuesPair(mayOverride.bind(null, validator), left, component)) {
-          left.unused = true;
-        }
-      } else if (right.shorthand && overridesNonComponentShorthand(right, left)) {
-        // `right` is a shorthand while `left` can be overriden by it, think `border` and `border-top`
-        if (!right.important && left.important) {
-          continue;
-        }
-
-        if (!sameVendorPrefixesIn([left], right.components)) {
-          continue;
-        }
-
-        if (!anyValue(validator.isFunction, left) && overridingFunction(right, validator)) {
-          continue;
-        }
-
-        overriddenComponents = left.shorthand ?
-          left.components:
-          [left];
-
-        for (k = overriddenComponents.length - 1; k >= 0; k--) {
-          overriddenComponent = overriddenComponents[k];
-          overridingComponent = findComponentIn(right, overriddenComponent);
-          mayOverride = compactable[overriddenComponent.name].canOverride;
-
-          if (!everyValuesPair(mayOverride.bind(null, validator), left, overridingComponent)) {
-            continue traverseLoop;
-          }
-        }
-
-        left.unused = true;
-      } else if (withMerging && left.shorthand && !right.shorthand && isComponentOf(left, right, true)) {
-        // maybe `right` can be pulled into `left` which is a shorthand?
-        if (right.important && !left.important)
-          continue;
-
-        if (!right.important && left.important) {
-          right.unused = true;
-          continue;
-        }
-
-        // Pending more clever algorithm in #527
-        if (moreSameShorthands(properties, i - 1, left.name))
-          continue;
-
-        if (overridingFunction(left, validator))
-          continue;
-
-        if (!isMergeableShorthand(left))
-          continue;
-
-        component = findComponentIn(left, right);
-        if (everyValuesPair(mayOverride.bind(null, validator), component, right)) {
-          var disabledBackgroundMerging =
-            !compatibility.properties.backgroundClipMerging && component.name.indexOf('background-clip') > -1 ||
-            !compatibility.properties.backgroundOriginMerging && component.name.indexOf('background-origin') > -1 ||
-            !compatibility.properties.backgroundSizeMerging && component.name.indexOf('background-size') > -1;
-          var nonMergeableValue = compactable[right.name].nonMergeableValue === right.value[0][1];
-
-          if (disabledBackgroundMerging || nonMergeableValue)
-            continue;
-
-          if (!compatibility.properties.merging && wouldBreakCompatibility(left, validator))
-            continue;
-
-          if (component.value[0][1] != right.value[0][1] && (hasInherit(left) || hasInherit(right)))
-            continue;
-
-          if (wouldResultInLongerValue(left, right))
-            continue;
-
-          if (!left.multiplex && right.multiplex)
-            turnIntoMultiplex(left, multiplexSize(right));
-
-          override(component, right);
-          left.dirty = true;
-        }
-      } else if (withMerging && left.shorthand && right.shorthand && left.name == right.name) {
-        // merge if all components can be merged
-
-        if (!left.multiplex && right.multiplex)
-          continue;
-
-        if (!right.important && left.important) {
-          right.unused = true;
-          continue propertyLoop;
-        }
-
-        if (right.important && !left.important) {
-          left.unused = true;
-          continue;
-        }
-
-        if (!isMergeableShorthand(right)) {
-          left.unused = true;
-          continue;
-        }
-
-        for (k = left.components.length - 1; k >= 0; k--) {
-          var leftComponent = left.components[k];
-          var rightComponent = right.components[k];
-
-          mayOverride = compactable[leftComponent.name].canOverride;
-          if (!everyValuesPair(mayOverride.bind(null, validator), leftComponent, rightComponent))
-            continue propertyLoop;
-        }
-
-        overrideShorthand(left, right);
-        left.dirty = true;
-      } else if (withMerging && left.shorthand && right.shorthand && isComponentOf(left, right)) {
-        // border is a shorthand but any of its components is a shorthand too
-
-        if (!left.important && right.important)
-          continue;
-
-        component = findComponentIn(left, right);
-        mayOverride = compactable[right.name].canOverride;
-        if (!everyValuesPair(mayOverride.bind(null, validator), component, right))
-          continue;
-
-        if (left.important && !right.important) {
-          right.unused = true;
-          continue;
-        }
-
-        var rightRestored = compactable[right.name].restore(right, compactable);
-        if (rightRestored.length > 1)
-          continue;
-
-        component = findComponentIn(left, right);
-        override(component, right);
-        right.dirty = true;
-      } else if (left.name == right.name) {
-        // two non-shorthands should be merged based on understandability
-        overridable = true;
-
-        if (right.shorthand) {
-          for (k = right.components.length - 1; k >= 0 && overridable; k--) {
-            overriddenComponent = left.components[k];
-            overridingComponent = right.components[k];
-            mayOverride = compactable[overridingComponent.name].canOverride;
-
-            overridable = overridable && everyValuesPair(mayOverride.bind(null, validator), overriddenComponent, overridingComponent);
-          }
-        } else {
-          mayOverride = compactable[right.name].canOverride;
-          overridable = everyValuesPair(mayOverride.bind(null, validator), left, right);
-        }
-
-        if (left.important && !right.important && overridable) {
-          right.unused = true;
-          continue;
-        }
-
-        if (!left.important && right.important && overridable) {
-          left.unused = true;
-          continue;
-        }
-
-        if (!overridable) {
-          continue;
-        }
-
-        left.unused = true;
-      }
-    }
-  }
-}
-
-module.exports = overrideProperties;

node_modules/clean-css/lib/optimizer/level-2/properties/overrides-non-component-shorthand.js

@@ -1,9 +0,0 @@
-var compactable = require('../compactable');
-
-function overridesNonComponentShorthand(property1, property2) {
-  return property1.name in compactable &&
-    'overridesShorthands' in compactable[property1.name] &&
-    compactable[property1.name].overridesShorthands.indexOf(property2.name) > -1;
-}
-
-module.exports = overridesNonComponentShorthand;

node_modules/clean-css/lib/optimizer/level-2/properties/populate-components.js

@@ -1,42 +0,0 @@
-var compactable = require('../compactable');
-var InvalidPropertyError = require('../invalid-property-error');
-
-function populateComponents(properties, validator, warnings) {
-  var component;
-  var j, m;
-
-  for (var i = properties.length - 1; i >= 0; i--) {
-    var property = properties[i];
-    var descriptor = compactable[property.name];
-
-    if (descriptor && descriptor.shorthand) {
-      property.shorthand = true;
-      property.dirty = true;
-
-      try {
-        property.components = descriptor.breakUp(property, compactable, validator);
-
-        if (descriptor.shorthandComponents) {
-          for (j = 0, m = property.components.length; j < m; j++) {
-            component = property.components[j];
-            component.components = compactable[component.name].breakUp(component, compactable, validator);
-          }
-        }
-      } catch (e) {
-        if (e instanceof InvalidPropertyError) {
-          property.components = []; // this will set property.unused to true below
-          warnings.push(e.message);
-        } else {
-          throw e;
-        }
-      }
-
-      if (property.components.length > 0)
-        property.multiplex = property.components[0].multiplex;
-      else
-        property.unused = true;
-    }
-  }
-}
-
-module.exports = populateComponents;

node_modules/clean-css/lib/optimizer/level-2/properties/understandable.js

@@ -1,15 +0,0 @@
-var sameVendorPrefixes = require('./vendor-prefixes').same;
-
-function understandable(validator, value1, value2, _position, isPaired) {
-  if (!sameVendorPrefixes(value1, value2)) {
-    return false;
-  }
-
-  if (isPaired && validator.isVariable(value1) !== validator.isVariable(value2)) {
-    return false;
-  }
-
-  return true;
-}
-
-module.exports = understandable;

node_modules/clean-css/lib/optimizer/level-2/properties/vendor-prefixes.js

@@ -1,23 +0,0 @@
-var VENDOR_PREFIX_PATTERN = /(?:^|\W)(\-\w+\-)/g;
-
-function unique(value) {
-  var prefixes = [];
-  var match;
-
-  while ((match = VENDOR_PREFIX_PATTERN.exec(value)) !== null) {
-    if (prefixes.indexOf(match[0]) == -1) {
-      prefixes.push(match[0]);
-    }
-  }
-
-  return prefixes;
-}
-
-function same(value1, value2) {
-  return unique(value1).sort().join(',') == unique(value2).sort().join(',');
-}
-
-module.exports = {
-  unique: unique,
-  same: same
-};

node_modules/clean-css/lib/optimizer/level-2/reduce-non-adjacent.js

@@ -1,180 +0,0 @@
-var isMergeable = require('./is-mergeable');
-
-var optimizeProperties = require('./properties/optimize');
-
-var cloneArray = require('../../utils/clone-array');
-
-var Token = require('../../tokenizer/token');
-
-var serializeBody = require('../../writer/one-time').body;
-var serializeRules = require('../../writer/one-time').rules;
-
-function reduceNonAdjacent(tokens, context) {
-  var options = context.options;
-  var mergeablePseudoClasses = options.compatibility.selectors.mergeablePseudoClasses;
-  var mergeablePseudoElements = options.compatibility.selectors.mergeablePseudoElements;
-  var multiplePseudoMerging = options.compatibility.selectors.multiplePseudoMerging;
-  var candidates = {};
-  var repeated = [];
-
-  for (var i = tokens.length - 1; i >= 0; i--) {
-    var token = tokens[i];
-
-    if (token[0] != Token.RULE) {
-      continue;
-    } else if (token[2].length === 0) {
-      continue;
-    }
-
-    var selectorAsString = serializeRules(token[1]);
-    var isComplexAndNotSpecial = token[1].length > 1 &&
-      isMergeable(selectorAsString, mergeablePseudoClasses, mergeablePseudoElements, multiplePseudoMerging);
-    var wrappedSelectors = wrappedSelectorsFrom(token[1]);
-    var selectors = isComplexAndNotSpecial ?
-      [selectorAsString].concat(wrappedSelectors) :
-      [selectorAsString];
-
-    for (var j = 0, m = selectors.length; j < m; j++) {
-      var selector = selectors[j];
-
-      if (!candidates[selector])
-        candidates[selector] = [];
-      else
-        repeated.push(selector);
-
-      candidates[selector].push({
-        where: i,
-        list: wrappedSelectors,
-        isPartial: isComplexAndNotSpecial && j > 0,
-        isComplex: isComplexAndNotSpecial && j === 0
-      });
-    }
-  }
-
-  reduceSimpleNonAdjacentCases(tokens, repeated, candidates, options, context);
-  reduceComplexNonAdjacentCases(tokens, candidates, options, context);
-}
-
-function wrappedSelectorsFrom(list) {
-  var wrapped = [];
-
-  for (var i = 0; i < list.length; i++) {
-    wrapped.push([list[i][1]]);
-  }
-
-  return wrapped;
-}
-
-function reduceSimpleNonAdjacentCases(tokens, repeated, candidates, options, context) {
-  function filterOut(idx, bodies) {
-    return data[idx].isPartial && bodies.length === 0;
-  }
-
-  function reduceBody(token, newBody, processedCount, tokenIdx) {
-    if (!data[processedCount - tokenIdx - 1].isPartial)
-      token[2] = newBody;
-  }
-
-  for (var i = 0, l = repeated.length; i < l; i++) {
-    var selector = repeated[i];
-    var data = candidates[selector];
-
-    reduceSelector(tokens, data, {
-      filterOut: filterOut,
-      callback: reduceBody
-    }, options, context);
-  }
-}
-
-function reduceComplexNonAdjacentCases(tokens, candidates, options, context) {
-  var mergeablePseudoClasses = options.compatibility.selectors.mergeablePseudoClasses;
-  var mergeablePseudoElements = options.compatibility.selectors.mergeablePseudoElements;
-  var multiplePseudoMerging = options.compatibility.selectors.multiplePseudoMerging;
-  var localContext = {};
-
-  function filterOut(idx) {
-    return localContext.data[idx].where < localContext.intoPosition;
-  }
-
-  function collectReducedBodies(token, newBody, processedCount, tokenIdx) {
-    if (tokenIdx === 0)
-      localContext.reducedBodies.push(newBody);
-  }
-
-  allSelectors:
-  for (var complexSelector in candidates) {
-    var into = candidates[complexSelector];
-    if (!into[0].isComplex)
-      continue;
-
-    var intoPosition = into[into.length - 1].where;
-    var intoToken = tokens[intoPosition];
-    var reducedBodies = [];
-
-    var selectors = isMergeable(complexSelector, mergeablePseudoClasses, mergeablePseudoElements, multiplePseudoMerging) ?
-      into[0].list :
-      [complexSelector];
-
-    localContext.intoPosition = intoPosition;
-    localContext.reducedBodies = reducedBodies;
-
-    for (var j = 0, m = selectors.length; j < m; j++) {
-      var selector = selectors[j];
-      var data = candidates[selector];
-
-      if (data.length < 2)
-        continue allSelectors;
-
-      localContext.data = data;
-
-      reduceSelector(tokens, data, {
-        filterOut: filterOut,
-        callback: collectReducedBodies
-      }, options, context);
-
-      if (serializeBody(reducedBodies[reducedBodies.length - 1]) != serializeBody(reducedBodies[0]))
-        continue allSelectors;
-    }
-
-    intoToken[2] = reducedBodies[0];
-  }
-}
-
-function reduceSelector(tokens, data, context, options, outerContext) {
-  var bodies = [];
-  var bodiesAsList = [];
-  var processedTokens = [];
-
-  for (var j = data.length - 1; j >= 0; j--) {
-    if (context.filterOut(j, bodies))
-      continue;
-
-    var where = data[j].where;
-    var token = tokens[where];
-    var clonedBody = cloneArray(token[2]);
-
-    bodies = bodies.concat(clonedBody);
-    bodiesAsList.push(clonedBody);
-    processedTokens.push(where);
-  }
-
-  optimizeProperties(bodies, true, false, outerContext);
-
-  var processedCount = processedTokens.length;
-  var propertyIdx = bodies.length - 1;
-  var tokenIdx = processedCount - 1;
-
-  while (tokenIdx >= 0) {
-     if ((tokenIdx === 0 || (bodies[propertyIdx] && bodiesAsList[tokenIdx].indexOf(bodies[propertyIdx]) > -1)) && propertyIdx > -1) {
-      propertyIdx--;
-      continue;
-    }
-
-    var newBody = bodies.splice(propertyIdx + 1);
-    context.callback(tokens[processedTokens[tokenIdx]], newBody, processedCount, tokenIdx);
-
-    tokenIdx--;
-  }
-}
-
-module.exports = reduceNonAdjacent;

node_modules/clean-css/lib/optimizer/level-2/remove-duplicate-font-at-rules.js

@@ -1,30 +0,0 @@
-var Token = require('../../tokenizer/token');
-
-var serializeAll = require('../../writer/one-time').all;
-
-var FONT_FACE_SCOPE = '@font-face';
-
-function removeDuplicateFontAtRules(tokens) {
-  var fontAtRules = [];
-  var token;
-  var key;
-  var i, l;
-
-  for (i = 0, l = tokens.length; i < l; i++) {
-    token = tokens[i];
-
-    if (token[0] != Token.AT_RULE_BLOCK && token[1][0][1] != FONT_FACE_SCOPE) {
-      continue;
-    }
-
-    key = serializeAll([token]);
-
-    if (fontAtRules.indexOf(key) > -1) {
-      token[2] = [];
-    } else {
-      fontAtRules.push(key);
-    }
-  }
-}
-
-module.exports = removeDuplicateFontAtRules;

node_modules/clean-css/lib/optimizer/level-2/remove-duplicate-media-queries.js

@@ -1,30 +0,0 @@
-var Token = require('../../tokenizer/token');
-
-var serializeAll = require('../../writer/one-time').all;
-var serializeRules = require('../../writer/one-time').rules;
-
-function removeDuplicateMediaQueries(tokens) {
-  var candidates = {};
-  var candidate;
-  var token;
-  var key;
-  var i, l;
-
-  for (i = 0, l = tokens.length; i < l; i++) {
-    token = tokens[i];
-    if (token[0] != Token.NESTED_BLOCK) {
-      continue;
-    }
-
-    key = serializeRules(token[1]) + '%' + serializeAll(token[2]);
-    candidate = candidates[key];
-
-    if (candidate) {
-      candidate[2] = [];
-    }
-
-    candidates[key] = token;
-  }
-}
-
-module.exports = removeDuplicateMediaQueries;

node_modules/clean-css/lib/optimizer/level-2/remove-duplicates.js

@@ -1,43 +0,0 @@
-var Token = require('../../tokenizer/token');
-
-var serializeBody = require('../../writer/one-time').body;
-var serializeRules = require('../../writer/one-time').rules;
-
-function removeDuplicates(tokens) {
-  var matched = {};
-  var moreThanOnce = [];
-  var id, token;
-  var body, bodies;
-
-  for (var i = 0, l = tokens.length; i < l; i++) {
-    token = tokens[i];
-    if (token[0] != Token.RULE)
-      continue;
-
-    id = serializeRules(token[1]);
-
-    if (matched[id] && matched[id].length == 1)
-      moreThanOnce.push(id);
-    else
-      matched[id] = matched[id] || [];
-
-    matched[id].push(i);
-  }
-
-  for (i = 0, l = moreThanOnce.length; i < l; i++) {
-    id = moreThanOnce[i];
-    bodies = [];
-
-    for (var j = matched[id].length - 1; j >= 0; j--) {
-      token = tokens[matched[id][j]];
-      body = serializeBody(token[2]);
-
-      if (bodies.indexOf(body) > -1)
-        token[2] = [];
-      else
-        bodies.push(body);
-    }
-  }
-}
-
-module.exports = removeDuplicates;

node_modules/clean-css/lib/optimizer/level-2/remove-unused-at-rules.js

@@ -1,249 +0,0 @@
-var populateComponents = require('./properties/populate-components');
-
-var wrapForOptimizing = require('../wrap-for-optimizing').single;
-var restoreFromOptimizing = require('../restore-from-optimizing');
-
-var Token = require('../../tokenizer/token');
-
-var animationNameRegex = /^(\-moz\-|\-o\-|\-webkit\-)?animation-name$/;
-var animationRegex = /^(\-moz\-|\-o\-|\-webkit\-)?animation$/;
-var keyframeRegex = /^@(\-moz\-|\-o\-|\-webkit\-)?keyframes /;
-var importantRegex = /\s{0,31}!important$/;
-var optionalMatchingQuotesRegex = /^(['"]?)(.*)\1$/;
-
-function normalize(value) {
-  return value
-    .replace(optionalMatchingQuotesRegex, '$2')
-    .replace(importantRegex, '');
-}
-
-function removeUnusedAtRules(tokens, context) {
-  removeUnusedAtRule(tokens, matchCounterStyle, markCounterStylesAsUsed, context);
-  removeUnusedAtRule(tokens, matchFontFace, markFontFacesAsUsed, context);
-  removeUnusedAtRule(tokens, matchKeyframe, markKeyframesAsUsed, context);
-  removeUnusedAtRule(tokens, matchNamespace, markNamespacesAsUsed, context);
-}
-
-function removeUnusedAtRule(tokens, matchCallback, markCallback, context) {
-  var atRules = {};
-  var atRule;
-  var atRuleTokens;
-  var atRuleToken;
-  var zeroAt;
-  var i, l;
-
-  for (i = 0, l = tokens.length; i < l; i++) {
-    matchCallback(tokens[i], atRules);
-  }
-
-  if (Object.keys(atRules).length === 0) {
-    return;
-  }
-
-  markUsedAtRules(tokens, markCallback, atRules, context);
-
-  for (atRule in atRules) {
-    atRuleTokens = atRules[atRule];
-
-    for (i = 0, l = atRuleTokens.length; i < l; i++) {
-      atRuleToken = atRuleTokens[i];
-      zeroAt = atRuleToken[0] == Token.AT_RULE ? 1 : 2;
-      atRuleToken[zeroAt] = [];
-    }
-  }
-}
-
-function markUsedAtRules(tokens, markCallback, atRules, context) {
-  var boundMarkCallback = markCallback(atRules);
-  var i, l;
-
-  for (i = 0, l = tokens.length; i < l; i++) {
-    switch (tokens[i][0]) {
-      case Token.RULE:
-        boundMarkCallback(tokens[i], context);
-        break;
-      case Token.NESTED_BLOCK:
-        markUsedAtRules(tokens[i][2], markCallback, atRules, context);
-    }
-  }
-}
-
-function matchCounterStyle(token, atRules) {
-  var match;
-
-  if (token[0] == Token.AT_RULE_BLOCK && token[1][0][1].indexOf('@counter-style') === 0) {
-    match = token[1][0][1].split(' ')[1];
-    atRules[match] = atRules[match] || [];
-    atRules[match].push(token);
-  }
-}
-
-function markCounterStylesAsUsed(atRules) {
-  return function (token, context) {
-    var property;
-    var wrappedProperty;
-    var i, l;
-
-    for (i = 0, l = token[2].length; i < l; i++) {
-      property = token[2][i];
-
-      if (property[1][1] == 'list-style') {
-        wrappedProperty = wrapForOptimizing(property);
-        populateComponents([wrappedProperty], context.validator, context.warnings);
-
-        if (wrappedProperty.components[0].value[0][1] in atRules) {
-          delete atRules[property[2][1]];
-        }
-
-        restoreFromOptimizing([wrappedProperty]);
-      }
-
-      if (property[1][1] == 'list-style-type' && property[2][1] in atRules) {
-        delete atRules[property[2][1]];
-      }
-    }
-  };
-}
-
-function matchFontFace(token, atRules) {
-  var property;
-  var match;
-  var i, l;
-
-  if (token[0] == Token.AT_RULE_BLOCK && token[1][0][1] == '@font-face') {
-    for (i = 0, l = token[2].length; i < l; i++) {
-      property = token[2][i];
-
-      if (property[1][1] == 'font-family') {
-        match = normalize(property[2][1].toLowerCase());
-        atRules[match] = atRules[match] || [];
-        atRules[match].push(token);
-        break;
-      }
-    }
-  }
-}
-
-function markFontFacesAsUsed(atRules) {
-  return function (token, context) {
-    var property;
-    var wrappedProperty;
-    var component;
-    var normalizedMatch;
-    var i, l;
-    var j, m;
-
-    for (i = 0, l = token[2].length; i < l; i++) {
-      property = token[2][i];
-
-      if (property[1][1] == 'font') {
-        wrappedProperty = wrapForOptimizing(property);
-        populateComponents([wrappedProperty], context.validator, context.warnings);
-        component = wrappedProperty.components[6];
-
-        for (j = 0, m = component.value.length; j < m; j++) {
-          normalizedMatch = normalize(component.value[j][1].toLowerCase());
-
-          if (normalizedMatch in atRules) {
-            delete atRules[normalizedMatch];
-          }
-        }
-
-        restoreFromOptimizing([wrappedProperty]);
-      }
-
-      if (property[1][1] == 'font-family') {
-        for (j = 2, m = property.length; j < m; j++) {
-          normalizedMatch = normalize(property[j][1].toLowerCase());
-
-          if (normalizedMatch in atRules) {
-            delete atRules[normalizedMatch];
-          }
-        }
-      }
-    }
-  };
-}
-
-function matchKeyframe(token, atRules) {
-  var match;
-
-  if (token[0] == Token.NESTED_BLOCK && keyframeRegex.test(token[1][0][1])) {
-    match = token[1][0][1].split(' ')[1];
-    atRules[match] = atRules[match] || [];
-    atRules[match].push(token);
-  }
-}
-
-function markKeyframesAsUsed(atRules) {
-  return function (token, context) {
-    var property;
-    var wrappedProperty;
-    var component;
-    var i, l;
-    var j, m;
-
-    for (i = 0, l = token[2].length; i < l; i++) {
-      property = token[2][i];
-
-      if (animationRegex.test(property[1][1])) {
-        wrappedProperty = wrapForOptimizing(property);
-        populateComponents([wrappedProperty], context.validator, context.warnings);
-        component = wrappedProperty.components[7];
-
-        for (j = 0, m = component.value.length; j < m; j++) {
-          if (component.value[j][1] in atRules) {
-            delete atRules[component.value[j][1]];
-          }
-        }
-
-        restoreFromOptimizing([wrappedProperty]);
-      }
-
-      if (animationNameRegex.test(property[1][1])) {
-        for (j = 2, m = property.length; j < m; j++) {
-          if (property[j][1] in atRules) {
-            delete atRules[property[j][1]];
-          }
-        }
-      }
-    }
-  };
-}
-
-function matchNamespace(token, atRules) {
-  var match;
-
-  if (token[0] == Token.AT_RULE && token[1].indexOf('@namespace') === 0) {
-    match = token[1].split(' ')[1];
-    atRules[match] = atRules[match] || [];
-    atRules[match].push(token);
-  }
-}
-
-function markNamespacesAsUsed(atRules) {
-  var namespaceRegex = new RegExp(Object.keys(atRules).join('\\\||') + '\\\|', 'g');
-
-  return function (token) {
-    var match;
-    var scope;
-    var normalizedMatch;
-    var i, l;
-    var j, m;
-
-    for (i = 0, l = token[1].length; i < l; i++) {
-      scope = token[1][i];
-      match = scope[1].match(namespaceRegex);
-
-      for (j = 0, m = match.length; j < m; j++) {
-        normalizedMatch = match[j].substring(0, match[j].length - 1);
-
-        if (normalizedMatch in atRules) {
-          delete atRules[normalizedMatch];
-        }
-      }
-    }
-  };
-}
-
-module.exports = removeUnusedAtRules;

node_modules/clean-css/lib/optimizer/level-2/reorderable.js

@@ -1,93 +0,0 @@
-// TODO: it'd be great to merge it with the other canReorder functionality
-
-var rulesOverlap = require('./rules-overlap');
-var specificitiesOverlap = require('./specificities-overlap');
-
-var FLEX_PROPERTIES = /align\-items|box\-align|box\-pack|flex|justify/;
-var BORDER_PROPERTIES = /^border\-(top|right|bottom|left|color|style|width|radius)/;
-
-function canReorder(left, right, cache) {
-  for (var i = right.length - 1; i >= 0; i--) {
-    for (var j = left.length - 1; j >= 0; j--) {
-      if (!canReorderSingle(left[j], right[i], cache))
-        return false;
-    }
-  }
-
-  return true;
-}
-
-function canReorderSingle(left, right, cache) {
-  var leftName = left[0];
-  var leftValue = left[1];
-  var leftNameRoot = left[2];
-  var leftSelector = left[5];
-  var leftInSpecificSelector = left[6];
-  var rightName = right[0];
-  var rightValue = right[1];
-  var rightNameRoot = right[2];
-  var rightSelector = right[5];
-  var rightInSpecificSelector = right[6];
-
-  if (leftName == 'font' && rightName == 'line-height' || rightName == 'font' && leftName == 'line-height')
-    return false;
-  if (FLEX_PROPERTIES.test(leftName) && FLEX_PROPERTIES.test(rightName))
-    return false;
-  if (leftNameRoot == rightNameRoot && unprefixed(leftName) == unprefixed(rightName) && (vendorPrefixed(leftName) ^ vendorPrefixed(rightName)))
-    return false;
-  if (leftNameRoot == 'border' && BORDER_PROPERTIES.test(rightNameRoot) && (leftName == 'border' || leftName == rightNameRoot || (leftValue != rightValue && sameBorderComponent(leftName, rightName))))
-    return false;
-  if (rightNameRoot == 'border' && BORDER_PROPERTIES.test(leftNameRoot) && (rightName == 'border' || rightName == leftNameRoot || (leftValue != rightValue && sameBorderComponent(leftName, rightName))))
-    return false;
-  if (leftNameRoot == 'border' && rightNameRoot == 'border' && leftName != rightName && (isSideBorder(leftName) && isStyleBorder(rightName) || isStyleBorder(leftName) && isSideBorder(rightName)))
-    return false;
-  if (leftNameRoot != rightNameRoot)
-    return true;
-  if (leftName == rightName && leftNameRoot == rightNameRoot && (leftValue == rightValue || withDifferentVendorPrefix(leftValue, rightValue)))
-    return true;
-  if (leftName != rightName && leftNameRoot == rightNameRoot && leftName != leftNameRoot && rightName != rightNameRoot)
-    return true;
-  if (leftName != rightName && leftNameRoot == rightNameRoot && leftValue == rightValue)
-    return true;
-  if (rightInSpecificSelector && leftInSpecificSelector && !inheritable(leftNameRoot) && !inheritable(rightNameRoot) && !rulesOverlap(rightSelector, leftSelector, false))
-    return true;
-  if (!specificitiesOverlap(leftSelector, rightSelector, cache))
-    return true;
-
-  return false;
-}
-
-function vendorPrefixed(name) {
-  return /^\-(?:moz|webkit|ms|o)\-/.test(name);
-}
-
-function unprefixed(name) {
-  return name.replace(/^\-(?:moz|webkit|ms|o)\-/, '');
-}
-
-function sameBorderComponent(name1, name2) {
-  return name1.split('-').pop() == name2.split('-').pop();
-}
-
-function isSideBorder(name) {
-  return name == 'border-top' || name == 'border-right' || name == 'border-bottom' || name == 'border-left';
-}
-
-function isStyleBorder(name) {
-  return name == 'border-color' || name == 'border-style' || name == 'border-width';
-}
-
-function withDifferentVendorPrefix(value1, value2) {
-  return vendorPrefixed(value1) && vendorPrefixed(value2) && value1.split('-')[1] != value2.split('-')[2];
-}
-
-function inheritable(name) {
-  // According to http://www.w3.org/TR/CSS21/propidx.html
-  // Others will be catched by other, preceeding rules
-  return name == 'font' || name == 'line-height' || name == 'list-style';
-}
-
-module.exports = {
-  canReorder: canReorder,
-  canReorderSingle: canReorderSingle
-};

node_modules/clean-css/lib/optimizer/level-2/restore-with-components.js

@@ -1,13 +0,0 @@
-var compactable = require('./compactable');
-
-function restoreWithComponents(property) {
-  var descriptor = compactable[property.name];
-
-  if (descriptor && descriptor.shorthand) {
-    return descriptor.restore(property, compactable);
-  } else {
-    return property.value;
-  }
-}
-
-module.exports = restoreWithComponents;

node_modules/clean-css/lib/optimizer/level-2/restore.js

@@ -1,303 +0,0 @@
-var shallowClone = require('./clone').shallow;
-
-var Token = require('../../tokenizer/token');
-var Marker = require('../../tokenizer/marker');
-
-function isInheritOnly(values) {
-  for (var i = 0, l = values.length; i < l; i++) {
-    var value = values[i][1];
-
-    if (value != 'inherit' && value != Marker.COMMA && value != Marker.FORWARD_SLASH)
-      return false;
-  }
-
-  return true;
-}
-
-function background(property, compactable, lastInMultiplex) {
-  var components = property.components;
-  var restored = [];
-  var needsOne, needsBoth;
-
-  function restoreValue(component) {
-    Array.prototype.unshift.apply(restored, component.value);
-  }
-
-  function isDefaultValue(component) {
-    var descriptor = compactable[component.name];
-
-    if (descriptor.doubleValues && descriptor.defaultValue.length == 1) {
-      return component.value[0][1] == descriptor.defaultValue[0] && (component.value[1] ? component.value[1][1] == descriptor.defaultValue[0] : true);
-    } else if (descriptor.doubleValues && descriptor.defaultValue.length != 1) {
-      return component.value[0][1] == descriptor.defaultValue[0] && (component.value[1] ? component.value[1][1] : component.value[0][1]) == descriptor.defaultValue[1];
-    } else {
-      return component.value[0][1] == descriptor.defaultValue;
-    }
-  }
-
-  for (var i = components.length - 1; i >= 0; i--) {
-    var component = components[i];
-    var isDefault = isDefaultValue(component);
-
-    if (component.name == 'background-clip') {
-      var originComponent = components[i - 1];
-      var isOriginDefault = isDefaultValue(originComponent);
-
-      needsOne = component.value[0][1] == originComponent.value[0][1];
-
-      needsBoth = !needsOne && (
-        (isOriginDefault && !isDefault) ||
-        (!isOriginDefault && !isDefault) ||
-        (!isOriginDefault && isDefault && component.value[0][1] != originComponent.value[0][1]));
-
-      if (needsOne) {
-        restoreValue(originComponent);
-      } else if (needsBoth) {
-        restoreValue(component);
-        restoreValue(originComponent);
-      }
-
-      i--;
-    } else if (component.name == 'background-size') {
-      var positionComponent = components[i - 1];
-      var isPositionDefault = isDefaultValue(positionComponent);
-
-      needsOne = !isPositionDefault && isDefault;
-
-      needsBoth = !needsOne &&
-        (isPositionDefault && !isDefault || !isPositionDefault && !isDefault);
-
-      if (needsOne) {
-        restoreValue(positionComponent);
-      } else if (needsBoth) {
-        restoreValue(component);
-        restored.unshift([Token.PROPERTY_VALUE, Marker.FORWARD_SLASH]);
-        restoreValue(positionComponent);
-      } else if (positionComponent.value.length == 1) {
-        restoreValue(positionComponent);
-      }
-
-      i--;
-    } else {
-      if (isDefault || compactable[component.name].multiplexLastOnly && !lastInMultiplex)
-        continue;
-
-      restoreValue(component);
-    }
-  }
-
-  if (restored.length === 0 && property.value.length == 1 && property.value[0][1] == '0')
-    restored.push(property.value[0]);
-
-  if (restored.length === 0)
-    restored.push([Token.PROPERTY_VALUE, compactable[property.name].defaultValue]);
-
-  if (isInheritOnly(restored))
-    return [restored[0]];
-
-  return restored;
-}
-
-function borderRadius(property, compactable) {
-  if (property.multiplex) {
-    var horizontal = shallowClone(property);
-    var vertical = shallowClone(property);
-
-    for (var i = 0; i < 4; i++) {
-      var component = property.components[i];
-
-      var horizontalComponent = shallowClone(property);
-      horizontalComponent.value = [component.value[0]];
-      horizontal.components.push(horizontalComponent);
-
-      var verticalComponent = shallowClone(property);
-      // FIXME: only shorthand compactor (see breakup#borderRadius) knows that border radius
-      // longhands have two values, whereas tokenizer does not care about populating 2nd value
-      // if it's missing, hence this fallback
-      verticalComponent.value = [component.value[1] || component.value[0]];
-      vertical.components.push(verticalComponent);
-    }
-
-    var horizontalValues = fourValues(horizontal, compactable);
-    var verticalValues = fourValues(vertical, compactable);
-
-    if (horizontalValues.length == verticalValues.length &&
-        horizontalValues[0][1] == verticalValues[0][1] &&
-        (horizontalValues.length > 1 ? horizontalValues[1][1] == verticalValues[1][1] : true) &&
-        (horizontalValues.length > 2 ? horizontalValues[2][1] == verticalValues[2][1] : true) &&
-        (horizontalValues.length > 3 ? horizontalValues[3][1] == verticalValues[3][1] : true)) {
-      return horizontalValues;
-    } else {
-      return horizontalValues.concat([[Token.PROPERTY_VALUE, Marker.FORWARD_SLASH]]).concat(verticalValues);
-    }
-  } else {
-    return fourValues(property, compactable);
-  }
-}
-
-function font(property, compactable) {
-  var components = property.components;
-  var restored = [];
-  var component;
-  var componentIndex = 0;
-  var fontFamilyIndex = 0;
-
-  if (property.value[0][1].indexOf(Marker.INTERNAL) === 0) {
-    property.value[0][1] = property.value[0][1].substring(Marker.INTERNAL.length);
-    return property.value;
-  }
-
-  // first four components are optional
-  while (componentIndex < 4) {
-    component = components[componentIndex];
-
-    if (component.value[0][1] != compactable[component.name].defaultValue) {
-      Array.prototype.push.apply(restored, component.value);
-    }
-
-    componentIndex++;
-  }
-
-  // then comes font-size
-  Array.prototype.push.apply(restored, components[componentIndex].value);
-  componentIndex++;
-
-  // then may come line-height
-  if (components[componentIndex].value[0][1] != compactable[components[componentIndex].name].defaultValue) {
-    Array.prototype.push.apply(restored, [[Token.PROPERTY_VALUE, Marker.FORWARD_SLASH]]);
-    Array.prototype.push.apply(restored, components[componentIndex].value);
-  }
-
-  componentIndex++;
-
-  // then comes font-family
-  while (components[componentIndex].value[fontFamilyIndex]) {
-    restored.push(components[componentIndex].value[fontFamilyIndex]);
-
-    if (components[componentIndex].value[fontFamilyIndex + 1]) {
-      restored.push([Token.PROPERTY_VALUE, Marker.COMMA]);
-    }
-
-    fontFamilyIndex++;
-  }
-
-  if (isInheritOnly(restored)) {
-    return [restored[0]];
-  }
-
-  return restored;
-}
-
-function fourValues(property) {
-  var components = property.components;
-  var value1 = components[0].value[0];
-  var value2 = components[1].value[0];
-  var value3 = components[2].value[0];
-  var value4 = components[3].value[0];
-
-  if (value1[1] == value2[1] && value1[1] == value3[1] && value1[1] == value4[1]) {
-    return [value1];
-  } else if (value1[1] == value3[1] && value2[1] == value4[1]) {
-    return [value1, value2];
-  } else if (value2[1] == value4[1]) {
-    return [value1, value2, value3];
-  } else {
-    return [value1, value2, value3, value4];
-  }
-}
-
-function multiplex(restoreWith) {
-  return function (property, compactable) {
-    if (!property.multiplex)
-      return restoreWith(property, compactable, true);
-
-    var multiplexSize = 0;
-    var restored = [];
-    var componentMultiplexSoFar = {};
-    var i, l;
-
-    // At this point we don't know what's the multiplex size, e.g. how many background layers are there
-    for (i = 0, l = property.components[0].value.length; i < l; i++) {
-      if (property.components[0].value[i][1] == Marker.COMMA)
-        multiplexSize++;
-    }
-
-    for (i = 0; i <= multiplexSize; i++) {
-      var _property = shallowClone(property);
-
-      // We split multiplex into parts and restore them one by one
-      for (var j = 0, m = property.components.length; j < m; j++) {
-        var componentToClone = property.components[j];
-        var _component = shallowClone(componentToClone);
-        _property.components.push(_component);
-
-        // The trick is some properties has more than one value, so we iterate over values looking for
-        // a multiplex separator - a comma
-        for (var k = componentMultiplexSoFar[_component.name] || 0, n = componentToClone.value.length; k < n; k++) {
-          if (componentToClone.value[k][1] == Marker.COMMA) {
-            componentMultiplexSoFar[_component.name] = k + 1;
-            break;
-          }
-
-          _component.value.push(componentToClone.value[k]);
-        }
-      }
-
-      // No we can restore shorthand value
-      var lastInMultiplex = i == multiplexSize;
-      var _restored = restoreWith(_property, compactable, lastInMultiplex);
-      Array.prototype.push.apply(restored, _restored);
-
-      if (i < multiplexSize)
-        restored.push([Token.PROPERTY_VALUE, Marker.COMMA]);
-    }
-
-    return restored;
-  };
-}
-
-function withoutDefaults(property, compactable) {
-  var components = property.components;
-  var restored = [];
-
-  for (var i = components.length - 1; i >= 0; i--) {
-    var component = components[i];
-    var descriptor = compactable[component.name];
-
-    if (component.value[0][1] != descriptor.defaultValue || ('keepUnlessDefault' in descriptor) && !isDefault(components, compactable, descriptor.keepUnlessDefault)) {
-      restored.unshift(component.value[0]);
-    }
-  }
-
-  if (restored.length === 0)
-    restored.push([Token.PROPERTY_VALUE, compactable[property.name].defaultValue]);
-
-  if (isInheritOnly(restored))
-    return [restored[0]];
-
-  return restored;
-}
-
-function isDefault(components, compactable, propertyName) {
-  var component;
-  var i, l;
-
-  for (i = 0, l = components.length; i < l; i++) {
-    component = components[i];
-
-    if (component.name == propertyName && component.value[0][1] == compactable[propertyName].defaultValue) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-module.exports = {
-  background: background,
-  borderRadius: borderRadius,
-  font: font,
-  fourValues: fourValues,
-  multiplex: multiplex,
-  withoutDefaults: withoutDefaults
-};

node_modules/clean-css/lib/optimizer/level-2/restructure.js

@@ -1,389 +0,0 @@
-var canReorderSingle = require('./reorderable').canReorderSingle;
-var extractProperties = require('./extract-properties');
-var isMergeable = require('./is-mergeable');
-var tidyRuleDuplicates = require('./tidy-rule-duplicates');
-
-var Token = require('../../tokenizer/token');
-
-var cloneArray = require('../../utils/clone-array');
-
-var serializeBody = require('../../writer/one-time').body;
-var serializeRules = require('../../writer/one-time').rules;
-
-function naturalSorter(a, b) {
-  return a > b ? 1 : -1;
-}
-
-function cloneAndMergeSelectors(propertyA, propertyB) {
-  var cloned = cloneArray(propertyA);
-  cloned[5] = cloned[5].concat(propertyB[5]);
-
-  return cloned;
-}
-
-function restructure(tokens, context) {
-  var options = context.options;
-  var mergeablePseudoClasses = options.compatibility.selectors.mergeablePseudoClasses;
-  var mergeablePseudoElements = options.compatibility.selectors.mergeablePseudoElements;
-  var mergeLimit = options.compatibility.selectors.mergeLimit;
-  var multiplePseudoMerging = options.compatibility.selectors.multiplePseudoMerging;
-  var specificityCache = context.cache.specificity;
-  var movableTokens = {};
-  var movedProperties = [];
-  var multiPropertyMoveCache = {};
-  var movedToBeDropped = [];
-  var maxCombinationsLevel = 2;
-  var ID_JOIN_CHARACTER = '%';
-
-  function sendToMultiPropertyMoveCache(position, movedProperty, allFits) {
-    for (var i = allFits.length - 1; i >= 0; i--) {
-      var fit = allFits[i][0];
-      var id = addToCache(movedProperty, fit);
-
-      if (multiPropertyMoveCache[id].length > 1 && processMultiPropertyMove(position, multiPropertyMoveCache[id])) {
-        removeAllMatchingFromCache(id);
-        break;
-      }
-    }
-  }
-
-  function addToCache(movedProperty, fit) {
-    var id = cacheId(fit);
-    multiPropertyMoveCache[id] = multiPropertyMoveCache[id] || [];
-    multiPropertyMoveCache[id].push([movedProperty, fit]);
-    return id;
-  }
-
-  function removeAllMatchingFromCache(matchId) {
-    var matchSelectors = matchId.split(ID_JOIN_CHARACTER);
-    var forRemoval = [];
-    var i;
-
-    for (var id in multiPropertyMoveCache) {
-      var selectors = id.split(ID_JOIN_CHARACTER);
-      for (i = selectors.length - 1; i >= 0; i--) {
-        if (matchSelectors.indexOf(selectors[i]) > -1) {
-          forRemoval.push(id);
-          break;
-        }
-      }
-    }
-
-    for (i = forRemoval.length - 1; i >= 0; i--) {
-      delete multiPropertyMoveCache[forRemoval[i]];
-    }
-  }
-
-  function cacheId(cachedTokens) {
-    var id = [];
-    for (var i = 0, l = cachedTokens.length; i < l; i++) {
-      id.push(serializeRules(cachedTokens[i][1]));
-    }
-    return id.join(ID_JOIN_CHARACTER);
-  }
-
-  function tokensToMerge(sourceTokens) {
-    var uniqueTokensWithBody = [];
-    var mergeableTokens = [];
-
-    for (var i = sourceTokens.length - 1; i >= 0; i--) {
-      if (!isMergeable(serializeRules(sourceTokens[i][1]), mergeablePseudoClasses, mergeablePseudoElements, multiplePseudoMerging)) {
-        continue;
-      }
-
-      mergeableTokens.unshift(sourceTokens[i]);
-      if (sourceTokens[i][2].length > 0 && uniqueTokensWithBody.indexOf(sourceTokens[i]) == -1)
-        uniqueTokensWithBody.push(sourceTokens[i]);
-    }
-
-    return uniqueTokensWithBody.length > 1 ?
-      mergeableTokens :
-      [];
-  }
-
-  function shortenIfPossible(position, movedProperty) {
-    var name = movedProperty[0];
-    var value = movedProperty[1];
-    var key = movedProperty[4];
-    var valueSize = name.length + value.length + 1;
-    var allSelectors = [];
-    var qualifiedTokens = [];
-
-    var mergeableTokens = tokensToMerge(movableTokens[key]);
-    if (mergeableTokens.length < 2)
-      return;
-
-    var allFits = findAllFits(mergeableTokens, valueSize, 1);
-    var bestFit = allFits[0];
-    if (bestFit[1] > 0)
-      return sendToMultiPropertyMoveCache(position, movedProperty, allFits);
-
-    for (var i = bestFit[0].length - 1; i >=0; i--) {
-      allSelectors = bestFit[0][i][1].concat(allSelectors);
-      qualifiedTokens.unshift(bestFit[0][i]);
-    }
-
-    allSelectors = tidyRuleDuplicates(allSelectors);
-    dropAsNewTokenAt(position, [movedProperty], allSelectors, qualifiedTokens);
-  }
-
-  function fitSorter(fit1, fit2) {
-    return fit1[1] > fit2[1] ? 1 : (fit1[1] == fit2[1] ? 0 : -1);
-  }
-
-  function findAllFits(mergeableTokens, propertySize, propertiesCount) {
-    var combinations = allCombinations(mergeableTokens, propertySize, propertiesCount, maxCombinationsLevel - 1);
-    return combinations.sort(fitSorter);
-  }
-
-  function allCombinations(tokensVariant, propertySize, propertiesCount, level) {
-    var differenceVariants = [[tokensVariant, sizeDifference(tokensVariant, propertySize, propertiesCount)]];
-    if (tokensVariant.length > 2 && level > 0) {
-      for (var i = tokensVariant.length - 1; i >= 0; i--) {
-        var subVariant = Array.prototype.slice.call(tokensVariant, 0);
-        subVariant.splice(i, 1);
-        differenceVariants = differenceVariants.concat(allCombinations(subVariant, propertySize, propertiesCount, level - 1));
-      }
-    }
-
-    return differenceVariants;
-  }
-
-  function sizeDifference(tokensVariant, propertySize, propertiesCount) {
-    var allSelectorsSize = 0;
-    for (var i = tokensVariant.length - 1; i >= 0; i--) {
-      allSelectorsSize += tokensVariant[i][2].length > propertiesCount ? serializeRules(tokensVariant[i][1]).length : -1;
-    }
-    return allSelectorsSize - (tokensVariant.length - 1) * propertySize + 1;
-  }
-
-  function dropAsNewTokenAt(position, properties, allSelectors, mergeableTokens) {
-    var i, j, k, m;
-    var allProperties = [];
-
-    for (i = mergeableTokens.length - 1; i >= 0; i--) {
-      var mergeableToken = mergeableTokens[i];
-
-      for (j = mergeableToken[2].length - 1; j >= 0; j--) {
-        var mergeableProperty = mergeableToken[2][j];
-
-        for (k = 0, m = properties.length; k < m; k++) {
-          var property = properties[k];
-
-          var mergeablePropertyName = mergeableProperty[1][1];
-          var propertyName = property[0];
-          var propertyBody = property[4];
-          if (mergeablePropertyName == propertyName && serializeBody([mergeableProperty]) == propertyBody) {
-            mergeableToken[2].splice(j, 1);
-            break;
-          }
-        }
-      }
-    }
-
-    for (i = properties.length - 1; i >= 0; i--) {
-      allProperties.unshift(properties[i][3]);
-    }
-
-    var newToken = [Token.RULE, allSelectors, allProperties];
-    tokens.splice(position, 0, newToken);
-  }
-
-  function dropPropertiesAt(position, movedProperty) {
-    var key = movedProperty[4];
-    var toMove = movableTokens[key];
-
-    if (toMove && toMove.length > 1) {
-      if (!shortenMultiMovesIfPossible(position, movedProperty))
-        shortenIfPossible(position, movedProperty);
-    }
-  }
-
-  function shortenMultiMovesIfPossible(position, movedProperty) {
-    var candidates = [];
-    var propertiesAndMergableTokens = [];
-    var key = movedProperty[4];
-    var j, k;
-
-    var mergeableTokens = tokensToMerge(movableTokens[key]);
-    if (mergeableTokens.length < 2)
-      return;
-
-    movableLoop:
-    for (var value in movableTokens) {
-      var tokensList = movableTokens[value];
-
-      for (j = mergeableTokens.length - 1; j >= 0; j--) {
-        if (tokensList.indexOf(mergeableTokens[j]) == -1)
-          continue movableLoop;
-      }
-
-      candidates.push(value);
-    }
-
-    if (candidates.length < 2)
-      return false;
-
-    for (j = candidates.length - 1; j >= 0; j--) {
-      for (k = movedProperties.length - 1; k >= 0; k--) {
-        if (movedProperties[k][4] == candidates[j]) {
-          propertiesAndMergableTokens.unshift([movedProperties[k], mergeableTokens]);
-          break;
-        }
-      }
-    }
-
-    return processMultiPropertyMove(position, propertiesAndMergableTokens);
-  }
-
-  function processMultiPropertyMove(position, propertiesAndMergableTokens) {
-    var valueSize = 0;
-    var properties = [];
-    var property;
-
-    for (var i = propertiesAndMergableTokens.length - 1; i >= 0; i--) {
-      property = propertiesAndMergableTokens[i][0];
-      var fullValue = property[4];
-      valueSize += fullValue.length + (i > 0 ? 1 : 0);
-
-      properties.push(property);
-    }
-
-    var mergeableTokens = propertiesAndMergableTokens[0][1];
-    var bestFit = findAllFits(mergeableTokens, valueSize, properties.length)[0];
-    if (bestFit[1] > 0)
-      return false;
-
-    var allSelectors = [];
-    var qualifiedTokens = [];
-    for (i = bestFit[0].length - 1; i >= 0; i--) {
-      allSelectors = bestFit[0][i][1].concat(allSelectors);
-      qualifiedTokens.unshift(bestFit[0][i]);
-    }
-
-    allSelectors = tidyRuleDuplicates(allSelectors);
-    dropAsNewTokenAt(position, properties, allSelectors, qualifiedTokens);
-
-    for (i = properties.length - 1; i >= 0; i--) {
-      property = properties[i];
-      var index = movedProperties.indexOf(property);
-
-      delete movableTokens[property[4]];
-
-      if (index > -1 && movedToBeDropped.indexOf(index) == -1)
-        movedToBeDropped.push(index);
-    }
-
-    return true;
-  }
-
-  function boundToAnotherPropertyInCurrrentToken(property, movedProperty, token) {
-    var propertyName = property[0];
-    var movedPropertyName = movedProperty[0];
-    if (propertyName != movedPropertyName)
-      return false;
-
-    var key = movedProperty[4];
-    var toMove = movableTokens[key];
-    return toMove && toMove.indexOf(token) > -1;
-  }
-
-  for (var i = tokens.length - 1; i >= 0; i--) {
-    var token = tokens[i];
-    var isRule;
-    var j, k, m;
-    var samePropertyAt;
-
-    if (token[0] == Token.RULE) {
-      isRule = true;
-    } else if (token[0] == Token.NESTED_BLOCK) {
-      isRule = false;
-    } else {
-      continue;
-    }
-
-    // We cache movedProperties.length as it may change in the loop
-    var movedCount = movedProperties.length;
-
-    var properties = extractProperties(token);
-    movedToBeDropped = [];
-
-    var unmovableInCurrentToken = [];
-    for (j = properties.length - 1; j >= 0; j--) {
-      for (k = j - 1; k >= 0; k--) {
-        if (!canReorderSingle(properties[j], properties[k], specificityCache)) {
-          unmovableInCurrentToken.push(j);
-          break;
-        }
-      }
-    }
-
-    for (j = properties.length - 1; j >= 0; j--) {
-      var property = properties[j];
-      var movedSameProperty = false;
-
-      for (k = 0; k < movedCount; k++) {
-        var movedProperty = movedProperties[k];
-
-        if (movedToBeDropped.indexOf(k) == -1 && (!canReorderSingle(property, movedProperty, specificityCache) && !boundToAnotherPropertyInCurrrentToken(property, movedProperty, token) ||
-            movableTokens[movedProperty[4]] && movableTokens[movedProperty[4]].length === mergeLimit)) {
-          dropPropertiesAt(i + 1, movedProperty, token);
-
-          if (movedToBeDropped.indexOf(k) == -1) {
-            movedToBeDropped.push(k);
-            delete movableTokens[movedProperty[4]];
-          }
-        }
-
-        if (!movedSameProperty) {
-          movedSameProperty = property[0] == movedProperty[0] && property[1] == movedProperty[1];
-
-          if (movedSameProperty) {
-            samePropertyAt = k;
-          }
-        }
-      }
-
-      if (!isRule || unmovableInCurrentToken.indexOf(j) > -1)
-        continue;
-
-      var key = property[4];
-
-      if (movedSameProperty && movedProperties[samePropertyAt][5].length + property[5].length > mergeLimit) {
-        dropPropertiesAt(i + 1, movedProperties[samePropertyAt]);
-        movedProperties.splice(samePropertyAt, 1);
-        movableTokens[key] = [token];
-        movedSameProperty = false;
-      } else {
-        movableTokens[key] = movableTokens[key] || [];
-        movableTokens[key].push(token);
-      }
-
-      if (movedSameProperty) {
-        movedProperties[samePropertyAt] = cloneAndMergeSelectors(movedProperties[samePropertyAt], property);
-      } else {
-        movedProperties.push(property);
-      }
-    }
-
-    movedToBeDropped = movedToBeDropped.sort(naturalSorter);
-    for (j = 0, m = movedToBeDropped.length; j < m; j++) {
-      var dropAt = movedToBeDropped[j] - j;
-      movedProperties.splice(dropAt, 1);
-    }
-  }
-
-  var position = tokens[0] && tokens[0][0] == Token.AT_RULE && tokens[0][1].indexOf('@charset') === 0 ? 1 : 0;
-  for (; position < tokens.length - 1; position++) {
-    var isImportRule = tokens[position][0] === Token.AT_RULE && tokens[position][1].indexOf('@import') === 0;
-    var isComment = tokens[position][0] === Token.COMMENT;
-    if (!(isImportRule || isComment))
-      break;
-  }
-
-  for (i = 0; i < movedProperties.length; i++) {
-    dropPropertiesAt(position, movedProperties[i]);
-  }
-}
-
-module.exports = restructure;

node_modules/clean-css/lib/optimizer/level-2/rules-overlap.js

@@ -1,32 +0,0 @@
-var MODIFIER_PATTERN = /\-\-.+$/;
-
-function rulesOverlap(rule1, rule2, bemMode) {
-  var scope1;
-  var scope2;
-  var i, l;
-  var j, m;
-
-  for (i = 0, l = rule1.length; i < l; i++) {
-    scope1 = rule1[i][1];
-
-    for (j = 0, m = rule2.length; j < m; j++) {
-      scope2 = rule2[j][1];
-
-      if (scope1 == scope2) {
-        return true;
-      }
-
-      if (bemMode && withoutModifiers(scope1) == withoutModifiers(scope2)) {
-        return true;
-      }
-    }
-  }
-
-  return false;
-}
-
-function withoutModifiers(scope) {
-  return scope.replace(MODIFIER_PATTERN, '');
-}
-
-module.exports = rulesOverlap;

node_modules/clean-css/lib/optimizer/level-2/specificities-overlap.js

@@ -1,34 +0,0 @@
-var specificity = require('./specificity');
-
-function specificitiesOverlap(selector1, selector2, cache) {
-  var specificity1;
-  var specificity2;
-  var i, l;
-  var j, m;
-
-  for (i = 0, l = selector1.length; i < l; i++) {
-    specificity1 = findSpecificity(selector1[i][1], cache);
-
-    for (j = 0, m = selector2.length; j < m; j++) {
-      specificity2 = findSpecificity(selector2[j][1], cache);
-
-      if (specificity1[0] === specificity2[0] && specificity1[1] === specificity2[1] && specificity1[2] === specificity2[2]) {
-        return true;
-      }
-    }
-  }
-
-  return false;
-}
-
-function findSpecificity(selector, cache) {
-  var value;
-
-  if (!(selector in cache)) {
-    cache[selector] = value = specificity(selector);
-  }
-
-  return value || cache[selector];
-}
-
-module.exports = specificitiesOverlap;

node_modules/clean-css/lib/optimizer/level-2/specificity.js

@@ -1,77 +0,0 @@
-var Marker = require('../../tokenizer/marker');
-
-var Selector = {
-  ADJACENT_SIBLING: '+',
-  DESCENDANT: '>',
-  DOT: '.',
-  HASH: '#',
-  NON_ADJACENT_SIBLING: '~',
-  PSEUDO: ':'
-};
-
-var LETTER_PATTERN = /[a-zA-Z]/;
-var NOT_PREFIX = ':not(';
-var SEPARATOR_PATTERN = /[\s,\(>~\+]/;
-
-function specificity(selector) {
-  var result = [0, 0, 0];
-  var character;
-  var isEscaped;
-  var isSingleQuoted;
-  var isDoubleQuoted;
-  var roundBracketLevel = 0;
-  var couldIntroduceNewTypeSelector;
-  var withinNotPseudoClass = false;
-  var wasPseudoClass = false;
-  var i, l;
-
-  for (i = 0, l = selector.length; i < l; i++) {
-    character = selector[i];
-
-    if (isEscaped) {
-      // noop
-    } else if (character == Marker.SINGLE_QUOTE && !isDoubleQuoted && !isSingleQuoted) {
-      isSingleQuoted = true;
-    } else if (character == Marker.SINGLE_QUOTE && !isDoubleQuoted && isSingleQuoted) {
-      isSingleQuoted = false;
-    } else if (character == Marker.DOUBLE_QUOTE && !isDoubleQuoted && !isSingleQuoted) {
-      isDoubleQuoted = true;
-    } else if (character == Marker.DOUBLE_QUOTE && isDoubleQuoted && !isSingleQuoted) {
-      isDoubleQuoted = false;
-    } else if (isSingleQuoted || isDoubleQuoted) {
-      continue;
-    } else if (roundBracketLevel > 0 && !withinNotPseudoClass) {
-      // noop
-    } else if (character == Marker.OPEN_ROUND_BRACKET) {
-      roundBracketLevel++;
-    } else if (character == Marker.CLOSE_ROUND_BRACKET && roundBracketLevel == 1) {
-      roundBracketLevel--;
-      withinNotPseudoClass = false;
-    } else if (character == Marker.CLOSE_ROUND_BRACKET) {
-      roundBracketLevel--;
-    } else if (character == Selector.HASH) {
-      result[0]++;
-    } else if (character == Selector.DOT || character == Marker.OPEN_SQUARE_BRACKET) {
-      result[1]++;
-    } else if (character == Selector.PSEUDO && !wasPseudoClass && !isNotPseudoClass(selector, i)) {
-      result[1]++;
-      withinNotPseudoClass = false;
-    } else if (character == Selector.PSEUDO) {
-      withinNotPseudoClass = true;
-    } else if ((i === 0 || couldIntroduceNewTypeSelector) && LETTER_PATTERN.test(character)) {
-      result[2]++;
-    }
-
-    isEscaped = character == Marker.BACK_SLASH;
-    wasPseudoClass = character == Selector.PSEUDO;
-    couldIntroduceNewTypeSelector = !isEscaped && SEPARATOR_PATTERN.test(character);
-  }
-
-  return result;
-}
-
-function isNotPseudoClass(selector, index) {
-  return selector.indexOf(NOT_PREFIX, index) === index;
-}
-
-module.exports = specificity;

node_modules/clean-css/lib/optimizer/level-2/tidy-rule-duplicates.js

@@ -1,21 +0,0 @@
-function ruleSorter(s1, s2) {
-  return s1[1] > s2[1] ? 1 : -1;
-}
-
-function tidyRuleDuplicates(rules) {
-  var list = [];
-  var repeated = [];
-
-  for (var i = 0, l = rules.length; i < l; i++) {
-    var rule = rules[i];
-
-    if (repeated.indexOf(rule[1]) == -1) {
-      repeated.push(rule[1]);
-      list.push(rule);
-    }
-  }
-
-  return list.sort(ruleSorter);
-}
-
-module.exports = tidyRuleDuplicates;

node_modules/clean-css/lib/optimizer/remove-unused.js

@@ -1,11 +0,0 @@
-function removeUnused(properties) {
-  for (var i = properties.length - 1; i >= 0; i--) {
-    var property = properties[i];
-
-    if (property.unused) {
-      property.all.splice(property.position, 1);
-    }
-  }
-}
-
-module.exports = removeUnused;

node_modules/clean-css/lib/optimizer/restore-from-optimizing.js

@@ -1,69 +0,0 @@
-var Hack = require('./hack');
-
-var Marker = require('../tokenizer/marker');
-
-var ASTERISK_HACK = '*';
-var BACKSLASH_HACK = '\\';
-var IMPORTANT_TOKEN = '!important';
-var UNDERSCORE_HACK = '_';
-var BANG_HACK = '!ie';
-
-function restoreFromOptimizing(properties, restoreCallback) {
-  var property;
-  var restored;
-  var current;
-  var i;
-
-  for (i = properties.length - 1; i >= 0; i--) {
-    property = properties[i];
-
-    if (property.unused) {
-      continue;
-    }
-
-    if (!property.dirty && !property.important && !property.hack) {
-      continue;
-    }
-
-    if (restoreCallback) {
-      restored = restoreCallback(property);
-      property.value = restored;
-    } else {
-      restored = property.value;
-    }
-
-    if (property.important) {
-      restoreImportant(property);
-    }
-
-    if (property.hack) {
-      restoreHack(property);
-    }
-
-    if ('all' in property) {
-      current = property.all[property.position];
-      current[1][1] = property.name;
-
-      current.splice(2, current.length - 1);
-      Array.prototype.push.apply(current, restored);
-    }
-  }
-}
-
-function restoreImportant(property) {
-  property.value[property.value.length - 1][1] += IMPORTANT_TOKEN;
-}
-
-function restoreHack(property) {
-  if (property.hack[0] == Hack.UNDERSCORE) {
-    property.name = UNDERSCORE_HACK + property.name;
-  } else if (property.hack[0] == Hack.ASTERISK) {
-    property.name = ASTERISK_HACK + property.name;
-  } else if (property.hack[0] == Hack.BACKSLASH) {
-    property.value[property.value.length - 1][1] += BACKSLASH_HACK + property.hack[1];
-  } else if (property.hack[0] == Hack.BANG) {
-    property.value[property.value.length - 1][1] += Marker.SPACE + BANG_HACK;
-  }
-}
-
-module.exports = restoreFromOptimizing;

node_modules/clean-css/lib/optimizer/validator.js

@@ -1,529 +0,0 @@
-var functionNoVendorRegexStr = '[A-Z]+(\\-|[A-Z]|[0-9])+\\(.*?\\)';
-var functionVendorRegexStr = '\\-(\\-|[A-Z]|[0-9])+\\(.*?\\)';
-var variableRegexStr = 'var\\(\\-\\-[^\\)]+\\)';
-var functionAnyRegexStr = '(' + variableRegexStr + '|' + functionNoVendorRegexStr + '|' + functionVendorRegexStr + ')';
-
-var calcRegex = new RegExp('^(\\-moz\\-|\\-webkit\\-)?calc\\([^\\)]+\\)$', 'i');
-var decimalRegex = /[0-9]/;
-var functionAnyRegex = new RegExp('^' + functionAnyRegexStr + '$', 'i');
-var hslColorRegex = /^hsl\(\s{0,31}[\-\.]?\d+\s{0,31},\s{0,31}\.?\d+%\s{0,31},\s{0,31}\.?\d+%\s{0,31}\)|hsla\(\s{0,31}[\-\.]?\d+\s{0,31},\s{0,31}\.?\d+%\s{0,31},\s{0,31}\.?\d+%\s{0,31},\s{0,31}\.?\d+\s{0,31}\)$/i;
-var identifierRegex = /^(\-[a-z0-9_][a-z0-9\-_]*|[a-z][a-z0-9\-_]*)$/i;
-var namedEntityRegex = /^[a-z]+$/i;
-var prefixRegex = /^-([a-z0-9]|-)*$/i;
-var rgbColorRegex = /^rgb\(\s{0,31}[\d]{1,3}\s{0,31},\s{0,31}[\d]{1,3}\s{0,31},\s{0,31}[\d]{1,3}\s{0,31}\)|rgba\(\s{0,31}[\d]{1,3}\s{0,31},\s{0,31}[\d]{1,3}\s{0,31},\s{0,31}[\d]{1,3}\s{0,31},\s{0,31}[\.\d]+\s{0,31}\)$/i;
-var timingFunctionRegex = /^(cubic\-bezier|steps)\([^\)]+\)$/;
-var validTimeUnits = ['ms', 's'];
-var urlRegex = /^url\([\s\S]+\)$/i;
-var variableRegex = new RegExp('^' + variableRegexStr + '$', 'i');
-
-var eightValueColorRegex = /^#[0-9a-f]{8}$/i;
-var fourValueColorRegex = /^#[0-9a-f]{4}$/i;
-var sixValueColorRegex = /^#[0-9a-f]{6}$/i;
-var threeValueColorRegex = /^#[0-9a-f]{3}$/i;
-
-var DECIMAL_DOT = '.';
-var MINUS_SIGN = '-';
-var PLUS_SIGN = '+';
-
-var Keywords = {
-  '^': [
-    'inherit',
-    'initial',
-    'unset'
-  ],
-  '*-style': [
-    'auto',
-    'dashed',
-    'dotted',
-    'double',
-    'groove',
-    'hidden',
-    'inset',
-    'none',
-    'outset',
-    'ridge',
-    'solid'
-  ],
-  '*-timing-function': [
-    'ease',
-    'ease-in',
-    'ease-in-out',
-    'ease-out',
-    'linear',
-    'step-end',
-    'step-start'
-  ],
-  'animation-direction': [
-    'alternate',
-    'alternate-reverse',
-    'normal',
-    'reverse'
-  ],
-  'animation-fill-mode': [
-    'backwards',
-    'both',
-    'forwards',
-    'none'
-  ],
-  'animation-iteration-count': [
-    'infinite'
-  ],
-  'animation-name': [
-    'none'
-  ],
-  'animation-play-state': [
-    'paused',
-    'running'
-  ],
-  'background-attachment': [
-    'fixed',
-    'inherit',
-    'local',
-    'scroll'
-  ],
-  'background-clip': [
-    'border-box',
-    'content-box',
-    'inherit',
-    'padding-box',
-    'text'
-  ],
-  'background-origin': [
-    'border-box',
-    'content-box',
-    'inherit',
-    'padding-box'
-  ],
-  'background-position': [
-    'bottom',
-    'center',
-    'left',
-    'right',
-    'top'
-  ],
-  'background-repeat': [
-    'no-repeat',
-    'inherit',
-    'repeat',
-    'repeat-x',
-    'repeat-y',
-    'round',
-    'space'
-  ],
-  'background-size': [
-    'auto',
-    'cover',
-    'contain'
-  ],
-  'border-collapse': [
-    'collapse',
-    'inherit',
-    'separate'
-  ],
-  'bottom': [
-    'auto'
-  ],
-  'clear': [
-    'both',
-    'left',
-    'none',
-    'right'
-  ],
-  'color': [
-    'transparent'
-  ],
-  'cursor': [
-    'all-scroll',
-    'auto',
-    'col-resize',
-    'crosshair',
-    'default',
-    'e-resize',
-    'help',
-    'move',
-    'n-resize',
-    'ne-resize',
-    'no-drop',
-    'not-allowed',
-    'nw-resize',
-    'pointer',
-    'progress',
-    'row-resize',
-    's-resize',
-    'se-resize',
-    'sw-resize',
-    'text',
-    'vertical-text',
-    'w-resize',
-    'wait'
-  ],
-  'display': [
-    'block',
-    'inline',
-    'inline-block',
-    'inline-table',
-    'list-item',
-    'none',
-    'table',
-    'table-caption',
-    'table-cell',
-    'table-column',
-    'table-column-group',
-    'table-footer-group',
-    'table-header-group',
-    'table-row',
-    'table-row-group'
-  ],
-  'float': [
-    'left',
-    'none',
-    'right'
-  ],
-  'left': [
-    'auto'
-  ],
-  'font': [
-    'caption',
-    'icon',
-    'menu',
-    'message-box',
-    'small-caption',
-    'status-bar',
-    'unset'
-  ],
-  'font-size': [
-    'large',
-    'larger',
-    'medium',
-    'small',
-    'smaller',
-    'x-large',
-    'x-small',
-    'xx-large',
-    'xx-small'
-  ],
-  'font-stretch': [
-    'condensed',
-    'expanded',
-    'extra-condensed',
-    'extra-expanded',
-    'normal',
-    'semi-condensed',
-    'semi-expanded',
-    'ultra-condensed',
-    'ultra-expanded'
-  ],
-  'font-style': [
-    'italic',
-    'normal',
-    'oblique'
-  ],
-  'font-variant': [
-    'normal',
-    'small-caps'
-  ],
-  'font-weight': [
-    '100',
-    '200',
-    '300',
-    '400',
-    '500',
-    '600',
-    '700',
-    '800',
-    '900',
-    'bold',
-    'bolder',
-    'lighter',
-    'normal'
-  ],
-  'line-height': [
-    'normal'
-  ],
-  'list-style-position': [
-    'inside',
-    'outside'
-  ],
-  'list-style-type': [
-    'armenian',
-    'circle',
-    'decimal',
-    'decimal-leading-zero',
-    'disc',
-    'decimal|disc', // this is the default value of list-style-type, see comment in compactable.js
-    'georgian',
-    'lower-alpha',
-    'lower-greek',
-    'lower-latin',
-    'lower-roman',
-    'none',
-    'square',
-    'upper-alpha',
-    'upper-latin',
-    'upper-roman'
-  ],
-  'overflow': [
-    'auto',
-    'hidden',
-    'scroll',
-    'visible'
-  ],
-  'position': [
-    'absolute',
-    'fixed',
-    'relative',
-    'static'
-  ],
-  'right': [
-    'auto'
-  ],
-  'text-align': [
-    'center',
-    'justify',
-    'left',
-    'left|right', // this is the default value of list-style-type, see comment in compactable.js
-    'right'
-  ],
-  'text-decoration': [
-    'line-through',
-    'none',
-    'overline',
-    'underline'
-  ],
-  'text-overflow': [
-    'clip',
-    'ellipsis'
-  ],
-  'top': [
-    'auto'
-  ],
-  'vertical-align': [
-    'baseline',
-    'bottom',
-    'middle',
-    'sub',
-    'super',
-    'text-bottom',
-    'text-top',
-    'top'
-  ],
-  'visibility': [
-    'collapse',
-    'hidden',
-    'visible'
-  ],
-  'white-space': [
-    'normal',
-    'nowrap',
-    'pre'
-  ],
-  'width': [
-    'inherit',
-    'initial',
-    'medium',
-    'thick',
-    'thin'
-  ]
-};
-
-var Units = [
-  '%',
-  'ch',
-  'cm',
-  'em',
-  'ex',
-  'in',
-  'mm',
-  'pc',
-  'pt',
-  'px',
-  'rem',
-  'vh',
-  'vm',
-  'vmax',
-  'vmin',
-  'vw'
-];
-
-function isColor(value) {
-  return value != 'auto' &&
-    (
-      isKeyword('color')(value) ||
-      isHexColor(value) ||
-      isColorFunction(value) ||
-      isNamedEntity(value)
-    );
-}
-
-function isColorFunction(value) {
-  return isRgbColor(value) || isHslColor(value);
-}
-
-function isDynamicUnit(value) {
-  return calcRegex.test(value);
-}
-
-function isFunction(value) {
-  return functionAnyRegex.test(value);
-}
-
-function isHexColor(value) {
-  return threeValueColorRegex.test(value) || fourValueColorRegex.test(value) || sixValueColorRegex.test(value) || eightValueColorRegex.test(value);
-}
-
-function isHslColor(value) {
-  return hslColorRegex.test(value);
-}
-
-function isIdentifier(value) {
-  return identifierRegex.test(value);
-}
-
-function isImage(value) {
-  return value == 'none' || value == 'inherit' || isUrl(value);
-}
-
-function isKeyword(propertyName) {
-  return function(value) {
-    return Keywords[propertyName].indexOf(value) > -1;
-  };
-}
-
-function isNamedEntity(value) {
-  return namedEntityRegex.test(value);
-}
-
-function isNumber(value) {
-  return scanForNumber(value) == value.length;
-}
-
-function isRgbColor(value) {
-  return rgbColorRegex.test(value);
-}
-
-function isPrefixed(value) {
-  return prefixRegex.test(value);
-}
-
-function isPositiveNumber(value) {
-  return isNumber(value) &&
-    parseFloat(value) >= 0;
-}
-
-function isVariable(value) {
-  return variableRegex.test(value);
-}
-
-function isTime(value) {
-  var numberUpTo = scanForNumber(value);
-
-  return numberUpTo == value.length && parseInt(value) === 0 ||
-    numberUpTo > -1 && validTimeUnits.indexOf(value.slice(numberUpTo + 1)) > -1;
-}
-
-function isTimingFunction() {
-  var isTimingFunctionKeyword = isKeyword('*-timing-function');
-
-  return function (value) {
-    return isTimingFunctionKeyword(value) || timingFunctionRegex.test(value);
-  };
-}
-
-function isUnit(validUnits, value) {
-  var numberUpTo = scanForNumber(value);
-
-  return numberUpTo == value.length && parseInt(value) === 0 ||
-    numberUpTo > -1 && validUnits.indexOf(value.slice(numberUpTo + 1)) > -1 ||
-    value == 'auto' ||
-    value == 'inherit';
-}
-
-function isUrl(value) {
-  return urlRegex.test(value);
-}
-
-function isZIndex(value) {
-  return value == 'auto' ||
-    isNumber(value) ||
-    isKeyword('^')(value);
-}
-
-function scanForNumber(value) {
-  var hasDot = false;
-  var hasSign = false;
-  var character;
-  var i, l;
-
-  for (i = 0, l = value.length; i < l; i++) {
-    character = value[i];
-
-    if (i === 0 && (character == PLUS_SIGN || character == MINUS_SIGN)) {
-      hasSign = true;
-    } else if (i > 0 && hasSign && (character == PLUS_SIGN || character == MINUS_SIGN)) {
-      return i - 1;
-    } else if (character == DECIMAL_DOT && !hasDot) {
-      hasDot = true;
-    } else if (character == DECIMAL_DOT && hasDot) {
-      return i - 1;
-    } else if (decimalRegex.test(character)) {
-      continue;
-    } else {
-      return i - 1;
-    }
-  }
-
-  return i;
-}
-
-function validator(compatibility) {
-  var validUnits = Units.slice(0).filter(function (value) {
-    return !(value in compatibility.units) || compatibility.units[value] === true;
-  });
-
-  return {
-    colorOpacity: compatibility.colors.opacity,
-    isAnimationDirectionKeyword: isKeyword('animation-direction'),
-    isAnimationFillModeKeyword: isKeyword('animation-fill-mode'),
-    isAnimationIterationCountKeyword: isKeyword('animation-iteration-count'),
-    isAnimationNameKeyword: isKeyword('animation-name'),
-    isAnimationPlayStateKeyword: isKeyword('animation-play-state'),
-    isTimingFunction: isTimingFunction(),
-    isBackgroundAttachmentKeyword: isKeyword('background-attachment'),
-    isBackgroundClipKeyword: isKeyword('background-clip'),
-    isBackgroundOriginKeyword: isKeyword('background-origin'),
-    isBackgroundPositionKeyword: isKeyword('background-position'),
-    isBackgroundRepeatKeyword: isKeyword('background-repeat'),
-    isBackgroundSizeKeyword: isKeyword('background-size'),
-    isColor: isColor,
-    isColorFunction: isColorFunction,
-    isDynamicUnit: isDynamicUnit,
-    isFontKeyword: isKeyword('font'),
-    isFontSizeKeyword: isKeyword('font-size'),
-    isFontStretchKeyword: isKeyword('font-stretch'),
-    isFontStyleKeyword: isKeyword('font-style'),
-    isFontVariantKeyword: isKeyword('font-variant'),
-    isFontWeightKeyword: isKeyword('font-weight'),
-    isFunction: isFunction,
-    isGlobal: isKeyword('^'),
-    isHslColor: isHslColor,
-    isIdentifier: isIdentifier,
-    isImage: isImage,
-    isKeyword: isKeyword,
-    isLineHeightKeyword: isKeyword('line-height'),
-    isListStylePositionKeyword: isKeyword('list-style-position'),
-    isListStyleTypeKeyword: isKeyword('list-style-type'),
-    isNumber: isNumber,
-    isPrefixed: isPrefixed,
-    isPositiveNumber: isPositiveNumber,
-    isRgbColor: isRgbColor,
-    isStyleKeyword: isKeyword('*-style'),
-    isTime: isTime,
-    isUnit: isUnit.bind(null, validUnits),
-    isUrl: isUrl,
-    isVariable: isVariable,
-    isWidth: isKeyword('width'),
-    isZIndex: isZIndex
-  };
-}
-
-module.exports = validator;

node_modules/clean-css/lib/optimizer/wrap-for-optimizing.js

@@ -1,191 +0,0 @@
-var Hack = require('./hack');
-
-var Marker = require('../tokenizer/marker');
-var Token = require('../tokenizer/token');
-
-var Match = {
-  ASTERISK: '*',
-  BACKSLASH: '\\',
-  BANG: '!',
-  BANG_SUFFIX_PATTERN: /!\w+$/,
-  IMPORTANT_TOKEN: '!important',
-  IMPORTANT_TOKEN_PATTERN: new RegExp('!important$', 'i'),
-  IMPORTANT_WORD: 'important',
-  IMPORTANT_WORD_PATTERN: new RegExp('important$', 'i'),
-  SUFFIX_BANG_PATTERN: /!$/,
-  UNDERSCORE: '_',
-  VARIABLE_REFERENCE_PATTERN: /var\(--.+\)$/
-};
-
-function wrapAll(properties, includeVariable, skipProperties) {
-  var wrapped = [];
-  var single;
-  var property;
-  var i;
-
-  for (i = properties.length - 1; i >= 0; i--) {
-    property = properties[i];
-
-    if (property[0] != Token.PROPERTY) {
-      continue;
-    }
-
-    if (!includeVariable && someVariableReferences(property)) {
-      continue;
-    }
-
-    if (skipProperties && skipProperties.indexOf(property[1][1]) > -1) {
-      continue;
-    }
-
-    single = wrapSingle(property);
-    single.all = properties;
-    single.position = i;
-    wrapped.unshift(single);
-  }
-
-  return wrapped;
-}
-
-function someVariableReferences(property) {
-  var i, l;
-  var value;
-
-  // skipping `property` and property name tokens
-  for (i = 2, l = property.length; i < l; i++) {
-    value = property[i];
-
-    if (value[0] != Token.PROPERTY_VALUE) {
-      continue;
-    }
-
-    if (isVariableReference(value[1])) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-function isVariableReference(value) {
-  return Match.VARIABLE_REFERENCE_PATTERN.test(value);
-}
-
-function isMultiplex(property) {
-  var value;
-  var i, l;
-
-  for (i = 3, l = property.length; i < l; i++) {
-    value = property[i];
-
-    if (value[0] == Token.PROPERTY_VALUE && (value[1] == Marker.COMMA || value[1] == Marker.FORWARD_SLASH)) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-function hackFrom(property) {
-  var match = false;
-  var name = property[1][1];
-  var lastValue = property[property.length - 1];
-
-  if (name[0] == Match.UNDERSCORE) {
-    match = [Hack.UNDERSCORE];
-  } else if (name[0] == Match.ASTERISK) {
-    match = [Hack.ASTERISK];
-  } else if (lastValue[1][0] == Match.BANG && !lastValue[1].match(Match.IMPORTANT_WORD_PATTERN)) {
-    match = [Hack.BANG];
-  } else if (lastValue[1].indexOf(Match.BANG) > 0 && !lastValue[1].match(Match.IMPORTANT_WORD_PATTERN) && Match.BANG_SUFFIX_PATTERN.test(lastValue[1])) {
-    match = [Hack.BANG];
-  } else if (lastValue[1].indexOf(Match.BACKSLASH) > 0 && lastValue[1].indexOf(Match.BACKSLASH) == lastValue[1].length - Match.BACKSLASH.length - 1) {
-    match = [Hack.BACKSLASH, lastValue[1].substring(lastValue[1].indexOf(Match.BACKSLASH) + 1)];
-  } else if (lastValue[1].indexOf(Match.BACKSLASH) === 0 && lastValue[1].length == 2) {
-    match = [Hack.BACKSLASH, lastValue[1].substring(1)];
-  }
-
-  return match;
-}
-
-function isImportant(property) {
-  if (property.length < 3)
-    return false;
-
-  var lastValue = property[property.length - 1];
-  if (Match.IMPORTANT_TOKEN_PATTERN.test(lastValue[1])) {
-    return true;
-  } else if (Match.IMPORTANT_WORD_PATTERN.test(lastValue[1]) && Match.SUFFIX_BANG_PATTERN.test(property[property.length - 2][1])) {
-    return true;
-  }
-
-  return false;
-}
-
-function stripImportant(property) {
-  var lastValue = property[property.length - 1];
-  var oneButLastValue = property[property.length - 2];
-
-  if (Match.IMPORTANT_TOKEN_PATTERN.test(lastValue[1])) {
-    lastValue[1] = lastValue[1].replace(Match.IMPORTANT_TOKEN_PATTERN, '');
-  } else {
-    lastValue[1] = lastValue[1].replace(Match.IMPORTANT_WORD_PATTERN, '');
-    oneButLastValue[1] = oneButLastValue[1].replace(Match.SUFFIX_BANG_PATTERN, '');
-  }
-
-  if (lastValue[1].length === 0) {
-    property.pop();
-  }
-
-  if (oneButLastValue[1].length === 0) {
-    property.pop();
-  }
-}
-
-function stripPrefixHack(property) {
-  property[1][1] = property[1][1].substring(1);
-}
-
-function stripSuffixHack(property, hackFrom) {
-  var lastValue = property[property.length - 1];
-  lastValue[1] = lastValue[1]
-    .substring(0, lastValue[1].indexOf(hackFrom[0] == Hack.BACKSLASH ? Match.BACKSLASH : Match.BANG))
-    .trim();
-
-  if (lastValue[1].length === 0) {
-    property.pop();
-  }
-}
-
-function wrapSingle(property) {
-  var importantProperty = isImportant(property);
-  if (importantProperty) {
-    stripImportant(property);
-  }
-
-  var whichHack = hackFrom(property);
-  if (whichHack[0] == Hack.ASTERISK || whichHack[0] == Hack.UNDERSCORE) {
-    stripPrefixHack(property);
-  } else if (whichHack[0] == Hack.BACKSLASH || whichHack[0] == Hack.BANG) {
-    stripSuffixHack(property, whichHack);
-  }
-
-  return {
-    block: property[2] && property[2][0] == Token.PROPERTY_BLOCK,
-    components: [],
-    dirty: false,
-    hack: whichHack,
-    important: importantProperty,
-    name: property[1][1],
-    multiplex: property.length > 3 ? isMultiplex(property) : false,
-    position: 0,
-    shorthand: false,
-    unused: false,
-    value: property.slice(2)
-  };
-}
-
-module.exports = {
-  all: wrapAll,
-  single: wrapSingle
-};

node_modules/clean-css/lib/options/compatibility.js

@@ -1,183 +0,0 @@
-var DEFAULTS = {
-  '*': {
-    colors: {
-      opacity: true // rgba / hsla
-    },
-    properties: {
-      backgroundClipMerging: true, // background-clip to shorthand
-      backgroundOriginMerging: true, // background-origin to shorthand
-      backgroundSizeMerging: true, // background-size to shorthand
-      colors: true, // any kind of color transformations, like `#ff00ff` to `#f0f` or `#fff` into `red`
-      ieBangHack: false, // !ie suffix hacks on IE<8
-      ieFilters: false, // whether to preserve `filter` and `-ms-filter` properties
-      iePrefixHack: false, // underscore / asterisk prefix hacks on IE
-      ieSuffixHack: false, // \9 suffix hacks on IE6-9
-      merging: true, // merging properties into one
-      shorterLengthUnits: false, // optimize pixel units into `pt`, `pc` or `in` units
-      spaceAfterClosingBrace: true, // 'url() no-repeat' to 'url()no-repeat'
-      urlQuotes: false, // whether to wrap content of `url()` into quotes or not
-      zeroUnits: true // 0[unit] -> 0
-    },
-    selectors: {
-      adjacentSpace: false, // div+ nav Android stock browser hack
-      ie7Hack: false, // *+html hack
-      mergeablePseudoClasses: [
-        ':active',
-        ':after',
-        ':before',
-        ':empty',
-        ':checked',
-        ':disabled',
-        ':empty',
-        ':enabled',
-        ':first-child',
-        ':first-letter',
-        ':first-line',
-        ':first-of-type',
-        ':focus',
-        ':hover',
-        ':lang',
-        ':last-child',
-        ':last-of-type',
-        ':link',
-        ':not',
-        ':nth-child',
-        ':nth-last-child',
-        ':nth-last-of-type',
-        ':nth-of-type',
-        ':only-child',
-        ':only-of-type',
-        ':root',
-        ':target',
-        ':visited'
-      ], // selectors with these pseudo-classes can be merged as these are universally supported
-      mergeablePseudoElements: [
-        '::after',
-        '::before',
-        '::first-letter',
-        '::first-line'
-      ], // selectors with these pseudo-elements can be merged as these are universally supported
-      mergeLimit: 8191, // number of rules that can be safely merged together
-      multiplePseudoMerging: true
-    },
-    units: {
-      ch: true,
-      in: true,
-      pc: true,
-      pt: true,
-      rem: true,
-      vh: true,
-      vm: true, // vm is vmin on IE9+ see https://developer.mozilla.org/en-US/docs/Web/CSS/length
-      vmax: true,
-      vmin: true,
-      vw: true
-    }
-  }
-};
-
-DEFAULTS.ie11 = DEFAULTS['*'];
-
-DEFAULTS.ie10 = DEFAULTS['*'];
-
-DEFAULTS.ie9 = merge(DEFAULTS['*'], {
-  properties: {
-    ieFilters: true,
-    ieSuffixHack: true
-  }
-});
-
-DEFAULTS.ie8 = merge(DEFAULTS.ie9, {
-  colors: {
-    opacity: false
-  },
-  properties: {
-    backgroundClipMerging: false,
-    backgroundOriginMerging: false,
-    backgroundSizeMerging: false,
-    iePrefixHack: true,
-    merging: false
-  },
-  selectors: {
-    mergeablePseudoClasses: [
-      ':after',
-      ':before',
-      ':first-child',
-      ':first-letter',
-      ':focus',
-      ':hover',
-      ':visited'
-    ],
-    mergeablePseudoElements: []
-  },
-  units: {
-    ch: false,
-    rem: false,
-    vh: false,
-    vm: false,
-    vmax: false,
-    vmin: false,
-    vw: false
-  }
-});
-
-DEFAULTS.ie7 = merge(DEFAULTS.ie8, {
-  properties: {
-    ieBangHack: true
-  },
-  selectors: {
-    ie7Hack: true,
-    mergeablePseudoClasses: [
-      ':first-child',
-      ':first-letter',
-      ':hover',
-      ':visited'
-    ]
-  },
-});
-
-function compatibilityFrom(source) {
-  return merge(DEFAULTS['*'], calculateSource(source));
-}
-
-function merge(source, target) {
-  for (var key in source) {
-    var value = source[key];
-
-    if (typeof value === 'object' && !Array.isArray(value)) {
-      target[key] = merge(value, target[key] || {});
-    } else {
-      target[key] = key in target ? target[key] : value;
-    }
-  }
-
-  return target;
-}
-
-function calculateSource(source) {
-  if (typeof source == 'object')
-    return source;
-
-  if (!/[,\+\-]/.test(source))
-    return DEFAULTS[source] || DEFAULTS['*'];
-
-  var parts = source.split(',');
-  var template = parts[0] in DEFAULTS ?
-    DEFAULTS[parts.shift()] :
-    DEFAULTS['*'];
-
-  source = {};
-
-  parts.forEach(function (part) {
-    var isAdd = part[0] == '+';
-    var key = part.substring(1).split('.');
-    var group = key[0];
-    var option = key[1];
-
-    source[group] = source[group] || {};
-    source[group][option] = isAdd;
-  });
-
-  return merge(template, source);
-}
-
-module.exports = compatibilityFrom;

node_modules/clean-css/lib/options/fetch.js

@@ -1,7 +0,0 @@
-var loadRemoteResource = require('../reader/load-remote-resource');
-
-function fetchFrom(callback) {
-  return callback || loadRemoteResource;
-}
-
-module.exports = fetchFrom;

node_modules/clean-css/lib/options/format.js

@@ -1,216 +0,0 @@
-var systemLineBreak = require('os').EOL;
-
-var override = require('../utils/override');
-
-var Breaks = {
-  AfterAtRule: 'afterAtRule',
-  AfterBlockBegins: 'afterBlockBegins',
-  AfterBlockEnds: 'afterBlockEnds',
-  AfterComment: 'afterComment',
-  AfterProperty: 'afterProperty',
-  AfterRuleBegins: 'afterRuleBegins',
-  AfterRuleEnds: 'afterRuleEnds',
-  BeforeBlockEnds: 'beforeBlockEnds',
-  BetweenSelectors: 'betweenSelectors'
-};
-
-var BreakWith = {
-  CarriageReturnLineFeed: '\r\n',
-  LineFeed: '\n',
-  System: systemLineBreak
-};
-
-var IndentWith = {
-  Space: ' ',
-  Tab: '\t'
-};
-
-var Spaces = {
-  AroundSelectorRelation: 'aroundSelectorRelation',
-  BeforeBlockBegins: 'beforeBlockBegins',
-  BeforeValue: 'beforeValue'
-};
-
-var DEFAULTS = {
-  breaks: breaks(false),
-  breakWith: BreakWith.System,
-  indentBy: 0,
-  indentWith: IndentWith.Space,
-  spaces: spaces(false),
-  wrapAt: false,
-  semicolonAfterLastProperty: false
-};
-
-var BEAUTIFY_ALIAS = 'beautify';
-var KEEP_BREAKS_ALIAS = 'keep-breaks';
-
-var OPTION_SEPARATOR = ';';
-var OPTION_NAME_VALUE_SEPARATOR = ':';
-var HASH_VALUES_OPTION_SEPARATOR = ',';
-var HASH_VALUES_NAME_VALUE_SEPARATOR = '=';
-
-var FALSE_KEYWORD_1 = 'false';
-var FALSE_KEYWORD_2 = 'off';
-var TRUE_KEYWORD_1 = 'true';
-var TRUE_KEYWORD_2 = 'on';
-
-function breaks(value) {
-  var breakOptions = {};
-
-  breakOptions[Breaks.AfterAtRule] = value;
-  breakOptions[Breaks.AfterBlockBegins] = value;
-  breakOptions[Breaks.AfterBlockEnds] = value;
-  breakOptions[Breaks.AfterComment] = value;
-  breakOptions[Breaks.AfterProperty] = value;
-  breakOptions[Breaks.AfterRuleBegins] = value;
-  breakOptions[Breaks.AfterRuleEnds] = value;
-  breakOptions[Breaks.BeforeBlockEnds] = value;
-  breakOptions[Breaks.BetweenSelectors] = value;
-
-  return breakOptions;
-}
-
-function spaces(value) {
-  var spaceOptions = {};
-
-  spaceOptions[Spaces.AroundSelectorRelation] = value;
-  spaceOptions[Spaces.BeforeBlockBegins] = value;
-  spaceOptions[Spaces.BeforeValue] = value;
-
-  return spaceOptions;
-}
-
-function formatFrom(source) {
-  if (source === undefined || source === false) {
-    return false;
-  }
-
-  if (typeof source == 'object' && 'breakWith' in source) {
-    source = override(source, { breakWith: mapBreakWith(source.breakWith) });
-  }
-
-  if (typeof source == 'object' && 'indentBy' in source) {
-    source = override(source, { indentBy: parseInt(source.indentBy) });
-  }
-
-  if (typeof source == 'object' && 'indentWith' in source) {
-    source = override(source, { indentWith: mapIndentWith(source.indentWith) });
-  }
-
-  if (typeof source == 'object') {
-    return override(DEFAULTS, source);
-  }
-
-  if (typeof source == 'object') {
-    return override(DEFAULTS, source);
-  }
-
-  if (typeof source == 'string' && source == BEAUTIFY_ALIAS) {
-    return override(DEFAULTS, {
-      breaks: breaks(true),
-      indentBy: 2,
-      spaces: spaces(true)
-    });
-  }
-
-  if (typeof source == 'string' && source == KEEP_BREAKS_ALIAS) {
-    return override(DEFAULTS, {
-      breaks: {
-        afterAtRule: true,
-        afterBlockBegins: true,
-        afterBlockEnds: true,
-        afterComment: true,
-        afterRuleEnds: true,
-        beforeBlockEnds: true
-      }
-    });
-  }
-
-  if (typeof source == 'string') {
-    return override(DEFAULTS, toHash(source));
-  }
-
-  return DEFAULTS;
-}
-
-function toHash(string) {
-  return string
-    .split(OPTION_SEPARATOR)
-    .reduce(function (accumulator, directive) {
-      var parts = directive.split(OPTION_NAME_VALUE_SEPARATOR);
-      var name = parts[0];
-      var value = parts[1];
-
-      if (name == 'breaks' || name == 'spaces') {
-        accumulator[name] = hashValuesToHash(value);
-      } else if (name == 'indentBy' || name == 'wrapAt') {
-        accumulator[name] = parseInt(value);
-      } else if (name == 'indentWith') {
-        accumulator[name] = mapIndentWith(value);
-      } else if (name == 'breakWith') {
-        accumulator[name] = mapBreakWith(value);
-      }
-
-      return accumulator;
-    }, {});
-}
-
-function hashValuesToHash(string) {
-  return string
-    .split(HASH_VALUES_OPTION_SEPARATOR)
-    .reduce(function (accumulator, directive) {
-      var parts = directive.split(HASH_VALUES_NAME_VALUE_SEPARATOR);
-      var name = parts[0];
-      var value = parts[1];
-
-      accumulator[name] = normalizeValue(value);
-
-      return accumulator;
-    }, {});
-}
-
-
-function normalizeValue(value) {
-  switch (value) {
-    case FALSE_KEYWORD_1:
-    case FALSE_KEYWORD_2:
-      return false;
-    case TRUE_KEYWORD_1:
-    case TRUE_KEYWORD_2:
-      return true;
-    default:
-      return value;
-  }
-}
-
-function mapBreakWith(value) {
-  switch (value) {
-    case 'windows':
-    case 'crlf':
-    case BreakWith.CarriageReturnLineFeed:
-      return BreakWith.CarriageReturnLineFeed;
-    case 'unix':
-    case 'lf':
-    case BreakWith.LineFeed:
-      return BreakWith.LineFeed;
-    default:
-      return systemLineBreak;
-  }
-}
-
-function mapIndentWith(value) {
-  switch (value) {
-    case 'space':
-      return IndentWith.Space;
-    case 'tab':
-      return IndentWith.Tab;
-    default:
-      return value;
-  }
-}
-
-module.exports = {
-  Breaks: Breaks,
-  Spaces: Spaces,
-  formatFrom: formatFrom
-};

node_modules/clean-css/lib/options/inline-request.js

@@ -1,22 +0,0 @@
-var url = require('url');
-
-var override = require('../utils/override');
-
-function inlineRequestFrom(option) {
-  return override(
-    /* jshint camelcase: false */
-    proxyOptionsFrom(process.env.HTTP_PROXY || process.env.http_proxy),
-    option || {}
-  );
-}
-
-function proxyOptionsFrom(httpProxy) {
-  return httpProxy ?
-    {
-      hostname: url.parse(httpProxy).hostname,
-      port: parseInt(url.parse(httpProxy).port)
-    } :
-    {};
-}
-
-module.exports = inlineRequestFrom;

node_modules/clean-css/lib/options/inline-timeout.js

@@ -1,7 +0,0 @@
-var DEFAULT_TIMEOUT = 5000;
-
-function inlineTimeoutFrom(option) {
-  return option || DEFAULT_TIMEOUT;
-}
-
-module.exports = inlineTimeoutFrom;

node_modules/clean-css/lib/options/inline.js

@@ -1,15 +0,0 @@
-function inlineOptionsFrom(rules) {
-  if (Array.isArray(rules)) {
-    return rules;
-  }
-
-  if (rules === false) {
-    return ['none'];
-  }
-
-  return undefined === rules ?
-    ['local'] :
-    rules.split(',');
-}
-
-module.exports = inlineOptionsFrom;

node_modules/clean-css/lib/options/optimization-level.js

@@ -1,221 +0,0 @@
-var roundingPrecisionFrom = require('./rounding-precision').roundingPrecisionFrom;
-
-var override = require('../utils/override');
-
-var OptimizationLevel = {
-  Zero: '0',
-  One: '1',
-  Two: '2'
-};
-
-var DEFAULTS = {};
-
-DEFAULTS[OptimizationLevel.Zero] = {};
-DEFAULTS[OptimizationLevel.One] = {
-  cleanupCharsets: true,
-  normalizeUrls: true,
-  optimizeBackground: true,
-  optimizeBorderRadius: true,
-  optimizeFilter: true,
-  optimizeFontWeight: true,
-  optimizeOutline: true,
-  removeEmpty: true,
-  removeNegativePaddings: true,
-  removeQuotes: true,
-  removeWhitespace: true,
-  replaceMultipleZeros: true,
-  replaceTimeUnits: true,
-  replaceZeroUnits: true,
-  roundingPrecision: roundingPrecisionFrom(undefined),
-  selectorsSortingMethod: 'standard',
-  specialComments: 'all',
-  tidyAtRules: true,
-  tidyBlockScopes: true,
-  tidySelectors: true,
-  transform: noop
-};
-DEFAULTS[OptimizationLevel.Two] = {
-  mergeAdjacentRules: true,
-  mergeIntoShorthands: true,
-  mergeMedia: true,
-  mergeNonAdjacentRules: true,
-  mergeSemantically: false,
-  overrideProperties: true,
-  removeEmpty: true,
-  reduceNonAdjacentRules: true,
-  removeDuplicateFontRules: true,
-  removeDuplicateMediaBlocks: true,
-  removeDuplicateRules: true,
-  removeUnusedAtRules: false,
-  restructureRules: false,
-  skipProperties: []
-};
-
-var ALL_KEYWORD_1 = '*';
-var ALL_KEYWORD_2 = 'all';
-var FALSE_KEYWORD_1 = 'false';
-var FALSE_KEYWORD_2 = 'off';
-var TRUE_KEYWORD_1 = 'true';
-var TRUE_KEYWORD_2 = 'on';
-
-var LIST_VALUE_SEPARATOR = ',';
-var OPTION_SEPARATOR = ';';
-var OPTION_VALUE_SEPARATOR = ':';
-
-function noop() {}
-
-function optimizationLevelFrom(source) {
-  var level = override(DEFAULTS, {});
-  var Zero = OptimizationLevel.Zero;
-  var One = OptimizationLevel.One;
-  var Two = OptimizationLevel.Two;
-
-
-  if (undefined === source) {
-    delete level[Two];
-    return level;
-  }
-
-  if (typeof source == 'string') {
-    source = parseInt(source);
-  }
-
-  if (typeof source == 'number' && source === parseInt(Two)) {
-    return level;
-  }
-
-  if (typeof source == 'number' && source === parseInt(One)) {
-    delete level[Two];
-    return level;
-  }
-
-  if (typeof source == 'number' && source === parseInt(Zero)) {
-    delete level[Two];
-    delete level[One];
-    return level;
-  }
-
-  if (typeof source == 'object') {
-    source = covertValuesToHashes(source);
-  }
-
-  if (One in source && 'roundingPrecision' in source[One]) {
-    source[One].roundingPrecision = roundingPrecisionFrom(source[One].roundingPrecision);
-  }
-
-  if (Two in source && 'skipProperties' in source[Two] && typeof(source[Two].skipProperties) == 'string') {
-    source[Two].skipProperties = source[Two].skipProperties.split(LIST_VALUE_SEPARATOR);
-  }
-
-  if (Zero in source || One in source || Two in source) {
-    level[Zero] = override(level[Zero], source[Zero]);
-  }
-
-  if (One in source && ALL_KEYWORD_1 in source[One]) {
-    level[One] = override(level[One], defaults(One, normalizeValue(source[One][ALL_KEYWORD_1])));
-    delete source[One][ALL_KEYWORD_1];
-  }
-
-  if (One in source && ALL_KEYWORD_2 in source[One]) {
-    level[One] = override(level[One], defaults(One, normalizeValue(source[One][ALL_KEYWORD_2])));
-    delete source[One][ALL_KEYWORD_2];
-  }
-
-  if (One in source || Two in source) {
-    level[One] = override(level[One], source[One]);
-  } else {
-    delete level[One];
-  }
-
-  if (Two in source && ALL_KEYWORD_1 in source[Two]) {
-    level[Two] = override(level[Two], defaults(Two, normalizeValue(source[Two][ALL_KEYWORD_1])));
-    delete source[Two][ALL_KEYWORD_1];
-  }
-
-  if (Two in source && ALL_KEYWORD_2 in source[Two]) {
-    level[Two] = override(level[Two], defaults(Two, normalizeValue(source[Two][ALL_KEYWORD_2])));
-    delete source[Two][ALL_KEYWORD_2];
-  }
-
-  if (Two in source) {
-    level[Two] = override(level[Two], source[Two]);
-  } else {
-    delete level[Two];
-  }
-
-  return level;
-}
-
-function defaults(level, value) {
-  var options = override(DEFAULTS[level], {});
-  var key;
-
-  for (key in options) {
-    if (typeof options[key] == 'boolean') {
-      options[key] = value;
-    }
-  }
-
-  return options;
-}
-
-function normalizeValue(value) {
-  switch (value) {
-    case FALSE_KEYWORD_1:
-    case FALSE_KEYWORD_2:
-      return false;
-    case TRUE_KEYWORD_1:
-    case TRUE_KEYWORD_2:
-      return true;
-    default:
-      return value;
-  }
-}
-
-function covertValuesToHashes(source) {
-  var clonedSource = override(source, {});
-  var level;
-  var i;
-
-  for (i = 0; i <= 2; i++) {
-    level = '' + i;
-
-    if (level in clonedSource && (clonedSource[level] === undefined || clonedSource[level] === false)) {
-      delete clonedSource[level];
-    }
-
-    if (level in clonedSource && clonedSource[level] === true) {
-      clonedSource[level] = {};
-    }
-
-    if (level in clonedSource && typeof clonedSource[level] == 'string') {
-      clonedSource[level] = covertToHash(clonedSource[level], level);
-    }
-  }
-
-  return clonedSource;
-}
-
-function covertToHash(asString, level) {
-  return asString
-    .split(OPTION_SEPARATOR)
-    .reduce(function (accumulator, directive) {
-      var parts = directive.split(OPTION_VALUE_SEPARATOR);
-      var name = parts[0];
-      var value = parts[1];
-      var normalizedValue = normalizeValue(value);
-
-      if (ALL_KEYWORD_1 == name || ALL_KEYWORD_2 == name) {
-        accumulator = override(accumulator, defaults(level, normalizedValue));
-      } else {
-        accumulator[name] = normalizedValue;
-      }
-
-      return accumulator;
-    }, {});
-}
-
-module.exports = {
-  OptimizationLevel: OptimizationLevel,
-  optimizationLevelFrom: optimizationLevelFrom,
-};

node_modules/clean-css/lib/options/rebase-to.js

@@ -1,7 +0,0 @@
-var path = require('path');
-
-function rebaseToFrom(option) {
-  return option ? path.resolve(option) : process.cwd();
-}
-
-module.exports = rebaseToFrom;

node_modules/clean-css/lib/options/rebase.js

@@ -1,5 +0,0 @@
-function rebaseFrom(rebaseOption) {
-  return undefined === rebaseOption ? true : !!rebaseOption;
-}
-
-module.exports = rebaseFrom;

node_modules/clean-css/lib/options/rounding-precision.js

@@ -1,88 +0,0 @@
-var override = require('../utils/override');
-
-var INTEGER_PATTERN = /^\d+$/;
-
-var ALL_UNITS = ['*', 'all'];
-var DEFAULT_PRECISION = 'off'; // all precision changes are disabled
-var DIRECTIVES_SEPARATOR = ','; // e.g. *=5,px=3
-var DIRECTIVE_VALUE_SEPARATOR = '='; // e.g. *=5
-
-function roundingPrecisionFrom(source) {
-  return override(defaults(DEFAULT_PRECISION), buildPrecisionFrom(source));
-}
-
-function defaults(value) {
-  return {
-    'ch': value,
-    'cm': value,
-    'em': value,
-    'ex': value,
-    'in': value,
-    'mm': value,
-    'pc': value,
-    'pt': value,
-    'px': value,
-    'q': value,
-    'rem': value,
-    'vh': value,
-    'vmax': value,
-    'vmin': value,
-    'vw': value,
-    '%': value
-  };
-}
-
-function buildPrecisionFrom(source) {
-  if (source === null || source === undefined) {
-    return {};
-  }
-
-  if (typeof source == 'boolean') {
-    return {};
-  }
-
-  if (typeof source == 'number' && source == -1) {
-    return defaults(DEFAULT_PRECISION);
-  }
-
-  if (typeof source == 'number') {
-    return defaults(source);
-  }
-
-  if (typeof source == 'string' && INTEGER_PATTERN.test(source)) {
-    return defaults(parseInt(source));
-  }
-
-  if (typeof source == 'string' && source == DEFAULT_PRECISION) {
-    return defaults(DEFAULT_PRECISION);
-  }
-
-  if (typeof source == 'object') {
-    return source;
-  }
-
-  return source
-    .split(DIRECTIVES_SEPARATOR)
-    .reduce(function (accumulator, directive) {
-      var directiveParts = directive.split(DIRECTIVE_VALUE_SEPARATOR);
-      var name = directiveParts[0];
-      var value = parseInt(directiveParts[1]);
-
-      if (isNaN(value) || value == -1) {
-        value = DEFAULT_PRECISION;
-      }
-
-      if (ALL_UNITS.indexOf(name) > -1) {
-        accumulator = override(accumulator, defaults(value));
-      } else {
-        accumulator[name] = value;
-      }
-
-      return accumulator;
-    }, {});
-}
-
-module.exports = {
-  DEFAULT: DEFAULT_PRECISION,
-  roundingPrecisionFrom: roundingPrecisionFrom
-};

node_modules/clean-css/lib/reader/apply-source-maps.js

@@ -1,245 +0,0 @@
-var fs = require('fs');
-var path = require('path');
-
-var isAllowedResource = require('./is-allowed-resource');
-var matchDataUri = require('./match-data-uri');
-var rebaseLocalMap = require('./rebase-local-map');
-var rebaseRemoteMap = require('./rebase-remote-map');
-
-var Token = require('../tokenizer/token');
-var hasProtocol = require('../utils/has-protocol');
-var isDataUriResource = require('../utils/is-data-uri-resource');
-var isRemoteResource = require('../utils/is-remote-resource');
-
-var MAP_MARKER_PATTERN = /^\/\*# sourceMappingURL=(\S+) \*\/$/;
-
-function applySourceMaps(tokens, context, callback) {
-  var applyContext = {
-    callback: callback,
-    fetch: context.options.fetch,
-    index: 0,
-    inline: context.options.inline,
-    inlineRequest: context.options.inlineRequest,
-    inlineTimeout: context.options.inlineTimeout,
-    inputSourceMapTracker: context.inputSourceMapTracker,
-    localOnly: context.localOnly,
-    processedTokens: [],
-    rebaseTo: context.options.rebaseTo,
-    sourceTokens: tokens,
-    warnings: context.warnings
-  };
-
-  return context.options.sourceMap && tokens.length > 0 ?
-    doApplySourceMaps(applyContext) :
-    callback(tokens);
-}
-
-function doApplySourceMaps(applyContext) {
-  var singleSourceTokens = [];
-  var lastSource = findTokenSource(applyContext.sourceTokens[0]);
-  var source;
-  var token;
-  var l;
-
-  for (l = applyContext.sourceTokens.length; applyContext.index < l; applyContext.index++) {
-    token = applyContext.sourceTokens[applyContext.index];
-    source = findTokenSource(token);
-
-    if (source != lastSource) {
-      singleSourceTokens = [];
-      lastSource = source;
-    }
-
-    singleSourceTokens.push(token);
-    applyContext.processedTokens.push(token);
-
-    if (token[0] == Token.COMMENT && MAP_MARKER_PATTERN.test(token[1])) {
-      return fetchAndApplySourceMap(token[1], source, singleSourceTokens, applyContext);
-    }
-  }
-
-  return applyContext.callback(applyContext.processedTokens);
-}
-
-function findTokenSource(token) {
-  var scope;
-  var metadata;
-
-  if (token[0] == Token.AT_RULE || token[0] == Token.COMMENT) {
-    metadata = token[2][0];
-  } else {
-    scope = token[1][0];
-    metadata = scope[2][0];
-  }
-
-  return metadata[2];
-}
-
-function fetchAndApplySourceMap(sourceMapComment, source, singleSourceTokens, applyContext) {
-  return extractInputSourceMapFrom(sourceMapComment, applyContext, function (inputSourceMap) {
-    if (inputSourceMap) {
-      applyContext.inputSourceMapTracker.track(source, inputSourceMap);
-      applySourceMapRecursively(singleSourceTokens, applyContext.inputSourceMapTracker);
-    }
-
-    applyContext.index++;
-    return doApplySourceMaps(applyContext);
-  });
-}
-
-function extractInputSourceMapFrom(sourceMapComment, applyContext, whenSourceMapReady) {
-  var uri = MAP_MARKER_PATTERN.exec(sourceMapComment)[1];
-  var absoluteUri;
-  var sourceMap;
-  var rebasedMap;
-
-  if (isDataUriResource(uri)) {
-    sourceMap = extractInputSourceMapFromDataUri(uri);
-    return whenSourceMapReady(sourceMap);
-  } else if (isRemoteResource(uri)) {
-    return loadInputSourceMapFromRemoteUri(uri, applyContext, function (sourceMap) {
-      var parsedMap;
-
-      if (sourceMap) {
-        parsedMap = JSON.parse(sourceMap);
-        rebasedMap = rebaseRemoteMap(parsedMap, uri);
-        whenSourceMapReady(rebasedMap);
-      } else {
-        whenSourceMapReady(null);
-      }
-    });
-  } else {
-    // at this point `uri` is already rebased, see lib/reader/rebase.js#rebaseSourceMapComment
-    // it is rebased to be consistent with rebasing other URIs
-    // however here we need to resolve it back to read it from disk
-    absoluteUri = path.resolve(applyContext.rebaseTo, uri);
-    sourceMap = loadInputSourceMapFromLocalUri(absoluteUri, applyContext);
-
-    if (sourceMap) {
-      rebasedMap = rebaseLocalMap(sourceMap, absoluteUri, applyContext.rebaseTo);
-      return whenSourceMapReady(rebasedMap);
-    } else {
-      return whenSourceMapReady(null);
-    }
-  }
-}
-
-function extractInputSourceMapFromDataUri(uri) {
-  var dataUriMatch = matchDataUri(uri);
-  var charset = dataUriMatch[2] ? dataUriMatch[2].split(/[=;]/)[2] : 'us-ascii';
-  var encoding = dataUriMatch[3] ? dataUriMatch[3].split(';')[1] : 'utf8';
-  var data = encoding == 'utf8' ? global.unescape(dataUriMatch[4]) : dataUriMatch[4];
-
-  var buffer = new Buffer(data, encoding);
-  buffer.charset = charset;
-
-  return JSON.parse(buffer.toString());
-}
-
-function loadInputSourceMapFromRemoteUri(uri, applyContext, whenLoaded) {
-  var isAllowed = isAllowedResource(uri, true, applyContext.inline);
-  var isRuntimeResource = !hasProtocol(uri);
-
-  if (applyContext.localOnly) {
-    applyContext.warnings.push('Cannot fetch remote resource from "' + uri + '" as no callback given.');
-    return whenLoaded(null);
-  } else if (isRuntimeResource) {
-    applyContext.warnings.push('Cannot fetch "' + uri + '" as no protocol given.');
-    return whenLoaded(null);
-  } else if (!isAllowed) {
-    applyContext.warnings.push('Cannot fetch "' + uri + '" as resource is not allowed.');
-    return whenLoaded(null);
-  }
-
-  applyContext.fetch(uri, applyContext.inlineRequest, applyContext.inlineTimeout, function (error, body) {
-    if (error) {
-      applyContext.warnings.push('Missing source map at "' + uri + '" - ' + error);
-      return whenLoaded(null);
-    }
-
-    whenLoaded(body);
-  });
-}
-
-function loadInputSourceMapFromLocalUri(uri, applyContext) {
-  var isAllowed = isAllowedResource(uri, false, applyContext.inline);
-  var sourceMap;
-
-  if (!fs.existsSync(uri) || !fs.statSync(uri).isFile()) {
-    applyContext.warnings.push('Ignoring local source map at "' + uri + '" as resource is missing.');
-    return null;
-  } else if (!isAllowed) {
-    applyContext.warnings.push('Cannot fetch "' + uri + '" as resource is not allowed.');
-    return null;
-  }
-
-  sourceMap = fs.readFileSync(uri, 'utf-8');
-  return JSON.parse(sourceMap);
-}
-
-function applySourceMapRecursively(tokens, inputSourceMapTracker) {
-  var token;
-  var i, l;
-
-  for (i = 0, l = tokens.length; i < l; i++) {
-    token = tokens[i];
-
-    switch (token[0]) {
-      case Token.AT_RULE:
-        applySourceMapTo(token, inputSourceMapTracker);
-        break;
-      case Token.AT_RULE_BLOCK:
-        applySourceMapRecursively(token[1], inputSourceMapTracker);
-        applySourceMapRecursively(token[2], inputSourceMapTracker);
-        break;
-      case Token.AT_RULE_BLOCK_SCOPE:
-        applySourceMapTo(token, inputSourceMapTracker);
-        break;
-      case Token.NESTED_BLOCK:
-        applySourceMapRecursively(token[1], inputSourceMapTracker);
-        applySourceMapRecursively(token[2], inputSourceMapTracker);
-        break;
-      case Token.NESTED_BLOCK_SCOPE:
-        applySourceMapTo(token, inputSourceMapTracker);
-        break;
-      case Token.COMMENT:
-        applySourceMapTo(token, inputSourceMapTracker);
-        break;
-      case Token.PROPERTY:
-        applySourceMapRecursively(token, inputSourceMapTracker);
-        break;
-      case Token.PROPERTY_BLOCK:
-        applySourceMapRecursively(token[1], inputSourceMapTracker);
-        break;
-      case Token.PROPERTY_NAME:
-        applySourceMapTo(token, inputSourceMapTracker);
-        break;
-      case Token.PROPERTY_VALUE:
-        applySourceMapTo(token, inputSourceMapTracker);
-        break;
-      case Token.RULE:
-        applySourceMapRecursively(token[1], inputSourceMapTracker);
-        applySourceMapRecursively(token[2], inputSourceMapTracker);
-        break;
-      case Token.RULE_SCOPE:
-        applySourceMapTo(token, inputSourceMapTracker);
-    }
-  }
-
-  return tokens;
-}
-
-function applySourceMapTo(token, inputSourceMapTracker) {
-  var value = token[1];
-  var metadata = token[2];
-  var newMetadata = [];
-  var i, l;
-
-  for (i = 0, l = metadata.length; i < l; i++) {
-    newMetadata.push(inputSourceMapTracker.originalPositionFor(metadata[i], value.length));
-  }
-
-  token[2] = newMetadata;
-}
-
-module.exports = applySourceMaps;

node_modules/clean-css/lib/reader/extract-import-url-and-media.js

@@ -1,35 +0,0 @@
-var split = require('../utils/split');
-
-var BRACE_PREFIX = /^\(/;
-var BRACE_SUFFIX = /\)$/;
-var IMPORT_PREFIX_PATTERN = /^@import/i;
-var QUOTE_PREFIX_PATTERN = /['"]\s*/;
-var QUOTE_SUFFIX_PATTERN = /\s*['"]/;
-var URL_PREFIX_PATTERN = /^url\(\s*/i;
-var URL_SUFFIX_PATTERN = /\s*\)/i;
-
-function extractImportUrlAndMedia(atRuleValue) {
-  var uri;
-  var mediaQuery;
-  var stripped;
-  var parts;
-
-  stripped = atRuleValue
-    .replace(IMPORT_PREFIX_PATTERN, '')
-    .trim()
-    .replace(URL_PREFIX_PATTERN, '(')
-    .replace(URL_SUFFIX_PATTERN, ')')
-    .replace(QUOTE_PREFIX_PATTERN, '')
-    .replace(QUOTE_SUFFIX_PATTERN, '');
-
-  parts = split(stripped, ' ');
-
-  uri = parts[0]
-    .replace(BRACE_PREFIX, '')
-    .replace(BRACE_SUFFIX, '');
-  mediaQuery = parts.slice(1).join(' ');
-
-  return [uri, mediaQuery];
-}
-
-module.exports = extractImportUrlAndMedia;

node_modules/clean-css/lib/reader/input-source-map-tracker.js

@@ -1,58 +0,0 @@
-var SourceMapConsumer = require('source-map').SourceMapConsumer;
-
-function inputSourceMapTracker() {
-  var maps = {};
-
-  return {
-    all: all.bind(null, maps),
-    isTracking: isTracking.bind(null, maps),
-    originalPositionFor: originalPositionFor.bind(null, maps),
-    track: track.bind(null, maps)
-  };
-}
-
-function all(maps) {
-  return maps;
-}
-
-function isTracking(maps, source) {
-  return source in maps;
-}
-
-function originalPositionFor(maps, metadata, range, selectorFallbacks) {
-  var line = metadata[0];
-  var column = metadata[1];
-  var source = metadata[2];
-  var position = {
-    line: line,
-    column: column + range
-  };
-  var originalPosition;
-
-  while (!originalPosition && position.column > column) {
-    position.column--;
-    originalPosition = maps[source].originalPositionFor(position);
-  }
-
-  if (!originalPosition || originalPosition.column < 0) {
-    return metadata;
-  }
-
-  if (originalPosition.line === null && line > 1 && selectorFallbacks > 0) {
-    return originalPositionFor(maps, [line - 1, column, source], range, selectorFallbacks - 1);
-  }
-
-  return originalPosition.line !== null ?
-    toMetadata(originalPosition) :
-    metadata;
-}
-
-function toMetadata(asHash) {
-  return [asHash.line, asHash.column, asHash.source];
-}
-
-function track(maps, source, data) {
-  maps[source] = new SourceMapConsumer(data);
-}
-
-module.exports = inputSourceMapTracker;

node_modules/clean-css/lib/reader/is-allowed-resource.js

@@ -1,77 +0,0 @@
-var path = require('path');
-var url = require('url');
-
-var isRemoteResource = require('../utils/is-remote-resource');
-var hasProtocol = require('../utils/has-protocol');
-
-var HTTP_PROTOCOL = 'http:';
-
-function isAllowedResource(uri, isRemote, rules) {
-  var match;
-  var absoluteUri;
-  var allowed = isRemote ? false : true;
-  var rule;
-  var isNegated;
-  var normalizedRule;
-  var i;
-
-  if (rules.length === 0) {
-    return false;
-  }
-
-  if (isRemote && !hasProtocol(uri)) {
-    uri = HTTP_PROTOCOL + uri;
-  }
-
-  match = isRemote ?
-    url.parse(uri).host :
-    uri;
-
-  absoluteUri = isRemote ?
-    uri :
-    path.resolve(uri);
-
-  for (i = 0; i < rules.length; i++) {
-    rule = rules[i];
-    isNegated = rule[0] == '!';
-    normalizedRule = rule.substring(1);
-
-    if (isNegated && isRemote && isRemoteRule(normalizedRule)) {
-      allowed = allowed && !isAllowedResource(uri, true, [normalizedRule]);
-    } else if (isNegated && !isRemote && !isRemoteRule(normalizedRule)) {
-      allowed = allowed && !isAllowedResource(uri, false, [normalizedRule]);
-    } else if (isNegated) {
-      allowed = allowed && true;
-    } else if (rule == 'all') {
-      allowed = true;
-    } else if (isRemote && rule == 'local') {
-      allowed = allowed || false;
-    } else if (isRemote && rule == 'remote') {
-      allowed = true;
-    } else if (!isRemote && rule == 'remote') {
-      allowed = false;
-    } else if (!isRemote && rule == 'local') {
-      allowed = true;
-    } else if (rule === match) {
-      allowed = true;
-    } else if (rule === uri) {
-      allowed = true;
-    } else if (isRemote && absoluteUri.indexOf(rule) === 0) {
-      allowed = true;
-    } else if (!isRemote && absoluteUri.indexOf(path.resolve(rule)) === 0) {
-      allowed = true;
-    } else if (isRemote != isRemoteRule(normalizedRule)) {
-      allowed = allowed && true;
-    } else {
-      allowed = false;
-    }
-  }
-
-  return allowed;
-}
-
-function isRemoteRule(rule) {
-  return isRemoteResource(rule) || url.parse(HTTP_PROTOCOL + '//' + rule).host == rule;
-}
-
-module.exports = isAllowedResource;

node_modules/clean-css/lib/reader/load-original-sources.js

@@ -1,126 +0,0 @@
-var fs = require('fs');
-var path = require('path');
-
-var isAllowedResource = require('./is-allowed-resource');
-
-var hasProtocol = require('../utils/has-protocol');
-var isRemoteResource = require('../utils/is-remote-resource');
-
-function loadOriginalSources(context, callback) {
-  var loadContext = {
-    callback: callback,
-    fetch: context.options.fetch,
-    index: 0,
-    inline: context.options.inline,
-    inlineRequest: context.options.inlineRequest,
-    inlineTimeout: context.options.inlineTimeout,
-    localOnly: context.localOnly,
-    rebaseTo: context.options.rebaseTo,
-    sourcesContent: context.sourcesContent,
-    uriToSource: uriToSourceMapping(context.inputSourceMapTracker.all()),
-    warnings: context.warnings
-  };
-
-  return context.options.sourceMap && context.options.sourceMapInlineSources ?
-    doLoadOriginalSources(loadContext) :
-    callback();
-}
-
-function uriToSourceMapping(allSourceMapConsumers) {
-  var mapping = {};
-  var consumer;
-  var uri;
-  var source;
-  var i, l;
-
-  for (source in allSourceMapConsumers) {
-    consumer = allSourceMapConsumers[source];
-
-    for (i = 0, l = consumer.sources.length; i < l; i++) {
-      uri = consumer.sources[i];
-      source = consumer.sourceContentFor(uri, true);
-
-      mapping[uri] = source;
-    }
-  }
-
-  return mapping;
-}
-
-function doLoadOriginalSources(loadContext) {
-  var uris = Object.keys(loadContext.uriToSource);
-  var uri;
-  var source;
-  var total;
-
-  for (total = uris.length; loadContext.index < total; loadContext.index++) {
-    uri = uris[loadContext.index];
-    source = loadContext.uriToSource[uri];
-
-    if (source) {
-      loadContext.sourcesContent[uri] = source;
-    } else {
-      return loadOriginalSource(uri, loadContext);
-    }
-  }
-
-  return loadContext.callback();
-}
-
-function loadOriginalSource(uri, loadContext) {
-  var content;
-
-  if (isRemoteResource(uri)) {
-    return loadOriginalSourceFromRemoteUri(uri, loadContext, function (content) {
-      loadContext.index++;
-      loadContext.sourcesContent[uri] = content;
-      return doLoadOriginalSources(loadContext);
-    });
-  } else {
-    content = loadOriginalSourceFromLocalUri(uri, loadContext);
-    loadContext.index++;
-    loadContext.sourcesContent[uri] = content;
-    return doLoadOriginalSources(loadContext);
-  }
-}
-
-function loadOriginalSourceFromRemoteUri(uri, loadContext, whenLoaded) {
-  var isAllowed = isAllowedResource(uri, true, loadContext.inline);
-  var isRuntimeResource = !hasProtocol(uri);
-
-  if (loadContext.localOnly) {
-    loadContext.warnings.push('Cannot fetch remote resource from "' + uri + '" as no callback given.');
-    return whenLoaded(null);
-  } else if (isRuntimeResource) {
-    loadContext.warnings.push('Cannot fetch "' + uri + '" as no protocol given.');
-    return whenLoaded(null);
-  } else if (!isAllowed) {
-    loadContext.warnings.push('Cannot fetch "' + uri + '" as resource is not allowed.');
-    return whenLoaded(null);
-  }
-
-  loadContext.fetch(uri, loadContext.inlineRequest, loadContext.inlineTimeout, function (error, content) {
-    if (error) {
-      loadContext.warnings.push('Missing original source at "' + uri + '" - ' + error);
-    }
-
-    whenLoaded(content);
-  });
-}
-
-function loadOriginalSourceFromLocalUri(relativeUri, loadContext) {
-  var isAllowed = isAllowedResource(relativeUri, false, loadContext.inline);
-  var absoluteUri = path.resolve(loadContext.rebaseTo, relativeUri);
-
-  if (!fs.existsSync(absoluteUri) || !fs.statSync(absoluteUri).isFile()) {
-    loadContext.warnings.push('Ignoring local source map at "' + absoluteUri + '" as resource is missing.');
-    return null;
-  } else if (!isAllowed) {
-    loadContext.warnings.push('Cannot fetch "' + absoluteUri + '" as resource is not allowed.');
-    return null;
-  }
-
-  return fs.readFileSync(absoluteUri, 'utf8');
-}
-
-module.exports = loadOriginalSources;

node_modules/clean-css/lib/reader/load-remote-resource.js

@@ -1,74 +0,0 @@
-var http = require('http');
-var https = require('https');
-var url = require('url');
-
-var isHttpResource = require('../utils/is-http-resource');
-var isHttpsResource = require('../utils/is-https-resource');
-var override = require('../utils/override');
-
-var HTTP_PROTOCOL = 'http:';
-
-function loadRemoteResource(uri, inlineRequest, inlineTimeout, callback) {
-  var proxyProtocol = inlineRequest.protocol || inlineRequest.hostname;
-  var errorHandled = false;
-  var requestOptions;
-  var fetch;
-
-  requestOptions = override(
-    url.parse(uri),
-    inlineRequest || {}
-  );
-
-  if (inlineRequest.hostname !== undefined) {
-    // overwrite as we always expect a http proxy currently
-    requestOptions.protocol = inlineRequest.protocol || HTTP_PROTOCOL;
-    requestOptions.path = requestOptions.href;
-  }
-
-  fetch = (proxyProtocol && !isHttpsResource(proxyProtocol)) || isHttpResource(uri) ?
-    http.get :
-    https.get;
-
-  fetch(requestOptions, function (res) {
-    var chunks = [];
-    var movedUri;
-
-    if (errorHandled) {
-      return;
-    }
-
-    if (res.statusCode < 200 || res.statusCode > 399) {
-      return callback(res.statusCode, null);
-    } else if (res.statusCode > 299) {
-      movedUri = url.resolve(uri, res.headers.location);
-      return loadRemoteResource(movedUri, inlineRequest, inlineTimeout, callback);
-    }
-
-    res.on('data', function (chunk) {
-      chunks.push(chunk.toString());
-    });
-    res.on('end', function () {
-      var body = chunks.join('');
-      callback(null, body);
-    });
-  })
-  .on('error', function (res) {
-    if (errorHandled) {
-      return;
-    }
-
-    errorHandled = true;
-    callback(res.message, null);
-  })
-  .on('timeout', function () {
-    if (errorHandled) {
-      return;
-    }
-
-    errorHandled = true;
-    callback('timeout', null);
-  })
-  .setTimeout(inlineTimeout);
-}
-
-module.exports = loadRemoteResource;

node_modules/clean-css/lib/reader/match-data-uri.js

@@ -1,7 +0,0 @@
-var DATA_URI_PATTERN = /^data:(\S*?)?(;charset=[^;]+)?(;[^,]+?)?,(.+)/;
-
-function matchDataUri(uri) {
-  return DATA_URI_PATTERN.exec(uri);
-}
-
-module.exports = matchDataUri;

node_modules/clean-css/lib/reader/normalize-path.js

@@ -1,8 +0,0 @@
-var UNIX_SEPARATOR = '/';
-var WINDOWS_SEPARATOR_PATTERN = /\\/g;
-
-function normalizePath(path) {
-  return path.replace(WINDOWS_SEPARATOR_PATTERN, UNIX_SEPARATOR);
-}
-
-module.exports = normalizePath;

node_modules/clean-css/lib/reader/read-sources.js

@@ -1,341 +0,0 @@
-var fs = require('fs');
-var path = require('path');
-
-var applySourceMaps = require('./apply-source-maps');
-var extractImportUrlAndMedia = require('./extract-import-url-and-media');
-var isAllowedResource = require('./is-allowed-resource');
-var loadOriginalSources = require('./load-original-sources');
-var normalizePath = require('./normalize-path');
-var rebase = require('./rebase');
-var rebaseLocalMap = require('./rebase-local-map');
-var rebaseRemoteMap = require('./rebase-remote-map');
-var restoreImport = require('./restore-import');
-
-var tokenize = require('../tokenizer/tokenize');
-var Token = require('../tokenizer/token');
-var Marker = require('../tokenizer/marker');
-var hasProtocol = require('../utils/has-protocol');
-var isImport = require('../utils/is-import');
-var isRemoteResource = require('../utils/is-remote-resource');
-
-var UNKNOWN_URI = 'uri:unknown';
-
-function readSources(input, context, callback) {
-  return doReadSources(input, context, function (tokens) {
-    return applySourceMaps(tokens, context, function () {
-      return loadOriginalSources(context, function () { return callback(tokens); });
-    });
-  });
-}
-
-function doReadSources(input, context, callback) {
-  if (typeof input == 'string') {
-    return fromString(input, context, callback);
-  } else if (Buffer.isBuffer(input)) {
-    return fromString(input.toString(), context, callback);
-  } else if (Array.isArray(input)) {
-    return fromArray(input, context, callback);
-  } else if (typeof input == 'object') {
-    return fromHash(input, context, callback);
-  }
-}
-
-function fromString(input, context, callback) {
-  context.source = undefined;
-  context.sourcesContent[undefined] = input;
-  context.stats.originalSize += input.length;
-
-  return fromStyles(input, context, { inline: context.options.inline }, callback);
-}
-
-function fromArray(input, context, callback) {
-  var inputAsImports = input.reduce(function (accumulator, uriOrHash) {
-    if (typeof uriOrHash === 'string') {
-      return addStringSource(uriOrHash, accumulator);
-    } else {
-      return addHashSource(uriOrHash, context, accumulator);
-    }
-
-  }, []);
-
-  return fromStyles(inputAsImports.join(''), context, { inline: ['all'] }, callback);
-}
-
-function fromHash(input, context, callback) {
-  var inputAsImports = addHashSource(input, context, []);
-  return fromStyles(inputAsImports.join(''), context, { inline: ['all'] }, callback);
-}
-
-function addStringSource(input, imports) {
-  imports.push(restoreAsImport(normalizeUri(input)));
-  return imports;
-}
-
-function addHashSource(input, context, imports) {
-  var uri;
-  var normalizedUri;
-  var source;
-
-  for (uri in input) {
-    source = input[uri];
-    normalizedUri = normalizeUri(uri);
-
-    imports.push(restoreAsImport(normalizedUri));
-
-    context.sourcesContent[normalizedUri] = source.styles;
-
-    if (source.sourceMap) {
-      trackSourceMap(source.sourceMap, normalizedUri, context);
-    }
-  }
-
-  return imports;
-}
-
-function normalizeUri(uri) {
-  var currentPath = path.resolve('');
-  var absoluteUri;
-  var relativeToCurrentPath;
-  var normalizedUri;
-
-  if (isRemoteResource(uri)) {
-    return uri;
-  }
-
-  absoluteUri = path.isAbsolute(uri) ?
-    uri :
-    path.resolve(uri);
-  relativeToCurrentPath = path.relative(currentPath, absoluteUri);
-  normalizedUri = normalizePath(relativeToCurrentPath);
-
-  return normalizedUri;
-}
-
-function trackSourceMap(sourceMap, uri, context) {
-  var parsedMap = typeof sourceMap == 'string' ?
-      JSON.parse(sourceMap) :
-      sourceMap;
-  var rebasedMap = isRemoteResource(uri) ?
-    rebaseRemoteMap(parsedMap, uri) :
-    rebaseLocalMap(parsedMap, uri || UNKNOWN_URI, context.options.rebaseTo);
-
-  context.inputSourceMapTracker.track(uri, rebasedMap);
-}
-
-function restoreAsImport(uri) {
-  return restoreImport('url(' + uri + ')', '') + Marker.SEMICOLON;
-}
-
-function fromStyles(styles, context, parentInlinerContext, callback) {
-  var tokens;
-  var rebaseConfig = {};
-
-  if (!context.source) {
-    rebaseConfig.fromBase = path.resolve('');
-    rebaseConfig.toBase = context.options.rebaseTo;
-  } else if (isRemoteResource(context.source)) {
-    rebaseConfig.fromBase = context.source;
-    rebaseConfig.toBase = context.source;
-  } else if (path.isAbsolute(context.source)) {
-    rebaseConfig.fromBase = path.dirname(context.source);
-    rebaseConfig.toBase = context.options.rebaseTo;
-  } else {
-    rebaseConfig.fromBase = path.dirname(path.resolve(context.source));
-    rebaseConfig.toBase = context.options.rebaseTo;
-  }
-
-  tokens = tokenize(styles, context);
-  tokens = rebase(tokens, context.options.rebase, context.validator, rebaseConfig);
-
-  return allowsAnyImports(parentInlinerContext.inline) ?
-    inline(tokens, context, parentInlinerContext, callback) :
-    callback(tokens);
-}
-
-function allowsAnyImports(inline) {
-  return !(inline.length == 1 && inline[0] == 'none');
-}
-
-function inline(tokens, externalContext, parentInlinerContext, callback) {
-  var inlinerContext = {
-    afterContent: false,
-    callback: callback,
-    errors: externalContext.errors,
-    externalContext: externalContext,
-    fetch: externalContext.options.fetch,
-    inlinedStylesheets: parentInlinerContext.inlinedStylesheets || externalContext.inlinedStylesheets,
-    inline: parentInlinerContext.inline,
-    inlineRequest: externalContext.options.inlineRequest,
-    inlineTimeout: externalContext.options.inlineTimeout,
-    isRemote: parentInlinerContext.isRemote || false,
-    localOnly: externalContext.localOnly,
-    outputTokens: [],
-    rebaseTo: externalContext.options.rebaseTo,
-    sourceTokens: tokens,
-    warnings: externalContext.warnings
-  };
-
-  return doInlineImports(inlinerContext);
-}
-
-function doInlineImports(inlinerContext) {
-  var token;
-  var i, l;
-
-  for (i = 0, l = inlinerContext.sourceTokens.length; i < l; i++) {
-    token = inlinerContext.sourceTokens[i];
-
-    if (token[0] == Token.AT_RULE && isImport(token[1])) {
-      inlinerContext.sourceTokens.splice(0, i);
-      return inlineStylesheet(token, inlinerContext);
-    } else if (token[0] == Token.AT_RULE || token[0] == Token.COMMENT) {
-      inlinerContext.outputTokens.push(token);
-    } else {
-      inlinerContext.outputTokens.push(token);
-      inlinerContext.afterContent = true;
-    }
-  }
-
-  inlinerContext.sourceTokens = [];
-  return inlinerContext.callback(inlinerContext.outputTokens);
-}
-
-function inlineStylesheet(token, inlinerContext) {
-  var uriAndMediaQuery = extractImportUrlAndMedia(token[1]);
-  var uri = uriAndMediaQuery[0];
-  var mediaQuery = uriAndMediaQuery[1];
-  var metadata = token[2];
-
-  return isRemoteResource(uri) ?
-    inlineRemoteStylesheet(uri, mediaQuery, metadata, inlinerContext) :
-    inlineLocalStylesheet(uri, mediaQuery, metadata, inlinerContext);
-}
-
-function inlineRemoteStylesheet(uri, mediaQuery, metadata, inlinerContext) {
-  var isAllowed = isAllowedResource(uri, true, inlinerContext.inline);
-  var originalUri = uri;
-  var isLoaded = uri in inlinerContext.externalContext.sourcesContent;
-  var isRuntimeResource = !hasProtocol(uri);
-
-  if (inlinerContext.inlinedStylesheets.indexOf(uri) > -1) {
-    inlinerContext.warnings.push('Ignoring remote @import of "' + uri + '" as it has already been imported.');
-    inlinerContext.sourceTokens = inlinerContext.sourceTokens.slice(1);
-    return doInlineImports(inlinerContext);
-  } else if (inlinerContext.localOnly && inlinerContext.afterContent) {
-    inlinerContext.warnings.push('Ignoring remote @import of "' + uri + '" as no callback given and after other content.');
-    inlinerContext.sourceTokens = inlinerContext.sourceTokens.slice(1);
-    return doInlineImports(inlinerContext);
-  } else if (isRuntimeResource) {
-    inlinerContext.warnings.push('Skipping remote @import of "' + uri + '" as no protocol given.');
-    inlinerContext.outputTokens = inlinerContext.outputTokens.concat(inlinerContext.sourceTokens.slice(0, 1));
-    inlinerContext.sourceTokens = inlinerContext.sourceTokens.slice(1);
-    return doInlineImports(inlinerContext);
-  } else if (inlinerContext.localOnly && !isLoaded) {
-    inlinerContext.warnings.push('Skipping remote @import of "' + uri + '" as no callback given.');
-    inlinerContext.outputTokens = inlinerContext.outputTokens.concat(inlinerContext.sourceTokens.slice(0, 1));
-    inlinerContext.sourceTokens = inlinerContext.sourceTokens.slice(1);
-    return doInlineImports(inlinerContext);
-  } else if (!isAllowed && inlinerContext.afterContent) {
-    inlinerContext.warnings.push('Ignoring remote @import of "' + uri + '" as resource is not allowed and after other content.');
-    inlinerContext.sourceTokens = inlinerContext.sourceTokens.slice(1);
-    return doInlineImports(inlinerContext);
-  } else if (!isAllowed) {
-    inlinerContext.warnings.push('Skipping remote @import of "' + uri + '" as resource is not allowed.');
-    inlinerContext.outputTokens = inlinerContext.outputTokens.concat(inlinerContext.sourceTokens.slice(0, 1));
-    inlinerContext.sourceTokens = inlinerContext.sourceTokens.slice(1);
-    return doInlineImports(inlinerContext);
-  }
-
-  inlinerContext.inlinedStylesheets.push(uri);
-
-  function whenLoaded(error, importedStyles) {
-    if (error) {
-      inlinerContext.errors.push('Broken @import declaration of "' + uri + '" - ' + error);
-
-      return process.nextTick(function () {
-        inlinerContext.outputTokens = inlinerContext.outputTokens.concat(inlinerContext.sourceTokens.slice(0, 1));
-        inlinerContext.sourceTokens = inlinerContext.sourceTokens.slice(1);
-        doInlineImports(inlinerContext);
-      });
-    }
-
-    inlinerContext.inline = inlinerContext.externalContext.options.inline;
-    inlinerContext.isRemote = true;
-
-    inlinerContext.externalContext.source = originalUri;
-    inlinerContext.externalContext.sourcesContent[uri] = importedStyles;
-    inlinerContext.externalContext.stats.originalSize += importedStyles.length;
-
-    return fromStyles(importedStyles, inlinerContext.externalContext, inlinerContext, function (importedTokens) {
-      importedTokens = wrapInMedia(importedTokens, mediaQuery, metadata);
-
-      inlinerContext.outputTokens = inlinerContext.outputTokens.concat(importedTokens);
-      inlinerContext.sourceTokens = inlinerContext.sourceTokens.slice(1);
-
-      return doInlineImports(inlinerContext);
-    });
-  }
-
-  return isLoaded ?
-    whenLoaded(null, inlinerContext.externalContext.sourcesContent[uri]) :
-    inlinerContext.fetch(uri, inlinerContext.inlineRequest, inlinerContext.inlineTimeout, whenLoaded);
-}
-
-function inlineLocalStylesheet(uri, mediaQuery, metadata, inlinerContext) {
-  var currentPath = path.resolve('');
-  var absoluteUri = path.isAbsolute(uri) ?
-    path.resolve(currentPath, uri[0] == '/' ? uri.substring(1) : uri) :
-    path.resolve(inlinerContext.rebaseTo, uri);
-  var relativeToCurrentPath = path.relative(currentPath, absoluteUri);
-  var importedStyles;
-  var isAllowed = isAllowedResource(uri, false, inlinerContext.inline);
-  var normalizedPath = normalizePath(relativeToCurrentPath);
-  var isLoaded = normalizedPath in inlinerContext.externalContext.sourcesContent;
-
-  if (inlinerContext.inlinedStylesheets.indexOf(absoluteUri) > -1) {
-    inlinerContext.warnings.push('Ignoring local @import of "' + uri + '" as it has already been imported.');
-  } else if (!isLoaded && (!fs.existsSync(absoluteUri) || !fs.statSync(absoluteUri).isFile())) {
-    inlinerContext.errors.push('Ignoring local @import of "' + uri + '" as resource is missing.');
-  } else if (!isAllowed && inlinerContext.afterContent) {
-    inlinerContext.warnings.push('Ignoring local @import of "' + uri + '" as resource is not allowed and after other content.');
-  } else if (inlinerContext.afterContent) {
-    inlinerContext.warnings.push('Ignoring local @import of "' + uri + '" as after other content.');
-  } else if (!isAllowed) {
-    inlinerContext.warnings.push('Skipping local @import of "' + uri + '" as resource is not allowed.');
-    inlinerContext.outputTokens = inlinerContext.outputTokens.concat(inlinerContext.sourceTokens.slice(0, 1));
-  } else {
-    importedStyles = isLoaded ?
-      inlinerContext.externalContext.sourcesContent[normalizedPath] :
-      fs.readFileSync(absoluteUri, 'utf-8');
-
-    inlinerContext.inlinedStylesheets.push(absoluteUri);
-    inlinerContext.inline = inlinerContext.externalContext.options.inline;
-
-    inlinerContext.externalContext.source = normalizedPath;
-    inlinerContext.externalContext.sourcesContent[normalizedPath] = importedStyles;
-    inlinerContext.externalContext.stats.originalSize += importedStyles.length;
-
-    return fromStyles(importedStyles, inlinerContext.externalContext, inlinerContext, function (importedTokens) {
-      importedTokens = wrapInMedia(importedTokens, mediaQuery, metadata);
-
-      inlinerContext.outputTokens = inlinerContext.outputTokens.concat(importedTokens);
-      inlinerContext.sourceTokens = inlinerContext.sourceTokens.slice(1);
-
-      return doInlineImports(inlinerContext);
-    });
-  }
-
-  inlinerContext.sourceTokens = inlinerContext.sourceTokens.slice(1);
-
-  return doInlineImports(inlinerContext);
-}
-
-function wrapInMedia(tokens, mediaQuery, metadata) {
-  if (mediaQuery) {
-    return [[Token.NESTED_BLOCK, [[Token.NESTED_BLOCK_SCOPE, '@media ' + mediaQuery, metadata]], tokens]];
-  } else {
-    return tokens;
-  }
-}
-
-module.exports = readSources;