{/* foo */}
+```
+
+Use fromCodePoint to convert high value unicode entities ([#243](https://github.com/babel/babylon/pull/243)) (Ryan Duffy)
+
+When high value unicode entities (e.g. 💩) were used in the input source code they are now correctly encoded in the resulting AST.
+
+Rename folder to avoid Windows-illegal characters ([#281](https://github.com/babel/babylon/pull/281)) (Ryan Plant)
+
+Allow this.state.clone() when parsing decorators ([#262](https://github.com/babel/babylon/pull/262)) (Alex Rattray)
+
+### :house: Internal
+
+User external-helpers ([#254](https://github.com/babel/babylon/pull/254)) (Daniel Tschinder)
+
+Add watch script for dev ([#234](https://github.com/babel/babylon/pull/234)) (Kai Cataldo)
+
+Freeze current plugins list for "*" option, and remove from README.md ([#245](https://github.com/babel/babylon/pull/245)) (Andrew Levine)
+
+Prepare tests for multiple fixture runners. ([#240](https://github.com/babel/babylon/pull/240)) (Daniel Tschinder)
+
+Add some test coverage for decorators stage-0 plugin ([#250](https://github.com/babel/babylon/pull/250)) (Andrew Levine)
+
+Refactor tokenizer types file ([#263](https://github.com/babel/babylon/pull/263)) (Sven SAULEAU)
+
+Update eslint-config-babel to the latest version 🚀 ([#273](https://github.com/babel/babylon/pull/273)) (greenkeeper[bot])
+
+chore(package): update rollup to version 0.41.0 ([#272](https://github.com/babel/babylon/pull/272)) (greenkeeper[bot])
+
+chore(package): update flow-bin to version 0.37.0 ([#255](https://github.com/babel/babylon/pull/255)) (greenkeeper[bot])
+
+## 6.14.1 (2016-11-17)
+
+### :bug: Bug Fix
+
+Allow `"plugins": ["*"]` ([#229](https://github.com/babel/babylon/pull/229)) (Daniel Tschinder)
+
+```js
+{
+ "plugins": ["*"]
+}
+```
+
+Will include all parser plugins instead of specifying each one individually. Useful for tools like babel-eslint, jscodeshift, and ast-explorer.
+
+## 6.14.0 (2016-11-16)
+
+### :eyeglasses: Spec Compliancy
+
+Throw error for reserved words `enum` and `await` ([#195](https://github.com/babel/babylon/pull/195)) (Kai Cataldo)
+
+[11.6.2.2 Future Reserved Words](http://www.ecma-international.org/ecma-262/6.0/#sec-future-reserved-words)
+
+Babylon will throw for more reserved words such as `enum` or `await` (in strict mode).
+
+```
+class enum {} // throws
+class await {} // throws in strict mode (module)
+```
+
+Optional names for function types and object type indexers ([#197](https://github.com/babel/babylon/pull/197)) (Gabe Levi)
+
+So where you used to have to write
+
+```js
+type A = (x: string, y: boolean) => number;
+type B = (z: string) => number;
+type C = { [key: string]: number };
+```
+
+you can now write (with flow 0.34.0)
+
+```js
+type A = (string, boolean) => number;
+type B = string => number;
+type C = { [string]: number };
+```
+
+Parse flow nested array type annotations like `number[][]` ([#219](https://github.com/babel/babylon/pull/219)) (Bernhard Häussner)
+
+Supports these form now of specifying array types:
+
+```js
+var a: number[][][][];
+var b: string[][];
+```
+
+### :bug: Bug Fix
+
+Correctly eat semicolon at the end of `DelcareModuleExports` ([#223](https://github.com/babel/babylon/pull/223)) (Daniel Tschinder)
+
+```
+declare module "foo" { declare module.exports: number }
+declare module "foo" { declare module.exports: number; } // also allowed now
+```
+
+### :house: Internal
+
+ * Count Babel tests towards Babylon code coverage ([#182](https://github.com/babel/babylon/pull/182)) (Moti Zilberman)
+ * Fix strange line endings ([#214](https://github.com/babel/babylon/pull/214)) (Thomas Grainger)
+ * Add node 7 (Daniel Tschinder)
+ * chore(package): update flow-bin to version 0.34.0 ([#204](https://github.com/babel/babylon/pull/204)) (Greenkeeper)
+
+## v6.13.1 (2016-10-26)
+
+### :nail_care: Polish
+
+- Use rollup for bundling to speed up startup time ([#190](https://github.com/babel/babylon/pull/190)) ([@drewml](https://github.com/DrewML))
+
+```js
+const babylon = require('babylon');
+const ast = babylon.parse('var foo = "lol";');
+```
+
+With that test case, there was a ~95ms savings by removing the need for node to build/traverse the dependency graph.
+
+**Without bundling**
+
+
+**With bundling**
+
+
+- add clean command [skip ci] ([#201](https://github.com/babel/babylon/pull/201)) (Henry Zhu)
+- add ForAwaitStatement (async generator already added) [skip ci] ([#196](https://github.com/babel/babylon/pull/196)) (Henry Zhu)
+
+## v6.13.0 (2016-10-21)
+
+### :eyeglasses: Spec Compliancy
+
+Property variance type annotations for Flow plugin ([#161](https://github.com/babel/babylon/pull/161)) (Sam Goldman)
+
+> See https://flowtype.org/docs/variance.html for more information
+
+```js
+type T = { +p: T };
+interface T { -p: T };
+declare class T { +[k:K]: V };
+class T { -[k:K]: V };
+class C2 { +p: T = e };
+```
+
+Raise error on duplicate definition of __proto__ ([#183](https://github.com/babel/babylon/pull/183)) (Moti Zilberman)
+
+```js
+({ __proto__: 1, __proto__: 2 }) // Throws an error now
+```
+
+### :bug: Bug Fix
+
+Flow: Allow class properties to be named `static` ([#184](https://github.com/babel/babylon/pull/184)) (Moti Zilberman)
+
+```js
+declare class A {
+ static: T;
+}
+```
+
+Allow "async" as identifier for object literal property shorthand ([#187](https://github.com/babel/babylon/pull/187)) (Andrew Levine)
+
+```js
+var foo = { async, bar };
+```
+
+### :nail_care: Polish
+
+Fix flowtype and add inType to state ([#189](https://github.com/babel/babylon/pull/189)) (Daniel Tschinder)
+
+> This improves the performance slightly (because of hidden classes)
+
+### :house: Internal
+
+Fix .gitattributes line ending setting ([#191](https://github.com/babel/babylon/pull/191)) (Moti Zilberman)
+
+Increase test coverage ([#175](https://github.com/babel/babylon/pull/175) (Moti Zilberman)
+
+Readd missin .eslinignore for IDEs (Daniel Tschinder)
+
+Error on missing expected.json fixture in CI ([#188](https://github.com/babel/babylon/pull/188)) (Moti Zilberman)
+
+Add .gitattributes and .editorconfig for LF line endings ([#179](https://github.com/babel/babylon/pull/179)) (Moti Zilberman)
+
+Fixes two tests that are failing after the merge of #172 ([#177](https://github.com/babel/babylon/pull/177)) (Moti Zilberman)
+
+## v6.12.0 (2016-10-14)
+
+### :eyeglasses: Spec Compliancy
+
+Implement import() syntax ([#163](https://github.com/babel/babylon/pull/163)) (Jordan Gensler)
+
+#### Dynamic Import
+
+- Proposal Repo: https://github.com/domenic/proposal-dynamic-import
+- Championed by [@domenic](https://github.com/domenic)
+- stage-2
+- [sept-28 tc39 notes](https://github.com/rwaldron/tc39-notes/blob/master/es7/2016-09/sept-28.md#113a-import)
+
+> This repository contains a proposal for adding a "function-like" import() module loading syntactic form to JavaScript
+
+```js
+import(`./section-modules/${link.dataset.entryModule}.js`)
+.then(module => {
+ module.loadPageInto(main);
+})
+```
+
+Add EmptyTypeAnnotation ([#171](https://github.com/babel/babylon/pull/171)) (Sam Goldman)
+
+#### EmptyTypeAnnotation
+
+Just wasn't covered before.
+
+```js
+type T = empty;
+```
+
+### :bug: Bug Fix
+
+Fix crash when exporting with destructuring and sparse array ([#170](https://github.com/babel/babylon/pull/170)) (Jeroen Engels)
+
+```js
+// was failing due to sparse array
+export const { foo: [ ,, qux7 ] } = bar;
+```
+
+Allow keyword in Flow object declaration property names with type parameters ([#146](https://github.com/babel/babylon/pull/146)) (Dan Harper)
+
+```js
+declare class X {
+ foobar
+ {...todos.map(todo => )}
+
+```
+
+- Add support for declare module.exports ([#72](https://github.com/babel/babylon/pull/72)) @danez
+
+```js
+declare module "foo" {
+ declare module.exports: {}
+}
+```
+
+### New Features
+
+- If supplied, attach filename property to comment node loc. ([#80](https://github.com/babel/babylon/pull/80)) @divmain
+- Add identifier name to node loc field ([#90](https://github.com/babel/babylon/pull/90)) @kittens
+
+### Bug Fixes
+
+- Fix exponential operator to behave according to spec ([#75](https://github.com/babel/babylon/pull/75)) @danez
+- Fix lookahead to not add comments to arrays which are not cloned ([#76](https://github.com/babel/babylon/pull/76)) @danez
+- Fix accidental fall-through in Flow type parsing. ([#82](https://github.com/babel/babylon/pull/82)) @xiemaisi
+- Only allow declares inside declare module ([#73](https://github.com/babel/babylon/pull/73)) @danez
+- Small fix for parsing type parameter declarations ([#83](https://github.com/babel/babylon/pull/83)) @gabelevi
+- Fix arrow param locations with flow types ([#57](https://github.com/babel/babylon/pull/57)) @danez
+- Fixes SyntaxError position with flow optional type ([#65](https://github.com/babel/babylon/pull/65)) @danez
+
+### Internal
+
+- Add codecoverage to tests @danez
+- Fix tests to not save expected output if we expect the test to fail @danez
+- Make a shallow clone of babel for testing @danez
+- chore(package): update cross-env to version 2.0.0 ([#77](https://github.com/babel/babylon/pull/77)) @greenkeeperio-bot
+- chore(package): update ava to version 0.16.0 ([#86](https://github.com/babel/babylon/pull/86)) @greenkeeperio-bot
+- chore(package): update babel-plugin-istanbul to version 2.0.0 ([#89](https://github.com/babel/babylon/pull/89)) @greenkeeperio-bot
+- chore(package): update nyc to version 8.0.0 ([#88](https://github.com/babel/babylon/pull/88)) @greenkeeperio-bot
+
+## 6.8.4 (2016-07-06)
+
+### Bug Fixes
+
+- Fix the location of params, when flow and default value used ([#68](https://github.com/babel/babylon/pull/68)) @danez
+
+## 6.8.3 (2016-07-02)
+
+### Bug Fixes
+
+- Fix performance regression introduced in 6.8.2 with conditionals ([#63](https://github.com/babel/babylon/pull/63)) @danez
+
+## 6.8.2 (2016-06-24)
+
+### Bug Fixes
+
+- Fix parse error with yielding jsx elements in generators `function* it() { yield ; }` ([#31](https://github.com/babel/babylon/pull/31)) @eldereal
+- When cloning nodes do not clone its comments ([#24](https://github.com/babel/babylon/pull/24)) @danez
+- Fix parse errors when using arrow functions with an spread element and return type `(...props): void => {}` ([#10](https://github.com/babel/babylon/pull/10)) @danez
+- Fix leading comments added from previous node ([#23](https://github.com/babel/babylon/pull/23)) @danez
+- Fix parse errors with flow's optional arguments `(arg?) => {}` ([#19](https://github.com/babel/babylon/pull/19)) @danez
+- Support negative numeric type literals @kittens
+- Remove line terminator restriction after await keyword @kittens
+- Remove grouped type arrow restriction as it seems flow no longer has it @kittens
+- Fix parse error with generic methods that have the name `get` or `set` `class foo { get() {} }` ([#55](https://github.com/babel/babylon/pull/55)) @vkurchatkin
+- Fix parse error with arrow functions that have flow type parameter declarations `
+ 
+
+ Babylon is a JavaScript parser used in Babel. +
+ +
+ 
+ 
+
-
+ shortestValue: 'none',
+ shorthand: true
+ },
+ 'list-style-type' : {
+ canOverride: canOverride.always,
+ defaultValue: '__hack',
+ // NOTE: we can't tell the real default value here, it's 'disc' for
- and 'decimal' for
-
+ // -- this is a hack, but it doesn't matter because this value will be either overridden or it will disappear at the final step anyway
+ shortestValue: 'none'
+ },
+ 'list-style-position' : {
+ canOverride: canOverride.always,
+ defaultValue: 'outside',
+ shortestValue: 'inside'
+ },
+ 'list-style-image' : {
+ canOverride: canOverride.always,
+ defaultValue: 'none'
+ },
+ 'outline': {
+ components: [
+ 'outline-color',
+ 'outline-style',
+ 'outline-width'
+ ],
+ breakUp: breakUp.outline,
+ restore: restore.withoutDefaults,
+ defaultValue: '0',
+ shorthand: true
+ },
+ 'outline-color': {
+ canOverride: canOverride.color,
+ defaultValue: 'invert',
+ shortestValue: 'red'
+ },
+ 'outline-style': {
+ canOverride: canOverride.always,
+ defaultValue: 'none'
+ },
+ 'outline-width': {
+ canOverride: canOverride.unit,
+ defaultValue: 'medium',
+ shortestValue: '0'
+ },
+ '-moz-transform': {
+ canOverride: canOverride.sameFunctionOrValue
+ },
+ '-ms-transform': {
+ canOverride: canOverride.sameFunctionOrValue
+ },
+ '-webkit-transform': {
+ canOverride: canOverride.sameFunctionOrValue
+ },
+ 'transform': {
+ canOverride: canOverride.sameFunctionOrValue
+ }
+};
+
+var addFourValueShorthand = function (prop, components, options) {
+ options = options || {};
+ compactable[prop] = {
+ canOverride: options.canOverride,
+ components: components,
+ breakUp: options.breakUp || breakUp.fourValues,
+ defaultValue: options.defaultValue || '0',
+ restore: options.restore || restore.fourValues,
+ shortestValue: options.shortestValue,
+ shorthand: true
+ };
+ for (var i = 0; i < components.length; i++) {
+ compactable[components[i]] = {
+ breakUp: options.breakUp || breakUp.fourValues,
+ canOverride: options.canOverride || canOverride.unit,
+ defaultValue: options.defaultValue || '0',
+ shortestValue: options.shortestValue
+ };
+ }
+};
+
+['', '-moz-', '-o-'].forEach(function (prefix) {
+ addFourValueShorthand(prefix + 'border-radius', [
+ prefix + 'border-top-left-radius',
+ prefix + 'border-top-right-radius',
+ prefix + 'border-bottom-right-radius',
+ prefix + 'border-bottom-left-radius'
+ ], {
+ breakUp: breakUp.borderRadius,
+ restore: restore.borderRadius
+ });
+});
+
+addFourValueShorthand('border-color', [
+ 'border-top-color',
+ 'border-right-color',
+ 'border-bottom-color',
+ 'border-left-color'
+], {
+ breakUp: breakUp.fourValues,
+ canOverride: canOverride.color,
+ defaultValue: 'none',
+ shortestValue: 'red'
+});
+
+addFourValueShorthand('border-style', [
+ 'border-top-style',
+ 'border-right-style',
+ 'border-bottom-style',
+ 'border-left-style'
+], {
+ breakUp: breakUp.fourValues,
+ canOverride: canOverride.always,
+ defaultValue: 'none'
+});
+
+addFourValueShorthand('border-width', [
+ 'border-top-width',
+ 'border-right-width',
+ 'border-bottom-width',
+ 'border-left-width'
+], {
+ defaultValue: 'medium',
+ shortestValue: '0'
+});
+
+addFourValueShorthand('padding', [
+ 'padding-top',
+ 'padding-right',
+ 'padding-bottom',
+ 'padding-left'
+]);
+
+addFourValueShorthand('margin', [
+ 'margin-top',
+ 'margin-right',
+ 'margin-bottom',
+ 'margin-left'
+]);
+
+// Adds `componentOf` field to all longhands
+for (var property in compactable) {
+ if (compactable[property].shorthand) {
+ for (var i = 0, l = compactable[property].components.length; i < l; i++) {
+ compactable[compactable[property].components[i]].componentOf = property;
+ }
+ }
+}
+
+module.exports = compactable;
diff --git a/node_modules/clean-css/lib/properties/every-combination.js b/node_modules/clean-css/lib/properties/every-combination.js
new file mode 100644
index 0000000000000000000000000000000000000000..be3faa69c433476cd2c0e6901a77811742c7923f
--- /dev/null
+++ b/node_modules/clean-css/lib/properties/every-combination.js
@@ -0,0 +1,28 @@
+var shallowClone = require('./clone').shallow;
+
+var MULTIPLEX_SEPARATOR = ',';
+
+function everyCombination(fn, left, right, validator) {
+ var samePositon = !left.shorthand && !right.shorthand && !left.multiplex && !right.multiplex;
+ var _left = shallowClone(left);
+ var _right = shallowClone(right);
+
+ for (var i = 0, l = left.value.length; i < l; i++) {
+ for (var j = 0, m = right.value.length; j < m; j++) {
+ if (left.value[i][0] == MULTIPLEX_SEPARATOR || right.value[j][0] == MULTIPLEX_SEPARATOR)
+ continue;
+
+ if (samePositon && i != j)
+ continue;
+
+ _left.value = [left.value[i]];
+ _right.value = [right.value[j]];
+ if (!fn(_left, _right, validator))
+ return false;
+ }
+ }
+
+ return true;
+}
+
+module.exports = everyCombination;
diff --git a/node_modules/clean-css/lib/properties/has-inherit.js b/node_modules/clean-css/lib/properties/has-inherit.js
new file mode 100644
index 0000000000000000000000000000000000000000..96a103baf5070df9445570ae13244615d9136654
--- /dev/null
+++ b/node_modules/clean-css/lib/properties/has-inherit.js
@@ -0,0 +1,10 @@
+function hasInherit(property) {
+ for (var i = property.value.length - 1; i >= 0; i--) {
+ if (property.value[i][0] == 'inherit')
+ return true;
+ }
+
+ return false;
+}
+
+module.exports = hasInherit;
diff --git a/node_modules/clean-css/lib/properties/invalid-property-error.js b/node_modules/clean-css/lib/properties/invalid-property-error.js
new file mode 100644
index 0000000000000000000000000000000000000000..86d5b5f9b8066813b20abbedc40fe1fe63b8b829
--- /dev/null
+++ b/node_modules/clean-css/lib/properties/invalid-property-error.js
@@ -0,0 +1,10 @@
+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;
diff --git a/node_modules/clean-css/lib/properties/optimizer.js b/node_modules/clean-css/lib/properties/optimizer.js
new file mode 100644
index 0000000000000000000000000000000000000000..855b7f9dac4dae4a23213055909d7d82d48b811e
--- /dev/null
+++ b/node_modules/clean-css/lib/properties/optimizer.js
@@ -0,0 +1,215 @@
+var compactable = require('./compactable');
+var wrapForOptimizing = require('./wrap-for-optimizing').all;
+var populateComponents = require('./populate-components');
+var compactOverrides = require('./override-compactor');
+var compactShorthands = require('./shorthand-compactor');
+var removeUnused = require('./remove-unused');
+var restoreFromOptimizing = require('./restore-from-optimizing');
+var stringifyProperty = require('../stringifier/one-time').property;
+
+var shorthands = {
+ 'animation-delay': ['animation'],
+ 'animation-direction': ['animation'],
+ 'animation-duration': ['animation'],
+ 'animation-fill-mode': ['animation'],
+ 'animation-iteration-count': ['animation'],
+ 'animation-name': ['animation'],
+ 'animation-play-state': ['animation'],
+ 'animation-timing-function': ['animation'],
+ '-moz-animation-delay': ['-moz-animation'],
+ '-moz-animation-direction': ['-moz-animation'],
+ '-moz-animation-duration': ['-moz-animation'],
+ '-moz-animation-fill-mode': ['-moz-animation'],
+ '-moz-animation-iteration-count': ['-moz-animation'],
+ '-moz-animation-name': ['-moz-animation'],
+ '-moz-animation-play-state': ['-moz-animation'],
+ '-moz-animation-timing-function': ['-moz-animation'],
+ '-o-animation-delay': ['-o-animation'],
+ '-o-animation-direction': ['-o-animation'],
+ '-o-animation-duration': ['-o-animation'],
+ '-o-animation-fill-mode': ['-o-animation'],
+ '-o-animation-iteration-count': ['-o-animation'],
+ '-o-animation-name': ['-o-animation'],
+ '-o-animation-play-state': ['-o-animation'],
+ '-o-animation-timing-function': ['-o-animation'],
+ '-webkit-animation-delay': ['-webkit-animation'],
+ '-webkit-animation-direction': ['-webkit-animation'],
+ '-webkit-animation-duration': ['-webkit-animation'],
+ '-webkit-animation-fill-mode': ['-webkit-animation'],
+ '-webkit-animation-iteration-count': ['-webkit-animation'],
+ '-webkit-animation-name': ['-webkit-animation'],
+ '-webkit-animation-play-state': ['-webkit-animation'],
+ '-webkit-animation-timing-function': ['-webkit-animation'],
+ 'border-color': ['border'],
+ 'border-style': ['border'],
+ 'border-width': ['border'],
+ 'border-bottom': ['border'],
+ 'border-bottom-color': ['border-bottom', 'border-color', 'border'],
+ 'border-bottom-style': ['border-bottom', 'border-style', 'border'],
+ 'border-bottom-width': ['border-bottom', 'border-width', 'border'],
+ 'border-left': ['border'],
+ 'border-left-color': ['border-left', 'border-color', 'border'],
+ 'border-left-style': ['border-left', 'border-style', 'border'],
+ 'border-left-width': ['border-left', 'border-width', 'border'],
+ 'border-right': ['border'],
+ 'border-right-color': ['border-right', 'border-color', 'border'],
+ 'border-right-style': ['border-right', 'border-style', 'border'],
+ 'border-right-width': ['border-right', 'border-width', 'border'],
+ 'border-top': ['border'],
+ 'border-top-color': ['border-top', 'border-color', 'border'],
+ 'border-top-style': ['border-top', 'border-style', 'border'],
+ 'border-top-width': ['border-top', 'border-width', 'border'],
+ 'font-family': ['font'],
+ 'font-size': ['font'],
+ 'font-style': ['font'],
+ 'font-variant': ['font'],
+ 'font-weight': ['font'],
+ 'transition-delay': ['transition'],
+ 'transition-duration': ['transition'],
+ 'transition-property': ['transition'],
+ 'transition-timing-function': ['transition'],
+ '-moz-transition-delay': ['-moz-transition'],
+ '-moz-transition-duration': ['-moz-transition'],
+ '-moz-transition-property': ['-moz-transition'],
+ '-moz-transition-timing-function': ['-moz-transition'],
+ '-o-transition-delay': ['-o-transition'],
+ '-o-transition-duration': ['-o-transition'],
+ '-o-transition-property': ['-o-transition'],
+ '-o-transition-timing-function': ['-o-transition'],
+ '-webkit-transition-delay': ['-webkit-transition'],
+ '-webkit-transition-duration': ['-webkit-transition'],
+ '-webkit-transition-property': ['-webkit-transition'],
+ '-webkit-transition-timing-function': ['-webkit-transition']
+};
+
+function _optimize(properties, mergeAdjacent, aggressiveMerging, validator) {
+ var overrideMapping = {};
+ var lastName = null;
+ var lastProperty;
+ var j;
+
+ function mergeablePosition(position) {
+ if (mergeAdjacent === false || mergeAdjacent === true)
+ return mergeAdjacent;
+
+ return mergeAdjacent.indexOf(position) > -1;
+ }
+
+ function sameValue(position) {
+ var left = properties[position - 1];
+ var right = properties[position];
+
+ return stringifyProperty(left.all, left.position) == stringifyProperty(right.all, right.position);
+ }
+
+ propertyLoop:
+ for (var position = 0, total = properties.length; position < total; position++) {
+ var property = properties[position];
+ var _name = (property.name == '-ms-filter' || property.name == 'filter') ?
+ (lastName == 'background' || lastName == 'background-image' ? lastName : property.name) :
+ property.name;
+ var isImportant = property.important;
+ var isHack = property.hack;
+
+ if (property.unused)
+ continue;
+
+ if (position > 0 && lastProperty && _name == lastName && isImportant == lastProperty.important && isHack == lastProperty.hack && sameValue(position) && !lastProperty.unused) {
+ property.unused = true;
+ continue;
+ }
+
+ // comment is necessary - we assume that if two properties are one after another
+ // then it is intentional way of redefining property which may not be widely supported
+ // e.g. a{display:inline-block;display:-moz-inline-box}
+ // however if `mergeablePosition` yields true then the rule does not apply
+ // (e.g merging two adjacent selectors: `a{display:block}a{display:block}`)
+ if (_name in overrideMapping && (aggressiveMerging && _name != lastName || mergeablePosition(position))) {
+ var toOverridePositions = overrideMapping[_name];
+ var canOverride = compactable[_name] && compactable[_name].canOverride;
+ var anyRemoved = false;
+
+ for (j = toOverridePositions.length - 1; j >= 0; j--) {
+ var toRemove = properties[toOverridePositions[j]];
+ var longhandToShorthand = toRemove.name != _name;
+ var wasImportant = toRemove.important;
+ var wasHack = toRemove.hack;
+
+ if (toRemove.unused)
+ continue;
+
+ if (longhandToShorthand && wasImportant)
+ continue;
+
+ if (!wasImportant && (wasHack && !isHack || !wasHack && isHack))
+ continue;
+
+ if (wasImportant && (isHack == 'star' || isHack == 'underscore'))
+ continue;
+
+ if (!wasHack && !isHack && !longhandToShorthand && canOverride && !canOverride(toRemove, property, validator))
+ continue;
+
+ if (wasImportant && !isImportant || wasImportant && isHack) {
+ property.unused = true;
+ lastProperty = property;
+ continue propertyLoop;
+ } else {
+ anyRemoved = true;
+ toRemove.unused = true;
+ }
+ }
+
+ if (anyRemoved) {
+ position = -1;
+ lastProperty = null;
+ lastName = null;
+ overrideMapping = {};
+ continue;
+ }
+ } else {
+ overrideMapping[_name] = overrideMapping[_name] || [];
+ overrideMapping[_name].push(position);
+
+ // TODO: to be removed with
+ // certain shorthand (see values of `shorthands`) should trigger removal of
+ // longhand properties (see keys of `shorthands`)
+ var _shorthands = shorthands[_name];
+ if (_shorthands) {
+ for (j = _shorthands.length - 1; j >= 0; j--) {
+ var shorthand = _shorthands[j];
+ overrideMapping[shorthand] = overrideMapping[shorthand] || [];
+ overrideMapping[shorthand].push(position);
+ }
+ }
+ }
+
+ lastName = _name;
+ lastProperty = property;
+ }
+}
+
+function optimize(selector, properties, mergeAdjacent, withCompacting, options, context) {
+ var validator = context.validator;
+ var warnings = context.warnings;
+
+ var _properties = wrapForOptimizing(properties);
+ populateComponents(_properties, validator, warnings);
+ _optimize(_properties, mergeAdjacent, options.aggressiveMerging, validator);
+
+ for (var i = 0, l = _properties.length; i < l; i++) {
+ var _property = _properties[i];
+ if (_property.variable && _property.block)
+ optimize(selector, _property.value[0], mergeAdjacent, withCompacting, options, context);
+ }
+
+ if (withCompacting && options.shorthandCompacting) {
+ compactOverrides(_properties, options.compatibility, validator);
+ compactShorthands(_properties, options.sourceMap, validator);
+ }
+
+ restoreFromOptimizing(_properties);
+ removeUnused(_properties);
+}
+
+module.exports = optimize;
diff --git a/node_modules/clean-css/lib/properties/override-compactor.js b/node_modules/clean-css/lib/properties/override-compactor.js
new file mode 100644
index 0000000000000000000000000000000000000000..bbf13ed33b0ca41c16a7c1c4fe4f73bc59ccd52f
--- /dev/null
+++ b/node_modules/clean-css/lib/properties/override-compactor.js
@@ -0,0 +1,384 @@
+var canOverride = require('./can-override');
+var compactable = require('./compactable');
+var deepClone = require('./clone').deep;
+var shallowClone = require('./clone').shallow;
+var hasInherit = require('./has-inherit');
+var restoreFromOptimizing = require('./restore-from-optimizing');
+var everyCombination = require('./every-combination');
+var sameVendorPrefixesIn = require('./vendor-prefixes').same;
+
+var stringifyProperty = require('../stringifier/one-time').property;
+
+var MULTIPLEX_SEPARATOR = ',';
+
+// Used when searching for a component that matches property
+function nameMatchFilter(to) {
+ return function (property) {
+ return to.name === property.name;
+ };
+}
+
+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 = [[descriptor.defaultValue]];
+
+ if (!canOverride(_component, component, validator))
+ return true;
+ }
+
+ return false;
+}
+
+function isComponentOf(shorthand, longhand) {
+ return compactable[shorthand.name].components.indexOf(longhand.name) > -1;
+}
+
+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;
+
+ for (var i = 0, l = property.components.length; i < l; i++) {
+ var component = property.components[i];
+ if (component.multiplex)
+ continue;
+
+ var value = component.value.slice(0);
+
+ for (var j = 1; j < size; j++) {
+ component.value.push([MULTIPLEX_SEPARATOR]);
+ Array.prototype.push.apply(component.value, value);
+ }
+ }
+}
+
+function multiplexSize(component) {
+ var size = 0;
+
+ for (var i = 0, l = component.value.length; i < l; i++) {
+ if (component.value[i][0] == MULTIPLEX_SEPARATOR)
+ size++;
+ }
+
+ return size + 1;
+}
+
+function lengthOf(property) {
+ var fakeAsArray = [[property.name]].concat(property.value);
+ return stringifyProperty([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.isValidFunction, 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][0] == MULTIPLEX_SEPARATOR)
+ continue;
+
+ if (fn(property.value[i][0]))
+ 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]);
+
+ var simpleClone = deepClone(simple);
+ restoreFromOptimizing([simpleClone]);
+
+ var lengthBefore = lengthOf(multiplexClone) + 1 + lengthOf(simpleClone);
+
+ if (left.multiplex) {
+ component = multiplexClone.components.filter(nameMatchFilter(simpleClone))[0];
+ overrideIntoMultiplex(component, simpleClone);
+ } else {
+ component = simpleClone.components.filter(nameMatchFilter(multiplexClone))[0];
+ turnIntoMultiplex(simpleClone, multiplexSize(multiplexClone));
+ overrideByMultiplex(component, multiplexClone);
+ }
+
+ restoreFromOptimizing([simpleClone]);
+
+ 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][0] == '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[0] == MULTIPLEX_SEPARATOR) {
+ layers.push(layer);
+ layer = [];
+ } else {
+ layer.push(value);
+ }
+ }
+
+ layers.push(layer);
+ return layers;
+}
+
+function compactOverrides(properties, compatibility, validator) {
+ var mayOverride, right, left, component;
+ var i, j, k;
+
+ propertyLoop:
+ for (i = properties.length - 1; i >= 0; i--) {
+ right = properties[i];
+
+ if (!isCompactable(right))
+ continue;
+
+ if (right.variable)
+ continue;
+
+ mayOverride = compactable[right.name].canOverride || canOverride.sameValue;
+
+ for (j = i - 1; j >= 0; j--) {
+ left = properties[j];
+
+ if (!isCompactable(left))
+ continue;
+
+ if (left.variable)
+ continue;
+
+ if (left.unused || right.unused)
+ continue;
+
+ if (left.hack && !right.hack || !left.hack && right.hack)
+ continue;
+
+ if (hasInherit(right))
+ continue;
+
+ if (noneOverrideHack(left, right))
+ continue;
+
+ if (!left.shorthand && 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.isValidFunction, left) && overridingFunction(right, validator))
+ continue;
+
+ component = right.components.filter(nameMatchFilter(left))[0];
+ mayOverride = (compactable[left.name] && compactable[left.name].canOverride) || canOverride.sameValue;
+ if (everyCombination(mayOverride, left, component, validator)) {
+ left.unused = true;
+ }
+ } else if (left.shorthand && !right.shorthand && isComponentOf(left, right)) {
+ // 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;
+
+ component = left.components.filter(nameMatchFilter(right))[0];
+ if (everyCombination(mayOverride, component, right, validator)) {
+ 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][0];
+
+ if (disabledBackgroundMerging || nonMergeableValue)
+ continue;
+
+ if (!compatibility.properties.merging && wouldBreakCompatibility(left, validator))
+ continue;
+
+ if (component.value[0][0] != right.value[0][0] && (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 (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;
+ }
+
+ for (k = left.components.length - 1; k >= 0; k--) {
+ var leftComponent = left.components[k];
+ var rightComponent = right.components[k];
+
+ mayOverride = compactable[leftComponent.name].canOverride || canOverride.sameValue;
+ if (!everyCombination(mayOverride, leftComponent, rightComponent, validator))
+ continue propertyLoop;
+ if (!everyCombination(canOverride.twoOptionalFunctions, leftComponent, rightComponent, validator) && validator.isValidFunction(rightComponent))
+ continue propertyLoop;
+ }
+
+ overrideShorthand(left, right);
+ left.dirty = true;
+ } else if (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 = left.components.filter(nameMatchFilter(right))[0];
+ mayOverride = compactable[right.name].canOverride || canOverride.sameValue;
+ if (!everyCombination(mayOverride, component, right, validator))
+ continue;
+
+ if (left.important && !right.important) {
+ right.unused = true;
+ continue;
+ }
+
+ var rightRestored = compactable[right.name].restore(right, compactable);
+ if (rightRestored.length > 1)
+ continue;
+
+ component = left.components.filter(nameMatchFilter(right))[0];
+ override(component, right);
+ right.dirty = true;
+ } else if (left.name == right.name) {
+ // two non-shorthands should be merged based on understandability
+
+ if (left.important && !right.important) {
+ right.unused = true;
+ continue;
+ }
+
+ mayOverride = compactable[right.name].canOverride || canOverride.sameValue;
+ if (!everyCombination(mayOverride, left, right, validator))
+ continue;
+
+ left.unused = true;
+ }
+ }
+ }
+}
+
+module.exports = compactOverrides;
diff --git a/node_modules/clean-css/lib/properties/populate-components.js b/node_modules/clean-css/lib/properties/populate-components.js
new file mode 100644
index 0000000000000000000000000000000000000000..dd8700ccc03219f75e06bc13b6652fc0489dcdfd
--- /dev/null
+++ b/node_modules/clean-css/lib/properties/populate-components.js
@@ -0,0 +1,32 @@
+var compactable = require('./compactable');
+var InvalidPropertyError = require('./invalid-property-error');
+
+function populateComponents(properties, validator, warnings) {
+ 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);
+ } 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;
diff --git a/node_modules/clean-css/lib/properties/remove-unused.js b/node_modules/clean-css/lib/properties/remove-unused.js
new file mode 100644
index 0000000000000000000000000000000000000000..08cb9b6ad117c045ad09d7f6d3394ae86e54e3ad
--- /dev/null
+++ b/node_modules/clean-css/lib/properties/remove-unused.js
@@ -0,0 +1,10 @@
+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;
diff --git a/node_modules/clean-css/lib/properties/restore-from-optimizing.js b/node_modules/clean-css/lib/properties/restore-from-optimizing.js
new file mode 100644
index 0000000000000000000000000000000000000000..f0dfc182c632edf06bd8c19b2efb9c01c0ba47a8
--- /dev/null
+++ b/node_modules/clean-css/lib/properties/restore-from-optimizing.js
@@ -0,0 +1,60 @@
+var compactable = require('./compactable');
+
+var BACKSLASH_HACK = '\\9';
+var IMPORTANT_TOKEN = '!important';
+var STAR_HACK = '*';
+var UNDERSCORE_HACK = '_';
+var BANG_HACK = '!ie';
+
+function restoreImportant(property) {
+ property.value[property.value.length - 1][0] += IMPORTANT_TOKEN;
+}
+
+function restoreHack(property) {
+ if (property.hack == 'underscore')
+ property.name = UNDERSCORE_HACK + property.name;
+ else if (property.hack == 'star')
+ property.name = STAR_HACK + property.name;
+ else if (property.hack == 'backslash')
+ property.value[property.value.length - 1][0] += BACKSLASH_HACK;
+ else if (property.hack == 'bang')
+ property.value[property.value.length - 1][0] += ' ' + BANG_HACK;
+}
+
+function restoreFromOptimizing(properties, simpleMode) {
+ for (var i = properties.length - 1; i >= 0; i--) {
+ var property = properties[i];
+ var descriptor = compactable[property.name];
+ var restored;
+
+ if (property.unused)
+ continue;
+
+ if (!property.dirty && !property.important && !property.hack)
+ continue;
+
+ if (!simpleMode && descriptor && descriptor.shorthand) {
+ restored = descriptor.restore(property, compactable);
+ property.value = restored;
+ } else {
+ restored = property.value;
+ }
+
+ if (property.important)
+ restoreImportant(property);
+
+ if (property.hack)
+ restoreHack(property);
+
+ if (!('all' in property))
+ continue;
+
+ var current = property.all[property.position];
+ current[0][0] = property.name;
+
+ current.splice(1, current.length - 1);
+ Array.prototype.push.apply(current, restored);
+ }
+}
+
+module.exports = restoreFromOptimizing;
diff --git a/node_modules/clean-css/lib/properties/restore.js b/node_modules/clean-css/lib/properties/restore.js
new file mode 100644
index 0000000000000000000000000000000000000000..a9f8e6f9e75c0e9f7359e91fe13e70497af5e926
--- /dev/null
+++ b/node_modules/clean-css/lib/properties/restore.js
@@ -0,0 +1,232 @@
+var shallowClone = require('./clone').shallow;
+var MULTIPLEX_SEPARATOR = ',';
+var SIZE_POSITION_SEPARATOR = '/';
+
+function isInheritOnly(values) {
+ for (var i = 0, l = values.length; i < l; i++) {
+ var value = values[i][0];
+
+ if (value != 'inherit' && value != MULTIPLEX_SEPARATOR && value != SIZE_POSITION_SEPARATOR)
+ 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) {
+ if (descriptor.defaultValue.length == 1)
+ return component.value[0][0] == descriptor.defaultValue[0] && (component.value[1] ? component.value[1][0] == descriptor.defaultValue[0] : true);
+ else
+ return component.value[0][0] == descriptor.defaultValue[0] && (component.value[1] ? component.value[1][0] : component.value[0][0]) == descriptor.defaultValue[1];
+ } else {
+ return component.value[0][0] == 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][0] == originComponent.value[0][0];
+
+ needsBoth = !needsOne && (
+ (isOriginDefault && !isDefault) ||
+ (!isOriginDefault && !isDefault) ||
+ (!isOriginDefault && isDefault && component.value[0][0] != originComponent.value[0][0]));
+
+ 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([SIZE_POSITION_SEPARATOR]);
+ 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][0] == '0')
+ restored.push(property.value[0]);
+
+ if (restored.length === 0)
+ restored.push([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][0] == verticalValues[0][0] &&
+ (horizontalValues.length > 1 ? horizontalValues[1][0] == verticalValues[1][0] : true) &&
+ (horizontalValues.length > 2 ? horizontalValues[2][0] == verticalValues[2][0] : true) &&
+ (horizontalValues.length > 3 ? horizontalValues[3][0] == verticalValues[3][0] : true)) {
+ return horizontalValues;
+ } else {
+ return horizontalValues.concat([['/']]).concat(verticalValues);
+ }
+ } else {
+ return fourValues(property, compactable);
+ }
+}
+
+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[0] == value2[0] && value1[0] == value3[0] && value1[0] == value4[0]) {
+ return [value1];
+ } else if (value1[0] == value3[0] && value2[0] == value4[0]) {
+ return [value1, value2];
+ } else if (value2[0] == value4[0]) {
+ 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][0] == MULTIPLEX_SEPARATOR)
+ 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][0] == MULTIPLEX_SEPARATOR) {
+ 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([',']);
+ }
+
+ 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][0] != descriptor.defaultValue)
+ restored.unshift(component.value[0]);
+ }
+
+ if (restored.length === 0)
+ restored.push([compactable[property.name].defaultValue]);
+
+ if (isInheritOnly(restored))
+ return [restored[0]];
+
+ return restored;
+}
+
+module.exports = {
+ background: background,
+ borderRadius: borderRadius,
+ fourValues: fourValues,
+ multiplex: multiplex,
+ withoutDefaults: withoutDefaults
+};
diff --git a/node_modules/clean-css/lib/properties/shorthand-compactor.js b/node_modules/clean-css/lib/properties/shorthand-compactor.js
new file mode 100644
index 0000000000000000000000000000000000000000..9be76236aa222e85553b2cc1b6641d25d2e5e4eb
--- /dev/null
+++ b/node_modules/clean-css/lib/properties/shorthand-compactor.js
@@ -0,0 +1,134 @@
+var compactable = require('./compactable');
+var deepClone = require('./clone').deep;
+var hasInherit = require('./has-inherit');
+var populateComponents = require('./populate-components');
+var wrapSingle = require('./wrap-for-optimizing').single;
+var everyCombination = require('./every-combination');
+
+function mixedImportance(components) {
+ var important;
+
+ for (var name in components) {
+ if (undefined !== important && components[name].important != important)
+ return true;
+
+ important = components[name].important;
+ }
+
+ return false;
+}
+
+function componentSourceMaps(components) {
+ var sourceMapping = [];
+
+ for (var name in components) {
+ var component = components[name];
+ var originalValue = component.all[component.position];
+ var mapping = originalValue[0][originalValue[0].length - 1];
+
+ if (Array.isArray(mapping))
+ Array.prototype.push.apply(sourceMapping, mapping);
+ }
+
+ return sourceMapping;
+}
+
+function replaceWithShorthand(properties, candidateComponents, name, sourceMaps, validator) {
+ var descriptor = compactable[name];
+ var newValuePlaceholder = [[name], [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]];
+ var canOverride = compactable[component.name].canOverride;
+
+ if (hasInherit(component))
+ return;
+
+ if (!everyCombination(canOverride, newProperty.components[i], component, validator))
+ return;
+
+ newProperty.components[i] = deepClone(component);
+ newProperty.important = component.important;
+
+ all = component.all;
+ }
+
+ for (var componentName in candidateComponents) {
+ candidateComponents[componentName].unused = true;
+ }
+
+ if (sourceMaps) {
+ var sourceMapping = componentSourceMaps(candidateComponents);
+ if (sourceMapping.length > 0)
+ newValuePlaceholder[0].push(sourceMapping);
+ }
+
+ newProperty.position = all.length;
+ newProperty.all = all;
+ newProperty.all.push(newValuePlaceholder);
+
+ properties.push(newProperty);
+}
+
+function invalidateOrCompact(properties, position, candidates, sourceMaps, validator) {
+ var property = properties[position];
+
+ for (var name in candidates) {
+ if (undefined !== property && name == property.name)
+ continue;
+
+ var descriptor = compactable[name];
+ var candidateComponents = candidates[name];
+ if (descriptor.components.length > Object.keys(candidateComponents).length) {
+ delete candidates[name];
+ continue;
+ }
+
+ if (mixedImportance(candidateComponents))
+ continue;
+
+ replaceWithShorthand(properties, candidateComponents, name, sourceMaps, validator);
+ }
+}
+
+function compactShortands(properties, sourceMaps, validator) {
+ var candidates = {};
+
+ if (properties.length < 3)
+ return;
+
+ for (var i = 0, l = properties.length; i < l; i++) {
+ var property = properties[i];
+ if (property.unused)
+ continue;
+
+ if (property.hack)
+ continue;
+
+ if (property.variable)
+ continue;
+
+ var descriptor = compactable[property.name];
+ if (!descriptor || !descriptor.componentOf)
+ continue;
+
+ if (property.shorthand) {
+ invalidateOrCompact(properties, i, candidates, sourceMaps, validator);
+ } else {
+ var componentOf = descriptor.componentOf;
+ candidates[componentOf] = candidates[componentOf] || {};
+ candidates[componentOf][property.name] = property;
+ }
+ }
+
+ invalidateOrCompact(properties, i, candidates, sourceMaps, validator);
+}
+
+module.exports = compactShortands;
diff --git a/node_modules/clean-css/lib/properties/validator.js b/node_modules/clean-css/lib/properties/validator.js
new file mode 100644
index 0000000000000000000000000000000000000000..db4ee8925685bb2ebab6d627946c6afd95dbb203
--- /dev/null
+++ b/node_modules/clean-css/lib/properties/validator.js
@@ -0,0 +1,197 @@
+// Validates various CSS property values
+
+var split = require('../utils/split');
+
+var widthKeywords = ['thin', 'thick', 'medium', 'inherit', 'initial'];
+var allUnits = ['px', '%', 'em', 'in', 'cm', 'mm', 'ex', 'pt', 'pc', 'ch', 'rem', 'vh', 'vm', 'vmin', 'vmax', 'vw'];
+var cssUnitRegexStr = '(\\-?\\.?\\d+\\.?\\d*(' + allUnits.join('|') + '|)|auto|inherit)';
+var cssCalcRegexStr = '(\\-moz\\-|\\-webkit\\-)?calc\\([^\\)]+\\)';
+var cssFunctionNoVendorRegexStr = '[A-Z]+(\\-|[A-Z]|[0-9])+\\(.*?\\)';
+var cssFunctionVendorRegexStr = '\\-(\\-|[A-Z]|[0-9])+\\(.*?\\)';
+var cssVariableRegexStr = 'var\\(\\-\\-[^\\)]+\\)';
+var cssFunctionAnyRegexStr = '(' + cssVariableRegexStr + '|' + cssFunctionNoVendorRegexStr + '|' + cssFunctionVendorRegexStr + ')';
+var cssUnitOrCalcRegexStr = '(' + cssUnitRegexStr + '|' + cssCalcRegexStr + ')';
+var cssUnitAnyRegexStr = '(none|' + widthKeywords.join('|') + '|' + cssUnitRegexStr + '|' + cssVariableRegexStr + '|' + cssFunctionNoVendorRegexStr + '|' + cssFunctionVendorRegexStr + ')';
+
+var cssFunctionNoVendorRegex = new RegExp('^' + cssFunctionNoVendorRegexStr + '$', 'i');
+var cssFunctionVendorRegex = new RegExp('^' + cssFunctionVendorRegexStr + '$', 'i');
+var cssVariableRegex = new RegExp('^' + cssVariableRegexStr + '$', 'i');
+var cssFunctionAnyRegex = new RegExp('^' + cssFunctionAnyRegexStr + '$', 'i');
+var cssUnitRegex = new RegExp('^' + cssUnitRegexStr + '$', 'i');
+var cssUnitOrCalcRegex = new RegExp('^' + cssUnitOrCalcRegexStr + '$', 'i');
+var cssUnitAnyRegex = new RegExp('^' + cssUnitAnyRegexStr + '$', 'i');
+
+var backgroundRepeatKeywords = ['repeat', 'no-repeat', 'repeat-x', 'repeat-y', 'inherit'];
+var backgroundAttachmentKeywords = ['inherit', 'scroll', 'fixed', 'local'];
+var backgroundPositionKeywords = ['center', 'top', 'bottom', 'left', 'right'];
+var backgroundSizeKeywords = ['contain', 'cover'];
+var backgroundBoxKeywords = ['border-box', 'content-box', 'padding-box'];
+var styleKeywords = ['auto', 'inherit', 'hidden', 'none', 'dotted', 'dashed', 'solid', 'double', 'groove', 'ridge', 'inset', 'outset'];
+var listStyleTypeKeywords = ['armenian', 'circle', 'cjk-ideographic', 'decimal', 'decimal-leading-zero', 'disc', 'georgian', 'hebrew', 'hiragana', 'hiragana-iroha', 'inherit', 'katakana', 'katakana-iroha', 'lower-alpha', 'lower-greek', 'lower-latin', 'lower-roman', 'none', 'square', 'upper-alpha', 'upper-latin', 'upper-roman'];
+var listStylePositionKeywords = ['inside', 'outside', 'inherit'];
+
+function Validator(compatibility) {
+ var validUnits = allUnits.slice(0).filter(function (value) {
+ return !(value in compatibility.units) || compatibility.units[value] === true;
+ });
+
+ var compatibleCssUnitRegexStr = '(\\-?\\.?\\d+\\.?\\d*(' + validUnits.join('|') + '|)|auto|inherit)';
+ this.compatibleCssUnitRegex = new RegExp('^' + compatibleCssUnitRegexStr + '$', 'i');
+ this.compatibleCssUnitAnyRegex = new RegExp('^(none|' + widthKeywords.join('|') + '|' + compatibleCssUnitRegexStr + '|' + cssVariableRegexStr + '|' + cssFunctionNoVendorRegexStr + '|' + cssFunctionVendorRegexStr + ')$', 'i');
+
+ this.colorOpacity = compatibility.colors.opacity;
+}
+
+Validator.prototype.isValidHexColor = function (s) {
+ return (s.length === 4 || s.length === 7) && s[0] === '#';
+};
+
+Validator.prototype.isValidRgbaColor = function (s) {
+ s = s.split(' ').join('');
+ return s.length > 0 && s.indexOf('rgba(') === 0 && s.indexOf(')') === s.length - 1;
+};
+
+Validator.prototype.isValidHslaColor = function (s) {
+ s = s.split(' ').join('');
+ return s.length > 0 && s.indexOf('hsla(') === 0 && s.indexOf(')') === s.length - 1;
+};
+
+Validator.prototype.isValidNamedColor = function (s) {
+ // We don't really check if it's a valid color value, but allow any letters in it
+ return s !== 'auto' && (s === 'transparent' || s === 'inherit' || /^[a-zA-Z]+$/.test(s));
+};
+
+Validator.prototype.isValidVariable = function (s) {
+ return cssVariableRegex.test(s);
+};
+
+Validator.prototype.isValidColor = function (s) {
+ return this.isValidNamedColor(s) ||
+ this.isValidColorValue(s) ||
+ this.isValidVariable(s) ||
+ this.isValidVendorPrefixedValue(s);
+};
+
+Validator.prototype.isValidColorValue = function (s) {
+ return this.isValidHexColor(s) ||
+ this.isValidRgbaColor(s) ||
+ this.isValidHslaColor(s);
+};
+
+Validator.prototype.isValidUrl = function (s) {
+ // NOTE: at this point all URLs are replaced with placeholders by clean-css, so we check for those placeholders
+ return s.indexOf('__ESCAPED_URL_CLEAN_CSS') === 0;
+};
+
+Validator.prototype.isValidUnit = function (s) {
+ return cssUnitAnyRegex.test(s);
+};
+
+Validator.prototype.isValidUnitWithoutFunction = function (s) {
+ return cssUnitRegex.test(s);
+};
+
+Validator.prototype.isValidAndCompatibleUnit = function (s) {
+ return this.compatibleCssUnitAnyRegex.test(s);
+};
+
+Validator.prototype.isValidAndCompatibleUnitWithoutFunction = function (s) {
+ return this.compatibleCssUnitRegex.test(s);
+};
+
+Validator.prototype.isValidFunctionWithoutVendorPrefix = function (s) {
+ return cssFunctionNoVendorRegex.test(s);
+};
+
+Validator.prototype.isValidFunctionWithVendorPrefix = function (s) {
+ return cssFunctionVendorRegex.test(s);
+};
+
+Validator.prototype.isValidFunction = function (s) {
+ return cssFunctionAnyRegex.test(s);
+};
+
+Validator.prototype.isValidBackgroundRepeat = function (s) {
+ return backgroundRepeatKeywords.indexOf(s) >= 0 || this.isValidVariable(s);
+};
+
+Validator.prototype.isValidBackgroundAttachment = function (s) {
+ return backgroundAttachmentKeywords.indexOf(s) >= 0 || this.isValidVariable(s);
+};
+
+Validator.prototype.isValidBackgroundBox = function (s) {
+ return backgroundBoxKeywords.indexOf(s) >= 0 || this.isValidVariable(s);
+};
+
+Validator.prototype.isValidBackgroundPositionPart = function (s) {
+ return backgroundPositionKeywords.indexOf(s) >= 0 || cssUnitOrCalcRegex.test(s) || this.isValidVariable(s);
+};
+
+Validator.prototype.isValidBackgroundPosition = function (s) {
+ if (s === 'inherit')
+ return true;
+
+ var parts = s.split(' ');
+ for (var i = 0, l = parts.length; i < l; i++) {
+ if (parts[i] === '')
+ continue;
+ if (this.isValidBackgroundPositionPart(parts[i]) || this.isValidVariable(parts[i]))
+ continue;
+
+ return false;
+ }
+
+ return true;
+};
+
+Validator.prototype.isValidBackgroundSizePart = function (s) {
+ return backgroundSizeKeywords.indexOf(s) >= 0 || cssUnitRegex.test(s) || this.isValidVariable(s);
+};
+
+Validator.prototype.isValidBackgroundPositionAndSize = function (s) {
+ if (s.indexOf('/') < 0)
+ return false;
+
+ var twoParts = split(s, '/');
+ return this.isValidBackgroundSizePart(twoParts.pop()) && this.isValidBackgroundPositionPart(twoParts.pop());
+};
+
+Validator.prototype.isValidListStyleType = function (s) {
+ return listStyleTypeKeywords.indexOf(s) >= 0 || this.isValidVariable(s);
+};
+
+Validator.prototype.isValidListStylePosition = function (s) {
+ return listStylePositionKeywords.indexOf(s) >= 0 || this.isValidVariable(s);
+};
+
+Validator.prototype.isValidStyle = function (s) {
+ return this.isValidStyleKeyword(s) || this.isValidVariable(s);
+};
+
+Validator.prototype.isValidStyleKeyword = function (s) {
+ return styleKeywords.indexOf(s) >= 0;
+};
+
+Validator.prototype.isValidWidth = function (s) {
+ return this.isValidUnit(s) || this.isValidWidthKeyword(s) || this.isValidVariable(s);
+};
+
+Validator.prototype.isValidWidthKeyword = function (s) {
+ return widthKeywords.indexOf(s) >= 0;
+};
+
+Validator.prototype.isValidVendorPrefixedValue = function (s) {
+ return /^-([A-Za-z0-9]|-)*$/gi.test(s);
+};
+
+Validator.prototype.areSameFunction = function (a, b) {
+ if (!this.isValidFunction(a) || !this.isValidFunction(b))
+ return false;
+
+ var f1name = a.substring(0, a.indexOf('('));
+ var f2name = b.substring(0, b.indexOf('('));
+
+ return f1name === f2name;
+};
+
+module.exports = Validator;
diff --git a/node_modules/clean-css/lib/properties/vendor-prefixes.js b/node_modules/clean-css/lib/properties/vendor-prefixes.js
new file mode 100644
index 0000000000000000000000000000000000000000..511fd604ec95585ea29f2b194e18917a1cb5bcd6
--- /dev/null
+++ b/node_modules/clean-css/lib/properties/vendor-prefixes.js
@@ -0,0 +1,26 @@
+var VENDOR_PREFIX_PATTERN = /$\-moz\-|\-ms\-|\-o\-|\-webkit\-/;
+
+function prefixesIn(tokens) {
+ var prefixes = [];
+
+ for (var i = 0, l = tokens.length; i < l; i++) {
+ var token = tokens[i];
+
+ for (var j = 0, m = token.value.length; j < m; j++) {
+ var match = VENDOR_PREFIX_PATTERN.exec(token.value[j][0]);
+
+ if (match && prefixes.indexOf(match[0]) == -1)
+ prefixes.push(match[0]);
+ }
+ }
+
+ return prefixes;
+}
+
+function same(left, right) {
+ return prefixesIn(left).sort().join(',') == prefixesIn(right).sort().join(',');
+}
+
+module.exports = {
+ same: same
+};
diff --git a/node_modules/clean-css/lib/properties/wrap-for-optimizing.js b/node_modules/clean-css/lib/properties/wrap-for-optimizing.js
new file mode 100644
index 0000000000000000000000000000000000000000..cb12a2b3d578bfa833a7ecb3e4978c2d46f30f5a
--- /dev/null
+++ b/node_modules/clean-css/lib/properties/wrap-for-optimizing.js
@@ -0,0 +1,118 @@
+var BACKSLASH_HACK = '\\';
+var IMPORTANT_WORD = 'important';
+var IMPORTANT_TOKEN = '!'+IMPORTANT_WORD;
+var IMPORTANT_WORD_MATCH = new RegExp(IMPORTANT_WORD+'$', 'i');
+var IMPORTANT_TOKEN_MATCH = new RegExp(IMPORTANT_TOKEN+'$', 'i');
+var STAR_HACK = '*';
+var UNDERSCORE_HACK = '_';
+var BANG_HACK = '!';
+
+function wrapAll(properties) {
+ var wrapped = [];
+
+ for (var i = properties.length - 1; i >= 0; i--) {
+ if (typeof properties[i][0] == 'string')
+ continue;
+
+ var single = wrapSingle(properties[i]);
+ single.all = properties;
+ single.position = i;
+ wrapped.unshift(single);
+ }
+
+ return wrapped;
+}
+
+function isMultiplex(property) {
+ for (var i = 1, l = property.length; i < l; i++) {
+ if (property[i][0] == ',' || property[i][0] == '/')
+ return true;
+ }
+
+ return false;
+}
+
+function hackType(property) {
+ var type = false;
+ var name = property[0][0];
+ var lastValue = property[property.length - 1];
+
+ if (name[0] == UNDERSCORE_HACK) {
+ type = 'underscore';
+ } else if (name[0] == STAR_HACK) {
+ type = 'star';
+ } else if (lastValue[0][0] == BANG_HACK && !lastValue[0].match(IMPORTANT_WORD_MATCH)) {
+ type = 'bang';
+ } else if (lastValue[0].indexOf(BANG_HACK) > 0 && !lastValue[0].match(IMPORTANT_WORD_MATCH)) {
+ type = 'bang';
+ } else if (lastValue[0].indexOf(BACKSLASH_HACK) > 0 && lastValue[0].indexOf(BACKSLASH_HACK) == lastValue[0].length - BACKSLASH_HACK.length - 1) {
+ type = 'backslash';
+ } else if (lastValue[0].indexOf(BACKSLASH_HACK) === 0 && lastValue[0].length == 2) {
+ type = 'backslash';
+ }
+
+ return type;
+}
+
+function isImportant(property) {
+ if (property.length > 1) {
+ var p = property[property.length - 1][0];
+ if (typeof(p) === 'string') {
+ return IMPORTANT_TOKEN_MATCH.test(p);
+ }
+ }
+ return false;
+}
+
+function stripImportant(property) {
+ if (property.length > 0)
+ property[property.length - 1][0] = property[property.length - 1][0].replace(IMPORTANT_TOKEN_MATCH, '');
+}
+
+function stripPrefixHack(property) {
+ property[0][0] = property[0][0].substring(1);
+}
+
+function stripSuffixHack(property, hackType) {
+ var lastValue = property[property.length - 1];
+ lastValue[0] = lastValue[0]
+ .substring(0, lastValue[0].indexOf(hackType == 'backslash' ? BACKSLASH_HACK : BANG_HACK))
+ .trim();
+
+ if (lastValue[0].length === 0)
+ property.pop();
+}
+
+function wrapSingle(property) {
+ var _isImportant = isImportant(property);
+ if (_isImportant)
+ stripImportant(property);
+
+ var _hackType = hackType(property);
+ if (_hackType == 'star' || _hackType == 'underscore')
+ stripPrefixHack(property);
+ else if (_hackType == 'backslash' || _hackType == 'bang')
+ stripSuffixHack(property, _hackType);
+
+ var isVariable = property[0][0].indexOf('--') === 0;
+
+ return {
+ block: isVariable && property[1] && Array.isArray(property[1][0][0]),
+ components: [],
+ dirty: false,
+ hack: _hackType,
+ important: _isImportant,
+ name: property[0][0],
+ multiplex: property.length > 2 ? isMultiplex(property) : false,
+ position: 0,
+ shorthand: false,
+ unused: property.length < 2,
+ value: property.slice(1),
+ variable: isVariable
+ };
+}
+
+module.exports = {
+ all: wrapAll,
+ single: wrapSingle
+};
diff --git a/node_modules/clean-css/lib/selectors/advanced.js b/node_modules/clean-css/lib/selectors/advanced.js
new file mode 100644
index 0000000000000000000000000000000000000000..38630e6aea6acb804781a565e9eabd30782c4f59
--- /dev/null
+++ b/node_modules/clean-css/lib/selectors/advanced.js
@@ -0,0 +1,86 @@
+var optimizeProperties = require('../properties/optimizer');
+
+var removeDuplicates = require('./remove-duplicates');
+var mergeAdjacent = require('./merge-adjacent');
+var reduceNonAdjacent = require('./reduce-non-adjacent');
+var mergeNonAdjacentBySelector = require('./merge-non-adjacent-by-selector');
+var mergeNonAdjacentByBody = require('./merge-non-adjacent-by-body');
+var restructure = require('./restructure');
+var removeDuplicateMediaQueries = require('./remove-duplicate-media-queries');
+var mergeMediaQueries = require('./merge-media-queries');
+
+function removeEmpty(tokens) {
+ for (var i = 0, l = tokens.length; i < l; i++) {
+ var token = tokens[i];
+ var isEmpty = false;
+
+ switch (token[0]) {
+ case 'selector':
+ isEmpty = token[1].length === 0 || token[2].length === 0;
+ break;
+ case 'block':
+ removeEmpty(token[2]);
+ isEmpty = token[2].length === 0;
+ }
+
+ if (isEmpty) {
+ tokens.splice(i, 1);
+ i--;
+ l--;
+ }
+ }
+}
+
+function recursivelyOptimizeBlocks(tokens, options, context) {
+ for (var i = 0, l = tokens.length; i < l; i++) {
+ var token = tokens[i];
+
+ if (token[0] == 'block') {
+ var isKeyframes = /@(-moz-|-o-|-webkit-)?keyframes/.test(token[1][0]);
+ optimize(token[2], options, context, !isKeyframes);
+ }
+ }
+}
+
+function recursivelyOptimizeProperties(tokens, options, context) {
+ for (var i = 0, l = tokens.length; i < l; i++) {
+ var token = tokens[i];
+
+ switch (token[0]) {
+ case 'selector':
+ optimizeProperties(token[1], token[2], false, true, options, context);
+ break;
+ case 'block':
+ recursivelyOptimizeProperties(token[2], options, context);
+ }
+ }
+}
+
+function optimize(tokens, options, context, withRestructuring) {
+ recursivelyOptimizeBlocks(tokens, options, context);
+ recursivelyOptimizeProperties(tokens, options, context);
+
+ removeDuplicates(tokens);
+ mergeAdjacent(tokens, options, context);
+ reduceNonAdjacent(tokens, options, context);
+
+ mergeNonAdjacentBySelector(tokens, options, context);
+ mergeNonAdjacentByBody(tokens, options);
+
+ if (options.restructuring && withRestructuring) {
+ restructure(tokens, options);
+ mergeAdjacent(tokens, options, context);
+ }
+
+ if (options.mediaMerging) {
+ removeDuplicateMediaQueries(tokens);
+ var reduced = mergeMediaQueries(tokens);
+ for (var i = reduced.length - 1; i >= 0; i--) {
+ optimize(reduced[i][2], options, context, false);
+ }
+ }
+
+ removeEmpty(tokens);
+}
+
+module.exports = optimize;
diff --git a/node_modules/clean-css/lib/selectors/clean-up.js b/node_modules/clean-css/lib/selectors/clean-up.js
new file mode 100644
index 0000000000000000000000000000000000000000..6bb17b99ca682b79adf43c7c99c64b6621ac3017
--- /dev/null
+++ b/node_modules/clean-css/lib/selectors/clean-up.js
@@ -0,0 +1,89 @@
+function removeWhitespace(match, value) {
+ return '[' + value.replace(/ /g, '') + ']';
+}
+
+function selectorSorter(s1, s2) {
+ return s1[0] > s2[0] ? 1 : -1;
+}
+
+function whitespaceReplacements(_, p1, p2, p3) {
+ if (p1 && p2 && p3.length)
+ return p1 + p2 + ' ';
+ else if (p1 && p2)
+ return p1 + p2;
+ else
+ return p2;
+}
+
+var CleanUp = {
+ selectors: function (selectors, removeUnsupported, adjacentSpace) {
+ var list = [];
+ var repeated = [];
+
+ for (var i = 0, l = selectors.length; i < l; i++) {
+ var selector = selectors[i];
+ var reduced = selector[0]
+ .replace(/\s+/g, ' ')
+ .replace(/ ?, ?/g, ',')
+ .replace(/\s*(\\)?([>+~])(\s*)/g, whitespaceReplacements)
+ .trim();
+
+ if (adjacentSpace && reduced.indexOf('nav') > 0)
+ reduced = reduced.replace(/\+nav(\S|$)/, '+ nav$1');
+
+ if (removeUnsupported && (reduced.indexOf('*+html ') != -1 || reduced.indexOf('*:first-child+html ') != -1))
+ continue;
+
+ if (reduced.indexOf('*') > -1) {
+ reduced = reduced
+ .replace(/\*([:#\.\[])/g, '$1')
+ .replace(/^(\:first\-child)?\+html/, '*$1+html');
+ }
+
+ if (reduced.indexOf('[') > -1)
+ reduced = reduced.replace(/\[([^\]]+)\]/g, removeWhitespace);
+
+ if (repeated.indexOf(reduced) == -1) {
+ selector[0] = reduced;
+ repeated.push(reduced);
+ list.push(selector);
+ }
+ }
+
+ return list.sort(selectorSorter);
+ },
+
+ selectorDuplicates: function (selectors) {
+ var list = [];
+ var repeated = [];
+
+ for (var i = 0, l = selectors.length; i < l; i++) {
+ var selector = selectors[i];
+
+ if (repeated.indexOf(selector[0]) == -1) {
+ repeated.push(selector[0]);
+ list.push(selector);
+ }
+ }
+
+ return list.sort(selectorSorter);
+ },
+
+ block: function (values, spaceAfterClosingBrace) {
+ values[0] = values[0]
+ .replace(/\s+/g, ' ')
+ .replace(/(,|:|\() /g, '$1')
+ .replace(/ \)/g, ')');
+
+ if (!spaceAfterClosingBrace)
+ values[0] = values[0].replace(/\) /g, ')');
+ },
+
+ atRule: function (values) {
+ values[0] = values[0]
+ .replace(/\s+/g, ' ')
+ .trim();
+ }
+};
+
+module.exports = CleanUp;
diff --git a/node_modules/clean-css/lib/selectors/extractor.js b/node_modules/clean-css/lib/selectors/extractor.js
new file mode 100644
index 0000000000000000000000000000000000000000..497198b23cd29c7b20ab8a2f06b21d55a69a6e76
--- /dev/null
+++ b/node_modules/clean-css/lib/selectors/extractor.js
@@ -0,0 +1,69 @@
+// This extractor is used in advanced optimizations
+// IMPORTANT: Mind Token class and this code is not related!
+// Properties will be tokenized in one step, see #429
+
+var stringifySelectors = require('../stringifier/one-time').selectors;
+var stringifyValue = require('../stringifier/one-time').value;
+
+var AT_RULE = 'at-rule';
+
+function extract(token) {
+ var properties = [];
+
+ if (token[0] == 'selector') {
+ var inSpecificSelector = !/[\.\+>~]/.test(stringifySelectors(token[1]));
+ for (var i = 0, l = token[2].length; i < l; i++) {
+ var property = token[2][i];
+
+ if (property.indexOf('__ESCAPED') === 0)
+ continue;
+
+ if (property[0] == AT_RULE)
+ continue;
+
+ var name = token[2][i][0][0];
+ if (name.length === 0)
+ continue;
+
+ if (name.indexOf('--') === 0)
+ continue;
+
+ var value = stringifyValue(token[2], i);
+
+ properties.push([
+ name,
+ value,
+ findNameRoot(name),
+ token[2][i],
+ name + ':' + value,
+ token[1],
+ inSpecificSelector
+ ]);
+ }
+ } else if (token[0] == 'block') {
+ for (var j = 0, k = token[2].length; j < k; j++) {
+ properties = properties.concat(extract(token[2][j]));
+ }
+ }
+
+ 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;
+
+ return name.replace(/^\-\w+\-/, '').match(/([a-zA-Z]+)/)[0].toLowerCase();
+}
+
+module.exports = extract;
diff --git a/node_modules/clean-css/lib/selectors/is-special.js b/node_modules/clean-css/lib/selectors/is-special.js
new file mode 100644
index 0000000000000000000000000000000000000000..96315141599e37d11e962a4ce9b93712daa8e327
--- /dev/null
+++ b/node_modules/clean-css/lib/selectors/is-special.js
@@ -0,0 +1,5 @@
+function isSpecial(options, selector) {
+ return options.compatibility.selectors.special.test(selector);
+}
+
+module.exports = isSpecial;
diff --git a/node_modules/clean-css/lib/selectors/merge-adjacent.js b/node_modules/clean-css/lib/selectors/merge-adjacent.js
new file mode 100644
index 0000000000000000000000000000000000000000..3de1c1fde212b8993b075f2c9ec0229dd9dc1f49
--- /dev/null
+++ b/node_modules/clean-css/lib/selectors/merge-adjacent.js
@@ -0,0 +1,35 @@
+var optimizeProperties = require('../properties/optimizer');
+
+var stringifyBody = require('../stringifier/one-time').body;
+var stringifySelectors = require('../stringifier/one-time').selectors;
+var cleanUpSelectors = require('./clean-up').selectors;
+var isSpecial = require('./is-special');
+
+function mergeAdjacent(tokens, options, context) {
+ var lastToken = [null, [], []];
+ var adjacentSpace = options.compatibility.selectors.adjacentSpace;
+
+ for (var i = 0, l = tokens.length; i < l; i++) {
+ var token = tokens[i];
+
+ if (token[0] != 'selector') {
+ lastToken = [null, [], []];
+ continue;
+ }
+
+ if (lastToken[0] == 'selector' && stringifySelectors(token[1]) == stringifySelectors(lastToken[1])) {
+ var joinAt = [lastToken[2].length];
+ Array.prototype.push.apply(lastToken[2], token[2]);
+ optimizeProperties(token[1], lastToken[2], joinAt, true, options, context);
+ token[2] = [];
+ } else if (lastToken[0] == 'selector' && stringifyBody(token[2]) == stringifyBody(lastToken[2]) &&
+ !isSpecial(options, stringifySelectors(token[1])) && !isSpecial(options, stringifySelectors(lastToken[1]))) {
+ lastToken[1] = cleanUpSelectors(lastToken[1].concat(token[1]), false, adjacentSpace);
+ token[2] = [];
+ } else {
+ lastToken = token;
+ }
+ }
+}
+
+module.exports = mergeAdjacent;
diff --git a/node_modules/clean-css/lib/selectors/merge-media-queries.js b/node_modules/clean-css/lib/selectors/merge-media-queries.js
new file mode 100644
index 0000000000000000000000000000000000000000..0df0d6f5739b92ea4ca7a399e5da021561a82d26
--- /dev/null
+++ b/node_modules/clean-css/lib/selectors/merge-media-queries.js
@@ -0,0 +1,64 @@
+var canReorder = require('./reorderable').canReorder;
+var extractProperties = require('./extractor');
+
+function mergeMediaQueries(tokens) {
+ var candidates = {};
+ var reduced = [];
+
+ for (var i = tokens.length - 1; i >= 0; i--) {
+ var token = tokens[i];
+ if (token[0] != 'block')
+ continue;
+
+ var candidate = candidates[token[1][0]];
+ if (!candidate) {
+ candidate = [];
+ candidates[token[1][0]] = 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 (!canReorder(movedProperties, traversedProperties))
+ continue directionLoop;
+ }
+
+ target[2] = topToBottom ?
+ source[2].concat(target[2]) :
+ target[2].concat(source[2]);
+ source[2] = [];
+
+ reduced.push(target);
+ continue positionLoop;
+ }
+ }
+ }
+
+ return reduced;
+}
+
+module.exports = mergeMediaQueries;
diff --git a/node_modules/clean-css/lib/selectors/merge-non-adjacent-by-body.js b/node_modules/clean-css/lib/selectors/merge-non-adjacent-by-body.js
new file mode 100644
index 0000000000000000000000000000000000000000..de148a03905e35f9127d31490f13dcbd71f45543
--- /dev/null
+++ b/node_modules/clean-css/lib/selectors/merge-non-adjacent-by-body.js
@@ -0,0 +1,61 @@
+var stringifyBody = require('../stringifier/one-time').body;
+var stringifySelectors = require('../stringifier/one-time').selectors;
+var cleanUpSelectors = require('./clean-up').selectors;
+var isSpecial = require('./is-special');
+
+function unsafeSelector(value) {
+ return /\.|\*| :/.test(value);
+}
+
+function isBemElement(token) {
+ var asString = stringifySelectors(token[1]);
+ return asString.indexOf('__') > -1 || asString.indexOf('--') > -1;
+}
+
+function withoutModifier(selector) {
+ return selector.replace(/--[^ ,>\+~:]+/g, '');
+}
+
+function removeAnyUnsafeElements(left, candidates) {
+ var leftSelector = withoutModifier(stringifySelectors(left[1]));
+
+ for (var body in candidates) {
+ var right = candidates[body];
+ var rightSelector = withoutModifier(stringifySelectors(right[1]));
+
+ if (rightSelector.indexOf(leftSelector) > -1 || leftSelector.indexOf(rightSelector) > -1)
+ delete candidates[body];
+ }
+}
+
+function mergeNonAdjacentByBody(tokens, options) {
+ var candidates = {};
+ var adjacentSpace = options.compatibility.selectors.adjacentSpace;
+
+ for (var i = tokens.length - 1; i >= 0; i--) {
+ var token = tokens[i];
+ if (token[0] != 'selector')
+ continue;
+
+ if (token[2].length > 0 && (!options.semanticMerging && unsafeSelector(stringifySelectors(token[1]))))
+ candidates = {};
+
+ if (token[2].length > 0 && options.semanticMerging && isBemElement(token))
+ removeAnyUnsafeElements(token, candidates);
+
+ var candidateBody = stringifyBody(token[2]);
+ var oldToken = candidates[candidateBody];
+ if (oldToken && !isSpecial(options, stringifySelectors(token[1])) && !isSpecial(options, stringifySelectors(oldToken[1]))) {
+ token[1] = token[2].length > 0 ?
+ cleanUpSelectors(oldToken[1].concat(token[1]), false, adjacentSpace) :
+ oldToken[1].concat(token[1]);
+
+ oldToken[2] = [];
+ candidates[candidateBody] = null;
+ }
+
+ candidates[stringifyBody(token[2])] = token;
+ }
+}
+
+module.exports = mergeNonAdjacentByBody;
diff --git a/node_modules/clean-css/lib/selectors/merge-non-adjacent-by-selector.js b/node_modules/clean-css/lib/selectors/merge-non-adjacent-by-selector.js
new file mode 100644
index 0000000000000000000000000000000000000000..bd1c1b9c9d80440b7bfe7bb3bf72f1068d9d5107
--- /dev/null
+++ b/node_modules/clean-css/lib/selectors/merge-non-adjacent-by-selector.js
@@ -0,0 +1,76 @@
+var optimizeProperties = require('../properties/optimizer');
+var stringifySelectors = require('../stringifier/one-time').selectors;
+var extractProperties = require('./extractor');
+var canReorder = require('./reorderable').canReorder;
+
+function mergeNonAdjacentBySelector(tokens, options, context) {
+ var allSelectors = {};
+ var repeatedSelectors = [];
+ var i;
+
+ for (i = tokens.length - 1; i >= 0; i--) {
+ if (tokens[i][0] != 'selector')
+ continue;
+ if (tokens[i][2].length === 0)
+ continue;
+
+ var selector = stringifySelectors(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);
+ var joinAt;
+
+ 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) :
+ canReorder(traversedProperties, movedProperties);
+
+ if (!reorderable && !topToBottom)
+ continue selectorIterator;
+ if (!reorderable && topToBottom)
+ continue directionIterator;
+ }
+
+ if (topToBottom) {
+ joinAt = [moved[2].length];
+ Array.prototype.push.apply(moved[2], target[2]);
+ target[2] = moved[2];
+ } else {
+ joinAt = [target[2].length];
+ Array.prototype.push.apply(target[2], moved[2]);
+ }
+
+ optimizeProperties(target[1], target[2], joinAt, true, options, context);
+ moved[2] = [];
+ }
+ }
+ }
+}
+
+module.exports = mergeNonAdjacentBySelector;
diff --git a/node_modules/clean-css/lib/selectors/reduce-non-adjacent.js b/node_modules/clean-css/lib/selectors/reduce-non-adjacent.js
new file mode 100644
index 0000000000000000000000000000000000000000..44b540c032ff2c9b433d97daf6858bdd0072b246
--- /dev/null
+++ b/node_modules/clean-css/lib/selectors/reduce-non-adjacent.js
@@ -0,0 +1,172 @@
+var optimizeProperties = require('../properties/optimizer');
+var stringifyBody = require('../stringifier/one-time').body;
+var stringifySelectors = require('../stringifier/one-time').selectors;
+var isSpecial = require('./is-special');
+var cloneArray = require('../utils/clone-array');
+
+function reduceNonAdjacent(tokens, options, context) {
+ var candidates = {};
+ var repeated = [];
+
+ for (var i = tokens.length - 1; i >= 0; i--) {
+ var token = tokens[i];
+
+ if (token[0] != 'selector')
+ continue;
+ if (token[2].length === 0)
+ continue;
+
+ var selectorAsString = stringifySelectors(token[1]);
+ var isComplexAndNotSpecial = token[1].length > 1 && !isSpecial(options, selectorAsString);
+ var wrappedSelectors = options.sourceMap ? wrappedSelectorsFrom(token[1]) : 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][0]]);
+ }
+
+ 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, selector, data, {
+ filterOut: filterOut,
+ callback: reduceBody
+ }, options, context);
+ }
+}
+
+function reduceComplexNonAdjacentCases(tokens, candidates, options, context) {
+ 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 = isSpecial(options, complexSelector) ?
+ [complexSelector] :
+ into[0].list;
+
+ 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, selector, data, {
+ filterOut: filterOut,
+ callback: collectReducedBodies
+ }, options, context);
+
+ if (stringifyBody(reducedBodies[reducedBodies.length - 1]) != stringifyBody(reducedBodies[0]))
+ continue allSelectors;
+ }
+
+ intoToken[2] = reducedBodies[0];
+ }
+}
+
+function reduceSelector(tokens, selector, data, context, options, outerContext) {
+ var bodies = [];
+ var bodiesAsList = [];
+ var joinsAt = [];
+ var processedTokens = [];
+
+ for (var j = data.length - 1, m = 0; 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);
+ }
+
+ for (j = 0, m = bodiesAsList.length; j < m; j++) {
+ if (bodiesAsList[j].length > 0)
+ joinsAt.push((joinsAt.length > 0 ? joinsAt[joinsAt.length - 1] : 0) + bodiesAsList[j].length);
+ }
+
+ optimizeProperties(selector, bodies, joinsAt, false, options, 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;
diff --git a/node_modules/clean-css/lib/selectors/remove-duplicate-media-queries.js b/node_modules/clean-css/lib/selectors/remove-duplicate-media-queries.js
new file mode 100644
index 0000000000000000000000000000000000000000..44070b0f78cc8c416d18f8e9152d4e50f74302b2
--- /dev/null
+++ b/node_modules/clean-css/lib/selectors/remove-duplicate-media-queries.js
@@ -0,0 +1,21 @@
+var stringifyAll = require('../stringifier/one-time').all;
+
+function removeDuplicateMediaQueries(tokens) {
+ var candidates = {};
+
+ for (var i = 0, l = tokens.length; i < l; i++) {
+ var token = tokens[i];
+ if (token[0] != 'block')
+ continue;
+
+ var key = token[1][0] + '%' + stringifyAll(token[2]);
+ var candidate = candidates[key];
+
+ if (candidate)
+ candidate[2] = [];
+
+ candidates[key] = token;
+ }
+}
+
+module.exports = removeDuplicateMediaQueries;
diff --git a/node_modules/clean-css/lib/selectors/remove-duplicates.js b/node_modules/clean-css/lib/selectors/remove-duplicates.js
new file mode 100644
index 0000000000000000000000000000000000000000..3a2ce959a4b4c1901e8b8afb4848f9ff7b8f0f31
--- /dev/null
+++ b/node_modules/clean-css/lib/selectors/remove-duplicates.js
@@ -0,0 +1,41 @@
+var stringifyBody = require('../stringifier/one-time').body;
+var stringifySelectors = require('../stringifier/one-time').selectors;
+
+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] != 'selector')
+ continue;
+
+ id = stringifySelectors(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 = stringifyBody(token[2]);
+
+ if (bodies.indexOf(body) > -1)
+ token[2] = [];
+ else
+ bodies.push(body);
+ }
+ }
+}
+
+module.exports = removeDuplicates;
diff --git a/node_modules/clean-css/lib/selectors/reorderable.js b/node_modules/clean-css/lib/selectors/reorderable.js
new file mode 100644
index 0000000000000000000000000000000000000000..3c49a3b493621830f78f2d751edb20fa9c551514
--- /dev/null
+++ b/node_modules/clean-css/lib/selectors/reorderable.js
@@ -0,0 +1,99 @@
+// TODO: it'd be great to merge it with the other canReorder functionality
+
+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) {
+ for (var i = right.length - 1; i >= 0; i--) {
+ for (var j = left.length - 1; j >= 0; j--) {
+ if (!canReorderSingle(left[j], right[i]))
+ return false;
+ }
+ }
+
+ return true;
+}
+
+function canReorderSingle(left, right) {
+ 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) && selectorsDoNotOverlap(rightSelector, leftSelector))
+ 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 selectorsDoNotOverlap(s1, s2) {
+ for (var i = 0, l = s1.length; i < l; i++) {
+ for (var j = 0, m = s2.length; j < m; j++) {
+ if (s1[i][0] == s2[j][0])
+ return false;
+ }
+ }
+
+ return true;
+}
+
+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
+};
diff --git a/node_modules/clean-css/lib/selectors/restructure.js b/node_modules/clean-css/lib/selectors/restructure.js
new file mode 100644
index 0000000000000000000000000000000000000000..c3e17f121bbb08f8646a775555d8bb6c3dc763bf
--- /dev/null
+++ b/node_modules/clean-css/lib/selectors/restructure.js
@@ -0,0 +1,369 @@
+var extractProperties = require('./extractor');
+var canReorderSingle = require('./reorderable').canReorderSingle;
+var stringifyBody = require('../stringifier/one-time').body;
+var stringifySelectors = require('../stringifier/one-time').selectors;
+var cleanUpSelectorDuplicates = require('./clean-up').selectorDuplicates;
+var isSpecial = require('./is-special');
+var cloneArray = require('../utils/clone-array');
+
+function naturalSorter(a, b) {
+ return a > b;
+}
+
+function cloneAndMergeSelectors(propertyA, propertyB) {
+ var cloned = cloneArray(propertyA);
+ cloned[5] = cloned[5].concat(propertyB[5]);
+
+ return cloned;
+}
+
+function restructure(tokens, options) {
+ 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(stringifySelectors(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 (isSpecial(options, stringifySelectors(sourceTokens[i][1])))
+ 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 = cleanUpSelectorDuplicates(allSelectors);
+ dropAsNewTokenAt(position, [movedProperty], allSelectors, qualifiedTokens);
+ }
+
+ function fitSorter(fit1, fit2) {
+ return fit1[1] > fit2[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 ? stringifySelectors(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[0][0];
+ var propertyName = property[0];
+ var propertyBody = property[4];
+ if (mergeablePropertyName == propertyName && stringifyBody([mergeableProperty]) == propertyBody) {
+ mergeableToken[2].splice(j, 1);
+ break;
+ }
+ }
+ }
+ }
+
+ for (i = properties.length - 1; i >= 0; i--) {
+ allProperties.unshift(properties[i][3]);
+ }
+
+ var newToken = ['selector', 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 = cleanUpSelectorDuplicates(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 isSelector;
+ var j, k, m;
+ var samePropertyAt;
+
+ if (token[0] == 'selector') {
+ isSelector = true;
+ } else if (token[0] == 'block') {
+ isSelector = 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])) {
+ 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) && !boundToAnotherPropertyInCurrrentToken(property, movedProperty, token)) {
+ 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 (!isSelector || unmovableInCurrentToken.indexOf(j) > -1)
+ continue;
+
+ var key = property[4];
+ 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] == 'at-rule' && tokens[0][1][0].indexOf('@charset') === 0 ? 1 : 0;
+ for (; position < tokens.length - 1; position++) {
+ var isImportRule = tokens[position][0] === 'at-rule' && tokens[position][1][0].indexOf('@import') === 0;
+ var isEscapedCommentSpecial = tokens[position][0] === 'text' && tokens[position][1][0].indexOf('__ESCAPED_COMMENT_SPECIAL') === 0;
+ if (!(isImportRule || isEscapedCommentSpecial))
+ break;
+ }
+
+ for (i = 0; i < movedProperties.length; i++) {
+ dropPropertiesAt(position, movedProperties[i]);
+ }
+}
+
+module.exports = restructure;
diff --git a/node_modules/clean-css/lib/selectors/simple.js b/node_modules/clean-css/lib/selectors/simple.js
new file mode 100644
index 0000000000000000000000000000000000000000..3bf29ca30fb4267398fc42b33651453a4f203640
--- /dev/null
+++ b/node_modules/clean-css/lib/selectors/simple.js
@@ -0,0 +1,454 @@
+var cleanUpSelectors = require('./clean-up').selectors;
+var cleanUpBlock = require('./clean-up').block;
+var cleanUpAtRule = require('./clean-up').atRule;
+var split = require('../utils/split');
+
+var RGB = require('../colors/rgb');
+var HSL = require('../colors/hsl');
+var HexNameShortener = require('../colors/hex-name-shortener');
+
+var wrapForOptimizing = require('../properties/wrap-for-optimizing').all;
+var restoreFromOptimizing = require('../properties/restore-from-optimizing');
+var removeUnused = require('../properties/remove-unused');
+
+var DEFAULT_ROUNDING_PRECISION = 2;
+var CHARSET_TOKEN = '@charset';
+var CHARSET_REGEXP = new RegExp('^' + CHARSET_TOKEN, 'i');
+var IMPORT_REGEXP = /^@import["'\s]/i;
+
+var FONT_NUMERAL_WEIGHTS = ['100', '200', '300', '400', '500', '600', '700', '800', '900'];
+var FONT_NAME_WEIGHTS = ['normal', 'bold', 'bolder', 'lighter'];
+var FONT_NAME_WEIGHTS_WITHOUT_NORMAL = ['bold', 'bolder', 'lighter'];
+
+var WHOLE_PIXEL_VALUE = /(?:^|\s|\()(-?\d+)px/;
+var TIME_VALUE = /^(\-?[\d\.]+)(m?s)$/;
+
+var valueMinifiers = {
+ 'background': function (value, index, total) {
+ return index === 0 && total == 1 && (value == 'none' || value == 'transparent') ? '0 0' : value;
+ },
+ 'font-weight': function (value) {
+ if (value == 'normal')
+ return '400';
+ else if (value == 'bold')
+ return '700';
+ else
+ return value;
+ },
+ 'outline': function (value, index, total) {
+ return index === 0 && total == 1 && value == 'none' ? '0' : value;
+ }
+};
+
+function isNegative(property, idx) {
+ return property.value[idx] && property.value[idx][0][0] == '-' && parseFloat(property.value[idx][0]) < 0;
+}
+
+function zeroMinifier(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 zeroDegMinifier(_, value) {
+ if (value.indexOf('0deg') == -1)
+ return value;
+
+ return value.replace(/\(0deg\)/g, '(0)');
+}
+
+function whitespaceMinifier(name, value) {
+ if (name.indexOf('filter') > -1 || value.indexOf(' ') == -1)
+ return value;
+
+ value = value.replace(/\s+/g, ' ');
+
+ if (value.indexOf('calc') > -1)
+ value = value.replace(/\) ?\/ ?/g, ')/ ');
+
+ return value
+ .replace(/\( /g, '(')
+ .replace(/ \)/g, ')')
+ .replace(/, /g, ',');
+}
+
+function precisionMinifier(_, value, precisionOptions) {
+ if (precisionOptions.value === -1 || value.indexOf('.') === -1)
+ return value;
+
+ return value
+ .replace(precisionOptions.regexp, function (match, number) {
+ return Math.round(parseFloat(number) * precisionOptions.multiplier) / precisionOptions.multiplier + 'px';
+ })
+ .replace(/(\d)\.($|\D)/g, '$1$2');
+}
+
+function unitMinifier(name, value, unitsRegexp) {
+ if (/^(?:\-moz\-calc|\-webkit\-calc|calc)\(/.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 multipleZerosMinifier(property) {
+ var values = property.value;
+ var spliceAt;
+
+ if (values.length == 4 && values[0][0] === '0' && values[1][0] === '0' && values[2][0] === '0' && values[3][0] === '0') {
+ if (property.name.indexOf('box-shadow') > -1)
+ spliceAt = 2;
+ else
+ spliceAt = 1;
+ }
+
+ if (spliceAt) {
+ property.value.splice(spliceAt);
+ property.dirty = true;
+ }
+}
+
+function colorMininifier(name, value, compatibility) {
+ if (value.indexOf('#') === -1 && value.indexOf('rgb') == -1 && value.indexOf('hsl') == -1)
+ return HexNameShortener.shorten(value);
+
+ value = value
+ .replace(/rgb\((\-?\d+),(\-?\d+),(\-?\d+)\)/g, function (match, red, green, blue) {
+ return new RGB(red, green, blue).toHex();
+ })
+ .replace(/hsl\((-?\d+),(-?\d+)%?,(-?\d+)%?\)/g, function (match, hue, saturation, lightness) {
+ return new HSL(hue, saturation, lightness).toHex();
+ })
+ .replace(/(^|[^='"])#([0-9a-f]{6})/gi, function (match, prefix, color) {
+ if (color[0] == color[1] && color[2] == color[3] && color[4] == color[5])
+ return prefix + '#' + color[0] + color[2] + color[4];
+ else
+ return prefix + '#' + color;
+ })
+ .replace(/(rgb|rgba|hsl|hsla)\(([^\)]+)\)/g, function (match, colorFunction, colorDef) {
+ var tokens = colorDef.split(',');
+ var applies = (colorFunction == 'hsl' && tokens.length == 3) ||
+ (colorFunction == 'hsla' && tokens.length == 4) ||
+ (colorFunction == 'rgb' && tokens.length == 3 && colorDef.indexOf('%') > 0) ||
+ (colorFunction == '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 HexNameShortener.shorten(value);
+}
+
+function pixelLengthMinifier(_, 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 timeUnitMinifier(_, 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 minifyBorderRadius(property) {
+ var values = property.value;
+ var spliceAt;
+
+ if (values.length == 3 && values[1][0] == '/' && values[0][0] == values[2][0])
+ spliceAt = 1;
+ else if (values.length == 5 && values[2][0] == '/' && values[0][0] == values[3][0] && values[1][0] == values[4][0])
+ spliceAt = 2;
+ else if (values.length == 7 && values[3][0] == '/' && values[0][0] == values[4][0] && values[1][0] == values[5][0] && values[2][0] == values[6][0])
+ spliceAt = 3;
+ else if (values.length == 9 && values[4][0] == '/' && values[0][0] == values[5][0] && values[1][0] == values[6][0] && values[2][0] == values[7][0] && values[3][0] == values[8][0])
+ spliceAt = 4;
+
+ if (spliceAt) {
+ property.value.splice(spliceAt);
+ property.dirty = true;
+ }
+}
+
+function minifyFilter(property) {
+ if (property.value.length == 1) {
+ property.value[0][0] = property.value[0][0].replace(/progid:DXImageTransform\.Microsoft\.(Alpha|Chroma)(\W)/, function (match, filter, suffix) {
+ return filter.toLowerCase() + suffix;
+ });
+ }
+
+ property.value[0][0] = property.value[0][0]
+ .replace(/,(\S)/g, ', $1')
+ .replace(/ ?= ?/g, '=');
+}
+
+function minifyFont(property) {
+ var values = property.value;
+ var hasNumeral = FONT_NUMERAL_WEIGHTS.indexOf(values[0][0]) > -1 ||
+ values[1] && FONT_NUMERAL_WEIGHTS.indexOf(values[1][0]) > -1 ||
+ values[2] && FONT_NUMERAL_WEIGHTS.indexOf(values[2][0]) > -1;
+
+ if (hasNumeral)
+ return;
+
+ if (values[1] == '/')
+ return;
+
+ var normalCount = 0;
+ if (values[0][0] == 'normal')
+ normalCount++;
+ if (values[1] && values[1][0] == 'normal')
+ normalCount++;
+ if (values[2] && values[2][0] == 'normal')
+ normalCount++;
+
+ if (normalCount > 1)
+ return;
+
+ var toOptimize;
+ if (FONT_NAME_WEIGHTS_WITHOUT_NORMAL.indexOf(values[0][0]) > -1)
+ toOptimize = 0;
+ else if (values[1] && FONT_NAME_WEIGHTS_WITHOUT_NORMAL.indexOf(values[1][0]) > -1)
+ toOptimize = 1;
+ else if (values[2] && FONT_NAME_WEIGHTS_WITHOUT_NORMAL.indexOf(values[2][0]) > -1)
+ toOptimize = 2;
+ else if (FONT_NAME_WEIGHTS.indexOf(values[0][0]) > -1)
+ toOptimize = 0;
+ else if (values[1] && FONT_NAME_WEIGHTS.indexOf(values[1][0]) > -1)
+ toOptimize = 1;
+ else if (values[2] && FONT_NAME_WEIGHTS.indexOf(values[2][0]) > -1)
+ toOptimize = 2;
+
+ if (toOptimize !== undefined) {
+ property.value[toOptimize][0] = valueMinifiers['font-weight'](values[toOptimize][0]);
+ property.dirty = true;
+ }
+}
+
+function optimizeBody(properties, options) {
+ var property, name, value;
+ var _properties = wrapForOptimizing(properties);
+
+ for (var i = 0, l = _properties.length; i < l; i++) {
+ property = _properties[i];
+ name = property.name;
+
+ if (property.hack && (
+ (property.hack == 'star' || property.hack == 'underscore') && !options.compatibility.properties.iePrefixHack ||
+ property.hack == 'backslash' && !options.compatibility.properties.ieSuffixHack ||
+ property.hack == 'bang' && !options.compatibility.properties.ieBangHack))
+ property.unused = true;
+
+ if (name.indexOf('padding') === 0 && (isNegative(property, 0) || isNegative(property, 1) || isNegative(property, 2) || isNegative(property, 3)))
+ property.unused = true;
+
+ if (property.unused)
+ continue;
+
+ if (property.variable) {
+ if (property.block)
+ optimizeBody(property.value[0], options);
+ continue;
+ }
+
+ for (var j = 0, m = property.value.length; j < m; j++) {
+ value = property.value[j][0];
+
+ if (valueMinifiers[name])
+ value = valueMinifiers[name](value, j, m);
+
+ value = whitespaceMinifier(name, value);
+ value = precisionMinifier(name, value, options.precision);
+ value = pixelLengthMinifier(name, value, options.compatibility);
+ value = timeUnitMinifier(name, value);
+ value = zeroMinifier(name, value);
+ if (options.compatibility.properties.zeroUnits) {
+ value = zeroDegMinifier(name, value);
+ value = unitMinifier(name, value, options.unitsRegexp);
+ }
+ if (options.compatibility.properties.colors)
+ value = colorMininifier(name, value, options.compatibility);
+
+ property.value[j][0] = value;
+ }
+
+ multipleZerosMinifier(property);
+
+ if (name.indexOf('border') === 0 && name.indexOf('radius') > 0)
+ minifyBorderRadius(property);
+ else if (name == 'filter')
+ minifyFilter(property);
+ else if (name == 'font')
+ minifyFont(property);
+ }
+
+ restoreFromOptimizing(_properties, true);
+ removeUnused(_properties);
+}
+
+function cleanupCharsets(tokens) {
+ var hasCharset = false;
+
+ for (var i = 0, l = tokens.length; i < l; i++) {
+ var token = tokens[i];
+
+ if (token[0] != 'at-rule')
+ continue;
+
+ if (!CHARSET_REGEXP.test(token[1][0]))
+ continue;
+
+ if (hasCharset || token[1][0].indexOf(CHARSET_TOKEN) == -1) {
+ tokens.splice(i, 1);
+ i--;
+ l--;
+ } else {
+ hasCharset = true;
+ tokens.splice(i, 1);
+ tokens.unshift(['at-rule', [token[1][0].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 buildPrecision(options) {
+ var precision = {};
+
+ precision.value = options.roundingPrecision === undefined ?
+ DEFAULT_ROUNDING_PRECISION :
+ options.roundingPrecision;
+ precision.multiplier = Math.pow(10, precision.value);
+ precision.regexp = new RegExp('(\\d*\\.\\d{' + (precision.value + 1) + ',})px', 'g');
+
+ return precision;
+}
+
+function optimize(tokens, options, context) {
+ var ie7Hack = options.compatibility.selectors.ie7Hack;
+ var adjacentSpace = options.compatibility.selectors.adjacentSpace;
+ var spaceAfterClosingBrace = options.compatibility.properties.spaceAfterClosingBrace;
+ var mayHaveCharset = false;
+ var afterContent = false;
+
+ options.unitsRegexp = buildUnitRegexp(options);
+ options.precision = buildPrecision(options);
+
+ for (var i = 0, l = tokens.length; i < l; i++) {
+ var token = tokens[i];
+
+ switch (token[0]) {
+ case 'selector':
+ token[1] = cleanUpSelectors(token[1], !ie7Hack, adjacentSpace);
+ optimizeBody(token[2], options);
+ afterContent = true;
+ break;
+ case 'block':
+ cleanUpBlock(token[1], spaceAfterClosingBrace);
+ optimize(token[2], options, context);
+ afterContent = true;
+ break;
+ case 'flat-block':
+ cleanUpBlock(token[1], spaceAfterClosingBrace);
+ optimizeBody(token[2], options);
+ afterContent = true;
+ break;
+ case 'at-rule':
+ cleanUpAtRule(token[1]);
+ mayHaveCharset = true;
+ }
+
+ if (token[0] == 'at-rule' && IMPORT_REGEXP.test(token[1]) && afterContent) {
+ context.warnings.push('Ignoring @import rule "' + token[1] + '" as it appears after rules thus browsers will ignore them.');
+ token[1] = '';
+ }
+
+ if (token[1].length === 0 || (token[2] && token[2].length === 0)) {
+ tokens.splice(i, 1);
+ i--;
+ l--;
+ }
+ }
+
+ if (mayHaveCharset)
+ cleanupCharsets(tokens);
+}
+
+module.exports = optimize;
diff --git a/node_modules/clean-css/lib/source-maps/track.js b/node_modules/clean-css/lib/source-maps/track.js
new file mode 100644
index 0000000000000000000000000000000000000000..735a58dc8f11ad8c7474f9d508e9b8642551047e
--- /dev/null
+++ b/node_modules/clean-css/lib/source-maps/track.js
@@ -0,0 +1,119 @@
+var escapePrefix = '__ESCAPED_';
+
+function trackPrefix(value, context, interestingContent) {
+ if (!interestingContent && value.indexOf('\n') == -1) {
+ if (value.indexOf(escapePrefix) === 0) {
+ return value;
+ } else {
+ context.column += value.length;
+ return;
+ }
+ }
+
+ var withoutContent = 0;
+ var split = value.split('\n');
+ var total = split.length;
+ var shift = 0;
+
+ while (true) {
+ if (withoutContent == total - 1)
+ break;
+
+ var part = split[withoutContent];
+ if (/\S/.test(part))
+ break;
+
+ shift += part.length + 1;
+ withoutContent++;
+ }
+
+ context.line += withoutContent;
+ context.column = withoutContent > 0 ? 0 : context.column;
+ context.column += /^(\s)*/.exec(split[withoutContent])[0].length;
+
+ return value.substring(shift).trimLeft();
+}
+
+function sourceFor(originalMetadata, contextMetadata, context) {
+ var source = originalMetadata.source || contextMetadata.source;
+
+ if (source && context.resolvePath)
+ return context.resolvePath(contextMetadata.source, source);
+
+ return source;
+}
+
+function snapshot(data, context, fallbacks) {
+ var metadata = {
+ line: context.line,
+ column: context.column,
+ source: context.source
+ };
+ var sourceContent = null;
+ var sourceMetadata = context.sourceMapTracker.isTracking(metadata.source) ?
+ context.sourceMapTracker.originalPositionFor(metadata, data, fallbacks || 0) :
+ {};
+
+ metadata.line = sourceMetadata.line || metadata.line;
+ metadata.column = sourceMetadata.column || metadata.column;
+ metadata.source = sourceMetadata.sourceResolved ?
+ sourceMetadata.source :
+ sourceFor(sourceMetadata, metadata, context);
+
+ if (context.sourceMapInlineSources) {
+ var sourceMapSourcesContent = context.sourceMapTracker.sourcesContentFor(context.source);
+ sourceContent = sourceMapSourcesContent && sourceMapSourcesContent[metadata.source] ?
+ sourceMapSourcesContent :
+ context.sourceReader.sourceAt(context.source);
+ }
+
+ return sourceContent ?
+ [metadata.line, metadata.column, metadata.source, sourceContent] :
+ [metadata.line, metadata.column, metadata.source];
+}
+
+function trackSuffix(data, context) {
+ var parts = data.split('\n');
+
+ for (var i = 0, l = parts.length; i < l; i++) {
+ var part = parts[i];
+ var cursor = 0;
+
+ if (i > 0) {
+ context.line++;
+ context.column = 0;
+ }
+
+ while (true) {
+ var next = part.indexOf(escapePrefix, cursor);
+
+ if (next == -1) {
+ context.column += part.substring(cursor).length;
+ break;
+ }
+
+ context.column += next - cursor;
+ cursor += next - cursor;
+
+ var escaped = part.substring(next, part.indexOf('__', next + 1) + 2);
+ var encodedValues = escaped.substring(escaped.indexOf('(') + 1, escaped.indexOf(')')).split(',');
+ context.line += ~~encodedValues[0];
+ context.column = (~~encodedValues[0] === 0 ? context.column : 0) + ~~encodedValues[1];
+ cursor += escaped.length;
+ }
+ }
+}
+
+function track(data, context, snapshotMetadata, fallbacks) {
+ var untracked = trackPrefix(data, context, snapshotMetadata);
+ var metadata = snapshotMetadata ?
+ snapshot(untracked, context, fallbacks) :
+ [];
+
+ if (untracked)
+ trackSuffix(untracked, context);
+
+ return metadata;
+}
+
+module.exports = track;
diff --git a/node_modules/clean-css/lib/stringifier/helpers.js b/node_modules/clean-css/lib/stringifier/helpers.js
new file mode 100644
index 0000000000000000000000000000000000000000..2e90001ef560396fdeaf8e5259d7a87530125865
--- /dev/null
+++ b/node_modules/clean-css/lib/stringifier/helpers.js
@@ -0,0 +1,167 @@
+var lineBreak = require('os').EOL;
+
+var AT_RULE = 'at-rule';
+var PROPERTY_SEPARATOR = ';';
+
+function hasMoreProperties(tokens, index) {
+ for (var i = index, l = tokens.length; i < l; i++) {
+ if (typeof tokens[i] != 'string')
+ return true;
+ }
+
+ return false;
+}
+
+function supportsAfterClosingBrace(token) {
+ return token[0][0] == 'background' || token[0][0] == 'transform' || token[0][0] == 'src';
+}
+
+function afterClosingBrace(token, valueIndex) {
+ return token[valueIndex][0][token[valueIndex][0].length - 1] == ')' || token[valueIndex][0].indexOf('__ESCAPED_URL_CLEAN_CSS') === 0;
+}
+
+function afterComma(token, valueIndex) {
+ return token[valueIndex][0] == ',';
+}
+
+function afterSlash(token, valueIndex) {
+ return token[valueIndex][0] == '/';
+}
+
+function beforeComma(token, valueIndex) {
+ return token[valueIndex + 1] && token[valueIndex + 1][0] == ',';
+}
+
+function beforeSlash(token, valueIndex) {
+ return token[valueIndex + 1] && token[valueIndex + 1][0] == '/';
+}
+
+function inFilter(token) {
+ return token[0][0] == 'filter' || token[0][0] == '-ms-filter';
+}
+
+function inSpecialContext(token, valueIndex, context) {
+ return !context.spaceAfterClosingBrace && supportsAfterClosingBrace(token) && afterClosingBrace(token, valueIndex) ||
+ beforeSlash(token, valueIndex) ||
+ afterSlash(token, valueIndex) ||
+ beforeComma(token, valueIndex) ||
+ afterComma(token, valueIndex);
+}
+
+function selectors(tokens, context) {
+ var store = context.store;
+
+ for (var i = 0, l = tokens.length; i < l; i++) {
+ store(tokens[i], context);
+
+ if (i < l - 1)
+ store(',', context);
+ }
+}
+
+function body(tokens, context) {
+ for (var i = 0, l = tokens.length; i < l; i++) {
+ property(tokens, i, i == l - 1, context);
+ }
+}
+
+function property(tokens, position, isLast, context) {
+ var store = context.store;
+ var token = tokens[position];
+
+ if (typeof token == 'string') {
+ store(token, context);
+ } else if (token[0] == AT_RULE) {
+ propertyAtRule(token[1], false, context);
+ } else {
+ store(token[0], context);
+ store(':', context);
+ value(tokens, position, isLast, context);
+ }
+}
+
+function propertyAtRule(value, isLast, context) {
+ var store = context.store;
+
+ store(value, context);
+ if (!isLast)
+ store(PROPERTY_SEPARATOR, context);
+}
+
+function value(tokens, position, isLast, context) {
+ var store = context.store;
+ var token = tokens[position];
+ var isVariableDeclaration = token[0][0].indexOf('--') === 0;
+ var isBlockVariable = isVariableDeclaration && Array.isArray(token[1][0]);
+
+ if (isVariableDeclaration && isBlockVariable && atRulesOrProperties(token[1])) {
+ store('{', context);
+ body(token[1], context);
+ store('};', context);
+ return;
+ }
+
+ for (var j = 1, m = token.length; j < m; j++) {
+ store(token[j], context);
+
+ if (j < m - 1 && (inFilter(token) || !inSpecialContext(token, j, context))) {
+ store(' ', context);
+ } else if (j == m - 1 && !isLast && hasMoreProperties(tokens, position + 1)) {
+ store(PROPERTY_SEPARATOR, context);
+ }
+ }
+}
+
+function atRulesOrProperties(values) {
+ for (var i = 0, l = values.length; i < l; i++) {
+ if (values[i][0] == AT_RULE || Array.isArray(values[i][0]))
+ return true;
+ }
+
+ return false;
+}
+
+function all(tokens, context) {
+ var joinCharacter = context.keepBreaks ? lineBreak : '';
+ var store = context.store;
+
+ for (var i = 0, l = tokens.length; i < l; i++) {
+ var token = tokens[i];
+
+ switch (token[0]) {
+ case 'at-rule':
+ case 'text':
+ store(token[1][0], context);
+ store(joinCharacter, context);
+ break;
+ case 'block':
+ selectors([token[1]], context);
+ store('{', context);
+ all(token[2], context);
+ store('}', context);
+ store(joinCharacter, context);
+ break;
+ case 'flat-block':
+ selectors([token[1]], context);
+ store('{', context);
+ body(token[2], context);
+ store('}', context);
+ store(joinCharacter, context);
+ break;
+ default:
+ selectors(token[1], context);
+ store('{', context);
+ body(token[2], context);
+ store('}', context);
+ store(joinCharacter, context);
+ }
+ }
+}
+
+module.exports = {
+ all: all,
+ body: body,
+ property: property,
+ selectors: selectors,
+ value: value
+};
diff --git a/node_modules/clean-css/lib/stringifier/one-time.js b/node_modules/clean-css/lib/stringifier/one-time.js
new file mode 100644
index 0000000000000000000000000000000000000000..4a65c7f2abea6e419fe9d9688b127f253a41b4fb
--- /dev/null
+++ b/node_modules/clean-css/lib/stringifier/one-time.js
@@ -0,0 +1,50 @@
+var helpers = require('./helpers');
+
+function store(token, context) {
+ context.output.push(typeof token == 'string' ? token : token[0]);
+}
+
+function context() {
+ return {
+ output: [],
+ store: store
+ };
+}
+
+function all(tokens) {
+ var fakeContext = context();
+ helpers.all(tokens, fakeContext);
+ return fakeContext.output.join('');
+}
+
+function body(tokens) {
+ var fakeContext = context();
+ helpers.body(tokens, fakeContext);
+ return fakeContext.output.join('');
+}
+
+function property(tokens, position) {
+ var fakeContext = context();
+ helpers.property(tokens, position, true, fakeContext);
+ return fakeContext.output.join('');
+}
+
+function selectors(tokens) {
+ var fakeContext = context();
+ helpers.selectors(tokens, fakeContext);
+ return fakeContext.output.join('');
+}
+
+function value(tokens, position) {
+ var fakeContext = context();
+ helpers.value(tokens, position, true, fakeContext);
+ return fakeContext.output.join('');
+}
+
+module.exports = {
+ all: all,
+ body: body,
+ property: property,
+ selectors: selectors,
+ value: value
+};
diff --git a/node_modules/clean-css/lib/stringifier/simple.js b/node_modules/clean-css/lib/stringifier/simple.js
new file mode 100644
index 0000000000000000000000000000000000000000..0673996d2bc2b953b9804f83409a230682324039
--- /dev/null
+++ b/node_modules/clean-css/lib/stringifier/simple.js
@@ -0,0 +1,22 @@
+var all = require('./helpers').all;
+
+function store(token, context) {
+ context.output.push(typeof token == 'string' ? token : token[0]);
+}
+
+function stringify(tokens, options, restoreCallback) {
+ var context = {
+ keepBreaks: options.keepBreaks,
+ output: [],
+ spaceAfterClosingBrace: options.compatibility.properties.spaceAfterClosingBrace,
+ store: store
+ };
+
+ all(tokens, context, false);
+
+ return {
+ styles: restoreCallback(context.output.join('')).trim()
+ };
+}
+
+module.exports = stringify;
diff --git a/node_modules/clean-css/lib/stringifier/source-maps.js b/node_modules/clean-css/lib/stringifier/source-maps.js
new file mode 100644
index 0000000000000000000000000000000000000000..77486140d53ed2eea469a5941e8aaf9ffe5481bb
--- /dev/null
+++ b/node_modules/clean-css/lib/stringifier/source-maps.js
@@ -0,0 +1,96 @@
+var SourceMapGenerator = require('source-map').SourceMapGenerator;
+var all = require('./helpers').all;
+
+var isWindows = process.platform == 'win32';
+var unknownSource = '$stdin';
+
+function store(element, context) {
+ var fromString = typeof element == 'string';
+ var value = fromString ? element : element[0];
+
+ if (value.indexOf('_') > -1)
+ value = context.restore(value, prefixContentFrom(context.output));
+
+ track(value, fromString ? null : element, context);
+ context.output.push(value);
+}
+
+function prefixContentFrom(values) {
+ var content = [];
+
+ for (var i = values.length - 1; i >= 0; i--) {
+ var value = values[i];
+ content.unshift(value);
+
+ if (value == '{' || value == ';')
+ break;
+ }
+
+ return content.join('');
+}
+
+function track(value, element, context) {
+ if (element)
+ trackAllMappings(element, context);
+
+ var parts = value.split('\n');
+ context.line += parts.length - 1;
+ context.column = parts.length > 1 ? 0 : (context.column + parts.pop().length);
+}
+
+function trackAllMappings(element, context) {
+ var mapping = element[element.length - 1];
+
+ if (!Array.isArray(mapping))
+ return;
+
+ for (var i = 0, l = mapping.length; i < l; i++) {
+ trackMapping(mapping[i], context);
+ }
+}
+
+function trackMapping(mapping, context) {
+ var source = mapping[2] || unknownSource;
+
+ if (isWindows)
+ source = source.replace(/\\/g, '/');
+
+ context.outputMap.addMapping({
+ generated: {
+ line: context.line,
+ column: context.column
+ },
+ source: source,
+ original: {
+ line: mapping[0],
+ column: mapping[1]
+ }
+ });
+
+ if (mapping[3])
+ context.outputMap.setSourceContent(source, mapping[3][mapping[2]]);
+}
+
+function stringify(tokens, options, restoreCallback, inputMapTracker) {
+ var context = {
+ column: 0,
+ inputMapTracker: inputMapTracker,
+ keepBreaks: options.keepBreaks,
+ line: 1,
+ output: [],
+ outputMap: new SourceMapGenerator(),
+ restore: restoreCallback,
+ sourceMapInlineSources: options.sourceMapInlineSources,
+ spaceAfterClosingBrace: options.compatibility.properties.spaceAfterClosingBrace,
+ store: store
+ };
+
+ all(tokens, context, false);
+
+ return {
+ sourceMap: context.outputMap,
+ styles: context.output.join('').trim()
+ };
+}
+
+module.exports = stringify;
diff --git a/node_modules/clean-css/lib/text/comments-processor.js b/node_modules/clean-css/lib/text/comments-processor.js
new file mode 100644
index 0000000000000000000000000000000000000000..2063b53a6a144be933d3b9c6c0e91b661ffa72a8
--- /dev/null
+++ b/node_modules/clean-css/lib/text/comments-processor.js
@@ -0,0 +1,131 @@
+var EscapeStore = require('./escape-store');
+var QuoteScanner = require('../utils/quote-scanner');
+
+var SPECIAL_COMMENT_PREFIX = '/*!';
+var COMMENT_PREFIX = '/*';
+var COMMENT_SUFFIX = '*/';
+
+var lineBreak = require('os').EOL;
+
+function CommentsProcessor(context, keepSpecialComments, keepBreaks, saveWaypoints) {
+ this.comments = new EscapeStore('COMMENT');
+ this.specialComments = new EscapeStore('COMMENT_SPECIAL');
+
+ this.context = context;
+ this.restored = 0;
+ this.keepAll = keepSpecialComments == '*';
+ this.keepOne = keepSpecialComments == '1' || keepSpecialComments === 1;
+ this.keepBreaks = keepBreaks;
+ this.saveWaypoints = saveWaypoints;
+}
+
+function quoteScannerFor(data) {
+ var quoteMap = [];
+ new QuoteScanner(data).each(function (quotedString, _, startsAt) {
+ quoteMap.push([startsAt, startsAt + quotedString.length]);
+ });
+
+ return function (position) {
+ for (var i = 0, l = quoteMap.length; i < l; i++) {
+ if (quoteMap[i][0] < position && quoteMap[i][1] > position)
+ return true;
+ }
+
+ return false;
+ };
+}
+
+CommentsProcessor.prototype.escape = function (data) {
+ var tempData = [];
+ var nextStart = 0;
+ var nextEnd = 0;
+ var cursor = 0;
+ var indent = 0;
+ var breaksCount;
+ var lastBreakAt;
+ var newIndent;
+ var isQuotedAt = quoteScannerFor(data);
+ var saveWaypoints = this.saveWaypoints;
+
+ for (; nextEnd < data.length;) {
+ nextStart = data.indexOf(COMMENT_PREFIX, cursor);
+ if (nextStart == -1)
+ break;
+
+ if (isQuotedAt(nextStart)) {
+ tempData.push(data.substring(cursor, nextStart + COMMENT_PREFIX.length));
+ cursor = nextStart + COMMENT_PREFIX.length;
+ continue;
+ }
+
+ nextEnd = data.indexOf(COMMENT_SUFFIX, nextStart + COMMENT_PREFIX.length);
+ if (nextEnd == -1) {
+ this.context.warnings.push('Broken comment: \'' + data.substring(nextStart) + '\'.');
+ nextEnd = data.length - 2;
+ }
+
+ tempData.push(data.substring(cursor, nextStart));
+
+ var comment = data.substring(nextStart, nextEnd + COMMENT_SUFFIX.length);
+ var isSpecialComment = comment.indexOf(SPECIAL_COMMENT_PREFIX) === 0;
+
+ if (saveWaypoints) {
+ breaksCount = comment.split(lineBreak).length - 1;
+ lastBreakAt = comment.lastIndexOf(lineBreak);
+ newIndent = lastBreakAt > 0 ?
+ comment.substring(lastBreakAt + lineBreak.length).length :
+ indent + comment.length;
+ }
+
+ if (saveWaypoints || isSpecialComment) {
+ var metadata = saveWaypoints ? [breaksCount, newIndent] : null;
+ var placeholder = isSpecialComment ?
+ this.specialComments.store(comment, metadata) :
+ this.comments.store(comment, metadata);
+ tempData.push(placeholder);
+ }
+
+ if (saveWaypoints)
+ indent = newIndent + 1;
+ cursor = nextEnd + COMMENT_SUFFIX.length;
+ }
+
+ return tempData.length > 0 ?
+ tempData.join('') + data.substring(cursor, data.length) :
+ data;
+};
+
+function restore(context, data, from, isSpecial) {
+ var tempData = [];
+ var cursor = 0;
+
+ for (; cursor < data.length;) {
+ var nextMatch = from.nextMatch(data, cursor);
+ if (nextMatch.start < 0)
+ break;
+
+ tempData.push(data.substring(cursor, nextMatch.start));
+ var comment = from.restore(nextMatch.match);
+
+ if (isSpecial && (context.keepAll || (context.keepOne && context.restored === 0))) {
+ context.restored++;
+ tempData.push(comment);
+
+ cursor = nextMatch.end;
+ } else {
+ cursor = nextMatch.end + (context.keepBreaks && data.substring(nextMatch.end, nextMatch.end + lineBreak.length) == lineBreak ? lineBreak.length : 0);
+ }
+ }
+
+ return tempData.length > 0 ?
+ tempData.join('') + data.substring(cursor, data.length) :
+ data;
+}
+
+CommentsProcessor.prototype.restore = function (data) {
+ data = restore(this, data, this.comments, false);
+ data = restore(this, data, this.specialComments, true);
+ return data;
+};
+
+module.exports = CommentsProcessor;
diff --git a/node_modules/clean-css/lib/text/escape-store.js b/node_modules/clean-css/lib/text/escape-store.js
new file mode 100644
index 0000000000000000000000000000000000000000..8598d732e8c540b6f47227b2dad148a6b19d8bb9
--- /dev/null
+++ b/node_modules/clean-css/lib/text/escape-store.js
@@ -0,0 +1,53 @@
+var placeholderBrace = '__';
+
+function EscapeStore(placeholderRoot) {
+ this.placeholderRoot = 'ESCAPED_' + placeholderRoot + '_CLEAN_CSS';
+ this.placeholderToData = {};
+ this.dataToPlaceholder = {};
+ this.count = 0;
+ this.restoreMatcher = new RegExp(this.placeholderRoot + '(\\d+)');
+}
+
+EscapeStore.prototype._nextPlaceholder = function (metadata) {
+ return {
+ index: this.count,
+ value: placeholderBrace + this.placeholderRoot + this.count++ + metadata + placeholderBrace
+ };
+};
+
+EscapeStore.prototype.store = function (data, metadata) {
+ var encodedMetadata = metadata ?
+ '(' + metadata.join(',') + ')' :
+ '';
+ var placeholder = this.dataToPlaceholder[data];
+
+ if (!placeholder) {
+ var nextPlaceholder = this._nextPlaceholder(encodedMetadata);
+ placeholder = nextPlaceholder.value;
+ this.placeholderToData[nextPlaceholder.index] = data;
+ this.dataToPlaceholder[data] = nextPlaceholder.value;
+ }
+
+ if (metadata)
+ placeholder = placeholder.replace(/\([^\)]+\)/, encodedMetadata);
+
+ return placeholder;
+};
+
+EscapeStore.prototype.nextMatch = function (data, cursor) {
+ var next = {};
+
+ next.start = data.indexOf(this.placeholderRoot, cursor) - placeholderBrace.length;
+ next.end = data.indexOf(placeholderBrace, next.start + placeholderBrace.length) + placeholderBrace.length;
+ if (next.start > -1 && next.end > -1)
+ next.match = data.substring(next.start, next.end);
+
+ return next;
+};
+
+EscapeStore.prototype.restore = function (placeholder) {
+ var index = this.restoreMatcher.exec(placeholder)[1];
+ return this.placeholderToData[index];
+};
+
+module.exports = EscapeStore;
diff --git a/node_modules/clean-css/lib/text/expressions-processor.js b/node_modules/clean-css/lib/text/expressions-processor.js
new file mode 100644
index 0000000000000000000000000000000000000000..3e22ced81b273352f59504d67e8b5de52c82e5b5
--- /dev/null
+++ b/node_modules/clean-css/lib/text/expressions-processor.js
@@ -0,0 +1,117 @@
+var EscapeStore = require('./escape-store');
+
+var EXPRESSION_NAME = 'expression';
+var EXPRESSION_START = '(';
+var EXPRESSION_END = ')';
+var EXPRESSION_PREFIX = EXPRESSION_NAME + EXPRESSION_START;
+var BODY_START = '{';
+var BODY_END = '}';
+
+var lineBreak = require('os').EOL;
+
+function findEnd(data, start) {
+ var end = start + EXPRESSION_NAME.length;
+ var level = 0;
+ var quoted = false;
+ var braced = false;
+
+ while (true) {
+ var current = data[end++];
+
+ if (quoted) {
+ quoted = current != '\'' && current != '"';
+ } else {
+ quoted = current == '\'' || current == '"';
+
+ if (current == EXPRESSION_START)
+ level++;
+ if (current == EXPRESSION_END)
+ level--;
+ if (current == BODY_START)
+ braced = true;
+ if (current == BODY_END && !braced && level == 1) {
+ end--;
+ level--;
+ }
+ }
+
+ if (level === 0 && current == EXPRESSION_END)
+ break;
+ if (!current) {
+ end = data.substring(0, end).lastIndexOf(BODY_END);
+ break;
+ }
+ }
+
+ return end;
+}
+
+function ExpressionsProcessor(saveWaypoints) {
+ this.expressions = new EscapeStore('EXPRESSION');
+ this.saveWaypoints = saveWaypoints;
+}
+
+ExpressionsProcessor.prototype.escape = function (data) {
+ var nextStart = 0;
+ var nextEnd = 0;
+ var cursor = 0;
+ var tempData = [];
+ var indent = 0;
+ var breaksCount;
+ var lastBreakAt;
+ var newIndent;
+ var saveWaypoints = this.saveWaypoints;
+
+ for (; nextEnd < data.length;) {
+ nextStart = data.indexOf(EXPRESSION_PREFIX, nextEnd);
+ if (nextStart == -1)
+ break;
+
+ nextEnd = findEnd(data, nextStart);
+
+ var expression = data.substring(nextStart, nextEnd);
+ if (saveWaypoints) {
+ breaksCount = expression.split(lineBreak).length - 1;
+ lastBreakAt = expression.lastIndexOf(lineBreak);
+ newIndent = lastBreakAt > 0 ?
+ expression.substring(lastBreakAt + lineBreak.length).length :
+ indent + expression.length;
+ }
+
+ var metadata = saveWaypoints ? [breaksCount, newIndent] : null;
+ var placeholder = this.expressions.store(expression, metadata);
+ tempData.push(data.substring(cursor, nextStart));
+ tempData.push(placeholder);
+
+ if (saveWaypoints)
+ indent = newIndent + 1;
+ cursor = nextEnd;
+ }
+
+ return tempData.length > 0 ?
+ tempData.join('') + data.substring(cursor, data.length) :
+ data;
+};
+
+ExpressionsProcessor.prototype.restore = function (data) {
+ var tempData = [];
+ var cursor = 0;
+
+ for (; cursor < data.length;) {
+ var nextMatch = this.expressions.nextMatch(data, cursor);
+ if (nextMatch.start < 0)
+ break;
+
+ tempData.push(data.substring(cursor, nextMatch.start));
+ var comment = this.expressions.restore(nextMatch.match);
+ tempData.push(comment);
+
+ cursor = nextMatch.end;
+ }
+
+ return tempData.length > 0 ?
+ tempData.join('') + data.substring(cursor, data.length) :
+ data;
+};
+
+module.exports = ExpressionsProcessor;
diff --git a/node_modules/clean-css/lib/text/free-text-processor.js b/node_modules/clean-css/lib/text/free-text-processor.js
new file mode 100644
index 0000000000000000000000000000000000000000..8a426244eb4f9f9088ffa796c974e1ba489b2d49
--- /dev/null
+++ b/node_modules/clean-css/lib/text/free-text-processor.js
@@ -0,0 +1,98 @@
+var EscapeStore = require('./escape-store');
+var QuoteScanner = require('../utils/quote-scanner');
+
+var lineBreak = require('os').EOL;
+
+function FreeTextProcessor(saveWaypoints) {
+ this.matches = new EscapeStore('FREE_TEXT');
+ this.saveWaypoints = saveWaypoints;
+}
+
+// Strip content tags by replacing them by the a special
+// marker for further restoring. It's done via string scanning
+// instead of regexps to speed up the process.
+FreeTextProcessor.prototype.escape = function (data) {
+ var self = this;
+ var breaksCount;
+ var lastBreakAt;
+ var indent;
+ var metadata;
+ var saveWaypoints = this.saveWaypoints;
+
+ return new QuoteScanner(data).each(function (match, store) {
+ if (saveWaypoints) {
+ breaksCount = match.split(lineBreak).length - 1;
+ lastBreakAt = match.lastIndexOf(lineBreak);
+ indent = lastBreakAt > 0 ?
+ match.substring(lastBreakAt + lineBreak.length).length :
+ match.length;
+ metadata = [breaksCount, indent];
+ }
+
+ var placeholder = self.matches.store(match, metadata);
+ store.push(placeholder);
+ });
+};
+
+function normalize(text, data, prefixContext, cursor) {
+ // FIXME: this is even a bigger hack now - see #407
+ var searchIn = data;
+ if (prefixContext) {
+ searchIn = prefixContext + data.substring(0, data.indexOf('__ESCAPED_FREE_TEXT_CLEAN_CSS'));
+ cursor = searchIn.length;
+ }
+
+ var lastSemicolon = searchIn.lastIndexOf(';', cursor);
+ var lastOpenBrace = searchIn.lastIndexOf('{', cursor);
+ var lastOne = 0;
+
+ if (lastSemicolon > -1 && lastOpenBrace > -1)
+ lastOne = Math.max(lastSemicolon, lastOpenBrace);
+ else if (lastSemicolon == -1)
+ lastOne = lastOpenBrace;
+ else
+ lastOne = lastSemicolon;
+
+ var context = searchIn.substring(lastOne + 1, cursor);
+
+ if (/\[[\w\d\-]+[\*\|\~\^\$]?=$/.test(context)) {
+ text = text
+ .replace(/\\\n|\\\r\n/g, '')
+ .replace(/\n|\r\n/g, '');
+ }
+
+ if (/^['"][a-zA-Z][a-zA-Z\d\-_]+['"]$/.test(text) && !/format\($/.test(context)) {
+ var isFont = /^(font|font\-family):/.test(context);
+ var isAttribute = /\[[\w\d\-]+[\*\|\~\^\$]?=$/.test(context);
+ var isKeyframe = /@(-moz-|-o-|-webkit-)?keyframes /.test(context);
+ var isAnimation = /^(-moz-|-o-|-webkit-)?animation(-name)?:/.test(context);
+
+ if (isFont || isAttribute || isKeyframe || isAnimation)
+ text = text.substring(1, text.length - 1);
+ }
+
+ return text;
+}
+
+FreeTextProcessor.prototype.restore = function (data, prefixContext) {
+ var tempData = [];
+ var cursor = 0;
+
+ for (; cursor < data.length;) {
+ var nextMatch = this.matches.nextMatch(data, cursor);
+ if (nextMatch.start < 0)
+ break;
+
+ tempData.push(data.substring(cursor, nextMatch.start));
+ var text = normalize(this.matches.restore(nextMatch.match), data, prefixContext, nextMatch.start);
+ tempData.push(text);
+
+ cursor = nextMatch.end;
+ }
+
+ return tempData.length > 0 ?
+ tempData.join('') + data.substring(cursor, data.length) :
+ data;
+};
+
+module.exports = FreeTextProcessor;
diff --git a/node_modules/clean-css/lib/text/urls-processor.js b/node_modules/clean-css/lib/text/urls-processor.js
new file mode 100644
index 0000000000000000000000000000000000000000..4dbb55adfc9f5ad99f09021edaa95f6aea884b32
--- /dev/null
+++ b/node_modules/clean-css/lib/text/urls-processor.js
@@ -0,0 +1,75 @@
+var EscapeStore = require('./escape-store');
+var reduceUrls = require('../urls/reduce');
+
+var lineBreak = require('os').EOL;
+
+function UrlsProcessor(context, saveWaypoints, keepUrlQuotes) {
+ this.urls = new EscapeStore('URL');
+ this.context = context;
+ this.saveWaypoints = saveWaypoints;
+ this.keepUrlQuotes = keepUrlQuotes;
+}
+
+// Strip urls by replacing them by a special
+// marker for further restoring. It's done via string scanning
+// instead of regexps to speed up the process.
+UrlsProcessor.prototype.escape = function (data) {
+ var breaksCount;
+ var lastBreakAt;
+ var indent;
+ var saveWaypoints = this.saveWaypoints;
+ var self = this;
+
+ return reduceUrls(data, this.context, function (url, tempData) {
+ if (saveWaypoints) {
+ breaksCount = url.split(lineBreak).length - 1;
+ lastBreakAt = url.lastIndexOf(lineBreak);
+ indent = lastBreakAt > 0 ?
+ url.substring(lastBreakAt + lineBreak.length).length :
+ url.length;
+ }
+
+ var placeholder = self.urls.store(url, saveWaypoints ? [breaksCount, indent] : null);
+ tempData.push(placeholder);
+ });
+};
+
+function normalize(url, keepUrlQuotes) {
+ url = url
+ .replace(/^url/gi, 'url')
+ .replace(/\\?\n|\\?\r\n/g, '')
+ .replace(/(\s{2,}|\s)/g, ' ')
+ .replace(/^url\((['"])? /, 'url($1')
+ .replace(/ (['"])?\)$/, '$1)');
+
+ if (/url\(".*'.*"\)/.test(url) || /url\('.*".*'\)/.test(url))
+ return url;
+
+ if (!keepUrlQuotes && !/^['"].+['"]$/.test(url) && !/url\(.*[\s\(\)].*\)/.test(url) && !/url\(['"]data:[^;]+;charset/.test(url))
+ url = url.replace(/["']/g, '');
+
+ return url;
+}
+
+UrlsProcessor.prototype.restore = function (data) {
+ var tempData = [];
+ var cursor = 0;
+
+ for (; cursor < data.length;) {
+ var nextMatch = this.urls.nextMatch(data, cursor);
+ if (nextMatch.start < 0)
+ break;
+
+ tempData.push(data.substring(cursor, nextMatch.start));
+ var url = normalize(this.urls.restore(nextMatch.match), this.keepUrlQuotes);
+ tempData.push(url);
+
+ cursor = nextMatch.end;
+ }
+
+ return tempData.length > 0 ?
+ tempData.join('') + data.substring(cursor, data.length) :
+ data;
+};
+
+module.exports = UrlsProcessor;
diff --git a/node_modules/clean-css/lib/tokenizer/extract-properties.js b/node_modules/clean-css/lib/tokenizer/extract-properties.js
new file mode 100644
index 0000000000000000000000000000000000000000..d4b0db397da8496600d11324b786feb88f99d8f8
--- /dev/null
+++ b/node_modules/clean-css/lib/tokenizer/extract-properties.js
@@ -0,0 +1,193 @@
+var split = require('../utils/split');
+
+var COMMA = ',';
+var FORWARD_SLASH = '/';
+
+var AT_RULE = 'at-rule';
+
+var IMPORTANT_WORD = 'important';
+var IMPORTANT_TOKEN = '!'+IMPORTANT_WORD;
+var IMPORTANT_WORD_MATCH = new RegExp('^'+IMPORTANT_WORD+'$', 'i');
+var IMPORTANT_TOKEN_MATCH = new RegExp('^'+IMPORTANT_TOKEN+'$', 'i');
+
+function selectorName(value) {
+ return value[0];
+}
+
+function noop() {}
+
+function withoutComments(string, into, heading, context) {
+ var matcher = heading ? /^__ESCAPED_COMMENT_/ : /__ESCAPED_COMMENT_/;
+ var track = heading ? context.track : noop; // don't track when comment not in a heading as we do it later in `trackComments`
+
+ while (matcher.test(string)) {
+ var startOfComment = string.indexOf('__');
+ var endOfComment = string.indexOf('__', startOfComment + 1) + 2;
+ var comment = string.substring(startOfComment, endOfComment);
+ string = string.substring(0, startOfComment) + string.substring(endOfComment);
+
+ track(comment);
+ into.push(comment);
+ }
+
+ return string;
+}
+
+function withoutHeadingComments(string, into, context) {
+ return withoutComments(string, into, true, context);
+}
+
+function withoutInnerComments(string, into, context) {
+ return withoutComments(string, into, false, context);
+}
+
+function trackComments(comments, into, context) {
+ for (var i = 0, l = comments.length; i < l; i++) {
+ context.track(comments[i]);
+ into.push(comments[i]);
+ }
+}
+
+function extractProperties(string, selectors, context) {
+ var list = [];
+ var innerComments = [];
+ var valueSeparator = /[\s,\/]/;
+
+ if (typeof string != 'string')
+ return [];
+
+ if (string.indexOf(')') > -1)
+ string = string.replace(/\)([^\s_;:,\)])/g, context.sourceMap ? ') __ESCAPED_COMMENT_CLEAN_CSS(0,-1)__ $1' : ') $1');
+
+ if (string.indexOf('ESCAPED_URL_CLEAN_CSS') > -1)
+ string = string.replace(/(ESCAPED_URL_CLEAN_CSS[^_]+?__)/g, context.sourceMap ? '$1 __ESCAPED_COMMENT_CLEAN_CSS(0,-1)__ ' : '$1 ');
+
+ var candidates = split(string, ';', false, '{', '}');
+
+ for (var i = 0, l = candidates.length; i < l; i++) {
+ var candidate = candidates[i];
+ var firstColonAt = candidate.indexOf(':');
+
+ var atRule = candidate.trim()[0] == '@';
+ if (atRule) {
+ context.track(candidate);
+ list.push([AT_RULE, candidate.trim()]);
+ continue;
+ }
+
+ if (firstColonAt == -1) {
+ context.track(candidate);
+ if (candidate.indexOf('__ESCAPED_COMMENT_SPECIAL') > -1)
+ list.push(candidate.trim());
+ continue;
+ }
+
+ if (candidate.indexOf('{') > 0 && candidate.indexOf('{') < firstColonAt) {
+ context.track(candidate);
+ continue;
+ }
+
+ var body = [];
+ var name = candidate.substring(0, firstColonAt);
+
+ innerComments = [];
+
+ if (name.indexOf('__ESCAPED_COMMENT') > -1)
+ name = withoutHeadingComments(name, list, context);
+
+ if (name.indexOf('__ESCAPED_COMMENT') > -1)
+ name = withoutInnerComments(name, innerComments, context);
+
+ body.push([name.trim()].concat(context.track(name, true)));
+ context.track(':');
+
+ trackComments(innerComments, list, context);
+
+ var firstBraceAt = candidate.indexOf('{');
+ var isVariable = name.trim().indexOf('--') === 0;
+ if (isVariable && firstBraceAt > 0) {
+ var blockPrefix = candidate.substring(firstColonAt + 1, firstBraceAt + 1);
+ var blockSuffix = candidate.substring(candidate.indexOf('}'));
+ var blockContent = candidate.substring(firstBraceAt + 1, candidate.length - blockSuffix.length);
+
+ context.track(blockPrefix);
+ body.push(extractProperties(blockContent, selectors, context));
+ list.push(body);
+ context.track(blockSuffix);
+ context.track(i < l - 1 ? ';' : '');
+
+ continue;
+ }
+
+ var values = split(candidate.substring(firstColonAt + 1), valueSeparator, true);
+
+ if (values.length == 1 && values[0] === '') {
+ context.warnings.push('Empty property \'' + name + '\' inside \'' + selectors.filter(selectorName).join(',') + '\' selector. Ignoring.');
+ continue;
+ }
+
+ for (var j = 0, m = values.length; j < m; j++) {
+ var value = values[j];
+ var trimmed = value.trim();
+
+ if (trimmed.length === 0)
+ continue;
+
+ var lastCharacter = trimmed[trimmed.length - 1];
+ var endsWithNonSpaceSeparator = trimmed.length > 1 && (lastCharacter == COMMA || lastCharacter == FORWARD_SLASH);
+
+ if (endsWithNonSpaceSeparator)
+ trimmed = trimmed.substring(0, trimmed.length - 1);
+
+ if (trimmed.indexOf('__ESCAPED_COMMENT_CLEAN_CSS(0,-') > -1) {
+ context.track(trimmed);
+ continue;
+ }
+
+ innerComments = [];
+
+ if (trimmed.indexOf('__ESCAPED_COMMENT') > -1)
+ trimmed = withoutHeadingComments(trimmed, list, context);
+
+ if (trimmed.indexOf('__ESCAPED_COMMENT') > -1)
+ trimmed = withoutInnerComments(trimmed, innerComments, context);
+
+ if (trimmed.length === 0) {
+ trackComments(innerComments, list, context);
+ continue;
+ }
+
+ var pos = body.length - 1;
+ if (IMPORTANT_WORD_MATCH.test(trimmed) && body[pos][0] == '!') {
+ context.track(trimmed);
+ body[pos - 1][0] += IMPORTANT_TOKEN;
+ body.pop();
+ continue;
+ }
+
+ if (IMPORTANT_TOKEN_MATCH.test(trimmed) || (IMPORTANT_WORD_MATCH.test(trimmed) && body[pos][0][body[pos][0].length - 1] == '!')) {
+ context.track(trimmed);
+ body[pos][0] += trimmed;
+ continue;
+ }
+
+ body.push([trimmed].concat(context.track(value, true)));
+
+ trackComments(innerComments, list, context);
+
+ if (endsWithNonSpaceSeparator) {
+ body.push([lastCharacter]);
+ context.track(lastCharacter);
+ }
+ }
+
+ if (i < l - 1)
+ context.track(';');
+
+ list.push(body);
+ }
+
+ return list;
+}
+
+module.exports = extractProperties;
diff --git a/node_modules/clean-css/lib/tokenizer/extract-selectors.js b/node_modules/clean-css/lib/tokenizer/extract-selectors.js
new file mode 100644
index 0000000000000000000000000000000000000000..dc8a47fa5aeb631c9928a645fbbfe9e79d41a0f0
--- /dev/null
+++ b/node_modules/clean-css/lib/tokenizer/extract-selectors.js
@@ -0,0 +1,17 @@
+var split = require('../utils/split');
+
+function extractSelectors(string, context) {
+ var list = [];
+ var metadata;
+ var selectors = split(string, ',');
+
+ for (var i = 0, l = selectors.length; i < l; i++) {
+ metadata = context.track(selectors[i], true, i);
+ context.track(',');
+ list.push([selectors[i].trim()].concat(metadata));
+ }
+
+ return list;
+}
+
+module.exports = extractSelectors;
diff --git a/node_modules/clean-css/lib/tokenizer/tokenize.js b/node_modules/clean-css/lib/tokenizer/tokenize.js
new file mode 100644
index 0000000000000000000000000000000000000000..e903f6e7d6a13a7a8030ae30f97d026a50c91502
--- /dev/null
+++ b/node_modules/clean-css/lib/tokenizer/tokenize.js
@@ -0,0 +1,297 @@
+var extractProperties = require('./extract-properties');
+var extractSelectors = require('./extract-selectors');
+var track = require('../source-maps/track');
+var split = require('../utils/split');
+
+var path = require('path');
+
+var flatBlock = /(@(font\-face|page|\-ms\-viewport|\-o\-viewport|viewport|counter\-style)|\\@.+?)/;
+var BACKSLASH = '\\';
+
+function tokenize(data, outerContext) {
+ var chunks = split(normalize(data), '}', true, '{', '}');
+ if (chunks.length === 0)
+ return [];
+
+ var context = {
+ chunk: chunks.shift(),
+ chunks: chunks,
+ column: 0,
+ cursor: 0,
+ line: 1,
+ mode: 'top',
+ resolvePath: outerContext.options.explicitTarget ?
+ relativePathResolver(outerContext.options.root, outerContext.options.target) :
+ null,
+ source: undefined,
+ sourceMap: outerContext.options.sourceMap,
+ sourceMapInlineSources: outerContext.options.sourceMapInlineSources,
+ sourceMapTracker: outerContext.inputSourceMapTracker,
+ sourceReader: outerContext.sourceReader,
+ sourceTracker: outerContext.sourceTracker,
+ state: [],
+ track: outerContext.options.sourceMap ?
+ function (data, snapshotMetadata, fallbacks) { return [[track(data, context, snapshotMetadata, fallbacks)]]; } :
+ function () { return []; },
+ warnings: outerContext.warnings
+ };
+
+ return intoTokens(context);
+}
+
+function normalize(data) {
+ return data.replace(/\r\n/g, '\n');
+}
+
+function relativePathResolver(root, target) {
+ var rebaseTo = path.relative(root, target);
+
+ return function (relativeTo, sourcePath) {
+ return relativeTo != sourcePath ?
+ path.normalize(path.join(path.relative(rebaseTo, path.dirname(relativeTo)), sourcePath)) :
+ sourcePath;
+ };
+}
+
+function whatsNext(context) {
+ var mode = context.mode;
+ var chunk = context.chunk;
+ var closest;
+
+ if (chunk.length == context.cursor) {
+ if (context.chunks.length === 0)
+ return null;
+
+ context.chunk = chunk = context.chunks.shift();
+ context.cursor = 0;
+ }
+
+ if (mode == 'body') {
+ if (chunk[context.cursor] == '}')
+ return [context.cursor, 'bodyEnd'];
+
+ if (chunk.indexOf('}', context.cursor) == -1)
+ return null;
+
+ closest = context.cursor + split(chunk.substring(context.cursor - 1), '}', true, '{', '}')[0].length - 2;
+ return [closest, 'bodyEnd'];
+ }
+
+ var nextSpecial = nextAt(context, '@');
+ var nextEscape = chunk.indexOf('__ESCAPED_', context.cursor);
+ var nextBodyStart = nextAt(context, '{');
+ var nextBodyEnd = nextAt(context, '}');
+
+ if (nextSpecial > -1 && context.cursor > 0 && !/\s|\{|\}|\/|_|,|;/.test(chunk.substring(nextSpecial - 1, nextSpecial))) {
+ nextSpecial = -1;
+ }
+
+ if (nextEscape > -1 && /\S/.test(chunk.substring(context.cursor, nextEscape)))
+ nextEscape = -1;
+
+ closest = nextSpecial;
+ if (closest == -1 || (nextEscape > -1 && nextEscape < closest))
+ closest = nextEscape;
+ if (closest == -1 || (nextBodyStart > -1 && nextBodyStart < closest))
+ closest = nextBodyStart;
+ if (closest == -1 || (nextBodyEnd > -1 && nextBodyEnd < closest))
+ closest = nextBodyEnd;
+
+ if (closest == -1)
+ return;
+ if (nextEscape === closest)
+ return [closest, 'escape'];
+ if (nextBodyStart === closest)
+ return [closest, 'bodyStart'];
+ if (nextBodyEnd === closest)
+ return [closest, 'bodyEnd'];
+ if (nextSpecial === closest)
+ return [closest, 'special'];
+}
+
+function nextAt(context, character) {
+ var startAt = context.cursor;
+ var chunk = context.chunk;
+ var position;
+
+ while ((position = chunk.indexOf(character, startAt)) > -1) {
+ if (isEscaped(chunk, position)) {
+ startAt = position + 1;
+ } else {
+ return position;
+ }
+ }
+
+ return -1;
+}
+
+function isEscaped(chunk, position) {
+ var startAt = position;
+ var backslashCount = 0;
+
+ while (startAt > 0 && chunk[startAt - 1] == BACKSLASH) {
+ backslashCount++;
+ startAt--;
+ }
+
+ return backslashCount % 2 !== 0;
+}
+
+function intoTokens(context) {
+ var chunk = context.chunk;
+ var tokenized = [];
+ var newToken;
+ var value;
+
+ while (true) {
+ var next = whatsNext(context);
+ if (!next) {
+ var whatsLeft = context.chunk.substring(context.cursor);
+ if (whatsLeft.trim().length > 0) {
+ if (context.mode == 'body') {
+ context.warnings.push('Missing \'}\' after \'' + whatsLeft + '\'. Ignoring.');
+ } else {
+ tokenized.push(['text', [whatsLeft]]);
+ }
+ context.cursor += whatsLeft.length;
+ }
+ break;
+ }
+
+ var nextSpecial = next[0];
+ var what = next[1];
+ var nextEnd;
+ var oldMode;
+
+ chunk = context.chunk;
+
+ if (context.cursor != nextSpecial && what != 'bodyEnd') {
+ var spacing = chunk.substring(context.cursor, nextSpecial);
+ var leadingWhitespace = /^\s+/.exec(spacing);
+
+ if (leadingWhitespace) {
+ context.cursor += leadingWhitespace[0].length;
+ context.track(leadingWhitespace[0]);
+ }
+ }
+
+ if (what == 'special') {
+ var firstOpenBraceAt = chunk.indexOf('{', nextSpecial);
+ var firstSemicolonAt = chunk.indexOf(';', nextSpecial);
+ var isSingle = firstSemicolonAt > -1 && (firstOpenBraceAt == -1 || firstSemicolonAt < firstOpenBraceAt);
+ var isBroken = firstOpenBraceAt == -1 && firstSemicolonAt == -1;
+ if (isBroken) {
+ context.warnings.push('Broken declaration: \'' + chunk.substring(context.cursor) + '\'.');
+ context.cursor = chunk.length;
+ } else if (isSingle) {
+ nextEnd = chunk.indexOf(';', nextSpecial + 1);
+ value = chunk.substring(context.cursor, nextEnd + 1);
+
+ tokenized.push([
+ 'at-rule',
+ [value].concat(context.track(value, true))
+ ]);
+
+ context.track(';');
+ context.cursor = nextEnd + 1;
+ } else {
+ nextEnd = chunk.indexOf('{', nextSpecial + 1);
+ value = chunk.substring(context.cursor, nextEnd);
+
+ var trimmedValue = value.trim();
+ var isFlat = flatBlock.test(trimmedValue);
+ oldMode = context.mode;
+ context.cursor = nextEnd + 1;
+ context.mode = isFlat ? 'body' : 'block';
+
+ newToken = [
+ isFlat ? 'flat-block' : 'block'
+ ];
+
+ newToken.push([trimmedValue].concat(context.track(value, true)));
+ context.track('{');
+ newToken.push(intoTokens(context));
+
+ if (typeof newToken[2] == 'string')
+ newToken[2] = extractProperties(newToken[2], [[trimmedValue]], context);
+
+ context.mode = oldMode;
+ context.track('}');
+
+ tokenized.push(newToken);
+ }
+ } else if (what == 'escape') {
+ nextEnd = chunk.indexOf('__', nextSpecial + 1);
+ var escaped = chunk.substring(context.cursor, nextEnd + 2);
+ var isStartSourceMarker = !!context.sourceTracker.nextStart(escaped);
+ var isEndSourceMarker = !!context.sourceTracker.nextEnd(escaped);
+
+ if (isStartSourceMarker) {
+ context.track(escaped);
+ context.state.push({
+ source: context.source,
+ line: context.line,
+ column: context.column
+ });
+ context.source = context.sourceTracker.nextStart(escaped).filename;
+ context.line = 1;
+ context.column = 0;
+ } else if (isEndSourceMarker) {
+ var oldState = context.state.pop();
+ context.source = oldState.source;
+ context.line = oldState.line;
+ context.column = oldState.column;
+ context.track(escaped);
+ } else {
+ if (escaped.indexOf('__ESCAPED_COMMENT_SPECIAL') === 0)
+ tokenized.push(['text', [escaped]]);
+
+ context.track(escaped);
+ }
+
+ context.cursor = nextEnd + 2;
+ } else if (what == 'bodyStart') {
+ var selectors = extractSelectors(chunk.substring(context.cursor, nextSpecial), context);
+
+ oldMode = context.mode;
+ context.cursor = nextSpecial + 1;
+ context.mode = 'body';
+
+ var body = extractProperties(intoTokens(context), selectors, context);
+
+ context.track('{');
+ context.mode = oldMode;
+
+ tokenized.push([
+ 'selector',
+ selectors,
+ body
+ ]);
+ } else if (what == 'bodyEnd') {
+ // extra closing brace at the top level can be safely ignored
+ if (context.mode == 'top') {
+ var at = context.cursor;
+ var warning = chunk[context.cursor] == '}' ?
+ 'Unexpected \'}\' in \'' + chunk.substring(at - 20, at + 20) + '\'. Ignoring.' :
+ 'Unexpected content: \'' + chunk.substring(at, nextSpecial + 1) + '\'. Ignoring.';
+
+ context.warnings.push(warning);
+ context.cursor = nextSpecial + 1;
+ continue;
+ }
+
+ if (context.mode == 'block')
+ context.track(chunk.substring(context.cursor, nextSpecial));
+ if (context.mode != 'block')
+ tokenized = chunk.substring(context.cursor, nextSpecial);
+
+ context.cursor = nextSpecial + 1;
+
+ break;
+ }
+ }
+
+ return tokenized;
+}
+
+module.exports = tokenize;
diff --git a/node_modules/clean-css/lib/urls/rebase.js b/node_modules/clean-css/lib/urls/rebase.js
new file mode 100644
index 0000000000000000000000000000000000000000..04346b1d427a05391775a44701bcbbd7db8901b6
--- /dev/null
+++ b/node_modules/clean-css/lib/urls/rebase.js
@@ -0,0 +1,30 @@
+var path = require('path');
+
+var rewriteUrls = require('./rewrite');
+
+function rebaseUrls(data, context) {
+ var rebaseOpts = {
+ absolute: context.options.explicitRoot,
+ relative: !context.options.explicitRoot && context.options.explicitTarget,
+ fromBase: context.options.relativeTo
+ };
+
+ if (!rebaseOpts.absolute && !rebaseOpts.relative)
+ return data;
+
+ if (rebaseOpts.absolute && context.options.explicitTarget)
+ context.warnings.push('Both \'root\' and output file given so rebasing URLs as absolute paths');
+
+ if (rebaseOpts.absolute)
+ rebaseOpts.toBase = path.resolve(context.options.root);
+
+ if (rebaseOpts.relative)
+ rebaseOpts.toBase = path.resolve(context.options.target);
+
+ if (!rebaseOpts.fromBase || !rebaseOpts.toBase)
+ return data;
+
+ return rewriteUrls(data, rebaseOpts, context);
+}
+
+module.exports = rebaseUrls;
diff --git a/node_modules/clean-css/lib/urls/reduce.js b/node_modules/clean-css/lib/urls/reduce.js
new file mode 100644
index 0000000000000000000000000000000000000000..35ad55569ffd7bd1be14eb6ce7ebd0a876d44e89
--- /dev/null
+++ b/node_modules/clean-css/lib/urls/reduce.js
@@ -0,0 +1,154 @@
+var split = require('../utils/split');
+
+var URL_PREFIX = 'url(';
+var UPPERCASE_URL_PREFIX = 'URL(';
+var URL_SUFFIX = ')';
+var SINGLE_QUOTE_URL_SUFFIX = '\')';
+var DOUBLE_QUOTE_URL_SUFFIX = '")';
+
+var DATA_URI_PREFIX_PATTERN = /^\s*['"]?\s*data:/;
+var DATA_URI_TRAILER_PATTERN = /[\s\};,\/!]/;
+
+var IMPORT_URL_PREFIX = '@import';
+var UPPERCASE_IMPORT_URL_PREFIX = '@IMPORT';
+
+var COMMENT_END_MARKER = /\*\//;
+
+function byUrl(data, context, callback) {
+ var nextStart = 0;
+ var nextStartUpperCase = 0;
+ var nextEnd = 0;
+ var firstMatch;
+ var isDataURI = false;
+ var cursor = 0;
+ var tempData = [];
+ var hasUppercaseUrl = data.indexOf(UPPERCASE_URL_PREFIX) > -1;
+
+ for (; nextEnd < data.length;) {
+ nextStart = data.indexOf(URL_PREFIX, nextEnd);
+ nextStartUpperCase = hasUppercaseUrl ? data.indexOf(UPPERCASE_URL_PREFIX, nextEnd) : -1;
+ if (nextStart == -1 && nextStartUpperCase == -1)
+ break;
+
+ if (nextStart == -1 && nextStartUpperCase > -1)
+ nextStart = nextStartUpperCase;
+
+ if (data[nextStart + URL_PREFIX.length] == '"') {
+ nextEnd = data.indexOf(DOUBLE_QUOTE_URL_SUFFIX, nextStart);
+ } else if (data[nextStart + URL_PREFIX.length] == '\'') {
+ nextEnd = data.indexOf(SINGLE_QUOTE_URL_SUFFIX, nextStart);
+ } else {
+ isDataURI = DATA_URI_PREFIX_PATTERN.test(data.substring(nextStart + URL_PREFIX.length));
+
+ if (isDataURI) {
+ firstMatch = split(data.substring(nextStart), DATA_URI_TRAILER_PATTERN, false, '(', ')', true).pop();
+
+ if (firstMatch && firstMatch[firstMatch.length - 1] == URL_SUFFIX) {
+ nextEnd = nextStart + firstMatch.length - URL_SUFFIX.length;
+ } else {
+ nextEnd = -1;
+ }
+ } else {
+ nextEnd = data.indexOf(URL_SUFFIX, nextStart);
+ }
+ }
+
+
+ // Following lines are a safety mechanism to ensure
+ // incorrectly terminated urls are processed correctly.
+ if (nextEnd == -1) {
+ nextEnd = data.indexOf('}', nextStart);
+
+ if (nextEnd == -1)
+ nextEnd = data.length;
+ else
+ nextEnd--;
+
+ context.warnings.push('Broken URL declaration: \'' + data.substring(nextStart, nextEnd + 1) + '\'.');
+ } else {
+ if (data[nextEnd] != URL_SUFFIX)
+ nextEnd = data.indexOf(URL_SUFFIX, nextEnd);
+ }
+
+ tempData.push(data.substring(cursor, nextStart));
+
+ var url = data.substring(nextStart, nextEnd + 1);
+ callback(url, tempData);
+
+ cursor = nextEnd + 1;
+ }
+
+ return tempData.length > 0 ?
+ tempData.join('') + data.substring(cursor, data.length) :
+ data;
+}
+
+function byImport(data, context, callback) {
+ var nextImport = 0;
+ var nextImportUpperCase = 0;
+ var nextStart = 0;
+ var nextEnd = 0;
+ var cursor = 0;
+ var tempData = [];
+ var nextSingleQuote = 0;
+ var nextDoubleQuote = 0;
+ var untilNextQuote;
+ var withQuote;
+ var SINGLE_QUOTE = '\'';
+ var DOUBLE_QUOTE = '"';
+
+ for (; nextEnd < data.length;) {
+ nextImport = data.indexOf(IMPORT_URL_PREFIX, nextEnd);
+ nextImportUpperCase = data.indexOf(UPPERCASE_IMPORT_URL_PREFIX, nextEnd);
+ if (nextImport == -1 && nextImportUpperCase == -1)
+ break;
+
+ if (nextImport > -1 && nextImportUpperCase > -1 && nextImportUpperCase < nextImport)
+ nextImport = nextImportUpperCase;
+
+ nextSingleQuote = data.indexOf(SINGLE_QUOTE, nextImport);
+ nextDoubleQuote = data.indexOf(DOUBLE_QUOTE, nextImport);
+
+ if (nextSingleQuote > -1 && nextDoubleQuote > -1 && nextSingleQuote < nextDoubleQuote) {
+ nextStart = nextSingleQuote;
+ withQuote = SINGLE_QUOTE;
+ } else if (nextSingleQuote > -1 && nextDoubleQuote > -1 && nextSingleQuote > nextDoubleQuote) {
+ nextStart = nextDoubleQuote;
+ withQuote = DOUBLE_QUOTE;
+ } else if (nextSingleQuote > -1) {
+ nextStart = nextSingleQuote;
+ withQuote = SINGLE_QUOTE;
+ } else if (nextDoubleQuote > -1) {
+ nextStart = nextDoubleQuote;
+ withQuote = DOUBLE_QUOTE;
+ } else {
+ break;
+ }
+
+ tempData.push(data.substring(cursor, nextStart));
+ nextEnd = data.indexOf(withQuote, nextStart + 1);
+
+ untilNextQuote = data.substring(nextImport, nextEnd);
+ if (nextEnd == -1 || /^@import\s+(url\(|__ESCAPED)/i.test(untilNextQuote) || COMMENT_END_MARKER.test(untilNextQuote)) {
+ cursor = nextStart;
+ break;
+ }
+
+ var url = data.substring(nextStart, nextEnd + 1);
+ callback(url, tempData);
+
+ cursor = nextEnd + 1;
+ }
+
+ return tempData.length > 0 ?
+ tempData.join('') + data.substring(cursor, data.length) :
+ data;
+}
+
+function reduceAll(data, context, callback) {
+ data = byUrl(data, context, callback);
+ data = byImport(data, context, callback);
+ return data;
+}
+
+module.exports = reduceAll;
diff --git a/node_modules/clean-css/lib/urls/rewrite.js b/node_modules/clean-css/lib/urls/rewrite.js
new file mode 100644
index 0000000000000000000000000000000000000000..0f5552b4eb8cd0b923923d225e572779f55a9628
--- /dev/null
+++ b/node_modules/clean-css/lib/urls/rewrite.js
@@ -0,0 +1,107 @@
+var path = require('path');
+var url = require('url');
+
+var reduceUrls = require('./reduce');
+
+var isWindows = process.platform == 'win32';
+
+function isAbsolute(uri) {
+ return uri[0] == '/';
+}
+
+function isSVGMarker(uri) {
+ return uri[0] == '#';
+}
+
+function isEscaped(uri) {
+ return uri.indexOf('__ESCAPED_URL_CLEAN_CSS__') === 0;
+}
+
+function isInternal(uri) {
+ return /^\w+:\w+/.test(uri);
+}
+
+function isRemote(uri) {
+ return /^[^:]+?:\/\//.test(uri) || uri.indexOf('//') === 0;
+}
+
+function isSameOrigin(uri1, uri2) {
+ return url.parse(uri1).protocol == url.parse(uri2).protocol &&
+ url.parse(uri1).host == url.parse(uri2).host;
+}
+
+function isImport(uri) {
+ return uri.lastIndexOf('.css') === uri.length - 4;
+}
+
+function isData(uri) {
+ return uri.indexOf('data:') === 0;
+}
+
+function absolute(uri, options) {
+ return path
+ .resolve(path.join(options.fromBase || '', uri))
+ .replace(options.toBase, '');
+}
+
+function relative(uri, options) {
+ return path.relative(options.toBase, path.join(options.fromBase || '', uri));
+}
+
+function normalize(uri) {
+ return isWindows ? uri.replace(/\\/g, '/') : uri;
+}
+
+function rebase(uri, options) {
+ if (isAbsolute(uri) || isSVGMarker(uri) || isEscaped(uri) || isInternal(uri))
+ return uri;
+
+ if (options.rebase === false && !isImport(uri))
+ return uri;
+
+ if (!options.imports && isImport(uri))
+ return uri;
+
+ if (isData(uri))
+ return '\'' + uri + '\'';
+
+ if (isRemote(uri) && !isRemote(options.toBase))
+ return uri;
+
+ if (isRemote(uri) && !isSameOrigin(uri, options.toBase))
+ return uri;
+
+ if (!isRemote(uri) && isRemote(options.toBase))
+ return url.resolve(options.toBase, uri);
+
+ return options.absolute ?
+ normalize(absolute(uri, options)) :
+ normalize(relative(uri, options));
+}
+
+function quoteFor(url) {
+ if (url.indexOf('\'') > -1)
+ return '"';
+ else if (url.indexOf('"') > -1)
+ return '\'';
+ else if (/\s/.test(url) || /[\(\)]/.test(url))
+ return '\'';
+ else
+ return '';
+}
+
+function rewriteUrls(data, options, context) {
+ return reduceUrls(data, context, function (originUrl, tempData) {
+ var url = originUrl.replace(/^(url\()?\s*['"]?|['"]?\s*\)?$/g, '');
+ var match = originUrl.match(/^(url\()?\s*(['"]).*?(['"])\s*\)?$/);
+ var quote;
+ if (!!options.urlQuotes && match && match[2] === match[3]) {
+ quote = match[2];
+ } else {
+ quote = quoteFor(url);
+ }
+ tempData.push('url(' + quote + rebase(url, options) + quote + ')');
+ });
+}
+
+module.exports = rewriteUrls;
diff --git a/node_modules/clean-css/lib/utils/clone-array.js b/node_modules/clean-css/lib/utils/clone-array.js
new file mode 100644
index 0000000000000000000000000000000000000000..b95ee6843b8248c9b2a5029a7fd607fb4280e1c9
--- /dev/null
+++ b/node_modules/clean-css/lib/utils/clone-array.js
@@ -0,0 +1,12 @@
+function cloneArray(array) {
+ var cloned = array.slice(0);
+
+ for (var i = 0, l = cloned.length; i < l; i++) {
+ if (Array.isArray(cloned[i]))
+ cloned[i] = cloneArray(cloned[i]);
+ }
+
+ return cloned;
+}
+
+module.exports = cloneArray;
diff --git a/node_modules/clean-css/lib/utils/compatibility.js b/node_modules/clean-css/lib/utils/compatibility.js
new file mode 100644
index 0000000000000000000000000000000000000000..112a6dcce4c55048d1351c53285574ae23994eb5
--- /dev/null
+++ b/node_modules/clean-css/lib/utils/compatibility.js
@@ -0,0 +1,162 @@
+var util = require('util');
+
+var DEFAULTS = {
+ '*': {
+ colors: {
+ opacity: true // rgba / hsla
+ },
+ properties: {
+ backgroundClipMerging: false, // background-clip to shorthand
+ backgroundOriginMerging: false, // background-origin to shorthand
+ backgroundSizeMerging: false, // 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
+ iePrefixHack: false, // underscore / asterisk prefix hacks on IE
+ ieSuffixHack: true, // \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
+ special: /(\-moz\-|\-ms\-|\-o\-|\-webkit\-|:dir\([a-z-]*\)|:first(?![a-z-])|:fullscreen|:left|:read-only|:read-write|:right|:placeholder|:host|:content|\/deep\/|:shadow|:selection|^,)/ // special selectors which prevent merging
+ },
+ 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
+ }
+ },
+ 'ie8': {
+ colors: {
+ opacity: false
+ },
+ properties: {
+ backgroundClipMerging: false,
+ backgroundOriginMerging: false,
+ backgroundSizeMerging: false,
+ colors: true,
+ ieBangHack: false,
+ iePrefixHack: true,
+ ieSuffixHack: true,
+ merging: false,
+ shorterLengthUnits: false,
+ spaceAfterClosingBrace: true,
+ urlQuotes: false,
+ zeroUnits: true
+ },
+ selectors: {
+ adjacentSpace: false,
+ ie7Hack: false,
+ special: /(\-moz\-|\-ms\-|\-o\-|\-webkit\-|:root|:nth|:first\-of|:last|:only|:empty|:target|:checked|::selection|:enabled|:disabled|:not|:placeholder|:host|::content|\/deep\/|::shadow|^,)/
+ },
+ units: {
+ ch: false,
+ in: true,
+ pc: true,
+ pt: true,
+ rem: false,
+ vh: false,
+ vm: false,
+ vmax: false,
+ vmin: false,
+ vw: false
+ }
+ },
+ 'ie7': {
+ colors: {
+ opacity: false
+ },
+ properties: {
+ backgroundClipMerging: false,
+ backgroundOriginMerging: false,
+ backgroundSizeMerging: false,
+ colors: true,
+ ieBangHack: true,
+ iePrefixHack: true,
+ ieSuffixHack: true,
+ merging: false,
+ shorterLengthUnits: false,
+ spaceAfterClosingBrace: true,
+ urlQuotes: false,
+ zeroUnits: true
+ },
+ selectors: {
+ adjacentSpace: false,
+ ie7Hack: true,
+ special: /(\-moz\-|\-ms\-|\-o\-|\-webkit\-|:focus|:before|:after|:root|:nth|:first\-of|:last|:only|:empty|:target|:checked|::selection|:enabled|:disabled|:not|:placeholder|:host|::content|\/deep\/|::shadow|^,)/
+ },
+ units: {
+ ch: false,
+ in: true,
+ pc: true,
+ pt: true,
+ rem: false,
+ vh: false,
+ vm: false,
+ vmax: false,
+ vmin: false,
+ vw: false,
+ }
+ }
+};
+
+function Compatibility(source) {
+ this.source = source || {};
+}
+
+function merge(source, target) {
+ for (var key in source) {
+ var value = source[key];
+
+ if (typeof value === 'object' && !util.isRegExp(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);
+}
+
+Compatibility.prototype.toOptions = function () {
+ return merge(DEFAULTS['*'], calculateSource(this.source));
+};
+
+module.exports = Compatibility;
diff --git a/node_modules/clean-css/lib/utils/input-source-map-tracker.js b/node_modules/clean-css/lib/utils/input-source-map-tracker.js
new file mode 100644
index 0000000000000000000000000000000000000000..bfd9106fc612e8f40df1b75998ba6af5303956f2
--- /dev/null
+++ b/node_modules/clean-css/lib/utils/input-source-map-tracker.js
@@ -0,0 +1,284 @@
+var SourceMapConsumer = require('source-map').SourceMapConsumer;
+
+var fs = require('fs');
+var path = require('path');
+var http = require('http');
+var https = require('https');
+var url = require('url');
+
+var override = require('../utils/object.js').override;
+
+var MAP_MARKER = /\/\*# sourceMappingURL=(\S+) \*\//;
+var REMOTE_RESOURCE = /^(https?:)?\/\//;
+var DATA_URI = /^data:(\S*?)?(;charset=[^;]+)?(;[^,]+?)?,(.+)/;
+
+var unescape = global.unescape;
+
+function InputSourceMapStore(outerContext) {
+ this.options = outerContext.options;
+ this.errors = outerContext.errors;
+ this.warnings = outerContext.warnings;
+ this.sourceTracker = outerContext.sourceTracker;
+ this.timeout = this.options.inliner.timeout;
+ this.requestOptions = this.options.inliner.request;
+ this.localOnly = outerContext.localOnly;
+ this.relativeTo = outerContext.options.target || process.cwd();
+
+ this.maps = {};
+ this.sourcesContent = {};
+}
+
+function fromString(self, _, whenDone) {
+ self.trackLoaded(undefined, undefined, self.options.sourceMap);
+ return whenDone();
+}
+
+function fromSource(self, data, whenDone, context) {
+ var nextAt = 0;
+
+ function proceedToNext() {
+ context.cursor += nextAt + 1;
+ fromSource(self, data, whenDone, context);
+ }
+
+ while (context.cursor < data.length) {
+ var fragment = data.substring(context.cursor);
+
+ var markerStartMatch = self.sourceTracker.nextStart(fragment) || { index: -1 };
+ var markerEndMatch = self.sourceTracker.nextEnd(fragment) || { index: -1 };
+ var mapMatch = MAP_MARKER.exec(fragment) || { index: -1 };
+ var sourceMapFile = mapMatch[1];
+
+ nextAt = data.length;
+ if (markerStartMatch.index > -1)
+ nextAt = markerStartMatch.index;
+ if (markerEndMatch.index > -1 && markerEndMatch.index < nextAt)
+ nextAt = markerEndMatch.index;
+ if (mapMatch.index > -1 && mapMatch.index < nextAt)
+ nextAt = mapMatch.index;
+
+ if (nextAt == data.length)
+ break;
+
+ if (nextAt == markerStartMatch.index) {
+ context.files.push(markerStartMatch.filename);
+ } else if (nextAt == markerEndMatch.index) {
+ context.files.pop();
+ } else if (nextAt == mapMatch.index) {
+ var isRemote = /^https?:\/\//.test(sourceMapFile) || /^\/\//.test(sourceMapFile);
+ var isDataUri = DATA_URI.test(sourceMapFile);
+
+ if (isRemote) {
+ return fetchMapFile(self, sourceMapFile, context, proceedToNext);
+ } else {
+ var sourceFile = context.files[context.files.length - 1];
+ var sourceMapPath, sourceMapData;
+ var sourceDir = sourceFile ? path.dirname(sourceFile) : self.options.relativeTo;
+
+ if (isDataUri) {
+ // source map's path is the same as the source file it comes from
+ sourceMapPath = path.resolve(self.options.root, sourceFile || '');
+ sourceMapData = fromDataUri(sourceMapFile);
+ } else {
+ sourceMapPath = path.resolve(self.options.root, path.join(sourceDir || '', sourceMapFile));
+ sourceMapData = fs.readFileSync(sourceMapPath, 'utf-8');
+ }
+ self.trackLoaded(sourceFile || undefined, sourceMapPath, sourceMapData);
+ }
+ }
+
+ context.cursor += nextAt + 1;
+ }
+
+ return whenDone();
+}
+
+function fromDataUri(uriString) {
+ var match = DATA_URI.exec(uriString);
+ var charset = match[2] ? match[2].split(/[=;]/)[2] : 'us-ascii';
+ var encoding = match[3] ? match[3].split(';')[1] : 'utf8';
+ var data = encoding == 'utf8' ? unescape(match[4]) : match[4];
+
+ var buffer = new Buffer(data, encoding);
+ buffer.charset = charset;
+
+ return buffer.toString();
+}
+
+function fetchMapFile(self, sourceUrl, context, done) {
+ fetch(self, sourceUrl, function (data) {
+ self.trackLoaded(context.files[context.files.length - 1] || undefined, sourceUrl, data);
+ done();
+ }, function (message) {
+ context.errors.push('Broken source map at "' + sourceUrl + '" - ' + message);
+ return done();
+ });
+}
+
+function fetch(self, path, onSuccess, onFailure) {
+ var protocol = path.indexOf('https') === 0 ? https : http;
+ var requestOptions = override(url.parse(path), self.requestOptions);
+ var errorHandled = false;
+
+ protocol
+ .get(requestOptions, function (res) {
+ if (res.statusCode < 200 || res.statusCode > 299)
+ return onFailure(res.statusCode);
+
+ var chunks = [];
+ res.on('data', function (chunk) {
+ chunks.push(chunk.toString());
+ });
+ res.on('end', function () {
+ onSuccess(chunks.join(''));
+ });
+ })
+ .on('error', function (res) {
+ if (errorHandled)
+ return;
+
+ onFailure(res.message);
+ errorHandled = true;
+ })
+ .on('timeout', function () {
+ if (errorHandled)
+ return;
+
+ onFailure('timeout');
+ errorHandled = true;
+ })
+ .setTimeout(self.timeout);
+}
+
+function originalPositionIn(trackedSource, line, column, token, allowNFallbacks) {
+ var originalPosition;
+ var maxRange = token.length;
+ var position = {
+ line: line,
+ column: column + maxRange
+ };
+
+ while (maxRange-- > 0) {
+ position.column--;
+ originalPosition = trackedSource.data.originalPositionFor(position);
+
+ if (originalPosition)
+ break;
+ }
+
+ if (originalPosition.line === null && line > 1 && allowNFallbacks > 0)
+ return originalPositionIn(trackedSource, line - 1, column, token, allowNFallbacks - 1);
+
+ if (trackedSource.path && originalPosition.source) {
+ originalPosition.source = REMOTE_RESOURCE.test(trackedSource.path) ?
+ url.resolve(trackedSource.path, originalPosition.source) :
+ path.join(trackedSource.path, originalPosition.source);
+
+ originalPosition.sourceResolved = true;
+ }
+
+ return originalPosition;
+}
+
+function trackContentSources(self, sourceFile) {
+ var consumer = self.maps[sourceFile].data;
+ var isRemote = REMOTE_RESOURCE.test(sourceFile);
+ var sourcesMapping = {};
+
+ consumer.sources.forEach(function (file, index) {
+ var uniquePath = isRemote ?
+ url.resolve(path.dirname(sourceFile), file) :
+ path.relative(self.relativeTo, path.resolve(path.dirname(sourceFile || '.'), file));
+
+ sourcesMapping[uniquePath] = consumer.sourcesContent && consumer.sourcesContent[index];
+ });
+ self.sourcesContent[sourceFile] = sourcesMapping;
+}
+
+function _resolveSources(self, remaining, whenDone) {
+ function processNext() {
+ return _resolveSources(self, remaining, whenDone);
+ }
+
+ if (remaining.length === 0)
+ return whenDone();
+
+ var current = remaining.shift();
+ var sourceFile = current[0];
+ var originalFile = current[1];
+ var isRemote = REMOTE_RESOURCE.test(sourceFile);
+
+ if (isRemote && self.localOnly) {
+ self.warnings.push('No callback given to `#minify` method, cannot fetch a remote file from "' + originalFile + '"');
+ return processNext();
+ }
+
+ if (isRemote) {
+ fetch(self, originalFile, function (data) {
+ self.sourcesContent[sourceFile][originalFile] = data;
+ processNext();
+ }, function (message) {
+ self.warnings.push('Broken original source file at "' + originalFile + '" - ' + message);
+ processNext();
+ });
+ } else {
+ var fullPath = path.join(self.options.root, originalFile);
+ if (fs.existsSync(fullPath))
+ self.sourcesContent[sourceFile][originalFile] = fs.readFileSync(fullPath, 'utf-8');
+ else
+ self.warnings.push('Missing original source file at "' + fullPath + '".');
+ return processNext();
+ }
+}
+
+InputSourceMapStore.prototype.track = function (data, whenDone) {
+ return typeof this.options.sourceMap == 'string' ?
+ fromString(this, data, whenDone) :
+ fromSource(this, data, whenDone, { files: [], cursor: 0, errors: this.errors });
+};
+
+InputSourceMapStore.prototype.trackLoaded = function (sourcePath, mapPath, mapData) {
+ var relativeTo = this.options.explicitTarget ? this.options.target : this.options.root;
+ var isRemote = REMOTE_RESOURCE.test(sourcePath);
+
+ if (mapPath) {
+ mapPath = isRemote ?
+ path.dirname(mapPath) :
+ path.dirname(path.relative(relativeTo, mapPath));
+ }
+
+ this.maps[sourcePath] = {
+ path: mapPath,
+ data: new SourceMapConsumer(mapData)
+ };
+
+ trackContentSources(this, sourcePath);
+};
+
+InputSourceMapStore.prototype.isTracking = function (source) {
+ return !!this.maps[source];
+};
+
+InputSourceMapStore.prototype.originalPositionFor = function (sourceInfo, token, allowNFallbacks) {
+ return originalPositionIn(this.maps[sourceInfo.source], sourceInfo.line, sourceInfo.column, token, allowNFallbacks);
+};
+
+InputSourceMapStore.prototype.sourcesContentFor = function (contextSource) {
+ return this.sourcesContent[contextSource];
+};
+
+InputSourceMapStore.prototype.resolveSources = function (whenDone) {
+ var toResolve = [];
+
+ for (var sourceFile in this.sourcesContent) {
+ var contents = this.sourcesContent[sourceFile];
+ for (var originalFile in contents) {
+ if (!contents[originalFile])
+ toResolve.push([sourceFile, originalFile]);
+ }
+ }
+
+ return _resolveSources(this, toResolve, whenDone);
+};
+
+module.exports = InputSourceMapStore;
diff --git a/node_modules/clean-css/lib/utils/object.js b/node_modules/clean-css/lib/utils/object.js
new file mode 100644
index 0000000000000000000000000000000000000000..8e94886c8b9bfb26f0aedb718f48cbdcead57273
--- /dev/null
+++ b/node_modules/clean-css/lib/utils/object.js
@@ -0,0 +1,11 @@
+module.exports = {
+ override: function (source1, source2) {
+ var target = {};
+ for (var key1 in source1)
+ target[key1] = source1[key1];
+ for (var key2 in source2)
+ target[key2] = source2[key2];
+
+ return target;
+ }
+};
diff --git a/node_modules/clean-css/lib/utils/quote-scanner.js b/node_modules/clean-css/lib/utils/quote-scanner.js
new file mode 100644
index 0000000000000000000000000000000000000000..1810b9ec65f7a68dd20edccc90cfd118324da62c
--- /dev/null
+++ b/node_modules/clean-css/lib/utils/quote-scanner.js
@@ -0,0 +1,119 @@
+var COMMENT_START_MARK = '/*';
+
+function QuoteScanner(data) {
+ this.data = data;
+}
+
+var findQuoteEnd = function (data, matched, cursor, oldCursor) {
+ var commentEndMark = '*/';
+ var escapeMark = '\\';
+ var blockEndMark = '}';
+ var dataPrefix = data.substring(oldCursor, cursor);
+ var commentEndedAt = dataPrefix.lastIndexOf(commentEndMark, cursor);
+ var commentStartedAt = findLastCommentStartedAt(dataPrefix, cursor);
+ var commentStarted = false;
+
+ if (commentEndedAt >= cursor && commentStartedAt > -1)
+ commentStarted = true;
+ if (commentStartedAt < cursor && commentStartedAt > commentEndedAt)
+ commentStarted = true;
+
+ if (commentStarted) {
+ var commentEndsAt = data.indexOf(commentEndMark, cursor);
+ if (commentEndsAt > -1)
+ return commentEndsAt;
+
+ commentEndsAt = data.indexOf(blockEndMark, cursor);
+ return commentEndsAt > -1 ? commentEndsAt - 1 : data.length;
+ }
+
+ while (true) {
+ if (data[cursor] === undefined)
+ break;
+ if (data[cursor] == matched && (data[cursor - 1] != escapeMark || data[cursor - 2] == escapeMark))
+ break;
+
+ cursor++;
+ }
+
+ return cursor;
+};
+
+function findLastCommentStartedAt(data, cursor) {
+ var position = cursor;
+
+ while (position > -1) {
+ position = data.lastIndexOf(COMMENT_START_MARK, position);
+
+ if (position > -1 && data[position - 1] != '*') {
+ break;
+ } else {
+ position--;
+ }
+ }
+
+ return position;
+}
+
+function findNext(data, mark, startAt) {
+ var escapeMark = '\\';
+ var candidate = startAt;
+
+ while (true) {
+ candidate = data.indexOf(mark, candidate + 1);
+ if (candidate == -1)
+ return -1;
+ if (data[candidate - 1] != escapeMark)
+ return candidate;
+ }
+}
+
+QuoteScanner.prototype.each = function (callback) {
+ var data = this.data;
+ var tempData = [];
+ var nextStart = 0;
+ var nextEnd = 0;
+ var cursor = 0;
+ var matchedMark = null;
+ var singleMark = '\'';
+ var doubleMark = '"';
+ var dataLength = data.length;
+
+ for (; nextEnd < data.length;) {
+ var nextStartSingle = findNext(data, singleMark, nextEnd);
+ var nextStartDouble = findNext(data, doubleMark, nextEnd);
+
+ if (nextStartSingle == -1)
+ nextStartSingle = dataLength;
+ if (nextStartDouble == -1)
+ nextStartDouble = dataLength;
+
+ if (nextStartSingle < nextStartDouble) {
+ nextStart = nextStartSingle;
+ matchedMark = singleMark;
+ } else {
+ nextStart = nextStartDouble;
+ matchedMark = doubleMark;
+ }
+
+ if (nextStart == -1)
+ break;
+
+ nextEnd = findQuoteEnd(data, matchedMark, nextStart + 1, cursor);
+ if (nextEnd == -1)
+ break;
+
+ var text = data.substring(nextStart, nextEnd + 1);
+ tempData.push(data.substring(cursor, nextStart));
+ if (text.length > 0)
+ callback(text, tempData, nextStart);
+
+ cursor = nextEnd + 1;
+ }
+
+ return tempData.length > 0 ?
+ tempData.join('') + data.substring(cursor, data.length) :
+ data;
+};
+
+module.exports = QuoteScanner;
diff --git a/node_modules/clean-css/lib/utils/source-reader.js b/node_modules/clean-css/lib/utils/source-reader.js
new file mode 100644
index 0000000000000000000000000000000000000000..d817e72b3273cf617e0d8425e680c90f0f57ed25
--- /dev/null
+++ b/node_modules/clean-css/lib/utils/source-reader.js
@@ -0,0 +1,96 @@
+var path = require('path');
+var rewriteUrls = require('../urls/rewrite');
+
+var REMOTE_RESOURCE = /^(https?:)?\/\//;
+
+function SourceReader(context, data) {
+ this.outerContext = context;
+ this.data = data;
+ this.sources = {};
+}
+
+SourceReader.prototype.sourceAt = function (path) {
+ return this.sources[path];
+};
+
+SourceReader.prototype.trackSource = function (path, source) {
+ this.sources[path] = {};
+ this.sources[path][path] = source;
+};
+
+SourceReader.prototype.toString = function () {
+ if (typeof this.data == 'string')
+ return fromString(this);
+ if (Buffer.isBuffer(this.data))
+ return fromBuffer(this);
+ if (Array.isArray(this.data))
+ return fromArray(this);
+
+ return fromHash(this);
+};
+
+function fromString(self) {
+ var data = self.data;
+ self.trackSource(undefined, data);
+ return data;
+}
+
+function fromBuffer(self) {
+ var data = self.data.toString();
+ self.trackSource(undefined, data);
+ return data;
+}
+
+function fromArray(self) {
+ return self.data
+ .map(function (source) {
+ return self.outerContext.options.processImport === false ?
+ source + '@shallow' :
+ source;
+ })
+ .map(function (source) {
+ return !self.outerContext.options.relativeTo || /^https?:\/\//.test(source) ?
+ source :
+ path.relative(self.outerContext.options.relativeTo, source);
+ })
+ .map(function (source) { return '@import url(' + source + ');'; })
+ .join('');
+}
+
+function fromHash(self) {
+ var data = [];
+ var toBase = path.resolve(self.outerContext.options.target || self.outerContext.options.root);
+
+ for (var source in self.data) {
+ var styles = self.data[source].styles;
+ var inputSourceMap = self.data[source].sourceMap;
+ var isRemote = REMOTE_RESOURCE.test(source);
+ var absoluteSource = isRemote ? source : path.resolve(source);
+ var absoluteSourcePath = path.dirname(absoluteSource);
+
+ var rewriteOptions = {
+ absolute: self.outerContext.options.explicitRoot,
+ relative: !self.outerContext.options.explicitRoot,
+ imports: true,
+ rebase: self.outerContext.options.rebase,
+ fromBase: absoluteSourcePath,
+ toBase: isRemote ? absoluteSourcePath : toBase,
+ urlQuotes: self.outerContext.options.compatibility.properties.urlQuotes
+ };
+ styles = rewriteUrls(styles, rewriteOptions, self.outerContext);
+
+ self.trackSource(source, styles);
+
+ styles = self.outerContext.sourceTracker.store(source, styles);
+
+ // here we assume source map lies in the same directory as `source` does
+ if (self.outerContext.options.sourceMap && inputSourceMap)
+ self.outerContext.inputSourceMapTracker.trackLoaded(source, source, inputSourceMap);
+
+ data.push(styles);
+ }
+
+ return data.join('');
+}
+
+module.exports = SourceReader;
diff --git a/node_modules/clean-css/lib/utils/source-tracker.js b/node_modules/clean-css/lib/utils/source-tracker.js
new file mode 100644
index 0000000000000000000000000000000000000000..4cc9b6dabe460d9afd105d82a4759fba37eb68d5
--- /dev/null
+++ b/node_modules/clean-css/lib/utils/source-tracker.js
@@ -0,0 +1,31 @@
+function SourceTracker() {
+ this.sources = [];
+}
+
+SourceTracker.prototype.store = function (filename, data) {
+ this.sources.push(filename);
+
+ return '__ESCAPED_SOURCE_CLEAN_CSS' + (this.sources.length - 1) + '__' +
+ data +
+ '__ESCAPED_SOURCE_END_CLEAN_CSS__';
+};
+
+SourceTracker.prototype.nextStart = function (data) {
+ var next = /__ESCAPED_SOURCE_CLEAN_CSS(\d+)__/.exec(data);
+
+ return next ?
+ { index: next.index, filename: this.sources[~~next[1]] } :
+ null;
+};
+
+SourceTracker.prototype.nextEnd = function (data) {
+ return /__ESCAPED_SOURCE_END_CLEAN_CSS__/g.exec(data);
+};
+
+SourceTracker.prototype.removeAll = function (data) {
+ return data
+ .replace(/__ESCAPED_SOURCE_CLEAN_CSS\d+__/g, '')
+ .replace(/__ESCAPED_SOURCE_END_CLEAN_CSS__/g, '');
+};
+
+module.exports = SourceTracker;
diff --git a/node_modules/clean-css/lib/utils/split.js b/node_modules/clean-css/lib/utils/split.js
new file mode 100644
index 0000000000000000000000000000000000000000..6efc1ea0d0472b26ac169cfc5e704faf14f8b088
--- /dev/null
+++ b/node_modules/clean-css/lib/utils/split.js
@@ -0,0 +1,62 @@
+function split(value, separator, includeSeparator, openLevel, closeLevel, firstOnly) {
+ var withRegex = typeof separator != 'string';
+ var hasSeparator = withRegex ?
+ separator.test(value) :
+ value.indexOf(separator);
+
+ if (!hasSeparator)
+ return [value];
+
+ openLevel = openLevel || '(';
+ closeLevel = closeLevel || ')';
+
+ if (value.indexOf(openLevel) == -1 && !includeSeparator && !firstOnly)
+ return value.split(separator);
+
+ var BACKSLASH = '\\';
+ var isEscaped = false;
+ var wasEscaped = false;
+ var level = 0;
+ var cursor = 0;
+ var lastStart = 0;
+ var len = value.length;
+ var tokens = [];
+
+ while (cursor < len) {
+ isEscaped = value[cursor] == BACKSLASH;
+
+ if (wasEscaped) {
+ // no-op
+ } else
+ if (value[cursor] == openLevel) {
+ level++;
+ } else if (value[cursor] == closeLevel) {
+ level--;
+ }
+
+ if (!wasEscaped && level === 0 && cursor > 0 && cursor + 1 < len && (withRegex ? separator.test(value[cursor]) : value[cursor] == separator)) {
+ tokens.push(value.substring(lastStart, cursor + (includeSeparator ? 1 : 0)));
+ lastStart = cursor + 1;
+
+ if (firstOnly && tokens.length == 1) {
+ break;
+ }
+ }
+
+ wasEscaped = isEscaped;
+ cursor++;
+ }
+
+ if (lastStart < cursor + 1) {
+ var lastValue = value.substring(lastStart);
+ var lastCharacter = lastValue[lastValue.length - 1];
+ if (!includeSeparator && (withRegex ? separator.test(lastCharacter) : lastCharacter == separator))
+ lastValue = lastValue.substring(0, lastValue.length - 1);
+
+ tokens.push(lastValue);
+ }
+
+ return tokens;
+}
+
+module.exports = split;
diff --git a/node_modules/clean-css/package.json b/node_modules/clean-css/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..b22d357624873ad6e992ded5036e1654aba7615e
--- /dev/null
+++ b/node_modules/clean-css/package.json
@@ -0,0 +1,53 @@
+{
+ "name": "clean-css",
+ "version": "3.4.28",
+ "author": "Jakub Pawlowicz
Welcome back, ' + escapeHtml(name) + '!
'); + } else { + res.write('Hello, new visitor!
'); + } + + res.write(''); +} + +http.createServer(onRequest).listen(3000); +``` + +## Testing + +```sh +$ npm test +``` + +## Benchmark + +``` +$ npm run bench + +> cookie@0.3.1 bench cookie +> node benchmark/index.js + + http_parser@2.8.0 + node@6.14.2 + v8@5.1.281.111 + uv@1.16.1 + zlib@1.2.11 + ares@1.10.1-DEV + icu@58.2 + modules@48 + napi@3 + openssl@1.0.2o + +> node benchmark/parse.js + + cookie.parse + + 6 tests completed. + + simple x 1,200,691 ops/sec ±1.12% (189 runs sampled) + decode x 1,012,994 ops/sec ±0.97% (186 runs sampled) + unquote x 1,074,174 ops/sec ±2.43% (186 runs sampled) + duplicates x 438,424 ops/sec ±2.17% (184 runs sampled) + 10 cookies x 147,154 ops/sec ±1.01% (186 runs sampled) + 100 cookies x 14,274 ops/sec ±1.07% (187 runs sampled) +``` + +## References + +- [RFC 6265: HTTP State Management Mechanism][rfc-6265] +- [Same-site Cookies][rfc-6265bis-03-4.1.2.7] + +[rfc-6265bis-03-4.1.2.7]: https://tools.ietf.org/html/draft-ietf-httpbis-rfc6265bis-03#section-4.1.2.7 +[rfc-6265]: https://tools.ietf.org/html/rfc6265 +[rfc-6265-5.1.4]: https://tools.ietf.org/html/rfc6265#section-5.1.4 +[rfc-6265-5.2.1]: https://tools.ietf.org/html/rfc6265#section-5.2.1 +[rfc-6265-5.2.2]: https://tools.ietf.org/html/rfc6265#section-5.2.2 +[rfc-6265-5.2.3]: https://tools.ietf.org/html/rfc6265#section-5.2.3 +[rfc-6265-5.2.4]: https://tools.ietf.org/html/rfc6265#section-5.2.4 +[rfc-6265-5.2.5]: https://tools.ietf.org/html/rfc6265#section-5.2.5 +[rfc-6265-5.2.6]: https://tools.ietf.org/html/rfc6265#section-5.2.6 +[rfc-6265-5.3]: https://tools.ietf.org/html/rfc6265#section-5.3 + +## License + +[MIT](LICENSE) + +[coveralls-image]: https://badgen.net/coveralls/c/github/jshttp/cookie/master +[coveralls-url]: https://coveralls.io/r/jshttp/cookie?branch=master +[node-version-image]: https://badgen.net/npm/node/cookie +[node-version-url]: https://nodejs.org/en/download +[npm-downloads-image]: https://badgen.net/npm/dm/cookie +[npm-url]: https://npmjs.org/package/cookie +[npm-version-image]: https://badgen.net/npm/v/cookie +[travis-image]: https://badgen.net/travis/jshttp/cookie/master +[travis-url]: https://travis-ci.org/jshttp/cookie diff --git a/node_modules/cookie/index.js b/node_modules/cookie/index.js new file mode 100644 index 0000000000000000000000000000000000000000..760f32e5d6af2e682cd6fe4d736ab4aa51f3918d --- /dev/null +++ b/node_modules/cookie/index.js @@ -0,0 +1,202 @@ +/*! + * cookie + * Copyright(c) 2012-2014 Roman Shtylman + * Copyright(c) 2015 Douglas Christopher Wilson + * MIT Licensed + */ + +'use strict'; + +/** + * Module exports. + * @public + */ + +exports.parse = parse; +exports.serialize = serialize; + +/** + * Module variables. + * @private + */ + +var decode = decodeURIComponent; +var encode = encodeURIComponent; +var pairSplitRegExp = /; */; + +/** + * RegExp to match field-content in RFC 7230 sec 3.2 + * + * field-content = field-vchar [ 1*( SP / HTAB ) field-vchar ] + * field-vchar = VCHAR / obs-text + * obs-text = %x80-FF + */ + +var fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/; + +/** + * Parse a cookie header. + * + * Parse the given cookie header string into an object + * The object has the various cookies as keys(names) => values + * + * @param {string} str + * @param {object} [options] + * @return {object} + * @public + */ + +function parse(str, options) { + if (typeof str !== 'string') { + throw new TypeError('argument str must be a string'); + } + + var obj = {} + var opt = options || {}; + var pairs = str.split(pairSplitRegExp); + var dec = opt.decode || decode; + + for (var i = 0; i < pairs.length; i++) { + var pair = pairs[i]; + var eq_idx = pair.indexOf('='); + + // skip things that don't look like key=value + if (eq_idx < 0) { + continue; + } + + var key = pair.substr(0, eq_idx).trim() + var val = pair.substr(++eq_idx, pair.length).trim(); + + // quoted values + if ('"' == val[0]) { + val = val.slice(1, -1); + } + + // only assign once + if (undefined == obj[key]) { + obj[key] = tryDecode(val, dec); + } + } + + return obj; +} + +/** + * Serialize data into a cookie header. + * + * Serialize the a name value pair into a cookie string suitable for + * http headers. An optional options object specified cookie parameters. + * + * serialize('foo', 'bar', { httpOnly: true }) + * => "foo=bar; httpOnly" + * + * @param {string} name + * @param {string} val + * @param {object} [options] + * @return {string} + * @public + */ + +function serialize(name, val, options) { + var opt = options || {}; + var enc = opt.encode || encode; + + if (typeof enc !== 'function') { + throw new TypeError('option encode is invalid'); + } + + if (!fieldContentRegExp.test(name)) { + throw new TypeError('argument name is invalid'); + } + + var value = enc(val); + + if (value && !fieldContentRegExp.test(value)) { + throw new TypeError('argument val is invalid'); + } + + var str = name + '=' + value; + + if (null != opt.maxAge) { + var maxAge = opt.maxAge - 0; + + if (isNaN(maxAge) || !isFinite(maxAge)) { + throw new TypeError('option maxAge is invalid') + } + + str += '; Max-Age=' + Math.floor(maxAge); + } + + if (opt.domain) { + if (!fieldContentRegExp.test(opt.domain)) { + throw new TypeError('option domain is invalid'); + } + + str += '; Domain=' + opt.domain; + } + + if (opt.path) { + if (!fieldContentRegExp.test(opt.path)) { + throw new TypeError('option path is invalid'); + } + + str += '; Path=' + opt.path; + } + + if (opt.expires) { + if (typeof opt.expires.toUTCString !== 'function') { + throw new TypeError('option expires is invalid'); + } + + str += '; Expires=' + opt.expires.toUTCString(); + } + + if (opt.httpOnly) { + str += '; HttpOnly'; + } + + if (opt.secure) { + str += '; Secure'; + } + + if (opt.sameSite) { + var sameSite = typeof opt.sameSite === 'string' + ? opt.sameSite.toLowerCase() : opt.sameSite; + + switch (sameSite) { + case true: + str += '; SameSite=Strict'; + break; + case 'lax': + str += '; SameSite=Lax'; + break; + case 'strict': + str += '; SameSite=Strict'; + break; + case 'none': + str += '; SameSite=None'; + break; + default: + throw new TypeError('option sameSite is invalid'); + } + } + + return str; +} + +/** + * Try decoding a string using a decoding function. + * + * @param {string} str + * @param {function} decode + * @private + */ + +function tryDecode(str, decode) { + try { + return decode(str); + } catch (e) { + return str; + } +} diff --git a/node_modules/cookie/package.json b/node_modules/cookie/package.json new file mode 100644 index 0000000000000000000000000000000000000000..1ae8eb612dce75c45dfd51337f31f03c24e4b036 --- /dev/null +++ b/node_modules/cookie/package.json @@ -0,0 +1,40 @@ +{ + "name": "cookie", + "description": "HTTP server cookie parsing and serialization", + "version": "0.4.1", + "author": "Roman Shtylman
+
+---
+
+
+
+---
+
+**It's documentation for obsolete `core-js@2`. If you looking documentation for actual `core-js` version, please, check [this branch](https://github.com/zloirock/core-js/tree/master).**
+
+Modular standard library for JavaScript. Includes polyfills for [ECMAScript 5](#ecmascript-5), [ECMAScript 6](#ecmascript-6): [promises](#ecmascript-6-promise), [symbols](#ecmascript-6-symbol), [collections](#ecmascript-6-collections), iterators, [typed arrays](#ecmascript-6-typed-arrays), [ECMAScript 7+ proposals](#ecmascript-7-proposals), [setImmediate](#setimmediate), etc. Some additional features such as [dictionaries](#dict) or [extended partial application](#partial-application). You can require only needed features or use it without global namespace pollution.
+
+[*Example*](http://goo.gl/a2xexl):
+```js
+Array.from(new Set([1, 2, 3, 2, 1])); // => [1, 2, 3]
+'*'.repeat(10); // => '**********'
+Promise.resolve(32).then(x => console.log(x)); // => 32
+setImmediate(x => console.log(x), 42); // => 42
+```
+
+[*Without global namespace pollution*](http://goo.gl/paOHb0):
+```js
+var core = require('core-js/library'); // With a modular system, otherwise use global `core`
+core.Array.from(new core.Set([1, 2, 3, 2, 1])); // => [1, 2, 3]
+core.String.repeat('*', 10); // => '**********'
+core.Promise.resolve(32).then(x => console.log(x)); // => 32
+core.setImmediate(x => console.log(x), 42); // => 42
+```
+
+### Index
+- [Usage](#usage)
+ - [Basic](#basic)
+ - [CommonJS](#commonjs)
+ - [Custom build](#custom-build-from-the-command-line)
+- [Supported engines](#supported-engines)
+- [Features](#features)
+ - [ECMAScript 5](#ecmascript-5)
+ - [ECMAScript 6](#ecmascript-6)
+ - [ECMAScript 6: Object](#ecmascript-6-object)
+ - [ECMAScript 6: Function](#ecmascript-6-function)
+ - [ECMAScript 6: Array](#ecmascript-6-array)
+ - [ECMAScript 6: String](#ecmascript-6-string)
+ - [ECMAScript 6: RegExp](#ecmascript-6-regexp)
+ - [ECMAScript 6: Number](#ecmascript-6-number)
+ - [ECMAScript 6: Math](#ecmascript-6-math)
+ - [ECMAScript 6: Date](#ecmascript-6-date)
+ - [ECMAScript 6: Promise](#ecmascript-6-promise)
+ - [ECMAScript 6: Symbol](#ecmascript-6-symbol)
+ - [ECMAScript 6: Collections](#ecmascript-6-collections)
+ - [ECMAScript 6: Typed Arrays](#ecmascript-6-typed-arrays)
+ - [ECMAScript 6: Reflect](#ecmascript-6-reflect)
+ - [ECMAScript 7+ proposals](#ecmascript-7-proposals)
+ - [stage 4 proposals](#stage-4-proposals)
+ - [stage 3 proposals](#stage-3-proposals)
+ - [stage 2 proposals](#stage-2-proposals)
+ - [stage 1 proposals](#stage-1-proposals)
+ - [stage 0 proposals](#stage-0-proposals)
+ - [pre-stage 0 proposals](#pre-stage-0-proposals)
+ - [Web standards](#web-standards)
+ - [setTimeout / setInterval](#settimeout--setinterval)
+ - [setImmediate](#setimmediate)
+ - [iterable DOM collections](#iterable-dom-collections)
+ - [Non-standard](#non-standard)
+ - [Object](#object)
+ - [Dict](#dict)
+ - [partial application](#partial-application)
+ - [Number Iterator](#number-iterator)
+ - [escaping strings](#escaping-strings)
+ - [delay](#delay)
+ - [helpers for iterators](#helpers-for-iterators)
+- [Missing polyfills](#missing-polyfills)
+- [Changelog](./CHANGELOG.md)
+
+## Usage
+### Basic
+```
+npm i core-js
+bower install core.js
+```
+
+```js
+// Default
+require('core-js');
+// Without global namespace pollution
+var core = require('core-js/library');
+// Shim only
+require('core-js/shim');
+```
+If you need complete build for browser, use builds from `core-js/client` path:
+
+* [default](https://raw.githack.com/zloirock/core-js/v2.6.12/client/core.min.js): Includes all features, standard and non-standard.
+* [as a library](https://raw.githack.com/zloirock/core-js/v2.6.12/client/library.min.js): Like "default", but does not pollute the global namespace (see [2nd example at the top](#core-js)).
+* [shim only](https://raw.githack.com/zloirock/core-js/v2.6.12/client/shim.min.js): Only includes the standard methods.
+
+Warning: if you use `core-js` with the extension of native objects, require all needed `core-js` modules at the beginning of entry point of your application, otherwise, conflicts may occur.
+
+### CommonJS
+You can require only needed modules.
+
+```js
+require('core-js/fn/set');
+require('core-js/fn/array/from');
+require('core-js/fn/array/find-index');
+Array.from(new Set([1, 2, 3, 2, 1])); // => [1, 2, 3]
+[1, 2, NaN, 3, 4].findIndex(isNaN); // => 2
+
+// or, w/o global namespace pollution:
+
+var Set = require('core-js/library/fn/set');
+var from = require('core-js/library/fn/array/from');
+var findIndex = require('core-js/library/fn/array/find-index');
+from(new Set([1, 2, 3, 2, 1])); // => [1, 2, 3]
+findIndex([1, 2, NaN, 3, 4], isNaN); // => 2
+```
+Available entry points for methods / constructors, as above examples, and namespaces: for example, `core-js/es6/array` (`core-js/library/es6/array`) contains all [ES6 `Array` features](#ecmascript-6-array), `core-js/es6` (`core-js/library/es6`) contains all ES6 features.
+
+##### Caveats when using CommonJS API:
+
+* `modules` path is internal API, does not inject all required dependencies and can be changed in minor or patch releases. Use it only for a custom build and / or if you know what are you doing.
+* `core-js` is extremely modular and uses a lot of very tiny modules, because of that for usage in browsers bundle up `core-js` instead of usage loader for each file, otherwise, you will have hundreds of requests.
+
+#### CommonJS and prototype methods without global namespace pollution
+In the `library` version, we can't pollute prototypes of native constructors. Because of that, prototype methods transformed to static methods like in examples above. `babel` `runtime` transformer also can't transform them. But with transpilers we can use one more trick - [bind operator and virtual methods](https://github.com/zenparsing/es-function-bind). Special for that, available `/virtual/` entry points. Example:
+```js
+import fill from 'core-js/library/fn/array/virtual/fill';
+import findIndex from 'core-js/library/fn/array/virtual/find-index';
+
+Array(10)::fill(0).map((a, b) => b * b)::findIndex(it => it && !(it % 8)); // => 4
+
+// or
+
+import {fill, findIndex} from 'core-js/library/fn/array/virtual';
+
+Array(10)::fill(0).map((a, b) => b * b)::findIndex(it => it && !(it % 8)); // => 4
+
+```
+
+### Custom build (from the command-line)
+```
+npm i core-js && cd node_modules/core-js && npm i
+npm run grunt build:core.dict,es6 -- --blacklist=es6.promise,es6.math --library=on --path=custom uglify
+```
+Where `core.dict` and `es6` are modules (namespaces) names, which will be added to the build, `es6.promise` and `es6.math` are modules (namespaces) names, which will be excluded from the build, `--library=on` is flag for build without global namespace pollution and `custom` is target file name.
+
+Available namespaces: for example, `es6.array` contains [ES6 `Array` features](#ecmascript-6-array), `es6` contains all modules whose names start with `es6`.
+
+### Custom build (from external scripts)
+
+[`core-js-builder`](https://www.npmjs.com/package/core-js-builder) package exports a function that takes the same parameters as the `build` target from the previous section. This will conditionally include or exclude certain parts of `core-js`:
+
+```js
+require('core-js-builder')({
+ modules: ['es6', 'core.dict'], // modules / namespaces
+ blacklist: ['es6.reflect'], // blacklist of modules / namespaces, by default - empty list
+ library: false, // flag for build without global namespace pollution, by default - false
+ umd: true // use UMD wrapper for export `core` object, by default - true
+}).then(code => {
+ // ...
+}).catch(error => {
+ // ...
+});
+```
+## Supported engines
+**Tested in:**
+- Chrome 26+
+- Firefox 4+
+- Safari 5+
+- Opera 12+
+- Internet Explorer 6+ (sure, IE8- with ES3 limitations)
+- Edge
+- Android Browser 2.3+
+- iOS Safari 5.1+
+- PhantomJS 1.9 / 2.1
+- NodeJS 0.8+
+
+...and it doesn't mean `core-js` will not work in other engines, they just have not been tested.
+
+## Features:
+[*CommonJS entry points:*](#commonjs)
+```
+core-js(/library) <- all features
+core-js(/library)/shim <- only polyfills
+```
+### ECMAScript 5
+All features moved to the [`es6` namespace](#ecmascript-6), here just a list of features:
+```js
+Object
+ .create(proto | null, descriptors?) -> object
+ .getPrototypeOf(object) -> proto | null
+ .defineProperty(target, key, desc) -> target, cap for ie8-
+ .defineProperties(target, descriptors) -> target, cap for ie8-
+ .getOwnPropertyDescriptor(object, key) -> desc
+ .getOwnPropertyNames(object) -> array
+ .keys(object) -> array
+ .seal(object) -> object, cap for ie8-
+ .freeze(object) -> object, cap for ie8-
+ .preventExtensions(object) -> object, cap for ie8-
+ .isSealed(object) -> bool, cap for ie8-
+ .isFrozen(object) -> bool, cap for ie8-
+ .isExtensible(object) -> bool, cap for ie8-
+Array
+ .isArray(var) -> bool
+ #slice(start?, end?) -> array, fix for ie7-
+ #join(string = ',') -> string, fix for ie7-
+ #indexOf(var, from?) -> int
+ #lastIndexOf(var, from?) -> int
+ #every(fn(val, index, @), that) -> bool
+ #some(fn(val, index, @), that) -> bool
+ #forEach(fn(val, index, @), that) -> void
+ #map(fn(val, index, @), that) -> array
+ #filter(fn(val, index, @), that) -> array
+ #reduce(fn(memo, val, index, @), memo?) -> var
+ #reduceRight(fn(memo, val, index, @), memo?) -> var
+ #sort(fn?) -> @, fixes for some engines
+Function
+ #bind(object, ...args) -> boundFn(...args)
+String
+ #split(separator, limit) -> array
+ #trim() -> str
+RegExp
+ #toString() -> str
+Number
+ #toFixed(digits) -> string
+ #toPrecision(precision) -> string
+parseInt(str, radix) -> int
+parseFloat(str) -> num
+Date
+ .now() -> int
+ #toISOString() -> string
+ #toJSON() -> string
+```
+[*CommonJS entry points:*](#commonjs)
+```
+core-js(/library)/es5
+```
+
+### ECMAScript 6
+[*CommonJS entry points:*](#commonjs)
+```
+core-js(/library)/es6
+```
+#### ECMAScript 6: Object
+Modules [`es6.object.assign`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.object.assign.js), [`es6.object.is`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.object.is.js), [`es6.object.set-prototype-of`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.object.set-prototype-of.js) and [`es6.object.to-string`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.object.to-string.js).
+
+In ES6 most `Object` static methods should work with primitives. Modules [`es6.object.freeze`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.object.freeze.js), [`es6.object.seal`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.object.seal.js), [`es6.object.prevent-extensions`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.object.prevent-extensions.js), [`es6.object.is-frozen`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.object.is-frozen.js), [`es6.object.is-sealed`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.object.is-sealed.js), [`es6.object.is-extensible`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.object.is-extensible.js), [`es6.object.get-own-property-descriptor`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.object.get-own-property-descriptor.js), [`es6.object.get-prototype-of`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.object.get-prototype-of.js), [`es6.object.keys`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.object.keys.js) and [`es6.object.get-own-property-names`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.object.get-own-property-names.js).
+
+Just ES5 features: [`es6.object.create`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.object.create.js), [`es6.object.define-property`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.object.define-property.js) and [`es6.object.define-properties`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.object.es6.object.define-properties.js).
+```js
+Object
+ .assign(target, ...src) -> target
+ .is(a, b) -> bool
+ .setPrototypeOf(target, proto | null) -> target (required __proto__ - IE11+)
+ .create(object | null, descriptors?) -> object
+ .getPrototypeOf(var) -> object | null
+ .defineProperty(object, key, desc) -> target
+ .defineProperties(object, descriptors) -> target
+ .getOwnPropertyDescriptor(var, key) -> desc | undefined
+ .keys(var) -> array
+ .getOwnPropertyNames(var) -> array
+ .freeze(var) -> var
+ .seal(var) -> var
+ .preventExtensions(var) -> var
+ .isFrozen(var) -> bool
+ .isSealed(var) -> bool
+ .isExtensible(var) -> bool
+ #toString() -> string, ES6 fix: @@toStringTag support
+```
+[*CommonJS entry points:*](#commonjs)
+```
+core-js(/library)/es6/object
+core-js(/library)/fn/object/assign
+core-js(/library)/fn/object/is
+core-js(/library)/fn/object/set-prototype-of
+core-js(/library)/fn/object/get-prototype-of
+core-js(/library)/fn/object/create
+core-js(/library)/fn/object/define-property
+core-js(/library)/fn/object/define-properties
+core-js(/library)/fn/object/get-own-property-descriptor
+core-js(/library)/fn/object/keys
+core-js(/library)/fn/object/get-own-property-names
+core-js(/library)/fn/object/freeze
+core-js(/library)/fn/object/seal
+core-js(/library)/fn/object/prevent-extensions
+core-js(/library)/fn/object/is-frozen
+core-js(/library)/fn/object/is-sealed
+core-js(/library)/fn/object/is-extensible
+core-js/fn/object/to-string
+```
+[*Examples*](http://goo.gl/ywdwPz):
+```js
+var foo = {q: 1, w: 2}
+ , bar = {e: 3, r: 4}
+ , baz = {t: 5, y: 6};
+Object.assign(foo, bar, baz); // => foo = {q: 1, w: 2, e: 3, r: 4, t: 5, y: 6}
+
+Object.is(NaN, NaN); // => true
+Object.is(0, -0); // => false
+Object.is(42, 42); // => true
+Object.is(42, '42'); // => false
+
+function Parent(){}
+function Child(){}
+Object.setPrototypeOf(Child.prototype, Parent.prototype);
+new Child instanceof Child; // => true
+new Child instanceof Parent; // => true
+
+var O = {};
+O[Symbol.toStringTag] = 'Foo';
+'' + O; // => '[object Foo]'
+
+Object.keys('qwe'); // => ['0', '1', '2']
+Object.getPrototypeOf('qwe') === String.prototype; // => true
+```
+#### ECMAScript 6: Function
+Modules [`es6.function.name`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.function.name.js), [`es6.function.has-instance`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.function.has-instance.js). Just ES5: [`es6.function.bind`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.function.bind.js).
+```js
+Function
+ #bind(object, ...args) -> boundFn(...args)
+ #name -> string (IE9+)
+ #@@hasInstance(var) -> bool
+```
+[*CommonJS entry points:*](#commonjs)
+```
+core-js/es6/function
+core-js/fn/function/name
+core-js/fn/function/has-instance
+core-js/fn/function/bind
+core-js/fn/function/virtual/bind
+```
+[*Example*](http://goo.gl/zqu3Wp):
+```js
+(function foo(){}).name // => 'foo'
+
+console.log.bind(console, 42)(43); // => 42 43
+```
+#### ECMAScript 6: Array
+Modules [`es6.array.from`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.array.from.js), [`es6.array.of`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.array.of.js), [`es6.array.copy-within`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.array.copy-within.js), [`es6.array.fill`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.array.fill.js), [`es6.array.find`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.array.find.js), [`es6.array.find-index`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.array.find-index.js), [`es6.array.iterator`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.array.iterator.js). ES5 features with fixes: [`es6.array.is-array`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.array.is-array.js), [`es6.array.slice`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.array.slice.js), [`es6.array.join`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.array.join.js), [`es6.array.index-of`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.array.index-of.js), [`es6.array.last-index-of`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.array.last-index-of.js), [`es6.array.every`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.array.every.js), [`es6.array.some`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.array.some.js), [`es6.array.for-each`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.array.for-each.js), [`es6.array.map`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.array.map.js), [`es6.array.filter`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.array.filter.js), [`es6.array.reduce`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.array.reduce.js), [`es6.array.reduce-right`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.array.reduce-right.js), [`es6.array.sort`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.array.sort.js).
+```js
+Array
+ .from(iterable | array-like, mapFn(val, index)?, that) -> array
+ .of(...args) -> array
+ .isArray(var) -> bool
+ #copyWithin(target = 0, start = 0, end = @length) -> @
+ #fill(val, start = 0, end = @length) -> @
+ #find(fn(val, index, @), that) -> val
+ #findIndex(fn(val, index, @), that) -> index | -1
+ #values() -> iterator
+ #keys() -> iterator
+ #entries() -> iterator
+ #join(string = ',') -> string, fix for ie7-
+ #slice(start?, end?) -> array, fix for ie7-
+ #indexOf(var, from?) -> index | -1
+ #lastIndexOf(var, from?) -> index | -1
+ #every(fn(val, index, @), that) -> bool
+ #some(fn(val, index, @), that) -> bool
+ #forEach(fn(val, index, @), that) -> void
+ #map(fn(val, index, @), that) -> array
+ #filter(fn(val, index, @), that) -> array
+ #reduce(fn(memo, val, index, @), memo?) -> var
+ #reduceRight(fn(memo, val, index, @), memo?) -> var
+ #sort(fn?) -> @, invalid arguments fix
+ #@@iterator() -> iterator (values)
+ #@@unscopables -> object (cap)
+Arguments
+ #@@iterator() -> iterator (values, available only in core-js methods)
+```
+[*CommonJS entry points:*](#commonjs)
+```
+core-js(/library)/es6/array
+core-js(/library)/fn/array/from
+core-js(/library)/fn/array/of
+core-js(/library)/fn/array/is-array
+core-js(/library)/fn/array/iterator
+core-js(/library)/fn/array/copy-within
+core-js(/library)/fn/array/fill
+core-js(/library)/fn/array/find
+core-js(/library)/fn/array/find-index
+core-js(/library)/fn/array/values
+core-js(/library)/fn/array/keys
+core-js(/library)/fn/array/entries
+core-js(/library)/fn/array/slice
+core-js(/library)/fn/array/join
+core-js(/library)/fn/array/index-of
+core-js(/library)/fn/array/last-index-of
+core-js(/library)/fn/array/every
+core-js(/library)/fn/array/some
+core-js(/library)/fn/array/for-each
+core-js(/library)/fn/array/map
+core-js(/library)/fn/array/filter
+core-js(/library)/fn/array/reduce
+core-js(/library)/fn/array/reduce-right
+core-js(/library)/fn/array/sort
+core-js(/library)/fn/array/virtual/iterator
+core-js(/library)/fn/array/virtual/copy-within
+core-js(/library)/fn/array/virtual/fill
+core-js(/library)/fn/array/virtual/find
+core-js(/library)/fn/array/virtual/find-index
+core-js(/library)/fn/array/virtual/values
+core-js(/library)/fn/array/virtual/keys
+core-js(/library)/fn/array/virtual/entries
+core-js(/library)/fn/array/virtual/slice
+core-js(/library)/fn/array/virtual/join
+core-js(/library)/fn/array/virtual/index-of
+core-js(/library)/fn/array/virtual/last-index-of
+core-js(/library)/fn/array/virtual/every
+core-js(/library)/fn/array/virtual/some
+core-js(/library)/fn/array/virtual/for-each
+core-js(/library)/fn/array/virtual/map
+core-js(/library)/fn/array/virtual/filter
+core-js(/library)/fn/array/virtual/reduce
+core-js(/library)/fn/array/virtual/reduce-right
+core-js(/library)/fn/array/virtual/sort
+```
+[*Examples*](http://goo.gl/oaUFUf):
+```js
+Array.from(new Set([1, 2, 3, 2, 1])); // => [1, 2, 3]
+Array.from({0: 1, 1: 2, 2: 3, length: 3}); // => [1, 2, 3]
+Array.from('123', Number); // => [1, 2, 3]
+Array.from('123', function(it){
+ return it * it;
+}); // => [1, 4, 9]
+
+Array.of(1); // => [1]
+Array.of(1, 2, 3); // => [1, 2, 3]
+
+var array = ['a', 'b', 'c'];
+
+for(var val of array)console.log(val); // => 'a', 'b', 'c'
+for(var val of array.values())console.log(val); // => 'a', 'b', 'c'
+for(var key of array.keys())console.log(key); // => 0, 1, 2
+for(var [key, val] of array.entries()){
+ console.log(key); // => 0, 1, 2
+ console.log(val); // => 'a', 'b', 'c'
+}
+
+function isOdd(val){
+ return val % 2;
+}
+[4, 8, 15, 16, 23, 42].find(isOdd); // => 15
+[4, 8, 15, 16, 23, 42].findIndex(isOdd); // => 2
+[4, 8, 15, 16, 23, 42].find(isNaN); // => undefined
+[4, 8, 15, 16, 23, 42].findIndex(isNaN); // => -1
+
+Array(5).fill(42); // => [42, 42, 42, 42, 42]
+
+[1, 2, 3, 4, 5].copyWithin(0, 3); // => [4, 5, 3, 4, 5]
+```
+#### ECMAScript 6: String
+Modules [`es6.string.from-code-point`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.string.from-code-point.js), [`es6.string.raw`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.string.raw.js), [`es6.string.iterator`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.string.iterator.js), [`es6.string.code-point-at`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.string.code-point-at.js), [`es6.string.ends-with`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.string.ends-with.js), [`es6.string.includes`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.string.includes.js), [`es6.string.repeat`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.string.repeat.js), [`es6.string.starts-with`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.string.starts-with.js) and [`es6.string.trim`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.string.trim.js).
+
+Annex B HTML methods. Ugly, but it's also the part of the spec. Modules [`es6.string.anchor`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.string.anchor.js), [`es6.string.big`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.string.big.js), [`es6.string.blink`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.string.blink.js), [`es6.string.bold`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.string.bold.js), [`es6.string.fixed`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.string.fixed.js), [`es6.string.fontcolor`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.string.fontcolor.js), [`es6.string.fontsize`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.string.fontsize.js), [`es6.string.italics`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.string.italics.js), [`es6.string.link`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.string.link.js), [`es6.string.small`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.string.small.js), [`es6.string.strike`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.string.strike.js), [`es6.string.sub`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.string.sub.js) and [`es6.string.sup`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.string.sup.js).
+```js
+String
+ .fromCodePoint(...codePoints) -> str
+ .raw({raw}, ...substitutions) -> str
+ #includes(str, from?) -> bool
+ #startsWith(str, from?) -> bool
+ #endsWith(str, from?) -> bool
+ #repeat(num) -> str
+ #codePointAt(pos) -> uint
+ #trim() -> str, ES6 fix
+ #anchor(name) -> str
+ #big() -> str
+ #blink() -> str
+ #bold() -> str
+ #fixed() -> str
+ #fontcolor(color) -> str
+ #fontsize(size) -> str
+ #italics() -> str
+ #link(url) -> str
+ #small() -> str
+ #strike() -> str
+ #sub() -> str
+ #sup() -> str
+ #@@iterator() -> iterator (code points)
+```
+[*CommonJS entry points:*](#commonjs)
+```
+core-js(/library)/es6/string
+core-js(/library)/fn/string/from-code-point
+core-js(/library)/fn/string/raw
+core-js(/library)/fn/string/includes
+core-js(/library)/fn/string/starts-with
+core-js(/library)/fn/string/ends-with
+core-js(/library)/fn/string/repeat
+core-js(/library)/fn/string/code-point-at
+core-js(/library)/fn/string/trim
+core-js(/library)/fn/string/anchor
+core-js(/library)/fn/string/big
+core-js(/library)/fn/string/blink
+core-js(/library)/fn/string/bold
+core-js(/library)/fn/string/fixed
+core-js(/library)/fn/string/fontcolor
+core-js(/library)/fn/string/fontsize
+core-js(/library)/fn/string/italics
+core-js(/library)/fn/string/link
+core-js(/library)/fn/string/small
+core-js(/library)/fn/string/strike
+core-js(/library)/fn/string/sub
+core-js(/library)/fn/string/sup
+core-js(/library)/fn/string/iterator
+core-js(/library)/fn/string/virtual/includes
+core-js(/library)/fn/string/virtual/starts-with
+core-js(/library)/fn/string/virtual/ends-with
+core-js(/library)/fn/string/virtual/repeat
+core-js(/library)/fn/string/virtual/code-point-at
+core-js(/library)/fn/string/virtual/trim
+core-js(/library)/fn/string/virtual/anchor
+core-js(/library)/fn/string/virtual/big
+core-js(/library)/fn/string/virtual/blink
+core-js(/library)/fn/string/virtual/bold
+core-js(/library)/fn/string/virtual/fixed
+core-js(/library)/fn/string/virtual/fontcolor
+core-js(/library)/fn/string/virtual/fontsize
+core-js(/library)/fn/string/virtual/italics
+core-js(/library)/fn/string/virtual/link
+core-js(/library)/fn/string/virtual/small
+core-js(/library)/fn/string/virtual/strike
+core-js(/library)/fn/string/virtual/sub
+core-js(/library)/fn/string/virtual/sup
+core-js(/library)/fn/string/virtual/iterator
+```
+[*Examples*](http://goo.gl/3UaQ93):
+```js
+for(var val of 'a𠮷b'){
+ console.log(val); // => 'a', '𠮷', 'b'
+}
+
+'foobarbaz'.includes('bar'); // => true
+'foobarbaz'.includes('bar', 4); // => false
+'foobarbaz'.startsWith('foo'); // => true
+'foobarbaz'.startsWith('bar', 3); // => true
+'foobarbaz'.endsWith('baz'); // => true
+'foobarbaz'.endsWith('bar', 6); // => true
+
+'string'.repeat(3); // => 'stringstringstring'
+
+'𠮷'.codePointAt(0); // => 134071
+String.fromCodePoint(97, 134071, 98); // => 'a𠮷b'
+
+var name = 'Bob';
+String.raw`Hi\n${name}!`; // => 'Hi\\nBob!' (ES6 template string syntax)
+String.raw({raw: 'test'}, 0, 1, 2); // => 't0e1s2t'
+
+'foo'.bold(); // => 'foo'
+'bar'.anchor('a"b'); // => 'bar'
+'baz'.link('http://example.com'); // => 'baz'
+```
+#### ECMAScript 6: RegExp
+Modules [`es6.regexp.constructor`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.regexp.constructor.js) and [`es6.regexp.flags`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.regexp.flags.js).
+
+Support well-known [symbols](#ecmascript-6-symbol) `@@match`, `@@replace`, `@@search` and `@@split`, modules [`es6.regexp.match`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.regexp.match.js), [`es6.regexp.replace`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.regexp.replace.js), [`es6.regexp.search`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.regexp.search.js) and [`es6.regexp.split`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.regexp.split.js).
+```
+[new] RegExp(pattern, flags?) -> regexp, ES6 fix: can alter flags (IE9+)
+ #flags -> str (IE9+)
+ #toString() -> str, ES6 fixes
+ #@@match(str) -> array | null
+ #@@replace(str, replacer) -> string
+ #@@search(str) -> index
+ #@@split(str, limit) -> array
+String
+ #match(tpl) -> var, ES6 fix for support @@match
+ #replace(tpl, replacer) -> var, ES6 fix for support @@replace
+ #search(tpl) -> var, ES6 fix for support @@search
+ #split(tpl, limit) -> var, ES6 fix for support @@split, some fixes for old engines
+```
+[*CommonJS entry points:*](#commonjs)
+```
+core-js/es6/regexp
+core-js/fn/regexp/constructor
+core-js(/library)/fn/regexp/flags
+core-js/fn/regexp/to-string
+core-js/fn/regexp/match
+core-js/fn/regexp/replace
+core-js/fn/regexp/search
+core-js/fn/regexp/split
+```
+[*Examples*](http://goo.gl/PiJxBD):
+```js
+RegExp(/./g, 'm'); // => /./m
+
+/foo/.flags; // => ''
+/foo/gim.flags; // => 'gim'
+
+'foo'.match({[Symbol.match]: _ => 1}); // => 1
+'foo'.replace({[Symbol.replace]: _ => 2}); // => 2
+'foo'.search({[Symbol.search]: _ => 3}); // => 3
+'foo'.split({[Symbol.split]: _ => 4}); // => 4
+
+RegExp.prototype.toString.call({source: 'foo', flags: 'bar'}); // => '/foo/bar'
+```
+#### ECMAScript 6: Number
+Module [`es6.number.constructor`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.number.constructor.js). `Number` constructor support binary and octal literals, [*example*](http://goo.gl/jRd6b3):
+```js
+Number('0b1010101'); // => 85
+Number('0o7654321'); // => 2054353
+```
+Modules [`es6.number.epsilon`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.number.epsilon.js), [`es6.number.is-finite`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.number.is-finite.js), [`es6.number.is-integer`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.number.is-integer.js), [`es6.number.is-nan`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.number.is-nan.js), [`es6.number.is-safe-integer`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.number.is-safe-integer.js), [`es6.number.max-safe-integer`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.number.max-safe-integer.js), [`es6.number.min-safe-integer`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.number.min-safe-integer.js), [`es6.number.parse-float`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.number.parse-float.js), [`es6.number.parse-int`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.number.parse-int.js), [`es6.number.to-fixed`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.number.to-fixed.js), [`es6.number.to-precision`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.number.to-precision.js), [`es6.parse-int`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.parse-int.js), [`es6.parse-float`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.parse-float.js).
+```js
+[new] Number(var) -> number | number object
+ .isFinite(num) -> bool
+ .isNaN(num) -> bool
+ .isInteger(num) -> bool
+ .isSafeInteger(num) -> bool
+ .parseFloat(str) -> num
+ .parseInt(str) -> int
+ .EPSILON -> num
+ .MAX_SAFE_INTEGER -> int
+ .MIN_SAFE_INTEGER -> int
+ #toFixed(digits) -> string, fixes
+ #toPrecision(precision) -> string, fixes
+parseFloat(str) -> num, fixes
+parseInt(str) -> int, fixes
+```
+[*CommonJS entry points:*](#commonjs)
+```
+core-js(/library)/es6/number
+core-js/es6/number/constructor
+core-js(/library)/fn/number/is-finite
+core-js(/library)/fn/number/is-nan
+core-js(/library)/fn/number/is-integer
+core-js(/library)/fn/number/is-safe-integer
+core-js(/library)/fn/number/parse-float
+core-js(/library)/fn/number/parse-int
+core-js(/library)/fn/number/epsilon
+core-js(/library)/fn/number/max-safe-integer
+core-js(/library)/fn/number/min-safe-integer
+core-js(/library)/fn/number/to-fixed
+core-js(/library)/fn/number/to-precision
+core-js(/library)/fn/parse-float
+core-js(/library)/fn/parse-int
+```
+#### ECMAScript 6: Math
+Modules [`es6.math.acosh`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.math.acosh.js), [`es6.math.asinh`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.math.asinh.js), [`es6.math.atanh`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.math.atanh.js), [`es6.math.cbrt`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.math.cbrt.js), [`es6.math.clz32`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.math.clz32.js), [`es6.math.cosh`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.math.cosh.js), [`es6.math.expm1`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.math.expm1.js), [`es6.math.fround`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.math.fround.js), [`es6.math.hypot`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.math.hypot.js), [`es6.math.imul`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.math.imul.js), [`es6.math.log10`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.math.log10.js), [`es6.math.log1p`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.math.log1p.js), [`es6.math.log2`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.math.log2.js), [`es6.math.sign`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.math.sign.js), [`es6.math.sinh`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.math.sinh.js), [`es6.math.tanh`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.math.tanh.js), [`es6.math.trunc`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.math.trunc.js).
+```js
+Math
+ .acosh(num) -> num
+ .asinh(num) -> num
+ .atanh(num) -> num
+ .cbrt(num) -> num
+ .clz32(num) -> uint
+ .cosh(num) -> num
+ .expm1(num) -> num
+ .fround(num) -> num
+ .hypot(...args) -> num
+ .imul(num, num) -> int
+ .log1p(num) -> num
+ .log10(num) -> num
+ .log2(num) -> num
+ .sign(num) -> 1 | -1 | 0 | -0 | NaN
+ .sinh(num) -> num
+ .tanh(num) -> num
+ .trunc(num) -> num
+```
+[*CommonJS entry points:*](#commonjs)
+```
+core-js(/library)/es6/math
+core-js(/library)/fn/math/acosh
+core-js(/library)/fn/math/asinh
+core-js(/library)/fn/math/atanh
+core-js(/library)/fn/math/cbrt
+core-js(/library)/fn/math/clz32
+core-js(/library)/fn/math/cosh
+core-js(/library)/fn/math/expm1
+core-js(/library)/fn/math/fround
+core-js(/library)/fn/math/hypot
+core-js(/library)/fn/math/imul
+core-js(/library)/fn/math/log1p
+core-js(/library)/fn/math/log10
+core-js(/library)/fn/math/log2
+core-js(/library)/fn/math/sign
+core-js(/library)/fn/math/sinh
+core-js(/library)/fn/math/tanh
+core-js(/library)/fn/math/trunc
+```
+#### ECMAScript 6: Date
+Modules [`es6.date.to-string`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.date.to-string.js), ES5 features with fixes: [`es6.date.now`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.date.now.js), [`es6.date.to-iso-string`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.date.to-iso-string.js), [`es6.date.to-json`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.date.to-json.js) and [`es6.date.to-primitive`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.date.to-primitive.js).
+```js
+Date
+ .now() -> int
+ #toISOString() -> string
+ #toJSON() -> string
+ #toString() -> string
+ #@@toPrimitive(hint) -> primitive
+```
+[*CommonJS entry points:*](#commonjs)
+```
+core-js/es6/date
+core-js/fn/date/to-string
+core-js(/library)/fn/date/now
+core-js(/library)/fn/date/to-iso-string
+core-js(/library)/fn/date/to-json
+core-js(/library)/fn/date/to-primitive
+```
+[*Example*](http://goo.gl/haeHLR):
+```js
+new Date(NaN).toString(); // => 'Invalid Date'
+```
+
+#### ECMAScript 6: Promise
+Module [`es6.promise`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.promise.js).
+```js
+new Promise(executor(resolve(var), reject(var))) -> promise
+ #then(resolved(var), rejected(var)) -> promise
+ #catch(rejected(var)) -> promise
+ .resolve(promise | var) -> promise
+ .reject(var) -> promise
+ .all(iterable) -> promise
+ .race(iterable) -> promise
+```
+[*CommonJS entry points:*](#commonjs)
+```
+core-js(/library)/es6/promise
+core-js(/library)/fn/promise
+```
+Basic [*example*](http://goo.gl/vGrtUC):
+```js
+function sleepRandom(time){
+ return new Promise(function(resolve, reject){
+ setTimeout(resolve, time * 1e3, 0 | Math.random() * 1e3);
+ });
+}
+
+console.log('Run'); // => Run
+sleepRandom(5).then(function(result){
+ console.log(result); // => 869, after 5 sec.
+ return sleepRandom(10);
+}).then(function(result){
+ console.log(result); // => 202, after 10 sec.
+}).then(function(){
+ console.log('immediately after'); // => immediately after
+ throw Error('Irror!');
+}).then(function(){
+ console.log('will not be displayed');
+}).catch(x => console.log(x)); // => => Error: Irror!
+```
+`Promise.resolve` and `Promise.reject` [*example*](http://goo.gl/vr8TN3):
+```js
+Promise.resolve(42).then(x => console.log(x)); // => 42
+Promise.reject(42).catch(x => console.log(x)); // => 42
+
+Promise.resolve($.getJSON('/data.json')); // => ES6 promise
+```
+`Promise.all` [*example*](http://goo.gl/RdoDBZ):
+```js
+Promise.all([
+ 'foo',
+ sleepRandom(5),
+ sleepRandom(15),
+ sleepRandom(10) // after 15 sec:
+]).then(x => console.log(x)); // => ['foo', 956, 85, 382]
+```
+`Promise.race` [*example*](http://goo.gl/L8ovkJ):
+```js
+function timeLimit(promise, time){
+ return Promise.race([promise, new Promise(function(resolve, reject){
+ setTimeout(reject, time * 1e3, Error('Await > ' + time + ' sec'));
+ })]);
+}
+
+timeLimit(sleepRandom(5), 10).then(x => console.log(x)); // => 853, after 5 sec.
+timeLimit(sleepRandom(15), 10).catch(x => console.log(x)); // Error: Await > 10 sec
+```
+ECMAScript 7 [async functions](https://tc39.github.io/ecmascript-asyncawait) [example](http://goo.gl/wnQS4j):
+```js
+var delay = time => new Promise(resolve => setTimeout(resolve, time))
+
+async function sleepRandom(time){
+ await delay(time * 1e3);
+ return 0 | Math.random() * 1e3;
+};
+async function sleepError(time, msg){
+ await delay(time * 1e3);
+ throw Error(msg);
+};
+
+(async () => {
+ try {
+ console.log('Run'); // => Run
+ console.log(await sleepRandom(5)); // => 936, after 5 sec.
+ var [a, b, c] = await Promise.all([
+ sleepRandom(5),
+ sleepRandom(15),
+ sleepRandom(10)
+ ]);
+ console.log(a, b, c); // => 210 445 71, after 15 sec.
+ await sleepError(5, 'Irror!');
+ console.log('Will not be displayed');
+ } catch(e){
+ console.log(e); // => Error: 'Irror!', after 5 sec.
+ }
+})();
+```
+
+##### Unhandled rejection tracking
+
+In Node.js, like in native implementation, available events [`unhandledRejection`](https://nodejs.org/api/process.html#process_event_unhandledrejection) and [`rejectionHandled`](https://nodejs.org/api/process.html#process_event_rejectionhandled):
+```js
+process.on('unhandledRejection', (reason, promise) => console.log('unhandled', reason, promise));
+process.on('rejectionHandled', (promise) => console.log('handled', promise));
+
+var p = Promise.reject(42);
+// unhandled 42 [object Promise]
+
+setTimeout(() => p.catch(_ => _), 1e3);
+// handled [object Promise]
+```
+In a browser on rejection, by default, you will see notify in the console, or you can add a custom handler and a handler on handling unhandled, [*example*](http://goo.gl/Wozskl):
+```js
+window.onunhandledrejection = e => console.log('unhandled', e.reason, e.promise);
+window.onrejectionhandled = e => console.log('handled', e.reason, e.promise);
+
+var p = Promise.reject(42);
+// unhandled 42 [object Promise]
+
+setTimeout(() => p.catch(_ => _), 1e3);
+// handled 42 [object Promise]
+```
+
+#### ECMAScript 6: Symbol
+Module [`es6.symbol`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.symbol.js).
+```js
+Symbol(description?) -> symbol
+ .hasInstance -> @@hasInstance
+ .isConcatSpreadable -> @@isConcatSpreadable
+ .iterator -> @@iterator
+ .match -> @@match
+ .replace -> @@replace
+ .search -> @@search
+ .species -> @@species
+ .split -> @@split
+ .toPrimitive -> @@toPrimitive
+ .toStringTag -> @@toStringTag
+ .unscopables -> @@unscopables
+ .for(key) -> symbol
+ .keyFor(symbol) -> key
+ .useSimple() -> void
+ .useSetter() -> void
+Object
+ .getOwnPropertySymbols(object) -> array
+```
+Also wrapped some methods for correct work with `Symbol` polyfill.
+```js
+Object
+ .create(proto | null, descriptors?) -> object
+ .defineProperty(target, key, desc) -> target
+ .defineProperties(target, descriptors) -> target
+ .getOwnPropertyDescriptor(var, key) -> desc | undefined
+ .getOwnPropertyNames(var) -> array
+ #propertyIsEnumerable(key) -> bool
+JSON
+ .stringify(target, replacer?, space?) -> string | undefined
+```
+[*CommonJS entry points:*](#commonjs)
+```
+core-js(/library)/es6/symbol
+core-js(/library)/fn/symbol
+core-js(/library)/fn/symbol/has-instance
+core-js(/library)/fn/symbol/is-concat-spreadable
+core-js(/library)/fn/symbol/iterator
+core-js(/library)/fn/symbol/match
+core-js(/library)/fn/symbol/replace
+core-js(/library)/fn/symbol/search
+core-js(/library)/fn/symbol/species
+core-js(/library)/fn/symbol/split
+core-js(/library)/fn/symbol/to-primitive
+core-js(/library)/fn/symbol/to-string-tag
+core-js(/library)/fn/symbol/unscopables
+core-js(/library)/fn/symbol/for
+core-js(/library)/fn/symbol/key-for
+```
+[*Basic example*](http://goo.gl/BbvWFc):
+```js
+var Person = (function(){
+ var NAME = Symbol('name');
+ function Person(name){
+ this[NAME] = name;
+ }
+ Person.prototype.getName = function(){
+ return this[NAME];
+ };
+ return Person;
+})();
+
+var person = new Person('Vasya');
+console.log(person.getName()); // => 'Vasya'
+console.log(person['name']); // => undefined
+console.log(person[Symbol('name')]); // => undefined, symbols are uniq
+for(var key in person)console.log(key); // => only 'getName', symbols are not enumerable
+```
+`Symbol.for` & `Symbol.keyFor` [*example*](http://goo.gl/0pdJjX):
+```js
+var symbol = Symbol.for('key');
+symbol === Symbol.for('key'); // true
+Symbol.keyFor(symbol); // 'key'
+```
+[*Example*](http://goo.gl/mKVOQJ) with methods for getting own object keys:
+```js
+var O = {a: 1};
+Object.defineProperty(O, 'b', {value: 2});
+O[Symbol('c')] = 3;
+Object.keys(O); // => ['a']
+Object.getOwnPropertyNames(O); // => ['a', 'b']
+Object.getOwnPropertySymbols(O); // => [Symbol(c)]
+Reflect.ownKeys(O); // => ['a', 'b', Symbol(c)]
+```
+##### Caveats when using `Symbol` polyfill:
+
+* We can't add new primitive type, `Symbol` returns object.
+* `Symbol.for` and `Symbol.keyFor` can't be shimmed cross-realm.
+* By default, to hide the keys, `Symbol` polyfill defines setter in `Object.prototype`. For this reason, uncontrolled creation of symbols can cause memory leak and the `in` operator is not working correctly with `Symbol` polyfill: `Symbol() in {} // => true`.
+
+You can disable defining setters in `Object.prototype`. [Example](http://goo.gl/N5UD7J):
+```js
+Symbol.useSimple();
+var s1 = Symbol('s1')
+ , o1 = {};
+o1[s1] = true;
+for(var key in o1)console.log(key); // => 'Symbol(s1)_t.qamkg9f3q', w/o native Symbol
+
+Symbol.useSetter();
+var s2 = Symbol('s2')
+ , o2 = {};
+o2[s2] = true;
+for(var key in o2)console.log(key); // nothing
+```
+* Currently, `core-js` not adds setters to `Object.prototype` for well-known symbols for correct work something like `Symbol.iterator in foo`. It can cause problems with their enumerability.
+* Some problems possible with environment exotic objects (for example, IE `localStorage`).
+
+#### ECMAScript 6: Collections
+`core-js` uses native collections in most case, just fixes methods / constructor, if it's required, and in old environment uses fast polyfill (O(1) lookup).
+#### Map
+Module [`es6.map`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.map.js).
+```js
+new Map(iterable (entries) ?) -> map
+ #clear() -> void
+ #delete(key) -> bool
+ #forEach(fn(val, key, @), that) -> void
+ #get(key) -> val
+ #has(key) -> bool
+ #set(key, val) -> @
+ #size -> uint
+ #values() -> iterator
+ #keys() -> iterator
+ #entries() -> iterator
+ #@@iterator() -> iterator (entries)
+```
+[*CommonJS entry points:*](#commonjs)
+```
+core-js(/library)/es6/map
+core-js(/library)/fn/map
+```
+[*Examples*](http://goo.gl/GWR7NI):
+```js
+var a = [1];
+
+var map = new Map([['a', 1], [42, 2]]);
+map.set(a, 3).set(true, 4);
+
+console.log(map.size); // => 4
+console.log(map.has(a)); // => true
+console.log(map.has([1])); // => false
+console.log(map.get(a)); // => 3
+map.forEach(function(val, key){
+ console.log(val); // => 1, 2, 3, 4
+ console.log(key); // => 'a', 42, [1], true
+});
+map.delete(a);
+console.log(map.size); // => 3
+console.log(map.get(a)); // => undefined
+console.log(Array.from(map)); // => [['a', 1], [42, 2], [true, 4]]
+
+var map = new Map([['a', 1], ['b', 2], ['c', 3]]);
+
+for(var [key, val] of map){
+ console.log(key); // => 'a', 'b', 'c'
+ console.log(val); // => 1, 2, 3
+}
+for(var val of map.values())console.log(val); // => 1, 2, 3
+for(var key of map.keys())console.log(key); // => 'a', 'b', 'c'
+for(var [key, val] of map.entries()){
+ console.log(key); // => 'a', 'b', 'c'
+ console.log(val); // => 1, 2, 3
+}
+```
+#### Set
+Module [`es6.set`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.set.js).
+```js
+new Set(iterable?) -> set
+ #add(key) -> @
+ #clear() -> void
+ #delete(key) -> bool
+ #forEach(fn(el, el, @), that) -> void
+ #has(key) -> bool
+ #size -> uint
+ #values() -> iterator
+ #keys() -> iterator
+ #entries() -> iterator
+ #@@iterator() -> iterator (values)
+```
+[*CommonJS entry points:*](#commonjs)
+```
+core-js(/library)/es6/set
+core-js(/library)/fn/set
+```
+[*Examples*](http://goo.gl/bmhLwg):
+```js
+var set = new Set(['a', 'b', 'a', 'c']);
+set.add('d').add('b').add('e');
+console.log(set.size); // => 5
+console.log(set.has('b')); // => true
+set.forEach(function(it){
+ console.log(it); // => 'a', 'b', 'c', 'd', 'e'
+});
+set.delete('b');
+console.log(set.size); // => 4
+console.log(set.has('b')); // => false
+console.log(Array.from(set)); // => ['a', 'c', 'd', 'e']
+
+var set = new Set([1, 2, 3, 2, 1]);
+
+for(var val of set)console.log(val); // => 1, 2, 3
+for(var val of set.values())console.log(val); // => 1, 2, 3
+for(var key of set.keys())console.log(key); // => 1, 2, 3
+for(var [key, val] of set.entries()){
+ console.log(key); // => 1, 2, 3
+ console.log(val); // => 1, 2, 3
+}
+```
+#### WeakMap
+Module [`es6.weak-map`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.weak-map.js).
+```js
+new WeakMap(iterable (entries) ?) -> weakmap
+ #delete(key) -> bool
+ #get(key) -> val
+ #has(key) -> bool
+ #set(key, val) -> @
+```
+[*CommonJS entry points:*](#commonjs)
+```
+core-js(/library)/es6/weak-map
+core-js(/library)/fn/weak-map
+```
+[*Examples*](http://goo.gl/SILXyw):
+```js
+var a = [1]
+ , b = [2]
+ , c = [3];
+
+var wmap = new WeakMap([[a, 1], [b, 2]]);
+wmap.set(c, 3).set(b, 4);
+console.log(wmap.has(a)); // => true
+console.log(wmap.has([1])); // => false
+console.log(wmap.get(a)); // => 1
+wmap.delete(a);
+console.log(wmap.get(a)); // => undefined
+
+// Private properties store:
+var Person = (function(){
+ var names = new WeakMap;
+ function Person(name){
+ names.set(this, name);
+ }
+ Person.prototype.getName = function(){
+ return names.get(this);
+ };
+ return Person;
+})();
+
+var person = new Person('Vasya');
+console.log(person.getName()); // => 'Vasya'
+for(var key in person)console.log(key); // => only 'getName'
+```
+#### WeakSet
+Module [`es6.weak-set`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.weak-set.js).
+```js
+new WeakSet(iterable?) -> weakset
+ #add(key) -> @
+ #delete(key) -> bool
+ #has(key) -> bool
+```
+[*CommonJS entry points:*](#commonjs)
+```
+core-js(/library)/es6/weak-set
+core-js(/library)/fn/weak-set
+```
+[*Examples*](http://goo.gl/TdFbEx):
+```js
+var a = [1]
+ , b = [2]
+ , c = [3];
+
+var wset = new WeakSet([a, b, a]);
+wset.add(c).add(b).add(c);
+console.log(wset.has(b)); // => true
+console.log(wset.has([2])); // => false
+wset.delete(b);
+console.log(wset.has(b)); // => false
+```
+##### Caveats when using collections polyfill:
+
+* Weak-collections polyfill stores values as hidden properties of keys. It works correct and not leak in most cases. However, it is desirable to store a collection longer than its keys.
+
+#### ECMAScript 6: Typed Arrays
+Implementations and fixes `ArrayBuffer`, `DataView`, typed arrays constructors, static and prototype methods. Typed Arrays work only in environments with support descriptors (IE9+), `ArrayBuffer` and `DataView` should work anywhere.
+
+Modules [`es6.typed.array-buffer`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.typed.array-buffer.js), [`es6.typed.data-view`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.typed.data-view.js), [`es6.typed.int8-array`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.typed.int8-array.js), [`es6.typed.uint8-array`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.typed.uint8-array.js), [`es6.typed.uint8-clamped-array`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.typed.uint8-clamped-array.js), [`es6.typed.int16-array`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.typed.int16-array.js), [`es6.typed.uint16-array`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.typed.uint16-array.js), [`es6.typed.int32-array`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.typed.int32-array.js), [`es6.typed.uint32-array`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.typed.uint32-array.js), [`es6.typed.float32-array`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.typed.float32-array.js) and [`es6.typed.float64-array`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.typed.float64-array.js).
+```js
+new ArrayBuffer(length) -> buffer
+ .isView(var) -> bool
+ #slice(start = 0, end = @length) -> buffer
+ #byteLength -> uint
+
+new DataView(buffer, byteOffset = 0, byteLength = buffer.byteLength - byteOffset) -> view
+ #getInt8(offset) -> int8
+ #getUint8(offset) -> uint8
+ #getInt16(offset, littleEndian = false) -> int16
+ #getUint16(offset, littleEndian = false) -> uint16
+ #getInt32(offset, littleEndian = false) -> int32
+ #getUint32(offset, littleEndian = false) -> uint32
+ #getFloat32(offset, littleEndian = false) -> float32
+ #getFloat64(offset, littleEndian = false) -> float64
+ #setInt8(offset, value) -> void
+ #setUint8(offset, value) -> void
+ #setInt16(offset, value, littleEndian = false) -> void
+ #setUint16(offset, value, littleEndian = false) -> void
+ #setInt32(offset, value, littleEndian = false) -> void
+ #setUint32(offset, value, littleEndian = false) -> void
+ #setFloat32(offset, value, littleEndian = false) -> void
+ #setFloat64(offset, value, littleEndian = false) -> void
+ #buffer -> buffer
+ #byteLength -> uint
+ #byteOffset -> uint
+
+{
+ Int8Array,
+ Uint8Array,
+ Uint8ClampedArray,
+ Int16Array,
+ Uint16Array,
+ Int32Array,
+ Uint32Array,
+ Float32Array,
+ Float64Array
+}
+ new %TypedArray%(length) -> typed
+ new %TypedArray%(typed) -> typed
+ new %TypedArray%(arrayLike) -> typed
+ new %TypedArray%(iterable) -> typed
+ new %TypedArray%(buffer, byteOffset = 0, length = (buffer.byteLength - byteOffset) / @BYTES_PER_ELEMENT) -> typed
+ .BYTES_PER_ELEMENT -> uint
+ .from(arrayLike | iterable, mapFn(val, index)?, that) -> typed
+ .of(...args) -> typed
+ #BYTES_PER_ELEMENT -> uint
+ #copyWithin(target = 0, start = 0, end = @length) -> @
+ #every(fn(val, index, @), that) -> bool
+ #fill(val, start = 0, end = @length) -> @
+ #filter(fn(val, index, @), that) -> typed
+ #find(fn(val, index, @), that) -> val
+ #findIndex(fn(val, index, @), that) -> index
+ #forEach(fn(val, index, @), that) -> void
+ #indexOf(var, from?) -> int
+ #join(string = ',') -> string
+ #lastIndexOf(var, from?) -> int
+ #map(fn(val, index, @), that) -> typed
+ #reduce(fn(memo, val, index, @), memo?) -> var
+ #reduceRight(fn(memo, val, index, @), memo?) -> var
+ #reverse() -> @
+ #set(arrayLike, offset = 0) -> void
+ #slice(start = 0, end = @length) -> typed
+ #some(fn(val, index, @), that) -> bool
+ #sort(fn(a, b)?) -> @
+ #subarray(start = 0, end = @length) -> typed
+ #toString() -> string
+ #toLocaleString() -> string
+ #values() -> iterator
+ #keys() -> iterator
+ #entries() -> iterator
+ #@@iterator() -> iterator (values)
+ #buffer -> buffer
+ #byteLength -> uint
+ #byteOffset -> uint
+ #length -> uint
+```
+[*CommonJS entry points:*](#commonjs)
+```
+core-js(/library)/es6/typed
+core-js(/library)/fn/typed
+core-js(/library)/fn/typed/array-buffer
+core-js(/library)/fn/typed/data-view
+core-js(/library)/fn/typed/int8-array
+core-js(/library)/fn/typed/uint8-array
+core-js(/library)/fn/typed/uint8-clamped-array
+core-js(/library)/fn/typed/int16-array
+core-js(/library)/fn/typed/uint16-array
+core-js(/library)/fn/typed/int32-array
+core-js(/library)/fn/typed/uint32-array
+core-js(/library)/fn/typed/float32-array
+core-js(/library)/fn/typed/float64-array
+```
+[*Examples*](http://goo.gl/yla75z):
+```js
+new Int32Array(4); // => [0, 0, 0, 0]
+new Uint8ClampedArray([1, 2, 3, 666]); // => [1, 2, 3, 255]
+new Float32Array(new Set([1, 2, 3, 2, 1])); // => [1, 2, 3]
+
+var buffer = new ArrayBuffer(8);
+var view = new DataView(buffer);
+view.setFloat64(0, 123.456, true);
+new Uint8Array(buffer.slice(4)); // => [47, 221, 94, 64]
+
+Int8Array.of(1, 1.5, 5.7, 745); // => [1, 1, 5, -23]
+Uint8Array.from([1, 1.5, 5.7, 745]); // => [1, 1, 5, 233]
+
+var typed = new Uint8Array([1, 2, 3]);
+
+var a = typed.slice(1); // => [2, 3]
+typed.buffer === a.buffer; // => false
+var b = typed.subarray(1); // => [2, 3]
+typed.buffer === b.buffer; // => true
+
+typed.filter(it => it % 2); // => [1, 3]
+typed.map(it => it * 1.5); // => [1, 3, 4]
+
+for(var val of typed)console.log(val); // => 1, 2, 3
+for(var val of typed.values())console.log(val); // => 1, 2, 3
+for(var key of typed.keys())console.log(key); // => 0, 1, 2
+for(var [key, val] of typed.entries()){
+ console.log(key); // => 0, 1, 2
+ console.log(val); // => 1, 2, 3
+}
+```
+##### Caveats when using typed arrays:
+
+* Typed Arrays polyfills works completely how should work by the spec, but because of internal use getter / setters on each instance, is slow and consumes significant memory. However, typed arrays polyfills required mainly for IE9 (and for `Uint8ClampedArray` in IE10 and early IE11), all modern engines have native typed arrays and requires only constructors fixes and methods.
+* The current version hasn't special entry points for methods, they can be added only with constructors. It can be added in the future.
+* In the `library` version we can't pollute native prototypes, so prototype methods available as constructors static.
+
+#### ECMAScript 6: Reflect
+Modules [`es6.reflect.apply`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.reflect.apply.js), [`es6.reflect.construct`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.reflect.construct.js), [`es6.reflect.define-property`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.reflect.define-property.js), [`es6.reflect.delete-property`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.reflect.delete-property.js), [`es6.reflect.enumerate`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.reflect.enumerate.js), [`es6.reflect.get`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.reflect.get.js), [`es6.reflect.get-own-property-descriptor`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.reflect.get-own-property-descriptor.js), [`es6.reflect.get-prototype-of`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.reflect.get-prototype-of.js), [`es6.reflect.has`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.reflect.has.js), [`es6.reflect.is-extensible`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.reflect.is-extensible.js), [`es6.reflect.own-keys`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.reflect.own-keys.js), [`es6.reflect.prevent-extensions`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.reflect.prevent-extensions.js), [`es6.reflect.set`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.reflect.set.js), [`es6.reflect.set-prototype-of`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es6.reflect.set-prototype-of.js).
+```js
+Reflect
+ .apply(target, thisArgument, argumentsList) -> var
+ .construct(target, argumentsList, newTarget?) -> object
+ .defineProperty(target, propertyKey, attributes) -> bool
+ .deleteProperty(target, propertyKey) -> bool
+ .enumerate(target) -> iterator (removed from the spec and will be removed from core-js@3)
+ .get(target, propertyKey, receiver?) -> var
+ .getOwnPropertyDescriptor(target, propertyKey) -> desc
+ .getPrototypeOf(target) -> object | null
+ .has(target, propertyKey) -> bool
+ .isExtensible(target) -> bool
+ .ownKeys(target) -> array
+ .preventExtensions(target) -> bool
+ .set(target, propertyKey, V, receiver?) -> bool
+ .setPrototypeOf(target, proto) -> bool (required __proto__ - IE11+)
+```
+[*CommonJS entry points:*](#commonjs)
+```
+core-js(/library)/es6/reflect
+core-js(/library)/fn/reflect
+core-js(/library)/fn/reflect/apply
+core-js(/library)/fn/reflect/construct
+core-js(/library)/fn/reflect/define-property
+core-js(/library)/fn/reflect/delete-property
+core-js(/library)/fn/reflect/enumerate (deprecated and will be removed from the next major release)
+core-js(/library)/fn/reflect/get
+core-js(/library)/fn/reflect/get-own-property-descriptor
+core-js(/library)/fn/reflect/get-prototype-of
+core-js(/library)/fn/reflect/has
+core-js(/library)/fn/reflect/is-extensible
+core-js(/library)/fn/reflect/own-keys
+core-js(/library)/fn/reflect/prevent-extensions
+core-js(/library)/fn/reflect/set
+core-js(/library)/fn/reflect/set-prototype-of
+```
+[*Examples*](http://goo.gl/gVT0cH):
+```js
+var O = {a: 1};
+Object.defineProperty(O, 'b', {value: 2});
+O[Symbol('c')] = 3;
+Reflect.ownKeys(O); // => ['a', 'b', Symbol(c)]
+
+function C(a, b){
+ this.c = a + b;
+}
+
+var instance = Reflect.construct(C, [20, 22]);
+instance.c; // => 42
+```
+
+### ECMAScript 7+ proposals
+[The TC39 process.](https://tc39.github.io/process-document/)
+
+[*CommonJS entry points:*](#commonjs)
+```
+core-js(/library)/es7
+core-js(/library)/es7/array
+core-js(/library)/es7/global
+core-js(/library)/es7/string
+core-js(/library)/es7/map
+core-js(/library)/es7/set
+core-js(/library)/es7/error
+core-js(/library)/es7/math
+core-js(/library)/es7/system
+core-js(/library)/es7/symbol
+core-js(/library)/es7/reflect
+core-js(/library)/es7/observable
+```
+`core-js/stage/4` entry point contains only stage 4 proposals, `core-js/stage/3` - stage 3 and stage 4, etc.
+#### Stage 4 proposals
+
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/stage/4
+```
+* `{Array, %TypedArray%}#includes` [proposal](https://github.com/tc39/Array.prototype.includes) - module [`es7.array.includes`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.array.includes.js), `%TypedArray%` version in modules from [this section](#ecmascript-6-typed-arrays).
+```js
+Array
+ #includes(var, from?) -> bool
+{
+ Int8Array,
+ Uint8Array,
+ Uint8ClampedArray,
+ Int16Array,
+ Uint16Array,
+ Int32Array,
+ Uint32Array,
+ Float32Array,
+ Float64Array
+}
+ #includes(var, from?) -> bool
+```
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/fn/array/includes
+```
+[*Examples*](http://goo.gl/2Gq4ma):
+```js
+[1, 2, 3].includes(2); // => true
+[1, 2, 3].includes(4); // => false
+[1, 2, 3].includes(2, 2); // => false
+
+[NaN].indexOf(NaN); // => -1
+[NaN].includes(NaN); // => true
+Array(1).indexOf(undefined); // => -1
+Array(1).includes(undefined); // => true
+```
+* `Object.values`, `Object.entries` [proposal](https://github.com/tc39/proposal-object-values-entries) - modules [`es7.object.values`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.object.values.js), [`es7.object.entries`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.object.entries.js)
+```js
+Object
+ .values(object) -> array
+ .entries(object) -> array
+```
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/fn/object/values
+core-js(/library)/fn/object/entries
+```
+[*Examples*](http://goo.gl/6kuGOn):
+```js
+Object.values({a: 1, b: 2, c: 3}); // => [1, 2, 3]
+Object.entries({a: 1, b: 2, c: 3}); // => [['a', 1], ['b', 2], ['c', 3]]
+
+for(let [key, value] of Object.entries({a: 1, b: 2, c: 3})){
+ console.log(key); // => 'a', 'b', 'c'
+ console.log(value); // => 1, 2, 3
+}
+```
+* `Object.getOwnPropertyDescriptors` [proposal](https://github.com/tc39/proposal-object-getownpropertydescriptors) - module [`es7.object.get-own-property-descriptors`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.object.get-own-property-descriptors.js)
+```js
+Object
+ .getOwnPropertyDescriptors(object) -> object
+```
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/fn/object/get-own-property-descriptors
+```
+*Examples*:
+```js
+// Shallow object cloning with prototype and descriptors:
+var copy = Object.create(Object.getPrototypeOf(O), Object.getOwnPropertyDescriptors(O));
+// Mixin:
+Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+```
+* `String#padStart`, `String#padEnd` [proposal](https://github.com/tc39/proposal-string-pad-start-end) - modules [`es7.string.pad-start`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.string.pad-start.js), [`es7.string.pad-end`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.string.pad-end.js)
+```js
+String
+ #padStart(length, fillStr = ' ') -> string
+ #padEnd(length, fillStr = ' ') -> string
+```
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/fn/string/pad-start
+core-js(/library)/fn/string/pad-end
+core-js(/library)/fn/string/virtual/pad-start
+core-js(/library)/fn/string/virtual/pad-end
+```
+[*Examples*](http://goo.gl/hK5ccv):
+```js
+'hello'.padStart(10); // => ' hello'
+'hello'.padStart(10, '1234'); // => '12341hello'
+'hello'.padEnd(10); // => 'hello '
+'hello'.padEnd(10, '1234'); // => 'hello12341'
+```
+* `Object#__(define|lookup)[GS]etter__`, [annex B ES2017](https://github.com/tc39/ecma262/pull/381), but we haven't special namespace for that - modules [`es7.object.define-setter`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.object.define-setter.js), [`es7.object.define-getter`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.object.define-getter.js), [`es7.object.lookup-setter`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.object.lookup-setter.js) and [`es7.object.lookup-getter`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.object.lookup-getter.js).
+```js
+Object
+ #__defineSetter__(key, fn) -> void
+ #__defineGetter__(key, fn) -> void
+ #__lookupSetter__(key) -> fn | void
+ #__lookupGetter__(key) -> fn | void
+```
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/fn/object/define-getter
+core-js(/library)/fn/object/define-setter
+core-js(/library)/fn/object/lookup-getter
+core-js(/library)/fn/object/lookup-setter
+```
+
+#### Stage 3 proposals
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/stage/3
+```
+* `global` [proposal](https://github.com/tc39/proposal-global) - modules [`es7.global`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.global.js) and [`es7.system.global`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.system.global.js) (obsolete)
+```js
+global -> object
+System
+ .global -> object (obsolete)
+```
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/fn/global
+core-js(/library)/fn/system/global (obsolete)
+```
+[*Examples*](http://goo.gl/gEqMl7):
+```js
+global.Array === Array; // => true
+```
+* `Promise#finally` [proposal](https://github.com/tc39/proposal-promise-finally) - module [`es7.promise.finally`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.promise.finally.js)
+```js
+Promise
+ #finally(onFinally()) -> promise
+```
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/fn/promise/finally
+```
+[*Examples*](https://goo.gl/AhyBbJ):
+```js
+Promise.resolve(42).finally(() => console.log('You will see it anyway'));
+
+Promise.reject(42).finally(() => console.log('You will see it anyway'));
+
+#### Stage 2 proposals
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/stage/2
+```
+* `String#trimLeft`, `String#trimRight` / `String#trimStart`, `String#trimEnd` [proposal](https://github.com/sebmarkbage/ecmascript-string-left-right-trim) - modules [`es7.string.trim-left`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.string.trim-right.js), [`es7.string.trim-right`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.string.trim-right.js)
+```js
+String
+ #trimLeft() -> string
+ #trimRight() -> string
+ #trimStart() -> string
+ #trimEnd() -> string
+```
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/fn/string/trim-start
+core-js(/library)/fn/string/trim-end
+core-js(/library)/fn/string/trim-left
+core-js(/library)/fn/string/trim-right
+core-js(/library)/fn/string/virtual/trim-start
+core-js(/library)/fn/string/virtual/trim-end
+core-js(/library)/fn/string/virtual/trim-left
+core-js(/library)/fn/string/virtual/trim-right
+```
+[*Examples*](http://goo.gl/Er5lMJ):
+```js
+' hello '.trimLeft(); // => 'hello '
+' hello '.trimRight(); // => ' hello'
+```
+```
+* `Symbol.asyncIterator` for [async iteration proposal](https://github.com/tc39/proposal-async-iteration) - module [`es7.symbol.async-iterator`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.symbol.async-iterator.js)
+```js
+Symbol
+ .asyncIterator -> @@asyncIterator
+```
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/fn/symbol/async-iterator
+```
+
+#### Stage 1 proposals
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/stage/1
+```
+* `Promise.try` [proposal](https://github.com/tc39/proposal-promise-try) - module [`es7.promise.try`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.promise.try.js)
+```js
+Promise
+ .try(function()) -> promise
+```
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/fn/promise/try
+```
+[*Examples*](https://goo.gl/k5GGRo):
+```js
+Promise.try(() => 42).then(it => console.log(`Promise, resolved as ${it}`));
+
+Promise.try(() => { throw 42; }).catch(it => console.log(`Promise, rejected as ${it}`));
+```
+* `Array#flatten` and `Array#flatMap` [proposal](https://tc39.github.io/proposal-flatMap) - modules [`es7.array.flatten`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.array.flatten.js) and [`es7.array.flat-map`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.array.flat-map.js)
+```js
+Array
+ #flatten(depthArg = 1) -> array
+ #flatMap(fn(val, key, @), that) -> array
+```
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/fn/array/flatten
+core-js(/library)/fn/array/flat-map
+core-js(/library)/fn/array/virtual/flatten
+core-js(/library)/fn/array/virtual/flat-map
+```
+[*Examples*](https://goo.gl/jTXsZi):
+```js
+[1, [2, 3], [4, 5]].flatten(); // => [1, 2, 3, 4, 5]
+[1, [2, [3, [4]]], 5].flatten(); // => [1, 2, [3, [4]], 5]
+[1, [2, [3, [4]]], 5].flatten(3); // => [1, 2, 3, 4, 5]
+
+[{a: 1, b: 2}, {a: 3, b: 4}, {a: 5, b: 6}].flatMap(it => [it.a, it.b]); // => [1, 2, 3, 4, 5, 6]
+```
+* `.of` and `.from` methods on collection constructors [proposal](https://github.com/tc39/proposal-setmap-offrom) - modules [`es7.set.of`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.set.of.js), [`es7.set.from`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.set.from.js), [`es7.map.of`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.map.of.js), [`es7.map.from`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.map.from.js), [`es7.weak-set.of`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.weak-set.of.js), [`es7.weak-set.from`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.weak-set.from.js), [`es7.weak-map.of`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.weak-map.of.js), [`es7.weak-map.from`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.weak-map.from.js)
+```js
+Set
+ .of(...args) -> set
+ .from(iterable, mapFn(val, index)?, that?) -> set
+Map
+ .of(...args) -> map
+ .from(iterable, mapFn(val, index)?, that?) -> map
+WeakSet
+ .of(...args) -> weakset
+ .from(iterable, mapFn(val, index)?, that?) -> weakset
+WeakMap
+ .of(...args) -> weakmap
+ .from(iterable, mapFn(val, index)?, that?) -> weakmap
+```
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/fn/set/of
+core-js(/library)/fn/set/from
+core-js(/library)/fn/map/of
+core-js(/library)/fn/map/from
+core-js(/library)/fn/weak-set/of
+core-js(/library)/fn/weak-set/from
+core-js(/library)/fn/weak-map/of
+core-js(/library)/fn/weak-map/from
+```
+[*Examples*](https://goo.gl/mSC7eU):
+```js
+Set.of(1, 2, 3, 2, 1); // => Set {1, 2, 3}
+
+Map.from([[1, 2], [3, 4]], ([key, val]) => [key ** 2, val ** 2]); // => Map {1: 4, 9: 16}
+```
+* `String#matchAll` [proposal](https://github.com/tc39/String.prototype.matchAll) - module [`es7.string.match-all`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.string.match-all.js)
+```js
+String
+ #matchAll(regexp) -> iterator
+```
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/fn/string/match-all
+core-js(/library)/fn/string/virtual/match-all
+```
+[*Examples*](http://goo.gl/6kp9EB):
+```js
+for(let [_, d, D] of '1111a2b3cccc'.matchAll(/(\d)(\D)/)){
+ console.log(d, D); // => 1 a, 2 b, 3 c
+}
+```
+* `Observable` [proposal](https://github.com/zenparsing/es-observable) - modules [`es7.observable`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.observable.js) and [`es7.symbol.observable`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.symbol.observable.js)
+```js
+new Observable(fn) -> observable
+ #subscribe(observer) -> subscription
+ #forEach(fn) -> promise
+ #@@observable() -> @
+ .of(...items) -> observable
+ .from(observable | iterable) -> observable
+ .@@species -> @
+Symbol
+ .observable -> @@observable
+```
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/fn/observable
+core-js(/library)/fn/symbol/observable
+```
+[*Examples*](http://goo.gl/1LDywi):
+```js
+new Observable(observer => {
+ observer.next('hello');
+ observer.next('world');
+ observer.complete();
+}).forEach(it => console.log(it))
+ .then(_ => console.log('!'));
+```
+* `Math.{clamp, DEG_PER_RAD, degrees, fscale, rad-per-deg, radians, scale}`
+ [proposal](https://github.com/rwaldron/proposal-math-extensions) - modules
+ [`es7.math.clamp`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.math.clamp.js),
+ [`es7.math.DEG_PER_RAD`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.math.DEG_PER_RAD.js),
+ [`es7.math.degrees`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.math.degrees.js),
+ [`es7.math.fscale`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.math.fscale.js),
+ [`es7.math.RAD_PER_DEG`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.math.RAD_PER_DEG.js),
+ [`es7.math.radians`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.math.radians.js) and
+ [`es7.math.scale`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.math.scale.js)
+```js
+Math
+ .DEG_PER_RAD -> number
+ .RAD_PER_DEG -> number
+ .clamp(x, lower, upper) -> number
+ .degrees(radians) -> number
+ .fscale(x, inLow, inHigh, outLow, outHigh) -> number
+ .radians(degrees) -> number
+ .scale(x, inLow, inHigh, outLow, outHigh) -> number
+```
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/fn/math/clamp
+core-js(/library)/fn/math/deg-per-rad
+core-js(/library)/fn/math/degrees
+core-js(/library)/fn/math/fscale
+core-js(/library)/fn/math/rad-per-deg
+core-js(/library)/fn/math/radians
+core-js(/library)/fn/math/scale
+```
+* `Math.signbit` [proposal](http://jfbastien.github.io/papers/Math.signbit.html) - module [`es7.math.signbit`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.math.signbit.js)
+```js
+Math
+ .signbit(x) -> bool
+```
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/fn/math/signbit
+```
+[*Examples*](http://es6.zloirock.ru/):
+```js
+Math.signbit(NaN); // => NaN
+Math.signbit(1); // => true
+Math.signbit(-1); // => false
+Math.signbit(0); // => true
+Math.signbit(-0); // => false
+```
+
+#### Stage 0 proposals
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/stage/0
+```
+* `String#at` [proposal](https://github.com/mathiasbynens/String.prototype.at) - module [`es7.string.at`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.string.at.js)
+```js
+String
+ #at(index) -> string
+```
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/fn/string/at
+core-js(/library)/fn/string/virtual/at
+```
+[*Examples*](http://goo.gl/XluXI8):
+```js
+'a𠮷b'.at(1); // => '𠮷'
+'a𠮷b'.at(1).length; // => 2
+```
+* `Map#toJSON`, `Set#toJSON` [proposal](https://github.com/DavidBruant/Map-Set.prototype.toJSON) - modules [`es7.map.to-json`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.map.to-json.js), [`es7.set.to-json`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.set.to-json.js) (rejected and will be removed from `core-js@3`)
+```js
+Map
+ #toJSON() -> array (rejected and will be removed from core-js@3)
+Set
+ #toJSON() -> array (rejected and will be removed from core-js@3)
+```
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/fn/map
+core-js(/library)/fn/set
+```
+* `Error.isError` [proposal](https://github.com/ljharb/proposal-is-error) - module [`es7.error.is-error`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.error.is-error.js) (withdrawn and will be removed from `core-js@3`)
+```js
+Error
+ .isError(it) -> bool (withdrawn and will be removed from core-js@3)
+```
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/fn/error/is-error
+```
+* `Math.{iaddh, isubh, imulh, umulh}` [proposal](https://gist.github.com/BrendanEich/4294d5c212a6d2254703) - modules [`es7.math.iaddh`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.math.iaddh.js), [`es7.math.isubh`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.math.isubh.js), [`es7.math.imulh`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.math.imulh.js) and [`es7.math.umulh`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.math.umulh.js)
+```js
+Math
+ .iaddh(lo0, hi0, lo1, hi1) -> int32
+ .isubh(lo0, hi0, lo1, hi1) -> int32
+ .imulh(a, b) -> int32
+ .umulh(a, b) -> uint32
+```
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/fn/math/iaddh
+core-js(/library)/fn/math/isubh
+core-js(/library)/fn/math/imulh
+core-js(/library)/fn/math/umulh
+```
+* `global.asap`, [TC39 discussion](https://github.com/rwaldron/tc39-notes/blob/master/es6/2014-09/sept-25.md#510-globalasap-for-enqueuing-a-microtask), module [`es7.asap`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.asap.js)
+```js
+asap(fn) -> void
+```
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/fn/asap
+```
+[*Examples*](http://goo.gl/tx3SRK):
+```js
+asap(() => console.log('called as microtask'));
+```
+
+#### Pre-stage 0 proposals
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/stage/pre
+```
+* `Reflect` metadata [proposal](https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md) - modules [`es7.reflect.define-metadata`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.reflect.define-metadata.js), [`es7.reflect.delete-metadata`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.reflect.delete-metadata.js), [`es7.reflect.get-metadata`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.reflect.get-metadata.js), [`es7.reflect.get-metadata-keys`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.reflect.get-metadata-keys.js), [`es7.reflect.get-own-metadata`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.reflect.get-own-metadata.js), [`es7.reflect.get-own-metadata-keys`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.reflect.get-own-metadata-keys.js), [`es7.reflect.has-metadata`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.reflect.has-metadata.js), [`es7.reflect.has-own-metadata`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.reflect.has-own-metadata.js) and [`es7.reflect.metadata`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/es7.reflect.metadata.js).
+```js
+Reflect
+ .defineMetadata(metadataKey, metadataValue, target, propertyKey?) -> void
+ .getMetadata(metadataKey, target, propertyKey?) -> var
+ .getOwnMetadata(metadataKey, target, propertyKey?) -> var
+ .hasMetadata(metadataKey, target, propertyKey?) -> bool
+ .hasOwnMetadata(metadataKey, target, propertyKey?) -> bool
+ .deleteMetadata(metadataKey, target, propertyKey?) -> bool
+ .getMetadataKeys(target, propertyKey?) -> array
+ .getOwnMetadataKeys(target, propertyKey?) -> array
+ .metadata(metadataKey, metadataValue) -> decorator(target, targetKey?) -> void
+```
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/fn/reflect/define-metadata
+core-js(/library)/fn/reflect/delete-metadata
+core-js(/library)/fn/reflect/get-metadata
+core-js(/library)/fn/reflect/get-metadata-keys
+core-js(/library)/fn/reflect/get-own-metadata
+core-js(/library)/fn/reflect/get-own-metadata-keys
+core-js(/library)/fn/reflect/has-metadata
+core-js(/library)/fn/reflect/has-own-metadata
+core-js(/library)/fn/reflect/metadata
+```
+[*Examples*](http://goo.gl/KCo3PS):
+```js
+var O = {};
+Reflect.defineMetadata('foo', 'bar', O);
+Reflect.ownKeys(O); // => []
+Reflect.getOwnMetadataKeys(O); // => ['foo']
+Reflect.getOwnMetadata('foo', O); // => 'bar'
+```
+
+### Web standards
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/web
+```
+#### setTimeout / setInterval
+Module [`web.timers`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/web.timers.js). Additional arguments fix for IE9-.
+```js
+setTimeout(fn(...args), time, ...args) -> id
+setInterval(fn(...args), time, ...args) -> id
+```
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/web/timers
+core-js(/library)/fn/set-timeout
+core-js(/library)/fn/set-interval
+```
+```js
+// Before:
+setTimeout(log.bind(null, 42), 1000);
+// After:
+setTimeout(log, 1000, 42);
+```
+#### setImmediate
+Module [`web.immediate`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/web.immediate.js). [`setImmediate` proposal](https://developer.mozilla.org/en-US/docs/Web/API/Window.setImmediate) polyfill.
+```js
+setImmediate(fn(...args), ...args) -> id
+clearImmediate(id) -> void
+```
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/web/immediate
+core-js(/library)/fn/set-immediate
+core-js(/library)/fn/clear-immediate
+```
+[*Examples*](http://goo.gl/6nXGrx):
+```js
+setImmediate(function(arg1, arg2){
+ console.log(arg1, arg2); // => Message will be displayed with minimum delay
+}, 'Message will be displayed', 'with minimum delay');
+
+clearImmediate(setImmediate(function(){
+ console.log('Message will not be displayed');
+}));
+```
+#### Iterable DOM collections
+Some DOM collections should have [iterable interface](https://heycam.github.io/webidl/#idl-iterable) or should be [inherited from `Array`](https://heycam.github.io/webidl/#LegacyArrayClass). That mean they should have `keys`, `values`, `entries` and `@@iterator` methods for iteration. So add them. Module [`web.dom.iterable`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/web.dom.iterable.js):
+```js
+{
+ CSSRuleList,
+ CSSStyleDeclaration,
+ CSSValueList,
+ ClientRectList,
+ DOMRectList,
+ DOMStringList,
+ DOMTokenList,
+ DataTransferItemList,
+ FileList,
+ HTMLAllCollection,
+ HTMLCollection,
+ HTMLFormElement,
+ HTMLSelectElement,
+ MediaList,
+ MimeTypeArray,
+ NamedNodeMap,
+ NodeList,
+ PaintRequestList,
+ Plugin,
+ PluginArray,
+ SVGLengthList,
+ SVGNumberList,
+ SVGPathSegList,
+ SVGPointList,
+ SVGStringList,
+ SVGTransformList,
+ SourceBufferList,
+ StyleSheetList,
+ TextTrackCueList,
+ TextTrackList,
+ TouchList
+}
+ #@@iterator() -> iterator (values)
+
+{
+ DOMTokenList,
+ NodeList
+}
+ #values() -> iterator
+ #keys() -> iterator
+ #entries() -> iterator
+```
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/web/dom-collections
+core-js(/library)/fn/dom-collections/iterator
+```
+[*Examples*](http://goo.gl/lfXVFl):
+```js
+for(var {id} of document.querySelectorAll('*')){
+ if(id)console.log(id);
+}
+
+for(var [index, {id}] of document.querySelectorAll('*').entries()){
+ if(id)console.log(index, id);
+}
+```
+### Non-standard
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/core
+```
+#### Object
+Modules [`core.object.is-object`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/core.object.is-object.js), [`core.object.classof`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/core.object.classof.js), [`core.object.define`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/core.object.define.js), [`core.object.make`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/core.object.make.js).
+```js
+Object
+ .isObject(var) -> bool
+ .classof(var) -> string
+ .define(target, mixin) -> target
+ .make(proto | null, mixin?) -> object
+```
+
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/core/object
+core-js(/library)/fn/object/is-object
+core-js(/library)/fn/object/define
+core-js(/library)/fn/object/make
+```
+Object classify [*examples*](http://goo.gl/YZQmGo):
+```js
+Object.isObject({}); // => true
+Object.isObject(isNaN); // => true
+Object.isObject(null); // => false
+
+var classof = Object.classof;
+
+classof(null); // => 'Null'
+classof(undefined); // => 'Undefined'
+classof(1); // => 'Number'
+classof(true); // => 'Boolean'
+classof('string'); // => 'String'
+classof(Symbol()); // => 'Symbol'
+
+classof(new Number(1)); // => 'Number'
+classof(new Boolean(true)); // => 'Boolean'
+classof(new String('string')); // => 'String'
+
+var fn = function(){}
+ , list = (function(){return arguments})(1, 2, 3);
+
+classof({}); // => 'Object'
+classof(fn); // => 'Function'
+classof([]); // => 'Array'
+classof(list); // => 'Arguments'
+classof(/./); // => 'RegExp'
+classof(new TypeError); // => 'Error'
+
+classof(new Set); // => 'Set'
+classof(new Map); // => 'Map'
+classof(new WeakSet); // => 'WeakSet'
+classof(new WeakMap); // => 'WeakMap'
+classof(new Promise(fn)); // => 'Promise'
+
+classof([].values()); // => 'Array Iterator'
+classof(new Set().values()); // => 'Set Iterator'
+classof(new Map().values()); // => 'Map Iterator'
+
+classof(Math); // => 'Math'
+classof(JSON); // => 'JSON'
+
+function Example(){}
+Example.prototype[Symbol.toStringTag] = 'Example';
+
+classof(new Example); // => 'Example'
+```
+`Object.define` and `Object.make` [*examples*](http://goo.gl/rtpD5Z):
+```js
+// Before:
+Object.defineProperty(target, 'c', {
+ enumerable: true,
+ configurable: true,
+ get: function(){
+ return this.a + this.b;
+ }
+});
+
+// After:
+Object.define(target, {
+ get c(){
+ return this.a + this.b;
+ }
+});
+
+// Shallow object cloning with prototype and descriptors:
+var copy = Object.make(Object.getPrototypeOf(src), src);
+
+// Simple inheritance:
+function Vector2D(x, y){
+ this.x = x;
+ this.y = y;
+}
+Object.define(Vector2D.prototype, {
+ get xy(){
+ return Math.hypot(this.x, this.y);
+ }
+});
+function Vector3D(x, y, z){
+ Vector2D.apply(this, arguments);
+ this.z = z;
+}
+Vector3D.prototype = Object.make(Vector2D.prototype, {
+ constructor: Vector3D,
+ get xyz(){
+ return Math.hypot(this.x, this.y, this.z);
+ }
+});
+
+var vector = new Vector3D(9, 12, 20);
+console.log(vector.xy); // => 15
+console.log(vector.xyz); // => 25
+vector.y++;
+console.log(vector.xy); // => 15.811388300841896
+console.log(vector.xyz); // => 25.495097567963924
+```
+#### Dict
+Module [`core.dict`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/core.dict.js). Based on [TC39 discuss](https://github.com/rwaldron/tc39-notes/blob/master/es6/2012-11/nov-29.md#collection-apis-review) / [strawman](http://wiki.ecmascript.org/doku.php?id=harmony:modules_standard#dictionaries).
+```js
+[new] Dict(iterable (entries) | object ?) -> dict
+ .isDict(var) -> bool
+ .values(object) -> iterator
+ .keys(object) -> iterator
+ .entries(object) -> iterator (entries)
+ .has(object, key) -> bool
+ .get(object, key) -> val
+ .set(object, key, value) -> object
+ .forEach(object, fn(val, key, @), that) -> void
+ .map(object, fn(val, key, @), that) -> new @
+ .mapPairs(object, fn(val, key, @), that) -> new @
+ .filter(object, fn(val, key, @), that) -> new @
+ .some(object, fn(val, key, @), that) -> bool
+ .every(object, fn(val, key, @), that) -> bool
+ .find(object, fn(val, key, @), that) -> val
+ .findKey(object, fn(val, key, @), that) -> key
+ .keyOf(object, var) -> key
+ .includes(object, var) -> bool
+ .reduce(object, fn(memo, val, key, @), memo?) -> var
+```
+
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/core/dict
+core-js(/library)/fn/dict
+```
+`Dict` create object without prototype from iterable or simple object.
+
+[*Examples*](http://goo.gl/pnp8Vr):
+```js
+var map = new Map([['a', 1], ['b', 2], ['c', 3]]);
+
+Dict(); // => {__proto__: null}
+Dict({a: 1, b: 2, c: 3}); // => {__proto__: null, a: 1, b: 2, c: 3}
+Dict(map); // => {__proto__: null, a: 1, b: 2, c: 3}
+Dict([1, 2, 3].entries()); // => {__proto__: null, 0: 1, 1: 2, 2: 3}
+
+var dict = Dict({a: 42});
+dict instanceof Object; // => false
+dict.a; // => 42
+dict.toString; // => undefined
+'a' in dict; // => true
+'hasOwnProperty' in dict; // => false
+
+Dict.isDict({}); // => false
+Dict.isDict(Dict()); // => true
+```
+`Dict.keys`, `Dict.values` and `Dict.entries` returns iterators for objects.
+
+[*Examples*](http://goo.gl/xAvECH):
+```js
+var dict = {a: 1, b: 2, c: 3};
+
+for(var key of Dict.keys(dict))console.log(key); // => 'a', 'b', 'c'
+
+for(var val of Dict.values(dict))console.log(val); // => 1, 2, 3
+
+for(var [key, val] of Dict.entries(dict)){
+ console.log(key); // => 'a', 'b', 'c'
+ console.log(val); // => 1, 2, 3
+}
+
+new Map(Dict.entries(dict)); // => Map {a: 1, b: 2, c: 3}
+```
+Basic dict operations for objects with prototype [*examples*](http://goo.gl/B28UnG):
+```js
+'q' in {q: 1}; // => true
+'toString' in {}; // => true
+
+Dict.has({q: 1}, 'q'); // => true
+Dict.has({}, 'toString'); // => false
+
+({q: 1})['q']; // => 1
+({}).toString; // => function toString(){ [native code] }
+
+Dict.get({q: 1}, 'q'); // => 1
+Dict.get({}, 'toString'); // => undefined
+
+var O = {};
+O['q'] = 1;
+O['q']; // => 1
+O['__proto__'] = {w: 2};
+O['__proto__']; // => {w: 2}
+O['w']; // => 2
+
+var O = {};
+Dict.set(O, 'q', 1);
+O['q']; // => 1
+Dict.set(O, '__proto__', {w: 2});
+O['__proto__']; // => {w: 2}
+O['w']; // => undefined
+```
+Other methods of `Dict` module are static equivalents of `Array.prototype` methods for dictionaries.
+
+[*Examples*](http://goo.gl/xFi1RH):
+```js
+var dict = {a: 1, b: 2, c: 3};
+
+Dict.forEach(dict, console.log, console);
+// => 1, 'a', {a: 1, b: 2, c: 3}
+// => 2, 'b', {a: 1, b: 2, c: 3}
+// => 3, 'c', {a: 1, b: 2, c: 3}
+
+Dict.map(dict, function(it){
+ return it * it;
+}); // => {a: 1, b: 4, c: 9}
+
+Dict.mapPairs(dict, function(val, key){
+ if(key != 'b')return [key + key, val * val];
+}); // => {aa: 1, cc: 9}
+
+Dict.filter(dict, function(it){
+ return it % 2;
+}); // => {a: 1, c: 3}
+
+Dict.some(dict, function(it){
+ return it === 2;
+}); // => true
+
+Dict.every(dict, function(it){
+ return it === 2;
+}); // => false
+
+Dict.find(dict, function(it){
+ return it > 2;
+}); // => 3
+Dict.find(dict, function(it){
+ return it > 4;
+}); // => undefined
+
+Dict.findKey(dict, function(it){
+ return it > 2;
+}); // => 'c'
+Dict.findKey(dict, function(it){
+ return it > 4;
+}); // => undefined
+
+Dict.keyOf(dict, 2); // => 'b'
+Dict.keyOf(dict, 4); // => undefined
+
+Dict.includes(dict, 2); // => true
+Dict.includes(dict, 4); // => false
+
+Dict.reduce(dict, function(memo, it){
+ return memo + it;
+}); // => 6
+Dict.reduce(dict, function(memo, it){
+ return memo + it;
+}, ''); // => '123'
+```
+#### Partial application
+Module [`core.function.part`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/core.function.part.js).
+```js
+Function
+ #part(...args | _) -> fn(...args)
+```
+
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js/core/function
+core-js(/library)/fn/function/part
+core-js(/library)/fn/function/virtual/part
+core-js(/library)/fn/_
+```
+`Function#part` partial apply function without `this` binding. Uses global variable `_` (`core._` for builds without global namespace pollution) as placeholder and not conflict with `Underscore` / `LoDash`.
+
+[*Examples*](http://goo.gl/p9ZJ8K):
+```js
+var fn1 = log.part(1, 2);
+fn1(3, 4); // => 1, 2, 3, 4
+
+var fn2 = log.part(_, 2, _, 4);
+fn2(1, 3); // => 1, 2, 3, 4
+
+var fn3 = log.part(1, _, _, 4);
+fn3(2, 3); // => 1, 2, 3, 4
+
+fn2(1, 3, 5); // => 1, 2, 3, 4, 5
+fn2(1); // => 1, 2, undefined, 4
+```
+#### Number Iterator
+Module [`core.number.iterator`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/core.number.iterator.js).
+```js
+Number
+ #@@iterator() -> iterator
+```
+
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/core/number
+core-js(/library)/fn/number/iterator
+core-js(/library)/fn/number/virtual/iterator
+```
+[*Examples*](http://goo.gl/o45pCN):
+```js
+for(var i of 3)console.log(i); // => 0, 1, 2
+
+[...10]; // => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+Array.from(10, Math.random); // => [0.9817775336559862, 0.02720663254149258, ...]
+
+Array.from(10, function(it){
+ return this + it * it;
+}, .42); // => [0.42, 1.42, 4.42, 9.42, 16.42, 25.42, 36.42, 49.42, 64.42, 81.42]
+```
+#### Escaping strings
+Modules [`core.regexp.escape`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/core.regexp.escape.js), [`core.string.escape-html`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/core.string.escape-html.js) and [`core.string.unescape-html`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/core.string.unescape-html.js).
+```js
+RegExp
+ .escape(str) -> str
+String
+ #escapeHTML() -> str
+ #unescapeHTML() -> str
+```
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/core/regexp
+core-js(/library)/core/string
+core-js(/library)/fn/regexp/escape
+core-js(/library)/fn/string/escape-html
+core-js(/library)/fn/string/unescape-html
+core-js(/library)/fn/string/virtual/escape-html
+core-js(/library)/fn/string/virtual/unescape-html
+```
+[*Examples*](http://goo.gl/6bOvsQ):
+```js
+RegExp.escape('Hello, []{}()*+?.\\^$|!'); // => 'Hello, \[\]\{\}\(\)\*\+\?\.\\\^\$\|!'
+
+''.escapeHTML(); // => '<script>doSomething();</script>'
+'<script>doSomething();</script>'.unescapeHTML(); // => ''
+```
+#### delay
+Module [`core.delay`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/core.delay.js). [Promise](#ecmascript-6-promise)-returning delay function, [esdiscuss](https://esdiscuss.org/topic/promise-returning-delay-function).
+```js
+delay(ms) -> promise
+```
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/core/delay
+core-js(/library)/fn/delay
+```
+[*Examples*](http://goo.gl/lbucba):
+```js
+delay(1e3).then(() => console.log('after 1 sec'));
+
+(async () => {
+ await delay(3e3);
+ console.log('after 3 sec');
+
+ while(await delay(3e3))console.log('each 3 sec');
+})();
+```
+#### Helpers for iterators
+Modules [`core.is-iterable`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/core.is-iterable.js), [`core.get-iterator`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/core.get-iterator.js), [`core.get-iterator-method`](https://github.com/zloirock/core-js/blob/v2.6.12/modules/core.get-iterator-method.js) - helpers for check iterability / get iterator in the `library` version or, for example, for `arguments` object:
+```js
+core
+ .isIterable(var) -> bool
+ .getIterator(iterable) -> iterator
+ .getIteratorMethod(var) -> function | undefined
+```
+[*CommonJS entry points:*](#commonjs)
+```js
+core-js(/library)/fn/is-iterable
+core-js(/library)/fn/get-iterator
+core-js(/library)/fn/get-iterator-method
+```
+[*Examples*](http://goo.gl/SXsM6D):
+```js
+var list = (function(){
+ return arguments;
+})(1, 2, 3);
+
+console.log(core.isIterable(list)); // true;
+
+var iter = core.getIterator(list);
+console.log(iter.next().value); // 1
+console.log(iter.next().value); // 2
+console.log(iter.next().value); // 3
+console.log(iter.next().value); // undefined
+
+core.getIterator({}); // TypeError: [object Object] is not iterable!
+
+var iterFn = core.getIteratorMethod(list);
+console.log(typeof iterFn); // 'function'
+var iter = iterFn.call(list);
+console.log(iter.next().value); // 1
+console.log(iter.next().value); // 2
+console.log(iter.next().value); // 3
+console.log(iter.next().value); // undefined
+
+console.log(core.getIteratorMethod({})); // undefined
+```
+
+## Missing polyfills
+- ES5 `JSON` is missing now only in IE7- and never will it be added to `core-js`, if you need it in these old browsers, many implementations are available, for example, [json3](https://github.com/bestiejs/json3).
+- ES6 `String#normalize` is not a very useful feature, but this polyfill will be very large. If you need it, you can use [unorm](https://github.com/walling/unorm/).
+- ES6 `Proxy` can't be polyfilled, but for Node.js / Chromium with additional flags you can try [harmony-reflect](https://github.com/tvcutsem/harmony-reflect) for adapt old style `Proxy` API to final ES6 version.
+- ES6 logic for `@@isConcatSpreadable` and `@@species` (in most places) can be polyfilled without problems, but it will cause a serious slowdown in popular cases in some engines. It will be polyfilled when it will be implemented in modern engines.
+- ES7 `SIMD`. `core-js` doesn't add polyfill of this feature because of large size and some other reasons. You can use [this polyfill](https://github.com/tc39/ecmascript_simd/blob/master/src/ecmascript_simd.js).
+- `window.fetch` is not a cross-platform feature, in some environments it makes no sense. For this reason, I don't think it should be in `core-js`. Looking at a large number of requests it *may be* added in the future. Now you can use, for example, [this polyfill](https://github.com/github/fetch).
+- ECMA-402 `Intl` is missed because of size. You can use [this polyfill](https://github.com/andyearnshaw/Intl.js/).
diff --git a/node_modules/core-js/bower.json b/node_modules/core-js/bower.json
new file mode 100644
index 0000000000000000000000000000000000000000..2275aeb246ebab5d8649423f2cd2940f133390c5
--- /dev/null
+++ b/node_modules/core-js/bower.json
@@ -0,0 +1,49 @@
+{
+ "name": "core.js",
+ "main": "client/core.js",
+ "version": "2.6.11",
+ "description": "Standard Library",
+ "keywords": [
+ "ES3",
+ "ES5",
+ "ES6",
+ "ES7",
+ "ES2015",
+ "ES2016",
+ "ES2017",
+ "ECMAScript 3",
+ "ECMAScript 5",
+ "ECMAScript 6",
+ "ECMAScript 7",
+ "ECMAScript 2015",
+ "ECMAScript 2016",
+ "ECMAScript 2017",
+ "Harmony",
+ "Strawman",
+ "Map",
+ "Set",
+ "WeakMap",
+ "WeakSet",
+ "Promise",
+ "Symbol",
+ "TypedArray",
+ "setImmediate",
+ "Dict",
+ "polyfill",
+ "shim"
+ ],
+ "authors": [
+ "Denis Pushkarev 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+## Sponsors
+
+Become a sponsor and get your logo on our README on Github with a link to your site. [[Become a sponsor](https://opencollective.com/debug#sponsor)]
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+## License
+
+(The MIT License)
+
+Copyright (c) 2014-2016 TJ Holowaychuk <tj@vision-media.ca>
+
+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.
diff --git a/node_modules/debug/component.json b/node_modules/debug/component.json
new file mode 100644
index 0000000000000000000000000000000000000000..9de26410f0d0bba2e48a07f094407d602eb5dd89
--- /dev/null
+++ b/node_modules/debug/component.json
@@ -0,0 +1,19 @@
+{
+ "name": "debug",
+ "repo": "visionmedia/debug",
+ "description": "small debugging utility",
+ "version": "2.6.9",
+ "keywords": [
+ "debug",
+ "log",
+ "debugger"
+ ],
+ "main": "src/browser.js",
+ "scripts": [
+ "src/browser.js",
+ "src/debug.js"
+ ],
+ "dependencies": {
+ "rauchg/ms.js": "0.7.1"
+ }
+}
diff --git a/node_modules/debug/karma.conf.js b/node_modules/debug/karma.conf.js
new file mode 100644
index 0000000000000000000000000000000000000000..103a82d15bd72b3cdf9ba4108272985f7e0bfdb3
--- /dev/null
+++ b/node_modules/debug/karma.conf.js
@@ -0,0 +1,70 @@
+// Karma configuration
+// Generated on Fri Dec 16 2016 13:09:51 GMT+0000 (UTC)
+
+module.exports = function(config) {
+ config.set({
+
+ // base path that will be used to resolve all patterns (eg. files, exclude)
+ basePath: '',
+
+
+ // frameworks to use
+ // available frameworks: https://npmjs.org/browse/keyword/karma-adapter
+ frameworks: ['mocha', 'chai', 'sinon'],
+
+
+ // list of files / patterns to load in the browser
+ files: [
+ 'dist/debug.js',
+ 'test/*spec.js'
+ ],
+
+
+ // list of files to exclude
+ exclude: [
+ 'src/node.js'
+ ],
+
+
+ // preprocess matching files before serving them to the browser
+ // available preprocessors: https://npmjs.org/browse/keyword/karma-preprocessor
+ preprocessors: {
+ },
+
+ // test results reporter to use
+ // possible values: 'dots', 'progress'
+ // available reporters: https://npmjs.org/browse/keyword/karma-reporter
+ reporters: ['progress'],
+
+
+ // web server port
+ port: 9876,
+
+
+ // enable / disable colors in the output (reporters and logs)
+ colors: true,
+
+
+ // level of logging
+ // possible values: config.LOG_DISABLE || config.LOG_ERROR || config.LOG_WARN || config.LOG_INFO || config.LOG_DEBUG
+ logLevel: config.LOG_INFO,
+
+
+ // enable / disable watching file and executing tests whenever any file changes
+ autoWatch: true,
+
+
+ // start these browsers
+ // available browser launchers: https://npmjs.org/browse/keyword/karma-launcher
+ browsers: ['PhantomJS'],
+
+
+ // Continuous Integration mode
+ // if true, Karma captures browsers, runs the tests and exits
+ singleRun: false,
+
+ // Concurrency level
+ // how many browser should be started simultaneous
+ concurrency: Infinity
+ })
+}
diff --git a/node_modules/debug/node.js b/node_modules/debug/node.js
new file mode 100644
index 0000000000000000000000000000000000000000..7fc36fe6dbecbfd41530c5a490cc738ec2968653
--- /dev/null
+++ b/node_modules/debug/node.js
@@ -0,0 +1 @@
+module.exports = require('./src/node');
diff --git a/node_modules/debug/package.json b/node_modules/debug/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..dc787ba76781de4c1d4721b69aa881a548365a90
--- /dev/null
+++ b/node_modules/debug/package.json
@@ -0,0 +1,49 @@
+{
+ "name": "debug",
+ "version": "2.6.9",
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/visionmedia/debug.git"
+ },
+ "description": "small debugging utility",
+ "keywords": [
+ "debug",
+ "log",
+ "debugger"
+ ],
+ "author": "TJ Holowaychuk +> Example: `unicornRainbow` → `unicorn_rainbow` + + +## Install + +``` +$ npm install --save decamelize +``` + + +## Usage + +```js +const decamelize = require('decamelize'); + +decamelize('unicornRainbow'); +//=> 'unicorn_rainbow' + +decamelize('unicornRainbow', '-'); +//=> 'unicorn-rainbow' +``` + + +## API + +### decamelize(input, [separator]) + +#### input + +Type: `string` + +#### separator + +Type: `string`
+Default: `_` + + +## Related + +See [`camelcase`](https://github.com/sindresorhus/camelcase) for the inverse. + + +## License + +MIT © [Sindre Sorhus](https://sindresorhus.com) diff --git a/node_modules/depd/History.md b/node_modules/depd/History.md new file mode 100644 index 0000000000000000000000000000000000000000..507ecb8de21d5d0d2db42ec03b99a5efd610acf7 --- /dev/null +++ b/node_modules/depd/History.md @@ -0,0 +1,96 @@ +1.1.2 / 2018-01-11 +================== + + * perf: remove argument reassignment + * Support Node.js 0.6 to 9.x + +1.1.1 / 2017-07-27 +================== + + * Remove unnecessary `Buffer` loading + * Support Node.js 0.6 to 8.x + +1.1.0 / 2015-09-14 +================== + + * Enable strict mode in more places + * Support io.js 3.x + * Support io.js 2.x + * Support web browser loading + - Requires bundler like Browserify or webpack + +1.0.1 / 2015-04-07 +================== + + * Fix `TypeError`s when under `'use strict'` code + * Fix useless type name on auto-generated messages + * Support io.js 1.x + * Support Node.js 0.12 + +1.0.0 / 2014-09-17 +================== + + * No changes + +0.4.5 / 2014-09-09 +================== + + * Improve call speed to functions using the function wrapper + * Support Node.js 0.6 + +0.4.4 / 2014-07-27 +================== + + * Work-around v8 generating empty stack traces + +0.4.3 / 2014-07-26 +================== + + * Fix exception when global `Error.stackTraceLimit` is too low + +0.4.2 / 2014-07-19 +================== + + * Correct call site for wrapped functions and properties + +0.4.1 / 2014-07-19 +================== + + * Improve automatic message generation for function properties + +0.4.0 / 2014-07-19 +================== + + * Add `TRACE_DEPRECATION` environment variable + * Remove non-standard grey color from color output + * Support `--no-deprecation` argument + * Support `--trace-deprecation` argument + * Support `deprecate.property(fn, prop, message)` + +0.3.0 / 2014-06-16 +================== + + * Add `NO_DEPRECATION` environment variable + +0.2.0 / 2014-06-15 +================== + + * Add `deprecate.property(obj, prop, message)` + * Remove `supports-color` dependency for node.js 0.8 + +0.1.0 / 2014-06-15 +================== + + * Add `deprecate.function(fn, message)` + * Add `process.on('deprecation', fn)` emitter + * Automatically generate message when omitted from `deprecate()` + +0.0.1 / 2014-06-15 +================== + + * Fix warning for dynamic calls at singe call site + +0.0.0 / 2014-06-15 +================== + + * Initial implementation diff --git a/node_modules/depd/LICENSE b/node_modules/depd/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..84441fbb5709262c2bfc9b5ff0166ad4f024a1b8 --- /dev/null +++ b/node_modules/depd/LICENSE @@ -0,0 +1,22 @@ +(The MIT License) + +Copyright (c) 2014-2017 Douglas Christopher Wilson + +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. diff --git a/node_modules/depd/Readme.md b/node_modules/depd/Readme.md new file mode 100644 index 0000000000000000000000000000000000000000..77906702044fe2ff41a4a50695666a48df89aa29 --- /dev/null +++ b/node_modules/depd/Readme.md @@ -0,0 +1,280 @@ +# depd + +[![NPM Version][npm-version-image]][npm-url] +[![NPM Downloads][npm-downloads-image]][npm-url] +[![Node.js Version][node-image]][node-url] +[![Linux Build][travis-image]][travis-url] +[![Windows Build][appveyor-image]][appveyor-url] +[![Coverage Status][coveralls-image]][coveralls-url] + +Deprecate all the things + +> With great modules comes great responsibility; mark things deprecated! + +## Install + +This module is installed directly using `npm`: + +```sh +$ npm install depd +``` + +This module can also be bundled with systems like +[Browserify](http://browserify.org/) or [webpack](https://webpack.github.io/), +though by default this module will alter it's API to no longer display or +track deprecations. + +## API + + + +```js +var deprecate = require('depd')('my-module') +``` + +This library allows you to display deprecation messages to your users. +This library goes above and beyond with deprecation warnings by +introspection of the call stack (but only the bits that it is interested +in). + +Instead of just warning on the first invocation of a deprecated +function and never again, this module will warn on the first invocation +of a deprecated function per unique call site, making it ideal to alert +users of all deprecated uses across the code base, rather than just +whatever happens to execute first. + +The deprecation warnings from this module also include the file and line +information for the call into the module that the deprecated function was +in. + +**NOTE** this library has a similar interface to the `debug` module, and +this module uses the calling file to get the boundary for the call stacks, +so you should always create a new `deprecate` object in each file and not +within some central file. + +### depd(namespace) + +Create a new deprecate function that uses the given namespace name in the +messages and will display the call site prior to the stack entering the +file this function was called from. It is highly suggested you use the +name of your module as the namespace. + +### deprecate(message) + +Call this function from deprecated code to display a deprecation message. +This message will appear once per unique caller site. Caller site is the +first call site in the stack in a different file from the caller of this +function. + +If the message is omitted, a message is generated for you based on the site +of the `deprecate()` call and will display the name of the function called, +similar to the name displayed in a stack trace. + +### deprecate.function(fn, message) + +Call this function to wrap a given function in a deprecation message on any +call to the function. An optional message can be supplied to provide a custom +message. + +### deprecate.property(obj, prop, message) + +Call this function to wrap a given property on object in a deprecation message +on any accessing or setting of the property. An optional message can be supplied +to provide a custom message. + +The method must be called on the object where the property belongs (not +inherited from the prototype). + +If the property is a data descriptor, it will be converted to an accessor +descriptor in order to display the deprecation message. + +### process.on('deprecation', fn) + +This module will allow easy capturing of deprecation errors by emitting the +errors as the type "deprecation" on the global `process`. If there are no +listeners for this type, the errors are written to STDERR as normal, but if +there are any listeners, nothing will be written to STDERR and instead only +emitted. From there, you can write the errors in a different format or to a +logging source. + +The error represents the deprecation and is emitted only once with the same +rules as writing to STDERR. The error has the following properties: + + - `message` - This is the message given by the library + - `name` - This is always `'DeprecationError'` + - `namespace` - This is the namespace the deprecation came from + - `stack` - This is the stack of the call to the deprecated thing + +Example `error.stack` output: + +``` +DeprecationError: my-cool-module deprecated oldfunction + at Object.
Location ' + escapeHtml(url) + ' not found
' + + // send a 404 + res.statusCode = 404 + res.setHeader('Content-Type', 'text/html; charset=UTF-8') + res.setHeader('Content-Length', String(Buffer.byteLength(body, 'utf-8'))) + res.end(body, 'utf-8') +}) +``` + +### Encode a URL for use in a header field + +```js +var encodeUrl = require('encodeurl') +var escapeHtml = require('escape-html') +var url = require('url') + +http.createServer(function onRequest (req, res) { + // parse inbound url + var href = url.parse(req) + + // set new host for redirect + href.host = 'localhost' + href.protocol = 'https:' + href.slashes = true + + // create location header + var location = encodeUrl(url.format(href)) + + // create html message + var body = 'Redirecting to new site: ' + escapeHtml(location) + '
' + + // send a 301 + res.statusCode = 301 + res.setHeader('Content-Type', 'text/html; charset=UTF-8') + res.setHeader('Content-Length', String(Buffer.byteLength(body, 'utf-8'))) + res.setHeader('Location', location) + res.end(body, 'utf-8') +}) +``` + +## Testing + +```sh +$ npm test +$ npm run lint +``` + +## References + +- [RFC 3986: Uniform Resource Identifier (URI): Generic Syntax][rfc-3986] +- [WHATWG URL Living Standard][whatwg-url] + +[rfc-3986]: https://tools.ietf.org/html/rfc3986 +[whatwg-url]: https://url.spec.whatwg.org/ + +## License + +[MIT](LICENSE) + +[npm-image]: https://img.shields.io/npm/v/encodeurl.svg +[npm-url]: https://npmjs.org/package/encodeurl +[node-version-image]: https://img.shields.io/node/v/encodeurl.svg +[node-version-url]: https://nodejs.org/en/download +[travis-image]: https://img.shields.io/travis/pillarjs/encodeurl.svg +[travis-url]: https://travis-ci.org/pillarjs/encodeurl +[coveralls-image]: https://img.shields.io/coveralls/pillarjs/encodeurl.svg +[coveralls-url]: https://coveralls.io/r/pillarjs/encodeurl?branch=master +[downloads-image]: https://img.shields.io/npm/dm/encodeurl.svg +[downloads-url]: https://npmjs.org/package/encodeurl diff --git a/node_modules/encodeurl/index.js b/node_modules/encodeurl/index.js new file mode 100644 index 0000000000000000000000000000000000000000..fc4906c6c7896396a877e1f369c78f804e3afa10 --- /dev/null +++ b/node_modules/encodeurl/index.js @@ -0,0 +1,60 @@ +/*! + * encodeurl + * Copyright(c) 2016 Douglas Christopher Wilson + * MIT Licensed + */ + +'use strict' + +/** + * Module exports. + * @public + */ + +module.exports = encodeUrl + +/** + * RegExp to match non-URL code points, *after* encoding (i.e. not including "%") + * and including invalid escape sequences. + * @private + */ + +var ENCODE_CHARS_REGEXP = /(?:[^\x21\x25\x26-\x3B\x3D\x3F-\x5B\x5D\x5F\x61-\x7A\x7E]|%(?:[^0-9A-Fa-f]|[0-9A-Fa-f][^0-9A-Fa-f]|$))+/g + +/** + * RegExp to match unmatched surrogate pair. + * @private + */ + +var UNMATCHED_SURROGATE_PAIR_REGEXP = /(^|[^\uD800-\uDBFF])[\uDC00-\uDFFF]|[\uD800-\uDBFF]([^\uDC00-\uDFFF]|$)/g + +/** + * String to replace unmatched surrogate pair with. + * @private + */ + +var UNMATCHED_SURROGATE_PAIR_REPLACE = '$1\uFFFD$2' + +/** + * Encode a URL to a percent-encoded form, excluding already-encoded sequences. + * + * This function will take an already-encoded URL and encode all the non-URL + * code points. This function will not encode the "%" character unless it is + * not part of a valid sequence (`%20` will be left as-is, but `%foo` will + * be encoded as `%25foo`). + * + * This encode is meant to be "safe" and does not throw errors. It will try as + * hard as it can to properly encode the given URL, including replacing any raw, + * unpaired surrogate pairs with the Unicode replacement character prior to + * encoding. + * + * @param {string} url + * @return {string} + * @public + */ + +function encodeUrl (url) { + return String(url) + .replace(UNMATCHED_SURROGATE_PAIR_REGEXP, UNMATCHED_SURROGATE_PAIR_REPLACE) + .replace(ENCODE_CHARS_REGEXP, encodeURI) +} diff --git a/node_modules/encodeurl/package.json b/node_modules/encodeurl/package.json new file mode 100644 index 0000000000000000000000000000000000000000..b9f25ef10b2fc15b4a9c2ea5aa48856d73f1aade --- /dev/null +++ b/node_modules/encodeurl/package.json @@ -0,0 +1,40 @@ +{ + "name": "encodeurl", + "description": "Encode a URL to a percent-encoded form, excluding already-encoded sequences", + "version": "1.0.2", + "contributors": [ + "Douglas Christopher Wilson