require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){

},{}],2:[function(require,module,exports){
(function (global){
'use strict';

// compare and isBuffer taken from https://github.com/feross/buffer/blob/680e9e5e488f22aac27599a57dc844a6315928dd/index.js
// original notice:

/*!
 * The buffer module from node.js, for the browser.
 *
 * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
 * @license  MIT
 */
function compare(a, b) {
  if (a === b) {
    return 0;
  }

  var x = a.length;
  var y = b.length;

  for (var i = 0, len = Math.min(x, y); i < len; ++i) {
    if (a[i] !== b[i]) {
      x = a[i];
      y = b[i];
      break;
    }
  }

  if (x < y) {
    return -1;
  }
  if (y < x) {
    return 1;
  }
  return 0;
}
function isBuffer(b) {
  if (global.Buffer && typeof global.Buffer.isBuffer === 'function') {
    return global.Buffer.isBuffer(b);
  }
  return !!(b != null && b._isBuffer);
}

// based on node assert, original notice:

// http://wiki.commonjs.org/wiki/Unit_Testing/1.0
//
// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!
//
// Originally from narwhal.js (http://narwhaljs.org)
// Copyright (c) 2009 Thomas Robinson <280north.com>
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the 'Software'), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS 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.

var util = require('util/');
var hasOwn = Object.prototype.hasOwnProperty;
var pSlice = Array.prototype.slice;
var functionsHaveNames = (function () {
  return function foo() {}.name === 'foo';
}());
function pToString (obj) {
  return Object.prototype.toString.call(obj);
}
function isView(arrbuf) {
  if (isBuffer(arrbuf)) {
    return false;
  }
  if (typeof global.ArrayBuffer !== 'function') {
    return false;
  }
  if (typeof ArrayBuffer.isView === 'function') {
    return ArrayBuffer.isView(arrbuf);
  }
  if (!arrbuf) {
    return false;
  }
  if (arrbuf instanceof DataView) {
    return true;
  }
  if (arrbuf.buffer && arrbuf.buffer instanceof ArrayBuffer) {
    return true;
  }
  return false;
}
// 1. The assert module provides functions that throw
// AssertionError's when particular conditions are not met. The
// assert module must conform to the following interface.

var assert = module.exports = ok;

// 2. The AssertionError is defined in assert.
// new assert.AssertionError({ message: message,
//                             actual: actual,
//                             expected: expected })

var regex = /\s*function\s+([^\(\s]*)\s*/;
// based on https://github.com/ljharb/function.prototype.name/blob/adeeeec8bfcc6068b187d7d9fb3d5bb1d3a30899/implementation.js
function getName(func) {
  if (!util.isFunction(func)) {
    return;
  }
  if (functionsHaveNames) {
    return func.name;
  }
  var str = func.toString();
  var match = str.match(regex);
  return match && match[1];
}
assert.AssertionError = function AssertionError(options) {
  this.name = 'AssertionError';
  this.actual = options.actual;
  this.expected = options.expected;
  this.operator = options.operator;
  if (options.message) {
    this.message = options.message;
    this.generatedMessage = false;
  } else {
    this.message = getMessage(this);
    this.generatedMessage = true;
  }
  var stackStartFunction = options.stackStartFunction || fail;
  if (Error.captureStackTrace) {
    Error.captureStackTrace(this, stackStartFunction);
  } else {
    // non v8 browsers so we can have a stacktrace
    var err = new Error();
    if (err.stack) {
      var out = err.stack;

      // try to strip useless frames
      var fn_name = getName(stackStartFunction);
      var idx = out.indexOf('\n' + fn_name);
      if (idx >= 0) {
        // once we have located the function frame
        // we need to strip out everything before it (and its line)
        var next_line = out.indexOf('\n', idx + 1);
        out = out.substring(next_line + 1);
      }

      this.stack = out;
    }
  }
};

// assert.AssertionError instanceof Error
util.inherits(assert.AssertionError, Error);

function truncate(s, n) {
  if (typeof s === 'string') {
    return s.length < n ? s : s.slice(0, n);
  } else {
    return s;
  }
}
function inspect(something) {
  if (functionsHaveNames || !util.isFunction(something)) {
    return util.inspect(something);
  }
  var rawname = getName(something);
  var name = rawname ? ': ' + rawname : '';
  return '[Function' +  name + ']';
}
function getMessage(self) {
  return truncate(inspect(self.actual), 128) + ' ' +
         self.operator + ' ' +
         truncate(inspect(self.expected), 128);
}

// At present only the three keys mentioned above are used and
// understood by the spec. Implementations or sub modules can pass
// other keys to the AssertionError's constructor - they will be
// ignored.

// 3. All of the following functions must throw an AssertionError
// when a corresponding condition is not met, with a message that
// may be undefined if not provided.  All assertion methods provide
// both the actual and expected values to the assertion error for
// display purposes.

function fail(actual, expected, message, operator, stackStartFunction) {
  throw new assert.AssertionError({
    message: message,
    actual: actual,
    expected: expected,
    operator: operator,
    stackStartFunction: stackStartFunction
  });
}

// EXTENSION! allows for well behaved errors defined elsewhere.
assert.fail = fail;

// 4. Pure assertion tests whether a value is truthy, as determined
// by !!guard.
// assert.ok(guard, message_opt);
// This statement is equivalent to assert.equal(true, !!guard,
// message_opt);. To test strictly for the value true, use
// assert.strictEqual(true, guard, message_opt);.

function ok(value, message) {
  if (!value) fail(value, true, message, '==', assert.ok);
}
assert.ok = ok;

// 5. The equality assertion tests shallow, coercive equality with
// ==.
// assert.equal(actual, expected, message_opt);

assert.equal = function equal(actual, expected, message) {
  if (actual != expected) fail(actual, expected, message, '==', assert.equal);
};

// 6. The non-equality assertion tests for whether two objects are not equal
// with != assert.notEqual(actual, expected, message_opt);

assert.notEqual = function notEqual(actual, expected, message) {
  if (actual == expected) {
    fail(actual, expected, message, '!=', assert.notEqual);
  }
};

// 7. The equivalence assertion tests a deep equality relation.
// assert.deepEqual(actual, expected, message_opt);

assert.deepEqual = function deepEqual(actual, expected, message) {
  if (!_deepEqual(actual, expected, false)) {
    fail(actual, expected, message, 'deepEqual', assert.deepEqual);
  }
};

assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
  if (!_deepEqual(actual, expected, true)) {
    fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual);
  }
};

function _deepEqual(actual, expected, strict, memos) {
  // 7.1. All identical values are equivalent, as determined by ===.
  if (actual === expected) {
    return true;
  } else if (isBuffer(actual) && isBuffer(expected)) {
    return compare(actual, expected) === 0;

  // 7.2. If the expected value is a Date object, the actual value is
  // equivalent if it is also a Date object that refers to the same time.
  } else if (util.isDate(actual) && util.isDate(expected)) {
    return actual.getTime() === expected.getTime();

  // 7.3 If the expected value is a RegExp object, the actual value is
  // equivalent if it is also a RegExp object with the same source and
  // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).
  } else if (util.isRegExp(actual) && util.isRegExp(expected)) {
    return actual.source === expected.source &&
           actual.global === expected.global &&
           actual.multiline === expected.multiline &&
           actual.lastIndex === expected.lastIndex &&
           actual.ignoreCase === expected.ignoreCase;

  // 7.4. Other pairs that do not both pass typeof value == 'object',
  // equivalence is determined by ==.
  } else if ((actual === null || typeof actual !== 'object') &&
             (expected === null || typeof expected !== 'object')) {
    return strict ? actual === expected : actual == expected;

  // If both values are instances of typed arrays, wrap their underlying
  // ArrayBuffers in a Buffer each to increase performance
  // This optimization requires the arrays to have the same type as checked by
  // Object.prototype.toString (aka pToString). Never perform binary
  // comparisons for Float*Arrays, though, since e.g. +0 === -0 but their
  // bit patterns are not identical.
  } else if (isView(actual) && isView(expected) &&
             pToString(actual) === pToString(expected) &&
             !(actual instanceof Float32Array ||
               actual instanceof Float64Array)) {
    return compare(new Uint8Array(actual.buffer),
                   new Uint8Array(expected.buffer)) === 0;

  // 7.5 For all other Object pairs, including Array objects, equivalence is
  // determined by having the same number of owned properties (as verified
  // with Object.prototype.hasOwnProperty.call), the same set of keys
  // (although not necessarily the same order), equivalent values for every
  // corresponding key, and an identical 'prototype' property. Note: this
  // accounts for both named and indexed properties on Arrays.
  } else if (isBuffer(actual) !== isBuffer(expected)) {
    return false;
  } else {
    memos = memos || {actual: [], expected: []};

    var actualIndex = memos.actual.indexOf(actual);
    if (actualIndex !== -1) {
      if (actualIndex === memos.expected.indexOf(expected)) {
        return true;
      }
    }

    memos.actual.push(actual);
    memos.expected.push(expected);

    return objEquiv(actual, expected, strict, memos);
  }
}

function isArguments(object) {
  return Object.prototype.toString.call(object) == '[object Arguments]';
}

function objEquiv(a, b, strict, actualVisitedObjects) {
  if (a === null || a === undefined || b === null || b === undefined)
    return false;
  // if one is a primitive, the other must be same
  if (util.isPrimitive(a) || util.isPrimitive(b))
    return a === b;
  if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))
    return false;
  var aIsArgs = isArguments(a);
  var bIsArgs = isArguments(b);
  if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))
    return false;
  if (aIsArgs) {
    a = pSlice.call(a);
    b = pSlice.call(b);
    return _deepEqual(a, b, strict);
  }
  var ka = objectKeys(a);
  var kb = objectKeys(b);
  var key, i;
  // having the same number of owned properties (keys incorporates
  // hasOwnProperty)
  if (ka.length !== kb.length)
    return false;
  //the same set of keys (although not necessarily the same order),
  ka.sort();
  kb.sort();
  //~~~cheap key test
  for (i = ka.length - 1; i >= 0; i--) {
    if (ka[i] !== kb[i])
      return false;
  }
  //equivalent values for every corresponding key, and
  //~~~possibly expensive deep test
  for (i = ka.length - 1; i >= 0; i--) {
    key = ka[i];
    if (!_deepEqual(a[key], b[key], strict, actualVisitedObjects))
      return false;
  }
  return true;
}

// 8. The non-equivalence assertion tests for any deep inequality.
// assert.notDeepEqual(actual, expected, message_opt);

assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
  if (_deepEqual(actual, expected, false)) {
    fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);
  }
};

assert.notDeepStrictEqual = notDeepStrictEqual;
function notDeepStrictEqual(actual, expected, message) {
  if (_deepEqual(actual, expected, true)) {
    fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual);
  }
}


// 9. The strict equality assertion tests strict equality, as determined by ===.
// assert.strictEqual(actual, expected, message_opt);

assert.strictEqual = function strictEqual(actual, expected, message) {
  if (actual !== expected) {
    fail(actual, expected, message, '===', assert.strictEqual);
  }
};

// 10. The strict non-equality assertion tests for strict inequality, as
// determined by !==.  assert.notStrictEqual(actual, expected, message_opt);

assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
  if (actual === expected) {
    fail(actual, expected, message, '!==', assert.notStrictEqual);
  }
};

function expectedException(actual, expected) {
  if (!actual || !expected) {
    return false;
  }

  if (Object.prototype.toString.call(expected) == '[object RegExp]') {
    return expected.test(actual);
  }

  try {
    if (actual instanceof expected) {
      return true;
    }
  } catch (e) {
    // Ignore.  The instanceof check doesn't work for arrow functions.
  }

  if (Error.isPrototypeOf(expected)) {
    return false;
  }

  return expected.call({}, actual) === true;
}

function _tryBlock(block) {
  var error;
  try {
    block();
  } catch (e) {
    error = e;
  }
  return error;
}

function _throws(shouldThrow, block, expected, message) {
  var actual;

  if (typeof block !== 'function') {
    throw new TypeError('"block" argument must be a function');
  }

  if (typeof expected === 'string') {
    message = expected;
    expected = null;
  }

  actual = _tryBlock(block);

  message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +
            (message ? ' ' + message : '.');

  if (shouldThrow && !actual) {
    fail(actual, expected, 'Missing expected exception' + message);
  }

  var userProvidedMessage = typeof message === 'string';
  var isUnwantedException = !shouldThrow && util.isError(actual);
  var isUnexpectedException = !shouldThrow && actual && !expected;

  if ((isUnwantedException &&
      userProvidedMessage &&
      expectedException(actual, expected)) ||
      isUnexpectedException) {
    fail(actual, expected, 'Got unwanted exception' + message);
  }

  if ((shouldThrow && actual && expected &&
      !expectedException(actual, expected)) || (!shouldThrow && actual)) {
    throw actual;
  }
}

// 11. Expected to throw an error:
// assert.throws(block, Error_opt, message_opt);

assert.throws = function(block, /*optional*/error, /*optional*/message) {
  _throws(true, block, error, message);
};

// EXTENSION! This is annoying to write outside this module.
assert.doesNotThrow = function(block, /*optional*/error, /*optional*/message) {
  _throws(false, block, error, message);
};

assert.ifError = function(err) { if (err) throw err; };

var objectKeys = Object.keys || function (obj) {
  var keys = [];
  for (var key in obj) {
    if (hasOwn.call(obj, key)) keys.push(key);
  }
  return keys;
};

}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{"util/":42}],3:[function(require,module,exports){
'use strict'

exports.byteLength = byteLength
exports.toByteArray = toByteArray
exports.fromByteArray = fromByteArray

var lookup = []
var revLookup = []
var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array

var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
for (var i = 0, len = code.length; i < len; ++i) {
  lookup[i] = code[i]
  revLookup[code.charCodeAt(i)] = i
}

revLookup['-'.charCodeAt(0)] = 62
revLookup['_'.charCodeAt(0)] = 63

function placeHoldersCount (b64) {
  var len = b64.length
  if (len % 4 > 0) {
    throw new Error('Invalid string. Length must be a multiple of 4')
  }

  // the number of equal signs (place holders)
  // if there are two placeholders, than the two characters before it
  // represent one byte
  // if there is only one, then the three characters before it represent 2 bytes
  // this is just a cheap hack to not do indexOf twice
  return b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0
}

function byteLength (b64) {
  // base64 is 4/3 + up to two characters of the original data
  return (b64.length * 3 / 4) - placeHoldersCount(b64)
}

function toByteArray (b64) {
  var i, l, tmp, placeHolders, arr
  var len = b64.length
  placeHolders = placeHoldersCount(b64)

  arr = new Arr((len * 3 / 4) - placeHolders)

  // if there are placeholders, only get up to the last complete 4 chars
  l = placeHolders > 0 ? len - 4 : len

  var L = 0

  for (i = 0; i < l; i += 4) {
    tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]
    arr[L++] = (tmp >> 16) & 0xFF
    arr[L++] = (tmp >> 8) & 0xFF
    arr[L++] = tmp & 0xFF
  }

  if (placeHolders === 2) {
    tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4)
    arr[L++] = tmp & 0xFF
  } else if (placeHolders === 1) {
    tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2)
    arr[L++] = (tmp >> 8) & 0xFF
    arr[L++] = tmp & 0xFF
  }

  return arr
}

function tripletToBase64 (num) {
  return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F]
}

function encodeChunk (uint8, start, end) {
  var tmp
  var output = []
  for (var i = start; i < end; i += 3) {
    tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])
    output.push(tripletToBase64(tmp))
  }
  return output.join('')
}

function fromByteArray (uint8) {
  var tmp
  var len = uint8.length
  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
  var output = ''
  var parts = []
  var maxChunkLength = 16383 // must be multiple of 3

  // go through the array every three bytes, we'll deal with trailing stuff later
  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))
  }

  // pad the end with zeros, but make sure to not forget the extra bytes
  if (extraBytes === 1) {
    tmp = uint8[len - 1]
    output += lookup[tmp >> 2]
    output += lookup[(tmp << 4) & 0x3F]
    output += '=='
  } else if (extraBytes === 2) {
    tmp = (uint8[len - 2] << 8) + (uint8[len - 1])
    output += lookup[tmp >> 10]
    output += lookup[(tmp >> 4) & 0x3F]
    output += lookup[(tmp << 2) & 0x3F]
    output += '='
  }

  parts.push(output)

  return parts.join('')
}

},{}],4:[function(require,module,exports){
arguments[4][1][0].apply(exports,arguments)
},{"dup":1}],5:[function(require,module,exports){
/*!
 * The buffer module from node.js, for the browser.
 *
 * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
 * @license  MIT
 */
/* eslint-disable no-proto */

'use strict'

var base64 = require('base64-js')
var ieee754 = require('ieee754')

exports.Buffer = Buffer
exports.SlowBuffer = SlowBuffer
exports.INSPECT_MAX_BYTES = 50

var K_MAX_LENGTH = 0x7fffffff
exports.kMaxLength = K_MAX_LENGTH

/**
 * If `Buffer.TYPED_ARRAY_SUPPORT`:
 *   === true    Use Uint8Array implementation (fastest)
 *   === false   Print warning and recommend using `buffer` v4.x which has an Object
 *               implementation (most compatible, even IE6)
 *
 * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
 * Opera 11.6+, iOS 4.2+.
 *
 * We report that the browser does not support typed arrays if the are not subclassable
 * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`
 * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support
 * for __proto__ and has a buggy typed array implementation.
 */
Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport()

if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&
    typeof console.error === 'function') {
  console.error(
    'This browser lacks typed array (Uint8Array) support which is required by ' +
    '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'
  )
}

function typedArraySupport () {
  // Can typed array instances can be augmented?
  try {
    var arr = new Uint8Array(1)
    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}
    return arr.foo() === 42
  } catch (e) {
    return false
  }
}

function createBuffer (length) {
  if (length > K_MAX_LENGTH) {
    throw new RangeError('Invalid typed array length')
  }
  // Return an augmented `Uint8Array` instance
  var buf = new Uint8Array(length)
  buf.__proto__ = Buffer.prototype
  return buf
}

/**
 * The Buffer constructor returns instances of `Uint8Array` that have their
 * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
 * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
 * and the `Uint8Array` methods. Square bracket notation works as expected -- it
 * returns a single octet.
 *
 * The `Uint8Array` prototype remains unmodified.
 */

function Buffer (arg, encodingOrOffset, length) {
  // Common case.
  if (typeof arg === 'number') {
    if (typeof encodingOrOffset === 'string') {
      throw new Error(
        'If encoding is specified then the first argument must be a string'
      )
    }
    return allocUnsafe(arg)
  }
  return from(arg, encodingOrOffset, length)
}

// Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
if (typeof Symbol !== 'undefined' && Symbol.species &&
    Buffer[Symbol.species] === Buffer) {
  Object.defineProperty(Buffer, Symbol.species, {
    value: null,
    configurable: true,
    enumerable: false,
    writable: false
  })
}

Buffer.poolSize = 8192 // not used by this implementation

function from (value, encodingOrOffset, length) {
  if (typeof value === 'number') {
    throw new TypeError('"value" argument must not be a number')
  }

  if (isArrayBuffer(value)) {
    return fromArrayBuffer(value, encodingOrOffset, length)
  }

  if (typeof value === 'string') {
    return fromString(value, encodingOrOffset)
  }

  return fromObject(value)
}

/**
 * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
 * if value is a number.
 * Buffer.from(str[, encoding])
 * Buffer.from(array)
 * Buffer.from(buffer)
 * Buffer.from(arrayBuffer[, byteOffset[, length]])
 **/
Buffer.from = function (value, encodingOrOffset, length) {
  return from(value, encodingOrOffset, length)
}

// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:
// https://github.com/feross/buffer/pull/148
Buffer.prototype.__proto__ = Uint8Array.prototype
Buffer.__proto__ = Uint8Array

function assertSize (size) {
  if (typeof size !== 'number') {
    throw new TypeError('"size" argument must be a number')
  } else if (size < 0) {
    throw new RangeError('"size" argument must not be negative')
  }
}

function alloc (size, fill, encoding) {
  assertSize(size)
  if (size <= 0) {
    return createBuffer(size)
  }
  if (fill !== undefined) {
    // Only pay attention to encoding if it's a string. This
    // prevents accidentally sending in a number that would
    // be interpretted as a start offset.
    return typeof encoding === 'string'
      ? createBuffer(size).fill(fill, encoding)
      : createBuffer(size).fill(fill)
  }
  return createBuffer(size)
}

/**
 * Creates a new filled Buffer instance.
 * alloc(size[, fill[, encoding]])
 **/
Buffer.alloc = function (size, fill, encoding) {
  return alloc(size, fill, encoding)
}

function allocUnsafe (size) {
  assertSize(size)
  return createBuffer(size < 0 ? 0 : checked(size) | 0)
}

/**
 * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
 * */
Buffer.allocUnsafe = function (size) {
  return allocUnsafe(size)
}
/**
 * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
 */
Buffer.allocUnsafeSlow = function (size) {
  return allocUnsafe(size)
}

function fromString (string, encoding) {
  if (typeof encoding !== 'string' || encoding === '') {
    encoding = 'utf8'
  }

  if (!Buffer.isEncoding(encoding)) {
    throw new TypeError('"encoding" must be a valid string encoding')
  }

  var length = byteLength(string, encoding) | 0
  var buf = createBuffer(length)

  var actual = buf.write(string, encoding)

  if (actual !== length) {
    // Writing a hex string, for example, that contains invalid characters will
    // cause everything after the first invalid character to be ignored. (e.g.
    // 'abxxcd' will be treated as 'ab')
    buf = buf.slice(0, actual)
  }

  return buf
}

function fromArrayLike (array) {
  var length = array.length < 0 ? 0 : checked(array.length) | 0
  var buf = createBuffer(length)
  for (var i = 0; i < length; i += 1) {
    buf[i] = array[i] & 255
  }
  return buf
}

function fromArrayBuffer (array, byteOffset, length) {
  if (byteOffset < 0 || array.byteLength < byteOffset) {
    throw new RangeError('\'offset\' is out of bounds')
  }

  if (array.byteLength < byteOffset + (length || 0)) {
    throw new RangeError('\'length\' is out of bounds')
  }

  var buf
  if (byteOffset === undefined && length === undefined) {
    buf = new Uint8Array(array)
  } else if (length === undefined) {
    buf = new Uint8Array(array, byteOffset)
  } else {
    buf = new Uint8Array(array, byteOffset, length)
  }

  // Return an augmented `Uint8Array` instance
  buf.__proto__ = Buffer.prototype
  return buf
}

function fromObject (obj) {
  if (Buffer.isBuffer(obj)) {
    var len = checked(obj.length) | 0
    var buf = createBuffer(len)

    if (buf.length === 0) {
      return buf
    }

    obj.copy(buf, 0, 0, len)
    return buf
  }

  if (obj) {
    if (isArrayBufferView(obj) || 'length' in obj) {
      if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {
        return createBuffer(0)
      }
      return fromArrayLike(obj)
    }

    if (obj.type === 'Buffer' && Array.isArray(obj.data)) {
      return fromArrayLike(obj.data)
    }
  }

  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')
}

function checked (length) {
  // Note: cannot use `length < K_MAX_LENGTH` here because that fails when
  // length is NaN (which is otherwise coerced to zero.)
  if (length >= K_MAX_LENGTH) {
    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
                         'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')
  }
  return length | 0
}

function SlowBuffer (length) {
  if (+length != length) { // eslint-disable-line eqeqeq
    length = 0
  }
  return Buffer.alloc(+length)
}

Buffer.isBuffer = function isBuffer (b) {
  return b != null && b._isBuffer === true
}

Buffer.compare = function compare (a, b) {
  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
    throw new TypeError('Arguments must be Buffers')
  }

  if (a === b) return 0

  var x = a.length
  var y = b.length

  for (var i = 0, len = Math.min(x, y); i < len; ++i) {
    if (a[i] !== b[i]) {
      x = a[i]
      y = b[i]
      break
    }
  }

  if (x < y) return -1
  if (y < x) return 1
  return 0
}

Buffer.isEncoding = function isEncoding (encoding) {
  switch (String(encoding).toLowerCase()) {
    case 'hex':
    case 'utf8':
    case 'utf-8':
    case 'ascii':
    case 'latin1':
    case 'binary':
    case 'base64':
    case 'ucs2':
    case 'ucs-2':
    case 'utf16le':
    case 'utf-16le':
      return true
    default:
      return false
  }
}

Buffer.concat = function concat (list, length) {
  if (!Array.isArray(list)) {
    throw new TypeError('"list" argument must be an Array of Buffers')
  }

  if (list.length === 0) {
    return Buffer.alloc(0)
  }

  var i
  if (length === undefined) {
    length = 0
    for (i = 0; i < list.length; ++i) {
      length += list[i].length
    }
  }

  var buffer = Buffer.allocUnsafe(length)
  var pos = 0
  for (i = 0; i < list.length; ++i) {
    var buf = list[i]
    if (!Buffer.isBuffer(buf)) {
      throw new TypeError('"list" argument must be an Array of Buffers')
    }
    buf.copy(buffer, pos)
    pos += buf.length
  }
  return buffer
}

function byteLength (string, encoding) {
  if (Buffer.isBuffer(string)) {
    return string.length
  }
  if (isArrayBufferView(string) || isArrayBuffer(string)) {
    return string.byteLength
  }
  if (typeof string !== 'string') {
    string = '' + string
  }

  var len = string.length
  if (len === 0) return 0

  // Use a for loop to avoid recursion
  var loweredCase = false
  for (;;) {
    switch (encoding) {
      case 'ascii':
      case 'latin1':
      case 'binary':
        return len
      case 'utf8':
      case 'utf-8':
      case undefined:
        return utf8ToBytes(string).length
      case 'ucs2':
      case 'ucs-2':
      case 'utf16le':
      case 'utf-16le':
        return len * 2
      case 'hex':
        return len >>> 1
      case 'base64':
        return base64ToBytes(string).length
      default:
        if (loweredCase) return utf8ToBytes(string).length // assume utf8
        encoding = ('' + encoding).toLowerCase()
        loweredCase = true
    }
  }
}
Buffer.byteLength = byteLength

function slowToString (encoding, start, end) {
  var loweredCase = false

  // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
  // property of a typed array.

  // This behaves neither like String nor Uint8Array in that we set start/end
  // to their upper/lower bounds if the value passed is out of range.
  // undefined is handled specially as per ECMA-262 6th Edition,
  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
  if (start === undefined || start < 0) {
    start = 0
  }
  // Return early if start > this.length. Done here to prevent potential uint32
  // coercion fail below.
  if (start > this.length) {
    return ''
  }

  if (end === undefined || end > this.length) {
    end = this.length
  }

  if (end <= 0) {
    return ''
  }

  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
  end >>>= 0
  start >>>= 0

  if (end <= start) {
    return ''
  }

  if (!encoding) encoding = 'utf8'

  while (true) {
    switch (encoding) {
      case 'hex':
        return hexSlice(this, start, end)

      case 'utf8':
      case 'utf-8':
        return utf8Slice(this, start, end)

      case 'ascii':
        return asciiSlice(this, start, end)

      case 'latin1':
      case 'binary':
        return latin1Slice(this, start, end)

      case 'base64':
        return base64Slice(this, start, end)

      case 'ucs2':
      case 'ucs-2':
      case 'utf16le':
      case 'utf-16le':
        return utf16leSlice(this, start, end)

      default:
        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
        encoding = (encoding + '').toLowerCase()
        loweredCase = true
    }
  }
}

// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)
// to detect a Buffer instance. It's not possible to use `instanceof Buffer`
// reliably in a browserify context because there could be multiple different
// copies of the 'buffer' package in use. This method works even for Buffer
// instances that were created from another copy of the `buffer` package.
// See: https://github.com/feross/buffer/issues/154
Buffer.prototype._isBuffer = true

function swap (b, n, m) {
  var i = b[n]
  b[n] = b[m]
  b[m] = i
}

Buffer.prototype.swap16 = function swap16 () {
  var len = this.length
  if (len % 2 !== 0) {
    throw new RangeError('Buffer size must be a multiple of 16-bits')
  }
  for (var i = 0; i < len; i += 2) {
    swap(this, i, i + 1)
  }
  return this
}

Buffer.prototype.swap32 = function swap32 () {
  var len = this.length
  if (len % 4 !== 0) {
    throw new RangeError('Buffer size must be a multiple of 32-bits')
  }
  for (var i = 0; i < len; i += 4) {
    swap(this, i, i + 3)
    swap(this, i + 1, i + 2)
  }
  return this
}

Buffer.prototype.swap64 = function swap64 () {
  var len = this.length
  if (len % 8 !== 0) {
    throw new RangeError('Buffer size must be a multiple of 64-bits')
  }
  for (var i = 0; i < len; i += 8) {
    swap(this, i, i + 7)
    swap(this, i + 1, i + 6)
    swap(this, i + 2, i + 5)
    swap(this, i + 3, i + 4)
  }
  return this
}

Buffer.prototype.toString = function toString () {
  var length = this.length
  if (length === 0) return ''
  if (arguments.length === 0) return utf8Slice(this, 0, length)
  return slowToString.apply(this, arguments)
}

Buffer.prototype.equals = function equals (b) {
  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
  if (this === b) return true
  return Buffer.compare(this, b) === 0
}

Buffer.prototype.inspect = function inspect () {
  var str = ''
  var max = exports.INSPECT_MAX_BYTES
  if (this.length > 0) {
    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')
    if (this.length > max) str += ' ... '
  }
  return '<Buffer ' + str + '>'
}

Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
  if (!Buffer.isBuffer(target)) {
    throw new TypeError('Argument must be a Buffer')
  }

  if (start === undefined) {
    start = 0
  }
  if (end === undefined) {
    end = target ? target.length : 0
  }
  if (thisStart === undefined) {
    thisStart = 0
  }
  if (thisEnd === undefined) {
    thisEnd = this.length
  }

  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
    throw new RangeError('out of range index')
  }

  if (thisStart >= thisEnd && start >= end) {
    return 0
  }
  if (thisStart >= thisEnd) {
    return -1
  }
  if (start >= end) {
    return 1
  }

  start >>>= 0
  end >>>= 0
  thisStart >>>= 0
  thisEnd >>>= 0

  if (this === target) return 0

  var x = thisEnd - thisStart
  var y = end - start
  var len = Math.min(x, y)

  var thisCopy = this.slice(thisStart, thisEnd)
  var targetCopy = target.slice(start, end)

  for (var i = 0; i < len; ++i) {
    if (thisCopy[i] !== targetCopy[i]) {
      x = thisCopy[i]
      y = targetCopy[i]
      break
    }
  }

  if (x < y) return -1
  if (y < x) return 1
  return 0
}

// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
//
// Arguments:
// - buffer - a Buffer to search
// - val - a string, Buffer, or number
// - byteOffset - an index into `buffer`; will be clamped to an int32
// - encoding - an optional encoding, relevant is val is a string
// - dir - true for indexOf, false for lastIndexOf
function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
  // Empty buffer means no match
  if (buffer.length === 0) return -1

  // Normalize byteOffset
  if (typeof byteOffset === 'string') {
    encoding = byteOffset
    byteOffset = 0
  } else if (byteOffset > 0x7fffffff) {
    byteOffset = 0x7fffffff
  } else if (byteOffset < -0x80000000) {
    byteOffset = -0x80000000
  }
  byteOffset = +byteOffset  // Coerce to Number.
  if (numberIsNaN(byteOffset)) {
    // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
    byteOffset = dir ? 0 : (buffer.length - 1)
  }

  // Normalize byteOffset: negative offsets start from the end of the buffer
  if (byteOffset < 0) byteOffset = buffer.length + byteOffset
  if (byteOffset >= buffer.length) {
    if (dir) return -1
    else byteOffset = buffer.length - 1
  } else if (byteOffset < 0) {
    if (dir) byteOffset = 0
    else return -1
  }

  // Normalize val
  if (typeof val === 'string') {
    val = Buffer.from(val, encoding)
  }

  // Finally, search either indexOf (if dir is true) or lastIndexOf
  if (Buffer.isBuffer(val)) {
    // Special case: looking for empty string/buffer always fails
    if (val.length === 0) {
      return -1
    }
    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
  } else if (typeof val === 'number') {
    val = val & 0xFF // Search for a byte value [0-255]
    if (typeof Uint8Array.prototype.indexOf === 'function') {
      if (dir) {
        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
      } else {
        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
      }
    }
    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
  }

  throw new TypeError('val must be string, number or Buffer')
}

function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
  var indexSize = 1
  var arrLength = arr.length
  var valLength = val.length

  if (encoding !== undefined) {
    encoding = String(encoding).toLowerCase()
    if (encoding === 'ucs2' || encoding === 'ucs-2' ||
        encoding === 'utf16le' || encoding === 'utf-16le') {
      if (arr.length < 2 || val.length < 2) {
        return -1
      }
      indexSize = 2
      arrLength /= 2
      valLength /= 2
      byteOffset /= 2
    }
  }

  function read (buf, i) {
    if (indexSize === 1) {
      return buf[i]
    } else {
      return buf.readUInt16BE(i * indexSize)
    }
  }

  var i
  if (dir) {
    var foundIndex = -1
    for (i = byteOffset; i < arrLength; i++) {
      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
        if (foundIndex === -1) foundIndex = i
        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
      } else {
        if (foundIndex !== -1) i -= i - foundIndex
        foundIndex = -1
      }
    }
  } else {
    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
    for (i = byteOffset; i >= 0; i--) {
      var found = true
      for (var j = 0; j < valLength; j++) {
        if (read(arr, i + j) !== read(val, j)) {
          found = false
          break
        }
      }
      if (found) return i
    }
  }

  return -1
}

Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
  return this.indexOf(val, byteOffset, encoding) !== -1
}

Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
}

Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
}

function hexWrite (buf, string, offset, length) {
  offset = Number(offset) || 0
  var remaining = buf.length - offset
  if (!length) {
    length = remaining
  } else {
    length = Number(length)
    if (length > remaining) {
      length = remaining
    }
  }

  // must be an even number of digits
  var strLen = string.length
  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')

  if (length > strLen / 2) {
    length = strLen / 2
  }
  for (var i = 0; i < length; ++i) {
    var parsed = parseInt(string.substr(i * 2, 2), 16)
    if (numberIsNaN(parsed)) return i
    buf[offset + i] = parsed
  }
  return i
}

function utf8Write (buf, string, offset, length) {
  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
}

function asciiWrite (buf, string, offset, length) {
  return blitBuffer(asciiToBytes(string), buf, offset, length)
}

function latin1Write (buf, string, offset, length) {
  return asciiWrite(buf, string, offset, length)
}

function base64Write (buf, string, offset, length) {
  return blitBuffer(base64ToBytes(string), buf, offset, length)
}

function ucs2Write (buf, string, offset, length) {
  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
}

Buffer.prototype.write = function write (string, offset, length, encoding) {
  // Buffer#write(string)
  if (offset === undefined) {
    encoding = 'utf8'
    length = this.length
    offset = 0
  // Buffer#write(string, encoding)
  } else if (length === undefined && typeof offset === 'string') {
    encoding = offset
    length = this.length
    offset = 0
  // Buffer#write(string, offset[, length][, encoding])
  } else if (isFinite(offset)) {
    offset = offset >>> 0
    if (isFinite(length)) {
      length = length >>> 0
      if (encoding === undefined) encoding = 'utf8'
    } else {
      encoding = length
      length = undefined
    }
  } else {
    throw new Error(
      'Buffer.write(string, encoding, offset[, length]) is no longer supported'
    )
  }

  var remaining = this.length - offset
  if (length === undefined || length > remaining) length = remaining

  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
    throw new RangeError('Attempt to write outside buffer bounds')
  }

  if (!encoding) encoding = 'utf8'

  var loweredCase = false
  for (;;) {
    switch (encoding) {
      case 'hex':
        return hexWrite(this, string, offset, length)

      case 'utf8':
      case 'utf-8':
        return utf8Write(this, string, offset, length)

      case 'ascii':
        return asciiWrite(this, string, offset, length)

      case 'latin1':
      case 'binary':
        return latin1Write(this, string, offset, length)

      case 'base64':
        // Warning: maxLength not taken into account in base64Write
        return base64Write(this, string, offset, length)

      case 'ucs2':
      case 'ucs-2':
      case 'utf16le':
      case 'utf-16le':
        return ucs2Write(this, string, offset, length)

      default:
        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
        encoding = ('' + encoding).toLowerCase()
        loweredCase = true
    }
  }
}

Buffer.prototype.toJSON = function toJSON () {
  return {
    type: 'Buffer',
    data: Array.prototype.slice.call(this._arr || this, 0)
  }
}

function base64Slice (buf, start, end) {
  if (start === 0 && end === buf.length) {
    return base64.fromByteArray(buf)
  } else {
    return base64.fromByteArray(buf.slice(start, end))
  }
}

function utf8Slice (buf, start, end) {
  end = Math.min(buf.length, end)
  var res = []

  var i = start
  while (i < end) {
    var firstByte = buf[i]
    var codePoint = null
    var bytesPerSequence = (firstByte > 0xEF) ? 4
      : (firstByte > 0xDF) ? 3
      : (firstByte > 0xBF) ? 2
      : 1

    if (i + bytesPerSequence <= end) {
      var secondByte, thirdByte, fourthByte, tempCodePoint

      switch (bytesPerSequence) {
        case 1:
          if (firstByte < 0x80) {
            codePoint = firstByte
          }
          break
        case 2:
          secondByte = buf[i + 1]
          if ((secondByte & 0xC0) === 0x80) {
            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
            if (tempCodePoint > 0x7F) {
              codePoint = tempCodePoint
            }
          }
          break
        case 3:
          secondByte = buf[i + 1]
          thirdByte = buf[i + 2]
          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
              codePoint = tempCodePoint
            }
          }
          break
        case 4:
          secondByte = buf[i + 1]
          thirdByte = buf[i + 2]
          fourthByte = buf[i + 3]
          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
              codePoint = tempCodePoint
            }
          }
      }
    }

    if (codePoint === null) {
      // we did not generate a valid codePoint so insert a
      // replacement char (U+FFFD) and advance only 1 byte
      codePoint = 0xFFFD
      bytesPerSequence = 1
    } else if (codePoint > 0xFFFF) {
      // encode to utf16 (surrogate pair dance)
      codePoint -= 0x10000
      res.push(codePoint >>> 10 & 0x3FF | 0xD800)
      codePoint = 0xDC00 | codePoint & 0x3FF
    }

    res.push(codePoint)
    i += bytesPerSequence
  }

  return decodeCodePointsArray(res)
}

// Based on http://stackoverflow.com/a/22747272/680742, the browser with
// the lowest limit is Chrome, with 0x10000 args.
// We go 1 magnitude less, for safety
var MAX_ARGUMENTS_LENGTH = 0x1000

function decodeCodePointsArray (codePoints) {
  var len = codePoints.length
  if (len <= MAX_ARGUMENTS_LENGTH) {
    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
  }

  // Decode in chunks to avoid "call stack size exceeded".
  var res = ''
  var i = 0
  while (i < len) {
    res += String.fromCharCode.apply(
      String,
      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
    )
  }
  return res
}

function asciiSlice (buf, start, end) {
  var ret = ''
  end = Math.min(buf.length, end)

  for (var i = start; i < end; ++i) {
    ret += String.fromCharCode(buf[i] & 0x7F)
  }
  return ret
}

function latin1Slice (buf, start, end) {
  var ret = ''
  end = Math.min(buf.length, end)

  for (var i = start; i < end; ++i) {
    ret += String.fromCharCode(buf[i])
  }
  return ret
}

function hexSlice (buf, start, end) {
  var len = buf.length

  if (!start || start < 0) start = 0
  if (!end || end < 0 || end > len) end = len

  var out = ''
  for (var i = start; i < end; ++i) {
    out += toHex(buf[i])
  }
  return out
}

function utf16leSlice (buf, start, end) {
  var bytes = buf.slice(start, end)
  var res = ''
  for (var i = 0; i < bytes.length; i += 2) {
    res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256))
  }
  return res
}

Buffer.prototype.slice = function slice (start, end) {
  var len = this.length
  start = ~~start
  end = end === undefined ? len : ~~end

  if (start < 0) {
    start += len
    if (start < 0) start = 0
  } else if (start > len) {
    start = len
  }

  if (end < 0) {
    end += len
    if (end < 0) end = 0
  } else if (end > len) {
    end = len
  }

  if (end < start) end = start

  var newBuf = this.subarray(start, end)
  // Return an augmented `Uint8Array` instance
  newBuf.__proto__ = Buffer.prototype
  return newBuf
}

/*
 * Need to make sure that buffer isn't trying to write out of bounds.
 */
function checkOffset (offset, ext, length) {
  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
}

Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
  offset = offset >>> 0
  byteLength = byteLength >>> 0
  if (!noAssert) checkOffset(offset, byteLength, this.length)

  var val = this[offset]
  var mul = 1
  var i = 0
  while (++i < byteLength && (mul *= 0x100)) {
    val += this[offset + i] * mul
  }

  return val
}

Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
  offset = offset >>> 0
  byteLength = byteLength >>> 0
  if (!noAssert) {
    checkOffset(offset, byteLength, this.length)
  }

  var val = this[offset + --byteLength]
  var mul = 1
  while (byteLength > 0 && (mul *= 0x100)) {
    val += this[offset + --byteLength] * mul
  }

  return val
}

Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 1, this.length)
  return this[offset]
}

Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 2, this.length)
  return this[offset] | (this[offset + 1] << 8)
}

Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 2, this.length)
  return (this[offset] << 8) | this[offset + 1]
}

Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 4, this.length)

  return ((this[offset]) |
      (this[offset + 1] << 8) |
      (this[offset + 2] << 16)) +
      (this[offset + 3] * 0x1000000)
}

Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 4, this.length)

  return (this[offset] * 0x1000000) +
    ((this[offset + 1] << 16) |
    (this[offset + 2] << 8) |
    this[offset + 3])
}

Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
  offset = offset >>> 0
  byteLength = byteLength >>> 0
  if (!noAssert) checkOffset(offset, byteLength, this.length)

  var val = this[offset]
  var mul = 1
  var i = 0
  while (++i < byteLength && (mul *= 0x100)) {
    val += this[offset + i] * mul
  }
  mul *= 0x80

  if (val >= mul) val -= Math.pow(2, 8 * byteLength)

  return val
}

Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
  offset = offset >>> 0
  byteLength = byteLength >>> 0
  if (!noAssert) checkOffset(offset, byteLength, this.length)

  var i = byteLength
  var mul = 1
  var val = this[offset + --i]
  while (i > 0 && (mul *= 0x100)) {
    val += this[offset + --i] * mul
  }
  mul *= 0x80

  if (val >= mul) val -= Math.pow(2, 8 * byteLength)

  return val
}

Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 1, this.length)
  if (!(this[offset] & 0x80)) return (this[offset])
  return ((0xff - this[offset] + 1) * -1)
}

Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 2, this.length)
  var val = this[offset] | (this[offset + 1] << 8)
  return (val & 0x8000) ? val | 0xFFFF0000 : val
}

Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 2, this.length)
  var val = this[offset + 1] | (this[offset] << 8)
  return (val & 0x8000) ? val | 0xFFFF0000 : val
}

Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 4, this.length)

  return (this[offset]) |
    (this[offset + 1] << 8) |
    (this[offset + 2] << 16) |
    (this[offset + 3] << 24)
}

Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 4, this.length)

  return (this[offset] << 24) |
    (this[offset + 1] << 16) |
    (this[offset + 2] << 8) |
    (this[offset + 3])
}

Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 4, this.length)
  return ieee754.read(this, offset, true, 23, 4)
}

Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 4, this.length)
  return ieee754.read(this, offset, false, 23, 4)
}

Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 8, this.length)
  return ieee754.read(this, offset, true, 52, 8)
}

Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 8, this.length)
  return ieee754.read(this, offset, false, 52, 8)
}

function checkInt (buf, value, offset, ext, max, min) {
  if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
  if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
  if (offset + ext > buf.length) throw new RangeError('Index out of range')
}

Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
  value = +value
  offset = offset >>> 0
  byteLength = byteLength >>> 0
  if (!noAssert) {
    var maxBytes = Math.pow(2, 8 * byteLength) - 1
    checkInt(this, value, offset, byteLength, maxBytes, 0)
  }

  var mul = 1
  var i = 0
  this[offset] = value & 0xFF
  while (++i < byteLength && (mul *= 0x100)) {
    this[offset + i] = (value / mul) & 0xFF
  }

  return offset + byteLength
}

Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
  value = +value
  offset = offset >>> 0
  byteLength = byteLength >>> 0
  if (!noAssert) {
    var maxBytes = Math.pow(2, 8 * byteLength) - 1
    checkInt(this, value, offset, byteLength, maxBytes, 0)
  }

  var i = byteLength - 1
  var mul = 1
  this[offset + i] = value & 0xFF
  while (--i >= 0 && (mul *= 0x100)) {
    this[offset + i] = (value / mul) & 0xFF
  }

  return offset + byteLength
}

Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
  this[offset] = (value & 0xff)
  return offset + 1
}

Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
  this[offset] = (value & 0xff)
  this[offset + 1] = (value >>> 8)
  return offset + 2
}

Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
  this[offset] = (value >>> 8)
  this[offset + 1] = (value & 0xff)
  return offset + 2
}

Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
  this[offset + 3] = (value >>> 24)
  this[offset + 2] = (value >>> 16)
  this[offset + 1] = (value >>> 8)
  this[offset] = (value & 0xff)
  return offset + 4
}

Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
  this[offset] = (value >>> 24)
  this[offset + 1] = (value >>> 16)
  this[offset + 2] = (value >>> 8)
  this[offset + 3] = (value & 0xff)
  return offset + 4
}

Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) {
    var limit = Math.pow(2, (8 * byteLength) - 1)

    checkInt(this, value, offset, byteLength, limit - 1, -limit)
  }

  var i = 0
  var mul = 1
  var sub = 0
  this[offset] = value & 0xFF
  while (++i < byteLength && (mul *= 0x100)) {
    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
      sub = 1
    }
    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
  }

  return offset + byteLength
}

Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) {
    var limit = Math.pow(2, (8 * byteLength) - 1)

    checkInt(this, value, offset, byteLength, limit - 1, -limit)
  }

  var i = byteLength - 1
  var mul = 1
  var sub = 0
  this[offset + i] = value & 0xFF
  while (--i >= 0 && (mul *= 0x100)) {
    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
      sub = 1
    }
    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
  }

  return offset + byteLength
}

Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
  if (value < 0) value = 0xff + value + 1
  this[offset] = (value & 0xff)
  return offset + 1
}

Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
  this[offset] = (value & 0xff)
  this[offset + 1] = (value >>> 8)
  return offset + 2
}

Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
  this[offset] = (value >>> 8)
  this[offset + 1] = (value & 0xff)
  return offset + 2
}

Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
  this[offset] = (value & 0xff)
  this[offset + 1] = (value >>> 8)
  this[offset + 2] = (value >>> 16)
  this[offset + 3] = (value >>> 24)
  return offset + 4
}

Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
  if (value < 0) value = 0xffffffff + value + 1
  this[offset] = (value >>> 24)
  this[offset + 1] = (value >>> 16)
  this[offset + 2] = (value >>> 8)
  this[offset + 3] = (value & 0xff)
  return offset + 4
}

function checkIEEE754 (buf, value, offset, ext, max, min) {
  if (offset + ext > buf.length) throw new RangeError('Index out of range')
  if (offset < 0) throw new RangeError('Index out of range')
}

function writeFloat (buf, value, offset, littleEndian, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) {
    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
  }
  ieee754.write(buf, value, offset, littleEndian, 23, 4)
  return offset + 4
}

Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
  return writeFloat(this, value, offset, true, noAssert)
}

Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
  return writeFloat(this, value, offset, false, noAssert)
}

function writeDouble (buf, value, offset, littleEndian, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) {
    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
  }
  ieee754.write(buf, value, offset, littleEndian, 52, 8)
  return offset + 8
}

Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
  return writeDouble(this, value, offset, true, noAssert)
}

Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
  return writeDouble(this, value, offset, false, noAssert)
}

// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
Buffer.prototype.copy = function copy (target, targetStart, start, end) {
  if (!start) start = 0
  if (!end && end !== 0) end = this.length
  if (targetStart >= target.length) targetStart = target.length
  if (!targetStart) targetStart = 0
  if (end > 0 && end < start) end = start

  // Copy 0 bytes; we're done
  if (end === start) return 0
  if (target.length === 0 || this.length === 0) return 0

  // Fatal error conditions
  if (targetStart < 0) {
    throw new RangeError('targetStart out of bounds')
  }
  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')
  if (end < 0) throw new RangeError('sourceEnd out of bounds')

  // Are we oob?
  if (end > this.length) end = this.length
  if (target.length - targetStart < end - start) {
    end = target.length - targetStart + start
  }

  var len = end - start
  var i

  if (this === target && start < targetStart && targetStart < end) {
    // descending copy from end
    for (i = len - 1; i >= 0; --i) {
      target[i + targetStart] = this[i + start]
    }
  } else if (len < 1000) {
    // ascending copy from start
    for (i = 0; i < len; ++i) {
      target[i + targetStart] = this[i + start]
    }
  } else {
    Uint8Array.prototype.set.call(
      target,
      this.subarray(start, start + len),
      targetStart
    )
  }

  return len
}

// Usage:
//    buffer.fill(number[, offset[, end]])
//    buffer.fill(buffer[, offset[, end]])
//    buffer.fill(string[, offset[, end]][, encoding])
Buffer.prototype.fill = function fill (val, start, end, encoding) {
  // Handle string cases:
  if (typeof val === 'string') {
    if (typeof start === 'string') {
      encoding = start
      start = 0
      end = this.length
    } else if (typeof end === 'string') {
      encoding = end
      end = this.length
    }
    if (val.length === 1) {
      var code = val.charCodeAt(0)
      if (code < 256) {
        val = code
      }
    }
    if (encoding !== undefined && typeof encoding !== 'string') {
      throw new TypeError('encoding must be a string')
    }
    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
      throw new TypeError('Unknown encoding: ' + encoding)
    }
  } else if (typeof val === 'number') {
    val = val & 255
  }

  // Invalid ranges are not set to a default, so can range check early.
  if (start < 0 || this.length < start || this.length < end) {
    throw new RangeError('Out of range index')
  }

  if (end <= start) {
    return this
  }

  start = start >>> 0
  end = end === undefined ? this.length : end >>> 0

  if (!val) val = 0

  var i
  if (typeof val === 'number') {
    for (i = start; i < end; ++i) {
      this[i] = val
    }
  } else {
    var bytes = Buffer.isBuffer(val)
      ? val
      : new Buffer(val, encoding)
    var len = bytes.length
    for (i = 0; i < end - start; ++i) {
      this[i + start] = bytes[i % len]
    }
  }

  return this
}

// HELPER FUNCTIONS
// ================

var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g

function base64clean (str) {
  // Node strips out invalid characters like \n and \t from the string, base64-js does not
  str = str.trim().replace(INVALID_BASE64_RE, '')
  // Node converts strings with length < 2 to ''
  if (str.length < 2) return ''
  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
  while (str.length % 4 !== 0) {
    str = str + '='
  }
  return str
}

function toHex (n) {
  if (n < 16) return '0' + n.toString(16)
  return n.toString(16)
}

function utf8ToBytes (string, units) {
  units = units || Infinity
  var codePoint
  var length = string.length
  var leadSurrogate = null
  var bytes = []

  for (var i = 0; i < length; ++i) {
    codePoint = string.charCodeAt(i)

    // is surrogate component
    if (codePoint > 0xD7FF && codePoint < 0xE000) {
      // last char was a lead
      if (!leadSurrogate) {
        // no lead yet
        if (codePoint > 0xDBFF) {
          // unexpected trail
          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
          continue
        } else if (i + 1 === length) {
          // unpaired lead
          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
          continue
        }

        // valid lead
        leadSurrogate = codePoint

        continue
      }

      // 2 leads in a row
      if (codePoint < 0xDC00) {
        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
        leadSurrogate = codePoint
        continue
      }

      // valid surrogate pair
      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
    } else if (leadSurrogate) {
      // valid bmp char, but last char was a lead
      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
    }

    leadSurrogate = null

    // encode utf8
    if (codePoint < 0x80) {
      if ((units -= 1) < 0) break
      bytes.push(codePoint)
    } else if (codePoint < 0x800) {
      if ((units -= 2) < 0) break
      bytes.push(
        codePoint >> 0x6 | 0xC0,
        codePoint & 0x3F | 0x80
      )
    } else if (codePoint < 0x10000) {
      if ((units -= 3) < 0) break
      bytes.push(
        codePoint >> 0xC | 0xE0,
        codePoint >> 0x6 & 0x3F | 0x80,
        codePoint & 0x3F | 0x80
      )
    } else if (codePoint < 0x110000) {
      if ((units -= 4) < 0) break
      bytes.push(
        codePoint >> 0x12 | 0xF0,
        codePoint >> 0xC & 0x3F | 0x80,
        codePoint >> 0x6 & 0x3F | 0x80,
        codePoint & 0x3F | 0x80
      )
    } else {
      throw new Error('Invalid code point')
    }
  }

  return bytes
}

function asciiToBytes (str) {
  var byteArray = []
  for (var i = 0; i < str.length; ++i) {
    // Node's code seems to be doing this and not & 0x7F..
    byteArray.push(str.charCodeAt(i) & 0xFF)
  }
  return byteArray
}

function utf16leToBytes (str, units) {
  var c, hi, lo
  var byteArray = []
  for (var i = 0; i < str.length; ++i) {
    if ((units -= 2) < 0) break

    c = str.charCodeAt(i)
    hi = c >> 8
    lo = c % 256
    byteArray.push(lo)
    byteArray.push(hi)
  }

  return byteArray
}

function base64ToBytes (str) {
  return base64.toByteArray(base64clean(str))
}

function blitBuffer (src, dst, offset, length) {
  for (var i = 0; i < length; ++i) {
    if ((i + offset >= dst.length) || (i >= src.length)) break
    dst[i + offset] = src[i]
  }
  return i
}

// ArrayBuffers from another context (i.e. an iframe) do not pass the `instanceof` check
// but they should be treated as valid. See: https://github.com/feross/buffer/issues/166
function isArrayBuffer (obj) {
  return obj instanceof ArrayBuffer ||
    (obj != null && obj.constructor != null && obj.constructor.name === 'ArrayBuffer' &&
      typeof obj.byteLength === 'number')
}

// Node 0.10 supports `ArrayBuffer` but lacks `ArrayBuffer.isView`
function isArrayBufferView (obj) {
  return (typeof ArrayBuffer.isView === 'function') && ArrayBuffer.isView(obj)
}

function numberIsNaN (obj) {
  return obj !== obj // eslint-disable-line no-self-compare
}

},{"base64-js":3,"ieee754":9}],6:[function(require,module,exports){
module.exports={
  "O_RDONLY": 0,
  "O_WRONLY": 1,
  "O_RDWR": 2,
  "S_IFMT": 61440,
  "S_IFREG": 32768,
  "S_IFDIR": 16384,
  "S_IFCHR": 8192,
  "S_IFBLK": 24576,
  "S_IFIFO": 4096,
  "S_IFLNK": 40960,
  "S_IFSOCK": 49152,
  "O_CREAT": 512,
  "O_EXCL": 2048,
  "O_NOCTTY": 131072,
  "O_TRUNC": 1024,
  "O_APPEND": 8,
  "O_DIRECTORY": 1048576,
  "O_NOFOLLOW": 256,
  "O_SYNC": 128,
  "O_SYMLINK": 2097152,
  "O_NONBLOCK": 4,
  "S_IRWXU": 448,
  "S_IRUSR": 256,
  "S_IWUSR": 128,
  "S_IXUSR": 64,
  "S_IRWXG": 56,
  "S_IRGRP": 32,
  "S_IWGRP": 16,
  "S_IXGRP": 8,
  "S_IRWXO": 7,
  "S_IROTH": 4,
  "S_IWOTH": 2,
  "S_IXOTH": 1,
  "E2BIG": 7,
  "EACCES": 13,
  "EADDRINUSE": 48,
  "EADDRNOTAVAIL": 49,
  "EAFNOSUPPORT": 47,
  "EAGAIN": 35,
  "EALREADY": 37,
  "EBADF": 9,
  "EBADMSG": 94,
  "EBUSY": 16,
  "ECANCELED": 89,
  "ECHILD": 10,
  "ECONNABORTED": 53,
  "ECONNREFUSED": 61,
  "ECONNRESET": 54,
  "EDEADLK": 11,
  "EDESTADDRREQ": 39,
  "EDOM": 33,
  "EDQUOT": 69,
  "EEXIST": 17,
  "EFAULT": 14,
  "EFBIG": 27,
  "EHOSTUNREACH": 65,
  "EIDRM": 90,
  "EILSEQ": 92,
  "EINPROGRESS": 36,
  "EINTR": 4,
  "EINVAL": 22,
  "EIO": 5,
  "EISCONN": 56,
  "EISDIR": 21,
  "ELOOP": 62,
  "EMFILE": 24,
  "EMLINK": 31,
  "EMSGSIZE": 40,
  "EMULTIHOP": 95,
  "ENAMETOOLONG": 63,
  "ENETDOWN": 50,
  "ENETRESET": 52,
  "ENETUNREACH": 51,
  "ENFILE": 23,
  "ENOBUFS": 55,
  "ENODATA": 96,
  "ENODEV": 19,
  "ENOENT": 2,
  "ENOEXEC": 8,
  "ENOLCK": 77,
  "ENOLINK": 97,
  "ENOMEM": 12,
  "ENOMSG": 91,
  "ENOPROTOOPT": 42,
  "ENOSPC": 28,
  "ENOSR": 98,
  "ENOSTR": 99,
  "ENOSYS": 78,
  "ENOTCONN": 57,
  "ENOTDIR": 20,
  "ENOTEMPTY": 66,
  "ENOTSOCK": 38,
  "ENOTSUP": 45,
  "ENOTTY": 25,
  "ENXIO": 6,
  "EOPNOTSUPP": 102,
  "EOVERFLOW": 84,
  "EPERM": 1,
  "EPIPE": 32,
  "EPROTO": 100,
  "EPROTONOSUPPORT": 43,
  "EPROTOTYPE": 41,
  "ERANGE": 34,
  "EROFS": 30,
  "ESPIPE": 29,
  "ESRCH": 3,
  "ESTALE": 70,
  "ETIME": 101,
  "ETIMEDOUT": 60,
  "ETXTBSY": 26,
  "EWOULDBLOCK": 35,
  "EXDEV": 18,
  "SIGHUP": 1,
  "SIGINT": 2,
  "SIGQUIT": 3,
  "SIGILL": 4,
  "SIGTRAP": 5,
  "SIGABRT": 6,
  "SIGIOT": 6,
  "SIGBUS": 10,
  "SIGFPE": 8,
  "SIGKILL": 9,
  "SIGUSR1": 30,
  "SIGSEGV": 11,
  "SIGUSR2": 31,
  "SIGPIPE": 13,
  "SIGALRM": 14,
  "SIGTERM": 15,
  "SIGCHLD": 20,
  "SIGCONT": 19,
  "SIGSTOP": 17,
  "SIGTSTP": 18,
  "SIGTTIN": 21,
  "SIGTTOU": 22,
  "SIGURG": 16,
  "SIGXCPU": 24,
  "SIGXFSZ": 25,
  "SIGVTALRM": 26,
  "SIGPROF": 27,
  "SIGWINCH": 28,
  "SIGIO": 23,
  "SIGSYS": 12,
  "SSL_OP_ALL": 2147486719,
  "SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION": 262144,
  "SSL_OP_CIPHER_SERVER_PREFERENCE": 4194304,
  "SSL_OP_CISCO_ANYCONNECT": 32768,
  "SSL_OP_COOKIE_EXCHANGE": 8192,
  "SSL_OP_CRYPTOPRO_TLSEXT_BUG": 2147483648,
  "SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS": 2048,
  "SSL_OP_EPHEMERAL_RSA": 0,
  "SSL_OP_LEGACY_SERVER_CONNECT": 4,
  "SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER": 32,
  "SSL_OP_MICROSOFT_SESS_ID_BUG": 1,
  "SSL_OP_MSIE_SSLV2_RSA_PADDING": 0,
  "SSL_OP_NETSCAPE_CA_DN_BUG": 536870912,
  "SSL_OP_NETSCAPE_CHALLENGE_BUG": 2,
  "SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG": 1073741824,
  "SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG": 8,
  "SSL_OP_NO_COMPRESSION": 131072,
  "SSL_OP_NO_QUERY_MTU": 4096,
  "SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION": 65536,
  "SSL_OP_NO_SSLv2": 16777216,
  "SSL_OP_NO_SSLv3": 33554432,
  "SSL_OP_NO_TICKET": 16384,
  "SSL_OP_NO_TLSv1": 67108864,
  "SSL_OP_NO_TLSv1_1": 268435456,
  "SSL_OP_NO_TLSv1_2": 134217728,
  "SSL_OP_PKCS1_CHECK_1": 0,
  "SSL_OP_PKCS1_CHECK_2": 0,
  "SSL_OP_SINGLE_DH_USE": 1048576,
  "SSL_OP_SINGLE_ECDH_USE": 524288,
  "SSL_OP_SSLEAY_080_CLIENT_DH_BUG": 128,
  "SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG": 0,
  "SSL_OP_TLS_BLOCK_PADDING_BUG": 512,
  "SSL_OP_TLS_D5_BUG": 256,
  "SSL_OP_TLS_ROLLBACK_BUG": 8388608,
  "ENGINE_METHOD_DSA": 2,
  "ENGINE_METHOD_DH": 4,
  "ENGINE_METHOD_RAND": 8,
  "ENGINE_METHOD_ECDH": 16,
  "ENGINE_METHOD_ECDSA": 32,
  "ENGINE_METHOD_CIPHERS": 64,
  "ENGINE_METHOD_DIGESTS": 128,
  "ENGINE_METHOD_STORE": 256,
  "ENGINE_METHOD_PKEY_METHS": 512,
  "ENGINE_METHOD_PKEY_ASN1_METHS": 1024,
  "ENGINE_METHOD_ALL": 65535,
  "ENGINE_METHOD_NONE": 0,
  "DH_CHECK_P_NOT_SAFE_PRIME": 2,
  "DH_CHECK_P_NOT_PRIME": 1,
  "DH_UNABLE_TO_CHECK_GENERATOR": 4,
  "DH_NOT_SUITABLE_GENERATOR": 8,
  "NPN_ENABLED": 1,
  "RSA_PKCS1_PADDING": 1,
  "RSA_SSLV23_PADDING": 2,
  "RSA_NO_PADDING": 3,
  "RSA_PKCS1_OAEP_PADDING": 4,
  "RSA_X931_PADDING": 5,
  "RSA_PKCS1_PSS_PADDING": 6,
  "POINT_CONVERSION_COMPRESSED": 2,
  "POINT_CONVERSION_UNCOMPRESSED": 4,
  "POINT_CONVERSION_HYBRID": 6,
  "F_OK": 0,
  "R_OK": 4,
  "W_OK": 2,
  "X_OK": 1,
  "UV_UDP_REUSEADDR": 4
}

},{}],7:[function(require,module,exports){
(function (Buffer){
// Copyright Joyent, Inc. and other Node contributors.
//
// 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.

// NOTE: These type checking functions intentionally don't use `instanceof`
// because it is fragile and can be easily faked with `Object.create()`.

function isArray(arg) {
  if (Array.isArray) {
    return Array.isArray(arg);
  }
  return objectToString(arg) === '[object Array]';
}
exports.isArray = isArray;

function isBoolean(arg) {
  return typeof arg === 'boolean';
}
exports.isBoolean = isBoolean;

function isNull(arg) {
  return arg === null;
}
exports.isNull = isNull;

function isNullOrUndefined(arg) {
  return arg == null;
}
exports.isNullOrUndefined = isNullOrUndefined;

function isNumber(arg) {
  return typeof arg === 'number';
}
exports.isNumber = isNumber;

function isString(arg) {
  return typeof arg === 'string';
}
exports.isString = isString;

function isSymbol(arg) {
  return typeof arg === 'symbol';
}
exports.isSymbol = isSymbol;

function isUndefined(arg) {
  return arg === void 0;
}
exports.isUndefined = isUndefined;

function isRegExp(re) {
  return objectToString(re) === '[object RegExp]';
}
exports.isRegExp = isRegExp;

function isObject(arg) {
  return typeof arg === 'object' && arg !== null;
}
exports.isObject = isObject;

function isDate(d) {
  return objectToString(d) === '[object Date]';
}
exports.isDate = isDate;

function isError(e) {
  return (objectToString(e) === '[object Error]' || e instanceof Error);
}
exports.isError = isError;

function isFunction(arg) {
  return typeof arg === 'function';
}
exports.isFunction = isFunction;

function isPrimitive(arg) {
  return arg === null ||
         typeof arg === 'boolean' ||
         typeof arg === 'number' ||
         typeof arg === 'string' ||
         typeof arg === 'symbol' ||  // ES6 symbol
         typeof arg === 'undefined';
}
exports.isPrimitive = isPrimitive;

exports.isBuffer = Buffer.isBuffer;

function objectToString(o) {
  return Object.prototype.toString.call(o);
}

}).call(this,{"isBuffer":require("../../is-buffer/index.js")})
},{"../../is-buffer/index.js":11}],8:[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// 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.

function EventEmitter() {
  this._events = this._events || {};
  this._maxListeners = this._maxListeners || undefined;
}
module.exports = EventEmitter;

// Backwards-compat with node 0.10.x
EventEmitter.EventEmitter = EventEmitter;

EventEmitter.prototype._events = undefined;
EventEmitter.prototype._maxListeners = undefined;

// By default EventEmitters will print a warning if more than 10 listeners are
// added to it. This is a useful default which helps finding memory leaks.
EventEmitter.defaultMaxListeners = 10;

// Obviously not all Emitters should be limited to 10. This function allows
// that to be increased. Set to zero for unlimited.
EventEmitter.prototype.setMaxListeners = function(n) {
  if (!isNumber(n) || n < 0 || isNaN(n))
    throw TypeError('n must be a positive number');
  this._maxListeners = n;
  return this;
};

EventEmitter.prototype.emit = function(type) {
  var er, handler, len, args, i, listeners;

  if (!this._events)
    this._events = {};

  // If there is no 'error' event listener then throw.
  if (type === 'error') {
    if (!this._events.error ||
        (isObject(this._events.error) && !this._events.error.length)) {
      er = arguments[1];
      if (er instanceof Error) {
        throw er; // Unhandled 'error' event
      } else {
        // At least give some kind of context to the user
        var err = new Error('Uncaught, unspecified "error" event. (' + er + ')');
        err.context = er;
        throw err;
      }
    }
  }

  handler = this._events[type];

  if (isUndefined(handler))
    return false;

  if (isFunction(handler)) {
    switch (arguments.length) {
      // fast cases
      case 1:
        handler.call(this);
        break;
      case 2:
        handler.call(this, arguments[1]);
        break;
      case 3:
        handler.call(this, arguments[1], arguments[2]);
        break;
      // slower
      default:
        args = Array.prototype.slice.call(arguments, 1);
        handler.apply(this, args);
    }
  } else if (isObject(handler)) {
    args = Array.prototype.slice.call(arguments, 1);
    listeners = handler.slice();
    len = listeners.length;
    for (i = 0; i < len; i++)
      listeners[i].apply(this, args);
  }

  return true;
};

EventEmitter.prototype.addListener = function(type, listener) {
  var m;

  if (!isFunction(listener))
    throw TypeError('listener must be a function');

  if (!this._events)
    this._events = {};

  // To avoid recursion in the case that type === "newListener"! Before
  // adding it to the listeners, first emit "newListener".
  if (this._events.newListener)
    this.emit('newListener', type,
              isFunction(listener.listener) ?
              listener.listener : listener);

  if (!this._events[type])
    // Optimize the case of one listener. Don't need the extra array object.
    this._events[type] = listener;
  else if (isObject(this._events[type]))
    // If we've already got an array, just append.
    this._events[type].push(listener);
  else
    // Adding the second element, need to change to array.
    this._events[type] = [this._events[type], listener];

  // Check for listener leak
  if (isObject(this._events[type]) && !this._events[type].warned) {
    if (!isUndefined(this._maxListeners)) {
      m = this._maxListeners;
    } else {
      m = EventEmitter.defaultMaxListeners;
    }

    if (m && m > 0 && this._events[type].length > m) {
      this._events[type].warned = true;
      console.error('(node) warning: possible EventEmitter memory ' +
                    'leak detected. %d listeners added. ' +
                    'Use emitter.setMaxListeners() to increase limit.',
                    this._events[type].length);
      if (typeof console.trace === 'function') {
        // not supported in IE 10
        console.trace();
      }
    }
  }

  return this;
};

EventEmitter.prototype.on = EventEmitter.prototype.addListener;

EventEmitter.prototype.once = function(type, listener) {
  if (!isFunction(listener))
    throw TypeError('listener must be a function');

  var fired = false;

  function g() {
    this.removeListener(type, g);

    if (!fired) {
      fired = true;
      listener.apply(this, arguments);
    }
  }

  g.listener = listener;
  this.on(type, g);

  return this;
};

// emits a 'removeListener' event iff the listener was removed
EventEmitter.prototype.removeListener = function(type, listener) {
  var list, position, length, i;

  if (!isFunction(listener))
    throw TypeError('listener must be a function');

  if (!this._events || !this._events[type])
    return this;

  list = this._events[type];
  length = list.length;
  position = -1;

  if (list === listener ||
      (isFunction(list.listener) && list.listener === listener)) {
    delete this._events[type];
    if (this._events.removeListener)
      this.emit('removeListener', type, listener);

  } else if (isObject(list)) {
    for (i = length; i-- > 0;) {
      if (list[i] === listener ||
          (list[i].listener && list[i].listener === listener)) {
        position = i;
        break;
      }
    }

    if (position < 0)
      return this;

    if (list.length === 1) {
      list.length = 0;
      delete this._events[type];
    } else {
      list.splice(position, 1);
    }

    if (this._events.removeListener)
      this.emit('removeListener', type, listener);
  }

  return this;
};

EventEmitter.prototype.removeAllListeners = function(type) {
  var key, listeners;

  if (!this._events)
    return this;

  // not listening for removeListener, no need to emit
  if (!this._events.removeListener) {
    if (arguments.length === 0)
      this._events = {};
    else if (this._events[type])
      delete this._events[type];
    return this;
  }

  // emit removeListener for all listeners on all events
  if (arguments.length === 0) {
    for (key in this._events) {
      if (key === 'removeListener') continue;
      this.removeAllListeners(key);
    }
    this.removeAllListeners('removeListener');
    this._events = {};
    return this;
  }

  listeners = this._events[type];

  if (isFunction(listeners)) {
    this.removeListener(type, listeners);
  } else if (listeners) {
    // LIFO order
    while (listeners.length)
      this.removeListener(type, listeners[listeners.length - 1]);
  }
  delete this._events[type];

  return this;
};

EventEmitter.prototype.listeners = function(type) {
  var ret;
  if (!this._events || !this._events[type])
    ret = [];
  else if (isFunction(this._events[type]))
    ret = [this._events[type]];
  else
    ret = this._events[type].slice();
  return ret;
};

EventEmitter.prototype.listenerCount = function(type) {
  if (this._events) {
    var evlistener = this._events[type];

    if (isFunction(evlistener))
      return 1;
    else if (evlistener)
      return evlistener.length;
  }
  return 0;
};

EventEmitter.listenerCount = function(emitter, type) {
  return emitter.listenerCount(type);
};

function isFunction(arg) {
  return typeof arg === 'function';
}

function isNumber(arg) {
  return typeof arg === 'number';
}

function isObject(arg) {
  return typeof arg === 'object' && arg !== null;
}

function isUndefined(arg) {
  return arg === void 0;
}

},{}],9:[function(require,module,exports){
exports.read = function (buffer, offset, isLE, mLen, nBytes) {
  var e, m
  var eLen = nBytes * 8 - mLen - 1
  var eMax = (1 << eLen) - 1
  var eBias = eMax >> 1
  var nBits = -7
  var i = isLE ? (nBytes - 1) : 0
  var d = isLE ? -1 : 1
  var s = buffer[offset + i]

  i += d

  e = s & ((1 << (-nBits)) - 1)
  s >>= (-nBits)
  nBits += eLen
  for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}

  m = e & ((1 << (-nBits)) - 1)
  e >>= (-nBits)
  nBits += mLen
  for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}

  if (e === 0) {
    e = 1 - eBias
  } else if (e === eMax) {
    return m ? NaN : ((s ? -1 : 1) * Infinity)
  } else {
    m = m + Math.pow(2, mLen)
    e = e - eBias
  }
  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
}

exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
  var e, m, c
  var eLen = nBytes * 8 - mLen - 1
  var eMax = (1 << eLen) - 1
  var eBias = eMax >> 1
  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
  var i = isLE ? 0 : (nBytes - 1)
  var d = isLE ? 1 : -1
  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0

  value = Math.abs(value)

  if (isNaN(value) || value === Infinity) {
    m = isNaN(value) ? 1 : 0
    e = eMax
  } else {
    e = Math.floor(Math.log(value) / Math.LN2)
    if (value * (c = Math.pow(2, -e)) < 1) {
      e--
      c *= 2
    }
    if (e + eBias >= 1) {
      value += rt / c
    } else {
      value += rt * Math.pow(2, 1 - eBias)
    }
    if (value * c >= 2) {
      e++
      c /= 2
    }

    if (e + eBias >= eMax) {
      m = 0
      e = eMax
    } else if (e + eBias >= 1) {
      m = (value * c - 1) * Math.pow(2, mLen)
      e = e + eBias
    } else {
      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
      e = 0
    }
  }

  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}

  e = (e << mLen) | m
  eLen += mLen
  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}

  buffer[offset + i - d] |= s * 128
}

},{}],10:[function(require,module,exports){
if (typeof Object.create === 'function') {
  // implementation from standard node.js 'util' module
  module.exports = function inherits(ctor, superCtor) {
    ctor.super_ = superCtor
    ctor.prototype = Object.create(superCtor.prototype, {
      constructor: {
        value: ctor,
        enumerable: false,
        writable: true,
        configurable: true
      }
    });
  };
} else {
  // old school shim for old browsers
  module.exports = function inherits(ctor, superCtor) {
    ctor.super_ = superCtor
    var TempCtor = function () {}
    TempCtor.prototype = superCtor.prototype
    ctor.prototype = new TempCtor()
    ctor.prototype.constructor = ctor
  }
}

},{}],11:[function(require,module,exports){
/*!
 * Determine if an object is a Buffer
 *
 * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
 * @license  MIT
 */

// The _isBuffer check is for Safari 5-7 support, because it's missing
// Object.prototype.constructor. Remove this eventually
module.exports = function (obj) {
  return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer)
}

function isBuffer (obj) {
  return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)
}

// For Node v0.10 support. Remove this eventually.
function isSlowBuffer (obj) {
  return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0))
}

},{}],12:[function(require,module,exports){
var toString = {}.toString;

module.exports = Array.isArray || function (arr) {
  return toString.call(arr) == '[object Array]';
};

},{}],13:[function(require,module,exports){
exports.endianness = function () { return 'LE' };

exports.hostname = function () {
    if (typeof location !== 'undefined') {
        return location.hostname
    }
    else return '';
};

exports.loadavg = function () { return [] };

exports.uptime = function () { return 0 };

exports.freemem = function () {
    return Number.MAX_VALUE;
};

exports.totalmem = function () {
    return Number.MAX_VALUE;
};

exports.cpus = function () { return [] };

exports.type = function () { return 'Browser' };

exports.release = function () {
    if (typeof navigator !== 'undefined') {
        return navigator.appVersion;
    }
    return '';
};

exports.networkInterfaces
= exports.getNetworkInterfaces
= function () { return {} };

exports.arch = function () { return 'javascript' };

exports.platform = function () { return 'browser' };

exports.tmpdir = exports.tmpDir = function () {
    return '/tmp';
};

exports.EOL = '\n';

},{}],14:[function(require,module,exports){
(function (process){
// Copyright Joyent, Inc. and other Node contributors.
//
// 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.

// resolves . and .. elements in a path array with directory names there
// must be no slashes, empty elements, or device names (c:\) in the array
// (so also no leading and trailing slashes - it does not distinguish
// relative and absolute paths)
function normalizeArray(parts, allowAboveRoot) {
  // if the path tries to go above the root, `up` ends up > 0
  var up = 0;
  for (var i = parts.length - 1; i >= 0; i--) {
    var last = parts[i];
    if (last === '.') {
      parts.splice(i, 1);
    } else if (last === '..') {
      parts.splice(i, 1);
      up++;
    } else if (up) {
      parts.splice(i, 1);
      up--;
    }
  }

  // if the path is allowed to go above the root, restore leading ..s
  if (allowAboveRoot) {
    for (; up--; up) {
      parts.unshift('..');
    }
  }

  return parts;
}

// Split a filename into [root, dir, basename, ext], unix version
// 'root' is just a slash, or nothing.
var splitPathRe =
    /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
var splitPath = function(filename) {
  return splitPathRe.exec(filename).slice(1);
};

// path.resolve([from ...], to)
// posix version
exports.resolve = function() {
  var resolvedPath = '',
      resolvedAbsolute = false;

  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
    var path = (i >= 0) ? arguments[i] : process.cwd();

    // Skip empty and invalid entries
    if (typeof path !== 'string') {
      throw new TypeError('Arguments to path.resolve must be strings');
    } else if (!path) {
      continue;
    }

    resolvedPath = path + '/' + resolvedPath;
    resolvedAbsolute = path.charAt(0) === '/';
  }

  // At this point the path should be resolved to a full absolute path, but
  // handle relative paths to be safe (might happen when process.cwd() fails)

  // Normalize the path
  resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {
    return !!p;
  }), !resolvedAbsolute).join('/');

  return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
};

// path.normalize(path)
// posix version
exports.normalize = function(path) {
  var isAbsolute = exports.isAbsolute(path),
      trailingSlash = substr(path, -1) === '/';

  // Normalize the path
  path = normalizeArray(filter(path.split('/'), function(p) {
    return !!p;
  }), !isAbsolute).join('/');

  if (!path && !isAbsolute) {
    path = '.';
  }
  if (path && trailingSlash) {
    path += '/';
  }

  return (isAbsolute ? '/' : '') + path;
};

// posix version
exports.isAbsolute = function(path) {
  return path.charAt(0) === '/';
};

// posix version
exports.join = function() {
  var paths = Array.prototype.slice.call(arguments, 0);
  return exports.normalize(filter(paths, function(p, index) {
    if (typeof p !== 'string') {
      throw new TypeError('Arguments to path.join must be strings');
    }
    return p;
  }).join('/'));
};


// path.relative(from, to)
// posix version
exports.relative = function(from, to) {
  from = exports.resolve(from).substr(1);
  to = exports.resolve(to).substr(1);

  function trim(arr) {
    var start = 0;
    for (; start < arr.length; start++) {
      if (arr[start] !== '') break;
    }

    var end = arr.length - 1;
    for (; end >= 0; end--) {
      if (arr[end] !== '') break;
    }

    if (start > end) return [];
    return arr.slice(start, end - start + 1);
  }

  var fromParts = trim(from.split('/'));
  var toParts = trim(to.split('/'));

  var length = Math.min(fromParts.length, toParts.length);
  var samePartsLength = length;
  for (var i = 0; i < length; i++) {
    if (fromParts[i] !== toParts[i]) {
      samePartsLength = i;
      break;
    }
  }

  var outputParts = [];
  for (var i = samePartsLength; i < fromParts.length; i++) {
    outputParts.push('..');
  }

  outputParts = outputParts.concat(toParts.slice(samePartsLength));

  return outputParts.join('/');
};

exports.sep = '/';
exports.delimiter = ':';

exports.dirname = function(path) {
  var result = splitPath(path),
      root = result[0],
      dir = result[1];

  if (!root && !dir) {
    // No dirname whatsoever
    return '.';
  }

  if (dir) {
    // It has a dirname, strip trailing slash
    dir = dir.substr(0, dir.length - 1);
  }

  return root + dir;
};


exports.basename = function(path, ext) {
  var f = splitPath(path)[2];
  // TODO: make this comparison case-insensitive on windows?
  if (ext && f.substr(-1 * ext.length) === ext) {
    f = f.substr(0, f.length - ext.length);
  }
  return f;
};


exports.extname = function(path) {
  return splitPath(path)[3];
};

function filter (xs, f) {
    if (xs.filter) return xs.filter(f);
    var res = [];
    for (var i = 0; i < xs.length; i++) {
        if (f(xs[i], i, xs)) res.push(xs[i]);
    }
    return res;
}

// String.prototype.substr - negative index don't work in IE8
var substr = 'ab'.substr(-1) === 'b'
    ? function (str, start, len) { return str.substr(start, len) }
    : function (str, start, len) {
        if (start < 0) start = str.length + start;
        return str.substr(start, len);
    }
;

}).call(this,require('_process'))
},{"_process":16}],15:[function(require,module,exports){
(function (process){
'use strict';

if (!process.version ||
    process.version.indexOf('v0.') === 0 ||
    process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {
  module.exports = nextTick;
} else {
  module.exports = process.nextTick;
}

function nextTick(fn, arg1, arg2, arg3) {
  if (typeof fn !== 'function') {
    throw new TypeError('"callback" argument must be a function');
  }
  var len = arguments.length;
  var args, i;
  switch (len) {
  case 0:
  case 1:
    return process.nextTick(fn);
  case 2:
    return process.nextTick(function afterTickOne() {
      fn.call(null, arg1);
    });
  case 3:
    return process.nextTick(function afterTickTwo() {
      fn.call(null, arg1, arg2);
    });
  case 4:
    return process.nextTick(function afterTickThree() {
      fn.call(null, arg1, arg2, arg3);
    });
  default:
    args = new Array(len - 1);
    i = 0;
    while (i < args.length) {
      args[i++] = arguments[i];
    }
    return process.nextTick(function afterTick() {
      fn.apply(null, args);
    });
  }
}

}).call(this,require('_process'))
},{"_process":16}],16:[function(require,module,exports){
// shim for using process in browser
var process = module.exports = {};

// cached from whatever global is present so that test runners that stub it
// don't break things.  But we need to wrap it in a try catch in case it is
// wrapped in strict mode code which doesn't define any globals.  It's inside a
// function because try/catches deoptimize in certain engines.

var cachedSetTimeout;
var cachedClearTimeout;

function defaultSetTimout() {
    throw new Error('setTimeout has not been defined');
}
function defaultClearTimeout () {
    throw new Error('clearTimeout has not been defined');
}
(function () {
    try {
        if (typeof setTimeout === 'function') {
            cachedSetTimeout = setTimeout;
        } else {
            cachedSetTimeout = defaultSetTimout;
        }
    } catch (e) {
        cachedSetTimeout = defaultSetTimout;
    }
    try {
        if (typeof clearTimeout === 'function') {
            cachedClearTimeout = clearTimeout;
        } else {
            cachedClearTimeout = defaultClearTimeout;
        }
    } catch (e) {
        cachedClearTimeout = defaultClearTimeout;
    }
} ())
function runTimeout(fun) {
    if (cachedSetTimeout === setTimeout) {
        //normal enviroments in sane situations
        return setTimeout(fun, 0);
    }
    // if setTimeout wasn't available but was latter defined
    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
        cachedSetTimeout = setTimeout;
        return setTimeout(fun, 0);
    }
    try {
        // when when somebody has screwed with setTimeout but no I.E. maddness
        return cachedSetTimeout(fun, 0);
    } catch(e){
        try {
            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
            return cachedSetTimeout.call(null, fun, 0);
        } catch(e){
            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
            return cachedSetTimeout.call(this, fun, 0);
        }
    }


}
function runClearTimeout(marker) {
    if (cachedClearTimeout === clearTimeout) {
        //normal enviroments in sane situations
        return clearTimeout(marker);
    }
    // if clearTimeout wasn't available but was latter defined
    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
        cachedClearTimeout = clearTimeout;
        return clearTimeout(marker);
    }
    try {
        // when when somebody has screwed with setTimeout but no I.E. maddness
        return cachedClearTimeout(marker);
    } catch (e){
        try {
            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
            return cachedClearTimeout.call(null, marker);
        } catch (e){
            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
            return cachedClearTimeout.call(this, marker);
        }
    }



}
var queue = [];
var draining = false;
var currentQueue;
var queueIndex = -1;

function cleanUpNextTick() {
    if (!draining || !currentQueue) {
        return;
    }
    draining = false;
    if (currentQueue.length) {
        queue = currentQueue.concat(queue);
    } else {
        queueIndex = -1;
    }
    if (queue.length) {
        drainQueue();
    }
}

function drainQueue() {
    if (draining) {
        return;
    }
    var timeout = runTimeout(cleanUpNextTick);
    draining = true;

    var len = queue.length;
    while(len) {
        currentQueue = queue;
        queue = [];
        while (++queueIndex < len) {
            if (currentQueue) {
                currentQueue[queueIndex].run();
            }
        }
        queueIndex = -1;
        len = queue.length;
    }
    currentQueue = null;
    draining = false;
    runClearTimeout(timeout);
}

process.nextTick = function (fun) {
    var args = new Array(arguments.length - 1);
    if (arguments.length > 1) {
        for (var i = 1; i < arguments.length; i++) {
            args[i - 1] = arguments[i];
        }
    }
    queue.push(new Item(fun, args));
    if (queue.length === 1 && !draining) {
        runTimeout(drainQueue);
    }
};

// v8 likes predictible objects
function Item(fun, array) {
    this.fun = fun;
    this.array = array;
}
Item.prototype.run = function () {
    this.fun.apply(null, this.array);
};
process.title = 'browser';
process.browser = true;
process.env = {};
process.argv = [];
process.version = ''; // empty string to avoid regexp issues
process.versions = {};

function noop() {}

process.on = noop;
process.addListener = noop;
process.once = noop;
process.off = noop;
process.removeListener = noop;
process.removeAllListeners = noop;
process.emit = noop;
process.prependListener = noop;
process.prependOnceListener = noop;

process.listeners = function (name) { return [] }

process.binding = function (name) {
    throw new Error('process.binding is not supported');
};

process.cwd = function () { return '/' };
process.chdir = function (dir) {
    throw new Error('process.chdir is not supported');
};
process.umask = function() { return 0; };

},{}],17:[function(require,module,exports){
(function (global){
/*! https://mths.be/punycode v1.4.1 by @mathias */
;(function(root) {

	/** Detect free variables */
	var freeExports = typeof exports == 'object' && exports &&
		!exports.nodeType && exports;
	var freeModule = typeof module == 'object' && module &&
		!module.nodeType && module;
	var freeGlobal = typeof global == 'object' && global;
	if (
		freeGlobal.global === freeGlobal ||
		freeGlobal.window === freeGlobal ||
		freeGlobal.self === freeGlobal
	) {
		root = freeGlobal;
	}

	/**
	 * The `punycode` object.
	 * @name punycode
	 * @type Object
	 */
	var punycode,

	/** Highest positive signed 32-bit float value */
	maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1

	/** Bootstring parameters */
	base = 36,
	tMin = 1,
	tMax = 26,
	skew = 38,
	damp = 700,
	initialBias = 72,
	initialN = 128, // 0x80
	delimiter = '-', // '\x2D'

	/** Regular expressions */
	regexPunycode = /^xn--/,
	regexNonASCII = /[^\x20-\x7E]/, // unprintable ASCII chars + non-ASCII chars
	regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, // RFC 3490 separators

	/** Error messages */
	errors = {
		'overflow': 'Overflow: input needs wider integers to process',
		'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
		'invalid-input': 'Invalid input'
	},

	/** Convenience shortcuts */
	baseMinusTMin = base - tMin,
	floor = Math.floor,
	stringFromCharCode = String.fromCharCode,

	/** Temporary variable */
	key;

	/*--------------------------------------------------------------------------*/

	/**
	 * A generic error utility function.
	 * @private
	 * @param {String} type The error type.
	 * @returns {Error} Throws a `RangeError` with the applicable error message.
	 */
	function error(type) {
		throw new RangeError(errors[type]);
	}

	/**
	 * A generic `Array#map` utility function.
	 * @private
	 * @param {Array} array The array to iterate over.
	 * @param {Function} callback The function that gets called for every array
	 * item.
	 * @returns {Array} A new array of values returned by the callback function.
	 */
	function map(array, fn) {
		var length = array.length;
		var result = [];
		while (length--) {
			result[length] = fn(array[length]);
		}
		return result;
	}

	/**
	 * A simple `Array#map`-like wrapper to work with domain name strings or email
	 * addresses.
	 * @private
	 * @param {String} domain The domain name or email address.
	 * @param {Function} callback The function that gets called for every
	 * character.
	 * @returns {Array} A new string of characters returned by the callback
	 * function.
	 */
	function mapDomain(string, fn) {
		var parts = string.split('@');
		var result = '';
		if (parts.length > 1) {
			// In email addresses, only the domain name should be punycoded. Leave
			// the local part (i.e. everything up to `@`) intact.
			result = parts[0] + '@';
			string = parts[1];
		}
		// Avoid `split(regex)` for IE8 compatibility. See #17.
		string = string.replace(regexSeparators, '\x2E');
		var labels = string.split('.');
		var encoded = map(labels, fn).join('.');
		return result + encoded;
	}

	/**
	 * Creates an array containing the numeric code points of each Unicode
	 * character in the string. While JavaScript uses UCS-2 internally,
	 * this function will convert a pair of surrogate halves (each of which
	 * UCS-2 exposes as separate characters) into a single code point,
	 * matching UTF-16.
	 * @see `punycode.ucs2.encode`
	 * @see <https://mathiasbynens.be/notes/javascript-encoding>
	 * @memberOf punycode.ucs2
	 * @name decode
	 * @param {String} string The Unicode input string (UCS-2).
	 * @returns {Array} The new array of code points.
	 */
	function ucs2decode(string) {
		var output = [],
		    counter = 0,
		    length = string.length,
		    value,
		    extra;
		while (counter < length) {
			value = string.charCodeAt(counter++);
			if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
				// high surrogate, and there is a next character
				extra = string.charCodeAt(counter++);
				if ((extra & 0xFC00) == 0xDC00) { // low surrogate
					output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
				} else {
					// unmatched surrogate; only append this code unit, in case the next
					// code unit is the high surrogate of a surrogate pair
					output.push(value);
					counter--;
				}
			} else {
				output.push(value);
			}
		}
		return output;
	}

	/**
	 * Creates a string based on an array of numeric code points.
	 * @see `punycode.ucs2.decode`
	 * @memberOf punycode.ucs2
	 * @name encode
	 * @param {Array} codePoints The array of numeric code points.
	 * @returns {String} The new Unicode string (UCS-2).
	 */
	function ucs2encode(array) {
		return map(array, function(value) {
			var output = '';
			if (value > 0xFFFF) {
				value -= 0x10000;
				output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
				value = 0xDC00 | value & 0x3FF;
			}
			output += stringFromCharCode(value);
			return output;
		}).join('');
	}

	/**
	 * Converts a basic code point into a digit/integer.
	 * @see `digitToBasic()`
	 * @private
	 * @param {Number} codePoint The basic numeric code point value.
	 * @returns {Number} The numeric value of a basic code point (for use in
	 * representing integers) in the range `0` to `base - 1`, or `base` if
	 * the code point does not represent a value.
	 */
	function basicToDigit(codePoint) {
		if (codePoint - 48 < 10) {
			return codePoint - 22;
		}
		if (codePoint - 65 < 26) {
			return codePoint - 65;
		}
		if (codePoint - 97 < 26) {
			return codePoint - 97;
		}
		return base;
	}

	/**
	 * Converts a digit/integer into a basic code point.
	 * @see `basicToDigit()`
	 * @private
	 * @param {Number} digit The numeric value of a basic code point.
	 * @returns {Number} The basic code point whose value (when used for
	 * representing integers) is `digit`, which needs to be in the range
	 * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
	 * used; else, the lowercase form is used. The behavior is undefined
	 * if `flag` is non-zero and `digit` has no uppercase form.
	 */
	function digitToBasic(digit, flag) {
		//  0..25 map to ASCII a..z or A..Z
		// 26..35 map to ASCII 0..9
		return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
	}

	/**
	 * Bias adaptation function as per section 3.4 of RFC 3492.
	 * https://tools.ietf.org/html/rfc3492#section-3.4
	 * @private
	 */
	function adapt(delta, numPoints, firstTime) {
		var k = 0;
		delta = firstTime ? floor(delta / damp) : delta >> 1;
		delta += floor(delta / numPoints);
		for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {
			delta = floor(delta / baseMinusTMin);
		}
		return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
	}

	/**
	 * Converts a Punycode string of ASCII-only symbols to a string of Unicode
	 * symbols.
	 * @memberOf punycode
	 * @param {String} input The Punycode string of ASCII-only symbols.
	 * @returns {String} The resulting string of Unicode symbols.
	 */
	function decode(input) {
		// Don't use UCS-2
		var output = [],
		    inputLength = input.length,
		    out,
		    i = 0,
		    n = initialN,
		    bias = initialBias,
		    basic,
		    j,
		    index,
		    oldi,
		    w,
		    k,
		    digit,
		    t,
		    /** Cached calculation results */
		    baseMinusT;

		// Handle the basic code points: let `basic` be the number of input code
		// points before the last delimiter, or `0` if there is none, then copy
		// the first basic code points to the output.

		basic = input.lastIndexOf(delimiter);
		if (basic < 0) {
			basic = 0;
		}

		for (j = 0; j < basic; ++j) {
			// if it's not a basic code point
			if (input.charCodeAt(j) >= 0x80) {
				error('not-basic');
			}
			output.push(input.charCodeAt(j));
		}

		// Main decoding loop: start just after the last delimiter if any basic code
		// points were copied; start at the beginning otherwise.

		for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {

			// `index` is the index of the next character to be consumed.
			// Decode a generalized variable-length integer into `delta`,
			// which gets added to `i`. The overflow checking is easier
			// if we increase `i` as we go, then subtract off its starting
			// value at the end to obtain `delta`.
			for (oldi = i, w = 1, k = base; /* no condition */; k += base) {

				if (index >= inputLength) {
					error('invalid-input');
				}

				digit = basicToDigit(input.charCodeAt(index++));

				if (digit >= base || digit > floor((maxInt - i) / w)) {
					error('overflow');
				}

				i += digit * w;
				t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);

				if (digit < t) {
					break;
				}

				baseMinusT = base - t;
				if (w > floor(maxInt / baseMinusT)) {
					error('overflow');
				}

				w *= baseMinusT;

			}

			out = output.length + 1;
			bias = adapt(i - oldi, out, oldi == 0);

			// `i` was supposed to wrap around from `out` to `0`,
			// incrementing `n` each time, so we'll fix that now:
			if (floor(i / out) > maxInt - n) {
				error('overflow');
			}

			n += floor(i / out);
			i %= out;

			// Insert `n` at position `i` of the output
			output.splice(i++, 0, n);

		}

		return ucs2encode(output);
	}

	/**
	 * Converts a string of Unicode symbols (e.g. a domain name label) to a
	 * Punycode string of ASCII-only symbols.
	 * @memberOf punycode
	 * @param {String} input The string of Unicode symbols.
	 * @returns {String} The resulting Punycode string of ASCII-only symbols.
	 */
	function encode(input) {
		var n,
		    delta,
		    handledCPCount,
		    basicLength,
		    bias,
		    j,
		    m,
		    q,
		    k,
		    t,
		    currentValue,
		    output = [],
		    /** `inputLength` will hold the number of code points in `input`. */
		    inputLength,
		    /** Cached calculation results */
		    handledCPCountPlusOne,
		    baseMinusT,
		    qMinusT;

		// Convert the input in UCS-2 to Unicode
		input = ucs2decode(input);

		// Cache the length
		inputLength = input.length;

		// Initialize the state
		n = initialN;
		delta = 0;
		bias = initialBias;

		// Handle the basic code points
		for (j = 0; j < inputLength; ++j) {
			currentValue = input[j];
			if (currentValue < 0x80) {
				output.push(stringFromCharCode(currentValue));
			}
		}

		handledCPCount = basicLength = output.length;

		// `handledCPCount` is the number of code points that have been handled;
		// `basicLength` is the number of basic code points.

		// Finish the basic string - if it is not empty - with a delimiter
		if (basicLength) {
			output.push(delimiter);
		}

		// Main encoding loop:
		while (handledCPCount < inputLength) {

			// All non-basic code points < n have been handled already. Find the next
			// larger one:
			for (m = maxInt, j = 0; j < inputLength; ++j) {
				currentValue = input[j];
				if (currentValue >= n && currentValue < m) {
					m = currentValue;
				}
			}

			// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
			// but guard against overflow
			handledCPCountPlusOne = handledCPCount + 1;
			if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
				error('overflow');
			}

			delta += (m - n) * handledCPCountPlusOne;
			n = m;

			for (j = 0; j < inputLength; ++j) {
				currentValue = input[j];

				if (currentValue < n && ++delta > maxInt) {
					error('overflow');
				}

				if (currentValue == n) {
					// Represent delta as a generalized variable-length integer
					for (q = delta, k = base; /* no condition */; k += base) {
						t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
						if (q < t) {
							break;
						}
						qMinusT = q - t;
						baseMinusT = base - t;
						output.push(
							stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
						);
						q = floor(qMinusT / baseMinusT);
					}

					output.push(stringFromCharCode(digitToBasic(q, 0)));
					bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
					delta = 0;
					++handledCPCount;
				}
			}

			++delta;
			++n;

		}
		return output.join('');
	}

	/**
	 * Converts a Punycode string representing a domain name or an email address
	 * to Unicode. Only the Punycoded parts of the input will be converted, i.e.
	 * it doesn't matter if you call it on a string that has already been
	 * converted to Unicode.
	 * @memberOf punycode
	 * @param {String} input The Punycoded domain name or email address to
	 * convert to Unicode.
	 * @returns {String} The Unicode representation of the given Punycode
	 * string.
	 */
	function toUnicode(input) {
		return mapDomain(input, function(string) {
			return regexPunycode.test(string)
				? decode(string.slice(4).toLowerCase())
				: string;
		});
	}

	/**
	 * Converts a Unicode string representing a domain name or an email address to
	 * Punycode. Only the non-ASCII parts of the domain name will be converted,
	 * i.e. it doesn't matter if you call it with a domain that's already in
	 * ASCII.
	 * @memberOf punycode
	 * @param {String} input The domain name or email address to convert, as a
	 * Unicode string.
	 * @returns {String} The Punycode representation of the given domain name or
	 * email address.
	 */
	function toASCII(input) {
		return mapDomain(input, function(string) {
			return regexNonASCII.test(string)
				? 'xn--' + encode(string)
				: string;
		});
	}

	/*--------------------------------------------------------------------------*/

	/** Define the public API */
	punycode = {
		/**
		 * A string representing the current Punycode.js version number.
		 * @memberOf punycode
		 * @type String
		 */
		'version': '1.4.1',
		/**
		 * An object of methods to convert from JavaScript's internal character
		 * representation (UCS-2) to Unicode code points, and back.
		 * @see <https://mathiasbynens.be/notes/javascript-encoding>
		 * @memberOf punycode
		 * @type Object
		 */
		'ucs2': {
			'decode': ucs2decode,
			'encode': ucs2encode
		},
		'decode': decode,
		'encode': encode,
		'toASCII': toASCII,
		'toUnicode': toUnicode
	};

	/** Expose `punycode` */
	// Some AMD build optimizers, like r.js, check for specific condition patterns
	// like the following:
	if (
		typeof define == 'function' &&
		typeof define.amd == 'object' &&
		define.amd
	) {
		define('punycode', function() {
			return punycode;
		});
	} else if (freeExports && freeModule) {
		if (module.exports == freeExports) {
			// in Node.js, io.js, or RingoJS v0.8.0+
			freeModule.exports = punycode;
		} else {
			// in Narwhal or RingoJS v0.7.0-
			for (key in punycode) {
				punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);
			}
		}
	} else {
		// in Rhino or a web browser
		root.punycode = punycode;
	}

}(this));

}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{}],18:[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// 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.

'use strict';

// If obj.hasOwnProperty has been overridden, then calling
// obj.hasOwnProperty(prop) will break.
// See: https://github.com/joyent/node/issues/1707
function hasOwnProperty(obj, prop) {
  return Object.prototype.hasOwnProperty.call(obj, prop);
}

module.exports = function(qs, sep, eq, options) {
  sep = sep || '&';
  eq = eq || '=';
  var obj = {};

  if (typeof qs !== 'string' || qs.length === 0) {
    return obj;
  }

  var regexp = /\+/g;
  qs = qs.split(sep);

  var maxKeys = 1000;
  if (options && typeof options.maxKeys === 'number') {
    maxKeys = options.maxKeys;
  }

  var len = qs.length;
  // maxKeys <= 0 means that we should not limit keys count
  if (maxKeys > 0 && len > maxKeys) {
    len = maxKeys;
  }

  for (var i = 0; i < len; ++i) {
    var x = qs[i].replace(regexp, '%20'),
        idx = x.indexOf(eq),
        kstr, vstr, k, v;

    if (idx >= 0) {
      kstr = x.substr(0, idx);
      vstr = x.substr(idx + 1);
    } else {
      kstr = x;
      vstr = '';
    }

    k = decodeURIComponent(kstr);
    v = decodeURIComponent(vstr);

    if (!hasOwnProperty(obj, k)) {
      obj[k] = v;
    } else if (isArray(obj[k])) {
      obj[k].push(v);
    } else {
      obj[k] = [obj[k], v];
    }
  }

  return obj;
};

var isArray = Array.isArray || function (xs) {
  return Object.prototype.toString.call(xs) === '[object Array]';
};

},{}],19:[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// 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.

'use strict';

var stringifyPrimitive = function(v) {
  switch (typeof v) {
    case 'string':
      return v;

    case 'boolean':
      return v ? 'true' : 'false';

    case 'number':
      return isFinite(v) ? v : '';

    default:
      return '';
  }
};

module.exports = function(obj, sep, eq, name) {
  sep = sep || '&';
  eq = eq || '=';
  if (obj === null) {
    obj = undefined;
  }

  if (typeof obj === 'object') {
    return map(objectKeys(obj), function(k) {
      var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;
      if (isArray(obj[k])) {
        return map(obj[k], function(v) {
          return ks + encodeURIComponent(stringifyPrimitive(v));
        }).join(sep);
      } else {
        return ks + encodeURIComponent(stringifyPrimitive(obj[k]));
      }
    }).join(sep);

  }

  if (!name) return '';
  return encodeURIComponent(stringifyPrimitive(name)) + eq +
         encodeURIComponent(stringifyPrimitive(obj));
};

var isArray = Array.isArray || function (xs) {
  return Object.prototype.toString.call(xs) === '[object Array]';
};

function map (xs, f) {
  if (xs.map) return xs.map(f);
  var res = [];
  for (var i = 0; i < xs.length; i++) {
    res.push(f(xs[i], i));
  }
  return res;
}

var objectKeys = Object.keys || function (obj) {
  var res = [];
  for (var key in obj) {
    if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key);
  }
  return res;
};

},{}],20:[function(require,module,exports){
'use strict';

exports.decode = exports.parse = require('./decode');
exports.encode = exports.stringify = require('./encode');

},{"./decode":18,"./encode":19}],21:[function(require,module,exports){
module.exports = require('./lib/_stream_duplex.js');

},{"./lib/_stream_duplex.js":22}],22:[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// 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.

// a duplex stream is just a stream that is both readable and writable.
// Since JS doesn't have multiple prototypal inheritance, this class
// prototypally inherits from Readable, and then parasitically from
// Writable.

'use strict';

/*<replacement>*/

var processNextTick = require('process-nextick-args');
/*</replacement>*/

/*<replacement>*/
var objectKeys = Object.keys || function (obj) {
  var keys = [];
  for (var key in obj) {
    keys.push(key);
  }return keys;
};
/*</replacement>*/

module.exports = Duplex;

/*<replacement>*/
var util = require('core-util-is');
util.inherits = require('inherits');
/*</replacement>*/

var Readable = require('./_stream_readable');
var Writable = require('./_stream_writable');

util.inherits(Duplex, Readable);

var keys = objectKeys(Writable.prototype);
for (var v = 0; v < keys.length; v++) {
  var method = keys[v];
  if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
}

function Duplex(options) {
  if (!(this instanceof Duplex)) return new Duplex(options);

  Readable.call(this, options);
  Writable.call(this, options);

  if (options && options.readable === false) this.readable = false;

  if (options && options.writable === false) this.writable = false;

  this.allowHalfOpen = true;
  if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;

  this.once('end', onend);
}

// the no-half-open enforcer
function onend() {
  // if we allow half-open state, or if the writable side ended,
  // then we're ok.
  if (this.allowHalfOpen || this._writableState.ended) return;

  // no more data can be written.
  // But allow more writes to happen in this tick.
  processNextTick(onEndNT, this);
}

function onEndNT(self) {
  self.end();
}

Object.defineProperty(Duplex.prototype, 'destroyed', {
  get: function () {
    if (this._readableState === undefined || this._writableState === undefined) {
      return false;
    }
    return this._readableState.destroyed && this._writableState.destroyed;
  },
  set: function (value) {
    // we ignore the value if the stream
    // has not been initialized yet
    if (this._readableState === undefined || this._writableState === undefined) {
      return;
    }

    // backward compatibility, the user is explicitly
    // managing destroyed
    this._readableState.destroyed = value;
    this._writableState.destroyed = value;
  }
});

Duplex.prototype._destroy = function (err, cb) {
  this.push(null);
  this.end();

  processNextTick(cb, err);
};

function forEach(xs, f) {
  for (var i = 0, l = xs.length; i < l; i++) {
    f(xs[i], i);
  }
}
},{"./_stream_readable":24,"./_stream_writable":26,"core-util-is":7,"inherits":10,"process-nextick-args":15}],23:[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// 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.

// a passthrough stream.
// basically just the most minimal sort of Transform stream.
// Every written chunk gets output as-is.

'use strict';

module.exports = PassThrough;

var Transform = require('./_stream_transform');

/*<replacement>*/
var util = require('core-util-is');
util.inherits = require('inherits');
/*</replacement>*/

util.inherits(PassThrough, Transform);

function PassThrough(options) {
  if (!(this instanceof PassThrough)) return new PassThrough(options);

  Transform.call(this, options);
}

PassThrough.prototype._transform = function (chunk, encoding, cb) {
  cb(null, chunk);
};
},{"./_stream_transform":25,"core-util-is":7,"inherits":10}],24:[function(require,module,exports){
(function (process,global){
// Copyright Joyent, Inc. and other Node contributors.
//
// 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.

'use strict';

/*<replacement>*/

var processNextTick = require('process-nextick-args');
/*</replacement>*/

module.exports = Readable;

/*<replacement>*/
var isArray = require('isarray');
/*</replacement>*/

/*<replacement>*/
var Duplex;
/*</replacement>*/

Readable.ReadableState = ReadableState;

/*<replacement>*/
var EE = require('events').EventEmitter;

var EElistenerCount = function (emitter, type) {
  return emitter.listeners(type).length;
};
/*</replacement>*/

/*<replacement>*/
var Stream = require('./internal/streams/stream');
/*</replacement>*/

// TODO(bmeurer): Change this back to const once hole checks are
// properly optimized away early in Ignition+TurboFan.
/*<replacement>*/
var Buffer = require('safe-buffer').Buffer;
var OurUint8Array = global.Uint8Array || function () {};
function _uint8ArrayToBuffer(chunk) {
  return Buffer.from(chunk);
}
function _isUint8Array(obj) {
  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
}
/*</replacement>*/

/*<replacement>*/
var util = require('core-util-is');
util.inherits = require('inherits');
/*</replacement>*/

/*<replacement>*/
var debugUtil = require('util');
var debug = void 0;
if (debugUtil && debugUtil.debuglog) {
  debug = debugUtil.debuglog('stream');
} else {
  debug = function () {};
}
/*</replacement>*/

var BufferList = require('./internal/streams/BufferList');
var destroyImpl = require('./internal/streams/destroy');
var StringDecoder;

util.inherits(Readable, Stream);

var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];

function prependListener(emitter, event, fn) {
  // Sadly this is not cacheable as some libraries bundle their own
  // event emitter implementation with them.
  if (typeof emitter.prependListener === 'function') {
    return emitter.prependListener(event, fn);
  } else {
    // This is a hack to make sure that our error handler is attached before any
    // userland ones.  NEVER DO THIS. This is here only because this code needs
    // to continue to work with older versions of Node.js that do not include
    // the prependListener() method. The goal is to eventually remove this hack.
    if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];
  }
}

function ReadableState(options, stream) {
  Duplex = Duplex || require('./_stream_duplex');

  options = options || {};

  // object stream flag. Used to make read(n) ignore n and to
  // make all the buffer merging and length checks go away
  this.objectMode = !!options.objectMode;

  if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.readableObjectMode;

  // the point at which it stops calling _read() to fill the buffer
  // Note: 0 is a valid value, means "don't call _read preemptively ever"
  var hwm = options.highWaterMark;
  var defaultHwm = this.objectMode ? 16 : 16 * 1024;
  this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;

  // cast to ints.
  this.highWaterMark = Math.floor(this.highWaterMark);

  // A linked list is used to store data chunks instead of an array because the
  // linked list can remove elements from the beginning faster than
  // array.shift()
  this.buffer = new BufferList();
  this.length = 0;
  this.pipes = null;
  this.pipesCount = 0;
  this.flowing = null;
  this.ended = false;
  this.endEmitted = false;
  this.reading = false;

  // a flag to be able to tell if the event 'readable'/'data' is emitted
  // immediately, or on a later tick.  We set this to true at first, because
  // any actions that shouldn't happen until "later" should generally also
  // not happen before the first read call.
  this.sync = true;

  // whenever we return null, then we set a flag to say
  // that we're awaiting a 'readable' event emission.
  this.needReadable = false;
  this.emittedReadable = false;
  this.readableListening = false;
  this.resumeScheduled = false;

  // has it been destroyed
  this.destroyed = false;

  // Crypto is kind of old and crusty.  Historically, its default string
  // encoding is 'binary' so we have to make this configurable.
  // Everything else in the universe uses 'utf8', though.
  this.defaultEncoding = options.defaultEncoding || 'utf8';

  // the number of writers that are awaiting a drain event in .pipe()s
  this.awaitDrain = 0;

  // if true, a maybeReadMore has been scheduled
  this.readingMore = false;

  this.decoder = null;
  this.encoding = null;
  if (options.encoding) {
    if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
    this.decoder = new StringDecoder(options.encoding);
    this.encoding = options.encoding;
  }
}

function Readable(options) {
  Duplex = Duplex || require('./_stream_duplex');

  if (!(this instanceof Readable)) return new Readable(options);

  this._readableState = new ReadableState(options, this);

  // legacy
  this.readable = true;

  if (options) {
    if (typeof options.read === 'function') this._read = options.read;

    if (typeof options.destroy === 'function') this._destroy = options.destroy;
  }

  Stream.call(this);
}

Object.defineProperty(Readable.prototype, 'destroyed', {
  get: function () {
    if (this._readableState === undefined) {
      return false;
    }
    return this._readableState.destroyed;
  },
  set: function (value) {
    // we ignore the value if the stream
    // has not been initialized yet
    if (!this._readableState) {
      return;
    }

    // backward compatibility, the user is explicitly
    // managing destroyed
    this._readableState.destroyed = value;
  }
});

Readable.prototype.destroy = destroyImpl.destroy;
Readable.prototype._undestroy = destroyImpl.undestroy;
Readable.prototype._destroy = function (err, cb) {
  this.push(null);
  cb(err);
};

// Manually shove something into the read() buffer.
// This returns true if the highWaterMark has not been hit yet,
// similar to how Writable.write() returns true if you should
// write() some more.
Readable.prototype.push = function (chunk, encoding) {
  var state = this._readableState;
  var skipChunkCheck;

  if (!state.objectMode) {
    if (typeof chunk === 'string') {
      encoding = encoding || state.defaultEncoding;
      if (encoding !== state.encoding) {
        chunk = Buffer.from(chunk, encoding);
        encoding = '';
      }
      skipChunkCheck = true;
    }
  } else {
    skipChunkCheck = true;
  }

  return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
};

// Unshift should *always* be something directly out of read()
Readable.prototype.unshift = function (chunk) {
  return readableAddChunk(this, chunk, null, true, false);
};

function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
  var state = stream._readableState;
  if (chunk === null) {
    state.reading = false;
    onEofChunk(stream, state);
  } else {
    var er;
    if (!skipChunkCheck) er = chunkInvalid(state, chunk);
    if (er) {
      stream.emit('error', er);
    } else if (state.objectMode || chunk && chunk.length > 0) {
      if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {
        chunk = _uint8ArrayToBuffer(chunk);
      }

      if (addToFront) {
        if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true);
      } else if (state.ended) {
        stream.emit('error', new Error('stream.push() after EOF'));
      } else {
        state.reading = false;
        if (state.decoder && !encoding) {
          chunk = state.decoder.write(chunk);
          if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);
        } else {
          addChunk(stream, state, chunk, false);
        }
      }
    } else if (!addToFront) {
      state.reading = false;
    }
  }

  return needMoreData(state);
}

function addChunk(stream, state, chunk, addToFront) {
  if (state.flowing && state.length === 0 && !state.sync) {
    stream.emit('data', chunk);
    stream.read(0);
  } else {
    // update the buffer info.
    state.length += state.objectMode ? 1 : chunk.length;
    if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);

    if (state.needReadable) emitReadable(stream);
  }
  maybeReadMore(stream, state);
}

function chunkInvalid(state, chunk) {
  var er;
  if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
    er = new TypeError('Invalid non-string/buffer chunk');
  }
  return er;
}

// if it's past the high water mark, we can push in some more.
// Also, if we have no data yet, we can stand some
// more bytes.  This is to work around cases where hwm=0,
// such as the repl.  Also, if the push() triggered a
// readable event, and the user called read(largeNumber) such that
// needReadable was set, then we ought to push more, so that another
// 'readable' event will be triggered.
function needMoreData(state) {
  return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);
}

Readable.prototype.isPaused = function () {
  return this._readableState.flowing === false;
};

// backwards compatibility.
Readable.prototype.setEncoding = function (enc) {
  if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
  this._readableState.decoder = new StringDecoder(enc);
  this._readableState.encoding = enc;
  return this;
};

// Don't raise the hwm > 8MB
var MAX_HWM = 0x800000;
function computeNewHighWaterMark(n) {
  if (n >= MAX_HWM) {
    n = MAX_HWM;
  } else {
    // Get the next highest power of 2 to prevent increasing hwm excessively in
    // tiny amounts
    n--;
    n |= n >>> 1;
    n |= n >>> 2;
    n |= n >>> 4;
    n |= n >>> 8;
    n |= n >>> 16;
    n++;
  }
  return n;
}

// This function is designed to be inlinable, so please take care when making
// changes to the function body.
function howMuchToRead(n, state) {
  if (n <= 0 || state.length === 0 && state.ended) return 0;
  if (state.objectMode) return 1;
  if (n !== n) {
    // Only flow one buffer at a time
    if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;
  }
  // If we're asking for more than the current hwm, then raise the hwm.
  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
  if (n <= state.length) return n;
  // Don't have enough
  if (!state.ended) {
    state.needReadable = true;
    return 0;
  }
  return state.length;
}

// you can override either this method, or the async _read(n) below.
Readable.prototype.read = function (n) {
  debug('read', n);
  n = parseInt(n, 10);
  var state = this._readableState;
  var nOrig = n;

  if (n !== 0) state.emittedReadable = false;

  // if we're doing read(0) to trigger a readable event, but we
  // already have a bunch of data in the buffer, then just trigger
  // the 'readable' event and move on.
  if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {
    debug('read: emitReadable', state.length, state.ended);
    if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);
    return null;
  }

  n = howMuchToRead(n, state);

  // if we've ended, and we're now clear, then finish it up.
  if (n === 0 && state.ended) {
    if (state.length === 0) endReadable(this);
    return null;
  }

  // All the actual chunk generation logic needs to be
  // *below* the call to _read.  The reason is that in certain
  // synthetic stream cases, such as passthrough streams, _read
  // may be a completely synchronous operation which may change
  // the state of the read buffer, providing enough data when
  // before there was *not* enough.
  //
  // So, the steps are:
  // 1. Figure out what the state of things will be after we do
  // a read from the buffer.
  //
  // 2. If that resulting state will trigger a _read, then call _read.
  // Note that this may be asynchronous, or synchronous.  Yes, it is
  // deeply ugly to write APIs this way, but that still doesn't mean
  // that the Readable class should behave improperly, as streams are
  // designed to be sync/async agnostic.
  // Take note if the _read call is sync or async (ie, if the read call
  // has returned yet), so that we know whether or not it's safe to emit
  // 'readable' etc.
  //
  // 3. Actually pull the requested chunks out of the buffer and return.

  // if we need a readable event, then we need to do some reading.
  var doRead = state.needReadable;
  debug('need readable', doRead);

  // if we currently have less than the highWaterMark, then also read some
  if (state.length === 0 || state.length - n < state.highWaterMark) {
    doRead = true;
    debug('length less than watermark', doRead);
  }

  // however, if we've ended, then there's no point, and if we're already
  // reading, then it's unnecessary.
  if (state.ended || state.reading) {
    doRead = false;
    debug('reading or ended', doRead);
  } else if (doRead) {
    debug('do read');
    state.reading = true;
    state.sync = true;
    // if the length is currently zero, then we *need* a readable event.
    if (state.length === 0) state.needReadable = true;
    // call internal read method
    this._read(state.highWaterMark);
    state.sync = false;
    // If _read pushed data synchronously, then `reading` will be false,
    // and we need to re-evaluate how much data we can return to the user.
    if (!state.reading) n = howMuchToRead(nOrig, state);
  }

  var ret;
  if (n > 0) ret = fromList(n, state);else ret = null;

  if (ret === null) {
    state.needReadable = true;
    n = 0;
  } else {
    state.length -= n;
  }

  if (state.length === 0) {
    // If we have nothing in the buffer, then we want to know
    // as soon as we *do* get something into the buffer.
    if (!state.ended) state.needReadable = true;

    // If we tried to read() past the EOF, then emit end on the next tick.
    if (nOrig !== n && state.ended) endReadable(this);
  }

  if (ret !== null) this.emit('data', ret);

  return ret;
};

function onEofChunk(stream, state) {
  if (state.ended) return;
  if (state.decoder) {
    var chunk = state.decoder.end();
    if (chunk && chunk.length) {
      state.buffer.push(chunk);
      state.length += state.objectMode ? 1 : chunk.length;
    }
  }
  state.ended = true;

  // emit 'readable' now to make sure it gets picked up.
  emitReadable(stream);
}

// Don't emit readable right away in sync mode, because this can trigger
// another read() call => stack overflow.  This way, it might trigger
// a nextTick recursion warning, but that's not so bad.
function emitReadable(stream) {
  var state = stream._readableState;
  state.needReadable = false;
  if (!state.emittedReadable) {
    debug('emitReadable', state.flowing);
    state.emittedReadable = true;
    if (state.sync) processNextTick(emitReadable_, stream);else emitReadable_(stream);
  }
}

function emitReadable_(stream) {
  debug('emit readable');
  stream.emit('readable');
  flow(stream);
}

// at this point, the user has presumably seen the 'readable' event,
// and called read() to consume some data.  that may have triggered
// in turn another _read(n) call, in which case reading = true if
// it's in progress.
// However, if we're not ended, or reading, and the length < hwm,
// then go ahead and try to read some more preemptively.
function maybeReadMore(stream, state) {
  if (!state.readingMore) {
    state.readingMore = true;
    processNextTick(maybeReadMore_, stream, state);
  }
}

function maybeReadMore_(stream, state) {
  var len = state.length;
  while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {
    debug('maybeReadMore read 0');
    stream.read(0);
    if (len === state.length)
      // didn't get any data, stop spinning.
      break;else len = state.length;
  }
  state.readingMore = false;
}

// abstract method.  to be overridden in specific implementation classes.
// call cb(er, data) where data is <= n in length.
// for virtual (non-string, non-buffer) streams, "length" is somewhat
// arbitrary, and perhaps not very meaningful.
Readable.prototype._read = function (n) {
  this.emit('error', new Error('_read() is not implemented'));
};

Readable.prototype.pipe = function (dest, pipeOpts) {
  var src = this;
  var state = this._readableState;

  switch (state.pipesCount) {
    case 0:
      state.pipes = dest;
      break;
    case 1:
      state.pipes = [state.pipes, dest];
      break;
    default:
      state.pipes.push(dest);
      break;
  }
  state.pipesCount += 1;
  debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);

  var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;

  var endFn = doEnd ? onend : unpipe;
  if (state.endEmitted) processNextTick(endFn);else src.once('end', endFn);

  dest.on('unpipe', onunpipe);
  function onunpipe(readable, unpipeInfo) {
    debug('onunpipe');
    if (readable === src) {
      if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
        unpipeInfo.hasUnpiped = true;
        cleanup();
      }
    }
  }

  function onend() {
    debug('onend');
    dest.end();
  }

  // when the dest drains, it reduces the awaitDrain counter
  // on the source.  This would be more elegant with a .once()
  // handler in flow(), but adding and removing repeatedly is
  // too slow.
  var ondrain = pipeOnDrain(src);
  dest.on('drain', ondrain);

  var cleanedUp = false;
  function cleanup() {
    debug('cleanup');
    // cleanup event handlers once the pipe is broken
    dest.removeListener('close', onclose);
    dest.removeListener('finish', onfinish);
    dest.removeListener('drain', ondrain);
    dest.removeListener('error', onerror);
    dest.removeListener('unpipe', onunpipe);
    src.removeListener('end', onend);
    src.removeListener('end', unpipe);
    src.removeListener('data', ondata);

    cleanedUp = true;

    // if the reader is waiting for a drain event from this
    // specific writer, then it would cause it to never start
    // flowing again.
    // So, if this is awaiting a drain, then we just call it now.
    // If we don't know, then assume that we are waiting for one.
    if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
  }

  // If the user pushes more data while we're writing to dest then we'll end up
  // in ondata again. However, we only want to increase awaitDrain once because
  // dest will only emit one 'drain' event for the multiple writes.
  // => Introduce a guard on increasing awaitDrain.
  var increasedAwaitDrain = false;
  src.on('data', ondata);
  function ondata(chunk) {
    debug('ondata');
    increasedAwaitDrain = false;
    var ret = dest.write(chunk);
    if (false === ret && !increasedAwaitDrain) {
      // If the user unpiped during `dest.write()`, it is possible
      // to get stuck in a permanently paused state if that write
      // also returned false.
      // => Check whether `dest` is still a piping destination.
      if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
        debug('false write response, pause', src._readableState.awaitDrain);
        src._readableState.awaitDrain++;
        increasedAwaitDrain = true;
      }
      src.pause();
    }
  }

  // if the dest has an error, then stop piping into it.
  // however, don't suppress the throwing behavior for this.
  function onerror(er) {
    debug('onerror', er);
    unpipe();
    dest.removeListener('error', onerror);
    if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);
  }

  // Make sure our error handler is attached before userland ones.
  prependListener(dest, 'error', onerror);

  // Both close and finish should trigger unpipe, but only once.
  function onclose() {
    dest.removeListener('finish', onfinish);
    unpipe();
  }
  dest.once('close', onclose);
  function onfinish() {
    debug('onfinish');
    dest.removeListener('close', onclose);
    unpipe();
  }
  dest.once('finish', onfinish);

  function unpipe() {
    debug('unpipe');
    src.unpipe(dest);
  }

  // tell the dest that it's being piped to
  dest.emit('pipe', src);

  // start the flow if it hasn't been started already.
  if (!state.flowing) {
    debug('pipe resume');
    src.resume();
  }

  return dest;
};

function pipeOnDrain(src) {
  return function () {
    var state = src._readableState;
    debug('pipeOnDrain', state.awaitDrain);
    if (state.awaitDrain) state.awaitDrain--;
    if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {
      state.flowing = true;
      flow(src);
    }
  };
}

Readable.prototype.unpipe = function (dest) {
  var state = this._readableState;
  var unpipeInfo = { hasUnpiped: false };

  // if we're not piping anywhere, then do nothing.
  if (state.pipesCount === 0) return this;

  // just one destination.  most common case.
  if (state.pipesCount === 1) {
    // passed in one, but it's not the right one.
    if (dest && dest !== state.pipes) return this;

    if (!dest) dest = state.pipes;

    // got a match.
    state.pipes = null;
    state.pipesCount = 0;
    state.flowing = false;
    if (dest) dest.emit('unpipe', this, unpipeInfo);
    return this;
  }

  // slow case. multiple pipe destinations.

  if (!dest) {
    // remove all.
    var dests = state.pipes;
    var len = state.pipesCount;
    state.pipes = null;
    state.pipesCount = 0;
    state.flowing = false;

    for (var i = 0; i < len; i++) {
      dests[i].emit('unpipe', this, unpipeInfo);
    }return this;
  }

  // try to find the right one.
  var index = indexOf(state.pipes, dest);
  if (index === -1) return this;

  state.pipes.splice(index, 1);
  state.pipesCount -= 1;
  if (state.pipesCount === 1) state.pipes = state.pipes[0];

  dest.emit('unpipe', this, unpipeInfo);

  return this;
};

// set up data events if they are asked for
// Ensure readable listeners eventually get something
Readable.prototype.on = function (ev, fn) {
  var res = Stream.prototype.on.call(this, ev, fn);

  if (ev === 'data') {
    // Start flowing on next tick if stream isn't explicitly paused
    if (this._readableState.flowing !== false) this.resume();
  } else if (ev === 'readable') {
    var state = this._readableState;
    if (!state.endEmitted && !state.readableListening) {
      state.readableListening = state.needReadable = true;
      state.emittedReadable = false;
      if (!state.reading) {
        processNextTick(nReadingNextTick, this);
      } else if (state.length) {
        emitReadable(this);
      }
    }
  }

  return res;
};
Readable.prototype.addListener = Readable.prototype.on;

function nReadingNextTick(self) {
  debug('readable nexttick read 0');
  self.read(0);
}

// pause() and resume() are remnants of the legacy readable stream API
// If the user uses them, then switch into old mode.
Readable.prototype.resume = function () {
  var state = this._readableState;
  if (!state.flowing) {
    debug('resume');
    state.flowing = true;
    resume(this, state);
  }
  return this;
};

function resume(stream, state) {
  if (!state.resumeScheduled) {
    state.resumeScheduled = true;
    processNextTick(resume_, stream, state);
  }
}

function resume_(stream, state) {
  if (!state.reading) {
    debug('resume read 0');
    stream.read(0);
  }

  state.resumeScheduled = false;
  state.awaitDrain = 0;
  stream.emit('resume');
  flow(stream);
  if (state.flowing && !state.reading) stream.read(0);
}

Readable.prototype.pause = function () {
  debug('call pause flowing=%j', this._readableState.flowing);
  if (false !== this._readableState.flowing) {
    debug('pause');
    this._readableState.flowing = false;
    this.emit('pause');
  }
  return this;
};

function flow(stream) {
  var state = stream._readableState;
  debug('flow', state.flowing);
  while (state.flowing && stream.read() !== null) {}
}

// wrap an old-style stream as the async data source.
// This is *not* part of the readable stream interface.
// It is an ugly unfortunate mess of history.
Readable.prototype.wrap = function (stream) {
  var state = this._readableState;
  var paused = false;

  var self = this;
  stream.on('end', function () {
    debug('wrapped end');
    if (state.decoder && !state.ended) {
      var chunk = state.decoder.end();
      if (chunk && chunk.length) self.push(chunk);
    }

    self.push(null);
  });

  stream.on('data', function (chunk) {
    debug('wrapped data');
    if (state.decoder) chunk = state.decoder.write(chunk);

    // don't skip over falsy values in objectMode
    if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;

    var ret = self.push(chunk);
    if (!ret) {
      paused = true;
      stream.pause();
    }
  });

  // proxy all the other methods.
  // important when wrapping filters and duplexes.
  for (var i in stream) {
    if (this[i] === undefined && typeof stream[i] === 'function') {
      this[i] = function (method) {
        return function () {
          return stream[method].apply(stream, arguments);
        };
      }(i);
    }
  }

  // proxy certain important events.
  for (var n = 0; n < kProxyEvents.length; n++) {
    stream.on(kProxyEvents[n], self.emit.bind(self, kProxyEvents[n]));
  }

  // when we try to consume some more bytes, simply unpause the
  // underlying stream.
  self._read = function (n) {
    debug('wrapped _read', n);
    if (paused) {
      paused = false;
      stream.resume();
    }
  };

  return self;
};

// exposed for testing purposes only.
Readable._fromList = fromList;

// Pluck off n bytes from an array of buffers.
// Length is the combined lengths of all the buffers in the list.
// This function is designed to be inlinable, so please take care when making
// changes to the function body.
function fromList(n, state) {
  // nothing buffered
  if (state.length === 0) return null;

  var ret;
  if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {
    // read it all, truncate the list
    if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length);
    state.buffer.clear();
  } else {
    // read part of list
    ret = fromListPartial(n, state.buffer, state.decoder);
  }

  return ret;
}

// Extracts only enough buffered data to satisfy the amount requested.
// This function is designed to be inlinable, so please take care when making
// changes to the function body.
function fromListPartial(n, list, hasStrings) {
  var ret;
  if (n < list.head.data.length) {
    // slice is the same for buffers and strings
    ret = list.head.data.slice(0, n);
    list.head.data = list.head.data.slice(n);
  } else if (n === list.head.data.length) {
    // first chunk is a perfect match
    ret = list.shift();
  } else {
    // result spans more than one buffer
    ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);
  }
  return ret;
}

// Copies a specified amount of characters from the list of buffered data
// chunks.
// This function is designed to be inlinable, so please take care when making
// changes to the function body.
function copyFromBufferString(n, list) {
  var p = list.head;
  var c = 1;
  var ret = p.data;
  n -= ret.length;
  while (p = p.next) {
    var str = p.data;
    var nb = n > str.length ? str.length : n;
    if (nb === str.length) ret += str;else ret += str.slice(0, n);
    n -= nb;
    if (n === 0) {
      if (nb === str.length) {
        ++c;
        if (p.next) list.head = p.next;else list.head = list.tail = null;
      } else {
        list.head = p;
        p.data = str.slice(nb);
      }
      break;
    }
    ++c;
  }
  list.length -= c;
  return ret;
}

// Copies a specified amount of bytes from the list of buffered data chunks.
// This function is designed to be inlinable, so please take care when making
// changes to the function body.
function copyFromBuffer(n, list) {
  var ret = Buffer.allocUnsafe(n);
  var p = list.head;
  var c = 1;
  p.data.copy(ret);
  n -= p.data.length;
  while (p = p.next) {
    var buf = p.data;
    var nb = n > buf.length ? buf.length : n;
    buf.copy(ret, ret.length - n, 0, nb);
    n -= nb;
    if (n === 0) {
      if (nb === buf.length) {
        ++c;
        if (p.next) list.head = p.next;else list.head = list.tail = null;
      } else {
        list.head = p;
        p.data = buf.slice(nb);
      }
      break;
    }
    ++c;
  }
  list.length -= c;
  return ret;
}

function endReadable(stream) {
  var state = stream._readableState;

  // If we get here before consuming all the bytes, then that is a
  // bug in node.  Should never happen.
  if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream');

  if (!state.endEmitted) {
    state.ended = true;
    processNextTick(endReadableNT, state, stream);
  }
}

function endReadableNT(state, stream) {
  // Check that we didn't get one last unshift.
  if (!state.endEmitted && state.length === 0) {
    state.endEmitted = true;
    stream.readable = false;
    stream.emit('end');
  }
}

function forEach(xs, f) {
  for (var i = 0, l = xs.length; i < l; i++) {
    f(xs[i], i);
  }
}

function indexOf(xs, x) {
  for (var i = 0, l = xs.length; i < l; i++) {
    if (xs[i] === x) return i;
  }
  return -1;
}
}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{"./_stream_duplex":22,"./internal/streams/BufferList":27,"./internal/streams/destroy":28,"./internal/streams/stream":29,"_process":16,"core-util-is":7,"events":8,"inherits":10,"isarray":12,"process-nextick-args":15,"safe-buffer":34,"string_decoder/":36,"util":4}],25:[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// 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.

// a transform stream is a readable/writable stream where you do
// something with the data.  Sometimes it's called a "filter",
// but that's not a great name for it, since that implies a thing where
// some bits pass through, and others are simply ignored.  (That would
// be a valid example of a transform, of course.)
//
// While the output is causally related to the input, it's not a
// necessarily symmetric or synchronous transformation.  For example,
// a zlib stream might take multiple plain-text writes(), and then
// emit a single compressed chunk some time in the future.
//
// Here's how this works:
//
// The Transform stream has all the aspects of the readable and writable
// stream classes.  When you write(chunk), that calls _write(chunk,cb)
// internally, and returns false if there's a lot of pending writes
// buffered up.  When you call read(), that calls _read(n) until
// there's enough pending readable data buffered up.
//
// In a transform stream, the written data is placed in a buffer.  When
// _read(n) is called, it transforms the queued up data, calling the
// buffered _write cb's as it consumes chunks.  If consuming a single
// written chunk would result in multiple output chunks, then the first
// outputted bit calls the readcb, and subsequent chunks just go into
// the read buffer, and will cause it to emit 'readable' if necessary.
//
// This way, back-pressure is actually determined by the reading side,
// since _read has to be called to start processing a new chunk.  However,
// a pathological inflate type of transform can cause excessive buffering
// here.  For example, imagine a stream where every byte of input is
// interpreted as an integer from 0-255, and then results in that many
// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in
// 1kb of data being output.  In this case, you could write a very small
// amount of input, and end up with a very large amount of output.  In
// such a pathological inflating mechanism, there'd be no way to tell
// the system to stop doing the transform.  A single 4MB write could
// cause the system to run out of memory.
//
// However, even in such a pathological case, only a single written chunk
// would be consumed, and then the rest would wait (un-transformed) until
// the results of the previous transformed chunk were consumed.

'use strict';

module.exports = Transform;

var Duplex = require('./_stream_duplex');

/*<replacement>*/
var util = require('core-util-is');
util.inherits = require('inherits');
/*</replacement>*/

util.inherits(Transform, Duplex);

function TransformState(stream) {
  this.afterTransform = function (er, data) {
    return afterTransform(stream, er, data);
  };

  this.needTransform = false;
  this.transforming = false;
  this.writecb = null;
  this.writechunk = null;
  this.writeencoding = null;
}

function afterTransform(stream, er, data) {
  var ts = stream._transformState;
  ts.transforming = false;

  var cb = ts.writecb;

  if (!cb) {
    return stream.emit('error', new Error('write callback called multiple times'));
  }

  ts.writechunk = null;
  ts.writecb = null;

  if (data !== null && data !== undefined) stream.push(data);

  cb(er);

  var rs = stream._readableState;
  rs.reading = false;
  if (rs.needReadable || rs.length < rs.highWaterMark) {
    stream._read(rs.highWaterMark);
  }
}

function Transform(options) {
  if (!(this instanceof Transform)) return new Transform(options);

  Duplex.call(this, options);

  this._transformState = new TransformState(this);

  var stream = this;

  // start out asking for a readable event once data is transformed.
  this._readableState.needReadable = true;

  // we have implemented the _read method, and done the other things
  // that Readable wants before the first _read call, so unset the
  // sync guard flag.
  this._readableState.sync = false;

  if (options) {
    if (typeof options.transform === 'function') this._transform = options.transform;

    if (typeof options.flush === 'function') this._flush = options.flush;
  }

  // When the writable side finishes, then flush out anything remaining.
  this.once('prefinish', function () {
    if (typeof this._flush === 'function') this._flush(function (er, data) {
      done(stream, er, data);
    });else done(stream);
  });
}

Transform.prototype.push = function (chunk, encoding) {
  this._transformState.needTransform = false;
  return Duplex.prototype.push.call(this, chunk, encoding);
};

// This is the part where you do stuff!
// override this function in implementation classes.
// 'chunk' is an input chunk.
//
// Call `push(newChunk)` to pass along transformed output
// to the readable side.  You may call 'push' zero or more times.
//
// Call `cb(err)` when you are done with this chunk.  If you pass
// an error, then that'll put the hurt on the whole operation.  If you
// never call cb(), then you'll never get another chunk.
Transform.prototype._transform = function (chunk, encoding, cb) {
  throw new Error('_transform() is not implemented');
};

Transform.prototype._write = function (chunk, encoding, cb) {
  var ts = this._transformState;
  ts.writecb = cb;
  ts.writechunk = chunk;
  ts.writeencoding = encoding;
  if (!ts.transforming) {
    var rs = this._readableState;
    if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
  }
};

// Doesn't matter what the args are here.
// _transform does all the work.
// That we got here means that the readable side wants more data.
Transform.prototype._read = function (n) {
  var ts = this._transformState;

  if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
    ts.transforming = true;
    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
  } else {
    // mark that we need a transform, so that any data that comes in
    // will get processed, now that we've asked for it.
    ts.needTransform = true;
  }
};

Transform.prototype._destroy = function (err, cb) {
  var _this = this;

  Duplex.prototype._destroy.call(this, err, function (err2) {
    cb(err2);
    _this.emit('close');
  });
};

function done(stream, er, data) {
  if (er) return stream.emit('error', er);

  if (data !== null && data !== undefined) stream.push(data);

  // if there's nothing in the write buffer, then that means
  // that nothing more will ever be provided
  var ws = stream._writableState;
  var ts = stream._transformState;

  if (ws.length) throw new Error('Calling transform done when ws.length != 0');

  if (ts.transforming) throw new Error('Calling transform done when still transforming');

  return stream.push(null);
}
},{"./_stream_duplex":22,"core-util-is":7,"inherits":10}],26:[function(require,module,exports){
(function (process,global){
// Copyright Joyent, Inc. and other Node contributors.
//
// 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.

// A bit simpler than readable streams.
// Implement an async ._write(chunk, encoding, cb), and it'll handle all
// the drain event emission and buffering.

'use strict';

/*<replacement>*/

var processNextTick = require('process-nextick-args');
/*</replacement>*/

module.exports = Writable;

/* <replacement> */
function WriteReq(chunk, encoding, cb) {
  this.chunk = chunk;
  this.encoding = encoding;
  this.callback = cb;
  this.next = null;
}

// It seems a linked list but it is not
// there will be only 2 of these for each stream
function CorkedRequest(state) {
  var _this = this;

  this.next = null;
  this.entry = null;
  this.finish = function () {
    onCorkedFinish(_this, state);
  };
}
/* </replacement> */

/*<replacement>*/
var asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : processNextTick;
/*</replacement>*/

/*<replacement>*/
var Duplex;
/*</replacement>*/

Writable.WritableState = WritableState;

/*<replacement>*/
var util = require('core-util-is');
util.inherits = require('inherits');
/*</replacement>*/

/*<replacement>*/
var internalUtil = {
  deprecate: require('util-deprecate')
};
/*</replacement>*/

/*<replacement>*/
var Stream = require('./internal/streams/stream');
/*</replacement>*/

/*<replacement>*/
var Buffer = require('safe-buffer').Buffer;
var OurUint8Array = global.Uint8Array || function () {};
function _uint8ArrayToBuffer(chunk) {
  return Buffer.from(chunk);
}
function _isUint8Array(obj) {
  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
}
/*</replacement>*/

var destroyImpl = require('./internal/streams/destroy');

util.inherits(Writable, Stream);

function nop() {}

function WritableState(options, stream) {
  Duplex = Duplex || require('./_stream_duplex');

  options = options || {};

  // object stream flag to indicate whether or not this stream
  // contains buffers or objects.
  this.objectMode = !!options.objectMode;

  if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.writableObjectMode;

  // the point at which write() starts returning false
  // Note: 0 is a valid value, means that we always return false if
  // the entire buffer is not flushed immediately on write()
  var hwm = options.highWaterMark;
  var defaultHwm = this.objectMode ? 16 : 16 * 1024;
  this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;

  // cast to ints.
  this.highWaterMark = Math.floor(this.highWaterMark);

  // if _final has been called
  this.finalCalled = false;

  // drain event flag.
  this.needDrain = false;
  // at the start of calling end()
  this.ending = false;
  // when end() has been called, and returned
  this.ended = false;
  // when 'finish' is emitted
  this.finished = false;

  // has it been destroyed
  this.destroyed = false;

  // should we decode strings into buffers before passing to _write?
  // this is here so that some node-core streams can optimize string
  // handling at a lower level.
  var noDecode = options.decodeStrings === false;
  this.decodeStrings = !noDecode;

  // Crypto is kind of old and crusty.  Historically, its default string
  // encoding is 'binary' so we have to make this configurable.
  // Everything else in the universe uses 'utf8', though.
  this.defaultEncoding = options.defaultEncoding || 'utf8';

  // not an actual buffer we keep track of, but a measurement
  // of how much we're waiting to get pushed to some underlying
  // socket or file.
  this.length = 0;

  // a flag to see when we're in the middle of a write.
  this.writing = false;

  // when true all writes will be buffered until .uncork() call
  this.corked = 0;

  // a flag to be able to tell if the onwrite cb is called immediately,
  // or on a later tick.  We set this to true at first, because any
  // actions that shouldn't happen until "later" should generally also
  // not happen before the first write call.
  this.sync = true;

  // a flag to know if we're processing previously buffered items, which
  // may call the _write() callback in the same tick, so that we don't
  // end up in an overlapped onwrite situation.
  this.bufferProcessing = false;

  // the callback that's passed to _write(chunk,cb)
  this.onwrite = function (er) {
    onwrite(stream, er);
  };

  // the callback that the user supplies to write(chunk,encoding,cb)
  this.writecb = null;

  // the amount that is being written when _write is called.
  this.writelen = 0;

  this.bufferedRequest = null;
  this.lastBufferedRequest = null;

  // number of pending user-supplied write callbacks
  // this must be 0 before 'finish' can be emitted
  this.pendingcb = 0;

  // emit prefinish if the only thing we're waiting for is _write cbs
  // This is relevant for synchronous Transform streams
  this.prefinished = false;

  // True if the error was already emitted and should not be thrown again
  this.errorEmitted = false;

  // count buffered requests
  this.bufferedRequestCount = 0;

  // allocate the first CorkedRequest, there is always
  // one allocated and free to use, and we maintain at most two
  this.corkedRequestsFree = new CorkedRequest(this);
}

WritableState.prototype.getBuffer = function getBuffer() {
  var current = this.bufferedRequest;
  var out = [];
  while (current) {
    out.push(current);
    current = current.next;
  }
  return out;
};

(function () {
  try {
    Object.defineProperty(WritableState.prototype, 'buffer', {
      get: internalUtil.deprecate(function () {
        return this.getBuffer();
      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')
    });
  } catch (_) {}
})();

// Test _writableState for inheritance to account for Duplex streams,
// whose prototype chain only points to Readable.
var realHasInstance;
if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {
  realHasInstance = Function.prototype[Symbol.hasInstance];
  Object.defineProperty(Writable, Symbol.hasInstance, {
    value: function (object) {
      if (realHasInstance.call(this, object)) return true;

      return object && object._writableState instanceof WritableState;
    }
  });
} else {
  realHasInstance = function (object) {
    return object instanceof this;
  };
}

function Writable(options) {
  Duplex = Duplex || require('./_stream_duplex');

  // Writable ctor is applied to Duplexes, too.
  // `realHasInstance` is necessary because using plain `instanceof`
  // would return false, as no `_writableState` property is attached.

  // Trying to use the custom `instanceof` for Writable here will also break the
  // Node.js LazyTransform implementation, which has a non-trivial getter for
  // `_writableState` that would lead to infinite recursion.
  if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {
    return new Writable(options);
  }

  this._writableState = new WritableState(options, this);

  // legacy.
  this.writable = true;

  if (options) {
    if (typeof options.write === 'function') this._write = options.write;

    if (typeof options.writev === 'function') this._writev = options.writev;

    if (typeof options.destroy === 'function') this._destroy = options.destroy;

    if (typeof options.final === 'function') this._final = options.final;
  }

  Stream.call(this);
}

// Otherwise people can pipe Writable streams, which is just wrong.
Writable.prototype.pipe = function () {
  this.emit('error', new Error('Cannot pipe, not readable'));
};

function writeAfterEnd(stream, cb) {
  var er = new Error('write after end');
  // TODO: defer error events consistently everywhere, not just the cb
  stream.emit('error', er);
  processNextTick(cb, er);
}

// Checks that a user-supplied chunk is valid, especially for the particular
// mode the stream is in. Currently this means that `null` is never accepted
// and undefined/non-string values are only allowed in object mode.
function validChunk(stream, state, chunk, cb) {
  var valid = true;
  var er = false;

  if (chunk === null) {
    er = new TypeError('May not write null values to stream');
  } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
    er = new TypeError('Invalid non-string/buffer chunk');
  }
  if (er) {
    stream.emit('error', er);
    processNextTick(cb, er);
    valid = false;
  }
  return valid;
}

Writable.prototype.write = function (chunk, encoding, cb) {
  var state = this._writableState;
  var ret = false;
  var isBuf = _isUint8Array(chunk) && !state.objectMode;

  if (isBuf && !Buffer.isBuffer(chunk)) {
    chunk = _uint8ArrayToBuffer(chunk);
  }

  if (typeof encoding === 'function') {
    cb = encoding;
    encoding = null;
  }

  if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;

  if (typeof cb !== 'function') cb = nop;

  if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {
    state.pendingcb++;
    ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
  }

  return ret;
};

Writable.prototype.cork = function () {
  var state = this._writableState;

  state.corked++;
};

Writable.prototype.uncork = function () {
  var state = this._writableState;

  if (state.corked) {
    state.corked--;

    if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
  }
};

Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
  // node::ParseEncoding() requires lower case.
  if (typeof encoding === 'string') encoding = encoding.toLowerCase();
  if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding);
  this._writableState.defaultEncoding = encoding;
  return this;
};

function decodeChunk(state, chunk, encoding) {
  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {
    chunk = Buffer.from(chunk, encoding);
  }
  return chunk;
}

// if we're already writing something, then just put this
// in the queue, and wait our turn.  Otherwise, call _write
// If we return false, then we need a drain event, so set that flag.
function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
  if (!isBuf) {
    var newChunk = decodeChunk(state, chunk, encoding);
    if (chunk !== newChunk) {
      isBuf = true;
      encoding = 'buffer';
      chunk = newChunk;
    }
  }
  var len = state.objectMode ? 1 : chunk.length;

  state.length += len;

  var ret = state.length < state.highWaterMark;
  // we must ensure that previous needDrain will not be reset to false.
  if (!ret) state.needDrain = true;

  if (state.writing || state.corked) {
    var last = state.lastBufferedRequest;
    state.lastBufferedRequest = {
      chunk: chunk,
      encoding: encoding,
      isBuf: isBuf,
      callback: cb,
      next: null
    };
    if (last) {
      last.next = state.lastBufferedRequest;
    } else {
      state.bufferedRequest = state.lastBufferedRequest;
    }
    state.bufferedRequestCount += 1;
  } else {
    doWrite(stream, state, false, len, chunk, encoding, cb);
  }

  return ret;
}

function doWrite(stream, state, writev, len, chunk, encoding, cb) {
  state.writelen = len;
  state.writecb = cb;
  state.writing = true;
  state.sync = true;
  if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);
  state.sync = false;
}

function onwriteError(stream, state, sync, er, cb) {
  --state.pendingcb;

  if (sync) {
    // defer the callback if we are being called synchronously
    // to avoid piling up things on the stack
    processNextTick(cb, er);
    // this can emit finish, and it will always happen
    // after error
    processNextTick(finishMaybe, stream, state);
    stream._writableState.errorEmitted = true;
    stream.emit('error', er);
  } else {
    // the caller expect this to happen before if
    // it is async
    cb(er);
    stream._writableState.errorEmitted = true;
    stream.emit('error', er);
    // this can emit finish, but finish must
    // always follow error
    finishMaybe(stream, state);
  }
}

function onwriteStateUpdate(state) {
  state.writing = false;
  state.writecb = null;
  state.length -= state.writelen;
  state.writelen = 0;
}

function onwrite(stream, er) {
  var state = stream._writableState;
  var sync = state.sync;
  var cb = state.writecb;

  onwriteStateUpdate(state);

  if (er) onwriteError(stream, state, sync, er, cb);else {
    // Check if we're actually ready to finish, but don't emit yet
    var finished = needFinish(state);

    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
      clearBuffer(stream, state);
    }

    if (sync) {
      /*<replacement>*/
      asyncWrite(afterWrite, stream, state, finished, cb);
      /*</replacement>*/
    } else {
      afterWrite(stream, state, finished, cb);
    }
  }
}

function afterWrite(stream, state, finished, cb) {
  if (!finished) onwriteDrain(stream, state);
  state.pendingcb--;
  cb();
  finishMaybe(stream, state);
}

// Must force callback to be called on nextTick, so that we don't
// emit 'drain' before the write() consumer gets the 'false' return
// value, and has a chance to attach a 'drain' listener.
function onwriteDrain(stream, state) {
  if (state.length === 0 && state.needDrain) {
    state.needDrain = false;
    stream.emit('drain');
  }
}

// if there's something in the buffer waiting, then process it
function clearBuffer(stream, state) {
  state.bufferProcessing = true;
  var entry = state.bufferedRequest;

  if (stream._writev && entry && entry.next) {
    // Fast case, write everything using _writev()
    var l = state.bufferedRequestCount;
    var buffer = new Array(l);
    var holder = state.corkedRequestsFree;
    holder.entry = entry;

    var count = 0;
    var allBuffers = true;
    while (entry) {
      buffer[count] = entry;
      if (!entry.isBuf) allBuffers = false;
      entry = entry.next;
      count += 1;
    }
    buffer.allBuffers = allBuffers;

    doWrite(stream, state, true, state.length, buffer, '', holder.finish);

    // doWrite is almost always async, defer these to save a bit of time
    // as the hot path ends with doWrite
    state.pendingcb++;
    state.lastBufferedRequest = null;
    if (holder.next) {
      state.corkedRequestsFree = holder.next;
      holder.next = null;
    } else {
      state.corkedRequestsFree = new CorkedRequest(state);
    }
  } else {
    // Slow case, write chunks one-by-one
    while (entry) {
      var chunk = entry.chunk;
      var encoding = entry.encoding;
      var cb = entry.callback;
      var len = state.objectMode ? 1 : chunk.length;

      doWrite(stream, state, false, len, chunk, encoding, cb);
      entry = entry.next;
      // if we didn't call the onwrite immediately, then
      // it means that we need to wait until it does.
      // also, that means that the chunk and cb are currently
      // being processed, so move the buffer counter past them.
      if (state.writing) {
        break;
      }
    }

    if (entry === null) state.lastBufferedRequest = null;
  }

  state.bufferedRequestCount = 0;
  state.bufferedRequest = entry;
  state.bufferProcessing = false;
}

Writable.prototype._write = function (chunk, encoding, cb) {
  cb(new Error('_write() is not implemented'));
};

Writable.prototype._writev = null;

Writable.prototype.end = function (chunk, encoding, cb) {
  var state = this._writableState;

  if (typeof chunk === 'function') {
    cb = chunk;
    chunk = null;
    encoding = null;
  } else if (typeof encoding === 'function') {
    cb = encoding;
    encoding = null;
  }

  if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);

  // .end() fully uncorks
  if (state.corked) {
    state.corked = 1;
    this.uncork();
  }

  // ignore unnecessary end() calls.
  if (!state.ending && !state.finished) endWritable(this, state, cb);
};

function needFinish(state) {
  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
}
function callFinal(stream, state) {
  stream._final(function (err) {
    state.pendingcb--;
    if (err) {
      stream.emit('error', err);
    }
    state.prefinished = true;
    stream.emit('prefinish');
    finishMaybe(stream, state);
  });
}
function prefinish(stream, state) {
  if (!state.prefinished && !state.finalCalled) {
    if (typeof stream._final === 'function') {
      state.pendingcb++;
      state.finalCalled = true;
      processNextTick(callFinal, stream, state);
    } else {
      state.prefinished = true;
      stream.emit('prefinish');
    }
  }
}

function finishMaybe(stream, state) {
  var need = needFinish(state);
  if (need) {
    prefinish(stream, state);
    if (state.pendingcb === 0) {
      state.finished = true;
      stream.emit('finish');
    }
  }
  return need;
}

function endWritable(stream, state, cb) {
  state.ending = true;
  finishMaybe(stream, state);
  if (cb) {
    if (state.finished) processNextTick(cb);else stream.once('finish', cb);
  }
  state.ended = true;
  stream.writable = false;
}

function onCorkedFinish(corkReq, state, err) {
  var entry = corkReq.entry;
  corkReq.entry = null;
  while (entry) {
    var cb = entry.callback;
    state.pendingcb--;
    cb(err);
    entry = entry.next;
  }
  if (state.corkedRequestsFree) {
    state.corkedRequestsFree.next = corkReq;
  } else {
    state.corkedRequestsFree = corkReq;
  }
}

Object.defineProperty(Writable.prototype, 'destroyed', {
  get: function () {
    if (this._writableState === undefined) {
      return false;
    }
    return this._writableState.destroyed;
  },
  set: function (value) {
    // we ignore the value if the stream
    // has not been initialized yet
    if (!this._writableState) {
      return;
    }

    // backward compatibility, the user is explicitly
    // managing destroyed
    this._writableState.destroyed = value;
  }
});

Writable.prototype.destroy = destroyImpl.destroy;
Writable.prototype._undestroy = destroyImpl.undestroy;
Writable.prototype._destroy = function (err, cb) {
  this.end();
  cb(err);
};
}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{"./_stream_duplex":22,"./internal/streams/destroy":28,"./internal/streams/stream":29,"_process":16,"core-util-is":7,"inherits":10,"process-nextick-args":15,"safe-buffer":34,"util-deprecate":39}],27:[function(require,module,exports){
'use strict';

/*<replacement>*/

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Buffer = require('safe-buffer').Buffer;
/*</replacement>*/

function copyBuffer(src, target, offset) {
  src.copy(target, offset);
}

module.exports = function () {
  function BufferList() {
    _classCallCheck(this, BufferList);

    this.head = null;
    this.tail = null;
    this.length = 0;
  }

  BufferList.prototype.push = function push(v) {
    var entry = { data: v, next: null };
    if (this.length > 0) this.tail.next = entry;else this.head = entry;
    this.tail = entry;
    ++this.length;
  };

  BufferList.prototype.unshift = function unshift(v) {
    var entry = { data: v, next: this.head };
    if (this.length === 0) this.tail = entry;
    this.head = entry;
    ++this.length;
  };

  BufferList.prototype.shift = function shift() {
    if (this.length === 0) return;
    var ret = this.head.data;
    if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;
    --this.length;
    return ret;
  };

  BufferList.prototype.clear = function clear() {
    this.head = this.tail = null;
    this.length = 0;
  };

  BufferList.prototype.join = function join(s) {
    if (this.length === 0) return '';
    var p = this.head;
    var ret = '' + p.data;
    while (p = p.next) {
      ret += s + p.data;
    }return ret;
  };

  BufferList.prototype.concat = function concat(n) {
    if (this.length === 0) return Buffer.alloc(0);
    if (this.length === 1) return this.head.data;
    var ret = Buffer.allocUnsafe(n >>> 0);
    var p = this.head;
    var i = 0;
    while (p) {
      copyBuffer(p.data, ret, i);
      i += p.data.length;
      p = p.next;
    }
    return ret;
  };

  return BufferList;
}();
},{"safe-buffer":34}],28:[function(require,module,exports){
'use strict';

/*<replacement>*/

var processNextTick = require('process-nextick-args');
/*</replacement>*/

// undocumented cb() API, needed for core, not for public API
function destroy(err, cb) {
  var _this = this;

  var readableDestroyed = this._readableState && this._readableState.destroyed;
  var writableDestroyed = this._writableState && this._writableState.destroyed;

  if (readableDestroyed || writableDestroyed) {
    if (cb) {
      cb(err);
    } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {
      processNextTick(emitErrorNT, this, err);
    }
    return;
  }

  // we set destroyed to true before firing error callbacks in order
  // to make it re-entrance safe in case destroy() is called within callbacks

  if (this._readableState) {
    this._readableState.destroyed = true;
  }

  // if this is a duplex stream mark the writable part as destroyed as well
  if (this._writableState) {
    this._writableState.destroyed = true;
  }

  this._destroy(err || null, function (err) {
    if (!cb && err) {
      processNextTick(emitErrorNT, _this, err);
      if (_this._writableState) {
        _this._writableState.errorEmitted = true;
      }
    } else if (cb) {
      cb(err);
    }
  });
}

function undestroy() {
  if (this._readableState) {
    this._readableState.destroyed = false;
    this._readableState.reading = false;
    this._readableState.ended = false;
    this._readableState.endEmitted = false;
  }

  if (this._writableState) {
    this._writableState.destroyed = false;
    this._writableState.ended = false;
    this._writableState.ending = false;
    this._writableState.finished = false;
    this._writableState.errorEmitted = false;
  }
}

function emitErrorNT(self, err) {
  self.emit('error', err);
}

module.exports = {
  destroy: destroy,
  undestroy: undestroy
};
},{"process-nextick-args":15}],29:[function(require,module,exports){
module.exports = require('events').EventEmitter;

},{"events":8}],30:[function(require,module,exports){
module.exports = require('./readable').PassThrough

},{"./readable":31}],31:[function(require,module,exports){
exports = module.exports = require('./lib/_stream_readable.js');
exports.Stream = exports;
exports.Readable = exports;
exports.Writable = require('./lib/_stream_writable.js');
exports.Duplex = require('./lib/_stream_duplex.js');
exports.Transform = require('./lib/_stream_transform.js');
exports.PassThrough = require('./lib/_stream_passthrough.js');

},{"./lib/_stream_duplex.js":22,"./lib/_stream_passthrough.js":23,"./lib/_stream_readable.js":24,"./lib/_stream_transform.js":25,"./lib/_stream_writable.js":26}],32:[function(require,module,exports){
module.exports = require('./readable').Transform

},{"./readable":31}],33:[function(require,module,exports){
module.exports = require('./lib/_stream_writable.js');

},{"./lib/_stream_writable.js":26}],34:[function(require,module,exports){
/* eslint-disable node/no-deprecated-api */
var buffer = require('buffer')
var Buffer = buffer.Buffer

// alternative to using Object.keys for old browsers
function copyProps (src, dst) {
  for (var key in src) {
    dst[key] = src[key]
  }
}
if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
  module.exports = buffer
} else {
  // Copy properties from require('buffer')
  copyProps(buffer, exports)
  exports.Buffer = SafeBuffer
}

function SafeBuffer (arg, encodingOrOffset, length) {
  return Buffer(arg, encodingOrOffset, length)
}

// Copy static methods from Buffer
copyProps(Buffer, SafeBuffer)

SafeBuffer.from = function (arg, encodingOrOffset, length) {
  if (typeof arg === 'number') {
    throw new TypeError('Argument must not be a number')
  }
  return Buffer(arg, encodingOrOffset, length)
}

SafeBuffer.alloc = function (size, fill, encoding) {
  if (typeof size !== 'number') {
    throw new TypeError('Argument must be a number')
  }
  var buf = Buffer(size)
  if (fill !== undefined) {
    if (typeof encoding === 'string') {
      buf.fill(fill, encoding)
    } else {
      buf.fill(fill)
    }
  } else {
    buf.fill(0)
  }
  return buf
}

SafeBuffer.allocUnsafe = function (size) {
  if (typeof size !== 'number') {
    throw new TypeError('Argument must be a number')
  }
  return Buffer(size)
}

SafeBuffer.allocUnsafeSlow = function (size) {
  if (typeof size !== 'number') {
    throw new TypeError('Argument must be a number')
  }
  return buffer.SlowBuffer(size)
}

},{"buffer":5}],35:[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// 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.

module.exports = Stream;

var EE = require('events').EventEmitter;
var inherits = require('inherits');

inherits(Stream, EE);
Stream.Readable = require('readable-stream/readable.js');
Stream.Writable = require('readable-stream/writable.js');
Stream.Duplex = require('readable-stream/duplex.js');
Stream.Transform = require('readable-stream/transform.js');
Stream.PassThrough = require('readable-stream/passthrough.js');

// Backwards-compat with node 0.4.x
Stream.Stream = Stream;



// old-style streams.  Note that the pipe method (the only relevant
// part of this class) is overridden in the Readable class.

function Stream() {
  EE.call(this);
}

Stream.prototype.pipe = function(dest, options) {
  var source = this;

  function ondata(chunk) {
    if (dest.writable) {
      if (false === dest.write(chunk) && source.pause) {
        source.pause();
      }
    }
  }

  source.on('data', ondata);

  function ondrain() {
    if (source.readable && source.resume) {
      source.resume();
    }
  }

  dest.on('drain', ondrain);

  // If the 'end' option is not supplied, dest.end() will be called when
  // source gets the 'end' or 'close' events.  Only dest.end() once.
  if (!dest._isStdio && (!options || options.end !== false)) {
    source.on('end', onend);
    source.on('close', onclose);
  }

  var didOnEnd = false;
  function onend() {
    if (didOnEnd) return;
    didOnEnd = true;

    dest.end();
  }


  function onclose() {
    if (didOnEnd) return;
    didOnEnd = true;

    if (typeof dest.destroy === 'function') dest.destroy();
  }

  // don't leave dangling pipes when there are errors.
  function onerror(er) {
    cleanup();
    if (EE.listenerCount(this, 'error') === 0) {
      throw er; // Unhandled stream error in pipe.
    }
  }

  source.on('error', onerror);
  dest.on('error', onerror);

  // remove all the event listeners that were added.
  function cleanup() {
    source.removeListener('data', ondata);
    dest.removeListener('drain', ondrain);

    source.removeListener('end', onend);
    source.removeListener('close', onclose);

    source.removeListener('error', onerror);
    dest.removeListener('error', onerror);

    source.removeListener('end', cleanup);
    source.removeListener('close', cleanup);

    dest.removeListener('close', cleanup);
  }

  source.on('end', cleanup);
  source.on('close', cleanup);

  dest.on('close', cleanup);

  dest.emit('pipe', source);

  // Allow for unix-like usage: A.pipe(B).pipe(C)
  return dest;
};

},{"events":8,"inherits":10,"readable-stream/duplex.js":21,"readable-stream/passthrough.js":30,"readable-stream/readable.js":31,"readable-stream/transform.js":32,"readable-stream/writable.js":33}],36:[function(require,module,exports){
'use strict';

var Buffer = require('safe-buffer').Buffer;

var isEncoding = Buffer.isEncoding || function (encoding) {
  encoding = '' + encoding;
  switch (encoding && encoding.toLowerCase()) {
    case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':
      return true;
    default:
      return false;
  }
};

function _normalizeEncoding(enc) {
  if (!enc) return 'utf8';
  var retried;
  while (true) {
    switch (enc) {
      case 'utf8':
      case 'utf-8':
        return 'utf8';
      case 'ucs2':
      case 'ucs-2':
      case 'utf16le':
      case 'utf-16le':
        return 'utf16le';
      case 'latin1':
      case 'binary':
        return 'latin1';
      case 'base64':
      case 'ascii':
      case 'hex':
        return enc;
      default:
        if (retried) return; // undefined
        enc = ('' + enc).toLowerCase();
        retried = true;
    }
  }
};

// Do not cache `Buffer.isEncoding` when checking encoding names as some
// modules monkey-patch it to support additional encodings
function normalizeEncoding(enc) {
  var nenc = _normalizeEncoding(enc);
  if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);
  return nenc || enc;
}

// StringDecoder provides an interface for efficiently splitting a series of
// buffers into a series of JS strings without breaking apart multi-byte
// characters.
exports.StringDecoder = StringDecoder;
function StringDecoder(encoding) {
  this.encoding = normalizeEncoding(encoding);
  var nb;
  switch (this.encoding) {
    case 'utf16le':
      this.text = utf16Text;
      this.end = utf16End;
      nb = 4;
      break;
    case 'utf8':
      this.fillLast = utf8FillLast;
      nb = 4;
      break;
    case 'base64':
      this.text = base64Text;
      this.end = base64End;
      nb = 3;
      break;
    default:
      this.write = simpleWrite;
      this.end = simpleEnd;
      return;
  }
  this.lastNeed = 0;
  this.lastTotal = 0;
  this.lastChar = Buffer.allocUnsafe(nb);
}

StringDecoder.prototype.write = function (buf) {
  if (buf.length === 0) return '';
  var r;
  var i;
  if (this.lastNeed) {
    r = this.fillLast(buf);
    if (r === undefined) return '';
    i = this.lastNeed;
    this.lastNeed = 0;
  } else {
    i = 0;
  }
  if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
  return r || '';
};

StringDecoder.prototype.end = utf8End;

// Returns only complete characters in a Buffer
StringDecoder.prototype.text = utf8Text;

// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer
StringDecoder.prototype.fillLast = function (buf) {
  if (this.lastNeed <= buf.length) {
    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
    return this.lastChar.toString(this.encoding, 0, this.lastTotal);
  }
  buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
  this.lastNeed -= buf.length;
};

// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a
// continuation byte.
function utf8CheckByte(byte) {
  if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;
  return -1;
}

// Checks at most 3 bytes at the end of a Buffer in order to detect an
// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)
// needed to complete the UTF-8 character (if applicable) are returned.
function utf8CheckIncomplete(self, buf, i) {
  var j = buf.length - 1;
  if (j < i) return 0;
  var nb = utf8CheckByte(buf[j]);
  if (nb >= 0) {
    if (nb > 0) self.lastNeed = nb - 1;
    return nb;
  }
  if (--j < i) return 0;
  nb = utf8CheckByte(buf[j]);
  if (nb >= 0) {
    if (nb > 0) self.lastNeed = nb - 2;
    return nb;
  }
  if (--j < i) return 0;
  nb = utf8CheckByte(buf[j]);
  if (nb >= 0) {
    if (nb > 0) {
      if (nb === 2) nb = 0;else self.lastNeed = nb - 3;
    }
    return nb;
  }
  return 0;
}

// Validates as many continuation bytes for a multi-byte UTF-8 character as
// needed or are available. If we see a non-continuation byte where we expect
// one, we "replace" the validated continuation bytes we've seen so far with
// UTF-8 replacement characters ('\ufffd'), to match v8's UTF-8 decoding
// behavior. The continuation byte check is included three times in the case
// where all of the continuation bytes for a character exist in the same buffer.
// It is also done this way as a slight performance increase instead of using a
// loop.
function utf8CheckExtraBytes(self, buf, p) {
  if ((buf[0] & 0xC0) !== 0x80) {
    self.lastNeed = 0;
    return '\ufffd'.repeat(p);
  }
  if (self.lastNeed > 1 && buf.length > 1) {
    if ((buf[1] & 0xC0) !== 0x80) {
      self.lastNeed = 1;
      return '\ufffd'.repeat(p + 1);
    }
    if (self.lastNeed > 2 && buf.length > 2) {
      if ((buf[2] & 0xC0) !== 0x80) {
        self.lastNeed = 2;
        return '\ufffd'.repeat(p + 2);
      }
    }
  }
}

// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.
function utf8FillLast(buf) {
  var p = this.lastTotal - this.lastNeed;
  var r = utf8CheckExtraBytes(this, buf, p);
  if (r !== undefined) return r;
  if (this.lastNeed <= buf.length) {
    buf.copy(this.lastChar, p, 0, this.lastNeed);
    return this.lastChar.toString(this.encoding, 0, this.lastTotal);
  }
  buf.copy(this.lastChar, p, 0, buf.length);
  this.lastNeed -= buf.length;
}

// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a
// partial character, the character's bytes are buffered until the required
// number of bytes are available.
function utf8Text(buf, i) {
  var total = utf8CheckIncomplete(this, buf, i);
  if (!this.lastNeed) return buf.toString('utf8', i);
  this.lastTotal = total;
  var end = buf.length - (total - this.lastNeed);
  buf.copy(this.lastChar, 0, end);
  return buf.toString('utf8', i, end);
}

// For UTF-8, a replacement character for each buffered byte of a (partial)
// character needs to be added to the output.
function utf8End(buf) {
  var r = buf && buf.length ? this.write(buf) : '';
  if (this.lastNeed) return r + '\ufffd'.repeat(this.lastTotal - this.lastNeed);
  return r;
}

// UTF-16LE typically needs two bytes per character, but even if we have an even
// number of bytes available, we need to check if we end on a leading/high
// surrogate. In that case, we need to wait for the next two bytes in order to
// decode the last character properly.
function utf16Text(buf, i) {
  if ((buf.length - i) % 2 === 0) {
    var r = buf.toString('utf16le', i);
    if (r) {
      var c = r.charCodeAt(r.length - 1);
      if (c >= 0xD800 && c <= 0xDBFF) {
        this.lastNeed = 2;
        this.lastTotal = 4;
        this.lastChar[0] = buf[buf.length - 2];
        this.lastChar[1] = buf[buf.length - 1];
        return r.slice(0, -1);
      }
    }
    return r;
  }
  this.lastNeed = 1;
  this.lastTotal = 2;
  this.lastChar[0] = buf[buf.length - 1];
  return buf.toString('utf16le', i, buf.length - 1);
}

// For UTF-16LE we do not explicitly append special replacement characters if we
// end on a partial character, we simply let v8 handle that.
function utf16End(buf) {
  var r = buf && buf.length ? this.write(buf) : '';
  if (this.lastNeed) {
    var end = this.lastTotal - this.lastNeed;
    return r + this.lastChar.toString('utf16le', 0, end);
  }
  return r;
}

function base64Text(buf, i) {
  var n = (buf.length - i) % 3;
  if (n === 0) return buf.toString('base64', i);
  this.lastNeed = 3 - n;
  this.lastTotal = 3;
  if (n === 1) {
    this.lastChar[0] = buf[buf.length - 1];
  } else {
    this.lastChar[0] = buf[buf.length - 2];
    this.lastChar[1] = buf[buf.length - 1];
  }
  return buf.toString('base64', i, buf.length - n);
}

function base64End(buf) {
  var r = buf && buf.length ? this.write(buf) : '';
  if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);
  return r;
}

// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)
function simpleWrite(buf) {
  return buf.toString(this.encoding);
}

function simpleEnd(buf) {
  return buf && buf.length ? this.write(buf) : '';
}
},{"safe-buffer":34}],37:[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// 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.

'use strict';

var punycode = require('punycode');
var util = require('./util');

exports.parse = urlParse;
exports.resolve = urlResolve;
exports.resolveObject = urlResolveObject;
exports.format = urlFormat;

exports.Url = Url;

function Url() {
  this.protocol = null;
  this.slashes = null;
  this.auth = null;
  this.host = null;
  this.port = null;
  this.hostname = null;
  this.hash = null;
  this.search = null;
  this.query = null;
  this.pathname = null;
  this.path = null;
  this.href = null;
}

// Reference: RFC 3986, RFC 1808, RFC 2396

// define these here so at least they only have to be
// compiled once on the first module load.
var protocolPattern = /^([a-z0-9.+-]+:)/i,
    portPattern = /:[0-9]*$/,

    // Special case for a simple path URL
    simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/,

    // RFC 2396: characters reserved for delimiting URLs.
    // We actually just auto-escape these.
    delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t'],

    // RFC 2396: characters not allowed for various reasons.
    unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims),

    // Allowed by RFCs, but cause of XSS attacks.  Always escape these.
    autoEscape = ['\''].concat(unwise),
    // Characters that are never ever allowed in a hostname.
    // Note that any invalid chars are also handled, but these
    // are the ones that are *expected* to be seen, so we fast-path
    // them.
    nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),
    hostEndingChars = ['/', '?', '#'],
    hostnameMaxLen = 255,
    hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,
    hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,
    // protocols that can allow "unsafe" and "unwise" chars.
    unsafeProtocol = {
      'javascript': true,
      'javascript:': true
    },
    // protocols that never have a hostname.
    hostlessProtocol = {
      'javascript': true,
      'javascript:': true
    },
    // protocols that always contain a // bit.
    slashedProtocol = {
      'http': true,
      'https': true,
      'ftp': true,
      'gopher': true,
      'file': true,
      'http:': true,
      'https:': true,
      'ftp:': true,
      'gopher:': true,
      'file:': true
    },
    querystring = require('querystring');

function urlParse(url, parseQueryString, slashesDenoteHost) {
  if (url && util.isObject(url) && url instanceof Url) return url;

  var u = new Url;
  u.parse(url, parseQueryString, slashesDenoteHost);
  return u;
}

Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {
  if (!util.isString(url)) {
    throw new TypeError("Parameter 'url' must be a string, not " + typeof url);
  }

  // Copy chrome, IE, opera backslash-handling behavior.
  // Back slashes before the query string get converted to forward slashes
  // See: https://code.google.com/p/chromium/issues/detail?id=25916
  var queryIndex = url.indexOf('?'),
      splitter =
          (queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#',
      uSplit = url.split(splitter),
      slashRegex = /\\/g;
  uSplit[0] = uSplit[0].replace(slashRegex, '/');
  url = uSplit.join(splitter);

  var rest = url;

  // trim before proceeding.
  // This is to support parse stuff like "  http://foo.com  \n"
  rest = rest.trim();

  if (!slashesDenoteHost && url.split('#').length === 1) {
    // Try fast path regexp
    var simplePath = simplePathPattern.exec(rest);
    if (simplePath) {
      this.path = rest;
      this.href = rest;
      this.pathname = simplePath[1];
      if (simplePath[2]) {
        this.search = simplePath[2];
        if (parseQueryString) {
          this.query = querystring.parse(this.search.substr(1));
        } else {
          this.query = this.search.substr(1);
        }
      } else if (parseQueryString) {
        this.search = '';
        this.query = {};
      }
      return this;
    }
  }

  var proto = protocolPattern.exec(rest);
  if (proto) {
    proto = proto[0];
    var lowerProto = proto.toLowerCase();
    this.protocol = lowerProto;
    rest = rest.substr(proto.length);
  }

  // figure out if it's got a host
  // user@server is *always* interpreted as a hostname, and url
  // resolution will treat //foo/bar as host=foo,path=bar because that's
  // how the browser resolves relative URLs.
  if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
    var slashes = rest.substr(0, 2) === '//';
    if (slashes && !(proto && hostlessProtocol[proto])) {
      rest = rest.substr(2);
      this.slashes = true;
    }
  }

  if (!hostlessProtocol[proto] &&
      (slashes || (proto && !slashedProtocol[proto]))) {

    // there's a hostname.
    // the first instance of /, ?, ;, or # ends the host.
    //
    // If there is an @ in the hostname, then non-host chars *are* allowed
    // to the left of the last @ sign, unless some host-ending character
    // comes *before* the @-sign.
    // URLs are obnoxious.
    //
    // ex:
    // http://a@b@c/ => user:a@b host:c
    // http://a@b?@c => user:a host:c path:/?@c

    // v0.12 TODO(isaacs): This is not quite how Chrome does things.
    // Review our test case against browsers more comprehensively.

    // find the first instance of any hostEndingChars
    var hostEnd = -1;
    for (var i = 0; i < hostEndingChars.length; i++) {
      var hec = rest.indexOf(hostEndingChars[i]);
      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
        hostEnd = hec;
    }

    // at this point, either we have an explicit point where the
    // auth portion cannot go past, or the last @ char is the decider.
    var auth, atSign;
    if (hostEnd === -1) {
      // atSign can be anywhere.
      atSign = rest.lastIndexOf('@');
    } else {
      // atSign must be in auth portion.
      // http://a@b/c@d => host:b auth:a path:/c@d
      atSign = rest.lastIndexOf('@', hostEnd);
    }

    // Now we have a portion which is definitely the auth.
    // Pull that off.
    if (atSign !== -1) {
      auth = rest.slice(0, atSign);
      rest = rest.slice(atSign + 1);
      this.auth = decodeURIComponent(auth);
    }

    // the host is the remaining to the left of the first non-host char
    hostEnd = -1;
    for (var i = 0; i < nonHostChars.length; i++) {
      var hec = rest.indexOf(nonHostChars[i]);
      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
        hostEnd = hec;
    }
    // if we still have not hit it, then the entire thing is a host.
    if (hostEnd === -1)
      hostEnd = rest.length;

    this.host = rest.slice(0, hostEnd);
    rest = rest.slice(hostEnd);

    // pull out port.
    this.parseHost();

    // we've indicated that there is a hostname,
    // so even if it's empty, it has to be present.
    this.hostname = this.hostname || '';

    // if hostname begins with [ and ends with ]
    // assume that it's an IPv6 address.
    var ipv6Hostname = this.hostname[0] === '[' &&
        this.hostname[this.hostname.length - 1] === ']';

    // validate a little.
    if (!ipv6Hostname) {
      var hostparts = this.hostname.split(/\./);
      for (var i = 0, l = hostparts.length; i < l; i++) {
        var part = hostparts[i];
        if (!part) continue;
        if (!part.match(hostnamePartPattern)) {
          var newpart = '';
          for (var j = 0, k = part.length; j < k; j++) {
            if (part.charCodeAt(j) > 127) {
              // we replace non-ASCII char with a temporary placeholder
              // we need this to make sure size of hostname is not
              // broken by replacing non-ASCII by nothing
              newpart += 'x';
            } else {
              newpart += part[j];
            }
          }
          // we test again with ASCII char only
          if (!newpart.match(hostnamePartPattern)) {
            var validParts = hostparts.slice(0, i);
            var notHost = hostparts.slice(i + 1);
            var bit = part.match(hostnamePartStart);
            if (bit) {
              validParts.push(bit[1]);
              notHost.unshift(bit[2]);
            }
            if (notHost.length) {
              rest = '/' + notHost.join('.') + rest;
            }
            this.hostname = validParts.join('.');
            break;
          }
        }
      }
    }

    if (this.hostname.length > hostnameMaxLen) {
      this.hostname = '';
    } else {
      // hostnames are always lower case.
      this.hostname = this.hostname.toLowerCase();
    }

    if (!ipv6Hostname) {
      // IDNA Support: Returns a punycoded representation of "domain".
      // It only converts parts of the domain name that
      // have non-ASCII characters, i.e. it doesn't matter if
      // you call it with a domain that already is ASCII-only.
      this.hostname = punycode.toASCII(this.hostname);
    }

    var p = this.port ? ':' + this.port : '';
    var h = this.hostname || '';
    this.host = h + p;
    this.href += this.host;

    // strip [ and ] from the hostname
    // the host field still retains them, though
    if (ipv6Hostname) {
      this.hostname = this.hostname.substr(1, this.hostname.length - 2);
      if (rest[0] !== '/') {
        rest = '/' + rest;
      }
    }
  }

  // now rest is set to the post-host stuff.
  // chop off any delim chars.
  if (!unsafeProtocol[lowerProto]) {

    // First, make 100% sure that any "autoEscape" chars get
    // escaped, even if encodeURIComponent doesn't think they
    // need to be.
    for (var i = 0, l = autoEscape.length; i < l; i++) {
      var ae = autoEscape[i];
      if (rest.indexOf(ae) === -1)
        continue;
      var esc = encodeURIComponent(ae);
      if (esc === ae) {
        esc = escape(ae);
      }
      rest = rest.split(ae).join(esc);
    }
  }


  // chop off from the tail first.
  var hash = rest.indexOf('#');
  if (hash !== -1) {
    // got a fragment string.
    this.hash = rest.substr(hash);
    rest = rest.slice(0, hash);
  }
  var qm = rest.indexOf('?');
  if (qm !== -1) {
    this.search = rest.substr(qm);
    this.query = rest.substr(qm + 1);
    if (parseQueryString) {
      this.query = querystring.parse(this.query);
    }
    rest = rest.slice(0, qm);
  } else if (parseQueryString) {
    // no query string, but parseQueryString still requested
    this.search = '';
    this.query = {};
  }
  if (rest) this.pathname = rest;
  if (slashedProtocol[lowerProto] &&
      this.hostname && !this.pathname) {
    this.pathname = '/';
  }

  //to support http.request
  if (this.pathname || this.search) {
    var p = this.pathname || '';
    var s = this.search || '';
    this.path = p + s;
  }

  // finally, reconstruct the href based on what has been validated.
  this.href = this.format();
  return this;
};

// format a parsed object into a url string
function urlFormat(obj) {
  // ensure it's an object, and not a string url.
  // If it's an obj, this is a no-op.
  // this way, you can call url_format() on strings
  // to clean up potentially wonky urls.
  if (util.isString(obj)) obj = urlParse(obj);
  if (!(obj instanceof Url)) return Url.prototype.format.call(obj);
  return obj.format();
}

Url.prototype.format = function() {
  var auth = this.auth || '';
  if (auth) {
    auth = encodeURIComponent(auth);
    auth = auth.replace(/%3A/i, ':');
    auth += '@';
  }

  var protocol = this.protocol || '',
      pathname = this.pathname || '',
      hash = this.hash || '',
      host = false,
      query = '';

  if (this.host) {
    host = auth + this.host;
  } else if (this.hostname) {
    host = auth + (this.hostname.indexOf(':') === -1 ?
        this.hostname :
        '[' + this.hostname + ']');
    if (this.port) {
      host += ':' + this.port;
    }
  }

  if (this.query &&
      util.isObject(this.query) &&
      Object.keys(this.query).length) {
    query = querystring.stringify(this.query);
  }

  var search = this.search || (query && ('?' + query)) || '';

  if (protocol && protocol.substr(-1) !== ':') protocol += ':';

  // only the slashedProtocols get the //.  Not mailto:, xmpp:, etc.
  // unless they had them to begin with.
  if (this.slashes ||
      (!protocol || slashedProtocol[protocol]) && host !== false) {
    host = '//' + (host || '');
    if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;
  } else if (!host) {
    host = '';
  }

  if (hash && hash.charAt(0) !== '#') hash = '#' + hash;
  if (search && search.charAt(0) !== '?') search = '?' + search;

  pathname = pathname.replace(/[?#]/g, function(match) {
    return encodeURIComponent(match);
  });
  search = search.replace('#', '%23');

  return protocol + host + pathname + search + hash;
};

function urlResolve(source, relative) {
  return urlParse(source, false, true).resolve(relative);
}

Url.prototype.resolve = function(relative) {
  return this.resolveObject(urlParse(relative, false, true)).format();
};

function urlResolveObject(source, relative) {
  if (!source) return relative;
  return urlParse(source, false, true).resolveObject(relative);
}

Url.prototype.resolveObject = function(relative) {
  if (util.isString(relative)) {
    var rel = new Url();
    rel.parse(relative, false, true);
    relative = rel;
  }

  var result = new Url();
  var tkeys = Object.keys(this);
  for (var tk = 0; tk < tkeys.length; tk++) {
    var tkey = tkeys[tk];
    result[tkey] = this[tkey];
  }

  // hash is always overridden, no matter what.
  // even href="" will remove it.
  result.hash = relative.hash;

  // if the relative url is empty, then there's nothing left to do here.
  if (relative.href === '') {
    result.href = result.format();
    return result;
  }

  // hrefs like //foo/bar always cut to the protocol.
  if (relative.slashes && !relative.protocol) {
    // take everything except the protocol from relative
    var rkeys = Object.keys(relative);
    for (var rk = 0; rk < rkeys.length; rk++) {
      var rkey = rkeys[rk];
      if (rkey !== 'protocol')
        result[rkey] = relative[rkey];
    }

    //urlParse appends trailing / to urls like http://www.example.com
    if (slashedProtocol[result.protocol] &&
        result.hostname && !result.pathname) {
      result.path = result.pathname = '/';
    }

    result.href = result.format();
    return result;
  }

  if (relative.protocol && relative.protocol !== result.protocol) {
    // if it's a known url protocol, then changing
    // the protocol does weird things
    // first, if it's not file:, then we MUST have a host,
    // and if there was a path
    // to begin with, then we MUST have a path.
    // if it is file:, then the host is dropped,
    // because that's known to be hostless.
    // anything else is assumed to be absolute.
    if (!slashedProtocol[relative.protocol]) {
      var keys = Object.keys(relative);
      for (var v = 0; v < keys.length; v++) {
        var k = keys[v];
        result[k] = relative[k];
      }
      result.href = result.format();
      return result;
    }

    result.protocol = relative.protocol;
    if (!relative.host && !hostlessProtocol[relative.protocol]) {
      var relPath = (relative.pathname || '').split('/');
      while (relPath.length && !(relative.host = relPath.shift()));
      if (!relative.host) relative.host = '';
      if (!relative.hostname) relative.hostname = '';
      if (relPath[0] !== '') relPath.unshift('');
      if (relPath.length < 2) relPath.unshift('');
      result.pathname = relPath.join('/');
    } else {
      result.pathname = relative.pathname;
    }
    result.search = relative.search;
    result.query = relative.query;
    result.host = relative.host || '';
    result.auth = relative.auth;
    result.hostname = relative.hostname || relative.host;
    result.port = relative.port;
    // to support http.request
    if (result.pathname || result.search) {
      var p = result.pathname || '';
      var s = result.search || '';
      result.path = p + s;
    }
    result.slashes = result.slashes || relative.slashes;
    result.href = result.format();
    return result;
  }

  var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),
      isRelAbs = (
          relative.host ||
          relative.pathname && relative.pathname.charAt(0) === '/'
      ),
      mustEndAbs = (isRelAbs || isSourceAbs ||
                    (result.host && relative.pathname)),
      removeAllDots = mustEndAbs,
      srcPath = result.pathname && result.pathname.split('/') || [],
      relPath = relative.pathname && relative.pathname.split('/') || [],
      psychotic = result.protocol && !slashedProtocol[result.protocol];

  // if the url is a non-slashed url, then relative
  // links like ../.. should be able
  // to crawl up to the hostname, as well.  This is strange.
  // result.protocol has already been set by now.
  // Later on, put the first path part into the host field.
  if (psychotic) {
    result.hostname = '';
    result.port = null;
    if (result.host) {
      if (srcPath[0] === '') srcPath[0] = result.host;
      else srcPath.unshift(result.host);
    }
    result.host = '';
    if (relative.protocol) {
      relative.hostname = null;
      relative.port = null;
      if (relative.host) {
        if (relPath[0] === '') relPath[0] = relative.host;
        else relPath.unshift(relative.host);
      }
      relative.host = null;
    }
    mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');
  }

  if (isRelAbs) {
    // it's absolute.
    result.host = (relative.host || relative.host === '') ?
                  relative.host : result.host;
    result.hostname = (relative.hostname || relative.hostname === '') ?
                      relative.hostname : result.hostname;
    result.search = relative.search;
    result.query = relative.query;
    srcPath = relPath;
    // fall through to the dot-handling below.
  } else if (relPath.length) {
    // it's relative
    // throw away the existing file, and take the new path instead.
    if (!srcPath) srcPath = [];
    srcPath.pop();
    srcPath = srcPath.concat(relPath);
    result.search = relative.search;
    result.query = relative.query;
  } else if (!util.isNullOrUndefined(relative.search)) {
    // just pull out the search.
    // like href='?foo'.
    // Put this after the other two cases because it simplifies the booleans
    if (psychotic) {
      result.hostname = result.host = srcPath.shift();
      //occationaly the auth can get stuck only in host
      //this especially happens in cases like
      //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
      var authInHost = result.host && result.host.indexOf('@') > 0 ?
                       result.host.split('@') : false;
      if (authInHost) {
        result.auth = authInHost.shift();
        result.host = result.hostname = authInHost.shift();
      }
    }
    result.search = relative.search;
    result.query = relative.query;
    //to support http.request
    if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
      result.path = (result.pathname ? result.pathname : '') +
                    (result.search ? result.search : '');
    }
    result.href = result.format();
    return result;
  }

  if (!srcPath.length) {
    // no path at all.  easy.
    // we've already handled the other stuff above.
    result.pathname = null;
    //to support http.request
    if (result.search) {
      result.path = '/' + result.search;
    } else {
      result.path = null;
    }
    result.href = result.format();
    return result;
  }

  // if a url ENDs in . or .., then it must get a trailing slash.
  // however, if it ends in anything else non-slashy,
  // then it must NOT get a trailing slash.
  var last = srcPath.slice(-1)[0];
  var hasTrailingSlash = (
      (result.host || relative.host || srcPath.length > 1) &&
      (last === '.' || last === '..') || last === '');

  // strip single dots, resolve double dots to parent dir
  // if the path tries to go above the root, `up` ends up > 0
  var up = 0;
  for (var i = srcPath.length; i >= 0; i--) {
    last = srcPath[i];
    if (last === '.') {
      srcPath.splice(i, 1);
    } else if (last === '..') {
      srcPath.splice(i, 1);
      up++;
    } else if (up) {
      srcPath.splice(i, 1);
      up--;
    }
  }

  // if the path is allowed to go above the root, restore leading ..s
  if (!mustEndAbs && !removeAllDots) {
    for (; up--; up) {
      srcPath.unshift('..');
    }
  }

  if (mustEndAbs && srcPath[0] !== '' &&
      (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {
    srcPath.unshift('');
  }

  if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {
    srcPath.push('');
  }

  var isAbsolute = srcPath[0] === '' ||
      (srcPath[0] && srcPath[0].charAt(0) === '/');

  // put the host back
  if (psychotic) {
    result.hostname = result.host = isAbsolute ? '' :
                                    srcPath.length ? srcPath.shift() : '';
    //occationaly the auth can get stuck only in host
    //this especially happens in cases like
    //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
    var authInHost = result.host && result.host.indexOf('@') > 0 ?
                     result.host.split('@') : false;
    if (authInHost) {
      result.auth = authInHost.shift();
      result.host = result.hostname = authInHost.shift();
    }
  }

  mustEndAbs = mustEndAbs || (result.host && srcPath.length);

  if (mustEndAbs && !isAbsolute) {
    srcPath.unshift('');
  }

  if (!srcPath.length) {
    result.pathname = null;
    result.path = null;
  } else {
    result.pathname = srcPath.join('/');
  }

  //to support request.http
  if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
    result.path = (result.pathname ? result.pathname : '') +
                  (result.search ? result.search : '');
  }
  result.auth = relative.auth || result.auth;
  result.slashes = result.slashes || relative.slashes;
  result.href = result.format();
  return result;
};

Url.prototype.parseHost = function() {
  var host = this.host;
  var port = portPattern.exec(host);
  if (port) {
    port = port[0];
    if (port !== ':') {
      this.port = port.substr(1);
    }
    host = host.substr(0, host.length - port.length);
  }
  if (host) this.hostname = host;
};

},{"./util":38,"punycode":17,"querystring":20}],38:[function(require,module,exports){
'use strict';

module.exports = {
  isString: function(arg) {
    return typeof(arg) === 'string';
  },
  isObject: function(arg) {
    return typeof(arg) === 'object' && arg !== null;
  },
  isNull: function(arg) {
    return arg === null;
  },
  isNullOrUndefined: function(arg) {
    return arg == null;
  }
};

},{}],39:[function(require,module,exports){
(function (global){

/**
 * Module exports.
 */

module.exports = deprecate;

/**
 * Mark that a method should not be used.
 * Returns a modified function which warns once by default.
 *
 * If `localStorage.noDeprecation = true` is set, then it is a no-op.
 *
 * If `localStorage.throwDeprecation = true` is set, then deprecated functions
 * will throw an Error when invoked.
 *
 * If `localStorage.traceDeprecation = true` is set, then deprecated functions
 * will invoke `console.trace()` instead of `console.error()`.
 *
 * @param {Function} fn - the function to deprecate
 * @param {String} msg - the string to print to the console when `fn` is invoked
 * @returns {Function} a new "deprecated" version of `fn`
 * @api public
 */

function deprecate (fn, msg) {
  if (config('noDeprecation')) {
    return fn;
  }

  var warned = false;
  function deprecated() {
    if (!warned) {
      if (config('throwDeprecation')) {
        throw new Error(msg);
      } else if (config('traceDeprecation')) {
        console.trace(msg);
      } else {
        console.warn(msg);
      }
      warned = true;
    }
    return fn.apply(this, arguments);
  }

  return deprecated;
}

/**
 * Checks `localStorage` for boolean values for the given `name`.
 *
 * @param {String} name
 * @returns {Boolean}
 * @api private
 */

function config (name) {
  // accessing global.localStorage can trigger a DOMException in sandboxed iframes
  try {
    if (!global.localStorage) return false;
  } catch (_) {
    return false;
  }
  var val = global.localStorage[name];
  if (null == val) return false;
  return String(val).toLowerCase() === 'true';
}

}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{}],40:[function(require,module,exports){
arguments[4][10][0].apply(exports,arguments)
},{"dup":10}],41:[function(require,module,exports){
module.exports = function isBuffer(arg) {
  return arg && typeof arg === 'object'
    && typeof arg.copy === 'function'
    && typeof arg.fill === 'function'
    && typeof arg.readUInt8 === 'function';
}
},{}],42:[function(require,module,exports){
(function (process,global){
// Copyright Joyent, Inc. and other Node contributors.
//
// 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.

var formatRegExp = /%[sdj%]/g;
exports.format = function(f) {
  if (!isString(f)) {
    var objects = [];
    for (var i = 0; i < arguments.length; i++) {
      objects.push(inspect(arguments[i]));
    }
    return objects.join(' ');
  }

  var i = 1;
  var args = arguments;
  var len = args.length;
  var str = String(f).replace(formatRegExp, function(x) {
    if (x === '%%') return '%';
    if (i >= len) return x;
    switch (x) {
      case '%s': return String(args[i++]);
      case '%d': return Number(args[i++]);
      case '%j':
        try {
          return JSON.stringify(args[i++]);
        } catch (_) {
          return '[Circular]';
        }
      default:
        return x;
    }
  });
  for (var x = args[i]; i < len; x = args[++i]) {
    if (isNull(x) || !isObject(x)) {
      str += ' ' + x;
    } else {
      str += ' ' + inspect(x);
    }
  }
  return str;
};


// Mark that a method should not be used.
// Returns a modified function which warns once by default.
// If --no-deprecation is set, then it is a no-op.
exports.deprecate = function(fn, msg) {
  // Allow for deprecating things in the process of starting up.
  if (isUndefined(global.process)) {
    return function() {
      return exports.deprecate(fn, msg).apply(this, arguments);
    };
  }

  if (process.noDeprecation === true) {
    return fn;
  }

  var warned = false;
  function deprecated() {
    if (!warned) {
      if (process.throwDeprecation) {
        throw new Error(msg);
      } else if (process.traceDeprecation) {
        console.trace(msg);
      } else {
        console.error(msg);
      }
      warned = true;
    }
    return fn.apply(this, arguments);
  }

  return deprecated;
};


var debugs = {};
var debugEnviron;
exports.debuglog = function(set) {
  if (isUndefined(debugEnviron))
    debugEnviron = process.env.NODE_DEBUG || '';
  set = set.toUpperCase();
  if (!debugs[set]) {
    if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
      var pid = process.pid;
      debugs[set] = function() {
        var msg = exports.format.apply(exports, arguments);
        console.error('%s %d: %s', set, pid, msg);
      };
    } else {
      debugs[set] = function() {};
    }
  }
  return debugs[set];
};


/**
 * Echos the value of a value. Trys to print the value out
 * in the best way possible given the different types.
 *
 * @param {Object} obj The object to print out.
 * @param {Object} opts Optional options object that alters the output.
 */
/* legacy: obj, showHidden, depth, colors*/
function inspect(obj, opts) {
  // default options
  var ctx = {
    seen: [],
    stylize: stylizeNoColor
  };
  // legacy...
  if (arguments.length >= 3) ctx.depth = arguments[2];
  if (arguments.length >= 4) ctx.colors = arguments[3];
  if (isBoolean(opts)) {
    // legacy...
    ctx.showHidden = opts;
  } else if (opts) {
    // got an "options" object
    exports._extend(ctx, opts);
  }
  // set default options
  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
  if (isUndefined(ctx.depth)) ctx.depth = 2;
  if (isUndefined(ctx.colors)) ctx.colors = false;
  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
  if (ctx.colors) ctx.stylize = stylizeWithColor;
  return formatValue(ctx, obj, ctx.depth);
}
exports.inspect = inspect;


// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
inspect.colors = {
  'bold' : [1, 22],
  'italic' : [3, 23],
  'underline' : [4, 24],
  'inverse' : [7, 27],
  'white' : [37, 39],
  'grey' : [90, 39],
  'black' : [30, 39],
  'blue' : [34, 39],
  'cyan' : [36, 39],
  'green' : [32, 39],
  'magenta' : [35, 39],
  'red' : [31, 39],
  'yellow' : [33, 39]
};

// Don't use 'blue' not visible on cmd.exe
inspect.styles = {
  'special': 'cyan',
  'number': 'yellow',
  'boolean': 'yellow',
  'undefined': 'grey',
  'null': 'bold',
  'string': 'green',
  'date': 'magenta',
  // "name": intentionally not styling
  'regexp': 'red'
};


function stylizeWithColor(str, styleType) {
  var style = inspect.styles[styleType];

  if (style) {
    return '\u001b[' + inspect.colors[style][0] + 'm' + str +
           '\u001b[' + inspect.colors[style][1] + 'm';
  } else {
    return str;
  }
}


function stylizeNoColor(str, styleType) {
  return str;
}


function arrayToHash(array) {
  var hash = {};

  array.forEach(function(val, idx) {
    hash[val] = true;
  });

  return hash;
}


function formatValue(ctx, value, recurseTimes) {
  // Provide a hook for user-specified inspect functions.
  // Check that value is an object with an inspect function on it
  if (ctx.customInspect &&
      value &&
      isFunction(value.inspect) &&
      // Filter out the util module, it's inspect function is special
      value.inspect !== exports.inspect &&
      // Also filter out any prototype objects using the circular check.
      !(value.constructor && value.constructor.prototype === value)) {
    var ret = value.inspect(recurseTimes, ctx);
    if (!isString(ret)) {
      ret = formatValue(ctx, ret, recurseTimes);
    }
    return ret;
  }

  // Primitive types cannot have properties
  var primitive = formatPrimitive(ctx, value);
  if (primitive) {
    return primitive;
  }

  // Look up the keys of the object.
  var keys = Object.keys(value);
  var visibleKeys = arrayToHash(keys);

  if (ctx.showHidden) {
    keys = Object.getOwnPropertyNames(value);
  }

  // IE doesn't make error fields non-enumerable
  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
  if (isError(value)
      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
    return formatError(value);
  }

  // Some type of object without properties can be shortcutted.
  if (keys.length === 0) {
    if (isFunction(value)) {
      var name = value.name ? ': ' + value.name : '';
      return ctx.stylize('[Function' + name + ']', 'special');
    }
    if (isRegExp(value)) {
      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
    }
    if (isDate(value)) {
      return ctx.stylize(Date.prototype.toString.call(value), 'date');
    }
    if (isError(value)) {
      return formatError(value);
    }
  }

  var base = '', array = false, braces = ['{', '}'];

  // Make Array say that they are Array
  if (isArray(value)) {
    array = true;
    braces = ['[', ']'];
  }

  // Make functions say that they are functions
  if (isFunction(value)) {
    var n = value.name ? ': ' + value.name : '';
    base = ' [Function' + n + ']';
  }

  // Make RegExps say that they are RegExps
  if (isRegExp(value)) {
    base = ' ' + RegExp.prototype.toString.call(value);
  }

  // Make dates with properties first say the date
  if (isDate(value)) {
    base = ' ' + Date.prototype.toUTCString.call(value);
  }

  // Make error with message first say the error
  if (isError(value)) {
    base = ' ' + formatError(value);
  }

  if (keys.length === 0 && (!array || value.length == 0)) {
    return braces[0] + base + braces[1];
  }

  if (recurseTimes < 0) {
    if (isRegExp(value)) {
      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
    } else {
      return ctx.stylize('[Object]', 'special');
    }
  }

  ctx.seen.push(value);

  var output;
  if (array) {
    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
  } else {
    output = keys.map(function(key) {
      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
    });
  }

  ctx.seen.pop();

  return reduceToSingleString(output, base, braces);
}


function formatPrimitive(ctx, value) {
  if (isUndefined(value))
    return ctx.stylize('undefined', 'undefined');
  if (isString(value)) {
    var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
                                             .replace(/'/g, "\\'")
                                             .replace(/\\"/g, '"') + '\'';
    return ctx.stylize(simple, 'string');
  }
  if (isNumber(value))
    return ctx.stylize('' + value, 'number');
  if (isBoolean(value))
    return ctx.stylize('' + value, 'boolean');
  // For some reason typeof null is "object", so special case here.
  if (isNull(value))
    return ctx.stylize('null', 'null');
}


function formatError(value) {
  return '[' + Error.prototype.toString.call(value) + ']';
}


function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
  var output = [];
  for (var i = 0, l = value.length; i < l; ++i) {
    if (hasOwnProperty(value, String(i))) {
      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
          String(i), true));
    } else {
      output.push('');
    }
  }
  keys.forEach(function(key) {
    if (!key.match(/^\d+$/)) {
      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
          key, true));
    }
  });
  return output;
}


function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
  var name, str, desc;
  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
  if (desc.get) {
    if (desc.set) {
      str = ctx.stylize('[Getter/Setter]', 'special');
    } else {
      str = ctx.stylize('[Getter]', 'special');
    }
  } else {
    if (desc.set) {
      str = ctx.stylize('[Setter]', 'special');
    }
  }
  if (!hasOwnProperty(visibleKeys, key)) {
    name = '[' + key + ']';
  }
  if (!str) {
    if (ctx.seen.indexOf(desc.value) < 0) {
      if (isNull(recurseTimes)) {
        str = formatValue(ctx, desc.value, null);
      } else {
        str = formatValue(ctx, desc.value, recurseTimes - 1);
      }
      if (str.indexOf('\n') > -1) {
        if (array) {
          str = str.split('\n').map(function(line) {
            return '  ' + line;
          }).join('\n').substr(2);
        } else {
          str = '\n' + str.split('\n').map(function(line) {
            return '   ' + line;
          }).join('\n');
        }
      }
    } else {
      str = ctx.stylize('[Circular]', 'special');
    }
  }
  if (isUndefined(name)) {
    if (array && key.match(/^\d+$/)) {
      return str;
    }
    name = JSON.stringify('' + key);
    if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
      name = name.substr(1, name.length - 2);
      name = ctx.stylize(name, 'name');
    } else {
      name = name.replace(/'/g, "\\'")
                 .replace(/\\"/g, '"')
                 .replace(/(^"|"$)/g, "'");
      name = ctx.stylize(name, 'string');
    }
  }

  return name + ': ' + str;
}


function reduceToSingleString(output, base, braces) {
  var numLinesEst = 0;
  var length = output.reduce(function(prev, cur) {
    numLinesEst++;
    if (cur.indexOf('\n') >= 0) numLinesEst++;
    return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
  }, 0);

  if (length > 60) {
    return braces[0] +
           (base === '' ? '' : base + '\n ') +
           ' ' +
           output.join(',\n  ') +
           ' ' +
           braces[1];
  }

  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
}


// NOTE: These type checking functions intentionally don't use `instanceof`
// because it is fragile and can be easily faked with `Object.create()`.
function isArray(ar) {
  return Array.isArray(ar);
}
exports.isArray = isArray;

function isBoolean(arg) {
  return typeof arg === 'boolean';
}
exports.isBoolean = isBoolean;

function isNull(arg) {
  return arg === null;
}
exports.isNull = isNull;

function isNullOrUndefined(arg) {
  return arg == null;
}
exports.isNullOrUndefined = isNullOrUndefined;

function isNumber(arg) {
  return typeof arg === 'number';
}
exports.isNumber = isNumber;

function isString(arg) {
  return typeof arg === 'string';
}
exports.isString = isString;

function isSymbol(arg) {
  return typeof arg === 'symbol';
}
exports.isSymbol = isSymbol;

function isUndefined(arg) {
  return arg === void 0;
}
exports.isUndefined = isUndefined;

function isRegExp(re) {
  return isObject(re) && objectToString(re) === '[object RegExp]';
}
exports.isRegExp = isRegExp;

function isObject(arg) {
  return typeof arg === 'object' && arg !== null;
}
exports.isObject = isObject;

function isDate(d) {
  return isObject(d) && objectToString(d) === '[object Date]';
}
exports.isDate = isDate;

function isError(e) {
  return isObject(e) &&
      (objectToString(e) === '[object Error]' || e instanceof Error);
}
exports.isError = isError;

function isFunction(arg) {
  return typeof arg === 'function';
}
exports.isFunction = isFunction;

function isPrimitive(arg) {
  return arg === null ||
         typeof arg === 'boolean' ||
         typeof arg === 'number' ||
         typeof arg === 'string' ||
         typeof arg === 'symbol' ||  // ES6 symbol
         typeof arg === 'undefined';
}
exports.isPrimitive = isPrimitive;

exports.isBuffer = require('./support/isBuffer');

function objectToString(o) {
  return Object.prototype.toString.call(o);
}


function pad(n) {
  return n < 10 ? '0' + n.toString(10) : n.toString(10);
}


var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
              'Oct', 'Nov', 'Dec'];

// 26 Feb 16:19:34
function timestamp() {
  var d = new Date();
  var time = [pad(d.getHours()),
              pad(d.getMinutes()),
              pad(d.getSeconds())].join(':');
  return [d.getDate(), months[d.getMonth()], time].join(' ');
}


// log is just a thin wrapper to console.log that prepends a timestamp
exports.log = function() {
  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
};


/**
 * Inherit the prototype methods from one constructor into another.
 *
 * The Function.prototype.inherits from lang.js rewritten as a standalone
 * function (not on Function.prototype). NOTE: If this file is to be loaded
 * during bootstrapping this function needs to be rewritten using some native
 * functions as prototype setup using normal JavaScript does not work as
 * expected during bootstrapping (see mirror.js in r114903).
 *
 * @param {function} ctor Constructor function which needs to inherit the
 *     prototype.
 * @param {function} superCtor Constructor function to inherit prototype from.
 */
exports.inherits = require('inherits');

exports._extend = function(origin, add) {
  // Don't do anything if add isn't an object
  if (!add || !isObject(add)) return origin;

  var keys = Object.keys(add);
  var i = keys.length;
  while (i--) {
    origin[keys[i]] = add[keys[i]];
  }
  return origin;
};

function hasOwnProperty(obj, prop) {
  return Object.prototype.hasOwnProperty.call(obj, prop);
}

}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{"./support/isBuffer":41,"_process":16,"inherits":40}],43:[function(require,module,exports){
'use strict';

/*eslint complexity: 0*/

module.exports = function equal(a, b) {
  if (a === b) return true;

  var arrA = Array.isArray(a)
    , arrB = Array.isArray(b)
    , i;

  if (arrA && arrB) {
    if (a.length != b.length) return false;
    for (i = 0; i < a.length; i++)
      if (!equal(a[i], b[i])) return false;
    return true;
  }

  if (arrA != arrB) return false;

  if (a && b && typeof a === 'object' && typeof b === 'object') {
    var keys = Object.keys(a);
    if (keys.length !== Object.keys(b).length) return false;

    var dateA = a instanceof Date
      , dateB = b instanceof Date;
    if (dateA && dateB) return a.getTime() == b.getTime();
    if (dateA != dateB) return false;

    var regexpA = a instanceof RegExp
      , regexpB = b instanceof RegExp;
    if (regexpA && regexpB) return a.toString() == b.toString();
    if (regexpA != regexpB) return false;

    for (i = 0; i < keys.length; i++)
      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;

    for (i = 0; i < keys.length; i++)
      if(!equal(a[keys[i]], b[keys[i]])) return false;

    return true;
  }

  return false;
};

},{}],44:[function(require,module,exports){
'use strict';
module.exports = function () {
	return /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-PRZcf-nqry=><]/g;
};

},{}],45:[function(require,module,exports){
'use strict';
const colorConvert = require('color-convert');

const wrapAnsi16 = (fn, offset) => function () {
	const code = fn.apply(colorConvert, arguments);
	return `\u001B[${code + offset}m`;
};

const wrapAnsi256 = (fn, offset) => function () {
	const code = fn.apply(colorConvert, arguments);
	return `\u001B[${38 + offset};5;${code}m`;
};

const wrapAnsi16m = (fn, offset) => function () {
	const rgb = fn.apply(colorConvert, arguments);
	return `\u001B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
};

function assembleStyles() {
	const codes = new Map();
	const styles = {
		modifier: {
			reset: [0, 0],
			// 21 isn't widely supported and 22 does the same thing
			bold: [1, 22],
			dim: [2, 22],
			italic: [3, 23],
			underline: [4, 24],
			inverse: [7, 27],
			hidden: [8, 28],
			strikethrough: [9, 29]
		},
		color: {
			black: [30, 39],
			red: [31, 39],
			green: [32, 39],
			yellow: [33, 39],
			blue: [34, 39],
			magenta: [35, 39],
			cyan: [36, 39],
			white: [37, 39],
			gray: [90, 39],

			// Bright color
			redBright: [91, 39],
			greenBright: [92, 39],
			yellowBright: [93, 39],
			blueBright: [94, 39],
			magentaBright: [95, 39],
			cyanBright: [96, 39],
			whiteBright: [97, 39]
		},
		bgColor: {
			bgBlack: [40, 49],
			bgRed: [41, 49],
			bgGreen: [42, 49],
			bgYellow: [43, 49],
			bgBlue: [44, 49],
			bgMagenta: [45, 49],
			bgCyan: [46, 49],
			bgWhite: [47, 49],

			// Bright color
			bgBlackBright: [100, 49],
			bgRedBright: [101, 49],
			bgGreenBright: [102, 49],
			bgYellowBright: [103, 49],
			bgBlueBright: [104, 49],
			bgMagentaBright: [105, 49],
			bgCyanBright: [106, 49],
			bgWhiteBright: [107, 49]
		}
	};

	// Fix humans
	styles.color.grey = styles.color.gray;

	for (const groupName of Object.keys(styles)) {
		const group = styles[groupName];

		for (const styleName of Object.keys(group)) {
			const style = group[styleName];

			styles[styleName] = {
				open: `\u001B[${style[0]}m`,
				close: `\u001B[${style[1]}m`
			};

			group[styleName] = styles[styleName];

			codes.set(style[0], style[1]);
		}

		Object.defineProperty(styles, groupName, {
			value: group,
			enumerable: false
		});

		Object.defineProperty(styles, 'codes', {
			value: codes,
			enumerable: false
		});
	}

	const rgb2rgb = (r, g, b) => [r, g, b];

	styles.color.close = '\u001B[39m';
	styles.bgColor.close = '\u001B[49m';

	styles.color.ansi = {};
	styles.color.ansi256 = {};
	styles.color.ansi16m = {
		rgb: wrapAnsi16m(rgb2rgb, 0)
	};

	styles.bgColor.ansi = {};
	styles.bgColor.ansi256 = {};
	styles.bgColor.ansi16m = {
		rgb: wrapAnsi16m(rgb2rgb, 10)
	};

	for (const key of Object.keys(colorConvert)) {
		if (typeof colorConvert[key] !== 'object') {
			continue;
		}

		const suite = colorConvert[key];

		if ('ansi16' in suite) {
			styles.color.ansi[key] = wrapAnsi16(suite.ansi16, 0);
			styles.bgColor.ansi[key] = wrapAnsi16(suite.ansi16, 10);
		}

		if ('ansi256' in suite) {
			styles.color.ansi256[key] = wrapAnsi256(suite.ansi256, 0);
			styles.bgColor.ansi256[key] = wrapAnsi256(suite.ansi256, 10);
		}

		if ('rgb' in suite) {
			styles.color.ansi16m[key] = wrapAnsi16m(suite.rgb, 0);
			styles.bgColor.ansi16m[key] = wrapAnsi16m(suite.rgb, 10);
		}
	}

	return styles;
}

// Make the export immutable
Object.defineProperty(module, 'exports', {
	enumerable: true,
	get: assembleStyles
});

},{"color-convert":585}],46:[function(require,module,exports){
/*!
 * arr-diff <https://github.com/jonschlinkert/arr-diff>
 *
 * Copyright (c) 2014 Jon Schlinkert, contributors.
 * Licensed under the MIT License
 */

'use strict';

var flatten = require('arr-flatten');
var slice = [].slice;

/**
 * Return the difference between the first array and
 * additional arrays.
 *
 * ```js
 * var diff = require('{%= name %}');
 *
 * var a = ['a', 'b', 'c', 'd'];
 * var b = ['b', 'c'];
 *
 * console.log(diff(a, b))
 * //=> ['a', 'd']
 * ```
 *
 * @param  {Array} `a`
 * @param  {Array} `b`
 * @return {Array}
 * @api public
 */

function diff(arr, arrays) {
  var argsLen = arguments.length;
  var len = arr.length, i = -1;
  var res = [], arrays;

  if (argsLen === 1) {
    return arr;
  }

  if (argsLen > 2) {
    arrays = flatten(slice.call(arguments, 1));
  }

  while (++i < len) {
    if (!~arrays.indexOf(arr[i])) {
      res.push(arr[i]);
    }
  }
  return res;
}

/**
 * Expose `diff`
 */

module.exports = diff;

},{"arr-flatten":47}],47:[function(require,module,exports){
/*!
 * arr-flatten <https://github.com/jonschlinkert/arr-flatten>
 *
 * Copyright (c) 2014-2017, Jon Schlinkert.
 * Released under the MIT License.
 */

'use strict';

module.exports = function (arr) {
  return flat(arr, []);
};

function flat(arr, res) {
  var i = 0, cur;
  var len = arr.length;
  for (; i < len; i++) {
    cur = arr[i];
    Array.isArray(cur) ? flat(cur, res) : res.push(cur);
  }
  return res;
}

},{}],48:[function(require,module,exports){
'use strict';
var arrayUniq = require('array-uniq');

module.exports = function () {
	return arrayUniq([].concat.apply([], arguments));
};

},{"array-uniq":49}],49:[function(require,module,exports){
(function (global){
'use strict';

// there's 3 implementations written in increasing order of efficiency

// 1 - no Set type is defined
function uniqNoSet(arr) {
	var ret = [];

	for (var i = 0; i < arr.length; i++) {
		if (ret.indexOf(arr[i]) === -1) {
			ret.push(arr[i]);
		}
	}

	return ret;
}

// 2 - a simple Set type is defined
function uniqSet(arr) {
	var seen = new Set();
	return arr.filter(function (el) {
		if (!seen.has(el)) {
			seen.add(el);
			return true;
		}

		return false;
	});
}

// 3 - a standard Set type is defined and it has a forEach method
function uniqSetWithForEach(arr) {
	var ret = [];

	(new Set(arr)).forEach(function (el) {
		ret.push(el);
	});

	return ret;
}

// V8 currently has a broken implementation
// https://github.com/joyent/node/issues/8449
function doesForEachActuallyWork() {
	var ret = false;

	(new Set([true])).forEach(function (el) {
		ret = el;
	});

	return ret === true;
}

if ('Set' in global) {
	if (typeof Set.prototype.forEach === 'function' && doesForEachActuallyWork()) {
		module.exports = uniqSetWithForEach;
	} else {
		module.exports = uniqSet;
	}
} else {
	module.exports = uniqNoSet;
}

}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{}],50:[function(require,module,exports){
/*!
 * array-unique <https://github.com/jonschlinkert/array-unique>
 *
 * Copyright (c) 2014-2015, Jon Schlinkert.
 * Licensed under the MIT License.
 */

'use strict';

module.exports = function unique(arr) {
  if (!Array.isArray(arr)) {
    throw new TypeError('array-unique expects an array.');
  }

  var len = arr.length;
  var i = -1;

  while (i++ < len) {
    var j = i + 1;

    for (; j < arr.length; ++j) {
      if (arr[i] === arr[j]) {
        arr.splice(j--, 1);
      }
    }
  }
  return arr;
};

},{}],51:[function(require,module,exports){
'use strict';
module.exports = function (val) {
	if (val === null || val === undefined) {
		return [];
	}

	return Array.isArray(val) ? val : [val];
};

},{}],52:[function(require,module,exports){
'use strict';

var unpack = require('caniuse-lite').feature;

var browsersSort = function browsersSort(a, b) {
    a = a.split(' ');
    b = b.split(' ');
    if (a[0] > b[0]) {
        return 1;
    } else if (a[0] < b[0]) {
        return -1;
    } else {
        return Math.sign(parseFloat(a[1]) - parseFloat(b[1]));
    }
};

// Convert Can I Use data
function f(data, opts, callback) {
    data = unpack(data);

    if (!callback) {
        var _ref = [opts, {}];
        callback = _ref[0];
        opts = _ref[1];
    }

    var match = opts.match || /\sx($|\s)/;
    var need = [];

    for (var browser in data.stats) {
        var versions = data.stats[browser];
        for (var version in versions) {
            var support = versions[version];
            if (support.match(match)) {
                need.push(browser + ' ' + version);
            }
        }
    }

    callback(need.sort(browsersSort));
}

// Add data for all properties
var result = {};

var prefix = function prefix(names, data) {
    for (var _iterator = names, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
        var _ref2;

        if (_isArray) {
            if (_i >= _iterator.length) break;
            _ref2 = _iterator[_i++];
        } else {
            _i = _iterator.next();
            if (_i.done) break;
            _ref2 = _i.value;
        }

        var name = _ref2;

        result[name] = Object.assign({}, data);
    }
};

var add = function add(names, data) {
    for (var _iterator2 = names, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
        var _ref3;

        if (_isArray2) {
            if (_i2 >= _iterator2.length) break;
            _ref3 = _iterator2[_i2++];
        } else {
            _i2 = _iterator2.next();
            if (_i2.done) break;
            _ref3 = _i2.value;
        }

        var name = _ref3;

        result[name].browsers = result[name].browsers.concat(data.browsers).sort(browsersSort);
    }
};

module.exports = result;

// Border Radius
f(require('caniuse-lite/data/features/border-radius.js'), function (browsers) {
    return prefix(['border-radius', 'border-top-left-radius', 'border-top-right-radius', 'border-bottom-right-radius', 'border-bottom-left-radius'], {
        mistakes: ['-khtml-', '-ms-', '-o-'],
        feature: 'border-radius',
        browsers: browsers
    });
});

// Box Shadow
f(require('caniuse-lite/data/features/css-boxshadow.js'), function (browsers) {
    return prefix(['box-shadow'], {
        mistakes: ['-khtml-'],
        feature: 'css-boxshadow',
        browsers: browsers
    });
});

// Animation
f(require('caniuse-lite/data/features/css-animation.js'), function (browsers) {
    return prefix(['animation', 'animation-name', 'animation-duration', 'animation-delay', 'animation-direction', 'animation-fill-mode', 'animation-iteration-count', 'animation-play-state', 'animation-timing-function', '@keyframes'], {
        mistakes: ['-khtml-', '-ms-'],
        feature: 'css-animation',
        browsers: browsers
    });
});

// Transition
f(require('caniuse-lite/data/features/css-transitions.js'), function (browsers) {
    return prefix(['transition', 'transition-property', 'transition-duration', 'transition-delay', 'transition-timing-function'], {
        mistakes: ['-khtml-', '-ms-'],
        browsers: browsers,
        feature: 'css-transitions'
    });
});

// Transform 2D
f(require('caniuse-lite/data/features/transforms2d.js'), function (browsers) {
    return prefix(['transform', 'transform-origin'], {
        feature: 'transforms2d',
        browsers: browsers
    });
});

// Transform 3D
var transforms3d = require('caniuse-lite/data/features/transforms3d.js');

f(transforms3d, function (browsers) {
    prefix(['perspective', 'perspective-origin'], {
        feature: 'transforms3d',
        browsers: browsers
    });
    return prefix(['transform-style'], {
        mistakes: ['-ms-', '-o-'],
        browsers: browsers,
        feature: 'transforms3d'
    });
});

f(transforms3d, { match: /y\sx|y\s#2/ }, function (browsers) {
    return prefix(['backface-visibility'], {
        mistakes: ['-ms-', '-o-'],
        feature: 'transforms3d',
        browsers: browsers
    });
});

// Gradients
var gradients = require('caniuse-lite/data/features/css-gradients.js');

f(gradients, { match: /y\sx/ }, function (browsers) {
    return prefix(['linear-gradient', 'repeating-linear-gradient', 'radial-gradient', 'repeating-radial-gradient'], {
        props: ['background', 'background-image', 'border-image', 'mask', 'list-style', 'list-style-image', 'content', 'mask-image'],
        mistakes: ['-ms-'],
        feature: 'css-gradients',
        browsers: browsers
    });
});

f(gradients, { match: /a\sx/ }, function (browsers) {
    browsers = browsers.map(function (i) {
        if (/op/.test(i)) {
            return i;
        } else {
            return i + ' old';
        }
    });
    return add(['linear-gradient', 'repeating-linear-gradient', 'radial-gradient', 'repeating-radial-gradient'], {
        feature: 'css-gradients',
        browsers: browsers
    });
});

// Box sizing
f(require('caniuse-lite/data/features/css3-boxsizing.js'), function (browsers) {
    return prefix(['box-sizing'], {
        feature: 'css3-boxsizing',
        browsers: browsers
    });
});

// Filter Effects
f(require('caniuse-lite/data/features/css-filters.js'), function (browsers) {
    return prefix(['filter'], {
        feature: 'css-filters',
        browsers: browsers
    });
});

// filter() function
f(require('caniuse-lite/data/features/css-filter-function.js'), function (browsers) {
    return prefix(['filter-function'], {
        props: ['background', 'background-image', 'border-image', 'mask', 'list-style', 'list-style-image', 'content', 'mask-image'],
        feature: 'css-filter-function',
        browsers: browsers
    });
});

// Backdrop-filter
f(require('caniuse-lite/data/features/css-backdrop-filter.js'), function (browsers) {
    return prefix(['backdrop-filter'], {
        feature: 'css-backdrop-filter',
        browsers: browsers
    });
});

// element() function
f(require('caniuse-lite/data/features/css-element-function.js'), function (browsers) {
    return prefix(['element'], {
        props: ['background', 'background-image', 'border-image', 'mask', 'list-style', 'list-style-image', 'content', 'mask-image'],
        feature: 'css-element-function',
        browsers: browsers
    });
});

// Multicolumns
f(require('caniuse-lite/data/features/multicolumn.js'), function (browsers) {
    prefix(['columns', 'column-width', 'column-gap', 'column-rule', 'column-rule-color', 'column-rule-width'], {
        feature: 'multicolumn',
        browsers: browsers
    });

    prefix(['column-count', 'column-rule-style', 'column-span', 'column-fill', 'break-before', 'break-after', 'break-inside'], {
        feature: 'multicolumn',
        browsers: browsers
    });
});

// User select
f(require('caniuse-lite/data/features/user-select-none.js'), function (browsers) {
    return prefix(['user-select'], {
        mistakes: ['-khtml-'],
        feature: 'user-select-none',
        browsers: browsers
    });
});

// Flexible Box Layout
var flexbox = require('caniuse-lite/data/features/flexbox.js');
f(flexbox, { match: /a\sx/ }, function (browsers) {
    browsers = browsers.map(function (i) {
        if (/ie|firefox/.test(i)) {
            return i;
        } else {
            return i + ' 2009';
        }
    });
    prefix(['display-flex', 'inline-flex'], {
        props: ['display'],
        feature: 'flexbox',
        browsers: browsers
    });
    prefix(['flex', 'flex-grow', 'flex-shrink', 'flex-basis'], {
        feature: 'flexbox',
        browsers: browsers
    });
    prefix(['flex-direction', 'flex-wrap', 'flex-flow', 'justify-content', 'order', 'align-items', 'align-self', 'align-content'], {
        feature: 'flexbox',
        browsers: browsers
    });
});

f(flexbox, { match: /y\sx/ }, function (browsers) {
    add(['display-flex', 'inline-flex'], {
        feature: 'flexbox',
        browsers: browsers
    });
    add(['flex', 'flex-grow', 'flex-shrink', 'flex-basis'], {
        feature: 'flexbox',
        browsers: browsers
    });
    add(['flex-direction', 'flex-wrap', 'flex-flow', 'justify-content', 'order', 'align-items', 'align-self', 'align-content'], {
        feature: 'flexbox',
        browsers: browsers
    });
});

// calc() unit
f(require('caniuse-lite/data/features/calc.js'), function (browsers) {
    return prefix(['calc'], {
        props: ['*'],
        feature: 'calc',
        browsers: browsers
    });
});

// Background options
f(require('caniuse-lite/data/features/background-img-opts.js'), function (browsers) {
    return prefix(['background-clip', 'background-origin', 'background-size'], {
        feature: 'background-img-opts',
        browsers: browsers
    });
});

// Font feature settings
f(require('caniuse-lite/data/features/font-feature.js'), function (browsers) {
    return prefix(['font-feature-settings', 'font-variant-ligatures', 'font-language-override'], {
        feature: 'font-feature',
        browsers: browsers
    });
});

// CSS font-kerning property
f(require('caniuse-lite/data/features/font-kerning.js'), function (browsers) {
    return prefix(['font-kerning'], {
        feature: 'font-kerning',
        browsers: browsers
    });
});

// Border image
f(require('caniuse-lite/data/features/border-image.js'), function (browsers) {
    return prefix(['border-image'], {
        feature: 'border-image',
        browsers: browsers
    });
});

// Selection selector
f(require('caniuse-lite/data/features/css-selection.js'), function (browsers) {
    return prefix(['::selection'], {
        selector: true,
        feature: 'css-selection',
        browsers: browsers
    });
});

// Placeholder selector
f(require('caniuse-lite/data/features/css-placeholder.js'), function (browsers) {
    browsers = browsers.map(function (i) {
        var _i$split = i.split(' '),
            name = _i$split[0],
            version = _i$split[1];

        if (name === 'firefox' && parseFloat(version) <= 18) {
            return i + ' old';
        } else {
            return i;
        }
    });

    prefix(['::placeholder'], {
        selector: true,
        feature: 'css-placeholder',
        browsers: browsers
    });
});

// Hyphenation
f(require('caniuse-lite/data/features/css-hyphens.js'), function (browsers) {
    return prefix(['hyphens'], {
        feature: 'css-hyphens',
        browsers: browsers
    });
});

// Fullscreen selector
var fullscreen = require('caniuse-lite/data/features/fullscreen.js');

f(fullscreen, function (browsers) {
    return prefix([':fullscreen'], {
        selector: true,
        feature: 'fullscreen',
        browsers: browsers
    });
});

f(fullscreen, { match: /x(\s#2|$)/ }, function (browsers) {
    return prefix(['::backdrop'], {
        selector: true,
        feature: 'fullscreen',
        browsers: browsers
    });
});

// Tab size
f(require('caniuse-lite/data/features/css3-tabsize.js'), function (browsers) {
    return prefix(['tab-size'], {
        feature: 'css3-tabsize',
        browsers: browsers
    });
});

// Intrinsic & extrinsic sizing
f(require('caniuse-lite/data/features/intrinsic-width.js'), function (browsers) {
    return prefix(['max-content', 'min-content', 'fit-content', 'fill', 'fill-available', 'stretch'], {
        props: ['width', 'min-width', 'max-width', 'height', 'min-height', 'max-height', 'inline-size', 'min-inline-size', 'max-inline-size', 'block-size', 'min-block-size', 'max-block-size', 'grid', 'grid-template', 'grid-template-rows', 'grid-template-columns', 'grid-auto-columns', 'grid-auto-rows'],
        feature: 'intrinsic-width',
        browsers: browsers
    });
});

// Zoom cursors
f(require('caniuse-lite/data/features/css3-cursors-newer.js'), function (browsers) {
    return prefix(['zoom-in', 'zoom-out'], {
        props: ['cursor'],
        feature: 'css3-cursors-newer',
        browsers: browsers
    });
});

// Grab cursors
f(require('caniuse-lite/data/features/css3-cursors-grab.js'), function (browsers) {
    return prefix(['grab', 'grabbing'], {
        props: ['cursor'],
        feature: 'css3-cursors-grab',
        browsers: browsers
    });
});

// Sticky position
f(require('caniuse-lite/data/features/css-sticky.js'), function (browsers) {
    return prefix(['sticky'], {
        props: ['position'],
        feature: 'css-sticky',
        browsers: browsers
    });
});

// Pointer Events
f(require('caniuse-lite/data/features/pointer.js'), function (browsers) {
    return prefix(['touch-action'], {
        feature: 'pointer',
        browsers: browsers
    });
});

// Text decoration
var decoration = require('caniuse-lite/data/features/text-decoration.js');

f(decoration, function (browsers) {
    return prefix(['text-decoration-style', 'text-decoration-color', 'text-decoration-line', 'text-decoration'], {
        feature: 'text-decoration',
        browsers: browsers
    });
});

f(decoration, { match: /x.*#[23]/ }, function (browsers) {
    return prefix(['text-decoration-skip'], {
        feature: 'text-decoration',
        browsers: browsers
    });
});

// Text Size Adjust
f(require('caniuse-lite/data/features/text-size-adjust.js'), function (browsers) {
    return prefix(['text-size-adjust'], {
        feature: 'text-size-adjust',
        browsers: browsers
    });
});

// CSS Masks
f(require('caniuse-lite/data/features/css-masks.js'), function (browsers) {
    prefix(['mask-clip', 'mask-composite', 'mask-image', 'mask-origin', 'mask-repeat', 'mask-border-repeat', 'mask-border-source'], {
        feature: 'css-masks',
        browsers: browsers
    });
    prefix(['mask', 'mask-position', 'mask-size', 'mask-border', 'mask-border-outset', 'mask-border-width', 'mask-border-slice'], {
        feature: 'css-masks',
        browsers: browsers
    });
});

// CSS clip-path property
f(require('caniuse-lite/data/features/css-clip-path.js'), function (browsers) {
    return prefix(['clip-path'], {
        feature: 'css-clip-path',
        browsers: browsers
    });
});

// Fragmented Borders and Backgrounds
f(require('caniuse-lite/data/features/css-boxdecorationbreak.js'), function (browsers) {
    return prefix(['box-decoration-break'], {
        feature: 'css-boxdecorationbreak',
        browsers: browsers
    });
});

// CSS3 object-fit/object-position
f(require('caniuse-lite/data/features/object-fit.js'), function (browsers) {
    return prefix(['object-fit', 'object-position'], {
        feature: 'object-fit',
        browsers: browsers
    });
});

// CSS Shapes
f(require('caniuse-lite/data/features/css-shapes.js'), function (browsers) {
    return prefix(['shape-margin', 'shape-outside', 'shape-image-threshold'], {
        feature: 'css-shapes',
        browsers: browsers
    });
});

// CSS3 text-overflow
f(require('caniuse-lite/data/features/text-overflow.js'), function (browsers) {
    return prefix(['text-overflow'], {
        feature: 'text-overflow',
        browsers: browsers
    });
});

// Viewport at-rule
f(require('caniuse-lite/data/features/css-deviceadaptation.js'), function (browsers) {
    return prefix(['@viewport'], {
        feature: 'css-deviceadaptation',
        browsers: browsers
    });
});

// Resolution Media Queries
var resolut = require('caniuse-lite/data/features/css-media-resolution.js');
f(resolut, { match: /( x($| )|a #3)/ }, function (browsers) {
    return prefix(['@resolution'], {
        feature: 'css-media-resolution',
        browsers: browsers
    });
});

// CSS text-align-last
f(require('caniuse-lite/data/features/css-text-align-last.js'), function (browsers) {
    return prefix(['text-align-last'], {
        feature: 'css-text-align-last',
        browsers: browsers
    });
});

// Crisp Edges Image Rendering Algorithm
var crispedges = require('caniuse-lite/data/features/css-crisp-edges.js');

f(crispedges, { match: /y x|a x #1/ }, function (browsers) {
    return prefix(['pixelated'], {
        props: ['image-rendering'],
        feature: 'css-crisp-edges',
        browsers: browsers
    });
});

f(crispedges, { match: /a x #2/ }, function (browsers) {
    return prefix(['image-rendering'], {
        feature: 'css-crisp-edges',
        browsers: browsers
    });
});

// Logical Properties
var logicalProps = require('caniuse-lite/data/features/css-logical-props.js');

f(logicalProps, function (browsers) {
    return prefix(['border-inline-start', 'border-inline-end', 'margin-inline-start', 'margin-inline-end', 'padding-inline-start', 'padding-inline-end'], {
        feature: 'css-logical-props',
        browsers: browsers
    });
});

f(logicalProps, { match: /x\s#2/ }, function (browsers) {
    return prefix(['border-block-start', 'border-block-end', 'margin-block-start', 'margin-block-end', 'padding-block-start', 'padding-block-end'], {
        feature: 'css-logical-props',
        browsers: browsers
    });
});

// CSS appearance
var appearance = require('caniuse-lite/data/features/css-appearance.js');
f(appearance, { match: /#2|x/ }, function (browsers) {
    return prefix(['appearance'], {
        feature: 'css-appearance',
        browsers: browsers
    });
});

// CSS Scroll snap points
f(require('caniuse-lite/data/features/css-snappoints.js'), function (browsers) {
    return prefix(['scroll-snap-type', 'scroll-snap-coordinate', 'scroll-snap-destination', 'scroll-snap-points-x', 'scroll-snap-points-y'], {
        feature: 'css-snappoints',
        browsers: browsers
    });
});

// CSS Regions
f(require('caniuse-lite/data/features/css-regions.js'), function (browsers) {
    return prefix(['flow-into', 'flow-from', 'region-fragment'], {
        feature: 'css-regions',
        browsers: browsers
    });
});

// CSS image-set
f(require('caniuse-lite/data/features/css-image-set.js'), function (browsers) {
    return prefix(['image-set'], {
        props: ['background', 'background-image', 'border-image', 'mask', 'list-style', 'list-style-image', 'content', 'mask-image'],
        feature: 'css-image-set',
        browsers: browsers
    });
});

// Writing Mode
var writingMode = require('caniuse-lite/data/features/css-writing-mode.js');
f(writingMode, { match: /a|x/ }, function (browsers) {
    return prefix(['writing-mode'], {
        feature: 'css-writing-mode',
        browsers: browsers
    });
});

// Cross-Fade Function
f(require('caniuse-lite/data/features/css-cross-fade.js'), function (browsers) {
    return prefix(['cross-fade'], {
        props: ['background', 'background-image', 'border-image', 'mask', 'list-style', 'list-style-image', 'content', 'mask-image'],
        feature: 'css-cross-fade',
        browsers: browsers
    });
});

// Read Only selector
f(require('caniuse-lite/data/features/css-read-only-write.js'), function (browsers) {
    return prefix([':read-only', ':read-write'], {
        selector: true,
        feature: 'css-read-only-write',
        browsers: browsers
    });
});

// Text Emphasize
f(require('caniuse-lite/data/features/text-emphasis.js'), function (browsers) {
    return prefix(['text-emphasis', 'text-emphasis-position', 'text-emphasis-style', 'text-emphasis-color'], {
        feature: 'text-emphasis',
        browsers: browsers
    });
});

// CSS Grid Layout
var grid = require('caniuse-lite/data/features/css-grid.js');

f(grid, function (browsers) {
    prefix(['display-grid', 'inline-grid'], {
        props: ['display'],
        feature: 'css-grid',
        browsers: browsers
    });
    prefix(['grid-template-columns', 'grid-template-rows', 'grid-row-start', 'grid-column-start', 'grid-row-end', 'grid-column-end', 'grid-row', 'grid-column'], {
        feature: 'css-grid',
        browsers: browsers
    });
});

f(grid, { match: /a x/ }, function (browsers) {
    return prefix(['grid-column-align', 'grid-row-align'], {
        feature: 'css-grid',
        browsers: browsers
    });
});

// CSS text-spacing
f(require('caniuse-lite/data/features/css-text-spacing.js'), function (browsers) {
    return prefix(['text-spacing'], {
        feature: 'css-text-spacing',
        browsers: browsers
    });
});

// :any-link selector
f(require('caniuse-lite/data/features/css-any-link.js'), function (browsers) {
    return prefix([':any-link'], {
        selector: true,
        feature: 'css-any-link',
        browsers: browsers
    });
});

// unicode-bidi
var bidi = require('caniuse-lite/data/features/css-unicode-bidi.js');

f(bidi, function (browsers) {
    return prefix(['isolate'], {
        props: ['unicode-bidi'],
        feature: 'css-unicode-bidi',
        browsers: browsers
    });
});

f(bidi, { match: /y x|a x #2/ }, function (browsers) {
    return prefix(['plaintext'], {
        props: ['unicode-bidi'],
        feature: 'css-unicode-bidi',
        browsers: browsers
    });
});

f(bidi, { match: /y x/ }, function (browsers) {
    return prefix(['isolate-override'], {
        props: ['unicode-bidi'],
        feature: 'css-unicode-bidi',
        browsers: browsers
    });
});
},{"caniuse-lite":578,"caniuse-lite/data/features/background-img-opts.js":137,"caniuse-lite/data/features/border-image.js":145,"caniuse-lite/data/features/border-radius.js":146,"caniuse-lite/data/features/calc.js":149,"caniuse-lite/data/features/css-animation.js":171,"caniuse-lite/data/features/css-any-link.js":172,"caniuse-lite/data/features/css-appearance.js":173,"caniuse-lite/data/features/css-backdrop-filter.js":176,"caniuse-lite/data/features/css-boxdecorationbreak.js":179,"caniuse-lite/data/features/css-boxshadow.js":180,"caniuse-lite/data/features/css-clip-path.js":184,"caniuse-lite/data/features/css-crisp-edges.js":188,"caniuse-lite/data/features/css-cross-fade.js":189,"caniuse-lite/data/features/css-deviceadaptation.js":192,"caniuse-lite/data/features/css-element-function.js":195,"caniuse-lite/data/features/css-filter-function.js":198,"caniuse-lite/data/features/css-filters.js":199,"caniuse-lite/data/features/css-gradients.js":207,"caniuse-lite/data/features/css-grid.js":208,"caniuse-lite/data/features/css-hyphens.js":212,"caniuse-lite/data/features/css-image-set.js":214,"caniuse-lite/data/features/css-logical-props.js":221,"caniuse-lite/data/features/css-masks.js":223,"caniuse-lite/data/features/css-media-resolution.js":226,"caniuse-lite/data/features/css-placeholder.js":240,"caniuse-lite/data/features/css-read-only-write.js":241,"caniuse-lite/data/features/css-regions.js":244,"caniuse-lite/data/features/css-selection.js":253,"caniuse-lite/data/features/css-shapes.js":254,"caniuse-lite/data/features/css-snappoints.js":255,"caniuse-lite/data/features/css-sticky.js":256,"caniuse-lite/data/features/css-text-align-last.js":259,"caniuse-lite/data/features/css-text-spacing.js":263,"caniuse-lite/data/features/css-transitions.js":267,"caniuse-lite/data/features/css-unicode-bidi.js":268,"caniuse-lite/data/features/css-writing-mode.js":272,"caniuse-lite/data/features/css3-boxsizing.js":275,"caniuse-lite/data/features/css3-cursors-grab.js":277,"caniuse-lite/data/features/css3-cursors-newer.js":278,"caniuse-lite/data/features/css3-tabsize.js":280,"caniuse-lite/data/features/flexbox.js":323,"caniuse-lite/data/features/font-feature.js":326,"caniuse-lite/data/features/font-kerning.js":327,"caniuse-lite/data/features/fullscreen.js":338,"caniuse-lite/data/features/intrinsic-width.js":387,"caniuse-lite/data/features/multicolumn.js":424,"caniuse-lite/data/features/object-fit.js":433,"caniuse-lite/data/features/pointer.js":455,"caniuse-lite/data/features/text-decoration.js":517,"caniuse-lite/data/features/text-emphasis.js":518,"caniuse-lite/data/features/text-overflow.js":519,"caniuse-lite/data/features/text-size-adjust.js":520,"caniuse-lite/data/features/transforms2d.js":529,"caniuse-lite/data/features/transforms3d.js":530,"caniuse-lite/data/features/user-select-none.js":538}],53:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Prefixer = require('./prefixer');

var AtRule = function (_Prefixer) {
    _inherits(AtRule, _Prefixer);

    function AtRule() {
        _classCallCheck(this, AtRule);

        return _possibleConstructorReturn(this, _Prefixer.apply(this, arguments));
    }

    /**
     * Clone and add prefixes for at-rule
     */
    AtRule.prototype.add = function add(rule, prefix) {
        var prefixed = prefix + rule.name;

        var already = rule.parent.some(function (i) {
            return i.name === prefixed && i.params === rule.params;
        });
        if (already) {
            return undefined;
        }

        var cloned = this.clone(rule, { name: prefixed });
        return rule.parent.insertBefore(rule, cloned);
    };

    /**
     * Clone node with prefixes
     */


    AtRule.prototype.process = function process(node) {
        var parent = this.parentPrefix(node);

        for (var _iterator = this.prefixes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
            var _ref;

            if (_isArray) {
                if (_i >= _iterator.length) break;
                _ref = _iterator[_i++];
            } else {
                _i = _iterator.next();
                if (_i.done) break;
                _ref = _i.value;
            }

            var prefix = _ref;

            if (!parent || parent === prefix) {
                this.add(node, prefix);
            }
        }
    };

    return AtRule;
}(Prefixer);

module.exports = AtRule;
},{"./prefixer":104}],54:[function(require,module,exports){
'use strict';

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

var browserslist = require('browserslist');
var postcss = require('postcss');

var Browsers = require('./browsers');
var Prefixes = require('./prefixes');

function isPlainObject(obj) {
    return Object.prototype.toString.apply(obj) === '[object Object]';
}

var cache = {};

function timeCapsule(result, prefixes) {
    if (prefixes.browsers.selected.length === 0) {
        return;
    }
    if (prefixes.add.selectors.length > 0) {
        return;
    }
    if (Object.keys(prefixes.add).length > 2) {
        return;
    }

    result.warn('Greetings, time traveller. ' + 'We are in the golden age of prefix-less CSS, ' + 'where Autoprefixer is no longer needed for your stylesheet.');
}

module.exports = postcss.plugin('autoprefixer', function () {
    for (var _len = arguments.length, reqs = Array(_len), _key = 0; _key < _len; _key++) {
        reqs[_key] = arguments[_key];
    }

    var options = void 0;
    if (reqs.length === 1 && isPlainObject(reqs[0])) {
        options = reqs[0];
        reqs = undefined;
    } else if (reqs.length === 0 || reqs.length === 1 && !reqs[0]) {
        reqs = undefined;
    } else if (reqs.length <= 2 && (reqs[0] instanceof Array || !reqs[0])) {
        options = reqs[1];
        reqs = reqs[0];
    } else if (_typeof(reqs[reqs.length - 1]) === 'object') {
        options = reqs.pop();
    }

    if (!options) {
        options = {};
    }

    if (options.browser) {
        throw new Error('Change `browser` option to `browsers` in Autoprefixer');
    }

    if (options.browsers) {
        reqs = options.browsers;
    }

    if (typeof options.grid === 'undefined') {
        options.grid = false;
    }

    var loadPrefixes = function loadPrefixes(opts) {
        var data = module.exports.data;
        var browsers = new Browsers(data.browsers, reqs, opts, options.stats);
        var key = browsers.selected.join(', ') + JSON.stringify(options);

        if (!cache[key]) {
            cache[key] = new Prefixes(data.prefixes, browsers, options);
        }

        return cache[key];
    };

    var plugin = function plugin(css, result) {
        var prefixes = loadPrefixes({
            from: css.source && css.source.input.file,
            env: options.env
        });
        timeCapsule(result, prefixes);
        if (options.remove !== false) {
            prefixes.processor.remove(css);
        }
        if (options.add !== false) {
            prefixes.processor.add(css, result);
        }
    };

    plugin.options = options;

    plugin.info = function (opts) {
        return require('./info')(loadPrefixes(opts));
    };

    return plugin;
});

/**
 * Autoprefixer data
 */
module.exports.data = {
    browsers: require('caniuse-lite').agents,
    prefixes: require('../data/prefixes')
};

/**
 * Autoprefixer default browsers
 */
module.exports.defaults = browserslist.defaults;

/**
 * Inspect with default Autoprefixer
 */
module.exports.info = function () {
    return module.exports().info();
};
},{"../data/prefixes":52,"./browsers":56,"./info":101,"./prefixes":105,"browserslist":116,"caniuse-lite":578,"postcss":828}],55:[function(require,module,exports){
'use strict';

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

var last = function last(array) {
    return array[array.length - 1];
};

var brackets = {

    /**
     * Parse string to nodes tree
     */
    parse: function parse(str) {
        var current = [''];
        var stack = [current];

        for (var i = 0; i < str.length; i++) {
            var sym = str[i];
            if (sym === '(') {
                current = [''];
                last(stack).push(current);
                stack.push(current);
            } else if (sym === ')') {
                stack.pop();
                current = last(stack);
                current.push('');
            } else {
                current[current.length - 1] += sym;
            }
        }

        return stack[0];
    },


    /**
     * Generate output string by nodes tree
     */
    stringify: function stringify(ast) {
        var result = '';
        for (var _iterator = ast, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
            var _ref;

            if (_isArray) {
                if (_i >= _iterator.length) break;
                _ref = _iterator[_i++];
            } else {
                _i = _iterator.next();
                if (_i.done) break;
                _ref = _i.value;
            }

            var i = _ref;

            if ((typeof i === 'undefined' ? 'undefined' : _typeof(i)) === 'object') {
                result += '(' + brackets.stringify(i) + ')';
            } else {
                result += i;
            }
        }
        return result;
    }
};

module.exports = brackets;
},{}],56:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var browserslist = require('browserslist');

var utils = require('./utils');

var Browsers = function () {

    /**
     * Return all prefixes for default browser data
     */
    Browsers.prefixes = function prefixes() {
        if (this.prefixesCache) {
            return this.prefixesCache;
        }

        var data = require('caniuse-lite').agents;

        this.prefixesCache = [];
        for (var name in data) {
            this.prefixesCache.push('-' + data[name].prefix + '-');
        }

        this.prefixesCache = utils.uniq(this.prefixesCache).sort(function (a, b) {
            return b.length - a.length;
        });

        return this.prefixesCache;
    };

    /**
     * Check is value contain any possibe prefix
     */


    Browsers.withPrefix = function withPrefix(value) {
        if (!this.prefixesRegexp) {
            this.prefixesRegexp = new RegExp(this.prefixes().join('|'));
        }

        return this.prefixesRegexp.test(value);
    };

    function Browsers(data, requirements, options, stats) {
        _classCallCheck(this, Browsers);

        this.data = data;
        this.options = options || {};
        this.stats = stats;
        this.selected = this.parse(requirements);
    }

    /**
     * Return browsers selected by requirements
     */


    Browsers.prototype.parse = function parse(requirements) {
        return browserslist(requirements, {
            stats: this.stats,
            path: this.options.from,
            env: this.options.env
        });
    };

    /**
     * Select major browsers versions by criteria
     */


    Browsers.prototype.browsers = function browsers(criteria) {
        var _this = this;

        var selected = [];

        var _loop = function _loop(browser) {
            var data = _this.data[browser];
            var versions = criteria(data).map(function (version) {
                return browser + ' ' + version;
            });
            selected = selected.concat(versions);
        };

        for (var browser in this.data) {
            _loop(browser);
        }
        return selected;
    };

    /**
     * Return prefix for selected browser
     */


    Browsers.prototype.prefix = function prefix(browser) {
        var _browser$split = browser.split(' '),
            name = _browser$split[0],
            version = _browser$split[1];

        var data = this.data[name];

        var prefix = data.prefix_exceptions && data.prefix_exceptions[version];
        if (!prefix) {
            prefix = data.prefix;
        }
        return '-' + prefix + '-';
    };

    /**
     * Is browser is selected by requirements
     */


    Browsers.prototype.isSelected = function isSelected(browser) {
        return this.selected.indexOf(browser) !== -1;
    };

    return Browsers;
}();

module.exports = Browsers;
},{"./utils":111,"browserslist":116,"caniuse-lite":578}],57:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Prefixer = require('./prefixer');
var Browsers = require('./browsers');
var utils = require('./utils');

var Declaration = function (_Prefixer) {
    _inherits(Declaration, _Prefixer);

    function Declaration() {
        _classCallCheck(this, Declaration);

        return _possibleConstructorReturn(this, _Prefixer.apply(this, arguments));
    }

    /**
     * Always true, because we already get prefixer by property name
     */
    Declaration.prototype.check = function check() /* decl */{
        return true;
    };

    /**
     * Return prefixed version of property
     */


    Declaration.prototype.prefixed = function prefixed(prop, prefix) {
        return prefix + prop;
    };

    /**
     * Return unprefixed version of property
     */


    Declaration.prototype.normalize = function normalize(prop) {
        return prop;
    };

    /**
     * Check `value`, that it contain other prefixes, rather than `prefix`
     */


    Declaration.prototype.otherPrefixes = function otherPrefixes(value, prefix) {
        for (var _iterator = Browsers.prefixes(), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
            var _ref;

            if (_isArray) {
                if (_i >= _iterator.length) break;
                _ref = _iterator[_i++];
            } else {
                _i = _iterator.next();
                if (_i.done) break;
                _ref = _i.value;
            }

            var other = _ref;

            if (other === prefix) {
                continue;
            }
            if (value.indexOf(other) !== -1) {
                return true;
            }
        }
        return false;
    };

    /**
     * Set prefix to declaration
     */


    Declaration.prototype.set = function set(decl, prefix) {
        decl.prop = this.prefixed(decl.prop, prefix);
        return decl;
    };

    /**
     * Should we use visual cascade for prefixes
     */


    Declaration.prototype.needCascade = function needCascade(decl) {
        if (!decl._autoprefixerCascade) {
            decl._autoprefixerCascade = this.all.options.cascade !== false && decl.raw('before').indexOf('\n') !== -1;
        }
        return decl._autoprefixerCascade;
    };

    /**
     * Return maximum length of possible prefixed property
     */


    Declaration.prototype.maxPrefixed = function maxPrefixed(prefixes, decl) {
        if (decl._autoprefixerMax) {
            return decl._autoprefixerMax;
        }

        var max = 0;
        for (var _iterator2 = prefixes, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
            var _ref2;

            if (_isArray2) {
                if (_i2 >= _iterator2.length) break;
                _ref2 = _iterator2[_i2++];
            } else {
                _i2 = _iterator2.next();
                if (_i2.done) break;
                _ref2 = _i2.value;
            }

            var prefix = _ref2;

            prefix = utils.removeNote(prefix);
            if (prefix.length > max) {
                max = prefix.length;
            }
        }
        decl._autoprefixerMax = max;

        return decl._autoprefixerMax;
    };

    /**
     * Calculate indentation to create visual cascade
     */


    Declaration.prototype.calcBefore = function calcBefore(prefixes, decl) {
        var prefix = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';

        var max = this.maxPrefixed(prefixes, decl);
        var diff = max - utils.removeNote(prefix).length;

        var before = decl.raw('before');
        before += Array(diff).fill(' ').join('');

        return before;
    };

    /**
     * Remove visual cascade
     */


    Declaration.prototype.restoreBefore = function restoreBefore(decl) {
        var lines = decl.raw('before').split('\n');
        var min = lines[lines.length - 1];

        this.all.group(decl).up(function (prefixed) {
            var array = prefixed.raw('before').split('\n');
            var last = array[array.length - 1];
            if (last.length < min.length) {
                min = last;
            }
        });

        lines[lines.length - 1] = min;
        decl.raws.before = lines.join('\n');
    };

    /**
     * Clone and insert new declaration
     */


    Declaration.prototype.insert = function insert(decl, prefix, prefixes) {
        var cloned = this.set(this.clone(decl), prefix);
        if (!cloned) return undefined;

        var already = decl.parent.some(function (i) {
            return i.prop === cloned.prop && i.value === cloned.value;
        });
        if (already) {
            return undefined;
        }

        if (this.needCascade(decl)) {
            cloned.raws.before = this.calcBefore(prefixes, decl, prefix);
        }
        return decl.parent.insertBefore(decl, cloned);
    };

    /**
     * Did this declaration has this prefix above
     */


    Declaration.prototype.isAlready = function isAlready(decl, prefixed) {
        var already = this.all.group(decl).up(function (i) {
            return i.prop === prefixed;
        });
        if (!already) {
            already = this.all.group(decl).down(function (i) {
                return i.prop === prefixed;
            });
        }
        return already;
    };

    /**
     * Clone and add prefixes for declaration
     */


    Declaration.prototype.add = function add(decl, prefix, prefixes) {
        var prefixed = this.prefixed(decl.prop, prefix);
        if (this.isAlready(decl, prefixed) || this.otherPrefixes(decl.value, prefix)) {
            return undefined;
        }
        return this.insert(decl, prefix, prefixes);
    };

    /**
     * Add spaces for visual cascade
     */


    Declaration.prototype.process = function process(decl) {
        if (this.needCascade(decl)) {
            var prefixes = _Prefixer.prototype.process.call(this, decl);
            if (prefixes && prefixes.length) {
                this.restoreBefore(decl);
                decl.raws.before = this.calcBefore(prefixes, decl);
            }
        } else {
            _Prefixer.prototype.process.call(this, decl);
        }
    };

    /**
     * Return list of prefixed properties to clean old prefixes
     */


    Declaration.prototype.old = function old(prop, prefix) {
        return [this.prefixed(prop, prefix)];
    };

    return Declaration;
}(Prefixer);

module.exports = Declaration;
},{"./browsers":56,"./prefixer":104,"./utils":111}],58:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var flexSpec = require('./flex-spec');
var Declaration = require('../declaration');

var AlignContent = function (_Declaration) {
    _inherits(AlignContent, _Declaration);

    function AlignContent() {
        _classCallCheck(this, AlignContent);

        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
    }

    /**
     * Change property name for 2012 spec
     */
    AlignContent.prototype.prefixed = function prefixed(prop, prefix) {
        var spec = void 0;

        var _flexSpec = flexSpec(prefix);

        spec = _flexSpec[0];
        prefix = _flexSpec[1];

        if (spec === 2012) {
            return prefix + 'flex-line-pack';
        } else {
            return _Declaration.prototype.prefixed.call(this, prop, prefix);
        }
    };

    /**
     * Return property name by final spec
     */


    AlignContent.prototype.normalize = function normalize() {
        return 'align-content';
    };

    /**
     * Change value for 2012 spec and ignore prefix for 2009
     */


    AlignContent.prototype.set = function set(decl, prefix) {
        var spec = flexSpec(prefix)[0];
        if (spec === 2012) {
            decl.value = AlignContent.oldValues[decl.value] || decl.value;
            return _Declaration.prototype.set.call(this, decl, prefix);
        } else if (spec === 'final') {
            return _Declaration.prototype.set.call(this, decl, prefix);
        }
        return undefined;
    };

    return AlignContent;
}(Declaration);

Object.defineProperty(AlignContent, 'names', {
    enumerable: true,
    writable: true,
    value: ['align-content', 'flex-line-pack']
});
Object.defineProperty(AlignContent, 'oldValues', {
    enumerable: true,
    writable: true,
    value: {
        'flex-end': 'end',
        'flex-start': 'start',
        'space-between': 'justify',
        'space-around': 'distribute'
    }
});


module.exports = AlignContent;
},{"../declaration":57,"./flex-spec":77}],59:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var flexSpec = require('./flex-spec');
var Declaration = require('../declaration');

var AlignItems = function (_Declaration) {
    _inherits(AlignItems, _Declaration);

    function AlignItems() {
        _classCallCheck(this, AlignItems);

        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
    }

    /**
     * Change property name for 2009 and 2012 specs
     */
    AlignItems.prototype.prefixed = function prefixed(prop, prefix) {
        var spec = void 0;

        var _flexSpec = flexSpec(prefix);

        spec = _flexSpec[0];
        prefix = _flexSpec[1];

        if (spec === 2009) {
            return prefix + 'box-align';
        } else if (spec === 2012) {
            return prefix + 'flex-align';
        } else {
            return _Declaration.prototype.prefixed.call(this, prop, prefix);
        }
    };

    /**
     * Return property name by final spec
     */


    AlignItems.prototype.normalize = function normalize() {
        return 'align-items';
    };

    /**
     * Change value for 2009 and 2012 specs
     */


    AlignItems.prototype.set = function set(decl, prefix) {
        var spec = flexSpec(prefix)[0];
        if (spec === 2009 || spec === 2012) {
            decl.value = AlignItems.oldValues[decl.value] || decl.value;
        }
        return _Declaration.prototype.set.call(this, decl, prefix);
    };

    return AlignItems;
}(Declaration);

Object.defineProperty(AlignItems, 'names', {
    enumerable: true,
    writable: true,
    value: ['align-items', 'flex-align', 'box-align']
});
Object.defineProperty(AlignItems, 'oldValues', {
    enumerable: true,
    writable: true,
    value: {
        'flex-end': 'end',
        'flex-start': 'start'
    }
});


module.exports = AlignItems;
},{"../declaration":57,"./flex-spec":77}],60:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var flexSpec = require('./flex-spec');
var Declaration = require('../declaration');

var AlignSelf = function (_Declaration) {
    _inherits(AlignSelf, _Declaration);

    function AlignSelf() {
        _classCallCheck(this, AlignSelf);

        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
    }

    /**
     * Change property name for 2012 specs
     */
    AlignSelf.prototype.prefixed = function prefixed(prop, prefix) {
        var spec = void 0;

        var _flexSpec = flexSpec(prefix);

        spec = _flexSpec[0];
        prefix = _flexSpec[1];

        if (spec === 2012) {
            return prefix + 'flex-item-align';
        } else {
            return _Declaration.prototype.prefixed.call(this, prop, prefix);
        }
    };

    /**
     * Return property name by final spec
     */


    AlignSelf.prototype.normalize = function normalize() {
        return 'align-self';
    };

    /**
     * Change value for 2012 spec and ignore prefix for 2009
     */


    AlignSelf.prototype.set = function set(decl, prefix) {
        var spec = flexSpec(prefix)[0];
        if (spec === 2012) {
            decl.value = AlignSelf.oldValues[decl.value] || decl.value;
            return _Declaration.prototype.set.call(this, decl, prefix);
        } else if (spec === 'final') {
            return _Declaration.prototype.set.call(this, decl, prefix);
        }
        return undefined;
    };

    return AlignSelf;
}(Declaration);

Object.defineProperty(AlignSelf, 'names', {
    enumerable: true,
    writable: true,
    value: ['align-self', 'flex-item-align']
});
Object.defineProperty(AlignSelf, 'oldValues', {
    enumerable: true,
    writable: true,
    value: {
        'flex-end': 'end',
        'flex-start': 'start'
    }
});


module.exports = AlignSelf;
},{"../declaration":57,"./flex-spec":77}],61:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Declaration = require('../declaration');
var utils = require('../utils');

var Appearance = function (_Declaration) {
    _inherits(Appearance, _Declaration);

    function Appearance(name, prefixes, all) {
        _classCallCheck(this, Appearance);

        var _this = _possibleConstructorReturn(this, _Declaration.call(this, name, prefixes, all));

        if (_this.prefixes) {
            _this.prefixes = utils.uniq(_this.prefixes.map(function (i) {
                if (i === '-ms-') {
                    return '-webkit-';
                } else {
                    return i;
                }
            }));
        }
        return _this;
    }

    return Appearance;
}(Declaration);

Object.defineProperty(Appearance, 'names', {
    enumerable: true,
    writable: true,
    value: ['appearance']
});


module.exports = Appearance;
},{"../declaration":57,"../utils":111}],62:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Declaration = require('../declaration');

var BackgroundSize = function (_Declaration) {
    _inherits(BackgroundSize, _Declaration);

    function BackgroundSize() {
        _classCallCheck(this, BackgroundSize);

        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
    }

    /**
     * Duplication parameter for -webkit- browsers
     */
    BackgroundSize.prototype.set = function set(decl, prefix) {
        var value = decl.value.toLowerCase();
        if (prefix === '-webkit-' && value.indexOf(' ') === -1 && value !== 'contain' && value !== 'cover') {
            decl.value = decl.value + ' ' + decl.value;
        }
        return _Declaration.prototype.set.call(this, decl, prefix);
    };

    return BackgroundSize;
}(Declaration);

Object.defineProperty(BackgroundSize, 'names', {
    enumerable: true,
    writable: true,
    value: ['background-size']
});


module.exports = BackgroundSize;
},{"../declaration":57}],63:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Declaration = require('../declaration');

var BlockLogical = function (_Declaration) {
    _inherits(BlockLogical, _Declaration);

    function BlockLogical() {
        _classCallCheck(this, BlockLogical);

        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
    }

    /**
     * Use old syntax for -moz- and -webkit-
     */
    BlockLogical.prototype.prefixed = function prefixed(prop, prefix) {
        return prefix + (prop.indexOf('-start') !== -1 ? prop.replace('-block-start', '-before') : prop.replace('-block-end', '-after'));
    };

    /**
     * Return property name by spec
     */


    BlockLogical.prototype.normalize = function normalize(prop) {
        if (prop.indexOf('-before') !== -1) {
            return prop.replace('-before', '-block-start');
        } else {
            return prop.replace('-after', '-block-end');
        }
    };

    return BlockLogical;
}(Declaration);

Object.defineProperty(BlockLogical, 'names', {
    enumerable: true,
    writable: true,
    value: ['border-block-start', 'border-block-end', 'margin-block-start', 'margin-block-end', 'padding-block-start', 'padding-block-end', 'border-before', 'border-after', 'margin-before', 'margin-after', 'padding-before', 'padding-after']
});


module.exports = BlockLogical;
},{"../declaration":57}],64:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Declaration = require('../declaration');

var BorderImage = function (_Declaration) {
    _inherits(BorderImage, _Declaration);

    function BorderImage() {
        _classCallCheck(this, BorderImage);

        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
    }

    /**
     * Remove fill parameter for prefixed declarations
     */
    BorderImage.prototype.set = function set(decl, prefix) {
        decl.value = decl.value.replace(/\s+fill(\s)/, '$1');
        return _Declaration.prototype.set.call(this, decl, prefix);
    };

    return BorderImage;
}(Declaration);

Object.defineProperty(BorderImage, 'names', {
    enumerable: true,
    writable: true,
    value: ['border-image']
});


module.exports = BorderImage;
},{"../declaration":57}],65:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Declaration = require('../declaration');

var BorderRadius = function (_Declaration) {
    _inherits(BorderRadius, _Declaration);

    function BorderRadius() {
        _classCallCheck(this, BorderRadius);

        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
    }

    /**
     * Change syntax, when add Mozilla prefix
     */
    BorderRadius.prototype.prefixed = function prefixed(prop, prefix) {
        if (prefix === '-moz-') {
            return prefix + (BorderRadius.toMozilla[prop] || prop);
        } else {
            return _Declaration.prototype.prefixed.call(this, prop, prefix);
        }
    };

    /**
     * Return unprefixed version of property
     */


    BorderRadius.prototype.normalize = function normalize(prop) {
        return BorderRadius.toNormal[prop] || prop;
    };

    return BorderRadius;
}(Declaration);

Object.defineProperty(BorderRadius, 'names', {
    enumerable: true,
    writable: true,
    value: ['border-radius']
});
Object.defineProperty(BorderRadius, 'toMozilla', {
    enumerable: true,
    writable: true,
    value: {}
});
Object.defineProperty(BorderRadius, 'toNormal', {
    enumerable: true,
    writable: true,
    value: {}
});
var _arr = ['top', 'bottom'];


for (var _i = 0; _i < _arr.length; _i++) {
    var ver = _arr[_i];var _arr2 = ['left', 'right'];

    for (var _i2 = 0; _i2 < _arr2.length; _i2++) {
        var hor = _arr2[_i2];
        var normal = 'border-' + ver + '-' + hor + '-radius';
        var mozilla = 'border-radius-' + ver + hor;

        BorderRadius.names.push(normal);
        BorderRadius.names.push(mozilla);

        BorderRadius.toMozilla[normal] = mozilla;
        BorderRadius.toNormal[mozilla] = normal;
    }
}

module.exports = BorderRadius;
},{"../declaration":57}],66:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Declaration = require('../declaration');

var BreakProps = function (_Declaration) {
    _inherits(BreakProps, _Declaration);

    function BreakProps() {
        _classCallCheck(this, BreakProps);

        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
    }

    /**
     * Change name for -webkit- and -moz- prefix
     */
    BreakProps.prototype.prefixed = function prefixed(prop, prefix) {
        if (prefix === '-webkit-') {
            return '-webkit-column-' + prop;
        } else if (prefix === '-moz-') {
            return 'page-' + prop;
        } else {
            return _Declaration.prototype.prefixed.call(this, prop, prefix);
        }
    };

    /**
     * Return property name by final spec
     */


    BreakProps.prototype.normalize = function normalize(prop) {
        if (prop.indexOf('inside') !== -1) {
            return 'break-inside';
        } else if (prop.indexOf('before') !== -1) {
            return 'break-before';
        } else if (prop.indexOf('after') !== -1) {
            return 'break-after';
        }
        return undefined;
    };

    /**
     * Change prefixed value for avoid-column and avoid-page
     */


    BreakProps.prototype.set = function set(decl, prefix) {
        var v = decl.value;
        if (decl.prop === 'break-inside' && v === 'avoid-column' || v === 'avoid-page') {
            decl.value = 'avoid';
        }
        return _Declaration.prototype.set.call(this, decl, prefix);
    };

    /**
     * Don’t prefix some values
     */


    BreakProps.prototype.insert = function insert(decl, prefix, prefixes) {
        if (decl.prop !== 'break-inside') {
            return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
        } else if (decl.value === 'avoid-region') {
            return undefined;
        } else if (decl.value === 'avoid-page' && prefix === '-webkit-') {
            return undefined;
        } else {
            return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
        }
    };

    return BreakProps;
}(Declaration);

Object.defineProperty(BreakProps, 'names', {
    enumerable: true,
    writable: true,
    value: ['break-inside', 'page-break-inside', 'column-break-inside', 'break-before', 'page-break-before', 'column-break-before', 'break-after', 'page-break-after', 'column-break-after']
});


module.exports = BreakProps;
},{"../declaration":57}],67:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Value = require('../value');
var list = require('postcss/lib/list');

var CrossFade = function (_Value) {
    _inherits(CrossFade, _Value);

    function CrossFade() {
        _classCallCheck(this, CrossFade);

        return _possibleConstructorReturn(this, _Value.apply(this, arguments));
    }

    CrossFade.prototype.replace = function replace(string, prefix) {
        var _this2 = this;

        return list.space(string).map(function (value) {
            if (value.slice(0, +_this2.name.length + 1) !== _this2.name + '(') {
                return value;
            }

            var close = value.lastIndexOf(')');
            var after = value.slice(close + 1);
            var args = value.slice(_this2.name.length + 1, close);

            if (prefix === '-webkit-') {
                var match = args.match(/\d*.?\d+%?/);
                if (match) {
                    args = args.slice(match[0].length).trim();
                    args += ', ' + match[0];
                } else {
                    args += ', 0.5';
                }
            }
            return prefix + _this2.name + '(' + args + ')' + after;
        }).join(' ');
    };

    return CrossFade;
}(Value);

Object.defineProperty(CrossFade, 'names', {
    enumerable: true,
    writable: true,
    value: ['cross-fade']
});


module.exports = CrossFade;
},{"../value":112,"postcss/lib/list":823}],68:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var flexSpec = require('./flex-spec');
var OldValue = require('../old-value');
var Value = require('../value');

var DisplayFlex = function (_Value) {
    _inherits(DisplayFlex, _Value);

    function DisplayFlex(name, prefixes) {
        _classCallCheck(this, DisplayFlex);

        var _this = _possibleConstructorReturn(this, _Value.call(this, name, prefixes));

        if (name === 'display-flex') {
            _this.name = 'flex';
        }
        return _this;
    }

    /**
     * Faster check for flex value
     */


    DisplayFlex.prototype.check = function check(decl) {
        return decl.prop === 'display' && decl.value === this.name;
    };

    /**
     * Return value by spec
     */


    DisplayFlex.prototype.prefixed = function prefixed(prefix) {
        var spec = void 0,
            value = void 0;

        var _flexSpec = flexSpec(prefix);

        spec = _flexSpec[0];
        prefix = _flexSpec[1];


        if (spec === 2009) {
            if (this.name === 'flex') {
                value = 'box';
            } else {
                value = 'inline-box';
            }
        } else if (spec === 2012) {
            if (this.name === 'flex') {
                value = 'flexbox';
            } else {
                value = 'inline-flexbox';
            }
        } else if (spec === 'final') {
            value = this.name;
        }

        return prefix + value;
    };

    /**
     * Add prefix to value depend on flebox spec version
     */


    DisplayFlex.prototype.replace = function replace(string, prefix) {
        return this.prefixed(prefix);
    };

    /**
     * Change value for old specs
     */


    DisplayFlex.prototype.old = function old(prefix) {
        var prefixed = this.prefixed(prefix);
        if (prefixed) {
            return new OldValue(this.name, prefixed);
        }
        return undefined;
    };

    return DisplayFlex;
}(Value);

Object.defineProperty(DisplayFlex, 'names', {
    enumerable: true,
    writable: true,
    value: ['display-flex', 'inline-flex']
});


module.exports = DisplayFlex;
},{"../old-value":103,"../value":112,"./flex-spec":77}],69:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Value = require('../value');

var DisplayGrid = function (_Value) {
    _inherits(DisplayGrid, _Value);

    function DisplayGrid(name, prefixes) {
        _classCallCheck(this, DisplayGrid);

        var _this = _possibleConstructorReturn(this, _Value.call(this, name, prefixes));

        if (name === 'display-grid') {
            _this.name = 'grid';
        }
        return _this;
    }

    /**
     * Faster check for flex value
     */


    DisplayGrid.prototype.check = function check(decl) {
        return decl.prop === 'display' && decl.value === this.name;
    };

    return DisplayGrid;
}(Value);

Object.defineProperty(DisplayGrid, 'names', {
    enumerable: true,
    writable: true,
    value: ['display-grid', 'inline-grid']
});


module.exports = DisplayGrid;
},{"../value":112}],70:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var OldValue = require('../old-value');
var Value = require('../value');
var utils = require('../utils');

var OldFilterValue = function (_OldValue) {
    _inherits(OldFilterValue, _OldValue);

    function OldFilterValue() {
        _classCallCheck(this, OldFilterValue);

        return _possibleConstructorReturn(this, _OldValue.apply(this, arguments));
    }

    /**
     * Clean -webkit-filter from properties list
     */
    OldFilterValue.prototype.clean = function clean(decl) {
        var _this2 = this;

        decl.value = utils.editList(decl.value, function (props) {
            if (props.every(function (i) {
                return i.indexOf(_this2.unprefixed) !== 0;
            })) {
                return props;
            }
            return props.filter(function (i) {
                return i.indexOf(_this2.prefixed) === -1;
            });
        });
    };

    return OldFilterValue;
}(OldValue);

var FilterValue = function (_Value) {
    _inherits(FilterValue, _Value);

    function FilterValue(name, prefixes) {
        _classCallCheck(this, FilterValue);

        var _this3 = _possibleConstructorReturn(this, _Value.call(this, name, prefixes));

        if (name === 'filter-function') {
            _this3.name = 'filter';
        }
        return _this3;
    }

    /**
     * Use prefixed and unprefixed filter for WebKit
     */


    FilterValue.prototype.replace = function replace(value, prefix) {
        if (prefix === '-webkit-' && value.indexOf('filter(') === -1) {
            if (value.indexOf('-webkit-filter') === -1) {
                return _Value.prototype.replace.call(this, value, prefix) + ', ' + value;
            } else {
                return value;
            }
        } else {
            return _Value.prototype.replace.call(this, value, prefix);
        }
    };

    /**
     * Clean -webkit-filter
     */


    FilterValue.prototype.old = function old(prefix) {
        return new OldFilterValue(this.name, prefix + this.name);
    };

    return FilterValue;
}(Value);

Object.defineProperty(FilterValue, 'names', {
    enumerable: true,
    writable: true,
    value: ['filter', 'filter-function']
});


module.exports = FilterValue;
},{"../old-value":103,"../utils":111,"../value":112}],71:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Declaration = require('../declaration');

var Filter = function (_Declaration) {
    _inherits(Filter, _Declaration);

    function Filter() {
        _classCallCheck(this, Filter);

        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
    }

    /**
     * Check is it Internet Explorer filter
     */
    Filter.prototype.check = function check(decl) {
        var v = decl.value;
        return v.toLowerCase().indexOf('alpha(') === -1 && v.indexOf('DXImageTransform.Microsoft') === -1 && v.indexOf('data:image/svg+xml') === -1;
    };

    return Filter;
}(Declaration);

Object.defineProperty(Filter, 'names', {
    enumerable: true,
    writable: true,
    value: ['filter']
});


module.exports = Filter;
},{"../declaration":57}],72:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var flexSpec = require('./flex-spec');
var Declaration = require('../declaration');

var FlexBasis = function (_Declaration) {
    _inherits(FlexBasis, _Declaration);

    function FlexBasis() {
        _classCallCheck(this, FlexBasis);

        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
    }

    /**
     * Return property name by final spec
     */
    FlexBasis.prototype.normalize = function normalize() {
        return 'flex-basis';
    };

    /**
     * Return flex property for 2012 spec
     */


    FlexBasis.prototype.prefixed = function prefixed(prop, prefix) {
        var spec = void 0;

        var _flexSpec = flexSpec(prefix);

        spec = _flexSpec[0];
        prefix = _flexSpec[1];

        if (spec === 2012) {
            return prefix + 'flex-preferred-size';
        } else {
            return _Declaration.prototype.prefixed.call(this, prop, prefix);
        }
    };

    /**
     * Ignore 2009 spec and use flex property for 2012
     */


    FlexBasis.prototype.set = function set(decl, prefix) {
        var spec = void 0;

        var _flexSpec2 = flexSpec(prefix);

        spec = _flexSpec2[0];
        prefix = _flexSpec2[1];

        if (spec === 2012 || spec === 'final') {
            return _Declaration.prototype.set.call(this, decl, prefix);
        }
        return undefined;
    };

    return FlexBasis;
}(Declaration);

Object.defineProperty(FlexBasis, 'names', {
    enumerable: true,
    writable: true,
    value: ['flex-basis', 'flex-preferred-size']
});


module.exports = FlexBasis;
},{"../declaration":57,"./flex-spec":77}],73:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var flexSpec = require('./flex-spec');
var Declaration = require('../declaration');

var FlexDirection = function (_Declaration) {
    _inherits(FlexDirection, _Declaration);

    function FlexDirection() {
        _classCallCheck(this, FlexDirection);

        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
    }

    /**
     * Return property name by final spec
     */
    FlexDirection.prototype.normalize = function normalize() {
        return 'flex-direction';
    };

    /**
     * Use two properties for 2009 spec
     */


    FlexDirection.prototype.insert = function insert(decl, prefix, prefixes) {
        var spec = void 0;

        var _flexSpec = flexSpec(prefix);

        spec = _flexSpec[0];
        prefix = _flexSpec[1];

        if (spec !== 2009) {
            return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
        } else {
            var already = decl.parent.some(function (i) {
                return i.prop === prefix + 'box-orient' || i.prop === prefix + 'box-direction';
            });
            if (already) {
                return undefined;
            }

            var value = decl.value;
            var orient = value.indexOf('row') !== -1 ? 'horizontal' : 'vertical';
            var dir = value.indexOf('reverse') !== -1 ? 'reverse' : 'normal';

            var cloned = this.clone(decl);
            cloned.prop = prefix + 'box-orient';
            cloned.value = orient;
            if (this.needCascade(decl)) {
                cloned.raws.before = this.calcBefore(prefixes, decl, prefix);
            }
            decl.parent.insertBefore(decl, cloned);

            cloned = this.clone(decl);
            cloned.prop = prefix + 'box-direction';
            cloned.value = dir;
            if (this.needCascade(decl)) {
                cloned.raws.before = this.calcBefore(prefixes, decl, prefix);
            }
            return decl.parent.insertBefore(decl, cloned);
        }
    };

    /**
     * Clean two properties for 2009 spec
     */


    FlexDirection.prototype.old = function old(prop, prefix) {
        var spec = void 0;

        var _flexSpec2 = flexSpec(prefix);

        spec = _flexSpec2[0];
        prefix = _flexSpec2[1];

        if (spec === 2009) {
            return [prefix + 'box-orient', prefix + 'box-direction'];
        } else {
            return _Declaration.prototype.old.call(this, prop, prefix);
        }
    };

    return FlexDirection;
}(Declaration);

Object.defineProperty(FlexDirection, 'names', {
    enumerable: true,
    writable: true,
    value: ['flex-direction', 'box-direction', 'box-orient']
});


module.exports = FlexDirection;
},{"../declaration":57,"./flex-spec":77}],74:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var flexSpec = require('./flex-spec');
var Declaration = require('../declaration');

var FlexFlow = function (_Declaration) {
    _inherits(FlexFlow, _Declaration);

    function FlexFlow() {
        _classCallCheck(this, FlexFlow);

        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
    }

    /**
     * Use two properties for 2009 spec
     */
    FlexFlow.prototype.insert = function insert(decl, prefix, prefixes) {
        var spec = void 0;

        var _flexSpec = flexSpec(prefix);

        spec = _flexSpec[0];
        prefix = _flexSpec[1];

        if (spec !== 2009) {
            return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
        } else {
            var values = decl.value.split(/\s+/).filter(function (i) {
                return i !== 'wrap' && i !== 'nowrap' && 'wrap-reverse';
            });
            if (values.length === 0) {
                return undefined;
            }

            var already = decl.parent.some(function (i) {
                return i.prop === prefix + 'box-orient' || i.prop === prefix + 'box-direction';
            });
            if (already) {
                return undefined;
            }

            var value = values[0];
            var orient = value.indexOf('row') !== -1 ? 'horizontal' : 'vertical';
            var dir = value.indexOf('reverse') !== -1 ? 'reverse' : 'normal';

            var cloned = this.clone(decl);
            cloned.prop = prefix + 'box-orient';
            cloned.value = orient;
            if (this.needCascade(decl)) {
                cloned.raws.before = this.calcBefore(prefixes, decl, prefix);
            }
            decl.parent.insertBefore(decl, cloned);

            cloned = this.clone(decl);
            cloned.prop = prefix + 'box-direction';
            cloned.value = dir;
            if (this.needCascade(decl)) {
                cloned.raws.before = this.calcBefore(prefixes, decl, prefix);
            }
            return decl.parent.insertBefore(decl, cloned);
        }
    };

    return FlexFlow;
}(Declaration);

Object.defineProperty(FlexFlow, 'names', {
    enumerable: true,
    writable: true,
    value: ['flex-flow', 'box-direction', 'box-orient']
});


module.exports = FlexFlow;
},{"../declaration":57,"./flex-spec":77}],75:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var flexSpec = require('./flex-spec');
var Declaration = require('../declaration');

var Flex = function (_Declaration) {
    _inherits(Flex, _Declaration);

    function Flex() {
        _classCallCheck(this, Flex);

        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
    }

    /**
     * Return property name by final spec
     */
    Flex.prototype.normalize = function normalize() {
        return 'flex';
    };

    /**
     * Return flex property for 2009 and 2012 specs
     */


    Flex.prototype.prefixed = function prefixed(prop, prefix) {
        var spec = void 0;

        var _flexSpec = flexSpec(prefix);

        spec = _flexSpec[0];
        prefix = _flexSpec[1];

        if (spec === 2009) {
            return prefix + 'box-flex';
        } else if (spec === 2012) {
            return prefix + 'flex-positive';
        } else {
            return _Declaration.prototype.prefixed.call(this, prop, prefix);
        }
    };

    return Flex;
}(Declaration);

Object.defineProperty(Flex, 'names', {
    enumerable: true,
    writable: true,
    value: ['flex-grow', 'flex-positive']
});


module.exports = Flex;
},{"../declaration":57,"./flex-spec":77}],76:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var flexSpec = require('./flex-spec');
var Declaration = require('../declaration');

var FlexShrink = function (_Declaration) {
    _inherits(FlexShrink, _Declaration);

    function FlexShrink() {
        _classCallCheck(this, FlexShrink);

        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
    }

    /**
     * Return property name by final spec
     */
    FlexShrink.prototype.normalize = function normalize() {
        return 'flex-shrink';
    };

    /**
     * Return flex property for 2012 spec
     */


    FlexShrink.prototype.prefixed = function prefixed(prop, prefix) {
        var spec = void 0;

        var _flexSpec = flexSpec(prefix);

        spec = _flexSpec[0];
        prefix = _flexSpec[1];

        if (spec === 2012) {
            return prefix + 'flex-negative';
        } else {
            return _Declaration.prototype.prefixed.call(this, prop, prefix);
        }
    };

    /**
     * Ignore 2009 spec and use flex property for 2012
     */


    FlexShrink.prototype.set = function set(decl, prefix) {
        var spec = void 0;

        var _flexSpec2 = flexSpec(prefix);

        spec = _flexSpec2[0];
        prefix = _flexSpec2[1];

        if (spec === 2012 || spec === 'final') {
            return _Declaration.prototype.set.call(this, decl, prefix);
        }
        return undefined;
    };

    return FlexShrink;
}(Declaration);

Object.defineProperty(FlexShrink, 'names', {
    enumerable: true,
    writable: true,
    value: ['flex-shrink', 'flex-negative']
});


module.exports = FlexShrink;
},{"../declaration":57,"./flex-spec":77}],77:[function(require,module,exports){
'use strict';

/**
 * Return flexbox spec versions by prefix
 */
module.exports = function (prefix) {
    var spec = void 0;
    if (prefix === '-webkit- 2009' || prefix === '-moz-') {
        spec = 2009;
    } else if (prefix === '-ms-') {
        spec = 2012;
    } else if (prefix === '-webkit-') {
        spec = 'final';
    }

    if (prefix === '-webkit- 2009') {
        prefix = '-webkit-';
    }

    return [spec, prefix];
};
},{}],78:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var OldValue = require('../old-value');
var Value = require('../value');

var FlexValues = function (_Value) {
    _inherits(FlexValues, _Value);

    function FlexValues() {
        _classCallCheck(this, FlexValues);

        return _possibleConstructorReturn(this, _Value.apply(this, arguments));
    }

    /**
     * Return prefixed property name
     */
    FlexValues.prototype.prefixed = function prefixed(prefix) {
        return this.all.prefixed(this.name, prefix);
    };

    /**
     * Change property name to prefixed property name
     */


    FlexValues.prototype.replace = function replace(string, prefix) {
        return string.replace(this.regexp(), '$1' + this.prefixed(prefix) + '$3');
    };

    /**
     * Return function to fast prefixed property name
     */


    FlexValues.prototype.old = function old(prefix) {
        return new OldValue(this.name, this.prefixed(prefix));
    };

    return FlexValues;
}(Value);

Object.defineProperty(FlexValues, 'names', {
    enumerable: true,
    writable: true,
    value: ['flex', 'flex-grow', 'flex-shrink', 'flex-basis']
});


module.exports = FlexValues;
},{"../old-value":103,"../value":112}],79:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var flexSpec = require('./flex-spec');
var Declaration = require('../declaration');

var FlexWrap = function (_Declaration) {
    _inherits(FlexWrap, _Declaration);

    function FlexWrap() {
        _classCallCheck(this, FlexWrap);

        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
    }

    /**
     * Don't add prefix for 2009 spec
     */
    FlexWrap.prototype.set = function set(decl, prefix) {
        var spec = flexSpec(prefix)[0];
        if (spec !== 2009) {
            return _Declaration.prototype.set.call(this, decl, prefix);
        }
        return undefined;
    };

    return FlexWrap;
}(Declaration);

Object.defineProperty(FlexWrap, 'names', {
    enumerable: true,
    writable: true,
    value: ['flex-wrap']
});


module.exports = FlexWrap;
},{"../declaration":57,"./flex-spec":77}],80:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var flexSpec = require('./flex-spec');
var Declaration = require('../declaration');

var list = require('postcss/lib/list');

var Flex = function (_Declaration) {
    _inherits(Flex, _Declaration);

    function Flex() {
        _classCallCheck(this, Flex);

        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
    }

    /**
     * Change property name for 2009 spec
     */
    Flex.prototype.prefixed = function prefixed(prop, prefix) {
        var spec = void 0;

        var _flexSpec = flexSpec(prefix);

        spec = _flexSpec[0];
        prefix = _flexSpec[1];

        if (spec === 2009) {
            return prefix + 'box-flex';
        } else {
            return _Declaration.prototype.prefixed.call(this, prop, prefix);
        }
    };

    /**
     * Return property name by final spec
     */


    Flex.prototype.normalize = function normalize() {
        return 'flex';
    };

    /**
     * Spec 2009 supports only first argument
     * Spec 2012 disallows unitless basis
     */


    Flex.prototype.set = function set(decl, prefix) {
        var spec = flexSpec(prefix)[0];
        if (spec === 2009) {
            decl.value = list.space(decl.value)[0];
            decl.value = Flex.oldValues[decl.value] || decl.value;
            return _Declaration.prototype.set.call(this, decl, prefix);
        } else if (spec === 2012) {
            var components = list.space(decl.value);
            if (components.length === 3 && components[2] === '0') {
                decl.value = components.slice(0, 2).concat('0px').join(' ');
            }
        }
        return _Declaration.prototype.set.call(this, decl, prefix);
    };

    return Flex;
}(Declaration);

Object.defineProperty(Flex, 'names', {
    enumerable: true,
    writable: true,
    value: ['flex', 'box-flex']
});
Object.defineProperty(Flex, 'oldValues', {
    enumerable: true,
    writable: true,
    value: {
        auto: '1',
        none: '0'
    }
});


module.exports = Flex;
},{"../declaration":57,"./flex-spec":77,"postcss/lib/list":823}],81:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Selector = require('../selector');

var Fullscreen = function (_Selector) {
    _inherits(Fullscreen, _Selector);

    function Fullscreen() {
        _classCallCheck(this, Fullscreen);

        return _possibleConstructorReturn(this, _Selector.apply(this, arguments));
    }

    /**
     * Return different selectors depend on prefix
     */
    Fullscreen.prototype.prefixed = function prefixed(prefix) {
        if (prefix === '-webkit-') {
            return ':-webkit-full-screen';
        } else if (prefix === '-moz-') {
            return ':-moz-full-screen';
        } else {
            return ':' + prefix + 'fullscreen';
        }
    };

    return Fullscreen;
}(Selector);

Object.defineProperty(Fullscreen, 'names', {
    enumerable: true,
    writable: true,
    value: [':fullscreen']
});


module.exports = Fullscreen;
},{"../selector":108}],82:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var OldValue = require('../old-value');
var Value = require('../value');
var utils = require('../utils');

var parser = require('postcss-value-parser');
var range = require('normalize-range');

var isDirection = /top|left|right|bottom/gi;

var Gradient = function (_Value) {
    _inherits(Gradient, _Value);

    function Gradient() {
        var _temp, _this, _ret;

        _classCallCheck(this, Gradient);

        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
            args[_key] = arguments[_key];
        }

        return _ret = (_temp = (_this = _possibleConstructorReturn(this, _Value.call.apply(_Value, [this].concat(args))), _this), Object.defineProperty(_this, 'directions', {
            enumerable: true,
            writable: true,
            value: {
                top: 'bottom',
                left: 'right',
                bottom: 'top',
                right: 'left'
            }
        }), Object.defineProperty(_this, 'oldDirections', {
            enumerable: true,
            writable: true,
            value: {
                'top': 'left bottom, left top',
                'left': 'right top, left top',
                'bottom': 'left top, left bottom',
                'right': 'left top, right top',

                'top right': 'left bottom, right top',
                'top left': 'right bottom, left top',
                'right top': 'left bottom, right top',
                'right bottom': 'left top, right bottom',
                'bottom right': 'left top, right bottom',
                'bottom left': 'right top, left bottom',
                'left top': 'right bottom, left top',
                'left bottom': 'right top, left bottom'
            }
        }), _temp), _possibleConstructorReturn(_this, _ret);
    }

    // Direction to replace


    // Direction to replace


    /**
     * Change degrees for webkit prefix
     */
    Gradient.prototype.replace = function replace(string, prefix) {
        var ast = parser(string);
        for (var _iterator = ast.nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
            var _ref;

            if (_isArray) {
                if (_i >= _iterator.length) break;
                _ref = _iterator[_i++];
            } else {
                _i = _iterator.next();
                if (_i.done) break;
                _ref = _i.value;
            }

            var node = _ref;

            if (node.type === 'function' && node.value === this.name) {
                node.nodes = this.newDirection(node.nodes);
                node.nodes = this.normalize(node.nodes);
                if (prefix === '-webkit- old') {
                    var changes = this.oldWebkit(node);
                    if (!changes) {
                        return undefined;
                    }
                } else {
                    node.nodes = this.convertDirection(node.nodes);
                    node.value = prefix + node.value;
                }
            }
        }
        return ast.toString();
    };

    /**
     * Replace first token
     */


    Gradient.prototype.replaceFirst = function replaceFirst(params) {
        for (var _len2 = arguments.length, words = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
            words[_key2 - 1] = arguments[_key2];
        }

        var prefix = words.map(function (i) {
            if (i === ' ') {
                return { type: 'space', value: i };
            } else {
                return { type: 'word', value: i };
            }
        });
        return prefix.concat(params.slice(1));
    };

    /**
     * Convert angle unit to deg
     */


    Gradient.prototype.normalizeUnit = function normalizeUnit(str, full) {
        var num = parseFloat(str);
        var deg = num / full * 360;
        return deg + 'deg';
    };

    /**
     * Normalize angle
     */


    Gradient.prototype.normalize = function normalize(nodes) {
        if (!nodes[0]) {
            return nodes;
        }

        if (/-?\d+(.\d+)?grad/.test(nodes[0].value)) {
            nodes[0].value = this.normalizeUnit(nodes[0].value, 400);
        } else if (/-?\d+(.\d+)?rad/.test(nodes[0].value)) {
            nodes[0].value = this.normalizeUnit(nodes[0].value, 2 * Math.PI);
        } else if (/-?\d+(.\d+)?turn/.test(nodes[0].value)) {
            nodes[0].value = this.normalizeUnit(nodes[0].value, 1);
        } else if (nodes[0].value.indexOf('deg') !== -1) {
            var num = parseFloat(nodes[0].value);
            num = range.wrap(0, 360, num);
            nodes[0].value = num + 'deg';
        }

        if (nodes[0].value === '0deg') {
            nodes = this.replaceFirst(nodes, 'to', ' ', 'top');
        } else if (nodes[0].value === '90deg') {
            nodes = this.replaceFirst(nodes, 'to', ' ', 'right');
        } else if (nodes[0].value === '180deg') {
            nodes = this.replaceFirst(nodes, 'to', ' ', 'bottom');
        } else if (nodes[0].value === '270deg') {
            nodes = this.replaceFirst(nodes, 'to', ' ', 'left');
        }

        return nodes;
    };

    /**
     * Replace old direction to new
     */


    Gradient.prototype.newDirection = function newDirection(params) {
        if (params[0].value === 'to') {
            return params;
        }
        if (!isDirection.test(params[0].value)) {
            return params;
        }

        params.unshift({
            type: 'word',
            value: 'to'
        }, {
            type: 'space',
            value: ' '
        });

        for (var i = 2; i < params.length; i++) {
            if (params[i].type === 'div') {
                break;
            }
            if (params[i].type === 'word') {
                params[i].value = this.revertDirection(params[i].value);
            }
        }

        return params;
    };

    /**
     * Change new direction to old
     */


    Gradient.prototype.convertDirection = function convertDirection(params) {
        if (params.length > 0) {
            if (params[0].value === 'to') {
                this.fixDirection(params);
            } else if (params[0].value.indexOf('deg') !== -1) {
                this.fixAngle(params);
            } else if (params[2].value === 'at') {
                this.fixRadial(params);
            }
        }
        return params;
    };

    /**
     * Replace `to top left` to `bottom right`
     */


    Gradient.prototype.fixDirection = function fixDirection(params) {
        params.splice(0, 2);

        for (var _iterator2 = params, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
            var _ref2;

            if (_isArray2) {
                if (_i2 >= _iterator2.length) break;
                _ref2 = _iterator2[_i2++];
            } else {
                _i2 = _iterator2.next();
                if (_i2.done) break;
                _ref2 = _i2.value;
            }

            var param = _ref2;

            if (param.type === 'div') {
                break;
            }
            if (param.type === 'word') {
                param.value = this.revertDirection(param.value);
            }
        }
    };

    /**
     * Add 90 degrees
     */


    Gradient.prototype.fixAngle = function fixAngle(params) {
        var first = params[0].value;
        first = parseFloat(first);
        first = Math.abs(450 - first) % 360;
        first = this.roundFloat(first, 3);
        params[0].value = first + 'deg';
    };

    /**
     * Fix radial direction syntax
     */


    Gradient.prototype.fixRadial = function fixRadial(params) {
        var first = params[0];
        var second = [];
        var i = void 0;

        for (i = 4; i < params.length; i++) {
            if (params[i].type === 'div') {
                break;
            } else {
                second.push(params[i]);
            }
        }

        params.splice.apply(params, [0, i].concat(second, [params[i + 2], first]));
    };

    Gradient.prototype.revertDirection = function revertDirection(word) {
        return this.directions[word.toLowerCase()] || word;
    };

    /**
     * Round float and save digits under dot
     */


    Gradient.prototype.roundFloat = function roundFloat(float, digits) {
        return parseFloat(float.toFixed(digits));
    };

    /**
     * Convert to old webkit syntax
     */


    Gradient.prototype.oldWebkit = function oldWebkit(node) {
        var nodes = node.nodes;

        var string = parser.stringify(node.nodes);

        if (this.name !== 'linear-gradient') {
            return false;
        }
        if (nodes[0] && nodes[0].value.indexOf('deg') !== -1) {
            return false;
        }
        if (string.indexOf('px') !== -1) {
            return false;
        }
        if (string.indexOf('-corner') !== -1) {
            return false;
        }
        if (string.indexOf('-side') !== -1) {
            return false;
        }

        var params = [[]];
        for (var _iterator3 = nodes, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
            var _ref3;

            if (_isArray3) {
                if (_i3 >= _iterator3.length) break;
                _ref3 = _iterator3[_i3++];
            } else {
                _i3 = _iterator3.next();
                if (_i3.done) break;
                _ref3 = _i3.value;
            }

            var i = _ref3;

            params[params.length - 1].push(i);
            if (i.type === 'div' && i.value === ',') {
                params.push([]);
            }
        }

        this.oldDirection(params);
        this.colorStops(params);

        node.nodes = [];
        for (var _iterator4 = params, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) {
            var _ref4;

            if (_isArray4) {
                if (_i4 >= _iterator4.length) break;
                _ref4 = _iterator4[_i4++];
            } else {
                _i4 = _iterator4.next();
                if (_i4.done) break;
                _ref4 = _i4.value;
            }

            var param = _ref4;

            node.nodes = node.nodes.concat(param);
        }

        node.nodes.unshift({ type: 'word', value: 'linear' }, this.cloneDiv(node.nodes));
        node.value = '-webkit-gradient';

        return true;
    };

    /**
     * Change direction syntax to old webkit
     */


    Gradient.prototype.oldDirection = function oldDirection(params) {
        var div = this.cloneDiv(params[0]);

        if (params[0][0].value !== 'to') {
            return params.unshift([{ type: 'word', value: this.oldDirections.bottom }, div]);
        } else {
            var _words = [];
            for (var _iterator5 = params[0].slice(2), _isArray5 = Array.isArray(_iterator5), _i5 = 0, _iterator5 = _isArray5 ? _iterator5 : _iterator5[Symbol.iterator]();;) {
                var _ref5;

                if (_isArray5) {
                    if (_i5 >= _iterator5.length) break;
                    _ref5 = _iterator5[_i5++];
                } else {
                    _i5 = _iterator5.next();
                    if (_i5.done) break;
                    _ref5 = _i5.value;
                }

                var node = _ref5;

                if (node.type === 'word') {
                    _words.push(node.value.toLowerCase());
                }
            }

            _words = _words.join(' ');
            var old = this.oldDirections[_words] || _words;

            params[0] = [{ type: 'word', value: old }, div];
            return params[0];
        }
    };

    /**
     * Get div token from exists parameters
     */


    Gradient.prototype.cloneDiv = function cloneDiv(params) {
        for (var _iterator6 = params, _isArray6 = Array.isArray(_iterator6), _i6 = 0, _iterator6 = _isArray6 ? _iterator6 : _iterator6[Symbol.iterator]();;) {
            var _ref6;

            if (_isArray6) {
                if (_i6 >= _iterator6.length) break;
                _ref6 = _iterator6[_i6++];
            } else {
                _i6 = _iterator6.next();
                if (_i6.done) break;
                _ref6 = _i6.value;
            }

            var i = _ref6;

            if (i.type === 'div' && i.value === ',') {
                return i;
            }
        }
        return { type: 'div', value: ',', after: ' ' };
    };

    /**
     * Change colors syntax to old webkit
     */


    Gradient.prototype.colorStops = function colorStops(params) {
        var result = [];
        for (var i = 0; i < params.length; i++) {
            var pos = void 0;
            var param = params[i];
            var item = void 0;
            if (i === 0) {
                continue;
            }

            var color = parser.stringify(param[0]);
            if (param[1] && param[1].type === 'word') {
                pos = param[1].value;
            } else if (param[2] && param[2].type === 'word') {
                pos = param[2].value;
            }

            var stop = void 0;
            if (i === 1 && (!pos || pos === '0%')) {
                stop = 'from(' + color + ')';
            } else if (i === params.length - 1 && (!pos || pos === '100%')) {
                stop = 'to(' + color + ')';
            } else if (pos) {
                stop = 'color-stop(' + pos + ', ' + color + ')';
            } else {
                stop = 'color-stop(' + color + ')';
            }

            var div = param[param.length - 1];
            params[i] = [{ type: 'word', value: stop }];
            if (div.type === 'div' && div.value === ',') {
                item = params[i].push(div);
            }
            result.push(item);
        }
        return result;
    };

    /**
     * Remove old WebKit gradient too
     */


    Gradient.prototype.old = function old(prefix) {
        if (prefix === '-webkit-') {
            var type = this.name === 'linear-gradient' ? 'linear' : 'radial';
            var string = '-gradient';
            var regexp = utils.regexp('-webkit-(' + type + '-gradient|gradient\\(\\s*' + type + ')', false);

            return new OldValue(this.name, prefix + this.name, string, regexp);
        } else {
            return _Value.prototype.old.call(this, prefix);
        }
    };

    /**
     * Do not add non-webkit prefixes for list-style and object
     */


    Gradient.prototype.add = function add(decl, prefix) {
        var p = decl.prop;
        if (p.indexOf('mask') !== -1) {
            if (prefix === '-webkit-' || prefix === '-webkit- old') {
                return _Value.prototype.add.call(this, decl, prefix);
            }
        } else if (p === 'list-style' || p === 'list-style-image' || p === 'content') {
            if (prefix === '-webkit-' || prefix === '-webkit- old') {
                return _Value.prototype.add.call(this, decl, prefix);
            }
        } else {
            return _Value.prototype.add.call(this, decl, prefix);
        }
        return undefined;
    };

    return Gradient;
}(Value);

Object.defineProperty(Gradient, 'names', {
    enumerable: true,
    writable: true,
    value: ['linear-gradient', 'repeating-linear-gradient', 'radial-gradient', 'repeating-radial-gradient']
});


module.exports = Gradient;
},{"../old-value":103,"../utils":111,"../value":112,"normalize-range":708,"postcss-value-parser":811}],83:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Declaration = require('../declaration');

var GridColumnAlign = function (_Declaration) {
    _inherits(GridColumnAlign, _Declaration);

    function GridColumnAlign() {
        _classCallCheck(this, GridColumnAlign);

        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
    }

    /**
     * Do not prefix flexbox values
     */
    GridColumnAlign.prototype.check = function check(decl) {
        return decl.value.indexOf('flex-') === -1 && decl.value !== 'baseline';
    };

    /**
     * Change property name for IE
     */


    GridColumnAlign.prototype.prefixed = function prefixed(prop, prefix) {
        return prefix + 'grid-column-align';
    };

    /**
     * Change IE property back
     */


    GridColumnAlign.prototype.normalize = function normalize() {
        return 'justify-self';
    };

    return GridColumnAlign;
}(Declaration);

Object.defineProperty(GridColumnAlign, 'names', {
    enumerable: true,
    writable: true,
    value: ['grid-column-align']
});


module.exports = GridColumnAlign;
},{"../declaration":57}],84:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Declaration = require('../declaration');

var GridEnd = function (_Declaration) {
    _inherits(GridEnd, _Declaration);

    function GridEnd() {
        _classCallCheck(this, GridEnd);

        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
    }

    /**
     * Do not add prefix for unsupported value in IE
     */
    GridEnd.prototype.check = function check(decl) {
        return decl.value.indexOf('span') !== -1;
    };

    /**
     * Return a final spec property
     */


    GridEnd.prototype.normalize = function normalize(prop) {
        return prop.replace(/(-span|-end)/, '');
    };

    /**
     * Change property name for IE
     */


    GridEnd.prototype.prefixed = function prefixed(prop, prefix) {
        if (prefix === '-ms-') {
            return prefix + prop.replace('-end', '-span');
        } else {
            return _Declaration.prototype.prefixed.call(this, prop, prefix);
        }
    };

    /**
     * Change repeating syntax for IE
     */


    GridEnd.prototype.set = function set(decl, prefix) {
        if (prefix === '-ms-') {
            decl.value = decl.value.replace(/span\s/i, '');
        }
        return _Declaration.prototype.set.call(this, decl, prefix);
    };

    return GridEnd;
}(Declaration);

Object.defineProperty(GridEnd, 'names', {
    enumerable: true,
    writable: true,
    value: ['grid-row-end', 'grid-column-end', 'grid-row-span', 'grid-column-span']
});


module.exports = GridEnd;
},{"../declaration":57}],85:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Declaration = require('../declaration');

var GridRowAlign = function (_Declaration) {
    _inherits(GridRowAlign, _Declaration);

    function GridRowAlign() {
        _classCallCheck(this, GridRowAlign);

        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
    }

    /**
     * Do not prefix flexbox values
     */
    GridRowAlign.prototype.check = function check(decl) {
        return decl.value.indexOf('flex-') === -1 && decl.value !== 'baseline';
    };

    /**
     * Change property name for IE
     */


    GridRowAlign.prototype.prefixed = function prefixed(prop, prefix) {
        return prefix + 'grid-row-align';
    };

    /**
     * Change IE property back
     */


    GridRowAlign.prototype.normalize = function normalize() {
        return 'align-self';
    };

    return GridRowAlign;
}(Declaration);

Object.defineProperty(GridRowAlign, 'names', {
    enumerable: true,
    writable: true,
    value: ['grid-row-align']
});


module.exports = GridRowAlign;
},{"../declaration":57}],86:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Declaration = require('../declaration');

var GridStart = function (_Declaration) {
    _inherits(GridStart, _Declaration);

    function GridStart() {
        _classCallCheck(this, GridStart);

        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
    }

    /**
     * Do not add prefix for unsupported value in IE
     */
    GridStart.prototype.check = function check(decl) {
        return decl.value.indexOf('/') === -1 || decl.value.indexOf('span') !== -1;
    };

    /**
     * Return a final spec property
     */


    GridStart.prototype.normalize = function normalize(prop) {
        return prop.replace('-start', '');
    };

    /**
     * Change property name for IE
     */


    GridStart.prototype.prefixed = function prefixed(prop, prefix) {
        if (prefix === '-ms-') {
            return prefix + prop.replace('-start', '');
        } else {
            return _Declaration.prototype.prefixed.call(this, prop, prefix);
        }
    };

    /**
     * Split one value to two
     */


    GridStart.prototype.insert = function insert(decl, prefix, prefixes) {
        var parts = this.splitValue(decl, prefix);
        if (parts.length === 2) {
            decl.cloneBefore({
                prop: '-ms-' + decl.prop + '-span',
                value: parts[1]
            });
        }
        return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
    };

    /**
     * Change value for combine property
     */


    GridStart.prototype.set = function set(decl, prefix) {
        var parts = this.splitValue(decl, prefix);
        if (parts.length === 2) {
            decl.value = parts[0];
        }
        return _Declaration.prototype.set.call(this, decl, prefix);
    };

    /**
     * If property contains start and end
     */


    GridStart.prototype.splitValue = function splitValue(decl, prefix) {
        if (prefix === '-ms-' && decl.prop.indexOf('-start') === -1) {
            var parts = decl.value.split(/\s*\/\s*span\s+/);
            if (parts.length === 2) {
                return parts;
            }
        }
        return false;
    };

    return GridStart;
}(Declaration);

Object.defineProperty(GridStart, 'names', {
    enumerable: true,
    writable: true,
    value: ['grid-row-start', 'grid-column-start', 'grid-row', 'grid-column']
});


module.exports = GridStart;
},{"../declaration":57}],87:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var parser = require('postcss-value-parser');

var Declaration = require('../declaration');

var GridTemplate = function (_Declaration) {
    _inherits(GridTemplate, _Declaration);

    function GridTemplate() {
        _classCallCheck(this, GridTemplate);

        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
    }

    /**
     * Change property name for IE
     */
    GridTemplate.prototype.prefixed = function prefixed(prop, prefix) {
        if (prefix === '-ms-') {
            return prefix + prop.replace('template-', '');
        } else {
            return _Declaration.prototype.prefixed.call(this, prop, prefix);
        }
    };

    /**
     * Change IE property back
     */


    GridTemplate.prototype.normalize = function normalize(prop) {
        return prop.replace(/^grid-(rows|columns)/, 'grid-template-$1');
    };

    /**
     * Recursive part of changeRepeat
     */


    GridTemplate.prototype.walkRepeat = function walkRepeat(node) {
        var fixed = [];
        for (var _iterator = node.nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
            var _ref;

            if (_isArray) {
                if (_i >= _iterator.length) break;
                _ref = _iterator[_i++];
            } else {
                _i = _iterator.next();
                if (_i.done) break;
                _ref = _i.value;
            }

            var i = _ref;

            if (i.nodes) {
                this.walkRepeat(i);
            }
            fixed.push(i);
            if (i.type === 'function' && i.value === 'repeat') {
                var first = i.nodes.shift();
                if (first) {
                    var count = first.value;
                    i.nodes.shift();
                    i.value = '';
                    fixed.push({ type: 'word', value: '[' + count + ']' });
                }
            }
        }
        node.nodes = fixed;
    };

    /**
     * IE repeating syntax
     */


    GridTemplate.prototype.changeRepeat = function changeRepeat(value) {
        var ast = parser(value);
        this.walkRepeat(ast);
        return ast.toString();
    };

    /**
     * Change repeating syntax for IE
     */


    GridTemplate.prototype.set = function set(decl, prefix) {
        if (prefix === '-ms-' && decl.value.indexOf('repeat(') !== -1) {
            decl.value = this.changeRepeat(decl.value);
        }
        return _Declaration.prototype.set.call(this, decl, prefix);
    };

    return GridTemplate;
}(Declaration);

Object.defineProperty(GridTemplate, 'names', {
    enumerable: true,
    writable: true,
    value: ['grid-template-rows', 'grid-template-columns', 'grid-rows', 'grid-columns']
});


module.exports = GridTemplate;
},{"../declaration":57,"postcss-value-parser":811}],88:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Declaration = require('../declaration');

var ImageRendering = function (_Declaration) {
    _inherits(ImageRendering, _Declaration);

    function ImageRendering() {
        _classCallCheck(this, ImageRendering);

        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
    }

    /**
     * Add hack only for crisp-edges
     */
    ImageRendering.prototype.check = function check(decl) {
        return decl.value === 'pixelated';
    };

    /**
     * Change property name for IE
     */


    ImageRendering.prototype.prefixed = function prefixed(prop, prefix) {
        if (prefix === '-ms-') {
            return '-ms-interpolation-mode';
        } else {
            return _Declaration.prototype.prefixed.call(this, prop, prefix);
        }
    };

    /**
     * Change property and value for IE
     */


    ImageRendering.prototype.set = function set(decl, prefix) {
        if (prefix === '-ms-') {
            decl.prop = '-ms-interpolation-mode';
            decl.value = 'nearest-neighbor';
            return decl;
        } else {
            return _Declaration.prototype.set.call(this, decl, prefix);
        }
    };

    /**
     * Return property name by spec
     */


    ImageRendering.prototype.normalize = function normalize() {
        return 'image-rendering';
    };

    /**
     * Warn on old value
     */


    ImageRendering.prototype.process = function process(node, result) {
        return _Declaration.prototype.process.call(this, node, result);
    };

    return ImageRendering;
}(Declaration);

Object.defineProperty(ImageRendering, 'names', {
    enumerable: true,
    writable: true,
    value: ['image-rendering', 'interpolation-mode']
});


module.exports = ImageRendering;
},{"../declaration":57}],89:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Value = require('../value');

var ImageSet = function (_Value) {
    _inherits(ImageSet, _Value);

    function ImageSet() {
        _classCallCheck(this, ImageSet);

        return _possibleConstructorReturn(this, _Value.apply(this, arguments));
    }

    /**
     * Use non-standard name for WebKit and Firefox
     */
    ImageSet.prototype.replace = function replace(string, prefix) {
        if (prefix === '-webkit-') {
            return _Value.prototype.replace.call(this, string, prefix).replace(/("[^"]+"|'[^']+')(\s+\d+\w)/gi, 'url($1)$2');
        } else {
            return _Value.prototype.replace.call(this, string, prefix);
        }
    };

    return ImageSet;
}(Value);

Object.defineProperty(ImageSet, 'names', {
    enumerable: true,
    writable: true,
    value: ['image-set']
});


module.exports = ImageSet;
},{"../value":112}],90:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Declaration = require('../declaration');

var InlineLogical = function (_Declaration) {
    _inherits(InlineLogical, _Declaration);

    function InlineLogical() {
        _classCallCheck(this, InlineLogical);

        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
    }

    /**
     * Use old syntax for -moz- and -webkit-
     */
    InlineLogical.prototype.prefixed = function prefixed(prop, prefix) {
        return prefix + prop.replace('-inline', '');
    };

    /**
     * Return property name by spec
     */


    InlineLogical.prototype.normalize = function normalize(prop) {
        return prop.replace(/(margin|padding|border)-(start|end)/, '$1-inline-$2');
    };

    return InlineLogical;
}(Declaration);

Object.defineProperty(InlineLogical, 'names', {
    enumerable: true,
    writable: true,
    value: ['border-inline-start', 'border-inline-end', 'margin-inline-start', 'margin-inline-end', 'padding-inline-start', 'padding-inline-end', 'border-start', 'border-end', 'margin-start', 'margin-end', 'padding-start', 'padding-end']
});


module.exports = InlineLogical;
},{"../declaration":57}],91:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var OldValue = require('../old-value');
var Value = require('../value');

function _regexp(name) {
    return new RegExp('(^|[\\s,(])(' + name + '($|[\\s),]))', 'gi');
}

var Intrinsic = function (_Value) {
    _inherits(Intrinsic, _Value);

    function Intrinsic() {
        _classCallCheck(this, Intrinsic);

        return _possibleConstructorReturn(this, _Value.apply(this, arguments));
    }

    Intrinsic.prototype.regexp = function regexp() {
        if (!this.regexpCache) this.regexpCache = _regexp(this.name);
        return this.regexpCache;
    };

    Intrinsic.prototype.isStretch = function isStretch() {
        return this.name === 'stretch' || this.name === 'fill' || this.name === 'fill-available';
    };

    Intrinsic.prototype.replace = function replace(string, prefix) {
        if (prefix === '-moz-' && this.isStretch()) {
            return string.replace(this.regexp(), '$1-moz-available$3');
        } else if (prefix === '-webkit-' && this.isStretch()) {
            return string.replace(this.regexp(), '$1-webkit-fill-available$3');
        } else {
            return _Value.prototype.replace.call(this, string, prefix);
        }
    };

    Intrinsic.prototype.old = function old(prefix) {
        var prefixed = prefix + this.name;
        if (this.isStretch()) {
            if (prefix === '-moz-') {
                prefixed = '-moz-available';
            } else if (prefix === '-webkit-') {
                prefixed = '-webkit-fill-available';
            }
        }
        return new OldValue(this.name, prefixed, prefixed, _regexp(prefixed));
    };

    Intrinsic.prototype.add = function add(decl, prefix) {
        if (decl.prop.indexOf('grid') !== -1 && prefix !== '-webkit-') {
            return undefined;
        }
        return _Value.prototype.add.call(this, decl, prefix);
    };

    return Intrinsic;
}(Value);

Object.defineProperty(Intrinsic, 'names', {
    enumerable: true,
    writable: true,
    value: ['max-content', 'min-content', 'fit-content', 'fill', 'fill-available', 'stretch']
});


module.exports = Intrinsic;
},{"../old-value":103,"../value":112}],92:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var flexSpec = require('./flex-spec');
var Declaration = require('../declaration');

var JustifyContent = function (_Declaration) {
    _inherits(JustifyContent, _Declaration);

    function JustifyContent() {
        _classCallCheck(this, JustifyContent);

        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
    }

    /**
     * Change property name for 2009 and 2012 specs
     */
    JustifyContent.prototype.prefixed = function prefixed(prop, prefix) {
        var spec = void 0;

        var _flexSpec = flexSpec(prefix);

        spec = _flexSpec[0];
        prefix = _flexSpec[1];

        if (spec === 2009) {
            return prefix + 'box-pack';
        } else if (spec === 2012) {
            return prefix + 'flex-pack';
        } else {
            return _Declaration.prototype.prefixed.call(this, prop, prefix);
        }
    };

    /**
     * Return property name by final spec
     */


    JustifyContent.prototype.normalize = function normalize() {
        return 'justify-content';
    };

    /**
     * Change value for 2009 and 2012 specs
     */


    JustifyContent.prototype.set = function set(decl, prefix) {
        var spec = flexSpec(prefix)[0];
        if (spec === 2009 || spec === 2012) {
            var value = JustifyContent.oldValues[decl.value] || decl.value;
            decl.value = value;
            if (spec !== 2009 || value !== 'distribute') {
                return _Declaration.prototype.set.call(this, decl, prefix);
            }
        } else if (spec === 'final') {
            return _Declaration.prototype.set.call(this, decl, prefix);
        }
        return undefined;
    };

    return JustifyContent;
}(Declaration);

Object.defineProperty(JustifyContent, 'names', {
    enumerable: true,
    writable: true,
    value: ['justify-content', 'flex-pack', 'box-pack']
});
Object.defineProperty(JustifyContent, 'oldValues', {
    enumerable: true,
    writable: true,
    value: {
        'flex-end': 'end',
        'flex-start': 'start',
        'space-between': 'justify',
        'space-around': 'distribute'
    }
});


module.exports = JustifyContent;
},{"../declaration":57,"./flex-spec":77}],93:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Declaration = require('../declaration');

var MaskBorder = function (_Declaration) {
    _inherits(MaskBorder, _Declaration);

    function MaskBorder() {
        _classCallCheck(this, MaskBorder);

        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
    }

    /**
     * Return property name by final spec
     */
    MaskBorder.prototype.normalize = function normalize() {
        return this.name.replace('box-image', 'border');
    };

    /**
     * Return flex property for 2012 spec
     */


    MaskBorder.prototype.prefixed = function prefixed(prop, prefix) {
        if (prefix === '-webkit-') {
            return _Declaration.prototype.prefixed.call(this, prop, prefix).replace('border', 'box-image');
        } else {
            return _Declaration.prototype.prefixed.call(this, prop, prefix);
        }
    };

    return MaskBorder;
}(Declaration);

Object.defineProperty(MaskBorder, 'names', {
    enumerable: true,
    writable: true,
    value: ['mask-border', 'mask-border-source', 'mask-border-slice', 'mask-border-width', 'mask-border-outset', 'mask-border-repeat', 'mask-box-image', 'mask-box-image-source', 'mask-box-image-slice', 'mask-box-image-width', 'mask-box-image-outset', 'mask-box-image-repeat']
});


module.exports = MaskBorder;
},{"../declaration":57}],94:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var flexSpec = require('./flex-spec');
var Declaration = require('../declaration');

var Order = function (_Declaration) {
    _inherits(Order, _Declaration);

    function Order() {
        _classCallCheck(this, Order);

        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
    }

    /**
     * Change property name for 2009 and 2012 specs
     */
    Order.prototype.prefixed = function prefixed(prop, prefix) {
        var spec = void 0;

        var _flexSpec = flexSpec(prefix);

        spec = _flexSpec[0];
        prefix = _flexSpec[1];

        if (spec === 2009) {
            return prefix + 'box-ordinal-group';
        } else if (spec === 2012) {
            return prefix + 'flex-order';
        } else {
            return _Declaration.prototype.prefixed.call(this, prop, prefix);
        }
    };

    /**
     * Return property name by final spec
     */


    Order.prototype.normalize = function normalize() {
        return 'order';
    };

    /**
     * Fix value for 2009 spec
     */


    Order.prototype.set = function set(decl, prefix) {
        var spec = flexSpec(prefix)[0];
        if (spec === 2009 && /\d/.test(decl.value)) {
            decl.value = (parseInt(decl.value) + 1).toString();
            return _Declaration.prototype.set.call(this, decl, prefix);
        } else {
            return _Declaration.prototype.set.call(this, decl, prefix);
        }
    };

    return Order;
}(Declaration);

Object.defineProperty(Order, 'names', {
    enumerable: true,
    writable: true,
    value: ['order', 'flex-order', 'box-ordinal-group']
});


module.exports = Order;
},{"../declaration":57,"./flex-spec":77}],95:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var OldValue = require('../old-value');
var Value = require('../value');

var Pixelated = function (_Value) {
    _inherits(Pixelated, _Value);

    function Pixelated() {
        _classCallCheck(this, Pixelated);

        return _possibleConstructorReturn(this, _Value.apply(this, arguments));
    }

    /**
     * Use non-standard name for WebKit and Firefox
     */
    Pixelated.prototype.replace = function replace(string, prefix) {
        if (prefix === '-webkit-') {
            return string.replace(this.regexp(), '$1-webkit-optimize-contrast');
        } else if (prefix === '-moz-') {
            return string.replace(this.regexp(), '$1-moz-crisp-edges');
        } else {
            return _Value.prototype.replace.call(this, string, prefix);
        }
    };

    /**
     * Different name for WebKit and Firefox
     */


    Pixelated.prototype.old = function old(prefix) {
        if (prefix === '-webkit-') {
            return new OldValue(this.name, '-webkit-optimize-contrast');
        } else if (prefix === '-moz-') {
            return new OldValue(this.name, '-moz-crisp-edges');
        } else {
            return _Value.prototype.old.call(this, prefix);
        }
    };

    return Pixelated;
}(Value);

Object.defineProperty(Pixelated, 'names', {
    enumerable: true,
    writable: true,
    value: ['pixelated']
});


module.exports = Pixelated;
},{"../old-value":103,"../value":112}],96:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Selector = require('../selector');

var Placeholder = function (_Selector) {
    _inherits(Placeholder, _Selector);

    function Placeholder() {
        _classCallCheck(this, Placeholder);

        return _possibleConstructorReturn(this, _Selector.apply(this, arguments));
    }

    /**
     * Add old mozilla to possible prefixes
     */
    Placeholder.prototype.possible = function possible() {
        return _Selector.prototype.possible.call(this).concat('-moz- old');
    };

    /**
     * Return different selectors depend on prefix
     */


    Placeholder.prototype.prefixed = function prefixed(prefix) {
        if (prefix === '-webkit-') {
            return '::-webkit-input-placeholder';
        } else if (prefix === '-ms-') {
            return ':-ms-input-placeholder';
        } else if (prefix === '-moz- old') {
            return ':-moz-placeholder';
        } else {
            return '::' + prefix + 'placeholder';
        }
    };

    return Placeholder;
}(Selector);

Object.defineProperty(Placeholder, 'names', {
    enumerable: true,
    writable: true,
    value: [':placeholder-shown', '::placeholder']
});


module.exports = Placeholder;
},{"../selector":108}],97:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Declaration = require('../declaration');

var BASIC = ['none', 'underline', 'overline', 'line-through', 'blink', 'inherit', 'initial', 'unset'];

var TextDecoration = function (_Declaration) {
    _inherits(TextDecoration, _Declaration);

    function TextDecoration() {
        _classCallCheck(this, TextDecoration);

        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
    }

    /**
     * Do not add prefixes for basic values.
     */
    TextDecoration.prototype.check = function check(decl) {
        return decl.value.split(/\s+/).some(function (i) {
            return BASIC.indexOf(i) === -1;
        });
    };

    return TextDecoration;
}(Declaration);

Object.defineProperty(TextDecoration, 'names', {
    enumerable: true,
    writable: true,
    value: ['text-decoration']
});


module.exports = TextDecoration;
},{"../declaration":57}],98:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Declaration = require('../declaration');

var TextEmphasisPosition = function (_Declaration) {
    _inherits(TextEmphasisPosition, _Declaration);

    function TextEmphasisPosition() {
        _classCallCheck(this, TextEmphasisPosition);

        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
    }

    TextEmphasisPosition.prototype.set = function set(decl, prefix) {
        if (prefix === '-webkit-') {
            decl.value = decl.value.replace(/\s*(right|left)\s*/i, '');
            return _Declaration.prototype.set.call(this, decl, prefix);
        } else {
            return _Declaration.prototype.set.call(this, decl, prefix);
        }
    };

    return TextEmphasisPosition;
}(Declaration);

Object.defineProperty(TextEmphasisPosition, 'names', {
    enumerable: true,
    writable: true,
    value: ['text-emphasis-position']
});


module.exports = TextEmphasisPosition;
},{"../declaration":57}],99:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Declaration = require('../declaration');

var TransformDecl = function (_Declaration) {
    _inherits(TransformDecl, _Declaration);

    function TransformDecl() {
        _classCallCheck(this, TransformDecl);

        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
    }

    /**
     * Recursively check all parents for @keyframes
     */
    TransformDecl.prototype.keyframeParents = function keyframeParents(decl) {
        var parent = decl.parent;

        while (parent) {
            if (parent.type === 'atrule' && parent.name === 'keyframes') {
                return true;
            }
            var _parent = parent;
            parent = _parent.parent;
        }
        return false;
    };

    /**
     * Is transform caontain 3D commands
     */


    TransformDecl.prototype.contain3d = function contain3d(decl) {
        if (decl.prop === 'transform-origin') {
            return false;
        }

        for (var _iterator = TransformDecl.functions3d, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
            var _ref;

            if (_isArray) {
                if (_i >= _iterator.length) break;
                _ref = _iterator[_i++];
            } else {
                _i = _iterator.next();
                if (_i.done) break;
                _ref = _i.value;
            }

            var func = _ref;

            if (decl.value.indexOf(func + '(') !== -1) {
                return true;
            }
        }

        return false;
    };

    /**
     * Replace rotateZ to rotate for IE 9
     */


    TransformDecl.prototype.set = function set(decl, prefix) {
        decl = _Declaration.prototype.set.call(this, decl, prefix);
        if (prefix === '-ms-') {
            decl.value = decl.value.replace(/rotateZ/gi, 'rotate');
        }
        return decl;
    };

    /**
     * Don't add prefix for IE in keyframes
     */


    TransformDecl.prototype.insert = function insert(decl, prefix, prefixes) {
        if (prefix === '-ms-') {
            if (!this.contain3d(decl) && !this.keyframeParents(decl)) {
                return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
            }
        } else if (prefix === '-o-') {
            if (!this.contain3d(decl)) {
                return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
            }
        } else {
            return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
        }
        return undefined;
    };

    return TransformDecl;
}(Declaration);

Object.defineProperty(TransformDecl, 'names', {
    enumerable: true,
    writable: true,
    value: ['transform', 'transform-origin']
});
Object.defineProperty(TransformDecl, 'functions3d', {
    enumerable: true,
    writable: true,
    value: ['matrix3d', 'translate3d', 'translateZ', 'scale3d', 'scaleZ', 'rotate3d', 'rotateX', 'rotateY', 'perspective']
});


module.exports = TransformDecl;
},{"../declaration":57}],100:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Declaration = require('../declaration');

var WritingMode = function (_Declaration) {
    _inherits(WritingMode, _Declaration);

    function WritingMode() {
        _classCallCheck(this, WritingMode);

        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
    }

    WritingMode.prototype.set = function set(decl, prefix) {
        if (prefix === '-ms-') {
            decl.value = WritingMode.msValues[decl.value] || decl.value;
            return _Declaration.prototype.set.call(this, decl, prefix);
        } else {
            return _Declaration.prototype.set.call(this, decl, prefix);
        }
    };

    return WritingMode;
}(Declaration);

Object.defineProperty(WritingMode, 'names', {
    enumerable: true,
    writable: true,
    value: ['writing-mode']
});
Object.defineProperty(WritingMode, 'msValues', {
    enumerable: true,
    writable: true,
    value: {
        'horizontal-tb': 'lr-tb',
        'vertical-rl': 'tb-rl',
        'vertical-lr': 'tb-lr'
    }
});


module.exports = WritingMode;
},{"../declaration":57}],101:[function(require,module,exports){
'use strict';

var browserslist = require('browserslist');

function capitalize(str) {
    return str.slice(0, 1).toUpperCase() + str.slice(1);
}

var names = {
    ie: 'IE',
    ie_mob: 'IE Mobile',
    ios_saf: 'iOS',
    op_mini: 'Opera Mini',
    op_mob: 'Opera Mobile',
    and_chr: 'Chrome for Android',
    and_ff: 'Firefox for Android',
    and_uc: 'UC for Android'
};

var prefix = function prefix(name, prefixes) {
    var out = '  ' + name + ': ';
    out += prefixes.map(function (i) {
        return i.replace(/^-(.*)-$/g, '$1');
    }).join(', ');
    out += '\n';
    return out;
};

module.exports = function (prefixes) {
    if (prefixes.browsers.selected.length === 0) {
        return 'No browsers selected';
    }

    var versions = {};
    for (var _iterator = prefixes.browsers.selected, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
        var _ref;

        if (_isArray) {
            if (_i >= _iterator.length) break;
            _ref = _iterator[_i++];
        } else {
            _i = _iterator.next();
            if (_i.done) break;
            _ref = _i.value;
        }

        var browser = _ref;

        var _browser$split = browser.split(' '),
            name = _browser$split[0],
            version = _browser$split[1];

        name = names[name] || capitalize(name);
        if (versions[name]) {
            versions[name].push(version);
        } else {
            versions[name] = [version];
        }
    }

    var out = 'Browsers:\n';
    for (var _browser in versions) {
        var list = versions[_browser];
        list = list.sort(function (a, b) {
            return parseFloat(b) - parseFloat(a);
        });
        out += '  ' + _browser + ': ' + list.join(', ') + '\n';
    }

    var coverage = browserslist.coverage(prefixes.browsers.selected);
    var round = Math.round(coverage * 100) / 100.0;
    out += '\nThese browsers account for ' + round + '% of all users globally\n';

    var atrules = '';
    for (var name in prefixes.add) {
        var data = prefixes.add[name];
        if (name[0] === '@' && data.prefixes) {
            atrules += prefix(name, data.prefixes);
        }
    }
    if (atrules !== '') {
        out += '\nAt-Rules:\n' + atrules;
    }

    var selectors = '';
    for (var _iterator2 = prefixes.add.selectors, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
        var _ref2;

        if (_isArray2) {
            if (_i2 >= _iterator2.length) break;
            _ref2 = _iterator2[_i2++];
        } else {
            _i2 = _iterator2.next();
            if (_i2.done) break;
            _ref2 = _i2.value;
        }

        var selector = _ref2;

        if (selector.prefixes) {
            selectors += prefix(selector.name, selector.prefixes);
        }
    }
    if (selectors !== '') {
        out += '\nSelectors:\n' + selectors;
    }

    var values = '';
    var props = '';
    for (var _name in prefixes.add) {
        var _data = prefixes.add[_name];
        if (_name[0] !== '@' && _data.prefixes) {
            props += prefix(_name, _data.prefixes);
        }

        if (!_data.values) {
            continue;
        }
        for (var _iterator3 = _data.values, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
            var _ref3;

            if (_isArray3) {
                if (_i3 >= _iterator3.length) break;
                _ref3 = _iterator3[_i3++];
            } else {
                _i3 = _iterator3.next();
                if (_i3.done) break;
                _ref3 = _i3.value;
            }

            var value = _ref3;

            var string = prefix(value.name, value.prefixes);
            if (values.indexOf(string) === -1) {
                values += string;
            }
        }
    }

    if (props !== '') {
        out += '\nProperties:\n' + props;
    }
    if (values !== '') {
        out += '\nValues:\n' + values;
    }

    if (atrules === '' && selectors === '' && props === '' && values === '') {
        out += '\nAwesome! Your browsers don\'t require any vendor prefixes.' + '\nNow you can remove Autoprefixer from build steps.';
    }

    return out;
};
},{"browserslist":116}],102:[function(require,module,exports){
"use strict";

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var OldSelector = function () {
    function OldSelector(selector, prefix) {
        _classCallCheck(this, OldSelector);

        this.prefix = prefix;
        this.prefixed = selector.prefixed(this.prefix);
        this.regexp = selector.regexp(this.prefix);

        this.prefixeds = selector.possible().map(function (x) {
            return [selector.prefixed(x), selector.regexp(x)];
        });

        this.unprefixed = selector.name;
        this.nameRegexp = selector.regexp();
    }

    /**
     * Is rule a hack without unprefixed version bottom
     */


    OldSelector.prototype.isHack = function isHack(rule) {
        var index = rule.parent.index(rule) + 1;
        var rules = rule.parent.nodes;

        while (index < rules.length) {
            var before = rules[index].selector;
            if (!before) {
                return true;
            }

            if (before.indexOf(this.unprefixed) !== -1 && before.match(this.nameRegexp)) {
                return false;
            }

            var some = false;
            for (var _iterator = this.prefixeds, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
                var _ref2;

                if (_isArray) {
                    if (_i >= _iterator.length) break;
                    _ref2 = _iterator[_i++];
                } else {
                    _i = _iterator.next();
                    if (_i.done) break;
                    _ref2 = _i.value;
                }

                var _ref = _ref2;
                var string = _ref[0];
                var regexp = _ref[1];

                if (before.indexOf(string) !== -1 && before.match(regexp)) {
                    some = true;
                    break;
                }
            }

            if (!some) {
                return true;
            }

            index += 1;
        }

        return true;
    };

    /**
     * Does rule contain an unnecessary prefixed selector
     */


    OldSelector.prototype.check = function check(rule) {
        if (rule.selector.indexOf(this.prefixed) === -1) {
            return false;
        }
        if (!rule.selector.match(this.regexp)) {
            return false;
        }
        if (this.isHack(rule)) {
            return false;
        }
        return true;
    };

    return OldSelector;
}();

module.exports = OldSelector;
},{}],103:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var utils = require('./utils');

var OldValue = function () {
    function OldValue(unprefixed, prefixed, string, regexp) {
        _classCallCheck(this, OldValue);

        this.unprefixed = unprefixed;
        this.prefixed = prefixed;
        this.string = string || prefixed;
        this.regexp = regexp || utils.regexp(prefixed);
    }

    /**
     * Check, that value contain old value
     */


    OldValue.prototype.check = function check(value) {
        if (value.indexOf(this.string) !== -1) {
            return !!value.match(this.regexp);
        }
        return false;
    };

    return OldValue;
}();

module.exports = OldValue;
},{"./utils":111}],104:[function(require,module,exports){
'use strict';

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Browsers = require('./browsers');
var utils = require('./utils');

var vendor = require('postcss/lib/vendor');

/**
 * Recursivly clone objects
 */
function _clone(obj, parent) {
    var cloned = new obj.constructor();

    for (var _iterator = Object.keys(obj || {}), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
        var _ref;

        if (_isArray) {
            if (_i >= _iterator.length) break;
            _ref = _iterator[_i++];
        } else {
            _i = _iterator.next();
            if (_i.done) break;
            _ref = _i.value;
        }

        var i = _ref;

        var value = obj[i];
        if (i === 'parent' && (typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object') {
            if (parent) {
                cloned[i] = parent;
            }
        } else if (i === 'source') {
            cloned[i] = value;
        } else if (i === null) {
            cloned[i] = value;
        } else if (value instanceof Array) {
            cloned[i] = value.map(function (x) {
                return _clone(x, cloned);
            });
        } else if (i !== '_autoprefixerPrefix' && i !== '_autoprefixerValues') {
            if ((typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object' && value !== null) {
                value = _clone(value, cloned);
            }
            cloned[i] = value;
        }
    }

    return cloned;
}

var Prefixer = function () {

    /**
     * Add hack to selected names
     */
    Prefixer.hack = function hack(klass) {
        var _this = this;

        if (!this.hacks) {
            this.hacks = {};
        }
        return klass.names.map(function (name) {
            _this.hacks[name] = klass;
            return _this.hacks[name];
        });
    };

    /**
     * Load hacks for some names
     */


    Prefixer.load = function load(name, prefixes, all) {
        var Klass = this.hacks && this.hacks[name];
        if (Klass) {
            return new Klass(name, prefixes, all);
        } else {
            return new this(name, prefixes, all);
        }
    };

    /**
     * Clone node and clean autprefixer custom caches
     */


    Prefixer.clone = function clone(node, overrides) {
        var cloned = _clone(node);
        for (var name in overrides) {
            cloned[name] = overrides[name];
        }
        return cloned;
    };

    function Prefixer(name, prefixes, all) {
        _classCallCheck(this, Prefixer);

        this.name = name;
        this.prefixes = prefixes;
        this.all = all;
    }

    /**
     * Find prefix in node parents
     */


    Prefixer.prototype.parentPrefix = function parentPrefix(node) {
        var prefix = void 0;

        if (typeof node._autoprefixerPrefix !== 'undefined') {
            prefix = node._autoprefixerPrefix;
        } else if (node.type === 'decl' && node.prop[0] === '-') {
            prefix = vendor.prefix(node.prop);
        } else if (node.type === 'root') {
            prefix = false;
        } else if (node.type === 'rule' && node.selector.indexOf(':-') !== -1 && /:(-\w+-)/.test(node.selector)) {
            prefix = node.selector.match(/:(-\w+-)/)[1];
        } else if (node.type === 'atrule' && node.name[0] === '-') {
            prefix = vendor.prefix(node.name);
        } else {
            prefix = this.parentPrefix(node.parent);
        }

        if (Browsers.prefixes().indexOf(prefix) === -1) {
            prefix = false;
        }

        node._autoprefixerPrefix = prefix;

        return node._autoprefixerPrefix;
    };

    /**
     * Clone node with prefixes
     */


    Prefixer.prototype.process = function process(node) {
        if (!this.check(node)) {
            return undefined;
        }

        var parent = this.parentPrefix(node);

        var prefixes = this.prefixes.filter(function (prefix) {
            return !parent || parent === utils.removeNote(prefix);
        });

        var added = [];
        for (var _iterator2 = prefixes, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
            var _ref2;

            if (_isArray2) {
                if (_i2 >= _iterator2.length) break;
                _ref2 = _iterator2[_i2++];
            } else {
                _i2 = _iterator2.next();
                if (_i2.done) break;
                _ref2 = _i2.value;
            }

            var prefix = _ref2;

            if (this.add(node, prefix, added.concat([prefix]))) {
                added.push(prefix);
            }
        }

        return added;
    };

    /**
     * Shortcut for Prefixer.clone
     */


    Prefixer.prototype.clone = function clone(node, overrides) {
        return Prefixer.clone(node, overrides);
    };

    return Prefixer;
}();

module.exports = Prefixer;
},{"./browsers":56,"./utils":111,"postcss/lib/vendor":838}],105:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Declaration = require('./declaration');
var Resolution = require('./resolution');
var Transition = require('./transition');
var Processor = require('./processor');
var Supports = require('./supports');
var Browsers = require('./browsers');
var Selector = require('./selector');
var AtRule = require('./at-rule');
var Value = require('./value');
var utils = require('./utils');

var vendor = require('postcss/lib/vendor');

Selector.hack(require('./hacks/fullscreen'));
Selector.hack(require('./hacks/placeholder'));

Declaration.hack(require('./hacks/flex'));
Declaration.hack(require('./hacks/order'));
Declaration.hack(require('./hacks/filter'));
Declaration.hack(require('./hacks/grid-end'));
Declaration.hack(require('./hacks/flex-flow'));
Declaration.hack(require('./hacks/flex-grow'));
Declaration.hack(require('./hacks/flex-wrap'));
Declaration.hack(require('./hacks/grid-start'));
Declaration.hack(require('./hacks/align-self'));
Declaration.hack(require('./hacks/appearance'));
Declaration.hack(require('./hacks/flex-basis'));
Declaration.hack(require('./hacks/mask-border'));
Declaration.hack(require('./hacks/align-items'));
Declaration.hack(require('./hacks/flex-shrink'));
Declaration.hack(require('./hacks/break-props'));
Declaration.hack(require('./hacks/writing-mode'));
Declaration.hack(require('./hacks/border-image'));
Declaration.hack(require('./hacks/align-content'));
Declaration.hack(require('./hacks/border-radius'));
Declaration.hack(require('./hacks/block-logical'));
Declaration.hack(require('./hacks/grid-template'));
Declaration.hack(require('./hacks/inline-logical'));
Declaration.hack(require('./hacks/grid-row-align'));
Declaration.hack(require('./hacks/transform-decl'));
Declaration.hack(require('./hacks/flex-direction'));
Declaration.hack(require('./hacks/image-rendering'));
Declaration.hack(require('./hacks/text-decoration'));
Declaration.hack(require('./hacks/justify-content'));
Declaration.hack(require('./hacks/background-size'));
Declaration.hack(require('./hacks/grid-column-align'));
Declaration.hack(require('./hacks/text-emphasis-position'));

Value.hack(require('./hacks/gradient'));
Value.hack(require('./hacks/intrinsic'));
Value.hack(require('./hacks/pixelated'));
Value.hack(require('./hacks/image-set'));
Value.hack(require('./hacks/cross-fade'));
Value.hack(require('./hacks/flex-values'));
Value.hack(require('./hacks/display-flex'));
Value.hack(require('./hacks/display-grid'));
Value.hack(require('./hacks/filter-value'));

var declsCache = {};

var Prefixes = function () {
    function Prefixes(data, browsers) {
        var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};

        _classCallCheck(this, Prefixes);

        this.data = data;
        this.browsers = browsers;
        this.options = options;

        var _preprocess = this.preprocess(this.select(this.data));

        this.add = _preprocess[0];
        this.remove = _preprocess[1];

        this.transition = new Transition(this);
        this.processor = new Processor(this);
    }

    /**
     * Return clone instance to remove all prefixes
     */


    Prefixes.prototype.cleaner = function cleaner() {
        if (this.cleanerCache) {
            return this.cleanerCache;
        }

        if (this.browsers.selected.length) {
            var empty = new Browsers(this.browsers.data, []);
            this.cleanerCache = new Prefixes(this.data, empty, this.options);
        } else {
            return this;
        }

        return this.cleanerCache;
    };

    /**
     * Select prefixes from data, which is necessary for selected browsers
     */


    Prefixes.prototype.select = function select(list) {
        var _this = this;

        var selected = { add: {}, remove: {} };

        var _loop = function _loop(name) {
            var data = list[name];
            var add = data.browsers.map(function (i) {
                var params = i.split(' ');
                return {
                    browser: params[0] + ' ' + params[1],
                    note: params[2]
                };
            });

            var notes = add.filter(function (i) {
                return i.note;
            }).map(function (i) {
                return _this.browsers.prefix(i.browser) + ' ' + i.note;
            });
            notes = utils.uniq(notes);

            add = add.filter(function (i) {
                return _this.browsers.isSelected(i.browser);
            }).map(function (i) {
                var prefix = _this.browsers.prefix(i.browser);
                if (i.note) {
                    return prefix + ' ' + i.note;
                } else {
                    return prefix;
                }
            });
            add = _this.sort(utils.uniq(add));

            if (_this.options.flexbox === 'no-2009') {
                add = add.filter(function (i) {
                    return i.indexOf('2009') === -1;
                });
            }

            var all = data.browsers.map(function (i) {
                return _this.browsers.prefix(i);
            });
            if (data.mistakes) {
                all = all.concat(data.mistakes);
            }
            all = all.concat(notes);
            all = utils.uniq(all);

            if (add.length) {
                selected.add[name] = add;
                if (add.length < all.length) {
                    selected.remove[name] = all.filter(function (i) {
                        return add.indexOf(i) === -1;
                    });
                }
            } else {
                selected.remove[name] = all;
            }
        };

        for (var name in list) {
            _loop(name);
        }

        return selected;
    };

    /**
     * Sort vendor prefixes
     */


    Prefixes.prototype.sort = function sort(prefixes) {
        return prefixes.sort(function (a, b) {
            var aLength = utils.removeNote(a).length;
            var bLength = utils.removeNote(b).length;

            if (aLength === bLength) {
                return b.length - a.length;
            } else {
                return bLength - aLength;
            }
        });
    };

    /**
     * Cache prefixes data to fast CSS processing
     */


    Prefixes.prototype.preprocess = function preprocess(selected) {
        var add = {
            'selectors': [],
            '@supports': new Supports(Prefixes, this)
        };
        for (var name in selected.add) {
            var prefixes = selected.add[name];
            if (name === '@keyframes' || name === '@viewport') {
                add[name] = new AtRule(name, prefixes, this);
            } else if (name === '@resolution') {
                add[name] = new Resolution(name, prefixes, this);
            } else if (this.data[name].selector) {
                add.selectors.push(Selector.load(name, prefixes, this));
            } else {
                var props = this.data[name].props;

                if (props) {
                    var value = Value.load(name, prefixes, this);
                    for (var _iterator = props, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
                        var _ref;

                        if (_isArray) {
                            if (_i >= _iterator.length) break;
                            _ref = _iterator[_i++];
                        } else {
                            _i = _iterator.next();
                            if (_i.done) break;
                            _ref = _i.value;
                        }

                        var prop = _ref;

                        if (!add[prop]) {
                            add[prop] = { values: [] };
                        }
                        add[prop].values.push(value);
                    }
                } else {
                    var values = add[name] && add[name].values || [];
                    add[name] = Declaration.load(name, prefixes, this);
                    add[name].values = values;
                }
            }
        }

        var remove = { selectors: [] };
        for (var _name in selected.remove) {
            var _prefixes = selected.remove[_name];
            if (this.data[_name].selector) {
                var selector = Selector.load(_name, _prefixes);
                for (var _iterator2 = _prefixes, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
                    var _ref2;

                    if (_isArray2) {
                        if (_i2 >= _iterator2.length) break;
                        _ref2 = _iterator2[_i2++];
                    } else {
                        _i2 = _iterator2.next();
                        if (_i2.done) break;
                        _ref2 = _i2.value;
                    }

                    var prefix = _ref2;

                    remove.selectors.push(selector.old(prefix));
                }
            } else if (_name === '@keyframes' || _name === '@viewport') {
                for (var _iterator3 = _prefixes, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
                    var _ref3;

                    if (_isArray3) {
                        if (_i3 >= _iterator3.length) break;
                        _ref3 = _iterator3[_i3++];
                    } else {
                        _i3 = _iterator3.next();
                        if (_i3.done) break;
                        _ref3 = _i3.value;
                    }

                    var _prefix = _ref3;

                    var prefixed = '@' + _prefix + _name.slice(1);
                    remove[prefixed] = { remove: true };
                }
            } else if (_name === '@resolution') {
                remove[_name] = new Resolution(_name, _prefixes, this);
            } else {
                var _props = this.data[_name].props;
                if (_props) {
                    var _value = Value.load(_name, [], this);
                    for (var _iterator4 = _prefixes, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) {
                        var _ref4;

                        if (_isArray4) {
                            if (_i4 >= _iterator4.length) break;
                            _ref4 = _iterator4[_i4++];
                        } else {
                            _i4 = _iterator4.next();
                            if (_i4.done) break;
                            _ref4 = _i4.value;
                        }

                        var _prefix2 = _ref4;

                        var old = _value.old(_prefix2);
                        if (old) {
                            for (var _iterator5 = _props, _isArray5 = Array.isArray(_iterator5), _i5 = 0, _iterator5 = _isArray5 ? _iterator5 : _iterator5[Symbol.iterator]();;) {
                                var _ref5;

                                if (_isArray5) {
                                    if (_i5 >= _iterator5.length) break;
                                    _ref5 = _iterator5[_i5++];
                                } else {
                                    _i5 = _iterator5.next();
                                    if (_i5.done) break;
                                    _ref5 = _i5.value;
                                }

                                var _prop = _ref5;

                                if (!remove[_prop]) {
                                    remove[_prop] = {};
                                }
                                if (!remove[_prop].values) {
                                    remove[_prop].values = [];
                                }
                                remove[_prop].values.push(old);
                            }
                        }
                    }
                } else {
                    for (var _iterator6 = _prefixes, _isArray6 = Array.isArray(_iterator6), _i6 = 0, _iterator6 = _isArray6 ? _iterator6 : _iterator6[Symbol.iterator]();;) {
                        var _ref6;

                        if (_isArray6) {
                            if (_i6 >= _iterator6.length) break;
                            _ref6 = _iterator6[_i6++];
                        } else {
                            _i6 = _iterator6.next();
                            if (_i6.done) break;
                            _ref6 = _i6.value;
                        }

                        var _prefix3 = _ref6;

                        var olds = this.decl(_name).old(_name, _prefix3);
                        if (_name === 'align-self') {
                            var a = add[_name] && add[_name].prefixes;
                            if (a) {
                                if (_prefix3 === '-webkit- 2009' && a.indexOf('-webkit-') !== -1) {
                                    continue;
                                } else if (_prefix3 === '-webkit-' && a.indexOf('-webkit- 2009') !== -1) {
                                    continue;
                                }
                            }
                        }
                        for (var _iterator7 = olds, _isArray7 = Array.isArray(_iterator7), _i7 = 0, _iterator7 = _isArray7 ? _iterator7 : _iterator7[Symbol.iterator]();;) {
                            var _ref7;

                            if (_isArray7) {
                                if (_i7 >= _iterator7.length) break;
                                _ref7 = _iterator7[_i7++];
                            } else {
                                _i7 = _iterator7.next();
                                if (_i7.done) break;
                                _ref7 = _i7.value;
                            }

                            var _prefixed = _ref7;

                            if (!remove[_prefixed]) {
                                remove[_prefixed] = {};
                            }
                            remove[_prefixed].remove = true;
                        }
                    }
                }
            }
        }

        return [add, remove];
    };

    /**
     * Declaration loader with caching
     */


    Prefixes.prototype.decl = function decl(prop) {
        var decl = declsCache[prop];

        if (decl) {
            return decl;
        } else {
            declsCache[prop] = Declaration.load(prop);
            return declsCache[prop];
        }
    };

    /**
     * Return unprefixed version of property
     */


    Prefixes.prototype.unprefixed = function unprefixed(prop) {
        var value = this.normalize(vendor.unprefixed(prop));
        if (value === 'flex-direction') {
            value = 'flex-flow';
        }
        return value;
    };

    /**
     * Normalize prefix for remover
     */


    Prefixes.prototype.normalize = function normalize(prop) {
        return this.decl(prop).normalize(prop);
    };

    /**
     * Return prefixed version of property
     */


    Prefixes.prototype.prefixed = function prefixed(prop, prefix) {
        prop = vendor.unprefixed(prop);
        return this.decl(prop).prefixed(prop, prefix);
    };

    /**
     * Return values, which must be prefixed in selected property
     */


    Prefixes.prototype.values = function values(type, prop) {
        var data = this[type];

        var global = data['*'] && data['*'].values;
        var values = data[prop] && data[prop].values;

        if (global && values) {
            return utils.uniq(global.concat(values));
        } else {
            return global || values || [];
        }
    };

    /**
     * Group declaration by unprefixed property to check them
     */


    Prefixes.prototype.group = function group(decl) {
        var _this2 = this;

        var rule = decl.parent;
        var index = rule.index(decl);
        var length = rule.nodes.length;

        var unprefixed = this.unprefixed(decl.prop);

        var checker = function checker(step, callback) {
            index += step;
            while (index >= 0 && index < length) {
                var other = rule.nodes[index];
                if (other.type === 'decl') {

                    if (step === -1 && other.prop === unprefixed) {
                        if (!Browsers.withPrefix(other.value)) {
                            break;
                        }
                    }

                    if (_this2.unprefixed(other.prop) !== unprefixed) {
                        break;
                    } else if (callback(other) === true) {
                        return true;
                    }

                    if (step === +1 && other.prop === unprefixed) {
                        if (!Browsers.withPrefix(other.value)) {
                            break;
                        }
                    }
                }

                index += step;
            }
            return false;
        };

        return {
            up: function up(callback) {
                return checker(-1, callback);
            },
            down: function down(callback) {
                return checker(+1, callback);
            }
        };
    };

    return Prefixes;
}();

module.exports = Prefixes;
},{"./at-rule":53,"./browsers":56,"./declaration":57,"./hacks/align-content":58,"./hacks/align-items":59,"./hacks/align-self":60,"./hacks/appearance":61,"./hacks/background-size":62,"./hacks/block-logical":63,"./hacks/border-image":64,"./hacks/border-radius":65,"./hacks/break-props":66,"./hacks/cross-fade":67,"./hacks/display-flex":68,"./hacks/display-grid":69,"./hacks/filter":71,"./hacks/filter-value":70,"./hacks/flex":80,"./hacks/flex-basis":72,"./hacks/flex-direction":73,"./hacks/flex-flow":74,"./hacks/flex-grow":75,"./hacks/flex-shrink":76,"./hacks/flex-values":78,"./hacks/flex-wrap":79,"./hacks/fullscreen":81,"./hacks/gradient":82,"./hacks/grid-column-align":83,"./hacks/grid-end":84,"./hacks/grid-row-align":85,"./hacks/grid-start":86,"./hacks/grid-template":87,"./hacks/image-rendering":88,"./hacks/image-set":89,"./hacks/inline-logical":90,"./hacks/intrinsic":91,"./hacks/justify-content":92,"./hacks/mask-border":93,"./hacks/order":94,"./hacks/pixelated":95,"./hacks/placeholder":96,"./hacks/text-decoration":97,"./hacks/text-emphasis-position":98,"./hacks/transform-decl":99,"./hacks/writing-mode":100,"./processor":106,"./resolution":107,"./selector":108,"./supports":109,"./transition":110,"./utils":111,"./value":112,"postcss/lib/vendor":838}],106:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Value = require('./value');

var OLD_DIRECTION = /(^|[^-])(linear|radial)-gradient\(\s*(top|left|right|bottom)/i;

var SIZES = ['width', 'height', 'min-width', 'max-width', 'min-height', 'max-height', 'inline-size', 'min-inline-size', 'max-inline-size', 'block-size', 'min-block-size', 'max-block-size'];

var Processor = function () {
    function Processor(prefixes) {
        _classCallCheck(this, Processor);

        this.prefixes = prefixes;
    }

    /**
     * Add necessary prefixes
     */


    Processor.prototype.add = function add(css, result) {
        var _this = this;

        // At-rules
        var resolution = this.prefixes.add['@resolution'];
        var keyframes = this.prefixes.add['@keyframes'];
        var viewport = this.prefixes.add['@viewport'];
        var supports = this.prefixes.add['@supports'];

        css.walkAtRules(function (rule) {
            if (rule.name === 'keyframes') {
                if (!_this.disabled(rule)) {
                    return keyframes && keyframes.process(rule);
                }
            } else if (rule.name === 'viewport') {
                if (!_this.disabled(rule)) {
                    return viewport && viewport.process(rule);
                }
            } else if (rule.name === 'supports') {
                if (_this.prefixes.options.supports !== false && !_this.disabled(rule)) {
                    return supports.process(rule);
                }
            } else if (rule.name === 'media' && rule.params.indexOf('-resolution') !== -1) {
                if (!_this.disabled(rule)) {
                    return resolution && resolution.process(rule);
                }
            }

            return undefined;
        });

        // Selectors
        css.walkRules(function (rule) {
            if (_this.disabled(rule)) return undefined;

            return _this.prefixes.add.selectors.map(function (selector) {
                return selector.process(rule, result);
            });
        });

        css.walkDecls(function (decl) {
            if (_this.disabledDecl(decl)) return undefined;

            if (decl.prop === 'display' && decl.value === 'box') {
                result.warn('You should write display: flex by final spec ' + 'instead of display: box', { node: decl });
                return undefined;
            }
            if (decl.value.indexOf('linear-gradient') !== -1) {
                if (OLD_DIRECTION.test(decl.value)) {
                    result.warn('Gradient has outdated direction syntax. ' + 'New syntax is like `to left` instead of `right`.', { node: decl });
                }
            }
            if (decl.prop === 'text-emphasis-position') {
                if (decl.value === 'under' || decl.value === 'over') {
                    result.warn('You should use 2 values for text-emphasis-position ' + 'For example, `under left` instead of just `under`.', { node: decl });
                }
            }

            if (SIZES.indexOf(decl.prop) !== -1) {
                if (decl.value.indexOf('fill-available') !== -1) {
                    result.warn('Replace fill-available to stretch, ' + 'because spec had been changed', { node: decl });
                } else if (decl.value.indexOf('fill') !== -1) {
                    result.warn('Replace fill to stretch, ' + 'because spec had been changed', { node: decl });
                }
            }

            if (_this.prefixes.options.flexbox !== false) {
                if (decl.prop === 'grid-row-end' && decl.value.indexOf('span') === -1) {
                    result.warn('IE supports only grid-row-end with span. ' + 'You should add grid: false option to Autoprefixer ' + 'and use some JS grid polyfill for full spec support', { node: decl });
                }
                if (decl.prop === 'grid-row') {
                    if (decl.value.indexOf('/') !== -1 && decl.value.indexOf('span') === -1) {
                        result.warn('IE supports only grid-row with / and span. ' + 'You should add grid: false option ' + 'to Autoprefixer and use some JS grid polyfill ' + 'for full spec support', { node: decl });
                    }
                }
            }

            var prefixer = void 0;

            if (decl.prop === 'transition' || decl.prop === 'transition-property') {
                // Transition
                return _this.prefixes.transition.add(decl, result);
            } else if (decl.prop === 'align-self') {
                // align-self flexbox or grid
                var display = _this.displayType(decl);
                if (display !== 'grid' && _this.prefixes.options.flexbox !== false) {
                    prefixer = _this.prefixes.add['align-self'];
                    if (prefixer && prefixer.prefixes) {
                        prefixer.process(decl);
                    }
                }
                if (display !== 'flex' && _this.prefixes.options.grid !== false) {
                    prefixer = _this.prefixes.add['grid-row-align'];
                    if (prefixer && prefixer.prefixes) {
                        return prefixer.process(decl);
                    }
                }
            } else if (decl.prop === 'justify-self') {
                // justify-self flexbox or grid
                var _display = _this.displayType(decl);
                if (_display !== 'flex' && _this.prefixes.options.grid !== false) {
                    prefixer = _this.prefixes.add['grid-column-align'];
                    if (prefixer && prefixer.prefixes) {
                        return prefixer.process(decl);
                    }
                }
            } else {
                // Properties
                prefixer = _this.prefixes.add[decl.prop];
                if (prefixer && prefixer.prefixes) {
                    return prefixer.process(decl);
                }
            }

            return undefined;
        });

        // Values
        return css.walkDecls(function (decl) {
            if (_this.disabledValue(decl)) return;

            var unprefixed = _this.prefixes.unprefixed(decl.prop);
            for (var _iterator = _this.prefixes.values('add', unprefixed), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
                var _ref;

                if (_isArray) {
                    if (_i >= _iterator.length) break;
                    _ref = _iterator[_i++];
                } else {
                    _i = _iterator.next();
                    if (_i.done) break;
                    _ref = _i.value;
                }

                var value = _ref;

                value.process(decl, result);
            }
            Value.save(_this.prefixes, decl);
        });
    };

    /**
     * Remove unnecessary pefixes
     */


    Processor.prototype.remove = function remove(css) {
        var _this2 = this;

        // At-rules
        var resolution = this.prefixes.remove['@resolution'];

        css.walkAtRules(function (rule, i) {
            if (_this2.prefixes.remove['@' + rule.name]) {
                if (!_this2.disabled(rule)) {
                    rule.parent.removeChild(i);
                }
            } else if (rule.name === 'media' && rule.params.indexOf('-resolution') !== -1 && resolution) {
                resolution.clean(rule);
            }
        });

        // Selectors

        var _loop = function _loop(checker) {
            css.walkRules(function (rule, i) {
                if (checker.check(rule)) {
                    if (!_this2.disabled(rule)) {
                        rule.parent.removeChild(i);
                    }
                }
            });
        };

        for (var _iterator2 = this.prefixes.remove.selectors, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
            var _ref2;

            if (_isArray2) {
                if (_i2 >= _iterator2.length) break;
                _ref2 = _iterator2[_i2++];
            } else {
                _i2 = _iterator2.next();
                if (_i2.done) break;
                _ref2 = _i2.value;
            }

            var checker = _ref2;

            _loop(checker);
        }

        return css.walkDecls(function (decl, i) {
            if (_this2.disabled(decl)) return;

            var rule = decl.parent;
            var unprefixed = _this2.prefixes.unprefixed(decl.prop);

            // Transition
            if (decl.prop === 'transition' || decl.prop === 'transition-property') {
                _this2.prefixes.transition.remove(decl);
            }

            // Properties
            if (_this2.prefixes.remove[decl.prop] && _this2.prefixes.remove[decl.prop].remove) {
                var notHack = _this2.prefixes.group(decl).down(function (other) {
                    return _this2.prefixes.normalize(other.prop) === unprefixed;
                });

                if (unprefixed === 'flex-flow') {
                    notHack = true;
                }

                if (notHack && !_this2.withHackValue(decl)) {
                    if (decl.raw('before').indexOf('\n') > -1) {
                        _this2.reduceSpaces(decl);
                    }
                    rule.removeChild(i);
                    return;
                }
            }

            // Values
            for (var _iterator3 = _this2.prefixes.values('remove', unprefixed), _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
                var _ref3;

                if (_isArray3) {
                    if (_i3 >= _iterator3.length) break;
                    _ref3 = _iterator3[_i3++];
                } else {
                    _i3 = _iterator3.next();
                    if (_i3.done) break;
                    _ref3 = _i3.value;
                }

                var checker = _ref3;

                if (checker.check(decl.value)) {
                    unprefixed = checker.unprefixed;
                    var _notHack = _this2.prefixes.group(decl).down(function (other) {
                        return other.value.indexOf(unprefixed) !== -1;
                    });

                    if (_notHack) {
                        rule.removeChild(i);
                        return;
                    } else if (checker.clean) {
                        checker.clean(decl);
                        return;
                    }
                }
            }
        });
    };

    /**
     * Some rare old values, which is not in standard
     */


    Processor.prototype.withHackValue = function withHackValue(decl) {
        return decl.prop === '-webkit-background-clip' && decl.value === 'text';
    };

    /**
     * Check for grid/flexbox options.
     */


    Processor.prototype.disabledValue = function disabledValue(node) {
        if (this.prefixes.options.grid === false && node.type === 'decl') {
            if (node.prop === 'display' && node.value.indexOf('grid') !== -1) {
                return true;
            }
        }
        if (this.prefixes.options.flexbox === false && node.type === 'decl') {
            if (node.prop === 'display' && node.value.indexOf('flex') !== -1) {
                return true;
            }
        }

        return this.disabled(node);
    };

    /**
     * Check for grid/flexbox options.
     */


    Processor.prototype.disabledDecl = function disabledDecl(node) {
        if (this.prefixes.options.grid === false && node.type === 'decl') {
            if (node.prop.indexOf('grid') !== -1 || node.prop === 'justify-items') {
                return true;
            }
        }
        if (this.prefixes.options.flexbox === false && node.type === 'decl') {
            var other = ['order', 'justify-content', 'align-items', 'align-content'];
            if (node.prop.indexOf('flex') !== -1 || other.indexOf(node.prop) !== -1) {
                return true;
            }
        }

        return this.disabled(node);
    };

    /**
     * Check for control comment and global options
     */


    Processor.prototype.disabled = function disabled(node) {
        if (node._autoprefixerDisabled !== undefined) {
            return node._autoprefixerDisabled;
        } else if (node.nodes) {
            var status = undefined;
            node.each(function (i) {
                if (i.type !== 'comment') {
                    return undefined;
                }
                if (/(!\s*)?autoprefixer:\s*off/i.test(i.text)) {
                    status = false;
                    return false;
                } else if (/(!\s*)?autoprefixer:\s*on/i.test(i.text)) {
                    status = true;
                    return false;
                }
                return undefined;
            });

            var result = false;
            if (status !== undefined) {
                result = !status;
            } else if (node.parent) {
                result = this.disabled(node.parent);
            }

            node._autoprefixerDisabled = result;
            return node._autoprefixerDisabled;
        } else if (node.parent) {
            node._autoprefixerDisabled = this.disabled(node.parent);
            return node._autoprefixerDisabled;
        } else {
            // unknown state
            return false;
        }
    };

    /**
     * Normalize spaces in cascade declaration group
     */


    Processor.prototype.reduceSpaces = function reduceSpaces(decl) {
        var stop = false;
        this.prefixes.group(decl).up(function () {
            stop = true;
            return true;
        });
        if (stop) {
            return;
        }

        var parts = decl.raw('before').split('\n');
        var prevMin = parts[parts.length - 1].length;
        var diff = false;

        this.prefixes.group(decl).down(function (other) {
            parts = other.raw('before').split('\n');
            var last = parts.length - 1;

            if (parts[last].length > prevMin) {
                if (diff === false) {
                    diff = parts[last].length - prevMin;
                }

                parts[last] = parts[last].slice(0, -diff);
                other.raws.before = parts.join('\n');
            }
        });
    };

    /**
     * Is it flebox or grid rule
     */


    Processor.prototype.displayType = function displayType(decl) {
        for (var _iterator4 = decl.parent.nodes, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) {
            var _ref4;

            if (_isArray4) {
                if (_i4 >= _iterator4.length) break;
                _ref4 = _iterator4[_i4++];
            } else {
                _i4 = _iterator4.next();
                if (_i4.done) break;
                _ref4 = _i4.value;
            }

            var i = _ref4;

            if (i.prop === 'display') {
                if (i.value.indexOf('flex') !== -1) {
                    return 'flex';
                } else if (i.value.indexOf('grid') !== -1) {
                    return 'grid';
                }
            }
        }
        return false;
    };

    return Processor;
}();

module.exports = Processor;
},{"./value":112}],107:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Prefixer = require('./prefixer');
var utils = require('./utils');

var n2f = require('num2fraction');

var regexp = /(min|max)-resolution\s*:\s*\d*\.?\d+(dppx|dpi)/gi;
var split = /(min|max)-resolution(\s*:\s*)(\d*\.?\d+)(dppx|dpi)/i;

var Resolution = function (_Prefixer) {
    _inherits(Resolution, _Prefixer);

    function Resolution() {
        _classCallCheck(this, Resolution);

        return _possibleConstructorReturn(this, _Prefixer.apply(this, arguments));
    }

    /**
     * Return prefixed query name
     */
    Resolution.prototype.prefixName = function prefixName(prefix, name) {
        var newName = prefix === '-moz-' ? name + '--moz-device-pixel-ratio' : prefix + name + '-device-pixel-ratio';
        return newName;
    };

    /**
     * Return prefixed query
     */


    Resolution.prototype.prefixQuery = function prefixQuery(prefix, name, colon, value, units) {
        if (units === 'dpi') {
            value = Number(value / 96);
        }
        if (prefix === '-o-') {
            value = n2f(value);
        }
        return this.prefixName(prefix, name) + colon + value;
    };

    /**
     * Remove prefixed queries
     */


    Resolution.prototype.clean = function clean(rule) {
        var _this2 = this;

        if (!this.bad) {
            this.bad = [];
            for (var _iterator = this.prefixes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
                var _ref;

                if (_isArray) {
                    if (_i >= _iterator.length) break;
                    _ref = _iterator[_i++];
                } else {
                    _i = _iterator.next();
                    if (_i.done) break;
                    _ref = _i.value;
                }

                var prefix = _ref;

                this.bad.push(this.prefixName(prefix, 'min'));
                this.bad.push(this.prefixName(prefix, 'max'));
            }
        }

        rule.params = utils.editList(rule.params, function (queries) {
            return queries.filter(function (query) {
                return _this2.bad.every(function (i) {
                    return query.indexOf(i) === -1;
                });
            });
        });
    };

    /**
     * Add prefixed queries
     */


    Resolution.prototype.process = function process(rule) {
        var _this3 = this;

        var parent = this.parentPrefix(rule);
        var prefixes = parent ? [parent] : this.prefixes;

        rule.params = utils.editList(rule.params, function (origin, prefixed) {
            for (var _iterator2 = origin, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
                var _ref2;

                if (_isArray2) {
                    if (_i2 >= _iterator2.length) break;
                    _ref2 = _iterator2[_i2++];
                } else {
                    _i2 = _iterator2.next();
                    if (_i2.done) break;
                    _ref2 = _i2.value;
                }

                var query = _ref2;

                if (query.indexOf('min-resolution') === -1 && query.indexOf('max-resolution') === -1) {
                    prefixed.push(query);
                    continue;
                }

                var _loop = function _loop(prefix) {
                    if (prefix === '-moz-' && rule.params.indexOf('dpi') !== -1) {
                        return 'continue';
                    } else {
                        var processed = query.replace(regexp, function (str) {
                            var parts = str.match(split);
                            return _this3.prefixQuery(prefix, parts[1], parts[2], parts[3], parts[4]);
                        });
                        prefixed.push(processed);
                    }
                };

                for (var _iterator3 = prefixes, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
                    var _ref3;

                    if (_isArray3) {
                        if (_i3 >= _iterator3.length) break;
                        _ref3 = _iterator3[_i3++];
                    } else {
                        _i3 = _iterator3.next();
                        if (_i3.done) break;
                        _ref3 = _i3.value;
                    }

                    var prefix = _ref3;

                    var _ret = _loop(prefix);

                    if (_ret === 'continue') continue;
                }
                prefixed.push(query);
            }

            return utils.uniq(prefixed);
        });
    };

    return Resolution;
}(Prefixer);

module.exports = Resolution;
},{"./prefixer":104,"./utils":111,"num2fraction":710}],108:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var OldSelector = require('./old-selector');
var Prefixer = require('./prefixer');
var Browsers = require('./browsers');
var utils = require('./utils');

var Selector = function (_Prefixer) {
    _inherits(Selector, _Prefixer);

    function Selector(name, prefixes, all) {
        _classCallCheck(this, Selector);

        var _this = _possibleConstructorReturn(this, _Prefixer.call(this, name, prefixes, all));

        _this.regexpCache = {};
        return _this;
    }

    /**
     * Is rule selectors need to be prefixed
     */


    Selector.prototype.check = function check(rule) {
        if (rule.selector.indexOf(this.name) !== -1) {
            return !!rule.selector.match(this.regexp());
        } else {
            return false;
        }
    };

    /**
     * Return prefixed version of selector
     */


    Selector.prototype.prefixed = function prefixed(prefix) {
        return this.name.replace(/^([^\w]*)/, '$1' + prefix);
    };

    /**
     * Lazy loadRegExp for name
     */


    Selector.prototype.regexp = function regexp(prefix) {
        if (this.regexpCache[prefix]) {
            return this.regexpCache[prefix];
        }

        var name = prefix ? this.prefixed(prefix) : this.name;
        this.regexpCache[prefix] = new RegExp('(^|[^:"\'=])' + utils.escapeRegexp(name), 'gi');
        return this.regexpCache[prefix];
    };

    /**
     * All possible prefixes
     */


    Selector.prototype.possible = function possible() {
        return Browsers.prefixes();
    };

    /**
     * Return all possible selector prefixes
     */


    Selector.prototype.prefixeds = function prefixeds(rule) {
        if (rule._autoprefixerPrefixeds) {
            return rule._autoprefixerPrefixeds;
        }

        var prefixeds = {};
        for (var _iterator = this.possible(), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
            var _ref;

            if (_isArray) {
                if (_i >= _iterator.length) break;
                _ref = _iterator[_i++];
            } else {
                _i = _iterator.next();
                if (_i.done) break;
                _ref = _i.value;
            }

            var prefix = _ref;

            prefixeds[prefix] = this.replace(rule.selector, prefix);
        }

        rule._autoprefixerPrefixeds = prefixeds;
        return rule._autoprefixerPrefixeds;
    };

    /**
     * Is rule already prefixed before
     */


    Selector.prototype.already = function already(rule, prefixeds, prefix) {
        var index = rule.parent.index(rule) - 1;

        while (index >= 0) {
            var before = rule.parent.nodes[index];

            if (before.type !== 'rule') {
                return false;
            }

            var some = false;
            for (var key in prefixeds) {
                var prefixed = prefixeds[key];
                if (before.selector === prefixed) {
                    if (prefix === key) {
                        return true;
                    } else {
                        some = true;
                        break;
                    }
                }
            }
            if (!some) {
                return false;
            }

            index -= 1;
        }

        return false;
    };

    /**
     * Replace selectors by prefixed one
     */


    Selector.prototype.replace = function replace(selector, prefix) {
        return selector.replace(this.regexp(), '$1' + this.prefixed(prefix));
    };

    /**
     * Clone and add prefixes for at-rule
     */


    Selector.prototype.add = function add(rule, prefix) {
        var prefixeds = this.prefixeds(rule);

        if (this.already(rule, prefixeds, prefix)) {
            return;
        }

        var cloned = this.clone(rule, { selector: prefixeds[prefix] });
        rule.parent.insertBefore(rule, cloned);
    };

    /**
     * Return function to fast find prefixed selector
     */


    Selector.prototype.old = function old(prefix) {
        return new OldSelector(this, prefix);
    };

    return Selector;
}(Prefixer);

module.exports = Selector;
},{"./browsers":56,"./old-selector":102,"./prefixer":104,"./utils":111}],109:[function(require,module,exports){
'use strict';

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Browsers = require('./browsers');
var brackets = require('./brackets');
var Value = require('./value');
var utils = require('./utils');

var postcss = require('postcss');

var supported = [];
var data = require('caniuse-lite').feature(require('caniuse-lite/data/features/css-featurequeries.js'));
for (var browser in data.stats) {
    var versions = data.stats[browser];
    for (var version in versions) {
        var support = versions[version];
        if (/y/.test(support)) {
            supported.push(browser + ' ' + version);
        }
    }
}

var Supports = function () {
    function Supports(Prefixes, all) {
        _classCallCheck(this, Supports);

        this.Prefixes = Prefixes;
        this.all = all;
    }

    /**
     * Return prefixer only with @supports supported browsers
     */


    Supports.prototype.prefixer = function prefixer() {
        if (this.prefixerCache) {
            return this.prefixerCache;
        }

        var filtered = this.all.browsers.selected.filter(function (i) {
            return supported.indexOf(i) !== -1;
        });

        var browsers = new Browsers(this.all.browsers.data, filtered, this.all.options);
        this.prefixerCache = new this.Prefixes(this.all.data, browsers, this.all.options);
        return this.prefixerCache;
    };

    /**
     * Parse string into declaration property and value
     */


    Supports.prototype.parse = function parse(str) {
        var _str$split = str.split(':'),
            prop = _str$split[0],
            value = _str$split[1];

        if (!value) value = '';
        return [prop.trim(), value.trim()];
    };

    /**
     * Create virtual rule to process it by prefixer
     */


    Supports.prototype.virtual = function virtual(str) {
        var _parse = this.parse(str),
            prop = _parse[0],
            value = _parse[1];

        var rule = postcss.parse('a{}').first;
        rule.append({ prop: prop, value: value, raws: { before: '' } });
        return rule;
    };

    /**
     * Return array of Declaration with all necessary prefixes
     */


    Supports.prototype.prefixed = function prefixed(str) {
        var rule = this.virtual(str);
        if (this.disabled(rule.first)) {
            return rule.nodes;
        }

        var prefixer = this.prefixer().add[rule.first.prop];
        prefixer && prefixer.process && prefixer.process(rule.first);

        for (var _iterator = rule.nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
            var _ref;

            if (_isArray) {
                if (_i >= _iterator.length) break;
                _ref = _iterator[_i++];
            } else {
                _i = _iterator.next();
                if (_i.done) break;
                _ref = _i.value;
            }

            var decl = _ref;

            for (var _iterator2 = this.prefixer().values('add', rule.first.prop), _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
                var _ref2;

                if (_isArray2) {
                    if (_i2 >= _iterator2.length) break;
                    _ref2 = _iterator2[_i2++];
                } else {
                    _i2 = _iterator2.next();
                    if (_i2.done) break;
                    _ref2 = _i2.value;
                }

                var value = _ref2;

                value.process(decl);
            }
            Value.save(this.all, decl);
        }

        return rule.nodes;
    };

    /**
     * Return true if brackets node is "not" word
     */


    Supports.prototype.isNot = function isNot(node) {
        return typeof node === 'string' && /not\s*/i.test(node);
    };

    /**
     * Return true if brackets node is "or" word
     */


    Supports.prototype.isOr = function isOr(node) {
        return typeof node === 'string' && /\s*or\s*/i.test(node);
    };

    /**
     * Return true if brackets node is (prop: value)
     */


    Supports.prototype.isProp = function isProp(node) {
        return (typeof node === 'undefined' ? 'undefined' : _typeof(node)) === 'object' && node.length === 1 && typeof node[0] === 'string';
    };

    /**
     * Return true if prefixed property has no unprefixed
     */


    Supports.prototype.isHack = function isHack(all, unprefixed) {
        var check = new RegExp('(\\(|\\s)' + utils.escapeRegexp(unprefixed) + ':');
        return !check.test(all);
    };

    /**
     * Return true if we need to remove node
     */


    Supports.prototype.toRemove = function toRemove(str, all) {
        var _parse2 = this.parse(str),
            prop = _parse2[0],
            value = _parse2[1];

        var unprefixed = this.all.unprefixed(prop);

        var cleaner = this.all.cleaner();

        if (cleaner.remove[prop] && cleaner.remove[prop].remove && !this.isHack(all, unprefixed)) {
            return true;
        }

        for (var _iterator3 = cleaner.values('remove', unprefixed), _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
            var _ref3;

            if (_isArray3) {
                if (_i3 >= _iterator3.length) break;
                _ref3 = _iterator3[_i3++];
            } else {
                _i3 = _iterator3.next();
                if (_i3.done) break;
                _ref3 = _i3.value;
            }

            var checker = _ref3;

            if (checker.check(value)) {
                return true;
            }
        }

        return false;
    };

    /**
     * Remove all unnecessary prefixes
     */


    Supports.prototype.remove = function remove(nodes, all) {
        var i = 0;
        while (i < nodes.length) {
            if (!this.isNot(nodes[i - 1]) && this.isProp(nodes[i]) && this.isOr(nodes[i + 1])) {
                if (this.toRemove(nodes[i][0], all)) {
                    nodes.splice(i, 2);
                } else {
                    i += 2;
                }
            } else {
                if (_typeof(nodes[i]) === 'object') {
                    nodes[i] = this.remove(nodes[i], all);
                }
                i += 1;
            }
        }
        return nodes;
    };

    /**
     * Clean brackets with one child
     */


    Supports.prototype.cleanBrackets = function cleanBrackets(nodes) {
        var _this = this;

        return nodes.map(function (i) {
            if ((typeof i === 'undefined' ? 'undefined' : _typeof(i)) === 'object') {
                if (i.length === 1 && _typeof(i[0]) === 'object') {
                    return _this.cleanBrackets(i[0]);
                } else {
                    return _this.cleanBrackets(i);
                }
            } else {
                return i;
            }
        });
    };

    /**
     * Add " or " between properties and convert it to brackets format
     */


    Supports.prototype.convert = function convert(progress) {
        var result = [''];
        for (var _iterator4 = progress, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) {
            var _ref4;

            if (_isArray4) {
                if (_i4 >= _iterator4.length) break;
                _ref4 = _iterator4[_i4++];
            } else {
                _i4 = _iterator4.next();
                if (_i4.done) break;
                _ref4 = _i4.value;
            }

            var i = _ref4;

            result.push([i.prop + ': ' + i.value]);
            result.push(' or ');
        }
        result[result.length - 1] = '';
        return result;
    };

    /**
     * Compress value functions into a string nodes
     */


    Supports.prototype.normalize = function normalize(nodes) {
        var _this2 = this;

        if ((typeof nodes === 'undefined' ? 'undefined' : _typeof(nodes)) === 'object') {
            nodes = nodes.filter(function (i) {
                return i !== '';
            });
            if (typeof nodes[0] === 'string' && nodes[0].indexOf(':') !== -1) {
                return [brackets.stringify(nodes)];
            } else {
                return nodes.map(function (i) {
                    return _this2.normalize(i);
                });
            }
        } else {
            return nodes;
        }
    };

    /**
     * Add prefixes
     */


    Supports.prototype.add = function add(nodes, all) {
        var _this3 = this;

        return nodes.map(function (i) {
            if (_this3.isProp(i)) {
                var prefixed = _this3.prefixed(i[0]);
                if (prefixed.length > 1) {
                    return _this3.convert(prefixed);
                } else {
                    return i;
                }
            } else if ((typeof i === 'undefined' ? 'undefined' : _typeof(i)) === 'object') {
                return _this3.add(i, all);
            } else {
                return i;
            }
        });
    };

    /**
     * Add prefixed declaration
     */


    Supports.prototype.process = function process(rule) {
        var ast = brackets.parse(rule.params);
        ast = this.normalize(ast);
        ast = this.remove(ast, rule.params);
        ast = this.add(ast, rule.params);
        ast = this.cleanBrackets(ast);
        rule.params = brackets.stringify(ast);
    };

    /**
     * Check global options
     */


    Supports.prototype.disabled = function disabled(node) {
        if (this.all.options.grid === false) {
            if (node.prop === 'display' && node.value.indexOf('grid') !== -1) {
                return true;
            }
            if (node.prop.indexOf('grid') !== -1 || node.prop === 'justify-items') {
                return true;
            }
        }

        if (this.all.options.flexbox === false) {
            if (node.prop === 'display' && node.value.indexOf('flex') !== -1) {
                return true;
            }
            var other = ['order', 'justify-content', 'align-items', 'align-content'];
            if (node.prop.indexOf('flex') !== -1 || other.indexOf(node.prop) !== -1) {
                return true;
            }
        }

        return false;
    };

    return Supports;
}();

module.exports = Supports;
},{"./brackets":55,"./browsers":56,"./utils":111,"./value":112,"caniuse-lite":578,"caniuse-lite/data/features/css-featurequeries.js":197,"postcss":828}],110:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var parser = require('postcss-value-parser');
var vendor = require('postcss/lib/vendor');
var list = require('postcss/lib/list');

var Transition = function () {
    function Transition(prefixes) {
        _classCallCheck(this, Transition);

        Object.defineProperty(this, 'props', {
            enumerable: true,
            writable: true,
            value: ['transition', 'transition-property']
        });

        this.prefixes = prefixes;
    }

    /**
     * Process transition and add prefies for all necessary properties
     */


    Transition.prototype.add = function add(decl, result) {
        var _this = this;

        var prefix = void 0,
            prop = void 0;
        var declPrefixes = this.prefixes.add[decl.prop] && this.prefixes.add[decl.prop].prefixes || [];

        var params = this.parse(decl.value);
        var names = params.map(function (i) {
            return _this.findProp(i);
        });
        var added = [];

        if (names.some(function (i) {
            return i[0] === '-';
        })) {
            return;
        }

        for (var _iterator = params, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
            var _ref;

            if (_isArray) {
                if (_i >= _iterator.length) break;
                _ref = _iterator[_i++];
            } else {
                _i = _iterator.next();
                if (_i.done) break;
                _ref = _i.value;
            }

            var param = _ref;

            prop = this.findProp(param);
            if (prop[0] === '-') {
                continue;
            }
            var prefixer = this.prefixes.add[prop];
            if (!prefixer || !prefixer.prefixes) {
                continue;
            }

            for (var _iterator3 = prefixer.prefixes, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
                if (_isArray3) {
                    if (_i3 >= _iterator3.length) break;
                    prefix = _iterator3[_i3++];
                } else {
                    _i3 = _iterator3.next();
                    if (_i3.done) break;
                    prefix = _i3.value;
                }

                var prefixed = this.prefixes.prefixed(prop, prefix);
                if (prefixed !== '-ms-transform' && names.indexOf(prefixed) === -1) {
                    if (!this.disabled(prop, prefix)) {
                        added.push(this.clone(prop, prefixed, param));
                    }
                }
            }
        }

        params = params.concat(added);
        var value = this.stringify(params);

        var webkitClean = this.stringify(this.cleanFromUnprefixed(params, '-webkit-'));
        if (declPrefixes.indexOf('-webkit-') !== -1) {
            this.cloneBefore(decl, '-webkit-' + decl.prop, webkitClean);
        }
        this.cloneBefore(decl, decl.prop, webkitClean);
        if (declPrefixes.indexOf('-o-') !== -1) {
            var operaClean = this.stringify(this.cleanFromUnprefixed(params, '-o-'));
            this.cloneBefore(decl, '-o-' + decl.prop, operaClean);
        }

        for (var _iterator2 = declPrefixes, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
            if (_isArray2) {
                if (_i2 >= _iterator2.length) break;
                prefix = _iterator2[_i2++];
            } else {
                _i2 = _iterator2.next();
                if (_i2.done) break;
                prefix = _i2.value;
            }

            if (prefix !== '-webkit-' && prefix !== '-o-') {
                var prefixValue = this.stringify(this.cleanOtherPrefixes(params, prefix));
                this.cloneBefore(decl, prefix + decl.prop, prefixValue);
            }
        }

        if (value !== decl.value && !this.already(decl, decl.prop, value)) {
            this.checkForWarning(result, decl);
            decl.cloneBefore();
            decl.value = value;
        }
    };

    /**
     * Find property name
     */


    Transition.prototype.findProp = function findProp(param) {
        var prop = param[0].value;
        if (/^\d/.test(prop)) {
            for (var i = 0; i < param.length; i++) {
                var token = param[i];
                if (i !== 0 && token.type === 'word') {
                    return token.value;
                }
            }
        }
        return prop;
    };

    /**
     * Does we aready have this declaration
     */


    Transition.prototype.already = function already(decl, prop, value) {
        return decl.parent.some(function (i) {
            return i.prop === prop && i.value === value;
        });
    };

    /**
     * Add declaration if it is not exist
     */


    Transition.prototype.cloneBefore = function cloneBefore(decl, prop, value) {
        if (!this.already(decl, prop, value)) {
            decl.cloneBefore({ prop: prop, value: value });
        }
    };

    /**
     * Show transition-property warning
     */


    Transition.prototype.checkForWarning = function checkForWarning(result, decl) {
        if (decl.prop === 'transition-property') {
            decl.parent.each(function (i) {
                if (i.type !== 'decl') {
                    return undefined;
                }
                if (i.prop.indexOf('transition-') !== 0) {
                    return undefined;
                }
                if (i.prop === 'transition-property') {
                    return undefined;
                }

                if (list.comma(i.value).length > 1) {
                    decl.warn(result, 'Replace transition-property to transition, ' + 'because Autoprefixer could not support ' + 'any cases of transition-property ' + 'and other transition-*');
                }
                return false;
            });
        }
    };

    /**
     * Process transition and remove all unnecessary properties
     */


    Transition.prototype.remove = function remove(decl) {
        var _this2 = this;

        var params = this.parse(decl.value);
        params = params.filter(function (i) {
            var prop = _this2.prefixes.remove[_this2.findProp(i)];
            return !prop || !prop.remove;
        });
        var value = this.stringify(params);

        if (decl.value === value) {
            return;
        }

        if (params.length === 0) {
            decl.remove();
            return;
        }

        var double = decl.parent.some(function (i) {
            return i.prop === decl.prop && i.value === value;
        });
        var smaller = decl.parent.some(function (i) {
            return i !== decl && i.prop === decl.prop && i.value.length > value.length;
        });

        if (double || smaller) {
            decl.remove();
        } else {
            decl.value = value;
        }
    };

    /**
     * Parse properties list to array
     */


    Transition.prototype.parse = function parse(value) {
        var ast = parser(value);
        var result = [];
        var param = [];
        for (var _iterator4 = ast.nodes, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) {
            var _ref2;

            if (_isArray4) {
                if (_i4 >= _iterator4.length) break;
                _ref2 = _iterator4[_i4++];
            } else {
                _i4 = _iterator4.next();
                if (_i4.done) break;
                _ref2 = _i4.value;
            }

            var node = _ref2;

            param.push(node);
            if (node.type === 'div' && node.value === ',') {
                result.push(param);
                param = [];
            }
        }
        result.push(param);
        return result.filter(function (i) {
            return i.length > 0;
        });
    };

    /**
     * Return properties string from array
     */


    Transition.prototype.stringify = function stringify(params) {
        if (params.length === 0) {
            return '';
        }
        var nodes = [];
        for (var _iterator5 = params, _isArray5 = Array.isArray(_iterator5), _i5 = 0, _iterator5 = _isArray5 ? _iterator5 : _iterator5[Symbol.iterator]();;) {
            var _ref3;

            if (_isArray5) {
                if (_i5 >= _iterator5.length) break;
                _ref3 = _iterator5[_i5++];
            } else {
                _i5 = _iterator5.next();
                if (_i5.done) break;
                _ref3 = _i5.value;
            }

            var param = _ref3;

            if (param[param.length - 1].type !== 'div') {
                param.push(this.div(params));
            }
            nodes = nodes.concat(param);
        }
        if (nodes[0].type === 'div') {
            nodes = nodes.slice(1);
        }
        if (nodes[nodes.length - 1].type === 'div') {
            nodes = nodes.slice(0, +-2 + 1 || undefined);
        }
        return parser.stringify({ nodes: nodes });
    };

    /**
     * Return new param array with different name
     */


    Transition.prototype.clone = function clone(origin, name, param) {
        var result = [];
        var changed = false;
        for (var _iterator6 = param, _isArray6 = Array.isArray(_iterator6), _i6 = 0, _iterator6 = _isArray6 ? _iterator6 : _iterator6[Symbol.iterator]();;) {
            var _ref4;

            if (_isArray6) {
                if (_i6 >= _iterator6.length) break;
                _ref4 = _iterator6[_i6++];
            } else {
                _i6 = _iterator6.next();
                if (_i6.done) break;
                _ref4 = _i6.value;
            }

            var i = _ref4;

            if (!changed && i.type === 'word' && i.value === origin) {
                result.push({ type: 'word', value: name });
                changed = true;
            } else {
                result.push(i);
            }
        }
        return result;
    };

    /**
     * Find or create seperator
     */


    Transition.prototype.div = function div(params) {
        for (var _iterator7 = params, _isArray7 = Array.isArray(_iterator7), _i7 = 0, _iterator7 = _isArray7 ? _iterator7 : _iterator7[Symbol.iterator]();;) {
            var _ref5;

            if (_isArray7) {
                if (_i7 >= _iterator7.length) break;
                _ref5 = _iterator7[_i7++];
            } else {
                _i7 = _iterator7.next();
                if (_i7.done) break;
                _ref5 = _i7.value;
            }

            var param = _ref5;

            for (var _iterator8 = param, _isArray8 = Array.isArray(_iterator8), _i8 = 0, _iterator8 = _isArray8 ? _iterator8 : _iterator8[Symbol.iterator]();;) {
                var _ref6;

                if (_isArray8) {
                    if (_i8 >= _iterator8.length) break;
                    _ref6 = _iterator8[_i8++];
                } else {
                    _i8 = _iterator8.next();
                    if (_i8.done) break;
                    _ref6 = _i8.value;
                }

                var node = _ref6;

                if (node.type === 'div' && node.value === ',') {
                    return node;
                }
            }
        }
        return { type: 'div', value: ',', after: ' ' };
    };

    Transition.prototype.cleanOtherPrefixes = function cleanOtherPrefixes(params, prefix) {
        var _this3 = this;

        return params.filter(function (param) {
            var current = vendor.prefix(_this3.findProp(param));
            return current === '' || current === prefix;
        });
    };

    /**
     * Remove all non-webkit prefixes and unprefixed params if we have prefixed
     */


    Transition.prototype.cleanFromUnprefixed = function cleanFromUnprefixed(params, prefix) {
        var _this4 = this;

        var remove = params.map(function (i) {
            return _this4.findProp(i);
        }).filter(function (i) {
            return i.slice(0, prefix.length) === prefix;
        }).map(function (i) {
            return _this4.prefixes.unprefixed(i);
        });

        var result = [];
        for (var _iterator9 = params, _isArray9 = Array.isArray(_iterator9), _i9 = 0, _iterator9 = _isArray9 ? _iterator9 : _iterator9[Symbol.iterator]();;) {
            var _ref7;

            if (_isArray9) {
                if (_i9 >= _iterator9.length) break;
                _ref7 = _iterator9[_i9++];
            } else {
                _i9 = _iterator9.next();
                if (_i9.done) break;
                _ref7 = _i9.value;
            }

            var param = _ref7;

            var prop = this.findProp(param);
            var p = vendor.prefix(prop);
            if (remove.indexOf(prop) === -1 && (p === prefix || p === '')) {
                result.push(param);
            }
        }
        return result;
    };

    /**
     * Check property for disabled by option
     */


    Transition.prototype.disabled = function disabled(prop, prefix) {
        var other = ['order', 'justify-content', 'align-self', 'align-content'];
        if (prop.indexOf('flex') !== -1 || other.indexOf(prop) !== -1) {
            if (this.prefixes.options.flexbox === false) {
                return true;
            } else if (this.prefixes.options.flexbox === 'no-2009') {
                return prefix.indexOf('2009') !== -1;
            }
        }
        return undefined;
    };

    return Transition;
}();

module.exports = Transition;
},{"postcss-value-parser":811,"postcss/lib/list":823,"postcss/lib/vendor":838}],111:[function(require,module,exports){
'use strict';

var list = require('postcss/lib/list');

module.exports = {

    /**
     * Throw special error, to tell beniary,
     * that this error is from Autoprefixer.
     */
    error: function error(text) {
        var err = new Error(text);
        err.autoprefixer = true;
        throw err;
    },


    /**
     * Return array, that doesn’t contain duplicates.
     */
    uniq: function uniq(array) {
        var filtered = [];
        for (var _iterator = array, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
            var _ref;

            if (_isArray) {
                if (_i >= _iterator.length) break;
                _ref = _iterator[_i++];
            } else {
                _i = _iterator.next();
                if (_i.done) break;
                _ref = _i.value;
            }

            var i = _ref;

            if (filtered.indexOf(i) === -1) {
                filtered.push(i);
            }
        }
        return filtered;
    },


    /**
     * Return "-webkit-" on "-webkit- old"
     */
    removeNote: function removeNote(string) {
        if (string.indexOf(' ') === -1) {
            return string;
        } else {
            return string.split(' ')[0];
        }
    },


    /**
     * Escape RegExp symbols
     */
    escapeRegexp: function escapeRegexp(string) {
        return string.replace(/[.?*+\^\$\[\]\\(){}|\-]/g, '\\$&');
    },


    /**
     * Return regexp to check, that CSS string contain word
     */
    regexp: function regexp(word) {
        var escape = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;

        if (escape) {
            word = this.escapeRegexp(word);
        }
        return new RegExp('(^|[\\s,(])(' + word + '($|[\\s(,]))', 'gi');
    },


    /**
     * Change comma list
     */
    editList: function editList(value, callback) {
        var origin = list.comma(value);
        var changed = callback(origin, []);

        if (origin === changed) {
            return value;
        } else {
            var join = value.match(/,\s*/);
            join = join ? join[0] : ', ';
            return changed.join(join);
        }
    }
};
},{"postcss/lib/list":823}],112:[function(require,module,exports){
'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Prefixer = require('./prefixer');
var OldValue = require('./old-value');
var utils = require('./utils');

var vendor = require('postcss/lib/vendor');

var Value = function (_Prefixer) {
    _inherits(Value, _Prefixer);

    function Value() {
        _classCallCheck(this, Value);

        return _possibleConstructorReturn(this, _Prefixer.apply(this, arguments));
    }

    /**
     * Clone decl for each prefixed values
     */
    Value.save = function save(prefixes, decl) {
        var _this2 = this;

        var prop = decl.prop;
        var result = [];

        for (var prefix in decl._autoprefixerValues) {
            var value = decl._autoprefixerValues[prefix];

            if (value === decl.value) {
                continue;
            }

            var item = void 0;
            var propPrefix = vendor.prefix(prop);

            if (propPrefix === prefix) {
                item = decl.value = value;
            } else if (propPrefix === '-pie-') {
                continue;
            } else {
                (function () {
                    var prefixed = prefixes.prefixed(prop, prefix);
                    var rule = decl.parent;
                    if (rule.every(function (i) {
                        return i.prop !== prefixed;
                    })) {
                        var trimmed = value.replace(/\s+/, ' ');
                        var already = rule.some(function (i) {
                            return i.prop === decl.prop && i.value.replace(/\s+/, ' ') === trimmed;
                        });

                        if (!already) {
                            var cloned = _this2.clone(decl, { value: value });
                            item = decl.parent.insertBefore(decl, cloned);
                        }
                    }
                })();
            }

            result.push(item);
        }

        return result;
    };

    /**
     * Is declaration need to be prefixed
     */


    Value.prototype.check = function check(decl) {
        var value = decl.value;
        if (value.indexOf(this.name) !== -1) {
            return !!value.match(this.regexp());
        } else {
            return false;
        }
    };

    /**
     * Lazy regexp loading
     */


    Value.prototype.regexp = function regexp() {
        return this.regexpCache || (this.regexpCache = utils.regexp(this.name));
    };

    /**
     * Add prefix to values in string
     */


    Value.prototype.replace = function replace(string, prefix) {
        return string.replace(this.regexp(), '$1' + prefix + '$2');
    };

    /**
     * Get value with comments if it was not changed
     */


    Value.prototype.value = function value(decl) {
        if (decl.raws.value && decl.raws.value.value === decl.value) {
            return decl.raws.value.raw;
        } else {
            return decl.value;
        }
    };

    /**
     * Save values with next prefixed token
     */


    Value.prototype.add = function add(decl, prefix) {
        if (!decl._autoprefixerValues) {
            decl._autoprefixerValues = {};
        }
        var value = decl._autoprefixerValues[prefix] || this.value(decl);
        value = this.replace(value, prefix);
        if (value) {
            decl._autoprefixerValues[prefix] = value;
        }
    };

    /**
     * Return function to fast find prefixed value
     */


    Value.prototype.old = function old(prefix) {
        return new OldValue(this.name, prefix + this.name);
    };

    return Value;
}(Prefixer);

module.exports = Value;
},{"./old-value":103,"./prefixer":104,"./utils":111,"postcss/lib/vendor":838}],113:[function(require,module,exports){
'use strict';
module.exports = balanced;
function balanced(a, b, str) {
  if (a instanceof RegExp) a = maybeMatch(a, str);
  if (b instanceof RegExp) b = maybeMatch(b, str);

  var r = range(a, b, str);

  return r && {
    start: r[0],
    end: r[1],
    pre: str.slice(0, r[0]),
    body: str.slice(r[0] + a.length, r[1]),
    post: str.slice(r[1] + b.length)
  };
}

function maybeMatch(reg, str) {
  var m = str.match(reg);
  return m ? m[0] : null;
}

balanced.range = range;
function range(a, b, str) {
  var begs, beg, left, right, result;
  var ai = str.indexOf(a);
  var bi = str.indexOf(b, ai + 1);
  var i = ai;

  if (ai >= 0 && bi > 0) {
    begs = [];
    left = str.length;

    while (i >= 0 && !result) {
      if (i == ai) {
        begs.push(i);
        ai = str.indexOf(a, i + 1);
      } else if (begs.length == 1) {
        result = [ begs.pop(), bi ];
      } else {
        beg = begs.pop();
        if (beg < left) {
          left = beg;
          right = bi;
        }

        bi = str.indexOf(b, i + 1);
      }

      i = ai < bi && ai >= 0 ? ai : bi;
    }

    if (begs.length) {
      result = [ left, right ];
    }
  }

  return result;
}

},{}],114:[function(require,module,exports){
var concatMap = require('concat-map');
var balanced = require('balanced-match');

module.exports = expandTop;

var escSlash = '\0SLASH'+Math.random()+'\0';
var escOpen = '\0OPEN'+Math.random()+'\0';
var escClose = '\0CLOSE'+Math.random()+'\0';
var escComma = '\0COMMA'+Math.random()+'\0';
var escPeriod = '\0PERIOD'+Math.random()+'\0';

function numeric(str) {
  return parseInt(str, 10) == str
    ? parseInt(str, 10)
    : str.charCodeAt(0);
}

function escapeBraces(str) {
  return str.split('\\\\').join(escSlash)
            .split('\\{').join(escOpen)
            .split('\\}').join(escClose)
            .split('\\,').join(escComma)
            .split('\\.').join(escPeriod);
}

function unescapeBraces(str) {
  return str.split(escSlash).join('\\')
            .split(escOpen).join('{')
            .split(escClose).join('}')
            .split(escComma).join(',')
            .split(escPeriod).join('.');
}


// Basically just str.split(","), but handling cases
// where we have nested braced sections, which should be
// treated as individual members, like {a,{b,c},d}
function parseCommaParts(str) {
  if (!str)
    return [''];

  var parts = [];
  var m = balanced('{', '}', str);

  if (!m)
    return str.split(',');

  var pre = m.pre;
  var body = m.body;
  var post = m.post;
  var p = pre.split(',');

  p[p.length-1] += '{' + body + '}';
  var postParts = parseCommaParts(post);
  if (post.length) {
    p[p.length-1] += postParts.shift();
    p.push.apply(p, postParts);
  }

  parts.push.apply(parts, p);

  return parts;
}

function expandTop(str) {
  if (!str)
    return [];

  // I don't know why Bash 4.3 does this, but it does.
  // Anything starting with {} will have the first two bytes preserved
  // but *only* at the top level, so {},a}b will not expand to anything,
  // but a{},b}c will be expanded to [a}c,abc].
  // One could argue that this is a bug in Bash, but since the goal of
  // this module is to match Bash's rules, we escape a leading {}
  if (str.substr(0, 2) === '{}') {
    str = '\\{\\}' + str.substr(2);
  }

  return expand(escapeBraces(str), true).map(unescapeBraces);
}

function identity(e) {
  return e;
}

function embrace(str) {
  return '{' + str + '}';
}
function isPadded(el) {
  return /^-?0\d/.test(el);
}

function lte(i, y) {
  return i <= y;
}
function gte(i, y) {
  return i >= y;
}

function expand(str, isTop) {
  var expansions = [];

  var m = balanced('{', '}', str);
  if (!m || /\$$/.test(m.pre)) return [str];

  var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
  var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
  var isSequence = isNumericSequence || isAlphaSequence;
  var isOptions = m.body.indexOf(',') >= 0;
  if (!isSequence && !isOptions) {
    // {a},b}
    if (m.post.match(/,.*\}/)) {
      str = m.pre + '{' + m.body + escClose + m.post;
      return expand(str);
    }
    return [str];
  }

  var n;
  if (isSequence) {
    n = m.body.split(/\.\./);
  } else {
    n = parseCommaParts(m.body);
    if (n.length === 1) {
      // x{{a,b}}y ==> x{a}y x{b}y
      n = expand(n[0], false).map(embrace);
      if (n.length === 1) {
        var post = m.post.length
          ? expand(m.post, false)
          : [''];
        return post.map(function(p) {
          return m.pre + n[0] + p;
        });
      }
    }
  }

  // at this point, n is the parts, and we know it's not a comma set
  // with a single entry.

  // no need to expand pre, since it is guaranteed to be free of brace-sets
  var pre = m.pre;
  var post = m.post.length
    ? expand(m.post, false)
    : [''];

  var N;

  if (isSequence) {
    var x = numeric(n[0]);
    var y = numeric(n[1]);
    var width = Math.max(n[0].length, n[1].length)
    var incr = n.length == 3
      ? Math.abs(numeric(n[2]))
      : 1;
    var test = lte;
    var reverse = y < x;
    if (reverse) {
      incr *= -1;
      test = gte;
    }
    var pad = n.some(isPadded);

    N = [];

    for (var i = x; test(i, y); i += incr) {
      var c;
      if (isAlphaSequence) {
        c = String.fromCharCode(i);
        if (c === '\\')
          c = '';
      } else {
        c = String(i);
        if (pad) {
          var need = width - c.length;
          if (need > 0) {
            var z = new Array(need + 1).join('0');
            if (i < 0)
              c = '-' + z + c.slice(1);
            else
              c = z + c;
          }
        }
      }
      N.push(c);
    }
  } else {
    N = concatMap(n, function(el) { return expand(el, false) });
  }

  for (var j = 0; j < N.length; j++) {
    for (var k = 0; k < post.length; k++) {
      var expansion = pre + N[j] + post[k];
      if (!isTop || isSequence || expansion)
        expansions.push(expansion);
    }
  }

  return expansions;
}


},{"balanced-match":113,"concat-map":588}],115:[function(require,module,exports){
/*!
 * braces <https://github.com/jonschlinkert/braces>
 *
 * Copyright (c) 2014-2015, Jon Schlinkert.
 * Licensed under the MIT license.
 */

'use strict';

/**
 * Module dependencies
 */

var expand = require('expand-range');
var repeat = require('repeat-element');
var tokens = require('preserve');

/**
 * Expose `braces`
 */

module.exports = function(str, options) {
  if (typeof str !== 'string') {
    throw new Error('braces expects a string');
  }
  return braces(str, options);
};

/**
 * Expand `{foo,bar}` or `{1..5}` braces in the
 * given `string`.
 *
 * @param  {String} `str`
 * @param  {Array} `arr`
 * @param  {Object} `options`
 * @return {Array}
 */

function braces(str, arr, options) {
  if (str === '') {
    return [];
  }

  if (!Array.isArray(arr)) {
    options = arr;
    arr = [];
  }

  var opts = options || {};
  arr = arr || [];

  if (typeof opts.nodupes === 'undefined') {
    opts.nodupes = true;
  }

  var fn = opts.fn;
  var es6;

  if (typeof opts === 'function') {
    fn = opts;
    opts = {};
  }

  if (!(patternRe instanceof RegExp)) {
    patternRe = patternRegex();
  }

  var matches = str.match(patternRe) || [];
  var m = matches[0];

  switch(m) {
    case '\\,':
      return escapeCommas(str, arr, opts);
    case '\\.':
      return escapeDots(str, arr, opts);
    case '\/.':
      return escapePaths(str, arr, opts);
    case ' ':
      return splitWhitespace(str);
    case '{,}':
      return exponential(str, opts, braces);
    case '{}':
      return emptyBraces(str, arr, opts);
    case '\\{':
    case '\\}':
      return escapeBraces(str, arr, opts);
    case '${':
      if (!/\{[^{]+\{/.test(str)) {
        return arr.concat(str);
      } else {
        es6 = true;
        str = tokens.before(str, es6Regex());
      }
  }

  if (!(braceRe instanceof RegExp)) {
    braceRe = braceRegex();
  }

  var match = braceRe.exec(str);
  if (match == null) {
    return [str];
  }

  var outter = match[1];
  var inner = match[2];
  if (inner === '') { return [str]; }

  var segs, segsLength;

  if (inner.indexOf('..') !== -1) {
    segs = expand(inner, opts, fn) || inner.split(',');
    segsLength = segs.length;

  } else if (inner[0] === '"' || inner[0] === '\'') {
    return arr.concat(str.split(/['"]/).join(''));

  } else {
    segs = inner.split(',');
    if (opts.makeRe) {
      return braces(str.replace(outter, wrap(segs, '|')), opts);
    }

    segsLength = segs.length;
    if (segsLength === 1 && opts.bash) {
      segs[0] = wrap(segs[0], '\\');
    }
  }

  var len = segs.length;
  var i = 0, val;

  while (len--) {
    var path = segs[i++];

    if (/(\.[^.\/])/.test(path)) {
      if (segsLength > 1) {
        return segs;
      } else {
        return [str];
      }
    }

    val = splice(str, outter, path);

    if (/\{[^{}]+?\}/.test(val)) {
      arr = braces(val, arr, opts);
    } else if (val !== '') {
      if (opts.nodupes && arr.indexOf(val) !== -1) { continue; }
      arr.push(es6 ? tokens.after(val) : val);
    }
  }

  if (opts.strict) { return filter(arr, filterEmpty); }
  return arr;
}

/**
 * Expand exponential ranges
 *
 *   `a{,}{,}` => ['a', 'a', 'a', 'a']
 */

function exponential(str, options, fn) {
  if (typeof options === 'function') {
    fn = options;
    options = null;
  }

  var opts = options || {};
  var esc = '__ESC_EXP__';
  var exp = 0;
  var res;

  var parts = str.split('{,}');
  if (opts.nodupes) {
    return fn(parts.join(''), opts);
  }

  exp = parts.length - 1;
  res = fn(parts.join(esc), opts);
  var len = res.length;
  var arr = [];
  var i = 0;

  while (len--) {
    var ele = res[i++];
    var idx = ele.indexOf(esc);

    if (idx === -1) {
      arr.push(ele);

    } else {
      ele = ele.split('__ESC_EXP__').join('');
      if (!!ele && opts.nodupes !== false) {
        arr.push(ele);

      } else {
        var num = Math.pow(2, exp);
        arr.push.apply(arr, repeat(ele, num));
      }
    }
  }
  return arr;
}

/**
 * Wrap a value with parens, brackets or braces,
 * based on the given character/separator.
 *
 * @param  {String|Array} `val`
 * @param  {String} `ch`
 * @return {String}
 */

function wrap(val, ch) {
  if (ch === '|') {
    return '(' + val.join(ch) + ')';
  }
  if (ch === ',') {
    return '{' + val.join(ch) + '}';
  }
  if (ch === '-') {
    return '[' + val.join(ch) + ']';
  }
  if (ch === '\\') {
    return '\\{' + val + '\\}';
  }
}

/**
 * Handle empty braces: `{}`
 */

function emptyBraces(str, arr, opts) {
  return braces(str.split('{}').join('\\{\\}'), arr, opts);
}

/**
 * Filter out empty-ish values
 */

function filterEmpty(ele) {
  return !!ele && ele !== '\\';
}

/**
 * Handle patterns with whitespace
 */

function splitWhitespace(str) {
  var segs = str.split(' ');
  var len = segs.length;
  var res = [];
  var i = 0;

  while (len--) {
    res.push.apply(res, braces(segs[i++]));
  }
  return res;
}

/**
 * Handle escaped braces: `\\{foo,bar}`
 */

function escapeBraces(str, arr, opts) {
  if (!/\{[^{]+\{/.test(str)) {
    return arr.concat(str.split('\\').join(''));
  } else {
    str = str.split('\\{').join('__LT_BRACE__');
    str = str.split('\\}').join('__RT_BRACE__');
    return map(braces(str, arr, opts), function(ele) {
      ele = ele.split('__LT_BRACE__').join('{');
      return ele.split('__RT_BRACE__').join('}');
    });
  }
}

/**
 * Handle escaped dots: `{1\\.2}`
 */

function escapeDots(str, arr, opts) {
  if (!/[^\\]\..+\\\./.test(str)) {
    return arr.concat(str.split('\\').join(''));
  } else {
    str = str.split('\\.').join('__ESC_DOT__');
    return map(braces(str, arr, opts), function(ele) {
      return ele.split('__ESC_DOT__').join('.');
    });
  }
}

/**
 * Handle escaped dots: `{1\\.2}`
 */

function escapePaths(str, arr, opts) {
  str = str.split('\/.').join('__ESC_PATH__');
  return map(braces(str, arr, opts), function(ele) {
    return ele.split('__ESC_PATH__').join('\/.');
  });
}

/**
 * Handle escaped commas: `{a\\,b}`
 */

function escapeCommas(str, arr, opts) {
  if (!/\w,/.test(str)) {
    return arr.concat(str.split('\\').join(''));
  } else {
    str = str.split('\\,').join('__ESC_COMMA__');
    return map(braces(str, arr, opts), function(ele) {
      return ele.split('__ESC_COMMA__').join(',');
    });
  }
}

/**
 * Regex for common patterns
 */

function patternRegex() {
  return /\${|( (?=[{,}])|(?=[{,}]) )|{}|{,}|\\,(?=.*[{}])|\/\.(?=.*[{}])|\\\.(?={)|\\{|\\}/;
}

/**
 * Braces regex.
 */

function braceRegex() {
  return /.*(\\?\{([^}]+)\})/;
}

/**
 * es6 delimiter regex.
 */

function es6Regex() {
  return /\$\{([^}]+)\}/;
}

var braceRe;
var patternRe;

/**
 * Faster alternative to `String.replace()` when the
 * index of the token to be replaces can't be supplied
 */

function splice(str, token, replacement) {
  var i = str.indexOf(token);
  return str.substr(0, i) + replacement
    + str.substr(i + token.length);
}

/**
 * Fast array map
 */

function map(arr, fn) {
  if (arr == null) {
    return [];
  }

  var len = arr.length;
  var res = new Array(len);
  var i = -1;

  while (++i < len) {
    res[i] = fn(arr[i], i, arr);
  }

  return res;
}

/**
 * Fast array filter
 */

function filter(arr, cb) {
  if (arr == null) return [];
  if (typeof cb !== 'function') {
    throw new TypeError('braces: filter expects a callback function.');
  }

  var len = arr.length;
  var res = arr.slice();
  var i = 0;

  while (len--) {
    if (!cb(arr[len], i++)) {
      res.splice(len, 1);
    }
  }
  return res;
}

},{"expand-range":607,"preserve":841,"repeat-element":848}],116:[function(require,module,exports){
(function (process){
var path = require('path')
var e2c = require('electron-to-chromium/versions')
var fs = require('fs')

var agents = require('caniuse-lite/dist/unpacker/agents').agents
var region = require('caniuse-lite/dist/unpacker/region').default

function normalize (versions) {
  return versions.filter(function (version) {
    return typeof version === 'string'
  })
}

var env = process.env

// eslint-disable-next-line security/detect-unsafe-regex
var FLOAT_RANGE = /^\d+(\.\d+)?(-\d+(\.\d+)?)*$/
var IS_SECTION = /^\s*\[(.+)\]\s*$/

function uniq (array) {
  var filtered = []
  for (var i = 0; i < array.length; i++) {
    if (filtered.indexOf(array[i]) === -1) filtered.push(array[i])
  }
  return filtered
}

function BrowserslistError (message) {
  this.name = 'BrowserslistError'
  this.message = message || ''
  this.browserslist = true
  if (Error.captureStackTrace) {
    Error.captureStackTrace(this, BrowserslistError)
  }
}
BrowserslistError.prototype = Error.prototype

// Helpers

function fillUsage (result, name, data) {
  for (var i in data) {
    result[name + ' ' + i] = data[i]
  }
}

var cacheEnabled = !env.BROWSERSLIST_DISABLE_CACHE
var filenessCache = {}
var configCache = {}

function isFile (file) {
  if (!fs.existsSync) {
    return false
  }
  if (file in filenessCache) {
    return filenessCache[file]
  }
  var result = fs.existsSync(file) && fs.statSync(file).isFile()
  if (cacheEnabled) {
    filenessCache[file] = result
  }
  return result
}

function eachParent (file, callback) {
  var loc = path.resolve(file)
  do {
    var result = callback(loc)
    if (typeof result !== 'undefined') return result
  } while (loc !== (loc = path.dirname(loc)))
  return undefined
}

function getStat (opts) {
  if (opts.stats) {
    return opts.stats
  } else if (env.BROWSERSLIST_STATS) {
    return env.BROWSERSLIST_STATS
  } else if (opts.path) {
    return eachParent(opts.path, function (dir) {
      var file = path.join(dir, 'browserslist-stats.json')
      return isFile(file) ? file : undefined
    })
  }

  return undefined
}

function parsePackage (file) {
  var config = JSON.parse(fs.readFileSync(file)).browserslist
  if (typeof config === 'object' && config.length) {
    config = { defaults: config }
  }
  return config
}

function pickEnv (config, opts) {
  if (typeof config !== 'object') return config

  var name
  if (typeof opts.env === 'string') {
    name = opts.env
  } else if (env.BROWSERSLIST_ENV) {
    name = env.BROWSERSLIST_ENV
  } else if (env.NODE_ENV) {
    name = env.NODE_ENV
  } else {
    name = 'development'
  }

  return config[name] || config.defaults
}

function generateFilter (sign, version) {
  version = parseFloat(version)
  if (sign === '>') {
    return function (v) {
      return parseFloat(v) > version
    }
  } else if (sign === '>=') {
    return function (v) {
      return parseFloat(v) >= version
    }
  } else if (sign === '<') {
    return function (v) {
      return parseFloat(v) < version
    }
  } else {
    return function (v) {
      return parseFloat(v) <= version
    }
  }
}

function compareStrings (a, b) {
  if (a < b) return -1
  if (a > b) return +1
  return 0
}

/**
 * Return array of browsers by selection queries.
 *
 * @param {string[]} queries Browser queries.
 * @param {object} opts Options.
 * @param {string} [opts.path="."] Path to processed file.
 *                                 It will be used to find config files.
 * @param {string} [opts.env="development"] Processing environment.
 *                                          It will be used to take right
 *                                          queries from config file.
 * @param {string} [opts.config] Path to config file with queries.
 * @param {object} [opts.stats] Custom browser usage statistics
 *                              for "> 1% in my stats" query.
 * @return {string[]} Array with browser names in Can I Use.
 *
 * @example
 * browserslist('IE >= 10, IE 8') //=> ['ie 11', 'ie 10', 'ie 8']
 */
function browserslist (queries, opts) {
  if (typeof opts === 'undefined') opts = { }

  if (!opts.hasOwnProperty('path')) {
    opts.path = path.resolve('.')
  }

  if (typeof queries === 'undefined' || queries === null) {
    if (env.BROWSERSLIST) {
      queries = env.BROWSERSLIST
    } else if (opts.config || env.BROWSERSLIST_CONFIG) {
      var file = opts.config || env.BROWSERSLIST_CONFIG
      if (path.basename(file) === 'package.json') {
        queries = pickEnv(parsePackage(file), opts)
      } else {
        queries = pickEnv(browserslist.readConfig(file), opts)
      }
    } else if (opts.path) {
      queries = pickEnv(browserslist.findConfig(opts.path), opts)
    }
  }

  if (typeof queries === 'undefined' || queries === null) {
    queries = browserslist.defaults
  }

  if (typeof queries === 'string') {
    queries = queries.split(/,\s*/)
  }

  var context = { }

  var stats = getStat(opts)
  if (stats) {
    if (typeof stats === 'string') {
      try {
        stats = JSON.parse(fs.readFileSync(stats))
      } catch (e) {
        throw new BrowserslistError('Can\'t read ' + stats)
      }
    }
    if ('dataByBrowser' in stats) {
      stats = stats.dataByBrowser
    }

    context.customUsage = { }
    for (var browser in stats) {
      fillUsage(context.customUsage, browser, stats[browser])
    }
  }

  var result = []

  queries.forEach(function (selection, index) {
    if (selection.trim() === '') return

    var exclude = selection.indexOf('not ') === 0
    if (exclude) {
      if (index === 0) {
        throw new BrowserslistError(
          'Write any browsers query (for instance, `defaults`) ' +
          'before `' + selection + '`')
      }
      selection = selection.slice(4)
    }

    for (var i = 0; i < QUERIES.length; i++) {
      var type = QUERIES[i]
      var match = selection.match(type.regexp)
      if (match) {
        var args = [context].concat(match.slice(1))
        var array = type.select.apply(browserslist, args)
        if (exclude) {
          array = array.concat(array.map(function (j) {
            return j.replace(/\s\d+/, ' 0')
          }))
          result = result.filter(function (j) {
            return array.indexOf(j) === -1
          })
        } else {
          result = result.concat(array)
        }
        return
      }
    }

    throw new BrowserslistError('Unknown browser query `' + selection + '`')
  })
  result = result.map(function (i) {
    var parts = i.split(' ')
    var name = parts[0]
    var version = parts[1]
    if (version === '0') {
      return name + ' ' + byName(name).versions[0]
    } else {
      return i
    }
  }).sort(function (name1, name2) {
    name1 = name1.split(' ')
    name2 = name2.split(' ')
    if (name1[0] === name2[0]) {
      if (FLOAT_RANGE.test(name1[1]) && FLOAT_RANGE.test(name2[1])) {
        return parseFloat(name2[1]) - parseFloat(name1[1])
      } else {
        return compareStrings(name2[1], name1[1])
      }
    } else {
      return compareStrings(name1[0], name2[0])
    }
  })

  return uniq(result)
}

function normalizeVersion (data, version) {
  if (data.versions.indexOf(version) !== -1) {
    return version
  } else if (browserslist.versionAliases[data.name][version]) {
    return browserslist.versionAliases[data.name][version]
  } else if (data.versions.length === 1) {
    return data.versions[0]
  } else {
    return false
  }
}

function loadCountryStatistics (country) {
  country = country.replace(/[^\w-]/g, '')
  if (!browserslist.usage[country]) {
    var usage = { }
    // eslint-disable-next-line security/detect-non-literal-require
    var compressed = require('caniuse-lite/data/regions/' + country + '.js')
    var data = region(compressed)
    for (var i in data) {
      fillUsage(usage, i, data[i])
    }
    browserslist.usage[country] = usage
  }
}

// Will be filled by Can I Use data below
browserslist.data = { }
browserslist.usage = {
  global: { },
  custom: null
}

// Default browsers query
browserslist.defaults = [
  '> 1%',
  'last 2 versions',
  'Firefox ESR'
]

// Browser names aliases
browserslist.aliases = {
  fx: 'firefox',
  ff: 'firefox',
  ios: 'ios_saf',
  explorer: 'ie',
  blackberry: 'bb',
  explorermobile: 'ie_mob',
  operamini: 'op_mini',
  operamobile: 'op_mob',
  chromeandroid: 'and_chr',
  firefoxandroid: 'and_ff',
  ucandroid: 'and_uc',
  qqandroid: 'and_qq'
}

// Aliases to work with joined versions like `ios_saf 7.0-7.1`
browserslist.versionAliases = { }

// Get browser data by alias or case insensitive name
function byName (name) {
  name = name.toLowerCase()
  name = browserslist.aliases[name] || name
  return browserslist.data[name]
}

// Get browser data by alias or case insensitive name and throw error
// on unknown browser
function checkName (name) {
  var data = byName(name)
  if (!data) throw new BrowserslistError('Unknown browser ' + name)
  return data
}

// Read and parse config
browserslist.readConfig = function (file) {
  if (!isFile(file)) {
    throw new BrowserslistError('Can\'t read ' + file + ' config')
  }
  return browserslist.parseConfig(fs.readFileSync(file))
}

// Find config, read file and parse it
browserslist.findConfig = function (from) {
  from = path.resolve(from)

  var cacheKey = isFile(from) ? path.dirname(from) : from
  if (cacheKey in configCache) {
    return configCache[cacheKey]
  }

  var resolved = eachParent(from, function (dir) {
    var config = path.join(dir, 'browserslist')
    var pkg = path.join(dir, 'package.json')
    var rc = path.join(dir, '.browserslistrc')

    var pkgBrowserslist
    if (isFile(pkg)) {
      try {
        pkgBrowserslist = parsePackage(pkg)
      } catch (e) {
        console.warn(
          '[Browserslist] Could not parse ' + pkg + '. Ignoring it.')
      }
    }

    if (isFile(config) && pkgBrowserslist) {
      throw new BrowserslistError(
        dir + ' contains both browserslist and package.json with browsers')
    } else if (isFile(rc) && pkgBrowserslist) {
      throw new BrowserslistError(
        dir + ' contains both .browserslistrc and package.json with browsers')
    } else if (isFile(config) && isFile(rc)) {
      throw new BrowserslistError(
        dir + ' contains both .browserslistrc and browserslist')
    } else if (isFile(config)) {
      return browserslist.readConfig(config)
    } else if (isFile(rc)) {
      return browserslist.readConfig(rc)
    } else {
      return pkgBrowserslist
    }
  })
  if (cacheEnabled) {
    configCache[cacheKey] = resolved
  }
  return resolved
}

/**
 * Return browsers market coverage.
 *
 * @param {string[]} browsers Browsers names in Can I Use.
 * @param {string} [country="global"] Which country statistics should be used.
 *
 * @return {number} Total market coverage for all selected browsers.
 *
 * @example
 * browserslist.coverage(browserslist('> 1% in US'), 'US') //=> 83.1
 */
browserslist.coverage = function (browsers, country) {
  if (country && country !== 'global') {
    if (country.length > 2) {
      country = country.toLowerCase()
    } else {
      country = country.toUpperCase()
    }
    loadCountryStatistics(country)
  } else {
    country = 'global'
  }

  return browsers.reduce(function (all, i) {
    var usage = browserslist.usage[country][i]
    if (usage === undefined) {
      usage = browserslist.usage[country][i.replace(/ [\d.]+$/, ' 0')]
    }
    return all + (usage || 0)
  }, 0)
}

// Return array of queries from config content
browserslist.parseConfig = function (string) {
  var result = { defaults: [] }
  var section = 'defaults'

  string.toString()
    .replace(/#[^\n]*/g, '')
    .split(/\n/)
    .map(function (line) {
      return line.trim()
    })
    .filter(function (line) {
      return line !== ''
    })
    .forEach(function (line) {
      if (IS_SECTION.test(line)) {
        section = line.match(IS_SECTION)[1].trim()
        result[section] = result[section] || []
      } else {
        result[section].push(line)
      }
    })

  return result
}

// Clear internal caches
browserslist.clearCaches = function () {
  filenessCache = {}
  configCache = {}
}

var QUERIES = [
  {
    regexp: /^last\s+(\d+)\s+versions?$/i,
    select: function (context, versions) {
      var selected = []
      Object.keys(agents).forEach(function (name) {
        var data = byName(name)
        if (!data) return
        var array = data.released.slice(-versions)

        array = array.map(function (v) {
          return data.name + ' ' + v
        })
        selected = selected.concat(array)
      })
      return selected
    }
  },
  {
    regexp: /^last\s+(\d+)\s+(\w+)\s+versions?$/i,
    select: function (context, versions, name) {
      var data = checkName(name)
      return data.released.slice(-versions).map(function (v) {
        return data.name + ' ' + v
      })
    }
  },
  {
    regexp: /^unreleased\s+versions$/i,
    select: function () {
      var selected = []
      Object.keys(agents).forEach(function (name) {
        var data = byName(name)
        if (!data) return
        var array = data.versions.filter(function (v) {
          return data.released.indexOf(v) === -1
        })

        array = array.map(function (v) {
          return data.name + ' ' + v
        })
        selected = selected.concat(array)
      })
      return selected
    }
  },
  {
    regexp: /^unreleased\s+(\w+)\s+versions?$/i,
    select: function (context, name) {
      var data = checkName(name)
      return data.versions.filter(function (v) {
        return data.released.indexOf(v) === -1
      }).map(function (v) {
        return data.name + ' ' + v
      })
    }
  },
  {
    regexp: /^(>=?)\s*(\d*\.?\d+)%$/,
    select: function (context, sign, popularity) {
      popularity = parseFloat(popularity)
      var result = []

      for (var version in browserslist.usage.global) {
        if (sign === '>') {
          if (browserslist.usage.global[version] > popularity) {
            result.push(version)
          }
        } else if (browserslist.usage.global[version] >= popularity) {
          result.push(version)
        }
      }

      return result
    }
  },
  {
    regexp: /^(>=?)\s*(\d*\.?\d+)%\s+in\s+my\s+stats$/,
    select: function (context, sign, popularity) {
      popularity = parseFloat(popularity)
      var result = []

      if (!context.customUsage) {
        throw new BrowserslistError('Custom usage statistics was not provided')
      }

      for (var version in context.customUsage) {
        if (sign === '>') {
          if (context.customUsage[version] > popularity) {
            result.push(version)
          }
        } else if (context.customUsage[version] >= popularity) {
          result.push(version)
        }
      }

      return result
    }
  },
  {
    regexp: /^(>=?)\s*(\d*\.?\d+)%\s+in\s+((alt-)?\w\w)$/,
    select: function (context, sign, popularity, place) {
      popularity = parseFloat(popularity)
      var result = []

      if (place.length === 2) {
        place = place.toUpperCase()
      } else {
        place = place.toLowerCase()
      }

      loadCountryStatistics(place)
      var usage = browserslist.usage[place]

      for (var version in usage) {
        if (sign === '>') {
          if (usage[version] > popularity) {
            result.push(version)
          }
        } else if (usage[version] >= popularity) {
          result.push(version)
        }
      }

      return result
    }
  },
  {
    regexp: /^electron\s+([\d.]+)\s*-\s*([\d.]+)$/i,
    select: function (context, from, to) {
      if (!e2c[from]) {
        throw new BrowserslistError('Unknown version ' + from + ' of electron')
      }
      if (!e2c[to]) {
        throw new BrowserslistError('Unknown version ' + to + ' of electron')
      }

      from = parseFloat(from)
      to = parseFloat(to)

      return Object.keys(e2c).filter(function (i) {
        var parsed = parseFloat(i)
        return parsed >= from && parsed <= to
      }).map(function (i) {
        return 'chrome ' + e2c[i]
      })
    }
  },
  {
    regexp: /^(\w+)\s+([\d.]+)\s*-\s*([\d.]+)$/i,
    select: function (context, name, from, to) {
      var data = checkName(name)
      from = parseFloat(normalizeVersion(data, from) || from)
      to = parseFloat(normalizeVersion(data, to) || to)

      function filter (v) {
        var parsed = parseFloat(v)
        return parsed >= from && parsed <= to
      }

      return data.released.filter(filter).map(function (v) {
        return data.name + ' ' + v
      })
    }
  },
  {
    regexp: /^electron\s*(>=?|<=?)\s*([\d.]+)$/i,
    select: function (context, sign, version) {
      return Object.keys(e2c)
        .filter(generateFilter(sign, version))
        .map(function (i) {
          return 'chrome ' + e2c[i]
        })
    }
  },
  {
    regexp: /^(\w+)\s*(>=?|<=?)\s*([\d.]+)$/,
    select: function (context, name, sign, version) {
      var data = checkName(name)
      var alias = browserslist.versionAliases[data.name][version]
      if (alias) {
        version = alias
      }
      return data.released
        .filter(generateFilter(sign, version))
        .map(function (v) {
          return data.name + ' ' + v
        })
    }
  },
  {
    regexp: /^(firefox|ff|fx)\s+esr$/i,
    select: function () {
      return ['firefox 52']
    }
  },
  {
    regexp: /(operamini|op_mini)\s+all/i,
    select: function () {
      return ['op_mini all']
    }
  },
  {
    regexp: /^electron\s+([\d.]+)$/i,
    select: function (context, version) {
      var chrome = e2c[version]
      if (!chrome) {
        throw new BrowserslistError(
          'Unknown version ' + version + ' of electron')
      }
      return ['chrome ' + chrome]
    }
  },
  {
    regexp: /^(\w+)\s+(tp|[\d.]+)$/i,
    select: function (context, name, version) {
      if (/^tp$/i.test(version)) version = 'TP'
      var data = checkName(name)
      var alias = normalizeVersion(data, version)
      if (alias) {
        version = alias
      } else {
        if (version.indexOf('.') === -1) {
          alias = version + '.0'
        } else if (/\.0$/.test(version)) {
          alias = version.replace(/\.0$/, '')
        }
        alias = normalizeVersion(data, alias)
        if (alias) {
          version = alias
        } else {
          throw new BrowserslistError(
            'Unknown version ' + version + ' of ' + name)
        }
      }
      return [data.name + ' ' + version]
    }
  },
  {
    regexp: /^defaults$/i,
    select: function () {
      return browserslist(browserslist.defaults)
    }
  }
];

// Get and convert Can I Use data

(function () {
  for (var name in agents) {
    var browser = agents[name]
    browserslist.data[name] = {
      name: name,
      versions: normalize(agents[name].versions),
      released: normalize(agents[name].versions.slice(0, -3))
    }
    fillUsage(browserslist.usage.global, name, browser.usage_global)

    browserslist.versionAliases[name] = { }
    for (var i = 0; i < browser.versions.length; i++) {
      var full = browser.versions[i]
      if (!full) continue

      if (full.indexOf('-') !== -1) {
        var interval = full.split('-')
        for (var j = 0; j < interval.length; j++) {
          browserslist.versionAliases[name][interval[j]] = full
        }
      }
    }
  }
}())

module.exports = browserslist

}).call(this,require('_process'))
},{"_process":16,"caniuse-lite/dist/unpacker/agents":573,"caniuse-lite/dist/unpacker/region":579,"electron-to-chromium/versions":602,"fs":4,"path":4}],117:[function(require,module,exports){
module.exports={A:{A:{J:0.0344717,C:0.0172359,G:0.336099,E:0.193904,B:0.198212,A:3.09815,UB:0.009298},B:"ms",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","UB","J","C","G","E","B","A","","",""],E:"IE"},B:{A:{D:0.03717,X:0.09086,g:0.84665,H:0,L:0},B:"ms",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","D","X","g","H","L","",""],E:"Edge"},C:{A:{"0":0.18172,"1":3.75417,"2":0.01652,"4":0,"5":0,SB:0.004227,F:0.00413,I:0.004879,J:0.020136,C:0.005725,G:0.00826,E:0.00533,B:0.00413,A:0.00413,D:0.00826,X:0.004486,g:0.00453,H:0.00413,L:0.00826,M:0.00413,N:0.00826,O:0.004443,P:0.004227,Q:0.00826,R:0.00413,S:0.00413,T:0.00826,U:0.00826,V:0.00413,W:0.00826,u:0.00413,Y:0.00826,Z:0.01239,a:0.02065,b:0.00826,c:0.00826,d:0.00826,e:0.01239,f:0.01239,K:0.01239,h:0.0413,i:0.01239,j:0.01652,k:0.02478,l:0.01652,m:0.04956,n:0.02065,o:0.07021,p:0.02065,q:0.09086,r:0.14868,w:0.07847,x:0.07021,v:0.11151,z:0.51625,t:0.1652,s:0,QB:0.004534,PB:0.01239},B:"moz",C:["","SB","2","QB","PB","F","I","J","C","G","E","B","A","D","X","g","H","L","M","N","O","P","Q","R","S","T","U","V","W","u","Y","Z","a","b","c","d","e","f","K","h","i","j","k","l","m","n","o","p","q","r","w","x","v","z","0","1","t","s","4","5"],E:"Firefox"},D:{A:{"0":0.06608,"1":0.14042,"4":0.2065,"5":1.04902,"8":20.4724,F:0.004706,I:0.004879,J:0.004879,C:0.005591,G:0.005591,E:0.005591,B:0.004534,A:0.02065,D:0.004367,X:0.004879,g:0.004706,H:0.004706,L:0.00413,M:0.00413,N:0.00826,O:0.00413,P:0.00413,Q:0.00826,R:0.03304,S:0.00413,T:0.00826,U:0.00826,V:0.01652,W:0.00826,u:0.00826,Y:0.03304,Z:0.01239,a:0.06608,b:0.01652,c:0.02478,d:0.02891,e:0.01652,f:0.09086,K:0.01652,h:0.03717,i:0.03717,j:0.01652,k:0.02478,l:0.02065,m:0.15694,n:0.02478,o:0.28497,p:0.03304,q:0.09499,r:0.07434,w:1.10684,x:0.10325,v:0.14042,z:0.0413,t:0.28084,s:0.2891,EB:0.30149,BB:0.05369,TB:0,CB:0},B:"webkit",C:["F","I","J","C","G","E","B","A","D","X","g","H","L","M","N","O","P","Q","R","S","T","U","V","W","u","Y","Z","a","b","c","d","e","f","K","h","i","j","k","l","m","n","o","p","q","r","w","x","v","z","0","1","t","s","4","5","8","EB","BB","TB","CB"],E:"Chrome"},E:{A:{"9":0.008692,F:0.00826,I:0.02065,J:0.00413,C:0.01239,G:0.06195,E:0.06195,B:0.22302,A:0.00826,DB:0,FB:0.05782,GB:0.02065,HB:0.00413,IB:0.2478,JB:1.30921,KB:0},B:"webkit",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","DB","9","F","I","FB","J","GB","C","HB","G","E","IB","B","JB","A","KB",""],E:"Safari"},F:{A:{"6":0.004879,"7":0.006229,E:0.0082,A:0.016581,D:0.00413,H:0.00685,L:0.00685,M:0.00685,N:0.005014,O:0.006015,P:0.004879,Q:0.006597,R:0.006597,S:0.013434,T:0.006702,U:0.006015,V:0.005595,W:0.004706,u:0.00413,Y:0.004879,Z:0.004879,a:0.00533,b:0.005152,c:0.005014,d:0.009758,e:0.004879,f:0.02891,K:0.00413,h:0.004367,i:0.004534,j:0.004367,k:0.004227,l:0.00826,m:0.01239,n:0.004227,o:0.04956,p:0.6608,q:0.00413,r:0.00413,LB:0.00685,MB:0,NB:0.008392,OB:0.004706,RB:0.004534,y:0.06195},B:"webkit",C:["","","","","","","","","","","","","","","E","LB","MB","NB","OB","A","7","6","RB","D","y","H","L","M","N","O","P","Q","R","S","T","U","V","W","u","Y","Z","a","b","c","d","e","f","K","h","i","j","k","l","m","n","o","p","q","r",""],E:"Opera",D:{"6":"o","7":"o",E:"o",A:"o",D:"o",LB:"o",MB:"o",NB:"o",OB:"o",RB:"o",y:"o"}},G:{A:{"3":0,"9":0,G:0,A:0,AB:0,VB:0,WB:0,XB:0.0488638,YB:0.0374276,ZB:0.0259914,aB:0.51359,bB:1.46487,cB:7.99806},B:"webkit",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","9","AB","3","VB","WB","XB","G","YB","ZB","aB","bB","cB","A","",""],E:"iOS Safari"},H:{A:{dB:3.26376},B:"o",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","dB","","",""],E:"Opera Mini"},I:{A:{"2":0,"3":0.348738,F:0,s:0,eB:0,fB:0,gB:0,hB:0.136648,iB:0.938034,jB:0.577909},B:"webkit",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","eB","fB","gB","2","F","hB","3","iB","jB","s","","",""],E:"Android Browser"},J:{A:{C:0.0322795,B:0},B:"webkit",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","C","B","","",""],E:"Blackberry Browser"},K:{A:{"6":0,"7":0,B:0,A:0,D:0,K:0.0111391,y:0},B:"o",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","B","A","7","6","D","y","K","","",""],E:"Opera Mobile",D:{K:"webkit"}},L:{A:{"8":29.8734},B:"webkit",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","8","","",""],E:"Chrome for Android"},M:{A:{t:0.035214},B:"moz",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","t","","",""],E:"Firefox for Android"},N:{A:{B:0.0564638,A:0.307414},B:"ms",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","B","A","","",""],E:"IE Mobile"},O:{A:{kB:9.1263},B:"webkit",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","kB","","",""],E:"UC Browser for Android",D:{kB:"webkit"}},P:{A:{F:3.83833,I:0},B:"webkit",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","F","I","","",""],E:"Samsung Internet"},Q:{A:{lB:0},B:"webkit",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","lB","","",""],E:"QQ Browser"},R:{A:{mB:0},B:"webkit",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mB","","",""],E:"Baidu Browser"}};

},{}],118:[function(require,module,exports){
module.exports={"0":"53","1":"54","2":"3","3":"4.2-4.3","4":"57","5":"58","6":"11.5","7":"11.1","8":"59","9":"3.2",A:"11",B:"10",C:"7",D:"12",E:"9",F:"4",G:"8",H:"15",I:"5",J:"6",K:"37",L:"16",M:"17",N:"18",O:"19",P:"20",Q:"21",R:"22",S:"23",T:"24",U:"25",V:"26",W:"27",X:"13",Y:"29",Z:"30",a:"31",b:"32",c:"33",d:"34",e:"35",f:"36",g:"14",h:"38",i:"39",j:"40",k:"41",l:"42",m:"43",n:"44",o:"45",p:"46",q:"47",r:"48",s:"56",t:"55",u:"28",v:"51",w:"49",x:"50",y:"12.1",z:"52",AB:"4.0-4.1",BB:"61",CB:"63",DB:"3.1",EB:"60",FB:"5.1",GB:"6.1",HB:"7.1",IB:"9.1",JB:"10.1",KB:"TP",LB:"9.5-9.6",MB:"10.0-10.1",NB:"10.5",OB:"10.6",PB:"3.6",QB:"3.5",RB:"11.6",SB:"2",TB:"62",UB:"5.5",VB:"5.0-5.1",WB:"6.0-6.1",XB:"7.0-7.1",YB:"8.1-8.4",ZB:"9.0-9.2",aB:"9.3",bB:"10.0-10.2",cB:"10.3",dB:"all",eB:"2.1",fB:"2.2",gB:"2.3",hB:"4.1",iB:"4.4",jB:"4.4.3-4.4.4",kB:"11.4",lB:"1.2",mB:"7.12"};

},{}],119:[function(require,module,exports){
module.exports={A:"ie",B:"edge",C:"firefox",D:"chrome",E:"safari",F:"opera",G:"ios_saf",H:"op_mini",I:"android",J:"bb",K:"op_mob",L:"and_chr",M:"and_ff",N:"ie_mob",O:"and_uc",P:"samsung",Q:"and_qq",R:"baidu"};

},{}],120:[function(require,module,exports){
module.exports={"aac":require("./features/aac"),"ac3-ec3":require("./features/ac3-ec3"),"addeventlistener":require("./features/addeventlistener"),"alternate-stylesheet":require("./features/alternate-stylesheet"),"ambient-light":require("./features/ambient-light"),"apng":require("./features/apng"),"arrow-functions":require("./features/arrow-functions"),"asmjs":require("./features/asmjs"),"async-functions":require("./features/async-functions"),"atob-btoa":require("./features/atob-btoa"),"audio-api":require("./features/audio-api"),"audio":require("./features/audio"),"audiotracks":require("./features/audiotracks"),"autofocus":require("./features/autofocus"),"aux-click":require("./features/aux-click"),"background-attachment":require("./features/background-attachment"),"background-img-opts":require("./features/background-img-opts"),"background-position-x-y":require("./features/background-position-x-y"),"background-repeat-round-space":require("./features/background-repeat-round-space"),"battery-status":require("./features/battery-status"),"beacon":require("./features/beacon"),"beforeafterprint":require("./features/beforeafterprint"),"blobbuilder":require("./features/blobbuilder"),"bloburls":require("./features/bloburls"),"border-image":require("./features/border-image"),"border-radius":require("./features/border-radius"),"broadcastchannel":require("./features/broadcastchannel"),"brotli":require("./features/brotli"),"calc":require("./features/calc"),"canvas-blending":require("./features/canvas-blending"),"canvas-text":require("./features/canvas-text"),"canvas":require("./features/canvas"),"ch-unit":require("./features/ch-unit"),"chacha20-poly1305":require("./features/chacha20-poly1305"),"channel-messaging":require("./features/channel-messaging"),"childnode-remove":require("./features/childnode-remove"),"classlist":require("./features/classlist"),"client-hints-dpr-width-viewport":require("./features/client-hints-dpr-width-viewport"),"clipboard":require("./features/clipboard"),"comparedocumentposition":require("./features/comparedocumentposition"),"console-basic":require("./features/console-basic"),"const":require("./features/const"),"constraint-validation":require("./features/constraint-validation"),"contenteditable":require("./features/contenteditable"),"contentsecuritypolicy":require("./features/contentsecuritypolicy"),"contentsecuritypolicy2":require("./features/contentsecuritypolicy2"),"cors":require("./features/cors"),"credential-management":require("./features/credential-management"),"cryptography":require("./features/cryptography"),"css-all":require("./features/css-all"),"css-animation":require("./features/css-animation"),"css-any-link":require("./features/css-any-link"),"css-appearance":require("./features/css-appearance"),"css-apply-rule":require("./features/css-apply-rule"),"css-at-counter-style":require("./features/css-at-counter-style"),"css-backdrop-filter":require("./features/css-backdrop-filter"),"css-background-offsets":require("./features/css-background-offsets"),"css-backgroundblendmode":require("./features/css-backgroundblendmode"),"css-boxdecorationbreak":require("./features/css-boxdecorationbreak"),"css-boxshadow":require("./features/css-boxshadow"),"css-canvas":require("./features/css-canvas"),"css-caret-color":require("./features/css-caret-color"),"css-case-insensitive":require("./features/css-case-insensitive"),"css-clip-path":require("./features/css-clip-path"),"css-conic-gradients":require("./features/css-conic-gradients"),"css-containment":require("./features/css-containment"),"css-counters":require("./features/css-counters"),"css-crisp-edges":require("./features/css-crisp-edges"),"css-cross-fade":require("./features/css-cross-fade"),"css-default-pseudo":require("./features/css-default-pseudo"),"css-descendant-gtgt":require("./features/css-descendant-gtgt"),"css-deviceadaptation":require("./features/css-deviceadaptation"),"css-dir-pseudo":require("./features/css-dir-pseudo"),"css-display-contents":require("./features/css-display-contents"),"css-element-function":require("./features/css-element-function"),"css-exclusions":require("./features/css-exclusions"),"css-featurequeries":require("./features/css-featurequeries"),"css-filter-function":require("./features/css-filter-function"),"css-filters":require("./features/css-filters"),"css-first-letter":require("./features/css-first-letter"),"css-first-line":require("./features/css-first-line"),"css-fixed":require("./features/css-fixed"),"css-focus-within":require("./features/css-focus-within"),"css-font-rendering-controls":require("./features/css-font-rendering-controls"),"css-font-stretch":require("./features/css-font-stretch"),"css-gencontent":require("./features/css-gencontent"),"css-gradients":require("./features/css-gradients"),"css-grid":require("./features/css-grid"),"css-hanging-punctuation":require("./features/css-hanging-punctuation"),"css-has":require("./features/css-has"),"css-hyphenate":require("./features/css-hyphenate"),"css-hyphens":require("./features/css-hyphens"),"css-image-orientation":require("./features/css-image-orientation"),"css-image-set":require("./features/css-image-set"),"css-in-out-of-range":require("./features/css-in-out-of-range"),"css-indeterminate-pseudo":require("./features/css-indeterminate-pseudo"),"css-initial-letter":require("./features/css-initial-letter"),"css-initial-value":require("./features/css-initial-value"),"css-letter-spacing":require("./features/css-letter-spacing"),"css-line-clamp":require("./features/css-line-clamp"),"css-logical-props":require("./features/css-logical-props"),"css-marker-pseudo":require("./features/css-marker-pseudo"),"css-masks":require("./features/css-masks"),"css-matches-pseudo":require("./features/css-matches-pseudo"),"css-media-interaction":require("./features/css-media-interaction"),"css-media-resolution":require("./features/css-media-resolution"),"css-media-scripting":require("./features/css-media-scripting"),"css-mediaqueries":require("./features/css-mediaqueries"),"css-mixblendmode":require("./features/css-mixblendmode"),"css-motion-paths":require("./features/css-motion-paths"),"css-namespaces":require("./features/css-namespaces"),"css-not-sel-list":require("./features/css-not-sel-list"),"css-nth-child-of":require("./features/css-nth-child-of"),"css-opacity":require("./features/css-opacity"),"css-optional-pseudo":require("./features/css-optional-pseudo"),"css-overflow-anchor":require("./features/css-overflow-anchor"),"css-page-break":require("./features/css-page-break"),"css-paged-media":require("./features/css-paged-media"),"css-placeholder-shown":require("./features/css-placeholder-shown"),"css-placeholder":require("./features/css-placeholder"),"css-read-only-write":require("./features/css-read-only-write"),"css-rebeccapurple":require("./features/css-rebeccapurple"),"css-reflections":require("./features/css-reflections"),"css-regions":require("./features/css-regions"),"css-repeating-gradients":require("./features/css-repeating-gradients"),"css-resize":require("./features/css-resize"),"css-revert-value":require("./features/css-revert-value"),"css-rrggbbaa":require("./features/css-rrggbbaa"),"css-scroll-behavior":require("./features/css-scroll-behavior"),"css-scrollbar":require("./features/css-scrollbar"),"css-sel2":require("./features/css-sel2"),"css-sel3":require("./features/css-sel3"),"css-selection":require("./features/css-selection"),"css-shapes":require("./features/css-shapes"),"css-snappoints":require("./features/css-snappoints"),"css-sticky":require("./features/css-sticky"),"css-supports-api":require("./features/css-supports-api"),"css-table":require("./features/css-table"),"css-text-align-last":require("./features/css-text-align-last"),"css-text-indent":require("./features/css-text-indent"),"css-text-justify":require("./features/css-text-justify"),"css-text-orientation":require("./features/css-text-orientation"),"css-text-spacing":require("./features/css-text-spacing"),"css-textshadow":require("./features/css-textshadow"),"css-touch-action-2":require("./features/css-touch-action-2"),"css-touch-action":require("./features/css-touch-action"),"css-transitions":require("./features/css-transitions"),"css-unicode-bidi":require("./features/css-unicode-bidi"),"css-unset-value":require("./features/css-unset-value"),"css-variables":require("./features/css-variables"),"css-widows-orphans":require("./features/css-widows-orphans"),"css-writing-mode":require("./features/css-writing-mode"),"css-zoom":require("./features/css-zoom"),"css3-attr":require("./features/css3-attr"),"css3-boxsizing":require("./features/css3-boxsizing"),"css3-colors":require("./features/css3-colors"),"css3-cursors-grab":require("./features/css3-cursors-grab"),"css3-cursors-newer":require("./features/css3-cursors-newer"),"css3-cursors":require("./features/css3-cursors"),"css3-tabsize":require("./features/css3-tabsize"),"currentcolor":require("./features/currentcolor"),"custom-elements":require("./features/custom-elements"),"custom-elementsv1":require("./features/custom-elementsv1"),"customevent":require("./features/customevent"),"datalist":require("./features/datalist"),"dataset":require("./features/dataset"),"datauri":require("./features/datauri"),"details":require("./features/details"),"deviceorientation":require("./features/deviceorientation"),"devicepixelratio":require("./features/devicepixelratio"),"dialog":require("./features/dialog"),"dispatchevent":require("./features/dispatchevent"),"document-currentscript":require("./features/document-currentscript"),"document-evaluate-xpath":require("./features/document-evaluate-xpath"),"document-execcommand":require("./features/document-execcommand"),"documenthead":require("./features/documenthead"),"dom-manip-convenience":require("./features/dom-manip-convenience"),"dom-range":require("./features/dom-range"),"domcontentloaded":require("./features/domcontentloaded"),"domfocusin-domfocusout-events":require("./features/domfocusin-domfocusout-events"),"dommatrix":require("./features/dommatrix"),"download":require("./features/download"),"dragndrop":require("./features/dragndrop"),"element-closest":require("./features/element-closest"),"element-from-point":require("./features/element-from-point"),"eme":require("./features/eme"),"eot":require("./features/eot"),"es5":require("./features/es5"),"es6-class":require("./features/es6-class"),"es6-generators":require("./features/es6-generators"),"es6-module-dynamic-import":require("./features/es6-module-dynamic-import"),"es6-module-nomodule":require("./features/es6-module-nomodule"),"es6-module":require("./features/es6-module"),"es6-number":require("./features/es6-number"),"eventsource":require("./features/eventsource"),"fetch":require("./features/fetch"),"fieldset-disabled":require("./features/fieldset-disabled"),"fileapi":require("./features/fileapi"),"filereader":require("./features/filereader"),"filereadersync":require("./features/filereadersync"),"filesystem":require("./features/filesystem"),"flac":require("./features/flac"),"flexbox":require("./features/flexbox"),"flow-root":require("./features/flow-root"),"focusin-focusout-events":require("./features/focusin-focusout-events"),"font-feature":require("./features/font-feature"),"font-kerning":require("./features/font-kerning"),"font-loading":require("./features/font-loading"),"font-size-adjust":require("./features/font-size-adjust"),"font-smooth":require("./features/font-smooth"),"font-unicode-range":require("./features/font-unicode-range"),"font-variant-alternates":require("./features/font-variant-alternates"),"fontface":require("./features/fontface"),"form-attribute":require("./features/form-attribute"),"form-submit-attributes":require("./features/form-submit-attributes"),"form-validation":require("./features/form-validation"),"forms":require("./features/forms"),"fullscreen":require("./features/fullscreen"),"gamepad":require("./features/gamepad"),"geolocation":require("./features/geolocation"),"getboundingclientrect":require("./features/getboundingclientrect"),"getcomputedstyle":require("./features/getcomputedstyle"),"getelementsbyclassname":require("./features/getelementsbyclassname"),"getrandomvalues":require("./features/getrandomvalues"),"hardwareconcurrency":require("./features/hardwareconcurrency"),"hashchange":require("./features/hashchange"),"heif":require("./features/heif"),"hevc":require("./features/hevc"),"hidden":require("./features/hidden"),"high-resolution-time":require("./features/high-resolution-time"),"history":require("./features/history"),"html-media-capture":require("./features/html-media-capture"),"html5semantic":require("./features/html5semantic"),"http-live-streaming":require("./features/http-live-streaming"),"http2":require("./features/http2"),"iframe-sandbox":require("./features/iframe-sandbox"),"iframe-seamless":require("./features/iframe-seamless"),"iframe-srcdoc":require("./features/iframe-srcdoc"),"imagecapture":require("./features/imagecapture"),"ime":require("./features/ime"),"img-naturalwidth-naturalheight":require("./features/img-naturalwidth-naturalheight"),"imports":require("./features/imports"),"indeterminate-checkbox":require("./features/indeterminate-checkbox"),"indexeddb":require("./features/indexeddb"),"indexeddb2":require("./features/indexeddb2"),"inline-block":require("./features/inline-block"),"innertext":require("./features/innertext"),"input-autocomplete-onoff":require("./features/input-autocomplete-onoff"),"input-color":require("./features/input-color"),"input-datetime":require("./features/input-datetime"),"input-email-tel-url":require("./features/input-email-tel-url"),"input-event":require("./features/input-event"),"input-file-accept":require("./features/input-file-accept"),"input-file-directory":require("./features/input-file-directory"),"input-file-multiple":require("./features/input-file-multiple"),"input-inputmode":require("./features/input-inputmode"),"input-minlength":require("./features/input-minlength"),"input-number":require("./features/input-number"),"input-pattern":require("./features/input-pattern"),"input-placeholder":require("./features/input-placeholder"),"input-range":require("./features/input-range"),"input-search":require("./features/input-search"),"insert-adjacent":require("./features/insert-adjacent"),"insertadjacenthtml":require("./features/insertadjacenthtml"),"internationalization":require("./features/internationalization"),"intersectionobserver":require("./features/intersectionobserver"),"intrinsic-width":require("./features/intrinsic-width"),"jpeg2000":require("./features/jpeg2000"),"jpegxr":require("./features/jpegxr"),"json":require("./features/json"),"kerning-pairs-ligatures":require("./features/kerning-pairs-ligatures"),"keyboardevent-charcode":require("./features/keyboardevent-charcode"),"keyboardevent-code":require("./features/keyboardevent-code"),"keyboardevent-getmodifierstate":require("./features/keyboardevent-getmodifierstate"),"keyboardevent-key":require("./features/keyboardevent-key"),"keyboardevent-location":require("./features/keyboardevent-location"),"keyboardevent-which":require("./features/keyboardevent-which"),"lazyload":require("./features/lazyload"),"let":require("./features/let"),"link-icon-png":require("./features/link-icon-png"),"link-icon-svg":require("./features/link-icon-svg"),"link-rel-dns-prefetch":require("./features/link-rel-dns-prefetch"),"link-rel-preconnect":require("./features/link-rel-preconnect"),"link-rel-prefetch":require("./features/link-rel-prefetch"),"link-rel-preload":require("./features/link-rel-preload"),"link-rel-prerender":require("./features/link-rel-prerender"),"localecompare":require("./features/localecompare"),"matchesselector":require("./features/matchesselector"),"matchmedia":require("./features/matchmedia"),"mathml":require("./features/mathml"),"maxlength":require("./features/maxlength"),"media-attribute":require("./features/media-attribute"),"media-session-api":require("./features/media-session-api"),"mediacapture-fromelement":require("./features/mediacapture-fromelement"),"mediarecorder":require("./features/mediarecorder"),"mediasource":require("./features/mediasource"),"menu":require("./features/menu"),"meter":require("./features/meter"),"midi":require("./features/midi"),"minmaxwh":require("./features/minmaxwh"),"mp3":require("./features/mp3"),"mpeg4":require("./features/mpeg4"),"multibackgrounds":require("./features/multibackgrounds"),"multicolumn":require("./features/multicolumn"),"mutation-events":require("./features/mutation-events"),"mutationobserver":require("./features/mutationobserver"),"namevalue-storage":require("./features/namevalue-storage"),"nav-timing":require("./features/nav-timing"),"netinfo":require("./features/netinfo"),"node-contains":require("./features/node-contains"),"node-parentelement":require("./features/node-parentelement"),"notifications":require("./features/notifications"),"object-fit":require("./features/object-fit"),"object-observe":require("./features/object-observe"),"objectrtc":require("./features/objectrtc"),"offline-apps":require("./features/offline-apps"),"offscreencanvas":require("./features/offscreencanvas"),"ogg-vorbis":require("./features/ogg-vorbis"),"ogv":require("./features/ogv"),"ol-reversed":require("./features/ol-reversed"),"once-event-listener":require("./features/once-event-listener"),"online-status":require("./features/online-status"),"opus":require("./features/opus"),"outline":require("./features/outline"),"pad-start-end":require("./features/pad-start-end"),"page-transition-events":require("./features/page-transition-events"),"pagevisibility":require("./features/pagevisibility"),"passive-event-listener":require("./features/passive-event-listener"),"payment-request":require("./features/payment-request"),"permissions-api":require("./features/permissions-api"),"picture":require("./features/picture"),"ping":require("./features/ping"),"png-alpha":require("./features/png-alpha"),"pointer-events":require("./features/pointer-events"),"pointer":require("./features/pointer"),"pointerlock":require("./features/pointerlock"),"progress":require("./features/progress"),"promises":require("./features/promises"),"proximity":require("./features/proximity"),"proxy":require("./features/proxy"),"publickeypinning":require("./features/publickeypinning"),"push-api":require("./features/push-api"),"queryselector":require("./features/queryselector"),"readonly-attr":require("./features/readonly-attr"),"referrer-policy":require("./features/referrer-policy"),"registerprotocolhandler":require("./features/registerprotocolhandler"),"rel-noopener":require("./features/rel-noopener"),"rel-noreferrer":require("./features/rel-noreferrer"),"rellist":require("./features/rellist"),"rem":require("./features/rem"),"requestanimationframe":require("./features/requestanimationframe"),"requestidlecallback":require("./features/requestidlecallback"),"resizeobserver":require("./features/resizeobserver"),"resource-timing":require("./features/resource-timing"),"rest-parameters":require("./features/rest-parameters"),"rtcpeerconnection":require("./features/rtcpeerconnection"),"ruby":require("./features/ruby"),"same-site-cookie-attribute":require("./features/same-site-cookie-attribute"),"screen-orientation":require("./features/screen-orientation"),"script-async":require("./features/script-async"),"script-defer":require("./features/script-defer"),"scrollintoview":require("./features/scrollintoview"),"scrollintoviewifneeded":require("./features/scrollintoviewifneeded"),"sdch":require("./features/sdch"),"selection-api":require("./features/selection-api"),"serviceworkers":require("./features/serviceworkers"),"setimmediate":require("./features/setimmediate"),"sha-2":require("./features/sha-2"),"shadowdom":require("./features/shadowdom"),"shadowdomv1":require("./features/shadowdomv1"),"sharedworkers":require("./features/sharedworkers"),"sni":require("./features/sni"),"spdy":require("./features/spdy"),"speech-recognition":require("./features/speech-recognition"),"speech-synthesis":require("./features/speech-synthesis"),"spellcheck-attribute":require("./features/spellcheck-attribute"),"sql-storage":require("./features/sql-storage"),"srcset":require("./features/srcset"),"stopimmediatepropagation":require("./features/stopimmediatepropagation"),"stream":require("./features/stream"),"stricttransportsecurity":require("./features/stricttransportsecurity"),"style-scoped":require("./features/style-scoped"),"subresource-integrity":require("./features/subresource-integrity"),"svg-css":require("./features/svg-css"),"svg-filters":require("./features/svg-filters"),"svg-fonts":require("./features/svg-fonts"),"svg-fragment":require("./features/svg-fragment"),"svg-html":require("./features/svg-html"),"svg-html5":require("./features/svg-html5"),"svg-img":require("./features/svg-img"),"svg-smil":require("./features/svg-smil"),"svg":require("./features/svg"),"tabindex-attr":require("./features/tabindex-attr"),"template-literals":require("./features/template-literals"),"template":require("./features/template"),"testfeat":require("./features/testfeat"),"text-decoration":require("./features/text-decoration"),"text-emphasis":require("./features/text-emphasis"),"text-overflow":require("./features/text-overflow"),"text-size-adjust":require("./features/text-size-adjust"),"text-stroke":require("./features/text-stroke"),"textcontent":require("./features/textcontent"),"textencoder":require("./features/textencoder"),"tls1-1":require("./features/tls1-1"),"tls1-2":require("./features/tls1-2"),"tls1-3":require("./features/tls1-3"),"token-binding":require("./features/token-binding"),"touch":require("./features/touch"),"transforms2d":require("./features/transforms2d"),"transforms3d":require("./features/transforms3d"),"ttf":require("./features/ttf"),"typedarrays":require("./features/typedarrays"),"u2f":require("./features/u2f"),"upgradeinsecurerequests":require("./features/upgradeinsecurerequests"),"url":require("./features/url"),"urlsearchparams":require("./features/urlsearchparams"),"use-strict":require("./features/use-strict"),"user-select-none":require("./features/user-select-none"),"user-timing":require("./features/user-timing"),"vibration":require("./features/vibration"),"video":require("./features/video"),"videotracks":require("./features/videotracks"),"viewport-units":require("./features/viewport-units"),"wai-aria":require("./features/wai-aria"),"wasm":require("./features/wasm"),"wav":require("./features/wav"),"wbr-element":require("./features/wbr-element"),"web-animation":require("./features/web-animation"),"web-app-manifest":require("./features/web-app-manifest"),"web-bluetooth":require("./features/web-bluetooth"),"web-share":require("./features/web-share"),"webgl":require("./features/webgl"),"webgl2":require("./features/webgl2"),"webm":require("./features/webm"),"webp":require("./features/webp"),"websockets":require("./features/websockets"),"webvr":require("./features/webvr"),"webvtt":require("./features/webvtt"),"webworkers":require("./features/webworkers"),"will-change":require("./features/will-change"),"woff":require("./features/woff"),"woff2":require("./features/woff2"),"word-break":require("./features/word-break"),"wordwrap":require("./features/wordwrap"),"x-doc-messaging":require("./features/x-doc-messaging"),"x-frame-options":require("./features/x-frame-options"),"xhr2":require("./features/xhr2"),"xhtml":require("./features/xhtml"),"xhtmlsmil":require("./features/xhtmlsmil"),"xml-serializer":require("./features/xml-serializer")};

},{"./features/aac":121,"./features/ac3-ec3":122,"./features/addeventlistener":123,"./features/alternate-stylesheet":124,"./features/ambient-light":125,"./features/apng":126,"./features/arrow-functions":127,"./features/asmjs":128,"./features/async-functions":129,"./features/atob-btoa":130,"./features/audio":132,"./features/audio-api":131,"./features/audiotracks":133,"./features/autofocus":134,"./features/aux-click":135,"./features/background-attachment":136,"./features/background-img-opts":137,"./features/background-position-x-y":138,"./features/background-repeat-round-space":139,"./features/battery-status":140,"./features/beacon":141,"./features/beforeafterprint":142,"./features/blobbuilder":143,"./features/bloburls":144,"./features/border-image":145,"./features/border-radius":146,"./features/broadcastchannel":147,"./features/brotli":148,"./features/calc":149,"./features/canvas":152,"./features/canvas-blending":150,"./features/canvas-text":151,"./features/ch-unit":153,"./features/chacha20-poly1305":154,"./features/channel-messaging":155,"./features/childnode-remove":156,"./features/classlist":157,"./features/client-hints-dpr-width-viewport":158,"./features/clipboard":159,"./features/comparedocumentposition":160,"./features/console-basic":161,"./features/const":162,"./features/constraint-validation":163,"./features/contenteditable":164,"./features/contentsecuritypolicy":165,"./features/contentsecuritypolicy2":166,"./features/cors":167,"./features/credential-management":168,"./features/cryptography":169,"./features/css-all":170,"./features/css-animation":171,"./features/css-any-link":172,"./features/css-appearance":173,"./features/css-apply-rule":174,"./features/css-at-counter-style":175,"./features/css-backdrop-filter":176,"./features/css-background-offsets":177,"./features/css-backgroundblendmode":178,"./features/css-boxdecorationbreak":179,"./features/css-boxshadow":180,"./features/css-canvas":181,"./features/css-caret-color":182,"./features/css-case-insensitive":183,"./features/css-clip-path":184,"./features/css-conic-gradients":185,"./features/css-containment":186,"./features/css-counters":187,"./features/css-crisp-edges":188,"./features/css-cross-fade":189,"./features/css-default-pseudo":190,"./features/css-descendant-gtgt":191,"./features/css-deviceadaptation":192,"./features/css-dir-pseudo":193,"./features/css-display-contents":194,"./features/css-element-function":195,"./features/css-exclusions":196,"./features/css-featurequeries":197,"./features/css-filter-function":198,"./features/css-filters":199,"./features/css-first-letter":200,"./features/css-first-line":201,"./features/css-fixed":202,"./features/css-focus-within":203,"./features/css-font-rendering-controls":204,"./features/css-font-stretch":205,"./features/css-gencontent":206,"./features/css-gradients":207,"./features/css-grid":208,"./features/css-hanging-punctuation":209,"./features/css-has":210,"./features/css-hyphenate":211,"./features/css-hyphens":212,"./features/css-image-orientation":213,"./features/css-image-set":214,"./features/css-in-out-of-range":215,"./features/css-indeterminate-pseudo":216,"./features/css-initial-letter":217,"./features/css-initial-value":218,"./features/css-letter-spacing":219,"./features/css-line-clamp":220,"./features/css-logical-props":221,"./features/css-marker-pseudo":222,"./features/css-masks":223,"./features/css-matches-pseudo":224,"./features/css-media-interaction":225,"./features/css-media-resolution":226,"./features/css-media-scripting":227,"./features/css-mediaqueries":228,"./features/css-mixblendmode":229,"./features/css-motion-paths":230,"./features/css-namespaces":231,"./features/css-not-sel-list":232,"./features/css-nth-child-of":233,"./features/css-opacity":234,"./features/css-optional-pseudo":235,"./features/css-overflow-anchor":236,"./features/css-page-break":237,"./features/css-paged-media":238,"./features/css-placeholder":240,"./features/css-placeholder-shown":239,"./features/css-read-only-write":241,"./features/css-rebeccapurple":242,"./features/css-reflections":243,"./features/css-regions":244,"./features/css-repeating-gradients":245,"./features/css-resize":246,"./features/css-revert-value":247,"./features/css-rrggbbaa":248,"./features/css-scroll-behavior":249,"./features/css-scrollbar":250,"./features/css-sel2":251,"./features/css-sel3":252,"./features/css-selection":253,"./features/css-shapes":254,"./features/css-snappoints":255,"./features/css-sticky":256,"./features/css-supports-api":257,"./features/css-table":258,"./features/css-text-align-last":259,"./features/css-text-indent":260,"./features/css-text-justify":261,"./features/css-text-orientation":262,"./features/css-text-spacing":263,"./features/css-textshadow":264,"./features/css-touch-action":266,"./features/css-touch-action-2":265,"./features/css-transitions":267,"./features/css-unicode-bidi":268,"./features/css-unset-value":269,"./features/css-variables":270,"./features/css-widows-orphans":271,"./features/css-writing-mode":272,"./features/css-zoom":273,"./features/css3-attr":274,"./features/css3-boxsizing":275,"./features/css3-colors":276,"./features/css3-cursors":279,"./features/css3-cursors-grab":277,"./features/css3-cursors-newer":278,"./features/css3-tabsize":280,"./features/currentcolor":281,"./features/custom-elements":282,"./features/custom-elementsv1":283,"./features/customevent":284,"./features/datalist":285,"./features/dataset":286,"./features/datauri":287,"./features/details":288,"./features/deviceorientation":289,"./features/devicepixelratio":290,"./features/dialog":291,"./features/dispatchevent":292,"./features/document-currentscript":293,"./features/document-evaluate-xpath":294,"./features/document-execcommand":295,"./features/documenthead":296,"./features/dom-manip-convenience":297,"./features/dom-range":298,"./features/domcontentloaded":299,"./features/domfocusin-domfocusout-events":300,"./features/dommatrix":301,"./features/download":302,"./features/dragndrop":303,"./features/element-closest":304,"./features/element-from-point":305,"./features/eme":306,"./features/eot":307,"./features/es5":308,"./features/es6-class":309,"./features/es6-generators":310,"./features/es6-module":313,"./features/es6-module-dynamic-import":311,"./features/es6-module-nomodule":312,"./features/es6-number":314,"./features/eventsource":315,"./features/fetch":316,"./features/fieldset-disabled":317,"./features/fileapi":318,"./features/filereader":319,"./features/filereadersync":320,"./features/filesystem":321,"./features/flac":322,"./features/flexbox":323,"./features/flow-root":324,"./features/focusin-focusout-events":325,"./features/font-feature":326,"./features/font-kerning":327,"./features/font-loading":328,"./features/font-size-adjust":329,"./features/font-smooth":330,"./features/font-unicode-range":331,"./features/font-variant-alternates":332,"./features/fontface":333,"./features/form-attribute":334,"./features/form-submit-attributes":335,"./features/form-validation":336,"./features/forms":337,"./features/fullscreen":338,"./features/gamepad":339,"./features/geolocation":340,"./features/getboundingclientrect":341,"./features/getcomputedstyle":342,"./features/getelementsbyclassname":343,"./features/getrandomvalues":344,"./features/hardwareconcurrency":345,"./features/hashchange":346,"./features/heif":347,"./features/hevc":348,"./features/hidden":349,"./features/high-resolution-time":350,"./features/history":351,"./features/html-media-capture":352,"./features/html5semantic":353,"./features/http-live-streaming":354,"./features/http2":355,"./features/iframe-sandbox":356,"./features/iframe-seamless":357,"./features/iframe-srcdoc":358,"./features/imagecapture":359,"./features/ime":360,"./features/img-naturalwidth-naturalheight":361,"./features/imports":362,"./features/indeterminate-checkbox":363,"./features/indexeddb":364,"./features/indexeddb2":365,"./features/inline-block":366,"./features/innertext":367,"./features/input-autocomplete-onoff":368,"./features/input-color":369,"./features/input-datetime":370,"./features/input-email-tel-url":371,"./features/input-event":372,"./features/input-file-accept":373,"./features/input-file-directory":374,"./features/input-file-multiple":375,"./features/input-inputmode":376,"./features/input-minlength":377,"./features/input-number":378,"./features/input-pattern":379,"./features/input-placeholder":380,"./features/input-range":381,"./features/input-search":382,"./features/insert-adjacent":383,"./features/insertadjacenthtml":384,"./features/internationalization":385,"./features/intersectionobserver":386,"./features/intrinsic-width":387,"./features/jpeg2000":388,"./features/jpegxr":389,"./features/json":390,"./features/kerning-pairs-ligatures":391,"./features/keyboardevent-charcode":392,"./features/keyboardevent-code":393,"./features/keyboardevent-getmodifierstate":394,"./features/keyboardevent-key":395,"./features/keyboardevent-location":396,"./features/keyboardevent-which":397,"./features/lazyload":398,"./features/let":399,"./features/link-icon-png":400,"./features/link-icon-svg":401,"./features/link-rel-dns-prefetch":402,"./features/link-rel-preconnect":403,"./features/link-rel-prefetch":404,"./features/link-rel-preload":405,"./features/link-rel-prerender":406,"./features/localecompare":407,"./features/matchesselector":408,"./features/matchmedia":409,"./features/mathml":410,"./features/maxlength":411,"./features/media-attribute":412,"./features/media-session-api":413,"./features/mediacapture-fromelement":414,"./features/mediarecorder":415,"./features/mediasource":416,"./features/menu":417,"./features/meter":418,"./features/midi":419,"./features/minmaxwh":420,"./features/mp3":421,"./features/mpeg4":422,"./features/multibackgrounds":423,"./features/multicolumn":424,"./features/mutation-events":425,"./features/mutationobserver":426,"./features/namevalue-storage":427,"./features/nav-timing":428,"./features/netinfo":429,"./features/node-contains":430,"./features/node-parentelement":431,"./features/notifications":432,"./features/object-fit":433,"./features/object-observe":434,"./features/objectrtc":435,"./features/offline-apps":436,"./features/offscreencanvas":437,"./features/ogg-vorbis":438,"./features/ogv":439,"./features/ol-reversed":440,"./features/once-event-listener":441,"./features/online-status":442,"./features/opus":443,"./features/outline":444,"./features/pad-start-end":445,"./features/page-transition-events":446,"./features/pagevisibility":447,"./features/passive-event-listener":448,"./features/payment-request":449,"./features/permissions-api":450,"./features/picture":451,"./features/ping":452,"./features/png-alpha":453,"./features/pointer":455,"./features/pointer-events":454,"./features/pointerlock":456,"./features/progress":457,"./features/promises":458,"./features/proximity":459,"./features/proxy":460,"./features/publickeypinning":461,"./features/push-api":462,"./features/queryselector":463,"./features/readonly-attr":464,"./features/referrer-policy":465,"./features/registerprotocolhandler":466,"./features/rel-noopener":467,"./features/rel-noreferrer":468,"./features/rellist":469,"./features/rem":470,"./features/requestanimationframe":471,"./features/requestidlecallback":472,"./features/resizeobserver":473,"./features/resource-timing":474,"./features/rest-parameters":475,"./features/rtcpeerconnection":476,"./features/ruby":477,"./features/same-site-cookie-attribute":478,"./features/screen-orientation":479,"./features/script-async":480,"./features/script-defer":481,"./features/scrollintoview":482,"./features/scrollintoviewifneeded":483,"./features/sdch":484,"./features/selection-api":485,"./features/serviceworkers":486,"./features/setimmediate":487,"./features/sha-2":488,"./features/shadowdom":489,"./features/shadowdomv1":490,"./features/sharedworkers":491,"./features/sni":492,"./features/spdy":493,"./features/speech-recognition":494,"./features/speech-synthesis":495,"./features/spellcheck-attribute":496,"./features/sql-storage":497,"./features/srcset":498,"./features/stopimmediatepropagation":499,"./features/stream":500,"./features/stricttransportsecurity":501,"./features/style-scoped":502,"./features/subresource-integrity":503,"./features/svg":512,"./features/svg-css":504,"./features/svg-filters":505,"./features/svg-fonts":506,"./features/svg-fragment":507,"./features/svg-html":508,"./features/svg-html5":509,"./features/svg-img":510,"./features/svg-smil":511,"./features/tabindex-attr":513,"./features/template":515,"./features/template-literals":514,"./features/testfeat":516,"./features/text-decoration":517,"./features/text-emphasis":518,"./features/text-overflow":519,"./features/text-size-adjust":520,"./features/text-stroke":521,"./features/textcontent":522,"./features/textencoder":523,"./features/tls1-1":524,"./features/tls1-2":525,"./features/tls1-3":526,"./features/token-binding":527,"./features/touch":528,"./features/transforms2d":529,"./features/transforms3d":530,"./features/ttf":531,"./features/typedarrays":532,"./features/u2f":533,"./features/upgradeinsecurerequests":534,"./features/url":535,"./features/urlsearchparams":536,"./features/use-strict":537,"./features/user-select-none":538,"./features/user-timing":539,"./features/vibration":540,"./features/video":541,"./features/videotracks":542,"./features/viewport-units":543,"./features/wai-aria":544,"./features/wasm":545,"./features/wav":546,"./features/wbr-element":547,"./features/web-animation":548,"./features/web-app-manifest":549,"./features/web-bluetooth":550,"./features/web-share":551,"./features/webgl":552,"./features/webgl2":553,"./features/webm":554,"./features/webp":555,"./features/websockets":556,"./features/webvr":557,"./features/webvtt":558,"./features/webworkers":559,"./features/will-change":560,"./features/woff":561,"./features/woff2":562,"./features/word-break":563,"./features/wordwrap":564,"./features/x-doc-messaging":565,"./features/x-frame-options":566,"./features/xhr2":567,"./features/xhtml":568,"./features/xhtmlsmil":569,"./features/xml-serializer":570}],121:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q QB PB","132":"0 1 4 5 R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"1":"0 1 4 5 8 D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E","16":"B A"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","2":"9 DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","16":"9"},H:{"2":"dB"},I:{"1":"2 3 F s hB iB jB","2":"eB fB gB"},J:{"1":"B","2":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"132":"t"},N:{"1":"B","2":"A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"AAC audio file format"};

},{}],122:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G AB VB WB XB YB","132":"A ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C","132":"B"},K:{"2":"6 7 B A D K","132":"y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"132":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:6,C:"AC-3 (Dolby Digital) and EC-3 (Dolby Digital Plus) codecs"};

},{}],123:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","130":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","257":"2 SB F I J QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"EventTarget.addEventListener()"};

},{}],124:[function(require,module,exports){
module.exports={A:{A:{"1":"G E B A","2":"J C UB"},B:{"2":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D LB MB NB OB RB y","16":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"16":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"16":"C B"},K:{"16":"6 7 B A D K y"},L:{"16":"8"},M:{"16":"t"},N:{"16":"B A"},O:{"16":"kB"},P:{"16":"F I"},Q:{"2":"lB"},R:{"16":"mB"}},B:1,C:"Alternate stylesheet"};

},{}],125:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"g H L","2":"D X"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q QB PB","132":"0 1 4 5 R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"2":"0 1 4 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","322":"5 8 EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:4,C:"Ambient Light API"};

},{}],126:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 2 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"SB"},D:{"1":"8 EB BB TB CB","2":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},E:{"1":"G E B A IB JB KB","2":"9 F I J C DB FB GB HB"},F:{"1":"6 7 A D p q r LB MB NB OB RB y","2":"E H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o"},G:{"1":"G A YB ZB aB bB cB","2":"3 9 AB VB WB XB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"6 7 B A D y","2":"K"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"Animated PNG (APNG)"};

},{}],127:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q QB PB"},D:{"1":"0 1 4 5 8 o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n"},E:{"1":"B A JB KB","2":"9 F I J C G E DB FB GB HB IB"},F:{"1":"b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a LB MB NB OB RB y"},G:{"1":"A bB cB","2":"3 9 G AB VB WB XB YB ZB aB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:6,C:"Arrow functions"};

},{}],128:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"X g H L","322":"D"},C:{"1":"0 1 4 5 R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q QB PB"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W","132":"0 1 4 5 8 u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D LB MB NB OB RB y","132":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","132":"s"},J:{"2":"C B"},K:{"2":"6 7 B A D y","132":"K"},L:{"132":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F","132":"I"},Q:{"132":"lB"},R:{"132":"mB"}},B:6,C:"asm.js"};

},{}],129:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"H L","2":"D X","194":"g"},C:{"1":"0 1 4 5 z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v QB PB"},D:{"1":"4 5 8 t s EB BB TB CB","2":"0 1 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z"},E:{"1":"A JB KB","2":"9 F I J C G E B DB FB GB HB IB"},F:{"1":"l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k LB MB NB OB RB y"},G:{"1":"A cB","2":"3 9 G AB VB WB XB YB ZB aB bB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:6,C:"Async functions"};

},{}],130:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r OB RB y","2":"E LB MB","16":"NB"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","16":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Base64 encoding and decoding"};

},{}],131:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T QB PB"},D:{"1":"0 1 4 5 8 d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E","33":"B A D X g H L M N O P Q R S T U V W u Y Z a b c"},E:{"2":"9 F I DB FB","33":"J C G E B A GB HB IB JB KB"},F:{"1":"R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y","33":"H L M N O P Q"},G:{"2":"3 9 AB VB","33":"G A WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"Web Audio API"};

},{}],132:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB","132":"F I J C G E B A D X g H L M N O QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","2":"9 DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r NB OB RB y","2":"E","4":"LB MB"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","2":"9"},H:{"2":"dB"},I:{"1":"2 3 F s gB hB iB jB","2":"eB fB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Audio element"};

},{}],133:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b QB PB","194":"0 1 4 5 c d e f K h i j k l m n o p q r w x v z t s"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"C G E B A GB HB IB JB KB","2":"9 F I J DB FB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB WB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"1":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:1,C:"Audio Tracks"};

},{}],134:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F"},E:{"1":"I J C G E B A FB GB HB IB JB KB","2":"9 F DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","2":"E"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"2 3 F s hB iB jB","2":"eB fB gB"},J:{"1":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"2":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Autofocus attribute"};

},{}],135:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z QB PB","129":"0 1 4 5 t s"},D:{"1":"4 5 8 t s EB BB TB CB","2":"0 1 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C","16":"B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"16":"kB"},P:{"1":"I","16":"F"},Q:{"16":"lB"},R:{"1":"mB"}},B:5,C:"Auxclick"};

},{}],136:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","132":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","132":"2 SB F I J C G E B A D X g H L M N O P Q R S T QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"I J C G E B A FB GB HB IB JB KB","132":"9 F DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r NB OB RB y","132":"E LB MB"},G:{"2":"3 9 AB","772":"G A VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 F s eB fB gB iB jB","132":"3 hB"},J:{"260":"C B"},K:{"1":"6 7 A D K y","132":"B"},L:{"1028":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"132":"kB"},P:{"2":"F","1028":"I"},Q:{"1":"lB"},R:{"1028":"mB"}},B:4,C:"CSS background-attachment"};

},{}],137:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB","36":"PB"},D:{"1":"0 1 4 5 8 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","516":"F I J C G E B A D X g"},E:{"1":"C G E B A HB IB JB KB","772":"9 F I J DB FB GB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r NB OB RB y","2":"E LB","36":"MB"},G:{"1":"G A XB YB ZB aB bB cB","4":"3 9 AB WB","516":"VB"},H:{"132":"dB"},I:{"1":"s iB jB","36":"eB","516":"2 3 F hB","548":"fB gB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS3 Background-image options"};

},{}],138:[function(require,module,exports){
module.exports={A:{A:{"1":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:7,C:"background-position-x & background-position-y"};

},{}],139:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G UB","132":"E"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r QB PB"},D:{"1":"0 1 4 5 8 b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a"},E:{"1":"C G E B A HB IB JB KB","2":"9 F I J DB FB GB"},F:{"1":"6 7 A D O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r NB OB RB y","2":"E H L M N LB MB"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB WB"},H:{"1":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"B","2":"C"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS background-repeat round and space"};

},{}],140:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"m n o p q r w x v","2":"0 1 2 4 5 SB F I J C G E z t s QB PB","132":"L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l","164":"B A D X g H"},D:{"1":"0 1 4 5 8 h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f","66":"K"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"132":"kB"},P:{"1":"F I"},Q:{"2":"lB"},R:{"1":"mB"}},B:4,C:"Battery Status API"};

},{}],141:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"g H L","2":"D X"},C:{"1":"0 1 4 5 a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z QB PB"},D:{"1":"0 1 4 5 8 i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h"},E:{"1":"KB","2":"9 F I J C G E B A DB FB GB HB IB JB"},F:{"1":"V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"Beacon API"};

},{}],142:[function(require,module,exports){
module.exports={A:{A:{"1":"J C G E B A","16":"UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"16":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"1":"t"},N:{"16":"B A"},O:{"16":"kB"},P:{"2":"I","16":"F"},Q:{"2":"lB"},R:{"2":"mB"}},B:2,C:"Printing Events"};

},{}],143:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I QB PB","36":"J C G E B A D"},D:{"1":"0 1 4 5 8 P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C","36":"G E B A D X g H L M N O"},E:{"1":"J C G E B A GB HB IB JB KB","2":"9 F I DB FB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"6 7 E A D LB MB NB OB RB"},G:{"1":"G A WB XB YB ZB aB bB cB","2":"3 9 AB VB"},H:{"2":"dB"},I:{"1":"s","2":"eB fB gB","36":"2 3 F hB iB jB"},J:{"1":"B","2":"C"},K:{"1":"K y","2":"6 7 B A D"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"Blob constructing"};

},{}],144:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"129":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C","33":"G E B A D X g H L M N O P Q R"},E:{"1":"C G E B A GB HB IB JB KB","2":"9 F I DB FB","33":"J"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB","33":"WB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 eB fB gB","33":"3 F hB"},J:{"1":"B","2":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","2":"B"},O:{"33":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"Blob URLs"};

},{}],145:[function(require,module,exports){
module.exports={A:{A:{"1":"A","2":"J C G E B UB"},B:{"1":"g H L","129":"D X"},C:{"1":"0 1 4 5 x v z t s","2":"2 SB","260":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w","804":"F I J C G E B A D X g QB PB"},D:{"260":"0 1 4 5 8 v z t s EB BB TB CB","388":"Z a b c d e f K h i j k l m n o p q r w x","1412":"H L M N O P Q R S T U V W u Y","1956":"F I J C G E B A D X g"},E:{"129":"B A IB JB KB","1412":"J C G E GB HB","1956":"9 F I DB FB"},F:{"2":"E LB MB","260":"h i j k l m n o p q r","388":"H L M N O P Q R S T U V W u Y Z a b c d e f K","1796":"NB OB","1828":"6 7 A D RB y"},G:{"129":"A aB bB cB","1412":"G WB XB YB ZB","1956":"3 9 AB VB"},H:{"1828":"dB"},I:{"388":"s iB jB","1956":"2 3 F eB fB gB hB"},J:{"1412":"B","1924":"C"},K:{"2":"B","388":"K","1828":"6 7 A D y"},L:{"260":"8"},M:{"1":"t"},N:{"1":"A","2":"B"},O:{"388":"kB"},P:{"260":"I","388":"F"},Q:{"260":"lB"},R:{"260":"mB"}},B:4,C:"CSS3 Border images"};

},{}],146:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 x v z t s","257":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w","289":"2 QB PB","292":"SB"},D:{"1":"0 1 4 5 8 I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","33":"F"},E:{"1":"I C G E B A HB IB JB KB","33":"9 F DB","129":"J FB GB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r NB OB RB y","2":"E LB MB"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","33":"9"},H:{"2":"dB"},I:{"1":"2 3 F s fB gB hB iB jB","33":"eB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS3 Border-radius (rounded corners)"};

},{}],147:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K QB PB"},D:{"1":"1 4 5 8 t s EB BB TB CB","2":"0 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:1,C:"BroadcastChannel"};

},{}],148:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"H L","2":"D X g"},C:{"1":"0 1 4 5 n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m QB PB"},D:{"1":"0 1 4 5 8 v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","194":"w","257":"x"},E:{"2":"9 F I J C G E B DB FB GB HB IB JB","513":"A KB"},F:{"1":"h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e LB MB NB OB RB y","194":"f K"},G:{"1":"A","2":"3 9 G AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","257":"s"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"1":"lB"},R:{"2":"mB"}},B:6,C:"Brotli Accept-Encoding/Content-Encoding"};

},{}],149:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G UB","260":"E"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB","33":"F I J C G E B A D X g H"},D:{"1":"0 1 4 5 8 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N","33":"O P Q R S T U"},E:{"1":"C G E B A GB HB IB JB KB","2":"9 F I DB FB","33":"J"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB","33":"WB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB","132":"iB jB"},J:{"1":"B","2":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"calc() as CSS unit value"};

},{}],150:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"X g H L","2":"D"},C:{"1":"0 1 4 5 P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O QB PB"},D:{"1":"0 1 4 5 8 Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y"},E:{"1":"C G E B A GB HB IB JB KB","2":"9 F I J DB FB"},F:{"1":"M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L LB MB NB OB RB y"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB WB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"Canvas blend modes"};

},{}],151:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"UB","8":"J C G"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","8":"2 SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","8":"9 DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r NB OB RB y","8":"E LB MB"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","8":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Text API for Canvas"};

},{}],152:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"UB","8":"J C G"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s PB","132":"2 SB QB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","132":"9 DB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"260":"dB"},I:{"1":"2 3 F s hB iB jB","132":"eB fB gB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Canvas (basic support)"};

},{}],153:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G UB","132":"E B A"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V"},E:{"1":"C G E B A HB IB JB KB","2":"9 F I J DB FB GB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB WB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"B","2":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"ch (character) unit"};

},{}],154:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p QB PB"},D:{"1":"0 1 4 5 8 w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b","129":"c d e f K h i j k l m n o p q r"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB","16":"jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"ChaCha20-Poly1305 cipher suites for TLS"};

},{}],155:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U QB PB","194":"V W u Y Z a b c d e f K h i j"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"I J C G E B A FB GB HB IB JB KB","2":"9 F DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r OB RB y","2":"E LB MB","16":"NB"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Channel messaging"};

},{}],156:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"X g H L","16":"D"},C:{"1":"0 1 4 5 S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R QB PB"},D:{"1":"0 1 4 5 8 T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S"},E:{"1":"C G E B A GB HB IB JB KB","2":"9 F I DB FB","16":"J"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB WB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"B","2":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"ChildNode.remove()"};

},{}],157:[function(require,module,exports){
module.exports={A:{A:{"8":"J C G E UB","900":"B A"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","8":"2 SB QB","516":"T U","772":"F I J C G E B A D X g H L M N O P Q R S PB"},D:{"1":"0 1 4 5 8 u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","8":"F I J C","516":"T U V W","772":"S","900":"G E B A D X g H L M N O P Q R"},E:{"1":"C G E B A HB IB JB KB","8":"9 F I DB","900":"J FB GB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","8":"7 E A LB MB NB OB","900":"6 D RB y"},G:{"1":"G A XB YB ZB aB bB cB","8":"3 9 AB","900":"VB WB"},H:{"900":"dB"},I:{"1":"s iB jB","8":"eB fB gB","900":"2 3 F hB"},J:{"1":"B","900":"C"},K:{"1":"K","8":"B A","900":"6 7 D y"},L:{"1":"8"},M:{"1":"t"},N:{"900":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"classList (DOMTokenList)"};

},{}],158:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:6,C:"Client Hints: DPR, Width, Viewport-Width"};

},{}],159:[function(require,module,exports){
module.exports={A:{A:{"2436":"J C G E B A UB"},B:{"2436":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q QB PB","772":"R S T U V W u Y Z a b c d e f K h i j","4100":"0 1 4 5 k l m n o p q r w x v z t s"},D:{"2":"F I J C G E B A D","2564":"X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l","10244":"0 1 4 5 8 m n o p q r w x v z t s EB BB TB CB"},E:{"16":"9 DB","2308":"B A JB KB","2820":"F I J C G E FB GB HB IB"},F:{"2":"6 7 E A LB MB NB OB RB","16":"D","516":"y","2564":"H L M N O P Q R S T U V W u Y","10244":"Z a b c d e f K h i j k l m n o p q r"},G:{"2":"3 9 AB","2820":"G A VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB","2308":"s iB jB"},J:{"2":"C","2308":"B"},K:{"2":"6 7 B A D","16":"y","3076":"K"},L:{"2052":"8"},M:{"1028":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2052":"I","2308":"F"},Q:{"10244":"lB"},R:{"2052":"mB"}},B:5,C:"Clipboard API"};

},{}],160:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","16":"2 SB QB PB"},D:{"1":"0 1 4 5 8 Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g","132":"H L M N O P Q R S T U V W u Y"},E:{"1":"B A JB KB","16":"9 F I J DB","132":"C G E GB HB IB","260":"FB"},F:{"1":"D M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","16":"6 7 E A LB MB NB OB","132":"H L"},G:{"1":"A bB cB","16":"9","132":"3 G AB VB WB XB YB ZB aB"},H:{"1":"dB"},I:{"1":"s iB jB","16":"eB fB","132":"2 3 F gB hB"},J:{"132":"C B"},K:{"1":"D K y","16":"6 7 B A"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Node.compareDocumentPosition()"};

},{}],161:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C UB","132":"G E"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"E LB MB NB OB"},G:{"1":"3 9 AB VB","513":"G A WB XB YB ZB aB bB cB"},H:{"4097":"dB"},I:{"1025":"2 3 F s eB fB gB hB iB jB"},J:{"258":"C B"},K:{"2":"B","258":"6 7 A D K y"},L:{"1025":"8"},M:{"2049":"t"},N:{"258":"B A"},O:{"258":"kB"},P:{"1025":"F I"},Q:{"1":"lB"},R:{"1025":"mB"}},B:1,C:"Basic console logging functions"};

},{}],162:[function(require,module,exports){
module.exports={A:{A:{"1":"A","2":"J C G E B UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 f K h i j k l m n o p q r w x v z t s","132":"2 SB F I J C G E B A D QB PB","260":"X g H L M N O P Q R S T U V W u Y Z a b c d e"},D:{"1":"0 1 4 5 8 w x v z t s EB BB TB CB","260":"F I J C G E B A D X g H L M N O P","772":"Q R S T U V W u Y Z a b c d e f K h i j","1028":"k l m n o p q r"},E:{"1":"B A JB KB","260":"9 F I DB","772":"J C G E FB GB HB IB"},F:{"1":"f K h i j k l m n o p q r","2":"E LB","132":"6 7 A MB NB OB","644":"D RB y","772":"H L M N O P Q R S T U V W","1028":"u Y Z a b c d e"},G:{"1":"A bB cB","260":"3 9 AB","772":"G VB WB XB YB ZB aB"},H:{"644":"dB"},I:{"1":"s","16":"eB fB","260":"gB","772":"2 3 F hB iB jB"},J:{"772":"C B"},K:{"1":"K","132":"6 7 B A","644":"D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","2":"B"},O:{"772":"kB"},P:{"1":"I","1028":"F"},Q:{"772":"lB"},R:{"1028":"mB"}},B:6,C:"const"};

},{}],163:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E UB","900":"B A"},B:{"388":"g H L","900":"D X"},C:{"1":"0 1 4 5 v z t s","2":"2 SB QB PB","260":"w x","388":"Y Z a b c d e f K h i j k l m n o p q r","900":"F I J C G E B A D X g H L M N O P Q R S T U V W u"},D:{"1":"0 1 4 5 8 j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g","388":"U V W u Y Z a b c d e f K h i","900":"H L M N O P Q R S T"},E:{"1":"B A JB KB","16":"9 F I DB","388":"G E HB IB","900":"J C FB GB"},F:{"1":"W u Y Z a b c d e f K h i j k l m n o p q r","16":"6 7 E A LB MB NB OB","388":"H L M N O P Q R S T U V","900":"D RB y"},G:{"1":"A bB cB","16":"3 9 AB","388":"G XB YB ZB aB","900":"VB WB"},H:{"2":"dB"},I:{"1":"s","16":"2 eB fB gB","388":"iB jB","900":"3 F hB"},J:{"16":"C","388":"B"},K:{"1":"K","16":"6 7 B A","900":"D y"},L:{"1":"8"},M:{"1":"t"},N:{"900":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"388":"lB"},R:{"1":"mB"}},B:1,C:"Constraint Validation API"};

},{}],164:[function(require,module,exports){
module.exports={A:{A:{"1":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"SB","4":"2"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"2":"dB"},I:{"1":"2 3 F s hB iB jB","2":"eB fB gB"},J:{"1":"C B"},K:{"1":"K y","2":"6 7 B A D"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"contenteditable attribute (basic support)"};

},{}],165:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E UB","132":"B A"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB","129":"F I J C G E B A D X g H L M N O P Q R"},D:{"1":"0 1 4 5 8 U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X","257":"g H L M N O P Q R S T"},E:{"1":"C G E B A HB IB JB KB","2":"9 F I DB","257":"J GB","260":"FB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB","257":"WB","260":"VB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"2":"C","257":"B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"132":"B A"},O:{"257":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"Content Security Policy 1.0"};

},{}],166:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"H L","2":"D X g"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z QB PB","132":"a b c d","260":"e","516":"f K h i j k l m n","8196":"0 1 4 5 o p q r w x v z t s"},D:{"1":"0 1 4 5 8 j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e","1028":"f K h","2052":"i"},E:{"1":"B A JB KB","2":"9 F I J C G E DB FB GB HB IB"},F:{"1":"W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R LB MB NB OB RB y","1028":"S T U","2052":"V"},G:{"1":"A aB bB cB","2":"3 9 G AB VB WB XB YB ZB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"4100":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"Content Security Policy Level 2"};

},{}],167:[function(require,module,exports){
module.exports={A:{A:{"1":"A","2":"J C UB","132":"B","260":"G E"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"2 SB"},D:{"1":"0 1 4 5 8 X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","132":"F I J C G E B A D"},E:{"2":"9 DB","513":"J C G E B A GB HB IB JB KB","644":"F I FB"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"6 7 E A LB MB NB OB RB"},G:{"513":"G A WB XB YB ZB aB bB cB","644":"3 9 AB VB"},H:{"2":"dB"},I:{"1":"s iB jB","132":"2 3 F eB fB gB hB"},J:{"1":"B","132":"C"},K:{"1":"D K y","2":"6 7 B A"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","132":"B"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Cross-Origin Resource Sharing"};

},{}],168:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"4 5 8 EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q","66":"r w x","129":"0 1 v z t s"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"Credential Management API"};

},{}],169:[function(require,module,exports){
module.exports={A:{A:{"2":"UB","8":"J C G E B","164":"A"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 d e f K h i j k l m n o p q r w x v z t s","8":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a QB PB","322":"b c"},D:{"1":"0 1 4 5 8 K h i j k l m n o p q r w x v z t s EB BB TB CB","8":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f"},E:{"1":"A","8":"9 F I J C DB FB GB","545":"G E B HB IB JB KB"},F:{"1":"T U V W u Y Z a b c d e f K h i j k l m n o p q r","8":"6 7 E A D H L M N O P Q R S LB MB NB OB RB y"},G:{"1":"A","8":"3 9 AB VB WB XB","545":"G YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","8":"2 3 F eB fB gB hB iB jB"},J:{"8":"C B"},K:{"1":"K","8":"6 7 B A D y"},L:{"1":"8"},M:{"8":"t"},N:{"8":"B","164":"A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"Web Cryptography"};

},{}],170:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V QB PB"},D:{"1":"0 1 4 5 8 K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f"},E:{"1":"B A IB JB KB","2":"9 F I J C G E DB FB GB HB"},F:{"1":"T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S LB MB NB OB RB y"},G:{"1":"A aB bB cB","2":"3 9 G AB VB WB XB YB ZB"},H:{"2":"dB"},I:{"1":"s jB","2":"2 3 F eB fB gB hB iB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS all property"};

},{}],171:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F QB PB","33":"I J C G E B A D X g H"},D:{"1":"0 1 4 5 8 m n o p q r w x v z t s EB BB TB CB","33":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l"},E:{"1":"E B A IB JB KB","2":"9 DB","33":"J C G FB GB HB","292":"F I"},F:{"1":"Z a b c d e f K h i j k l m n o p q r y","2":"6 7 E A LB MB NB OB RB","33":"D H L M N O P Q R S T U V W u Y"},G:{"1":"A ZB aB bB cB","33":"G WB XB YB","164":"3 9 AB VB"},H:{"2":"dB"},I:{"1":"s","33":"3 F hB iB jB","164":"2 eB fB gB"},J:{"33":"C B"},K:{"1":"K y","2":"6 7 B A D"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"33":"kB"},P:{"1":"F I"},Q:{"33":"lB"},R:{"1":"mB"}},B:5,C:"CSS Animation"};

},{}],172:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 x v z t s","16":"2 SB F I J C G E B A D X g H L M N O P QB PB","33":"Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w"},D:{"16":"F I J C G E B A D X g H L M N O P Q R S","33":"0 1 4 5 8 T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"16":"9 F I J DB FB","33":"C G E B A GB HB IB JB KB"},F:{"2":"6 7 E A D LB MB NB OB RB y","33":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"16":"3 9 AB VB","33":"G A WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"16":"2 3 F eB fB gB hB iB jB","33":"s"},J:{"16":"C B"},K:{"2":"6 7 B A D y","33":"K"},L:{"33":"8"},M:{"33":"t"},N:{"2":"B A"},O:{"16":"kB"},P:{"16":"F","33":"I"},Q:{"33":"lB"},R:{"33":"mB"}},B:5,C:"CSS :any-link selector"};

},{}],173:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"388":"D X g H L"},C:{"164":"0 1 4 5 e f K h i j k l m n o p q r w x v z t s","676":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d QB PB"},D:{"164":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"164":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D LB MB NB OB RB y","164":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"164":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"164":"2 3 F s eB fB gB hB iB jB"},J:{"164":"C B"},K:{"2":"6 7 B A D y","164":"K"},L:{"164":"8"},M:{"164":"t"},N:{"2":"B","388":"A"},O:{"164":"kB"},P:{"164":"F I"},Q:{"164":"lB"},R:{"164":"mB"}},B:5,C:"CSS Appearance"};

},{}],174:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g","16":"H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x","194":"0 1 4 5 8 v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K LB MB NB OB RB y","194":"h i j k l m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D y","194":"K"},L:{"194":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F","194":"I"},Q:{"2":"lB"},R:{"194":"mB"}},B:7,C:"CSS @apply rule"};

},{}],175:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b QB PB","132":"0 1 4 5 c d e f K h i j k l m n o p q r w x v z t s"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"132":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:4,C:"CSS Counter Styles"};

},{}],176:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p","194":"0 1 4 5 8 q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G DB FB GB HB","33":"E B A IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c LB MB NB OB RB y","194":"d e f K h i j k l m n o p q r"},G:{"2":"3 9 G AB VB WB XB YB","33":"A ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D y","194":"K"},L:{"194":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F","194":"I"},Q:{"194":"lB"},R:{"194":"mB"}},B:7,C:"CSS Backdrop Filter"};

},{}],177:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D QB PB"},D:{"1":"0 1 4 5 8 U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T"},E:{"1":"C G E B A HB IB JB KB","2":"9 F I J DB FB GB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r NB OB RB y","2":"E LB MB"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB WB"},H:{"1":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"B","2":"C"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS background-position edge offsets"};

},{}],178:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y QB PB"},D:{"1":"0 1 4 5 8 e f K h i j k l m n o q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d","260":"p"},E:{"2":"9 F I J C DB FB GB","132":"G E B A HB IB JB KB"},F:{"1":"R S T U V W u Y Z a b d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q LB MB NB OB RB y","260":"c"},G:{"2":"3 9 AB VB WB XB","132":"G A YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D y","260":"K"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS background-blend-mode"};

},{}],179:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a QB PB"},D:{"2":"F I J C G E B A D X g H L M N O P Q","164":"0 1 4 5 8 R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J DB FB","164":"C G E B A GB HB IB JB KB"},F:{"2":"E LB MB NB OB","129":"6 7 A D RB y","164":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"2":"3 9 AB VB WB","164":"G A XB YB ZB aB bB cB"},H:{"132":"dB"},I:{"2":"2 3 F eB fB gB hB","164":"s iB jB"},J:{"2":"C","164":"B"},K:{"2":"B","129":"6 7 A D y","164":"K"},L:{"164":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"164":"F I"},Q:{"164":"lB"},R:{"164":"mB"}},B:5,C:"CSS box-decoration-break"};

},{}],180:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB","33":"QB PB"},D:{"1":"0 1 4 5 8 B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","33":"F I J C G E"},E:{"1":"J C G E B A FB GB HB IB JB KB","33":"I","164":"9 F DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r NB OB RB y","2":"E LB MB"},G:{"1":"G A VB WB XB YB ZB aB bB cB","33":"3 AB","164":"9"},H:{"2":"dB"},I:{"1":"3 F s hB iB jB","164":"2 eB fB gB"},J:{"1":"B","33":"C"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS3 Box-shadow"};

},{}],181:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v QB PB","16":"0 1 4 5 z t s"},D:{"2":"0 1 4 5 8 r w x v z t s EB BB TB CB","33":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q"},E:{"2":"9 DB","33":"F I J C G E B A FB GB HB IB JB KB"},F:{"2":"6 7 E A D e f K h i j k l m n o p q r LB MB NB OB RB y","33":"H L M N O P Q R S T U V W u Y Z a b c d"},G:{"33":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"s","33":"2 3 F eB fB gB hB iB jB"},J:{"33":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"33":"kB"},P:{"2":"I","33":"F"},Q:{"33":"lB"},R:{"2":"mB"}},B:7,C:"CSS Canvas Drawings"};

},{}],182:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z QB PB"},D:{"1":"4 5 8 EB BB TB CB","2":"0 1 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:4,C:"CSS caret-color"};

},{}],183:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p QB PB"},D:{"1":"0 1 4 5 8 w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},E:{"1":"E B A IB JB KB","2":"9 F I J C G DB FB GB HB"},F:{"1":"f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e LB MB NB OB RB y"},G:{"1":"A ZB aB bB cB","2":"3 9 G AB VB WB XB YB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"Case-insensitive CSS attribute selectors"};

},{}],184:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"1 4 5 t s","2":"2 SB","132":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p QB PB","644":"0 q r w x v z"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S","260":"4 5 8 t s EB BB TB CB","292":"0 1 T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z"},E:{"2":"9 F I J DB FB GB","292":"C G E B A HB IB JB KB"},F:{"2":"6 7 E A D LB MB NB OB RB y","260":"l m n o p q r","292":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k"},G:{"2":"3 9 AB VB WB","292":"G A XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB","260":"s","292":"iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D y","292":"K"},L:{"260":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"292":"kB"},P:{"292":"F I"},Q:{"292":"lB"},R:{"260":"mB"}},B:4,C:"CSS clip-path property (for HTML)"};

},{}],185:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","194":"8 EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o LB MB NB OB RB y","194":"p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"194":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"CSS Conical Gradients"};

},{}],186:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v QB PB","16":"0 1 4 5 z t s"},D:{"1":"0 1 4 5 8 z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x","194":"v"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K LB MB NB OB RB y","194":"h i"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"CSS Containment"};

},{}],187:[function(require,module,exports){
module.exports={A:{A:{"1":"G E B A","2":"J C UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"CSS Counters"};

},{}],188:[function(require,module,exports){
module.exports={A:{A:{"2":"J UB","2340":"C G E B A"},B:{"2":"D X g H L"},C:{"2":"2 SB QB","545":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s PB"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j","1025":"0 1 4 5 8 k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"B A JB KB","2":"9 F I DB FB","164":"J","4644":"C G E GB HB IB"},F:{"2":"6 7 E A H L M N O P Q R S T U V W LB MB NB OB","545":"D RB y","1025":"u Y Z a b c d e f K h i j k l m n o p q r"},G:{"1":"A bB cB","2":"3 9 AB","4260":"VB WB","4644":"G XB YB ZB aB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","1025":"s"},J:{"2":"C","4260":"B"},K:{"2":"6 7 B A","545":"D y","1025":"K"},L:{"1025":"8"},M:{"545":"t"},N:{"2340":"B A"},O:{"4260":"kB"},P:{"1025":"F I"},Q:{"2":"lB"},R:{"1025":"mB"}},B:7,C:"Crisp edges/pixelated images"};

},{}],189:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"F I J C G E B A D X g H L","33":"0 1 4 5 8 M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"B A JB KB","2":"9 F I DB","33":"J C G E FB GB HB IB"},F:{"2":"6 7 E A D LB MB NB OB RB y","33":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"1":"A bB cB","2":"3 9 AB","33":"G VB WB XB YB ZB aB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB","33":"s iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D y","33":"K"},L:{"33":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"33":"kB"},P:{"33":"F I"},Q:{"33":"lB"},R:{"33":"mB"}},B:7,C:"CSS Cross-Fade Function"};

},{}],190:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","16":"2 SB QB PB"},D:{"1":"0 1 4 5 8 v z t s EB BB TB CB","16":"F I J C G E B A D X g","132":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x"},E:{"1":"A JB KB","16":"9 F I DB","132":"J C G E B FB GB HB IB"},F:{"1":"h i j k l m n o p q r","16":"6 7 E A LB MB NB OB","132":"H L M N O P Q R S T U V W u Y Z a b c d e f K","260":"D RB y"},G:{"1":"A cB","16":"3 9 AB VB WB","132":"G XB YB ZB aB bB"},H:{"260":"dB"},I:{"1":"s","16":"2 eB fB gB","132":"3 F hB iB jB"},J:{"16":"C","132":"B"},K:{"16":"6 7 B A D","132":"K","260":"y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"132":"kB"},P:{"1":"I","132":"F"},Q:{"1":"lB"},R:{"2":"mB"}},B:7,C:":default CSS pseudo-class"};

},{}],191:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB","16":"BB TB CB"},E:{"1":"A KB","2":"9 F I J C G E B DB FB GB HB IB JB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"Explicit descendant combinator >>"};

},{}],192:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E UB","164":"B A"},B:{"164":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W u","66":"0 1 4 5 8 Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i LB MB NB OB RB y","66":"j k l m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"292":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"B K","292":"6 7 A D y"},L:{"2":"8"},M:{"2":"t"},N:{"164":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"66":"lB"},R:{"2":"mB"}},B:5,C:"CSS Device Adaptation"};

},{}],193:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 w x v z t s","2":"2 SB F I J C G E B A D X g H L QB PB","33":"M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:":dir() CSS pseudo-class"};

},{}],194:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f QB PB"},D:{"2":"0 1 4 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","194":"5 8 EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"CSS display: contents"};

},{}],195:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"33":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","164":"2 SB QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"33":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"CSS element() function"};

},{}],196:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E UB","33":"B A"},B:{"33":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"33":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"CSS Exclusions Level 1"};

},{}],197:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q QB PB"},D:{"1":"0 1 4 5 8 u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W"},E:{"1":"E B A IB JB KB","2":"9 F I J C G DB FB GB HB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"6 7 E A D LB MB NB OB RB"},G:{"1":"A ZB aB bB cB","2":"3 9 G AB VB WB XB YB"},H:{"1":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS Feature Queries"};

},{}],198:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"B A IB JB KB","2":"9 F I J C G DB FB GB HB","33":"E"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"A bB cB","2":"3 9 G AB VB WB XB YB","33":"ZB aB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"CSS filter() function"};

},{}],199:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1028":"X g H L","1346":"D"},C:{"1":"0 1 4 5 e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB","196":"d","516":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c PB"},D:{"1":"0 1 4 5 8 t s EB BB TB CB","2":"F I J C G E B A D X g H L M","33":"N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z"},E:{"1":"B A IB JB KB","2":"9 F I DB FB","33":"J C G E GB HB"},F:{"1":"j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y","33":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i"},G:{"1":"A aB bB cB","2":"3 9 AB VB","33":"G WB XB YB ZB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB","33":"iB jB"},J:{"2":"C","33":"B"},K:{"2":"6 7 B A D y","33":"K"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"33":"kB"},P:{"33":"F I"},Q:{"33":"lB"},R:{"33":"mB"}},B:5,C:"CSS Filter Effects"};

},{}],200:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","16":"UB","516":"G","1540":"J C"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","132":"2","260":"SB"},D:{"1":"0 1 4 5 8 E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"I J C G","132":"F"},E:{"1":"J C G E B A FB GB HB IB JB KB","16":"I DB","132":"9 F"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","16":"E LB","260":"6 7 A MB NB OB"},G:{"1":"G A VB WB XB YB ZB aB bB cB","16":"3 9 AB"},H:{"1":"dB"},I:{"1":"2 3 F s hB iB jB","16":"eB fB","132":"gB"},J:{"1":"C B"},K:{"1":"D K y","260":"6 7 B A"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"::first-letter CSS pseudo-element selector"};

},{}],201:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","132":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"CSS first-line pseudo-element"};

},{}],202:[function(require,module,exports){
module.exports={A:{A:{"1":"C G E B A","2":"UB","8":"J"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"G A YB ZB aB bB cB","2":"3 9 AB","132":"VB WB XB"},H:{"2":"dB"},I:{"1":"2 s iB jB","260":"eB fB gB","513":"3 F hB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"CSS position:fixed"};

},{}],203:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v QB PB"},D:{"1":"EB BB TB CB","2":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","194":"8"},E:{"1":"A JB KB","2":"9 F I J C G E B DB FB GB HB IB"},F:{"1":"q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o LB MB NB OB RB y","194":"p"},G:{"1":"A cB","2":"3 9 G AB VB WB XB YB ZB aB bB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:":focus-within CSS pseudo-class"};

},{}],204:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o QB PB","322":"0 1 4 5 p q r w x v z t s"},D:{"1":"EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","194":"0 1 4 5 8 w x v z t s"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e LB MB NB OB RB y","194":"f K h i j k l m n o p"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D y","194":"K"},L:{"194":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F","194":"I"},Q:{"194":"lB"},R:{"2":"mB"}},B:7,C:"CSS font-rendering controls"};

},{}],205:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G QB PB"},D:{"1":"0 1 4 5 8 r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q"},E:{"1":"A KB","2":"9 F I J C G E B DB FB GB HB IB JB"},F:{"1":"e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:4,C:"CSS font-stretch"};

},{}],206:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C UB","132":"G"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"CSS Generated content for pseudo-elements"};

},{}],207:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB","33":"F I J C G E B A D X g H PB"},D:{"1":"0 1 4 5 8 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","33":"B A D X g H L M N O P Q R S T U","36":"F I J C G E"},E:{"1":"C G E B A GB HB IB JB KB","2":"9 DB","33":"J FB","36":"F I"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"E A LB MB NB OB","33":"D RB","164":"6 7"},G:{"1":"G A XB YB ZB aB bB cB","33":"VB WB","36":"3 9 AB"},H:{"2":"dB"},I:{"1":"s iB jB","33":"3 F hB","36":"2 eB fB gB"},J:{"1":"B","36":"C"},K:{"1":"K y","2":"B A","33":"D","164":"6 7"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS Gradients"};

},{}],208:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G UB","8":"E","292":"B A"},B:{"1":"L","292":"D X g H"},C:{"1":"1 4 5 t s","2":"2 SB F I J C G E B A D X g H L M N QB PB","8":"O P Q R S T U V W u Y Z a b c d e f K h i","584":"j k l m n o p q r w x v","1025":"0 z"},D:{"1":"5 8 EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T","8":"U V W u","200":"0 1 Y Z a b c d e f K h i j k l m n o p q r w x v z t s","1025":"4"},E:{"1":"A JB KB","2":"9 F I DB FB","8":"J C G E B GB HB IB"},F:{"1":"n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W LB MB NB OB RB y","200":"u Y Z a b c d e f K h i j k l m"},G:{"1":"A cB","2":"3 9 AB VB","8":"G WB XB YB ZB aB bB"},H:{"2":"dB"},I:{"1":"s","2":"2 F eB fB gB hB","8":"3 iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D y","8":"K"},L:{"1":"8"},M:{"1":"t"},N:{"292":"B A"},O:{"2":"kB"},P:{"2":"I","8":"F"},Q:{"200":"lB"},R:{"2":"mB"}},B:4,C:"CSS Grid Layout"};

},{}],209:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g","16":"H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"B A JB KB","2":"9 F I J C G E DB FB GB HB IB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"A bB cB","2":"3 9 G AB VB WB XB YB ZB aB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"CSS hanging-punctuation"};

},{}],210:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:":has() CSS relational pseudo-class"};

},{}],211:[function(require,module,exports){
module.exports={A:{A:{"16":"J C G E B A UB"},B:{"16":"D X g H L"},C:{"16":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"4 5 8 t s EB BB TB CB","16":"0 1 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z"},E:{"16":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"16":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"16":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"16":"dB"},I:{"16":"2 3 F s eB fB gB hB iB jB"},J:{"16":"C B"},K:{"16":"6 7 B A D K y"},L:{"16":"8"},M:{"16":"t"},N:{"16":"B A"},O:{"16":"kB"},P:{"16":"F I"},Q:{"16":"lB"},R:{"16":"mB"}},B:5,C:"CSS4 Hyphenation"};

},{}],212:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E UB","33":"B A"},B:{"33":"D X g H L"},C:{"1":"0 1 4 5 m n o p q r w x v z t s","2":"2 SB F I QB PB","33":"J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l"},D:{"2":"0 1 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z","132":"4 5 8 t s EB BB TB CB"},E:{"2":"9 F I DB","33":"J C G E B A FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k LB MB NB OB RB y","132":"l m n o p q r"},G:{"2":"9 AB","33":"3 G A VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","132":"s"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"132":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"36":"kB"},P:{"2":"F","132":"I"},Q:{"2":"lB"},R:{"132":"mB"}},B:5,C:"CSS Hyphenation"};

},{}],213:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"132":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:4,C:"CSS3 image-orientation"};

},{}],214:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"F I J C G E B A D X g H L M N O P","33":"0 1 4 5 8 Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I DB FB","33":"J C G E B A GB HB IB JB KB"},F:{"2":"6 7 E A D LB MB NB OB RB y","33":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"2":"3 9 AB VB","33":"G A WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB","33":"s iB jB"},J:{"2":"C","33":"B"},K:{"2":"6 7 B A D y","33":"K"},L:{"33":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"33":"kB"},P:{"33":"F I"},Q:{"33":"lB"},R:{"33":"mB"}},B:7,C:"CSS image-set"};

},{}],215:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D","260":"X g H L"},C:{"1":"0 1 4 5 x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u QB PB","516":"Y Z a b c d e f K h i j k l m n o p q r w"},D:{"1":"0 1 4 5 8 t s EB BB TB CB","2":"F","16":"I J C G E B A D X g","260":"z","772":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v"},E:{"1":"A JB KB","2":"9 F DB","16":"I","772":"J C G E B FB GB HB IB"},F:{"1":"j k l m n o p q r","16":"E LB","260":"6 7 A D i MB NB OB RB y","772":"H L M N O P Q R S T U V W u Y Z a b c d e f K h"},G:{"1":"A cB","2":"3 9 AB","772":"G VB WB XB YB ZB aB bB"},H:{"132":"dB"},I:{"1":"s","2":"2 eB fB gB","260":"3 F hB iB jB"},J:{"2":"C","260":"B"},K:{"260":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"260":"kB"},P:{"1":"I","260":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:":in-range and :out-of-range CSS pseudo-classes"};

},{}],216:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G UB","132":"B A","388":"E"},B:{"132":"D X g H L"},C:{"1":"0 1 4 5 v z t s","16":"2 SB QB PB","132":"J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x","388":"F I"},D:{"1":"0 1 4 5 8 i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g","132":"H L M N O P Q R S T U V W u Y Z a b c d e f K h"},E:{"1":"A JB KB","16":"9 F I J DB","132":"C G E B GB HB IB","388":"FB"},F:{"1":"V W u Y Z a b c d e f K h i j k l m n o p q r","16":"6 7 E A LB MB NB OB","132":"H L M N O P Q R S T U","516":"D RB y"},G:{"1":"A cB","16":"3 9 AB VB WB","132":"G XB YB ZB aB bB"},H:{"516":"dB"},I:{"1":"s","16":"2 eB fB gB jB","132":"iB","388":"3 F hB"},J:{"16":"C","132":"B"},K:{"1":"K","16":"6 7 B A D","516":"y"},L:{"1":"8"},M:{"132":"t"},N:{"132":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:7,C:":indeterminate CSS pseudo-class"};

},{}],217:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G DB FB GB HB","4":"E","164":"B A IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G AB VB WB XB YB","164":"A ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"CSS Initial Letter"};

},{}],218:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A FB GB HB IB JB KB","16":"DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","16":"9"},H:{"2":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS initial value"};

},{}],219:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","16":"UB","132":"J C G"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","132":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y"},E:{"1":"C G E B A GB HB IB JB KB","16":"DB","132":"9 F I J FB"},F:{"1":"M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","16":"E LB","132":"6 7 A D H L MB NB OB RB y"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","16":"9"},H:{"2":"dB"},I:{"1":"s iB jB","16":"eB fB","132":"2 3 F gB hB"},J:{"132":"C B"},K:{"1":"K","132":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"letter-spacing CSS property"};

},{}],220:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"16":"F I J C G E B A D X","33":"0 1 4 5 8 g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F DB","33":"I J C G E B A FB GB HB IB JB KB"},F:{"2":"6 7 E A D LB MB NB OB RB y","33":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"2":"3 9 AB","33":"G A VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"16":"eB fB","33":"2 3 F s gB hB iB jB"},J:{"33":"C B"},K:{"2":"6 7 B A D y","33":"K"},L:{"33":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"33":"kB"},P:{"33":"F I"},Q:{"33":"lB"},R:{"33":"mB"}},B:7,C:"CSS line-clamp"};

},{}],221:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 k l m n o p q r w x v z t s","2":"SB","164":"2 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j QB PB"},D:{"292":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"292":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D LB MB NB OB RB y","292":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"292":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"292":"2 3 F s eB fB gB hB iB jB"},J:{"292":"C B"},K:{"2":"6 7 B A D y","292":"K"},L:{"292":"8"},M:{"164":"t"},N:{"2":"B A"},O:{"292":"kB"},P:{"292":"F I"},Q:{"292":"lB"},R:{"292":"mB"}},B:7,C:"CSS Logical Properties"};

},{}],222:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"CSS ::marker pseudo-element"};

},{}],223:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 t s","2":"2 SB","260":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z QB PB"},D:{"164":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 DB","164":"F I J C G E B A FB GB HB IB JB KB"},F:{"2":"6 7 E A D LB MB NB OB RB y","164":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"164":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"164":"s iB jB","676":"2 3 F eB fB gB hB"},J:{"164":"C B"},K:{"2":"6 7 B A D y","164":"K"},L:{"164":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"164":"kB"},P:{"164":"F I"},Q:{"164":"lB"},R:{"164":"mB"}},B:4,C:"CSS Masks"};

},{}],224:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"16":"2 SB QB PB","548":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"16":"F I J C G E B A D X g","164":"0 1 4 5 8 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F DB","16":"I","164":"J C G FB GB HB","257":"E B A IB JB KB"},F:{"2":"6 7 E A D LB MB NB OB RB y","164":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"16":"3 9 AB VB WB","164":"G XB YB","257":"A ZB aB bB cB"},H:{"2":"dB"},I:{"16":"2 eB fB gB","164":"3 F s hB iB jB"},J:{"16":"C","164":"B"},K:{"2":"6 7 B A D y","164":"K"},L:{"164":"8"},M:{"548":"t"},N:{"2":"B A"},O:{"164":"kB"},P:{"164":"F I"},Q:{"164":"lB"},R:{"164":"mB"}},B:5,C:":matches() CSS pseudo-class"};

},{}],225:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j"},E:{"1":"E B A IB JB KB","2":"9 F I J C G DB FB GB HB"},F:{"1":"u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W LB MB NB OB RB y"},G:{"1":"A ZB aB bB cB","2":"3 9 G AB VB WB XB YB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:5,C:"Media Queries: interaction media features"};

},{}],226:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G UB","132":"E B A"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB","260":"F I J C G E B A D X g H QB PB"},D:{"1":"0 1 4 5 8 Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","548":"F I J C G E B A D X g H L M N O P Q R S T U V W u"},E:{"2":"9 DB","548":"F I J C G E B A FB GB HB IB JB KB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"E","548":"6 7 A D LB MB NB OB RB"},G:{"16":"9","548":"3 G A AB VB WB XB YB ZB aB bB cB"},H:{"132":"dB"},I:{"1":"s iB jB","16":"eB fB","548":"2 3 F gB hB"},J:{"548":"C B"},K:{"1":"K y","548":"6 7 B A D"},L:{"1":"8"},M:{"1":"t"},N:{"132":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"Media Queries: resolution feature"};

},{}],227:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"16":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v QB PB","16":"0 1 4 5 z t s"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB","16":"BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p LB MB NB OB RB y","16":"q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"Media Queries: scripting media feature"};

},{}],228:[function(require,module,exports){
module.exports={A:{A:{"8":"J C G UB","129":"E B A"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"2 SB"},D:{"1":"0 1 4 5 8 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","129":"F I J C G E B A D X g H L M N O P Q R S T U"},E:{"1":"C G E B A GB HB IB JB KB","129":"F I J FB","388":"9 DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","2":"E"},G:{"1":"G A XB YB ZB aB bB cB","129":"3 9 AB VB WB"},H:{"1":"dB"},I:{"1":"s iB jB","129":"2 3 F eB fB gB hB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"129":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"CSS3 Media Queries"};

},{}],229:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a QB PB"},D:{"1":"0 1 4 5 8 k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u","194":"Y Z a b c d e f K h i j"},E:{"2":"9 F I J C DB FB GB","260":"G E B A HB IB JB KB"},F:{"1":"Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u LB MB NB OB RB y"},G:{"2":"3 9 AB VB WB XB","260":"G A YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"Blending of HTML/SVG elements"};

},{}],230:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l","194":"m n o"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y LB MB NB OB RB y","194":"Z a b"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:7,C:"CSS Motion Path"};

},{}],231:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","16":"9 DB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 G A VB WB XB YB ZB aB bB cB","16":"9 AB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"CSS namespaces"};

},{}],232:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t QB PB","16":"4 5 s"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB","16":"BB TB CB"},E:{"1":"E B A IB JB KB","2":"9 F I J C G DB FB GB HB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"A ZB aB bB cB","2":"3 9 G AB VB WB XB YB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"selector list argument of :not()"};

},{}],233:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"E B A IB JB KB","2":"9 F I J C G DB FB GB HB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"A ZB aB bB cB","2":"3 9 G AB VB WB XB YB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"selector list argument of :nth-child and :nth-last-child CSS pseudo-classes"};

},{}],234:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","4":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"CSS3 Opacity"};

},{}],235:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g"},E:{"1":"I J C G E B A FB GB HB IB JB KB","2":"9 F DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","16":"E LB","132":"6 7 A D MB NB OB RB y"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"132":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"1":"K","132":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:7,C:":optional CSS pseudo-class"};

},{}],236:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"4 5 8 s EB BB TB CB","2":"0 1 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:5,C:"CSS overflow-anchor (Scroll Anchoring)"};

},{}],237:[function(require,module,exports){
module.exports={A:{A:{"388":"B A","900":"J C G E UB"},B:{"388":"D X g H L"},C:{"900":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"900":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"772":"B","900":"9 F I J C G E A DB FB GB HB IB JB KB"},F:{"16":"E LB","129":"6 7 A D MB NB OB RB y","900":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"900":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"129":"dB"},I:{"900":"2 3 F s eB fB gB hB iB jB"},J:{"900":"C B"},K:{"129":"6 7 B A D y","900":"K"},L:{"900":"8"},M:{"900":"t"},N:{"388":"B A"},O:{"900":"kB"},P:{"900":"F I"},Q:{"900":"lB"},R:{"900":"mB"}},B:2,C:"CSS page-break properties"};

},{}],238:[function(require,module,exports){
module.exports={A:{A:{"2":"J C UB","132":"G E B A"},B:{"132":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N QB PB","132":"0 1 4 5 O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"1":"0 1 4 5 8 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","132":"6 7 E A D LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"16":"dB"},I:{"16":"2 3 F s eB fB gB hB iB jB"},J:{"16":"C B"},K:{"16":"6 7 B A D y","258":"K"},L:{"1":"8"},M:{"132":"t"},N:{"258":"B A"},O:{"258":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"CSS Paged Media (@page)"};

},{}],239:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x QB PB"},D:{"1":"0 1 4 5 8 q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p"},E:{"1":"E B A IB JB KB","2":"9 F I J C G DB FB GB HB"},F:{"1":"d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c LB MB NB OB RB y"},G:{"1":"A ZB aB bB cB","2":"3 9 G AB VB WB XB YB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:":placeholder-shown CSS pseudo-class"};

},{}],240:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E UB","36":"B A"},B:{"36":"D X g H L"},C:{"1":"0 1 4 5 v z t s","2":"2 SB QB PB","33":"O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x","164":"F I J C G E B A D X g H L M N"},D:{"1":"4 5 8 EB BB TB CB","36":"0 1 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},E:{"1":"A JB KB","2":"9 F DB","36":"I J C G E B FB GB HB IB"},F:{"1":"n o p q r","2":"6 7 E A D LB MB NB OB RB y","36":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m"},G:{"1":"A cB","2":"9 AB","36":"3 G VB WB XB YB ZB aB bB"},H:{"2":"dB"},I:{"1":"s","36":"2 3 F eB fB gB hB iB jB"},J:{"36":"C B"},K:{"2":"6 7 B A D y","36":"K"},L:{"1":"8"},M:{"1":"t"},N:{"36":"B A"},O:{"36":"kB"},P:{"36":"F I"},Q:{"36":"lB"},R:{"1":"mB"}},B:5,C:"::placeholder CSS pseudo-element"};

},{}],241:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"X g H L","2":"D"},C:{"16":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V QB PB","33":"0 1 4 5 W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"16":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c","132":"0 1 4 5 8 d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"16":"9 F I J DB FB GB","132":"C G E B A HB IB JB KB"},F:{"2":"6 7 E A D LB MB NB OB RB y","132":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"16":"3 9 AB VB WB XB","132":"G A YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","132":"s"},J:{"16":"C B"},K:{"2":"6 7 B A D y","132":"K"},L:{"132":"8"},M:{"33":"t"},N:{"16":"B A"},O:{"16":"kB"},P:{"2":"F","132":"I"},Q:{"132":"lB"},R:{"132":"mB"}},B:1,C:"CSS :read-only and :read-write selectors"};

},{}],242:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B UB","132":"A"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b QB PB"},D:{"1":"0 1 4 5 8 h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K"},E:{"1":"C G E B A HB IB JB KB","2":"9 F I J DB FB","16":"GB"},F:{"1":"U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T LB MB NB OB RB y"},G:{"1":"G A YB ZB aB bB cB","2":"3 9 AB VB WB XB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"2":"lB"},R:{"1":"mB"}},B:5,C:"Rebeccapurple color"};

},{}],243:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"33":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 DB","33":"F I J C G E B A FB GB HB IB JB KB"},F:{"2":"6 7 E A D LB MB NB OB RB y","33":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"33":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"33":"2 3 F s eB fB gB hB iB jB"},J:{"33":"C B"},K:{"2":"6 7 B A D y","33":"K"},L:{"33":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"33":"F I"},Q:{"33":"lB"},R:{"33":"mB"}},B:7,C:"CSS Reflections"};

},{}],244:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E UB","420":"B A"},B:{"420":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g e f K h i j k l m n o p q r w x v z t s EB BB TB CB","36":"H L M N","66":"O P Q R S T U V W u Y Z a b c d"},E:{"2":"9 F I J DB FB","33":"C G E B A GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 AB VB WB","33":"G A XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"420":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"CSS Regions"};

},{}],245:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB","33":"F I J C G E B A D X g H PB"},D:{"1":"0 1 4 5 8 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E","33":"B A D X g H L M N O P Q R S T U"},E:{"1":"C G E B A GB HB IB JB KB","2":"9 F I DB","33":"J FB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"E A LB MB NB OB","33":"D RB","36":"6 7"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB","33":"VB WB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 eB fB gB","33":"3 F hB"},J:{"1":"B","2":"C"},K:{"1":"K y","2":"B A","33":"D","36":"6 7"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS Repeating Gradients"};

},{}],246:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB","33":"F"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","2":"9 DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB","132":"y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"I","2":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS resize property"};

},{}],247:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"B A IB JB KB","2":"9 F I J C G E DB FB GB HB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"A aB bB cB","2":"3 9 G AB VB WB XB YB ZB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"CSS revert value"};

},{}],248:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r QB PB"},D:{"1":"TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v","194":"0 1 4 5 8 z t s EB BB"},E:{"1":"B A JB KB","2":"9 F I J C G E DB FB GB HB IB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h LB MB NB OB RB y","194":"i j k l m n o p q r"},G:{"1":"A bB cB","2":"3 9 G AB VB WB XB YB ZB aB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"194":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F","194":"I"},Q:{"194":"lB"},R:{"194":"mB"}},B:7,C:"#rrggbbaa hex color notation"};

},{}],249:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e QB PB"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j","450":"0 1 4 5 8 k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W LB MB NB OB RB y","450":"u Y Z a b c d e f K h i j k l m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"450":"lB"},R:{"2":"mB"}},B:5,C:"CSSOM Scroll-behavior"};

},{}],250:[function(require,module,exports){
module.exports={A:{A:{"132":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"289":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"16":"9 F I DB","289":"J C G E B A FB GB HB IB JB KB"},F:{"2":"6 7 E A D LB MB NB OB RB y","289":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"16":"3 9 AB VB WB","289":"G A XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"16":"eB fB","289":"2 3 F s gB hB iB jB"},J:{"289":"C B"},K:{"2":"6 7 B A D y","289":"K"},L:{"289":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"289":"kB"},P:{"289":"F I"},Q:{"289":"lB"},R:{"289":"mB"}},B:7,C:"CSS scrollbar styling"};

},{}],251:[function(require,module,exports){
module.exports={A:{A:{"1":"C G E B A","2":"UB","8":"J"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"CSS 2.1 selectors"};

},{}],252:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"UB","8":"J","132":"C G"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"2 SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A FB GB HB IB JB KB","2":"DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","2":"E"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"CSS3 selectors"};

},{}],253:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"33":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","2":"E"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"B","2":"C"},K:{"1":"6 D K y","16":"7 B A"},L:{"1":"8"},M:{"33":"t"},N:{"1":"B A"},O:{"2":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"::selection CSS pseudo-element"};

},{}],254:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c","194":"d e f"},E:{"1":"A JB KB","2":"9 F I J C DB FB GB","33":"G E B HB IB"},F:{"1":"T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S LB MB NB OB RB y"},G:{"1":"A cB","2":"3 9 AB VB WB XB","33":"G YB ZB aB bB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS Shapes Level 1"};

},{}],255:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E UB","6308":"B","6436":"A"},B:{"6436":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h QB PB","2052":"0 1 4 5 i j k l m n o p q r w x v z t s"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"A KB","2":"9 F I J C G DB FB GB HB","3108":"E B IB JB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G AB VB WB XB YB","3108":"A ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2052":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:4,C:"CSS Scroll snap points"};

},{}],256:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"L","2":"D X g H"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U QB PB","194":"V W u Y Z a","516":"0 1 4 5 b c d e f K h i j k l m n o p q r w x v z t s"},D:{"2":"F I J C G E B A D X g H L M N O P Q R K h i j k l m n o p q r w x v","322":"0 1 S T U V W u Y Z a b c d e f z t","1028":"4 5 8 s EB BB TB CB"},E:{"2":"9 F I J DB FB","33":"G E B A HB IB JB KB","2084":"C GB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h LB MB NB OB RB y","322":"i j k","1028":"l m n o p q r"},G:{"2":"3 9 AB VB","33":"G A YB ZB aB bB cB","2084":"WB XB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","1028":"s"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1028":"8"},M:{"516":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"322":"lB"},R:{"2":"mB"}},B:5,C:"CSS position:sticky"};

},{}],257:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O QB PB","66":"P Q R"},D:{"1":"0 1 4 5 8 u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W"},E:{"1":"E B A IB JB KB","2":"9 F I J C G DB FB GB HB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB","132":"y"},G:{"1":"A ZB aB bB cB","2":"3 9 G AB VB WB XB YB"},H:{"132":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D","132":"y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS.supports() API"};

},{}],258:[function(require,module,exports){
module.exports={A:{A:{"1":"G E B A","2":"J C UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","132":"SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"CSS Table display"};

},{}],259:[function(require,module,exports){
module.exports={A:{A:{"132":"J C G E B A UB"},B:{"4":"D X g H L"},C:{"1":"0 1 4 5 w x v z t s","2":"2 SB F I J C G E B A QB PB","33":"D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},D:{"1":"0 1 4 5 8 q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d","322":"e f K h i j k l m n o p"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q LB MB NB OB RB y","578":"R S T U V W u Y Z a b c"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"132":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:5,C:"CSS3 text-align-last"};

},{}],260:[function(require,module,exports){
module.exports={A:{A:{"132":"J C G E B A UB"},B:{"132":"D X g H L"},C:{"132":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"132":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K","388":"0 1 4 5 8 h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"132":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"132":"6 7 E A D H L M N O P Q R S T LB MB NB OB RB y","388":"U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"132":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"132":"dB"},I:{"132":"2 3 F s eB fB gB hB iB jB"},J:{"132":"C B"},K:{"132":"6 7 B A D y","388":"K"},L:{"388":"8"},M:{"132":"t"},N:{"132":"B A"},O:{"132":"kB"},P:{"132":"F","388":"I"},Q:{"388":"lB"},R:{"388":"mB"}},B:5,C:"CSS text-indent"};

},{}],261:[function(require,module,exports){
module.exports={A:{A:{"16":"J C UB","132":"G E B A"},B:{"132":"D X g H L"},C:{"2":"0 2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z QB PB","1025":"4 5 t s","1602":"1"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l","322":"0 1 4 5 8 m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y LB MB NB OB RB y","322":"Z a b c d e f K h i j k l m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","322":"s"},J:{"2":"C B"},K:{"2":"6 7 B A D y","322":"K"},L:{"322":"8"},M:{"1025":"t"},N:{"132":"B A"},O:{"2":"kB"},P:{"2":"F","322":"I"},Q:{"322":"lB"},R:{"322":"mB"}},B:5,C:"CSS text-justify"};

},{}],262:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x QB PB"},D:{"1":"0 1 4 5 8 r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q"},E:{"2":"9 F I J C G E DB FB GB HB IB","16":"B","33":"A JB KB"},F:{"1":"e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d LB MB NB OB RB y"},G:{"1":"A bB cB","2":"3 9 G AB VB WB XB YB ZB aB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:4,C:"CSS text-orientation"};

},{}],263:[function(require,module,exports){
module.exports={A:{A:{"2":"J C UB","161":"G E B A"},B:{"161":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"16":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"CSS Text 4 text-spacing"};

},{}],264:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E UB","129":"B A"},B:{"129":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"2 SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","260":"9 DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","2":"E"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"4":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"B","4":"C"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"129":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS3 Text-shadow"};

},{}],265:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E UB","132":"A","164":"B"},B:{"132":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"4 5 8 s EB BB TB CB","2":"0 1 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z","260":"t"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k LB MB NB OB RB y","260":"l"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"2":"t"},N:{"132":"A","164":"B"},O:{"2":"kB"},P:{"1":"I","16":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:5,C:"CSS touch-action level 2 values"};

},{}],266:[function(require,module,exports){
module.exports={A:{A:{"1":"A","2":"J C G E UB","289":"B"},B:{"1":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u QB PB","194":"Y Z a b c d e f K h i j k l m n o p q r w x v","1025":"0 1 4 5 z t s"},D:{"1":"0 1 4 5 8 f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R LB MB NB OB RB y"},G:{"2":"3 9 G AB VB WB XB YB ZB","516":"A aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","289":"B"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"CSS touch-action property"};

},{}],267:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB","33":"I J C G E B A D X g H","164":"F"},D:{"1":"0 1 4 5 8 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","33":"F I J C G E B A D X g H L M N O P Q R S T U"},E:{"1":"C G E B A GB HB IB JB KB","33":"J FB","164":"9 F I DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"E LB MB","33":"D","164":"6 7 A NB OB RB"},G:{"1":"G A XB YB ZB aB bB cB","33":"WB","164":"3 9 AB VB"},H:{"2":"dB"},I:{"1":"s iB jB","33":"2 3 F eB fB gB hB"},J:{"1":"B","33":"C"},K:{"1":"K y","33":"D","164":"6 7 B A"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"CSS3 Transitions"};

},{}],268:[function(require,module,exports){
module.exports={A:{A:{"132":"J C G E B A UB"},B:{"132":"D X g H L"},C:{"1":"0 1 4 5 x v z t s","33":"M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w","132":"2 SB F I J C G E QB PB","292":"B A D X g H L"},D:{"1":"0 1 4 5 8 r w x v z t s EB BB TB CB","132":"F I J C G E B A D X g H L","548":"M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q"},E:{"132":"9 F I J C G DB FB GB HB","548":"E B A IB JB KB"},F:{"132":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"132":"3 9 G AB VB WB XB YB","548":"A ZB aB bB cB"},H:{"16":"dB"},I:{"1":"s","16":"2 3 F eB fB gB hB iB jB"},J:{"16":"C B"},K:{"16":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"132":"B A"},O:{"16":"kB"},P:{"1":"I","16":"F"},Q:{"16":"lB"},R:{"16":"mB"}},B:4,C:"CSS unicode-bidi property"};

},{}],269:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"X g H L","2":"D"},C:{"1":"0 1 4 5 W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V QB PB"},D:{"1":"0 1 4 5 8 k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j"},E:{"1":"B A IB JB KB","2":"9 F I J C G E DB FB GB HB"},F:{"1":"u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W LB MB NB OB RB y"},G:{"1":"A aB bB cB","2":"3 9 G AB VB WB XB YB ZB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"F I"},Q:{"2":"lB"},R:{"1":"mB"}},B:4,C:"CSS unset value"};

},{}],270:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g","260":"H L"},C:{"1":"0 1 4 5 a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z QB PB"},D:{"1":"0 1 4 5 8 w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q","194":"r"},E:{"1":"B A IB JB KB","2":"9 F I J C G E DB FB GB HB"},F:{"1":"f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d LB MB NB OB RB y","194":"e"},G:{"1":"A aB bB cB","2":"3 9 G AB VB WB XB YB ZB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"2":"mB"}},B:4,C:"CSS Variables (Custom Properties)"};

},{}],271:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C UB","129":"G E"},B:{"1":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v QB PB","16":"0 1 4 5 z t s"},D:{"1":"0 1 4 5 8 U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T"},E:{"1":"C G E B A HB IB JB KB","2":"9 F I J DB FB GB"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","129":"6 7 E A LB MB NB OB RB"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB WB"},H:{"1":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"2":"C B"},K:{"1":"K y","2":"6 7 B A D"},L:{"1":"8"},M:{"2":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"CSS widows & orphans"};

},{}],272:[function(require,module,exports){
module.exports={A:{A:{"132":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e QB PB","322":"f K h i j"},D:{"1":"0 1 4 5 8 r w x v z t s EB BB TB CB","2":"F I J","16":"C","33":"G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q"},E:{"2":"9 F DB","16":"I","33":"J C G E B A FB GB HB IB JB KB"},F:{"1":"e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y","33":"H L M N O P Q R S T U V W u Y Z a b c d"},G:{"16":"3 9 AB","33":"G A VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"eB fB gB","33":"2 3 F hB iB jB"},J:{"33":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"36":"B A"},O:{"33":"kB"},P:{"1":"I","33":"F"},Q:{"33":"lB"},R:{"1":"mB"}},B:4,C:"CSS writing-mode property"};

},{}],273:[function(require,module,exports){
module.exports={A:{A:{"1":"J C UB","129":"G E B A"},B:{"1":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","2":"9 DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","2":"9"},H:{"2":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"2":"t"},N:{"129":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:7,C:"CSS zoom"};

},{}],274:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:4,C:"CSS3 attr() function"};

},{}],275:[function(require,module,exports){
module.exports={A:{A:{"1":"G E B A","8":"J C UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 Y Z a b c d e f K h i j k l m n o p q r w x v z t s","33":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u QB PB"},D:{"1":"0 1 4 5 8 B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","33":"F I J C G E"},E:{"1":"J C G E B A FB GB HB IB JB KB","33":"9 F I DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","2":"E"},G:{"1":"G A VB WB XB YB ZB aB bB cB","33":"3 9 AB"},H:{"1":"dB"},I:{"1":"3 F s hB iB jB","33":"2 eB fB gB"},J:{"1":"B","33":"C"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS3 Box-sizing"};

},{}],276:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","4":"SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r MB NB OB RB y","2":"E","4":"LB"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"CSS3 Colors"};

},{}],277:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","33":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V QB PB"},D:{"33":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"33":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"D RB y","2":"6 7 E A LB MB NB OB","33":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"33":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"33":"lB"},R:{"2":"mB"}},B:4,C:"CSS3 Cursors: grab & grabbing"};

},{}],278:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","33":"2 SB F I J C G E B A D X g H L M N O P Q R S QB PB"},D:{"1":"0 1 4 5 8 K h i j k l m n o p q r w x v z t s EB BB TB CB","33":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f"},E:{"1":"E B A IB JB KB","33":"9 F I J C G DB FB GB HB"},F:{"1":"D T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"6 7 E A LB MB NB OB","33":"H L M N O P Q R S"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"33":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:4,C:"CSS3 Cursors: zoom-in & zoom-out"};

},{}],279:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","132":"J C G UB"},B:{"1":"g H L","260":"D X"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","4":"2 SB QB PB"},D:{"1":"0 1 4 5 8 I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","4":"F"},E:{"1":"I J C G E B A FB GB HB IB JB KB","4":"9 F DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","260":"6 7 E A D LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C","16":"B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:4,C:"CSS3 Cursors (original values)"};

},{}],280:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB QB PB","33":"0 1 4 5 t s","164":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z"},D:{"1":"0 1 4 5 8 l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P","132":"Q R S T U V W u Y Z a b c d e f K h i j k"},E:{"2":"9 F I J DB FB","132":"C G E B A GB HB IB JB KB"},F:{"1":"Y Z a b c d e f K h i j k l m n o p q r","2":"E LB MB NB","132":"H L M N O P Q R S T U V W u","164":"6 7 A D OB RB y"},G:{"2":"3 9 AB VB WB","132":"G A XB YB ZB aB bB cB"},H:{"164":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB","132":"iB jB"},J:{"132":"C B"},K:{"1":"K","2":"B","164":"6 7 A D y"},L:{"1":"8"},M:{"33":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"CSS3 tab-size"};

},{}],281:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","2":"9 DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","2":"E"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","16":"9"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"CSS currentColor value"};

},{}],282:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E UB","8":"B A"},B:{"8":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R QB PB","194":"S T U V W u Y","200":"0 1 4 5 Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"1":"0 1 4 5 8 c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V","66":"W u Y Z a b"},E:{"2":"9 F I DB FB","8":"J C G E B A GB HB IB JB KB"},F:{"1":"P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y","66":"H L M N O"},G:{"2":"3 9 AB VB WB","8":"G A XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s jB","2":"2 3 F eB fB gB hB iB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"200":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"Custom Elements v0"};

},{}],283:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E UB","8":"B A"},B:{"8":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y QB PB","8":"0 1 4 5 Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v","8":"0 z","132":"1 4 5 8 t s EB BB TB CB"},E:{"2":"9 F I J C DB FB GB HB","8":"G E B IB","132":"A JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j LB MB NB OB RB y","132":"k l m n o p q r"},G:{"2":"3 9 G AB VB WB XB YB ZB aB bB","132":"A cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","132":"s"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"132":"8"},M:{"8":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F","132":"I"},Q:{"8":"lB"},R:{"132":"mB"}},B:1,C:"Custom Elements v1"};

},{}],284:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G UB","132":"E B A"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I QB PB","132":"J C G E B"},D:{"1":"0 1 4 5 8 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F","16":"I J C G X g","388":"E B A D"},E:{"1":"C G E B A GB HB IB JB KB","2":"9 F DB","16":"I J","388":"FB"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"E LB MB NB OB","132":"6 7 A"},G:{"1":"G A WB XB YB ZB aB bB cB","2":"AB","16":"3 9","388":"VB"},H:{"1":"dB"},I:{"1":"s iB jB","2":"eB fB gB","388":"2 3 F hB"},J:{"1":"B","388":"C"},K:{"1":"D K y","2":"B","132":"6 7 A"},L:{"1":"8"},M:{"1":"t"},N:{"132":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"CustomEvent"};

},{}],285:[function(require,module,exports){
module.exports={A:{A:{"2":"UB","8":"J C G E","260":"B A"},B:{"260":"D X g H L"},C:{"8":"2 SB QB PB","516":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"8":"F I J C G E B A D X g H L M N O","132":"0 1 4 5 8 P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"8":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D LB MB NB OB RB y","132":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"8":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"jB","8":"2 3 F eB fB gB hB iB","132":"s"},J:{"1":"B","8":"C"},K:{"1":"6 7 B A D y","8":"K"},L:{"1":"8"},M:{"516":"t"},N:{"8":"B A"},O:{"8":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Datalist element"};

},{}],286:[function(require,module,exports){
module.exports={A:{A:{"1":"A","4":"J C G E B UB"},B:{"1":"D X g H L"},C:{"1":"J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x","4":"2 SB F I QB PB","129":"0 1 4 5 v z t s"},D:{"1":"0 1 o p q r w x v z","4":"F I J","129":"4 5 8 C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n t s EB BB TB CB"},E:{"4":"9 F I DB","129":"J C G E B A FB GB HB IB JB KB"},F:{"1":"6 7 D b c d e f K h i j k RB y","4":"E A LB MB NB OB","129":"H L M N O P Q R S T U V W u Y Z a l m n o p q r"},G:{"4":"3 9 AB","129":"G A VB WB XB YB ZB aB bB cB"},H:{"4":"dB"},I:{"4":"eB fB gB","129":"2 3 F s hB iB jB"},J:{"129":"C B"},K:{"1":"6 7 D y","4":"B A","129":"K"},L:{"129":"8"},M:{"129":"t"},N:{"1":"A","4":"B"},O:{"129":"kB"},P:{"129":"F I"},Q:{"1":"lB"},R:{"129":"mB"}},B:1,C:"dataset & data-* attributes"};

},{}],287:[function(require,module,exports){
module.exports={A:{A:{"2":"J C UB","132":"G","260":"E B A"},B:{"260":"D X H L","772":"g"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"260":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"Data URIs"};

},{}],288:[function(require,module,exports){
module.exports={A:{A:{"2":"E B A UB","8":"J C G"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 w x v z t s","2":"SB","8":"2 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p QB PB","194":"q r"},D:{"1":"0 1 4 5 8 f K h i j k l m n o p q r w x v z t s EB BB TB CB","8":"F I J C G E B A","257":"O P Q R S T U V W u Y Z a b c d e","769":"D X g H L M N"},E:{"1":"A JB KB","8":"9 F I DB FB","257":"J C G E B GB HB IB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 D RB y","8":"E A LB MB NB OB"},G:{"1":"G A WB XB YB ZB aB bB cB","8":"3 9 AB VB"},H:{"8":"dB"},I:{"1":"3 F s hB iB jB","8":"2 eB fB gB"},J:{"1":"B","8":"C"},K:{"1":"K","8":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"769":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Details & Summary elements"};

},{}],289:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B UB","132":"A"},B:{"1":"D X g H L"},C:{"2":"2 SB QB","4":"0 1 4 5 J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","8":"F I PB"},D:{"2":"F I J","4":"0 1 4 5 8 C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D LB MB NB OB RB y","4":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"2":"9 AB","4":"3 G A VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"eB fB gB","4":"2 3 F s hB iB jB"},J:{"2":"C","4":"B"},K:{"1":"D y","2":"6 7 B A","4":"K"},L:{"4":"8"},M:{"4":"t"},N:{"1":"A","2":"B"},O:{"4":"kB"},P:{"4":"F I"},Q:{"4":"lB"},R:{"4":"mB"}},B:4,C:"DeviceOrientation & DeviceMotion events"};

},{}],290:[function(require,module,exports){
module.exports={A:{A:{"1":"A","2":"J C G E B UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"6 7 E A LB MB NB OB"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"D K y","2":"6 7 B A"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","2":"B"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"Window.devicePixelRatio"};

},{}],291:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z QB PB","194":"0 1 4 5 t s"},D:{"1":"0 1 4 5 8 K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a","322":"b c d e f"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N LB MB NB OB RB y","578":"O P Q R S"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Dialog element"};

},{}],292:[function(require,module,exports){
module.exports={A:{A:{"1":"A","16":"UB","129":"E B","130":"J C G"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A FB GB HB IB JB KB","16":"DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","16":"E"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","16":"9"},H:{"1":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","129":"B"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"EventTarget.dispatchEvent"};

},{}],293:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u"},E:{"1":"G E B A IB JB KB","2":"9 F I J C DB FB GB HB"},F:{"1":"L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H LB MB NB OB RB y"},G:{"1":"G A YB ZB aB bB cB","2":"3 9 AB VB WB XB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"document.currentScript"};

},{}],294:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","16":"SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","16":"E"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:7,C:"document.evaluate & XPath"};

},{}],295:[function(require,module,exports){
module.exports={A:{A:{"1":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"J C G E B A GB HB IB JB KB","16":"9 F I DB FB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r MB NB OB RB y","16":"E LB"},G:{"1":"G A XB YB ZB aB bB cB","2":"9 AB","16":"3 VB WB"},H:{"2":"dB"},I:{"1":"3 hB iB jB","2":"2 F s eB fB gB"},J:{"1":"B","2":"C"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","2":"B"},O:{"2":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:7,C:"Document.execCommand()"};

},{}],296:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"J C G E B A FB GB HB IB JB KB","2":"9 F DB","16":"I"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"E LB MB NB OB"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","16":"9"},H:{"1":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"document.head"};

},{}],297:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r QB PB"},D:{"1":"1 4 5 8 t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v","194":"0 z"},E:{"1":"B A JB KB","2":"9 F I J C G E DB FB GB HB IB"},F:{"1":"k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i LB MB NB OB RB y","194":"j"},G:{"1":"A bB cB","2":"3 9 G AB VB WB XB YB ZB aB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"194":"lB"},R:{"2":"mB"}},B:1,C:"DOM manipulation convenience methods"};

},{}],298:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"UB","8":"J C G"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Document Object Model Range"};

},{}],299:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"DOMContentLoaded"};

},{}],300:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g H L M N O P Q R S T U"},E:{"1":"J C G E B A FB GB HB IB JB KB","2":"9 F DB","16":"I"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","16":"6 7 E A LB MB NB OB"},G:{"1":"G A XB YB ZB aB bB cB","16":"3 9 AB VB WB"},H:{"16":"dB"},I:{"1":"3 F s hB iB jB","16":"2 eB fB gB"},J:{"16":"C B"},K:{"16":"6 7 B A D K y"},L:{"1":"8"},M:{"2":"t"},N:{"16":"B A"},O:{"16":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"DOMFocusIn & DOMFocusOut events"};

},{}],301:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E UB","132":"B A"},B:{"132":"D X g H L"},C:{"1":"0 1 4 5 w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b QB PB","516":"c d e f K h i j k l m n o p q r"},D:{"16":"F I J C","132":"0 1 4 5 8 E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","388":"G"},E:{"1":"A KB","16":"9 F DB","132":"I J C G E B FB GB HB IB JB"},F:{"2":"6 7 E A D LB MB NB OB RB y","132":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"16":"3 9 AB","132":"G A VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"132":"3 F s hB iB jB","292":"2 eB fB gB"},J:{"16":"C","132":"B"},K:{"2":"6 7 B A D y","132":"K"},L:{"132":"8"},M:{"1":"t"},N:{"132":"B A"},O:{"132":"kB"},P:{"132":"F I"},Q:{"132":"lB"},R:{"132":"mB"}},B:4,C:"DOMMatrix"};

},{}],302:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"X g H L","2":"D"},C:{"1":"0 1 4 5 P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O QB PB"},D:{"1":"0 1 4 5 8 g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X"},E:{"1":"A JB KB","2":"9 F I J C G E B DB FB GB HB IB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"B","2":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Download attribute"};

},{}],303:[function(require,module,exports){
module.exports={A:{A:{"644":"J C G E UB","772":"B A"},B:{"260":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","8":"2 SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","8":"6 7 E A LB MB NB OB RB"},G:{"1":"A","2":"3 9 G AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"y","2":"K","8":"6 7 B A D"},L:{"2":"8"},M:{"2":"t"},N:{"1":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:1,C:"Drag and Drop"};

},{}],304:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"H L","2":"D X g"},C:{"1":"0 1 4 5 e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d QB PB"},D:{"1":"0 1 4 5 8 k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j"},E:{"1":"E B A IB JB KB","2":"9 F I J C G DB FB GB HB"},F:{"1":"u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W LB MB NB OB RB y"},G:{"1":"A ZB aB bB cB","2":"3 9 G AB VB WB XB YB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:1,C:"Element.closest()"};

},{}],305:[function(require,module,exports){
module.exports={A:{A:{"1":"J C G E B A","16":"UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","16":"SB"},D:{"1":"0 1 4 5 8 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g"},E:{"1":"I J C G E B A FB GB HB IB JB KB","16":"9 F DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","16":"E LB MB NB OB"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","16":"9"},H:{"1":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"1":"D K y","16":"6 7 B A"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"document.elementFromPoint()"};

},{}],306:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B UB","164":"A"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K QB PB"},D:{"1":"0 1 4 5 8 l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d","132":"e f K h i j k"},E:{"2":"9 F I J DB FB GB","164":"C G E B A HB IB JB KB"},F:{"1":"Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q LB MB NB OB RB y","132":"R S T U V W u"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"2":"mB"}},B:3,C:"Encrypted Media Extensions"};

},{}],307:[function(require,module,exports){
module.exports={A:{A:{"1":"J C G E B A","2":"UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"EOT - Embedded OpenType fonts"};

},{}],308:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C UB","260":"E","1026":"G"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","4":"2 SB QB PB","132":"F I J C G E B A D X g H L M N O P"},D:{"1":"0 1 4 5 8 S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","4":"F I J C G E B A D X g H L M N","132":"O P Q R"},E:{"1":"J C G E B A GB HB IB JB KB","4":"9 F I DB FB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","4":"6 7 E A D LB MB NB OB RB","132":"y"},G:{"1":"G A WB XB YB ZB aB bB cB","4":"3 9 AB VB"},H:{"132":"dB"},I:{"1":"s iB jB","4":"2 eB fB gB","132":"3 hB","900":"F"},J:{"1":"B","4":"C"},K:{"1":"K","4":"6 7 B A D","132":"y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"ECMAScript 5"};

},{}],309:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n QB PB"},D:{"1":"0 1 4 5 8 w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k","132":"l m n o p q r"},E:{"1":"E B A IB JB KB","2":"9 F I J C G DB FB GB HB"},F:{"1":"f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u LB MB NB OB RB y","132":"Y Z a b c d e"},G:{"1":"A ZB aB bB cB","2":"3 9 G AB VB WB XB YB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:6,C:"ES6 classes"};

},{}],310:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"X g H L","2":"D"},C:{"1":"0 1 4 5 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U QB PB"},D:{"1":"0 1 4 5 8 i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h"},E:{"1":"B A JB KB","2":"9 F I J C G E DB FB GB HB IB"},F:{"1":"V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U LB MB NB OB RB y"},G:{"1":"A bB cB","2":"3 9 G AB VB WB XB YB ZB aB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"2":"lB"},R:{"1":"mB"}},B:6,C:"ES6 Generators"};

},{}],311:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"KB","2":"9 F I J C G E B DB FB GB HB IB","16":"A","130":"JB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G AB VB WB XB YB ZB aB bB","16":"A","130":"cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"JavaScript modules: dynamic import()"};

},{}],312:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H","514":"L"},C:{"2":"0 1 2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z QB PB","322":"4 5 t s"},D:{"1":"BB TB CB","2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","194":"EB"},E:{"1":"A KB","2":"9 F I J C G E B DB FB GB HB IB JB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q LB MB NB OB RB y","194":"r"},G:{"1":"A","2":"3 9 G AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:1,C:"JavaScript modules: nomodule attribute"};

},{}],313:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g","194":"H L"},C:{"2":"0 2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z QB PB","322":"1 4 5 t s"},D:{"1":"BB TB CB","2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","194":"EB"},E:{"1":"A JB KB","2":"9 F I J C G E B DB FB GB HB IB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p LB MB NB OB RB y","194":"q r"},G:{"1":"A cB","2":"3 9 G AB VB WB XB YB ZB aB bB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"322":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:1,C:"JavaScript modules via script tag"};

},{}],314:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H QB PB","132":"L M N O P Q R S T","260":"U V W u Y Z","516":"a"},D:{"1":"0 1 4 5 8 d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N","1028":"O P Q R S T U V W u Y Z a b c"},E:{"1":"E B A IB JB KB","2":"9 F I J C G DB FB GB HB"},F:{"1":"Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y","1028":"H L M N O P"},G:{"1":"A ZB aB bB cB","2":"3 9 G AB VB WB XB YB"},H:{"2":"dB"},I:{"1":"s","2":"2 F eB fB gB","1028":"3 hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"ES6 Number"};

},{}],315:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I QB PB"},D:{"1":"0 1 4 5 8 J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I"},E:{"1":"I J C G E B A FB GB HB IB JB KB","2":"9 F DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","4":"E LB MB NB OB"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","2":"9"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"C B"},K:{"1":"6 7 D K y","4":"B A"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Server-sent events"};

},{}],316:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"g H L","2":"D X"},C:{"1":"0 1 4 5 j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c QB PB","1025":"i","1218":"d e f K h"},D:{"1":"0 1 4 5 8 l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i","260":"j","772":"k"},E:{"1":"A JB KB","2":"9 F I J C G E B DB FB GB HB IB"},F:{"1":"Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V LB MB NB OB RB y","260":"W","772":"u"},G:{"1":"A cB","2":"3 9 G AB VB WB XB YB ZB aB bB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Fetch"};

},{}],317:[function(require,module,exports){
module.exports={A:{A:{"16":"UB","132":"G E","388":"J C B A"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H","16":"L M N O"},E:{"1":"J C G E B A GB HB IB JB KB","2":"9 F I DB FB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r MB NB OB RB y","16":"E LB"},G:{"1":"G A WB XB YB ZB aB bB cB","2":"3 9 AB VB"},H:{"388":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"B","2":"C"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B","260":"A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"disabled attribute of the fieldset element"};

},{}],318:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E UB","260":"B A"},B:{"260":"D X g H L"},C:{"1":"0 1 4 5 u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB","260":"F I J C G E B A D X g H L M N O P Q R S T U V W PB"},D:{"1":"0 1 4 5 8 h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I","260":"X g H L M N O P Q R S T U V W u Y Z a b c d e f K","388":"J C G E B A D"},E:{"1":"B A JB KB","2":"9 F I DB","260":"J C G E GB HB IB","388":"FB"},F:{"1":"U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"E A LB MB NB OB","260":"6 7 D H L M N O P Q R S T RB y"},G:{"1":"A bB cB","2":"3 9 AB VB","260":"G WB XB YB ZB aB"},H:{"2":"dB"},I:{"1":"s jB","2":"eB fB gB","260":"iB","388":"2 3 F hB"},J:{"260":"B","388":"C"},K:{"1":"K","2":"B A","260":"6 7 D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B","260":"A"},O:{"260":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"File API"};

},{}],319:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E UB","132":"B A"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s PB","2":"2 SB QB"},D:{"1":"0 1 4 5 8 J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I"},E:{"1":"J C G E B A GB HB IB JB KB","2":"9 F I DB FB"},F:{"1":"6 7 D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"E A LB MB NB OB"},G:{"1":"G A WB XB YB ZB aB bB cB","2":"3 9 AB VB"},H:{"2":"dB"},I:{"1":"2 3 F s hB iB jB","2":"eB fB gB"},J:{"1":"B","2":"C"},K:{"1":"6 7 D K y","2":"B A"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"FileReader API"};

},{}],320:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C QB PB"},D:{"1":"0 1 4 5 8 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g"},E:{"1":"J C G E B A GB HB IB JB KB","2":"9 F I DB FB"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"E LB MB","16":"6 7 A NB OB"},G:{"1":"G A WB XB YB ZB aB bB cB","2":"3 9 AB VB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"B","2":"C"},K:{"1":"6 D K y","2":"B","16":"7 A"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"FileReaderSync"};

},{}],321:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"F I J C","33":"0 1 4 5 8 X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","36":"G E B A D"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D LB MB NB OB RB y","33":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C","33":"B"},K:{"2":"6 7 B A D y","33":"K"},L:{"33":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F","33":"I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"Filesystem & FileWriter API"};

},{}],322:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x QB PB"},D:{"1":"4 5 8 s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m","16":"n o p","388":"0 1 q r w x v z t"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"eB fB gB","16":"2 3 F hB iB jB"},J:{"1":"B","2":"C"},K:{"1":"y","16":"6 7 B A D","129":"K"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"I","129":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:6,C:"FLAC audio format"};

},{}],323:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E UB","1028":"A","1316":"B"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","164":"2 SB F I J C G E B A D X g H L M N O P Q QB PB","516":"R S T U V W"},D:{"1":"0 1 4 5 8 Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","33":"Q R S T U V W u","164":"F I J C G E B A D X g H L M N O P"},E:{"1":"E B A IB JB KB","33":"C G GB HB","164":"9 F I J DB FB"},F:{"1":"M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"6 7 E A D LB MB NB OB RB","33":"H L"},G:{"1":"A ZB aB bB cB","33":"G XB YB","164":"3 9 AB VB WB"},H:{"1":"dB"},I:{"1":"s iB jB","164":"2 3 F eB fB gB hB"},J:{"1":"B","164":"C"},K:{"1":"K y","2":"6 7 B A D"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","292":"B"},O:{"164":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS Flexible Box Layout Module"};

},{}],324:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z QB PB"},D:{"1":"5 8 EB BB TB CB","2":"0 1 4 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"display: flow-root"};

},{}],325:[function(require,module,exports){
module.exports={A:{A:{"1":"J C G E B A","2":"UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v QB PB"},D:{"1":"0 1 4 5 8 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g"},E:{"1":"J C G E B A FB GB HB IB JB KB","16":"9 F I DB"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"E LB MB NB OB","16":"6 7 A"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"2":"dB"},I:{"1":"3 F s hB iB jB","2":"eB fB gB","16":"2"},J:{"1":"C B"},K:{"1":"D K y","2":"B","16":"6 7 A"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"focusin & focusout events"};

},{}],326:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB","33":"H L M N O P Q R S T U V W u Y Z a b c","164":"F I J C G E B A D X g"},D:{"1":"0 1 4 5 8 r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H","33":"Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q","292":"L M N O P"},E:{"1":"B A IB JB KB","2":"9 C G E DB GB HB","4":"F I J FB"},F:{"1":"e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y","33":"H L M N O P Q R S T U V W u Y Z a b c d"},G:{"1":"A aB bB cB","2":"G XB YB ZB","4":"3 9 AB VB WB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB","33":"iB jB"},J:{"2":"C","33":"B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"33":"kB"},P:{"1":"I","33":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS font-feature-settings"};

},{}],327:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S QB PB","194":"T U V W u Y Z a b c"},D:{"1":"0 1 4 5 8 c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u","33":"Y Z a b"},E:{"1":"B A IB JB KB","2":"9 F I J DB FB GB","33":"C G E HB"},F:{"1":"P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H LB MB NB OB RB y","33":"L M N O"},G:{"2":"3 9 AB VB WB XB","33":"G A YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s jB","2":"2 3 F eB fB gB hB","33":"iB"},J:{"2":"C","33":"B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS3 font-kerning"};

},{}],328:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d QB PB","194":"e f K h i j"},D:{"1":"0 1 4 5 8 e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d"},E:{"1":"B A JB KB","2":"9 F I J C G E DB FB GB HB IB"},F:{"1":"R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q LB MB NB OB RB y"},G:{"1":"A bB cB","2":"3 9 G AB VB WB XB YB ZB aB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS Font Loading"};

},{}],329:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 2 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"SB"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l","194":"0 1 4 5 8 m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y LB MB NB OB RB y","194":"Z a b c d e f K h i j k l m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"258":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"194":"lB"},R:{"2":"mB"}},B:4,C:"CSS font-size-adjust"};

},{}],330:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T QB PB","804":"0 1 4 5 U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"2":"F","676":"0 1 4 5 8 I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 DB","676":"F I J C G E B A FB GB HB IB JB KB"},F:{"2":"6 7 E A D LB MB NB OB RB y","676":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"CSS font-smooth"};

},{}],331:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G UB","4":"E B A"},B:{"4":"D X g H L"},C:{"1":"0 1 4 5 n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e QB PB","194":"f K h i j k l m"},D:{"1":"0 1 4 5 8 f K h i j k l m n o p q r w x v z t s EB BB TB CB","4":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e"},E:{"1":"B A JB KB","4":"9 F I J C G E DB FB GB HB IB"},F:{"1":"S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y","4":"H L M N O P Q R"},G:{"1":"A bB cB","4":"3 9 G AB VB WB XB YB ZB aB"},H:{"2":"dB"},I:{"1":"s","4":"2 3 F eB fB gB hB iB jB"},J:{"2":"C","4":"B"},K:{"2":"6 7 B A D y","4":"K"},L:{"1":"8"},M:{"1":"t"},N:{"4":"B A"},O:{"4":"kB"},P:{"1":"I","4":"F"},Q:{"1":"lB"},R:{"2":"mB"}},B:4,C:"Font unicode-range subsetting"};

},{}],332:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E UB","130":"B A"},B:{"130":"D X g H L"},C:{"1":"0 1 4 5 d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB","130":"F I J C G E B A D X g H L M N O P Q R S","322":"T U V W u Y Z a b c"},D:{"2":"F I J C G E B A D X g H","130":"0 1 4 5 8 L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"B A IB JB KB","2":"9 C G E DB GB HB","130":"F I J FB"},F:{"2":"6 7 E A D LB MB NB OB RB y","130":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"1":"A aB bB cB","2":"9 G XB YB ZB","130":"3 AB VB WB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB","130":"s iB jB"},J:{"2":"C","130":"B"},K:{"2":"6 7 B A D y","130":"K"},L:{"130":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"130":"kB"},P:{"130":"F I"},Q:{"130":"lB"},R:{"130":"mB"}},B:4,C:"CSS font-variant-alternates"};

},{}],333:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","132":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"2 SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A FB GB HB IB JB KB","2":"DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r MB NB OB RB y","2":"E LB"},G:{"1":"3 G A VB WB XB YB ZB aB bB cB","260":"9 AB"},H:{"2":"dB"},I:{"1":"3 F s hB iB jB","2":"eB","4":"2 fB gB"},J:{"1":"B","4":"C"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"@font-face Web fonts"};

},{}],334:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E"},E:{"1":"J C G E B A FB GB HB IB JB KB","2":"9 F DB","16":"I"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","2":"E"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"1":"dB"},I:{"1":"2 3 F s hB iB jB","2":"eB fB gB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Form attribute"};

},{}],335:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g"},E:{"1":"J C G E B A FB GB HB IB JB KB","2":"9 F I DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r OB RB y","2":"E LB","16":"MB NB"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"1":"dB"},I:{"1":"3 F s hB iB jB","2":"eB fB gB","16":"2"},J:{"1":"B","2":"C"},K:{"1":"6 7 A D K y","16":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Attributes for form submission"};

},{}],336:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E"},E:{"1":"A JB KB","2":"9 F DB","132":"I J C G E B FB GB HB IB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r MB NB OB RB y","2":"E LB"},G:{"1":"A cB","2":"9","132":"3 G AB VB WB XB YB ZB aB bB"},H:{"516":"dB"},I:{"1":"s jB","2":"2 eB fB gB","132":"3 F hB iB"},J:{"1":"B","132":"C"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"260":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Form validation"};

},{}],337:[function(require,module,exports){
module.exports={A:{A:{"2":"UB","4":"B A","8":"J C G E"},B:{"4":"D X g H L"},C:{"4":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","8":"2 SB QB PB"},D:{"4":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"4":"F I J C G E B A FB GB HB IB JB KB","8":"9 DB"},F:{"1":"6 7 E A D LB MB NB OB RB y","4":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"2":"9","4":"3 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB","4":"s iB jB"},J:{"2":"C","4":"B"},K:{"1":"6 7 B A D y","4":"K"},L:{"4":"8"},M:{"4":"t"},N:{"4":"B A"},O:{"1":"kB"},P:{"4":"F I"},Q:{"4":"lB"},R:{"4":"mB"}},B:1,C:"HTML5 form features"};

},{}],338:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B UB","548":"A"},B:{"516":"D X g H L"},C:{"2":"2 SB F I J C G E QB PB","676":"B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p","1700":"0 1 4 5 q r w x v z t s"},D:{"2":"F I J C G E B A D X g","676":"H L M N O","804":"0 1 4 5 8 P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I DB","676":"FB","804":"J C G E B A GB HB IB JB KB"},F:{"1":"y","2":"6 7 E A D LB MB NB OB RB","804":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C","292":"B"},K:{"2":"6 7 B A D y","804":"K"},L:{"804":"8"},M:{"1700":"t"},N:{"2":"B","548":"A"},O:{"804":"kB"},P:{"804":"F I"},Q:{"804":"lB"},R:{"804":"mB"}},B:1,C:"Full Screen API"};

},{}],339:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u QB PB"},D:{"1":"0 1 4 5 8 U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P","33":"Q R S T"},E:{"1":"A JB KB","2":"9 F I J C G E B DB FB GB HB IB"},F:{"1":"T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S LB MB NB OB RB y"},G:{"1":"A cB","2":"3 9 G AB VB WB XB YB ZB aB bB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"Gamepad API"};

},{}],340:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"UB","8":"J C G"},B:{"1":"D X g H L"},C:{"1":"0 1 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z QB PB","8":"2 SB","129":"4 5 t s"},D:{"1":"I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w","4":"F","129":"0 1 4 5 8 x v z t s EB BB TB CB"},E:{"1":"I J C G E A FB GB HB IB JB KB","8":"9 F DB","129":"B"},F:{"1":"6 7 A D L M N O P Q R S T U V W u Y Z a b c d e f K h OB RB y","2":"E H LB","8":"MB NB","129":"i j k l m n o p q r"},G:{"1":"3 9 G AB VB WB XB YB ZB aB","129":"A bB cB"},H:{"2":"dB"},I:{"1":"2 3 F eB fB gB hB iB jB","129":"s"},J:{"1":"C B"},K:{"1":"6 7 A D K y","8":"B"},L:{"129":"8"},M:{"129":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F","129":"I"},Q:{"129":"lB"},R:{"129":"mB"}},B:2,C:"Geolocation"};

},{}],341:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","644":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"SB","260":"F I J C G E B A","1156":"2","1284":"QB","1796":"PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","16":"9 DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r OB RB y","16":"E LB","132":"MB NB"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","16":"9"},H:{"1":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","132":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"Element.getBoundingClientRect()"};

},{}],342:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"SB","132":"2 QB PB"},D:{"1":"0 1 4 5 8 A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","260":"F I J C G E B"},E:{"1":"I J C G E B A FB GB HB IB JB KB","260":"9 F DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r OB RB y","260":"E LB MB NB"},G:{"1":"G A VB WB XB YB ZB aB bB cB","260":"3 9 AB"},H:{"260":"dB"},I:{"1":"3 F s hB iB jB","260":"2 eB fB gB"},J:{"1":"B","260":"C"},K:{"1":"6 7 A D K y","260":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"getComputedStyle"};

},{}],343:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"UB","8":"J C G"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","8":"SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","2":"E"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"getElementsByClassName"};

},{}],344:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B UB","33":"A"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P QB PB"},D:{"1":"0 1 4 5 8 A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B"},E:{"1":"C G E B A GB HB IB JB KB","2":"9 F I J DB FB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB WB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"B","2":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B","33":"A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"crypto.getRandomValues()"};

},{}],345:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"H L","2":"D X g"},C:{"1":"0 1 4 5 r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q QB PB"},D:{"1":"0 1 4 5 8 K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f"},E:{"2":"9 F I J C DB FB GB HB","129":"A JB KB","194":"G E B IB"},F:{"1":"T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S LB MB NB OB RB y"},G:{"2":"3 9 AB VB WB XB","129":"A cB","194":"G YB ZB aB bB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"navigator.hardwareConcurrency"};

},{}],346:[function(require,module,exports){
module.exports={A:{A:{"1":"G E B A","8":"J C UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s PB","8":"2 SB QB"},D:{"1":"0 1 4 5 8 I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","8":"F"},E:{"1":"I J C G E B A FB GB HB IB JB KB","8":"9 F DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r OB RB y","8":"E LB MB NB"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","2":"9"},H:{"2":"dB"},I:{"1":"2 3 F s fB gB hB iB jB","2":"eB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","8":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Hashchange event"};

},{}],347:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B DB FB GB HB IB JB","129":"A KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G AB VB WB XB YB ZB aB bB cB","129":"A"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:6,C:"HEIF/ISO Base Media File Format"};

},{}],348:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B UB","132":"A"},B:{"132":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B DB FB GB HB IB JB","513":"A KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"A","2":"3 9 G AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","258":"s"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"258":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F","258":"I"},Q:{"2":"lB"},R:{"2":"mB"}},B:6,C:"HEVC/H.265 video format"};

},{}],349:[function(require,module,exports){
module.exports={A:{A:{"1":"A","2":"J C G E B UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I"},E:{"1":"J C G E B A FB GB HB IB JB KB","2":"9 F I DB"},F:{"1":"6 7 D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"E A LB MB NB OB"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"1":"dB"},I:{"1":"3 F s hB iB jB","2":"2 eB fB gB"},J:{"1":"B","2":"C"},K:{"1":"6 7 D K y","2":"B A"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","2":"B"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"hidden attribute"};

},{}],350:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g QB PB"},D:{"1":"0 1 4 5 8 T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O","33":"P Q R S"},E:{"1":"G E B A IB JB KB","2":"9 F I J C DB FB GB HB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"G A ZB aB bB cB","2":"3 9 AB VB WB XB YB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"B","2":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"High Resolution Time API"};

},{}],351:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F"},E:{"1":"J C G E B A GB HB IB JB KB","2":"9 F DB","4":"I FB"},F:{"1":"6 D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"7 E A LB MB NB OB"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"9 AB","4":"3"},H:{"2":"dB"},I:{"1":"3 s fB gB iB jB","2":"2 F eB hB"},J:{"1":"C B"},K:{"1":"6 7 D K y","2":"B A"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Session history management"};

},{}],352:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 AB VB","129":"G A WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"2 3 F s hB iB jB","2":"eB","257":"fB gB"},J:{"1":"B","16":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"516":"kB"},P:{"1":"F I"},Q:{"16":"lB"},R:{"1":"mB"}},B:4,C:"HTML Media Capture"};

},{}],353:[function(require,module,exports){
module.exports={A:{A:{"2":"UB","8":"J C G","260":"E B A"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"SB","132":"2 QB PB","260":"F I J C G E B A D X g H L M N O P"},D:{"1":"0 1 4 5 8 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","132":"F I","260":"J C G E B A D X g H L M N O P Q R S T U"},E:{"1":"C G E B A GB HB IB JB KB","132":"9 F DB","260":"I J FB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","132":"E A LB MB NB OB","260":"6 7 D RB y"},G:{"1":"G A XB YB ZB aB bB cB","132":"9","260":"3 AB VB WB"},H:{"132":"dB"},I:{"1":"s iB jB","132":"eB","260":"2 3 F fB gB hB"},J:{"260":"C B"},K:{"1":"K","132":"B","260":"6 7 A D y"},L:{"1":"8"},M:{"1":"t"},N:{"260":"B A"},O:{"260":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"New semantic elements"};

},{}],354:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"J C G E B A GB HB IB JB KB","2":"9 F I DB FB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"2 3 F s hB iB jB","2":"eB fB gB"},J:{"1":"B","2":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:7,C:"HTTP Live Streaming (HLS)"};

},{}],355:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B UB","388":"A"},B:{"257":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e QB PB","257":"0 1 4 5 f K h i j k l m n o p q r w x v z t s"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j","257":"k l m n o p q r w x","1281":"0 1 4 5 8 v z t s EB BB TB CB"},E:{"2":"9 F I J C G DB FB GB HB","772":"E B A IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W LB MB NB OB RB y","257":"u Y Z a b c d e f K","1281":"h i j k l m n o p q r"},G:{"2":"3 9 G AB VB WB XB YB","257":"A ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","257":"s"},J:{"2":"C B"},K:{"2":"6 7 B A D y","257":"K"},L:{"1281":"8"},M:{"257":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"257":"F","1281":"I"},Q:{"1281":"lB"},R:{"257":"mB"}},B:6,C:"HTTP/2 protocol"};

},{}],356:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L QB PB","4":"M N O P Q R S T U V W"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"I J C G E B A FB GB HB IB JB KB","2":"9 F DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"3 G A VB WB XB YB ZB aB bB cB","2":"9 AB"},H:{"2":"dB"},I:{"1":"2 3 F s fB gB hB iB jB","2":"eB"},J:{"1":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"sandbox attribute for iframes"};

},{}],357:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v QB PB","16":"0 1 4 5 z t s"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","66":"P Q R S T U V"},E:{"2":"9 F I J G E B A DB FB GB IB JB KB","130":"C HB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB YB ZB aB bB cB","130":"XB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"seamless attribute for iframes"};

},{}],358:[function(require,module,exports){
module.exports={A:{A:{"2":"UB","8":"J C G E B A"},B:{"8":"D X g H L"},C:{"1":"0 1 4 5 U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"SB","8":"2 F I J C G E B A D X g H L M N O P Q R S T QB PB"},D:{"1":"0 1 4 5 8 P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X","8":"g H L M N O"},E:{"1":"J C G E B A GB HB IB JB KB","2":"9 DB","8":"F I FB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"E A LB MB NB OB","8":"6 7 D RB y"},G:{"1":"G A WB XB YB ZB aB bB cB","2":"9","8":"3 AB VB"},H:{"2":"dB"},I:{"1":"s iB jB","8":"2 3 F eB fB gB hB"},J:{"1":"B","8":"C"},K:{"1":"K","2":"B A","8":"6 7 D y"},L:{"1":"8"},M:{"1":"t"},N:{"8":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"srcdoc attribute for iframes"};

},{}],359:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d QB PB","194":"0 1 4 5 e f K h i j k l m n o p q r w x v z t s"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z","322":"0 1 4 5 8 t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i LB MB NB OB RB y","322":"j k l m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"322":"lB"},R:{"1":"mB"}},B:5,C:"ImageCapture API"};

},{}],360:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B UB","161":"A"},B:{"161":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B","161":"A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"Input Method Editor API"};

},{}],361:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"naturalWidth & naturalHeight image properties"};

},{}],362:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E UB","8":"B A"},B:{"8":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y QB PB","8":"Z a","200":"0 1 4 5 b c d e f K h i j k l m n o p q r w x v z t s"},D:{"1":"0 1 4 5 8 f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y","322":"Z a b c d","584":"e"},E:{"2":"9 F I DB FB","8":"J C G E B A GB HB IB JB KB"},F:{"1":"S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L LB MB NB OB RB y","1090":"M N O P Q","2120":"R"},G:{"2":"3 9 AB VB WB","8":"G A XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"8":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"HTML Imports"};

},{}],363:[function(require,module,exports){
module.exports={A:{A:{"1":"J C G E B A","16":"UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s PB","2":"2 SB","16":"QB"},D:{"1":"0 1 4 5 8 u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W"},E:{"1":"J C G E B A GB HB IB JB KB","2":"9 F I DB FB"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"6 7 E A LB MB NB OB"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"2":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"indeterminate checkbox"};

},{}],364:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E UB","132":"B A"},B:{"132":"D X g H L"},C:{"1":"0 1 4 5 L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB","33":"B A D X g H","36":"F I J C G E"},D:{"1":"0 1 4 5 8 T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"B","8":"F I J C G E","33":"S","36":"A D X g H L M N O P Q R"},E:{"1":"B A JB KB","8":"9 F I J C DB FB GB","260":"G E HB IB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"E LB MB","8":"6 7 A D NB OB RB y"},G:{"1":"A bB cB","8":"3 9 AB VB WB XB","260":"G YB ZB aB"},H:{"2":"dB"},I:{"1":"s iB jB","8":"2 3 F eB fB gB hB"},J:{"1":"B","8":"C"},K:{"1":"K","2":"B","8":"6 7 A D y"},L:{"1":"8"},M:{"1":"t"},N:{"132":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"IndexedDB"};

},{}],365:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m QB PB","132":"n o p","260":"q r w x"},D:{"1":"5 8 EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q","132":"r w x v","260":"0 1 4 z t s"},E:{"1":"A JB KB","2":"9 F I J C G E B DB FB GB HB IB"},F:{"1":"o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d LB MB NB OB RB y","132":"e f K h","260":"i j k l m n"},G:{"1":"A cB","2":"3 9 G AB VB WB XB YB ZB aB","16":"bB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","260":"s"},J:{"2":"C","16":"B"},K:{"2":"6 7 B A D y","132":"K"},L:{"260":"8"},M:{"16":"t"},N:{"2":"B A"},O:{"16":"kB"},P:{"16":"F","260":"I"},Q:{"16":"lB"},R:{"16":"mB"}},B:5,C:"IndexedDB 2.0"};

},{}],366:[function(require,module,exports){
module.exports={A:{A:{"1":"G E B A","4":"UB","132":"J C"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","36":"SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"CSS inline-block"};

},{}],367:[function(require,module,exports){
module.exports={A:{A:{"1":"J C G E B A","16":"UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A FB GB HB IB JB KB","16":"DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","16":"E"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","16":"9"},H:{"1":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Node.innerText"};

},{}],368:[function(require,module,exports){
module.exports={A:{A:{"1":"J C G E B UB","132":"A"},B:{"132":"D X g H L"},C:{"1":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y QB PB","516":"0 1 4 5 Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"1":"M N O P Q R S T U V","2":"F I J C G E B A D X g H L","132":"W u Y Z a b c d e f K h i j","260":"0 1 4 5 8 k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"J FB GB","2":"9 F I DB","2052":"C G E B A HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 AB","1025":"G A VB WB XB YB ZB aB bB cB"},H:{"1025":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2052":"B A"},O:{"1025":"kB"},P:{"1":"F I"},Q:{"260":"lB"},R:{"1":"mB"}},B:1,C:"autocomplete attribute: on & off values"};

},{}],369:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"g H L","2":"D X"},C:{"1":"0 1 4 5 Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u QB PB"},D:{"1":"0 1 4 5 8 P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O"},E:{"1":"A KB","2":"9 F I J C G E B DB FB GB HB IB JB"},F:{"1":"6 7 A D M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"E H L LB MB NB OB"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Color input type"};

},{}],370:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"X g H L","132":"D"},C:{"1":"4 5","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z QB PB","1090":"0 1 t s"},D:{"1":"0 1 4 5 8 P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 AB","260":"G A VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 eB fB gB","514":"3 F hB"},J:{"1":"B","2":"C"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Date and time input types"};

},{}],371:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F"},E:{"1":"I J C G E B A FB GB HB IB JB KB","2":"9 F DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","2":"E"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"2 3 F s hB iB jB","132":"eB fB gB"},J:{"1":"B","132":"C"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Email, telephone & URL input types"};

},{}],372:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G UB","2561":"B A","2692":"E"},B:{"2561":"D X g H L"},C:{"1":"0 1 4 5 w x v z t s","16":"SB","1537":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r PB","1796":"2 QB"},D:{"16":"F I J C G E B A D X g","1025":"0 1 4 5 8 e f K h i j k l m n o p q r w x v z t s EB BB TB CB","1537":"H L M N O P Q R S T U V W u Y Z a b c d"},E:{"16":"9 F I J DB","1025":"C G E B A GB HB IB JB KB","1537":"FB"},F:{"1":"y","16":"6 7 E A D LB MB NB OB","260":"RB","1025":"R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","1537":"H L M N O P Q"},G:{"16":"3 9 AB","1025":"G A YB ZB aB bB cB","1537":"VB WB XB"},H:{"2":"dB"},I:{"16":"eB fB","1025":"s jB","1537":"2 3 F gB hB iB"},J:{"1025":"B","1537":"C"},K:{"1":"6 7 B A D y","1025":"K"},L:{"1025":"8"},M:{"1537":"t"},N:{"2561":"B A"},O:{"1537":"kB"},P:{"1025":"F I"},Q:{"1025":"lB"},R:{"1025":"mB"}},B:1,C:"input event"};

},{}],373:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB","132":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f"},D:{"1":"0 1 4 5 8 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F","16":"I J C G Q R S T U","132":"E B A D X g H L M N O P"},E:{"2":"9 F I DB FB","132":"J C G E B A GB HB IB JB KB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"2":"WB XB","132":"G A YB ZB aB bB cB","514":"3 9 AB VB"},H:{"2":"dB"},I:{"2":"eB fB gB","260":"2 3 F hB","514":"s iB jB"},J:{"132":"B","260":"C"},K:{"2":"6 7 B A D y","260":"K"},L:{"260":"8"},M:{"2":"t"},N:{"514":"B","1028":"A"},O:{"2":"kB"},P:{"260":"F I"},Q:{"1":"lB"},R:{"260":"mB"}},B:1,C:"accept attribute for file input"};

},{}],374:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"g H L","2":"D X"},C:{"1":"0 1 4 5 x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w QB PB"},D:{"1":"0 1 4 5 8 Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"Directory selection from file input"};

},{}],375:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s PB","2":"2 SB QB"},D:{"1":"0 1 4 5 8 I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","2":"9 DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r OB RB y","2":"E LB MB NB"},G:{"1":"G A WB XB YB ZB aB bB cB","2":"3 9 AB VB"},H:{"130":"dB"},I:{"130":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"130":"6 7 B A D K y"},L:{"132":"8"},M:{"130":"t"},N:{"2":"B A"},O:{"130":"kB"},P:{"130":"F","132":"I"},Q:{"1":"lB"},R:{"132":"mB"}},B:1,C:"Multiple file selection"};

},{}],376:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L QB PB","4":"M N O P","194":"0 1 4 5 Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"194":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:1,C:"inputmode attribute"};

},{}],377:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x QB PB"},D:{"1":"0 1 4 5 8 j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i"},E:{"1":"A JB KB","2":"9 F I J C G E B DB FB GB HB IB"},F:{"1":"W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V LB MB NB OB RB y"},G:{"1":"A cB","2":"3 9 G AB VB WB XB YB ZB aB bB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:1,C:"Minimum length attribute for input fields"};

},{}],378:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E UB","129":"B A"},B:{"129":"D X","1025":"g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u QB PB","513":"0 1 4 5 Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"1":"0 1 4 5 8 J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I"},E:{"1":"I J C G E B A FB GB HB IB JB KB","2":"9 F DB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"388":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 eB fB gB","388":"3 F s hB iB jB"},J:{"2":"C","388":"B"},K:{"1":"6 7 B A D y","388":"K"},L:{"388":"8"},M:{"641":"t"},N:{"388":"B A"},O:{"388":"kB"},P:{"388":"F I"},Q:{"1":"lB"},R:{"388":"mB"}},B:1,C:"Number input type"};

},{}],379:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E"},E:{"1":"A JB KB","2":"9 F DB","16":"I","388":"J C G E B FB GB HB IB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","2":"E"},G:{"1":"A cB","16":"3 9 AB","388":"G VB WB XB YB ZB aB bB"},H:{"2":"dB"},I:{"1":"s jB","2":"2 3 F eB fB gB hB iB"},J:{"1":"B","2":"C"},K:{"1":"6 7 B A D y","132":"K"},L:{"1":"8"},M:{"1":"t"},N:{"132":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Pattern attribute for input fields"};

},{}],380:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"I J C G E B A FB GB HB IB JB KB","132":"9 F DB"},F:{"1":"6 D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"E LB MB NB OB","132":"7 A"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 s eB fB gB iB jB","4":"F hB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"input placeholder attribute"};

},{}],381:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"2":"dB"},I:{"1":"3 s iB jB","4":"2 F eB fB gB hB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Range input type"};

},{}],382:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E UB","129":"B A"},B:{"129":"D X g H L"},C:{"2":"2 SB QB PB","129":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"1":"0 1 4 5 8 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g Q R S T U","129":"H L M N O P"},E:{"1":"J C G E B A FB GB HB IB JB KB","16":"9 F I DB"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"E LB MB NB OB","16":"6 7 A"},G:{"1":"G A VB WB XB YB ZB aB bB cB","16":"3 9 AB"},H:{"129":"dB"},I:{"1":"s iB jB","16":"eB fB","129":"2 3 F gB hB"},J:{"1":"C","129":"B"},K:{"1":"D","2":"B","16":"6 7 A","129":"K y"},L:{"1":"8"},M:{"129":"t"},N:{"129":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Search input type"};

},{}],383:[function(require,module,exports){
module.exports={A:{A:{"1":"J C G E B A","16":"UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","16":"E"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Element.insertAdjacentElement() & Element.insertAdjacentText()"};

},{}],384:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","16":"UB","132":"J C G E"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","2":"9 DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r MB NB OB RB y","16":"E LB"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","16":"9"},H:{"1":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"Element.insertAdjacentHTML()"};

},{}],385:[function(require,module,exports){
module.exports={A:{A:{"1":"A","2":"J C G E B UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u QB PB"},D:{"1":"0 1 4 5 8 T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S"},E:{"1":"B A JB KB","2":"9 F I J C G E DB FB GB HB IB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"A bB cB","2":"3 9 G AB VB WB XB YB ZB aB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"2":"t"},N:{"1":"A","2":"B"},O:{"2":"kB"},P:{"1":"F I"},Q:{"2":"lB"},R:{"1":"mB"}},B:6,C:"Internationalization API"};

},{}],386:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"H L","2":"D X g"},C:{"1":"4 5 t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v QB PB","194":"0 1 z"},D:{"1":"0 1 4 5 8 v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"IntersectionObserver"};

},{}],387:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"SB","932":"0 1 2 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"F I J C G E B A D X g H L M N O P Q","545":"R S T U V W u Y Z a b c d e f K h i j k l m n o","1537":"0 1 4 5 8 p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J DB FB","516":"A KB","548":"E B IB JB","676":"C G GB HB"},F:{"2":"6 7 E A D LB MB NB OB RB y","513":"d","545":"H L M N O P Q R S T U V W u Y Z a b","1537":"c e f K h i j k l m n o p q r"},G:{"2":"3 9 AB VB WB","548":"A ZB aB bB cB","676":"G XB YB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB","545":"iB jB","1537":"s"},J:{"2":"C","545":"B"},K:{"2":"6 7 B A D y","1537":"K"},L:{"1537":"8"},M:{"932":"t"},N:{"2":"B A"},O:{"545":"kB"},P:{"545":"F","1537":"I"},Q:{"545":"lB"},R:{"1537":"mB"}},B:5,C:"Intrinsic & Extrinsic Sizing"};

},{}],388:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"J C G E B A GB HB IB JB KB","2":"9 F DB","129":"I FB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:6,C:"JPEG 2000 image format"};

},{}],389:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"1":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:6,C:"JPEG XR image format"};

},{}],390:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C UB","129":"G"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"2 SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","2":"9 DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r NB OB RB y","2":"E LB MB"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","2":"9"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"JSON parsing"};

},{}],391:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 2 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"I J C G E B A FB GB HB IB JB KB","2":"9 F DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"3 G A VB WB XB YB ZB aB bB cB","16":"9 AB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"eB fB gB","132":"2 3 F hB"},J:{"1":"B","2":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:7,C:"Improved kerning pairs & ligatures"};

},{}],392:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","16":"SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","16":"9 DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"6 7 E A LB MB NB OB RB","16":"D"},G:{"1":"G A VB WB XB YB ZB aB bB cB","16":"3 9 AB"},H:{"2":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"1":"y","2":"6 7 B A","16":"D","130":"K"},L:{"1":"8"},M:{"130":"t"},N:{"130":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:7,C:"KeyboardEvent.charCode"};

},{}],393:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K QB PB"},D:{"1":"0 1 4 5 8 r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k","194":"l m n o p q"},E:{"1":"A JB KB","2":"9 F I J C G E B DB FB GB HB IB"},F:{"1":"e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u LB MB NB OB RB y","194":"Y Z a b c d"},G:{"1":"A cB","2":"3 9 G AB VB WB XB YB ZB aB bB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D y","194":"K"},L:{"194":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F","194":"I"},Q:{"2":"lB"},R:{"194":"mB"}},B:5,C:"KeyboardEvent.code"};

},{}],394:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g QB PB"},D:{"1":"0 1 4 5 8 Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y"},E:{"1":"A JB KB","2":"9 F I J C G E B DB FB GB HB IB"},F:{"1":"M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"6 7 E A H L LB MB NB OB RB","16":"D"},G:{"1":"A cB","2":"3 9 G AB VB WB XB YB ZB aB bB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"2":"C B"},K:{"1":"K y","2":"6 7 B A","16":"D"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"KeyboardEvent.getModifierState()"};

},{}],395:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G UB","260":"E B A"},B:{"260":"D X g H L"},C:{"1":"0 1 4 5 Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R QB PB","132":"S T U V W u"},D:{"1":"0 1 4 5 8 v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x"},E:{"1":"A JB KB","2":"9 F I J C G E B DB FB GB HB IB"},F:{"1":"h i j k l m n o p q r y","2":"6 7 E A H L M N O P Q R S T U V W u Y Z a b c d e f K LB MB NB OB RB","16":"D"},G:{"1":"A cB","2":"3 9 G AB VB WB XB YB ZB aB bB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"y","2":"6 7 B A K","16":"D"},L:{"1":"8"},M:{"1":"t"},N:{"260":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"KeyboardEvent.key"};

},{}],396:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g QB PB"},D:{"1":"0 1 4 5 8 Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","132":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y"},E:{"1":"C G E B A GB HB IB JB KB","16":"9 J DB","132":"F I FB"},F:{"1":"M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"6 7 E A LB MB NB OB RB","16":"D","132":"H L"},G:{"1":"G A YB ZB aB bB cB","16":"3 9 AB","132":"VB WB XB"},H:{"2":"dB"},I:{"1":"s iB jB","16":"eB fB","132":"2 3 F gB hB"},J:{"132":"C B"},K:{"1":"K y","2":"6 7 B A","16":"D"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"KeyboardEvent.location"};

},{}],397:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"J C G E B A FB GB HB IB JB KB","2":"9 F DB","16":"I"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r MB NB OB RB y","16":"E LB"},G:{"1":"G A VB WB XB YB ZB aB bB cB","16":"3 9 AB"},H:{"2":"dB"},I:{"1":"2 3 F s gB hB","16":"eB fB","132":"iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D y","132":"K"},L:{"132":"8"},M:{"132":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"2":"F","132":"I"},Q:{"1":"lB"},R:{"132":"mB"}},B:7,C:"KeyboardEvent.which"};

},{}],398:[function(require,module,exports){
module.exports={A:{A:{"1":"A","2":"J C G E B UB"},B:{"1":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"1":"A","2":"B"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"Resource Hints: Lazyload"};

},{}],399:[function(require,module,exports){
module.exports={A:{A:{"1":"A","2":"J C G E B UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 n o p q r w x v z t s","194":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m QB PB"},D:{"1":"0 1 4 5 8 w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N","322":"O P Q R S T U V W u Y Z a b c d e f K h i j","516":"k l m n o p q r"},E:{"1":"B A JB KB","2":"9 F I J C G E DB FB GB HB IB"},F:{"1":"f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y","322":"H L M N O P Q R S T U V W","516":"u Y Z a b c d e"},G:{"1":"A bB cB","2":"3 9 G AB VB WB XB YB ZB aB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","2":"B"},O:{"2":"kB"},P:{"1":"I","516":"F"},Q:{"2":"lB"},R:{"516":"mB"}},B:6,C:"let"};

},{}],400:[function(require,module,exports){
module.exports={A:{A:{"1":"A","2":"J C G E B UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"129":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"257":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"129":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","513":"6 7 E A D LB MB NB OB RB y"},G:{"1026":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1026":"dB"},I:{"1":"2 3 F eB fB gB hB","513":"s iB jB"},J:{"1":"C","1026":"B"},K:{"1026":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1026":"B A"},O:{"257":"kB"},P:{"1":"I","513":"F"},Q:{"129":"lB"},R:{"1":"mB"}},B:1,C:"PNG favicons"};

},{}],401:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB QB PB","260":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j","1025":"0 1 4 5 k l m n o p q r w x v z t s"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB","16":"BB TB CB"},E:{"2":"9 F I J C G DB FB GB HB","516":"E B A IB JB KB"},F:{"1":"n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m LB MB NB OB RB y"},G:{"130":"3 9 G AB VB WB XB YB","516":"A ZB aB bB cB"},H:{"130":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C","130":"B"},K:{"130":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"130":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:1,C:"SVG favicons"};

},{}],402:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G UB","132":"E"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"2 SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"I J C G E B A FB GB HB IB JB KB","2":"9 F DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"16":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"16":"2 3 F s eB fB gB hB iB jB"},J:{"16":"C B"},K:{"16":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","2":"B"},O:{"16":"kB"},P:{"1":"I","16":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"Resource Hints: dns-prefetch"};

},{}],403:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h QB PB","129":"i"},D:{"1":"0 1 4 5 8 p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"16":"t"},N:{"2":"B A"},O:{"16":"kB"},P:{"1":"I","2":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"Resource Hints: preconnect"};

},{}],404:[function(require,module,exports){
module.exports={A:{A:{"1":"A","2":"J C G E B UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"F s iB jB","2":"2 3 eB fB gB hB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","2":"B"},O:{"2":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"Resource Hints: prefetch"};

},{}],405:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t QB PB","132":"4 5 s"},D:{"1":"0 1 4 5 8 x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w"},E:{"1":"A KB","2":"9 F I J C G E B DB FB GB HB IB JB"},F:{"1":"K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"Resource Hints: preload"};

},{}],406:[function(require,module,exports){
module.exports={A:{A:{"1":"A","2":"J C G E B UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"5 8 F I J C G E B A D EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"2":"t"},N:{"1":"A","2":"B"},O:{"2":"kB"},P:{"1":"F I"},Q:{"2":"lB"},R:{"1":"mB"}},B:5,C:"Resource Hints: prerender"};

},{}],407:[function(require,module,exports){
module.exports={A:{A:{"1":"A","16":"UB","132":"J C G E B"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 Y Z a b c d e f K h i j k l m n o p q r w x v z t s","132":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u QB PB"},D:{"1":"0 1 4 5 8 T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","132":"F I J C G E B A D X g H L M N O P Q R S"},E:{"1":"B A JB KB","132":"9 F I J C G E DB FB GB HB IB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","16":"6 7 E A D LB MB NB OB RB","132":"y"},G:{"1":"A bB cB","132":"3 9 G AB VB WB XB YB ZB aB"},H:{"132":"dB"},I:{"1":"s iB jB","132":"2 3 F eB fB gB hB"},J:{"132":"C B"},K:{"1":"K","16":"6 7 B A D","132":"y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","132":"B"},O:{"132":"kB"},P:{"1":"I","132":"F"},Q:{"132":"lB"},R:{"1":"mB"}},B:6,C:"localeCompare()"};

},{}],408:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G UB","36":"E B A"},B:{"1":"H L","36":"D X g"},C:{"1":"0 1 4 5 d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB","36":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c PB"},D:{"1":"0 1 4 5 8 d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","36":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c"},E:{"1":"G E B A HB IB JB KB","2":"9 F DB","36":"I J C FB GB"},F:{"1":"Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"7 E A LB MB NB OB","36":"6 D H L M N O P RB y"},G:{"1":"G A YB ZB aB bB cB","2":"9","36":"3 AB VB WB XB"},H:{"2":"dB"},I:{"1":"s","2":"eB","36":"2 3 F fB gB hB iB jB"},J:{"36":"C B"},K:{"1":"K","2":"B A","36":"6 7 D y"},L:{"1":"8"},M:{"1":"t"},N:{"36":"B A"},O:{"36":"kB"},P:{"1":"I","36":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"matches() DOM method"};

},{}],409:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I QB PB"},D:{"1":"0 1 4 5 8 E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G"},E:{"1":"J C G E B A FB GB HB IB JB KB","2":"9 F I DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"6 7 E A D LB MB NB OB RB"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"1":"dB"},I:{"1":"2 3 F s hB iB jB","2":"eB fB gB"},J:{"1":"B","2":"C"},K:{"1":"K y","2":"6 7 B A D"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"matchMedia"};

},{}],410:[function(require,module,exports){
module.exports={A:{A:{"2":"E B A UB","8":"J C G"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","129":"2 SB QB PB"},D:{"1":"T","8":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"B A JB KB","260":"9 F I J C G E DB FB GB HB IB"},F:{"2":"E","4":"6 7 A D LB MB NB OB RB y","8":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"1":"G A VB WB XB YB ZB aB bB cB","8":"3 9 AB"},H:{"8":"dB"},I:{"8":"2 3 F s eB fB gB hB iB jB"},J:{"1":"B","8":"C"},K:{"8":"6 7 B A D K y"},L:{"8":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"4":"kB"},P:{"8":"F I"},Q:{"8":"lB"},R:{"8":"mB"}},B:2,C:"MathML"};

},{}],411:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","16":"UB","900":"J C G E"},B:{"1025":"D X g H L"},C:{"1":"0 1 4 5 v z t s","900":"2 SB QB PB","1025":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"J C G E B A FB GB HB IB JB KB","16":"I DB","900":"9 F"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","16":"E","132":"6 7 A D LB MB NB OB RB y"},G:{"1":"3 A AB VB WB XB ZB aB bB cB","16":"9","2052":"G YB"},H:{"132":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"132":"6 7 B A D y","4100":"K"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"4100":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"maxlength attribute for input and textarea elements"};

},{}],412:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g QB PB"},D:{"1":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c","2":"0 1 4 5 8 d e f K h i j k l m n o p q r w x v z t s EB","16":"BB TB CB"},E:{"1":"J C G E B A FB GB HB IB JB KB","2":"9 F I DB"},F:{"1":"6 7 A D H L M N O P Q R S T MB NB OB RB y","2":"E U V W u Y Z a b c d e f K h i j k l m n o p q r LB"},G:{"1":"G A VB WB XB YB ZB aB bB cB","16":"3 9 AB"},H:{"16":"dB"},I:{"1":"3 F s hB iB jB","16":"2 eB fB gB"},J:{"16":"C B"},K:{"1":"D K y","16":"6 7 B A"},L:{"1":"8"},M:{"1":"t"},N:{"16":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"2":"lB"},R:{"1":"mB"}},B:1,C:"Media attribute"};

},{}],413:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"4 5 8 EB BB TB CB","2":"0 1 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},E:{"2":"9 F I J C G E B DB FB GB HB IB JB","16":"A KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p LB MB NB OB RB y","16":"q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:6,C:"Media Session API"};

},{}],414:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l QB PB"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x","193":"0 1 4 5 8 v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:5,C:"Media Capture from DOM Elements API"};

},{}],415:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u QB PB"},D:{"1":"0 1 4 5 8 w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p","194":"q r"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c LB MB NB OB RB y","194":"d e"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"MediaRecorder API"};

},{}],416:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B UB","260":"A"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T QB PB","194":"U V W u Y Z a b c d e f K h i j k"},D:{"1":"0 1 4 5 8 a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L","33":"S T U V W u Y Z","66":"M N O P Q R"},E:{"1":"G E B A IB JB KB","2":"9 F I J C DB FB GB HB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s jB","2":"2 3 F eB fB gB hB iB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","2":"B"},O:{"1":"kB"},P:{"1":"I","514":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:4,C:"Media Source Extensions"};

},{}],417:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB F I J C QB PB","132":"0 1 4 5 G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j","322":"r w x v","578":"k l m n o p q","2114":"0 1 4 5 8 z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d LB MB NB OB RB y","322":"e f K h","2114":"i j k l m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"1156":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2114":"lB"},R:{"2":"mB"}},B:1,C:"Toolbar/context menu"};

},{}],418:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"X g H L","2":"D"},C:{"1":"0 1 4 5 L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H QB PB"},D:{"1":"0 1 4 5 8 G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C"},E:{"1":"J C G E B A GB HB IB JB KB","2":"9 F I DB FB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"E LB MB NB OB"},G:{"1":"A cB","2":"3 9 G AB VB WB XB YB ZB aB bB"},H:{"1":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"meter element"};

},{}],419:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"F I"},Q:{"2":"lB"},R:{"1":"mB"}},B:5,C:"Web MIDI API"};

},{}],420:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","8":"J UB","129":"C","257":"G"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"CSS min/max-width/height"};

},{}],421:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB","132":"F I J C G E B A D X g H L M N O P Q QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","2":"9 DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","2":"9"},H:{"2":"dB"},I:{"1":"2 3 F s gB hB iB jB","2":"eB fB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"MP3 audio format"};

},{}],422:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P QB PB","4":"Q R S T U V W u Y Z a b c d"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A FB GB HB IB JB KB","2":"DB"},F:{"1":"U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s iB jB","4":"2 3 F eB fB hB","132":"gB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"260":"t"},N:{"1":"B A"},O:{"4":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"MPEG-4/H.264 video format"};

},{}],423:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s PB","2":"2 SB QB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r NB OB RB y","2":"E LB MB"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS3 Multiple backgrounds"};

},{}],424:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"132":"0 1 4 5 z t s","164":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v QB PB"},D:{"132":"0 1 4 5 8 x v z t s EB BB TB CB","420":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w"},E:{"132":"E B A IB JB KB","164":"C G HB","420":"9 F I J DB FB GB"},F:{"1":"6 7 D RB y","2":"E A LB MB NB OB","132":"K h i j k l m n o p q r","420":"H L M N O P Q R S T U V W u Y Z a b c d e f"},G:{"132":"A ZB aB bB cB","164":"G XB YB","420":"3 9 AB VB WB"},H:{"1":"dB"},I:{"132":"s","420":"2 3 F eB fB gB hB iB jB"},J:{"420":"C B"},K:{"1":"6 7 D y","2":"B A","132":"K"},L:{"132":"8"},M:{"132":"t"},N:{"1":"B A"},O:{"420":"kB"},P:{"132":"I","420":"F"},Q:{"132":"lB"},R:{"132":"mB"}},B:4,C:"CSS3 Multiple column layout"};

},{}],425:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G UB","260":"E B A"},B:{"260":"D X g H L"},C:{"2":"2 SB F I QB PB","260":"0 1 4 5 J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"16":"F I J C G E B A D X g","132":"0 1 4 5 8 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"16":"9 DB","132":"F I J C G E B A FB GB HB IB JB KB"},F:{"1":"D RB y","2":"E LB MB NB OB","16":"6 7 A","132":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"16":"9 AB","132":"3 G A VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"16":"eB fB","132":"2 3 F s gB hB iB jB"},J:{"132":"C B"},K:{"1":"D y","2":"B","16":"6 7 A","132":"K"},L:{"132":"8"},M:{"260":"t"},N:{"260":"B A"},O:{"132":"kB"},P:{"132":"F I"},Q:{"132":"lB"},R:{"132":"mB"}},B:5,C:"Mutation events"};

},{}],426:[function(require,module,exports){
module.exports={A:{A:{"1":"A","2":"J C G UB","8":"E B"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X QB PB"},D:{"1":"0 1 4 5 8 W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M","33":"N O P Q R S T U V"},E:{"1":"C G E B A GB HB IB JB KB","2":"9 F I DB FB","33":"J"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB","33":"WB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 eB fB gB","8":"3 F hB"},J:{"1":"B","2":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","8":"B"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Mutation Observer"};

},{}],427:[function(require,module,exports){
module.exports={A:{A:{"1":"G E B A","2":"UB","8":"J C"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","4":"2 SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","2":"9 DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r NB OB RB y","2":"E LB MB"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Web Storage - name/value pairs"};

},{}],428:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J QB PB"},D:{"1":"0 1 4 5 8 X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I","33":"J C G E B A D"},E:{"1":"G E B A IB JB KB","2":"9 F I J C DB FB GB HB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"G A ZB aB bB cB","2":"3 9 AB VB WB XB YB"},H:{"2":"dB"},I:{"1":"3 F s hB iB jB","2":"2 eB fB gB"},J:{"1":"B","2":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"Navigation Timing API"};

},{}],429:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"eB iB jB","132":"2 3 F fB gB hB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","132":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:7,C:"Network Information API"};

},{}],430:[function(require,module,exports){
module.exports={A:{A:{"16":"UB","644":"E B A","2308":"J C G"},B:{"1":"X g H L","16":"D"},C:{"1":"0 1 4 5 E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G QB PB"},D:{"1":"0 1 4 5 8 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g H L M N O P Q R S T U"},E:{"1":"C G E B A GB HB IB JB KB","16":"9 F I J DB","1668":"FB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","16":"6 7 E A D LB MB NB OB","132":"RB"},G:{"1":"G A XB YB ZB aB bB cB","16":"3 9 AB VB WB"},H:{"16":"dB"},I:{"1":"s iB jB","16":"2 eB fB gB","1668":"3 F hB"},J:{"16":"C B"},K:{"16":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"16":"B A"},O:{"16":"kB"},P:{"1":"I","16":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Node.contains()"};

},{}],431:[function(require,module,exports){
module.exports={A:{A:{"16":"UB","132":"E B A","260":"J C G"},B:{"1":"X g H L","16":"D"},C:{"1":"0 1 4 5 E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G QB PB"},D:{"1":"0 1 4 5 8 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g H L M N O P Q R S T U"},E:{"1":"J C G E B A FB GB HB IB JB KB","16":"9 F I DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","16":"6 7 E A LB MB NB OB","132":"D RB y"},G:{"1":"G A WB XB YB ZB aB bB cB","16":"3 9 AB VB"},H:{"16":"dB"},I:{"1":"3 F s hB iB jB","16":"2 eB fB gB"},J:{"16":"C B"},K:{"16":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"16":"B A"},O:{"16":"kB"},P:{"1":"I","16":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Node.parentElement"};

},{}],432:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"g H L","2":"D X"},C:{"1":"0 1 4 5 R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q QB PB"},D:{"1":"0 1 4 5 8 R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F","36":"I J C G E B A D X g H L M N O P Q"},E:{"1":"J C G E B A GB HB IB JB KB","2":"9 F I DB FB"},F:{"1":"U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB","36":"s iB jB"},J:{"1":"B","2":"C"},K:{"2":"6 7 B A D y","36":"K"},L:{"258":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"36":"F","258":"I"},Q:{"2":"lB"},R:{"258":"mB"}},B:1,C:"Web Notifications"};

},{}],433:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"L","2":"D X g H"},C:{"1":"0 1 4 5 f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e QB PB"},D:{"1":"0 1 4 5 8 a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z"},E:{"1":"B A JB KB","2":"9 F I J C DB FB GB","132":"G E HB IB"},F:{"1":"O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"E H L M N LB MB NB","33":"6 7 A D OB RB y"},G:{"1":"A bB cB","2":"3 9 AB VB WB XB","132":"G YB ZB aB"},H:{"33":"dB"},I:{"1":"s jB","2":"2 3 F eB fB gB hB iB"},J:{"2":"C B"},K:{"1":"K","2":"B","33":"6 7 A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS3 object-fit/object-position"};

},{}],434:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"f K h i j k l m n o p q r w","2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"S T U V W u Y Z a b c d e f","2":"6 7 E A D H L M N O P Q R K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F","2":"I"},Q:{"1":"lB"},R:{"1":"mB"}},B:7,C:"Object.observe data binding"};

},{}],435:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"X g H L","2":"D"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"A","2":"3 9 G AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C","130":"B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:6,C:"Object RTC (ORTC) API for WebRTC"};

},{}],436:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"E UB","8":"J C G"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","4":"2","8":"SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","8":"9 DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r OB RB y","2":"E LB","8":"MB NB"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:7,C:"Offline web applications"};

},{}],437:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m QB PB","194":"0 1 4 5 n o p q r w x v z t s"},D:{"2":"0 1 4 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","322":"5 8 EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n LB MB NB OB RB y","322":"o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"194":"8"},M:{"194":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:1,C:"OffscreenCanvas"};

},{}],438:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"2 SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r NB OB RB y","2":"E LB MB"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"B","2":"C"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"Ogg Vorbis audio format"};

},{}],439:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G UB","8":"E B A"},B:{"8":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"2 SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r NB OB RB y","2":"E LB MB"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"1":"t"},N:{"8":"B A"},O:{"1":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:6,C:"Ogg/Theora video format"};

},{}],440:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M QB PB"},D:{"1":"0 1 4 5 8 P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H","16":"L M N O"},E:{"1":"C G E B A GB HB IB JB KB","2":"9 F I DB FB","16":"J"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"6 7 E A LB MB NB OB RB","16":"D"},G:{"1":"G A WB XB YB ZB aB bB cB","2":"3 9 AB VB"},H:{"1":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"B","2":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Reversed attribute of ordered lists"};

},{}],441:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"L","2":"D X g H"},C:{"1":"0 1 4 5 x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w QB PB"},D:{"1":"4 5 8 t s EB BB TB CB","2":"0 1 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z"},E:{"1":"B A JB KB","2":"9 F I J C G E DB FB GB HB IB"},F:{"1":"l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k LB MB NB OB RB y"},G:{"1":"A bB cB","2":"3 9 G AB VB WB XB YB ZB aB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:1,C:"\"once\" event listener option"};

},{}],442:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C UB","260":"G"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 k l m n o p q r w x v z t s QB PB","2":"2 SB","516":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j"},D:{"1":"0 1 4 5 8 g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X"},E:{"1":"I J C G E B A FB GB HB IB JB KB","2":"9 F DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB","4":"y"},G:{"1":"3 G A VB WB XB YB ZB aB bB cB","16":"9 AB"},H:{"2":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"B","132":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"132":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Online/offline status"};

},{}],443:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"g H L","2":"D X"},C:{"1":"0 1 4 5 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g QB PB"},D:{"1":"0 1 4 5 8 c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:6,C:"Opus"};

},{}],444:[function(require,module,exports){
module.exports={A:{A:{"2":"J C UB","260":"G","388":"E B A"},B:{"1":"H L","388":"D X g"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB","129":"y","260":"6 7 E A LB MB NB OB"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"D K y","260":"6 7 B A"},L:{"1":"8"},M:{"1":"t"},N:{"388":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS outline properties"};

},{}],445:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"H L","2":"D X g"},C:{"1":"0 1 4 5 r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q QB PB"},D:{"1":"4 5 8 EB BB TB CB","2":"0 1 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},E:{"1":"B A JB KB","2":"9 F I J C G E DB FB GB HB IB"},F:{"1":"n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m LB MB NB OB RB y"},G:{"1":"A bB cB","2":"3 9 G AB VB WB XB YB ZB aB"},H:{"16":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","16":"s"},J:{"2":"C","16":"B"},K:{"2":"6 7 B A D y","16":"K"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"String.prototype.padStart(), String.prototype.padEnd()"};

},{}],446:[function(require,module,exports){
module.exports={A:{A:{"1":"A","2":"J C G E B UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"I J C G E B A FB GB HB IB JB KB","2":"9 F DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"G A VB WB XB YB ZB aB bB cB","16":"3 9 AB"},H:{"2":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","2":"B"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"PageTransitionEvent"};

},{}],447:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E QB PB","33":"B A D X g H L M"},D:{"1":"0 1 4 5 8 c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X","33":"g H L M N O P Q R S T U V W u Y Z a b"},E:{"1":"C G E B A GB HB IB JB KB","2":"9 F I J DB FB"},F:{"1":"P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"6 7 E A D LB MB NB OB RB","33":"H L M N O"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB WB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB","33":"iB jB"},J:{"1":"B","2":"C"},K:{"1":"K y","2":"6 7 B A D"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"I","33":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"Page Visibility"};

},{}],448:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"L","2":"D X g H"},C:{"1":"0 1 4 5 w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r QB PB"},D:{"1":"0 1 4 5 8 v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x"},E:{"1":"B A JB KB","2":"9 F I J C G E DB FB GB HB IB"},F:{"1":"h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K LB MB NB OB RB y"},G:{"1":"A bB cB","2":"3 9 G AB VB WB XB YB ZB aB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"2":"mB"}},B:1,C:"Passive event listeners"};

},{}],449:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"H L","2":"D X","322":"g"},C:{"2":"0 1 2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z QB PB","4162":"4 5 t s"},D:{"1":"BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z","194":"0 1 4 5 t s","1090":"8 EB"},E:{"2":"9 F I J C G E DB FB GB HB IB","514":"B A JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i LB MB NB OB RB y","194":"j k l m n o p q r"},G:{"2":"3 9 G AB VB WB XB YB ZB aB","514":"A bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2049":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"194":"lB"},R:{"2":"mB"}},B:5,C:"Payment Request API"};

},{}],450:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o QB PB"},D:{"1":"0 1 4 5 8 m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"Permissions API"};

},{}],451:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"X g H L","2":"D"},C:{"1":"0 1 4 5 h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c QB PB","578":"d e f K"},D:{"1":"0 1 4 5 8 h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f","194":"K"},E:{"1":"B A IB JB KB","2":"9 F I J C G E DB FB GB HB"},F:{"1":"U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S LB MB NB OB RB y","322":"T"},G:{"1":"A aB bB cB","2":"3 9 G AB VB WB XB YB ZB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Picture element"};

},{}],452:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"SB","194":"0 1 2 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g"},E:{"1":"J C G E B A GB HB IB JB KB","2":"9 F I DB FB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"194":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Ping attribute"};

},{}],453:[function(require,module,exports){
module.exports={A:{A:{"1":"C G E B A","2":"UB","8":"J"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"PNG alpha transparency"};

},{}],454:[function(require,module,exports){
module.exports={A:{A:{"1":"A","2":"J C G E B UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s PB","2":"2 SB QB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","2":"9 DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","2":"B"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:7,C:"CSS pointer-events (for HTML)"};

},{}],455:[function(require,module,exports){
module.exports={A:{A:{"1":"A","2":"J C G E UB","164":"B"},B:{"1":"D X g H L"},C:{"2":"2 SB F I QB PB","8":"J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j","328":"0 1 4 5 k l m n o p q r w x v z t s"},D:{"1":"4 5 8 t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q","8":"R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v","584":"0 1 z"},E:{"2":"9 F I J DB FB","8":"C G E B A GB HB IB JB KB"},F:{"1":"l m n o p q r","2":"6 7 E A D LB MB NB OB RB y","8":"H L M N O P Q R S T U V W u Y Z a b c d e f K h","584":"i j k"},G:{"8":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","8":"2 3 F eB fB gB hB iB jB"},J:{"8":"C B"},K:{"2":"B","8":"6 7 A D K y"},L:{"1":"8"},M:{"328":"t"},N:{"1":"A","36":"B"},O:{"8":"kB"},P:{"2":"I","8":"F"},Q:{"584":"lB"},R:{"2":"mB"}},B:2,C:"Pointer events"};

},{}],456:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"X g H L","2":"D"},C:{"1":"0 1 4 5 k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X QB PB","33":"g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j"},D:{"1":"0 1 4 5 8 K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H","33":"R S T U V W u Y Z a b c d e f","66":"L M N O P Q"},E:{"1":"A JB KB","2":"9 F I J C G E B DB FB GB HB IB"},F:{"1":"T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y","33":"H L M N O P Q R S"},G:{"1":"A cB","2":"3 9 G AB VB WB XB YB ZB aB bB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:4,C:"PointerLock API"};

},{}],457:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I QB PB"},D:{"1":"0 1 4 5 8 G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C"},E:{"1":"J C G E B A GB HB IB JB KB","2":"9 F I DB FB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"E LB MB NB OB"},G:{"2":"3 9 AB VB WB","132":"G A XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"progress element"};

},{}],458:[function(require,module,exports){
module.exports={A:{A:{"8":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 Y Z a b c d e f K h i j k l m n o p q r w x v z t s","4":"W u","8":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V QB PB"},D:{"1":"0 1 4 5 8 c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","4":"b","8":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a"},E:{"1":"G E B A HB IB JB KB","8":"9 F I J C DB FB GB"},F:{"1":"P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","4":"O","8":"6 7 E A D H L M N LB MB NB OB RB y"},G:{"1":"G A YB ZB aB bB cB","8":"3 9 AB VB WB XB"},H:{"8":"dB"},I:{"1":"s jB","8":"2 3 F eB fB gB hB iB"},J:{"8":"C B"},K:{"1":"K","8":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"8":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"Promises"};

},{}],459:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:4,C:"Proximity API"};

},{}],460:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M QB PB"},D:{"1":"0 1 4 5 8 w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N h i j k l m n o p q r","66":"O P Q R S T U V W u Y Z a b c d e f K"},E:{"1":"B A JB KB","2":"9 F I J C G E DB FB GB HB IB"},F:{"1":"f K h i j k l m n o p q r","2":"6 7 E A D U V W u Y Z a b c d e LB MB NB OB RB y","66":"H L M N O P Q R S T"},G:{"1":"A bB cB","2":"3 9 G AB VB WB XB YB ZB aB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"2":"mB"}},B:6,C:"Proxy object"};

},{}],461:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d QB PB"},D:{"1":"0 1 4 5 8 h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O LB MB NB OB RB y","4":"S","16":"P Q R T"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"F I"},Q:{"2":"lB"},R:{"1":"mB"}},B:6,C:"Public Key Pinning"};

},{}],462:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m QB PB","257":"0 1 4 5 n p q r w x v t s","1281":"o z"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m","257":"0 1 4 5 8 x v z t s EB BB TB CB","388":"n o p q r w"},E:{"2":"9 F I J C G E DB FB GB HB","514":"B A IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f LB MB NB OB RB y","16":"K h i j k","257":"l m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"2":"mB"}},B:5,C:"Push API"};

},{}],463:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"UB","8":"J C","132":"G"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","8":"2 SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r MB NB OB RB y","8":"E LB"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"querySelector/querySelectorAll"};

},{}],464:[function(require,module,exports){
module.exports={A:{A:{"1":"J C G E B A","16":"UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","16":"2 SB QB PB"},D:{"1":"0 1 4 5 8 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g H L M N O P Q R S T U"},E:{"1":"J C G E B A FB GB HB IB JB KB","16":"9 F I DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","16":"E LB","132":"6 7 A D MB NB OB RB y"},G:{"1":"G A XB YB ZB aB bB cB","16":"3 9 AB VB WB"},H:{"1":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"1":"K","132":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"257":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"readonly attribute of input and textarea elements"};

},{}],465:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"132":"D X g H L"},C:{"1":"0 1 4 5 f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e QB PB"},D:{"1":"BB TB CB","2":"F I J C G E B A D X g H L M N O P","260":"0 1 4 5 8 Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB"},E:{"2":"9 F I J C DB FB GB","132":"G E B A HB IB JB KB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"2":"3 9 AB VB WB XB","132":"G A YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"Referrer Policy"};

},{}],466:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 2 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"SB"},D:{"2":"F I J C G E B A D","129":"0 1 4 5 8 X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A LB MB NB OB","129":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C","129":"B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:1,C:"Custom protocol handling"};

},{}],467:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v QB PB"},D:{"1":"0 1 4 5 8 w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},E:{"1":"A JB KB","2":"9 F I J C G E B DB FB GB HB IB"},F:{"1":"f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e LB MB NB OB RB y"},G:{"1":"A cB","2":"3 9 G AB VB WB XB YB ZB aB bB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"rel=noopener"};

},{}],468:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B UB","132":"A"},B:{"1":"X g H L","16":"D"},C:{"1":"0 1 4 5 c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b QB PB"},D:{"1":"0 1 4 5 8 L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g H"},E:{"1":"I J C G E B A FB GB HB IB JB KB","2":"9 F DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","2":"9"},H:{"2":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Link type \"noreferrer\""};

},{}],469:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y QB PB"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w","132":"0 1 4 5 8 x v z t s EB BB TB CB"},E:{"1":"E B A IB JB KB","2":"9 F I J C G DB FB GB HB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f LB MB NB OB RB y","132":"K h i j k l m n o p q r"},G:{"1":"A ZB aB bB cB","2":"3 9 G AB VB WB XB YB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","132":"s"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"132":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F","132":"I"},Q:{"2":"lB"},R:{"2":"mB"}},B:1,C:"relList (DOMTokenList)"};

},{}],470:[function(require,module,exports){
module.exports={A:{A:{"1":"A","2":"J C G UB","132":"E B"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s PB","2":"2 SB QB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"I J C G E B A FB GB HB IB JB KB","2":"9 F DB"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"6 7 E A LB MB NB OB"},G:{"1":"3 G A AB WB XB YB ZB aB bB cB","2":"9","260":"VB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"D K y","2":"6 7 B A"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"rem (root em) units"};

},{}],471:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB","33":"A D X g H L M N O P Q R","164":"F I J C G E B"},D:{"1":"0 1 4 5 8 T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E","33":"R S","164":"N O P Q","420":"B A D X g H L M"},E:{"1":"C G E B A GB HB IB JB KB","2":"9 F I DB FB","33":"J"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB","33":"WB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"B","2":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"requestAnimationFrame"};

},{}],472:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"4 5 t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z QB PB","194":"0 1"},D:{"1":"0 1 4 5 8 q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:5,C:"requestIdleCallback"};

},{}],473:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z","194":"1 4 5 8 t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j LB MB NB OB RB y","194":"k l m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"194":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"Resize Observer"};

},{}],474:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z QB PB","194":"a b c d"},D:{"1":"0 1 4 5 8 U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T"},E:{"1":"A KB","2":"9 F I J C G E B DB FB GB HB IB JB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"A","2":"3 9 G AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"Resource Timing"};

},{}],475:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g QB PB"},D:{"1":"0 1 4 5 8 q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m","194":"n o p"},E:{"1":"B A JB KB","2":"9 F I J C G E DB FB GB HB IB"},F:{"1":"d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z LB MB NB OB RB y","194":"a b c"},G:{"1":"A bB cB","2":"3 9 G AB VB WB XB YB ZB aB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:6,C:"Rest parameters"};

},{}],476:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"H L","2":"D X g"},C:{"1":"0 1 4 5 n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q QB PB","33":"R S T U V W u Y Z a b c d e f K h i j k l m"},D:{"2":"F I J C G E B A D X g H L M N O P Q R","33":"0 1 4 5 8 S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"A KB","2":"9 F I J C G E B DB FB GB HB IB JB"},F:{"2":"6 7 E A D H L M LB MB NB OB RB y","33":"N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"1":"A","2":"3 9 G AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","33":"s"},J:{"2":"C","130":"B"},K:{"2":"6 7 B A D y","33":"K"},L:{"33":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"33":"F I"},Q:{"33":"lB"},R:{"33":"mB"}},B:5,C:"WebRTC Peer-to-peer connections"};

},{}],477:[function(require,module,exports){
module.exports={A:{A:{"4":"J C G E B A UB"},B:{"4":"D X g H L"},C:{"1":"0 1 4 5 h i j k l m n o p q r w x v z t s","8":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K QB PB"},D:{"4":"0 1 4 5 8 I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","8":"F"},E:{"4":"I J C G E B A FB GB HB IB JB KB","8":"9 F DB"},F:{"4":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","8":"6 7 E A D LB MB NB OB RB y"},G:{"4":"G A VB WB XB YB ZB aB bB cB","8":"3 9 AB"},H:{"8":"dB"},I:{"4":"2 3 F s hB iB jB","8":"eB fB gB"},J:{"4":"B","8":"C"},K:{"4":"K","8":"6 7 B A D y"},L:{"4":"8"},M:{"1":"t"},N:{"4":"B A"},O:{"4":"kB"},P:{"4":"F I"},Q:{"4":"lB"},R:{"4":"mB"}},B:1,C:"Ruby annotation"};

},{}],478:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:6,C:"'SameSite' cookie attribute"};

},{}],479:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B UB","36":"A"},B:{"36":"D X g H L"},C:{"1":"0 1 4 5 n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M QB PB","36":"N O P Q R S T U V W u Y Z a b c d e f K h i j k l m"},D:{"1":"0 1 4 5 8 h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B","36":"A"},O:{"1":"kB"},P:{"1":"I","16":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:5,C:"Screen Orientation"};

},{}],480:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s PB","2":"2 SB QB"},D:{"1":"0 1 4 5 8 G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C"},E:{"1":"J C G E B A FB GB HB IB JB KB","2":"9 F DB","132":"I"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"2":"dB"},I:{"1":"2 3 F s hB iB jB","2":"eB fB gB"},J:{"1":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"async attribute for external scripts"};

},{}],481:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","132":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB","257":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z QB PB"},D:{"1":"0 1 4 5 8 G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C"},E:{"1":"I J C G E B A FB GB HB IB JB KB","2":"9 F DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"2":"dB"},I:{"1":"2 3 F s hB iB jB","2":"eB fB gB"},J:{"1":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"defer attribute for external scripts"};

},{}],482:[function(require,module,exports){
module.exports={A:{A:{"2":"J C UB","132":"G E B A"},B:{"132":"D X g H L"},C:{"1":"0 1 4 5 f K h i j k l m n o p q r w x v z t s","132":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e QB PB"},D:{"132":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I DB","132":"J C G E B A FB GB HB IB JB KB"},F:{"2":"E LB MB NB OB","16":"6 7 A","132":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y"},G:{"16":"3 9 AB","132":"G A VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"16":"eB fB","132":"2 3 F s gB hB iB jB"},J:{"132":"C B"},K:{"132":"6 7 B A D K y"},L:{"132":"8"},M:{"132":"t"},N:{"132":"B A"},O:{"132":"kB"},P:{"132":"F I"},Q:{"132":"lB"},R:{"132":"mB"}},B:5,C:"scrollIntoView"};

},{}],483:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g"},E:{"1":"J C G E B A FB GB HB IB JB KB","16":"9 F I DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"G A VB WB XB YB ZB aB bB cB","16":"3 9 AB"},H:{"2":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:7,C:"Element.scrollIntoViewIfNeeded()"};

},{}],484:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"8 EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"2":"mB"}},B:6,C:"SDCH Accept-Encoding/Content-Encoding"};

},{}],485:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","16":"UB","260":"J C G"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 z t s","132":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l QB PB","2180":"m n o p q r w x v"},D:{"1":"0 1 4 5 8 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g"},E:{"1":"J C G E B A FB GB HB IB JB KB","16":"9 F I DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","132":"6 7 E A D LB MB NB OB RB y"},G:{"16":"3","132":"9 AB","516":"G A VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s iB jB","16":"2 F eB fB gB hB","1025":"3"},J:{"1":"B","16":"C"},K:{"1":"K","16":"6 7 B A D","132":"y"},L:{"1":"8"},M:{"132":"t"},N:{"1":"A","16":"B"},O:{"1025":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"Selection API"};

},{}],486:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g","322":"H L"},C:{"1":"0 1 4 5 n p q r w x v t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b QB PB","194":"c d e f K h i j k l m","513":"o z"},D:{"1":"0 1 4 5 8 o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i","4":"j k l m n"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V LB MB NB OB RB y","4":"W u Y Z a"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","4":"s"},J:{"2":"C B"},K:{"2":"6 7 B A D y","4":"K"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"4":"kB"},P:{"1":"F I"},Q:{"4":"lB"},R:{"4":"mB"}},B:5,C:"Service Workers"};

},{}],487:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"1":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"Efficient Script Yielding: setImmediate()"};

},{}],488:[function(require,module,exports){
module.exports={A:{A:{"1":"J C G E B A","2":"UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 h i j k l m n o p q r w x v z t s EB BB TB CB","132":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"16":"dB"},I:{"1":"2 3 F s fB gB hB iB jB","260":"eB"},J:{"1":"C B"},K:{"16":"6 7 B A D K y"},L:{"1":"8"},M:{"16":"t"},N:{"16":"B A"},O:{"16":"kB"},P:{"1":"I","16":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"SHA-2 SSL certificates"};

},{}],489:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u QB PB","194":"0 1 4 5 Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"1":"0 1 4 5 8 e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T","33":"U V W u Y Z a b c d"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y","33":"H L M N O P Q"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB","33":"iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"I","33":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"Shadow DOM v0"};

},{}],490:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z"},E:{"2":"9 F I J C G E DB FB GB HB IB","132":"B A JB KB"},F:{"1":"j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i LB MB NB OB RB y"},G:{"2":"3 9 G AB VB WB XB YB ZB aB","132":"A bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F","4":"I"},Q:{"1":"lB"},R:{"2":"mB"}},B:5,C:"Shadow DOM v1"};

},{}],491:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"I J FB","2":"9 F C G E B A DB GB HB IB JB KB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r OB RB y","2":"E LB MB NB"},G:{"1":"VB WB","2":"3 9 G A AB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 A D y","2":"K","16":"B"},L:{"2":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F","2":"I"},Q:{"2":"lB"},R:{"2":"mB"}},B:1,C:"Shared Web Workers"};

},{}],492:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J UB","132":"C G"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","2":"9"},H:{"1":"dB"},I:{"1":"2 3 F s hB iB jB","2":"eB fB gB"},J:{"1":"B","2":"C"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"Server Name Indication"};

},{}],493:[function(require,module,exports){
module.exports={A:{A:{"1":"A","2":"J C G E B UB"},B:{"2":"D X g H L"},C:{"1":"X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x","2":"0 1 2 4 5 SB F I J C G E B A D v z t s QB PB"},D:{"1":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x","2":"0 1 4 5 8 v z t s EB BB TB CB"},E:{"1":"G E B A IB JB KB","2":"9 F I J C DB FB GB HB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i l n y","2":"6 7 E A D j k m o p q r LB MB NB OB RB"},G:{"1":"G A YB ZB aB bB cB","2":"3 9 AB VB WB XB"},H:{"2":"dB"},I:{"1":"2 3 F hB iB jB","2":"s eB fB gB"},J:{"2":"C B"},K:{"1":"K y","2":"6 7 B A D"},L:{"2":"8"},M:{"2":"t"},N:{"1":"A","2":"B"},O:{"2":"kB"},P:{"1":"F","2":"I"},Q:{"2":"lB"},R:{"16":"mB"}},B:7,C:"SPDY protocol"};

},{}],494:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q QB PB","322":"0 1 4 5 R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T","164":"0 1 4 5 8 U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V LB MB NB OB RB y","164":"W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"164":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"164":"F I"},Q:{"164":"lB"},R:{"164":"mB"}},B:7,C:"Speech Recognition API"};

},{}],495:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"g H L","2":"D X"},C:{"1":"0 1 4 5 w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z QB PB","194":"a b c d e f K h i j k l m n o p q r"},D:{"1":"0 1 c d e f K h i j k l m n o p q r w x v z","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b","257":"4 5 8 t s EB BB TB CB"},E:{"1":"C G E B A HB IB JB KB","2":"9 F I J DB FB GB"},F:{"1":"W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V LB MB NB OB RB y"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB WB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"1":"lB"},R:{"2":"mB"}},B:7,C:"Speech Synthesis API"};

},{}],496:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G"},E:{"1":"J C G E B A FB GB HB IB JB KB","2":"9 F I DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r NB OB RB y","2":"E LB MB"},G:{"4":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"4":"dB"},I:{"4":"2 3 F s eB fB gB hB iB jB"},J:{"1":"B","4":"C"},K:{"4":"6 7 B A D K y"},L:{"4":"8"},M:{"4":"t"},N:{"4":"B A"},O:{"4":"kB"},P:{"4":"F I"},Q:{"1":"lB"},R:{"4":"mB"}},B:1,C:"Spellcheck attribute"};

},{}],497:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r NB OB RB y","2":"E LB MB"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:7,C:"Web SQL Database"};

},{}],498:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"L","260":"D","514":"X g H"},C:{"1":"0 1 4 5 h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a QB PB","194":"b c d e f K"},D:{"1":"0 1 4 5 8 h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c","260":"d e f K"},E:{"1":"E B A IB JB KB","2":"9 F I J C DB FB GB","260":"G HB"},F:{"1":"U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P LB MB NB OB RB y","260":"Q R S T"},G:{"1":"A ZB aB bB cB","2":"3 9 AB VB WB XB","260":"G YB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Srcset and sizes attributes"};

},{}],499:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E QB PB"},D:{"1":"0 1 4 5 8 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g H L M N O P Q R S T U"},E:{"1":"J C G E B A FB GB HB IB JB KB","16":"9 F I DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"6 7 E A LB MB NB OB RB","16":"D"},G:{"1":"G A WB XB YB ZB aB bB cB","16":"3 9 AB VB"},H:{"16":"dB"},I:{"1":"3 F s hB iB jB","16":"2 eB fB gB"},J:{"16":"C B"},K:{"16":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"16":"B A"},O:{"16":"kB"},P:{"1":"I","16":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Event.stopImmediatePropagation()"};

},{}],500:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L QB PB","33":"0 1 4 5 M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"2":"F I J C G E B A D X g H L M N O P","164":"0 1 4 5 8 Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"A","2":"9 F I J C G E B DB FB GB HB IB JB KB"},F:{"2":"6 7 E A H L M LB MB NB OB RB","164":"D N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y"},G:{"1":"A","2":"3 9 G AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","164":"s"},J:{"2":"C","164":"B"},K:{"2":"6 7 B A","164":"D K y"},L:{"164":"8"},M:{"33":"t"},N:{"2":"B A"},O:{"164":"kB"},P:{"16":"F","164":"I"},Q:{"164":"lB"},R:{"164":"mB"}},B:4,C:"getUserMedia/Stream API"};

},{}],501:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B UB","129":"A"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"C G E B A HB IB JB KB","2":"9 F I J DB FB GB"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"6 7 E A LB MB NB OB RB"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB WB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"Strict Transport Security"};

},{}],502:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z","2":"2 SB F I J C G E B A D X g H L M N O P QB PB","322":"4 5 t s"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O K h i j k l m n o p q r w x v z t s EB BB TB CB","194":"P Q R S T U V W u Y Z a b c d e f"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"322":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"Scoped CSS"};

},{}],503:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l QB PB"},D:{"1":"0 1 4 5 8 o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n"},E:{"1":"A KB","2":"9 F I J C G E B DB FB GB HB IB JB"},F:{"1":"b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"Subresource Integrity"};

},{}],504:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB","260":"F I J C G E B A D X g H L M N O P Q R S"},D:{"1":"0 1 4 5 8 I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","4":"F"},E:{"1":"I J C G E B A FB GB HB IB JB KB","2":"DB","132":"9 F"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","2":"E"},G:{"1":"3 G A VB WB XB YB ZB aB bB cB","132":"9 AB"},H:{"260":"dB"},I:{"1":"2 3 F s hB iB jB","2":"eB fB gB"},J:{"1":"C B"},K:{"1":"K","260":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"SVG in CSS backgrounds"};

},{}],505:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"SB"},D:{"1":"0 1 4 5 8 G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F","4":"I J C"},E:{"1":"J C G E B A GB HB IB JB KB","2":"9 F I DB FB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"G A WB XB YB ZB aB bB cB","2":"3 9 AB VB"},H:{"1":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"B","2":"C"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"SVG filters"};

},{}],506:[function(require,module,exports){
module.exports={A:{A:{"2":"E B A UB","8":"J C G"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K","2":"0 1 4 5 8 v z t s EB BB TB CB","130":"h i j k l m n o p q r w x"},E:{"1":"9 F I J C G E B A FB GB HB IB JB KB","2":"DB"},F:{"1":"6 7 E A D H L M N O P Q R S T LB MB NB OB RB y","2":"K h i j k l m n o p q r","130":"U V W u Y Z a b c d e f"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"258":"dB"},I:{"1":"2 3 F hB iB jB","2":"s eB fB gB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"130":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F","130":"I"},Q:{"1":"lB"},R:{"130":"mB"}},B:7,C:"SVG fonts"};

},{}],507:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g QB PB"},D:{"1":"0 1 4 5 8 x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e","132":"f K h i j k l m n o p q r w"},E:{"2":"9 F I J C E B A DB FB GB IB JB KB","132":"G HB"},F:{"1":"K h i j k l m n o p q r y","2":"H L M N O P Q R","4":"6 7 A D MB NB OB RB","16":"E LB","132":"S T U V W u Y Z a b c d e f"},G:{"2":"3 9 A AB VB WB XB ZB aB bB cB","132":"G YB"},H:{"1":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C","132":"B"},K:{"1":"K y","4":"6 7 B A D"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"132":"kB"},P:{"1":"I","132":"F"},Q:{"132":"lB"},R:{"132":"mB"}},B:2,C:"SVG fragment identifiers"};

},{}],508:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G UB","388":"E B A"},B:{"260":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"SB","4":"2"},D:{"4":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 DB","4":"F I J C G E B A FB GB HB IB JB KB"},F:{"4":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"4":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB","4":"s iB jB"},J:{"1":"B","2":"C"},K:{"4":"6 7 B A D K y"},L:{"4":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"4":"F I"},Q:{"4":"lB"},R:{"4":"mB"}},B:2,C:"SVG effects for HTML"};

},{}],509:[function(require,module,exports){
module.exports={A:{A:{"2":"UB","8":"J C G","129":"E B A"},B:{"129":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","8":"2 SB QB PB"},D:{"1":"0 1 4 5 8 C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","8":"F I J"},E:{"1":"E B A IB JB KB","8":"9 F I DB","129":"J C G FB GB HB"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"6 7 A OB","8":"E LB MB NB"},G:{"1":"A ZB aB bB cB","8":"3 9 AB","129":"G VB WB XB YB"},H:{"1":"dB"},I:{"1":"s iB jB","2":"eB fB gB","129":"2 3 F hB"},J:{"1":"B","129":"C"},K:{"1":"D K y","8":"6 7 B A"},L:{"1":"8"},M:{"1":"t"},N:{"129":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Inline SVG in HTML5"};

},{}],510:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","132":"F I J C G E B A D X g H L M N O P Q R S T U V W"},E:{"1":"E B A IB JB KB","2":"DB","4":"9","132":"F I J C G FB GB HB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"A ZB aB bB cB","132":"3 9 G AB VB WB XB YB"},H:{"1":"dB"},I:{"1":"s iB jB","2":"eB fB gB","132":"2 3 F hB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"SVG in HTML img element"};

},{}],511:[function(require,module,exports){
module.exports={A:{A:{"2":"UB","8":"J C G E B A"},B:{"8":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","8":"2 SB QB PB"},D:{"1":"I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n","4":"F","257":"0 1 4 5 8 o p q r w x v z t s EB BB TB CB"},E:{"1":"J C G E B A GB HB IB JB KB","8":"9 DB","132":"F I FB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a LB MB NB OB RB y","257":"b c d e f K h i j k l m n o p q r"},G:{"1":"G A WB XB YB ZB aB bB cB","132":"3 9 AB VB"},H:{"2":"dB"},I:{"1":"2 3 F s hB iB jB","2":"eB fB gB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"8":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"257":"lB"},R:{"1":"mB"}},B:2,C:"SVG SMIL animation"};

},{}],512:[function(require,module,exports){
module.exports={A:{A:{"2":"UB","8":"J C G","257":"E B A"},B:{"257":"D X g H L"},C:{"1":"0 1 2 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","4":"SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A FB GB HB IB JB KB","4":"DB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"s iB jB","2":"eB fB gB","132":"2 3 F hB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"257":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"SVG (basic support)"};

},{}],513:[function(require,module,exports){
module.exports={A:{A:{"1":"C G E B A","16":"J UB"},B:{"1":"D X g H L"},C:{"16":"2 SB QB PB","129":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"1":"0 1 4 5 8 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g"},E:{"16":"9 F I DB","257":"J C G E B A FB GB HB IB JB KB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","16":"E"},G:{"769":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"16":"dB"},I:{"16":"2 3 F s eB fB gB hB iB jB"},J:{"16":"C B"},K:{"16":"6 7 B A D K y"},L:{"16":"8"},M:{"16":"t"},N:{"16":"B A"},O:{"16":"kB"},P:{"16":"F I"},Q:{"2":"lB"},R:{"16":"mB"}},B:1,C:"tabindex global attribute"};

},{}],514:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"X g H L","16":"D"},C:{"1":"0 1 4 5 d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c QB PB"},D:{"1":"0 1 4 5 8 k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j"},E:{"1":"B A IB JB KB","2":"9 F I J C G E DB FB GB HB"},F:{"1":"Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u LB MB NB OB RB y"},G:{"1":"A ZB aB bB cB","2":"3 9 G AB VB WB XB YB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"F I"},Q:{"2":"lB"},R:{"1":"mB"}},B:6,C:"ES6 Template Literals (Template Strings)"};

},{}],515:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D","388":"X g H L"},C:{"1":"0 1 4 5 R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q QB PB"},D:{"1":"0 1 4 5 8 e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U","132":"V W u Y Z a b c d"},E:{"1":"E B A IB JB KB","2":"9 F I J C DB FB","388":"G HB","514":"GB"},F:{"1":"R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y","132":"H L M N O P Q"},G:{"1":"A ZB aB bB cB","2":"3 9 AB VB WB XB","388":"G YB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"HTML templates"};

},{}],516:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G B A UB","16":"E"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","16":"F I"},D:{"2":"0 1 4 5 8 F I J C G E B X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"A D"},E:{"2":"9 F J DB FB","16":"I C G E B A GB HB IB JB KB"},F:{"2":"6 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","16":"7"},G:{"2":"3 9 AB VB WB","16":"G A XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB hB iB jB","16":"gB"},J:{"2":"B","16":"C"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"Test feature - updated"};

},{}],517:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB F I QB PB","1028":"0 1 4 5 f K h i j k l m n o p q r w x v z t s","1060":"J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U","226":"0 1 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2052":"4 5 8 EB BB TB CB"},E:{"2":"9 F I J C DB FB GB","804":"G E B A IB JB KB","1316":"HB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d LB MB NB OB RB y","226":"e f K h i j k l m","2052":"n o p q r"},G:{"2":"3 9 AB VB WB XB","292":"G A YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2052":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"1":"mB"}},B:4,C:"text-decoration styling"};

},{}],518:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n QB PB","322":"o"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T","164":"0 1 4 5 8 U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"G E B A HB IB JB KB","2":"9 F I J DB FB","164":"C GB"},F:{"2":"6 7 E A D LB MB NB OB RB y","164":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB WB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB","164":"s iB jB"},J:{"2":"C","164":"B"},K:{"2":"6 7 B A D y","164":"K"},L:{"164":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"164":"kB"},P:{"164":"F I"},Q:{"164":"lB"},R:{"164":"mB"}},B:4,C:"text-emphasis styling"};

},{}],519:[function(require,module,exports){
module.exports={A:{A:{"1":"J C G E B A","2":"UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","8":"2 SB F I J QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","33":"E LB MB NB OB"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"K y","33":"6 7 B A D"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS3 Text-overflow"};

},{}],520:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"1 4 5 8 t s EB BB TB CB","2":"0 F I J C G E B A D X g H L M N O P Q R S T U W u Y Z a b c d e f K h i j k l m n o p q r w x v z","258":"V"},E:{"2":"9 F I J C G E B A DB GB HB IB JB KB","258":"FB"},F:{"1":"m o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l n LB MB NB OB RB y"},G:{"2":"3 9 AB","33":"G A VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"33":"t"},N:{"161":"B A"},O:{"33":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"CSS text-size-adjust"};

},{}],521:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g","161":"H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q QB PB","161":"0 1 4 5 w x v z t s","450":"r"},D:{"33":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"A KB","33":"9 F I J C G E B DB FB GB HB IB JB"},F:{"2":"6 7 E A D LB MB NB OB RB y","33":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"33":"3 G A AB VB WB XB YB ZB aB bB cB","36":"9"},H:{"2":"dB"},I:{"2":"2","33":"3 F s eB fB gB hB iB jB"},J:{"33":"C B"},K:{"2":"6 7 B A D y","33":"K"},L:{"33":"8"},M:{"161":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"33":"F I"},Q:{"33":"lB"},R:{"33":"mB"}},B:7,C:"CSS text-stroke and text-fill"};

},{}],522:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A FB GB HB IB JB KB","16":"DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","16":"E"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","16":"9"},H:{"1":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Node.textContent"};

},{}],523:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N QB PB","132":"O"},D:{"1":"0 1 4 5 8 h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K"},E:{"1":"A JB KB","2":"9 F I J C G E B DB FB GB HB IB"},F:{"1":"U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T LB MB NB OB RB y"},G:{"1":"A cB","2":"3 9 G AB VB WB XB YB ZB aB bB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"2":"lB"},R:{"1":"mB"}},B:1,C:"TextEncoder & TextDecoder"};

},{}],524:[function(require,module,exports){
module.exports={A:{A:{"1":"A","2":"J C UB","66":"G E B"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R QB PB","66":"S"},D:{"1":"0 1 4 5 8 R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q"},E:{"1":"C G E B A HB IB JB KB","2":"9 F I J DB FB GB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"6 7 E A D LB MB NB OB RB"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"1":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"1":"B","2":"C"},K:{"1":"K y","2":"6 7 B A D"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","66":"B"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"TLS 1.1"};

},{}],525:[function(require,module,exports){
module.exports={A:{A:{"1":"A","2":"J C UB","66":"G E B"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S QB PB","66":"T U V"},D:{"1":"0 1 4 5 8 Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y"},E:{"1":"C G E B A HB IB JB KB","2":"9 F I J DB FB GB"},F:{"1":"M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"E H L LB","66":"6 7 A D MB NB OB RB"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"1":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"1":"B","2":"C"},K:{"1":"K y","2":"6 7 B A D"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","66":"B"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"TLS 1.2"};

},{}],526:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x QB PB","66":"v"},D:{"1":"4 5 8 s EB BB TB CB","2":"0 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z","66":"1 t"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k LB MB NB OB RB y","66":"l"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","16":"s"},J:{"2":"C","16":"B"},K:{"2":"6 7 B A D K y"},L:{"16":"8"},M:{"16":"t"},N:{"2":"B","16":"A"},O:{"16":"kB"},P:{"16":"F I"},Q:{"16":"lB"},R:{"16":"mB"}},B:6,C:"TLS 1.3"};

},{}],527:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g","257":"H L"},C:{"2":"0 1 2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t QB PB","16":"4 5 s"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h","16":"0 1 4 i j k l m n o p q r w x v z t s","194":"5 8 EB BB TB CB"},E:{"2":"9 F I J C G DB FB GB HB","16":"E B A IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y LB MB NB OB RB y","16":"Z a b c d e f K h i j k l m n o p q r"},G:{"2":"3 9 G AB VB WB XB YB","16":"A ZB aB bB cB"},H:{"16":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","16":"s"},J:{"2":"C B"},K:{"2":"6 7 B A D y","16":"K"},L:{"16":"8"},M:{"16":"t"},N:{"2":"B","16":"A"},O:{"16":"kB"},P:{"16":"F I"},Q:{"16":"lB"},R:{"16":"mB"}},B:6,C:"Token Binding"};

},{}],528:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E UB","8":"B A"},B:{"578":"D X g H L"},C:{"1":"0 1 4 5 N O P Q R S T z t s","2":"2 SB QB PB","4":"F I J C G E B A D X g H L M","194":"U V W u Y Z a b c d e f K h i j k l m n o p q r w x v"},D:{"1":"0 1 4 5 8 R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"8":"B","260":"A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"Touch events"};

},{}],529:[function(require,module,exports){
module.exports={A:{A:{"2":"UB","8":"J C G","129":"B A","161":"E"},B:{"129":"D X g H L"},C:{"1":"0 1 4 5 L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB","33":"F I J C G E B A D X g H QB PB"},D:{"1":"0 1 4 5 8 f K h i j k l m n o p q r w x v z t s EB BB TB CB","33":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e"},E:{"1":"E B A IB JB KB","33":"9 F I J C G DB FB GB HB"},F:{"1":"S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"E LB MB","33":"6 7 A D H L M N O P Q R NB OB RB"},G:{"1":"A ZB aB bB cB","33":"3 9 G AB VB WB XB YB"},H:{"2":"dB"},I:{"1":"s","33":"2 3 F eB fB gB hB iB jB"},J:{"33":"C B"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"33":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"CSS3 2D Transforms"};

},{}],530:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E UB","132":"B A"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E QB PB","33":"B A D X g H"},D:{"1":"0 1 4 5 8 f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A","33":"D X g H L M N O P Q R S T U V W u Y Z a b c d e"},E:{"2":"9 DB","33":"F I J C G FB GB HB","257":"E B A IB JB KB"},F:{"1":"S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y","33":"H L M N O P Q R"},G:{"1":"A ZB aB bB cB","33":"3 9 G AB VB WB XB YB"},H:{"2":"dB"},I:{"1":"s","2":"eB fB gB","33":"2 3 F hB iB jB"},J:{"33":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"132":"B A"},O:{"33":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"CSS3 3D Transforms"};

},{}],531:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G UB","132":"E B A"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"2 SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r MB NB OB RB y","2":"E LB"},G:{"1":"3 G A VB WB XB YB ZB aB bB cB","2":"9 AB"},H:{"2":"dB"},I:{"1":"2 3 F s fB gB hB iB jB","2":"eB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"132":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"TTF/OTF - TrueType and OpenType font support"};

},{}],532:[function(require,module,exports){
module.exports={A:{A:{"1":"A","2":"J C G E UB","132":"B"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J"},E:{"1":"J C G E B A GB HB IB JB KB","2":"9 F I DB","260":"FB"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"6 7 E A LB MB NB OB"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"9 AB","260":"3"},H:{"1":"dB"},I:{"1":"3 F s hB iB jB","2":"2 eB fB gB"},J:{"1":"B","2":"C"},K:{"1":"D K y","2":"6 7 B A"},L:{"1":"8"},M:{"1":"t"},N:{"132":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"Typed Arrays"};

},{}],533:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K","130":"h i j"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"j l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i k LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:6,C:"FIDO U2F API"};

},{}],534:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k QB PB"},D:{"1":"0 1 4 5 8 m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l"},E:{"1":"A JB KB","2":"9 F I J C G E B DB FB GB HB IB"},F:{"1":"Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y LB MB NB OB RB y"},G:{"1":"A cB","2":"3 9 G AB VB WB XB YB ZB aB bB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"Upgrade Insecure Requests"};

},{}],535:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U QB PB"},D:{"1":"0 1 4 5 8 b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R","130":"S T U V W u Y Z a"},E:{"1":"G E B A HB IB JB KB","2":"9 F I J DB FB GB","130":"C"},F:{"1":"O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y","130":"H L M N"},G:{"1":"G A YB ZB aB bB cB","2":"3 9 AB VB WB","130":"XB"},H:{"2":"dB"},I:{"1":"s jB","2":"2 3 F eB fB gB hB","130":"iB"},J:{"2":"C","130":"B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"URL API"};

},{}],536:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u QB PB","132":"Y Z a b c d e f K h i j k l m"},D:{"1":"0 1 4 5 8 w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},E:{"1":"A JB KB","2":"9 F I J C G E B DB FB GB HB IB"},F:{"1":"f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e LB MB NB OB RB y"},G:{"1":"A cB","2":"3 9 G AB VB WB XB YB ZB aB bB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"2":"mB"}},B:1,C:"URLSearchParams"};

},{}],537:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D"},E:{"1":"J C G E B A GB HB IB JB KB","2":"9 F DB","132":"I FB"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"6 7 E A LB MB NB OB"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"1":"dB"},I:{"1":"2 3 F s hB iB jB","2":"eB fB gB"},J:{"1":"C B"},K:{"1":"6 D K y","2":"7 B A"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"ECMAScript 5 Strict Mode"};

},{}],538:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E UB","33":"B A"},B:{"33":"D X g H L"},C:{"33":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"1 4 5 8 t s EB BB TB CB","33":"0 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z"},E:{"33":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y","33":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j"},G:{"33":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","33":"2 3 F eB fB gB hB iB jB"},J:{"33":"C B"},K:{"2":"6 7 B A D y","33":"K"},L:{"1":"8"},M:{"33":"t"},N:{"33":"B A"},O:{"33":"kB"},P:{"33":"F I"},Q:{"33":"lB"},R:{"2":"mB"}},B:5,C:"CSS user-select: none"};

},{}],539:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K QB PB"},D:{"1":"0 1 4 5 8 U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T"},E:{"1":"A KB","2":"9 F I J C G E B DB FB GB HB IB JB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"User Timing API"};

},{}],540:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B QB PB","33":"A D X g H"},D:{"1":"0 1 4 5 8 Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"B","2":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"Vibration API"};

},{}],541:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB","260":"F I J C G E B A D X g H L M N O QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","2":"9 DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r NB OB RB y","2":"E LB MB"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"2 3 F s gB hB iB jB","132":"eB fB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Video element"};

},{}],542:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"C G E B A GB HB IB JB KB","2":"9 F I J DB FB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB WB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:1,C:"Video Tracks"};

},{}],543:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G UB","132":"E","260":"B A"},B:{"260":"D X g H L"},C:{"1":"0 1 4 5 O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N QB PB"},D:{"1":"0 1 4 5 8 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O","260":"P Q R S T U"},E:{"1":"C G E B A GB HB IB JB KB","2":"9 F I DB FB","260":"J"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"G A YB ZB aB bB cB","2":"3 9 AB VB","516":"XB","772":"WB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"B","2":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"260":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"Viewport units: vw, vh, vmin, vmax"};

},{}],544:[function(require,module,exports){
module.exports={A:{A:{"2":"J C UB","4":"G E B A"},B:{"4":"D X g H L"},C:{"4":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"4":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 DB","4":"F I J C G E B A FB GB HB IB JB KB"},F:{"2":"E","4":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"4":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"4":"dB"},I:{"2":"2 3 F eB fB gB hB","4":"s iB jB"},J:{"2":"C B"},K:{"4":"6 7 B A D K y"},L:{"4":"8"},M:{"4":"t"},N:{"4":"B A"},O:{"2":"kB"},P:{"4":"F I"},Q:{"4":"lB"},R:{"4":"mB"}},B:2,C:"WAI-ARIA Accessibility features"};

},{}],545:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"L","2":"D X g","578":"H"},C:{"1":"0 1 4 5 t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p QB PB","194":"q r w x v","1025":"z"},D:{"1":"4 5 8 EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x","322":"0 1 v z t s"},E:{"1":"A KB","2":"9 F I J C G E B DB FB GB HB IB JB"},F:{"1":"n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K LB MB NB OB RB y","322":"h i j k l m"},G:{"1":"A","2":"3 9 G AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"322":"lB"},R:{"2":"mB"}},B:6,C:"WebAssembly"};

},{}],546:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"2 SB"},D:{"1":"0 1 4 5 8 G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","2":"9 DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r NB OB RB y","2":"E LB MB"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","16":"B"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"Wav audio format"};

},{}],547:[function(require,module,exports){
module.exports={A:{A:{"1":"J C UB","2":"G E B A"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A FB GB HB IB JB KB","16":"DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","16":"E"},G:{"1":"G A VB WB XB YB ZB aB bB cB","16":"3 9 AB"},H:{"1":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"wbr (word break opportunity) element"};

},{}],548:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b QB PB","516":"0 1 4 5 q r w x v z t s","580":"c d e f K h i j k l m n o p"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e","132":"f K h","260":"0 1 4 5 8 i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R LB MB NB OB RB y","132":"S T U","260":"V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","260":"s"},J:{"2":"C B"},K:{"2":"6 7 B A D y","260":"K"},L:{"260":"8"},M:{"516":"t"},N:{"2":"B A"},O:{"260":"kB"},P:{"260":"F I"},Q:{"260":"lB"},R:{"260":"mB"}},B:5,C:"Web Animations API"};

},{}],549:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"Web App Manifest"};

},{}],550:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n","194":"o p q r w x v z","706":"0 1 t","1025":"4 5 8 s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e LB MB NB OB RB y","450":"f K h i","706":"j k l","1025":"m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","1025":"s"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1025":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"706":"lB"},R:{"2":"mB"}},B:7,C:"Web Bluetooth"};

},{}],551:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 F I J C G E B A D X g H L M U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z","129":"4 5 8 t s EB BB TB CB","258":"N O P Q R S T"},E:{"2":"9 F I J C G E B A DB FB HB IB JB KB","16":"GB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB","129":"s","514":"jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"642":"8"},M:{"514":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F","642":"I"},Q:{"2":"lB"},R:{"16":"mB"}},B:5,C:"Web Share Api"};

},{}],552:[function(require,module,exports){
module.exports={A:{A:{"2":"UB","8":"J C G E B","129":"A"},B:{"129":"D X g H L"},C:{"1":"0 1 4 5 T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB","129":"F I J C G E B A D X g H L M N O P Q R S"},D:{"1":"0 1 4 5 8 c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C","129":"G E B A D X g H L M N O P Q R S T U V W u Y Z a b"},E:{"1":"G E B A IB JB KB","2":"9 F I DB","129":"J C FB GB HB"},F:{"1":"O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A LB MB NB OB RB","129":"D H L M N y"},G:{"1":"G A YB ZB aB bB cB","2":"3 9 AB VB WB XB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"1":"B","2":"C"},K:{"1":"D K y","2":"6 7 B A"},L:{"1":"8"},M:{"1":"t"},N:{"8":"B","129":"A"},O:{"129":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"WebGL - 3D Canvas graphics"};

},{}],553:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T QB PB","194":"l m n","450":"U V W u Y Z a b c d e f K h i j k","2242":"o p q r w x"},D:{"1":"4 5 8 s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l","578":"0 1 m n o p q r w x v z t"},E:{"2":"9 F I J C G E B DB FB GB HB IB","1090":"A JB KB"},F:{"1":"m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"578":"lB"},R:{"2":"mB"}},B:6,C:"WebGL 2.0"};

},{}],554:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G UB","8":"E B A"},B:{"4":"g H L","8":"D X"},C:{"1":"0 1 4 5 u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB","4":"F I J C G E B A D X g H L M N O P Q R S T U V W"},D:{"1":"0 1 4 5 8 U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I","4":"J C G E B A D X g H L M N O P Q R S T"},E:{"2":"DB","8":"9 F I J C G E B A FB GB HB IB JB KB"},F:{"1":"L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"E LB MB NB","4":"6 7 A D H OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"eB fB","4":"2 3 F gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D y","4":"K"},L:{"1":"8"},M:{"1":"t"},N:{"8":"B A"},O:{"1":"kB"},P:{"1":"I","4":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"WebM video format"};

},{}],555:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB QB PB","8":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"1":"0 1 4 5 8 S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I","8":"J C G","132":"E B A D X g H L M N O P Q R"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"E LB MB NB","8":"A OB","132":"6 7 RB"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"3 s iB jB","2":"2 eB fB gB","132":"F hB"},J:{"2":"C B"},K:{"1":"6 7 D K y","2":"B","132":"A"},L:{"1":"8"},M:{"8":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:7,C:"WebP image format"};

},{}],556:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB","132":"F I","292":"J C G E B"},D:{"1":"0 1 4 5 8 L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","132":"F I J C G E B A D X g","260":"H"},E:{"1":"C G E B A HB IB JB KB","2":"9 F DB","132":"I FB","260":"J GB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"E LB MB NB OB","132":"6 7 A D RB"},G:{"1":"G A WB XB YB ZB aB bB cB","2":"9 AB","132":"3 VB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"B","129":"C"},K:{"1":"K y","2":"B","132":"6 7 A D"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Web Sockets"};

},{}],557:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g","513":"H L"},C:{"2":"0 2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z QB PB","129":"4 5 t s","194":"1"},D:{"2":"0 1 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","322":"4 5 8 EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2049":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1025":"F","1028":"I"},Q:{"2":"lB"},R:{"322":"mB"}},B:7,C:"WebVR API"};

},{}],558:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S QB PB","66":"T U V W u Y Z","129":"0 1 4 5 a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"1":"0 1 4 5 8 N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M"},E:{"1":"J C G E B A GB HB IB JB KB","2":"9 F I DB FB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB WB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"B","2":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","2":"B"},O:{"2":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"WebVTT - Web Video Text Tracks"};

},{}],559:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","2":"UB","8":"J C G E"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","8":"2 SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","8":"9 DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r OB RB y","2":"E LB","8":"MB NB"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"2":"dB"},I:{"1":"s eB iB jB","2":"2 3 F fB gB hB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","8":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Web Workers"};

},{}],560:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u QB PB","194":"Y Z a b c d e"},D:{"1":"0 1 4 5 8 f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e"},E:{"1":"B A IB JB KB","2":"9 F I J C G E DB FB GB HB"},F:{"1":"T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S LB MB NB OB RB y"},G:{"1":"A aB bB cB","2":"3 9 G AB VB WB XB YB ZB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"CSS will-change property"};

},{}],561:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s PB","2":"2 SB QB"},D:{"1":"0 1 4 5 8 I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F"},E:{"1":"J C G E B A FB GB HB IB JB KB","2":"9 F I DB"},F:{"1":"6 7 D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"E A LB MB NB OB"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 eB fB gB hB","130":"F"},J:{"1":"C B"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"WOFF - Web Open Font Format"};

},{}],562:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"g H L","2":"D X"},C:{"1":"0 1 4 5 i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h QB PB"},D:{"1":"0 1 4 5 8 f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e"},E:{"2":"9 F I J C G E DB FB GB HB IB","132":"B A JB KB"},F:{"1":"S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R LB MB NB OB RB y"},G:{"1":"A bB cB","2":"3 9 G AB VB WB XB YB ZB aB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"WOFF 2.0 - Web Open Font Format"};

},{}],563:[function(require,module,exports){
module.exports={A:{A:{"1":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g QB PB"},D:{"1":"0 1 4 5 8 n o p q r w x v z t s EB BB TB CB","4":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m"},E:{"1":"E B A IB JB KB","4":"9 F I J C G DB FB GB HB"},F:{"1":"a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y","4":"H L M N O P Q R S T U V W u Y Z"},G:{"1":"A ZB aB bB cB","4":"3 9 G AB VB WB XB YB"},H:{"2":"dB"},I:{"1":"s","4":"2 3 F eB fB gB hB iB jB"},J:{"4":"C B"},K:{"2":"6 7 B A D y","4":"K"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"4":"kB"},P:{"1":"F I"},Q:{"4":"lB"},R:{"1":"mB"}},B:5,C:"CSS3 word-break"};

},{}],564:[function(require,module,exports){
module.exports={A:{A:{"4":"J C G E B A UB"},B:{"4":"D X g H L"},C:{"1":"0 1 4 5 w x v z t s","2":"2 SB","4":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r QB PB"},D:{"1":"0 1 4 5 8 S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","4":"F I J C G E B A D X g H L M N O P Q R"},E:{"1":"C G E B A GB HB IB JB KB","4":"9 F I J DB FB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"E LB MB","4":"6 7 A D NB OB RB"},G:{"1":"G A XB YB ZB aB bB cB","4":"3 9 AB VB WB"},H:{"4":"dB"},I:{"1":"s iB jB","4":"2 3 F eB fB gB hB"},J:{"1":"B","4":"C"},K:{"1":"K","4":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"4":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"CSS3 Overflow-wrap"};

},{}],565:[function(require,module,exports){
module.exports={A:{A:{"2":"J C UB","132":"G E","260":"B A"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","2":"9 DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","2":"E"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"4":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Cross-document messaging"};

},{}],566:[function(require,module,exports){
module.exports={A:{A:{"1":"G E B A","2":"J C UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","4":"F I J C G E B A D X g H L M","16":"2 SB QB PB"},D:{"4":"0 1 4 5 8 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g H L M N O P Q R S T U"},E:{"4":"J C G E B A FB GB HB IB JB KB","16":"9 F I DB"},F:{"4":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","16":"6 7 E A LB MB NB OB"},G:{"4":"G A XB YB ZB aB bB cB","16":"3 9 AB VB WB"},H:{"2":"dB"},I:{"4":"3 F s hB iB jB","16":"2 eB fB gB"},J:{"4":"C B"},K:{"4":"K y","16":"6 7 B A D"},L:{"4":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"4":"kB"},P:{"4":"F I"},Q:{"4":"lB"},R:{"4":"mB"}},B:6,C:"X-Frame-Options HTTP header"};

},{}],567:[function(require,module,exports){
module.exports={A:{A:{"2":"J C G E UB","132":"B A"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB","260":"B A","388":"J C G E","900":"F I QB PB"},D:{"1":"0 1 4 5 8 a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J","132":"Y Z","388":"C G E B A D X g H L M N O P Q R S T U V W u"},E:{"1":"G E B A HB IB JB KB","2":"9 F DB","132":"C GB","388":"I J FB"},F:{"1":"D N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"6 7 E A LB MB NB OB RB","132":"H L M"},G:{"1":"G A YB ZB aB bB cB","2":"3 9 AB","132":"XB","388":"VB WB"},H:{"2":"dB"},I:{"1":"s jB","2":"eB fB gB","388":"iB","900":"2 3 F hB"},J:{"132":"B","388":"C"},K:{"1":"D K y","2":"6 7 B A"},L:{"1":"8"},M:{"1":"t"},N:{"132":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"XMLHttpRequest advanced features"};

},{}],568:[function(require,module,exports){
module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"2":"mB"}},B:1,C:"XHTML served as application/xhtml+xml"};

},{}],569:[function(require,module,exports){
module.exports={A:{A:{"2":"E B A UB","4":"J C G"},B:{"2":"D X g H L"},C:{"8":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"8":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"8":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"8":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"8":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"8":"dB"},I:{"8":"2 3 F s eB fB gB hB iB jB"},J:{"8":"C B"},K:{"8":"6 7 B A D K y"},L:{"8":"8"},M:{"8":"t"},N:{"2":"B A"},O:{"8":"kB"},P:{"8":"F I"},Q:{"8":"lB"},R:{"8":"mB"}},B:7,C:"XHTML+SMIL animation"};

},{}],570:[function(require,module,exports){
module.exports={A:{A:{"1":"B A","132":"E","260":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","132":"A","260":"2 SB F I J C QB PB","516":"G E B"},D:{"1":"0 1 4 5 8 Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","132":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y"},E:{"1":"G E B A HB IB JB KB","132":"9 F I J C DB FB GB"},F:{"1":"M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","16":"E LB","132":"6 7 A D H L MB NB OB RB y"},G:{"1":"G A YB ZB aB bB cB","132":"3 9 AB VB WB XB"},H:{"132":"dB"},I:{"1":"s iB jB","132":"2 3 F eB fB gB hB"},J:{"132":"C B"},K:{"1":"K","16":"B","132":"6 7 A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"DOM Parsing and Serialization"};

},{}],571:[function(require,module,exports){
"use strict";

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.default = {
    1: "ls", // WHATWG Living Standard
    2: "rec", // W3C Recommendation
    3: "pr", // W3C Proposed Recommendation
    4: "cr", // W3C Candidate Recommendation
    5: "wd", // W3C Working Draft
    6: "other", // Non-W3C, but reputable
    7: "unoff" // Unofficial, Editor's Draft or W3C "Note"
};

},{}],572:[function(require,module,exports){
"use strict";

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.default = {
    y: 1 << 0,
    n: 1 << 1,
    a: 1 << 2,
    p: 1 << 3,
    u: 1 << 4,
    x: 1 << 5,
    d: 1 << 6
};

},{}],573:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.agents = undefined;

var _browsers = require('./browsers');

var _browserVersions = require('./browserVersions');

var agentsData = require('../../data/agents');

function unpackBrowserVersions(versionsData) {
    return Object.keys(versionsData).reduce(function (usage, version) {
        usage[_browserVersions.browserVersions[version]] = versionsData[version];
        return usage;
    }, {});
}

var agents = exports.agents = Object.keys(agentsData).reduce(function (map, key) {
    var versionsData = agentsData[key];
    map[_browsers.browsers[key]] = Object.keys(versionsData).reduce(function (data, entry) {
        if (entry === 'A') {
            data.usage_global = unpackBrowserVersions(versionsData[entry]);
        } else if (entry === 'C') {
            data.versions = versionsData[entry].reduce(function (list, version) {
                if (version === '') {
                    list.push(null);
                } else {
                    list.push(_browserVersions.browserVersions[version]);
                }
                return list;
            }, []);
        } else if (entry === 'D') {
            data.prefix_exceptions = unpackBrowserVersions(versionsData[entry]);
        } else if (entry === 'E') {
            data.browser = versionsData[entry];
        } else {
            // entry is B
            data.prefix = versionsData[entry];
        }
        return data;
    }, {});
    return map;
}, {});
},{"../../data/agents":117,"./browserVersions":574,"./browsers":575}],574:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
var browserVersions = exports.browserVersions = require('../../data/browserVersions');
},{"../../data/browserVersions":118}],575:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
var browsers = exports.browsers = require('../../data/browsers');
},{"../../data/browsers":119}],576:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.default = unpackFeature;

var _statuses = require('../lib/statuses');

var _statuses2 = _interopRequireDefault(_statuses);

var _supported = require('../lib/supported');

var _supported2 = _interopRequireDefault(_supported);

var _browsers = require('./browsers');

var _browserVersions = require('./browserVersions');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function unpackSupport(cipher) {
    // bit flags
    var stats = Object.keys(_supported2.default).reduce(function (list, support) {
        if (cipher & _supported2.default[support]) list.push(support);
        return list;
    }, []);

    // notes
    var notes = cipher >> 7;
    var notesArray = [];
    while (notes) {
        var note = Math.floor(Math.log2(notes)) + 1;
        notesArray.unshift('#' + note);
        notes -= Math.pow(2, note - 1);
    }

    return stats.concat(notesArray).join(' ');
}

function unpackFeature(packed) {
    var unpacked = { status: _statuses2.default[packed.B], title: packed.C };
    unpacked.stats = Object.keys(packed.A).reduce(function (browserStats, key) {
        var browser = packed.A[key];
        browserStats[_browsers.browsers[key]] = Object.keys(browser).reduce(function (stats, support) {
            var packedVersions = browser[support].split(' ');
            var unpacked = unpackSupport(support);
            packedVersions.forEach(function (v) {
                return stats[_browserVersions.browserVersions[v]] = unpacked;
            });
            return stats;
        }, {});
        return browserStats;
    }, {});
    return unpacked;
}
},{"../lib/statuses":571,"../lib/supported":572,"./browserVersions":574,"./browsers":575}],577:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
/*
 * Load this dynamically so that it
 * doesn't appear in the rollup bundle.
 */

var features = exports.features = require('../../data/features');
},{"../../data/features":120}],578:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _agents = require('./agents');

Object.defineProperty(exports, 'agents', {
  enumerable: true,
  get: function get() {
    return _agents.agents;
  }
});

var _feature = require('./feature');

Object.defineProperty(exports, 'feature', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_feature).default;
  }
});

var _features = require('./features');

Object.defineProperty(exports, 'features', {
  enumerable: true,
  get: function get() {
    return _features.features;
  }
});

var _region = require('./region');

Object.defineProperty(exports, 'region', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_region).default;
  }
});

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
},{"./agents":573,"./feature":576,"./features":577,"./region":579}],579:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.default = unpackRegion;

var _browsers = require('./browsers');

function unpackRegion(packed) {
    return Object.keys(packed).reduce(function (list, browser) {
        var data = packed[browser];
        list[_browsers.browsers[browser]] = Object.keys(data).reduce(function (memo, key) {
            var stats = data[key];
            if (key === '_') {
                stats.split(' ').forEach(function (version) {
                    return memo[version] = null;
                });
            } else {
                memo[key] = stats;
            }
            return memo;
        }, {});
        return list;
    }, {});
}
},{"./browsers":575}],580:[function(require,module,exports){
(function (process){
'use strict';
const escapeStringRegexp = require('escape-string-regexp');
const ansiStyles = require('ansi-styles');
const supportsColor = require('supports-color');

const template = require('./templates.js');

const isSimpleWindowsTerm = process.platform === 'win32' && !(process.env.TERM || '').toLowerCase().startsWith('xterm');

// `supportsColor.level` → `ansiStyles.color[name]` mapping
const levelMapping = ['ansi', 'ansi', 'ansi256', 'ansi16m'];

// `color-convert` models to exclude from the Chalk API due to conflicts and such
const skipModels = new Set(['gray']);

const styles = Object.create(null);

function applyOptions(obj, options) {
	options = options || {};

	// Detect level if not set manually
	const scLevel = supportsColor ? supportsColor.level : 0;
	obj.level = options.level === undefined ? scLevel : options.level;
	obj.enabled = 'enabled' in options ? options.enabled : obj.level > 0;
}

function Chalk(options) {
	// We check for this.template here since calling `chalk.constructor()`
	// by itself will have a `this` of a previously constructed chalk object
	if (!this || !(this instanceof Chalk) || this.template) {
		const chalk = {};
		applyOptions(chalk, options);

		chalk.template = function () {
			const args = [].slice.call(arguments);
			return chalkTag.apply(null, [chalk.template].concat(args));
		};

		Object.setPrototypeOf(chalk, Chalk.prototype);
		Object.setPrototypeOf(chalk.template, chalk);

		chalk.template.constructor = Chalk;

		return chalk.template;
	}

	applyOptions(this, options);
}

// Use bright blue on Windows as the normal blue color is illegible
if (isSimpleWindowsTerm) {
	ansiStyles.blue.open = '\u001B[94m';
}

for (const key of Object.keys(ansiStyles)) {
	ansiStyles[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles[key].close), 'g');

	styles[key] = {
		get() {
			const codes = ansiStyles[key];
			return build.call(this, this._styles ? this._styles.concat(codes) : [codes], key);
		}
	};
}

ansiStyles.color.closeRe = new RegExp(escapeStringRegexp(ansiStyles.color.close), 'g');
for (const model of Object.keys(ansiStyles.color.ansi)) {
	if (skipModels.has(model)) {
		continue;
	}

	styles[model] = {
		get() {
			const level = this.level;
			return function () {
				const open = ansiStyles.color[levelMapping[level]][model].apply(null, arguments);
				const codes = {
					open,
					close: ansiStyles.color.close,
					closeRe: ansiStyles.color.closeRe
				};
				return build.call(this, this._styles ? this._styles.concat(codes) : [codes], model);
			};
		}
	};
}

ansiStyles.bgColor.closeRe = new RegExp(escapeStringRegexp(ansiStyles.bgColor.close), 'g');
for (const model of Object.keys(ansiStyles.bgColor.ansi)) {
	if (skipModels.has(model)) {
		continue;
	}

	const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);
	styles[bgModel] = {
		get() {
			const level = this.level;
			return function () {
				const open = ansiStyles.bgColor[levelMapping[level]][model].apply(null, arguments);
				const codes = {
					open,
					close: ansiStyles.bgColor.close,
					closeRe: ansiStyles.bgColor.closeRe
				};
				return build.call(this, this._styles ? this._styles.concat(codes) : [codes], model);
			};
		}
	};
}

const proto = Object.defineProperties(() => {}, styles);

function build(_styles, key) {
	const builder = function () {
		return applyStyle.apply(builder, arguments);
	};

	builder._styles = _styles;

	const self = this;

	Object.defineProperty(builder, 'level', {
		enumerable: true,
		get() {
			return self.level;
		},
		set(level) {
			self.level = level;
		}
	});

	Object.defineProperty(builder, 'enabled', {
		enumerable: true,
		get() {
			return self.enabled;
		},
		set(enabled) {
			self.enabled = enabled;
		}
	});

	// See below for fix regarding invisible grey/dim combination on Windows
	builder.hasGrey = this.hasGrey || key === 'gray' || key === 'grey';

	// `__proto__` is used because we must return a function, but there is
	// no way to create a function with a different prototype
	builder.__proto__ = proto; // eslint-disable-line no-proto

	return builder;
}

function applyStyle() {
	// Support varags, but simply cast to string in case there's only one arg
	const args = arguments;
	const argsLen = args.length;
	let str = String(arguments[0]);

	if (argsLen === 0) {
		return '';
	}

	if (argsLen > 1) {
		// Don't slice `arguments`, it prevents V8 optimizations
		for (let a = 1; a < argsLen; a++) {
			str += ' ' + args[a];
		}
	}

	if (!this.enabled || this.level <= 0 || !str) {
		return str;
	}

	// Turns out that on Windows dimmed gray text becomes invisible in cmd.exe,
	// see https://github.com/chalk/chalk/issues/58
	// If we're on Windows and we're dealing with a gray color, temporarily make 'dim' a noop.
	const originalDim = ansiStyles.dim.open;
	if (isSimpleWindowsTerm && this.hasGrey) {
		ansiStyles.dim.open = '';
	}

	for (const code of this._styles.slice().reverse()) {
		// Replace any instances already present with a re-opening code
		// otherwise only the part of the string until said closing code
		// will be colored, and the rest will simply be 'plain'.
		str = code.open + str.replace(code.closeRe, code.open) + code.close;

		// Close the styling before a linebreak and reopen
		// after next line to fix a bleed issue on macOS
		// https://github.com/chalk/chalk/pull/92
		str = str.replace(/\r?\n/g, `${code.close}$&${code.open}`);
	}

	// Reset the original `dim` if we changed it to work around the Windows dimmed gray issue
	ansiStyles.dim.open = originalDim;

	return str;
}

function chalkTag(chalk, strings) {
	if (!Array.isArray(strings)) {
		// If chalk() was called by itself or with a string,
		// return the string itself as a string.
		return [].slice.call(arguments, 1).join(' ');
	}

	const args = [].slice.call(arguments, 2);
	const parts = [strings.raw[0]];

	for (let i = 1; i < strings.length; i++) {
		parts.push(String(args[i - 1]).replace(/[{}\\]/g, '\\$&'));
		parts.push(String(strings.raw[i]));
	}

	return template(chalk, parts.join(''));
}

Object.defineProperties(Chalk.prototype, styles);

module.exports = Chalk(); // eslint-disable-line new-cap
module.exports.supportsColor = supportsColor;

}).call(this,require('_process'))
},{"./templates.js":581,"_process":16,"ansi-styles":45,"escape-string-regexp":604,"supports-color":1155}],581:[function(require,module,exports){
'use strict';
const TEMPLATE_REGEX = /(?:\\(u[a-f0-9]{4}|x[a-f0-9]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
const STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
const STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
const ESCAPE_REGEX = /\\(u[0-9a-f]{4}|x[0-9a-f]{2}|.)|([^\\])/gi;

const ESCAPES = {
	n: '\n',
	r: '\r',
	t: '\t',
	b: '\b',
	f: '\f',
	v: '\v',
	0: '\0',
	'\\': '\\',
	e: '\u001b',
	a: '\u0007'
};

function unescape(c) {
	if ((c[0] === 'u' && c.length === 5) || (c[0] === 'x' && c.length === 3)) {
		return String.fromCharCode(parseInt(c.slice(1), 16));
	}

	return ESCAPES[c] || c;
}

function parseArguments(name, args) {
	const results = [];
	const chunks = args.trim().split(/\s*,\s*/g);
	let matches;

	for (const chunk of chunks) {
		if (!isNaN(chunk)) {
			results.push(Number(chunk));
		} else if ((matches = chunk.match(STRING_REGEX))) {
			results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, chr) => escape ? unescape(escape) : chr));
		} else {
			throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
		}
	}

	return results;
}

function parseStyle(style) {
	STYLE_REGEX.lastIndex = 0;

	const results = [];
	let matches;

	while ((matches = STYLE_REGEX.exec(style)) !== null) {
		const name = matches[1];

		if (matches[2]) {
			const args = parseArguments(name, matches[2]);
			results.push([name].concat(args));
		} else {
			results.push([name]);
		}
	}

	return results;
}

function buildStyle(chalk, styles) {
	const enabled = {};

	for (const layer of styles) {
		for (const style of layer.styles) {
			enabled[style[0]] = layer.inverse ? null : style.slice(1);
		}
	}

	let current = chalk;
	for (const styleName of Object.keys(enabled)) {
		if (Array.isArray(enabled[styleName])) {
			if (!(styleName in current)) {
				throw new Error(`Unknown Chalk style: ${styleName}`);
			}

			if (enabled[styleName].length > 0) {
				current = current[styleName].apply(current, enabled[styleName]);
			} else {
				current = current[styleName];
			}
		}
	}

	return current;
}

module.exports = (chalk, tmp) => {
	const styles = [];
	const chunks = [];
	let chunk = [];

	// eslint-disable-next-line max-params
	tmp.replace(TEMPLATE_REGEX, (m, escapeChar, inverse, style, close, chr) => {
		if (escapeChar) {
			chunk.push(unescape(escapeChar));
		} else if (style) {
			const str = chunk.join('');
			chunk = [];
			chunks.push(styles.length === 0 ? str : buildStyle(chalk, styles)(str));
			styles.push({inverse, styles: parseStyle(style)});
		} else if (close) {
			if (styles.length === 0) {
				throw new Error('Found extraneous } in Chalk template literal');
			}

			chunks.push(buildStyle(chalk, styles)(chunk.join('')));
			chunk = [];
			styles.pop();
		} else {
			chunk.push(chr);
		}
	});

	chunks.push(chunk.join(''));

	if (styles.length > 0) {
		const errMsg = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? '' : 's'} (\`}\`)`;
		throw new Error(errMsg);
	}

	return chunks.join('');
};

},{}],582:[function(require,module,exports){
/*!
Copyright (C) 2013 by WebReflection

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.

*/
var
  // should be a not so common char
  // possibly one JSON does not encode
  // possibly one encodeURIComponent does not encode
  // right now this char is '~' but this might change in the future
  specialChar = '~',
  safeSpecialChar = '\\x' + (
    '0' + specialChar.charCodeAt(0).toString(16)
  ).slice(-2),
  escapedSafeSpecialChar = '\\' + safeSpecialChar,
  specialCharRG = new RegExp(safeSpecialChar, 'g'),
  safeSpecialCharRG = new RegExp(escapedSafeSpecialChar, 'g'),

  safeStartWithSpecialCharRG = new RegExp('(?:^|([^\\\\]))' + escapedSafeSpecialChar),

  indexOf = [].indexOf || function(v){
    for(var i=this.length;i--&&this[i]!==v;);
    return i;
  },
  $String = String  // there's no way to drop warnings in JSHint
                    // about new String ... well, I need that here!
                    // faked, and happy linter!
;

function generateReplacer(value, replacer, resolve) {
  var
    path = [],
    all  = [value],
    seen = [value],
    mapp = [resolve ? specialChar : '[Circular]'],
    last = value,
    lvl  = 1,
    i
  ;
  return function(key, value) {
    // the replacer has rights to decide
    // if a new object should be returned
    // or if there's some key to drop
    // let's call it here rather than "too late"
    if (replacer) value = replacer.call(this, key, value);

    // did you know ? Safari passes keys as integers for arrays
    // which means if (key) when key === 0 won't pass the check
    if (key !== '') {
      if (last !== this) {
        i = lvl - indexOf.call(all, this) - 1;
        lvl -= i;
        all.splice(lvl, all.length);
        path.splice(lvl - 1, path.length);
        last = this;
      }
      // console.log(lvl, key, path);
      if (typeof value === 'object' && value) {
    	// if object isn't referring to parent object, add to the
        // object path stack. Otherwise it is already there.
        if (indexOf.call(all, value) < 0) {
          all.push(last = value);
        }
        lvl = all.length;
        i = indexOf.call(seen, value);
        if (i < 0) {
          i = seen.push(value) - 1;
          if (resolve) {
            // key cannot contain specialChar but could be not a string
            path.push(('' + key).replace(specialCharRG, safeSpecialChar));
            mapp[i] = specialChar + path.join(specialChar);
          } else {
            mapp[i] = mapp[0];
          }
        } else {
          value = mapp[i];
        }
      } else {
        if (typeof value === 'string' && resolve) {
          // ensure no special char involved on deserialization
          // in this case only first char is important
          // no need to replace all value (better performance)
          value = value .replace(safeSpecialChar, escapedSafeSpecialChar)
                        .replace(specialChar, safeSpecialChar);
        }
      }
    }
    return value;
  };
}

function retrieveFromPath(current, keys) {
  for(var i = 0, length = keys.length; i < length; current = current[
    // keys should be normalized back here
    keys[i++].replace(safeSpecialCharRG, specialChar)
  ]);
  return current;
}

function generateReviver(reviver) {
  return function(key, value) {
    var isString = typeof value === 'string';
    if (isString && value.charAt(0) === specialChar) {
      return new $String(value.slice(1));
    }
    if (key === '') value = regenerate(value, value, {});
    // again, only one needed, do not use the RegExp for this replacement
    // only keys need the RegExp
    if (isString) value = value .replace(safeStartWithSpecialCharRG, '$1' + specialChar)
                                .replace(escapedSafeSpecialChar, safeSpecialChar);
    return reviver ? reviver.call(this, key, value) : value;
  };
}

function regenerateArray(root, current, retrieve) {
  for (var i = 0, length = current.length; i < length; i++) {
    current[i] = regenerate(root, current[i], retrieve);
  }
  return current;
}

function regenerateObject(root, current, retrieve) {
  for (var key in current) {
    if (current.hasOwnProperty(key)) {
      current[key] = regenerate(root, current[key], retrieve);
    }
  }
  return current;
}

function regenerate(root, current, retrieve) {
  return current instanceof Array ?
    // fast Array reconstruction
    regenerateArray(root, current, retrieve) :
    (
      current instanceof $String ?
        (
          // root is an empty string
          current.length ?
            (
              retrieve.hasOwnProperty(current) ?
                retrieve[current] :
                retrieve[current] = retrieveFromPath(
                  root, current.split(specialChar)
                )
            ) :
            root
        ) :
        (
          current instanceof Object ?
            // dedicated Object parser
            regenerateObject(root, current, retrieve) :
            // value as it is
            current
        )
    )
  ;
}

function stringifyRecursion(value, replacer, space, doNotResolve) {
  return JSON.stringify(value, generateReplacer(value, replacer, !doNotResolve), space);
}

function parseRecursion(text, reviver) {
  return JSON.parse(text, generateReviver(reviver));
}
this.stringify = stringifyRecursion;
this.parse = parseRecursion;
},{}],583:[function(require,module,exports){
'use strict';
var isRegexp = require('is-regexp');
var isSupportedRegexpFlag = require('is-supported-regexp-flag');

var flagMap = {
	global: 'g',
	ignoreCase: 'i',
	multiline: 'm'
};

if (isSupportedRegexpFlag('y')) {
	flagMap.sticky = 'y';
}

if (isSupportedRegexpFlag('u')) {
	flagMap.unicode = 'u';
}

module.exports = function (re, opts) {
	if (!isRegexp(re)) {
		throw new TypeError('Expected a RegExp instance');
	}

	opts = opts || {};

	var flags = Object.keys(flagMap).map(function (el) {
		return (typeof opts[el] === 'boolean' ? opts[el] : re[el]) ? flagMap[el] : '';
	}).join('');

	return new RegExp(opts.source || re.source, flags);
};

},{"is-regexp":654,"is-supported-regexp-flag":655}],584:[function(require,module,exports){
/* MIT license */
var cssKeywords = require('color-name');

// NOTE: conversions should only return primitive values (i.e. arrays, or
//       values that give correct `typeof` results).
//       do not use box values types (i.e. Number(), String(), etc.)

var reverseKeywords = {};
for (var key in cssKeywords) {
	if (cssKeywords.hasOwnProperty(key)) {
		reverseKeywords[cssKeywords[key]] = key;
	}
}

var convert = module.exports = {
	rgb: {channels: 3, labels: 'rgb'},
	hsl: {channels: 3, labels: 'hsl'},
	hsv: {channels: 3, labels: 'hsv'},
	hwb: {channels: 3, labels: 'hwb'},
	cmyk: {channels: 4, labels: 'cmyk'},
	xyz: {channels: 3, labels: 'xyz'},
	lab: {channels: 3, labels: 'lab'},
	lch: {channels: 3, labels: 'lch'},
	hex: {channels: 1, labels: ['hex']},
	keyword: {channels: 1, labels: ['keyword']},
	ansi16: {channels: 1, labels: ['ansi16']},
	ansi256: {channels: 1, labels: ['ansi256']},
	hcg: {channels: 3, labels: ['h', 'c', 'g']},
	apple: {channels: 3, labels: ['r16', 'g16', 'b16']},
	gray: {channels: 1, labels: ['gray']}
};

// hide .channels and .labels properties
for (var model in convert) {
	if (convert.hasOwnProperty(model)) {
		if (!('channels' in convert[model])) {
			throw new Error('missing channels property: ' + model);
		}

		if (!('labels' in convert[model])) {
			throw new Error('missing channel labels property: ' + model);
		}

		if (convert[model].labels.length !== convert[model].channels) {
			throw new Error('channel and label counts mismatch: ' + model);
		}

		var channels = convert[model].channels;
		var labels = convert[model].labels;
		delete convert[model].channels;
		delete convert[model].labels;
		Object.defineProperty(convert[model], 'channels', {value: channels});
		Object.defineProperty(convert[model], 'labels', {value: labels});
	}
}

convert.rgb.hsl = function (rgb) {
	var r = rgb[0] / 255;
	var g = rgb[1] / 255;
	var b = rgb[2] / 255;
	var min = Math.min(r, g, b);
	var max = Math.max(r, g, b);
	var delta = max - min;
	var h;
	var s;
	var l;

	if (max === min) {
		h = 0;
	} else if (r === max) {
		h = (g - b) / delta;
	} else if (g === max) {
		h = 2 + (b - r) / delta;
	} else if (b === max) {
		h = 4 + (r - g) / delta;
	}

	h = Math.min(h * 60, 360);

	if (h < 0) {
		h += 360;
	}

	l = (min + max) / 2;

	if (max === min) {
		s = 0;
	} else if (l <= 0.5) {
		s = delta / (max + min);
	} else {
		s = delta / (2 - max - min);
	}

	return [h, s * 100, l * 100];
};

convert.rgb.hsv = function (rgb) {
	var r = rgb[0];
	var g = rgb[1];
	var b = rgb[2];
	var min = Math.min(r, g, b);
	var max = Math.max(r, g, b);
	var delta = max - min;
	var h;
	var s;
	var v;

	if (max === 0) {
		s = 0;
	} else {
		s = (delta / max * 1000) / 10;
	}

	if (max === min) {
		h = 0;
	} else if (r === max) {
		h = (g - b) / delta;
	} else if (g === max) {
		h = 2 + (b - r) / delta;
	} else if (b === max) {
		h = 4 + (r - g) / delta;
	}

	h = Math.min(h * 60, 360);

	if (h < 0) {
		h += 360;
	}

	v = ((max / 255) * 1000) / 10;

	return [h, s, v];
};

convert.rgb.hwb = function (rgb) {
	var r = rgb[0];
	var g = rgb[1];
	var b = rgb[2];
	var h = convert.rgb.hsl(rgb)[0];
	var w = 1 / 255 * Math.min(r, Math.min(g, b));

	b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));

	return [h, w * 100, b * 100];
};

convert.rgb.cmyk = function (rgb) {
	var r = rgb[0] / 255;
	var g = rgb[1] / 255;
	var b = rgb[2] / 255;
	var c;
	var m;
	var y;
	var k;

	k = Math.min(1 - r, 1 - g, 1 - b);
	c = (1 - r - k) / (1 - k) || 0;
	m = (1 - g - k) / (1 - k) || 0;
	y = (1 - b - k) / (1 - k) || 0;

	return [c * 100, m * 100, y * 100, k * 100];
};

/**
 * See https://en.m.wikipedia.org/wiki/Euclidean_distance#Squared_Euclidean_distance
 * */
function comparativeDistance(x, y) {
	return (
		Math.pow(x[0] - y[0], 2) +
		Math.pow(x[1] - y[1], 2) +
		Math.pow(x[2] - y[2], 2)
	);
}

convert.rgb.keyword = function (rgb) {
	var reversed = reverseKeywords[rgb];
	if (reversed) {
		return reversed;
	}

	var currentClosestDistance = Infinity;
	var currentClosestKeyword;

	for (var keyword in cssKeywords) {
		if (cssKeywords.hasOwnProperty(keyword)) {
			var value = cssKeywords[keyword];

			// Compute comparative distance
			var distance = comparativeDistance(rgb, value);

			// Check if its less, if so set as closest
			if (distance < currentClosestDistance) {
				currentClosestDistance = distance;
				currentClosestKeyword = keyword;
			}
		}
	}

	return currentClosestKeyword;
};

convert.keyword.rgb = function (keyword) {
	return cssKeywords[keyword];
};

convert.rgb.xyz = function (rgb) {
	var r = rgb[0] / 255;
	var g = rgb[1] / 255;
	var b = rgb[2] / 255;

	// assume sRGB
	r = r > 0.04045 ? Math.pow(((r + 0.055) / 1.055), 2.4) : (r / 12.92);
	g = g > 0.04045 ? Math.pow(((g + 0.055) / 1.055), 2.4) : (g / 12.92);
	b = b > 0.04045 ? Math.pow(((b + 0.055) / 1.055), 2.4) : (b / 12.92);

	var x = (r * 0.4124) + (g * 0.3576) + (b * 0.1805);
	var y = (r * 0.2126) + (g * 0.7152) + (b * 0.0722);
	var z = (r * 0.0193) + (g * 0.1192) + (b * 0.9505);

	return [x * 100, y * 100, z * 100];
};

convert.rgb.lab = function (rgb) {
	var xyz = convert.rgb.xyz(rgb);
	var x = xyz[0];
	var y = xyz[1];
	var z = xyz[2];
	var l;
	var a;
	var b;

	x /= 95.047;
	y /= 100;
	z /= 108.883;

	x = x > 0.008856 ? Math.pow(x, 1 / 3) : (7.787 * x) + (16 / 116);
	y = y > 0.008856 ? Math.pow(y, 1 / 3) : (7.787 * y) + (16 / 116);
	z = z > 0.008856 ? Math.pow(z, 1 / 3) : (7.787 * z) + (16 / 116);

	l = (116 * y) - 16;
	a = 500 * (x - y);
	b = 200 * (y - z);

	return [l, a, b];
};

convert.hsl.rgb = function (hsl) {
	var h = hsl[0] / 360;
	var s = hsl[1] / 100;
	var l = hsl[2] / 100;
	var t1;
	var t2;
	var t3;
	var rgb;
	var val;

	if (s === 0) {
		val = l * 255;
		return [val, val, val];
	}

	if (l < 0.5) {
		t2 = l * (1 + s);
	} else {
		t2 = l + s - l * s;
	}

	t1 = 2 * l - t2;

	rgb = [0, 0, 0];
	for (var i = 0; i < 3; i++) {
		t3 = h + 1 / 3 * -(i - 1);
		if (t3 < 0) {
			t3++;
		}
		if (t3 > 1) {
			t3--;
		}

		if (6 * t3 < 1) {
			val = t1 + (t2 - t1) * 6 * t3;
		} else if (2 * t3 < 1) {
			val = t2;
		} else if (3 * t3 < 2) {
			val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
		} else {
			val = t1;
		}

		rgb[i] = val * 255;
	}

	return rgb;
};

convert.hsl.hsv = function (hsl) {
	var h = hsl[0];
	var s = hsl[1] / 100;
	var l = hsl[2] / 100;
	var smin = s;
	var lmin = Math.max(l, 0.01);
	var sv;
	var v;

	l *= 2;
	s *= (l <= 1) ? l : 2 - l;
	smin *= lmin <= 1 ? lmin : 2 - lmin;
	v = (l + s) / 2;
	sv = l === 0 ? (2 * smin) / (lmin + smin) : (2 * s) / (l + s);

	return [h, sv * 100, v * 100];
};

convert.hsv.rgb = function (hsv) {
	var h = hsv[0] / 60;
	var s = hsv[1] / 100;
	var v = hsv[2] / 100;
	var hi = Math.floor(h) % 6;

	var f = h - Math.floor(h);
	var p = 255 * v * (1 - s);
	var q = 255 * v * (1 - (s * f));
	var t = 255 * v * (1 - (s * (1 - f)));
	v *= 255;

	switch (hi) {
		case 0:
			return [v, t, p];
		case 1:
			return [q, v, p];
		case 2:
			return [p, v, t];
		case 3:
			return [p, q, v];
		case 4:
			return [t, p, v];
		case 5:
			return [v, p, q];
	}
};

convert.hsv.hsl = function (hsv) {
	var h = hsv[0];
	var s = hsv[1] / 100;
	var v = hsv[2] / 100;
	var vmin = Math.max(v, 0.01);
	var lmin;
	var sl;
	var l;

	l = (2 - s) * v;
	lmin = (2 - s) * vmin;
	sl = s * vmin;
	sl /= (lmin <= 1) ? lmin : 2 - lmin;
	sl = sl || 0;
	l /= 2;

	return [h, sl * 100, l * 100];
};

// http://dev.w3.org/csswg/css-color/#hwb-to-rgb
convert.hwb.rgb = function (hwb) {
	var h = hwb[0] / 360;
	var wh = hwb[1] / 100;
	var bl = hwb[2] / 100;
	var ratio = wh + bl;
	var i;
	var v;
	var f;
	var n;

	// wh + bl cant be > 1
	if (ratio > 1) {
		wh /= ratio;
		bl /= ratio;
	}

	i = Math.floor(6 * h);
	v = 1 - bl;
	f = 6 * h - i;

	if ((i & 0x01) !== 0) {
		f = 1 - f;
	}

	n = wh + f * (v - wh); // linear interpolation

	var r;
	var g;
	var b;
	switch (i) {
		default:
		case 6:
		case 0: r = v; g = n; b = wh; break;
		case 1: r = n; g = v; b = wh; break;
		case 2: r = wh; g = v; b = n; break;
		case 3: r = wh; g = n; b = v; break;
		case 4: r = n; g = wh; b = v; break;
		case 5: r = v; g = wh; b = n; break;
	}

	return [r * 255, g * 255, b * 255];
};

convert.cmyk.rgb = function (cmyk) {
	var c = cmyk[0] / 100;
	var m = cmyk[1] / 100;
	var y = cmyk[2] / 100;
	var k = cmyk[3] / 100;
	var r;
	var g;
	var b;

	r = 1 - Math.min(1, c * (1 - k) + k);
	g = 1 - Math.min(1, m * (1 - k) + k);
	b = 1 - Math.min(1, y * (1 - k) + k);

	return [r * 255, g * 255, b * 255];
};

convert.xyz.rgb = function (xyz) {
	var x = xyz[0] / 100;
	var y = xyz[1] / 100;
	var z = xyz[2] / 100;
	var r;
	var g;
	var b;

	r = (x * 3.2406) + (y * -1.5372) + (z * -0.4986);
	g = (x * -0.9689) + (y * 1.8758) + (z * 0.0415);
	b = (x * 0.0557) + (y * -0.2040) + (z * 1.0570);

	// assume sRGB
	r = r > 0.0031308
		? ((1.055 * Math.pow(r, 1.0 / 2.4)) - 0.055)
		: r * 12.92;

	g = g > 0.0031308
		? ((1.055 * Math.pow(g, 1.0 / 2.4)) - 0.055)
		: g * 12.92;

	b = b > 0.0031308
		? ((1.055 * Math.pow(b, 1.0 / 2.4)) - 0.055)
		: b * 12.92;

	r = Math.min(Math.max(0, r), 1);
	g = Math.min(Math.max(0, g), 1);
	b = Math.min(Math.max(0, b), 1);

	return [r * 255, g * 255, b * 255];
};

convert.xyz.lab = function (xyz) {
	var x = xyz[0];
	var y = xyz[1];
	var z = xyz[2];
	var l;
	var a;
	var b;

	x /= 95.047;
	y /= 100;
	z /= 108.883;

	x = x > 0.008856 ? Math.pow(x, 1 / 3) : (7.787 * x) + (16 / 116);
	y = y > 0.008856 ? Math.pow(y, 1 / 3) : (7.787 * y) + (16 / 116);
	z = z > 0.008856 ? Math.pow(z, 1 / 3) : (7.787 * z) + (16 / 116);

	l = (116 * y) - 16;
	a = 500 * (x - y);
	b = 200 * (y - z);

	return [l, a, b];
};

convert.lab.xyz = function (lab) {
	var l = lab[0];
	var a = lab[1];
	var b = lab[2];
	var x;
	var y;
	var z;

	y = (l + 16) / 116;
	x = a / 500 + y;
	z = y - b / 200;

	var y2 = Math.pow(y, 3);
	var x2 = Math.pow(x, 3);
	var z2 = Math.pow(z, 3);
	y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787;
	x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787;
	z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787;

	x *= 95.047;
	y *= 100;
	z *= 108.883;

	return [x, y, z];
};

convert.lab.lch = function (lab) {
	var l = lab[0];
	var a = lab[1];
	var b = lab[2];
	var hr;
	var h;
	var c;

	hr = Math.atan2(b, a);
	h = hr * 360 / 2 / Math.PI;

	if (h < 0) {
		h += 360;
	}

	c = Math.sqrt(a * a + b * b);

	return [l, c, h];
};

convert.lch.lab = function (lch) {
	var l = lch[0];
	var c = lch[1];
	var h = lch[2];
	var a;
	var b;
	var hr;

	hr = h / 360 * 2 * Math.PI;
	a = c * Math.cos(hr);
	b = c * Math.sin(hr);

	return [l, a, b];
};

convert.rgb.ansi16 = function (args) {
	var r = args[0];
	var g = args[1];
	var b = args[2];
	var value = 1 in arguments ? arguments[1] : convert.rgb.hsv(args)[2]; // hsv -> ansi16 optimization

	value = Math.round(value / 50);

	if (value === 0) {
		return 30;
	}

	var ansi = 30
		+ ((Math.round(b / 255) << 2)
		| (Math.round(g / 255) << 1)
		| Math.round(r / 255));

	if (value === 2) {
		ansi += 60;
	}

	return ansi;
};

convert.hsv.ansi16 = function (args) {
	// optimization here; we already know the value and don't need to get
	// it converted for us.
	return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);
};

convert.rgb.ansi256 = function (args) {
	var r = args[0];
	var g = args[1];
	var b = args[2];

	// we use the extended greyscale palette here, with the exception of
	// black and white. normal palette only has 4 greyscale shades.
	if (r === g && g === b) {
		if (r < 8) {
			return 16;
		}

		if (r > 248) {
			return 231;
		}

		return Math.round(((r - 8) / 247) * 24) + 232;
	}

	var ansi = 16
		+ (36 * Math.round(r / 255 * 5))
		+ (6 * Math.round(g / 255 * 5))
		+ Math.round(b / 255 * 5);

	return ansi;
};

convert.ansi16.rgb = function (args) {
	var color = args % 10;

	// handle greyscale
	if (color === 0 || color === 7) {
		if (args > 50) {
			color += 3.5;
		}

		color = color / 10.5 * 255;

		return [color, color, color];
	}

	var mult = (~~(args > 50) + 1) * 0.5;
	var r = ((color & 1) * mult) * 255;
	var g = (((color >> 1) & 1) * mult) * 255;
	var b = (((color >> 2) & 1) * mult) * 255;

	return [r, g, b];
};

convert.ansi256.rgb = function (args) {
	// handle greyscale
	if (args >= 232) {
		var c = (args - 232) * 10 + 8;
		return [c, c, c];
	}

	args -= 16;

	var rem;
	var r = Math.floor(args / 36) / 5 * 255;
	var g = Math.floor((rem = args % 36) / 6) / 5 * 255;
	var b = (rem % 6) / 5 * 255;

	return [r, g, b];
};

convert.rgb.hex = function (args) {
	var integer = ((Math.round(args[0]) & 0xFF) << 16)
		+ ((Math.round(args[1]) & 0xFF) << 8)
		+ (Math.round(args[2]) & 0xFF);

	var string = integer.toString(16).toUpperCase();
	return '000000'.substring(string.length) + string;
};

convert.hex.rgb = function (args) {
	var match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
	if (!match) {
		return [0, 0, 0];
	}

	var colorString = match[0];

	if (match[0].length === 3) {
		colorString = colorString.split('').map(function (char) {
			return char + char;
		}).join('');
	}

	var integer = parseInt(colorString, 16);
	var r = (integer >> 16) & 0xFF;
	var g = (integer >> 8) & 0xFF;
	var b = integer & 0xFF;

	return [r, g, b];
};

convert.rgb.hcg = function (rgb) {
	var r = rgb[0] / 255;
	var g = rgb[1] / 255;
	var b = rgb[2] / 255;
	var max = Math.max(Math.max(r, g), b);
	var min = Math.min(Math.min(r, g), b);
	var chroma = (max - min);
	var grayscale;
	var hue;

	if (chroma < 1) {
		grayscale = min / (1 - chroma);
	} else {
		grayscale = 0;
	}

	if (chroma <= 0) {
		hue = 0;
	} else
	if (max === r) {
		hue = ((g - b) / chroma) % 6;
	} else
	if (max === g) {
		hue = 2 + (b - r) / chroma;
	} else {
		hue = 4 + (r - g) / chroma + 4;
	}

	hue /= 6;
	hue %= 1;

	return [hue * 360, chroma * 100, grayscale * 100];
};

convert.hsl.hcg = function (hsl) {
	var s = hsl[1] / 100;
	var l = hsl[2] / 100;
	var c = 1;
	var f = 0;

	if (l < 0.5) {
		c = 2.0 * s * l;
	} else {
		c = 2.0 * s * (1.0 - l);
	}

	if (c < 1.0) {
		f = (l - 0.5 * c) / (1.0 - c);
	}

	return [hsl[0], c * 100, f * 100];
};

convert.hsv.hcg = function (hsv) {
	var s = hsv[1] / 100;
	var v = hsv[2] / 100;

	var c = s * v;
	var f = 0;

	if (c < 1.0) {
		f = (v - c) / (1 - c);
	}

	return [hsv[0], c * 100, f * 100];
};

convert.hcg.rgb = function (hcg) {
	var h = hcg[0] / 360;
	var c = hcg[1] / 100;
	var g = hcg[2] / 100;

	if (c === 0.0) {
		return [g * 255, g * 255, g * 255];
	}

	var pure = [0, 0, 0];
	var hi = (h % 1) * 6;
	var v = hi % 1;
	var w = 1 - v;
	var mg = 0;

	switch (Math.floor(hi)) {
		case 0:
			pure[0] = 1; pure[1] = v; pure[2] = 0; break;
		case 1:
			pure[0] = w; pure[1] = 1; pure[2] = 0; break;
		case 2:
			pure[0] = 0; pure[1] = 1; pure[2] = v; break;
		case 3:
			pure[0] = 0; pure[1] = w; pure[2] = 1; break;
		case 4:
			pure[0] = v; pure[1] = 0; pure[2] = 1; break;
		default:
			pure[0] = 1; pure[1] = 0; pure[2] = w;
	}

	mg = (1.0 - c) * g;

	return [
		(c * pure[0] + mg) * 255,
		(c * pure[1] + mg) * 255,
		(c * pure[2] + mg) * 255
	];
};

convert.hcg.hsv = function (hcg) {
	var c = hcg[1] / 100;
	var g = hcg[2] / 100;

	var v = c + g * (1.0 - c);
	var f = 0;

	if (v > 0.0) {
		f = c / v;
	}

	return [hcg[0], f * 100, v * 100];
};

convert.hcg.hsl = function (hcg) {
	var c = hcg[1] / 100;
	var g = hcg[2] / 100;

	var l = g * (1.0 - c) + 0.5 * c;
	var s = 0;

	if (l > 0.0 && l < 0.5) {
		s = c / (2 * l);
	} else
	if (l >= 0.5 && l < 1.0) {
		s = c / (2 * (1 - l));
	}

	return [hcg[0], s * 100, l * 100];
};

convert.hcg.hwb = function (hcg) {
	var c = hcg[1] / 100;
	var g = hcg[2] / 100;
	var v = c + g * (1.0 - c);
	return [hcg[0], (v - c) * 100, (1 - v) * 100];
};

convert.hwb.hcg = function (hwb) {
	var w = hwb[1] / 100;
	var b = hwb[2] / 100;
	var v = 1 - b;
	var c = v - w;
	var g = 0;

	if (c < 1) {
		g = (v - c) / (1 - c);
	}

	return [hwb[0], c * 100, g * 100];
};

convert.apple.rgb = function (apple) {
	return [(apple[0] / 65535) * 255, (apple[1] / 65535) * 255, (apple[2] / 65535) * 255];
};

convert.rgb.apple = function (rgb) {
	return [(rgb[0] / 255) * 65535, (rgb[1] / 255) * 65535, (rgb[2] / 255) * 65535];
};

convert.gray.rgb = function (args) {
	return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
};

convert.gray.hsl = convert.gray.hsv = function (args) {
	return [0, 0, args[0]];
};

convert.gray.hwb = function (gray) {
	return [0, 100, gray[0]];
};

convert.gray.cmyk = function (gray) {
	return [0, 0, 0, gray[0]];
};

convert.gray.lab = function (gray) {
	return [gray[0], 0, 0];
};

convert.gray.hex = function (gray) {
	var val = Math.round(gray[0] / 100 * 255) & 0xFF;
	var integer = (val << 16) + (val << 8) + val;

	var string = integer.toString(16).toUpperCase();
	return '000000'.substring(string.length) + string;
};

convert.rgb.gray = function (rgb) {
	var val = (rgb[0] + rgb[1] + rgb[2]) / 3;
	return [val / 255 * 100];
};

},{"color-name":587}],585:[function(require,module,exports){
var conversions = require('./conversions');
var route = require('./route');

var convert = {};

var models = Object.keys(conversions);

function wrapRaw(fn) {
	var wrappedFn = function (args) {
		if (args === undefined || args === null) {
			return args;
		}

		if (arguments.length > 1) {
			args = Array.prototype.slice.call(arguments);
		}

		return fn(args);
	};

	// preserve .conversion property if there is one
	if ('conversion' in fn) {
		wrappedFn.conversion = fn.conversion;
	}

	return wrappedFn;
}

function wrapRounded(fn) {
	var wrappedFn = function (args) {
		if (args === undefined || args === null) {
			return args;
		}

		if (arguments.length > 1) {
			args = Array.prototype.slice.call(arguments);
		}

		var result = fn(args);

		// we're assuming the result is an array here.
		// see notice in conversions.js; don't use box types
		// in conversion functions.
		if (typeof result === 'object') {
			for (var len = result.length, i = 0; i < len; i++) {
				result[i] = Math.round(result[i]);
			}
		}

		return result;
	};

	// preserve .conversion property if there is one
	if ('conversion' in fn) {
		wrappedFn.conversion = fn.conversion;
	}

	return wrappedFn;
}

models.forEach(function (fromModel) {
	convert[fromModel] = {};

	Object.defineProperty(convert[fromModel], 'channels', {value: conversions[fromModel].channels});
	Object.defineProperty(convert[fromModel], 'labels', {value: conversions[fromModel].labels});

	var routes = route(fromModel);
	var routeModels = Object.keys(routes);

	routeModels.forEach(function (toModel) {
		var fn = routes[toModel];

		convert[fromModel][toModel] = wrapRounded(fn);
		convert[fromModel][toModel].raw = wrapRaw(fn);
	});
});

module.exports = convert;

},{"./conversions":584,"./route":586}],586:[function(require,module,exports){
var conversions = require('./conversions');

/*
	this function routes a model to all other models.

	all functions that are routed have a property `.conversion` attached
	to the returned synthetic function. This property is an array
	of strings, each with the steps in between the 'from' and 'to'
	color models (inclusive).

	conversions that are not possible simply are not included.
*/

// https://jsperf.com/object-keys-vs-for-in-with-closure/3
var models = Object.keys(conversions);

function buildGraph() {
	var graph = {};

	for (var len = models.length, i = 0; i < len; i++) {
		graph[models[i]] = {
			// http://jsperf.com/1-vs-infinity
			// micro-opt, but this is simple.
			distance: -1,
			parent: null
		};
	}

	return graph;
}

// https://en.wikipedia.org/wiki/Breadth-first_search
function deriveBFS(fromModel) {
	var graph = buildGraph();
	var queue = [fromModel]; // unshift -> queue -> pop

	graph[fromModel].distance = 0;

	while (queue.length) {
		var current = queue.pop();
		var adjacents = Object.keys(conversions[current]);

		for (var len = adjacents.length, i = 0; i < len; i++) {
			var adjacent = adjacents[i];
			var node = graph[adjacent];

			if (node.distance === -1) {
				node.distance = graph[current].distance + 1;
				node.parent = current;
				queue.unshift(adjacent);
			}
		}
	}

	return graph;
}

function link(from, to) {
	return function (args) {
		return to(from(args));
	};
}

function wrapConversion(toModel, graph) {
	var path = [graph[toModel].parent, toModel];
	var fn = conversions[graph[toModel].parent][toModel];

	var cur = graph[toModel].parent;
	while (graph[cur].parent) {
		path.unshift(graph[cur].parent);
		fn = link(conversions[graph[cur].parent][cur], fn);
		cur = graph[cur].parent;
	}

	fn.conversion = path;
	return fn;
}

module.exports = function (fromModel) {
	var graph = deriveBFS(fromModel);
	var conversion = {};

	var models = Object.keys(graph);
	for (var len = models.length, i = 0; i < len; i++) {
		var toModel = models[i];
		var node = graph[toModel];

		if (node.parent === null) {
			// no possible conversion, or this node is the source model.
			continue;
		}

		conversion[toModel] = wrapConversion(toModel, graph);
	}

	return conversion;
};


},{"./conversions":584}],587:[function(require,module,exports){
'use strict'

module.exports = {
	"aliceblue": [240, 248, 255],
	"antiquewhite": [250, 235, 215],
	"aqua": [0, 255, 255],
	"aquamarine": [127, 255, 212],
	"azure": [240, 255, 255],
	"beige": [245, 245, 220],
	"bisque": [255, 228, 196],
	"black": [0, 0, 0],
	"blanchedalmond": [255, 235, 205],
	"blue": [0, 0, 255],
	"blueviolet": [138, 43, 226],
	"brown": [165, 42, 42],
	"burlywood": [222, 184, 135],
	"cadetblue": [95, 158, 160],
	"chartreuse": [127, 255, 0],
	"chocolate": [210, 105, 30],
	"coral": [255, 127, 80],
	"cornflowerblue": [100, 149, 237],
	"cornsilk": [255, 248, 220],
	"crimson": [220, 20, 60],
	"cyan": [0, 255, 255],
	"darkblue": [0, 0, 139],
	"darkcyan": [0, 139, 139],
	"darkgoldenrod": [184, 134, 11],
	"darkgray": [169, 169, 169],
	"darkgreen": [0, 100, 0],
	"darkgrey": [169, 169, 169],
	"darkkhaki": [189, 183, 107],
	"darkmagenta": [139, 0, 139],
	"darkolivegreen": [85, 107, 47],
	"darkorange": [255, 140, 0],
	"darkorchid": [153, 50, 204],
	"darkred": [139, 0, 0],
	"darksalmon": [233, 150, 122],
	"darkseagreen": [143, 188, 143],
	"darkslateblue": [72, 61, 139],
	"darkslategray": [47, 79, 79],
	"darkslategrey": [47, 79, 79],
	"darkturquoise": [0, 206, 209],
	"darkviolet": [148, 0, 211],
	"deeppink": [255, 20, 147],
	"deepskyblue": [0, 191, 255],
	"dimgray": [105, 105, 105],
	"dimgrey": [105, 105, 105],
	"dodgerblue": [30, 144, 255],
	"firebrick": [178, 34, 34],
	"floralwhite": [255, 250, 240],
	"forestgreen": [34, 139, 34],
	"fuchsia": [255, 0, 255],
	"gainsboro": [220, 220, 220],
	"ghostwhite": [248, 248, 255],
	"gold": [255, 215, 0],
	"goldenrod": [218, 165, 32],
	"gray": [128, 128, 128],
	"green": [0, 128, 0],
	"greenyellow": [173, 255, 47],
	"grey": [128, 128, 128],
	"honeydew": [240, 255, 240],
	"hotpink": [255, 105, 180],
	"indianred": [205, 92, 92],
	"indigo": [75, 0, 130],
	"ivory": [255, 255, 240],
	"khaki": [240, 230, 140],
	"lavender": [230, 230, 250],
	"lavenderblush": [255, 240, 245],
	"lawngreen": [124, 252, 0],
	"lemonchiffon": [255, 250, 205],
	"lightblue": [173, 216, 230],
	"lightcoral": [240, 128, 128],
	"lightcyan": [224, 255, 255],
	"lightgoldenrodyellow": [250, 250, 210],
	"lightgray": [211, 211, 211],
	"lightgreen": [144, 238, 144],
	"lightgrey": [211, 211, 211],
	"lightpink": [255, 182, 193],
	"lightsalmon": [255, 160, 122],
	"lightseagreen": [32, 178, 170],
	"lightskyblue": [135, 206, 250],
	"lightslategray": [119, 136, 153],
	"lightslategrey": [119, 136, 153],
	"lightsteelblue": [176, 196, 222],
	"lightyellow": [255, 255, 224],
	"lime": [0, 255, 0],
	"limegreen": [50, 205, 50],
	"linen": [250, 240, 230],
	"magenta": [255, 0, 255],
	"maroon": [128, 0, 0],
	"mediumaquamarine": [102, 205, 170],
	"mediumblue": [0, 0, 205],
	"mediumorchid": [186, 85, 211],
	"mediumpurple": [147, 112, 219],
	"mediumseagreen": [60, 179, 113],
	"mediumslateblue": [123, 104, 238],
	"mediumspringgreen": [0, 250, 154],
	"mediumturquoise": [72, 209, 204],
	"mediumvioletred": [199, 21, 133],
	"midnightblue": [25, 25, 112],
	"mintcream": [245, 255, 250],
	"mistyrose": [255, 228, 225],
	"moccasin": [255, 228, 181],
	"navajowhite": [255, 222, 173],
	"navy": [0, 0, 128],
	"oldlace": [253, 245, 230],
	"olive": [128, 128, 0],
	"olivedrab": [107, 142, 35],
	"orange": [255, 165, 0],
	"orangered": [255, 69, 0],
	"orchid": [218, 112, 214],
	"palegoldenrod": [238, 232, 170],
	"palegreen": [152, 251, 152],
	"paleturquoise": [175, 238, 238],
	"palevioletred": [219, 112, 147],
	"papayawhip": [255, 239, 213],
	"peachpuff": [255, 218, 185],
	"peru": [205, 133, 63],
	"pink": [255, 192, 203],
	"plum": [221, 160, 221],
	"powderblue": [176, 224, 230],
	"purple": [128, 0, 128],
	"rebeccapurple": [102, 51, 153],
	"red": [255, 0, 0],
	"rosybrown": [188, 143, 143],
	"royalblue": [65, 105, 225],
	"saddlebrown": [139, 69, 19],
	"salmon": [250, 128, 114],
	"sandybrown": [244, 164, 96],
	"seagreen": [46, 139, 87],
	"seashell": [255, 245, 238],
	"sienna": [160, 82, 45],
	"silver": [192, 192, 192],
	"skyblue": [135, 206, 235],
	"slateblue": [106, 90, 205],
	"slategray": [112, 128, 144],
	"slategrey": [112, 128, 144],
	"snow": [255, 250, 250],
	"springgreen": [0, 255, 127],
	"steelblue": [70, 130, 180],
	"tan": [210, 180, 140],
	"teal": [0, 128, 128],
	"thistle": [216, 191, 216],
	"tomato": [255, 99, 71],
	"turquoise": [64, 224, 208],
	"violet": [238, 130, 238],
	"wheat": [245, 222, 179],
	"white": [255, 255, 255],
	"whitesmoke": [245, 245, 245],
	"yellow": [255, 255, 0],
	"yellowgreen": [154, 205, 50]
};

},{}],588:[function(require,module,exports){
module.exports = function (xs, fn) {
    var res = [];
    for (var i = 0; i < xs.length; i++) {
        var x = fn(xs[i], i);
        if (isArray(x)) res.push.apply(res, x);
        else res.push(x);
    }
    return res;
};

var isArray = Array.isArray || function (xs) {
    return Object.prototype.toString.call(xs) === '[object Array]';
};

},{}],589:[function(require,module,exports){
(function (process){
'use strict';

var path = require('path');
var oshomedir = require('os-homedir');
var minimist = require('minimist');
var assign = require('object-assign');
var createExplorer = require('./lib/createExplorer');

var parsedCliArgs = minimist(process.argv);

module.exports = function (moduleName, options) {
  options = assign({
    packageProp: moduleName,
    rc: '.' + moduleName + 'rc',
    js: moduleName + '.config.js',
    argv: 'config',
    rcStrictJson: false,
    stopDir: oshomedir(),
    cache: true,
  }, options);

  if (options.argv && parsedCliArgs[options.argv]) {
    options.configPath = path.resolve(parsedCliArgs[options.argv]);
  }

  return createExplorer(options);
};

}).call(this,require('_process'))
},{"./lib/createExplorer":590,"_process":16,"minimist":704,"object-assign":711,"os-homedir":714,"path":14}],590:[function(require,module,exports){
(function (process){
'use strict';

var path = require('path');
var isDir = require('is-directory');
var loadPackageProp = require('./loadPackageProp');
var loadRc = require('./loadRc');
var loadJs = require('./loadJs');
var loadDefinedFile = require('./loadDefinedFile');

module.exports = function (options) {
  // These cache Promises that resolve with results, not the results themselves
  var fileCache = (options.cache) ? new Map() : null;
  var directoryCache = (options.cache) ? new Map() : null;
  var transform = options.transform || identityPromise;

  function clearFileCache() {
    if (fileCache) fileCache.clear();
  }

  function clearDirectoryCache() {
    if (directoryCache) directoryCache.clear();
  }

  function clearCaches() {
    clearFileCache();
    clearDirectoryCache();
  }

  function load(searchPath, configPath) {
    if (!configPath && options.configPath) {
      configPath = options.configPath;
    }

    if (configPath) {
      var absoluteConfigPath = path.resolve(process.cwd(), configPath);
      if (fileCache && fileCache.has(absoluteConfigPath)) {
        return fileCache.get(absoluteConfigPath);
      }
      var result = loadDefinedFile(absoluteConfigPath, options)
        .then(transform);
      if (fileCache) fileCache.set(absoluteConfigPath, result);
      return result;
    }

    if (!searchPath) return Promise.resolve(null);

    var absoluteSearchPath = path.resolve(process.cwd(), searchPath);

    return isDirectory(absoluteSearchPath)
      .then(function (searchPathIsDirectory) {
        var directory = (searchPathIsDirectory)
          ? absoluteSearchPath
          : path.dirname(absoluteSearchPath);
        return searchDirectory(directory);
      });
  }

  function searchDirectory(directory) {
    if (directoryCache && directoryCache.has(directory)) {
      return directoryCache.get(directory);
    }

    var result = Promise.resolve()
      .then(function () {
        if (!options.packageProp) return;
        return loadPackageProp(directory, options);
      })
      .then(function (result) {
        if (result || !options.rc) return result;
        return loadRc(path.join(directory, options.rc), options);
      })
      .then(function (result) {
        if (result || !options.js) return result;
        return loadJs(path.join(directory, options.js));
      })
      .then(function (result) {
        if (result) return result;

        var splitPath = directory.split(path.sep);
        var nextDirectory = (splitPath.length > 1)
          ? splitPath.slice(0, -1).join(path.sep)
          : null;

        if (!nextDirectory || directory === options.stopDir) return null;

        return searchDirectory(nextDirectory);
      })
      .then(transform);

    if (directoryCache) directoryCache.set(directory, result);
    return result;
  }

  return {
    load: load,
    clearFileCache: clearFileCache,
    clearDirectoryCache: clearDirectoryCache,
    clearCaches: clearCaches,
  };
};

function isDirectory(filepath) {
  return new Promise(function (resolve, reject) {
    return isDir(filepath, function (err, dir) {
      if (err) return reject(err);
      return resolve(dir);
    });
  });
}

function identityPromise(x) {
  return Promise.resolve(x);
}

}).call(this,require('_process'))
},{"./loadDefinedFile":591,"./loadJs":592,"./loadPackageProp":593,"./loadRc":594,"_process":16,"is-directory":641,"path":14}],591:[function(require,module,exports){
'use strict';

var yaml = require('js-yaml');
var requireFromString = require('require-from-string');
var readFile = require('./readFile');
var parseJson = require('./parseJson');

module.exports = function (filepath, options) {
  return readFile(filepath, { throwNotFound: true }).then(function (content) {
    var parsedConfig = (function () {
      switch (options.format) {
        case 'json':
          return parseJson(content, filepath);
        case 'yaml':
          return yaml.safeLoad(content, {
            filename: filepath,
          });
        case 'js':
          return requireFromString(content, filepath);
        default:
          return tryAllParsing(content, filepath);
      }
    })();

    if (!parsedConfig) {
      throw new Error(
        'Failed to parse "' + filepath + '" as JSON, JS, or YAML.'
      );
    }

    return {
      config: parsedConfig,
      filepath: filepath,
    };
  });
};

function tryAllParsing(content, filepath) {
  return tryYaml(content, filepath, function () {
    return tryRequire(content, filepath, function () {
      return null;
    });
  });
}

function tryYaml(content, filepath, cb) {
  try {
    var result = yaml.safeLoad(content, {
      filename: filepath,
    });
    if (typeof result === 'string') {
      return cb();
    }
    return result;
  } catch (e) {
    return cb();
  }
}

function tryRequire(content, filepath, cb) {
  try {
    return requireFromString(content, filepath);
  } catch (e) {
    return cb();
  }
}

},{"./parseJson":595,"./readFile":596,"js-yaml":659,"require-from-string":850}],592:[function(require,module,exports){
'use strict';

var requireFromString = require('require-from-string');
var readFile = require('./readFile');

module.exports = function (filepath) {
  return readFile(filepath).then(function (content) {
    if (!content) return null;

    return {
      config: requireFromString(content, filepath),
      filepath: filepath,
    };
  });
};

},{"./readFile":596,"require-from-string":850}],593:[function(require,module,exports){
'use strict';

var path = require('path');
var readFile = require('./readFile');
var parseJson = require('./parseJson');

module.exports = function (packageDir, options) {
  var packagePath = path.join(packageDir, 'package.json');

  return readFile(packagePath).then(function (content) {
    if (!content) return null;
    var parsedContent = parseJson(content, packagePath);
    var packagePropValue = parsedContent[options.packageProp];
    if (!packagePropValue) return null;

    return {
      config: packagePropValue,
      filepath: packagePath,
    };
  });
};

},{"./parseJson":595,"./readFile":596,"path":14}],594:[function(require,module,exports){
'use strict';

var yaml = require('js-yaml');
var requireFromString = require('require-from-string');
var readFile = require('./readFile');
var parseJson = require('./parseJson');

module.exports = function (filepath, options) {
  return loadExtensionlessRc().then(function (result) {
    if (result) return result;
    if (options.rcExtensions) return loadRcWithExtensions();
    return null;
  });

  function loadExtensionlessRc() {
    return readRcFile().then(function (content) {
      if (!content) return null;

      var pasedConfig = (options.rcStrictJson)
        ? parseJson(content, filepath)
        : yaml.safeLoad(content, {
          filename: filepath,
        });
      return {
        config: pasedConfig,
        filepath: filepath,
      };
    });
  }

  function loadRcWithExtensions() {
    return readRcFile('json').then(function (content) {
      if (content) {
        var successFilepath = filepath + '.json';
        return {
          config: parseJson(content, successFilepath),
          filepath: successFilepath,
        };
      }
      // If not content was found in the file with extension,
      // try the next possible extension
      return readRcFile('yaml');
    }).then(function (content) {
      if (content) {
        // If the previous check returned an object with a config
        // property, then it succeeded and this step can be skipped
        if (content.config) return content;
        // If it just returned a string, then *this* check succeeded
        var successFilepath = filepath + '.yaml';
        return {
          config: yaml.safeLoad(content, { filename: successFilepath }),
          filepath: successFilepath,
        };
      }
      return readRcFile('yml');
    }).then(function (content) {
      if (content) {
        if (content.config) return content;
        var successFilepath = filepath + '.yml';
        return {
          config: yaml.safeLoad(content, { filename: successFilepath }),
          filepath: successFilepath,
        };
      }
      return readRcFile('js');
    }).then(function (content) {
      if (content) {
        if (content.config) return content;
        var successFilepath = filepath + '.js';
        return {
          config: requireFromString(content, successFilepath),
          filepath: successFilepath,
        };
      }
      return null;
    });
  }

  function readRcFile(extension) {
    var filepathWithExtension = (extension)
      ? filepath + '.' + extension
      : filepath;
    return readFile(filepathWithExtension);
  }
};

},{"./parseJson":595,"./readFile":596,"js-yaml":659,"require-from-string":850}],595:[function(require,module,exports){
'use strict';

var parseJson = require('parse-json');

module.exports = function (json, filepath) {
  try {
    return parseJson(json);
  } catch (err) {
    err.message = 'JSON Error in ' + filepath + ':\n' + err.message;
    throw err;
  }
};

},{"parse-json":716}],596:[function(require,module,exports){
'use strict';

var fs = require('fs');

module.exports = function (filepath, options) {
  options = options || {};
  options.throwNotFound = options.throwNotFound || false;

  return new Promise(function (resolve, reject) {
    fs.readFile(filepath, 'utf8', function (err, content) {
      if (err && err.code === 'ENOENT' && !options.throwNotFound) {
        return resolve(null);
      }

      if (err) return reject(err);

      resolve(content);
    });
  });
};

},{"fs":1}],597:[function(require,module,exports){
(function (process){
/**
 * This is the web browser implementation of `debug()`.
 *
 * Expose `debug()` as the module.
 */

exports = module.exports = require('./debug');
exports.log = log;
exports.formatArgs = formatArgs;
exports.save = save;
exports.load = load;
exports.useColors = useColors;
exports.storage = 'undefined' != typeof chrome
               && 'undefined' != typeof chrome.storage
                  ? chrome.storage.local
                  : localstorage();

/**
 * Colors.
 */

exports.colors = [
  'lightseagreen',
  'forestgreen',
  'goldenrod',
  'dodgerblue',
  'darkorchid',
  'crimson'
];

/**
 * Currently only WebKit-based Web Inspectors, Firefox >= v31,
 * and the Firebug extension (any Firefox version) are known
 * to support "%c" CSS customizations.
 *
 * TODO: add a `localStorage` variable to explicitly enable/disable colors
 */

function useColors() {
  // NB: In an Electron preload script, document will be defined but not fully
  // initialized. Since we know we're in Chrome, we'll just detect this case
  // explicitly
  if (typeof window !== 'undefined' && window.process && window.process.type === 'renderer') {
    return true;
  }

  // is webkit? http://stackoverflow.com/a/16459606/376773
  // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
  return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
    // is firebug? http://stackoverflow.com/a/398120/376773
    (typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
    // is firefox >= v31?
    // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
    (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
    // double check webkit in userAgent just in case we are in a worker
    (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
}

/**
 * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
 */

exports.formatters.j = function(v) {
  try {
    return JSON.stringify(v);
  } catch (err) {
    return '[UnexpectedJSONParseError]: ' + err.message;
  }
};


/**
 * Colorize log arguments if enabled.
 *
 * @api public
 */

function formatArgs(args) {
  var useColors = this.useColors;

  args[0] = (useColors ? '%c' : '')
    + this.namespace
    + (useColors ? ' %c' : ' ')
    + args[0]
    + (useColors ? '%c ' : ' ')
    + '+' + exports.humanize(this.diff);

  if (!useColors) return;

  var c = 'color: ' + this.color;
  args.splice(1, 0, c, 'color: inherit')

  // the final "%c" is somewhat tricky, because there could be other
  // arguments passed either before or after the %c, so we need to
  // figure out the correct index to insert the CSS into
  var index = 0;
  var lastC = 0;
  args[0].replace(/%[a-zA-Z%]/g, function(match) {
    if ('%%' === match) return;
    index++;
    if ('%c' === match) {
      // we only are interested in the *last* %c
      // (the user may have provided their own)
      lastC = index;
    }
  });

  args.splice(lastC, 0, c);
}

/**
 * Invokes `console.log()` when available.
 * No-op when `console.log` is not a "function".
 *
 * @api public
 */

function log() {
  // this hackery is required for IE8/9, where
  // the `console.log` function doesn't have 'apply'
  return 'object' === typeof console
    && console.log
    && Function.prototype.apply.call(console.log, console, arguments);
}

/**
 * Save `namespaces`.
 *
 * @param {String} namespaces
 * @api private
 */

function save(namespaces) {
  try {
    if (null == namespaces) {
      exports.storage.removeItem('debug');
    } else {
      exports.storage.debug = namespaces;
    }
  } catch(e) {}
}

/**
 * Load `namespaces`.
 *
 * @return {String} returns the previously persisted debug modes
 * @api private
 */

function load() {
  var r;
  try {
    r = exports.storage.debug;
  } catch(e) {}

  // If debug isn't set in LS, and we're in Electron, try to load $DEBUG
  if (!r && typeof process !== 'undefined' && 'env' in process) {
    r = process.env.DEBUG;
  }

  return r;
}

/**
 * Enable namespaces listed in `localStorage.debug` initially.
 */

exports.enable(load());

/**
 * Localstorage attempts to return the localstorage.
 *
 * This is necessary because safari throws
 * when a user disables cookies/localstorage
 * and you attempt to access it.
 *
 * @return {LocalStorage}
 * @api private
 */

function localstorage() {
  try {
    return window.localStorage;
  } catch (e) {}
}

}).call(this,require('_process'))
},{"./debug":598,"_process":16}],598:[function(require,module,exports){

/**
 * This is the common logic for both the Node.js and web browser
 * implementations of `debug()`.
 *
 * Expose `debug()` as the module.
 */

exports = module.exports = createDebug.debug = createDebug['default'] = createDebug;
exports.coerce = coerce;
exports.disable = disable;
exports.enable = enable;
exports.enabled = enabled;
exports.humanize = require('ms');

/**
 * The currently active debug mode names, and names to skip.
 */

exports.names = [];
exports.skips = [];

/**
 * Map of special "%n" handling functions, for the debug "format" argument.
 *
 * Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
 */

exports.formatters = {};

/**
 * Previous log timestamp.
 */

var prevTime;

/**
 * Select a color.
 * @param {String} namespace
 * @return {Number}
 * @api private
 */

function selectColor(namespace) {
  var hash = 0, i;

  for (i in namespace) {
    hash  = ((hash << 5) - hash) + namespace.charCodeAt(i);
    hash |= 0; // Convert to 32bit integer
  }

  return exports.colors[Math.abs(hash) % exports.colors.length];
}

/**
 * Create a debugger with the given `namespace`.
 *
 * @param {String} namespace
 * @return {Function}
 * @api public
 */

function createDebug(namespace) {

  function debug() {
    // disabled?
    if (!debug.enabled) return;

    var self = debug;

    // set `diff` timestamp
    var curr = +new Date();
    var ms = curr - (prevTime || curr);
    self.diff = ms;
    self.prev = prevTime;
    self.curr = curr;
    prevTime = curr;

    // turn the `arguments` into a proper Array
    var args = new Array(arguments.length);
    for (var i = 0; i < args.length; i++) {
      args[i] = arguments[i];
    }

    args[0] = exports.coerce(args[0]);

    if ('string' !== typeof args[0]) {
      // anything else let's inspect with %O
      args.unshift('%O');
    }

    // apply any `formatters` transformations
    var index = 0;
    args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {
      // if we encounter an escaped % then don't increase the array index
      if (match === '%%') return match;
      index++;
      var formatter = exports.formatters[format];
      if ('function' === typeof formatter) {
        var val = args[index];
        match = formatter.call(self, val);

        // now we need to remove `args[index]` since it's inlined in the `format`
        args.splice(index, 1);
        index--;
      }
      return match;
    });

    // apply env-specific formatting (colors, etc.)
    exports.formatArgs.call(self, args);

    var logFn = debug.log || exports.log || console.log.bind(console);
    logFn.apply(self, args);
  }

  debug.namespace = namespace;
  debug.enabled = exports.enabled(namespace);
  debug.useColors = exports.useColors();
  debug.color = selectColor(namespace);

  // env-specific initialization logic for debug instances
  if ('function' === typeof exports.init) {
    exports.init(debug);
  }

  return debug;
}

/**
 * Enables a debug mode by namespaces. This can include modes
 * separated by a colon and wildcards.
 *
 * @param {String} namespaces
 * @api public
 */

function enable(namespaces) {
  exports.save(namespaces);

  exports.names = [];
  exports.skips = [];

  var split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
  var len = split.length;

  for (var i = 0; i < len; i++) {
    if (!split[i]) continue; // ignore empty strings
    namespaces = split[i].replace(/\*/g, '.*?');
    if (namespaces[0] === '-') {
      exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
    } else {
      exports.names.push(new RegExp('^' + namespaces + '$'));
    }
  }
}

/**
 * Disable debug output.
 *
 * @api public
 */

function disable() {
  exports.enable('');
}

/**
 * Returns true if the given mode name is enabled, false otherwise.
 *
 * @param {String} name
 * @return {Boolean}
 * @api public
 */

function enabled(name) {
  var i, len;
  for (i = 0, len = exports.skips.length; i < len; i++) {
    if (exports.skips[i].test(name)) {
      return false;
    }
  }
  for (i = 0, len = exports.names.length; i < len; i++) {
    if (exports.names[i].test(name)) {
      return true;
    }
  }
  return false;
}

/**
 * Coerce `val`.
 *
 * @param {Mixed} val
 * @return {Mixed}
 * @api private
 */

function coerce(val) {
  if (val instanceof Error) return val.stack || val.message;
  return val;
}

},{"ms":706}],599:[function(require,module,exports){
'use strict';
var path = require('path');
var globby = require('globby');
var isPathCwd = require('is-path-cwd');
var isPathInCwd = require('is-path-in-cwd');
var objectAssign = require('object-assign');
var Promise = require('pinkie-promise');
var pify = require('pify');
var rimraf = require('rimraf');

var rimrafP = pify(rimraf, Promise);

function safeCheck(file) {
	if (isPathCwd(file)) {
		throw new Error('Cannot delete the current working directory. Can be overriden with the `force` option.');
	}

	if (!isPathInCwd(file)) {
		throw new Error('Cannot delete files/folders outside the current working directory. Can be overriden with the `force` option.');
	}
}

module.exports = function (patterns, opts) {
	opts = objectAssign({}, opts);

	var force = opts.force;
	delete opts.force;

	var dryRun = opts.dryRun;
	delete opts.dryRun;

	return globby(patterns, opts).then(function (files) {
		return Promise.all(files.map(function (file) {
			if (!force) {
				safeCheck(file);
			}

			file = path.resolve(opts.cwd || '', file);

			if (dryRun) {
				return Promise.resolve(file);
			}

			return rimrafP(file).then(function () {
				return file;
			});
		}));
	});
};

module.exports.sync = function (patterns, opts) {
	opts = objectAssign({}, opts);

	var force = opts.force;
	delete opts.force;

	var dryRun = opts.dryRun;
	delete opts.dryRun;

	return globby.sync(patterns, opts).map(function (file) {
		if (!force) {
			safeCheck(file);
		}

		file = path.resolve(opts.cwd || '', file);

		if (!dryRun) {
			rimraf.sync(file);
		}

		return file;
	});
};

},{"globby":600,"is-path-cwd":649,"is-path-in-cwd":650,"object-assign":711,"path":14,"pify":601,"pinkie-promise":722,"rimraf":852}],600:[function(require,module,exports){
'use strict';
var Promise = require('pinkie-promise');
var arrayUnion = require('array-union');
var objectAssign = require('object-assign');
var glob = require('glob');
var arrify = require('arrify');
var pify = require('pify');

var globP = pify(glob, Promise).bind(glob);

function isNegative(pattern) {
	return pattern[0] === '!';
}

function generateGlobTasks(patterns, opts) {
	var globTasks = [];

	patterns = arrify(patterns);
	opts = objectAssign({
		cache: Object.create(null),
		statCache: Object.create(null),
		realpathCache: Object.create(null),
		symlinks: Object.create(null),
		ignore: []
	}, opts);

	patterns.forEach(function (pattern, i) {
		if (isNegative(pattern)) {
			return;
		}

		var ignore = patterns.slice(i).filter(isNegative).map(function (pattern) {
			return pattern.slice(1);
		});

		globTasks.push({
			pattern: pattern,
			opts: objectAssign({}, opts, {
				ignore: opts.ignore.concat(ignore)
			})
		});
	});

	return globTasks;
}

module.exports = function (patterns, opts) {
	var globTasks = generateGlobTasks(patterns, opts);

	return Promise.all(globTasks.map(function (task) {
		return globP(task.pattern, task.opts);
	})).then(function (paths) {
		return arrayUnion.apply(null, paths);
	});
};

module.exports.sync = function (patterns, opts) {
	var globTasks = generateGlobTasks(patterns, opts);

	return globTasks.reduce(function (matches, task) {
		return arrayUnion(matches, glob.sync(task.pattern, task.opts));
	}, []);
};

module.exports.generateGlobTasks = generateGlobTasks;

},{"array-union":48,"arrify":51,"glob":622,"object-assign":711,"pify":601,"pinkie-promise":722}],601:[function(require,module,exports){
'use strict';

var processFn = function (fn, P, opts) {
	return function () {
		var that = this;
		var args = new Array(arguments.length);

		for (var i = 0; i < arguments.length; i++) {
			args[i] = arguments[i];
		}

		return new P(function (resolve, reject) {
			args.push(function (err, result) {
				if (err) {
					reject(err);
				} else if (opts.multiArgs) {
					var results = new Array(arguments.length - 1);

					for (var i = 1; i < arguments.length; i++) {
						results[i - 1] = arguments[i];
					}

					resolve(results);
				} else {
					resolve(result);
				}
			});

			fn.apply(that, args);
		});
	};
};

var pify = module.exports = function (obj, P, opts) {
	if (typeof P !== 'function') {
		opts = P;
		P = Promise;
	}

	opts = opts || {};
	opts.exclude = opts.exclude || [/.+Sync$/];

	var filter = function (key) {
		var match = function (pattern) {
			return typeof pattern === 'string' ? key === pattern : pattern.test(key);
		};

		return opts.include ? opts.include.some(match) : !opts.exclude.some(match);
	};

	var ret = typeof obj === 'function' ? function () {
		if (opts.excludeMain) {
			return obj.apply(this, arguments);
		}

		return processFn(obj, P, opts).apply(this, arguments);
	} : {};

	return Object.keys(obj).reduce(function (ret, key) {
		var x = obj[key];

		ret[key] = typeof x === 'function' && filter(key) ? processFn(x, P, opts) : x;

		return ret;
	}, ret);
};

pify.all = pify;

},{}],602:[function(require,module,exports){
module.exports = {
	"1.7": "58",
	"1.6": "56",
	"1.3": "52",
	"1.4": "53",
	"1.5": "54",
	"1.2": "51",
	"1.1": "50",
	"1.0": "49",
	"0.37": "49",
	"0.36": "47",
	"0.35": "45",
	"0.34": "45",
	"0.33": "45",
	"0.32": "45",
	"0.31": "44",
	"0.30": "44",
	"0.29": "43",
	"0.28": "43",
	"0.27": "42",
	"0.26": "42",
	"0.25": "42",
	"0.24": "41",
	"0.23": "41",
	"0.22": "41",
	"0.21": "40",
	"0.20": "39"
};
},{}],603:[function(require,module,exports){
'use strict';

var util = require('util');
var isArrayish = require('is-arrayish');

var errorEx = function errorEx(name, properties) {
	if (!name || name.constructor !== String) {
		properties = name || {};
		name = Error.name;
	}

	var errorExError = function ErrorEXError(message) {
		if (!this) {
			return new ErrorEXError(message);
		}

		message = message instanceof Error
			? message.message
			: (message || this.message);

		Error.call(this, message);
		Error.captureStackTrace(this, errorExError);

		this.name = name;

		Object.defineProperty(this, 'message', {
			configurable: true,
			enumerable: false,
			get: function () {
				var newMessage = message.split(/\r?\n/g);

				for (var key in properties) {
					if (!properties.hasOwnProperty(key)) {
						continue;
					}

					var modifier = properties[key];

					if ('message' in modifier) {
						newMessage = modifier.message(this[key], newMessage) || newMessage;
						if (!isArrayish(newMessage)) {
							newMessage = [newMessage];
						}
					}
				}

				return newMessage.join('\n');
			},
			set: function (v) {
				message = v;
			}
		});

		var stackDescriptor = Object.getOwnPropertyDescriptor(this, 'stack');
		var stackGetter = stackDescriptor.get;
		var stackValue = stackDescriptor.value;
		delete stackDescriptor.value;
		delete stackDescriptor.writable;

		stackDescriptor.get = function () {
			var stack = (stackGetter)
				? stackGetter.call(this).split(/\r?\n+/g)
				: stackValue.split(/\r?\n+/g);

			// starting in Node 7, the stack builder caches the message.
			// just replace it.
			stack[0] = this.name + ': ' + this.message;

			var lineCount = 1;
			for (var key in properties) {
				if (!properties.hasOwnProperty(key)) {
					continue;
				}

				var modifier = properties[key];

				if ('line' in modifier) {
					var line = modifier.line(this[key]);
					if (line) {
						stack.splice(lineCount++, 0, '    ' + line);
					}
				}

				if ('stack' in modifier) {
					modifier.stack(this[key], stack);
				}
			}

			return stack.join('\n');
		};

		Object.defineProperty(this, 'stack', stackDescriptor);
	};

	if (Object.setPrototypeOf) {
		Object.setPrototypeOf(errorExError.prototype, Error.prototype);
		Object.setPrototypeOf(errorExError, Error);
	} else {
		util.inherits(errorExError, Error);
	}

	return errorExError;
};

errorEx.append = function (str, def) {
	return {
		message: function (v, message) {
			v = v || def;

			if (v) {
				message[0] += ' ' + str.replace('%s', v.toString());
			}

			return message;
		}
	};
};

errorEx.line = function (str, def) {
	return {
		line: function (v) {
			v = v || def;

			if (v) {
				return str.replace('%s', v.toString());
			}

			return null;
		}
	};
};

module.exports = errorEx;

},{"is-arrayish":639,"util":42}],604:[function(require,module,exports){
'use strict';

var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;

module.exports = function (str) {
	if (typeof str !== 'string') {
		throw new TypeError('Expected a string');
	}

	return str.replace(matchOperatorsRe, '\\$&');
};

},{}],605:[function(require,module,exports){
'use strict';
var cloneRegexp = require('clone-regexp');

module.exports = function (input, str) {
	var match;
	var matches = [];
	var re = cloneRegexp(input);
	var isGlobal = re.global;

	while (match = re.exec(str)) {
		matches.push({
			match: match[0],
			sub: match.slice(1),
			index: match.index
		})

		if (!isGlobal) {
			break;
		}
	}

	return matches;
};

},{"clone-regexp":583}],606:[function(require,module,exports){
/*!
 * expand-brackets <https://github.com/jonschlinkert/expand-brackets>
 *
 * Copyright (c) 2015 Jon Schlinkert.
 * Licensed under the MIT license.
 */

'use strict';

var isPosixBracket = require('is-posix-bracket');

/**
 * POSIX character classes
 */

var POSIX = {
  alnum: 'a-zA-Z0-9',
  alpha: 'a-zA-Z',
  blank: ' \\t',
  cntrl: '\\x00-\\x1F\\x7F',
  digit: '0-9',
  graph: '\\x21-\\x7E',
  lower: 'a-z',
  print: '\\x20-\\x7E',
  punct: '-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~',
  space: ' \\t\\r\\n\\v\\f',
  upper: 'A-Z',
  word:  'A-Za-z0-9_',
  xdigit: 'A-Fa-f0-9',
};

/**
 * Expose `brackets`
 */

module.exports = brackets;

function brackets(str) {
  if (!isPosixBracket(str)) {
    return str;
  }

  var negated = false;
  if (str.indexOf('[^') !== -1) {
    negated = true;
    str = str.split('[^').join('[');
  }
  if (str.indexOf('[!') !== -1) {
    negated = true;
    str = str.split('[!').join('[');
  }

  var a = str.split('[');
  var b = str.split(']');
  var imbalanced = a.length !== b.length;

  var parts = str.split(/(?::\]\[:|\[?\[:|:\]\]?)/);
  var len = parts.length, i = 0;
  var end = '', beg = '';
  var res = [];

  // start at the end (innermost) first
  while (len--) {
    var inner = parts[i++];
    if (inner === '^[!' || inner === '[!') {
      inner = '';
      negated = true;
    }

    var prefix = negated ? '^' : '';
    var ch = POSIX[inner];

    if (ch) {
      res.push('[' + prefix + ch + ']');
    } else if (inner) {
      if (/^\[?\w-\w\]?$/.test(inner)) {
        if (i === parts.length) {
          res.push('[' + prefix + inner);
        } else if (i === 1) {
          res.push(prefix + inner + ']');
        } else {
          res.push(prefix + inner);
        }
      } else {
        if (i === 1) {
          beg += inner;
        } else if (i === parts.length) {
          end += inner;
        } else {
          res.push('[' + prefix + inner + ']');
        }
      }
    }
  }

  var result = res.join('|');
  var rlen = res.length || 1;
  if (rlen > 1) {
    result = '(?:' + result + ')';
    rlen = 1;
  }
  if (beg) {
    rlen++;
    if (beg.charAt(0) === '[') {
      if (imbalanced) {
        beg = '\\[' + beg.slice(1);
      } else {
        beg += ']';
      }
    }
    result = beg + result;
  }
  if (end) {
    rlen++;
    if (end.slice(-1) === ']') {
      if (imbalanced) {
        end = end.slice(0, end.length - 1) + '\\]';
      } else {
        end = '[' + end;
      }
    }
    result += end;
  }

  if (rlen > 1) {
    result = result.split('][').join(']|[');
    if (result.indexOf('|') !== -1 && !/\(\?/.test(result)) {
      result = '(?:' + result + ')';
    }
  }

  result = result.replace(/\[+=|=\]+/g, '\\b');
  return result;
}

brackets.makeRe = function(pattern) {
  try {
    return new RegExp(brackets(pattern));
  } catch (err) {}
};

brackets.isMatch = function(str, pattern) {
  try {
    return brackets.makeRe(pattern).test(str);
  } catch (err) {
    return false;
  }
};

brackets.match = function(arr, pattern) {
  var len = arr.length, i = 0;
  var res = arr.slice();

  var re = brackets.makeRe(pattern);
  while (i < len) {
    var ele = arr[i++];
    if (!re.test(ele)) {
      continue;
    }
    res.splice(i, 1);
  }
  return res;
};

},{"is-posix-bracket":652}],607:[function(require,module,exports){
/*!
 * expand-range <https://github.com/jonschlinkert/expand-range>
 *
 * Copyright (c) 2014-2015, Jon Schlinkert.
 * Licensed under the MIT license.
 */

'use strict';

var fill = require('fill-range');

module.exports = function expandRange(str, options, fn) {
  if (typeof str !== 'string') {
    throw new TypeError('expand-range expects a string.');
  }

  if (typeof options === 'function') {
    fn = options;
    options = {};
  }

  if (typeof options === 'boolean') {
    options = {};
    options.makeRe = true;
  }

  // create arguments to pass to fill-range
  var opts = options || {};
  var args = str.split('..');
  var len = args.length;
  if (len > 3) { return str; }

  // if only one argument, it can't expand so return it
  if (len === 1) { return args; }

  // if `true`, tell fill-range to regexify the string
  if (typeof fn === 'boolean' && fn === true) {
    opts.makeRe = true;
  }

  args.push(opts);
  return fill.apply(null, args.concat(fn));
};

},{"fill-range":611}],608:[function(require,module,exports){
/*!
 * extglob <https://github.com/jonschlinkert/extglob>
 *
 * Copyright (c) 2015, Jon Schlinkert.
 * Licensed under the MIT License.
 */

'use strict';

/**
 * Module dependencies
 */

var isExtglob = require('is-extglob');
var re, cache = {};

/**
 * Expose `extglob`
 */

module.exports = extglob;

/**
 * Convert the given extglob `string` to a regex-compatible
 * string.
 *
 * ```js
 * var extglob = require('extglob');
 * extglob('!(a?(b))');
 * //=> '(?!a(?:b)?)[^/]*?'
 * ```
 *
 * @param {String} `str` The string to convert.
 * @param {Object} `options`
 *   @option {Boolean} [options] `esc` If `false` special characters will not be escaped. Defaults to `true`.
 *   @option {Boolean} [options] `regex` If `true` a regular expression is returned instead of a string.
 * @return {String}
 * @api public
 */


function extglob(str, opts) {
  opts = opts || {};
  var o = {}, i = 0;

  // fix common character reversals
  // '*!(.js)' => '*.!(js)'
  str = str.replace(/!\(([^\w*()])/g, '$1!(');

  // support file extension negation
  str = str.replace(/([*\/])\.!\([*]\)/g, function (m, ch) {
    if (ch === '/') {
      return escape('\\/[^.]+');
    }
    return escape('[^.]+');
  });

  // create a unique key for caching by
  // combining the string and options
  var key = str
    + String(!!opts.regex)
    + String(!!opts.contains)
    + String(!!opts.escape);

  if (cache.hasOwnProperty(key)) {
    return cache[key];
  }

  if (!(re instanceof RegExp)) {
    re = regex();
  }

  opts.negate = false;
  var m;

  while (m = re.exec(str)) {
    var prefix = m[1];
    var inner = m[3];
    if (prefix === '!') {
      opts.negate = true;
    }

    var id = '__EXTGLOB_' + (i++) + '__';
    // use the prefix of the _last_ (outtermost) pattern
    o[id] = wrap(inner, prefix, opts.escape);
    str = str.split(m[0]).join(id);
  }

  var keys = Object.keys(o);
  var len = keys.length;

  // we have to loop again to allow us to convert
  // patterns in reverse order (starting with the
  // innermost/last pattern first)
  while (len--) {
    var prop = keys[len];
    str = str.split(prop).join(o[prop]);
  }

  var result = opts.regex
    ? toRegex(str, opts.contains, opts.negate)
    : str;

  result = result.split('.').join('\\.');

  // cache the result and return it
  return (cache[key] = result);
}

/**
 * Convert `string` to a regex string.
 *
 * @param  {String} `str`
 * @param  {String} `prefix` Character that determines how to wrap the string.
 * @param  {Boolean} `esc` If `false` special characters will not be escaped. Defaults to `true`.
 * @return {String}
 */

function wrap(inner, prefix, esc) {
  if (esc) inner = escape(inner);

  switch (prefix) {
    case '!':
      return '(?!' + inner + ')[^/]' + (esc ? '%%%~' : '*?');
    case '@':
      return '(?:' + inner + ')';
    case '+':
      return '(?:' + inner + ')+';
    case '*':
      return '(?:' + inner + ')' + (esc ? '%%' : '*')
    case '?':
      return '(?:' + inner + '|)';
    default:
      return inner;
  }
}

function escape(str) {
  str = str.split('*').join('[^/]%%%~');
  str = str.split('.').join('\\.');
  return str;
}

/**
 * extglob regex.
 */

function regex() {
  return /(\\?[@?!+*$]\\?)(\(([^()]*?)\))/;
}

/**
 * Negation regex
 */

function negate(str) {
  return '(?!^' + str + ').*$';
}

/**
 * Create the regex to do the matching. If
 * the leading character in the `pattern` is `!`
 * a negation regex is returned.
 *
 * @param {String} `pattern`
 * @param {Boolean} `contains` Allow loose matching.
 * @param {Boolean} `isNegated` True if the pattern is a negation pattern.
 */

function toRegex(pattern, contains, isNegated) {
  var prefix = contains ? '^' : '';
  var after = contains ? '$' : '';
  pattern = ('(?:' + pattern + ')' + after);
  if (isNegated) {
    pattern = prefix + negate(pattern);
  }
  return new RegExp(prefix + pattern);
}

},{"is-extglob":645}],609:[function(require,module,exports){
var path = require( 'path' );

module.exports = {
  createFromFile: function ( filePath ) {
    var fname = path.basename( filePath );
    var dir = path.dirname( filePath );
    return this.create( fname, dir );
  },

  create: function ( cacheId, _path ) {
    var fs = require( 'fs' );
    var flatCache = require( 'flat-cache' );
    var cache = flatCache.load( cacheId, _path );
    var assign = require( 'object-assign' );
    var normalizedEntries = { };

    var removeNotFoundFiles = function removeNotFoundFiles() {
      const cachedEntries = cache.keys();
      // remove not found entries
      cachedEntries.forEach( function remover( fPath ) {
        try {
          fs.statSync( fPath );
        } catch (err) {
          if ( err.code === 'ENOENT' ) {
            cache.removeKey( fPath );
          }
        }
      } );
    };

    removeNotFoundFiles();

    return {
      /**
       * the flat cache storage used to persist the metadata of the `files
       * @type {Object}
       */
      cache: cache,
      /**
       * Return whether or not a file has changed since last time reconcile was called.
       * @method hasFileChanged
       * @param  {String}  file  the filepath to check
       * @return {Boolean}       wheter or not the file has changed
       */
      hasFileChanged: function ( file ) {
        return this.getFileDescriptor( file ).changed;
      },

      /**
       * given an array of file paths it return and object with three arrays:
       *  - changedFiles: Files that changed since previous run
       *  - notChangedFiles: Files that haven't change
       *  - notFoundFiles: Files that were not found, probably deleted
       *
       * @param  {Array} files the files to analyze and compare to the previous seen files
       * @return {[type]}       [description]
       */
      analyzeFiles: function ( files ) {
        var me = this;
        files = files || [ ];

        var res = {
          changedFiles: [],
          notFoundFiles: [],
          notChangedFiles: []
        };

        me.normalizeEntries( files ).forEach( function ( entry ) {
          if ( entry.changed ) {
            res.changedFiles.push( entry.key );
            return;
          }
          if ( entry.notFound ) {
            res.notFoundFiles.push( entry.key );
            return;
          }
          res.notChangedFiles.push( entry.key );
        } );
        return res;
      },

      getFileDescriptor: function ( file ) {
        var meta = cache.getKey( file );
        var cacheExists = !!meta;
        var fstat;
        var me = this;

        try {
          fstat = fs.statSync( file );
        } catch (ex) {
          me.removeEntry( file );
          return { key: file, notFound: true, err: ex };
        }

        var cSize = fstat.size;
        var cTime = fstat.mtime.getTime();

        if ( !meta ) {
          meta = { size: cSize, mtime: cTime };
        } else {
          var isDifferentDate = cTime !== meta.mtime;
          var isDifferentSize = cSize !== meta.size;
        }

        var nEntry = normalizedEntries[ file ] = {
          key: file,
          changed: !cacheExists || isDifferentDate || isDifferentSize,
          meta: meta
        };

        return nEntry;
      },

      /**
       * Return the list o the files that changed compared
       * against the ones stored in the cache
       *
       * @method getUpdated
       * @param files {Array} the array of files to compare against the ones in the cache
       * @returns {Array}
       */
      getUpdatedFiles: function ( files ) {
        var me = this;
        files = files || [ ];

        return me.normalizeEntries( files ).filter( function ( entry ) {
          return entry.changed;
        } ).map( function ( entry ) {
          return entry.key;
        } );
      },

      /**
       * return the list of files
       * @method normalizeEntries
       * @param files
       * @returns {*}
       */
      normalizeEntries: function ( files ) {
        files = files || [ ];

        var me = this;
        var nEntries = files.map( function ( file ) {
          return me.getFileDescriptor( file );
        } );

        //normalizeEntries = nEntries;
        return nEntries;
      },

      /**
       * Remove an entry from the file-entry-cache. Useful to force the file to still be considered
       * modified the next time the process is run
       *
       * @method removeEntry
       * @param entryName
       */
      removeEntry: function ( entryName ) {
        delete normalizedEntries[ entryName ];
        cache.removeKey( entryName );
      },

      /**
       * Delete the cache file from the disk
       * @method deleteCacheFile
       */
      deleteCacheFile: function () {
        cache.removeCacheFile();
      },

      /**
       * remove the cache from the file and clear the memory cache
       */
      destroy: function () {
        normalizedEntries = { };
        cache.destroy();
      },
      /**
       * Sync the files and persist them to the cache
       * @method reconcile
       */
      reconcile: function () {
        removeNotFoundFiles();

        var entries = normalizedEntries;
        var keys = Object.keys( entries );

        if ( keys.length === 0 ) {
          return;
        }

        keys.forEach( function ( entryName ) {
          var cacheEntry = entries[ entryName ];

          try {
            var stat = fs.statSync( cacheEntry.key );
            var meta = assign( cacheEntry.meta, {
              size: stat.size,
              mtime: stat.mtime.getTime()
            } );

            cache.setKey( entryName, meta );
          } catch (err) {
            // if the file does not exists we don't save it
            // other errors are just thrown
            if ( err.code !== 'ENOENT' ) {
              throw err;
            }
          }
        } );

        cache.save( true );
      }
    };
  }
};

},{"flat-cache":612,"fs":1,"object-assign":711,"path":14}],610:[function(require,module,exports){
/*!
 * filename-regex <https://github.com/regexps/filename-regex>
 *
 * Copyright (c) 2014-2015, Jon Schlinkert
 * Licensed under the MIT license.
 */

module.exports = function filenameRegex() {
  return /([^\\\/]+)$/;
};

},{}],611:[function(require,module,exports){
/*!
 * fill-range <https://github.com/jonschlinkert/fill-range>
 *
 * Copyright (c) 2014-2015, Jon Schlinkert.
 * Licensed under the MIT License.
 */

'use strict';

var isObject = require('isobject');
var isNumber = require('is-number');
var randomize = require('randomatic');
var repeatStr = require('repeat-string');
var repeat = require('repeat-element');

/**
 * Expose `fillRange`
 */

module.exports = fillRange;

/**
 * Return a range of numbers or letters.
 *
 * @param  {String} `a` Start of the range
 * @param  {String} `b` End of the range
 * @param  {String} `step` Increment or decrement to use.
 * @param  {Function} `fn` Custom function to modify each element in the range.
 * @return {Array}
 */

function fillRange(a, b, step, options, fn) {
  if (a == null || b == null) {
    throw new Error('fill-range expects the first and second args to be strings.');
  }

  if (typeof step === 'function') {
    fn = step; options = {}; step = null;
  }

  if (typeof options === 'function') {
    fn = options; options = {};
  }

  if (isObject(step)) {
    options = step; step = '';
  }

  var expand, regex = false, sep = '';
  var opts = options || {};

  if (typeof opts.silent === 'undefined') {
    opts.silent = true;
  }

  step = step || opts.step;

  // store a ref to unmodified arg
  var origA = a, origB = b;

  b = (b.toString() === '-0') ? 0 : b;

  if (opts.optimize || opts.makeRe) {
    step = step ? (step += '~') : step;
    expand = true;
    regex = true;
    sep = '~';
  }

  // handle special step characters
  if (typeof step === 'string') {
    var match = stepRe().exec(step);

    if (match) {
      var i = match.index;
      var m = match[0];

      // repeat string
      if (m === '+') {
        return repeat(a, b);

      // randomize a, `b` times
      } else if (m === '?') {
        return [randomize(a, b)];

      // expand right, no regex reduction
      } else if (m === '>') {
        step = step.substr(0, i) + step.substr(i + 1);
        expand = true;

      // expand to an array, or if valid create a reduced
      // string for a regex logic `or`
      } else if (m === '|') {
        step = step.substr(0, i) + step.substr(i + 1);
        expand = true;
        regex = true;
        sep = m;

      // expand to an array, or if valid create a reduced
      // string for a regex range
      } else if (m === '~') {
        step = step.substr(0, i) + step.substr(i + 1);
        expand = true;
        regex = true;
        sep = m;
      }
    } else if (!isNumber(step)) {
      if (!opts.silent) {
        throw new TypeError('fill-range: invalid step.');
      }
      return null;
    }
  }

  if (/[.&*()[\]^%$#@!]/.test(a) || /[.&*()[\]^%$#@!]/.test(b)) {
    if (!opts.silent) {
      throw new RangeError('fill-range: invalid range arguments.');
    }
    return null;
  }

  // has neither a letter nor number, or has both letters and numbers
  // this needs to be after the step logic
  if (!noAlphaNum(a) || !noAlphaNum(b) || hasBoth(a) || hasBoth(b)) {
    if (!opts.silent) {
      throw new RangeError('fill-range: invalid range arguments.');
    }
    return null;
  }

  // validate arguments
  var isNumA = isNumber(zeros(a));
  var isNumB = isNumber(zeros(b));

  if ((!isNumA && isNumB) || (isNumA && !isNumB)) {
    if (!opts.silent) {
      throw new TypeError('fill-range: first range argument is incompatible with second.');
    }
    return null;
  }

  // by this point both are the same, so we
  // can use A to check going forward.
  var isNum = isNumA;
  var num = formatStep(step);

  // is the range alphabetical? or numeric?
  if (isNum) {
    // if numeric, coerce to an integer
    a = +a; b = +b;
  } else {
    // otherwise, get the charCode to expand alpha ranges
    a = a.charCodeAt(0);
    b = b.charCodeAt(0);
  }

  // is the pattern descending?
  var isDescending = a > b;

  // don't create a character class if the args are < 0
  if (a < 0 || b < 0) {
    expand = false;
    regex = false;
  }

  // detect padding
  var padding = isPadded(origA, origB);
  var res, pad, arr = [];
  var ii = 0;

  // character classes, ranges and logical `or`
  if (regex) {
    if (shouldExpand(a, b, num, isNum, padding, opts)) {
      // make sure the correct separator is used
      if (sep === '|' || sep === '~') {
        sep = detectSeparator(a, b, num, isNum, isDescending);
      }
      return wrap([origA, origB], sep, opts);
    }
  }

  while (isDescending ? (a >= b) : (a <= b)) {
    if (padding && isNum) {
      pad = padding(a);
    }

    // custom function
    if (typeof fn === 'function') {
      res = fn(a, isNum, pad, ii++);

    // letters
    } else if (!isNum) {
      if (regex && isInvalidChar(a)) {
        res = null;
      } else {
        res = String.fromCharCode(a);
      }

    // numbers
    } else {
      res = formatPadding(a, pad);
    }

    // add result to the array, filtering any nulled values
    if (res !== null) arr.push(res);

    // increment or decrement
    if (isDescending) {
      a -= num;
    } else {
      a += num;
    }
  }

  // now that the array is expanded, we need to handle regex
  // character classes, ranges or logical `or` that wasn't
  // already handled before the loop
  if ((regex || expand) && !opts.noexpand) {
    // make sure the correct separator is used
    if (sep === '|' || sep === '~') {
      sep = detectSeparator(a, b, num, isNum, isDescending);
    }
    if (arr.length === 1 || a < 0 || b < 0) { return arr; }
    return wrap(arr, sep, opts);
  }

  return arr;
}

/**
 * Wrap the string with the correct regex
 * syntax.
 */

function wrap(arr, sep, opts) {
  if (sep === '~') { sep = '-'; }
  var str = arr.join(sep);
  var pre = opts && opts.regexPrefix;

  // regex logical `or`
  if (sep === '|') {
    str = pre ? pre + str : str;
    str = '(' + str + ')';
  }

  // regex character class
  if (sep === '-') {
    str = (pre && pre === '^')
      ? pre + str
      : str;
    str = '[' + str + ']';
  }
  return [str];
}

/**
 * Check for invalid characters
 */

function isCharClass(a, b, step, isNum, isDescending) {
  if (isDescending) { return false; }
  if (isNum) { return a <= 9 && b <= 9; }
  if (a < b) { return step === 1; }
  return false;
}

/**
 * Detect the correct separator to use
 */

function shouldExpand(a, b, num, isNum, padding, opts) {
  if (isNum && (a > 9 || b > 9)) { return false; }
  return !padding && num === 1 && a < b;
}

/**
 * Detect the correct separator to use
 */

function detectSeparator(a, b, step, isNum, isDescending) {
  var isChar = isCharClass(a, b, step, isNum, isDescending);
  if (!isChar) {
    return '|';
  }
  return '~';
}

/**
 * Correctly format the step based on type
 */

function formatStep(step) {
  return Math.abs(step >> 0) || 1;
}

/**
 * Format padding, taking leading `-` into account
 */

function formatPadding(ch, pad) {
  var res = pad ? pad + ch : ch;
  if (pad && ch.toString().charAt(0) === '-') {
    res = '-' + pad + ch.toString().substr(1);
  }
  return res.toString();
}

/**
 * Check for invalid characters
 */

function isInvalidChar(str) {
  var ch = toStr(str);
  return ch === '\\'
    || ch === '['
    || ch === ']'
    || ch === '^'
    || ch === '('
    || ch === ')'
    || ch === '`';
}

/**
 * Convert to a string from a charCode
 */

function toStr(ch) {
  return String.fromCharCode(ch);
}


/**
 * Step regex
 */

function stepRe() {
  return /\?|>|\||\+|\~/g;
}

/**
 * Return true if `val` has either a letter
 * or a number
 */

function noAlphaNum(val) {
  return /[a-z0-9]/i.test(val);
}

/**
 * Return true if `val` has both a letter and
 * a number (invalid)
 */

function hasBoth(val) {
  return /[a-z][0-9]|[0-9][a-z]/i.test(val);
}

/**
 * Normalize zeros for checks
 */

function zeros(val) {
  if (/^-*0+$/.test(val.toString())) {
    return '0';
  }
  return val;
}

/**
 * Return true if `val` has leading zeros,
 * or a similar valid pattern.
 */

function hasZeros(val) {
  return /[^.]\.|^-*0+[0-9]/.test(val);
}

/**
 * If the string is padded, returns a curried function with
 * the a cached padding string, or `false` if no padding.
 *
 * @param  {*} `origA` String or number.
 * @return {String|Boolean}
 */

function isPadded(origA, origB) {
  if (hasZeros(origA) || hasZeros(origB)) {
    var alen = length(origA);
    var blen = length(origB);

    var len = alen >= blen
      ? alen
      : blen;

    return function (a) {
      return repeatStr('0', len - length(a));
    };
  }
  return false;
}

/**
 * Get the string length of `val`
 */

function length(val) {
  return val.toString().length;
}

},{"is-number":648,"isobject":657,"randomatic":842,"repeat-element":848,"repeat-string":849}],612:[function(require,module,exports){
(function (__dirname){
var path = require( 'path' );
var fs = require( 'graceful-fs' );
var del = require( 'del' ).sync;
var utils = require( './utils' );
var writeJSON = utils.writeJSON;

var cache = {
  /**
   * Load a cache identified by the given Id. If the element does not exists, then initialize an empty
   * cache storage. If specified `cacheDir` will be used as the directory to persist the data to. If omitted
   * then the cache module directory `./cache` will be used instead
   *
   * @method load
   * @param docId {String} the id of the cache, would also be used as the name of the file cache
   * @param [cacheDir] {String} directory for the cache entry
   */
  load: function ( docId, cacheDir ) {
    var me = this;

    me._visited = { };
    me._persisted = { };
    me._pathToFile = cacheDir ? path.resolve( cacheDir, docId ) : path.resolve( __dirname, './.cache/', docId );

    if ( fs.existsSync( me._pathToFile ) ) {
      me._persisted = utils.tryParse( me._pathToFile, { } );
    }
  },

  /**
   * Load the cache from the provided file
   * @method loadFile
   * @param  {String} pathToFile the path to the file containing the info for the cache
   */
  loadFile: function ( pathToFile ) {
    var me = this;
    var dir = path.dirname( pathToFile );
    var fName = path.basename( pathToFile );

    me.load( fName, dir );
  },

  keys: function () {
    return Object.keys( this._persisted );
  },
  /**
   * sets a key to a given value
   * @method setKey
   * @param key {string} the key to set
   * @param value {object} the value of the key. Could be any object that can be serialized with JSON.stringify
   */
  setKey: function ( key, value ) {
    this._visited[ key ] = true;
    this._persisted[ key ] = value;
  },
  /**
   * remove a given key from the cache
   * @method removeKey
   * @param key {String} the key to remove from the object
   */
  removeKey: function ( key ) {
    delete this._visited[ key ]; // esfmt-ignore-line
    delete this._persisted[ key ]; // esfmt-ignore-line
  },
  /**
   * Return the value of the provided key
   * @method getKey
   * @param key {String} the name of the key to retrieve
   * @returns {*} the value from the key
   */
  getKey: function ( key ) {
    this._visited[ key ] = true;
    return this._persisted[ key ];
  },

  /**
   * Remove keys that were not accessed/set since the
   * last time the `prune` method was called.
   * @method _prune
   * @private
   */
  _prune: function () {
    var me = this;
    var obj = { };

    var keys = Object.keys( me._visited );

    // no keys visited for either get or set value
    if ( keys.length === 0 ) {
      return;
    }

    keys.forEach( function ( key ) {
      obj[ key ] = me._persisted[ key ];
    } );

    me._visited = { };
    me._persisted = obj;
  },

  /**
   * Save the state of the cache identified by the docId to disk
   * as a JSON structure
   * @param [noPrune=false] {Boolean} whether to remove from cache the non visited files
   * @method save
   */
  save: function ( noPrune ) {
    var me = this;

    (!noPrune) && me._prune();
    writeJSON( me._pathToFile, me._persisted );
  },

  /**
   * remove the file where the cache is persisted
   * @method removeCacheFile
   * @return {Boolean} true or false if the file was successfully deleted
   */
  removeCacheFile: function () {
    return del( this._pathToFile, { force: true } );
  },
  /**
   * Destroy the file cache and cache content.
   * @method destroy
   */
  destroy: function () {
    var me = this;
    me._visited = { };
    me._persisted = { };

    me.removeCacheFile();
  }
};

module.exports = {
  /**
   * Alias for create. Should be considered depreacted. Will be removed in next releases
   *
   * @method load
   * @param docId {String} the id of the cache, would also be used as the name of the file cache
   * @param [cacheDir] {String} directory for the cache entry
   * @returns {cache} cache instance
   */
  load: function ( docId, cacheDir ) {
    return this.create( docId, cacheDir );
  },

  /**
  * Load a cache identified by the given Id. If the element does not exists, then initialize an empty
  * cache storage.
  *
  * @method create
  * @param docId {String} the id of the cache, would also be used as the name of the file cache
  * @param [cacheDir] {String} directory for the cache entry
  * @returns {cache} cache instance
  */
  create: function ( docId, cacheDir ) {
    var obj = Object.create( cache );
    obj.load( docId, cacheDir );
    return obj;
  },

  createFromFile: function ( filePath ) {
    var obj = Object.create( cache );
    obj.loadFile( filePath );
    return obj;
  },
  /**
   * Clear the cache identified by the given id. Caches stored in a different cache directory can be deleted directly
   *
   * @method clearCache
   * @param docId {String} the id of the cache, would also be used as the name of the file cache
   * @param cacheDir {String} the directory where the cache file was written
   * @returns {Boolean} true if the cache folder was deleted. False otherwise
   */
  clearCacheById: function ( docId, cacheDir ) {
    var filePath = cacheDir ? path.resolve( cacheDir, docId ) : path.resolve( __dirname, './.cache/', docId );
    return del( filePath, { force: true } ).length > 0;
  },
  /**
   * Remove all cache stored in the cache directory
   * @method clearAll
   * @returns {Boolean} true if the cache folder was deleted. False otherwise
   */
  clearAll: function ( cacheDir ) {
    var filePath = cacheDir ? path.resolve( cacheDir ) : path.resolve( __dirname, './.cache/' );
    return del( filePath, { force: true } ).length > 0;
  }
};

}).call(this,"/node_modules\\flat-cache")
},{"./utils":613,"del":599,"graceful-fs":628,"path":14}],613:[function(require,module,exports){
var fs = require( 'graceful-fs' );
var write = require( 'write' );
var circularJson = require( 'circular-json' );

module.exports = {

  tryParse: function ( filePath, defaultValue) {
    var result;
    try {
      result = this.readJSON( filePath );
    } catch (ex) {
      result = defaultValue;
    }
    return result;
  },

  /**
   * Read json file synchronously using circular-json
   *
   * @method readJSON
   * @param  {String} filePath Json filepath
   * @returns {*} parse result
   */
  readJSON: function ( filePath ) {
    return circularJson.parse( fs.readFileSync( filePath ).toString() );
  },

  /**
   * Write json file synchronously using circular-json
   *
   * @method writeJSON
   * @param  {String} filePath Json filepath
   * @param  {*} data Object to serialize
   */
  writeJSON: function (filePath, data ) {
    write.sync( filePath, circularJson.stringify( data ) );
  }

};

},{"circular-json":582,"graceful-fs":628,"write":1183}],614:[function(require,module,exports){
module.exports = function flatten(list, depth) {
  depth = (typeof depth == 'number') ? depth : Infinity;

  if (!depth) {
    if (Array.isArray(list)) {
      return list.map(function(i) { return i; });
    }
    return list;
  }

  return _flatten(list, 1);

  function _flatten(list, d) {
    return list.reduce(function (acc, item) {
      if (Array.isArray(item) && d < depth) {
        return acc.concat(_flatten(item, d + 1));
      }
      else {
        return acc.concat(item);
      }
    }, []);
  }
};

},{}],615:[function(require,module,exports){
/*!
 * for-in <https://github.com/jonschlinkert/for-in>
 *
 * Copyright (c) 2014-2017, Jon Schlinkert.
 * Released under the MIT License.
 */

'use strict';

module.exports = function forIn(obj, fn, thisArg) {
  for (var key in obj) {
    if (fn.call(thisArg, obj[key], key, obj) === false) {
      break;
    }
  }
};

},{}],616:[function(require,module,exports){
/*!
 * for-own <https://github.com/jonschlinkert/for-own>
 *
 * Copyright (c) 2014-2017, Jon Schlinkert.
 * Released under the MIT License.
 */

'use strict';

var forIn = require('for-in');
var hasOwn = Object.prototype.hasOwnProperty;

module.exports = function forOwn(obj, fn, thisArg) {
  forIn(obj, function(val, key) {
    if (hasOwn.call(obj, key)) {
      return fn.call(thisArg, obj[key], key, obj);
    }
  });
};

},{"for-in":615}],617:[function(require,module,exports){
(function (process){
module.exports = realpath
realpath.realpath = realpath
realpath.sync = realpathSync
realpath.realpathSync = realpathSync
realpath.monkeypatch = monkeypatch
realpath.unmonkeypatch = unmonkeypatch

var fs = require('fs')
var origRealpath = fs.realpath
var origRealpathSync = fs.realpathSync

var version = process.version
var ok = /^v[0-5]\./.test(version)
var old = require('./old.js')

function newError (er) {
  return er && er.syscall === 'realpath' && (
    er.code === 'ELOOP' ||
    er.code === 'ENOMEM' ||
    er.code === 'ENAMETOOLONG'
  )
}

function realpath (p, cache, cb) {
  if (ok) {
    return origRealpath(p, cache, cb)
  }

  if (typeof cache === 'function') {
    cb = cache
    cache = null
  }
  origRealpath(p, cache, function (er, result) {
    if (newError(er)) {
      old.realpath(p, cache, cb)
    } else {
      cb(er, result)
    }
  })
}

function realpathSync (p, cache) {
  if (ok) {
    return origRealpathSync(p, cache)
  }

  try {
    return origRealpathSync(p, cache)
  } catch (er) {
    if (newError(er)) {
      return old.realpathSync(p, cache)
    } else {
      throw er
    }
  }
}

function monkeypatch () {
  fs.realpath = realpath
  fs.realpathSync = realpathSync
}

function unmonkeypatch () {
  fs.realpath = origRealpath
  fs.realpathSync = origRealpathSync
}

}).call(this,require('_process'))
},{"./old.js":618,"_process":16,"fs":1}],618:[function(require,module,exports){
(function (process){
// Copyright Joyent, Inc. and other Node contributors.
//
// 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.

var pathModule = require('path');
var isWindows = process.platform === 'win32';
var fs = require('fs');

// JavaScript implementation of realpath, ported from node pre-v6

var DEBUG = process.env.NODE_DEBUG && /fs/.test(process.env.NODE_DEBUG);

function rethrow() {
  // Only enable in debug mode. A backtrace uses ~1000 bytes of heap space and
  // is fairly slow to generate.
  var callback;
  if (DEBUG) {
    var backtrace = new Error;
    callback = debugCallback;
  } else
    callback = missingCallback;

  return callback;

  function debugCallback(err) {
    if (err) {
      backtrace.message = err.message;
      err = backtrace;
      missingCallback(err);
    }
  }

  function missingCallback(err) {
    if (err) {
      if (process.throwDeprecation)
        throw err;  // Forgot a callback but don't know where? Use NODE_DEBUG=fs
      else if (!process.noDeprecation) {
        var msg = 'fs: missing callback ' + (err.stack || err.message);
        if (process.traceDeprecation)
          console.trace(msg);
        else
          console.error(msg);
      }
    }
  }
}

function maybeCallback(cb) {
  return typeof cb === 'function' ? cb : rethrow();
}

var normalize = pathModule.normalize;

// Regexp that finds the next partion of a (partial) path
// result is [base_with_slash, base], e.g. ['somedir/', 'somedir']
if (isWindows) {
  var nextPartRe = /(.*?)(?:[\/\\]+|$)/g;
} else {
  var nextPartRe = /(.*?)(?:[\/]+|$)/g;
}

// Regex to find the device root, including trailing slash. E.g. 'c:\\'.
if (isWindows) {
  var splitRootRe = /^(?:[a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/][^\\\/]+)?[\\\/]*/;
} else {
  var splitRootRe = /^[\/]*/;
}

exports.realpathSync = function realpathSync(p, cache) {
  // make p is absolute
  p = pathModule.resolve(p);

  if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
    return cache[p];
  }

  var original = p,
      seenLinks = {},
      knownHard = {};

  // current character position in p
  var pos;
  // the partial path so far, including a trailing slash if any
  var current;
  // the partial path without a trailing slash (except when pointing at a root)
  var base;
  // the partial path scanned in the previous round, with slash
  var previous;

  start();

  function start() {
    // Skip over roots
    var m = splitRootRe.exec(p);
    pos = m[0].length;
    current = m[0];
    base = m[0];
    previous = '';

    // On windows, check that the root exists. On unix there is no need.
    if (isWindows && !knownHard[base]) {
      fs.lstatSync(base);
      knownHard[base] = true;
    }
  }

  // walk down the path, swapping out linked pathparts for their real
  // values
  // NB: p.length changes.
  while (pos < p.length) {
    // find the next part
    nextPartRe.lastIndex = pos;
    var result = nextPartRe.exec(p);
    previous = current;
    current += result[0];
    base = previous + result[1];
    pos = nextPartRe.lastIndex;

    // continue if not a symlink
    if (knownHard[base] || (cache && cache[base] === base)) {
      continue;
    }

    var resolvedLink;
    if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
      // some known symbolic link.  no need to stat again.
      resolvedLink = cache[base];
    } else {
      var stat = fs.lstatSync(base);
      if (!stat.isSymbolicLink()) {
        knownHard[base] = true;
        if (cache) cache[base] = base;
        continue;
      }

      // read the link if it wasn't read before
      // dev/ino always return 0 on windows, so skip the check.
      var linkTarget = null;
      if (!isWindows) {
        var id = stat.dev.toString(32) + ':' + stat.ino.toString(32);
        if (seenLinks.hasOwnProperty(id)) {
          linkTarget = seenLinks[id];
        }
      }
      if (linkTarget === null) {
        fs.statSync(base);
        linkTarget = fs.readlinkSync(base);
      }
      resolvedLink = pathModule.resolve(previous, linkTarget);
      // track this, if given a cache.
      if (cache) cache[base] = resolvedLink;
      if (!isWindows) seenLinks[id] = linkTarget;
    }

    // resolve the link, then start over
    p = pathModule.resolve(resolvedLink, p.slice(pos));
    start();
  }

  if (cache) cache[original] = p;

  return p;
};


exports.realpath = function realpath(p, cache, cb) {
  if (typeof cb !== 'function') {
    cb = maybeCallback(cache);
    cache = null;
  }

  // make p is absolute
  p = pathModule.resolve(p);

  if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
    return process.nextTick(cb.bind(null, null, cache[p]));
  }

  var original = p,
      seenLinks = {},
      knownHard = {};

  // current character position in p
  var pos;
  // the partial path so far, including a trailing slash if any
  var current;
  // the partial path without a trailing slash (except when pointing at a root)
  var base;
  // the partial path scanned in the previous round, with slash
  var previous;

  start();

  function start() {
    // Skip over roots
    var m = splitRootRe.exec(p);
    pos = m[0].length;
    current = m[0];
    base = m[0];
    previous = '';

    // On windows, check that the root exists. On unix there is no need.
    if (isWindows && !knownHard[base]) {
      fs.lstat(base, function(err) {
        if (err) return cb(err);
        knownHard[base] = true;
        LOOP();
      });
    } else {
      process.nextTick(LOOP);
    }
  }

  // walk down the path, swapping out linked pathparts for their real
  // values
  function LOOP() {
    // stop if scanned past end of path
    if (pos >= p.length) {
      if (cache) cache[original] = p;
      return cb(null, p);
    }

    // find the next part
    nextPartRe.lastIndex = pos;
    var result = nextPartRe.exec(p);
    previous = current;
    current += result[0];
    base = previous + result[1];
    pos = nextPartRe.lastIndex;

    // continue if not a symlink
    if (knownHard[base] || (cache && cache[base] === base)) {
      return process.nextTick(LOOP);
    }

    if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
      // known symbolic link.  no need to stat again.
      return gotResolvedLink(cache[base]);
    }

    return fs.lstat(base, gotStat);
  }

  function gotStat(err, stat) {
    if (err) return cb(err);

    // if not a symlink, skip to the next path part
    if (!stat.isSymbolicLink()) {
      knownHard[base] = true;
      if (cache) cache[base] = base;
      return process.nextTick(LOOP);
    }

    // stat & read the link if not read before
    // call gotTarget as soon as the link target is known
    // dev/ino always return 0 on windows, so skip the check.
    if (!isWindows) {
      var id = stat.dev.toString(32) + ':' + stat.ino.toString(32);
      if (seenLinks.hasOwnProperty(id)) {
        return gotTarget(null, seenLinks[id], base);
      }
    }
    fs.stat(base, function(err) {
      if (err) return cb(err);

      fs.readlink(base, function(err, target) {
        if (!isWindows) seenLinks[id] = target;
        gotTarget(err, target);
      });
    });
  }

  function gotTarget(err, target, base) {
    if (err) return cb(err);

    var resolvedLink = pathModule.resolve(previous, target);
    if (cache) cache[base] = resolvedLink;
    gotResolvedLink(resolvedLink);
  }

  function gotResolvedLink(resolvedLink) {
    // resolve the link, then start over
    p = pathModule.resolve(resolvedLink, p.slice(pos));
    start();
  }
};

}).call(this,require('_process'))
},{"_process":16,"fs":1,"path":14}],619:[function(require,module,exports){
/*!
 * glob-base <https://github.com/jonschlinkert/glob-base>
 *
 * Copyright (c) 2015, Jon Schlinkert.
 * Licensed under the MIT License.
 */

'use strict';

var path = require('path');
var parent = require('glob-parent');
var isGlob = require('is-glob');

module.exports = function globBase(pattern) {
  if (typeof pattern !== 'string') {
    throw new TypeError('glob-base expects a string.');
  }

  var res = {};
  res.base = parent(pattern);
  res.isGlob = isGlob(pattern);

  if (res.base !== '.') {
    res.glob = pattern.substr(res.base.length);
    if (res.glob.charAt(0) === '/') {
      res.glob = res.glob.substr(1);
    }
  } else {
    res.glob = pattern;
  }

  if (!res.isGlob) {
    res.base = dirname(pattern);
    res.glob = res.base !== '.'
      ? pattern.substr(res.base.length)
      : pattern;
  }

  if (res.glob.substr(0, 2) === './') {
    res.glob = res.glob.substr(2);
  }
  if (res.glob.charAt(0) === '/') {
    res.glob = res.glob.substr(1);
  }
  return res;
};

function dirname(glob) {
  if (glob.slice(-1) === '/') return glob;
  return path.dirname(glob);
}

},{"glob-parent":620,"is-glob":647,"path":14}],620:[function(require,module,exports){
'use strict';

var path = require('path');
var isglob = require('is-glob');

module.exports = function globParent(str) {
	str += 'a'; // preserves full path in case of trailing path separator
	do {str = path.dirname(str)} while (isglob(str));
	return str;
};

},{"is-glob":647,"path":14}],621:[function(require,module,exports){
(function (process){
exports.alphasort = alphasort
exports.alphasorti = alphasorti
exports.setopts = setopts
exports.ownProp = ownProp
exports.makeAbs = makeAbs
exports.finish = finish
exports.mark = mark
exports.isIgnored = isIgnored
exports.childrenIgnored = childrenIgnored

function ownProp (obj, field) {
  return Object.prototype.hasOwnProperty.call(obj, field)
}

var path = require("path")
var minimatch = require("minimatch")
var isAbsolute = require("path-is-absolute")
var Minimatch = minimatch.Minimatch

function alphasorti (a, b) {
  return a.toLowerCase().localeCompare(b.toLowerCase())
}

function alphasort (a, b) {
  return a.localeCompare(b)
}

function setupIgnores (self, options) {
  self.ignore = options.ignore || []

  if (!Array.isArray(self.ignore))
    self.ignore = [self.ignore]

  if (self.ignore.length) {
    self.ignore = self.ignore.map(ignoreMap)
  }
}

// ignore patterns are always in dot:true mode.
function ignoreMap (pattern) {
  var gmatcher = null
  if (pattern.slice(-3) === '/**') {
    var gpattern = pattern.replace(/(\/\*\*)+$/, '')
    gmatcher = new Minimatch(gpattern, { dot: true })
  }

  return {
    matcher: new Minimatch(pattern, { dot: true }),
    gmatcher: gmatcher
  }
}

function setopts (self, pattern, options) {
  if (!options)
    options = {}

  // base-matching: just use globstar for that.
  if (options.matchBase && -1 === pattern.indexOf("/")) {
    if (options.noglobstar) {
      throw new Error("base matching requires globstar")
    }
    pattern = "**/" + pattern
  }

  self.silent = !!options.silent
  self.pattern = pattern
  self.strict = options.strict !== false
  self.realpath = !!options.realpath
  self.realpathCache = options.realpathCache || Object.create(null)
  self.follow = !!options.follow
  self.dot = !!options.dot
  self.mark = !!options.mark
  self.nodir = !!options.nodir
  if (self.nodir)
    self.mark = true
  self.sync = !!options.sync
  self.nounique = !!options.nounique
  self.nonull = !!options.nonull
  self.nosort = !!options.nosort
  self.nocase = !!options.nocase
  self.stat = !!options.stat
  self.noprocess = !!options.noprocess
  self.absolute = !!options.absolute

  self.maxLength = options.maxLength || Infinity
  self.cache = options.cache || Object.create(null)
  self.statCache = options.statCache || Object.create(null)
  self.symlinks = options.symlinks || Object.create(null)

  setupIgnores(self, options)

  self.changedCwd = false
  var cwd = process.cwd()
  if (!ownProp(options, "cwd"))
    self.cwd = cwd
  else {
    self.cwd = path.resolve(options.cwd)
    self.changedCwd = self.cwd !== cwd
  }

  self.root = options.root || path.resolve(self.cwd, "/")
  self.root = path.resolve(self.root)
  if (process.platform === "win32")
    self.root = self.root.replace(/\\/g, "/")

  // TODO: is an absolute `cwd` supposed to be resolved against `root`?
  // e.g. { cwd: '/test', root: __dirname } === path.join(__dirname, '/test')
  self.cwdAbs = isAbsolute(self.cwd) ? self.cwd : makeAbs(self, self.cwd)
  if (process.platform === "win32")
    self.cwdAbs = self.cwdAbs.replace(/\\/g, "/")
  self.nomount = !!options.nomount

  // disable comments and negation in Minimatch.
  // Note that they are not supported in Glob itself anyway.
  options.nonegate = true
  options.nocomment = true

  self.minimatch = new Minimatch(pattern, options)
  self.options = self.minimatch.options
}

function finish (self) {
  var nou = self.nounique
  var all = nou ? [] : Object.create(null)

  for (var i = 0, l = self.matches.length; i < l; i ++) {
    var matches = self.matches[i]
    if (!matches || Object.keys(matches).length === 0) {
      if (self.nonull) {
        // do like the shell, and spit out the literal glob
        var literal = self.minimatch.globSet[i]
        if (nou)
          all.push(literal)
        else
          all[literal] = true
      }
    } else {
      // had matches
      var m = Object.keys(matches)
      if (nou)
        all.push.apply(all, m)
      else
        m.forEach(function (m) {
          all[m] = true
        })
    }
  }

  if (!nou)
    all = Object.keys(all)

  if (!self.nosort)
    all = all.sort(self.nocase ? alphasorti : alphasort)

  // at *some* point we statted all of these
  if (self.mark) {
    for (var i = 0; i < all.length; i++) {
      all[i] = self._mark(all[i])
    }
    if (self.nodir) {
      all = all.filter(function (e) {
        var notDir = !(/\/$/.test(e))
        var c = self.cache[e] || self.cache[makeAbs(self, e)]
        if (notDir && c)
          notDir = c !== 'DIR' && !Array.isArray(c)
        return notDir
      })
    }
  }

  if (self.ignore.length)
    all = all.filter(function(m) {
      return !isIgnored(self, m)
    })

  self.found = all
}

function mark (self, p) {
  var abs = makeAbs(self, p)
  var c = self.cache[abs]
  var m = p
  if (c) {
    var isDir = c === 'DIR' || Array.isArray(c)
    var slash = p.slice(-1) === '/'

    if (isDir && !slash)
      m += '/'
    else if (!isDir && slash)
      m = m.slice(0, -1)

    if (m !== p) {
      var mabs = makeAbs(self, m)
      self.statCache[mabs] = self.statCache[abs]
      self.cache[mabs] = self.cache[abs]
    }
  }

  return m
}

// lotta situps...
function makeAbs (self, f) {
  var abs = f
  if (f.charAt(0) === '/') {
    abs = path.join(self.root, f)
  } else if (isAbsolute(f) || f === '') {
    abs = f
  } else if (self.changedCwd) {
    abs = path.resolve(self.cwd, f)
  } else {
    abs = path.resolve(f)
  }

  if (process.platform === 'win32')
    abs = abs.replace(/\\/g, '/')

  return abs
}


// Return true, if pattern ends with globstar '**', for the accompanying parent directory.
// Ex:- If node_modules/** is the pattern, add 'node_modules' to ignore list along with it's contents
function isIgnored (self, path) {
  if (!self.ignore.length)
    return false

  return self.ignore.some(function(item) {
    return item.matcher.match(path) || !!(item.gmatcher && item.gmatcher.match(path))
  })
}

function childrenIgnored (self, path) {
  if (!self.ignore.length)
    return false

  return self.ignore.some(function(item) {
    return !!(item.gmatcher && item.gmatcher.match(path))
  })
}

}).call(this,require('_process'))
},{"_process":16,"minimatch":703,"path":14,"path-is-absolute":719}],622:[function(require,module,exports){
(function (process){
// Approach:
//
// 1. Get the minimatch set
// 2. For each pattern in the set, PROCESS(pattern, false)
// 3. Store matches per-set, then uniq them
//
// PROCESS(pattern, inGlobStar)
// Get the first [n] items from pattern that are all strings
// Join these together.  This is PREFIX.
//   If there is no more remaining, then stat(PREFIX) and
//   add to matches if it succeeds.  END.
//
// If inGlobStar and PREFIX is symlink and points to dir
//   set ENTRIES = []
// else readdir(PREFIX) as ENTRIES
//   If fail, END
//
// with ENTRIES
//   If pattern[n] is GLOBSTAR
//     // handle the case where the globstar match is empty
//     // by pruning it out, and testing the resulting pattern
//     PROCESS(pattern[0..n] + pattern[n+1 .. $], false)
//     // handle other cases.
//     for ENTRY in ENTRIES (not dotfiles)
//       // attach globstar + tail onto the entry
//       // Mark that this entry is a globstar match
//       PROCESS(pattern[0..n] + ENTRY + pattern[n .. $], true)
//
//   else // not globstar
//     for ENTRY in ENTRIES (not dotfiles, unless pattern[n] is dot)
//       Test ENTRY against pattern[n]
//       If fails, continue
//       If passes, PROCESS(pattern[0..n] + item + pattern[n+1 .. $])
//
// Caveat:
//   Cache all stats and readdirs results to minimize syscall.  Since all
//   we ever care about is existence and directory-ness, we can just keep
//   `true` for files, and [children,...] for directories, or `false` for
//   things that don't exist.

module.exports = glob

var fs = require('fs')
var rp = require('fs.realpath')
var minimatch = require('minimatch')
var Minimatch = minimatch.Minimatch
var inherits = require('inherits')
var EE = require('events').EventEmitter
var path = require('path')
var assert = require('assert')
var isAbsolute = require('path-is-absolute')
var globSync = require('./sync.js')
var common = require('./common.js')
var alphasort = common.alphasort
var alphasorti = common.alphasorti
var setopts = common.setopts
var ownProp = common.ownProp
var inflight = require('inflight')
var util = require('util')
var childrenIgnored = common.childrenIgnored
var isIgnored = common.isIgnored

var once = require('once')

function glob (pattern, options, cb) {
  if (typeof options === 'function') cb = options, options = {}
  if (!options) options = {}

  if (options.sync) {
    if (cb)
      throw new TypeError('callback provided to sync glob')
    return globSync(pattern, options)
  }

  return new Glob(pattern, options, cb)
}

glob.sync = globSync
var GlobSync = glob.GlobSync = globSync.GlobSync

// old api surface
glob.glob = glob

function extend (origin, add) {
  if (add === null || typeof add !== 'object') {
    return origin
  }

  var keys = Object.keys(add)
  var i = keys.length
  while (i--) {
    origin[keys[i]] = add[keys[i]]
  }
  return origin
}

glob.hasMagic = function (pattern, options_) {
  var options = extend({}, options_)
  options.noprocess = true

  var g = new Glob(pattern, options)
  var set = g.minimatch.set

  if (!pattern)
    return false

  if (set.length > 1)
    return true

  for (var j = 0; j < set[0].length; j++) {
    if (typeof set[0][j] !== 'string')
      return true
  }

  return false
}

glob.Glob = Glob
inherits(Glob, EE)
function Glob (pattern, options, cb) {
  if (typeof options === 'function') {
    cb = options
    options = null
  }

  if (options && options.sync) {
    if (cb)
      throw new TypeError('callback provided to sync glob')
    return new GlobSync(pattern, options)
  }

  if (!(this instanceof Glob))
    return new Glob(pattern, options, cb)

  setopts(this, pattern, options)
  this._didRealPath = false

  // process each pattern in the minimatch set
  var n = this.minimatch.set.length

  // The matches are stored as {<filename>: true,...} so that
  // duplicates are automagically pruned.
  // Later, we do an Object.keys() on these.
  // Keep them as a list so we can fill in when nonull is set.
  this.matches = new Array(n)

  if (typeof cb === 'function') {
    cb = once(cb)
    this.on('error', cb)
    this.on('end', function (matches) {
      cb(null, matches)
    })
  }

  var self = this
  this._processing = 0

  this._emitQueue = []
  this._processQueue = []
  this.paused = false

  if (this.noprocess)
    return this

  if (n === 0)
    return done()

  var sync = true
  for (var i = 0; i < n; i ++) {
    this._process(this.minimatch.set[i], i, false, done)
  }
  sync = false

  function done () {
    --self._processing
    if (self._processing <= 0) {
      if (sync) {
        process.nextTick(function () {
          self._finish()
        })
      } else {
        self._finish()
      }
    }
  }
}

Glob.prototype._finish = function () {
  assert(this instanceof Glob)
  if (this.aborted)
    return

  if (this.realpath && !this._didRealpath)
    return this._realpath()

  common.finish(this)
  this.emit('end', this.found)
}

Glob.prototype._realpath = function () {
  if (this._didRealpath)
    return

  this._didRealpath = true

  var n = this.matches.length
  if (n === 0)
    return this._finish()

  var self = this
  for (var i = 0; i < this.matches.length; i++)
    this._realpathSet(i, next)

  function next () {
    if (--n === 0)
      self._finish()
  }
}

Glob.prototype._realpathSet = function (index, cb) {
  var matchset = this.matches[index]
  if (!matchset)
    return cb()

  var found = Object.keys(matchset)
  var self = this
  var n = found.length

  if (n === 0)
    return cb()

  var set = this.matches[index] = Object.create(null)
  found.forEach(function (p, i) {
    // If there's a problem with the stat, then it means that
    // one or more of the links in the realpath couldn't be
    // resolved.  just return the abs value in that case.
    p = self._makeAbs(p)
    rp.realpath(p, self.realpathCache, function (er, real) {
      if (!er)
        set[real] = true
      else if (er.syscall === 'stat')
        set[p] = true
      else
        self.emit('error', er) // srsly wtf right here

      if (--n === 0) {
        self.matches[index] = set
        cb()
      }
    })
  })
}

Glob.prototype._mark = function (p) {
  return common.mark(this, p)
}

Glob.prototype._makeAbs = function (f) {
  return common.makeAbs(this, f)
}

Glob.prototype.abort = function () {
  this.aborted = true
  this.emit('abort')
}

Glob.prototype.pause = function () {
  if (!this.paused) {
    this.paused = true
    this.emit('pause')
  }
}

Glob.prototype.resume = function () {
  if (this.paused) {
    this.emit('resume')
    this.paused = false
    if (this._emitQueue.length) {
      var eq = this._emitQueue.slice(0)
      this._emitQueue.length = 0
      for (var i = 0; i < eq.length; i ++) {
        var e = eq[i]
        this._emitMatch(e[0], e[1])
      }
    }
    if (this._processQueue.length) {
      var pq = this._processQueue.slice(0)
      this._processQueue.length = 0
      for (var i = 0; i < pq.length; i ++) {
        var p = pq[i]
        this._processing--
        this._process(p[0], p[1], p[2], p[3])
      }
    }
  }
}

Glob.prototype._process = function (pattern, index, inGlobStar, cb) {
  assert(this instanceof Glob)
  assert(typeof cb === 'function')

  if (this.aborted)
    return

  this._processing++
  if (this.paused) {
    this._processQueue.push([pattern, index, inGlobStar, cb])
    return
  }

  //console.error('PROCESS %d', this._processing, pattern)

  // Get the first [n] parts of pattern that are all strings.
  var n = 0
  while (typeof pattern[n] === 'string') {
    n ++
  }
  // now n is the index of the first one that is *not* a string.

  // see if there's anything else
  var prefix
  switch (n) {
    // if not, then this is rather simple
    case pattern.length:
      this._processSimple(pattern.join('/'), index, cb)
      return

    case 0:
      // pattern *starts* with some non-trivial item.
      // going to readdir(cwd), but not include the prefix in matches.
      prefix = null
      break

    default:
      // pattern has some string bits in the front.
      // whatever it starts with, whether that's 'absolute' like /foo/bar,
      // or 'relative' like '../baz'
      prefix = pattern.slice(0, n).join('/')
      break
  }

  var remain = pattern.slice(n)

  // get the list of entries.
  var read
  if (prefix === null)
    read = '.'
  else if (isAbsolute(prefix) || isAbsolute(pattern.join('/'))) {
    if (!prefix || !isAbsolute(prefix))
      prefix = '/' + prefix
    read = prefix
  } else
    read = prefix

  var abs = this._makeAbs(read)

  //if ignored, skip _processing
  if (childrenIgnored(this, read))
    return cb()

  var isGlobStar = remain[0] === minimatch.GLOBSTAR
  if (isGlobStar)
    this._processGlobStar(prefix, read, abs, remain, index, inGlobStar, cb)
  else
    this._processReaddir(prefix, read, abs, remain, index, inGlobStar, cb)
}

Glob.prototype._processReaddir = function (prefix, read, abs, remain, index, inGlobStar, cb) {
  var self = this
  this._readdir(abs, inGlobStar, function (er, entries) {
    return self._processReaddir2(prefix, read, abs, remain, index, inGlobStar, entries, cb)
  })
}

Glob.prototype._processReaddir2 = function (prefix, read, abs, remain, index, inGlobStar, entries, cb) {

  // if the abs isn't a dir, then nothing can match!
  if (!entries)
    return cb()

  // It will only match dot entries if it starts with a dot, or if
  // dot is set.  Stuff like @(.foo|.bar) isn't allowed.
  var pn = remain[0]
  var negate = !!this.minimatch.negate
  var rawGlob = pn._glob
  var dotOk = this.dot || rawGlob.charAt(0) === '.'

  var matchedEntries = []
  for (var i = 0; i < entries.length; i++) {
    var e = entries[i]
    if (e.charAt(0) !== '.' || dotOk) {
      var m
      if (negate && !prefix) {
        m = !e.match(pn)
      } else {
        m = e.match(pn)
      }
      if (m)
        matchedEntries.push(e)
    }
  }

  //console.error('prd2', prefix, entries, remain[0]._glob, matchedEntries)

  var len = matchedEntries.length
  // If there are no matched entries, then nothing matches.
  if (len === 0)
    return cb()

  // if this is the last remaining pattern bit, then no need for
  // an additional stat *unless* the user has specified mark or
  // stat explicitly.  We know they exist, since readdir returned
  // them.

  if (remain.length === 1 && !this.mark && !this.stat) {
    if (!this.matches[index])
      this.matches[index] = Object.create(null)

    for (var i = 0; i < len; i ++) {
      var e = matchedEntries[i]
      if (prefix) {
        if (prefix !== '/')
          e = prefix + '/' + e
        else
          e = prefix + e
      }

      if (e.charAt(0) === '/' && !this.nomount) {
        e = path.join(this.root, e)
      }
      this._emitMatch(index, e)
    }
    // This was the last one, and no stats were needed
    return cb()
  }

  // now test all matched entries as stand-ins for that part
  // of the pattern.
  remain.shift()
  for (var i = 0; i < len; i ++) {
    var e = matchedEntries[i]
    var newPattern
    if (prefix) {
      if (prefix !== '/')
        e = prefix + '/' + e
      else
        e = prefix + e
    }
    this._process([e].concat(remain), index, inGlobStar, cb)
  }
  cb()
}

Glob.prototype._emitMatch = function (index, e) {
  if (this.aborted)
    return

  if (isIgnored(this, e))
    return

  if (this.paused) {
    this._emitQueue.push([index, e])
    return
  }

  var abs = isAbsolute(e) ? e : this._makeAbs(e)

  if (this.mark)
    e = this._mark(e)

  if (this.absolute)
    e = abs

  if (this.matches[index][e])
    return

  if (this.nodir) {
    var c = this.cache[abs]
    if (c === 'DIR' || Array.isArray(c))
      return
  }

  this.matches[index][e] = true

  var st = this.statCache[abs]
  if (st)
    this.emit('stat', e, st)

  this.emit('match', e)
}

Glob.prototype._readdirInGlobStar = function (abs, cb) {
  if (this.aborted)
    return

  // follow all symlinked directories forever
  // just proceed as if this is a non-globstar situation
  if (this.follow)
    return this._readdir(abs, false, cb)

  var lstatkey = 'lstat\0' + abs
  var self = this
  var lstatcb = inflight(lstatkey, lstatcb_)

  if (lstatcb)
    fs.lstat(abs, lstatcb)

  function lstatcb_ (er, lstat) {
    if (er && er.code === 'ENOENT')
      return cb()

    var isSym = lstat && lstat.isSymbolicLink()
    self.symlinks[abs] = isSym

    // If it's not a symlink or a dir, then it's definitely a regular file.
    // don't bother doing a readdir in that case.
    if (!isSym && lstat && !lstat.isDirectory()) {
      self.cache[abs] = 'FILE'
      cb()
    } else
      self._readdir(abs, false, cb)
  }
}

Glob.prototype._readdir = function (abs, inGlobStar, cb) {
  if (this.aborted)
    return

  cb = inflight('readdir\0'+abs+'\0'+inGlobStar, cb)
  if (!cb)
    return

  //console.error('RD %j %j', +inGlobStar, abs)
  if (inGlobStar && !ownProp(this.symlinks, abs))
    return this._readdirInGlobStar(abs, cb)

  if (ownProp(this.cache, abs)) {
    var c = this.cache[abs]
    if (!c || c === 'FILE')
      return cb()

    if (Array.isArray(c))
      return cb(null, c)
  }

  var self = this
  fs.readdir(abs, readdirCb(this, abs, cb))
}

function readdirCb (self, abs, cb) {
  return function (er, entries) {
    if (er)
      self._readdirError(abs, er, cb)
    else
      self._readdirEntries(abs, entries, cb)
  }
}

Glob.prototype._readdirEntries = function (abs, entries, cb) {
  if (this.aborted)
    return

  // if we haven't asked to stat everything, then just
  // assume that everything in there exists, so we can avoid
  // having to stat it a second time.
  if (!this.mark && !this.stat) {
    for (var i = 0; i < entries.length; i ++) {
      var e = entries[i]
      if (abs === '/')
        e = abs + e
      else
        e = abs + '/' + e
      this.cache[e] = true
    }
  }

  this.cache[abs] = entries
  return cb(null, entries)
}

Glob.prototype._readdirError = function (f, er, cb) {
  if (this.aborted)
    return

  // handle errors, and cache the information
  switch (er.code) {
    case 'ENOTSUP': // https://github.com/isaacs/node-glob/issues/205
    case 'ENOTDIR': // totally normal. means it *does* exist.
      var abs = this._makeAbs(f)
      this.cache[abs] = 'FILE'
      if (abs === this.cwdAbs) {
        var error = new Error(er.code + ' invalid cwd ' + this.cwd)
        error.path = this.cwd
        error.code = er.code
        this.emit('error', error)
        this.abort()
      }
      break

    case 'ENOENT': // not terribly unusual
    case 'ELOOP':
    case 'ENAMETOOLONG':
    case 'UNKNOWN':
      this.cache[this._makeAbs(f)] = false
      break

    default: // some unusual error.  Treat as failure.
      this.cache[this._makeAbs(f)] = false
      if (this.strict) {
        this.emit('error', er)
        // If the error is handled, then we abort
        // if not, we threw out of here
        this.abort()
      }
      if (!this.silent)
        console.error('glob error', er)
      break
  }

  return cb()
}

Glob.prototype._processGlobStar = function (prefix, read, abs, remain, index, inGlobStar, cb) {
  var self = this
  this._readdir(abs, inGlobStar, function (er, entries) {
    self._processGlobStar2(prefix, read, abs, remain, index, inGlobStar, entries, cb)
  })
}


Glob.prototype._processGlobStar2 = function (prefix, read, abs, remain, index, inGlobStar, entries, cb) {
  //console.error('pgs2', prefix, remain[0], entries)

  // no entries means not a dir, so it can never have matches
  // foo.txt/** doesn't match foo.txt
  if (!entries)
    return cb()

  // test without the globstar, and with every child both below
  // and replacing the globstar.
  var remainWithoutGlobStar = remain.slice(1)
  var gspref = prefix ? [ prefix ] : []
  var noGlobStar = gspref.concat(remainWithoutGlobStar)

  // the noGlobStar pattern exits the inGlobStar state
  this._process(noGlobStar, index, false, cb)

  var isSym = this.symlinks[abs]
  var len = entries.length

  // If it's a symlink, and we're in a globstar, then stop
  if (isSym && inGlobStar)
    return cb()

  for (var i = 0; i < len; i++) {
    var e = entries[i]
    if (e.charAt(0) === '.' && !this.dot)
      continue

    // these two cases enter the inGlobStar state
    var instead = gspref.concat(entries[i], remainWithoutGlobStar)
    this._process(instead, index, true, cb)

    var below = gspref.concat(entries[i], remain)
    this._process(below, index, true, cb)
  }

  cb()
}

Glob.prototype._processSimple = function (prefix, index, cb) {
  // XXX review this.  Shouldn't it be doing the mounting etc
  // before doing stat?  kinda weird?
  var self = this
  this._stat(prefix, function (er, exists) {
    self._processSimple2(prefix, index, er, exists, cb)
  })
}
Glob.prototype._processSimple2 = function (prefix, index, er, exists, cb) {

  //console.error('ps2', prefix, exists)

  if (!this.matches[index])
    this.matches[index] = Object.create(null)

  // If it doesn't exist, then just mark the lack of results
  if (!exists)
    return cb()

  if (prefix && isAbsolute(prefix) && !this.nomount) {
    var trail = /[\/\\]$/.test(prefix)
    if (prefix.charAt(0) === '/') {
      prefix = path.join(this.root, prefix)
    } else {
      prefix = path.resolve(this.root, prefix)
      if (trail)
        prefix += '/'
    }
  }

  if (process.platform === 'win32')
    prefix = prefix.replace(/\\/g, '/')

  // Mark this as a match
  this._emitMatch(index, prefix)
  cb()
}

// Returns either 'DIR', 'FILE', or false
Glob.prototype._stat = function (f, cb) {
  var abs = this._makeAbs(f)
  var needDir = f.slice(-1) === '/'

  if (f.length > this.maxLength)
    return cb()

  if (!this.stat && ownProp(this.cache, abs)) {
    var c = this.cache[abs]

    if (Array.isArray(c))
      c = 'DIR'

    // It exists, but maybe not how we need it
    if (!needDir || c === 'DIR')
      return cb(null, c)

    if (needDir && c === 'FILE')
      return cb()

    // otherwise we have to stat, because maybe c=true
    // if we know it exists, but not what it is.
  }

  var exists
  var stat = this.statCache[abs]
  if (stat !== undefined) {
    if (stat === false)
      return cb(null, stat)
    else {
      var type = stat.isDirectory() ? 'DIR' : 'FILE'
      if (needDir && type === 'FILE')
        return cb()
      else
        return cb(null, type, stat)
    }
  }

  var self = this
  var statcb = inflight('stat\0' + abs, lstatcb_)
  if (statcb)
    fs.lstat(abs, statcb)

  function lstatcb_ (er, lstat) {
    if (lstat && lstat.isSymbolicLink()) {
      // If it's a symlink, then treat it as the target, unless
      // the target does not exist, then treat it as a file.
      return fs.stat(abs, function (er, stat) {
        if (er)
          self._stat2(f, abs, null, lstat, cb)
        else
          self._stat2(f, abs, er, stat, cb)
      })
    } else {
      self._stat2(f, abs, er, lstat, cb)
    }
  }
}

Glob.prototype._stat2 = function (f, abs, er, stat, cb) {
  if (er && (er.code === 'ENOENT' || er.code === 'ENOTDIR')) {
    this.statCache[abs] = false
    return cb()
  }

  var needDir = f.slice(-1) === '/'
  this.statCache[abs] = stat

  if (abs.slice(-1) === '/' && stat && !stat.isDirectory())
    return cb(null, false, stat)

  var c = true
  if (stat)
    c = stat.isDirectory() ? 'DIR' : 'FILE'
  this.cache[abs] = this.cache[abs] || c

  if (needDir && c === 'FILE')
    return cb()

  return cb(null, c, stat)
}

}).call(this,require('_process'))
},{"./common.js":621,"./sync.js":623,"_process":16,"assert":2,"events":8,"fs":1,"fs.realpath":617,"inflight":637,"inherits":638,"minimatch":703,"once":713,"path":14,"path-is-absolute":719,"util":42}],623:[function(require,module,exports){
(function (process){
module.exports = globSync
globSync.GlobSync = GlobSync

var fs = require('fs')
var rp = require('fs.realpath')
var minimatch = require('minimatch')
var Minimatch = minimatch.Minimatch
var Glob = require('./glob.js').Glob
var util = require('util')
var path = require('path')
var assert = require('assert')
var isAbsolute = require('path-is-absolute')
var common = require('./common.js')
var alphasort = common.alphasort
var alphasorti = common.alphasorti
var setopts = common.setopts
var ownProp = common.ownProp
var childrenIgnored = common.childrenIgnored
var isIgnored = common.isIgnored

function globSync (pattern, options) {
  if (typeof options === 'function' || arguments.length === 3)
    throw new TypeError('callback provided to sync glob\n'+
                        'See: https://github.com/isaacs/node-glob/issues/167')

  return new GlobSync(pattern, options).found
}

function GlobSync (pattern, options) {
  if (!pattern)
    throw new Error('must provide pattern')

  if (typeof options === 'function' || arguments.length === 3)
    throw new TypeError('callback provided to sync glob\n'+
                        'See: https://github.com/isaacs/node-glob/issues/167')

  if (!(this instanceof GlobSync))
    return new GlobSync(pattern, options)

  setopts(this, pattern, options)

  if (this.noprocess)
    return this

  var n = this.minimatch.set.length
  this.matches = new Array(n)
  for (var i = 0; i < n; i ++) {
    this._process(this.minimatch.set[i], i, false)
  }
  this._finish()
}

GlobSync.prototype._finish = function () {
  assert(this instanceof GlobSync)
  if (this.realpath) {
    var self = this
    this.matches.forEach(function (matchset, index) {
      var set = self.matches[index] = Object.create(null)
      for (var p in matchset) {
        try {
          p = self._makeAbs(p)
          var real = rp.realpathSync(p, self.realpathCache)
          set[real] = true
        } catch (er) {
          if (er.syscall === 'stat')
            set[self._makeAbs(p)] = true
          else
            throw er
        }
      }
    })
  }
  common.finish(this)
}


GlobSync.prototype._process = function (pattern, index, inGlobStar) {
  assert(this instanceof GlobSync)

  // Get the first [n] parts of pattern that are all strings.
  var n = 0
  while (typeof pattern[n] === 'string') {
    n ++
  }
  // now n is the index of the first one that is *not* a string.

  // See if there's anything else
  var prefix
  switch (n) {
    // if not, then this is rather simple
    case pattern.length:
      this._processSimple(pattern.join('/'), index)
      return

    case 0:
      // pattern *starts* with some non-trivial item.
      // going to readdir(cwd), but not include the prefix in matches.
      prefix = null
      break

    default:
      // pattern has some string bits in the front.
      // whatever it starts with, whether that's 'absolute' like /foo/bar,
      // or 'relative' like '../baz'
      prefix = pattern.slice(0, n).join('/')
      break
  }

  var remain = pattern.slice(n)

  // get the list of entries.
  var read
  if (prefix === null)
    read = '.'
  else if (isAbsolute(prefix) || isAbsolute(pattern.join('/'))) {
    if (!prefix || !isAbsolute(prefix))
      prefix = '/' + prefix
    read = prefix
  } else
    read = prefix

  var abs = this._makeAbs(read)

  //if ignored, skip processing
  if (childrenIgnored(this, read))
    return

  var isGlobStar = remain[0] === minimatch.GLOBSTAR
  if (isGlobStar)
    this._processGlobStar(prefix, read, abs, remain, index, inGlobStar)
  else
    this._processReaddir(prefix, read, abs, remain, index, inGlobStar)
}


GlobSync.prototype._processReaddir = function (prefix, read, abs, remain, index, inGlobStar) {
  var entries = this._readdir(abs, inGlobStar)

  // if the abs isn't a dir, then nothing can match!
  if (!entries)
    return

  // It will only match dot entries if it starts with a dot, or if
  // dot is set.  Stuff like @(.foo|.bar) isn't allowed.
  var pn = remain[0]
  var negate = !!this.minimatch.negate
  var rawGlob = pn._glob
  var dotOk = this.dot || rawGlob.charAt(0) === '.'

  var matchedEntries = []
  for (var i = 0; i < entries.length; i++) {
    var e = entries[i]
    if (e.charAt(0) !== '.' || dotOk) {
      var m
      if (negate && !prefix) {
        m = !e.match(pn)
      } else {
        m = e.match(pn)
      }
      if (m)
        matchedEntries.push(e)
    }
  }

  var len = matchedEntries.length
  // If there are no matched entries, then nothing matches.
  if (len === 0)
    return

  // if this is the last remaining pattern bit, then no need for
  // an additional stat *unless* the user has specified mark or
  // stat explicitly.  We know they exist, since readdir returned
  // them.

  if (remain.length === 1 && !this.mark && !this.stat) {
    if (!this.matches[index])
      this.matches[index] = Object.create(null)

    for (var i = 0; i < len; i ++) {
      var e = matchedEntries[i]
      if (prefix) {
        if (prefix.slice(-1) !== '/')
          e = prefix + '/' + e
        else
          e = prefix + e
      }

      if (e.charAt(0) === '/' && !this.nomount) {
        e = path.join(this.root, e)
      }
      this._emitMatch(index, e)
    }
    // This was the last one, and no stats were needed
    return
  }

  // now test all matched entries as stand-ins for that part
  // of the pattern.
  remain.shift()
  for (var i = 0; i < len; i ++) {
    var e = matchedEntries[i]
    var newPattern
    if (prefix)
      newPattern = [prefix, e]
    else
      newPattern = [e]
    this._process(newPattern.concat(remain), index, inGlobStar)
  }
}


GlobSync.prototype._emitMatch = function (index, e) {
  if (isIgnored(this, e))
    return

  var abs = this._makeAbs(e)

  if (this.mark)
    e = this._mark(e)

  if (this.absolute) {
    e = abs
  }

  if (this.matches[index][e])
    return

  if (this.nodir) {
    var c = this.cache[abs]
    if (c === 'DIR' || Array.isArray(c))
      return
  }

  this.matches[index][e] = true

  if (this.stat)
    this._stat(e)
}


GlobSync.prototype._readdirInGlobStar = function (abs) {
  // follow all symlinked directories forever
  // just proceed as if this is a non-globstar situation
  if (this.follow)
    return this._readdir(abs, false)

  var entries
  var lstat
  var stat
  try {
    lstat = fs.lstatSync(abs)
  } catch (er) {
    if (er.code === 'ENOENT') {
      // lstat failed, doesn't exist
      return null
    }
  }

  var isSym = lstat && lstat.isSymbolicLink()
  this.symlinks[abs] = isSym

  // If it's not a symlink or a dir, then it's definitely a regular file.
  // don't bother doing a readdir in that case.
  if (!isSym && lstat && !lstat.isDirectory())
    this.cache[abs] = 'FILE'
  else
    entries = this._readdir(abs, false)

  return entries
}

GlobSync.prototype._readdir = function (abs, inGlobStar) {
  var entries

  if (inGlobStar && !ownProp(this.symlinks, abs))
    return this._readdirInGlobStar(abs)

  if (ownProp(this.cache, abs)) {
    var c = this.cache[abs]
    if (!c || c === 'FILE')
      return null

    if (Array.isArray(c))
      return c
  }

  try {
    return this._readdirEntries(abs, fs.readdirSync(abs))
  } catch (er) {
    this._readdirError(abs, er)
    return null
  }
}

GlobSync.prototype._readdirEntries = function (abs, entries) {
  // if we haven't asked to stat everything, then just
  // assume that everything in there exists, so we can avoid
  // having to stat it a second time.
  if (!this.mark && !this.stat) {
    for (var i = 0; i < entries.length; i ++) {
      var e = entries[i]
      if (abs === '/')
        e = abs + e
      else
        e = abs + '/' + e
      this.cache[e] = true
    }
  }

  this.cache[abs] = entries

  // mark and cache dir-ness
  return entries
}

GlobSync.prototype._readdirError = function (f, er) {
  // handle errors, and cache the information
  switch (er.code) {
    case 'ENOTSUP': // https://github.com/isaacs/node-glob/issues/205
    case 'ENOTDIR': // totally normal. means it *does* exist.
      var abs = this._makeAbs(f)
      this.cache[abs] = 'FILE'
      if (abs === this.cwdAbs) {
        var error = new Error(er.code + ' invalid cwd ' + this.cwd)
        error.path = this.cwd
        error.code = er.code
        throw error
      }
      break

    case 'ENOENT': // not terribly unusual
    case 'ELOOP':
    case 'ENAMETOOLONG':
    case 'UNKNOWN':
      this.cache[this._makeAbs(f)] = false
      break

    default: // some unusual error.  Treat as failure.
      this.cache[this._makeAbs(f)] = false
      if (this.strict)
        throw er
      if (!this.silent)
        console.error('glob error', er)
      break
  }
}

GlobSync.prototype._processGlobStar = function (prefix, read, abs, remain, index, inGlobStar) {

  var entries = this._readdir(abs, inGlobStar)

  // no entries means not a dir, so it can never have matches
  // foo.txt/** doesn't match foo.txt
  if (!entries)
    return

  // test without the globstar, and with every child both below
  // and replacing the globstar.
  var remainWithoutGlobStar = remain.slice(1)
  var gspref = prefix ? [ prefix ] : []
  var noGlobStar = gspref.concat(remainWithoutGlobStar)

  // the noGlobStar pattern exits the inGlobStar state
  this._process(noGlobStar, index, false)

  var len = entries.length
  var isSym = this.symlinks[abs]

  // If it's a symlink, and we're in a globstar, then stop
  if (isSym && inGlobStar)
    return

  for (var i = 0; i < len; i++) {
    var e = entries[i]
    if (e.charAt(0) === '.' && !this.dot)
      continue

    // these two cases enter the inGlobStar state
    var instead = gspref.concat(entries[i], remainWithoutGlobStar)
    this._process(instead, index, true)

    var below = gspref.concat(entries[i], remain)
    this._process(below, index, true)
  }
}

GlobSync.prototype._processSimple = function (prefix, index) {
  // XXX review this.  Shouldn't it be doing the mounting etc
  // before doing stat?  kinda weird?
  var exists = this._stat(prefix)

  if (!this.matches[index])
    this.matches[index] = Object.create(null)

  // If it doesn't exist, then just mark the lack of results
  if (!exists)
    return

  if (prefix && isAbsolute(prefix) && !this.nomount) {
    var trail = /[\/\\]$/.test(prefix)
    if (prefix.charAt(0) === '/') {
      prefix = path.join(this.root, prefix)
    } else {
      prefix = path.resolve(this.root, prefix)
      if (trail)
        prefix += '/'
    }
  }

  if (process.platform === 'win32')
    prefix = prefix.replace(/\\/g, '/')

  // Mark this as a match
  this._emitMatch(index, prefix)
}

// Returns either 'DIR', 'FILE', or false
GlobSync.prototype._stat = function (f) {
  var abs = this._makeAbs(f)
  var needDir = f.slice(-1) === '/'

  if (f.length > this.maxLength)
    return false

  if (!this.stat && ownProp(this.cache, abs)) {
    var c = this.cache[abs]

    if (Array.isArray(c))
      c = 'DIR'

    // It exists, but maybe not how we need it
    if (!needDir || c === 'DIR')
      return c

    if (needDir && c === 'FILE')
      return false

    // otherwise we have to stat, because maybe c=true
    // if we know it exists, but not what it is.
  }

  var exists
  var stat = this.statCache[abs]
  if (!stat) {
    var lstat
    try {
      lstat = fs.lstatSync(abs)
    } catch (er) {
      if (er && (er.code === 'ENOENT' || er.code === 'ENOTDIR')) {
        this.statCache[abs] = false
        return false
      }
    }

    if (lstat && lstat.isSymbolicLink()) {
      try {
        stat = fs.statSync(abs)
      } catch (er) {
        stat = lstat
      }
    } else {
      stat = lstat
    }
  }

  this.statCache[abs] = stat

  var c = true
  if (stat)
    c = stat.isDirectory() ? 'DIR' : 'FILE'

  this.cache[abs] = this.cache[abs] || c

  if (needDir && c === 'FILE')
    return false

  return c
}

GlobSync.prototype._mark = function (p) {
  return common.mark(this, p)
}

GlobSync.prototype._makeAbs = function (f) {
  return common.makeAbs(this, f)
}

}).call(this,require('_process'))
},{"./common.js":621,"./glob.js":622,"_process":16,"assert":2,"fs":1,"fs.realpath":617,"minimatch":703,"path":14,"path-is-absolute":719,"util":42}],624:[function(require,module,exports){
'use strict';
var Promise = require('pinkie-promise');
var arrayUnion = require('array-union');
var objectAssign = require('object-assign');
var glob = require('glob');
var pify = require('pify');

var globP = pify(glob, Promise).bind(glob);

function isNegative(pattern) {
	return pattern[0] === '!';
}

function isString(value) {
	return typeof value === 'string';
}

function assertPatternsInput(patterns) {
	if (!patterns.every(isString)) {
		throw new TypeError('patterns must be a string or an array of strings');
	}
}

function generateGlobTasks(patterns, opts) {
	patterns = [].concat(patterns);
	assertPatternsInput(patterns);

	var globTasks = [];

	opts = objectAssign({
		cache: Object.create(null),
		statCache: Object.create(null),
		realpathCache: Object.create(null),
		symlinks: Object.create(null),
		ignore: []
	}, opts);

	patterns.forEach(function (pattern, i) {
		if (isNegative(pattern)) {
			return;
		}

		var ignore = patterns.slice(i).filter(isNegative).map(function (pattern) {
			return pattern.slice(1);
		});

		globTasks.push({
			pattern: pattern,
			opts: objectAssign({}, opts, {
				ignore: opts.ignore.concat(ignore)
			})
		});
	});

	return globTasks;
}

module.exports = function (patterns, opts) {
	var globTasks;

	try {
		globTasks = generateGlobTasks(patterns, opts);
	} catch (err) {
		return Promise.reject(err);
	}

	return Promise.all(globTasks.map(function (task) {
		return globP(task.pattern, task.opts);
	})).then(function (paths) {
		return arrayUnion.apply(null, paths);
	});
};

module.exports.sync = function (patterns, opts) {
	var globTasks = generateGlobTasks(patterns, opts);

	return globTasks.reduce(function (matches, task) {
		return arrayUnion(matches, glob.sync(task.pattern, task.opts));
	}, []);
};

module.exports.generateGlobTasks = generateGlobTasks;

module.exports.hasMagic = function (patterns, opts) {
	return [].concat(patterns).some(function (pattern) {
		return glob.hasMagic(pattern, opts);
	});
};

},{"array-union":48,"glob":622,"object-assign":711,"pify":625,"pinkie-promise":722}],625:[function(require,module,exports){
arguments[4][601][0].apply(exports,arguments)
},{"dup":601}],626:[function(require,module,exports){
'use strict';

var Path = require('path');
var slice = Array.prototype.slice;

function join(/* globs */) {
	var args;

	args = slice.call(arguments, 0);
	return args.reduce(function (result, globs) {
		return _apply(result, function (path) {
			return _apply(globs, function (glob) {
				return _join(path, glob);
			});
		});
	}, '');
}

function _apply(values, fn) {
	if (Array.isArray(values)) {
		return values.reduce(function (result, value) {
			return result.concat(fn(value));
		}, []);
	}
	return fn(values);
}

function _join(path, glob) {
	var negative, positive;

	if (glob[0] === '!') {
		positive = glob.substr(1);
		if (path[0] === '!') {
			negative = '';
		} else {
			negative = '!';
		}
		return negative + Path.join(path, positive);
	}
	return Path.join(path, glob);
}

module.exports = join;

},{"path":14}],627:[function(require,module,exports){
'use strict'

var fs = require('fs')

module.exports = clone(fs)

function clone (obj) {
  if (obj === null || typeof obj !== 'object')
    return obj

  if (obj instanceof Object)
    var copy = { __proto__: obj.__proto__ }
  else
    var copy = Object.create(null)

  Object.getOwnPropertyNames(obj).forEach(function (key) {
    Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key))
  })

  return copy
}

},{"fs":1}],628:[function(require,module,exports){
(function (process){
var fs = require('fs')
var polyfills = require('./polyfills.js')
var legacy = require('./legacy-streams.js')
var queue = []

var util = require('util')

function noop () {}

var debug = noop
if (util.debuglog)
  debug = util.debuglog('gfs4')
else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ''))
  debug = function() {
    var m = util.format.apply(util, arguments)
    m = 'GFS4: ' + m.split(/\n/).join('\nGFS4: ')
    console.error(m)
  }

if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) {
  process.on('exit', function() {
    debug(queue)
    require('assert').equal(queue.length, 0)
  })
}

module.exports = patch(require('./fs.js'))
if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH) {
  module.exports = patch(fs)
}

// Always patch fs.close/closeSync, because we want to
// retry() whenever a close happens *anywhere* in the program.
// This is essential when multiple graceful-fs instances are
// in play at the same time.
module.exports.close =
fs.close = (function (fs$close) { return function (fd, cb) {
  return fs$close.call(fs, fd, function (err) {
    if (!err)
      retry()

    if (typeof cb === 'function')
      cb.apply(this, arguments)
  })
}})(fs.close)

module.exports.closeSync =
fs.closeSync = (function (fs$closeSync) { return function (fd) {
  // Note that graceful-fs also retries when fs.closeSync() fails.
  // Looks like a bug to me, although it's probably a harmless one.
  var rval = fs$closeSync.apply(fs, arguments)
  retry()
  return rval
}})(fs.closeSync)

function patch (fs) {
  // Everything that references the open() function needs to be in here
  polyfills(fs)
  fs.gracefulify = patch
  fs.FileReadStream = ReadStream;  // Legacy name.
  fs.FileWriteStream = WriteStream;  // Legacy name.
  fs.createReadStream = createReadStream
  fs.createWriteStream = createWriteStream
  var fs$readFile = fs.readFile
  fs.readFile = readFile
  function readFile (path, options, cb) {
    if (typeof options === 'function')
      cb = options, options = null

    return go$readFile(path, options, cb)

    function go$readFile (path, options, cb) {
      return fs$readFile(path, options, function (err) {
        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
          enqueue([go$readFile, [path, options, cb]])
        else {
          if (typeof cb === 'function')
            cb.apply(this, arguments)
          retry()
        }
      })
    }
  }

  var fs$writeFile = fs.writeFile
  fs.writeFile = writeFile
  function writeFile (path, data, options, cb) {
    if (typeof options === 'function')
      cb = options, options = null

    return go$writeFile(path, data, options, cb)

    function go$writeFile (path, data, options, cb) {
      return fs$writeFile(path, data, options, function (err) {
        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
          enqueue([go$writeFile, [path, data, options, cb]])
        else {
          if (typeof cb === 'function')
            cb.apply(this, arguments)
          retry()
        }
      })
    }
  }

  var fs$appendFile = fs.appendFile
  if (fs$appendFile)
    fs.appendFile = appendFile
  function appendFile (path, data, options, cb) {
    if (typeof options === 'function')
      cb = options, options = null

    return go$appendFile(path, data, options, cb)

    function go$appendFile (path, data, options, cb) {
      return fs$appendFile(path, data, options, function (err) {
        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
          enqueue([go$appendFile, [path, data, options, cb]])
        else {
          if (typeof cb === 'function')
            cb.apply(this, arguments)
          retry()
        }
      })
    }
  }

  var fs$readdir = fs.readdir
  fs.readdir = readdir
  function readdir (path, options, cb) {
    var args = [path]
    if (typeof options !== 'function') {
      args.push(options)
    } else {
      cb = options
    }
    args.push(go$readdir$cb)

    return go$readdir(args)

    function go$readdir$cb (err, files) {
      if (files && files.sort)
        files.sort()

      if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
        enqueue([go$readdir, [args]])
      else {
        if (typeof cb === 'function')
          cb.apply(this, arguments)
        retry()
      }
    }
  }

  function go$readdir (args) {
    return fs$readdir.apply(fs, args)
  }

  if (process.version.substr(0, 4) === 'v0.8') {
    var legStreams = legacy(fs)
    ReadStream = legStreams.ReadStream
    WriteStream = legStreams.WriteStream
  }

  var fs$ReadStream = fs.ReadStream
  ReadStream.prototype = Object.create(fs$ReadStream.prototype)
  ReadStream.prototype.open = ReadStream$open

  var fs$WriteStream = fs.WriteStream
  WriteStream.prototype = Object.create(fs$WriteStream.prototype)
  WriteStream.prototype.open = WriteStream$open

  fs.ReadStream = ReadStream
  fs.WriteStream = WriteStream

  function ReadStream (path, options) {
    if (this instanceof ReadStream)
      return fs$ReadStream.apply(this, arguments), this
    else
      return ReadStream.apply(Object.create(ReadStream.prototype), arguments)
  }

  function ReadStream$open () {
    var that = this
    open(that.path, that.flags, that.mode, function (err, fd) {
      if (err) {
        if (that.autoClose)
          that.destroy()

        that.emit('error', err)
      } else {
        that.fd = fd
        that.emit('open', fd)
        that.read()
      }
    })
  }

  function WriteStream (path, options) {
    if (this instanceof WriteStream)
      return fs$WriteStream.apply(this, arguments), this
    else
      return WriteStream.apply(Object.create(WriteStream.prototype), arguments)
  }

  function WriteStream$open () {
    var that = this
    open(that.path, that.flags, that.mode, function (err, fd) {
      if (err) {
        that.destroy()
        that.emit('error', err)
      } else {
        that.fd = fd
        that.emit('open', fd)
      }
    })
  }

  function createReadStream (path, options) {
    return new ReadStream(path, options)
  }

  function createWriteStream (path, options) {
    return new WriteStream(path, options)
  }

  var fs$open = fs.open
  fs.open = open
  function open (path, flags, mode, cb) {
    if (typeof mode === 'function')
      cb = mode, mode = null

    return go$open(path, flags, mode, cb)

    function go$open (path, flags, mode, cb) {
      return fs$open(path, flags, mode, function (err, fd) {
        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
          enqueue([go$open, [path, flags, mode, cb]])
        else {
          if (typeof cb === 'function')
            cb.apply(this, arguments)
          retry()
        }
      })
    }
  }

  return fs
}

function enqueue (elem) {
  debug('ENQUEUE', elem[0].name, elem[1])
  queue.push(elem)
}

function retry () {
  var elem = queue.shift()
  if (elem) {
    debug('RETRY', elem[0].name, elem[1])
    elem[0].apply(null, elem[1])
  }
}

}).call(this,require('_process'))
},{"./fs.js":627,"./legacy-streams.js":629,"./polyfills.js":630,"_process":16,"assert":2,"fs":1,"util":42}],629:[function(require,module,exports){
(function (process){
var Stream = require('stream').Stream

module.exports = legacy

function legacy (fs) {
  return {
    ReadStream: ReadStream,
    WriteStream: WriteStream
  }

  function ReadStream (path, options) {
    if (!(this instanceof ReadStream)) return new ReadStream(path, options);

    Stream.call(this);

    var self = this;

    this.path = path;
    this.fd = null;
    this.readable = true;
    this.paused = false;

    this.flags = 'r';
    this.mode = 438; /*=0666*/
    this.bufferSize = 64 * 1024;

    options = options || {};

    // Mixin options into this
    var keys = Object.keys(options);
    for (var index = 0, length = keys.length; index < length; index++) {
      var key = keys[index];
      this[key] = options[key];
    }

    if (this.encoding) this.setEncoding(this.encoding);

    if (this.start !== undefined) {
      if ('number' !== typeof this.start) {
        throw TypeError('start must be a Number');
      }
      if (this.end === undefined) {
        this.end = Infinity;
      } else if ('number' !== typeof this.end) {
        throw TypeError('end must be a Number');
      }

      if (this.start > this.end) {
        throw new Error('start must be <= end');
      }

      this.pos = this.start;
    }

    if (this.fd !== null) {
      process.nextTick(function() {
        self._read();
      });
      return;
    }

    fs.open(this.path, this.flags, this.mode, function (err, fd) {
      if (err) {
        self.emit('error', err);
        self.readable = false;
        return;
      }

      self.fd = fd;
      self.emit('open', fd);
      self._read();
    })
  }

  function WriteStream (path, options) {
    if (!(this instanceof WriteStream)) return new WriteStream(path, options);

    Stream.call(this);

    this.path = path;
    this.fd = null;
    this.writable = true;

    this.flags = 'w';
    this.encoding = 'binary';
    this.mode = 438; /*=0666*/
    this.bytesWritten = 0;

    options = options || {};

    // Mixin options into this
    var keys = Object.keys(options);
    for (var index = 0, length = keys.length; index < length; index++) {
      var key = keys[index];
      this[key] = options[key];
    }

    if (this.start !== undefined) {
      if ('number' !== typeof this.start) {
        throw TypeError('start must be a Number');
      }
      if (this.start < 0) {
        throw new Error('start must be >= zero');
      }

      this.pos = this.start;
    }

    this.busy = false;
    this._queue = [];

    if (this.fd === null) {
      this._open = fs.open;
      this._queue.push([this._open, this.path, this.flags, this.mode, undefined]);
      this.flush();
    }
  }
}

}).call(this,require('_process'))
},{"_process":16,"stream":35}],630:[function(require,module,exports){
(function (process){
var fs = require('./fs.js')
var constants = require('constants')

var origCwd = process.cwd
var cwd = null

var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform

process.cwd = function() {
  if (!cwd)
    cwd = origCwd.call(process)
  return cwd
}
try {
  process.cwd()
} catch (er) {}

var chdir = process.chdir
process.chdir = function(d) {
  cwd = null
  chdir.call(process, d)
}

module.exports = patch

function patch (fs) {
  // (re-)implement some things that are known busted or missing.

  // lchmod, broken prior to 0.6.2
  // back-port the fix here.
  if (constants.hasOwnProperty('O_SYMLINK') &&
      process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
    patchLchmod(fs)
  }

  // lutimes implementation, or no-op
  if (!fs.lutimes) {
    patchLutimes(fs)
  }

  // https://github.com/isaacs/node-graceful-fs/issues/4
  // Chown should not fail on einval or eperm if non-root.
  // It should not fail on enosys ever, as this just indicates
  // that a fs doesn't support the intended operation.

  fs.chown = chownFix(fs.chown)
  fs.fchown = chownFix(fs.fchown)
  fs.lchown = chownFix(fs.lchown)

  fs.chmod = chmodFix(fs.chmod)
  fs.fchmod = chmodFix(fs.fchmod)
  fs.lchmod = chmodFix(fs.lchmod)

  fs.chownSync = chownFixSync(fs.chownSync)
  fs.fchownSync = chownFixSync(fs.fchownSync)
  fs.lchownSync = chownFixSync(fs.lchownSync)

  fs.chmodSync = chmodFixSync(fs.chmodSync)
  fs.fchmodSync = chmodFixSync(fs.fchmodSync)
  fs.lchmodSync = chmodFixSync(fs.lchmodSync)

  fs.stat = statFix(fs.stat)
  fs.fstat = statFix(fs.fstat)
  fs.lstat = statFix(fs.lstat)

  fs.statSync = statFixSync(fs.statSync)
  fs.fstatSync = statFixSync(fs.fstatSync)
  fs.lstatSync = statFixSync(fs.lstatSync)

  // if lchmod/lchown do not exist, then make them no-ops
  if (!fs.lchmod) {
    fs.lchmod = function (path, mode, cb) {
      if (cb) process.nextTick(cb)
    }
    fs.lchmodSync = function () {}
  }
  if (!fs.lchown) {
    fs.lchown = function (path, uid, gid, cb) {
      if (cb) process.nextTick(cb)
    }
    fs.lchownSync = function () {}
  }

  // on Windows, A/V software can lock the directory, causing this
  // to fail with an EACCES or EPERM if the directory contains newly
  // created files.  Try again on failure, for up to 60 seconds.

  // Set the timeout this long because some Windows Anti-Virus, such as Parity
  // bit9, may lock files for up to a minute, causing npm package install
  // failures. Also, take care to yield the scheduler. Windows scheduling gives
  // CPU to a busy looping process, which can cause the program causing the lock
  // contention to be starved of CPU by node, so the contention doesn't resolve.
  if (platform === "win32") {
    fs.rename = (function (fs$rename) { return function (from, to, cb) {
      var start = Date.now()
      var backoff = 0;
      fs$rename(from, to, function CB (er) {
        if (er
            && (er.code === "EACCES" || er.code === "EPERM")
            && Date.now() - start < 60000) {
          setTimeout(function() {
            fs.stat(to, function (stater, st) {
              if (stater && stater.code === "ENOENT")
                fs$rename(from, to, CB);
              else
                cb(er)
            })
          }, backoff)
          if (backoff < 100)
            backoff += 10;
          return;
        }
        if (cb) cb(er)
      })
    }})(fs.rename)
  }

  // if read() returns EAGAIN, then just try it again.
  fs.read = (function (fs$read) { return function (fd, buffer, offset, length, position, callback_) {
    var callback
    if (callback_ && typeof callback_ === 'function') {
      var eagCounter = 0
      callback = function (er, _, __) {
        if (er && er.code === 'EAGAIN' && eagCounter < 10) {
          eagCounter ++
          return fs$read.call(fs, fd, buffer, offset, length, position, callback)
        }
        callback_.apply(this, arguments)
      }
    }
    return fs$read.call(fs, fd, buffer, offset, length, position, callback)
  }})(fs.read)

  fs.readSync = (function (fs$readSync) { return function (fd, buffer, offset, length, position) {
    var eagCounter = 0
    while (true) {
      try {
        return fs$readSync.call(fs, fd, buffer, offset, length, position)
      } catch (er) {
        if (er.code === 'EAGAIN' && eagCounter < 10) {
          eagCounter ++
          continue
        }
        throw er
      }
    }
  }})(fs.readSync)
}

function patchLchmod (fs) {
  fs.lchmod = function (path, mode, callback) {
    fs.open( path
           , constants.O_WRONLY | constants.O_SYMLINK
           , mode
           , function (err, fd) {
      if (err) {
        if (callback) callback(err)
        return
      }
      // prefer to return the chmod error, if one occurs,
      // but still try to close, and report closing errors if they occur.
      fs.fchmod(fd, mode, function (err) {
        fs.close(fd, function(err2) {
          if (callback) callback(err || err2)
        })
      })
    })
  }

  fs.lchmodSync = function (path, mode) {
    var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode)

    // prefer to return the chmod error, if one occurs,
    // but still try to close, and report closing errors if they occur.
    var threw = true
    var ret
    try {
      ret = fs.fchmodSync(fd, mode)
      threw = false
    } finally {
      if (threw) {
        try {
          fs.closeSync(fd)
        } catch (er) {}
      } else {
        fs.closeSync(fd)
      }
    }
    return ret
  }
}

function patchLutimes (fs) {
  if (constants.hasOwnProperty("O_SYMLINK")) {
    fs.lutimes = function (path, at, mt, cb) {
      fs.open(path, constants.O_SYMLINK, function (er, fd) {
        if (er) {
          if (cb) cb(er)
          return
        }
        fs.futimes(fd, at, mt, function (er) {
          fs.close(fd, function (er2) {
            if (cb) cb(er || er2)
          })
        })
      })
    }

    fs.lutimesSync = function (path, at, mt) {
      var fd = fs.openSync(path, constants.O_SYMLINK)
      var ret
      var threw = true
      try {
        ret = fs.futimesSync(fd, at, mt)
        threw = false
      } finally {
        if (threw) {
          try {
            fs.closeSync(fd)
          } catch (er) {}
        } else {
          fs.closeSync(fd)
        }
      }
      return ret
    }

  } else {
    fs.lutimes = function (_a, _b, _c, cb) { if (cb) process.nextTick(cb) }
    fs.lutimesSync = function () {}
  }
}

function chmodFix (orig) {
  if (!orig) return orig
  return function (target, mode, cb) {
    return orig.call(fs, target, mode, function (er) {
      if (chownErOk(er)) er = null
      if (cb) cb.apply(this, arguments)
    })
  }
}

function chmodFixSync (orig) {
  if (!orig) return orig
  return function (target, mode) {
    try {
      return orig.call(fs, target, mode)
    } catch (er) {
      if (!chownErOk(er)) throw er
    }
  }
}


function chownFix (orig) {
  if (!orig) return orig
  return function (target, uid, gid, cb) {
    return orig.call(fs, target, uid, gid, function (er) {
      if (chownErOk(er)) er = null
      if (cb) cb.apply(this, arguments)
    })
  }
}

function chownFixSync (orig) {
  if (!orig) return orig
  return function (target, uid, gid) {
    try {
      return orig.call(fs, target, uid, gid)
    } catch (er) {
      if (!chownErOk(er)) throw er
    }
  }
}


function statFix (orig) {
  if (!orig) return orig
  // Older versions of Node erroneously returned signed integers for
  // uid + gid.
  return function (target, cb) {
    return orig.call(fs, target, function (er, stats) {
      if (!stats) return cb.apply(this, arguments)
      if (stats.uid < 0) stats.uid += 0x100000000
      if (stats.gid < 0) stats.gid += 0x100000000
      if (cb) cb.apply(this, arguments)
    })
  }
}

function statFixSync (orig) {
  if (!orig) return orig
  // Older versions of Node erroneously returned signed integers for
  // uid + gid.
  return function (target) {
    var stats = orig.call(fs, target)
    if (stats.uid < 0) stats.uid += 0x100000000
    if (stats.gid < 0) stats.gid += 0x100000000
    return stats;
  }
}

// ENOSYS means that the fs doesn't support the op. Just ignore
// that, because it doesn't matter.
//
// if there's no getuid, or if getuid() is something other
// than 0, and the error is EINVAL or EPERM, then just ignore
// it.
//
// This specific case is a silent failure in cp, install, tar,
// and most other unix tools that manage permissions.
//
// When running as root, or if other types of errors are
// encountered, then it's strict.
function chownErOk (er) {
  if (!er)
    return true

  if (er.code === "ENOSYS")
    return true

  var nonroot = !process.getuid || process.getuid() !== 0
  if (nonroot) {
    if (er.code === "EINVAL" || er.code === "EPERM")
      return true
  }

  return false
}

}).call(this,require('_process'))
},{"./fs.js":627,"_process":16,"constants":6}],631:[function(require,module,exports){
'use strict';
var ansiRegex = require('ansi-regex');
var re = new RegExp(ansiRegex().source); // remove the `g` flag
module.exports = re.test.bind(re);

},{"ansi-regex":44}],632:[function(require,module,exports){
module.exports=[
	"a",
	"abbr",
	"address",
	"area",
	"article",
	"aside",
	"audio",
	"b",
	"base",
	"bdi",
	"bdo",
	"blockquote",
	"body",
	"br",
	"button",
	"canvas",
	"caption",
	"cite",
	"code",
	"col",
	"colgroup",
	"data",
	"datalist",
	"dd",
	"del",
	"details",
	"dfn",
	"dialog",
	"div",
	"dl",
	"dt",
	"em",
	"embed",
	"fieldset",
	"figcaption",
	"figure",
	"footer",
	"form",
	"h1",
	"h2",
	"h3",
	"h4",
	"h5",
	"h6",
	"head",
	"header",
	"hgroup",
	"hr",
	"html",
	"i",
	"iframe",
	"img",
	"input",
	"ins",
	"kbd",
	"keygen",
	"label",
	"legend",
	"li",
	"link",
	"main",
	"map",
	"mark",
	"math",
	"menu",
	"menuitem",
	"meta",
	"meter",
	"nav",
	"noscript",
	"object",
	"ol",
	"optgroup",
	"option",
	"output",
	"p",
	"param",
	"picture",
	"pre",
	"progress",
	"q",
	"rb",
	"rp",
	"rt",
	"rtc",
	"ruby",
	"s",
	"samp",
	"script",
	"section",
	"select",
	"slot",
	"small",
	"source",
	"span",
	"strong",
	"style",
	"sub",
	"summary",
	"sup",
	"svg",
	"table",
	"tbody",
	"td",
	"template",
	"textarea",
	"tfoot",
	"th",
	"thead",
	"time",
	"title",
	"tr",
	"track",
	"u",
	"ul",
	"var",
	"video",
	"wbr"
]

},{}],633:[function(require,module,exports){
'use strict';
module.exports = require('./html-tags.json');

},{"./html-tags.json":632}],634:[function(require,module,exports){
(function (process){
'use strict';

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

module.exports = function () {
  return new IgnoreBase();
};

// A simple implementation of make-array
function make_array(subject) {
  return Array.isArray(subject) ? subject : [subject];
}

var REGEX_BLANK_LINE = /^\s+$/;
var REGEX_LEADING_EXCAPED_EXCLAMATION = /^\\\!/;
var REGEX_LEADING_EXCAPED_HASH = /^\\#/;
var SLASH = '/';

var IgnoreBase = function () {
  function IgnoreBase() {
    _classCallCheck(this, IgnoreBase);

    this._rules = [];
    this._initCache();
  }

  _createClass(IgnoreBase, [{
    key: '_initCache',
    value: function _initCache() {
      this._cache = {};
    }

    // @param {Array.<string>|string|Ignore} pattern

  }, {
    key: 'add',
    value: function add(pattern) {
      this._added = false;

      if (typeof pattern === 'string') {
        pattern = pattern.split(/\r?\n/g);
      }

      make_array(pattern).forEach(this._addPattern, this);

      // Some rules have just added to the ignore,
      // making the behavior changed.
      if (this._added) {
        this._initCache();
      }

      return this;
    }

    // legacy

  }, {
    key: 'addPattern',
    value: function addPattern(pattern) {
      return this.add(pattern);
    }
  }, {
    key: '_addPattern',
    value: function _addPattern(pattern) {
      if (pattern instanceof IgnoreBase) {
        this._rules = this._rules.concat(pattern._rules);
        this._added = true;
        return;
      }

      if (this._checkPattern(pattern)) {
        var rule = this._createRule(pattern);
        this._added = true;
        this._rules.push(rule);
      }
    }
  }, {
    key: '_checkPattern',
    value: function _checkPattern(pattern) {
      // > A blank line matches no files, so it can serve as a separator for readability.
      return pattern && typeof pattern === 'string' && !REGEX_BLANK_LINE.test(pattern)

      // > A line starting with # serves as a comment.
       && pattern.indexOf('#') !== 0;
    }
  }, {
    key: 'filter',
    value: function filter(paths) {
      var _this = this;

      return make_array(paths).filter(function (path) {
        return _this._filter(path);
      });
    }
  }, {
    key: 'createFilter',
    value: function createFilter() {
      var _this2 = this;

      return function (path) {
        return _this2._filter(path);
      };
    }
  }, {
    key: 'ignores',
    value: function ignores(path) {
      return !this._filter(path);
    }
  }, {
    key: '_createRule',
    value: function _createRule(pattern) {
      var origin = pattern;
      var negative = false;

      // > An optional prefix "!" which negates the pattern;
      if (pattern.indexOf('!') === 0) {
        negative = true;
        pattern = pattern.substr(1);
      }

      pattern = pattern
      // > Put a backslash ("\") in front of the first "!" for patterns that begin with a literal "!", for example, `"\!important!.txt"`.
      .replace(REGEX_LEADING_EXCAPED_EXCLAMATION, '!')
      // > Put a backslash ("\") in front of the first hash for patterns that begin with a hash.
      .replace(REGEX_LEADING_EXCAPED_HASH, '#');

      var regex = make_regex(pattern, negative);

      return {
        origin: origin,
        pattern: pattern,
        negative: negative,
        regex: regex
      };
    }

    // @returns `Boolean` true if the `path` is NOT ignored

  }, {
    key: '_filter',
    value: function _filter(path, slices) {
      if (!path) {
        return false;
      }

      if (path in this._cache) {
        return this._cache[path];
      }

      if (!slices) {
        // path/to/a.js
        // ['path', 'to', 'a.js']
        slices = path.split(SLASH);

        // '/b/a.js' -> ['', 'b', 'a.js'] -> ['']
        if (slices.length && !slices[0]) {
          slices = slices.slice(1);
          slices[0] = SLASH + slices[0];
        }
      }

      slices.pop();

      return this._cache[path] = slices.length
      // > It is not possible to re-include a file if a parent directory of that file is excluded.
      // If the path contains a parent directory, check the parent first
      ? this._filter(slices.join(SLASH) + SLASH, slices) && this._test(path)

      // Or only test the path
      : this._test(path);
    }

    // @returns {Boolean} true if a file is NOT ignored

  }, {
    key: '_test',
    value: function _test(path) {
      // Explicitly define variable type by setting matched to `0`
      var matched = 0;

      this._rules.forEach(function (rule) {
        // if matched = true, then we only test negative rules
        // if matched = false, then we test non-negative rules
        if (!(matched ^ rule.negative)) {
          matched = rule.negative ^ rule.regex.test(path);
        }
      });

      return !matched;
    }
  }]);

  return IgnoreBase;
}();

// > If the pattern ends with a slash,
// > it is removed for the purpose of the following description,
// > but it would only find a match with a directory.
// > In other words, foo/ will match a directory foo and paths underneath it,
// > but will not match a regular file or a symbolic link foo
// >  (this is consistent with the way how pathspec works in general in Git).
// '`foo/`' will not match regular file '`foo`' or symbolic link '`foo`'
// -> ignore-rules will not deal with it, because it costs extra `fs.stat` call
//      you could use option `mark: true` with `glob`

// '`foo/`' should not continue with the '`..`'


var DEFAULT_REPLACER_PREFIX = [

// > Trailing spaces are ignored unless they are quoted with backslash ("\")
[
// (a\ ) -> (a )
// (a  ) -> (a)
// (a \ ) -> (a  )
/\\?\s+$/, function (match) {
  return match.indexOf('\\') === 0 ? ' ' : '';
}],

// replace (\ ) with ' '
[/\\\s/g, function () {
  return ' ';
}],

// Escape metacharacters
// which is written down by users but means special for regular expressions.

// > There are 12 characters with special meanings:
// > - the backslash \,
// > - the caret ^,
// > - the dollar sign $,
// > - the period or dot .,
// > - the vertical bar or pipe symbol |,
// > - the question mark ?,
// > - the asterisk or star *,
// > - the plus sign +,
// > - the opening parenthesis (,
// > - the closing parenthesis ),
// > - and the opening square bracket [,
// > - the opening curly brace {,
// > These special characters are often called "metacharacters".
[/[\\\^$.|?*+()\[{]/g, function (match) {
  return '\\' + match;
}],

// leading slash
[

// > A leading slash matches the beginning of the pathname.
// > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
// A leading slash matches the beginning of the pathname
/^\//, function () {
  return '^';
}],

// replace special metacharacter slash after the leading slash
[/\//g, function () {
  return '\\/';
}], [
// > A leading "**" followed by a slash means match in all directories.
// > For example, "**/foo" matches file or directory "foo" anywhere,
// > the same as pattern "foo".
// > "**/foo/bar" matches file or directory "bar" anywhere that is directly under directory "foo".
// Notice that the '*'s have been replaced as '\\*'
/^\^*\\\*\\\*\\\//,

// '**/foo' <-> 'foo'
function () {
  return '^(?:.*\\/)?';
}]];

var DEFAULT_REPLACER_SUFFIX = [
// starting
[
// there will be no leading '/' (which has been replaced by section "leading slash")
// If starts with '**', adding a '^' to the regular expression also works
/^(?=[^\^])/, function () {
  return !/\/(?!$)/.test(this)
  // > If the pattern does not contain a slash /, Git treats it as a shell glob pattern
  // Actually, if there is only a trailing slash, git also treats it as a shell glob pattern
  ? '(?:^|\\/)'

  // > Otherwise, Git treats the pattern as a shell glob suitable for consumption by fnmatch(3)
  : '^';
}],

// two globstars
[
// Use lookahead assertions so that we could match more than one `'/**'`
/\\\/\\\*\\\*(?=\\\/|$)/g,

// Zero, one or several directories
// should not use '*', or it will be replaced by the next replacer

// Check if it is not the last `'/**'`
function (match, index, str) {
  return index + 6 < str.length

  // case: /**/
  // > A slash followed by two consecutive asterisks then a slash matches zero or more directories.
  // > For example, "a/**/b" matches "a/b", "a/x/b", "a/x/y/b" and so on.
  // '/**/'
  ? '(?:\\/[^\\/]+)*'

  // case: /**
  // > A trailing `"/**"` matches everything inside.

  // #21: everything inside but it should not include the current folder
  : '\\/.+';
}],

// intermediate wildcards
[
// Never replace escaped '*'
// ignore rule '\*' will match the path '*'

// 'abc.*/' -> go
// 'abc.*'  -> skip this rule
/(^|[^\\]+)\\\*(?=.+)/g,

// '*.js' matches '.js'
// '*.js' doesn't match 'abc'
function (match, p1) {
  return p1 + '[^\\/]*';
}],

// trailing wildcard
[/(\^|\\\/)?\\\*$/, function (match, p1) {
  return (p1
  // '\^':
  // '/*' does not match ''
  // '/*' does not match everything

  // '\\\/':
  // 'abc/*' does not match 'abc/'
  ? p1 + '[^/]+'

  // 'a*' matches 'a'
  // 'a*' matches 'aa'
  : '[^/]*') + '(?=$|\\/$)';
}], [
// unescape
/\\\\\\/g, function () {
  return '\\';
}]];

var POSITIVE_REPLACERS = [].concat(DEFAULT_REPLACER_PREFIX, [

// 'f'
// matches
// - /f(end)
// - /f/
// - (start)f(end)
// - (start)f/
// doesn't match
// - oof
// - foo
// pseudo:
// -> (^|/)f(/|$)

// ending
[
// 'js' will not match 'js.'
// 'ab' will not match 'abc'
/(?:[^*\/])$/,

// 'js*' will not match 'a.js'
// 'js/' will not match 'a.js'
// 'js' will match 'a.js' and 'a.js/'
function (match) {
  return match + '(?=$|\\/)';
}]], DEFAULT_REPLACER_SUFFIX);

var NEGATIVE_REPLACERS = [].concat(DEFAULT_REPLACER_PREFIX, [

// #24
// The MISSING rule of [gitignore docs](https://git-scm.com/docs/gitignore)
// A negative pattern without a trailing wildcard should not
// re-include the things inside that directory.

// eg:
// ['node_modules/*', '!node_modules']
// should ignore `node_modules/a.js`
[/(?:[^*\/])$/, function (match) {
  return match + '(?=$|\\/$)';
}]], DEFAULT_REPLACER_SUFFIX);

// A simple cache, because an ignore rule only has only one certain meaning
var cache = {};

// @param {pattern}
function make_regex(pattern, negative) {
  var r = cache[pattern];
  if (r) {
    return r;
  }

  var replacers = negative ? NEGATIVE_REPLACERS : POSITIVE_REPLACERS;

  var source = replacers.reduce(function (prev, current) {
    return prev.replace(current[0], current[1].bind(pattern));
  }, pattern);

  return cache[pattern] = new RegExp(source, 'i');
}

// Windows
// --------------------------------------------------------------
/* istanbul ignore if  */
if (process.env.IGNORE_TEST_WIN32 || process.platform === 'win32') {

  var filter = IgnoreBase.prototype._filter;
  var make_posix = function make_posix(str) {
    return (/^\\\\\?\\/.test(str) || /[^\x00-\x80]+/.test(str) ? str : str.replace(/\\/g, '/')
    );
  };

  IgnoreBase.prototype._filter = function (path, slices) {
    path = make_posix(path);
    return filter.call(this, path, slices);
  };
}

}).call(this,require('_process'))
},{"_process":16}],635:[function(require,module,exports){
/**
 * @preserve
 * JS Implementation of incremental MurmurHash3 (r150) (as of May 10, 2013)
 *
 * @author <a href="mailto:jensyt@gmail.com">Jens Taylor</a>
 * @see http://github.com/homebrewing/brauhaus-diff
 * @author <a href="mailto:gary.court@gmail.com">Gary Court</a>
 * @see http://github.com/garycourt/murmurhash-js
 * @author <a href="mailto:aappleby@gmail.com">Austin Appleby</a>
 * @see http://sites.google.com/site/murmurhash/
 */
(function(){
    var cache;

    // Call this function without `new` to use the cached object (good for
    // single-threaded environments), or with `new` to create a new object.
    //
    // @param {string} key A UTF-16 or ASCII string
    // @param {number} seed An optional positive integer
    // @return {object} A MurmurHash3 object for incremental hashing
    function MurmurHash3(key, seed) {
        var m = this instanceof MurmurHash3 ? this : cache;
        m.reset(seed)
        if (typeof key === 'string' && key.length > 0) {
            m.hash(key);
        }

        if (m !== this) {
            return m;
        }
    };

    // Incrementally add a string to this hash
    //
    // @param {string} key A UTF-16 or ASCII string
    // @return {object} this
    MurmurHash3.prototype.hash = function(key) {
        var h1, k1, i, top, len;

        len = key.length;
        this.len += len;

        k1 = this.k1;
        i = 0;
        switch (this.rem) {
            case 0: k1 ^= len > i ? (key.charCodeAt(i++) & 0xffff) : 0;
            case 1: k1 ^= len > i ? (key.charCodeAt(i++) & 0xffff) << 8 : 0;
            case 2: k1 ^= len > i ? (key.charCodeAt(i++) & 0xffff) << 16 : 0;
            case 3:
                k1 ^= len > i ? (key.charCodeAt(i) & 0xff) << 24 : 0;
                k1 ^= len > i ? (key.charCodeAt(i++) & 0xff00) >> 8 : 0;
        }

        this.rem = (len + this.rem) & 3; // & 3 is same as % 4
        len -= this.rem;
        if (len > 0) {
            h1 = this.h1;
            while (1) {
                k1 = (k1 * 0x2d51 + (k1 & 0xffff) * 0xcc9e0000) & 0xffffffff;
                k1 = (k1 << 15) | (k1 >>> 17);
                k1 = (k1 * 0x3593 + (k1 & 0xffff) * 0x1b870000) & 0xffffffff;

                h1 ^= k1;
                h1 = (h1 << 13) | (h1 >>> 19);
                h1 = (h1 * 5 + 0xe6546b64) & 0xffffffff;

                if (i >= len) {
                    break;
                }

                k1 = ((key.charCodeAt(i++) & 0xffff)) ^
                     ((key.charCodeAt(i++) & 0xffff) << 8) ^
                     ((key.charCodeAt(i++) & 0xffff) << 16);
                top = key.charCodeAt(i++);
                k1 ^= ((top & 0xff) << 24) ^
                      ((top & 0xff00) >> 8);
            }

            k1 = 0;
            switch (this.rem) {
                case 3: k1 ^= (key.charCodeAt(i + 2) & 0xffff) << 16;
                case 2: k1 ^= (key.charCodeAt(i + 1) & 0xffff) << 8;
                case 1: k1 ^= (key.charCodeAt(i) & 0xffff);
            }

            this.h1 = h1;
        }

        this.k1 = k1;
        return this;
    };

    // Get the result of this hash
    //
    // @return {number} The 32-bit hash
    MurmurHash3.prototype.result = function() {
        var k1, h1;

        k1 = this.k1;
        h1 = this.h1;

        if (k1 > 0) {
            k1 = (k1 * 0x2d51 + (k1 & 0xffff) * 0xcc9e0000) & 0xffffffff;
            k1 = (k1 << 15) | (k1 >>> 17);
            k1 = (k1 * 0x3593 + (k1 & 0xffff) * 0x1b870000) & 0xffffffff;
            h1 ^= k1;
        }

        h1 ^= this.len;

        h1 ^= h1 >>> 16;
        h1 = (h1 * 0xca6b + (h1 & 0xffff) * 0x85eb0000) & 0xffffffff;
        h1 ^= h1 >>> 13;
        h1 = (h1 * 0xae35 + (h1 & 0xffff) * 0xc2b20000) & 0xffffffff;
        h1 ^= h1 >>> 16;

        return h1 >>> 0;
    };

    // Reset the hash object for reuse
    //
    // @param {number} seed An optional positive integer
    MurmurHash3.prototype.reset = function(seed) {
        this.h1 = typeof seed === 'number' ? seed : 0;
        this.rem = this.k1 = this.len = 0;
        return this;
    };

    // A cached object to use. This can be safely used if you're in a single-
    // threaded environment, otherwise you need to create new hashes to use.
    cache = new MurmurHash3();

    if (typeof(module) != 'undefined') {
        module.exports = MurmurHash3;
    } else {
        this.MurmurHash3 = MurmurHash3;
    }
}());

},{}],636:[function(require,module,exports){
module.exports = function (ary, item) {
  var i = -1, indexes = []
  while((i = ary.indexOf(item, i + 1)) !== -1)
    indexes.push(i)
  return indexes
}

},{}],637:[function(require,module,exports){
(function (process){
var wrappy = require('wrappy')
var reqs = Object.create(null)
var once = require('once')

module.exports = wrappy(inflight)

function inflight (key, cb) {
  if (reqs[key]) {
    reqs[key].push(cb)
    return null
  } else {
    reqs[key] = [cb]
    return makeres(key)
  }
}

function makeres (key) {
  return once(function RES () {
    var cbs = reqs[key]
    var len = cbs.length
    var args = slice(arguments)

    // XXX It's somewhat ambiguous whether a new callback added in this
    // pass should be queued for later execution if something in the
    // list of callbacks throws, or if it should just be discarded.
    // However, it's such an edge case that it hardly matters, and either
    // choice is likely as surprising as the other.
    // As it happens, we do go ahead and schedule it for later execution.
    try {
      for (var i = 0; i < len; i++) {
        cbs[i].apply(null, args)
      }
    } finally {
      if (cbs.length > len) {
        // added more in the interim.
        // de-zalgo, just in case, but don't call again.
        cbs.splice(0, len)
        process.nextTick(function () {
          RES.apply(null, args)
        })
      } else {
        delete reqs[key]
      }
    }
  })
}

function slice (args) {
  var length = args.length
  var array = []

  for (var i = 0; i < length; i++) array[i] = args[i]
  return array
}

}).call(this,require('_process'))
},{"_process":16,"once":713,"wrappy":1182}],638:[function(require,module,exports){
arguments[4][10][0].apply(exports,arguments)
},{"dup":10}],639:[function(require,module,exports){
'use strict';

module.exports = function isArrayish(obj) {
	if (!obj) {
		return false;
	}

	return obj instanceof Array || Array.isArray(obj) ||
		(obj.length >= 0 && obj.splice instanceof Function);
};

},{}],640:[function(require,module,exports){
arguments[4][11][0].apply(exports,arguments)
},{"dup":11}],641:[function(require,module,exports){
/*!
 * is-directory <https://github.com/jonschlinkert/is-directory>
 *
 * Copyright (c) 2014-2015, Jon Schlinkert.
 * Licensed under the MIT License.
 */

'use strict';

var fs = require('fs');

/**
 * async
 */

function isDirectory(filepath, cb) {
  if (typeof cb !== 'function') {
    throw new Error('expected a callback function');
  }

  if (typeof filepath !== 'string') {
    cb(new Error('expected filepath to be a string'));
    return;
  }

  fs.stat(filepath, function(err, stats) {
    if (err) {
      if (err.code === 'ENOENT') {
        cb(null, false);
        return;
      }
      cb(err);
      return;
    }
    cb(null, stats.isDirectory());
  });
}

/**
 * sync
 */

isDirectory.sync = function isDirectorySync(filepath) {
  if (typeof filepath !== 'string') {
    throw new Error('expected filepath to be a string');
  }

  try {
    var stat = fs.statSync(filepath);
    return stat.isDirectory();
  } catch (err) {
    if (err.code === 'ENOENT') {
      return false;
    } else {
      throw err;
    }
  }
  return false;
};

/**
 * Expose `isDirectory`
 */

module.exports = isDirectory;

},{"fs":1}],642:[function(require,module,exports){
/*!
 * is-dotfile <https://github.com/jonschlinkert/is-dotfile>
 *
 * Copyright (c) 2015-2017, Jon Schlinkert.
 * Released under the MIT License.
 */

module.exports = function(str) {
  if (str.charCodeAt(0) === 46 /* . */ && str.indexOf('/', 1) === -1) {
    return true;
  }
  var slash = str.lastIndexOf('/');
  return slash !== -1 ? str.charCodeAt(slash + 1) === 46  /* . */ : false;
};

},{}],643:[function(require,module,exports){
/*!
 * is-equal-shallow <https://github.com/jonschlinkert/is-equal-shallow>
 *
 * Copyright (c) 2015, Jon Schlinkert.
 * Licensed under the MIT License.
 */

'use strict';

var isPrimitive = require('is-primitive');

module.exports = function isEqual(a, b) {
  if (!a && !b) { return true; }
  if (!a && b || a && !b) { return false; }

  var numKeysA = 0, numKeysB = 0, key;
  for (key in b) {
    numKeysB++;
    if (!isPrimitive(b[key]) || !a.hasOwnProperty(key) || (a[key] !== b[key])) {
      return false;
    }
  }
  for (key in a) {
    numKeysA++;
  }
  return numKeysA === numKeysB;
};

},{"is-primitive":653}],644:[function(require,module,exports){
/*!
 * is-extendable <https://github.com/jonschlinkert/is-extendable>
 *
 * Copyright (c) 2015, Jon Schlinkert.
 * Licensed under the MIT License.
 */

'use strict';

module.exports = function isExtendable(val) {
  return typeof val !== 'undefined' && val !== null
    && (typeof val === 'object' || typeof val === 'function');
};

},{}],645:[function(require,module,exports){
/*!
 * is-extglob <https://github.com/jonschlinkert/is-extglob>
 *
 * Copyright (c) 2014-2015, Jon Schlinkert.
 * Licensed under the MIT License.
 */

module.exports = function isExtglob(str) {
  return typeof str === 'string'
    && /[@?!+*]\(/.test(str);
};

},{}],646:[function(require,module,exports){
'use strict';
/* eslint-disable yoda */
module.exports = x => {
	if (Number.isNaN(x)) {
		return false;
	}

	// code points are derived from:
	// http://www.unix.org/Public/UNIDATA/EastAsianWidth.txt
	if (
		x >= 0x1100 && (
			x <= 0x115f ||  // Hangul Jamo
			x === 0x2329 || // LEFT-POINTING ANGLE BRACKET
			x === 0x232a || // RIGHT-POINTING ANGLE BRACKET
			// CJK Radicals Supplement .. Enclosed CJK Letters and Months
			(0x2e80 <= x && x <= 0x3247 && x !== 0x303f) ||
			// Enclosed CJK Letters and Months .. CJK Unified Ideographs Extension A
			(0x3250 <= x && x <= 0x4dbf) ||
			// CJK Unified Ideographs .. Yi Radicals
			(0x4e00 <= x && x <= 0xa4c6) ||
			// Hangul Jamo Extended-A
			(0xa960 <= x && x <= 0xa97c) ||
			// Hangul Syllables
			(0xac00 <= x && x <= 0xd7a3) ||
			// CJK Compatibility Ideographs
			(0xf900 <= x && x <= 0xfaff) ||
			// Vertical Forms
			(0xfe10 <= x && x <= 0xfe19) ||
			// CJK Compatibility Forms .. Small Form Variants
			(0xfe30 <= x && x <= 0xfe6b) ||
			// Halfwidth and Fullwidth Forms
			(0xff01 <= x && x <= 0xff60) ||
			(0xffe0 <= x && x <= 0xffe6) ||
			// Kana Supplement
			(0x1b000 <= x && x <= 0x1b001) ||
			// Enclosed Ideographic Supplement
			(0x1f200 <= x && x <= 0x1f251) ||
			// CJK Unified Ideographs Extension B .. Tertiary Ideographic Plane
			(0x20000 <= x && x <= 0x3fffd)
		)
	) {
		return true;
	}

	return false;
};

},{}],647:[function(require,module,exports){
/*!
 * is-glob <https://github.com/jonschlinkert/is-glob>
 *
 * Copyright (c) 2014-2015, Jon Schlinkert.
 * Licensed under the MIT License.
 */

var isExtglob = require('is-extglob');

module.exports = function isGlob(str) {
  return typeof str === 'string'
    && (/[*!?{}(|)[\]]/.test(str)
     || isExtglob(str));
};
},{"is-extglob":645}],648:[function(require,module,exports){
/*!
 * is-number <https://github.com/jonschlinkert/is-number>
 *
 * Copyright (c) 2014-2015, Jon Schlinkert.
 * Licensed under the MIT License.
 */

'use strict';

var typeOf = require('kind-of');

module.exports = function isNumber(num) {
  var type = typeOf(num);
  if (type !== 'number' && type !== 'string') {
    return false;
  }
  var n = +num;
  return (n - n + 1) >= 0 && num !== '';
};

},{"kind-of":689}],649:[function(require,module,exports){
(function (process){
'use strict';
var path = require('path');

module.exports = function (str) {
	return path.resolve(str) === path.resolve(process.cwd());
};

}).call(this,require('_process'))
},{"_process":16,"path":14}],650:[function(require,module,exports){
(function (process){
'use strict';
var isPathInside = require('is-path-inside');

module.exports = function (str) {
	return isPathInside(str, process.cwd());
};

}).call(this,require('_process'))
},{"_process":16,"is-path-inside":651}],651:[function(require,module,exports){
'use strict';
var path = require('path');
var pathIsInside = require('path-is-inside');

module.exports = function (a, b) {
	a = path.resolve(a);
	b = path.resolve(b);

	if (a === b) {
		return false;
	}

	return pathIsInside(a, b);
};

},{"path":14,"path-is-inside":720}],652:[function(require,module,exports){
/*!
 * is-posix-bracket <https://github.com/jonschlinkert/is-posix-bracket>
 *
 * Copyright (c) 2015-2016, Jon Schlinkert.
 * Licensed under the MIT License.
 */

module.exports = function isPosixBracket(str) {
  return typeof str === 'string' && /\[([:.=+])(?:[^\[\]]|)+\1\]/.test(str);
};

},{}],653:[function(require,module,exports){
/*!
 * is-primitive <https://github.com/jonschlinkert/is-primitive>
 *
 * Copyright (c) 2014-2015, Jon Schlinkert.
 * Licensed under the MIT License.
 */

'use strict';

// see http://jsperf.com/testing-value-is-primitive/7
module.exports = function isPrimitive(value) {
  return value == null || (typeof value !== 'function' && typeof value !== 'object');
};

},{}],654:[function(require,module,exports){
'use strict';
module.exports = function (re) {
	return Object.prototype.toString.call(re) === '[object RegExp]';
};

},{}],655:[function(require,module,exports){
'use strict';
module.exports = function (flag) {
	var supported = true;

	try {
		new RegExp('', flag);
	} catch (err) {
		supported = false;
	}

	return supported;
};

},{}],656:[function(require,module,exports){
arguments[4][12][0].apply(exports,arguments)
},{"dup":12}],657:[function(require,module,exports){
/*!
 * isobject <https://github.com/jonschlinkert/isobject>
 *
 * Copyright (c) 2014-2015, Jon Schlinkert.
 * Licensed under the MIT License.
 */

'use strict';

var isArray = require('isarray');

module.exports = function isObject(val) {
  return val != null && typeof val === 'object' && isArray(val) === false;
};

},{"isarray":656}],658:[function(require,module,exports){
/*
 * $Id: base64.js,v 2.15 2014/04/05 12:58:57 dankogai Exp dankogai $
 *
 *  Licensed under the MIT license.
 *    http://opensource.org/licenses/mit-license
 *
 *  References:
 *    http://en.wikipedia.org/wiki/Base64
 */

(function(global) {
    'use strict';
    // existing version for noConflict()
    var _Base64 = global.Base64;
    var version = "2.1.9";
    // if node.js, we use Buffer
    var buffer;
    if (typeof module !== 'undefined' && module.exports) {
        try {
            buffer = require('buffer').Buffer;
        } catch (err) {}
    }
    // constants
    var b64chars
        = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
    var b64tab = function(bin) {
        var t = {};
        for (var i = 0, l = bin.length; i < l; i++) t[bin.charAt(i)] = i;
        return t;
    }(b64chars);
    var fromCharCode = String.fromCharCode;
    // encoder stuff
    var cb_utob = function(c) {
        if (c.length < 2) {
            var cc = c.charCodeAt(0);
            return cc < 0x80 ? c
                : cc < 0x800 ? (fromCharCode(0xc0 | (cc >>> 6))
                                + fromCharCode(0x80 | (cc & 0x3f)))
                : (fromCharCode(0xe0 | ((cc >>> 12) & 0x0f))
                   + fromCharCode(0x80 | ((cc >>>  6) & 0x3f))
                   + fromCharCode(0x80 | ( cc         & 0x3f)));
        } else {
            var cc = 0x10000
                + (c.charCodeAt(0) - 0xD800) * 0x400
                + (c.charCodeAt(1) - 0xDC00);
            return (fromCharCode(0xf0 | ((cc >>> 18) & 0x07))
                    + fromCharCode(0x80 | ((cc >>> 12) & 0x3f))
                    + fromCharCode(0x80 | ((cc >>>  6) & 0x3f))
                    + fromCharCode(0x80 | ( cc         & 0x3f)));
        }
    };
    var re_utob = /[\uD800-\uDBFF][\uDC00-\uDFFFF]|[^\x00-\x7F]/g;
    var utob = function(u) {
        return u.replace(re_utob, cb_utob);
    };
    var cb_encode = function(ccc) {
        var padlen = [0, 2, 1][ccc.length % 3],
        ord = ccc.charCodeAt(0) << 16
            | ((ccc.length > 1 ? ccc.charCodeAt(1) : 0) << 8)
            | ((ccc.length > 2 ? ccc.charCodeAt(2) : 0)),
        chars = [
            b64chars.charAt( ord >>> 18),
            b64chars.charAt((ord >>> 12) & 63),
            padlen >= 2 ? '=' : b64chars.charAt((ord >>> 6) & 63),
            padlen >= 1 ? '=' : b64chars.charAt(ord & 63)
        ];
        return chars.join('');
    };
    var btoa = global.btoa ? function(b) {
        return global.btoa(b);
    } : function(b) {
        return b.replace(/[\s\S]{1,3}/g, cb_encode);
    };
    var _encode = buffer ? function (u) {
        return (u.constructor === buffer.constructor ? u : new buffer(u))
        .toString('base64')
    }
    : function (u) { return btoa(utob(u)) }
    ;
    var encode = function(u, urisafe) {
        return !urisafe
            ? _encode(String(u))
            : _encode(String(u)).replace(/[+\/]/g, function(m0) {
                return m0 == '+' ? '-' : '_';
            }).replace(/=/g, '');
    };
    var encodeURI = function(u) { return encode(u, true) };
    // decoder stuff
    var re_btou = new RegExp([
        '[\xC0-\xDF][\x80-\xBF]',
        '[\xE0-\xEF][\x80-\xBF]{2}',
        '[\xF0-\xF7][\x80-\xBF]{3}'
    ].join('|'), 'g');
    var cb_btou = function(cccc) {
        switch(cccc.length) {
        case 4:
            var cp = ((0x07 & cccc.charCodeAt(0)) << 18)
                |    ((0x3f & cccc.charCodeAt(1)) << 12)
                |    ((0x3f & cccc.charCodeAt(2)) <<  6)
                |     (0x3f & cccc.charCodeAt(3)),
            offset = cp - 0x10000;
            return (fromCharCode((offset  >>> 10) + 0xD800)
                    + fromCharCode((offset & 0x3FF) + 0xDC00));
        case 3:
            return fromCharCode(
                ((0x0f & cccc.charCodeAt(0)) << 12)
                    | ((0x3f & cccc.charCodeAt(1)) << 6)
                    |  (0x3f & cccc.charCodeAt(2))
            );
        default:
            return  fromCharCode(
                ((0x1f & cccc.charCodeAt(0)) << 6)
                    |  (0x3f & cccc.charCodeAt(1))
            );
        }
    };
    var btou = function(b) {
        return b.replace(re_btou, cb_btou);
    };
    var cb_decode = function(cccc) {
        var len = cccc.length,
        padlen = len % 4,
        n = (len > 0 ? b64tab[cccc.charAt(0)] << 18 : 0)
            | (len > 1 ? b64tab[cccc.charAt(1)] << 12 : 0)
            | (len > 2 ? b64tab[cccc.charAt(2)] <<  6 : 0)
            | (len > 3 ? b64tab[cccc.charAt(3)]       : 0),
        chars = [
            fromCharCode( n >>> 16),
            fromCharCode((n >>>  8) & 0xff),
            fromCharCode( n         & 0xff)
        ];
        chars.length -= [0, 0, 2, 1][padlen];
        return chars.join('');
    };
    var atob = global.atob ? function(a) {
        return global.atob(a);
    } : function(a){
        return a.replace(/[\s\S]{1,4}/g, cb_decode);
    };
    var _decode = buffer ? function(a) {
        return (a.constructor === buffer.constructor
                ? a : new buffer(a, 'base64')).toString();
    }
    : function(a) { return btou(atob(a)) };
    var decode = function(a){
        return _decode(
            String(a).replace(/[-_]/g, function(m0) { return m0 == '-' ? '+' : '/' })
                .replace(/[^A-Za-z0-9\+\/]/g, '')
        );
    };
    var noConflict = function() {
        var Base64 = global.Base64;
        global.Base64 = _Base64;
        return Base64;
    };
    // export Base64
    global.Base64 = {
        VERSION: version,
        atob: atob,
        btoa: btoa,
        fromBase64: decode,
        toBase64: encode,
        utob: utob,
        encode: encode,
        encodeURI: encodeURI,
        btou: btou,
        decode: decode,
        noConflict: noConflict
    };
    // if ES5 is available, make Base64.extendString() available
    if (typeof Object.defineProperty === 'function') {
        var noEnum = function(v){
            return {value:v,enumerable:false,writable:true,configurable:true};
        };
        global.Base64.extendString = function () {
            Object.defineProperty(
                String.prototype, 'fromBase64', noEnum(function () {
                    return decode(this)
                }));
            Object.defineProperty(
                String.prototype, 'toBase64', noEnum(function (urisafe) {
                    return encode(this, urisafe)
                }));
            Object.defineProperty(
                String.prototype, 'toBase64URI', noEnum(function () {
                    return encode(this, true)
                }));
        };
    }
    // that's it!
    if (global['Meteor']) {
       Base64 = global.Base64; // for normal export in Meteor.js
    }
})(this);

},{"buffer":5}],659:[function(require,module,exports){
'use strict';


var yaml = require('./lib/js-yaml.js');


module.exports = yaml;

},{"./lib/js-yaml.js":660}],660:[function(require,module,exports){
'use strict';


var loader = require('./js-yaml/loader');
var dumper = require('./js-yaml/dumper');


function deprecated(name) {
  return function () {
    throw new Error('Function ' + name + ' is deprecated and cannot be used.');
  };
}


module.exports.Type                = require('./js-yaml/type');
module.exports.Schema              = require('./js-yaml/schema');
module.exports.FAILSAFE_SCHEMA     = require('./js-yaml/schema/failsafe');
module.exports.JSON_SCHEMA         = require('./js-yaml/schema/json');
module.exports.CORE_SCHEMA         = require('./js-yaml/schema/core');
module.exports.DEFAULT_SAFE_SCHEMA = require('./js-yaml/schema/default_safe');
module.exports.DEFAULT_FULL_SCHEMA = require('./js-yaml/schema/default_full');
module.exports.load                = loader.load;
module.exports.loadAll             = loader.loadAll;
module.exports.safeLoad            = loader.safeLoad;
module.exports.safeLoadAll         = loader.safeLoadAll;
module.exports.dump                = dumper.dump;
module.exports.safeDump            = dumper.safeDump;
module.exports.YAMLException       = require('./js-yaml/exception');

// Deprecated schema names from JS-YAML 2.0.x
module.exports.MINIMAL_SCHEMA = require('./js-yaml/schema/failsafe');
module.exports.SAFE_SCHEMA    = require('./js-yaml/schema/default_safe');
module.exports.DEFAULT_SCHEMA = require('./js-yaml/schema/default_full');

// Deprecated functions from JS-YAML 1.x.x
module.exports.scan           = deprecated('scan');
module.exports.parse          = deprecated('parse');
module.exports.compose        = deprecated('compose');
module.exports.addConstructor = deprecated('addConstructor');

},{"./js-yaml/dumper":662,"./js-yaml/exception":663,"./js-yaml/loader":664,"./js-yaml/schema":666,"./js-yaml/schema/core":667,"./js-yaml/schema/default_full":668,"./js-yaml/schema/default_safe":669,"./js-yaml/schema/failsafe":670,"./js-yaml/schema/json":671,"./js-yaml/type":672}],661:[function(require,module,exports){
'use strict';


function isNothing(subject) {
  return (typeof subject === 'undefined') || (subject === null);
}


function isObject(subject) {
  return (typeof subject === 'object') && (subject !== null);
}


function toArray(sequence) {
  if (Array.isArray(sequence)) return sequence;
  else if (isNothing(sequence)) return [];

  return [ sequence ];
}


function extend(target, source) {
  var index, length, key, sourceKeys;

  if (source) {
    sourceKeys = Object.keys(source);

    for (index = 0, length = sourceKeys.length; index < length; index += 1) {
      key = sourceKeys[index];
      target[key] = source[key];
    }
  }

  return target;
}


function repeat(string, count) {
  var result = '', cycle;

  for (cycle = 0; cycle < count; cycle += 1) {
    result += string;
  }

  return result;
}


function isNegativeZero(number) {
  return (number === 0) && (Number.NEGATIVE_INFINITY === 1 / number);
}


module.exports.isNothing      = isNothing;
module.exports.isObject       = isObject;
module.exports.toArray        = toArray;
module.exports.repeat         = repeat;
module.exports.isNegativeZero = isNegativeZero;
module.exports.extend         = extend;

},{}],662:[function(require,module,exports){
'use strict';

/*eslint-disable no-use-before-define*/

var common              = require('./common');
var YAMLException       = require('./exception');
var DEFAULT_FULL_SCHEMA = require('./schema/default_full');
var DEFAULT_SAFE_SCHEMA = require('./schema/default_safe');

var _toString       = Object.prototype.toString;
var _hasOwnProperty = Object.prototype.hasOwnProperty;

var CHAR_TAB                  = 0x09; /* Tab */
var CHAR_LINE_FEED            = 0x0A; /* LF */
var CHAR_SPACE                = 0x20; /* Space */
var CHAR_EXCLAMATION          = 0x21; /* ! */
var CHAR_DOUBLE_QUOTE         = 0x22; /* " */
var CHAR_SHARP                = 0x23; /* # */
var CHAR_PERCENT              = 0x25; /* % */
var CHAR_AMPERSAND            = 0x26; /* & */
var CHAR_SINGLE_QUOTE         = 0x27; /* ' */
var CHAR_ASTERISK             = 0x2A; /* * */
var CHAR_COMMA                = 0x2C; /* , */
var CHAR_MINUS                = 0x2D; /* - */
var CHAR_COLON                = 0x3A; /* : */
var CHAR_GREATER_THAN         = 0x3E; /* > */
var CHAR_QUESTION             = 0x3F; /* ? */
var CHAR_COMMERCIAL_AT        = 0x40; /* @ */
var CHAR_LEFT_SQUARE_BRACKET  = 0x5B; /* [ */
var CHAR_RIGHT_SQUARE_BRACKET = 0x5D; /* ] */
var CHAR_GRAVE_ACCENT         = 0x60; /* ` */
var CHAR_LEFT_CURLY_BRACKET   = 0x7B; /* { */
var CHAR_VERTICAL_LINE        = 0x7C; /* | */
var CHAR_RIGHT_CURLY_BRACKET  = 0x7D; /* } */

var ESCAPE_SEQUENCES = {};

ESCAPE_SEQUENCES[0x00]   = '\\0';
ESCAPE_SEQUENCES[0x07]   = '\\a';
ESCAPE_SEQUENCES[0x08]   = '\\b';
ESCAPE_SEQUENCES[0x09]   = '\\t';
ESCAPE_SEQUENCES[0x0A]   = '\\n';
ESCAPE_SEQUENCES[0x0B]   = '\\v';
ESCAPE_SEQUENCES[0x0C]   = '\\f';
ESCAPE_SEQUENCES[0x0D]   = '\\r';
ESCAPE_SEQUENCES[0x1B]   = '\\e';
ESCAPE_SEQUENCES[0x22]   = '\\"';
ESCAPE_SEQUENCES[0x5C]   = '\\\\';
ESCAPE_SEQUENCES[0x85]   = '\\N';
ESCAPE_SEQUENCES[0xA0]   = '\\_';
ESCAPE_SEQUENCES[0x2028] = '\\L';
ESCAPE_SEQUENCES[0x2029] = '\\P';

var DEPRECATED_BOOLEANS_SYNTAX = [
  'y', 'Y', 'yes', 'Yes', 'YES', 'on', 'On', 'ON',
  'n', 'N', 'no', 'No', 'NO', 'off', 'Off', 'OFF'
];

function compileStyleMap(schema, map) {
  var result, keys, index, length, tag, style, type;

  if (map === null) return {};

  result = {};
  keys = Object.keys(map);

  for (index = 0, length = keys.length; index < length; index += 1) {
    tag = keys[index];
    style = String(map[tag]);

    if (tag.slice(0, 2) === '!!') {
      tag = 'tag:yaml.org,2002:' + tag.slice(2);
    }
    type = schema.compiledTypeMap['fallback'][tag];

    if (type && _hasOwnProperty.call(type.styleAliases, style)) {
      style = type.styleAliases[style];
    }

    result[tag] = style;
  }

  return result;
}

function encodeHex(character) {
  var string, handle, length;

  string = character.toString(16).toUpperCase();

  if (character <= 0xFF) {
    handle = 'x';
    length = 2;
  } else if (character <= 0xFFFF) {
    handle = 'u';
    length = 4;
  } else if (character <= 0xFFFFFFFF) {
    handle = 'U';
    length = 8;
  } else {
    throw new YAMLException('code point within a string may not be greater than 0xFFFFFFFF');
  }

  return '\\' + handle + common.repeat('0', length - string.length) + string;
}

function State(options) {
  this.schema       = options['schema'] || DEFAULT_FULL_SCHEMA;
  this.indent       = Math.max(1, (options['indent'] || 2));
  this.skipInvalid  = options['skipInvalid'] || false;
  this.flowLevel    = (common.isNothing(options['flowLevel']) ? -1 : options['flowLevel']);
  this.styleMap     = compileStyleMap(this.schema, options['styles'] || null);
  this.sortKeys     = options['sortKeys'] || false;
  this.lineWidth    = options['lineWidth'] || 80;
  this.noRefs       = options['noRefs'] || false;
  this.noCompatMode = options['noCompatMode'] || false;
  this.condenseFlow = options['condenseFlow'] || false;

  this.implicitTypes = this.schema.compiledImplicit;
  this.explicitTypes = this.schema.compiledExplicit;

  this.tag = null;
  this.result = '';

  this.duplicates = [];
  this.usedDuplicates = null;
}

// Indents every line in a string. Empty lines (\n only) are not indented.
function indentString(string, spaces) {
  var ind = common.repeat(' ', spaces),
      position = 0,
      next = -1,
      result = '',
      line,
      length = string.length;

  while (position < length) {
    next = string.indexOf('\n', position);
    if (next === -1) {
      line = string.slice(position);
      position = length;
    } else {
      line = string.slice(position, next + 1);
      position = next + 1;
    }

    if (line.length && line !== '\n') result += ind;

    result += line;
  }

  return result;
}

function generateNextLine(state, level) {
  return '\n' + common.repeat(' ', state.indent * level);
}

function testImplicitResolving(state, str) {
  var index, length, type;

  for (index = 0, length = state.implicitTypes.length; index < length; index += 1) {
    type = state.implicitTypes[index];

    if (type.resolve(str)) {
      return true;
    }
  }

  return false;
}

// [33] s-white ::= s-space | s-tab
function isWhitespace(c) {
  return c === CHAR_SPACE || c === CHAR_TAB;
}

// Returns true if the character can be printed without escaping.
// From YAML 1.2: "any allowed characters known to be non-printable
// should also be escaped. [However,] This isn’t mandatory"
// Derived from nb-char - \t - #x85 - #xA0 - #x2028 - #x2029.
function isPrintable(c) {
  return  (0x00020 <= c && c <= 0x00007E)
      || ((0x000A1 <= c && c <= 0x00D7FF) && c !== 0x2028 && c !== 0x2029)
      || ((0x0E000 <= c && c <= 0x00FFFD) && c !== 0xFEFF /* BOM */)
      ||  (0x10000 <= c && c <= 0x10FFFF);
}

// Simplified test for values allowed after the first character in plain style.
function isPlainSafe(c) {
  // Uses a subset of nb-char - c-flow-indicator - ":" - "#"
  // where nb-char ::= c-printable - b-char - c-byte-order-mark.
  return isPrintable(c) && c !== 0xFEFF
    // - c-flow-indicator
    && c !== CHAR_COMMA
    && c !== CHAR_LEFT_SQUARE_BRACKET
    && c !== CHAR_RIGHT_SQUARE_BRACKET
    && c !== CHAR_LEFT_CURLY_BRACKET
    && c !== CHAR_RIGHT_CURLY_BRACKET
    // - ":" - "#"
    && c !== CHAR_COLON
    && c !== CHAR_SHARP;
}

// Simplified test for values allowed as the first character in plain style.
function isPlainSafeFirst(c) {
  // Uses a subset of ns-char - c-indicator
  // where ns-char = nb-char - s-white.
  return isPrintable(c) && c !== 0xFEFF
    && !isWhitespace(c) // - s-white
    // - (c-indicator ::=
    // “-” | “?” | “:” | “,” | “[” | “]” | “{” | “}”
    && c !== CHAR_MINUS
    && c !== CHAR_QUESTION
    && c !== CHAR_COLON
    && c !== CHAR_COMMA
    && c !== CHAR_LEFT_SQUARE_BRACKET
    && c !== CHAR_RIGHT_SQUARE_BRACKET
    && c !== CHAR_LEFT_CURLY_BRACKET
    && c !== CHAR_RIGHT_CURLY_BRACKET
    // | “#” | “&” | “*” | “!” | “|” | “>” | “'” | “"”
    && c !== CHAR_SHARP
    && c !== CHAR_AMPERSAND
    && c !== CHAR_ASTERISK
    && c !== CHAR_EXCLAMATION
    && c !== CHAR_VERTICAL_LINE
    && c !== CHAR_GREATER_THAN
    && c !== CHAR_SINGLE_QUOTE
    && c !== CHAR_DOUBLE_QUOTE
    // | “%” | “@” | “`”)
    && c !== CHAR_PERCENT
    && c !== CHAR_COMMERCIAL_AT
    && c !== CHAR_GRAVE_ACCENT;
}

var STYLE_PLAIN   = 1,
    STYLE_SINGLE  = 2,
    STYLE_LITERAL = 3,
    STYLE_FOLDED  = 4,
    STYLE_DOUBLE  = 5;

// Determines which scalar styles are possible and returns the preferred style.
// lineWidth = -1 => no limit.
// Pre-conditions: str.length > 0.
// Post-conditions:
//    STYLE_PLAIN or STYLE_SINGLE => no \n are in the string.
//    STYLE_LITERAL => no lines are suitable for folding (or lineWidth is -1).
//    STYLE_FOLDED => a line > lineWidth and can be folded (and lineWidth != -1).
function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth, testAmbiguousType) {
  var i;
  var char;
  var hasLineBreak = false;
  var hasFoldableLine = false; // only checked if shouldTrackWidth
  var shouldTrackWidth = lineWidth !== -1;
  var previousLineBreak = -1; // count the first line correctly
  var plain = isPlainSafeFirst(string.charCodeAt(0))
          && !isWhitespace(string.charCodeAt(string.length - 1));

  if (singleLineOnly) {
    // Case: no block styles.
    // Check for disallowed characters to rule out plain and single.
    for (i = 0; i < string.length; i++) {
      char = string.charCodeAt(i);
      if (!isPrintable(char)) {
        return STYLE_DOUBLE;
      }
      plain = plain && isPlainSafe(char);
    }
  } else {
    // Case: block styles permitted.
    for (i = 0; i < string.length; i++) {
      char = string.charCodeAt(i);
      if (char === CHAR_LINE_FEED) {
        hasLineBreak = true;
        // Check if any line can be folded.
        if (shouldTrackWidth) {
          hasFoldableLine = hasFoldableLine ||
            // Foldable line = too long, and not more-indented.
            (i - previousLineBreak - 1 > lineWidth &&
             string[previousLineBreak + 1] !== ' ');
          previousLineBreak = i;
        }
      } else if (!isPrintable(char)) {
        return STYLE_DOUBLE;
      }
      plain = plain && isPlainSafe(char);
    }
    // in case the end is missing a \n
    hasFoldableLine = hasFoldableLine || (shouldTrackWidth &&
      (i - previousLineBreak - 1 > lineWidth &&
       string[previousLineBreak + 1] !== ' '));
  }
  // Although every style can represent \n without escaping, prefer block styles
  // for multiline, since they're more readable and they don't add empty lines.
  // Also prefer folding a super-long line.
  if (!hasLineBreak && !hasFoldableLine) {
    // Strings interpretable as another type have to be quoted;
    // e.g. the string 'true' vs. the boolean true.
    return plain && !testAmbiguousType(string)
      ? STYLE_PLAIN : STYLE_SINGLE;
  }
  // Edge case: block indentation indicator can only have one digit.
  if (string[0] === ' ' && indentPerLevel > 9) {
    return STYLE_DOUBLE;
  }
  // At this point we know block styles are valid.
  // Prefer literal style unless we want to fold.
  return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL;
}

// Note: line breaking/folding is implemented for only the folded style.
// NB. We drop the last trailing newline (if any) of a returned block scalar
//  since the dumper adds its own newline. This always works:
//    • No ending newline => unaffected; already using strip "-" chomping.
//    • Ending newline    => removed then restored.
//  Importantly, this keeps the "+" chomp indicator from gaining an extra line.
function writeScalar(state, string, level, iskey) {
  state.dump = (function () {
    if (string.length === 0) {
      return "''";
    }
    if (!state.noCompatMode &&
        DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1) {
      return "'" + string + "'";
    }

    var indent = state.indent * Math.max(1, level); // no 0-indent scalars
    // As indentation gets deeper, let the width decrease monotonically
    // to the lower bound min(state.lineWidth, 40).
    // Note that this implies
    //  state.lineWidth ≤ 40 + state.indent: width is fixed at the lower bound.
    //  state.lineWidth > 40 + state.indent: width decreases until the lower bound.
    // This behaves better than a constant minimum width which disallows narrower options,
    // or an indent threshold which causes the width to suddenly increase.
    var lineWidth = state.lineWidth === -1
      ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent);

    // Without knowing if keys are implicit/explicit, assume implicit for safety.
    var singleLineOnly = iskey
      // No block styles in flow mode.
      || (state.flowLevel > -1 && level >= state.flowLevel);
    function testAmbiguity(string) {
      return testImplicitResolving(state, string);
    }

    switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth, testAmbiguity)) {
      case STYLE_PLAIN:
        return string;
      case STYLE_SINGLE:
        return "'" + string.replace(/'/g, "''") + "'";
      case STYLE_LITERAL:
        return '|' + blockHeader(string, state.indent)
          + dropEndingNewline(indentString(string, indent));
      case STYLE_FOLDED:
        return '>' + blockHeader(string, state.indent)
          + dropEndingNewline(indentString(foldString(string, lineWidth), indent));
      case STYLE_DOUBLE:
        return '"' + escapeString(string, lineWidth) + '"';
      default:
        throw new YAMLException('impossible error: invalid scalar style');
    }
  }());
}

// Pre-conditions: string is valid for a block scalar, 1 <= indentPerLevel <= 9.
function blockHeader(string, indentPerLevel) {
  var indentIndicator = (string[0] === ' ') ? String(indentPerLevel) : '';

  // note the special case: the string '\n' counts as a "trailing" empty line.
  var clip =          string[string.length - 1] === '\n';
  var keep = clip && (string[string.length - 2] === '\n' || string === '\n');
  var chomp = keep ? '+' : (clip ? '' : '-');

  return indentIndicator + chomp + '\n';
}

// (See the note for writeScalar.)
function dropEndingNewline(string) {
  return string[string.length - 1] === '\n' ? string.slice(0, -1) : string;
}

// Note: a long line without a suitable break point will exceed the width limit.
// Pre-conditions: every char in str isPrintable, str.length > 0, width > 0.
function foldString(string, width) {
  // In folded style, $k$ consecutive newlines output as $k+1$ newlines—
  // unless they're before or after a more-indented line, or at the very
  // beginning or end, in which case $k$ maps to $k$.
  // Therefore, parse each chunk as newline(s) followed by a content line.
  var lineRe = /(\n+)([^\n]*)/g;

  // first line (possibly an empty line)
  var result = (function () {
    var nextLF = string.indexOf('\n');
    nextLF = nextLF !== -1 ? nextLF : string.length;
    lineRe.lastIndex = nextLF;
    return foldLine(string.slice(0, nextLF), width);
  }());
  // If we haven't reached the first content line yet, don't add an extra \n.
  var prevMoreIndented = string[0] === '\n' || string[0] === ' ';
  var moreIndented;

  // rest of the lines
  var match;
  while ((match = lineRe.exec(string))) {
    var prefix = match[1], line = match[2];
    moreIndented = (line[0] === ' ');
    result += prefix
      + (!prevMoreIndented && !moreIndented && line !== ''
        ? '\n' : '')
      + foldLine(line, width);
    prevMoreIndented = moreIndented;
  }

  return result;
}

// Greedy line breaking.
// Picks the longest line under the limit each time,
// otherwise settles for the shortest line over the limit.
// NB. More-indented lines *cannot* be folded, as that would add an extra \n.
function foldLine(line, width) {
  if (line === '' || line[0] === ' ') return line;

  // Since a more-indented line adds a \n, breaks can't be followed by a space.
  var breakRe = / [^ ]/g; // note: the match index will always be <= length-2.
  var match;
  // start is an inclusive index. end, curr, and next are exclusive.
  var start = 0, end, curr = 0, next = 0;
  var result = '';

  // Invariants: 0 <= start <= length-1.
  //   0 <= curr <= next <= max(0, length-2). curr - start <= width.
  // Inside the loop:
  //   A match implies length >= 2, so curr and next are <= length-2.
  while ((match = breakRe.exec(line))) {
    next = match.index;
    // maintain invariant: curr - start <= width
    if (next - start > width) {
      end = (curr > start) ? curr : next; // derive end <= length-2
      result += '\n' + line.slice(start, end);
      // skip the space that was output as \n
      start = end + 1;                    // derive start <= length-1
    }
    curr = next;
  }

  // By the invariants, start <= length-1, so there is something left over.
  // It is either the whole string or a part starting from non-whitespace.
  result += '\n';
  // Insert a break if the remainder is too long and there is a break available.
  if (line.length - start > width && curr > start) {
    result += line.slice(start, curr) + '\n' + line.slice(curr + 1);
  } else {
    result += line.slice(start);
  }

  return result.slice(1); // drop extra \n joiner
}

// Escapes a double-quoted string.
function escapeString(string) {
  var result = '';
  var char;
  var escapeSeq;

  for (var i = 0; i < string.length; i++) {
    char = string.charCodeAt(i);
    escapeSeq = ESCAPE_SEQUENCES[char];
    result += !escapeSeq && isPrintable(char)
      ? string[i]
      : escapeSeq || encodeHex(char);
  }

  return result;
}

function writeFlowSequence(state, level, object) {
  var _result = '',
      _tag    = state.tag,
      index,
      length;

  for (index = 0, length = object.length; index < length; index += 1) {
    // Write only valid elements.
    if (writeNode(state, level, object[index], false, false)) {
      if (index !== 0) _result += ',' + (!state.condenseFlow ? ' ' : '');
      _result += state.dump;
    }
  }

  state.tag = _tag;
  state.dump = '[' + _result + ']';
}

function writeBlockSequence(state, level, object, compact) {
  var _result = '',
      _tag    = state.tag,
      index,
      length;

  for (index = 0, length = object.length; index < length; index += 1) {
    // Write only valid elements.
    if (writeNode(state, level + 1, object[index], true, true)) {
      if (!compact || index !== 0) {
        _result += generateNextLine(state, level);
      }

      if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
        _result += '-';
      } else {
        _result += '- ';
      }

      _result += state.dump;
    }
  }

  state.tag = _tag;
  state.dump = _result || '[]'; // Empty sequence if no valid values.
}

function writeFlowMapping(state, level, object) {
  var _result       = '',
      _tag          = state.tag,
      objectKeyList = Object.keys(object),
      index,
      length,
      objectKey,
      objectValue,
      pairBuffer;

  for (index = 0, length = objectKeyList.length; index < length; index += 1) {
    pairBuffer = '';

    if (index !== 0) pairBuffer += ', ';

    objectKey = objectKeyList[index];
    objectValue = object[objectKey];

    if (!writeNode(state, level, objectKey, false, false)) {
      continue; // Skip this pair because of invalid key;
    }

    if (state.dump.length > 1024) pairBuffer += '? ';

    pairBuffer += state.dump + ':' + (state.condenseFlow ? '' : ' ');

    if (!writeNode(state, level, objectValue, false, false)) {
      continue; // Skip this pair because of invalid value.
    }

    pairBuffer += state.dump;

    // Both key and value are valid.
    _result += pairBuffer;
  }

  state.tag = _tag;
  state.dump = '{' + _result + '}';
}

function writeBlockMapping(state, level, object, compact) {
  var _result       = '',
      _tag          = state.tag,
      objectKeyList = Object.keys(object),
      index,
      length,
      objectKey,
      objectValue,
      explicitPair,
      pairBuffer;

  // Allow sorting keys so that the output file is deterministic
  if (state.sortKeys === true) {
    // Default sorting
    objectKeyList.sort();
  } else if (typeof state.sortKeys === 'function') {
    // Custom sort function
    objectKeyList.sort(state.sortKeys);
  } else if (state.sortKeys) {
    // Something is wrong
    throw new YAMLException('sortKeys must be a boolean or a function');
  }

  for (index = 0, length = objectKeyList.length; index < length; index += 1) {
    pairBuffer = '';

    if (!compact || index !== 0) {
      pairBuffer += generateNextLine(state, level);
    }

    objectKey = objectKeyList[index];
    objectValue = object[objectKey];

    if (!writeNode(state, level + 1, objectKey, true, true, true)) {
      continue; // Skip this pair because of invalid key.
    }

    explicitPair = (state.tag !== null && state.tag !== '?') ||
                   (state.dump && state.dump.length > 1024);

    if (explicitPair) {
      if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
        pairBuffer += '?';
      } else {
        pairBuffer += '? ';
      }
    }

    pairBuffer += state.dump;

    if (explicitPair) {
      pairBuffer += generateNextLine(state, level);
    }

    if (!writeNode(state, level + 1, objectValue, true, explicitPair)) {
      continue; // Skip this pair because of invalid value.
    }

    if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
      pairBuffer += ':';
    } else {
      pairBuffer += ': ';
    }

    pairBuffer += state.dump;

    // Both key and value are valid.
    _result += pairBuffer;
  }

  state.tag = _tag;
  state.dump = _result || '{}'; // Empty mapping if no valid pairs.
}

function detectType(state, object, explicit) {
  var _result, typeList, index, length, type, style;

  typeList = explicit ? state.explicitTypes : state.implicitTypes;

  for (index = 0, length = typeList.length; index < length; index += 1) {
    type = typeList[index];

    if ((type.instanceOf  || type.predicate) &&
        (!type.instanceOf || ((typeof object === 'object') && (object instanceof type.instanceOf))) &&
        (!type.predicate  || type.predicate(object))) {

      state.tag = explicit ? type.tag : '?';

      if (type.represent) {
        style = state.styleMap[type.tag] || type.defaultStyle;

        if (_toString.call(type.represent) === '[object Function]') {
          _result = type.represent(object, style);
        } else if (_hasOwnProperty.call(type.represent, style)) {
          _result = type.represent[style](object, style);
        } else {
          throw new YAMLException('!<' + type.tag + '> tag resolver accepts not "' + style + '" style');
        }

        state.dump = _result;
      }

      return true;
    }
  }

  return false;
}

// Serializes `object` and writes it to global `result`.
// Returns true on success, or false on invalid object.
//
function writeNode(state, level, object, block, compact, iskey) {
  state.tag = null;
  state.dump = object;

  if (!detectType(state, object, false)) {
    detectType(state, object, true);
  }

  var type = _toString.call(state.dump);

  if (block) {
    block = (state.flowLevel < 0 || state.flowLevel > level);
  }

  var objectOrArray = type === '[object Object]' || type === '[object Array]',
      duplicateIndex,
      duplicate;

  if (objectOrArray) {
    duplicateIndex = state.duplicates.indexOf(object);
    duplicate = duplicateIndex !== -1;
  }

  if ((state.tag !== null && state.tag !== '?') || duplicate || (state.indent !== 2 && level > 0)) {
    compact = false;
  }

  if (duplicate && state.usedDuplicates[duplicateIndex]) {
    state.dump = '*ref_' + duplicateIndex;
  } else {
    if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) {
      state.usedDuplicates[duplicateIndex] = true;
    }
    if (type === '[object Object]') {
      if (block && (Object.keys(state.dump).length !== 0)) {
        writeBlockMapping(state, level, state.dump, compact);
        if (duplicate) {
          state.dump = '&ref_' + duplicateIndex + state.dump;
        }
      } else {
        writeFlowMapping(state, level, state.dump);
        if (duplicate) {
          state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;
        }
      }
    } else if (type === '[object Array]') {
      if (block && (state.dump.length !== 0)) {
        writeBlockSequence(state, level, state.dump, compact);
        if (duplicate) {
          state.dump = '&ref_' + duplicateIndex + state.dump;
        }
      } else {
        writeFlowSequence(state, level, state.dump);
        if (duplicate) {
          state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;
        }
      }
    } else if (type === '[object String]') {
      if (state.tag !== '?') {
        writeScalar(state, state.dump, level, iskey);
      }
    } else {
      if (state.skipInvalid) return false;
      throw new YAMLException('unacceptable kind of an object to dump ' + type);
    }

    if (state.tag !== null && state.tag !== '?') {
      state.dump = '!<' + state.tag + '> ' + state.dump;
    }
  }

  return true;
}

function getDuplicateReferences(object, state) {
  var objects = [],
      duplicatesIndexes = [],
      index,
      length;

  inspectNode(object, objects, duplicatesIndexes);

  for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) {
    state.duplicates.push(objects[duplicatesIndexes[index]]);
  }
  state.usedDuplicates = new Array(length);
}

function inspectNode(object, objects, duplicatesIndexes) {
  var objectKeyList,
      index,
      length;

  if (object !== null && typeof object === 'object') {
    index = objects.indexOf(object);
    if (index !== -1) {
      if (duplicatesIndexes.indexOf(index) === -1) {
        duplicatesIndexes.push(index);
      }
    } else {
      objects.push(object);

      if (Array.isArray(object)) {
        for (index = 0, length = object.length; index < length; index += 1) {
          inspectNode(object[index], objects, duplicatesIndexes);
        }
      } else {
        objectKeyList = Object.keys(object);

        for (index = 0, length = objectKeyList.length; index < length; index += 1) {
          inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes);
        }
      }
    }
  }
}

function dump(input, options) {
  options = options || {};

  var state = new State(options);

  if (!state.noRefs) getDuplicateReferences(input, state);

  if (writeNode(state, 0, input, true, true)) return state.dump + '\n';

  return '';
}

function safeDump(input, options) {
  return dump(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options));
}

module.exports.dump     = dump;
module.exports.safeDump = safeDump;

},{"./common":661,"./exception":663,"./schema/default_full":668,"./schema/default_safe":669}],663:[function(require,module,exports){
// YAML error class. http://stackoverflow.com/questions/8458984
//
'use strict';

function YAMLException(reason, mark) {
  // Super constructor
  Error.call(this);

  this.name = 'YAMLException';
  this.reason = reason;
  this.mark = mark;
  this.message = (this.reason || '(unknown reason)') + (this.mark ? ' ' + this.mark.toString() : '');

  // Include stack trace in error object
  if (Error.captureStackTrace) {
    // Chrome and NodeJS
    Error.captureStackTrace(this, this.constructor);
  } else {
    // FF, IE 10+ and Safari 6+. Fallback for others
    this.stack = (new Error()).stack || '';
  }
}


// Inherit from Error
YAMLException.prototype = Object.create(Error.prototype);
YAMLException.prototype.constructor = YAMLException;


YAMLException.prototype.toString = function toString(compact) {
  var result = this.name + ': ';

  result += this.reason || '(unknown reason)';

  if (!compact && this.mark) {
    result += ' ' + this.mark.toString();
  }

  return result;
};


module.exports = YAMLException;

},{}],664:[function(require,module,exports){
'use strict';

/*eslint-disable max-len,no-use-before-define*/

var common              = require('./common');
var YAMLException       = require('./exception');
var Mark                = require('./mark');
var DEFAULT_SAFE_SCHEMA = require('./schema/default_safe');
var DEFAULT_FULL_SCHEMA = require('./schema/default_full');


var _hasOwnProperty = Object.prototype.hasOwnProperty;


var CONTEXT_FLOW_IN   = 1;
var CONTEXT_FLOW_OUT  = 2;
var CONTEXT_BLOCK_IN  = 3;
var CONTEXT_BLOCK_OUT = 4;


var CHOMPING_CLIP  = 1;
var CHOMPING_STRIP = 2;
var CHOMPING_KEEP  = 3;


var PATTERN_NON_PRINTABLE         = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/;
var PATTERN_FLOW_INDICATORS       = /[,\[\]\{\}]/;
var PATTERN_TAG_HANDLE            = /^(?:!|!!|![a-z\-]+!)$/i;
var PATTERN_TAG_URI               = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i;


function is_EOL(c) {
  return (c === 0x0A/* LF */) || (c === 0x0D/* CR */);
}

function is_WHITE_SPACE(c) {
  return (c === 0x09/* Tab */) || (c === 0x20/* Space */);
}

function is_WS_OR_EOL(c) {
  return (c === 0x09/* Tab */) ||
         (c === 0x20/* Space */) ||
         (c === 0x0A/* LF */) ||
         (c === 0x0D/* CR */);
}

function is_FLOW_INDICATOR(c) {
  return c === 0x2C/* , */ ||
         c === 0x5B/* [ */ ||
         c === 0x5D/* ] */ ||
         c === 0x7B/* { */ ||
         c === 0x7D/* } */;
}

function fromHexCode(c) {
  var lc;

  if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) {
    return c - 0x30;
  }

  /*eslint-disable no-bitwise*/
  lc = c | 0x20;

  if ((0x61/* a */ <= lc) && (lc <= 0x66/* f */)) {
    return lc - 0x61 + 10;
  }

  return -1;
}

function escapedHexLen(c) {
  if (c === 0x78/* x */) { return 2; }
  if (c === 0x75/* u */) { return 4; }
  if (c === 0x55/* U */) { return 8; }
  return 0;
}

function fromDecimalCode(c) {
  if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) {
    return c - 0x30;
  }

  return -1;
}

function simpleEscapeSequence(c) {
  /* eslint-disable indent */
  return (c === 0x30/* 0 */) ? '\x00' :
        (c === 0x61/* a */) ? '\x07' :
        (c === 0x62/* b */) ? '\x08' :
        (c === 0x74/* t */) ? '\x09' :
        (c === 0x09/* Tab */) ? '\x09' :
        (c === 0x6E/* n */) ? '\x0A' :
        (c === 0x76/* v */) ? '\x0B' :
        (c === 0x66/* f */) ? '\x0C' :
        (c === 0x72/* r */) ? '\x0D' :
        (c === 0x65/* e */) ? '\x1B' :
        (c === 0x20/* Space */) ? ' ' :
        (c === 0x22/* " */) ? '\x22' :
        (c === 0x2F/* / */) ? '/' :
        (c === 0x5C/* \ */) ? '\x5C' :
        (c === 0x4E/* N */) ? '\x85' :
        (c === 0x5F/* _ */) ? '\xA0' :
        (c === 0x4C/* L */) ? '\u2028' :
        (c === 0x50/* P */) ? '\u2029' : '';
}

function charFromCodepoint(c) {
  if (c <= 0xFFFF) {
    return String.fromCharCode(c);
  }
  // Encode UTF-16 surrogate pair
  // https://en.wikipedia.org/wiki/UTF-16#Code_points_U.2B010000_to_U.2B10FFFF
  return String.fromCharCode(
    ((c - 0x010000) >> 10) + 0xD800,
    ((c - 0x010000) & 0x03FF) + 0xDC00
  );
}

var simpleEscapeCheck = new Array(256); // integer, for fast access
var simpleEscapeMap = new Array(256);
for (var i = 0; i < 256; i++) {
  simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0;
  simpleEscapeMap[i] = simpleEscapeSequence(i);
}


function State(input, options) {
  this.input = input;

  this.filename  = options['filename']  || null;
  this.schema    = options['schema']    || DEFAULT_FULL_SCHEMA;
  this.onWarning = options['onWarning'] || null;
  this.legacy    = options['legacy']    || false;
  this.json      = options['json']      || false;
  this.listener  = options['listener']  || null;

  this.implicitTypes = this.schema.compiledImplicit;
  this.typeMap       = this.schema.compiledTypeMap;

  this.length     = input.length;
  this.position   = 0;
  this.line       = 0;
  this.lineStart  = 0;
  this.lineIndent = 0;

  this.documents = [];

  /*
  this.version;
  this.checkLineBreaks;
  this.tagMap;
  this.anchorMap;
  this.tag;
  this.anchor;
  this.kind;
  this.result;*/

}


function generateError(state, message) {
  return new YAMLException(
    message,
    new Mark(state.filename, state.input, state.position, state.line, (state.position - state.lineStart)));
}

function throwError(state, message) {
  throw generateError(state, message);
}

function throwWarning(state, message) {
  if (state.onWarning) {
    state.onWarning.call(null, generateError(state, message));
  }
}


var directiveHandlers = {

  YAML: function handleYamlDirective(state, name, args) {

    var match, major, minor;

    if (state.version !== null) {
      throwError(state, 'duplication of %YAML directive');
    }

    if (args.length !== 1) {
      throwError(state, 'YAML directive accepts exactly one argument');
    }

    match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);

    if (match === null) {
      throwError(state, 'ill-formed argument of the YAML directive');
    }

    major = parseInt(match[1], 10);
    minor = parseInt(match[2], 10);

    if (major !== 1) {
      throwError(state, 'unacceptable YAML version of the document');
    }

    state.version = args[0];
    state.checkLineBreaks = (minor < 2);

    if (minor !== 1 && minor !== 2) {
      throwWarning(state, 'unsupported YAML version of the document');
    }
  },

  TAG: function handleTagDirective(state, name, args) {

    var handle, prefix;

    if (args.length !== 2) {
      throwError(state, 'TAG directive accepts exactly two arguments');
    }

    handle = args[0];
    prefix = args[1];

    if (!PATTERN_TAG_HANDLE.test(handle)) {
      throwError(state, 'ill-formed tag handle (first argument) of the TAG directive');
    }

    if (_hasOwnProperty.call(state.tagMap, handle)) {
      throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle');
    }

    if (!PATTERN_TAG_URI.test(prefix)) {
      throwError(state, 'ill-formed tag prefix (second argument) of the TAG directive');
    }

    state.tagMap[handle] = prefix;
  }
};


function captureSegment(state, start, end, checkJson) {
  var _position, _length, _character, _result;

  if (start < end) {
    _result = state.input.slice(start, end);

    if (checkJson) {
      for (_position = 0, _length = _result.length; _position < _length; _position += 1) {
        _character = _result.charCodeAt(_position);
        if (!(_character === 0x09 ||
              (0x20 <= _character && _character <= 0x10FFFF))) {
          throwError(state, 'expected valid JSON character');
        }
      }
    } else if (PATTERN_NON_PRINTABLE.test(_result)) {
      throwError(state, 'the stream contains non-printable characters');
    }

    state.result += _result;
  }
}

function mergeMappings(state, destination, source, overridableKeys) {
  var sourceKeys, key, index, quantity;

  if (!common.isObject(source)) {
    throwError(state, 'cannot merge mappings; the provided source object is unacceptable');
  }

  sourceKeys = Object.keys(source);

  for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
    key = sourceKeys[index];

    if (!_hasOwnProperty.call(destination, key)) {
      destination[key] = source[key];
      overridableKeys[key] = true;
    }
  }
}

function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startPos) {
  var index, quantity;

  keyNode = String(keyNode);

  if (_result === null) {
    _result = {};
  }

  if (keyTag === 'tag:yaml.org,2002:merge') {
    if (Array.isArray(valueNode)) {
      for (index = 0, quantity = valueNode.length; index < quantity; index += 1) {
        mergeMappings(state, _result, valueNode[index], overridableKeys);
      }
    } else {
      mergeMappings(state, _result, valueNode, overridableKeys);
    }
  } else {
    if (!state.json &&
        !_hasOwnProperty.call(overridableKeys, keyNode) &&
        _hasOwnProperty.call(_result, keyNode)) {
      state.line = startLine || state.line;
      state.position = startPos || state.position;
      throwError(state, 'duplicated mapping key');
    }
    _result[keyNode] = valueNode;
    delete overridableKeys[keyNode];
  }

  return _result;
}

function readLineBreak(state) {
  var ch;

  ch = state.input.charCodeAt(state.position);

  if (ch === 0x0A/* LF */) {
    state.position++;
  } else if (ch === 0x0D/* CR */) {
    state.position++;
    if (state.input.charCodeAt(state.position) === 0x0A/* LF */) {
      state.position++;
    }
  } else {
    throwError(state, 'a line break is expected');
  }

  state.line += 1;
  state.lineStart = state.position;
}

function skipSeparationSpace(state, allowComments, checkIndent) {
  var lineBreaks = 0,
      ch = state.input.charCodeAt(state.position);

  while (ch !== 0) {
    while (is_WHITE_SPACE(ch)) {
      ch = state.input.charCodeAt(++state.position);
    }

    if (allowComments && ch === 0x23/* # */) {
      do {
        ch = state.input.charCodeAt(++state.position);
      } while (ch !== 0x0A/* LF */ && ch !== 0x0D/* CR */ && ch !== 0);
    }

    if (is_EOL(ch)) {
      readLineBreak(state);

      ch = state.input.charCodeAt(state.position);
      lineBreaks++;
      state.lineIndent = 0;

      while (ch === 0x20/* Space */) {
        state.lineIndent++;
        ch = state.input.charCodeAt(++state.position);
      }
    } else {
      break;
    }
  }

  if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) {
    throwWarning(state, 'deficient indentation');
  }

  return lineBreaks;
}

function testDocumentSeparator(state) {
  var _position = state.position,
      ch;

  ch = state.input.charCodeAt(_position);

  // Condition state.position === state.lineStart is tested
  // in parent on each call, for efficiency. No needs to test here again.
  if ((ch === 0x2D/* - */ || ch === 0x2E/* . */) &&
      ch === state.input.charCodeAt(_position + 1) &&
      ch === state.input.charCodeAt(_position + 2)) {

    _position += 3;

    ch = state.input.charCodeAt(_position);

    if (ch === 0 || is_WS_OR_EOL(ch)) {
      return true;
    }
  }

  return false;
}

function writeFoldedLines(state, count) {
  if (count === 1) {
    state.result += ' ';
  } else if (count > 1) {
    state.result += common.repeat('\n', count - 1);
  }
}


function readPlainScalar(state, nodeIndent, withinFlowCollection) {
  var preceding,
      following,
      captureStart,
      captureEnd,
      hasPendingContent,
      _line,
      _lineStart,
      _lineIndent,
      _kind = state.kind,
      _result = state.result,
      ch;

  ch = state.input.charCodeAt(state.position);

  if (is_WS_OR_EOL(ch)      ||
      is_FLOW_INDICATOR(ch) ||
      ch === 0x23/* # */    ||
      ch === 0x26/* & */    ||
      ch === 0x2A/* * */    ||
      ch === 0x21/* ! */    ||
      ch === 0x7C/* | */    ||
      ch === 0x3E/* > */    ||
      ch === 0x27/* ' */    ||
      ch === 0x22/* " */    ||
      ch === 0x25/* % */    ||
      ch === 0x40/* @ */    ||
      ch === 0x60/* ` */) {
    return false;
  }

  if (ch === 0x3F/* ? */ || ch === 0x2D/* - */) {
    following = state.input.charCodeAt(state.position + 1);

    if (is_WS_OR_EOL(following) ||
        withinFlowCollection && is_FLOW_INDICATOR(following)) {
      return false;
    }
  }

  state.kind = 'scalar';
  state.result = '';
  captureStart = captureEnd = state.position;
  hasPendingContent = false;

  while (ch !== 0) {
    if (ch === 0x3A/* : */) {
      following = state.input.charCodeAt(state.position + 1);

      if (is_WS_OR_EOL(following) ||
          withinFlowCollection && is_FLOW_INDICATOR(following)) {
        break;
      }

    } else if (ch === 0x23/* # */) {
      preceding = state.input.charCodeAt(state.position - 1);

      if (is_WS_OR_EOL(preceding)) {
        break;
      }

    } else if ((state.position === state.lineStart && testDocumentSeparator(state)) ||
               withinFlowCollection && is_FLOW_INDICATOR(ch)) {
      break;

    } else if (is_EOL(ch)) {
      _line = state.line;
      _lineStart = state.lineStart;
      _lineIndent = state.lineIndent;
      skipSeparationSpace(state, false, -1);

      if (state.lineIndent >= nodeIndent) {
        hasPendingContent = true;
        ch = state.input.charCodeAt(state.position);
        continue;
      } else {
        state.position = captureEnd;
        state.line = _line;
        state.lineStart = _lineStart;
        state.lineIndent = _lineIndent;
        break;
      }
    }

    if (hasPendingContent) {
      captureSegment(state, captureStart, captureEnd, false);
      writeFoldedLines(state, state.line - _line);
      captureStart = captureEnd = state.position;
      hasPendingContent = false;
    }

    if (!is_WHITE_SPACE(ch)) {
      captureEnd = state.position + 1;
    }

    ch = state.input.charCodeAt(++state.position);
  }

  captureSegment(state, captureStart, captureEnd, false);

  if (state.result) {
    return true;
  }

  state.kind = _kind;
  state.result = _result;
  return false;
}

function readSingleQuotedScalar(state, nodeIndent) {
  var ch,
      captureStart, captureEnd;

  ch = state.input.charCodeAt(state.position);

  if (ch !== 0x27/* ' */) {
    return false;
  }

  state.kind = 'scalar';
  state.result = '';
  state.position++;
  captureStart = captureEnd = state.position;

  while ((ch = state.input.charCodeAt(state.position)) !== 0) {
    if (ch === 0x27/* ' */) {
      captureSegment(state, captureStart, state.position, true);
      ch = state.input.charCodeAt(++state.position);

      if (ch === 0x27/* ' */) {
        captureStart = state.position;
        state.position++;
        captureEnd = state.position;
      } else {
        return true;
      }

    } else if (is_EOL(ch)) {
      captureSegment(state, captureStart, captureEnd, true);
      writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
      captureStart = captureEnd = state.position;

    } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
      throwError(state, 'unexpected end of the document within a single quoted scalar');

    } else {
      state.position++;
      captureEnd = state.position;
    }
  }

  throwError(state, 'unexpected end of the stream within a single quoted scalar');
}

function readDoubleQuotedScalar(state, nodeIndent) {
  var captureStart,
      captureEnd,
      hexLength,
      hexResult,
      tmp,
      ch;

  ch = state.input.charCodeAt(state.position);

  if (ch !== 0x22/* " */) {
    return false;
  }

  state.kind = 'scalar';
  state.result = '';
  state.position++;
  captureStart = captureEnd = state.position;

  while ((ch = state.input.charCodeAt(state.position)) !== 0) {
    if (ch === 0x22/* " */) {
      captureSegment(state, captureStart, state.position, true);
      state.position++;
      return true;

    } else if (ch === 0x5C/* \ */) {
      captureSegment(state, captureStart, state.position, true);
      ch = state.input.charCodeAt(++state.position);

      if (is_EOL(ch)) {
        skipSeparationSpace(state, false, nodeIndent);

        // TODO: rework to inline fn with no type cast?
      } else if (ch < 256 && simpleEscapeCheck[ch]) {
        state.result += simpleEscapeMap[ch];
        state.position++;

      } else if ((tmp = escapedHexLen(ch)) > 0) {
        hexLength = tmp;
        hexResult = 0;

        for (; hexLength > 0; hexLength--) {
          ch = state.input.charCodeAt(++state.position);

          if ((tmp = fromHexCode(ch)) >= 0) {
            hexResult = (hexResult << 4) + tmp;

          } else {
            throwError(state, 'expected hexadecimal character');
          }
        }

        state.result += charFromCodepoint(hexResult);

        state.position++;

      } else {
        throwError(state, 'unknown escape sequence');
      }

      captureStart = captureEnd = state.position;

    } else if (is_EOL(ch)) {
      captureSegment(state, captureStart, captureEnd, true);
      writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
      captureStart = captureEnd = state.position;

    } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
      throwError(state, 'unexpected end of the document within a double quoted scalar');

    } else {
      state.position++;
      captureEnd = state.position;
    }
  }

  throwError(state, 'unexpected end of the stream within a double quoted scalar');
}

function readFlowCollection(state, nodeIndent) {
  var readNext = true,
      _line,
      _tag     = state.tag,
      _result,
      _anchor  = state.anchor,
      following,
      terminator,
      isPair,
      isExplicitPair,
      isMapping,
      overridableKeys = {},
      keyNode,
      keyTag,
      valueNode,
      ch;

  ch = state.input.charCodeAt(state.position);

  if (ch === 0x5B/* [ */) {
    terminator = 0x5D;/* ] */
    isMapping = false;
    _result = [];
  } else if (ch === 0x7B/* { */) {
    terminator = 0x7D;/* } */
    isMapping = true;
    _result = {};
  } else {
    return false;
  }

  if (state.anchor !== null) {
    state.anchorMap[state.anchor] = _result;
  }

  ch = state.input.charCodeAt(++state.position);

  while (ch !== 0) {
    skipSeparationSpace(state, true, nodeIndent);

    ch = state.input.charCodeAt(state.position);

    if (ch === terminator) {
      state.position++;
      state.tag = _tag;
      state.anchor = _anchor;
      state.kind = isMapping ? 'mapping' : 'sequence';
      state.result = _result;
      return true;
    } else if (!readNext) {
      throwError(state, 'missed comma between flow collection entries');
    }

    keyTag = keyNode = valueNode = null;
    isPair = isExplicitPair = false;

    if (ch === 0x3F/* ? */) {
      following = state.input.charCodeAt(state.position + 1);

      if (is_WS_OR_EOL(following)) {
        isPair = isExplicitPair = true;
        state.position++;
        skipSeparationSpace(state, true, nodeIndent);
      }
    }

    _line = state.line;
    composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
    keyTag = state.tag;
    keyNode = state.result;
    skipSeparationSpace(state, true, nodeIndent);

    ch = state.input.charCodeAt(state.position);

    if ((isExplicitPair || state.line === _line) && ch === 0x3A/* : */) {
      isPair = true;
      ch = state.input.charCodeAt(++state.position);
      skipSeparationSpace(state, true, nodeIndent);
      composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
      valueNode = state.result;
    }

    if (isMapping) {
      storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode);
    } else if (isPair) {
      _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode));
    } else {
      _result.push(keyNode);
    }

    skipSeparationSpace(state, true, nodeIndent);

    ch = state.input.charCodeAt(state.position);

    if (ch === 0x2C/* , */) {
      readNext = true;
      ch = state.input.charCodeAt(++state.position);
    } else {
      readNext = false;
    }
  }

  throwError(state, 'unexpected end of the stream within a flow collection');
}

function readBlockScalar(state, nodeIndent) {
  var captureStart,
      folding,
      chomping       = CHOMPING_CLIP,
      didReadContent = false,
      detectedIndent = false,
      textIndent     = nodeIndent,
      emptyLines     = 0,
      atMoreIndented = false,
      tmp,
      ch;

  ch = state.input.charCodeAt(state.position);

  if (ch === 0x7C/* | */) {
    folding = false;
  } else if (ch === 0x3E/* > */) {
    folding = true;
  } else {
    return false;
  }

  state.kind = 'scalar';
  state.result = '';

  while (ch !== 0) {
    ch = state.input.charCodeAt(++state.position);

    if (ch === 0x2B/* + */ || ch === 0x2D/* - */) {
      if (CHOMPING_CLIP === chomping) {
        chomping = (ch === 0x2B/* + */) ? CHOMPING_KEEP : CHOMPING_STRIP;
      } else {
        throwError(state, 'repeat of a chomping mode identifier');
      }

    } else if ((tmp = fromDecimalCode(ch)) >= 0) {
      if (tmp === 0) {
        throwError(state, 'bad explicit indentation width of a block scalar; it cannot be less than one');
      } else if (!detectedIndent) {
        textIndent = nodeIndent + tmp - 1;
        detectedIndent = true;
      } else {
        throwError(state, 'repeat of an indentation width identifier');
      }

    } else {
      break;
    }
  }

  if (is_WHITE_SPACE(ch)) {
    do { ch = state.input.charCodeAt(++state.position); }
    while (is_WHITE_SPACE(ch));

    if (ch === 0x23/* # */) {
      do { ch = state.input.charCodeAt(++state.position); }
      while (!is_EOL(ch) && (ch !== 0));
    }
  }

  while (ch !== 0) {
    readLineBreak(state);
    state.lineIndent = 0;

    ch = state.input.charCodeAt(state.position);

    while ((!detectedIndent || state.lineIndent < textIndent) &&
           (ch === 0x20/* Space */)) {
      state.lineIndent++;
      ch = state.input.charCodeAt(++state.position);
    }

    if (!detectedIndent && state.lineIndent > textIndent) {
      textIndent = state.lineIndent;
    }

    if (is_EOL(ch)) {
      emptyLines++;
      continue;
    }

    // End of the scalar.
    if (state.lineIndent < textIndent) {

      // Perform the chomping.
      if (chomping === CHOMPING_KEEP) {
        state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
      } else if (chomping === CHOMPING_CLIP) {
        if (didReadContent) { // i.e. only if the scalar is not empty.
          state.result += '\n';
        }
      }

      // Break this `while` cycle and go to the funciton's epilogue.
      break;
    }

    // Folded style: use fancy rules to handle line breaks.
    if (folding) {

      // Lines starting with white space characters (more-indented lines) are not folded.
      if (is_WHITE_SPACE(ch)) {
        atMoreIndented = true;
        // except for the first content line (cf. Example 8.1)
        state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);

      // End of more-indented block.
      } else if (atMoreIndented) {
        atMoreIndented = false;
        state.result += common.repeat('\n', emptyLines + 1);

      // Just one line break - perceive as the same line.
      } else if (emptyLines === 0) {
        if (didReadContent) { // i.e. only if we have already read some scalar content.
          state.result += ' ';
        }

      // Several line breaks - perceive as different lines.
      } else {
        state.result += common.repeat('\n', emptyLines);
      }

    // Literal style: just add exact number of line breaks between content lines.
    } else {
      // Keep all line breaks except the header line break.
      state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
    }

    didReadContent = true;
    detectedIndent = true;
    emptyLines = 0;
    captureStart = state.position;

    while (!is_EOL(ch) && (ch !== 0)) {
      ch = state.input.charCodeAt(++state.position);
    }

    captureSegment(state, captureStart, state.position, false);
  }

  return true;
}

function readBlockSequence(state, nodeIndent) {
  var _line,
      _tag      = state.tag,
      _anchor   = state.anchor,
      _result   = [],
      following,
      detected  = false,
      ch;

  if (state.anchor !== null) {
    state.anchorMap[state.anchor] = _result;
  }

  ch = state.input.charCodeAt(state.position);

  while (ch !== 0) {

    if (ch !== 0x2D/* - */) {
      break;
    }

    following = state.input.charCodeAt(state.position + 1);

    if (!is_WS_OR_EOL(following)) {
      break;
    }

    detected = true;
    state.position++;

    if (skipSeparationSpace(state, true, -1)) {
      if (state.lineIndent <= nodeIndent) {
        _result.push(null);
        ch = state.input.charCodeAt(state.position);
        continue;
      }
    }

    _line = state.line;
    composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true);
    _result.push(state.result);
    skipSeparationSpace(state, true, -1);

    ch = state.input.charCodeAt(state.position);

    if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) {
      throwError(state, 'bad indentation of a sequence entry');
    } else if (state.lineIndent < nodeIndent) {
      break;
    }
  }

  if (detected) {
    state.tag = _tag;
    state.anchor = _anchor;
    state.kind = 'sequence';
    state.result = _result;
    return true;
  }
  return false;
}

function readBlockMapping(state, nodeIndent, flowIndent) {
  var following,
      allowCompact,
      _line,
      _pos,
      _tag          = state.tag,
      _anchor       = state.anchor,
      _result       = {},
      overridableKeys = {},
      keyTag        = null,
      keyNode       = null,
      valueNode     = null,
      atExplicitKey = false,
      detected      = false,
      ch;

  if (state.anchor !== null) {
    state.anchorMap[state.anchor] = _result;
  }

  ch = state.input.charCodeAt(state.position);

  while (ch !== 0) {
    following = state.input.charCodeAt(state.position + 1);
    _line = state.line; // Save the current line.
    _pos = state.position;

    //
    // Explicit notation case. There are two separate blocks:
    // first for the key (denoted by "?") and second for the value (denoted by ":")
    //
    if ((ch === 0x3F/* ? */ || ch === 0x3A/* : */) && is_WS_OR_EOL(following)) {

      if (ch === 0x3F/* ? */) {
        if (atExplicitKey) {
          storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);
          keyTag = keyNode = valueNode = null;
        }

        detected = true;
        atExplicitKey = true;
        allowCompact = true;

      } else if (atExplicitKey) {
        // i.e. 0x3A/* : */ === character after the explicit key.
        atExplicitKey = false;
        allowCompact = true;

      } else {
        throwError(state, 'incomplete explicit mapping pair; a key node is missed');
      }

      state.position += 1;
      ch = following;

    //
    // Implicit notation case. Flow-style node as the key first, then ":", and the value.
    //
    } else if (composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) {

      if (state.line === _line) {
        ch = state.input.charCodeAt(state.position);

        while (is_WHITE_SPACE(ch)) {
          ch = state.input.charCodeAt(++state.position);
        }

        if (ch === 0x3A/* : */) {
          ch = state.input.charCodeAt(++state.position);

          if (!is_WS_OR_EOL(ch)) {
            throwError(state, 'a whitespace character is expected after the key-value separator within a block mapping');
          }

          if (atExplicitKey) {
            storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);
            keyTag = keyNode = valueNode = null;
          }

          detected = true;
          atExplicitKey = false;
          allowCompact = false;
          keyTag = state.tag;
          keyNode = state.result;

        } else if (detected) {
          throwError(state, 'can not read an implicit mapping pair; a colon is missed');

        } else {
          state.tag = _tag;
          state.anchor = _anchor;
          return true; // Keep the result of `composeNode`.
        }

      } else if (detected) {
        throwError(state, 'can not read a block mapping entry; a multiline key may not be an implicit key');

      } else {
        state.tag = _tag;
        state.anchor = _anchor;
        return true; // Keep the result of `composeNode`.
      }

    } else {
      break; // Reading is done. Go to the epilogue.
    }

    //
    // Common reading code for both explicit and implicit notations.
    //
    if (state.line === _line || state.lineIndent > nodeIndent) {
      if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) {
        if (atExplicitKey) {
          keyNode = state.result;
        } else {
          valueNode = state.result;
        }
      }

      if (!atExplicitKey) {
        storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _pos);
        keyTag = keyNode = valueNode = null;
      }

      skipSeparationSpace(state, true, -1);
      ch = state.input.charCodeAt(state.position);
    }

    if (state.lineIndent > nodeIndent && (ch !== 0)) {
      throwError(state, 'bad indentation of a mapping entry');
    } else if (state.lineIndent < nodeIndent) {
      break;
    }
  }

  //
  // Epilogue.
  //

  // Special case: last mapping's node contains only the key in explicit notation.
  if (atExplicitKey) {
    storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);
  }

  // Expose the resulting mapping.
  if (detected) {
    state.tag = _tag;
    state.anchor = _anchor;
    state.kind = 'mapping';
    state.result = _result;
  }

  return detected;
}

function readTagProperty(state) {
  var _position,
      isVerbatim = false,
      isNamed    = false,
      tagHandle,
      tagName,
      ch;

  ch = state.input.charCodeAt(state.position);

  if (ch !== 0x21/* ! */) return false;

  if (state.tag !== null) {
    throwError(state, 'duplication of a tag property');
  }

  ch = state.input.charCodeAt(++state.position);

  if (ch === 0x3C/* < */) {
    isVerbatim = true;
    ch = state.input.charCodeAt(++state.position);

  } else if (ch === 0x21/* ! */) {
    isNamed = true;
    tagHandle = '!!';
    ch = state.input.charCodeAt(++state.position);

  } else {
    tagHandle = '!';
  }

  _position = state.position;

  if (isVerbatim) {
    do { ch = state.input.charCodeAt(++state.position); }
    while (ch !== 0 && ch !== 0x3E/* > */);

    if (state.position < state.length) {
      tagName = state.input.slice(_position, state.position);
      ch = state.input.charCodeAt(++state.position);
    } else {
      throwError(state, 'unexpected end of the stream within a verbatim tag');
    }
  } else {
    while (ch !== 0 && !is_WS_OR_EOL(ch)) {

      if (ch === 0x21/* ! */) {
        if (!isNamed) {
          tagHandle = state.input.slice(_position - 1, state.position + 1);

          if (!PATTERN_TAG_HANDLE.test(tagHandle)) {
            throwError(state, 'named tag handle cannot contain such characters');
          }

          isNamed = true;
          _position = state.position + 1;
        } else {
          throwError(state, 'tag suffix cannot contain exclamation marks');
        }
      }

      ch = state.input.charCodeAt(++state.position);
    }

    tagName = state.input.slice(_position, state.position);

    if (PATTERN_FLOW_INDICATORS.test(tagName)) {
      throwError(state, 'tag suffix cannot contain flow indicator characters');
    }
  }

  if (tagName && !PATTERN_TAG_URI.test(tagName)) {
    throwError(state, 'tag name cannot contain such characters: ' + tagName);
  }

  if (isVerbatim) {
    state.tag = tagName;

  } else if (_hasOwnProperty.call(state.tagMap, tagHandle)) {
    state.tag = state.tagMap[tagHandle] + tagName;

  } else if (tagHandle === '!') {
    state.tag = '!' + tagName;

  } else if (tagHandle === '!!') {
    state.tag = 'tag:yaml.org,2002:' + tagName;

  } else {
    throwError(state, 'undeclared tag handle "' + tagHandle + '"');
  }

  return true;
}

function readAnchorProperty(state) {
  var _position,
      ch;

  ch = state.input.charCodeAt(state.position);

  if (ch !== 0x26/* & */) return false;

  if (state.anchor !== null) {
    throwError(state, 'duplication of an anchor property');
  }

  ch = state.input.charCodeAt(++state.position);
  _position = state.position;

  while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
    ch = state.input.charCodeAt(++state.position);
  }

  if (state.position === _position) {
    throwError(state, 'name of an anchor node must contain at least one character');
  }

  state.anchor = state.input.slice(_position, state.position);
  return true;
}

function readAlias(state) {
  var _position, alias,
      ch;

  ch = state.input.charCodeAt(state.position);

  if (ch !== 0x2A/* * */) return false;

  ch = state.input.charCodeAt(++state.position);
  _position = state.position;

  while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
    ch = state.input.charCodeAt(++state.position);
  }

  if (state.position === _position) {
    throwError(state, 'name of an alias node must contain at least one character');
  }

  alias = state.input.slice(_position, state.position);

  if (!state.anchorMap.hasOwnProperty(alias)) {
    throwError(state, 'unidentified alias "' + alias + '"');
  }

  state.result = state.anchorMap[alias];
  skipSeparationSpace(state, true, -1);
  return true;
}

function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) {
  var allowBlockStyles,
      allowBlockScalars,
      allowBlockCollections,
      indentStatus = 1, // 1: this>parent, 0: this=parent, -1: this<parent
      atNewLine  = false,
      hasContent = false,
      typeIndex,
      typeQuantity,
      type,
      flowIndent,
      blockIndent;

  if (state.listener !== null) {
    state.listener('open', state);
  }

  state.tag    = null;
  state.anchor = null;
  state.kind   = null;
  state.result = null;

  allowBlockStyles = allowBlockScalars = allowBlockCollections =
    CONTEXT_BLOCK_OUT === nodeContext ||
    CONTEXT_BLOCK_IN  === nodeContext;

  if (allowToSeek) {
    if (skipSeparationSpace(state, true, -1)) {
      atNewLine = true;

      if (state.lineIndent > parentIndent) {
        indentStatus = 1;
      } else if (state.lineIndent === parentIndent) {
        indentStatus = 0;
      } else if (state.lineIndent < parentIndent) {
        indentStatus = -1;
      }
    }
  }

  if (indentStatus === 1) {
    while (readTagProperty(state) || readAnchorProperty(state)) {
      if (skipSeparationSpace(state, true, -1)) {
        atNewLine = true;
        allowBlockCollections = allowBlockStyles;

        if (state.lineIndent > parentIndent) {
          indentStatus = 1;
        } else if (state.lineIndent === parentIndent) {
          indentStatus = 0;
        } else if (state.lineIndent < parentIndent) {
          indentStatus = -1;
        }
      } else {
        allowBlockCollections = false;
      }
    }
  }

  if (allowBlockCollections) {
    allowBlockCollections = atNewLine || allowCompact;
  }

  if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) {
    if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) {
      flowIndent = parentIndent;
    } else {
      flowIndent = parentIndent + 1;
    }

    blockIndent = state.position - state.lineStart;

    if (indentStatus === 1) {
      if (allowBlockCollections &&
          (readBlockSequence(state, blockIndent) ||
           readBlockMapping(state, blockIndent, flowIndent)) ||
          readFlowCollection(state, flowIndent)) {
        hasContent = true;
      } else {
        if ((allowBlockScalars && readBlockScalar(state, flowIndent)) ||
            readSingleQuotedScalar(state, flowIndent) ||
            readDoubleQuotedScalar(state, flowIndent)) {
          hasContent = true;

        } else if (readAlias(state)) {
          hasContent = true;

          if (state.tag !== null || state.anchor !== null) {
            throwError(state, 'alias node should not have any properties');
          }

        } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) {
          hasContent = true;

          if (state.tag === null) {
            state.tag = '?';
          }
        }

        if (state.anchor !== null) {
          state.anchorMap[state.anchor] = state.result;
        }
      }
    } else if (indentStatus === 0) {
      // Special case: block sequences are allowed to have same indentation level as the parent.
      // http://www.yaml.org/spec/1.2/spec.html#id2799784
      hasContent = allowBlockCollections && readBlockSequence(state, blockIndent);
    }
  }

  if (state.tag !== null && state.tag !== '!') {
    if (state.tag === '?') {
      for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) {
        type = state.implicitTypes[typeIndex];

        // Implicit resolving is not allowed for non-scalar types, and '?'
        // non-specific tag is only assigned to plain scalars. So, it isn't
        // needed to check for 'kind' conformity.

        if (type.resolve(state.result)) { // `state.result` updated in resolver if matched
          state.result = type.construct(state.result);
          state.tag = type.tag;
          if (state.anchor !== null) {
            state.anchorMap[state.anchor] = state.result;
          }
          break;
        }
      }
    } else if (_hasOwnProperty.call(state.typeMap[state.kind || 'fallback'], state.tag)) {
      type = state.typeMap[state.kind || 'fallback'][state.tag];

      if (state.result !== null && type.kind !== state.kind) {
        throwError(state, 'unacceptable node kind for !<' + state.tag + '> tag; it should be "' + type.kind + '", not "' + state.kind + '"');
      }

      if (!type.resolve(state.result)) { // `state.result` updated in resolver if matched
        throwError(state, 'cannot resolve a node with !<' + state.tag + '> explicit tag');
      } else {
        state.result = type.construct(state.result);
        if (state.anchor !== null) {
          state.anchorMap[state.anchor] = state.result;
        }
      }
    } else {
      throwError(state, 'unknown tag !<' + state.tag + '>');
    }
  }

  if (state.listener !== null) {
    state.listener('close', state);
  }
  return state.tag !== null ||  state.anchor !== null || hasContent;
}

function readDocument(state) {
  var documentStart = state.position,
      _position,
      directiveName,
      directiveArgs,
      hasDirectives = false,
      ch;

  state.version = null;
  state.checkLineBreaks = state.legacy;
  state.tagMap = {};
  state.anchorMap = {};

  while ((ch = state.input.charCodeAt(state.position)) !== 0) {
    skipSeparationSpace(state, true, -1);

    ch = state.input.charCodeAt(state.position);

    if (state.lineIndent > 0 || ch !== 0x25/* % */) {
      break;
    }

    hasDirectives = true;
    ch = state.input.charCodeAt(++state.position);
    _position = state.position;

    while (ch !== 0 && !is_WS_OR_EOL(ch)) {
      ch = state.input.charCodeAt(++state.position);
    }

    directiveName = state.input.slice(_position, state.position);
    directiveArgs = [];

    if (directiveName.length < 1) {
      throwError(state, 'directive name must not be less than one character in length');
    }

    while (ch !== 0) {
      while (is_WHITE_SPACE(ch)) {
        ch = state.input.charCodeAt(++state.position);
      }

      if (ch === 0x23/* # */) {
        do { ch = state.input.charCodeAt(++state.position); }
        while (ch !== 0 && !is_EOL(ch));
        break;
      }

      if (is_EOL(ch)) break;

      _position = state.position;

      while (ch !== 0 && !is_WS_OR_EOL(ch)) {
        ch = state.input.charCodeAt(++state.position);
      }

      directiveArgs.push(state.input.slice(_position, state.position));
    }

    if (ch !== 0) readLineBreak(state);

    if (_hasOwnProperty.call(directiveHandlers, directiveName)) {
      directiveHandlers[directiveName](state, directiveName, directiveArgs);
    } else {
      throwWarning(state, 'unknown document directive "' + directiveName + '"');
    }
  }

  skipSeparationSpace(state, true, -1);

  if (state.lineIndent === 0 &&
      state.input.charCodeAt(state.position)     === 0x2D/* - */ &&
      state.input.charCodeAt(state.position + 1) === 0x2D/* - */ &&
      state.input.charCodeAt(state.position + 2) === 0x2D/* - */) {
    state.position += 3;
    skipSeparationSpace(state, true, -1);

  } else if (hasDirectives) {
    throwError(state, 'directives end mark is expected');
  }

  composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true);
  skipSeparationSpace(state, true, -1);

  if (state.checkLineBreaks &&
      PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) {
    throwWarning(state, 'non-ASCII line breaks are interpreted as content');
  }

  state.documents.push(state.result);

  if (state.position === state.lineStart && testDocumentSeparator(state)) {

    if (state.input.charCodeAt(state.position) === 0x2E/* . */) {
      state.position += 3;
      skipSeparationSpace(state, true, -1);
    }
    return;
  }

  if (state.position < (state.length - 1)) {
    throwError(state, 'end of the stream or a document separator is expected');
  } else {
    return;
  }
}


function loadDocuments(input, options) {
  input = String(input);
  options = options || {};

  if (input.length !== 0) {

    // Add tailing `\n` if not exists
    if (input.charCodeAt(input.length - 1) !== 0x0A/* LF */ &&
        input.charCodeAt(input.length - 1) !== 0x0D/* CR */) {
      input += '\n';
    }

    // Strip BOM
    if (input.charCodeAt(0) === 0xFEFF) {
      input = input.slice(1);
    }
  }

  var state = new State(input, options);

  // Use 0 as string terminator. That significantly simplifies bounds check.
  state.input += '\0';

  while (state.input.charCodeAt(state.position) === 0x20/* Space */) {
    state.lineIndent += 1;
    state.position += 1;
  }

  while (state.position < (state.length - 1)) {
    readDocument(state);
  }

  return state.documents;
}


function loadAll(input, iterator, options) {
  var documents = loadDocuments(input, options), index, length;

  if (typeof iterator !== 'function') {
    return documents;
  }

  for (index = 0, length = documents.length; index < length; index += 1) {
    iterator(documents[index]);
  }
}


function load(input, options) {
  var documents = loadDocuments(input, options);

  if (documents.length === 0) {
    /*eslint-disable no-undefined*/
    return undefined;
  } else if (documents.length === 1) {
    return documents[0];
  }
  throw new YAMLException('expected a single document in the stream, but found more');
}


function safeLoadAll(input, output, options) {
  if (typeof output === 'function') {
    loadAll(input, output, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options));
  } else {
    return loadAll(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options));
  }
}


function safeLoad(input, options) {
  return load(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options));
}


module.exports.loadAll     = loadAll;
module.exports.load        = load;
module.exports.safeLoadAll = safeLoadAll;
module.exports.safeLoad    = safeLoad;

},{"./common":661,"./exception":663,"./mark":665,"./schema/default_full":668,"./schema/default_safe":669}],665:[function(require,module,exports){
'use strict';


var common = require('./common');


function Mark(name, buffer, position, line, column) {
  this.name     = name;
  this.buffer   = buffer;
  this.position = position;
  this.line     = line;
  this.column   = column;
}


Mark.prototype.getSnippet = function getSnippet(indent, maxLength) {
  var head, start, tail, end, snippet;

  if (!this.buffer) return null;

  indent = indent || 4;
  maxLength = maxLength || 75;

  head = '';
  start = this.position;

  while (start > 0 && '\x00\r\n\x85\u2028\u2029'.indexOf(this.buffer.charAt(start - 1)) === -1) {
    start -= 1;
    if (this.position - start > (maxLength / 2 - 1)) {
      head = ' ... ';
      start += 5;
      break;
    }
  }

  tail = '';
  end = this.position;

  while (end < this.buffer.length && '\x00\r\n\x85\u2028\u2029'.indexOf(this.buffer.charAt(end)) === -1) {
    end += 1;
    if (end - this.position > (maxLength / 2 - 1)) {
      tail = ' ... ';
      end -= 5;
      break;
    }
  }

  snippet = this.buffer.slice(start, end);

  return common.repeat(' ', indent) + head + snippet + tail + '\n' +
         common.repeat(' ', indent + this.position - start + head.length) + '^';
};


Mark.prototype.toString = function toString(compact) {
  var snippet, where = '';

  if (this.name) {
    where += 'in "' + this.name + '" ';
  }

  where += 'at line ' + (this.line + 1) + ', column ' + (this.column + 1);

  if (!compact) {
    snippet = this.getSnippet();

    if (snippet) {
      where += ':\n' + snippet;
    }
  }

  return where;
};


module.exports = Mark;

},{"./common":661}],666:[function(require,module,exports){
'use strict';

/*eslint-disable max-len*/

var common        = require('./common');
var YAMLException = require('./exception');
var Type          = require('./type');


function compileList(schema, name, result) {
  var exclude = [];

  schema.include.forEach(function (includedSchema) {
    result = compileList(includedSchema, name, result);
  });

  schema[name].forEach(function (currentType) {
    result.forEach(function (previousType, previousIndex) {
      if (previousType.tag === currentType.tag && previousType.kind === currentType.kind) {
        exclude.push(previousIndex);
      }
    });

    result.push(currentType);
  });

  return result.filter(function (type, index) {
    return exclude.indexOf(index) === -1;
  });
}


function compileMap(/* lists... */) {
  var result = {
        scalar: {},
        sequence: {},
        mapping: {},
        fallback: {}
      }, index, length;

  function collectType(type) {
    result[type.kind][type.tag] = result['fallback'][type.tag] = type;
  }

  for (index = 0, length = arguments.length; index < length; index += 1) {
    arguments[index].forEach(collectType);
  }
  return result;
}


function Schema(definition) {
  this.include  = definition.include  || [];
  this.implicit = definition.implicit || [];
  this.explicit = definition.explicit || [];

  this.implicit.forEach(function (type) {
    if (type.loadKind && type.loadKind !== 'scalar') {
      throw new YAMLException('There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.');
    }
  });

  this.compiledImplicit = compileList(this, 'implicit', []);
  this.compiledExplicit = compileList(this, 'explicit', []);
  this.compiledTypeMap  = compileMap(this.compiledImplicit, this.compiledExplicit);
}


Schema.DEFAULT = null;


Schema.create = function createSchema() {
  var schemas, types;

  switch (arguments.length) {
    case 1:
      schemas = Schema.DEFAULT;
      types = arguments[0];
      break;

    case 2:
      schemas = arguments[0];
      types = arguments[1];
      break;

    default:
      throw new YAMLException('Wrong number of arguments for Schema.create function');
  }

  schemas = common.toArray(schemas);
  types = common.toArray(types);

  if (!schemas.every(function (schema) { return schema instanceof Schema; })) {
    throw new YAMLException('Specified list of super schemas (or a single Schema object) contains a non-Schema object.');
  }

  if (!types.every(function (type) { return type instanceof Type; })) {
    throw new YAMLException('Specified list of YAML types (or a single Type object) contains a non-Type object.');
  }

  return new Schema({
    include: schemas,
    explicit: types
  });
};


module.exports = Schema;

},{"./common":661,"./exception":663,"./type":672}],667:[function(require,module,exports){
// Standard YAML's Core schema.
// http://www.yaml.org/spec/1.2/spec.html#id2804923
//
// NOTE: JS-YAML does not support schema-specific tag resolution restrictions.
// So, Core schema has no distinctions from JSON schema is JS-YAML.


'use strict';


var Schema = require('../schema');


module.exports = new Schema({
  include: [
    require('./json')
  ]
});

},{"../schema":666,"./json":671}],668:[function(require,module,exports){
// JS-YAML's default schema for `load` function.
// It is not described in the YAML specification.
//
// This schema is based on JS-YAML's default safe schema and includes
// JavaScript-specific types: !!js/undefined, !!js/regexp and !!js/function.
//
// Also this schema is used as default base schema at `Schema.create` function.


'use strict';


var Schema = require('../schema');


module.exports = Schema.DEFAULT = new Schema({
  include: [
    require('./default_safe')
  ],
  explicit: [
    require('../type/js/undefined'),
    require('../type/js/regexp'),
    require('../type/js/function')
  ]
});

},{"../schema":666,"../type/js/function":677,"../type/js/regexp":678,"../type/js/undefined":679,"./default_safe":669}],669:[function(require,module,exports){
// JS-YAML's default schema for `safeLoad` function.
// It is not described in the YAML specification.
//
// This schema is based on standard YAML's Core schema and includes most of
// extra types described at YAML tag repository. (http://yaml.org/type/)


'use strict';


var Schema = require('../schema');


module.exports = new Schema({
  include: [
    require('./core')
  ],
  implicit: [
    require('../type/timestamp'),
    require('../type/merge')
  ],
  explicit: [
    require('../type/binary'),
    require('../type/omap'),
    require('../type/pairs'),
    require('../type/set')
  ]
});

},{"../schema":666,"../type/binary":673,"../type/merge":681,"../type/omap":683,"../type/pairs":684,"../type/set":686,"../type/timestamp":688,"./core":667}],670:[function(require,module,exports){
// Standard YAML's Failsafe schema.
// http://www.yaml.org/spec/1.2/spec.html#id2802346


'use strict';


var Schema = require('../schema');


module.exports = new Schema({
  explicit: [
    require('../type/str'),
    require('../type/seq'),
    require('../type/map')
  ]
});

},{"../schema":666,"../type/map":680,"../type/seq":685,"../type/str":687}],671:[function(require,module,exports){
// Standard YAML's JSON schema.
// http://www.yaml.org/spec/1.2/spec.html#id2803231
//
// NOTE: JS-YAML does not support schema-specific tag resolution restrictions.
// So, this schema is not such strict as defined in the YAML specification.
// It allows numbers in binary notaion, use `Null` and `NULL` as `null`, etc.


'use strict';


var Schema = require('../schema');


module.exports = new Schema({
  include: [
    require('./failsafe')
  ],
  implicit: [
    require('../type/null'),
    require('../type/bool'),
    require('../type/int'),
    require('../type/float')
  ]
});

},{"../schema":666,"../type/bool":674,"../type/float":675,"../type/int":676,"../type/null":682,"./failsafe":670}],672:[function(require,module,exports){
'use strict';

var YAMLException = require('./exception');

var TYPE_CONSTRUCTOR_OPTIONS = [
  'kind',
  'resolve',
  'construct',
  'instanceOf',
  'predicate',
  'represent',
  'defaultStyle',
  'styleAliases'
];

var YAML_NODE_KINDS = [
  'scalar',
  'sequence',
  'mapping'
];

function compileStyleAliases(map) {
  var result = {};

  if (map !== null) {
    Object.keys(map).forEach(function (style) {
      map[style].forEach(function (alias) {
        result[String(alias)] = style;
      });
    });
  }

  return result;
}

function Type(tag, options) {
  options = options || {};

  Object.keys(options).forEach(function (name) {
    if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) {
      throw new YAMLException('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.');
    }
  });

  // TODO: Add tag format check.
  this.tag          = tag;
  this.kind         = options['kind']         || null;
  this.resolve      = options['resolve']      || function () { return true; };
  this.construct    = options['construct']    || function (data) { return data; };
  this.instanceOf   = options['instanceOf']   || null;
  this.predicate    = options['predicate']    || null;
  this.represent    = options['represent']    || null;
  this.defaultStyle = options['defaultStyle'] || null;
  this.styleAliases = compileStyleAliases(options['styleAliases'] || null);

  if (YAML_NODE_KINDS.indexOf(this.kind) === -1) {
    throw new YAMLException('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.');
  }
}

module.exports = Type;

},{"./exception":663}],673:[function(require,module,exports){
'use strict';

/*eslint-disable no-bitwise*/

var NodeBuffer;

try {
  // A trick for browserified version, to not include `Buffer` shim
  var _require = require;
  NodeBuffer = _require('buffer').Buffer;
} catch (__) {}

var Type       = require('../type');


// [ 64, 65, 66 ] -> [ padding, CR, LF ]
var BASE64_MAP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r';


function resolveYamlBinary(data) {
  if (data === null) return false;

  var code, idx, bitlen = 0, max = data.length, map = BASE64_MAP;

  // Convert one by one.
  for (idx = 0; idx < max; idx++) {
    code = map.indexOf(data.charAt(idx));

    // Skip CR/LF
    if (code > 64) continue;

    // Fail on illegal characters
    if (code < 0) return false;

    bitlen += 6;
  }

  // If there are any bits left, source was corrupted
  return (bitlen % 8) === 0;
}

function constructYamlBinary(data) {
  var idx, tailbits,
      input = data.replace(/[\r\n=]/g, ''), // remove CR/LF & padding to simplify scan
      max = input.length,
      map = BASE64_MAP,
      bits = 0,
      result = [];

  // Collect by 6*4 bits (3 bytes)

  for (idx = 0; idx < max; idx++) {
    if ((idx % 4 === 0) && idx) {
      result.push((bits >> 16) & 0xFF);
      result.push((bits >> 8) & 0xFF);
      result.push(bits & 0xFF);
    }

    bits = (bits << 6) | map.indexOf(input.charAt(idx));
  }

  // Dump tail

  tailbits = (max % 4) * 6;

  if (tailbits === 0) {
    result.push((bits >> 16) & 0xFF);
    result.push((bits >> 8) & 0xFF);
    result.push(bits & 0xFF);
  } else if (tailbits === 18) {
    result.push((bits >> 10) & 0xFF);
    result.push((bits >> 2) & 0xFF);
  } else if (tailbits === 12) {
    result.push((bits >> 4) & 0xFF);
  }

  // Wrap into Buffer for NodeJS and leave Array for browser
  if (NodeBuffer) {
    // Support node 6.+ Buffer API when available
    return NodeBuffer.from ? NodeBuffer.from(result) : new NodeBuffer(result);
  }

  return result;
}

function representYamlBinary(object /*, style*/) {
  var result = '', bits = 0, idx, tail,
      max = object.length,
      map = BASE64_MAP;

  // Convert every three bytes to 4 ASCII characters.

  for (idx = 0; idx < max; idx++) {
    if ((idx % 3 === 0) && idx) {
      result += map[(bits >> 18) & 0x3F];
      result += map[(bits >> 12) & 0x3F];
      result += map[(bits >> 6) & 0x3F];
      result += map[bits & 0x3F];
    }

    bits = (bits << 8) + object[idx];
  }

  // Dump tail

  tail = max % 3;

  if (tail === 0) {
    result += map[(bits >> 18) & 0x3F];
    result += map[(bits >> 12) & 0x3F];
    result += map[(bits >> 6) & 0x3F];
    result += map[bits & 0x3F];
  } else if (tail === 2) {
    result += map[(bits >> 10) & 0x3F];
    result += map[(bits >> 4) & 0x3F];
    result += map[(bits << 2) & 0x3F];
    result += map[64];
  } else if (tail === 1) {
    result += map[(bits >> 2) & 0x3F];
    result += map[(bits << 4) & 0x3F];
    result += map[64];
    result += map[64];
  }

  return result;
}

function isBinary(object) {
  return NodeBuffer && NodeBuffer.isBuffer(object);
}

module.exports = new Type('tag:yaml.org,2002:binary', {
  kind: 'scalar',
  resolve: resolveYamlBinary,
  construct: constructYamlBinary,
  predicate: isBinary,
  represent: representYamlBinary
});

},{"../type":672}],674:[function(require,module,exports){
'use strict';

var Type = require('../type');

function resolveYamlBoolean(data) {
  if (data === null) return false;

  var max = data.length;

  return (max === 4 && (data === 'true' || data === 'True' || data === 'TRUE')) ||
         (max === 5 && (data === 'false' || data === 'False' || data === 'FALSE'));
}

function constructYamlBoolean(data) {
  return data === 'true' ||
         data === 'True' ||
         data === 'TRUE';
}

function isBoolean(object) {
  return Object.prototype.toString.call(object) === '[object Boolean]';
}

module.exports = new Type('tag:yaml.org,2002:bool', {
  kind: 'scalar',
  resolve: resolveYamlBoolean,
  construct: constructYamlBoolean,
  predicate: isBoolean,
  represent: {
    lowercase: function (object) { return object ? 'true' : 'false'; },
    uppercase: function (object) { return object ? 'TRUE' : 'FALSE'; },
    camelcase: function (object) { return object ? 'True' : 'False'; }
  },
  defaultStyle: 'lowercase'
});

},{"../type":672}],675:[function(require,module,exports){
'use strict';

var common = require('../common');
var Type   = require('../type');

var YAML_FLOAT_PATTERN = new RegExp(
  // 2.5e4, 2.5 and integers
  '^(?:[-+]?(?:0|[1-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?' +
  // .2e4, .2
  // special case, seems not from spec
  '|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?' +
  // 20:59
  '|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*' +
  // .inf
  '|[-+]?\\.(?:inf|Inf|INF)' +
  // .nan
  '|\\.(?:nan|NaN|NAN))$');

function resolveYamlFloat(data) {
  if (data === null) return false;

  if (!YAML_FLOAT_PATTERN.test(data) ||
      // Quick hack to not allow integers end with `_`
      // Probably should update regexp & check speed
      data[data.length - 1] === '_') {
    return false;
  }

  return true;
}

function constructYamlFloat(data) {
  var value, sign, base, digits;

  value  = data.replace(/_/g, '').toLowerCase();
  sign   = value[0] === '-' ? -1 : 1;
  digits = [];

  if ('+-'.indexOf(value[0]) >= 0) {
    value = value.slice(1);
  }

  if (value === '.inf') {
    return (sign === 1) ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;

  } else if (value === '.nan') {
    return NaN;

  } else if (value.indexOf(':') >= 0) {
    value.split(':').forEach(function (v) {
      digits.unshift(parseFloat(v, 10));
    });

    value = 0.0;
    base = 1;

    digits.forEach(function (d) {
      value += d * base;
      base *= 60;
    });

    return sign * value;

  }
  return sign * parseFloat(value, 10);
}


var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;

function representYamlFloat(object, style) {
  var res;

  if (isNaN(object)) {
    switch (style) {
      case 'lowercase': return '.nan';
      case 'uppercase': return '.NAN';
      case 'camelcase': return '.NaN';
    }
  } else if (Number.POSITIVE_INFINITY === object) {
    switch (style) {
      case 'lowercase': return '.inf';
      case 'uppercase': return '.INF';
      case 'camelcase': return '.Inf';
    }
  } else if (Number.NEGATIVE_INFINITY === object) {
    switch (style) {
      case 'lowercase': return '-.inf';
      case 'uppercase': return '-.INF';
      case 'camelcase': return '-.Inf';
    }
  } else if (common.isNegativeZero(object)) {
    return '-0.0';
  }

  res = object.toString(10);

  // JS stringifier can build scientific format without dots: 5e-100,
  // while YAML requres dot: 5.e-100. Fix it with simple hack

  return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace('e', '.e') : res;
}

function isFloat(object) {
  return (Object.prototype.toString.call(object) === '[object Number]') &&
         (object % 1 !== 0 || common.isNegativeZero(object));
}

module.exports = new Type('tag:yaml.org,2002:float', {
  kind: 'scalar',
  resolve: resolveYamlFloat,
  construct: constructYamlFloat,
  predicate: isFloat,
  represent: representYamlFloat,
  defaultStyle: 'lowercase'
});

},{"../common":661,"../type":672}],676:[function(require,module,exports){
'use strict';

var common = require('../common');
var Type   = require('../type');

function isHexCode(c) {
  return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) ||
         ((0x41/* A */ <= c) && (c <= 0x46/* F */)) ||
         ((0x61/* a */ <= c) && (c <= 0x66/* f */));
}

function isOctCode(c) {
  return ((0x30/* 0 */ <= c) && (c <= 0x37/* 7 */));
}

function isDecCode(c) {
  return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */));
}

function resolveYamlInteger(data) {
  if (data === null) return false;

  var max = data.length,
      index = 0,
      hasDigits = false,
      ch;

  if (!max) return false;

  ch = data[index];

  // sign
  if (ch === '-' || ch === '+') {
    ch = data[++index];
  }

  if (ch === '0') {
    // 0
    if (index + 1 === max) return true;
    ch = data[++index];

    // base 2, base 8, base 16

    if (ch === 'b') {
      // base 2
      index++;

      for (; index < max; index++) {
        ch = data[index];
        if (ch === '_') continue;
        if (ch !== '0' && ch !== '1') return false;
        hasDigits = true;
      }
      return hasDigits && ch !== '_';
    }


    if (ch === 'x') {
      // base 16
      index++;

      for (; index < max; index++) {
        ch = data[index];
        if (ch === '_') continue;
        if (!isHexCode(data.charCodeAt(index))) return false;
        hasDigits = true;
      }
      return hasDigits && ch !== '_';
    }

    // base 8
    for (; index < max; index++) {
      ch = data[index];
      if (ch === '_') continue;
      if (!isOctCode(data.charCodeAt(index))) return false;
      hasDigits = true;
    }
    return hasDigits && ch !== '_';
  }

  // base 10 (except 0) or base 60

  // value should not start with `_`;
  if (ch === '_') return false;

  for (; index < max; index++) {
    ch = data[index];
    if (ch === '_') continue;
    if (ch === ':') break;
    if (!isDecCode(data.charCodeAt(index))) {
      return false;
    }
    hasDigits = true;
  }

  // Should have digits and should not end with `_`
  if (!hasDigits || ch === '_') return false;

  // if !base60 - done;
  if (ch !== ':') return true;

  // base60 almost not used, no needs to optimize
  return /^(:[0-5]?[0-9])+$/.test(data.slice(index));
}

function constructYamlInteger(data) {
  var value = data, sign = 1, ch, base, digits = [];

  if (value.indexOf('_') !== -1) {
    value = value.replace(/_/g, '');
  }

  ch = value[0];

  if (ch === '-' || ch === '+') {
    if (ch === '-') sign = -1;
    value = value.slice(1);
    ch = value[0];
  }

  if (value === '0') return 0;

  if (ch === '0') {
    if (value[1] === 'b') return sign * parseInt(value.slice(2), 2);
    if (value[1] === 'x') return sign * parseInt(value, 16);
    return sign * parseInt(value, 8);
  }

  if (value.indexOf(':') !== -1) {
    value.split(':').forEach(function (v) {
      digits.unshift(parseInt(v, 10));
    });

    value = 0;
    base = 1;

    digits.forEach(function (d) {
      value += (d * base);
      base *= 60;
    });

    return sign * value;

  }

  return sign * parseInt(value, 10);
}

function isInteger(object) {
  return (Object.prototype.toString.call(object)) === '[object Number]' &&
         (object % 1 === 0 && !common.isNegativeZero(object));
}

module.exports = new Type('tag:yaml.org,2002:int', {
  kind: 'scalar',
  resolve: resolveYamlInteger,
  construct: constructYamlInteger,
  predicate: isInteger,
  represent: {
    binary:      function (object) { return '0b' + object.toString(2); },
    octal:       function (object) { return '0'  + object.toString(8); },
    decimal:     function (object) { return        object.toString(10); },
    hexadecimal: function (object) { return '0x' + object.toString(16).toUpperCase(); }
  },
  defaultStyle: 'decimal',
  styleAliases: {
    binary:      [ 2,  'bin' ],
    octal:       [ 8,  'oct' ],
    decimal:     [ 10, 'dec' ],
    hexadecimal: [ 16, 'hex' ]
  }
});

},{"../common":661,"../type":672}],677:[function(require,module,exports){
'use strict';

var esprima;

// Browserified version does not have esprima
//
// 1. For node.js just require module as deps
// 2. For browser try to require mudule via external AMD system.
//    If not found - try to fallback to window.esprima. If not
//    found too - then fail to parse.
//
try {
  // workaround to exclude package from browserify list.
  var _require = require;
  esprima = _require('esprima');
} catch (_) {
  /*global window */
  if (typeof window !== 'undefined') esprima = window.esprima;
}

var Type = require('../../type');

function resolveJavascriptFunction(data) {
  if (data === null) return false;

  try {
    var source = '(' + data + ')',
        ast    = esprima.parse(source, { range: true });

    if (ast.type                    !== 'Program'             ||
        ast.body.length             !== 1                     ||
        ast.body[0].type            !== 'ExpressionStatement' ||
        ast.body[0].expression.type !== 'FunctionExpression') {
      return false;
    }

    return true;
  } catch (err) {
    return false;
  }
}

function constructJavascriptFunction(data) {
  /*jslint evil:true*/

  var source = '(' + data + ')',
      ast    = esprima.parse(source, { range: true }),
      params = [],
      body;

  if (ast.type                    !== 'Program'             ||
      ast.body.length             !== 1                     ||
      ast.body[0].type            !== 'ExpressionStatement' ||
      ast.body[0].expression.type !== 'FunctionExpression') {
    throw new Error('Failed to resolve function');
  }

  ast.body[0].expression.params.forEach(function (param) {
    params.push(param.name);
  });

  body = ast.body[0].expression.body.range;

  // Esprima's ranges include the first '{' and the last '}' characters on
  // function expressions. So cut them out.
  /*eslint-disable no-new-func*/
  return new Function(params, source.slice(body[0] + 1, body[1] - 1));
}

function representJavascriptFunction(object /*, style*/) {
  return object.toString();
}

function isFunction(object) {
  return Object.prototype.toString.call(object) === '[object Function]';
}

module.exports = new Type('tag:yaml.org,2002:js/function', {
  kind: 'scalar',
  resolve: resolveJavascriptFunction,
  construct: constructJavascriptFunction,
  predicate: isFunction,
  represent: representJavascriptFunction
});

},{"../../type":672}],678:[function(require,module,exports){
'use strict';

var Type = require('../../type');

function resolveJavascriptRegExp(data) {
  if (data === null) return false;
  if (data.length === 0) return false;

  var regexp = data,
      tail   = /\/([gim]*)$/.exec(data),
      modifiers = '';

  // if regexp starts with '/' it can have modifiers and must be properly closed
  // `/foo/gim` - modifiers tail can be maximum 3 chars
  if (regexp[0] === '/') {
    if (tail) modifiers = tail[1];

    if (modifiers.length > 3) return false;
    // if expression starts with /, is should be properly terminated
    if (regexp[regexp.length - modifiers.length - 1] !== '/') return false;
  }

  return true;
}

function constructJavascriptRegExp(data) {
  var regexp = data,
      tail   = /\/([gim]*)$/.exec(data),
      modifiers = '';

  // `/foo/gim` - tail can be maximum 4 chars
  if (regexp[0] === '/') {
    if (tail) modifiers = tail[1];
    regexp = regexp.slice(1, regexp.length - modifiers.length - 1);
  }

  return new RegExp(regexp, modifiers);
}

function representJavascriptRegExp(object /*, style*/) {
  var result = '/' + object.source + '/';

  if (object.global) result += 'g';
  if (object.multiline) result += 'm';
  if (object.ignoreCase) result += 'i';

  return result;
}

function isRegExp(object) {
  return Object.prototype.toString.call(object) === '[object RegExp]';
}

module.exports = new Type('tag:yaml.org,2002:js/regexp', {
  kind: 'scalar',
  resolve: resolveJavascriptRegExp,
  construct: constructJavascriptRegExp,
  predicate: isRegExp,
  represent: representJavascriptRegExp
});

},{"../../type":672}],679:[function(require,module,exports){
'use strict';

var Type = require('../../type');

function resolveJavascriptUndefined() {
  return true;
}

function constructJavascriptUndefined() {
  /*eslint-disable no-undefined*/
  return undefined;
}

function representJavascriptUndefined() {
  return '';
}

function isUndefined(object) {
  return typeof object === 'undefined';
}

module.exports = new Type('tag:yaml.org,2002:js/undefined', {
  kind: 'scalar',
  resolve: resolveJavascriptUndefined,
  construct: constructJavascriptUndefined,
  predicate: isUndefined,
  represent: representJavascriptUndefined
});

},{"../../type":672}],680:[function(require,module,exports){
'use strict';

var Type = require('../type');

module.exports = new Type('tag:yaml.org,2002:map', {
  kind: 'mapping',
  construct: function (data) { return data !== null ? data : {}; }
});

},{"../type":672}],681:[function(require,module,exports){
'use strict';

var Type = require('../type');

function resolveYamlMerge(data) {
  return data === '<<' || data === null;
}

module.exports = new Type('tag:yaml.org,2002:merge', {
  kind: 'scalar',
  resolve: resolveYamlMerge
});

},{"../type":672}],682:[function(require,module,exports){
'use strict';

var Type = require('../type');

function resolveYamlNull(data) {
  if (data === null) return true;

  var max = data.length;

  return (max === 1 && data === '~') ||
         (max === 4 && (data === 'null' || data === 'Null' || data === 'NULL'));
}

function constructYamlNull() {
  return null;
}

function isNull(object) {
  return object === null;
}

module.exports = new Type('tag:yaml.org,2002:null', {
  kind: 'scalar',
  resolve: resolveYamlNull,
  construct: constructYamlNull,
  predicate: isNull,
  represent: {
    canonical: function () { return '~';    },
    lowercase: function () { return 'null'; },
    uppercase: function () { return 'NULL'; },
    camelcase: function () { return 'Null'; }
  },
  defaultStyle: 'lowercase'
});

},{"../type":672}],683:[function(require,module,exports){
'use strict';

var Type = require('../type');

var _hasOwnProperty = Object.prototype.hasOwnProperty;
var _toString       = Object.prototype.toString;

function resolveYamlOmap(data) {
  if (data === null) return true;

  var objectKeys = [], index, length, pair, pairKey, pairHasKey,
      object = data;

  for (index = 0, length = object.length; index < length; index += 1) {
    pair = object[index];
    pairHasKey = false;

    if (_toString.call(pair) !== '[object Object]') return false;

    for (pairKey in pair) {
      if (_hasOwnProperty.call(pair, pairKey)) {
        if (!pairHasKey) pairHasKey = true;
        else return false;
      }
    }

    if (!pairHasKey) return false;

    if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey);
    else return false;
  }

  return true;
}

function constructYamlOmap(data) {
  return data !== null ? data : [];
}

module.exports = new Type('tag:yaml.org,2002:omap', {
  kind: 'sequence',
  resolve: resolveYamlOmap,
  construct: constructYamlOmap
});

},{"../type":672}],684:[function(require,module,exports){
'use strict';

var Type = require('../type');

var _toString = Object.prototype.toString;

function resolveYamlPairs(data) {
  if (data === null) return true;

  var index, length, pair, keys, result,
      object = data;

  result = new Array(object.length);

  for (index = 0, length = object.length; index < length; index += 1) {
    pair = object[index];

    if (_toString.call(pair) !== '[object Object]') return false;

    keys = Object.keys(pair);

    if (keys.length !== 1) return false;

    result[index] = [ keys[0], pair[keys[0]] ];
  }

  return true;
}

function constructYamlPairs(data) {
  if (data === null) return [];

  var index, length, pair, keys, result,
      object = data;

  result = new Array(object.length);

  for (index = 0, length = object.length; index < length; index += 1) {
    pair = object[index];

    keys = Object.keys(pair);

    result[index] = [ keys[0], pair[keys[0]] ];
  }

  return result;
}

module.exports = new Type('tag:yaml.org,2002:pairs', {
  kind: 'sequence',
  resolve: resolveYamlPairs,
  construct: constructYamlPairs
});

},{"../type":672}],685:[function(require,module,exports){
'use strict';

var Type = require('../type');

module.exports = new Type('tag:yaml.org,2002:seq', {
  kind: 'sequence',
  construct: function (data) { return data !== null ? data : []; }
});

},{"../type":672}],686:[function(require,module,exports){
'use strict';

var Type = require('../type');

var _hasOwnProperty = Object.prototype.hasOwnProperty;

function resolveYamlSet(data) {
  if (data === null) return true;

  var key, object = data;

  for (key in object) {
    if (_hasOwnProperty.call(object, key)) {
      if (object[key] !== null) return false;
    }
  }

  return true;
}

function constructYamlSet(data) {
  return data !== null ? data : {};
}

module.exports = new Type('tag:yaml.org,2002:set', {
  kind: 'mapping',
  resolve: resolveYamlSet,
  construct: constructYamlSet
});

},{"../type":672}],687:[function(require,module,exports){
'use strict';

var Type = require('../type');

module.exports = new Type('tag:yaml.org,2002:str', {
  kind: 'scalar',
  construct: function (data) { return data !== null ? data : ''; }
});

},{"../type":672}],688:[function(require,module,exports){
'use strict';

var Type = require('../type');

var YAML_DATE_REGEXP = new RegExp(
  '^([0-9][0-9][0-9][0-9])'          + // [1] year
  '-([0-9][0-9])'                    + // [2] month
  '-([0-9][0-9])$');                   // [3] day

var YAML_TIMESTAMP_REGEXP = new RegExp(
  '^([0-9][0-9][0-9][0-9])'          + // [1] year
  '-([0-9][0-9]?)'                   + // [2] month
  '-([0-9][0-9]?)'                   + // [3] day
  '(?:[Tt]|[ \\t]+)'                 + // ...
  '([0-9][0-9]?)'                    + // [4] hour
  ':([0-9][0-9])'                    + // [5] minute
  ':([0-9][0-9])'                    + // [6] second
  '(?:\\.([0-9]*))?'                 + // [7] fraction
  '(?:[ \\t]*(Z|([-+])([0-9][0-9]?)' + // [8] tz [9] tz_sign [10] tz_hour
  '(?::([0-9][0-9]))?))?$');           // [11] tz_minute

function resolveYamlTimestamp(data) {
  if (data === null) return false;
  if (YAML_DATE_REGEXP.exec(data) !== null) return true;
  if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true;
  return false;
}

function constructYamlTimestamp(data) {
  var match, year, month, day, hour, minute, second, fraction = 0,
      delta = null, tz_hour, tz_minute, date;

  match = YAML_DATE_REGEXP.exec(data);
  if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data);

  if (match === null) throw new Error('Date resolve error');

  // match: [1] year [2] month [3] day

  year = +(match[1]);
  month = +(match[2]) - 1; // JS month starts with 0
  day = +(match[3]);

  if (!match[4]) { // no hour
    return new Date(Date.UTC(year, month, day));
  }

  // match: [4] hour [5] minute [6] second [7] fraction

  hour = +(match[4]);
  minute = +(match[5]);
  second = +(match[6]);

  if (match[7]) {
    fraction = match[7].slice(0, 3);
    while (fraction.length < 3) { // milli-seconds
      fraction += '0';
    }
    fraction = +fraction;
  }

  // match: [8] tz [9] tz_sign [10] tz_hour [11] tz_minute

  if (match[9]) {
    tz_hour = +(match[10]);
    tz_minute = +(match[11] || 0);
    delta = (tz_hour * 60 + tz_minute) * 60000; // delta in mili-seconds
    if (match[9] === '-') delta = -delta;
  }

  date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));

  if (delta) date.setTime(date.getTime() - delta);

  return date;
}

function representYamlTimestamp(object /*, style*/) {
  return object.toISOString();
}

module.exports = new Type('tag:yaml.org,2002:timestamp', {
  kind: 'scalar',
  resolve: resolveYamlTimestamp,
  construct: constructYamlTimestamp,
  instanceOf: Date,
  represent: representYamlTimestamp
});

},{"../type":672}],689:[function(require,module,exports){
var isBuffer = require('is-buffer');
var toString = Object.prototype.toString;

/**
 * Get the native `typeof` a value.
 *
 * @param  {*} `val`
 * @return {*} Native javascript type
 */

module.exports = function kindOf(val) {
  // primitivies
  if (typeof val === 'undefined') {
    return 'undefined';
  }
  if (val === null) {
    return 'null';
  }
  if (val === true || val === false || val instanceof Boolean) {
    return 'boolean';
  }
  if (typeof val === 'string' || val instanceof String) {
    return 'string';
  }
  if (typeof val === 'number' || val instanceof Number) {
    return 'number';
  }

  // functions
  if (typeof val === 'function' || val instanceof Function) {
    return 'function';
  }

  // array
  if (typeof Array.isArray !== 'undefined' && Array.isArray(val)) {
    return 'array';
  }

  // check for instances of RegExp and Date before calling `toString`
  if (val instanceof RegExp) {
    return 'regexp';
  }
  if (val instanceof Date) {
    return 'date';
  }

  // other objects
  var type = toString.call(val);

  if (type === '[object RegExp]') {
    return 'regexp';
  }
  if (type === '[object Date]') {
    return 'date';
  }
  if (type === '[object Arguments]') {
    return 'arguments';
  }
  if (type === '[object Error]') {
    return 'error';
  }

  // buffer
  if (isBuffer(val)) {
    return 'buffer';
  }

  // es6: Map, WeakMap, Set, WeakSet
  if (type === '[object Set]') {
    return 'set';
  }
  if (type === '[object WeakSet]') {
    return 'weakset';
  }
  if (type === '[object Map]') {
    return 'map';
  }
  if (type === '[object WeakMap]') {
    return 'weakmap';
  }
  if (type === '[object Symbol]') {
    return 'symbol';
  }

  // typed arrays
  if (type === '[object Int8Array]') {
    return 'int8array';
  }
  if (type === '[object Uint8Array]') {
    return 'uint8array';
  }
  if (type === '[object Uint8ClampedArray]') {
    return 'uint8clampedarray';
  }
  if (type === '[object Int16Array]') {
    return 'int16array';
  }
  if (type === '[object Uint16Array]') {
    return 'uint16array';
  }
  if (type === '[object Int32Array]') {
    return 'int32array';
  }
  if (type === '[object Uint32Array]') {
    return 'uint32array';
  }
  if (type === '[object Float32Array]') {
    return 'float32array';
  }
  if (type === '[object Float64Array]') {
    return 'float64array';
  }

  // must be a plain object
  return 'object';
};

},{"is-buffer":640}],690:[function(require,module,exports){
module.exports={
  "properties": [
    "accelerator",
    "-wap-accesskey",
    "align-content",
    "-webkit-align-content",
    "align-items",
    "-webkit-align-items",
    "align-self",
    "-webkit-align-self",
    "alignment-baseline",
    "all",
    "alt",
    "-webkit-alt",
    "animation",
    "animation-delay",
    "-moz-animation-delay",
    "-ms-animation-delay",
    "-webkit-animation-delay",
    "animation-direction",
    "-moz-animation-direction",
    "-ms-animation-direction",
    "-webkit-animation-direction",
    "animation-duration",
    "-moz-animation-duration",
    "-ms-animation-duration",
    "-webkit-animation-duration",
    "animation-fill-mode",
    "-moz-animation-fill-mode",
    "-ms-animation-fill-mode",
    "-webkit-animation-fill-mode",
    "animation-iteration-count",
    "-moz-animation-iteration-count",
    "-ms-animation-iteration-count",
    "-webkit-animation-iteration-count",
    "-moz-animation",
    "-ms-animation",
    "animation-name",
    "-moz-animation-name",
    "-ms-animation-name",
    "-webkit-animation-name",
    "animation-play-state",
    "-moz-animation-play-state",
    "-ms-animation-play-state",
    "-webkit-animation-play-state",
    "animation-timing-function",
    "-moz-animation-timing-function",
    "-ms-animation-timing-function",
    "-webkit-animation-timing-function",
    "-webkit-animation",
    "-webkit-app-region",
    "appearance",
    "-moz-appearance",
    "-webkit-appearance",
    "-webkit-aspect-ratio",
    "audio-level",
    "azimuth",
    "backdrop-filter",
    "-webkit-backdrop-filter",
    "backface-visibility",
    "-moz-backface-visibility",
    "-ms-backface-visibility",
    "-webkit-backface-visibility",
    "background",
    "background-attachment",
    "-webkit-background-attachment",
    "background-blend-mode",
    "background-clip",
    "-moz-background-clip",
    "-webkit-background-clip",
    "background-color",
    "-webkit-background-color",
    "-webkit-background-composite",
    "background-image",
    "-webkit-background-image",
    "-moz-background-inline-policy",
    "background-origin",
    "-moz-background-origin",
    "-webkit-background-origin",
    "background-position",
    "-webkit-background-position",
    "background-position-x",
    "-webkit-background-position-x",
    "background-position-y",
    "-webkit-background-position-y",
    "background-repeat",
    "-webkit-background-repeat",
    "background-repeat-x",
    "background-repeat-y",
    "background-size",
    "-moz-background-size",
    "-webkit-background-size",
    "-webkit-background",
    "baseline-shift",
    "behavior",
    "-moz-binding",
    "-ms-block-progression",
    "block-size",
    "bookmark-label",
    "bookmark-level",
    "bookmark-state",
    "border",
    "-webkit-border-after-color",
    "-webkit-border-after-style",
    "-webkit-border-after",
    "-webkit-border-after-width",
    "-webkit-border-before-color",
    "-webkit-border-before-style",
    "-webkit-border-before",
    "-webkit-border-before-width",
    "border-block-end",
    "border-block-end-color",
    "border-block-end-style",
    "border-block-end-width",
    "border-block-start",
    "border-block-start-color",
    "border-block-start-style",
    "border-block-start-width",
    "border-bottom",
    "border-bottom-color",
    "-moz-border-bottom-colors",
    "border-bottom-left-radius",
    "-webkit-border-bottom-left-radius",
    "border-bottom-right-radius",
    "-webkit-border-bottom-right-radius",
    "border-bottom-style",
    "border-bottom-width",
    "border-boundary",
    "border-collapse",
    "border-color",
    "-moz-border-end-color",
    "-webkit-border-end-color",
    "-moz-border-end",
    "-moz-border-end-style",
    "-webkit-border-end-style",
    "-webkit-border-end",
    "-moz-border-end-width",
    "-webkit-border-end-width",
    "-webkit-border-fit",
    "-webkit-border-horizontal-spacing",
    "border-image",
    "-moz-border-image",
    "-o-border-image",
    "border-image-outset",
    "-webkit-border-image-outset",
    "border-image-repeat",
    "-webkit-border-image-repeat",
    "border-image-slice",
    "-webkit-border-image-slice",
    "border-image-source",
    "-webkit-border-image-source",
    "-webkit-border-image",
    "border-image-width",
    "-webkit-border-image-width",
    "border-inline-end",
    "border-inline-end-color",
    "border-inline-end-style",
    "border-inline-end-width",
    "border-inline-start",
    "border-inline-start-color",
    "border-inline-start-style",
    "border-inline-start-width",
    "border-left",
    "border-left-color",
    "-moz-border-left-colors",
    "border-left-style",
    "border-left-width",
    "border-radius",
    "-moz-border-radius-bottomleft",
    "-moz-border-radius-bottomright",
    "-moz-border-radius",
    "-moz-border-radius-topleft",
    "-moz-border-radius-topright",
    "-webkit-border-radius",
    "border-right",
    "border-right-color",
    "-moz-border-right-colors",
    "border-right-style",
    "border-right-width",
    "border-spacing",
    "-moz-border-start-color",
    "-webkit-border-start-color",
    "-moz-border-start",
    "-moz-border-start-style",
    "-webkit-border-start-style",
    "-webkit-border-start",
    "-moz-border-start-width",
    "-webkit-border-start-width",
    "border-style",
    "border-top",
    "border-top-color",
    "-moz-border-top-colors",
    "border-top-left-radius",
    "-webkit-border-top-left-radius",
    "border-top-right-radius",
    "-webkit-border-top-right-radius",
    "border-top-style",
    "border-top-width",
    "-webkit-border-vertical-spacing",
    "border-width",
    "bottom",
    "-moz-box-align",
    "-webkit-box-align",
    "box-decoration-break",
    "-webkit-box-decoration-break",
    "-moz-box-direction",
    "-webkit-box-direction",
    "-webkit-box-flex-group",
    "-moz-box-flex",
    "-webkit-box-flex",
    "-webkit-box-lines",
    "-moz-box-ordinal-group",
    "-webkit-box-ordinal-group",
    "-moz-box-orient",
    "-webkit-box-orient",
    "-moz-box-pack",
    "-webkit-box-pack",
    "-webkit-box-reflect",
    "box-shadow",
    "-moz-box-shadow",
    "-webkit-box-shadow",
    "box-sizing",
    "-moz-box-sizing",
    "-webkit-box-sizing",
    "box-snap",
    "box-suppress",
    "break-after",
    "break-before",
    "break-inside",
    "buffered-rendering",
    "caption-side",
    "caret",
    "caret-animation",
    "caret-color",
    "caret-shape",
    "clear",
    "clip",
    "clip-path",
    "-webkit-clip-path",
    "clip-rule",
    "color",
    "color-adjust",
    "-webkit-color-correction",
    "color-interpolation",
    "color-interpolation-filters",
    "color-profile",
    "color-rendering",
    "-webkit-column-axis",
    "-webkit-column-break-after",
    "-webkit-column-break-before",
    "-webkit-column-break-inside",
    "column-count",
    "-moz-column-count",
    "-webkit-column-count",
    "column-fill",
    "-moz-column-fill",
    "-webkit-column-fill",
    "column-gap",
    "-moz-column-gap",
    "-webkit-column-gap",
    "column-progression",
    "-webkit-column-progression",
    "column-rule",
    "column-rule-color",
    "-moz-column-rule-color",
    "-webkit-column-rule-color",
    "-moz-column-rule",
    "column-rule-style",
    "-moz-column-rule-style",
    "-webkit-column-rule-style",
    "-webkit-column-rule",
    "column-rule-width",
    "-moz-column-rule-width",
    "-webkit-column-rule-width",
    "column-span",
    "-webkit-column-span",
    "column-width",
    "-moz-column-width",
    "-webkit-column-width",
    "columns",
    "-moz-columns",
    "-webkit-columns",
    "-webkit-composition-fill-color",
    "-webkit-composition-frame-color",
    "contain",
    "content",
    "-ms-content-zoom-chaining",
    "-ms-content-zoom-limit-max",
    "-ms-content-zoom-limit-min",
    "-ms-content-zoom-limit",
    "-ms-content-zoom-snap",
    "-ms-content-zoom-snap-points",
    "-ms-content-zoom-snap-type",
    "-ms-content-zooming",
    "counter-increment",
    "counter-reset",
    "counter-set",
    "cue",
    "cue-after",
    "cue-before",
    "cursor",
    "-webkit-cursor-visibility",
    "cx",
    "cy",
    "d",
    "-apple-dashboard-region",
    "-webkit-dashboard-region",
    "direction",
    "display",
    "display-align",
    "dominant-baseline",
    "elevation",
    "empty-cells",
    "enable-background",
    "fill",
    "fill-opacity",
    "fill-rule",
    "filter",
    "-ms-filter",
    "-webkit-filter",
    "flex",
    "-ms-flex-align",
    "-webkit-flex-align",
    "flex-basis",
    "-webkit-flex-basis",
    "flex-direction",
    "-ms-flex-direction",
    "-webkit-flex-direction",
    "flex-flow",
    "-ms-flex-flow",
    "-webkit-flex-flow",
    "flex-grow",
    "-webkit-flex-grow",
    "-ms-flex-item-align",
    "-webkit-flex-item-align",
    "-ms-flex-line-pack",
    "-webkit-flex-line-pack",
    "-ms-flex",
    "-ms-flex-negative",
    "-ms-flex-order",
    "-webkit-flex-order",
    "-ms-flex-pack",
    "-webkit-flex-pack",
    "-ms-flex-positive",
    "-ms-flex-preferred-size",
    "flex-shrink",
    "-webkit-flex-shrink",
    "-webkit-flex",
    "flex-wrap",
    "-ms-flex-wrap",
    "-webkit-flex-wrap",
    "float",
    "float-defer",
    "-moz-float-edge",
    "float-offset",
    "float-reference",
    "flood-color",
    "flood-opacity",
    "flow-from",
    "-ms-flow-from",
    "-webkit-flow-from",
    "flow-into",
    "-ms-flow-into",
    "-webkit-flow-into",
    "font",
    "font-display",
    "font-family",
    "font-feature-settings",
    "-moz-font-feature-settings",
    "-ms-font-feature-settings",
    "-webkit-font-feature-settings",
    "font-kerning",
    "-webkit-font-kerning",
    "font-language-override",
    "-moz-font-language-override",
    "font-size",
    "font-size-adjust",
    "-webkit-font-size-delta",
    "-webkit-font-smoothing",
    "font-stretch",
    "font-style",
    "font-synthesis",
    "font-variant",
    "font-variant-alternates",
    "font-variant-caps",
    "font-variant-east-asian",
    "font-variant-ligatures",
    "-webkit-font-variant-ligatures",
    "font-variant-numeric",
    "font-variant-position",
    "font-variation-settings",
    "font-weight",
    "footnote-display",
    "footnote-policy",
    "-moz-force-broken-image-icon",
    "glyph-orientation-horizontal",
    "glyph-orientation-vertical",
    "grid",
    "-webkit-grid-after",
    "grid-area",
    "grid-auto-columns",
    "-webkit-grid-auto-columns",
    "grid-auto-flow",
    "-webkit-grid-auto-flow",
    "grid-auto-rows",
    "-webkit-grid-auto-rows",
    "-webkit-grid-before",
    "grid-column",
    "-ms-grid-column-align",
    "grid-column-end",
    "grid-column-gap",
    "-ms-grid-column",
    "-ms-grid-column-span",
    "grid-column-start",
    "-webkit-grid-column",
    "-ms-grid-columns",
    "-webkit-grid-columns",
    "-webkit-grid-end",
    "grid-gap",
    "grid-row",
    "-ms-grid-row-align",
    "grid-row-end",
    "grid-row-gap",
    "-ms-grid-row",
    "-ms-grid-row-span",
    "grid-row-start",
    "-webkit-grid-row",
    "-ms-grid-rows",
    "-webkit-grid-rows",
    "-webkit-grid-start",
    "grid-template",
    "grid-template-areas",
    "grid-template-columns",
    "grid-template-rows",
    "hanging-punctuation",
    "height",
    "-ms-high-contrast-adjust",
    "-webkit-highlight",
    "hyphenate-character",
    "-webkit-hyphenate-character",
    "-webkit-hyphenate-limit-after",
    "-webkit-hyphenate-limit-before",
    "hyphenate-limit-chars",
    "-ms-hyphenate-limit-chars",
    "hyphenate-limit-last",
    "hyphenate-limit-lines",
    "-ms-hyphenate-limit-lines",
    "-webkit-hyphenate-limit-lines",
    "hyphenate-limit-zone",
    "-ms-hyphenate-limit-zone",
    "hyphens",
    "-moz-hyphens",
    "-ms-hyphens",
    "-webkit-hyphens",
    "image-orientation",
    "-moz-image-region",
    "image-rendering",
    "image-resolution",
    "-ms-ime-align",
    "ime-mode",
    "initial-letter",
    "initial-letter-align",
    "-webkit-initial-letter",
    "initial-letter-wrap",
    "inline-size",
    "input-format",
    "-wap-input-format",
    "-wap-input-required",
    "-ms-interpolation-mode",
    "isolation",
    "justify-content",
    "-webkit-justify-content",
    "justify-items",
    "justify-self",
    "-webkit-justify-self",
    "kerning",
    "layout-flow",
    "layout-grid",
    "layout-grid-char",
    "layout-grid-line",
    "layout-grid-mode",
    "layout-grid-type",
    "left",
    "letter-spacing",
    "lighting-color",
    "-webkit-line-align",
    "-webkit-line-box-contain",
    "line-break",
    "-webkit-line-break",
    "-webkit-line-clamp",
    "line-grid",
    "-webkit-line-grid-snap",
    "-webkit-line-grid",
    "line-height",
    "line-height-step",
    "line-increment",
    "line-snap",
    "-webkit-line-snap",
    "-o-link",
    "-o-link-source",
    "list-style",
    "list-style-image",
    "list-style-position",
    "list-style-type",
    "-webkit-locale",
    "-webkit-logical-height",
    "-webkit-logical-width",
    "margin",
    "-webkit-margin-after-collapse",
    "-webkit-margin-after",
    "-webkit-margin-before-collapse",
    "-webkit-margin-before",
    "margin-block-end",
    "margin-block-start",
    "margin-bottom",
    "-webkit-margin-bottom-collapse",
    "-webkit-margin-collapse",
    "-moz-margin-end",
    "-webkit-margin-end",
    "margin-inline-end",
    "margin-inline-start",
    "margin-left",
    "margin-right",
    "-moz-margin-start",
    "-webkit-margin-start",
    "margin-top",
    "-webkit-margin-top-collapse",
    "marker",
    "marker-end",
    "marker-knockout-left",
    "marker-knockout-right",
    "marker-mid",
    "marker-offset",
    "marker-pattern",
    "marker-segment",
    "marker-side",
    "marker-start",
    "marks",
    "-wap-marquee-dir",
    "marquee-direction",
    "-webkit-marquee-direction",
    "-webkit-marquee-increment",
    "marquee-loop",
    "-wap-marquee-loop",
    "-webkit-marquee-repetition",
    "marquee-speed",
    "-wap-marquee-speed",
    "-webkit-marquee-speed",
    "marquee-style",
    "-wap-marquee-style",
    "-webkit-marquee-style",
    "-webkit-marquee",
    "mask",
    "-webkit-mask-attachment",
    "mask-border",
    "mask-border-mode",
    "mask-border-outset",
    "mask-border-repeat",
    "mask-border-slice",
    "mask-border-source",
    "mask-border-width",
    "-webkit-mask-box-image-outset",
    "-webkit-mask-box-image-repeat",
    "-webkit-mask-box-image-slice",
    "-webkit-mask-box-image-source",
    "-webkit-mask-box-image",
    "-webkit-mask-box-image-width",
    "mask-clip",
    "-webkit-mask-clip",
    "mask-composite",
    "-webkit-mask-composite",
    "mask-image",
    "-webkit-mask-image",
    "mask-mode",
    "mask-origin",
    "-webkit-mask-origin",
    "mask-position",
    "-webkit-mask-position",
    "mask-position-x",
    "-webkit-mask-position-x",
    "mask-position-y",
    "-webkit-mask-position-y",
    "mask-repeat",
    "-webkit-mask-repeat",
    "-webkit-mask-repeat-x",
    "-webkit-mask-repeat-y",
    "mask-size",
    "-webkit-mask-size",
    "mask-source-type",
    "-webkit-mask-source-type",
    "mask-type",
    "-webkit-mask",
    "-webkit-match-nearest-mail-blockquote-color",
    "max-block-size",
    "max-height",
    "max-inline-size",
    "max-lines",
    "-webkit-max-logical-height",
    "-webkit-max-logical-width",
    "max-width",
    "max-zoom",
    "min-block-size",
    "min-height",
    "min-inline-size",
    "-webkit-min-logical-height",
    "-webkit-min-logical-width",
    "min-width",
    "min-zoom",
    "mix-blend-mode",
    "motion",
    "motion-offset",
    "motion-path",
    "motion-rotation",
    "nav-down",
    "nav-index",
    "nav-left",
    "nav-right",
    "nav-up",
    "-webkit-nbsp-mode",
    "object-fit",
    "-o-object-fit",
    "object-position",
    "-o-object-position",
    "offset",
    "offset-after",
    "offset-anchor",
    "offset-before",
    "offset-block-end",
    "offset-block-start",
    "offset-distance",
    "offset-end",
    "offset-inline-end",
    "offset-inline-start",
    "offset-path",
    "offset-position",
    "offset-rotate",
    "offset-rotation",
    "offset-start",
    "opacity",
    "-moz-opacity",
    "order",
    "-webkit-order",
    "-moz-orient",
    "orientation",
    "orphans",
    "-moz-osx-font-smoothing",
    "outline",
    "outline-color",
    "-moz-outline-color",
    "-moz-outline",
    "outline-offset",
    "-moz-outline-offset",
    "-moz-outline-radius-bottomleft",
    "-moz-outline-radius-bottomright",
    "-moz-outline-radius",
    "-moz-outline-radius-topleft",
    "-moz-outline-radius-topright",
    "outline-style",
    "-moz-outline-style",
    "outline-width",
    "-moz-outline-width",
    "overflow",
    "overflow-anchor",
    "-webkit-overflow-scrolling",
    "overflow-style",
    "-ms-overflow-style",
    "overflow-wrap",
    "overflow-x",
    "overflow-y",
    "padding",
    "-webkit-padding-after",
    "-webkit-padding-before",
    "padding-block-end",
    "padding-block-start",
    "padding-bottom",
    "-moz-padding-end",
    "-webkit-padding-end",
    "padding-inline-end",
    "padding-inline-start",
    "padding-left",
    "padding-right",
    "-moz-padding-start",
    "-webkit-padding-start",
    "padding-top",
    "page",
    "page-break-after",
    "page-break-before",
    "page-break-inside",
    "paint-order",
    "pause",
    "pause-after",
    "pause-before",
    "perspective",
    "-moz-perspective",
    "-ms-perspective",
    "perspective-origin",
    "-moz-perspective-origin",
    "-ms-perspective-origin",
    "-webkit-perspective-origin",
    "perspective-origin-x",
    "-webkit-perspective-origin-x",
    "perspective-origin-y",
    "-webkit-perspective-origin-y",
    "-webkit-perspective",
    "pitch",
    "pitch-range",
    "place-content",
    "place-items",
    "place-self",
    "play-during",
    "pointer-events",
    "polar-anchor",
    "polar-angle",
    "polar-distance",
    "polar-origin",
    "position",
    "-webkit-print-color-adjust",
    "quotes",
    "r",
    "-webkit-region-break-after",
    "-webkit-region-break-before",
    "-webkit-region-break-inside",
    "region-fragment",
    "-webkit-region-fragment",
    "-webkit-region-overflow",
    "resize",
    "rest",
    "rest-after",
    "rest-before",
    "richness",
    "right",
    "rotate",
    "rotation",
    "rotation-point",
    "-webkit-rtl-ordering",
    "ruby-align",
    "ruby-merge",
    "ruby-overhang",
    "ruby-position",
    "-webkit-ruby-position",
    "running",
    "rx",
    "ry",
    "scale",
    "scroll-behavior",
    "-ms-scroll-chaining",
    "-ms-scroll-limit",
    "-ms-scroll-limit-x-max",
    "-ms-scroll-limit-x-min",
    "-ms-scroll-limit-y-max",
    "-ms-scroll-limit-y-min",
    "-ms-scroll-rails",
    "scroll-snap-align",
    "scroll-snap-coordinate",
    "-webkit-scroll-snap-coordinate",
    "scroll-snap-destination",
    "-webkit-scroll-snap-destination",
    "scroll-snap-margin",
    "scroll-snap-padding",
    "scroll-snap-points-x",
    "-ms-scroll-snap-points-x",
    "-webkit-scroll-snap-points-x",
    "scroll-snap-points-y",
    "-ms-scroll-snap-points-y",
    "-webkit-scroll-snap-points-y",
    "scroll-snap-type",
    "-ms-scroll-snap-type",
    "-webkit-scroll-snap-type",
    "scroll-snap-type-x",
    "scroll-snap-type-y",
    "-ms-scroll-snap-x",
    "-ms-scroll-snap-y",
    "-ms-scroll-translation",
    "scrollbar-arrow-color",
    "scrollbar-base-color",
    "scrollbar-dark-shadow-color",
    "scrollbar-darkshadow-color",
    "scrollbar-face-color",
    "scrollbar-highlight-color",
    "scrollbar-shadow-color",
    "scrollbar-track-color",
    "scrollbar3d-light-color",
    "scrollbar3dlight-color",
    "shape-image-threshold",
    "-webkit-shape-image-threshold",
    "shape-inside",
    "-webkit-shape-inside",
    "shape-margin",
    "-webkit-shape-margin",
    "shape-outside",
    "-webkit-shape-outside",
    "-webkit-shape-padding",
    "shape-rendering",
    "size",
    "snap-height",
    "solid-color",
    "solid-opacity",
    "speak",
    "speak-as",
    "speak-header",
    "speak-numeral",
    "speak-punctuation",
    "speech-rate",
    "src",
    "-moz-stack-sizing",
    "stop-color",
    "stop-opacity",
    "stress",
    "string-set",
    "stroke",
    "stroke-alignment",
    "stroke-dashadjust",
    "stroke-dasharray",
    "stroke-dashcorner",
    "stroke-dashoffset",
    "stroke-linecap",
    "stroke-linejoin",
    "stroke-miterlimit",
    "stroke-opacity",
    "stroke-width",
    "-webkit-svg-shadow",
    "tab-size",
    "-moz-tab-size",
    "-o-tab-size",
    "-o-table-baseline",
    "table-layout",
    "-webkit-tap-highlight-color",
    "text-align",
    "text-align-last",
    "-moz-text-align-last",
    "text-anchor",
    "text-autospace",
    "-moz-text-blink",
    "-ms-text-combine-horizontal",
    "text-combine-upright",
    "-webkit-text-combine",
    "text-decoration",
    "text-decoration-blink",
    "text-decoration-color",
    "-moz-text-decoration-color",
    "-webkit-text-decoration-color",
    "text-decoration-line",
    "-moz-text-decoration-line",
    "text-decoration-line-through",
    "-webkit-text-decoration-line",
    "text-decoration-none",
    "text-decoration-overline",
    "text-decoration-skip",
    "-webkit-text-decoration-skip",
    "text-decoration-style",
    "-moz-text-decoration-style",
    "-webkit-text-decoration-style",
    "text-decoration-underline",
    "-webkit-text-decoration",
    "-webkit-text-decorations-in-effect",
    "text-emphasis",
    "text-emphasis-color",
    "-webkit-text-emphasis-color",
    "text-emphasis-position",
    "-webkit-text-emphasis-position",
    "text-emphasis-style",
    "-webkit-text-emphasis-style",
    "-webkit-text-emphasis",
    "-webkit-text-fill-color",
    "text-indent",
    "text-justify",
    "text-justify-trim",
    "text-kashida",
    "text-kashida-space",
    "text-line-through",
    "text-line-through-color",
    "text-line-through-mode",
    "text-line-through-style",
    "text-line-through-width",
    "text-orientation",
    "-webkit-text-orientation",
    "text-overflow",
    "text-overline",
    "text-overline-color",
    "text-overline-mode",
    "text-overline-style",
    "text-overline-width",
    "text-rendering",
    "-webkit-text-security",
    "text-shadow",
    "text-size-adjust",
    "-moz-text-size-adjust",
    "-ms-text-size-adjust",
    "-webkit-text-size-adjust",
    "text-space-collapse",
    "text-space-trim",
    "text-spacing",
    "-webkit-text-stroke-color",
    "-webkit-text-stroke",
    "-webkit-text-stroke-width",
    "text-transform",
    "text-underline",
    "text-underline-color",
    "text-underline-mode",
    "text-underline-position",
    "-webkit-text-underline-position",
    "text-underline-style",
    "text-underline-width",
    "text-wrap",
    "-webkit-text-zoom",
    "top",
    "touch-action",
    "touch-action-delay",
    "-ms-touch-action",
    "-webkit-touch-callout",
    "-ms-touch-select",
    "transform",
    "transform-box",
    "-moz-transform",
    "-ms-transform",
    "-o-transform",
    "transform-origin",
    "-moz-transform-origin",
    "-ms-transform-origin",
    "-o-transform-origin",
    "-webkit-transform-origin",
    "transform-origin-x",
    "-webkit-transform-origin-x",
    "transform-origin-y",
    "-webkit-transform-origin-y",
    "transform-origin-z",
    "-webkit-transform-origin-z",
    "transform-style",
    "-moz-transform-style",
    "-ms-transform-style",
    "-webkit-transform-style",
    "-webkit-transform",
    "transition",
    "transition-delay",
    "-moz-transition-delay",
    "-ms-transition-delay",
    "-o-transition-delay",
    "-webkit-transition-delay",
    "transition-duration",
    "-moz-transition-duration",
    "-ms-transition-duration",
    "-o-transition-duration",
    "-webkit-transition-duration",
    "-moz-transition",
    "-ms-transition",
    "-o-transition",
    "transition-property",
    "-moz-transition-property",
    "-ms-transition-property",
    "-o-transition-property",
    "-webkit-transition-property",
    "transition-timing-function",
    "-moz-transition-timing-function",
    "-ms-transition-timing-function",
    "-o-transition-timing-function",
    "-webkit-transition-timing-function",
    "-webkit-transition",
    "translate",
    "uc-alt-skin",
    "uc-skin",
    "unicode-bidi",
    "unicode-range",
    "-webkit-user-drag",
    "-moz-user-focus",
    "-moz-user-input",
    "-moz-user-modify",
    "-webkit-user-modify",
    "user-select",
    "-moz-user-select",
    "-ms-user-select",
    "-webkit-user-select",
    "user-zoom",
    "vector-effect",
    "vertical-align",
    "viewport-fill",
    "viewport-fill-opacity",
    "visibility",
    "voice-balance",
    "voice-duration",
    "voice-family",
    "voice-pitch",
    "voice-range",
    "voice-rate",
    "voice-stress",
    "voice-volume",
    "volume",
    "white-space",
    "-webkit-widget-region",
    "widows",
    "width",
    "will-change",
    "-moz-window-dragging",
    "-moz-window-shadow",
    "word-break",
    "word-spacing",
    "word-wrap",
    "wrap-after",
    "wrap-before",
    "wrap-flow",
    "-ms-wrap-flow",
    "-webkit-wrap-flow",
    "wrap-inside",
    "-ms-wrap-margin",
    "-webkit-wrap-margin",
    "-webkit-wrap-padding",
    "-webkit-wrap-shape-inside",
    "-webkit-wrap-shape-outside",
    "wrap-through",
    "-ms-wrap-through",
    "-webkit-wrap-through",
    "-webkit-wrap",
    "writing-mode",
    "-webkit-writing-mode",
    "x",
    "y",
    "z-index",
    "zoom"
  ]
}
},{}],691:[function(require,module,exports){
module.exports.all = require('./data/all').properties;

},{"./data/all":690}],692:[function(require,module,exports){
(function (global){
/**
 * @license
 * Lodash <https://lodash.com/>
 * Copyright JS Foundation and other contributors <https://js.foundation/>
 * Released under MIT license <https://lodash.com/license>
 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
 * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
 */
;(function() {

  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
  var undefined;

  /** Used as the semantic version number. */
  var VERSION = '4.17.4';

  /** Used as the size to enable large array optimizations. */
  var LARGE_ARRAY_SIZE = 200;

  /** Error message constants. */
  var CORE_ERROR_TEXT = 'Unsupported core-js use. Try https://npms.io/search?q=ponyfill.',
      FUNC_ERROR_TEXT = 'Expected a function';

  /** Used to stand-in for `undefined` hash values. */
  var HASH_UNDEFINED = '__lodash_hash_undefined__';

  /** Used as the maximum memoize cache size. */
  var MAX_MEMOIZE_SIZE = 500;

  /** Used as the internal argument placeholder. */
  var PLACEHOLDER = '__lodash_placeholder__';

  /** Used to compose bitmasks for cloning. */
  var CLONE_DEEP_FLAG = 1,
      CLONE_FLAT_FLAG = 2,
      CLONE_SYMBOLS_FLAG = 4;

  /** Used to compose bitmasks for value comparisons. */
  var COMPARE_PARTIAL_FLAG = 1,
      COMPARE_UNORDERED_FLAG = 2;

  /** Used to compose bitmasks for function metadata. */
  var WRAP_BIND_FLAG = 1,
      WRAP_BIND_KEY_FLAG = 2,
      WRAP_CURRY_BOUND_FLAG = 4,
      WRAP_CURRY_FLAG = 8,
      WRAP_CURRY_RIGHT_FLAG = 16,
      WRAP_PARTIAL_FLAG = 32,
      WRAP_PARTIAL_RIGHT_FLAG = 64,
      WRAP_ARY_FLAG = 128,
      WRAP_REARG_FLAG = 256,
      WRAP_FLIP_FLAG = 512;

  /** Used as default options for `_.truncate`. */
  var DEFAULT_TRUNC_LENGTH = 30,
      DEFAULT_TRUNC_OMISSION = '...';

  /** Used to detect hot functions by number of calls within a span of milliseconds. */
  var HOT_COUNT = 800,
      HOT_SPAN = 16;

  /** Used to indicate the type of lazy iteratees. */
  var LAZY_FILTER_FLAG = 1,
      LAZY_MAP_FLAG = 2,
      LAZY_WHILE_FLAG = 3;

  /** Used as references for various `Number` constants. */
  var INFINITY = 1 / 0,
      MAX_SAFE_INTEGER = 9007199254740991,
      MAX_INTEGER = 1.7976931348623157e+308,
      NAN = 0 / 0;

  /** Used as references for the maximum length and index of an array. */
  var MAX_ARRAY_LENGTH = 4294967295,
      MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1,
      HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;

  /** Used to associate wrap methods with their bit flags. */
  var wrapFlags = [
    ['ary', WRAP_ARY_FLAG],
    ['bind', WRAP_BIND_FLAG],
    ['bindKey', WRAP_BIND_KEY_FLAG],
    ['curry', WRAP_CURRY_FLAG],
    ['curryRight', WRAP_CURRY_RIGHT_FLAG],
    ['flip', WRAP_FLIP_FLAG],
    ['partial', WRAP_PARTIAL_FLAG],
    ['partialRight', WRAP_PARTIAL_RIGHT_FLAG],
    ['rearg', WRAP_REARG_FLAG]
  ];

  /** `Object#toString` result references. */
  var argsTag = '[object Arguments]',
      arrayTag = '[object Array]',
      asyncTag = '[object AsyncFunction]',
      boolTag = '[object Boolean]',
      dateTag = '[object Date]',
      domExcTag = '[object DOMException]',
      errorTag = '[object Error]',
      funcTag = '[object Function]',
      genTag = '[object GeneratorFunction]',
      mapTag = '[object Map]',
      numberTag = '[object Number]',
      nullTag = '[object Null]',
      objectTag = '[object Object]',
      promiseTag = '[object Promise]',
      proxyTag = '[object Proxy]',
      regexpTag = '[object RegExp]',
      setTag = '[object Set]',
      stringTag = '[object String]',
      symbolTag = '[object Symbol]',
      undefinedTag = '[object Undefined]',
      weakMapTag = '[object WeakMap]',
      weakSetTag = '[object WeakSet]';

  var arrayBufferTag = '[object ArrayBuffer]',
      dataViewTag = '[object DataView]',
      float32Tag = '[object Float32Array]',
      float64Tag = '[object Float64Array]',
      int8Tag = '[object Int8Array]',
      int16Tag = '[object Int16Array]',
      int32Tag = '[object Int32Array]',
      uint8Tag = '[object Uint8Array]',
      uint8ClampedTag = '[object Uint8ClampedArray]',
      uint16Tag = '[object Uint16Array]',
      uint32Tag = '[object Uint32Array]';

  /** Used to match empty string literals in compiled template source. */
  var reEmptyStringLeading = /\b__p \+= '';/g,
      reEmptyStringMiddle = /\b(__p \+=) '' \+/g,
      reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;

  /** Used to match HTML entities and HTML characters. */
  var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g,
      reUnescapedHtml = /[&<>"']/g,
      reHasEscapedHtml = RegExp(reEscapedHtml.source),
      reHasUnescapedHtml = RegExp(reUnescapedHtml.source);

  /** Used to match template delimiters. */
  var reEscape = /<%-([\s\S]+?)%>/g,
      reEvaluate = /<%([\s\S]+?)%>/g,
      reInterpolate = /<%=([\s\S]+?)%>/g;

  /** Used to match property names within property paths. */
  var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
      reIsPlainProp = /^\w*$/,
      reLeadingDot = /^\./,
      rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;

  /**
   * Used to match `RegExp`
   * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
   */
  var reRegExpChar = /[\\^$.*+?()[\]{}|]/g,
      reHasRegExpChar = RegExp(reRegExpChar.source);

  /** Used to match leading and trailing whitespace. */
  var reTrim = /^\s+|\s+$/g,
      reTrimStart = /^\s+/,
      reTrimEnd = /\s+$/;

  /** Used to match wrap detail comments. */
  var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/,
      reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/,
      reSplitDetails = /,? & /;

  /** Used to match words composed of alphanumeric characters. */
  var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;

  /** Used to match backslashes in property paths. */
  var reEscapeChar = /\\(\\)?/g;

  /**
   * Used to match
   * [ES template delimiters](http://ecma-international.org/ecma-262/7.0/#sec-template-literal-lexical-components).
   */
  var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;

  /** Used to match `RegExp` flags from their coerced string values. */
  var reFlags = /\w*$/;

  /** Used to detect bad signed hexadecimal string values. */
  var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;

  /** Used to detect binary string values. */
  var reIsBinary = /^0b[01]+$/i;

  /** Used to detect host constructors (Safari). */
  var reIsHostCtor = /^\[object .+?Constructor\]$/;

  /** Used to detect octal string values. */
  var reIsOctal = /^0o[0-7]+$/i;

  /** Used to detect unsigned integer values. */
  var reIsUint = /^(?:0|[1-9]\d*)$/;

  /** Used to match Latin Unicode letters (excluding mathematical operators). */
  var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;

  /** Used to ensure capturing order of template delimiters. */
  var reNoMatch = /($^)/;

  /** Used to match unescaped characters in compiled string literals. */
  var reUnescapedString = /['\n\r\u2028\u2029\\]/g;

  /** Used to compose unicode character classes. */
  var rsAstralRange = '\\ud800-\\udfff',
      rsComboMarksRange = '\\u0300-\\u036f',
      reComboHalfMarksRange = '\\ufe20-\\ufe2f',
      rsComboSymbolsRange = '\\u20d0-\\u20ff',
      rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,
      rsDingbatRange = '\\u2700-\\u27bf',
      rsLowerRange = 'a-z\\xdf-\\xf6\\xf8-\\xff',
      rsMathOpRange = '\\xac\\xb1\\xd7\\xf7',
      rsNonCharRange = '\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf',
      rsPunctuationRange = '\\u2000-\\u206f',
      rsSpaceRange = ' \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000',
      rsUpperRange = 'A-Z\\xc0-\\xd6\\xd8-\\xde',
      rsVarRange = '\\ufe0e\\ufe0f',
      rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;

  /** Used to compose unicode capture groups. */
  var rsApos = "['\u2019]",
      rsAstral = '[' + rsAstralRange + ']',
      rsBreak = '[' + rsBreakRange + ']',
      rsCombo = '[' + rsComboRange + ']',
      rsDigits = '\\d+',
      rsDingbat = '[' + rsDingbatRange + ']',
      rsLower = '[' + rsLowerRange + ']',
      rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']',
      rsFitz = '\\ud83c[\\udffb-\\udfff]',
      rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',
      rsNonAstral = '[^' + rsAstralRange + ']',
      rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}',
      rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]',
      rsUpper = '[' + rsUpperRange + ']',
      rsZWJ = '\\u200d';

  /** Used to compose unicode regexes. */
  var rsMiscLower = '(?:' + rsLower + '|' + rsMisc + ')',
      rsMiscUpper = '(?:' + rsUpper + '|' + rsMisc + ')',
      rsOptContrLower = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?',
      rsOptContrUpper = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?',
      reOptMod = rsModifier + '?',
      rsOptVar = '[' + rsVarRange + ']?',
      rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',
      rsOrdLower = '\\d*(?:(?:1st|2nd|3rd|(?![123])\\dth)\\b)',
      rsOrdUpper = '\\d*(?:(?:1ST|2ND|3RD|(?![123])\\dTH)\\b)',
      rsSeq = rsOptVar + reOptMod + rsOptJoin,
      rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq,
      rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';

  /** Used to match apostrophes. */
  var reApos = RegExp(rsApos, 'g');

  /**
   * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and
   * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).
   */
  var reComboMark = RegExp(rsCombo, 'g');

  /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */
  var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');

  /** Used to match complex or compound words. */
  var reUnicodeWord = RegExp([
    rsUpper + '?' + rsLower + '+' + rsOptContrLower + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')',
    rsMiscUpper + '+' + rsOptContrUpper + '(?=' + [rsBreak, rsUpper + rsMiscLower, '$'].join('|') + ')',
    rsUpper + '?' + rsMiscLower + '+' + rsOptContrLower,
    rsUpper + '+' + rsOptContrUpper,
    rsOrdUpper,
    rsOrdLower,
    rsDigits,
    rsEmoji
  ].join('|'), 'g');

  /** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */
  var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange  + rsComboRange + rsVarRange + ']');

  /** Used to detect strings that need a more robust regexp to match words. */
  var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2,}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;

  /** Used to assign default `context` object properties. */
  var contextProps = [
    'Array', 'Buffer', 'DataView', 'Date', 'Error', 'Float32Array', 'Float64Array',
    'Function', 'Int8Array', 'Int16Array', 'Int32Array', 'Map', 'Math', 'Object',
    'Promise', 'RegExp', 'Set', 'String', 'Symbol', 'TypeError', 'Uint8Array',
    'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap',
    '_', 'clearTimeout', 'isFinite', 'parseInt', 'setTimeout'
  ];

  /** Used to make template sourceURLs easier to identify. */
  var templateCounter = -1;

  /** Used to identify `toStringTag` values of typed arrays. */
  var typedArrayTags = {};
  typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
  typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
  typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
  typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
  typedArrayTags[uint32Tag] = true;
  typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
  typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
  typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
  typedArrayTags[errorTag] = typedArrayTags[funcTag] =
  typedArrayTags[mapTag] = typedArrayTags[numberTag] =
  typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
  typedArrayTags[setTag] = typedArrayTags[stringTag] =
  typedArrayTags[weakMapTag] = false;

  /** Used to identify `toStringTag` values supported by `_.clone`. */
  var cloneableTags = {};
  cloneableTags[argsTag] = cloneableTags[arrayTag] =
  cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =
  cloneableTags[boolTag] = cloneableTags[dateTag] =
  cloneableTags[float32Tag] = cloneableTags[float64Tag] =
  cloneableTags[int8Tag] = cloneableTags[int16Tag] =
  cloneableTags[int32Tag] = cloneableTags[mapTag] =
  cloneableTags[numberTag] = cloneableTags[objectTag] =
  cloneableTags[regexpTag] = cloneableTags[setTag] =
  cloneableTags[stringTag] = cloneableTags[symbolTag] =
  cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =
  cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
  cloneableTags[errorTag] = cloneableTags[funcTag] =
  cloneableTags[weakMapTag] = false;

  /** Used to map Latin Unicode letters to basic Latin letters. */
  var deburredLetters = {
    // Latin-1 Supplement block.
    '\xc0': 'A',  '\xc1': 'A', '\xc2': 'A', '\xc3': 'A', '\xc4': 'A', '\xc5': 'A',
    '\xe0': 'a',  '\xe1': 'a', '\xe2': 'a', '\xe3': 'a', '\xe4': 'a', '\xe5': 'a',
    '\xc7': 'C',  '\xe7': 'c',
    '\xd0': 'D',  '\xf0': 'd',
    '\xc8': 'E',  '\xc9': 'E', '\xca': 'E', '\xcb': 'E',
    '\xe8': 'e',  '\xe9': 'e', '\xea': 'e', '\xeb': 'e',
    '\xcc': 'I',  '\xcd': 'I', '\xce': 'I', '\xcf': 'I',
    '\xec': 'i',  '\xed': 'i', '\xee': 'i', '\xef': 'i',
    '\xd1': 'N',  '\xf1': 'n',
    '\xd2': 'O',  '\xd3': 'O', '\xd4': 'O', '\xd5': 'O', '\xd6': 'O', '\xd8': 'O',
    '\xf2': 'o',  '\xf3': 'o', '\xf4': 'o', '\xf5': 'o', '\xf6': 'o', '\xf8': 'o',
    '\xd9': 'U',  '\xda': 'U', '\xdb': 'U', '\xdc': 'U',
    '\xf9': 'u',  '\xfa': 'u', '\xfb': 'u', '\xfc': 'u',
    '\xdd': 'Y',  '\xfd': 'y', '\xff': 'y',
    '\xc6': 'Ae', '\xe6': 'ae',
    '\xde': 'Th', '\xfe': 'th',
    '\xdf': 'ss',
    // Latin Extended-A block.
    '\u0100': 'A',  '\u0102': 'A', '\u0104': 'A',
    '\u0101': 'a',  '\u0103': 'a', '\u0105': 'a',
    '\u0106': 'C',  '\u0108': 'C', '\u010a': 'C', '\u010c': 'C',
    '\u0107': 'c',  '\u0109': 'c', '\u010b': 'c', '\u010d': 'c',
    '\u010e': 'D',  '\u0110': 'D', '\u010f': 'd', '\u0111': 'd',
    '\u0112': 'E',  '\u0114': 'E', '\u0116': 'E', '\u0118': 'E', '\u011a': 'E',
    '\u0113': 'e',  '\u0115': 'e', '\u0117': 'e', '\u0119': 'e', '\u011b': 'e',
    '\u011c': 'G',  '\u011e': 'G', '\u0120': 'G', '\u0122': 'G',
    '\u011d': 'g',  '\u011f': 'g', '\u0121': 'g', '\u0123': 'g',
    '\u0124': 'H',  '\u0126': 'H', '\u0125': 'h', '\u0127': 'h',
    '\u0128': 'I',  '\u012a': 'I', '\u012c': 'I', '\u012e': 'I', '\u0130': 'I',
    '\u0129': 'i',  '\u012b': 'i', '\u012d': 'i', '\u012f': 'i', '\u0131': 'i',
    '\u0134': 'J',  '\u0135': 'j',
    '\u0136': 'K',  '\u0137': 'k', '\u0138': 'k',
    '\u0139': 'L',  '\u013b': 'L', '\u013d': 'L', '\u013f': 'L', '\u0141': 'L',
    '\u013a': 'l',  '\u013c': 'l', '\u013e': 'l', '\u0140': 'l', '\u0142': 'l',
    '\u0143': 'N',  '\u0145': 'N', '\u0147': 'N', '\u014a': 'N',
    '\u0144': 'n',  '\u0146': 'n', '\u0148': 'n', '\u014b': 'n',
    '\u014c': 'O',  '\u014e': 'O', '\u0150': 'O',
    '\u014d': 'o',  '\u014f': 'o', '\u0151': 'o',
    '\u0154': 'R',  '\u0156': 'R', '\u0158': 'R',
    '\u0155': 'r',  '\u0157': 'r', '\u0159': 'r',
    '\u015a': 'S',  '\u015c': 'S', '\u015e': 'S', '\u0160': 'S',
    '\u015b': 's',  '\u015d': 's', '\u015f': 's', '\u0161': 's',
    '\u0162': 'T',  '\u0164': 'T', '\u0166': 'T',
    '\u0163': 't',  '\u0165': 't', '\u0167': 't',
    '\u0168': 'U',  '\u016a': 'U', '\u016c': 'U', '\u016e': 'U', '\u0170': 'U', '\u0172': 'U',
    '\u0169': 'u',  '\u016b': 'u', '\u016d': 'u', '\u016f': 'u', '\u0171': 'u', '\u0173': 'u',
    '\u0174': 'W',  '\u0175': 'w',
    '\u0176': 'Y',  '\u0177': 'y', '\u0178': 'Y',
    '\u0179': 'Z',  '\u017b': 'Z', '\u017d': 'Z',
    '\u017a': 'z',  '\u017c': 'z', '\u017e': 'z',
    '\u0132': 'IJ', '\u0133': 'ij',
    '\u0152': 'Oe', '\u0153': 'oe',
    '\u0149': "'n", '\u017f': 's'
  };

  /** Used to map characters to HTML entities. */
  var htmlEscapes = {
    '&': '&amp;',
    '<': '&lt;',
    '>': '&gt;',
    '"': '&quot;',
    "'": '&#39;'
  };

  /** Used to map HTML entities to characters. */
  var htmlUnescapes = {
    '&amp;': '&',
    '&lt;': '<',
    '&gt;': '>',
    '&quot;': '"',
    '&#39;': "'"
  };

  /** Used to escape characters for inclusion in compiled string literals. */
  var stringEscapes = {
    '\\': '\\',
    "'": "'",
    '\n': 'n',
    '\r': 'r',
    '\u2028': 'u2028',
    '\u2029': 'u2029'
  };

  /** Built-in method references without a dependency on `root`. */
  var freeParseFloat = parseFloat,
      freeParseInt = parseInt;

  /** Detect free variable `global` from Node.js. */
  var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;

  /** Detect free variable `self`. */
  var freeSelf = typeof self == 'object' && self && self.Object === Object && self;

  /** Used as a reference to the global object. */
  var root = freeGlobal || freeSelf || Function('return this')();

  /** Detect free variable `exports`. */
  var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;

  /** Detect free variable `module`. */
  var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;

  /** Detect the popular CommonJS extension `module.exports`. */
  var moduleExports = freeModule && freeModule.exports === freeExports;

  /** Detect free variable `process` from Node.js. */
  var freeProcess = moduleExports && freeGlobal.process;

  /** Used to access faster Node.js helpers. */
  var nodeUtil = (function() {
    try {
      return freeProcess && freeProcess.binding && freeProcess.binding('util');
    } catch (e) {}
  }());

  /* Node.js helper references. */
  var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer,
      nodeIsDate = nodeUtil && nodeUtil.isDate,
      nodeIsMap = nodeUtil && nodeUtil.isMap,
      nodeIsRegExp = nodeUtil && nodeUtil.isRegExp,
      nodeIsSet = nodeUtil && nodeUtil.isSet,
      nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;

  /*--------------------------------------------------------------------------*/

  /**
   * Adds the key-value `pair` to `map`.
   *
   * @private
   * @param {Object} map The map to modify.
   * @param {Array} pair The key-value pair to add.
   * @returns {Object} Returns `map`.
   */
  function addMapEntry(map, pair) {
    // Don't return `map.set` because it's not chainable in IE 11.
    map.set(pair[0], pair[1]);
    return map;
  }

  /**
   * Adds `value` to `set`.
   *
   * @private
   * @param {Object} set The set to modify.
   * @param {*} value The value to add.
   * @returns {Object} Returns `set`.
   */
  function addSetEntry(set, value) {
    // Don't return `set.add` because it's not chainable in IE 11.
    set.add(value);
    return set;
  }

  /**
   * A faster alternative to `Function#apply`, this function invokes `func`
   * with the `this` binding of `thisArg` and the arguments of `args`.
   *
   * @private
   * @param {Function} func The function to invoke.
   * @param {*} thisArg The `this` binding of `func`.
   * @param {Array} args The arguments to invoke `func` with.
   * @returns {*} Returns the result of `func`.
   */
  function apply(func, thisArg, args) {
    switch (args.length) {
      case 0: return func.call(thisArg);
      case 1: return func.call(thisArg, args[0]);
      case 2: return func.call(thisArg, args[0], args[1]);
      case 3: return func.call(thisArg, args[0], args[1], args[2]);
    }
    return func.apply(thisArg, args);
  }

  /**
   * A specialized version of `baseAggregator` for arrays.
   *
   * @private
   * @param {Array} [array] The array to iterate over.
   * @param {Function} setter The function to set `accumulator` values.
   * @param {Function} iteratee The iteratee to transform keys.
   * @param {Object} accumulator The initial aggregated object.
   * @returns {Function} Returns `accumulator`.
   */
  function arrayAggregator(array, setter, iteratee, accumulator) {
    var index = -1,
        length = array == null ? 0 : array.length;

    while (++index < length) {
      var value = array[index];
      setter(accumulator, value, iteratee(value), array);
    }
    return accumulator;
  }

  /**
   * A specialized version of `_.forEach` for arrays without support for
   * iteratee shorthands.
   *
   * @private
   * @param {Array} [array] The array to iterate over.
   * @param {Function} iteratee The function invoked per iteration.
   * @returns {Array} Returns `array`.
   */
  function arrayEach(array, iteratee) {
    var index = -1,
        length = array == null ? 0 : array.length;

    while (++index < length) {
      if (iteratee(array[index], index, array) === false) {
        break;
      }
    }
    return array;
  }

  /**
   * A specialized version of `_.forEachRight` for arrays without support for
   * iteratee shorthands.
   *
   * @private
   * @param {Array} [array] The array to iterate over.
   * @param {Function} iteratee The function invoked per iteration.
   * @returns {Array} Returns `array`.
   */
  function arrayEachRight(array, iteratee) {
    var length = array == null ? 0 : array.length;

    while (length--) {
      if (iteratee(array[length], length, array) === false) {
        break;
      }
    }
    return array;
  }

  /**
   * A specialized version of `_.every` for arrays without support for
   * iteratee shorthands.
   *
   * @private
   * @param {Array} [array] The array to iterate over.
   * @param {Function} predicate The function invoked per iteration.
   * @returns {boolean} Returns `true` if all elements pass the predicate check,
   *  else `false`.
   */
  function arrayEvery(array, predicate) {
    var index = -1,
        length = array == null ? 0 : array.length;

    while (++index < length) {
      if (!predicate(array[index], index, array)) {
        return false;
      }
    }
    return true;
  }

  /**
   * A specialized version of `_.filter` for arrays without support for
   * iteratee shorthands.
   *
   * @private
   * @param {Array} [array] The array to iterate over.
   * @param {Function} predicate The function invoked per iteration.
   * @returns {Array} Returns the new filtered array.
   */
  function arrayFilter(array, predicate) {
    var index = -1,
        length = array == null ? 0 : array.length,
        resIndex = 0,
        result = [];

    while (++index < length) {
      var value = array[index];
      if (predicate(value, index, array)) {
        result[resIndex++] = value;
      }
    }
    return result;
  }

  /**
   * A specialized version of `_.includes` for arrays without support for
   * specifying an index to search from.
   *
   * @private
   * @param {Array} [array] The array to inspect.
   * @param {*} target The value to search for.
   * @returns {boolean} Returns `true` if `target` is found, else `false`.
   */
  function arrayIncludes(array, value) {
    var length = array == null ? 0 : array.length;
    return !!length && baseIndexOf(array, value, 0) > -1;
  }

  /**
   * This function is like `arrayIncludes` except that it accepts a comparator.
   *
   * @private
   * @param {Array} [array] The array to inspect.
   * @param {*} target The value to search for.
   * @param {Function} comparator The comparator invoked per element.
   * @returns {boolean} Returns `true` if `target` is found, else `false`.
   */
  function arrayIncludesWith(array, value, comparator) {
    var index = -1,
        length = array == null ? 0 : array.length;

    while (++index < length) {
      if (comparator(value, array[index])) {
        return true;
      }
    }
    return false;
  }

  /**
   * A specialized version of `_.map` for arrays without support for iteratee
   * shorthands.
   *
   * @private
   * @param {Array} [array] The array to iterate over.
   * @param {Function} iteratee The function invoked per iteration.
   * @returns {Array} Returns the new mapped array.
   */
  function arrayMap(array, iteratee) {
    var index = -1,
        length = array == null ? 0 : array.length,
        result = Array(length);

    while (++index < length) {
      result[index] = iteratee(array[index], index, array);
    }
    return result;
  }

  /**
   * Appends the elements of `values` to `array`.
   *
   * @private
   * @param {Array} array The array to modify.
   * @param {Array} values The values to append.
   * @returns {Array} Returns `array`.
   */
  function arrayPush(array, values) {
    var index = -1,
        length = values.length,
        offset = array.length;

    while (++index < length) {
      array[offset + index] = values[index];
    }
    return array;
  }

  /**
   * A specialized version of `_.reduce` for arrays without support for
   * iteratee shorthands.
   *
   * @private
   * @param {Array} [array] The array to iterate over.
   * @param {Function} iteratee The function invoked per iteration.
   * @param {*} [accumulator] The initial value.
   * @param {boolean} [initAccum] Specify using the first element of `array` as
   *  the initial value.
   * @returns {*} Returns the accumulated value.
   */
  function arrayReduce(array, iteratee, accumulator, initAccum) {
    var index = -1,
        length = array == null ? 0 : array.length;

    if (initAccum && length) {
      accumulator = array[++index];
    }
    while (++index < length) {
      accumulator = iteratee(accumulator, array[index], index, array);
    }
    return accumulator;
  }

  /**
   * A specialized version of `_.reduceRight` for arrays without support for
   * iteratee shorthands.
   *
   * @private
   * @param {Array} [array] The array to iterate over.
   * @param {Function} iteratee The function invoked per iteration.
   * @param {*} [accumulator] The initial value.
   * @param {boolean} [initAccum] Specify using the last element of `array` as
   *  the initial value.
   * @returns {*} Returns the accumulated value.
   */
  function arrayReduceRight(array, iteratee, accumulator, initAccum) {
    var length = array == null ? 0 : array.length;
    if (initAccum && length) {
      accumulator = array[--length];
    }
    while (length--) {
      accumulator = iteratee(accumulator, array[length], length, array);
    }
    return accumulator;
  }

  /**
   * A specialized version of `_.some` for arrays without support for iteratee
   * shorthands.
   *
   * @private
   * @param {Array} [array] The array to iterate over.
   * @param {Function} predicate The function invoked per iteration.
   * @returns {boolean} Returns `true` if any element passes the predicate check,
   *  else `false`.
   */
  function arraySome(array, predicate) {
    var index = -1,
        length = array == null ? 0 : array.length;

    while (++index < length) {
      if (predicate(array[index], index, array)) {
        return true;
      }
    }
    return false;
  }

  /**
   * Gets the size of an ASCII `string`.
   *
   * @private
   * @param {string} string The string inspect.
   * @returns {number} Returns the string size.
   */
  var asciiSize = baseProperty('length');

  /**
   * Converts an ASCII `string` to an array.
   *
   * @private
   * @param {string} string The string to convert.
   * @returns {Array} Returns the converted array.
   */
  function asciiToArray(string) {
    return string.split('');
  }

  /**
   * Splits an ASCII `string` into an array of its words.
   *
   * @private
   * @param {string} The string to inspect.
   * @returns {Array} Returns the words of `string`.
   */
  function asciiWords(string) {
    return string.match(reAsciiWord) || [];
  }

  /**
   * The base implementation of methods like `_.findKey` and `_.findLastKey`,
   * without support for iteratee shorthands, which iterates over `collection`
   * using `eachFunc`.
   *
   * @private
   * @param {Array|Object} collection The collection to inspect.
   * @param {Function} predicate The function invoked per iteration.
   * @param {Function} eachFunc The function to iterate over `collection`.
   * @returns {*} Returns the found element or its key, else `undefined`.
   */
  function baseFindKey(collection, predicate, eachFunc) {
    var result;
    eachFunc(collection, function(value, key, collection) {
      if (predicate(value, key, collection)) {
        result = key;
        return false;
      }
    });
    return result;
  }

  /**
   * The base implementation of `_.findIndex` and `_.findLastIndex` without
   * support for iteratee shorthands.
   *
   * @private
   * @param {Array} array The array to inspect.
   * @param {Function} predicate The function invoked per iteration.
   * @param {number} fromIndex The index to search from.
   * @param {boolean} [fromRight] Specify iterating from right to left.
   * @returns {number} Returns the index of the matched value, else `-1`.
   */
  function baseFindIndex(array, predicate, fromIndex, fromRight) {
    var length = array.length,
        index = fromIndex + (fromRight ? 1 : -1);

    while ((fromRight ? index-- : ++index < length)) {
      if (predicate(array[index], index, array)) {
        return index;
      }
    }
    return -1;
  }

  /**
   * The base implementation of `_.indexOf` without `fromIndex` bounds checks.
   *
   * @private
   * @param {Array} array The array to inspect.
   * @param {*} value The value to search for.
   * @param {number} fromIndex The index to search from.
   * @returns {number} Returns the index of the matched value, else `-1`.
   */
  function baseIndexOf(array, value, fromIndex) {
    return value === value
      ? strictIndexOf(array, value, fromIndex)
      : baseFindIndex(array, baseIsNaN, fromIndex);
  }

  /**
   * This function is like `baseIndexOf` except that it accepts a comparator.
   *
   * @private
   * @param {Array} array The array to inspect.
   * @param {*} value The value to search for.
   * @param {number} fromIndex The index to search from.
   * @param {Function} comparator The comparator invoked per element.
   * @returns {number} Returns the index of the matched value, else `-1`.
   */
  function baseIndexOfWith(array, value, fromIndex, comparator) {
    var index = fromIndex - 1,
        length = array.length;

    while (++index < length) {
      if (comparator(array[index], value)) {
        return index;
      }
    }
    return -1;
  }

  /**
   * The base implementation of `_.isNaN` without support for number objects.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
   */
  function baseIsNaN(value) {
    return value !== value;
  }

  /**
   * The base implementation of `_.mean` and `_.meanBy` without support for
   * iteratee shorthands.
   *
   * @private
   * @param {Array} array The array to iterate over.
   * @param {Function} iteratee The function invoked per iteration.
   * @returns {number} Returns the mean.
   */
  function baseMean(array, iteratee) {
    var length = array == null ? 0 : array.length;
    return length ? (baseSum(array, iteratee) / length) : NAN;
  }

  /**
   * The base implementation of `_.property` without support for deep paths.
   *
   * @private
   * @param {string} key The key of the property to get.
   * @returns {Function} Returns the new accessor function.
   */
  function baseProperty(key) {
    return function(object) {
      return object == null ? undefined : object[key];
    };
  }

  /**
   * The base implementation of `_.propertyOf` without support for deep paths.
   *
   * @private
   * @param {Object} object The object to query.
   * @returns {Function} Returns the new accessor function.
   */
  function basePropertyOf(object) {
    return function(key) {
      return object == null ? undefined : object[key];
    };
  }

  /**
   * The base implementation of `_.reduce` and `_.reduceRight`, without support
   * for iteratee shorthands, which iterates over `collection` using `eachFunc`.
   *
   * @private
   * @param {Array|Object} collection The collection to iterate over.
   * @param {Function} iteratee The function invoked per iteration.
   * @param {*} accumulator The initial value.
   * @param {boolean} initAccum Specify using the first or last element of
   *  `collection` as the initial value.
   * @param {Function} eachFunc The function to iterate over `collection`.
   * @returns {*} Returns the accumulated value.
   */
  function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {
    eachFunc(collection, function(value, index, collection) {
      accumulator = initAccum
        ? (initAccum = false, value)
        : iteratee(accumulator, value, index, collection);
    });
    return accumulator;
  }

  /**
   * The base implementation of `_.sortBy` which uses `comparer` to define the
   * sort order of `array` and replaces criteria objects with their corresponding
   * values.
   *
   * @private
   * @param {Array} array The array to sort.
   * @param {Function} comparer The function to define sort order.
   * @returns {Array} Returns `array`.
   */
  function baseSortBy(array, comparer) {
    var length = array.length;

    array.sort(comparer);
    while (length--) {
      array[length] = array[length].value;
    }
    return array;
  }

  /**
   * The base implementation of `_.sum` and `_.sumBy` without support for
   * iteratee shorthands.
   *
   * @private
   * @param {Array} array The array to iterate over.
   * @param {Function} iteratee The function invoked per iteration.
   * @returns {number} Returns the sum.
   */
  function baseSum(array, iteratee) {
    var result,
        index = -1,
        length = array.length;

    while (++index < length) {
      var current = iteratee(array[index]);
      if (current !== undefined) {
        result = result === undefined ? current : (result + current);
      }
    }
    return result;
  }

  /**
   * The base implementation of `_.times` without support for iteratee shorthands
   * or max array length checks.
   *
   * @private
   * @param {number} n The number of times to invoke `iteratee`.
   * @param {Function} iteratee The function invoked per iteration.
   * @returns {Array} Returns the array of results.
   */
  function baseTimes(n, iteratee) {
    var index = -1,
        result = Array(n);

    while (++index < n) {
      result[index] = iteratee(index);
    }
    return result;
  }

  /**
   * The base implementation of `_.toPairs` and `_.toPairsIn` which creates an array
   * of key-value pairs for `object` corresponding to the property names of `props`.
   *
   * @private
   * @param {Object} object The object to query.
   * @param {Array} props The property names to get values for.
   * @returns {Object} Returns the key-value pairs.
   */
  function baseToPairs(object, props) {
    return arrayMap(props, function(key) {
      return [key, object[key]];
    });
  }

  /**
   * The base implementation of `_.unary` without support for storing metadata.
   *
   * @private
   * @param {Function} func The function to cap arguments for.
   * @returns {Function} Returns the new capped function.
   */
  function baseUnary(func) {
    return function(value) {
      return func(value);
    };
  }

  /**
   * The base implementation of `_.values` and `_.valuesIn` which creates an
   * array of `object` property values corresponding to the property names
   * of `props`.
   *
   * @private
   * @param {Object} object The object to query.
   * @param {Array} props The property names to get values for.
   * @returns {Object} Returns the array of property values.
   */
  function baseValues(object, props) {
    return arrayMap(props, function(key) {
      return object[key];
    });
  }

  /**
   * Checks if a `cache` value for `key` exists.
   *
   * @private
   * @param {Object} cache The cache to query.
   * @param {string} key The key of the entry to check.
   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
   */
  function cacheHas(cache, key) {
    return cache.has(key);
  }

  /**
   * Used by `_.trim` and `_.trimStart` to get the index of the first string symbol
   * that is not found in the character symbols.
   *
   * @private
   * @param {Array} strSymbols The string symbols to inspect.
   * @param {Array} chrSymbols The character symbols to find.
   * @returns {number} Returns the index of the first unmatched string symbol.
   */
  function charsStartIndex(strSymbols, chrSymbols) {
    var index = -1,
        length = strSymbols.length;

    while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}
    return index;
  }

  /**
   * Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol
   * that is not found in the character symbols.
   *
   * @private
   * @param {Array} strSymbols The string symbols to inspect.
   * @param {Array} chrSymbols The character symbols to find.
   * @returns {number} Returns the index of the last unmatched string symbol.
   */
  function charsEndIndex(strSymbols, chrSymbols) {
    var index = strSymbols.length;

    while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}
    return index;
  }

  /**
   * Gets the number of `placeholder` occurrences in `array`.
   *
   * @private
   * @param {Array} array The array to inspect.
   * @param {*} placeholder The placeholder to search for.
   * @returns {number} Returns the placeholder count.
   */
  function countHolders(array, placeholder) {
    var length = array.length,
        result = 0;

    while (length--) {
      if (array[length] === placeholder) {
        ++result;
      }
    }
    return result;
  }

  /**
   * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A
   * letters to basic Latin letters.
   *
   * @private
   * @param {string} letter The matched letter to deburr.
   * @returns {string} Returns the deburred letter.
   */
  var deburrLetter = basePropertyOf(deburredLetters);

  /**
   * Used by `_.escape` to convert characters to HTML entities.
   *
   * @private
   * @param {string} chr The matched character to escape.
   * @returns {string} Returns the escaped character.
   */
  var escapeHtmlChar = basePropertyOf(htmlEscapes);

  /**
   * Used by `_.template` to escape characters for inclusion in compiled string literals.
   *
   * @private
   * @param {string} chr The matched character to escape.
   * @returns {string} Returns the escaped character.
   */
  function escapeStringChar(chr) {
    return '\\' + stringEscapes[chr];
  }

  /**
   * Gets the value at `key` of `object`.
   *
   * @private
   * @param {Object} [object] The object to query.
   * @param {string} key The key of the property to get.
   * @returns {*} Returns the property value.
   */
  function getValue(object, key) {
    return object == null ? undefined : object[key];
  }

  /**
   * Checks if `string` contains Unicode symbols.
   *
   * @private
   * @param {string} string The string to inspect.
   * @returns {boolean} Returns `true` if a symbol is found, else `false`.
   */
  function hasUnicode(string) {
    return reHasUnicode.test(string);
  }

  /**
   * Checks if `string` contains a word composed of Unicode symbols.
   *
   * @private
   * @param {string} string The string to inspect.
   * @returns {boolean} Returns `true` if a word is found, else `false`.
   */
  function hasUnicodeWord(string) {
    return reHasUnicodeWord.test(string);
  }

  /**
   * Converts `iterator` to an array.
   *
   * @private
   * @param {Object} iterator The iterator to convert.
   * @returns {Array} Returns the converted array.
   */
  function iteratorToArray(iterator) {
    var data,
        result = [];

    while (!(data = iterator.next()).done) {
      result.push(data.value);
    }
    return result;
  }

  /**
   * Converts `map` to its key-value pairs.
   *
   * @private
   * @param {Object} map The map to convert.
   * @returns {Array} Returns the key-value pairs.
   */
  function mapToArray(map) {
    var index = -1,
        result = Array(map.size);

    map.forEach(function(value, key) {
      result[++index] = [key, value];
    });
    return result;
  }

  /**
   * Creates a unary function that invokes `func` with its argument transformed.
   *
   * @private
   * @param {Function} func The function to wrap.
   * @param {Function} transform The argument transform.
   * @returns {Function} Returns the new function.
   */
  function overArg(func, transform) {
    return function(arg) {
      return func(transform(arg));
    };
  }

  /**
   * Replaces all `placeholder` elements in `array` with an internal placeholder
   * and returns an array of their indexes.
   *
   * @private
   * @param {Array} array The array to modify.
   * @param {*} placeholder The placeholder to replace.
   * @returns {Array} Returns the new array of placeholder indexes.
   */
  function replaceHolders(array, placeholder) {
    var index = -1,
        length = array.length,
        resIndex = 0,
        result = [];

    while (++index < length) {
      var value = array[index];
      if (value === placeholder || value === PLACEHOLDER) {
        array[index] = PLACEHOLDER;
        result[resIndex++] = index;
      }
    }
    return result;
  }

  /**
   * Converts `set` to an array of its values.
   *
   * @private
   * @param {Object} set The set to convert.
   * @returns {Array} Returns the values.
   */
  function setToArray(set) {
    var index = -1,
        result = Array(set.size);

    set.forEach(function(value) {
      result[++index] = value;
    });
    return result;
  }

  /**
   * Converts `set` to its value-value pairs.
   *
   * @private
   * @param {Object} set The set to convert.
   * @returns {Array} Returns the value-value pairs.
   */
  function setToPairs(set) {
    var index = -1,
        result = Array(set.size);

    set.forEach(function(value) {
      result[++index] = [value, value];
    });
    return result;
  }

  /**
   * A specialized version of `_.indexOf` which performs strict equality
   * comparisons of values, i.e. `===`.
   *
   * @private
   * @param {Array} array The array to inspect.
   * @param {*} value The value to search for.
   * @param {number} fromIndex The index to search from.
   * @returns {number} Returns the index of the matched value, else `-1`.
   */
  function strictIndexOf(array, value, fromIndex) {
    var index = fromIndex - 1,
        length = array.length;

    while (++index < length) {
      if (array[index] === value) {
        return index;
      }
    }
    return -1;
  }

  /**
   * A specialized version of `_.lastIndexOf` which performs strict equality
   * comparisons of values, i.e. `===`.
   *
   * @private
   * @param {Array} array The array to inspect.
   * @param {*} value The value to search for.
   * @param {number} fromIndex The index to search from.
   * @returns {number} Returns the index of the matched value, else `-1`.
   */
  function strictLastIndexOf(array, value, fromIndex) {
    var index = fromIndex + 1;
    while (index--) {
      if (array[index] === value) {
        return index;
      }
    }
    return index;
  }

  /**
   * Gets the number of symbols in `string`.
   *
   * @private
   * @param {string} string The string to inspect.
   * @returns {number} Returns the string size.
   */
  function stringSize(string) {
    return hasUnicode(string)
      ? unicodeSize(string)
      : asciiSize(string);
  }

  /**
   * Converts `string` to an array.
   *
   * @private
   * @param {string} string The string to convert.
   * @returns {Array} Returns the converted array.
   */
  function stringToArray(string) {
    return hasUnicode(string)
      ? unicodeToArray(string)
      : asciiToArray(string);
  }

  /**
   * Used by `_.unescape` to convert HTML entities to characters.
   *
   * @private
   * @param {string} chr The matched character to unescape.
   * @returns {string} Returns the unescaped character.
   */
  var unescapeHtmlChar = basePropertyOf(htmlUnescapes);

  /**
   * Gets the size of a Unicode `string`.
   *
   * @private
   * @param {string} string The string inspect.
   * @returns {number} Returns the string size.
   */
  function unicodeSize(string) {
    var result = reUnicode.lastIndex = 0;
    while (reUnicode.test(string)) {
      ++result;
    }
    return result;
  }

  /**
   * Converts a Unicode `string` to an array.
   *
   * @private
   * @param {string} string The string to convert.
   * @returns {Array} Returns the converted array.
   */
  function unicodeToArray(string) {
    return string.match(reUnicode) || [];
  }

  /**
   * Splits a Unicode `string` into an array of its words.
   *
   * @private
   * @param {string} The string to inspect.
   * @returns {Array} Returns the words of `string`.
   */
  function unicodeWords(string) {
    return string.match(reUnicodeWord) || [];
  }

  /*--------------------------------------------------------------------------*/

  /**
   * Create a new pristine `lodash` function using the `context` object.
   *
   * @static
   * @memberOf _
   * @since 1.1.0
   * @category Util
   * @param {Object} [context=root] The context object.
   * @returns {Function} Returns a new `lodash` function.
   * @example
   *
   * _.mixin({ 'foo': _.constant('foo') });
   *
   * var lodash = _.runInContext();
   * lodash.mixin({ 'bar': lodash.constant('bar') });
   *
   * _.isFunction(_.foo);
   * // => true
   * _.isFunction(_.bar);
   * // => false
   *
   * lodash.isFunction(lodash.foo);
   * // => false
   * lodash.isFunction(lodash.bar);
   * // => true
   *
   * // Create a suped-up `defer` in Node.js.
   * var defer = _.runInContext({ 'setTimeout': setImmediate }).defer;
   */
  var runInContext = (function runInContext(context) {
    context = context == null ? root : _.defaults(root.Object(), context, _.pick(root, contextProps));

    /** Built-in constructor references. */
    var Array = context.Array,
        Date = context.Date,
        Error = context.Error,
        Function = context.Function,
        Math = context.Math,
        Object = context.Object,
        RegExp = context.RegExp,
        String = context.String,
        TypeError = context.TypeError;

    /** Used for built-in method references. */
    var arrayProto = Array.prototype,
        funcProto = Function.prototype,
        objectProto = Object.prototype;

    /** Used to detect overreaching core-js shims. */
    var coreJsData = context['__core-js_shared__'];

    /** Used to resolve the decompiled source of functions. */
    var funcToString = funcProto.toString;

    /** Used to check objects for own properties. */
    var hasOwnProperty = objectProto.hasOwnProperty;

    /** Used to generate unique IDs. */
    var idCounter = 0;

    /** Used to detect methods masquerading as native. */
    var maskSrcKey = (function() {
      var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
      return uid ? ('Symbol(src)_1.' + uid) : '';
    }());

    /**
     * Used to resolve the
     * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
     * of values.
     */
    var nativeObjectToString = objectProto.toString;

    /** Used to infer the `Object` constructor. */
    var objectCtorString = funcToString.call(Object);

    /** Used to restore the original `_` reference in `_.noConflict`. */
    var oldDash = root._;

    /** Used to detect if a method is native. */
    var reIsNative = RegExp('^' +
      funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
      .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
    );

    /** Built-in value references. */
    var Buffer = moduleExports ? context.Buffer : undefined,
        Symbol = context.Symbol,
        Uint8Array = context.Uint8Array,
        allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined,
        getPrototype = overArg(Object.getPrototypeOf, Object),
        objectCreate = Object.create,
        propertyIsEnumerable = objectProto.propertyIsEnumerable,
        splice = arrayProto.splice,
        spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined,
        symIterator = Symbol ? Symbol.iterator : undefined,
        symToStringTag = Symbol ? Symbol.toStringTag : undefined;

    var defineProperty = (function() {
      try {
        var func = getNative(Object, 'defineProperty');
        func({}, '', {});
        return func;
      } catch (e) {}
    }());

    /** Mocked built-ins. */
    var ctxClearTimeout = context.clearTimeout !== root.clearTimeout && context.clearTimeout,
        ctxNow = Date && Date.now !== root.Date.now && Date.now,
        ctxSetTimeout = context.setTimeout !== root.setTimeout && context.setTimeout;

    /* Built-in method references for those with the same name as other `lodash` methods. */
    var nativeCeil = Math.ceil,
        nativeFloor = Math.floor,
        nativeGetSymbols = Object.getOwnPropertySymbols,
        nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,
        nativeIsFinite = context.isFinite,
        nativeJoin = arrayProto.join,
        nativeKeys = overArg(Object.keys, Object),
        nativeMax = Math.max,
        nativeMin = Math.min,
        nativeNow = Date.now,
        nativeParseInt = context.parseInt,
        nativeRandom = Math.random,
        nativeReverse = arrayProto.reverse;

    /* Built-in method references that are verified to be native. */
    var DataView = getNative(context, 'DataView'),
        Map = getNative(context, 'Map'),
        Promise = getNative(context, 'Promise'),
        Set = getNative(context, 'Set'),
        WeakMap = getNative(context, 'WeakMap'),
        nativeCreate = getNative(Object, 'create');

    /** Used to store function metadata. */
    var metaMap = WeakMap && new WeakMap;

    /** Used to lookup unminified function names. */
    var realNames = {};

    /** Used to detect maps, sets, and weakmaps. */
    var dataViewCtorString = toSource(DataView),
        mapCtorString = toSource(Map),
        promiseCtorString = toSource(Promise),
        setCtorString = toSource(Set),
        weakMapCtorString = toSource(WeakMap);

    /** Used to convert symbols to primitives and strings. */
    var symbolProto = Symbol ? Symbol.prototype : undefined,
        symbolValueOf = symbolProto ? symbolProto.valueOf : undefined,
        symbolToString = symbolProto ? symbolProto.toString : undefined;

    /*------------------------------------------------------------------------*/

    /**
     * Creates a `lodash` object which wraps `value` to enable implicit method
     * chain sequences. Methods that operate on and return arrays, collections,
     * and functions can be chained together. Methods that retrieve a single value
     * or may return a primitive value will automatically end the chain sequence
     * and return the unwrapped value. Otherwise, the value must be unwrapped
     * with `_#value`.
     *
     * Explicit chain sequences, which must be unwrapped with `_#value`, may be
     * enabled using `_.chain`.
     *
     * The execution of chained methods is lazy, that is, it's deferred until
     * `_#value` is implicitly or explicitly called.
     *
     * Lazy evaluation allows several methods to support shortcut fusion.
     * Shortcut fusion is an optimization to merge iteratee calls; this avoids
     * the creation of intermediate arrays and can greatly reduce the number of
     * iteratee executions. Sections of a chain sequence qualify for shortcut
     * fusion if the section is applied to an array and iteratees accept only
     * one argument. The heuristic for whether a section qualifies for shortcut
     * fusion is subject to change.
     *
     * Chaining is supported in custom builds as long as the `_#value` method is
     * directly or indirectly included in the build.
     *
     * In addition to lodash methods, wrappers have `Array` and `String` methods.
     *
     * The wrapper `Array` methods are:
     * `concat`, `join`, `pop`, `push`, `shift`, `sort`, `splice`, and `unshift`
     *
     * The wrapper `String` methods are:
     * `replace` and `split`
     *
     * The wrapper methods that support shortcut fusion are:
     * `at`, `compact`, `drop`, `dropRight`, `dropWhile`, `filter`, `find`,
     * `findLast`, `head`, `initial`, `last`, `map`, `reject`, `reverse`, `slice`,
     * `tail`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, and `toArray`
     *
     * The chainable wrapper methods are:
     * `after`, `ary`, `assign`, `assignIn`, `assignInWith`, `assignWith`, `at`,
     * `before`, `bind`, `bindAll`, `bindKey`, `castArray`, `chain`, `chunk`,
     * `commit`, `compact`, `concat`, `conforms`, `constant`, `countBy`, `create`,
     * `curry`, `debounce`, `defaults`, `defaultsDeep`, `defer`, `delay`,
     * `difference`, `differenceBy`, `differenceWith`, `drop`, `dropRight`,
     * `dropRightWhile`, `dropWhile`, `extend`, `extendWith`, `fill`, `filter`,
     * `flatMap`, `flatMapDeep`, `flatMapDepth`, `flatten`, `flattenDeep`,
     * `flattenDepth`, `flip`, `flow`, `flowRight`, `fromPairs`, `functions`,
     * `functionsIn`, `groupBy`, `initial`, `intersection`, `intersectionBy`,
     * `intersectionWith`, `invert`, `invertBy`, `invokeMap`, `iteratee`, `keyBy`,
     * `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`, `matchesProperty`,
     * `memoize`, `merge`, `mergeWith`, `method`, `methodOf`, `mixin`, `negate`,
     * `nthArg`, `omit`, `omitBy`, `once`, `orderBy`, `over`, `overArgs`,
     * `overEvery`, `overSome`, `partial`, `partialRight`, `partition`, `pick`,
     * `pickBy`, `plant`, `property`, `propertyOf`, `pull`, `pullAll`, `pullAllBy`,
     * `pullAllWith`, `pullAt`, `push`, `range`, `rangeRight`, `rearg`, `reject`,
     * `remove`, `rest`, `reverse`, `sampleSize`, `set`, `setWith`, `shuffle`,
     * `slice`, `sort`, `sortBy`, `splice`, `spread`, `tail`, `take`, `takeRight`,
     * `takeRightWhile`, `takeWhile`, `tap`, `throttle`, `thru`, `toArray`,
     * `toPairs`, `toPairsIn`, `toPath`, `toPlainObject`, `transform`, `unary`,
     * `union`, `unionBy`, `unionWith`, `uniq`, `uniqBy`, `uniqWith`, `unset`,
     * `unshift`, `unzip`, `unzipWith`, `update`, `updateWith`, `values`,
     * `valuesIn`, `without`, `wrap`, `xor`, `xorBy`, `xorWith`, `zip`,
     * `zipObject`, `zipObjectDeep`, and `zipWith`
     *
     * The wrapper methods that are **not** chainable by default are:
     * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clamp`, `clone`,
     * `cloneDeep`, `cloneDeepWith`, `cloneWith`, `conformsTo`, `deburr`,
     * `defaultTo`, `divide`, `each`, `eachRight`, `endsWith`, `eq`, `escape`,
     * `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`, `findLast`,
     * `findLastIndex`, `findLastKey`, `first`, `floor`, `forEach`, `forEachRight`,
     * `forIn`, `forInRight`, `forOwn`, `forOwnRight`, `get`, `gt`, `gte`, `has`,
     * `hasIn`, `head`, `identity`, `includes`, `indexOf`, `inRange`, `invoke`,
     * `isArguments`, `isArray`, `isArrayBuffer`, `isArrayLike`, `isArrayLikeObject`,
     * `isBoolean`, `isBuffer`, `isDate`, `isElement`, `isEmpty`, `isEqual`,
     * `isEqualWith`, `isError`, `isFinite`, `isFunction`, `isInteger`, `isLength`,
     * `isMap`, `isMatch`, `isMatchWith`, `isNaN`, `isNative`, `isNil`, `isNull`,
     * `isNumber`, `isObject`, `isObjectLike`, `isPlainObject`, `isRegExp`,
     * `isSafeInteger`, `isSet`, `isString`, `isUndefined`, `isTypedArray`,
     * `isWeakMap`, `isWeakSet`, `join`, `kebabCase`, `last`, `lastIndexOf`,
     * `lowerCase`, `lowerFirst`, `lt`, `lte`, `max`, `maxBy`, `mean`, `meanBy`,
     * `min`, `minBy`, `multiply`, `noConflict`, `noop`, `now`, `nth`, `pad`,
     * `padEnd`, `padStart`, `parseInt`, `pop`, `random`, `reduce`, `reduceRight`,
     * `repeat`, `result`, `round`, `runInContext`, `sample`, `shift`, `size`,
     * `snakeCase`, `some`, `sortedIndex`, `sortedIndexBy`, `sortedLastIndex`,
     * `sortedLastIndexBy`, `startCase`, `startsWith`, `stubArray`, `stubFalse`,
     * `stubObject`, `stubString`, `stubTrue`, `subtract`, `sum`, `sumBy`,
     * `template`, `times`, `toFinite`, `toInteger`, `toJSON`, `toLength`,
     * `toLower`, `toNumber`, `toSafeInteger`, `toString`, `toUpper`, `trim`,
     * `trimEnd`, `trimStart`, `truncate`, `unescape`, `uniqueId`, `upperCase`,
     * `upperFirst`, `value`, and `words`
     *
     * @name _
     * @constructor
     * @category Seq
     * @param {*} value The value to wrap in a `lodash` instance.
     * @returns {Object} Returns the new `lodash` wrapper instance.
     * @example
     *
     * function square(n) {
     *   return n * n;
     * }
     *
     * var wrapped = _([1, 2, 3]);
     *
     * // Returns an unwrapped value.
     * wrapped.reduce(_.add);
     * // => 6
     *
     * // Returns a wrapped value.
     * var squares = wrapped.map(square);
     *
     * _.isArray(squares);
     * // => false
     *
     * _.isArray(squares.value());
     * // => true
     */
    function lodash(value) {
      if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) {
        if (value instanceof LodashWrapper) {
          return value;
        }
        if (hasOwnProperty.call(value, '__wrapped__')) {
          return wrapperClone(value);
        }
      }
      return new LodashWrapper(value);
    }

    /**
     * The base implementation of `_.create` without support for assigning
     * properties to the created object.
     *
     * @private
     * @param {Object} proto The object to inherit from.
     * @returns {Object} Returns the new object.
     */
    var baseCreate = (function() {
      function object() {}
      return function(proto) {
        if (!isObject(proto)) {
          return {};
        }
        if (objectCreate) {
          return objectCreate(proto);
        }
        object.prototype = proto;
        var result = new object;
        object.prototype = undefined;
        return result;
      };
    }());

    /**
     * The function whose prototype chain sequence wrappers inherit from.
     *
     * @private
     */
    function baseLodash() {
      // No operation performed.
    }

    /**
     * The base constructor for creating `lodash` wrapper objects.
     *
     * @private
     * @param {*} value The value to wrap.
     * @param {boolean} [chainAll] Enable explicit method chain sequences.
     */
    function LodashWrapper(value, chainAll) {
      this.__wrapped__ = value;
      this.__actions__ = [];
      this.__chain__ = !!chainAll;
      this.__index__ = 0;
      this.__values__ = undefined;
    }

    /**
     * By default, the template delimiters used by lodash are like those in
     * embedded Ruby (ERB) as well as ES2015 template strings. Change the
     * following template settings to use alternative delimiters.
     *
     * @static
     * @memberOf _
     * @type {Object}
     */
    lodash.templateSettings = {

      /**
       * Used to detect `data` property values to be HTML-escaped.
       *
       * @memberOf _.templateSettings
       * @type {RegExp}
       */
      'escape': reEscape,

      /**
       * Used to detect code to be evaluated.
       *
       * @memberOf _.templateSettings
       * @type {RegExp}
       */
      'evaluate': reEvaluate,

      /**
       * Used to detect `data` property values to inject.
       *
       * @memberOf _.templateSettings
       * @type {RegExp}
       */
      'interpolate': reInterpolate,

      /**
       * Used to reference the data object in the template text.
       *
       * @memberOf _.templateSettings
       * @type {string}
       */
      'variable': '',

      /**
       * Used to import variables into the compiled template.
       *
       * @memberOf _.templateSettings
       * @type {Object}
       */
      'imports': {

        /**
         * A reference to the `lodash` function.
         *
         * @memberOf _.templateSettings.imports
         * @type {Function}
         */
        '_': lodash
      }
    };

    // Ensure wrappers are instances of `baseLodash`.
    lodash.prototype = baseLodash.prototype;
    lodash.prototype.constructor = lodash;

    LodashWrapper.prototype = baseCreate(baseLodash.prototype);
    LodashWrapper.prototype.constructor = LodashWrapper;

    /*------------------------------------------------------------------------*/

    /**
     * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.
     *
     * @private
     * @constructor
     * @param {*} value The value to wrap.
     */
    function LazyWrapper(value) {
      this.__wrapped__ = value;
      this.__actions__ = [];
      this.__dir__ = 1;
      this.__filtered__ = false;
      this.__iteratees__ = [];
      this.__takeCount__ = MAX_ARRAY_LENGTH;
      this.__views__ = [];
    }

    /**
     * Creates a clone of the lazy wrapper object.
     *
     * @private
     * @name clone
     * @memberOf LazyWrapper
     * @returns {Object} Returns the cloned `LazyWrapper` object.
     */
    function lazyClone() {
      var result = new LazyWrapper(this.__wrapped__);
      result.__actions__ = copyArray(this.__actions__);
      result.__dir__ = this.__dir__;
      result.__filtered__ = this.__filtered__;
      result.__iteratees__ = copyArray(this.__iteratees__);
      result.__takeCount__ = this.__takeCount__;
      result.__views__ = copyArray(this.__views__);
      return result;
    }

    /**
     * Reverses the direction of lazy iteration.
     *
     * @private
     * @name reverse
     * @memberOf LazyWrapper
     * @returns {Object} Returns the new reversed `LazyWrapper` object.
     */
    function lazyReverse() {
      if (this.__filtered__) {
        var result = new LazyWrapper(this);
        result.__dir__ = -1;
        result.__filtered__ = true;
      } else {
        result = this.clone();
        result.__dir__ *= -1;
      }
      return result;
    }

    /**
     * Extracts the unwrapped value from its lazy wrapper.
     *
     * @private
     * @name value
     * @memberOf LazyWrapper
     * @returns {*} Returns the unwrapped value.
     */
    function lazyValue() {
      var array = this.__wrapped__.value(),
          dir = this.__dir__,
          isArr = isArray(array),
          isRight = dir < 0,
          arrLength = isArr ? array.length : 0,
          view = getView(0, arrLength, this.__views__),
          start = view.start,
          end = view.end,
          length = end - start,
          index = isRight ? end : (start - 1),
          iteratees = this.__iteratees__,
          iterLength = iteratees.length,
          resIndex = 0,
          takeCount = nativeMin(length, this.__takeCount__);

      if (!isArr || (!isRight && arrLength == length && takeCount == length)) {
        return baseWrapperValue(array, this.__actions__);
      }
      var result = [];

      outer:
      while (length-- && resIndex < takeCount) {
        index += dir;

        var iterIndex = -1,
            value = array[index];

        while (++iterIndex < iterLength) {
          var data = iteratees[iterIndex],
              iteratee = data.iteratee,
              type = data.type,
              computed = iteratee(value);

          if (type == LAZY_MAP_FLAG) {
            value = computed;
          } else if (!computed) {
            if (type == LAZY_FILTER_FLAG) {
              continue outer;
            } else {
              break outer;
            }
          }
        }
        result[resIndex++] = value;
      }
      return result;
    }

    // Ensure `LazyWrapper` is an instance of `baseLodash`.
    LazyWrapper.prototype = baseCreate(baseLodash.prototype);
    LazyWrapper.prototype.constructor = LazyWrapper;

    /*------------------------------------------------------------------------*/

    /**
     * Creates a hash object.
     *
     * @private
     * @constructor
     * @param {Array} [entries] The key-value pairs to cache.
     */
    function Hash(entries) {
      var index = -1,
          length = entries == null ? 0 : entries.length;

      this.clear();
      while (++index < length) {
        var entry = entries[index];
        this.set(entry[0], entry[1]);
      }
    }

    /**
     * Removes all key-value entries from the hash.
     *
     * @private
     * @name clear
     * @memberOf Hash
     */
    function hashClear() {
      this.__data__ = nativeCreate ? nativeCreate(null) : {};
      this.size = 0;
    }

    /**
     * Removes `key` and its value from the hash.
     *
     * @private
     * @name delete
     * @memberOf Hash
     * @param {Object} hash The hash to modify.
     * @param {string} key The key of the value to remove.
     * @returns {boolean} Returns `true` if the entry was removed, else `false`.
     */
    function hashDelete(key) {
      var result = this.has(key) && delete this.__data__[key];
      this.size -= result ? 1 : 0;
      return result;
    }

    /**
     * Gets the hash value for `key`.
     *
     * @private
     * @name get
     * @memberOf Hash
     * @param {string} key The key of the value to get.
     * @returns {*} Returns the entry value.
     */
    function hashGet(key) {
      var data = this.__data__;
      if (nativeCreate) {
        var result = data[key];
        return result === HASH_UNDEFINED ? undefined : result;
      }
      return hasOwnProperty.call(data, key) ? data[key] : undefined;
    }

    /**
     * Checks if a hash value for `key` exists.
     *
     * @private
     * @name has
     * @memberOf Hash
     * @param {string} key The key of the entry to check.
     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
     */
    function hashHas(key) {
      var data = this.__data__;
      return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);
    }

    /**
     * Sets the hash `key` to `value`.
     *
     * @private
     * @name set
     * @memberOf Hash
     * @param {string} key The key of the value to set.
     * @param {*} value The value to set.
     * @returns {Object} Returns the hash instance.
     */
    function hashSet(key, value) {
      var data = this.__data__;
      this.size += this.has(key) ? 0 : 1;
      data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
      return this;
    }

    // Add methods to `Hash`.
    Hash.prototype.clear = hashClear;
    Hash.prototype['delete'] = hashDelete;
    Hash.prototype.get = hashGet;
    Hash.prototype.has = hashHas;
    Hash.prototype.set = hashSet;

    /*------------------------------------------------------------------------*/

    /**
     * Creates an list cache object.
     *
     * @private
     * @constructor
     * @param {Array} [entries] The key-value pairs to cache.
     */
    function ListCache(entries) {
      var index = -1,
          length = entries == null ? 0 : entries.length;

      this.clear();
      while (++index < length) {
        var entry = entries[index];
        this.set(entry[0], entry[1]);
      }
    }

    /**
     * Removes all key-value entries from the list cache.
     *
     * @private
     * @name clear
     * @memberOf ListCache
     */
    function listCacheClear() {
      this.__data__ = [];
      this.size = 0;
    }

    /**
     * Removes `key` and its value from the list cache.
     *
     * @private
     * @name delete
     * @memberOf ListCache
     * @param {string} key The key of the value to remove.
     * @returns {boolean} Returns `true` if the entry was removed, else `false`.
     */
    function listCacheDelete(key) {
      var data = this.__data__,
          index = assocIndexOf(data, key);

      if (index < 0) {
        return false;
      }
      var lastIndex = data.length - 1;
      if (index == lastIndex) {
        data.pop();
      } else {
        splice.call(data, index, 1);
      }
      --this.size;
      return true;
    }

    /**
     * Gets the list cache value for `key`.
     *
     * @private
     * @name get
     * @memberOf ListCache
     * @param {string} key The key of the value to get.
     * @returns {*} Returns the entry value.
     */
    function listCacheGet(key) {
      var data = this.__data__,
          index = assocIndexOf(data, key);

      return index < 0 ? undefined : data[index][1];
    }

    /**
     * Checks if a list cache value for `key` exists.
     *
     * @private
     * @name has
     * @memberOf ListCache
     * @param {string} key The key of the entry to check.
     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
     */
    function listCacheHas(key) {
      return assocIndexOf(this.__data__, key) > -1;
    }

    /**
     * Sets the list cache `key` to `value`.
     *
     * @private
     * @name set
     * @memberOf ListCache
     * @param {string} key The key of the value to set.
     * @param {*} value The value to set.
     * @returns {Object} Returns the list cache instance.
     */
    function listCacheSet(key, value) {
      var data = this.__data__,
          index = assocIndexOf(data, key);

      if (index < 0) {
        ++this.size;
        data.push([key, value]);
      } else {
        data[index][1] = value;
      }
      return this;
    }

    // Add methods to `ListCache`.
    ListCache.prototype.clear = listCacheClear;
    ListCache.prototype['delete'] = listCacheDelete;
    ListCache.prototype.get = listCacheGet;
    ListCache.prototype.has = listCacheHas;
    ListCache.prototype.set = listCacheSet;

    /*------------------------------------------------------------------------*/

    /**
     * Creates a map cache object to store key-value pairs.
     *
     * @private
     * @constructor
     * @param {Array} [entries] The key-value pairs to cache.
     */
    function MapCache(entries) {
      var index = -1,
          length = entries == null ? 0 : entries.length;

      this.clear();
      while (++index < length) {
        var entry = entries[index];
        this.set(entry[0], entry[1]);
      }
    }

    /**
     * Removes all key-value entries from the map.
     *
     * @private
     * @name clear
     * @memberOf MapCache
     */
    function mapCacheClear() {
      this.size = 0;
      this.__data__ = {
        'hash': new Hash,
        'map': new (Map || ListCache),
        'string': new Hash
      };
    }

    /**
     * Removes `key` and its value from the map.
     *
     * @private
     * @name delete
     * @memberOf MapCache
     * @param {string} key The key of the value to remove.
     * @returns {boolean} Returns `true` if the entry was removed, else `false`.
     */
    function mapCacheDelete(key) {
      var result = getMapData(this, key)['delete'](key);
      this.size -= result ? 1 : 0;
      return result;
    }

    /**
     * Gets the map value for `key`.
     *
     * @private
     * @name get
     * @memberOf MapCache
     * @param {string} key The key of the value to get.
     * @returns {*} Returns the entry value.
     */
    function mapCacheGet(key) {
      return getMapData(this, key).get(key);
    }

    /**
     * Checks if a map value for `key` exists.
     *
     * @private
     * @name has
     * @memberOf MapCache
     * @param {string} key The key of the entry to check.
     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
     */
    function mapCacheHas(key) {
      return getMapData(this, key).has(key);
    }

    /**
     * Sets the map `key` to `value`.
     *
     * @private
     * @name set
     * @memberOf MapCache
     * @param {string} key The key of the value to set.
     * @param {*} value The value to set.
     * @returns {Object} Returns the map cache instance.
     */
    function mapCacheSet(key, value) {
      var data = getMapData(this, key),
          size = data.size;

      data.set(key, value);
      this.size += data.size == size ? 0 : 1;
      return this;
    }

    // Add methods to `MapCache`.
    MapCache.prototype.clear = mapCacheClear;
    MapCache.prototype['delete'] = mapCacheDelete;
    MapCache.prototype.get = mapCacheGet;
    MapCache.prototype.has = mapCacheHas;
    MapCache.prototype.set = mapCacheSet;

    /*------------------------------------------------------------------------*/

    /**
     *
     * Creates an array cache object to store unique values.
     *
     * @private
     * @constructor
     * @param {Array} [values] The values to cache.
     */
    function SetCache(values) {
      var index = -1,
          length = values == null ? 0 : values.length;

      this.__data__ = new MapCache;
      while (++index < length) {
        this.add(values[index]);
      }
    }

    /**
     * Adds `value` to the array cache.
     *
     * @private
     * @name add
     * @memberOf SetCache
     * @alias push
     * @param {*} value The value to cache.
     * @returns {Object} Returns the cache instance.
     */
    function setCacheAdd(value) {
      this.__data__.set(value, HASH_UNDEFINED);
      return this;
    }

    /**
     * Checks if `value` is in the array cache.
     *
     * @private
     * @name has
     * @memberOf SetCache
     * @param {*} value The value to search for.
     * @returns {number} Returns `true` if `value` is found, else `false`.
     */
    function setCacheHas(value) {
      return this.__data__.has(value);
    }

    // Add methods to `SetCache`.
    SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
    SetCache.prototype.has = setCacheHas;

    /*------------------------------------------------------------------------*/

    /**
     * Creates a stack cache object to store key-value pairs.
     *
     * @private
     * @constructor
     * @param {Array} [entries] The key-value pairs to cache.
     */
    function Stack(entries) {
      var data = this.__data__ = new ListCache(entries);
      this.size = data.size;
    }

    /**
     * Removes all key-value entries from the stack.
     *
     * @private
     * @name clear
     * @memberOf Stack
     */
    function stackClear() {
      this.__data__ = new ListCache;
      this.size = 0;
    }

    /**
     * Removes `key` and its value from the stack.
     *
     * @private
     * @name delete
     * @memberOf Stack
     * @param {string} key The key of the value to remove.
     * @returns {boolean} Returns `true` if the entry was removed, else `false`.
     */
    function stackDelete(key) {
      var data = this.__data__,
          result = data['delete'](key);

      this.size = data.size;
      return result;
    }

    /**
     * Gets the stack value for `key`.
     *
     * @private
     * @name get
     * @memberOf Stack
     * @param {string} key The key of the value to get.
     * @returns {*} Returns the entry value.
     */
    function stackGet(key) {
      return this.__data__.get(key);
    }

    /**
     * Checks if a stack value for `key` exists.
     *
     * @private
     * @name has
     * @memberOf Stack
     * @param {string} key The key of the entry to check.
     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
     */
    function stackHas(key) {
      return this.__data__.has(key);
    }

    /**
     * Sets the stack `key` to `value`.
     *
     * @private
     * @name set
     * @memberOf Stack
     * @param {string} key The key of the value to set.
     * @param {*} value The value to set.
     * @returns {Object} Returns the stack cache instance.
     */
    function stackSet(key, value) {
      var data = this.__data__;
      if (data instanceof ListCache) {
        var pairs = data.__data__;
        if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
          pairs.push([key, value]);
          this.size = ++data.size;
          return this;
        }
        data = this.__data__ = new MapCache(pairs);
      }
      data.set(key, value);
      this.size = data.size;
      return this;
    }

    // Add methods to `Stack`.
    Stack.prototype.clear = stackClear;
    Stack.prototype['delete'] = stackDelete;
    Stack.prototype.get = stackGet;
    Stack.prototype.has = stackHas;
    Stack.prototype.set = stackSet;

    /*------------------------------------------------------------------------*/

    /**
     * Creates an array of the enumerable property names of the array-like `value`.
     *
     * @private
     * @param {*} value The value to query.
     * @param {boolean} inherited Specify returning inherited property names.
     * @returns {Array} Returns the array of property names.
     */
    function arrayLikeKeys(value, inherited) {
      var isArr = isArray(value),
          isArg = !isArr && isArguments(value),
          isBuff = !isArr && !isArg && isBuffer(value),
          isType = !isArr && !isArg && !isBuff && isTypedArray(value),
          skipIndexes = isArr || isArg || isBuff || isType,
          result = skipIndexes ? baseTimes(value.length, String) : [],
          length = result.length;

      for (var key in value) {
        if ((inherited || hasOwnProperty.call(value, key)) &&
            !(skipIndexes && (
               // Safari 9 has enumerable `arguments.length` in strict mode.
               key == 'length' ||
               // Node.js 0.10 has enumerable non-index properties on buffers.
               (isBuff && (key == 'offset' || key == 'parent')) ||
               // PhantomJS 2 has enumerable non-index properties on typed arrays.
               (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
               // Skip index properties.
               isIndex(key, length)
            ))) {
          result.push(key);
        }
      }
      return result;
    }

    /**
     * A specialized version of `_.sample` for arrays.
     *
     * @private
     * @param {Array} array The array to sample.
     * @returns {*} Returns the random element.
     */
    function arraySample(array) {
      var length = array.length;
      return length ? array[baseRandom(0, length - 1)] : undefined;
    }

    /**
     * A specialized version of `_.sampleSize` for arrays.
     *
     * @private
     * @param {Array} array The array to sample.
     * @param {number} n The number of elements to sample.
     * @returns {Array} Returns the random elements.
     */
    function arraySampleSize(array, n) {
      return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length));
    }

    /**
     * A specialized version of `_.shuffle` for arrays.
     *
     * @private
     * @param {Array} array The array to shuffle.
     * @returns {Array} Returns the new shuffled array.
     */
    function arrayShuffle(array) {
      return shuffleSelf(copyArray(array));
    }

    /**
     * This function is like `assignValue` except that it doesn't assign
     * `undefined` values.
     *
     * @private
     * @param {Object} object The object to modify.
     * @param {string} key The key of the property to assign.
     * @param {*} value The value to assign.
     */
    function assignMergeValue(object, key, value) {
      if ((value !== undefined && !eq(object[key], value)) ||
          (value === undefined && !(key in object))) {
        baseAssignValue(object, key, value);
      }
    }

    /**
     * Assigns `value` to `key` of `object` if the existing value is not equivalent
     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
     * for equality comparisons.
     *
     * @private
     * @param {Object} object The object to modify.
     * @param {string} key The key of the property to assign.
     * @param {*} value The value to assign.
     */
    function assignValue(object, key, value) {
      var objValue = object[key];
      if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
          (value === undefined && !(key in object))) {
        baseAssignValue(object, key, value);
      }
    }

    /**
     * Gets the index at which the `key` is found in `array` of key-value pairs.
     *
     * @private
     * @param {Array} array The array to inspect.
     * @param {*} key The key to search for.
     * @returns {number} Returns the index of the matched value, else `-1`.
     */
    function assocIndexOf(array, key) {
      var length = array.length;
      while (length--) {
        if (eq(array[length][0], key)) {
          return length;
        }
      }
      return -1;
    }

    /**
     * Aggregates elements of `collection` on `accumulator` with keys transformed
     * by `iteratee` and values set by `setter`.
     *
     * @private
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} setter The function to set `accumulator` values.
     * @param {Function} iteratee The iteratee to transform keys.
     * @param {Object} accumulator The initial aggregated object.
     * @returns {Function} Returns `accumulator`.
     */
    function baseAggregator(collection, setter, iteratee, accumulator) {
      baseEach(collection, function(value, key, collection) {
        setter(accumulator, value, iteratee(value), collection);
      });
      return accumulator;
    }

    /**
     * The base implementation of `_.assign` without support for multiple sources
     * or `customizer` functions.
     *
     * @private
     * @param {Object} object The destination object.
     * @param {Object} source The source object.
     * @returns {Object} Returns `object`.
     */
    function baseAssign(object, source) {
      return object && copyObject(source, keys(source), object);
    }

    /**
     * The base implementation of `_.assignIn` without support for multiple sources
     * or `customizer` functions.
     *
     * @private
     * @param {Object} object The destination object.
     * @param {Object} source The source object.
     * @returns {Object} Returns `object`.
     */
    function baseAssignIn(object, source) {
      return object && copyObject(source, keysIn(source), object);
    }

    /**
     * The base implementation of `assignValue` and `assignMergeValue` without
     * value checks.
     *
     * @private
     * @param {Object} object The object to modify.
     * @param {string} key The key of the property to assign.
     * @param {*} value The value to assign.
     */
    function baseAssignValue(object, key, value) {
      if (key == '__proto__' && defineProperty) {
        defineProperty(object, key, {
          'configurable': true,
          'enumerable': true,
          'value': value,
          'writable': true
        });
      } else {
        object[key] = value;
      }
    }

    /**
     * The base implementation of `_.at` without support for individual paths.
     *
     * @private
     * @param {Object} object The object to iterate over.
     * @param {string[]} paths The property paths to pick.
     * @returns {Array} Returns the picked elements.
     */
    function baseAt(object, paths) {
      var index = -1,
          length = paths.length,
          result = Array(length),
          skip = object == null;

      while (++index < length) {
        result[index] = skip ? undefined : get(object, paths[index]);
      }
      return result;
    }

    /**
     * The base implementation of `_.clamp` which doesn't coerce arguments.
     *
     * @private
     * @param {number} number The number to clamp.
     * @param {number} [lower] The lower bound.
     * @param {number} upper The upper bound.
     * @returns {number} Returns the clamped number.
     */
    function baseClamp(number, lower, upper) {
      if (number === number) {
        if (upper !== undefined) {
          number = number <= upper ? number : upper;
        }
        if (lower !== undefined) {
          number = number >= lower ? number : lower;
        }
      }
      return number;
    }

    /**
     * The base implementation of `_.clone` and `_.cloneDeep` which tracks
     * traversed objects.
     *
     * @private
     * @param {*} value The value to clone.
     * @param {boolean} bitmask The bitmask flags.
     *  1 - Deep clone
     *  2 - Flatten inherited properties
     *  4 - Clone symbols
     * @param {Function} [customizer] The function to customize cloning.
     * @param {string} [key] The key of `value`.
     * @param {Object} [object] The parent object of `value`.
     * @param {Object} [stack] Tracks traversed objects and their clone counterparts.
     * @returns {*} Returns the cloned value.
     */
    function baseClone(value, bitmask, customizer, key, object, stack) {
      var result,
          isDeep = bitmask & CLONE_DEEP_FLAG,
          isFlat = bitmask & CLONE_FLAT_FLAG,
          isFull = bitmask & CLONE_SYMBOLS_FLAG;

      if (customizer) {
        result = object ? customizer(value, key, object, stack) : customizer(value);
      }
      if (result !== undefined) {
        return result;
      }
      if (!isObject(value)) {
        return value;
      }
      var isArr = isArray(value);
      if (isArr) {
        result = initCloneArray(value);
        if (!isDeep) {
          return copyArray(value, result);
        }
      } else {
        var tag = getTag(value),
            isFunc = tag == funcTag || tag == genTag;

        if (isBuffer(value)) {
          return cloneBuffer(value, isDeep);
        }
        if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
          result = (isFlat || isFunc) ? {} : initCloneObject(value);
          if (!isDeep) {
            return isFlat
              ? copySymbolsIn(value, baseAssignIn(result, value))
              : copySymbols(value, baseAssign(result, value));
          }
        } else {
          if (!cloneableTags[tag]) {
            return object ? value : {};
          }
          result = initCloneByTag(value, tag, baseClone, isDeep);
        }
      }
      // Check for circular references and return its corresponding clone.
      stack || (stack = new Stack);
      var stacked = stack.get(value);
      if (stacked) {
        return stacked;
      }
      stack.set(value, result);

      var keysFunc = isFull
        ? (isFlat ? getAllKeysIn : getAllKeys)
        : (isFlat ? keysIn : keys);

      var props = isArr ? undefined : keysFunc(value);
      arrayEach(props || value, function(subValue, key) {
        if (props) {
          key = subValue;
          subValue = value[key];
        }
        // Recursively populate clone (susceptible to call stack limits).
        assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));
      });
      return result;
    }

    /**
     * The base implementation of `_.conforms` which doesn't clone `source`.
     *
     * @private
     * @param {Object} source The object of property predicates to conform to.
     * @returns {Function} Returns the new spec function.
     */
    function baseConforms(source) {
      var props = keys(source);
      return function(object) {
        return baseConformsTo(object, source, props);
      };
    }

    /**
     * The base implementation of `_.conformsTo` which accepts `props` to check.
     *
     * @private
     * @param {Object} object The object to inspect.
     * @param {Object} source The object of property predicates to conform to.
     * @returns {boolean} Returns `true` if `object` conforms, else `false`.
     */
    function baseConformsTo(object, source, props) {
      var length = props.length;
      if (object == null) {
        return !length;
      }
      object = Object(object);
      while (length--) {
        var key = props[length],
            predicate = source[key],
            value = object[key];

        if ((value === undefined && !(key in object)) || !predicate(value)) {
          return false;
        }
      }
      return true;
    }

    /**
     * The base implementation of `_.delay` and `_.defer` which accepts `args`
     * to provide to `func`.
     *
     * @private
     * @param {Function} func The function to delay.
     * @param {number} wait The number of milliseconds to delay invocation.
     * @param {Array} args The arguments to provide to `func`.
     * @returns {number|Object} Returns the timer id or timeout object.
     */
    function baseDelay(func, wait, args) {
      if (typeof func != 'function') {
        throw new TypeError(FUNC_ERROR_TEXT);
      }
      return setTimeout(function() { func.apply(undefined, args); }, wait);
    }

    /**
     * The base implementation of methods like `_.difference` without support
     * for excluding multiple arrays or iteratee shorthands.
     *
     * @private
     * @param {Array} array The array to inspect.
     * @param {Array} values The values to exclude.
     * @param {Function} [iteratee] The iteratee invoked per element.
     * @param {Function} [comparator] The comparator invoked per element.
     * @returns {Array} Returns the new array of filtered values.
     */
    function baseDifference(array, values, iteratee, comparator) {
      var index = -1,
          includes = arrayIncludes,
          isCommon = true,
          length = array.length,
          result = [],
          valuesLength = values.length;

      if (!length) {
        return result;
      }
      if (iteratee) {
        values = arrayMap(values, baseUnary(iteratee));
      }
      if (comparator) {
        includes = arrayIncludesWith;
        isCommon = false;
      }
      else if (values.length >= LARGE_ARRAY_SIZE) {
        includes = cacheHas;
        isCommon = false;
        values = new SetCache(values);
      }
      outer:
      while (++index < length) {
        var value = array[index],
            computed = iteratee == null ? value : iteratee(value);

        value = (comparator || value !== 0) ? value : 0;
        if (isCommon && computed === computed) {
          var valuesIndex = valuesLength;
          while (valuesIndex--) {
            if (values[valuesIndex] === computed) {
              continue outer;
            }
          }
          result.push(value);
        }
        else if (!includes(values, computed, comparator)) {
          result.push(value);
        }
      }
      return result;
    }

    /**
     * The base implementation of `_.forEach` without support for iteratee shorthands.
     *
     * @private
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} iteratee The function invoked per iteration.
     * @returns {Array|Object} Returns `collection`.
     */
    var baseEach = createBaseEach(baseForOwn);

    /**
     * The base implementation of `_.forEachRight` without support for iteratee shorthands.
     *
     * @private
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} iteratee The function invoked per iteration.
     * @returns {Array|Object} Returns `collection`.
     */
    var baseEachRight = createBaseEach(baseForOwnRight, true);

    /**
     * The base implementation of `_.every` without support for iteratee shorthands.
     *
     * @private
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} predicate The function invoked per iteration.
     * @returns {boolean} Returns `true` if all elements pass the predicate check,
     *  else `false`
     */
    function baseEvery(collection, predicate) {
      var result = true;
      baseEach(collection, function(value, index, collection) {
        result = !!predicate(value, index, collection);
        return result;
      });
      return result;
    }

    /**
     * The base implementation of methods like `_.max` and `_.min` which accepts a
     * `comparator` to determine the extremum value.
     *
     * @private
     * @param {Array} array The array to iterate over.
     * @param {Function} iteratee The iteratee invoked per iteration.
     * @param {Function} comparator The comparator used to compare values.
     * @returns {*} Returns the extremum value.
     */
    function baseExtremum(array, iteratee, comparator) {
      var index = -1,
          length = array.length;

      while (++index < length) {
        var value = array[index],
            current = iteratee(value);

        if (current != null && (computed === undefined
              ? (current === current && !isSymbol(current))
              : comparator(current, computed)
            )) {
          var computed = current,
              result = value;
        }
      }
      return result;
    }

    /**
     * The base implementation of `_.fill` without an iteratee call guard.
     *
     * @private
     * @param {Array} array The array to fill.
     * @param {*} value The value to fill `array` with.
     * @param {number} [start=0] The start position.
     * @param {number} [end=array.length] The end position.
     * @returns {Array} Returns `array`.
     */
    function baseFill(array, value, start, end) {
      var length = array.length;

      start = toInteger(start);
      if (start < 0) {
        start = -start > length ? 0 : (length + start);
      }
      end = (end === undefined || end > length) ? length : toInteger(end);
      if (end < 0) {
        end += length;
      }
      end = start > end ? 0 : toLength(end);
      while (start < end) {
        array[start++] = value;
      }
      return array;
    }

    /**
     * The base implementation of `_.filter` without support for iteratee shorthands.
     *
     * @private
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} predicate The function invoked per iteration.
     * @returns {Array} Returns the new filtered array.
     */
    function baseFilter(collection, predicate) {
      var result = [];
      baseEach(collection, function(value, index, collection) {
        if (predicate(value, index, collection)) {
          result.push(value);
        }
      });
      return result;
    }

    /**
     * The base implementation of `_.flatten` with support for restricting flattening.
     *
     * @private
     * @param {Array} array The array to flatten.
     * @param {number} depth The maximum recursion depth.
     * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.
     * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.
     * @param {Array} [result=[]] The initial result value.
     * @returns {Array} Returns the new flattened array.
     */
    function baseFlatten(array, depth, predicate, isStrict, result) {
      var index = -1,
          length = array.length;

      predicate || (predicate = isFlattenable);
      result || (result = []);

      while (++index < length) {
        var value = array[index];
        if (depth > 0 && predicate(value)) {
          if (depth > 1) {
            // Recursively flatten arrays (susceptible to call stack limits).
            baseFlatten(value, depth - 1, predicate, isStrict, result);
          } else {
            arrayPush(result, value);
          }
        } else if (!isStrict) {
          result[result.length] = value;
        }
      }
      return result;
    }

    /**
     * The base implementation of `baseForOwn` which iterates over `object`
     * properties returned by `keysFunc` and invokes `iteratee` for each property.
     * Iteratee functions may exit iteration early by explicitly returning `false`.
     *
     * @private
     * @param {Object} object The object to iterate over.
     * @param {Function} iteratee The function invoked per iteration.
     * @param {Function} keysFunc The function to get the keys of `object`.
     * @returns {Object} Returns `object`.
     */
    var baseFor = createBaseFor();

    /**
     * This function is like `baseFor` except that it iterates over properties
     * in the opposite order.
     *
     * @private
     * @param {Object} object The object to iterate over.
     * @param {Function} iteratee The function invoked per iteration.
     * @param {Function} keysFunc The function to get the keys of `object`.
     * @returns {Object} Returns `object`.
     */
    var baseForRight = createBaseFor(true);

    /**
     * The base implementation of `_.forOwn` without support for iteratee shorthands.
     *
     * @private
     * @param {Object} object The object to iterate over.
     * @param {Function} iteratee The function invoked per iteration.
     * @returns {Object} Returns `object`.
     */
    function baseForOwn(object, iteratee) {
      return object && baseFor(object, iteratee, keys);
    }

    /**
     * The base implementation of `_.forOwnRight` without support for iteratee shorthands.
     *
     * @private
     * @param {Object} object The object to iterate over.
     * @param {Function} iteratee The function invoked per iteration.
     * @returns {Object} Returns `object`.
     */
    function baseForOwnRight(object, iteratee) {
      return object && baseForRight(object, iteratee, keys);
    }

    /**
     * The base implementation of `_.functions` which creates an array of
     * `object` function property names filtered from `props`.
     *
     * @private
     * @param {Object} object The object to inspect.
     * @param {Array} props The property names to filter.
     * @returns {Array} Returns the function names.
     */
    function baseFunctions(object, props) {
      return arrayFilter(props, function(key) {
        return isFunction(object[key]);
      });
    }

    /**
     * The base implementation of `_.get` without support for default values.
     *
     * @private
     * @param {Object} object The object to query.
     * @param {Array|string} path The path of the property to get.
     * @returns {*} Returns the resolved value.
     */
    function baseGet(object, path) {
      path = castPath(path, object);

      var index = 0,
          length = path.length;

      while (object != null && index < length) {
        object = object[toKey(path[index++])];
      }
      return (index && index == length) ? object : undefined;
    }

    /**
     * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
     * `keysFunc` and `symbolsFunc` to get the enumerable property names and
     * symbols of `object`.
     *
     * @private
     * @param {Object} object The object to query.
     * @param {Function} keysFunc The function to get the keys of `object`.
     * @param {Function} symbolsFunc The function to get the symbols of `object`.
     * @returns {Array} Returns the array of property names and symbols.
     */
    function baseGetAllKeys(object, keysFunc, symbolsFunc) {
      var result = keysFunc(object);
      return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
    }

    /**
     * The base implementation of `getTag` without fallbacks for buggy environments.
     *
     * @private
     * @param {*} value The value to query.
     * @returns {string} Returns the `toStringTag`.
     */
    function baseGetTag(value) {
      if (value == null) {
        return value === undefined ? undefinedTag : nullTag;
      }
      return (symToStringTag && symToStringTag in Object(value))
        ? getRawTag(value)
        : objectToString(value);
    }

    /**
     * The base implementation of `_.gt` which doesn't coerce arguments.
     *
     * @private
     * @param {*} value The value to compare.
     * @param {*} other The other value to compare.
     * @returns {boolean} Returns `true` if `value` is greater than `other`,
     *  else `false`.
     */
    function baseGt(value, other) {
      return value > other;
    }

    /**
     * The base implementation of `_.has` without support for deep paths.
     *
     * @private
     * @param {Object} [object] The object to query.
     * @param {Array|string} key The key to check.
     * @returns {boolean} Returns `true` if `key` exists, else `false`.
     */
    function baseHas(object, key) {
      return object != null && hasOwnProperty.call(object, key);
    }

    /**
     * The base implementation of `_.hasIn` without support for deep paths.
     *
     * @private
     * @param {Object} [object] The object to query.
     * @param {Array|string} key The key to check.
     * @returns {boolean} Returns `true` if `key` exists, else `false`.
     */
    function baseHasIn(object, key) {
      return object != null && key in Object(object);
    }

    /**
     * The base implementation of `_.inRange` which doesn't coerce arguments.
     *
     * @private
     * @param {number} number The number to check.
     * @param {number} start The start of the range.
     * @param {number} end The end of the range.
     * @returns {boolean} Returns `true` if `number` is in the range, else `false`.
     */
    function baseInRange(number, start, end) {
      return number >= nativeMin(start, end) && number < nativeMax(start, end);
    }

    /**
     * The base implementation of methods like `_.intersection`, without support
     * for iteratee shorthands, that accepts an array of arrays to inspect.
     *
     * @private
     * @param {Array} arrays The arrays to inspect.
     * @param {Function} [iteratee] The iteratee invoked per element.
     * @param {Function} [comparator] The comparator invoked per element.
     * @returns {Array} Returns the new array of shared values.
     */
    function baseIntersection(arrays, iteratee, comparator) {
      var includes = comparator ? arrayIncludesWith : arrayIncludes,
          length = arrays[0].length,
          othLength = arrays.length,
          othIndex = othLength,
          caches = Array(othLength),
          maxLength = Infinity,
          result = [];

      while (othIndex--) {
        var array = arrays[othIndex];
        if (othIndex && iteratee) {
          array = arrayMap(array, baseUnary(iteratee));
        }
        maxLength = nativeMin(array.length, maxLength);
        caches[othIndex] = !comparator && (iteratee || (length >= 120 && array.length >= 120))
          ? new SetCache(othIndex && array)
          : undefined;
      }
      array = arrays[0];

      var index = -1,
          seen = caches[0];

      outer:
      while (++index < length && result.length < maxLength) {
        var value = array[index],
            computed = iteratee ? iteratee(value) : value;

        value = (comparator || value !== 0) ? value : 0;
        if (!(seen
              ? cacheHas(seen, computed)
              : includes(result, computed, comparator)
            )) {
          othIndex = othLength;
          while (--othIndex) {
            var cache = caches[othIndex];
            if (!(cache
                  ? cacheHas(cache, computed)
                  : includes(arrays[othIndex], computed, comparator))
                ) {
              continue outer;
            }
          }
          if (seen) {
            seen.push(computed);
          }
          result.push(value);
        }
      }
      return result;
    }

    /**
     * The base implementation of `_.invert` and `_.invertBy` which inverts
     * `object` with values transformed by `iteratee` and set by `setter`.
     *
     * @private
     * @param {Object} object The object to iterate over.
     * @param {Function} setter The function to set `accumulator` values.
     * @param {Function} iteratee The iteratee to transform values.
     * @param {Object} accumulator The initial inverted object.
     * @returns {Function} Returns `accumulator`.
     */
    function baseInverter(object, setter, iteratee, accumulator) {
      baseForOwn(object, function(value, key, object) {
        setter(accumulator, iteratee(value), key, object);
      });
      return accumulator;
    }

    /**
     * The base implementation of `_.invoke` without support for individual
     * method arguments.
     *
     * @private
     * @param {Object} object The object to query.
     * @param {Array|string} path The path of the method to invoke.
     * @param {Array} args The arguments to invoke the method with.
     * @returns {*} Returns the result of the invoked method.
     */
    function baseInvoke(object, path, args) {
      path = castPath(path, object);
      object = parent(object, path);
      var func = object == null ? object : object[toKey(last(path))];
      return func == null ? undefined : apply(func, object, args);
    }

    /**
     * The base implementation of `_.isArguments`.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is an `arguments` object,
     */
    function baseIsArguments(value) {
      return isObjectLike(value) && baseGetTag(value) == argsTag;
    }

    /**
     * The base implementation of `_.isArrayBuffer` without Node.js optimizations.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.
     */
    function baseIsArrayBuffer(value) {
      return isObjectLike(value) && baseGetTag(value) == arrayBufferTag;
    }

    /**
     * The base implementation of `_.isDate` without Node.js optimizations.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a date object, else `false`.
     */
    function baseIsDate(value) {
      return isObjectLike(value) && baseGetTag(value) == dateTag;
    }

    /**
     * The base implementation of `_.isEqual` which supports partial comparisons
     * and tracks traversed objects.
     *
     * @private
     * @param {*} value The value to compare.
     * @param {*} other The other value to compare.
     * @param {boolean} bitmask The bitmask flags.
     *  1 - Unordered comparison
     *  2 - Partial comparison
     * @param {Function} [customizer] The function to customize comparisons.
     * @param {Object} [stack] Tracks traversed `value` and `other` objects.
     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
     */
    function baseIsEqual(value, other, bitmask, customizer, stack) {
      if (value === other) {
        return true;
      }
      if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {
        return value !== value && other !== other;
      }
      return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
    }

    /**
     * A specialized version of `baseIsEqual` for arrays and objects which performs
     * deep comparisons and tracks traversed objects enabling objects with circular
     * references to be compared.
     *
     * @private
     * @param {Object} object The object to compare.
     * @param {Object} other The other object to compare.
     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
     * @param {Function} customizer The function to customize comparisons.
     * @param {Function} equalFunc The function to determine equivalents of values.
     * @param {Object} [stack] Tracks traversed `object` and `other` objects.
     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
     */
    function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
      var objIsArr = isArray(object),
          othIsArr = isArray(other),
          objTag = objIsArr ? arrayTag : getTag(object),
          othTag = othIsArr ? arrayTag : getTag(other);

      objTag = objTag == argsTag ? objectTag : objTag;
      othTag = othTag == argsTag ? objectTag : othTag;

      var objIsObj = objTag == objectTag,
          othIsObj = othTag == objectTag,
          isSameTag = objTag == othTag;

      if (isSameTag && isBuffer(object)) {
        if (!isBuffer(other)) {
          return false;
        }
        objIsArr = true;
        objIsObj = false;
      }
      if (isSameTag && !objIsObj) {
        stack || (stack = new Stack);
        return (objIsArr || isTypedArray(object))
          ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)
          : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
      }
      if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
        var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
            othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');

        if (objIsWrapped || othIsWrapped) {
          var objUnwrapped = objIsWrapped ? object.value() : object,
              othUnwrapped = othIsWrapped ? other.value() : other;

          stack || (stack = new Stack);
          return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
        }
      }
      if (!isSameTag) {
        return false;
      }
      stack || (stack = new Stack);
      return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
    }

    /**
     * The base implementation of `_.isMap` without Node.js optimizations.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a map, else `false`.
     */
    function baseIsMap(value) {
      return isObjectLike(value) && getTag(value) == mapTag;
    }

    /**
     * The base implementation of `_.isMatch` without support for iteratee shorthands.
     *
     * @private
     * @param {Object} object The object to inspect.
     * @param {Object} source The object of property values to match.
     * @param {Array} matchData The property names, values, and compare flags to match.
     * @param {Function} [customizer] The function to customize comparisons.
     * @returns {boolean} Returns `true` if `object` is a match, else `false`.
     */
    function baseIsMatch(object, source, matchData, customizer) {
      var index = matchData.length,
          length = index,
          noCustomizer = !customizer;

      if (object == null) {
        return !length;
      }
      object = Object(object);
      while (index--) {
        var data = matchData[index];
        if ((noCustomizer && data[2])
              ? data[1] !== object[data[0]]
              : !(data[0] in object)
            ) {
          return false;
        }
      }
      while (++index < length) {
        data = matchData[index];
        var key = data[0],
            objValue = object[key],
            srcValue = data[1];

        if (noCustomizer && data[2]) {
          if (objValue === undefined && !(key in object)) {
            return false;
          }
        } else {
          var stack = new Stack;
          if (customizer) {
            var result = customizer(objValue, srcValue, key, object, source, stack);
          }
          if (!(result === undefined
                ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack)
                : result
              )) {
            return false;
          }
        }
      }
      return true;
    }

    /**
     * The base implementation of `_.isNative` without bad shim checks.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a native function,
     *  else `false`.
     */
    function baseIsNative(value) {
      if (!isObject(value) || isMasked(value)) {
        return false;
      }
      var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
      return pattern.test(toSource(value));
    }

    /**
     * The base implementation of `_.isRegExp` without Node.js optimizations.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.
     */
    function baseIsRegExp(value) {
      return isObjectLike(value) && baseGetTag(value) == regexpTag;
    }

    /**
     * The base implementation of `_.isSet` without Node.js optimizations.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a set, else `false`.
     */
    function baseIsSet(value) {
      return isObjectLike(value) && getTag(value) == setTag;
    }

    /**
     * The base implementation of `_.isTypedArray` without Node.js optimizations.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
     */
    function baseIsTypedArray(value) {
      return isObjectLike(value) &&
        isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
    }

    /**
     * The base implementation of `_.iteratee`.
     *
     * @private
     * @param {*} [value=_.identity] The value to convert to an iteratee.
     * @returns {Function} Returns the iteratee.
     */
    function baseIteratee(value) {
      // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.
      // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.
      if (typeof value == 'function') {
        return value;
      }
      if (value == null) {
        return identity;
      }
      if (typeof value == 'object') {
        return isArray(value)
          ? baseMatchesProperty(value[0], value[1])
          : baseMatches(value);
      }
      return property(value);
    }

    /**
     * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
     *
     * @private
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of property names.
     */
    function baseKeys(object) {
      if (!isPrototype(object)) {
        return nativeKeys(object);
      }
      var result = [];
      for (var key in Object(object)) {
        if (hasOwnProperty.call(object, key) && key != 'constructor') {
          result.push(key);
        }
      }
      return result;
    }

    /**
     * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
     *
     * @private
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of property names.
     */
    function baseKeysIn(object) {
      if (!isObject(object)) {
        return nativeKeysIn(object);
      }
      var isProto = isPrototype(object),
          result = [];

      for (var key in object) {
        if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
          result.push(key);
        }
      }
      return result;
    }

    /**
     * The base implementation of `_.lt` which doesn't coerce arguments.
     *
     * @private
     * @param {*} value The value to compare.
     * @param {*} other The other value to compare.
     * @returns {boolean} Returns `true` if `value` is less than `other`,
     *  else `false`.
     */
    function baseLt(value, other) {
      return value < other;
    }

    /**
     * The base implementation of `_.map` without support for iteratee shorthands.
     *
     * @private
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} iteratee The function invoked per iteration.
     * @returns {Array} Returns the new mapped array.
     */
    function baseMap(collection, iteratee) {
      var index = -1,
          result = isArrayLike(collection) ? Array(collection.length) : [];

      baseEach(collection, function(value, key, collection) {
        result[++index] = iteratee(value, key, collection);
      });
      return result;
    }

    /**
     * The base implementation of `_.matches` which doesn't clone `source`.
     *
     * @private
     * @param {Object} source The object of property values to match.
     * @returns {Function} Returns the new spec function.
     */
    function baseMatches(source) {
      var matchData = getMatchData(source);
      if (matchData.length == 1 && matchData[0][2]) {
        return matchesStrictComparable(matchData[0][0], matchData[0][1]);
      }
      return function(object) {
        return object === source || baseIsMatch(object, source, matchData);
      };
    }

    /**
     * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.
     *
     * @private
     * @param {string} path The path of the property to get.
     * @param {*} srcValue The value to match.
     * @returns {Function} Returns the new spec function.
     */
    function baseMatchesProperty(path, srcValue) {
      if (isKey(path) && isStrictComparable(srcValue)) {
        return matchesStrictComparable(toKey(path), srcValue);
      }
      return function(object) {
        var objValue = get(object, path);
        return (objValue === undefined && objValue === srcValue)
          ? hasIn(object, path)
          : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
      };
    }

    /**
     * The base implementation of `_.merge` without support for multiple sources.
     *
     * @private
     * @param {Object} object The destination object.
     * @param {Object} source The source object.
     * @param {number} srcIndex The index of `source`.
     * @param {Function} [customizer] The function to customize merged values.
     * @param {Object} [stack] Tracks traversed source values and their merged
     *  counterparts.
     */
    function baseMerge(object, source, srcIndex, customizer, stack) {
      if (object === source) {
        return;
      }
      baseFor(source, function(srcValue, key) {
        if (isObject(srcValue)) {
          stack || (stack = new Stack);
          baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
        }
        else {
          var newValue = customizer
            ? customizer(object[key], srcValue, (key + ''), object, source, stack)
            : undefined;

          if (newValue === undefined) {
            newValue = srcValue;
          }
          assignMergeValue(object, key, newValue);
        }
      }, keysIn);
    }

    /**
     * A specialized version of `baseMerge` for arrays and objects which performs
     * deep merges and tracks traversed objects enabling objects with circular
     * references to be merged.
     *
     * @private
     * @param {Object} object The destination object.
     * @param {Object} source The source object.
     * @param {string} key The key of the value to merge.
     * @param {number} srcIndex The index of `source`.
     * @param {Function} mergeFunc The function to merge values.
     * @param {Function} [customizer] The function to customize assigned values.
     * @param {Object} [stack] Tracks traversed source values and their merged
     *  counterparts.
     */
    function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
      var objValue = object[key],
          srcValue = source[key],
          stacked = stack.get(srcValue);

      if (stacked) {
        assignMergeValue(object, key, stacked);
        return;
      }
      var newValue = customizer
        ? customizer(objValue, srcValue, (key + ''), object, source, stack)
        : undefined;

      var isCommon = newValue === undefined;

      if (isCommon) {
        var isArr = isArray(srcValue),
            isBuff = !isArr && isBuffer(srcValue),
            isTyped = !isArr && !isBuff && isTypedArray(srcValue);

        newValue = srcValue;
        if (isArr || isBuff || isTyped) {
          if (isArray(objValue)) {
            newValue = objValue;
          }
          else if (isArrayLikeObject(objValue)) {
            newValue = copyArray(objValue);
          }
          else if (isBuff) {
            isCommon = false;
            newValue = cloneBuffer(srcValue, true);
          }
          else if (isTyped) {
            isCommon = false;
            newValue = cloneTypedArray(srcValue, true);
          }
          else {
            newValue = [];
          }
        }
        else if (isPlainObject(srcValue) || isArguments(srcValue)) {
          newValue = objValue;
          if (isArguments(objValue)) {
            newValue = toPlainObject(objValue);
          }
          else if (!isObject(objValue) || (srcIndex && isFunction(objValue))) {
            newValue = initCloneObject(srcValue);
          }
        }
        else {
          isCommon = false;
        }
      }
      if (isCommon) {
        // Recursively merge objects and arrays (susceptible to call stack limits).
        stack.set(srcValue, newValue);
        mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
        stack['delete'](srcValue);
      }
      assignMergeValue(object, key, newValue);
    }

    /**
     * The base implementation of `_.nth` which doesn't coerce arguments.
     *
     * @private
     * @param {Array} array The array to query.
     * @param {number} n The index of the element to return.
     * @returns {*} Returns the nth element of `array`.
     */
    function baseNth(array, n) {
      var length = array.length;
      if (!length) {
        return;
      }
      n += n < 0 ? length : 0;
      return isIndex(n, length) ? array[n] : undefined;
    }

    /**
     * The base implementation of `_.orderBy` without param guards.
     *
     * @private
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by.
     * @param {string[]} orders The sort orders of `iteratees`.
     * @returns {Array} Returns the new sorted array.
     */
    function baseOrderBy(collection, iteratees, orders) {
      var index = -1;
      iteratees = arrayMap(iteratees.length ? iteratees : [identity], baseUnary(getIteratee()));

      var result = baseMap(collection, function(value, key, collection) {
        var criteria = arrayMap(iteratees, function(iteratee) {
          return iteratee(value);
        });
        return { 'criteria': criteria, 'index': ++index, 'value': value };
      });

      return baseSortBy(result, function(object, other) {
        return compareMultiple(object, other, orders);
      });
    }

    /**
     * The base implementation of `_.pick` without support for individual
     * property identifiers.
     *
     * @private
     * @param {Object} object The source object.
     * @param {string[]} paths The property paths to pick.
     * @returns {Object} Returns the new object.
     */
    function basePick(object, paths) {
      return basePickBy(object, paths, function(value, path) {
        return hasIn(object, path);
      });
    }

    /**
     * The base implementation of  `_.pickBy` without support for iteratee shorthands.
     *
     * @private
     * @param {Object} object The source object.
     * @param {string[]} paths The property paths to pick.
     * @param {Function} predicate The function invoked per property.
     * @returns {Object} Returns the new object.
     */
    function basePickBy(object, paths, predicate) {
      var index = -1,
          length = paths.length,
          result = {};

      while (++index < length) {
        var path = paths[index],
            value = baseGet(object, path);

        if (predicate(value, path)) {
          baseSet(result, castPath(path, object), value);
        }
      }
      return result;
    }

    /**
     * A specialized version of `baseProperty` which supports deep paths.
     *
     * @private
     * @param {Array|string} path The path of the property to get.
     * @returns {Function} Returns the new accessor function.
     */
    function basePropertyDeep(path) {
      return function(object) {
        return baseGet(object, path);
      };
    }

    /**
     * The base implementation of `_.pullAllBy` without support for iteratee
     * shorthands.
     *
     * @private
     * @param {Array} array The array to modify.
     * @param {Array} values The values to remove.
     * @param {Function} [iteratee] The iteratee invoked per element.
     * @param {Function} [comparator] The comparator invoked per element.
     * @returns {Array} Returns `array`.
     */
    function basePullAll(array, values, iteratee, comparator) {
      var indexOf = comparator ? baseIndexOfWith : baseIndexOf,
          index = -1,
          length = values.length,
          seen = array;

      if (array === values) {
        values = copyArray(values);
      }
      if (iteratee) {
        seen = arrayMap(array, baseUnary(iteratee));
      }
      while (++index < length) {
        var fromIndex = 0,
            value = values[index],
            computed = iteratee ? iteratee(value) : value;

        while ((fromIndex = indexOf(seen, computed, fromIndex, comparator)) > -1) {
          if (seen !== array) {
            splice.call(seen, fromIndex, 1);
          }
          splice.call(array, fromIndex, 1);
        }
      }
      return array;
    }

    /**
     * The base implementation of `_.pullAt` without support for individual
     * indexes or capturing the removed elements.
     *
     * @private
     * @param {Array} array The array to modify.
     * @param {number[]} indexes The indexes of elements to remove.
     * @returns {Array} Returns `array`.
     */
    function basePullAt(array, indexes) {
      var length = array ? indexes.length : 0,
          lastIndex = length - 1;

      while (length--) {
        var index = indexes[length];
        if (length == lastIndex || index !== previous) {
          var previous = index;
          if (isIndex(index)) {
            splice.call(array, index, 1);
          } else {
            baseUnset(array, index);
          }
        }
      }
      return array;
    }

    /**
     * The base implementation of `_.random` without support for returning
     * floating-point numbers.
     *
     * @private
     * @param {number} lower The lower bound.
     * @param {number} upper The upper bound.
     * @returns {number} Returns the random number.
     */
    function baseRandom(lower, upper) {
      return lower + nativeFloor(nativeRandom() * (upper - lower + 1));
    }

    /**
     * The base implementation of `_.range` and `_.rangeRight` which doesn't
     * coerce arguments.
     *
     * @private
     * @param {number} start The start of the range.
     * @param {number} end The end of the range.
     * @param {number} step The value to increment or decrement by.
     * @param {boolean} [fromRight] Specify iterating from right to left.
     * @returns {Array} Returns the range of numbers.
     */
    function baseRange(start, end, step, fromRight) {
      var index = -1,
          length = nativeMax(nativeCeil((end - start) / (step || 1)), 0),
          result = Array(length);

      while (length--) {
        result[fromRight ? length : ++index] = start;
        start += step;
      }
      return result;
    }

    /**
     * The base implementation of `_.repeat` which doesn't coerce arguments.
     *
     * @private
     * @param {string} string The string to repeat.
     * @param {number} n The number of times to repeat the string.
     * @returns {string} Returns the repeated string.
     */
    function baseRepeat(string, n) {
      var result = '';
      if (!string || n < 1 || n > MAX_SAFE_INTEGER) {
        return result;
      }
      // Leverage the exponentiation by squaring algorithm for a faster repeat.
      // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details.
      do {
        if (n % 2) {
          result += string;
        }
        n = nativeFloor(n / 2);
        if (n) {
          string += string;
        }
      } while (n);

      return result;
    }

    /**
     * The base implementation of `_.rest` which doesn't validate or coerce arguments.
     *
     * @private
     * @param {Function} func The function to apply a rest parameter to.
     * @param {number} [start=func.length-1] The start position of the rest parameter.
     * @returns {Function} Returns the new function.
     */
    function baseRest(func, start) {
      return setToString(overRest(func, start, identity), func + '');
    }

    /**
     * The base implementation of `_.sample`.
     *
     * @private
     * @param {Array|Object} collection The collection to sample.
     * @returns {*} Returns the random element.
     */
    function baseSample(collection) {
      return arraySample(values(collection));
    }

    /**
     * The base implementation of `_.sampleSize` without param guards.
     *
     * @private
     * @param {Array|Object} collection The collection to sample.
     * @param {number} n The number of elements to sample.
     * @returns {Array} Returns the random elements.
     */
    function baseSampleSize(collection, n) {
      var array = values(collection);
      return shuffleSelf(array, baseClamp(n, 0, array.length));
    }

    /**
     * The base implementation of `_.set`.
     *
     * @private
     * @param {Object} object The object to modify.
     * @param {Array|string} path The path of the property to set.
     * @param {*} value The value to set.
     * @param {Function} [customizer] The function to customize path creation.
     * @returns {Object} Returns `object`.
     */
    function baseSet(object, path, value, customizer) {
      if (!isObject(object)) {
        return object;
      }
      path = castPath(path, object);

      var index = -1,
          length = path.length,
          lastIndex = length - 1,
          nested = object;

      while (nested != null && ++index < length) {
        var key = toKey(path[index]),
            newValue = value;

        if (index != lastIndex) {
          var objValue = nested[key];
          newValue = customizer ? customizer(objValue, key, nested) : undefined;
          if (newValue === undefined) {
            newValue = isObject(objValue)
              ? objValue
              : (isIndex(path[index + 1]) ? [] : {});
          }
        }
        assignValue(nested, key, newValue);
        nested = nested[key];
      }
      return object;
    }

    /**
     * The base implementation of `setData` without support for hot loop shorting.
     *
     * @private
     * @param {Function} func The function to associate metadata with.
     * @param {*} data The metadata.
     * @returns {Function} Returns `func`.
     */
    var baseSetData = !metaMap ? identity : function(func, data) {
      metaMap.set(func, data);
      return func;
    };

    /**
     * The base implementation of `setToString` without support for hot loop shorting.
     *
     * @private
     * @param {Function} func The function to modify.
     * @param {Function} string The `toString` result.
     * @returns {Function} Returns `func`.
     */
    var baseSetToString = !defineProperty ? identity : function(func, string) {
      return defineProperty(func, 'toString', {
        'configurable': true,
        'enumerable': false,
        'value': constant(string),
        'writable': true
      });
    };

    /**
     * The base implementation of `_.shuffle`.
     *
     * @private
     * @param {Array|Object} collection The collection to shuffle.
     * @returns {Array} Returns the new shuffled array.
     */
    function baseShuffle(collection) {
      return shuffleSelf(values(collection));
    }

    /**
     * The base implementation of `_.slice` without an iteratee call guard.
     *
     * @private
     * @param {Array} array The array to slice.
     * @param {number} [start=0] The start position.
     * @param {number} [end=array.length] The end position.
     * @returns {Array} Returns the slice of `array`.
     */
    function baseSlice(array, start, end) {
      var index = -1,
          length = array.length;

      if (start < 0) {
        start = -start > length ? 0 : (length + start);
      }
      end = end > length ? length : end;
      if (end < 0) {
        end += length;
      }
      length = start > end ? 0 : ((end - start) >>> 0);
      start >>>= 0;

      var result = Array(length);
      while (++index < length) {
        result[index] = array[index + start];
      }
      return result;
    }

    /**
     * The base implementation of `_.some` without support for iteratee shorthands.
     *
     * @private
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} predicate The function invoked per iteration.
     * @returns {boolean} Returns `true` if any element passes the predicate check,
     *  else `false`.
     */
    function baseSome(collection, predicate) {
      var result;

      baseEach(collection, function(value, index, collection) {
        result = predicate(value, index, collection);
        return !result;
      });
      return !!result;
    }

    /**
     * The base implementation of `_.sortedIndex` and `_.sortedLastIndex` which
     * performs a binary search of `array` to determine the index at which `value`
     * should be inserted into `array` in order to maintain its sort order.
     *
     * @private
     * @param {Array} array The sorted array to inspect.
     * @param {*} value The value to evaluate.
     * @param {boolean} [retHighest] Specify returning the highest qualified index.
     * @returns {number} Returns the index at which `value` should be inserted
     *  into `array`.
     */
    function baseSortedIndex(array, value, retHighest) {
      var low = 0,
          high = array == null ? low : array.length;

      if (typeof value == 'number' && value === value && high <= HALF_MAX_ARRAY_LENGTH) {
        while (low < high) {
          var mid = (low + high) >>> 1,
              computed = array[mid];

          if (computed !== null && !isSymbol(computed) &&
              (retHighest ? (computed <= value) : (computed < value))) {
            low = mid + 1;
          } else {
            high = mid;
          }
        }
        return high;
      }
      return baseSortedIndexBy(array, value, identity, retHighest);
    }

    /**
     * The base implementation of `_.sortedIndexBy` and `_.sortedLastIndexBy`
     * which invokes `iteratee` for `value` and each element of `array` to compute
     * their sort ranking. The iteratee is invoked with one argument; (value).
     *
     * @private
     * @param {Array} array The sorted array to inspect.
     * @param {*} value The value to evaluate.
     * @param {Function} iteratee The iteratee invoked per element.
     * @param {boolean} [retHighest] Specify returning the highest qualified index.
     * @returns {number} Returns the index at which `value` should be inserted
     *  into `array`.
     */
    function baseSortedIndexBy(array, value, iteratee, retHighest) {
      value = iteratee(value);

      var low = 0,
          high = array == null ? 0 : array.length,
          valIsNaN = value !== value,
          valIsNull = value === null,
          valIsSymbol = isSymbol(value),
          valIsUndefined = value === undefined;

      while (low < high) {
        var mid = nativeFloor((low + high) / 2),
            computed = iteratee(array[mid]),
            othIsDefined = computed !== undefined,
            othIsNull = computed === null,
            othIsReflexive = computed === computed,
            othIsSymbol = isSymbol(computed);

        if (valIsNaN) {
          var setLow = retHighest || othIsReflexive;
        } else if (valIsUndefined) {
          setLow = othIsReflexive && (retHighest || othIsDefined);
        } else if (valIsNull) {
          setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);
        } else if (valIsSymbol) {
          setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);
        } else if (othIsNull || othIsSymbol) {
          setLow = false;
        } else {
          setLow = retHighest ? (computed <= value) : (computed < value);
        }
        if (setLow) {
          low = mid + 1;
        } else {
          high = mid;
        }
      }
      return nativeMin(high, MAX_ARRAY_INDEX);
    }

    /**
     * The base implementation of `_.sortedUniq` and `_.sortedUniqBy` without
     * support for iteratee shorthands.
     *
     * @private
     * @param {Array} array The array to inspect.
     * @param {Function} [iteratee] The iteratee invoked per element.
     * @returns {Array} Returns the new duplicate free array.
     */
    function baseSortedUniq(array, iteratee) {
      var index = -1,
          length = array.length,
          resIndex = 0,
          result = [];

      while (++index < length) {
        var value = array[index],
            computed = iteratee ? iteratee(value) : value;

        if (!index || !eq(computed, seen)) {
          var seen = computed;
          result[resIndex++] = value === 0 ? 0 : value;
        }
      }
      return result;
    }

    /**
     * The base implementation of `_.toNumber` which doesn't ensure correct
     * conversions of binary, hexadecimal, or octal string values.
     *
     * @private
     * @param {*} value The value to process.
     * @returns {number} Returns the number.
     */
    function baseToNumber(value) {
      if (typeof value == 'number') {
        return value;
      }
      if (isSymbol(value)) {
        return NAN;
      }
      return +value;
    }

    /**
     * The base implementation of `_.toString` which doesn't convert nullish
     * values to empty strings.
     *
     * @private
     * @param {*} value The value to process.
     * @returns {string} Returns the string.
     */
    function baseToString(value) {
      // Exit early for strings to avoid a performance hit in some environments.
      if (typeof value == 'string') {
        return value;
      }
      if (isArray(value)) {
        // Recursively convert values (susceptible to call stack limits).
        return arrayMap(value, baseToString) + '';
      }
      if (isSymbol(value)) {
        return symbolToString ? symbolToString.call(value) : '';
      }
      var result = (value + '');
      return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
    }

    /**
     * The base implementation of `_.uniqBy` without support for iteratee shorthands.
     *
     * @private
     * @param {Array} array The array to inspect.
     * @param {Function} [iteratee] The iteratee invoked per element.
     * @param {Function} [comparator] The comparator invoked per element.
     * @returns {Array} Returns the new duplicate free array.
     */
    function baseUniq(array, iteratee, comparator) {
      var index = -1,
          includes = arrayIncludes,
          length = array.length,
          isCommon = true,
          result = [],
          seen = result;

      if (comparator) {
        isCommon = false;
        includes = arrayIncludesWith;
      }
      else if (length >= LARGE_ARRAY_SIZE) {
        var set = iteratee ? null : createSet(array);
        if (set) {
          return setToArray(set);
        }
        isCommon = false;
        includes = cacheHas;
        seen = new SetCache;
      }
      else {
        seen = iteratee ? [] : result;
      }
      outer:
      while (++index < length) {
        var value = array[index],
            computed = iteratee ? iteratee(value) : value;

        value = (comparator || value !== 0) ? value : 0;
        if (isCommon && computed === computed) {
          var seenIndex = seen.length;
          while (seenIndex--) {
            if (seen[seenIndex] === computed) {
              continue outer;
            }
          }
          if (iteratee) {
            seen.push(computed);
          }
          result.push(value);
        }
        else if (!includes(seen, computed, comparator)) {
          if (seen !== result) {
            seen.push(computed);
          }
          result.push(value);
        }
      }
      return result;
    }

    /**
     * The base implementation of `_.unset`.
     *
     * @private
     * @param {Object} object The object to modify.
     * @param {Array|string} path The property path to unset.
     * @returns {boolean} Returns `true` if the property is deleted, else `false`.
     */
    function baseUnset(object, path) {
      path = castPath(path, object);
      object = parent(object, path);
      return object == null || delete object[toKey(last(path))];
    }

    /**
     * The base implementation of `_.update`.
     *
     * @private
     * @param {Object} object The object to modify.
     * @param {Array|string} path The path of the property to update.
     * @param {Function} updater The function to produce the updated value.
     * @param {Function} [customizer] The function to customize path creation.
     * @returns {Object} Returns `object`.
     */
    function baseUpdate(object, path, updater, customizer) {
      return baseSet(object, path, updater(baseGet(object, path)), customizer);
    }

    /**
     * The base implementation of methods like `_.dropWhile` and `_.takeWhile`
     * without support for iteratee shorthands.
     *
     * @private
     * @param {Array} array The array to query.
     * @param {Function} predicate The function invoked per iteration.
     * @param {boolean} [isDrop] Specify dropping elements instead of taking them.
     * @param {boolean} [fromRight] Specify iterating from right to left.
     * @returns {Array} Returns the slice of `array`.
     */
    function baseWhile(array, predicate, isDrop, fromRight) {
      var length = array.length,
          index = fromRight ? length : -1;

      while ((fromRight ? index-- : ++index < length) &&
        predicate(array[index], index, array)) {}

      return isDrop
        ? baseSlice(array, (fromRight ? 0 : index), (fromRight ? index + 1 : length))
        : baseSlice(array, (fromRight ? index + 1 : 0), (fromRight ? length : index));
    }

    /**
     * The base implementation of `wrapperValue` which returns the result of
     * performing a sequence of actions on the unwrapped `value`, where each
     * successive action is supplied the return value of the previous.
     *
     * @private
     * @param {*} value The unwrapped value.
     * @param {Array} actions Actions to perform to resolve the unwrapped value.
     * @returns {*} Returns the resolved value.
     */
    function baseWrapperValue(value, actions) {
      var result = value;
      if (result instanceof LazyWrapper) {
        result = result.value();
      }
      return arrayReduce(actions, function(result, action) {
        return action.func.apply(action.thisArg, arrayPush([result], action.args));
      }, result);
    }

    /**
     * The base implementation of methods like `_.xor`, without support for
     * iteratee shorthands, that accepts an array of arrays to inspect.
     *
     * @private
     * @param {Array} arrays The arrays to inspect.
     * @param {Function} [iteratee] The iteratee invoked per element.
     * @param {Function} [comparator] The comparator invoked per element.
     * @returns {Array} Returns the new array of values.
     */
    function baseXor(arrays, iteratee, comparator) {
      var length = arrays.length;
      if (length < 2) {
        return length ? baseUniq(arrays[0]) : [];
      }
      var index = -1,
          result = Array(length);

      while (++index < length) {
        var array = arrays[index],
            othIndex = -1;

        while (++othIndex < length) {
          if (othIndex != index) {
            result[index] = baseDifference(result[index] || array, arrays[othIndex], iteratee, comparator);
          }
        }
      }
      return baseUniq(baseFlatten(result, 1), iteratee, comparator);
    }

    /**
     * This base implementation of `_.zipObject` which assigns values using `assignFunc`.
     *
     * @private
     * @param {Array} props The property identifiers.
     * @param {Array} values The property values.
     * @param {Function} assignFunc The function to assign values.
     * @returns {Object} Returns the new object.
     */
    function baseZipObject(props, values, assignFunc) {
      var index = -1,
          length = props.length,
          valsLength = values.length,
          result = {};

      while (++index < length) {
        var value = index < valsLength ? values[index] : undefined;
        assignFunc(result, props[index], value);
      }
      return result;
    }

    /**
     * Casts `value` to an empty array if it's not an array like object.
     *
     * @private
     * @param {*} value The value to inspect.
     * @returns {Array|Object} Returns the cast array-like object.
     */
    function castArrayLikeObject(value) {
      return isArrayLikeObject(value) ? value : [];
    }

    /**
     * Casts `value` to `identity` if it's not a function.
     *
     * @private
     * @param {*} value The value to inspect.
     * @returns {Function} Returns cast function.
     */
    function castFunction(value) {
      return typeof value == 'function' ? value : identity;
    }

    /**
     * Casts `value` to a path array if it's not one.
     *
     * @private
     * @param {*} value The value to inspect.
     * @param {Object} [object] The object to query keys on.
     * @returns {Array} Returns the cast property path array.
     */
    function castPath(value, object) {
      if (isArray(value)) {
        return value;
      }
      return isKey(value, object) ? [value] : stringToPath(toString(value));
    }

    /**
     * A `baseRest` alias which can be replaced with `identity` by module
     * replacement plugins.
     *
     * @private
     * @type {Function}
     * @param {Function} func The function to apply a rest parameter to.
     * @returns {Function} Returns the new function.
     */
    var castRest = baseRest;

    /**
     * Casts `array` to a slice if it's needed.
     *
     * @private
     * @param {Array} array The array to inspect.
     * @param {number} start The start position.
     * @param {number} [end=array.length] The end position.
     * @returns {Array} Returns the cast slice.
     */
    function castSlice(array, start, end) {
      var length = array.length;
      end = end === undefined ? length : end;
      return (!start && end >= length) ? array : baseSlice(array, start, end);
    }

    /**
     * A simple wrapper around the global [`clearTimeout`](https://mdn.io/clearTimeout).
     *
     * @private
     * @param {number|Object} id The timer id or timeout object of the timer to clear.
     */
    var clearTimeout = ctxClearTimeout || function(id) {
      return root.clearTimeout(id);
    };

    /**
     * Creates a clone of  `buffer`.
     *
     * @private
     * @param {Buffer} buffer The buffer to clone.
     * @param {boolean} [isDeep] Specify a deep clone.
     * @returns {Buffer} Returns the cloned buffer.
     */
    function cloneBuffer(buffer, isDeep) {
      if (isDeep) {
        return buffer.slice();
      }
      var length = buffer.length,
          result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);

      buffer.copy(result);
      return result;
    }

    /**
     * Creates a clone of `arrayBuffer`.
     *
     * @private
     * @param {ArrayBuffer} arrayBuffer The array buffer to clone.
     * @returns {ArrayBuffer} Returns the cloned array buffer.
     */
    function cloneArrayBuffer(arrayBuffer) {
      var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
      new Uint8Array(result).set(new Uint8Array(arrayBuffer));
      return result;
    }

    /**
     * Creates a clone of `dataView`.
     *
     * @private
     * @param {Object} dataView The data view to clone.
     * @param {boolean} [isDeep] Specify a deep clone.
     * @returns {Object} Returns the cloned data view.
     */
    function cloneDataView(dataView, isDeep) {
      var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
      return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
    }

    /**
     * Creates a clone of `map`.
     *
     * @private
     * @param {Object} map The map to clone.
     * @param {Function} cloneFunc The function to clone values.
     * @param {boolean} [isDeep] Specify a deep clone.
     * @returns {Object} Returns the cloned map.
     */
    function cloneMap(map, isDeep, cloneFunc) {
      var array = isDeep ? cloneFunc(mapToArray(map), CLONE_DEEP_FLAG) : mapToArray(map);
      return arrayReduce(array, addMapEntry, new map.constructor);
    }

    /**
     * Creates a clone of `regexp`.
     *
     * @private
     * @param {Object} regexp The regexp to clone.
     * @returns {Object} Returns the cloned regexp.
     */
    function cloneRegExp(regexp) {
      var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
      result.lastIndex = regexp.lastIndex;
      return result;
    }

    /**
     * Creates a clone of `set`.
     *
     * @private
     * @param {Object} set The set to clone.
     * @param {Function} cloneFunc The function to clone values.
     * @param {boolean} [isDeep] Specify a deep clone.
     * @returns {Object} Returns the cloned set.
     */
    function cloneSet(set, isDeep, cloneFunc) {
      var array = isDeep ? cloneFunc(setToArray(set), CLONE_DEEP_FLAG) : setToArray(set);
      return arrayReduce(array, addSetEntry, new set.constructor);
    }

    /**
     * Creates a clone of the `symbol` object.
     *
     * @private
     * @param {Object} symbol The symbol object to clone.
     * @returns {Object} Returns the cloned symbol object.
     */
    function cloneSymbol(symbol) {
      return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
    }

    /**
     * Creates a clone of `typedArray`.
     *
     * @private
     * @param {Object} typedArray The typed array to clone.
     * @param {boolean} [isDeep] Specify a deep clone.
     * @returns {Object} Returns the cloned typed array.
     */
    function cloneTypedArray(typedArray, isDeep) {
      var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
      return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
    }

    /**
     * Compares values to sort them in ascending order.
     *
     * @private
     * @param {*} value The value to compare.
     * @param {*} other The other value to compare.
     * @returns {number} Returns the sort order indicator for `value`.
     */
    function compareAscending(value, other) {
      if (value !== other) {
        var valIsDefined = value !== undefined,
            valIsNull = value === null,
            valIsReflexive = value === value,
            valIsSymbol = isSymbol(value);

        var othIsDefined = other !== undefined,
            othIsNull = other === null,
            othIsReflexive = other === other,
            othIsSymbol = isSymbol(other);

        if ((!othIsNull && !othIsSymbol && !valIsSymbol && value > other) ||
            (valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol) ||
            (valIsNull && othIsDefined && othIsReflexive) ||
            (!valIsDefined && othIsReflexive) ||
            !valIsReflexive) {
          return 1;
        }
        if ((!valIsNull && !valIsSymbol && !othIsSymbol && value < other) ||
            (othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol) ||
            (othIsNull && valIsDefined && valIsReflexive) ||
            (!othIsDefined && valIsReflexive) ||
            !othIsReflexive) {
          return -1;
        }
      }
      return 0;
    }

    /**
     * Used by `_.orderBy` to compare multiple properties of a value to another
     * and stable sort them.
     *
     * If `orders` is unspecified, all values are sorted in ascending order. Otherwise,
     * specify an order of "desc" for descending or "asc" for ascending sort order
     * of corresponding values.
     *
     * @private
     * @param {Object} object The object to compare.
     * @param {Object} other The other object to compare.
     * @param {boolean[]|string[]} orders The order to sort by for each property.
     * @returns {number} Returns the sort order indicator for `object`.
     */
    function compareMultiple(object, other, orders) {
      var index = -1,
          objCriteria = object.criteria,
          othCriteria = other.criteria,
          length = objCriteria.length,
          ordersLength = orders.length;

      while (++index < length) {
        var result = compareAscending(objCriteria[index], othCriteria[index]);
        if (result) {
          if (index >= ordersLength) {
            return result;
          }
          var order = orders[index];
          return result * (order == 'desc' ? -1 : 1);
        }
      }
      // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications
      // that causes it, under certain circumstances, to provide the same value for
      // `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247
      // for more details.
      //
      // This also ensures a stable sort in V8 and other engines.
      // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details.
      return object.index - other.index;
    }

    /**
     * Creates an array that is the composition of partially applied arguments,
     * placeholders, and provided arguments into a single array of arguments.
     *
     * @private
     * @param {Array} args The provided arguments.
     * @param {Array} partials The arguments to prepend to those provided.
     * @param {Array} holders The `partials` placeholder indexes.
     * @params {boolean} [isCurried] Specify composing for a curried function.
     * @returns {Array} Returns the new array of composed arguments.
     */
    function composeArgs(args, partials, holders, isCurried) {
      var argsIndex = -1,
          argsLength = args.length,
          holdersLength = holders.length,
          leftIndex = -1,
          leftLength = partials.length,
          rangeLength = nativeMax(argsLength - holdersLength, 0),
          result = Array(leftLength + rangeLength),
          isUncurried = !isCurried;

      while (++leftIndex < leftLength) {
        result[leftIndex] = partials[leftIndex];
      }
      while (++argsIndex < holdersLength) {
        if (isUncurried || argsIndex < argsLength) {
          result[holders[argsIndex]] = args[argsIndex];
        }
      }
      while (rangeLength--) {
        result[leftIndex++] = args[argsIndex++];
      }
      return result;
    }

    /**
     * This function is like `composeArgs` except that the arguments composition
     * is tailored for `_.partialRight`.
     *
     * @private
     * @param {Array} args The provided arguments.
     * @param {Array} partials The arguments to append to those provided.
     * @param {Array} holders The `partials` placeholder indexes.
     * @params {boolean} [isCurried] Specify composing for a curried function.
     * @returns {Array} Returns the new array of composed arguments.
     */
    function composeArgsRight(args, partials, holders, isCurried) {
      var argsIndex = -1,
          argsLength = args.length,
          holdersIndex = -1,
          holdersLength = holders.length,
          rightIndex = -1,
          rightLength = partials.length,
          rangeLength = nativeMax(argsLength - holdersLength, 0),
          result = Array(rangeLength + rightLength),
          isUncurried = !isCurried;

      while (++argsIndex < rangeLength) {
        result[argsIndex] = args[argsIndex];
      }
      var offset = argsIndex;
      while (++rightIndex < rightLength) {
        result[offset + rightIndex] = partials[rightIndex];
      }
      while (++holdersIndex < holdersLength) {
        if (isUncurried || argsIndex < argsLength) {
          result[offset + holders[holdersIndex]] = args[argsIndex++];
        }
      }
      return result;
    }

    /**
     * Copies the values of `source` to `array`.
     *
     * @private
     * @param {Array} source The array to copy values from.
     * @param {Array} [array=[]] The array to copy values to.
     * @returns {Array} Returns `array`.
     */
    function copyArray(source, array) {
      var index = -1,
          length = source.length;

      array || (array = Array(length));
      while (++index < length) {
        array[index] = source[index];
      }
      return array;
    }

    /**
     * Copies properties of `source` to `object`.
     *
     * @private
     * @param {Object} source The object to copy properties from.
     * @param {Array} props The property identifiers to copy.
     * @param {Object} [object={}] The object to copy properties to.
     * @param {Function} [customizer] The function to customize copied values.
     * @returns {Object} Returns `object`.
     */
    function copyObject(source, props, object, customizer) {
      var isNew = !object;
      object || (object = {});

      var index = -1,
          length = props.length;

      while (++index < length) {
        var key = props[index];

        var newValue = customizer
          ? customizer(object[key], source[key], key, object, source)
          : undefined;

        if (newValue === undefined) {
          newValue = source[key];
        }
        if (isNew) {
          baseAssignValue(object, key, newValue);
        } else {
          assignValue(object, key, newValue);
        }
      }
      return object;
    }

    /**
     * Copies own symbols of `source` to `object`.
     *
     * @private
     * @param {Object} source The object to copy symbols from.
     * @param {Object} [object={}] The object to copy symbols to.
     * @returns {Object} Returns `object`.
     */
    function copySymbols(source, object) {
      return copyObject(source, getSymbols(source), object);
    }

    /**
     * Copies own and inherited symbols of `source` to `object`.
     *
     * @private
     * @param {Object} source The object to copy symbols from.
     * @param {Object} [object={}] The object to copy symbols to.
     * @returns {Object} Returns `object`.
     */
    function copySymbolsIn(source, object) {
      return copyObject(source, getSymbolsIn(source), object);
    }

    /**
     * Creates a function like `_.groupBy`.
     *
     * @private
     * @param {Function} setter The function to set accumulator values.
     * @param {Function} [initializer] The accumulator object initializer.
     * @returns {Function} Returns the new aggregator function.
     */
    function createAggregator(setter, initializer) {
      return function(collection, iteratee) {
        var func = isArray(collection) ? arrayAggregator : baseAggregator,
            accumulator = initializer ? initializer() : {};

        return func(collection, setter, getIteratee(iteratee, 2), accumulator);
      };
    }

    /**
     * Creates a function like `_.assign`.
     *
     * @private
     * @param {Function} assigner The function to assign values.
     * @returns {Function} Returns the new assigner function.
     */
    function createAssigner(assigner) {
      return baseRest(function(object, sources) {
        var index = -1,
            length = sources.length,
            customizer = length > 1 ? sources[length - 1] : undefined,
            guard = length > 2 ? sources[2] : undefined;

        customizer = (assigner.length > 3 && typeof customizer == 'function')
          ? (length--, customizer)
          : undefined;

        if (guard && isIterateeCall(sources[0], sources[1], guard)) {
          customizer = length < 3 ? undefined : customizer;
          length = 1;
        }
        object = Object(object);
        while (++index < length) {
          var source = sources[index];
          if (source) {
            assigner(object, source, index, customizer);
          }
        }
        return object;
      });
    }

    /**
     * Creates a `baseEach` or `baseEachRight` function.
     *
     * @private
     * @param {Function} eachFunc The function to iterate over a collection.
     * @param {boolean} [fromRight] Specify iterating from right to left.
     * @returns {Function} Returns the new base function.
     */
    function createBaseEach(eachFunc, fromRight) {
      return function(collection, iteratee) {
        if (collection == null) {
          return collection;
        }
        if (!isArrayLike(collection)) {
          return eachFunc(collection, iteratee);
        }
        var length = collection.length,
            index = fromRight ? length : -1,
            iterable = Object(collection);

        while ((fromRight ? index-- : ++index < length)) {
          if (iteratee(iterable[index], index, iterable) === false) {
            break;
          }
        }
        return collection;
      };
    }

    /**
     * Creates a base function for methods like `_.forIn` and `_.forOwn`.
     *
     * @private
     * @param {boolean} [fromRight] Specify iterating from right to left.
     * @returns {Function} Returns the new base function.
     */
    function createBaseFor(fromRight) {
      return function(object, iteratee, keysFunc) {
        var index = -1,
            iterable = Object(object),
            props = keysFunc(object),
            length = props.length;

        while (length--) {
          var key = props[fromRight ? length : ++index];
          if (iteratee(iterable[key], key, iterable) === false) {
            break;
          }
        }
        return object;
      };
    }

    /**
     * Creates a function that wraps `func` to invoke it with the optional `this`
     * binding of `thisArg`.
     *
     * @private
     * @param {Function} func The function to wrap.
     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
     * @param {*} [thisArg] The `this` binding of `func`.
     * @returns {Function} Returns the new wrapped function.
     */
    function createBind(func, bitmask, thisArg) {
      var isBind = bitmask & WRAP_BIND_FLAG,
          Ctor = createCtor(func);

      function wrapper() {
        var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
        return fn.apply(isBind ? thisArg : this, arguments);
      }
      return wrapper;
    }

    /**
     * Creates a function like `_.lowerFirst`.
     *
     * @private
     * @param {string} methodName The name of the `String` case method to use.
     * @returns {Function} Returns the new case function.
     */
    function createCaseFirst(methodName) {
      return function(string) {
        string = toString(string);

        var strSymbols = hasUnicode(string)
          ? stringToArray(string)
          : undefined;

        var chr = strSymbols
          ? strSymbols[0]
          : string.charAt(0);

        var trailing = strSymbols
          ? castSlice(strSymbols, 1).join('')
          : string.slice(1);

        return chr[methodName]() + trailing;
      };
    }

    /**
     * Creates a function like `_.camelCase`.
     *
     * @private
     * @param {Function} callback The function to combine each word.
     * @returns {Function} Returns the new compounder function.
     */
    function createCompounder(callback) {
      return function(string) {
        return arrayReduce(words(deburr(string).replace(reApos, '')), callback, '');
      };
    }

    /**
     * Creates a function that produces an instance of `Ctor` regardless of
     * whether it was invoked as part of a `new` expression or by `call` or `apply`.
     *
     * @private
     * @param {Function} Ctor The constructor to wrap.
     * @returns {Function} Returns the new wrapped function.
     */
    function createCtor(Ctor) {
      return function() {
        // Use a `switch` statement to work with class constructors. See
        // http://ecma-international.org/ecma-262/7.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist
        // for more details.
        var args = arguments;
        switch (args.length) {
          case 0: return new Ctor;
          case 1: return new Ctor(args[0]);
          case 2: return new Ctor(args[0], args[1]);
          case 3: return new Ctor(args[0], args[1], args[2]);
          case 4: return new Ctor(args[0], args[1], args[2], args[3]);
          case 5: return new Ctor(args[0], args[1], args[2], args[3], args[4]);
          case 6: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]);
          case 7: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
        }
        var thisBinding = baseCreate(Ctor.prototype),
            result = Ctor.apply(thisBinding, args);

        // Mimic the constructor's `return` behavior.
        // See https://es5.github.io/#x13.2.2 for more details.
        return isObject(result) ? result : thisBinding;
      };
    }

    /**
     * Creates a function that wraps `func` to enable currying.
     *
     * @private
     * @param {Function} func The function to wrap.
     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
     * @param {number} arity The arity of `func`.
     * @returns {Function} Returns the new wrapped function.
     */
    function createCurry(func, bitmask, arity) {
      var Ctor = createCtor(func);

      function wrapper() {
        var length = arguments.length,
            args = Array(length),
            index = length,
            placeholder = getHolder(wrapper);

        while (index--) {
          args[index] = arguments[index];
        }
        var holders = (length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder)
          ? []
          : replaceHolders(args, placeholder);

        length -= holders.length;
        if (length < arity) {
          return createRecurry(
            func, bitmask, createHybrid, wrapper.placeholder, undefined,
            args, holders, undefined, undefined, arity - length);
        }
        var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
        return apply(fn, this, args);
      }
      return wrapper;
    }

    /**
     * Creates a `_.find` or `_.findLast` function.
     *
     * @private
     * @param {Function} findIndexFunc The function to find the collection index.
     * @returns {Function} Returns the new find function.
     */
    function createFind(findIndexFunc) {
      return function(collection, predicate, fromIndex) {
        var iterable = Object(collection);
        if (!isArrayLike(collection)) {
          var iteratee = getIteratee(predicate, 3);
          collection = keys(collection);
          predicate = function(key) { return iteratee(iterable[key], key, iterable); };
        }
        var index = findIndexFunc(collection, predicate, fromIndex);
        return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined;
      };
    }

    /**
     * Creates a `_.flow` or `_.flowRight` function.
     *
     * @private
     * @param {boolean} [fromRight] Specify iterating from right to left.
     * @returns {Function} Returns the new flow function.
     */
    function createFlow(fromRight) {
      return flatRest(function(funcs) {
        var length = funcs.length,
            index = length,
            prereq = LodashWrapper.prototype.thru;

        if (fromRight) {
          funcs.reverse();
        }
        while (index--) {
          var func = funcs[index];
          if (typeof func != 'function') {
            throw new TypeError(FUNC_ERROR_TEXT);
          }
          if (prereq && !wrapper && getFuncName(func) == 'wrapper') {
            var wrapper = new LodashWrapper([], true);
          }
        }
        index = wrapper ? index : length;
        while (++index < length) {
          func = funcs[index];

          var funcName = getFuncName(func),
              data = funcName == 'wrapper' ? getData(func) : undefined;

          if (data && isLaziable(data[0]) &&
                data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) &&
                !data[4].length && data[9] == 1
              ) {
            wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);
          } else {
            wrapper = (func.length == 1 && isLaziable(func))
              ? wrapper[funcName]()
              : wrapper.thru(func);
          }
        }
        return function() {
          var args = arguments,
              value = args[0];

          if (wrapper && args.length == 1 && isArray(value)) {
            return wrapper.plant(value).value();
          }
          var index = 0,
              result = length ? funcs[index].apply(this, args) : value;

          while (++index < length) {
            result = funcs[index].call(this, result);
          }
          return result;
        };
      });
    }

    /**
     * Creates a function that wraps `func` to invoke it with optional `this`
     * binding of `thisArg`, partial application, and currying.
     *
     * @private
     * @param {Function|string} func The function or method name to wrap.
     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
     * @param {*} [thisArg] The `this` binding of `func`.
     * @param {Array} [partials] The arguments to prepend to those provided to
     *  the new function.
     * @param {Array} [holders] The `partials` placeholder indexes.
     * @param {Array} [partialsRight] The arguments to append to those provided
     *  to the new function.
     * @param {Array} [holdersRight] The `partialsRight` placeholder indexes.
     * @param {Array} [argPos] The argument positions of the new function.
     * @param {number} [ary] The arity cap of `func`.
     * @param {number} [arity] The arity of `func`.
     * @returns {Function} Returns the new wrapped function.
     */
    function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) {
      var isAry = bitmask & WRAP_ARY_FLAG,
          isBind = bitmask & WRAP_BIND_FLAG,
          isBindKey = bitmask & WRAP_BIND_KEY_FLAG,
          isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG),
          isFlip = bitmask & WRAP_FLIP_FLAG,
          Ctor = isBindKey ? undefined : createCtor(func);

      function wrapper() {
        var length = arguments.length,
            args = Array(length),
            index = length;

        while (index--) {
          args[index] = arguments[index];
        }
        if (isCurried) {
          var placeholder = getHolder(wrapper),
              holdersCount = countHolders(args, placeholder);
        }
        if (partials) {
          args = composeArgs(args, partials, holders, isCurried);
        }
        if (partialsRight) {
          args = composeArgsRight(args, partialsRight, holdersRight, isCurried);
        }
        length -= holdersCount;
        if (isCurried && length < arity) {
          var newHolders = replaceHolders(args, placeholder);
          return createRecurry(
            func, bitmask, createHybrid, wrapper.placeholder, thisArg,
            args, newHolders, argPos, ary, arity - length
          );
        }
        var thisBinding = isBind ? thisArg : this,
            fn = isBindKey ? thisBinding[func] : func;

        length = args.length;
        if (argPos) {
          args = reorder(args, argPos);
        } else if (isFlip && length > 1) {
          args.reverse();
        }
        if (isAry && ary < length) {
          args.length = ary;
        }
        if (this && this !== root && this instanceof wrapper) {
          fn = Ctor || createCtor(fn);
        }
        return fn.apply(thisBinding, args);
      }
      return wrapper;
    }

    /**
     * Creates a function like `_.invertBy`.
     *
     * @private
     * @param {Function} setter The function to set accumulator values.
     * @param {Function} toIteratee The function to resolve iteratees.
     * @returns {Function} Returns the new inverter function.
     */
    function createInverter(setter, toIteratee) {
      return function(object, iteratee) {
        return baseInverter(object, setter, toIteratee(iteratee), {});
      };
    }

    /**
     * Creates a function that performs a mathematical operation on two values.
     *
     * @private
     * @param {Function} operator The function to perform the operation.
     * @param {number} [defaultValue] The value used for `undefined` arguments.
     * @returns {Function} Returns the new mathematical operation function.
     */
    function createMathOperation(operator, defaultValue) {
      return function(value, other) {
        var result;
        if (value === undefined && other === undefined) {
          return defaultValue;
        }
        if (value !== undefined) {
          result = value;
        }
        if (other !== undefined) {
          if (result === undefined) {
            return other;
          }
          if (typeof value == 'string' || typeof other == 'string') {
            value = baseToString(value);
            other = baseToString(other);
          } else {
            value = baseToNumber(value);
            other = baseToNumber(other);
          }
          result = operator(value, other);
        }
        return result;
      };
    }

    /**
     * Creates a function like `_.over`.
     *
     * @private
     * @param {Function} arrayFunc The function to iterate over iteratees.
     * @returns {Function} Returns the new over function.
     */
    function createOver(arrayFunc) {
      return flatRest(function(iteratees) {
        iteratees = arrayMap(iteratees, baseUnary(getIteratee()));
        return baseRest(function(args) {
          var thisArg = this;
          return arrayFunc(iteratees, function(iteratee) {
            return apply(iteratee, thisArg, args);
          });
        });
      });
    }

    /**
     * Creates the padding for `string` based on `length`. The `chars` string
     * is truncated if the number of characters exceeds `length`.
     *
     * @private
     * @param {number} length The padding length.
     * @param {string} [chars=' '] The string used as padding.
     * @returns {string} Returns the padding for `string`.
     */
    function createPadding(length, chars) {
      chars = chars === undefined ? ' ' : baseToString(chars);

      var charsLength = chars.length;
      if (charsLength < 2) {
        return charsLength ? baseRepeat(chars, length) : chars;
      }
      var result = baseRepeat(chars, nativeCeil(length / stringSize(chars)));
      return hasUnicode(chars)
        ? castSlice(stringToArray(result), 0, length).join('')
        : result.slice(0, length);
    }

    /**
     * Creates a function that wraps `func` to invoke it with the `this` binding
     * of `thisArg` and `partials` prepended to the arguments it receives.
     *
     * @private
     * @param {Function} func The function to wrap.
     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
     * @param {*} thisArg The `this` binding of `func`.
     * @param {Array} partials The arguments to prepend to those provided to
     *  the new function.
     * @returns {Function} Returns the new wrapped function.
     */
    function createPartial(func, bitmask, thisArg, partials) {
      var isBind = bitmask & WRAP_BIND_FLAG,
          Ctor = createCtor(func);

      function wrapper() {
        var argsIndex = -1,
            argsLength = arguments.length,
            leftIndex = -1,
            leftLength = partials.length,
            args = Array(leftLength + argsLength),
            fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;

        while (++leftIndex < leftLength) {
          args[leftIndex] = partials[leftIndex];
        }
        while (argsLength--) {
          args[leftIndex++] = arguments[++argsIndex];
        }
        return apply(fn, isBind ? thisArg : this, args);
      }
      return wrapper;
    }

    /**
     * Creates a `_.range` or `_.rangeRight` function.
     *
     * @private
     * @param {boolean} [fromRight] Specify iterating from right to left.
     * @returns {Function} Returns the new range function.
     */
    function createRange(fromRight) {
      return function(start, end, step) {
        if (step && typeof step != 'number' && isIterateeCall(start, end, step)) {
          end = step = undefined;
        }
        // Ensure the sign of `-0` is preserved.
        start = toFinite(start);
        if (end === undefined) {
          end = start;
          start = 0;
        } else {
          end = toFinite(end);
        }
        step = step === undefined ? (start < end ? 1 : -1) : toFinite(step);
        return baseRange(start, end, step, fromRight);
      };
    }

    /**
     * Creates a function that performs a relational operation on two values.
     *
     * @private
     * @param {Function} operator The function to perform the operation.
     * @returns {Function} Returns the new relational operation function.
     */
    function createRelationalOperation(operator) {
      return function(value, other) {
        if (!(typeof value == 'string' && typeof other == 'string')) {
          value = toNumber(value);
          other = toNumber(other);
        }
        return operator(value, other);
      };
    }

    /**
     * Creates a function that wraps `func` to continue currying.
     *
     * @private
     * @param {Function} func The function to wrap.
     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
     * @param {Function} wrapFunc The function to create the `func` wrapper.
     * @param {*} placeholder The placeholder value.
     * @param {*} [thisArg] The `this` binding of `func`.
     * @param {Array} [partials] The arguments to prepend to those provided to
     *  the new function.
     * @param {Array} [holders] The `partials` placeholder indexes.
     * @param {Array} [argPos] The argument positions of the new function.
     * @param {number} [ary] The arity cap of `func`.
     * @param {number} [arity] The arity of `func`.
     * @returns {Function} Returns the new wrapped function.
     */
    function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) {
      var isCurry = bitmask & WRAP_CURRY_FLAG,
          newHolders = isCurry ? holders : undefined,
          newHoldersRight = isCurry ? undefined : holders,
          newPartials = isCurry ? partials : undefined,
          newPartialsRight = isCurry ? undefined : partials;

      bitmask |= (isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG);
      bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG);

      if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) {
        bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG);
      }
      var newData = [
        func, bitmask, thisArg, newPartials, newHolders, newPartialsRight,
        newHoldersRight, argPos, ary, arity
      ];

      var result = wrapFunc.apply(undefined, newData);
      if (isLaziable(func)) {
        setData(result, newData);
      }
      result.placeholder = placeholder;
      return setWrapToString(result, func, bitmask);
    }

    /**
     * Creates a function like `_.round`.
     *
     * @private
     * @param {string} methodName The name of the `Math` method to use when rounding.
     * @returns {Function} Returns the new round function.
     */
    function createRound(methodName) {
      var func = Math[methodName];
      return function(number, precision) {
        number = toNumber(number);
        precision = precision == null ? 0 : nativeMin(toInteger(precision), 292);
        if (precision) {
          // Shift with exponential notation to avoid floating-point issues.
          // See [MDN](https://mdn.io/round#Examples) for more details.
          var pair = (toString(number) + 'e').split('e'),
              value = func(pair[0] + 'e' + (+pair[1] + precision));

          pair = (toString(value) + 'e').split('e');
          return +(pair[0] + 'e' + (+pair[1] - precision));
        }
        return func(number);
      };
    }

    /**
     * Creates a set object of `values`.
     *
     * @private
     * @param {Array} values The values to add to the set.
     * @returns {Object} Returns the new set.
     */
    var createSet = !(Set && (1 / setToArray(new Set([,-0]))[1]) == INFINITY) ? noop : function(values) {
      return new Set(values);
    };

    /**
     * Creates a `_.toPairs` or `_.toPairsIn` function.
     *
     * @private
     * @param {Function} keysFunc The function to get the keys of a given object.
     * @returns {Function} Returns the new pairs function.
     */
    function createToPairs(keysFunc) {
      return function(object) {
        var tag = getTag(object);
        if (tag == mapTag) {
          return mapToArray(object);
        }
        if (tag == setTag) {
          return setToPairs(object);
        }
        return baseToPairs(object, keysFunc(object));
      };
    }

    /**
     * Creates a function that either curries or invokes `func` with optional
     * `this` binding and partially applied arguments.
     *
     * @private
     * @param {Function|string} func The function or method name to wrap.
     * @param {number} bitmask The bitmask flags.
     *    1 - `_.bind`
     *    2 - `_.bindKey`
     *    4 - `_.curry` or `_.curryRight` of a bound function
     *    8 - `_.curry`
     *   16 - `_.curryRight`
     *   32 - `_.partial`
     *   64 - `_.partialRight`
     *  128 - `_.rearg`
     *  256 - `_.ary`
     *  512 - `_.flip`
     * @param {*} [thisArg] The `this` binding of `func`.
     * @param {Array} [partials] The arguments to be partially applied.
     * @param {Array} [holders] The `partials` placeholder indexes.
     * @param {Array} [argPos] The argument positions of the new function.
     * @param {number} [ary] The arity cap of `func`.
     * @param {number} [arity] The arity of `func`.
     * @returns {Function} Returns the new wrapped function.
     */
    function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) {
      var isBindKey = bitmask & WRAP_BIND_KEY_FLAG;
      if (!isBindKey && typeof func != 'function') {
        throw new TypeError(FUNC_ERROR_TEXT);
      }
      var length = partials ? partials.length : 0;
      if (!length) {
        bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG);
        partials = holders = undefined;
      }
      ary = ary === undefined ? ary : nativeMax(toInteger(ary), 0);
      arity = arity === undefined ? arity : toInteger(arity);
      length -= holders ? holders.length : 0;

      if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) {
        var partialsRight = partials,
            holdersRight = holders;

        partials = holders = undefined;
      }
      var data = isBindKey ? undefined : getData(func);

      var newData = [
        func, bitmask, thisArg, partials, holders, partialsRight, holdersRight,
        argPos, ary, arity
      ];

      if (data) {
        mergeData(newData, data);
      }
      func = newData[0];
      bitmask = newData[1];
      thisArg = newData[2];
      partials = newData[3];
      holders = newData[4];
      arity = newData[9] = newData[9] === undefined
        ? (isBindKey ? 0 : func.length)
        : nativeMax(newData[9] - length, 0);

      if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) {
        bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG);
      }
      if (!bitmask || bitmask == WRAP_BIND_FLAG) {
        var result = createBind(func, bitmask, thisArg);
      } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) {
        result = createCurry(func, bitmask, arity);
      } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) {
        result = createPartial(func, bitmask, thisArg, partials);
      } else {
        result = createHybrid.apply(undefined, newData);
      }
      var setter = data ? baseSetData : setData;
      return setWrapToString(setter(result, newData), func, bitmask);
    }

    /**
     * Used by `_.defaults` to customize its `_.assignIn` use to assign properties
     * of source objects to the destination object for all destination properties
     * that resolve to `undefined`.
     *
     * @private
     * @param {*} objValue The destination value.
     * @param {*} srcValue The source value.
     * @param {string} key The key of the property to assign.
     * @param {Object} object The parent object of `objValue`.
     * @returns {*} Returns the value to assign.
     */
    function customDefaultsAssignIn(objValue, srcValue, key, object) {
      if (objValue === undefined ||
          (eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key))) {
        return srcValue;
      }
      return objValue;
    }

    /**
     * Used by `_.defaultsDeep` to customize its `_.merge` use to merge source
     * objects into destination objects that are passed thru.
     *
     * @private
     * @param {*} objValue The destination value.
     * @param {*} srcValue The source value.
     * @param {string} key The key of the property to merge.
     * @param {Object} object The parent object of `objValue`.
     * @param {Object} source The parent object of `srcValue`.
     * @param {Object} [stack] Tracks traversed source values and their merged
     *  counterparts.
     * @returns {*} Returns the value to assign.
     */
    function customDefaultsMerge(objValue, srcValue, key, object, source, stack) {
      if (isObject(objValue) && isObject(srcValue)) {
        // Recursively merge objects and arrays (susceptible to call stack limits).
        stack.set(srcValue, objValue);
        baseMerge(objValue, srcValue, undefined, customDefaultsMerge, stack);
        stack['delete'](srcValue);
      }
      return objValue;
    }

    /**
     * Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain
     * objects.
     *
     * @private
     * @param {*} value The value to inspect.
     * @param {string} key The key of the property to inspect.
     * @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`.
     */
    function customOmitClone(value) {
      return isPlainObject(value) ? undefined : value;
    }

    /**
     * A specialized version of `baseIsEqualDeep` for arrays with support for
     * partial deep comparisons.
     *
     * @private
     * @param {Array} array The array to compare.
     * @param {Array} other The other array to compare.
     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
     * @param {Function} customizer The function to customize comparisons.
     * @param {Function} equalFunc The function to determine equivalents of values.
     * @param {Object} stack Tracks traversed `array` and `other` objects.
     * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
     */
    function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
      var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
          arrLength = array.length,
          othLength = other.length;

      if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
        return false;
      }
      // Assume cyclic values are equal.
      var stacked = stack.get(array);
      if (stacked && stack.get(other)) {
        return stacked == other;
      }
      var index = -1,
          result = true,
          seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;

      stack.set(array, other);
      stack.set(other, array);

      // Ignore non-index properties.
      while (++index < arrLength) {
        var arrValue = array[index],
            othValue = other[index];

        if (customizer) {
          var compared = isPartial
            ? customizer(othValue, arrValue, index, other, array, stack)
            : customizer(arrValue, othValue, index, array, other, stack);
        }
        if (compared !== undefined) {
          if (compared) {
            continue;
          }
          result = false;
          break;
        }
        // Recursively compare arrays (susceptible to call stack limits).
        if (seen) {
          if (!arraySome(other, function(othValue, othIndex) {
                if (!cacheHas(seen, othIndex) &&
                    (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
                  return seen.push(othIndex);
                }
              })) {
            result = false;
            break;
          }
        } else if (!(
              arrValue === othValue ||
                equalFunc(arrValue, othValue, bitmask, customizer, stack)
            )) {
          result = false;
          break;
        }
      }
      stack['delete'](array);
      stack['delete'](other);
      return result;
    }

    /**
     * A specialized version of `baseIsEqualDeep` for comparing objects of
     * the same `toStringTag`.
     *
     * **Note:** This function only supports comparing values with tags of
     * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
     *
     * @private
     * @param {Object} object The object to compare.
     * @param {Object} other The other object to compare.
     * @param {string} tag The `toStringTag` of the objects to compare.
     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
     * @param {Function} customizer The function to customize comparisons.
     * @param {Function} equalFunc The function to determine equivalents of values.
     * @param {Object} stack Tracks traversed `object` and `other` objects.
     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
     */
    function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
      switch (tag) {
        case dataViewTag:
          if ((object.byteLength != other.byteLength) ||
              (object.byteOffset != other.byteOffset)) {
            return false;
          }
          object = object.buffer;
          other = other.buffer;

        case arrayBufferTag:
          if ((object.byteLength != other.byteLength) ||
              !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
            return false;
          }
          return true;

        case boolTag:
        case dateTag:
        case numberTag:
          // Coerce booleans to `1` or `0` and dates to milliseconds.
          // Invalid dates are coerced to `NaN`.
          return eq(+object, +other);

        case errorTag:
          return object.name == other.name && object.message == other.message;

        case regexpTag:
        case stringTag:
          // Coerce regexes to strings and treat strings, primitives and objects,
          // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring
          // for more details.
          return object == (other + '');

        case mapTag:
          var convert = mapToArray;

        case setTag:
          var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
          convert || (convert = setToArray);

          if (object.size != other.size && !isPartial) {
            return false;
          }
          // Assume cyclic values are equal.
          var stacked = stack.get(object);
          if (stacked) {
            return stacked == other;
          }
          bitmask |= COMPARE_UNORDERED_FLAG;

          // Recursively compare objects (susceptible to call stack limits).
          stack.set(object, other);
          var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
          stack['delete'](object);
          return result;

        case symbolTag:
          if (symbolValueOf) {
            return symbolValueOf.call(object) == symbolValueOf.call(other);
          }
      }
      return false;
    }

    /**
     * A specialized version of `baseIsEqualDeep` for objects with support for
     * partial deep comparisons.
     *
     * @private
     * @param {Object} object The object to compare.
     * @param {Object} other The other object to compare.
     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
     * @param {Function} customizer The function to customize comparisons.
     * @param {Function} equalFunc The function to determine equivalents of values.
     * @param {Object} stack Tracks traversed `object` and `other` objects.
     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
     */
    function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
      var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
          objProps = getAllKeys(object),
          objLength = objProps.length,
          othProps = getAllKeys(other),
          othLength = othProps.length;

      if (objLength != othLength && !isPartial) {
        return false;
      }
      var index = objLength;
      while (index--) {
        var key = objProps[index];
        if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
          return false;
        }
      }
      // Assume cyclic values are equal.
      var stacked = stack.get(object);
      if (stacked && stack.get(other)) {
        return stacked == other;
      }
      var result = true;
      stack.set(object, other);
      stack.set(other, object);

      var skipCtor = isPartial;
      while (++index < objLength) {
        key = objProps[index];
        var objValue = object[key],
            othValue = other[key];

        if (customizer) {
          var compared = isPartial
            ? customizer(othValue, objValue, key, other, object, stack)
            : customizer(objValue, othValue, key, object, other, stack);
        }
        // Recursively compare objects (susceptible to call stack limits).
        if (!(compared === undefined
              ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))
              : compared
            )) {
          result = false;
          break;
        }
        skipCtor || (skipCtor = key == 'constructor');
      }
      if (result && !skipCtor) {
        var objCtor = object.constructor,
            othCtor = other.constructor;

        // Non `Object` object instances with different constructors are not equal.
        if (objCtor != othCtor &&
            ('constructor' in object && 'constructor' in other) &&
            !(typeof objCtor == 'function' && objCtor instanceof objCtor &&
              typeof othCtor == 'function' && othCtor instanceof othCtor)) {
          result = false;
        }
      }
      stack['delete'](object);
      stack['delete'](other);
      return result;
    }

    /**
     * A specialized version of `baseRest` which flattens the rest array.
     *
     * @private
     * @param {Function} func The function to apply a rest parameter to.
     * @returns {Function} Returns the new function.
     */
    function flatRest(func) {
      return setToString(overRest(func, undefined, flatten), func + '');
    }

    /**
     * Creates an array of own enumerable property names and symbols of `object`.
     *
     * @private
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of property names and symbols.
     */
    function getAllKeys(object) {
      return baseGetAllKeys(object, keys, getSymbols);
    }

    /**
     * Creates an array of own and inherited enumerable property names and
     * symbols of `object`.
     *
     * @private
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of property names and symbols.
     */
    function getAllKeysIn(object) {
      return baseGetAllKeys(object, keysIn, getSymbolsIn);
    }

    /**
     * Gets metadata for `func`.
     *
     * @private
     * @param {Function} func The function to query.
     * @returns {*} Returns the metadata for `func`.
     */
    var getData = !metaMap ? noop : function(func) {
      return metaMap.get(func);
    };

    /**
     * Gets the name of `func`.
     *
     * @private
     * @param {Function} func The function to query.
     * @returns {string} Returns the function name.
     */
    function getFuncName(func) {
      var result = (func.name + ''),
          array = realNames[result],
          length = hasOwnProperty.call(realNames, result) ? array.length : 0;

      while (length--) {
        var data = array[length],
            otherFunc = data.func;
        if (otherFunc == null || otherFunc == func) {
          return data.name;
        }
      }
      return result;
    }

    /**
     * Gets the argument placeholder value for `func`.
     *
     * @private
     * @param {Function} func The function to inspect.
     * @returns {*} Returns the placeholder value.
     */
    function getHolder(func) {
      var object = hasOwnProperty.call(lodash, 'placeholder') ? lodash : func;
      return object.placeholder;
    }

    /**
     * Gets the appropriate "iteratee" function. If `_.iteratee` is customized,
     * this function returns the custom method, otherwise it returns `baseIteratee`.
     * If arguments are provided, the chosen function is invoked with them and
     * its result is returned.
     *
     * @private
     * @param {*} [value] The value to convert to an iteratee.
     * @param {number} [arity] The arity of the created iteratee.
     * @returns {Function} Returns the chosen function or its result.
     */
    function getIteratee() {
      var result = lodash.iteratee || iteratee;
      result = result === iteratee ? baseIteratee : result;
      return arguments.length ? result(arguments[0], arguments[1]) : result;
    }

    /**
     * Gets the data for `map`.
     *
     * @private
     * @param {Object} map The map to query.
     * @param {string} key The reference key.
     * @returns {*} Returns the map data.
     */
    function getMapData(map, key) {
      var data = map.__data__;
      return isKeyable(key)
        ? data[typeof key == 'string' ? 'string' : 'hash']
        : data.map;
    }

    /**
     * Gets the property names, values, and compare flags of `object`.
     *
     * @private
     * @param {Object} object The object to query.
     * @returns {Array} Returns the match data of `object`.
     */
    function getMatchData(object) {
      var result = keys(object),
          length = result.length;

      while (length--) {
        var key = result[length],
            value = object[key];

        result[length] = [key, value, isStrictComparable(value)];
      }
      return result;
    }

    /**
     * Gets the native function at `key` of `object`.
     *
     * @private
     * @param {Object} object The object to query.
     * @param {string} key The key of the method to get.
     * @returns {*} Returns the function if it's native, else `undefined`.
     */
    function getNative(object, key) {
      var value = getValue(object, key);
      return baseIsNative(value) ? value : undefined;
    }

    /**
     * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
     *
     * @private
     * @param {*} value The value to query.
     * @returns {string} Returns the raw `toStringTag`.
     */
    function getRawTag(value) {
      var isOwn = hasOwnProperty.call(value, symToStringTag),
          tag = value[symToStringTag];

      try {
        value[symToStringTag] = undefined;
        var unmasked = true;
      } catch (e) {}

      var result = nativeObjectToString.call(value);
      if (unmasked) {
        if (isOwn) {
          value[symToStringTag] = tag;
        } else {
          delete value[symToStringTag];
        }
      }
      return result;
    }

    /**
     * Creates an array of the own enumerable symbols of `object`.
     *
     * @private
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of symbols.
     */
    var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
      if (object == null) {
        return [];
      }
      object = Object(object);
      return arrayFilter(nativeGetSymbols(object), function(symbol) {
        return propertyIsEnumerable.call(object, symbol);
      });
    };

    /**
     * Creates an array of the own and inherited enumerable symbols of `object`.
     *
     * @private
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of symbols.
     */
    var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {
      var result = [];
      while (object) {
        arrayPush(result, getSymbols(object));
        object = getPrototype(object);
      }
      return result;
    };

    /**
     * Gets the `toStringTag` of `value`.
     *
     * @private
     * @param {*} value The value to query.
     * @returns {string} Returns the `toStringTag`.
     */
    var getTag = baseGetTag;

    // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
    if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
        (Map && getTag(new Map) != mapTag) ||
        (Promise && getTag(Promise.resolve()) != promiseTag) ||
        (Set && getTag(new Set) != setTag) ||
        (WeakMap && getTag(new WeakMap) != weakMapTag)) {
      getTag = function(value) {
        var result = baseGetTag(value),
            Ctor = result == objectTag ? value.constructor : undefined,
            ctorString = Ctor ? toSource(Ctor) : '';

        if (ctorString) {
          switch (ctorString) {
            case dataViewCtorString: return dataViewTag;
            case mapCtorString: return mapTag;
            case promiseCtorString: return promiseTag;
            case setCtorString: return setTag;
            case weakMapCtorString: return weakMapTag;
          }
        }
        return result;
      };
    }

    /**
     * Gets the view, applying any `transforms` to the `start` and `end` positions.
     *
     * @private
     * @param {number} start The start of the view.
     * @param {number} end The end of the view.
     * @param {Array} transforms The transformations to apply to the view.
     * @returns {Object} Returns an object containing the `start` and `end`
     *  positions of the view.
     */
    function getView(start, end, transforms) {
      var index = -1,
          length = transforms.length;

      while (++index < length) {
        var data = transforms[index],
            size = data.size;

        switch (data.type) {
          case 'drop':      start += size; break;
          case 'dropRight': end -= size; break;
          case 'take':      end = nativeMin(end, start + size); break;
          case 'takeRight': start = nativeMax(start, end - size); break;
        }
      }
      return { 'start': start, 'end': end };
    }

    /**
     * Extracts wrapper details from the `source` body comment.
     *
     * @private
     * @param {string} source The source to inspect.
     * @returns {Array} Returns the wrapper details.
     */
    function getWrapDetails(source) {
      var match = source.match(reWrapDetails);
      return match ? match[1].split(reSplitDetails) : [];
    }

    /**
     * Checks if `path` exists on `object`.
     *
     * @private
     * @param {Object} object The object to query.
     * @param {Array|string} path The path to check.
     * @param {Function} hasFunc The function to check properties.
     * @returns {boolean} Returns `true` if `path` exists, else `false`.
     */
    function hasPath(object, path, hasFunc) {
      path = castPath(path, object);

      var index = -1,
          length = path.length,
          result = false;

      while (++index < length) {
        var key = toKey(path[index]);
        if (!(result = object != null && hasFunc(object, key))) {
          break;
        }
        object = object[key];
      }
      if (result || ++index != length) {
        return result;
      }
      length = object == null ? 0 : object.length;
      return !!length && isLength(length) && isIndex(key, length) &&
        (isArray(object) || isArguments(object));
    }

    /**
     * Initializes an array clone.
     *
     * @private
     * @param {Array} array The array to clone.
     * @returns {Array} Returns the initialized clone.
     */
    function initCloneArray(array) {
      var length = array.length,
          result = array.constructor(length);

      // Add properties assigned by `RegExp#exec`.
      if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {
        result.index = array.index;
        result.input = array.input;
      }
      return result;
    }

    /**
     * Initializes an object clone.
     *
     * @private
     * @param {Object} object The object to clone.
     * @returns {Object} Returns the initialized clone.
     */
    function initCloneObject(object) {
      return (typeof object.constructor == 'function' && !isPrototype(object))
        ? baseCreate(getPrototype(object))
        : {};
    }

    /**
     * Initializes an object clone based on its `toStringTag`.
     *
     * **Note:** This function only supports cloning values with tags of
     * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
     *
     * @private
     * @param {Object} object The object to clone.
     * @param {string} tag The `toStringTag` of the object to clone.
     * @param {Function} cloneFunc The function to clone values.
     * @param {boolean} [isDeep] Specify a deep clone.
     * @returns {Object} Returns the initialized clone.
     */
    function initCloneByTag(object, tag, cloneFunc, isDeep) {
      var Ctor = object.constructor;
      switch (tag) {
        case arrayBufferTag:
          return cloneArrayBuffer(object);

        case boolTag:
        case dateTag:
          return new Ctor(+object);

        case dataViewTag:
          return cloneDataView(object, isDeep);

        case float32Tag: case float64Tag:
        case int8Tag: case int16Tag: case int32Tag:
        case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:
          return cloneTypedArray(object, isDeep);

        case mapTag:
          return cloneMap(object, isDeep, cloneFunc);

        case numberTag:
        case stringTag:
          return new Ctor(object);

        case regexpTag:
          return cloneRegExp(object);

        case setTag:
          return cloneSet(object, isDeep, cloneFunc);

        case symbolTag:
          return cloneSymbol(object);
      }
    }

    /**
     * Inserts wrapper `details` in a comment at the top of the `source` body.
     *
     * @private
     * @param {string} source The source to modify.
     * @returns {Array} details The details to insert.
     * @returns {string} Returns the modified source.
     */
    function insertWrapDetails(source, details) {
      var length = details.length;
      if (!length) {
        return source;
      }
      var lastIndex = length - 1;
      details[lastIndex] = (length > 1 ? '& ' : '') + details[lastIndex];
      details = details.join(length > 2 ? ', ' : ' ');
      return source.replace(reWrapComment, '{\n/* [wrapped with ' + details + '] */\n');
    }

    /**
     * Checks if `value` is a flattenable `arguments` object or array.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.
     */
    function isFlattenable(value) {
      return isArray(value) || isArguments(value) ||
        !!(spreadableSymbol && value && value[spreadableSymbol]);
    }

    /**
     * Checks if `value` is a valid array-like index.
     *
     * @private
     * @param {*} value The value to check.
     * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
     * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
     */
    function isIndex(value, length) {
      length = length == null ? MAX_SAFE_INTEGER : length;
      return !!length &&
        (typeof value == 'number' || reIsUint.test(value)) &&
        (value > -1 && value % 1 == 0 && value < length);
    }

    /**
     * Checks if the given arguments are from an iteratee call.
     *
     * @private
     * @param {*} value The potential iteratee value argument.
     * @param {*} index The potential iteratee index or key argument.
     * @param {*} object The potential iteratee object argument.
     * @returns {boolean} Returns `true` if the arguments are from an iteratee call,
     *  else `false`.
     */
    function isIterateeCall(value, index, object) {
      if (!isObject(object)) {
        return false;
      }
      var type = typeof index;
      if (type == 'number'
            ? (isArrayLike(object) && isIndex(index, object.length))
            : (type == 'string' && index in object)
          ) {
        return eq(object[index], value);
      }
      return false;
    }

    /**
     * Checks if `value` is a property name and not a property path.
     *
     * @private
     * @param {*} value The value to check.
     * @param {Object} [object] The object to query keys on.
     * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
     */
    function isKey(value, object) {
      if (isArray(value)) {
        return false;
      }
      var type = typeof value;
      if (type == 'number' || type == 'symbol' || type == 'boolean' ||
          value == null || isSymbol(value)) {
        return true;
      }
      return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
        (object != null && value in Object(object));
    }

    /**
     * Checks if `value` is suitable for use as unique object key.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
     */
    function isKeyable(value) {
      var type = typeof value;
      return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
        ? (value !== '__proto__')
        : (value === null);
    }

    /**
     * Checks if `func` has a lazy counterpart.
     *
     * @private
     * @param {Function} func The function to check.
     * @returns {boolean} Returns `true` if `func` has a lazy counterpart,
     *  else `false`.
     */
    function isLaziable(func) {
      var funcName = getFuncName(func),
          other = lodash[funcName];

      if (typeof other != 'function' || !(funcName in LazyWrapper.prototype)) {
        return false;
      }
      if (func === other) {
        return true;
      }
      var data = getData(other);
      return !!data && func === data[0];
    }

    /**
     * Checks if `func` has its source masked.
     *
     * @private
     * @param {Function} func The function to check.
     * @returns {boolean} Returns `true` if `func` is masked, else `false`.
     */
    function isMasked(func) {
      return !!maskSrcKey && (maskSrcKey in func);
    }

    /**
     * Checks if `func` is capable of being masked.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `func` is maskable, else `false`.
     */
    var isMaskable = coreJsData ? isFunction : stubFalse;

    /**
     * Checks if `value` is likely a prototype object.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
     */
    function isPrototype(value) {
      var Ctor = value && value.constructor,
          proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;

      return value === proto;
    }

    /**
     * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` if suitable for strict
     *  equality comparisons, else `false`.
     */
    function isStrictComparable(value) {
      return value === value && !isObject(value);
    }

    /**
     * A specialized version of `matchesProperty` for source values suitable
     * for strict equality comparisons, i.e. `===`.
     *
     * @private
     * @param {string} key The key of the property to get.
     * @param {*} srcValue The value to match.
     * @returns {Function} Returns the new spec function.
     */
    function matchesStrictComparable(key, srcValue) {
      return function(object) {
        if (object == null) {
          return false;
        }
        return object[key] === srcValue &&
          (srcValue !== undefined || (key in Object(object)));
      };
    }

    /**
     * A specialized version of `_.memoize` which clears the memoized function's
     * cache when it exceeds `MAX_MEMOIZE_SIZE`.
     *
     * @private
     * @param {Function} func The function to have its output memoized.
     * @returns {Function} Returns the new memoized function.
     */
    function memoizeCapped(func) {
      var result = memoize(func, function(key) {
        if (cache.size === MAX_MEMOIZE_SIZE) {
          cache.clear();
        }
        return key;
      });

      var cache = result.cache;
      return result;
    }

    /**
     * Merges the function metadata of `source` into `data`.
     *
     * Merging metadata reduces the number of wrappers used to invoke a function.
     * This is possible because methods like `_.bind`, `_.curry`, and `_.partial`
     * may be applied regardless of execution order. Methods like `_.ary` and
     * `_.rearg` modify function arguments, making the order in which they are
     * executed important, preventing the merging of metadata. However, we make
     * an exception for a safe combined case where curried functions have `_.ary`
     * and or `_.rearg` applied.
     *
     * @private
     * @param {Array} data The destination metadata.
     * @param {Array} source The source metadata.
     * @returns {Array} Returns `data`.
     */
    function mergeData(data, source) {
      var bitmask = data[1],
          srcBitmask = source[1],
          newBitmask = bitmask | srcBitmask,
          isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG);

      var isCombo =
        ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_CURRY_FLAG)) ||
        ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_REARG_FLAG) && (data[7].length <= source[8])) ||
        ((srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG)) && (source[7].length <= source[8]) && (bitmask == WRAP_CURRY_FLAG));

      // Exit early if metadata can't be merged.
      if (!(isCommon || isCombo)) {
        return data;
      }
      // Use source `thisArg` if available.
      if (srcBitmask & WRAP_BIND_FLAG) {
        data[2] = source[2];
        // Set when currying a bound function.
        newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG;
      }
      // Compose partial arguments.
      var value = source[3];
      if (value) {
        var partials = data[3];
        data[3] = partials ? composeArgs(partials, value, source[4]) : value;
        data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4];
      }
      // Compose partial right arguments.
      value = source[5];
      if (value) {
        partials = data[5];
        data[5] = partials ? composeArgsRight(partials, value, source[6]) : value;
        data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6];
      }
      // Use source `argPos` if available.
      value = source[7];
      if (value) {
        data[7] = value;
      }
      // Use source `ary` if it's smaller.
      if (srcBitmask & WRAP_ARY_FLAG) {
        data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]);
      }
      // Use source `arity` if one is not provided.
      if (data[9] == null) {
        data[9] = source[9];
      }
      // Use source `func` and merge bitmasks.
      data[0] = source[0];
      data[1] = newBitmask;

      return data;
    }

    /**
     * This function is like
     * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
     * except that it includes inherited enumerable properties.
     *
     * @private
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of property names.
     */
    function nativeKeysIn(object) {
      var result = [];
      if (object != null) {
        for (var key in Object(object)) {
          result.push(key);
        }
      }
      return result;
    }

    /**
     * Converts `value` to a string using `Object.prototype.toString`.
     *
     * @private
     * @param {*} value The value to convert.
     * @returns {string} Returns the converted string.
     */
    function objectToString(value) {
      return nativeObjectToString.call(value);
    }

    /**
     * A specialized version of `baseRest` which transforms the rest array.
     *
     * @private
     * @param {Function} func The function to apply a rest parameter to.
     * @param {number} [start=func.length-1] The start position of the rest parameter.
     * @param {Function} transform The rest array transform.
     * @returns {Function} Returns the new function.
     */
    function overRest(func, start, transform) {
      start = nativeMax(start === undefined ? (func.length - 1) : start, 0);
      return function() {
        var args = arguments,
            index = -1,
            length = nativeMax(args.length - start, 0),
            array = Array(length);

        while (++index < length) {
          array[index] = args[start + index];
        }
        index = -1;
        var otherArgs = Array(start + 1);
        while (++index < start) {
          otherArgs[index] = args[index];
        }
        otherArgs[start] = transform(array);
        return apply(func, this, otherArgs);
      };
    }

    /**
     * Gets the parent value at `path` of `object`.
     *
     * @private
     * @param {Object} object The object to query.
     * @param {Array} path The path to get the parent value of.
     * @returns {*} Returns the parent value.
     */
    function parent(object, path) {
      return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));
    }

    /**
     * Reorder `array` according to the specified indexes where the element at
     * the first index is assigned as the first element, the element at
     * the second index is assigned as the second element, and so on.
     *
     * @private
     * @param {Array} array The array to reorder.
     * @param {Array} indexes The arranged array indexes.
     * @returns {Array} Returns `array`.
     */
    function reorder(array, indexes) {
      var arrLength = array.length,
          length = nativeMin(indexes.length, arrLength),
          oldArray = copyArray(array);

      while (length--) {
        var index = indexes[length];
        array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined;
      }
      return array;
    }

    /**
     * Sets metadata for `func`.
     *
     * **Note:** If this function becomes hot, i.e. is invoked a lot in a short
     * period of time, it will trip its breaker and transition to an identity
     * function to avoid garbage collection pauses in V8. See
     * [V8 issue 2070](https://bugs.chromium.org/p/v8/issues/detail?id=2070)
     * for more details.
     *
     * @private
     * @param {Function} func The function to associate metadata with.
     * @param {*} data The metadata.
     * @returns {Function} Returns `func`.
     */
    var setData = shortOut(baseSetData);

    /**
     * A simple wrapper around the global [`setTimeout`](https://mdn.io/setTimeout).
     *
     * @private
     * @param {Function} func The function to delay.
     * @param {number} wait The number of milliseconds to delay invocation.
     * @returns {number|Object} Returns the timer id or timeout object.
     */
    var setTimeout = ctxSetTimeout || function(func, wait) {
      return root.setTimeout(func, wait);
    };

    /**
     * Sets the `toString` method of `func` to return `string`.
     *
     * @private
     * @param {Function} func The function to modify.
     * @param {Function} string The `toString` result.
     * @returns {Function} Returns `func`.
     */
    var setToString = shortOut(baseSetToString);

    /**
     * Sets the `toString` method of `wrapper` to mimic the source of `reference`
     * with wrapper details in a comment at the top of the source body.
     *
     * @private
     * @param {Function} wrapper The function to modify.
     * @param {Function} reference The reference function.
     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
     * @returns {Function} Returns `wrapper`.
     */
    function setWrapToString(wrapper, reference, bitmask) {
      var source = (reference + '');
      return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask)));
    }

    /**
     * Creates a function that'll short out and invoke `identity` instead
     * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`
     * milliseconds.
     *
     * @private
     * @param {Function} func The function to restrict.
     * @returns {Function} Returns the new shortable function.
     */
    function shortOut(func) {
      var count = 0,
          lastCalled = 0;

      return function() {
        var stamp = nativeNow(),
            remaining = HOT_SPAN - (stamp - lastCalled);

        lastCalled = stamp;
        if (remaining > 0) {
          if (++count >= HOT_COUNT) {
            return arguments[0];
          }
        } else {
          count = 0;
        }
        return func.apply(undefined, arguments);
      };
    }

    /**
     * A specialized version of `_.shuffle` which mutates and sets the size of `array`.
     *
     * @private
     * @param {Array} array The array to shuffle.
     * @param {number} [size=array.length] The size of `array`.
     * @returns {Array} Returns `array`.
     */
    function shuffleSelf(array, size) {
      var index = -1,
          length = array.length,
          lastIndex = length - 1;

      size = size === undefined ? length : size;
      while (++index < size) {
        var rand = baseRandom(index, lastIndex),
            value = array[rand];

        array[rand] = array[index];
        array[index] = value;
      }
      array.length = size;
      return array;
    }

    /**
     * Converts `string` to a property path array.
     *
     * @private
     * @param {string} string The string to convert.
     * @returns {Array} Returns the property path array.
     */
    var stringToPath = memoizeCapped(function(string) {
      var result = [];
      if (reLeadingDot.test(string)) {
        result.push('');
      }
      string.replace(rePropName, function(match, number, quote, string) {
        result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match));
      });
      return result;
    });

    /**
     * Converts `value` to a string key if it's not a string or symbol.
     *
     * @private
     * @param {*} value The value to inspect.
     * @returns {string|symbol} Returns the key.
     */
    function toKey(value) {
      if (typeof value == 'string' || isSymbol(value)) {
        return value;
      }
      var result = (value + '');
      return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
    }

    /**
     * Converts `func` to its source code.
     *
     * @private
     * @param {Function} func The function to convert.
     * @returns {string} Returns the source code.
     */
    function toSource(func) {
      if (func != null) {
        try {
          return funcToString.call(func);
        } catch (e) {}
        try {
          return (func + '');
        } catch (e) {}
      }
      return '';
    }

    /**
     * Updates wrapper `details` based on `bitmask` flags.
     *
     * @private
     * @returns {Array} details The details to modify.
     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
     * @returns {Array} Returns `details`.
     */
    function updateWrapDetails(details, bitmask) {
      arrayEach(wrapFlags, function(pair) {
        var value = '_.' + pair[0];
        if ((bitmask & pair[1]) && !arrayIncludes(details, value)) {
          details.push(value);
        }
      });
      return details.sort();
    }

    /**
     * Creates a clone of `wrapper`.
     *
     * @private
     * @param {Object} wrapper The wrapper to clone.
     * @returns {Object} Returns the cloned wrapper.
     */
    function wrapperClone(wrapper) {
      if (wrapper instanceof LazyWrapper) {
        return wrapper.clone();
      }
      var result = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__);
      result.__actions__ = copyArray(wrapper.__actions__);
      result.__index__  = wrapper.__index__;
      result.__values__ = wrapper.__values__;
      return result;
    }

    /*------------------------------------------------------------------------*/

    /**
     * Creates an array of elements split into groups the length of `size`.
     * If `array` can't be split evenly, the final chunk will be the remaining
     * elements.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Array
     * @param {Array} array The array to process.
     * @param {number} [size=1] The length of each chunk
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {Array} Returns the new array of chunks.
     * @example
     *
     * _.chunk(['a', 'b', 'c', 'd'], 2);
     * // => [['a', 'b'], ['c', 'd']]
     *
     * _.chunk(['a', 'b', 'c', 'd'], 3);
     * // => [['a', 'b', 'c'], ['d']]
     */
    function chunk(array, size, guard) {
      if ((guard ? isIterateeCall(array, size, guard) : size === undefined)) {
        size = 1;
      } else {
        size = nativeMax(toInteger(size), 0);
      }
      var length = array == null ? 0 : array.length;
      if (!length || size < 1) {
        return [];
      }
      var index = 0,
          resIndex = 0,
          result = Array(nativeCeil(length / size));

      while (index < length) {
        result[resIndex++] = baseSlice(array, index, (index += size));
      }
      return result;
    }

    /**
     * Creates an array with all falsey values removed. The values `false`, `null`,
     * `0`, `""`, `undefined`, and `NaN` are falsey.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Array
     * @param {Array} array The array to compact.
     * @returns {Array} Returns the new array of filtered values.
     * @example
     *
     * _.compact([0, 1, false, 2, '', 3]);
     * // => [1, 2, 3]
     */
    function compact(array) {
      var index = -1,
          length = array == null ? 0 : array.length,
          resIndex = 0,
          result = [];

      while (++index < length) {
        var value = array[index];
        if (value) {
          result[resIndex++] = value;
        }
      }
      return result;
    }

    /**
     * Creates a new array concatenating `array` with any additional arrays
     * and/or values.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {Array} array The array to concatenate.
     * @param {...*} [values] The values to concatenate.
     * @returns {Array} Returns the new concatenated array.
     * @example
     *
     * var array = [1];
     * var other = _.concat(array, 2, [3], [[4]]);
     *
     * console.log(other);
     * // => [1, 2, 3, [4]]
     *
     * console.log(array);
     * // => [1]
     */
    function concat() {
      var length = arguments.length;
      if (!length) {
        return [];
      }
      var args = Array(length - 1),
          array = arguments[0],
          index = length;

      while (index--) {
        args[index - 1] = arguments[index];
      }
      return arrayPush(isArray(array) ? copyArray(array) : [array], baseFlatten(args, 1));
    }

    /**
     * Creates an array of `array` values not included in the other given arrays
     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
     * for equality comparisons. The order and references of result values are
     * determined by the first array.
     *
     * **Note:** Unlike `_.pullAll`, this method returns a new array.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Array
     * @param {Array} array The array to inspect.
     * @param {...Array} [values] The values to exclude.
     * @returns {Array} Returns the new array of filtered values.
     * @see _.without, _.xor
     * @example
     *
     * _.difference([2, 1], [2, 3]);
     * // => [1]
     */
    var difference = baseRest(function(array, values) {
      return isArrayLikeObject(array)
        ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true))
        : [];
    });

    /**
     * This method is like `_.difference` except that it accepts `iteratee` which
     * is invoked for each element of `array` and `values` to generate the criterion
     * by which they're compared. The order and references of result values are
     * determined by the first array. The iteratee is invoked with one argument:
     * (value).
     *
     * **Note:** Unlike `_.pullAllBy`, this method returns a new array.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {Array} array The array to inspect.
     * @param {...Array} [values] The values to exclude.
     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
     * @returns {Array} Returns the new array of filtered values.
     * @example
     *
     * _.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor);
     * // => [1.2]
     *
     * // The `_.property` iteratee shorthand.
     * _.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x');
     * // => [{ 'x': 2 }]
     */
    var differenceBy = baseRest(function(array, values) {
      var iteratee = last(values);
      if (isArrayLikeObject(iteratee)) {
        iteratee = undefined;
      }
      return isArrayLikeObject(array)
        ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), getIteratee(iteratee, 2))
        : [];
    });

    /**
     * This method is like `_.difference` except that it accepts `comparator`
     * which is invoked to compare elements of `array` to `values`. The order and
     * references of result values are determined by the first array. The comparator
     * is invoked with two arguments: (arrVal, othVal).
     *
     * **Note:** Unlike `_.pullAllWith`, this method returns a new array.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {Array} array The array to inspect.
     * @param {...Array} [values] The values to exclude.
     * @param {Function} [comparator] The comparator invoked per element.
     * @returns {Array} Returns the new array of filtered values.
     * @example
     *
     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
     *
     * _.differenceWith(objects, [{ 'x': 1, 'y': 2 }], _.isEqual);
     * // => [{ 'x': 2, 'y': 1 }]
     */
    var differenceWith = baseRest(function(array, values) {
      var comparator = last(values);
      if (isArrayLikeObject(comparator)) {
        comparator = undefined;
      }
      return isArrayLikeObject(array)
        ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), undefined, comparator)
        : [];
    });

    /**
     * Creates a slice of `array` with `n` elements dropped from the beginning.
     *
     * @static
     * @memberOf _
     * @since 0.5.0
     * @category Array
     * @param {Array} array The array to query.
     * @param {number} [n=1] The number of elements to drop.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {Array} Returns the slice of `array`.
     * @example
     *
     * _.drop([1, 2, 3]);
     * // => [2, 3]
     *
     * _.drop([1, 2, 3], 2);
     * // => [3]
     *
     * _.drop([1, 2, 3], 5);
     * // => []
     *
     * _.drop([1, 2, 3], 0);
     * // => [1, 2, 3]
     */
    function drop(array, n, guard) {
      var length = array == null ? 0 : array.length;
      if (!length) {
        return [];
      }
      n = (guard || n === undefined) ? 1 : toInteger(n);
      return baseSlice(array, n < 0 ? 0 : n, length);
    }

    /**
     * Creates a slice of `array` with `n` elements dropped from the end.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Array
     * @param {Array} array The array to query.
     * @param {number} [n=1] The number of elements to drop.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {Array} Returns the slice of `array`.
     * @example
     *
     * _.dropRight([1, 2, 3]);
     * // => [1, 2]
     *
     * _.dropRight([1, 2, 3], 2);
     * // => [1]
     *
     * _.dropRight([1, 2, 3], 5);
     * // => []
     *
     * _.dropRight([1, 2, 3], 0);
     * // => [1, 2, 3]
     */
    function dropRight(array, n, guard) {
      var length = array == null ? 0 : array.length;
      if (!length) {
        return [];
      }
      n = (guard || n === undefined) ? 1 : toInteger(n);
      n = length - n;
      return baseSlice(array, 0, n < 0 ? 0 : n);
    }

    /**
     * Creates a slice of `array` excluding elements dropped from the end.
     * Elements are dropped until `predicate` returns falsey. The predicate is
     * invoked with three arguments: (value, index, array).
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Array
     * @param {Array} array The array to query.
     * @param {Function} [predicate=_.identity] The function invoked per iteration.
     * @returns {Array} Returns the slice of `array`.
     * @example
     *
     * var users = [
     *   { 'user': 'barney',  'active': true },
     *   { 'user': 'fred',    'active': false },
     *   { 'user': 'pebbles', 'active': false }
     * ];
     *
     * _.dropRightWhile(users, function(o) { return !o.active; });
     * // => objects for ['barney']
     *
     * // The `_.matches` iteratee shorthand.
     * _.dropRightWhile(users, { 'user': 'pebbles', 'active': false });
     * // => objects for ['barney', 'fred']
     *
     * // The `_.matchesProperty` iteratee shorthand.
     * _.dropRightWhile(users, ['active', false]);
     * // => objects for ['barney']
     *
     * // The `_.property` iteratee shorthand.
     * _.dropRightWhile(users, 'active');
     * // => objects for ['barney', 'fred', 'pebbles']
     */
    function dropRightWhile(array, predicate) {
      return (array && array.length)
        ? baseWhile(array, getIteratee(predicate, 3), true, true)
        : [];
    }

    /**
     * Creates a slice of `array` excluding elements dropped from the beginning.
     * Elements are dropped until `predicate` returns falsey. The predicate is
     * invoked with three arguments: (value, index, array).
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Array
     * @param {Array} array The array to query.
     * @param {Function} [predicate=_.identity] The function invoked per iteration.
     * @returns {Array} Returns the slice of `array`.
     * @example
     *
     * var users = [
     *   { 'user': 'barney',  'active': false },
     *   { 'user': 'fred',    'active': false },
     *   { 'user': 'pebbles', 'active': true }
     * ];
     *
     * _.dropWhile(users, function(o) { return !o.active; });
     * // => objects for ['pebbles']
     *
     * // The `_.matches` iteratee shorthand.
     * _.dropWhile(users, { 'user': 'barney', 'active': false });
     * // => objects for ['fred', 'pebbles']
     *
     * // The `_.matchesProperty` iteratee shorthand.
     * _.dropWhile(users, ['active', false]);
     * // => objects for ['pebbles']
     *
     * // The `_.property` iteratee shorthand.
     * _.dropWhile(users, 'active');
     * // => objects for ['barney', 'fred', 'pebbles']
     */
    function dropWhile(array, predicate) {
      return (array && array.length)
        ? baseWhile(array, getIteratee(predicate, 3), true)
        : [];
    }

    /**
     * Fills elements of `array` with `value` from `start` up to, but not
     * including, `end`.
     *
     * **Note:** This method mutates `array`.
     *
     * @static
     * @memberOf _
     * @since 3.2.0
     * @category Array
     * @param {Array} array The array to fill.
     * @param {*} value The value to fill `array` with.
     * @param {number} [start=0] The start position.
     * @param {number} [end=array.length] The end position.
     * @returns {Array} Returns `array`.
     * @example
     *
     * var array = [1, 2, 3];
     *
     * _.fill(array, 'a');
     * console.log(array);
     * // => ['a', 'a', 'a']
     *
     * _.fill(Array(3), 2);
     * // => [2, 2, 2]
     *
     * _.fill([4, 6, 8, 10], '*', 1, 3);
     * // => [4, '*', '*', 10]
     */
    function fill(array, value, start, end) {
      var length = array == null ? 0 : array.length;
      if (!length) {
        return [];
      }
      if (start && typeof start != 'number' && isIterateeCall(array, value, start)) {
        start = 0;
        end = length;
      }
      return baseFill(array, value, start, end);
    }

    /**
     * This method is like `_.find` except that it returns the index of the first
     * element `predicate` returns truthy for instead of the element itself.
     *
     * @static
     * @memberOf _
     * @since 1.1.0
     * @category Array
     * @param {Array} array The array to inspect.
     * @param {Function} [predicate=_.identity] The function invoked per iteration.
     * @param {number} [fromIndex=0] The index to search from.
     * @returns {number} Returns the index of the found element, else `-1`.
     * @example
     *
     * var users = [
     *   { 'user': 'barney',  'active': false },
     *   { 'user': 'fred',    'active': false },
     *   { 'user': 'pebbles', 'active': true }
     * ];
     *
     * _.findIndex(users, function(o) { return o.user == 'barney'; });
     * // => 0
     *
     * // The `_.matches` iteratee shorthand.
     * _.findIndex(users, { 'user': 'fred', 'active': false });
     * // => 1
     *
     * // The `_.matchesProperty` iteratee shorthand.
     * _.findIndex(users, ['active', false]);
     * // => 0
     *
     * // The `_.property` iteratee shorthand.
     * _.findIndex(users, 'active');
     * // => 2
     */
    function findIndex(array, predicate, fromIndex) {
      var length = array == null ? 0 : array.length;
      if (!length) {
        return -1;
      }
      var index = fromIndex == null ? 0 : toInteger(fromIndex);
      if (index < 0) {
        index = nativeMax(length + index, 0);
      }
      return baseFindIndex(array, getIteratee(predicate, 3), index);
    }

    /**
     * This method is like `_.findIndex` except that it iterates over elements
     * of `collection` from right to left.
     *
     * @static
     * @memberOf _
     * @since 2.0.0
     * @category Array
     * @param {Array} array The array to inspect.
     * @param {Function} [predicate=_.identity] The function invoked per iteration.
     * @param {number} [fromIndex=array.length-1] The index to search from.
     * @returns {number} Returns the index of the found element, else `-1`.
     * @example
     *
     * var users = [
     *   { 'user': 'barney',  'active': true },
     *   { 'user': 'fred',    'active': false },
     *   { 'user': 'pebbles', 'active': false }
     * ];
     *
     * _.findLastIndex(users, function(o) { return o.user == 'pebbles'; });
     * // => 2
     *
     * // The `_.matches` iteratee shorthand.
     * _.findLastIndex(users, { 'user': 'barney', 'active': true });
     * // => 0
     *
     * // The `_.matchesProperty` iteratee shorthand.
     * _.findLastIndex(users, ['active', false]);
     * // => 2
     *
     * // The `_.property` iteratee shorthand.
     * _.findLastIndex(users, 'active');
     * // => 0
     */
    function findLastIndex(array, predicate, fromIndex) {
      var length = array == null ? 0 : array.length;
      if (!length) {
        return -1;
      }
      var index = length - 1;
      if (fromIndex !== undefined) {
        index = toInteger(fromIndex);
        index = fromIndex < 0
          ? nativeMax(length + index, 0)
          : nativeMin(index, length - 1);
      }
      return baseFindIndex(array, getIteratee(predicate, 3), index, true);
    }

    /**
     * Flattens `array` a single level deep.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Array
     * @param {Array} array The array to flatten.
     * @returns {Array} Returns the new flattened array.
     * @example
     *
     * _.flatten([1, [2, [3, [4]], 5]]);
     * // => [1, 2, [3, [4]], 5]
     */
    function flatten(array) {
      var length = array == null ? 0 : array.length;
      return length ? baseFlatten(array, 1) : [];
    }

    /**
     * Recursively flattens `array`.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Array
     * @param {Array} array The array to flatten.
     * @returns {Array} Returns the new flattened array.
     * @example
     *
     * _.flattenDeep([1, [2, [3, [4]], 5]]);
     * // => [1, 2, 3, 4, 5]
     */
    function flattenDeep(array) {
      var length = array == null ? 0 : array.length;
      return length ? baseFlatten(array, INFINITY) : [];
    }

    /**
     * Recursively flatten `array` up to `depth` times.
     *
     * @static
     * @memberOf _
     * @since 4.4.0
     * @category Array
     * @param {Array} array The array to flatten.
     * @param {number} [depth=1] The maximum recursion depth.
     * @returns {Array} Returns the new flattened array.
     * @example
     *
     * var array = [1, [2, [3, [4]], 5]];
     *
     * _.flattenDepth(array, 1);
     * // => [1, 2, [3, [4]], 5]
     *
     * _.flattenDepth(array, 2);
     * // => [1, 2, 3, [4], 5]
     */
    function flattenDepth(array, depth) {
      var length = array == null ? 0 : array.length;
      if (!length) {
        return [];
      }
      depth = depth === undefined ? 1 : toInteger(depth);
      return baseFlatten(array, depth);
    }

    /**
     * The inverse of `_.toPairs`; this method returns an object composed
     * from key-value `pairs`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {Array} pairs The key-value pairs.
     * @returns {Object} Returns the new object.
     * @example
     *
     * _.fromPairs([['a', 1], ['b', 2]]);
     * // => { 'a': 1, 'b': 2 }
     */
    function fromPairs(pairs) {
      var index = -1,
          length = pairs == null ? 0 : pairs.length,
          result = {};

      while (++index < length) {
        var pair = pairs[index];
        result[pair[0]] = pair[1];
      }
      return result;
    }

    /**
     * Gets the first element of `array`.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @alias first
     * @category Array
     * @param {Array} array The array to query.
     * @returns {*} Returns the first element of `array`.
     * @example
     *
     * _.head([1, 2, 3]);
     * // => 1
     *
     * _.head([]);
     * // => undefined
     */
    function head(array) {
      return (array && array.length) ? array[0] : undefined;
    }

    /**
     * Gets the index at which the first occurrence of `value` is found in `array`
     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
     * for equality comparisons. If `fromIndex` is negative, it's used as the
     * offset from the end of `array`.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Array
     * @param {Array} array The array to inspect.
     * @param {*} value The value to search for.
     * @param {number} [fromIndex=0] The index to search from.
     * @returns {number} Returns the index of the matched value, else `-1`.
     * @example
     *
     * _.indexOf([1, 2, 1, 2], 2);
     * // => 1
     *
     * // Search from the `fromIndex`.
     * _.indexOf([1, 2, 1, 2], 2, 2);
     * // => 3
     */
    function indexOf(array, value, fromIndex) {
      var length = array == null ? 0 : array.length;
      if (!length) {
        return -1;
      }
      var index = fromIndex == null ? 0 : toInteger(fromIndex);
      if (index < 0) {
        index = nativeMax(length + index, 0);
      }
      return baseIndexOf(array, value, index);
    }

    /**
     * Gets all but the last element of `array`.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Array
     * @param {Array} array The array to query.
     * @returns {Array} Returns the slice of `array`.
     * @example
     *
     * _.initial([1, 2, 3]);
     * // => [1, 2]
     */
    function initial(array) {
      var length = array == null ? 0 : array.length;
      return length ? baseSlice(array, 0, -1) : [];
    }

    /**
     * Creates an array of unique values that are included in all given arrays
     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
     * for equality comparisons. The order and references of result values are
     * determined by the first array.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Array
     * @param {...Array} [arrays] The arrays to inspect.
     * @returns {Array} Returns the new array of intersecting values.
     * @example
     *
     * _.intersection([2, 1], [2, 3]);
     * // => [2]
     */
    var intersection = baseRest(function(arrays) {
      var mapped = arrayMap(arrays, castArrayLikeObject);
      return (mapped.length && mapped[0] === arrays[0])
        ? baseIntersection(mapped)
        : [];
    });

    /**
     * This method is like `_.intersection` except that it accepts `iteratee`
     * which is invoked for each element of each `arrays` to generate the criterion
     * by which they're compared. The order and references of result values are
     * determined by the first array. The iteratee is invoked with one argument:
     * (value).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {...Array} [arrays] The arrays to inspect.
     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
     * @returns {Array} Returns the new array of intersecting values.
     * @example
     *
     * _.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor);
     * // => [2.1]
     *
     * // The `_.property` iteratee shorthand.
     * _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
     * // => [{ 'x': 1 }]
     */
    var intersectionBy = baseRest(function(arrays) {
      var iteratee = last(arrays),
          mapped = arrayMap(arrays, castArrayLikeObject);

      if (iteratee === last(mapped)) {
        iteratee = undefined;
      } else {
        mapped.pop();
      }
      return (mapped.length && mapped[0] === arrays[0])
        ? baseIntersection(mapped, getIteratee(iteratee, 2))
        : [];
    });

    /**
     * This method is like `_.intersection` except that it accepts `comparator`
     * which is invoked to compare elements of `arrays`. The order and references
     * of result values are determined by the first array. The comparator is
     * invoked with two arguments: (arrVal, othVal).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {...Array} [arrays] The arrays to inspect.
     * @param {Function} [comparator] The comparator invoked per element.
     * @returns {Array} Returns the new array of intersecting values.
     * @example
     *
     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
     * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
     *
     * _.intersectionWith(objects, others, _.isEqual);
     * // => [{ 'x': 1, 'y': 2 }]
     */
    var intersectionWith = baseRest(function(arrays) {
      var comparator = last(arrays),
          mapped = arrayMap(arrays, castArrayLikeObject);

      comparator = typeof comparator == 'function' ? comparator : undefined;
      if (comparator) {
        mapped.pop();
      }
      return (mapped.length && mapped[0] === arrays[0])
        ? baseIntersection(mapped, undefined, comparator)
        : [];
    });

    /**
     * Converts all elements in `array` into a string separated by `separator`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {Array} array The array to convert.
     * @param {string} [separator=','] The element separator.
     * @returns {string} Returns the joined string.
     * @example
     *
     * _.join(['a', 'b', 'c'], '~');
     * // => 'a~b~c'
     */
    function join(array, separator) {
      return array == null ? '' : nativeJoin.call(array, separator);
    }

    /**
     * Gets the last element of `array`.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Array
     * @param {Array} array The array to query.
     * @returns {*} Returns the last element of `array`.
     * @example
     *
     * _.last([1, 2, 3]);
     * // => 3
     */
    function last(array) {
      var length = array == null ? 0 : array.length;
      return length ? array[length - 1] : undefined;
    }

    /**
     * This method is like `_.indexOf` except that it iterates over elements of
     * `array` from right to left.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Array
     * @param {Array} array The array to inspect.
     * @param {*} value The value to search for.
     * @param {number} [fromIndex=array.length-1] The index to search from.
     * @returns {number} Returns the index of the matched value, else `-1`.
     * @example
     *
     * _.lastIndexOf([1, 2, 1, 2], 2);
     * // => 3
     *
     * // Search from the `fromIndex`.
     * _.lastIndexOf([1, 2, 1, 2], 2, 2);
     * // => 1
     */
    function lastIndexOf(array, value, fromIndex) {
      var length = array == null ? 0 : array.length;
      if (!length) {
        return -1;
      }
      var index = length;
      if (fromIndex !== undefined) {
        index = toInteger(fromIndex);
        index = index < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1);
      }
      return value === value
        ? strictLastIndexOf(array, value, index)
        : baseFindIndex(array, baseIsNaN, index, true);
    }

    /**
     * Gets the element at index `n` of `array`. If `n` is negative, the nth
     * element from the end is returned.
     *
     * @static
     * @memberOf _
     * @since 4.11.0
     * @category Array
     * @param {Array} array The array to query.
     * @param {number} [n=0] The index of the element to return.
     * @returns {*} Returns the nth element of `array`.
     * @example
     *
     * var array = ['a', 'b', 'c', 'd'];
     *
     * _.nth(array, 1);
     * // => 'b'
     *
     * _.nth(array, -2);
     * // => 'c';
     */
    function nth(array, n) {
      return (array && array.length) ? baseNth(array, toInteger(n)) : undefined;
    }

    /**
     * Removes all given values from `array` using
     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
     * for equality comparisons.
     *
     * **Note:** Unlike `_.without`, this method mutates `array`. Use `_.remove`
     * to remove elements from an array by predicate.
     *
     * @static
     * @memberOf _
     * @since 2.0.0
     * @category Array
     * @param {Array} array The array to modify.
     * @param {...*} [values] The values to remove.
     * @returns {Array} Returns `array`.
     * @example
     *
     * var array = ['a', 'b', 'c', 'a', 'b', 'c'];
     *
     * _.pull(array, 'a', 'c');
     * console.log(array);
     * // => ['b', 'b']
     */
    var pull = baseRest(pullAll);

    /**
     * This method is like `_.pull` except that it accepts an array of values to remove.
     *
     * **Note:** Unlike `_.difference`, this method mutates `array`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {Array} array The array to modify.
     * @param {Array} values The values to remove.
     * @returns {Array} Returns `array`.
     * @example
     *
     * var array = ['a', 'b', 'c', 'a', 'b', 'c'];
     *
     * _.pullAll(array, ['a', 'c']);
     * console.log(array);
     * // => ['b', 'b']
     */
    function pullAll(array, values) {
      return (array && array.length && values && values.length)
        ? basePullAll(array, values)
        : array;
    }

    /**
     * This method is like `_.pullAll` except that it accepts `iteratee` which is
     * invoked for each element of `array` and `values` to generate the criterion
     * by which they're compared. The iteratee is invoked with one argument: (value).
     *
     * **Note:** Unlike `_.differenceBy`, this method mutates `array`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {Array} array The array to modify.
     * @param {Array} values The values to remove.
     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
     * @returns {Array} Returns `array`.
     * @example
     *
     * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];
     *
     * _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');
     * console.log(array);
     * // => [{ 'x': 2 }]
     */
    function pullAllBy(array, values, iteratee) {
      return (array && array.length && values && values.length)
        ? basePullAll(array, values, getIteratee(iteratee, 2))
        : array;
    }

    /**
     * This method is like `_.pullAll` except that it accepts `comparator` which
     * is invoked to compare elements of `array` to `values`. The comparator is
     * invoked with two arguments: (arrVal, othVal).
     *
     * **Note:** Unlike `_.differenceWith`, this method mutates `array`.
     *
     * @static
     * @memberOf _
     * @since 4.6.0
     * @category Array
     * @param {Array} array The array to modify.
     * @param {Array} values The values to remove.
     * @param {Function} [comparator] The comparator invoked per element.
     * @returns {Array} Returns `array`.
     * @example
     *
     * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }];
     *
     * _.pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual);
     * console.log(array);
     * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }]
     */
    function pullAllWith(array, values, comparator) {
      return (array && array.length && values && values.length)
        ? basePullAll(array, values, undefined, comparator)
        : array;
    }

    /**
     * Removes elements from `array` corresponding to `indexes` and returns an
     * array of removed elements.
     *
     * **Note:** Unlike `_.at`, this method mutates `array`.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Array
     * @param {Array} array The array to modify.
     * @param {...(number|number[])} [indexes] The indexes of elements to remove.
     * @returns {Array} Returns the new array of removed elements.
     * @example
     *
     * var array = ['a', 'b', 'c', 'd'];
     * var pulled = _.pullAt(array, [1, 3]);
     *
     * console.log(array);
     * // => ['a', 'c']
     *
     * console.log(pulled);
     * // => ['b', 'd']
     */
    var pullAt = flatRest(function(array, indexes) {
      var length = array == null ? 0 : array.length,
          result = baseAt(array, indexes);

      basePullAt(array, arrayMap(indexes, function(index) {
        return isIndex(index, length) ? +index : index;
      }).sort(compareAscending));

      return result;
    });

    /**
     * Removes all elements from `array` that `predicate` returns truthy for
     * and returns an array of the removed elements. The predicate is invoked
     * with three arguments: (value, index, array).
     *
     * **Note:** Unlike `_.filter`, this method mutates `array`. Use `_.pull`
     * to pull elements from an array by value.
     *
     * @static
     * @memberOf _
     * @since 2.0.0
     * @category Array
     * @param {Array} array The array to modify.
     * @param {Function} [predicate=_.identity] The function invoked per iteration.
     * @returns {Array} Returns the new array of removed elements.
     * @example
     *
     * var array = [1, 2, 3, 4];
     * var evens = _.remove(array, function(n) {
     *   return n % 2 == 0;
     * });
     *
     * console.log(array);
     * // => [1, 3]
     *
     * console.log(evens);
     * // => [2, 4]
     */
    function remove(array, predicate) {
      var result = [];
      if (!(array && array.length)) {
        return result;
      }
      var index = -1,
          indexes = [],
          length = array.length;

      predicate = getIteratee(predicate, 3);
      while (++index < length) {
        var value = array[index];
        if (predicate(value, index, array)) {
          result.push(value);
          indexes.push(index);
        }
      }
      basePullAt(array, indexes);
      return result;
    }

    /**
     * Reverses `array` so that the first element becomes the last, the second
     * element becomes the second to last, and so on.
     *
     * **Note:** This method mutates `array` and is based on
     * [`Array#reverse`](https://mdn.io/Array/reverse).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {Array} array The array to modify.
     * @returns {Array} Returns `array`.
     * @example
     *
     * var array = [1, 2, 3];
     *
     * _.reverse(array);
     * // => [3, 2, 1]
     *
     * console.log(array);
     * // => [3, 2, 1]
     */
    function reverse(array) {
      return array == null ? array : nativeReverse.call(array);
    }

    /**
     * Creates a slice of `array` from `start` up to, but not including, `end`.
     *
     * **Note:** This method is used instead of
     * [`Array#slice`](https://mdn.io/Array/slice) to ensure dense arrays are
     * returned.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Array
     * @param {Array} array The array to slice.
     * @param {number} [start=0] The start position.
     * @param {number} [end=array.length] The end position.
     * @returns {Array} Returns the slice of `array`.
     */
    function slice(array, start, end) {
      var length = array == null ? 0 : array.length;
      if (!length) {
        return [];
      }
      if (end && typeof end != 'number' && isIterateeCall(array, start, end)) {
        start = 0;
        end = length;
      }
      else {
        start = start == null ? 0 : toInteger(start);
        end = end === undefined ? length : toInteger(end);
      }
      return baseSlice(array, start, end);
    }

    /**
     * Uses a binary search to determine the lowest index at which `value`
     * should be inserted into `array` in order to maintain its sort order.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Array
     * @param {Array} array The sorted array to inspect.
     * @param {*} value The value to evaluate.
     * @returns {number} Returns the index at which `value` should be inserted
     *  into `array`.
     * @example
     *
     * _.sortedIndex([30, 50], 40);
     * // => 1
     */
    function sortedIndex(array, value) {
      return baseSortedIndex(array, value);
    }

    /**
     * This method is like `_.sortedIndex` except that it accepts `iteratee`
     * which is invoked for `value` and each element of `array` to compute their
     * sort ranking. The iteratee is invoked with one argument: (value).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {Array} array The sorted array to inspect.
     * @param {*} value The value to evaluate.
     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
     * @returns {number} Returns the index at which `value` should be inserted
     *  into `array`.
     * @example
     *
     * var objects = [{ 'x': 4 }, { 'x': 5 }];
     *
     * _.sortedIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });
     * // => 0
     *
     * // The `_.property` iteratee shorthand.
     * _.sortedIndexBy(objects, { 'x': 4 }, 'x');
     * // => 0
     */
    function sortedIndexBy(array, value, iteratee) {
      return baseSortedIndexBy(array, value, getIteratee(iteratee, 2));
    }

    /**
     * This method is like `_.indexOf` except that it performs a binary
     * search on a sorted `array`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {Array} array The array to inspect.
     * @param {*} value The value to search for.
     * @returns {number} Returns the index of the matched value, else `-1`.
     * @example
     *
     * _.sortedIndexOf([4, 5, 5, 5, 6], 5);
     * // => 1
     */
    function sortedIndexOf(array, value) {
      var length = array == null ? 0 : array.length;
      if (length) {
        var index = baseSortedIndex(array, value);
        if (index < length && eq(array[index], value)) {
          return index;
        }
      }
      return -1;
    }

    /**
     * This method is like `_.sortedIndex` except that it returns the highest
     * index at which `value` should be inserted into `array` in order to
     * maintain its sort order.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Array
     * @param {Array} array The sorted array to inspect.
     * @param {*} value The value to evaluate.
     * @returns {number} Returns the index at which `value` should be inserted
     *  into `array`.
     * @example
     *
     * _.sortedLastIndex([4, 5, 5, 5, 6], 5);
     * // => 4
     */
    function sortedLastIndex(array, value) {
      return baseSortedIndex(array, value, true);
    }

    /**
     * This method is like `_.sortedLastIndex` except that it accepts `iteratee`
     * which is invoked for `value` and each element of `array` to compute their
     * sort ranking. The iteratee is invoked with one argument: (value).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {Array} array The sorted array to inspect.
     * @param {*} value The value to evaluate.
     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
     * @returns {number} Returns the index at which `value` should be inserted
     *  into `array`.
     * @example
     *
     * var objects = [{ 'x': 4 }, { 'x': 5 }];
     *
     * _.sortedLastIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });
     * // => 1
     *
     * // The `_.property` iteratee shorthand.
     * _.sortedLastIndexBy(objects, { 'x': 4 }, 'x');
     * // => 1
     */
    function sortedLastIndexBy(array, value, iteratee) {
      return baseSortedIndexBy(array, value, getIteratee(iteratee, 2), true);
    }

    /**
     * This method is like `_.lastIndexOf` except that it performs a binary
     * search on a sorted `array`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {Array} array The array to inspect.
     * @param {*} value The value to search for.
     * @returns {number} Returns the index of the matched value, else `-1`.
     * @example
     *
     * _.sortedLastIndexOf([4, 5, 5, 5, 6], 5);
     * // => 3
     */
    function sortedLastIndexOf(array, value) {
      var length = array == null ? 0 : array.length;
      if (length) {
        var index = baseSortedIndex(array, value, true) - 1;
        if (eq(array[index], value)) {
          return index;
        }
      }
      return -1;
    }

    /**
     * This method is like `_.uniq` except that it's designed and optimized
     * for sorted arrays.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {Array} array The array to inspect.
     * @returns {Array} Returns the new duplicate free array.
     * @example
     *
     * _.sortedUniq([1, 1, 2]);
     * // => [1, 2]
     */
    function sortedUniq(array) {
      return (array && array.length)
        ? baseSortedUniq(array)
        : [];
    }

    /**
     * This method is like `_.uniqBy` except that it's designed and optimized
     * for sorted arrays.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {Array} array The array to inspect.
     * @param {Function} [iteratee] The iteratee invoked per element.
     * @returns {Array} Returns the new duplicate free array.
     * @example
     *
     * _.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor);
     * // => [1.1, 2.3]
     */
    function sortedUniqBy(array, iteratee) {
      return (array && array.length)
        ? baseSortedUniq(array, getIteratee(iteratee, 2))
        : [];
    }

    /**
     * Gets all but the first element of `array`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {Array} array The array to query.
     * @returns {Array} Returns the slice of `array`.
     * @example
     *
     * _.tail([1, 2, 3]);
     * // => [2, 3]
     */
    function tail(array) {
      var length = array == null ? 0 : array.length;
      return length ? baseSlice(array, 1, length) : [];
    }

    /**
     * Creates a slice of `array` with `n` elements taken from the beginning.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Array
     * @param {Array} array The array to query.
     * @param {number} [n=1] The number of elements to take.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {Array} Returns the slice of `array`.
     * @example
     *
     * _.take([1, 2, 3]);
     * // => [1]
     *
     * _.take([1, 2, 3], 2);
     * // => [1, 2]
     *
     * _.take([1, 2, 3], 5);
     * // => [1, 2, 3]
     *
     * _.take([1, 2, 3], 0);
     * // => []
     */
    function take(array, n, guard) {
      if (!(array && array.length)) {
        return [];
      }
      n = (guard || n === undefined) ? 1 : toInteger(n);
      return baseSlice(array, 0, n < 0 ? 0 : n);
    }

    /**
     * Creates a slice of `array` with `n` elements taken from the end.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Array
     * @param {Array} array The array to query.
     * @param {number} [n=1] The number of elements to take.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {Array} Returns the slice of `array`.
     * @example
     *
     * _.takeRight([1, 2, 3]);
     * // => [3]
     *
     * _.takeRight([1, 2, 3], 2);
     * // => [2, 3]
     *
     * _.takeRight([1, 2, 3], 5);
     * // => [1, 2, 3]
     *
     * _.takeRight([1, 2, 3], 0);
     * // => []
     */
    function takeRight(array, n, guard) {
      var length = array == null ? 0 : array.length;
      if (!length) {
        return [];
      }
      n = (guard || n === undefined) ? 1 : toInteger(n);
      n = length - n;
      return baseSlice(array, n < 0 ? 0 : n, length);
    }

    /**
     * Creates a slice of `array` with elements taken from the end. Elements are
     * taken until `predicate` returns falsey. The predicate is invoked with
     * three arguments: (value, index, array).
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Array
     * @param {Array} array The array to query.
     * @param {Function} [predicate=_.identity] The function invoked per iteration.
     * @returns {Array} Returns the slice of `array`.
     * @example
     *
     * var users = [
     *   { 'user': 'barney',  'active': true },
     *   { 'user': 'fred',    'active': false },
     *   { 'user': 'pebbles', 'active': false }
     * ];
     *
     * _.takeRightWhile(users, function(o) { return !o.active; });
     * // => objects for ['fred', 'pebbles']
     *
     * // The `_.matches` iteratee shorthand.
     * _.takeRightWhile(users, { 'user': 'pebbles', 'active': false });
     * // => objects for ['pebbles']
     *
     * // The `_.matchesProperty` iteratee shorthand.
     * _.takeRightWhile(users, ['active', false]);
     * // => objects for ['fred', 'pebbles']
     *
     * // The `_.property` iteratee shorthand.
     * _.takeRightWhile(users, 'active');
     * // => []
     */
    function takeRightWhile(array, predicate) {
      return (array && array.length)
        ? baseWhile(array, getIteratee(predicate, 3), false, true)
        : [];
    }

    /**
     * Creates a slice of `array` with elements taken from the beginning. Elements
     * are taken until `predicate` returns falsey. The predicate is invoked with
     * three arguments: (value, index, array).
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Array
     * @param {Array} array The array to query.
     * @param {Function} [predicate=_.identity] The function invoked per iteration.
     * @returns {Array} Returns the slice of `array`.
     * @example
     *
     * var users = [
     *   { 'user': 'barney',  'active': false },
     *   { 'user': 'fred',    'active': false },
     *   { 'user': 'pebbles', 'active': true }
     * ];
     *
     * _.takeWhile(users, function(o) { return !o.active; });
     * // => objects for ['barney', 'fred']
     *
     * // The `_.matches` iteratee shorthand.
     * _.takeWhile(users, { 'user': 'barney', 'active': false });
     * // => objects for ['barney']
     *
     * // The `_.matchesProperty` iteratee shorthand.
     * _.takeWhile(users, ['active', false]);
     * // => objects for ['barney', 'fred']
     *
     * // The `_.property` iteratee shorthand.
     * _.takeWhile(users, 'active');
     * // => []
     */
    function takeWhile(array, predicate) {
      return (array && array.length)
        ? baseWhile(array, getIteratee(predicate, 3))
        : [];
    }

    /**
     * Creates an array of unique values, in order, from all given arrays using
     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
     * for equality comparisons.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Array
     * @param {...Array} [arrays] The arrays to inspect.
     * @returns {Array} Returns the new array of combined values.
     * @example
     *
     * _.union([2], [1, 2]);
     * // => [2, 1]
     */
    var union = baseRest(function(arrays) {
      return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true));
    });

    /**
     * This method is like `_.union` except that it accepts `iteratee` which is
     * invoked for each element of each `arrays` to generate the criterion by
     * which uniqueness is computed. Result values are chosen from the first
     * array in which the value occurs. The iteratee is invoked with one argument:
     * (value).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {...Array} [arrays] The arrays to inspect.
     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
     * @returns {Array} Returns the new array of combined values.
     * @example
     *
     * _.unionBy([2.1], [1.2, 2.3], Math.floor);
     * // => [2.1, 1.2]
     *
     * // The `_.property` iteratee shorthand.
     * _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
     * // => [{ 'x': 1 }, { 'x': 2 }]
     */
    var unionBy = baseRest(function(arrays) {
      var iteratee = last(arrays);
      if (isArrayLikeObject(iteratee)) {
        iteratee = undefined;
      }
      return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), getIteratee(iteratee, 2));
    });

    /**
     * This method is like `_.union` except that it accepts `comparator` which
     * is invoked to compare elements of `arrays`. Result values are chosen from
     * the first array in which the value occurs. The comparator is invoked
     * with two arguments: (arrVal, othVal).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {...Array} [arrays] The arrays to inspect.
     * @param {Function} [comparator] The comparator invoked per element.
     * @returns {Array} Returns the new array of combined values.
     * @example
     *
     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
     * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
     *
     * _.unionWith(objects, others, _.isEqual);
     * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]
     */
    var unionWith = baseRest(function(arrays) {
      var comparator = last(arrays);
      comparator = typeof comparator == 'function' ? comparator : undefined;
      return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), undefined, comparator);
    });

    /**
     * Creates a duplicate-free version of an array, using
     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
     * for equality comparisons, in which only the first occurrence of each element
     * is kept. The order of result values is determined by the order they occur
     * in the array.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Array
     * @param {Array} array The array to inspect.
     * @returns {Array} Returns the new duplicate free array.
     * @example
     *
     * _.uniq([2, 1, 2]);
     * // => [2, 1]
     */
    function uniq(array) {
      return (array && array.length) ? baseUniq(array) : [];
    }

    /**
     * This method is like `_.uniq` except that it accepts `iteratee` which is
     * invoked for each element in `array` to generate the criterion by which
     * uniqueness is computed. The order of result values is determined by the
     * order they occur in the array. The iteratee is invoked with one argument:
     * (value).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {Array} array The array to inspect.
     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
     * @returns {Array} Returns the new duplicate free array.
     * @example
     *
     * _.uniqBy([2.1, 1.2, 2.3], Math.floor);
     * // => [2.1, 1.2]
     *
     * // The `_.property` iteratee shorthand.
     * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
     * // => [{ 'x': 1 }, { 'x': 2 }]
     */
    function uniqBy(array, iteratee) {
      return (array && array.length) ? baseUniq(array, getIteratee(iteratee, 2)) : [];
    }

    /**
     * This method is like `_.uniq` except that it accepts `comparator` which
     * is invoked to compare elements of `array`. The order of result values is
     * determined by the order they occur in the array.The comparator is invoked
     * with two arguments: (arrVal, othVal).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {Array} array The array to inspect.
     * @param {Function} [comparator] The comparator invoked per element.
     * @returns {Array} Returns the new duplicate free array.
     * @example
     *
     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];
     *
     * _.uniqWith(objects, _.isEqual);
     * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]
     */
    function uniqWith(array, comparator) {
      comparator = typeof comparator == 'function' ? comparator : undefined;
      return (array && array.length) ? baseUniq(array, undefined, comparator) : [];
    }

    /**
     * This method is like `_.zip` except that it accepts an array of grouped
     * elements and creates an array regrouping the elements to their pre-zip
     * configuration.
     *
     * @static
     * @memberOf _
     * @since 1.2.0
     * @category Array
     * @param {Array} array The array of grouped elements to process.
     * @returns {Array} Returns the new array of regrouped elements.
     * @example
     *
     * var zipped = _.zip(['a', 'b'], [1, 2], [true, false]);
     * // => [['a', 1, true], ['b', 2, false]]
     *
     * _.unzip(zipped);
     * // => [['a', 'b'], [1, 2], [true, false]]
     */
    function unzip(array) {
      if (!(array && array.length)) {
        return [];
      }
      var length = 0;
      array = arrayFilter(array, function(group) {
        if (isArrayLikeObject(group)) {
          length = nativeMax(group.length, length);
          return true;
        }
      });
      return baseTimes(length, function(index) {
        return arrayMap(array, baseProperty(index));
      });
    }

    /**
     * This method is like `_.unzip` except that it accepts `iteratee` to specify
     * how regrouped values should be combined. The iteratee is invoked with the
     * elements of each group: (...group).
     *
     * @static
     * @memberOf _
     * @since 3.8.0
     * @category Array
     * @param {Array} array The array of grouped elements to process.
     * @param {Function} [iteratee=_.identity] The function to combine
     *  regrouped values.
     * @returns {Array} Returns the new array of regrouped elements.
     * @example
     *
     * var zipped = _.zip([1, 2], [10, 20], [100, 200]);
     * // => [[1, 10, 100], [2, 20, 200]]
     *
     * _.unzipWith(zipped, _.add);
     * // => [3, 30, 300]
     */
    function unzipWith(array, iteratee) {
      if (!(array && array.length)) {
        return [];
      }
      var result = unzip(array);
      if (iteratee == null) {
        return result;
      }
      return arrayMap(result, function(group) {
        return apply(iteratee, undefined, group);
      });
    }

    /**
     * Creates an array excluding all given values using
     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
     * for equality comparisons.
     *
     * **Note:** Unlike `_.pull`, this method returns a new array.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Array
     * @param {Array} array The array to inspect.
     * @param {...*} [values] The values to exclude.
     * @returns {Array} Returns the new array of filtered values.
     * @see _.difference, _.xor
     * @example
     *
     * _.without([2, 1, 2, 3], 1, 2);
     * // => [3]
     */
    var without = baseRest(function(array, values) {
      return isArrayLikeObject(array)
        ? baseDifference(array, values)
        : [];
    });

    /**
     * Creates an array of unique values that is the
     * [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference)
     * of the given arrays. The order of result values is determined by the order
     * they occur in the arrays.
     *
     * @static
     * @memberOf _
     * @since 2.4.0
     * @category Array
     * @param {...Array} [arrays] The arrays to inspect.
     * @returns {Array} Returns the new array of filtered values.
     * @see _.difference, _.without
     * @example
     *
     * _.xor([2, 1], [2, 3]);
     * // => [1, 3]
     */
    var xor = baseRest(function(arrays) {
      return baseXor(arrayFilter(arrays, isArrayLikeObject));
    });

    /**
     * This method is like `_.xor` except that it accepts `iteratee` which is
     * invoked for each element of each `arrays` to generate the criterion by
     * which by which they're compared. The order of result values is determined
     * by the order they occur in the arrays. The iteratee is invoked with one
     * argument: (value).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {...Array} [arrays] The arrays to inspect.
     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
     * @returns {Array} Returns the new array of filtered values.
     * @example
     *
     * _.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor);
     * // => [1.2, 3.4]
     *
     * // The `_.property` iteratee shorthand.
     * _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
     * // => [{ 'x': 2 }]
     */
    var xorBy = baseRest(function(arrays) {
      var iteratee = last(arrays);
      if (isArrayLikeObject(iteratee)) {
        iteratee = undefined;
      }
      return baseXor(arrayFilter(arrays, isArrayLikeObject), getIteratee(iteratee, 2));
    });

    /**
     * This method is like `_.xor` except that it accepts `comparator` which is
     * invoked to compare elements of `arrays`. The order of result values is
     * determined by the order they occur in the arrays. The comparator is invoked
     * with two arguments: (arrVal, othVal).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {...Array} [arrays] The arrays to inspect.
     * @param {Function} [comparator] The comparator invoked per element.
     * @returns {Array} Returns the new array of filtered values.
     * @example
     *
     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
     * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
     *
     * _.xorWith(objects, others, _.isEqual);
     * // => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]
     */
    var xorWith = baseRest(function(arrays) {
      var comparator = last(arrays);
      comparator = typeof comparator == 'function' ? comparator : undefined;
      return baseXor(arrayFilter(arrays, isArrayLikeObject), undefined, comparator);
    });

    /**
     * Creates an array of grouped elements, the first of which contains the
     * first elements of the given arrays, the second of which contains the
     * second elements of the given arrays, and so on.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Array
     * @param {...Array} [arrays] The arrays to process.
     * @returns {Array} Returns the new array of grouped elements.
     * @example
     *
     * _.zip(['a', 'b'], [1, 2], [true, false]);
     * // => [['a', 1, true], ['b', 2, false]]
     */
    var zip = baseRest(unzip);

    /**
     * This method is like `_.fromPairs` except that it accepts two arrays,
     * one of property identifiers and one of corresponding values.
     *
     * @static
     * @memberOf _
     * @since 0.4.0
     * @category Array
     * @param {Array} [props=[]] The property identifiers.
     * @param {Array} [values=[]] The property values.
     * @returns {Object} Returns the new object.
     * @example
     *
     * _.zipObject(['a', 'b'], [1, 2]);
     * // => { 'a': 1, 'b': 2 }
     */
    function zipObject(props, values) {
      return baseZipObject(props || [], values || [], assignValue);
    }

    /**
     * This method is like `_.zipObject` except that it supports property paths.
     *
     * @static
     * @memberOf _
     * @since 4.1.0
     * @category Array
     * @param {Array} [props=[]] The property identifiers.
     * @param {Array} [values=[]] The property values.
     * @returns {Object} Returns the new object.
     * @example
     *
     * _.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]);
     * // => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } }
     */
    function zipObjectDeep(props, values) {
      return baseZipObject(props || [], values || [], baseSet);
    }

    /**
     * This method is like `_.zip` except that it accepts `iteratee` to specify
     * how grouped values should be combined. The iteratee is invoked with the
     * elements of each group: (...group).
     *
     * @static
     * @memberOf _
     * @since 3.8.0
     * @category Array
     * @param {...Array} [arrays] The arrays to process.
     * @param {Function} [iteratee=_.identity] The function to combine
     *  grouped values.
     * @returns {Array} Returns the new array of grouped elements.
     * @example
     *
     * _.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) {
     *   return a + b + c;
     * });
     * // => [111, 222]
     */
    var zipWith = baseRest(function(arrays) {
      var length = arrays.length,
          iteratee = length > 1 ? arrays[length - 1] : undefined;

      iteratee = typeof iteratee == 'function' ? (arrays.pop(), iteratee) : undefined;
      return unzipWith(arrays, iteratee);
    });

    /*------------------------------------------------------------------------*/

    /**
     * Creates a `lodash` wrapper instance that wraps `value` with explicit method
     * chain sequences enabled. The result of such sequences must be unwrapped
     * with `_#value`.
     *
     * @static
     * @memberOf _
     * @since 1.3.0
     * @category Seq
     * @param {*} value The value to wrap.
     * @returns {Object} Returns the new `lodash` wrapper instance.
     * @example
     *
     * var users = [
     *   { 'user': 'barney',  'age': 36 },
     *   { 'user': 'fred',    'age': 40 },
     *   { 'user': 'pebbles', 'age': 1 }
     * ];
     *
     * var youngest = _
     *   .chain(users)
     *   .sortBy('age')
     *   .map(function(o) {
     *     return o.user + ' is ' + o.age;
     *   })
     *   .head()
     *   .value();
     * // => 'pebbles is 1'
     */
    function chain(value) {
      var result = lodash(value);
      result.__chain__ = true;
      return result;
    }

    /**
     * This method invokes `interceptor` and returns `value`. The interceptor
     * is invoked with one argument; (value). The purpose of this method is to
     * "tap into" a method chain sequence in order to modify intermediate results.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Seq
     * @param {*} value The value to provide to `interceptor`.
     * @param {Function} interceptor The function to invoke.
     * @returns {*} Returns `value`.
     * @example
     *
     * _([1, 2, 3])
     *  .tap(function(array) {
     *    // Mutate input array.
     *    array.pop();
     *  })
     *  .reverse()
     *  .value();
     * // => [2, 1]
     */
    function tap(value, interceptor) {
      interceptor(value);
      return value;
    }

    /**
     * This method is like `_.tap` except that it returns the result of `interceptor`.
     * The purpose of this method is to "pass thru" values replacing intermediate
     * results in a method chain sequence.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Seq
     * @param {*} value The value to provide to `interceptor`.
     * @param {Function} interceptor The function to invoke.
     * @returns {*} Returns the result of `interceptor`.
     * @example
     *
     * _('  abc  ')
     *  .chain()
     *  .trim()
     *  .thru(function(value) {
     *    return [value];
     *  })
     *  .value();
     * // => ['abc']
     */
    function thru(value, interceptor) {
      return interceptor(value);
    }

    /**
     * This method is the wrapper version of `_.at`.
     *
     * @name at
     * @memberOf _
     * @since 1.0.0
     * @category Seq
     * @param {...(string|string[])} [paths] The property paths to pick.
     * @returns {Object} Returns the new `lodash` wrapper instance.
     * @example
     *
     * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };
     *
     * _(object).at(['a[0].b.c', 'a[1]']).value();
     * // => [3, 4]
     */
    var wrapperAt = flatRest(function(paths) {
      var length = paths.length,
          start = length ? paths[0] : 0,
          value = this.__wrapped__,
          interceptor = function(object) { return baseAt(object, paths); };

      if (length > 1 || this.__actions__.length ||
          !(value instanceof LazyWrapper) || !isIndex(start)) {
        return this.thru(interceptor);
      }
      value = value.slice(start, +start + (length ? 1 : 0));
      value.__actions__.push({
        'func': thru,
        'args': [interceptor],
        'thisArg': undefined
      });
      return new LodashWrapper(value, this.__chain__).thru(function(array) {
        if (length && !array.length) {
          array.push(undefined);
        }
        return array;
      });
    });

    /**
     * Creates a `lodash` wrapper instance with explicit method chain sequences enabled.
     *
     * @name chain
     * @memberOf _
     * @since 0.1.0
     * @category Seq
     * @returns {Object} Returns the new `lodash` wrapper instance.
     * @example
     *
     * var users = [
     *   { 'user': 'barney', 'age': 36 },
     *   { 'user': 'fred',   'age': 40 }
     * ];
     *
     * // A sequence without explicit chaining.
     * _(users).head();
     * // => { 'user': 'barney', 'age': 36 }
     *
     * // A sequence with explicit chaining.
     * _(users)
     *   .chain()
     *   .head()
     *   .pick('user')
     *   .value();
     * // => { 'user': 'barney' }
     */
    function wrapperChain() {
      return chain(this);
    }

    /**
     * Executes the chain sequence and returns the wrapped result.
     *
     * @name commit
     * @memberOf _
     * @since 3.2.0
     * @category Seq
     * @returns {Object} Returns the new `lodash` wrapper instance.
     * @example
     *
     * var array = [1, 2];
     * var wrapped = _(array).push(3);
     *
     * console.log(array);
     * // => [1, 2]
     *
     * wrapped = wrapped.commit();
     * console.log(array);
     * // => [1, 2, 3]
     *
     * wrapped.last();
     * // => 3
     *
     * console.log(array);
     * // => [1, 2, 3]
     */
    function wrapperCommit() {
      return new LodashWrapper(this.value(), this.__chain__);
    }

    /**
     * Gets the next value on a wrapped object following the
     * [iterator protocol](https://mdn.io/iteration_protocols#iterator).
     *
     * @name next
     * @memberOf _
     * @since 4.0.0
     * @category Seq
     * @returns {Object} Returns the next iterator value.
     * @example
     *
     * var wrapped = _([1, 2]);
     *
     * wrapped.next();
     * // => { 'done': false, 'value': 1 }
     *
     * wrapped.next();
     * // => { 'done': false, 'value': 2 }
     *
     * wrapped.next();
     * // => { 'done': true, 'value': undefined }
     */
    function wrapperNext() {
      if (this.__values__ === undefined) {
        this.__values__ = toArray(this.value());
      }
      var done = this.__index__ >= this.__values__.length,
          value = done ? undefined : this.__values__[this.__index__++];

      return { 'done': done, 'value': value };
    }

    /**
     * Enables the wrapper to be iterable.
     *
     * @name Symbol.iterator
     * @memberOf _
     * @since 4.0.0
     * @category Seq
     * @returns {Object} Returns the wrapper object.
     * @example
     *
     * var wrapped = _([1, 2]);
     *
     * wrapped[Symbol.iterator]() === wrapped;
     * // => true
     *
     * Array.from(wrapped);
     * // => [1, 2]
     */
    function wrapperToIterator() {
      return this;
    }

    /**
     * Creates a clone of the chain sequence planting `value` as the wrapped value.
     *
     * @name plant
     * @memberOf _
     * @since 3.2.0
     * @category Seq
     * @param {*} value The value to plant.
     * @returns {Object} Returns the new `lodash` wrapper instance.
     * @example
     *
     * function square(n) {
     *   return n * n;
     * }
     *
     * var wrapped = _([1, 2]).map(square);
     * var other = wrapped.plant([3, 4]);
     *
     * other.value();
     * // => [9, 16]
     *
     * wrapped.value();
     * // => [1, 4]
     */
    function wrapperPlant(value) {
      var result,
          parent = this;

      while (parent instanceof baseLodash) {
        var clone = wrapperClone(parent);
        clone.__index__ = 0;
        clone.__values__ = undefined;
        if (result) {
          previous.__wrapped__ = clone;
        } else {
          result = clone;
        }
        var previous = clone;
        parent = parent.__wrapped__;
      }
      previous.__wrapped__ = value;
      return result;
    }

    /**
     * This method is the wrapper version of `_.reverse`.
     *
     * **Note:** This method mutates the wrapped array.
     *
     * @name reverse
     * @memberOf _
     * @since 0.1.0
     * @category Seq
     * @returns {Object} Returns the new `lodash` wrapper instance.
     * @example
     *
     * var array = [1, 2, 3];
     *
     * _(array).reverse().value()
     * // => [3, 2, 1]
     *
     * console.log(array);
     * // => [3, 2, 1]
     */
    function wrapperReverse() {
      var value = this.__wrapped__;
      if (value instanceof LazyWrapper) {
        var wrapped = value;
        if (this.__actions__.length) {
          wrapped = new LazyWrapper(this);
        }
        wrapped = wrapped.reverse();
        wrapped.__actions__.push({
          'func': thru,
          'args': [reverse],
          'thisArg': undefined
        });
        return new LodashWrapper(wrapped, this.__chain__);
      }
      return this.thru(reverse);
    }

    /**
     * Executes the chain sequence to resolve the unwrapped value.
     *
     * @name value
     * @memberOf _
     * @since 0.1.0
     * @alias toJSON, valueOf
     * @category Seq
     * @returns {*} Returns the resolved unwrapped value.
     * @example
     *
     * _([1, 2, 3]).value();
     * // => [1, 2, 3]
     */
    function wrapperValue() {
      return baseWrapperValue(this.__wrapped__, this.__actions__);
    }

    /*------------------------------------------------------------------------*/

    /**
     * Creates an object composed of keys generated from the results of running
     * each element of `collection` thru `iteratee`. The corresponding value of
     * each key is the number of times the key was returned by `iteratee`. The
     * iteratee is invoked with one argument: (value).
     *
     * @static
     * @memberOf _
     * @since 0.5.0
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} [iteratee=_.identity] The iteratee to transform keys.
     * @returns {Object} Returns the composed aggregate object.
     * @example
     *
     * _.countBy([6.1, 4.2, 6.3], Math.floor);
     * // => { '4': 1, '6': 2 }
     *
     * // The `_.property` iteratee shorthand.
     * _.countBy(['one', 'two', 'three'], 'length');
     * // => { '3': 2, '5': 1 }
     */
    var countBy = createAggregator(function(result, value, key) {
      if (hasOwnProperty.call(result, key)) {
        ++result[key];
      } else {
        baseAssignValue(result, key, 1);
      }
    });

    /**
     * Checks if `predicate` returns truthy for **all** elements of `collection`.
     * Iteration is stopped once `predicate` returns falsey. The predicate is
     * invoked with three arguments: (value, index|key, collection).
     *
     * **Note:** This method returns `true` for
     * [empty collections](https://en.wikipedia.org/wiki/Empty_set) because
     * [everything is true](https://en.wikipedia.org/wiki/Vacuous_truth) of
     * elements of empty collections.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} [predicate=_.identity] The function invoked per iteration.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {boolean} Returns `true` if all elements pass the predicate check,
     *  else `false`.
     * @example
     *
     * _.every([true, 1, null, 'yes'], Boolean);
     * // => false
     *
     * var users = [
     *   { 'user': 'barney', 'age': 36, 'active': false },
     *   { 'user': 'fred',   'age': 40, 'active': false }
     * ];
     *
     * // The `_.matches` iteratee shorthand.
     * _.every(users, { 'user': 'barney', 'active': false });
     * // => false
     *
     * // The `_.matchesProperty` iteratee shorthand.
     * _.every(users, ['active', false]);
     * // => true
     *
     * // The `_.property` iteratee shorthand.
     * _.every(users, 'active');
     * // => false
     */
    function every(collection, predicate, guard) {
      var func = isArray(collection) ? arrayEvery : baseEvery;
      if (guard && isIterateeCall(collection, predicate, guard)) {
        predicate = undefined;
      }
      return func(collection, getIteratee(predicate, 3));
    }

    /**
     * Iterates over elements of `collection`, returning an array of all elements
     * `predicate` returns truthy for. The predicate is invoked with three
     * arguments: (value, index|key, collection).
     *
     * **Note:** Unlike `_.remove`, this method returns a new array.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} [predicate=_.identity] The function invoked per iteration.
     * @returns {Array} Returns the new filtered array.
     * @see _.reject
     * @example
     *
     * var users = [
     *   { 'user': 'barney', 'age': 36, 'active': true },
     *   { 'user': 'fred',   'age': 40, 'active': false }
     * ];
     *
     * _.filter(users, function(o) { return !o.active; });
     * // => objects for ['fred']
     *
     * // The `_.matches` iteratee shorthand.
     * _.filter(users, { 'age': 36, 'active': true });
     * // => objects for ['barney']
     *
     * // The `_.matchesProperty` iteratee shorthand.
     * _.filter(users, ['active', false]);
     * // => objects for ['fred']
     *
     * // The `_.property` iteratee shorthand.
     * _.filter(users, 'active');
     * // => objects for ['barney']
     */
    function filter(collection, predicate) {
      var func = isArray(collection) ? arrayFilter : baseFilter;
      return func(collection, getIteratee(predicate, 3));
    }

    /**
     * Iterates over elements of `collection`, returning the first element
     * `predicate` returns truthy for. The predicate is invoked with three
     * arguments: (value, index|key, collection).
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Collection
     * @param {Array|Object} collection The collection to inspect.
     * @param {Function} [predicate=_.identity] The function invoked per iteration.
     * @param {number} [fromIndex=0] The index to search from.
     * @returns {*} Returns the matched element, else `undefined`.
     * @example
     *
     * var users = [
     *   { 'user': 'barney',  'age': 36, 'active': true },
     *   { 'user': 'fred',    'age': 40, 'active': false },
     *   { 'user': 'pebbles', 'age': 1,  'active': true }
     * ];
     *
     * _.find(users, function(o) { return o.age < 40; });
     * // => object for 'barney'
     *
     * // The `_.matches` iteratee shorthand.
     * _.find(users, { 'age': 1, 'active': true });
     * // => object for 'pebbles'
     *
     * // The `_.matchesProperty` iteratee shorthand.
     * _.find(users, ['active', false]);
     * // => object for 'fred'
     *
     * // The `_.property` iteratee shorthand.
     * _.find(users, 'active');
     * // => object for 'barney'
     */
    var find = createFind(findIndex);

    /**
     * This method is like `_.find` except that it iterates over elements of
     * `collection` from right to left.
     *
     * @static
     * @memberOf _
     * @since 2.0.0
     * @category Collection
     * @param {Array|Object} collection The collection to inspect.
     * @param {Function} [predicate=_.identity] The function invoked per iteration.
     * @param {number} [fromIndex=collection.length-1] The index to search from.
     * @returns {*} Returns the matched element, else `undefined`.
     * @example
     *
     * _.findLast([1, 2, 3, 4], function(n) {
     *   return n % 2 == 1;
     * });
     * // => 3
     */
    var findLast = createFind(findLastIndex);

    /**
     * Creates a flattened array of values by running each element in `collection`
     * thru `iteratee` and flattening the mapped results. The iteratee is invoked
     * with three arguments: (value, index|key, collection).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
     * @returns {Array} Returns the new flattened array.
     * @example
     *
     * function duplicate(n) {
     *   return [n, n];
     * }
     *
     * _.flatMap([1, 2], duplicate);
     * // => [1, 1, 2, 2]
     */
    function flatMap(collection, iteratee) {
      return baseFlatten(map(collection, iteratee), 1);
    }

    /**
     * This method is like `_.flatMap` except that it recursively flattens the
     * mapped results.
     *
     * @static
     * @memberOf _
     * @since 4.7.0
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
     * @returns {Array} Returns the new flattened array.
     * @example
     *
     * function duplicate(n) {
     *   return [[[n, n]]];
     * }
     *
     * _.flatMapDeep([1, 2], duplicate);
     * // => [1, 1, 2, 2]
     */
    function flatMapDeep(collection, iteratee) {
      return baseFlatten(map(collection, iteratee), INFINITY);
    }

    /**
     * This method is like `_.flatMap` except that it recursively flattens the
     * mapped results up to `depth` times.
     *
     * @static
     * @memberOf _
     * @since 4.7.0
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
     * @param {number} [depth=1] The maximum recursion depth.
     * @returns {Array} Returns the new flattened array.
     * @example
     *
     * function duplicate(n) {
     *   return [[[n, n]]];
     * }
     *
     * _.flatMapDepth([1, 2], duplicate, 2);
     * // => [[1, 1], [2, 2]]
     */
    function flatMapDepth(collection, iteratee, depth) {
      depth = depth === undefined ? 1 : toInteger(depth);
      return baseFlatten(map(collection, iteratee), depth);
    }

    /**
     * Iterates over elements of `collection` and invokes `iteratee` for each element.
     * The iteratee is invoked with three arguments: (value, index|key, collection).
     * Iteratee functions may exit iteration early by explicitly returning `false`.
     *
     * **Note:** As with other "Collections" methods, objects with a "length"
     * property are iterated like arrays. To avoid this behavior use `_.forIn`
     * or `_.forOwn` for object iteration.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @alias each
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
     * @returns {Array|Object} Returns `collection`.
     * @see _.forEachRight
     * @example
     *
     * _.forEach([1, 2], function(value) {
     *   console.log(value);
     * });
     * // => Logs `1` then `2`.
     *
     * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) {
     *   console.log(key);
     * });
     * // => Logs 'a' then 'b' (iteration order is not guaranteed).
     */
    function forEach(collection, iteratee) {
      var func = isArray(collection) ? arrayEach : baseEach;
      return func(collection, getIteratee(iteratee, 3));
    }

    /**
     * This method is like `_.forEach` except that it iterates over elements of
     * `collection` from right to left.
     *
     * @static
     * @memberOf _
     * @since 2.0.0
     * @alias eachRight
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
     * @returns {Array|Object} Returns `collection`.
     * @see _.forEach
     * @example
     *
     * _.forEachRight([1, 2], function(value) {
     *   console.log(value);
     * });
     * // => Logs `2` then `1`.
     */
    function forEachRight(collection, iteratee) {
      var func = isArray(collection) ? arrayEachRight : baseEachRight;
      return func(collection, getIteratee(iteratee, 3));
    }

    /**
     * Creates an object composed of keys generated from the results of running
     * each element of `collection` thru `iteratee`. The order of grouped values
     * is determined by the order they occur in `collection`. The corresponding
     * value of each key is an array of elements responsible for generating the
     * key. The iteratee is invoked with one argument: (value).
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} [iteratee=_.identity] The iteratee to transform keys.
     * @returns {Object} Returns the composed aggregate object.
     * @example
     *
     * _.groupBy([6.1, 4.2, 6.3], Math.floor);
     * // => { '4': [4.2], '6': [6.1, 6.3] }
     *
     * // The `_.property` iteratee shorthand.
     * _.groupBy(['one', 'two', 'three'], 'length');
     * // => { '3': ['one', 'two'], '5': ['three'] }
     */
    var groupBy = createAggregator(function(result, value, key) {
      if (hasOwnProperty.call(result, key)) {
        result[key].push(value);
      } else {
        baseAssignValue(result, key, [value]);
      }
    });

    /**
     * Checks if `value` is in `collection`. If `collection` is a string, it's
     * checked for a substring of `value`, otherwise
     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
     * is used for equality comparisons. If `fromIndex` is negative, it's used as
     * the offset from the end of `collection`.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Collection
     * @param {Array|Object|string} collection The collection to inspect.
     * @param {*} value The value to search for.
     * @param {number} [fromIndex=0] The index to search from.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.
     * @returns {boolean} Returns `true` if `value` is found, else `false`.
     * @example
     *
     * _.includes([1, 2, 3], 1);
     * // => true
     *
     * _.includes([1, 2, 3], 1, 2);
     * // => false
     *
     * _.includes({ 'a': 1, 'b': 2 }, 1);
     * // => true
     *
     * _.includes('abcd', 'bc');
     * // => true
     */
    function includes(collection, value, fromIndex, guard) {
      collection = isArrayLike(collection) ? collection : values(collection);
      fromIndex = (fromIndex && !guard) ? toInteger(fromIndex) : 0;

      var length = collection.length;
      if (fromIndex < 0) {
        fromIndex = nativeMax(length + fromIndex, 0);
      }
      return isString(collection)
        ? (fromIndex <= length && collection.indexOf(value, fromIndex) > -1)
        : (!!length && baseIndexOf(collection, value, fromIndex) > -1);
    }

    /**
     * Invokes the method at `path` of each element in `collection`, returning
     * an array of the results of each invoked method. Any additional arguments
     * are provided to each invoked method. If `path` is a function, it's invoked
     * for, and `this` bound to, each element in `collection`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Array|Function|string} path The path of the method to invoke or
     *  the function invoked per iteration.
     * @param {...*} [args] The arguments to invoke each method with.
     * @returns {Array} Returns the array of results.
     * @example
     *
     * _.invokeMap([[5, 1, 7], [3, 2, 1]], 'sort');
     * // => [[1, 5, 7], [1, 2, 3]]
     *
     * _.invokeMap([123, 456], String.prototype.split, '');
     * // => [['1', '2', '3'], ['4', '5', '6']]
     */
    var invokeMap = baseRest(function(collection, path, args) {
      var index = -1,
          isFunc = typeof path == 'function',
          result = isArrayLike(collection) ? Array(collection.length) : [];

      baseEach(collection, function(value) {
        result[++index] = isFunc ? apply(path, value, args) : baseInvoke(value, path, args);
      });
      return result;
    });

    /**
     * Creates an object composed of keys generated from the results of running
     * each element of `collection` thru `iteratee`. The corresponding value of
     * each key is the last element responsible for generating the key. The
     * iteratee is invoked with one argument: (value).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} [iteratee=_.identity] The iteratee to transform keys.
     * @returns {Object} Returns the composed aggregate object.
     * @example
     *
     * var array = [
     *   { 'dir': 'left', 'code': 97 },
     *   { 'dir': 'right', 'code': 100 }
     * ];
     *
     * _.keyBy(array, function(o) {
     *   return String.fromCharCode(o.code);
     * });
     * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }
     *
     * _.keyBy(array, 'dir');
     * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }
     */
    var keyBy = createAggregator(function(result, value, key) {
      baseAssignValue(result, key, value);
    });

    /**
     * Creates an array of values by running each element in `collection` thru
     * `iteratee`. The iteratee is invoked with three arguments:
     * (value, index|key, collection).
     *
     * Many lodash methods are guarded to work as iteratees for methods like
     * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.
     *
     * The guarded methods are:
     * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`,
     * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`,
     * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`,
     * `template`, `trim`, `trimEnd`, `trimStart`, and `words`
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
     * @returns {Array} Returns the new mapped array.
     * @example
     *
     * function square(n) {
     *   return n * n;
     * }
     *
     * _.map([4, 8], square);
     * // => [16, 64]
     *
     * _.map({ 'a': 4, 'b': 8 }, square);
     * // => [16, 64] (iteration order is not guaranteed)
     *
     * var users = [
     *   { 'user': 'barney' },
     *   { 'user': 'fred' }
     * ];
     *
     * // The `_.property` iteratee shorthand.
     * _.map(users, 'user');
     * // => ['barney', 'fred']
     */
    function map(collection, iteratee) {
      var func = isArray(collection) ? arrayMap : baseMap;
      return func(collection, getIteratee(iteratee, 3));
    }

    /**
     * This method is like `_.sortBy` except that it allows specifying the sort
     * orders of the iteratees to sort by. If `orders` is unspecified, all values
     * are sorted in ascending order. Otherwise, specify an order of "desc" for
     * descending or "asc" for ascending sort order of corresponding values.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Array[]|Function[]|Object[]|string[]} [iteratees=[_.identity]]
     *  The iteratees to sort by.
     * @param {string[]} [orders] The sort orders of `iteratees`.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.
     * @returns {Array} Returns the new sorted array.
     * @example
     *
     * var users = [
     *   { 'user': 'fred',   'age': 48 },
     *   { 'user': 'barney', 'age': 34 },
     *   { 'user': 'fred',   'age': 40 },
     *   { 'user': 'barney', 'age': 36 }
     * ];
     *
     * // Sort by `user` in ascending order and by `age` in descending order.
     * _.orderBy(users, ['user', 'age'], ['asc', 'desc']);
     * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]
     */
    function orderBy(collection, iteratees, orders, guard) {
      if (collection == null) {
        return [];
      }
      if (!isArray(iteratees)) {
        iteratees = iteratees == null ? [] : [iteratees];
      }
      orders = guard ? undefined : orders;
      if (!isArray(orders)) {
        orders = orders == null ? [] : [orders];
      }
      return baseOrderBy(collection, iteratees, orders);
    }

    /**
     * Creates an array of elements split into two groups, the first of which
     * contains elements `predicate` returns truthy for, the second of which
     * contains elements `predicate` returns falsey for. The predicate is
     * invoked with one argument: (value).
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} [predicate=_.identity] The function invoked per iteration.
     * @returns {Array} Returns the array of grouped elements.
     * @example
     *
     * var users = [
     *   { 'user': 'barney',  'age': 36, 'active': false },
     *   { 'user': 'fred',    'age': 40, 'active': true },
     *   { 'user': 'pebbles', 'age': 1,  'active': false }
     * ];
     *
     * _.partition(users, function(o) { return o.active; });
     * // => objects for [['fred'], ['barney', 'pebbles']]
     *
     * // The `_.matches` iteratee shorthand.
     * _.partition(users, { 'age': 1, 'active': false });
     * // => objects for [['pebbles'], ['barney', 'fred']]
     *
     * // The `_.matchesProperty` iteratee shorthand.
     * _.partition(users, ['active', false]);
     * // => objects for [['barney', 'pebbles'], ['fred']]
     *
     * // The `_.property` iteratee shorthand.
     * _.partition(users, 'active');
     * // => objects for [['fred'], ['barney', 'pebbles']]
     */
    var partition = createAggregator(function(result, value, key) {
      result[key ? 0 : 1].push(value);
    }, function() { return [[], []]; });

    /**
     * Reduces `collection` to a value which is the accumulated result of running
     * each element in `collection` thru `iteratee`, where each successive
     * invocation is supplied the return value of the previous. If `accumulator`
     * is not given, the first element of `collection` is used as the initial
     * value. The iteratee is invoked with four arguments:
     * (accumulator, value, index|key, collection).
     *
     * Many lodash methods are guarded to work as iteratees for methods like
     * `_.reduce`, `_.reduceRight`, and `_.transform`.
     *
     * The guarded methods are:
     * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `orderBy`,
     * and `sortBy`
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
     * @param {*} [accumulator] The initial value.
     * @returns {*} Returns the accumulated value.
     * @see _.reduceRight
     * @example
     *
     * _.reduce([1, 2], function(sum, n) {
     *   return sum + n;
     * }, 0);
     * // => 3
     *
     * _.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {
     *   (result[value] || (result[value] = [])).push(key);
     *   return result;
     * }, {});
     * // => { '1': ['a', 'c'], '2': ['b'] } (iteration order is not guaranteed)
     */
    function reduce(collection, iteratee, accumulator) {
      var func = isArray(collection) ? arrayReduce : baseReduce,
          initAccum = arguments.length < 3;

      return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEach);
    }

    /**
     * This method is like `_.reduce` except that it iterates over elements of
     * `collection` from right to left.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
     * @param {*} [accumulator] The initial value.
     * @returns {*} Returns the accumulated value.
     * @see _.reduce
     * @example
     *
     * var array = [[0, 1], [2, 3], [4, 5]];
     *
     * _.reduceRight(array, function(flattened, other) {
     *   return flattened.concat(other);
     * }, []);
     * // => [4, 5, 2, 3, 0, 1]
     */
    function reduceRight(collection, iteratee, accumulator) {
      var func = isArray(collection) ? arrayReduceRight : baseReduce,
          initAccum = arguments.length < 3;

      return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEachRight);
    }

    /**
     * The opposite of `_.filter`; this method returns the elements of `collection`
     * that `predicate` does **not** return truthy for.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} [predicate=_.identity] The function invoked per iteration.
     * @returns {Array} Returns the new filtered array.
     * @see _.filter
     * @example
     *
     * var users = [
     *   { 'user': 'barney', 'age': 36, 'active': false },
     *   { 'user': 'fred',   'age': 40, 'active': true }
     * ];
     *
     * _.reject(users, function(o) { return !o.active; });
     * // => objects for ['fred']
     *
     * // The `_.matches` iteratee shorthand.
     * _.reject(users, { 'age': 40, 'active': true });
     * // => objects for ['barney']
     *
     * // The `_.matchesProperty` iteratee shorthand.
     * _.reject(users, ['active', false]);
     * // => objects for ['fred']
     *
     * // The `_.property` iteratee shorthand.
     * _.reject(users, 'active');
     * // => objects for ['barney']
     */
    function reject(collection, predicate) {
      var func = isArray(collection) ? arrayFilter : baseFilter;
      return func(collection, negate(getIteratee(predicate, 3)));
    }

    /**
     * Gets a random element from `collection`.
     *
     * @static
     * @memberOf _
     * @since 2.0.0
     * @category Collection
     * @param {Array|Object} collection The collection to sample.
     * @returns {*} Returns the random element.
     * @example
     *
     * _.sample([1, 2, 3, 4]);
     * // => 2
     */
    function sample(collection) {
      var func = isArray(collection) ? arraySample : baseSample;
      return func(collection);
    }

    /**
     * Gets `n` random elements at unique keys from `collection` up to the
     * size of `collection`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Collection
     * @param {Array|Object} collection The collection to sample.
     * @param {number} [n=1] The number of elements to sample.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {Array} Returns the random elements.
     * @example
     *
     * _.sampleSize([1, 2, 3], 2);
     * // => [3, 1]
     *
     * _.sampleSize([1, 2, 3], 4);
     * // => [2, 3, 1]
     */
    function sampleSize(collection, n, guard) {
      if ((guard ? isIterateeCall(collection, n, guard) : n === undefined)) {
        n = 1;
      } else {
        n = toInteger(n);
      }
      var func = isArray(collection) ? arraySampleSize : baseSampleSize;
      return func(collection, n);
    }

    /**
     * Creates an array of shuffled values, using a version of the
     * [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle).
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Collection
     * @param {Array|Object} collection The collection to shuffle.
     * @returns {Array} Returns the new shuffled array.
     * @example
     *
     * _.shuffle([1, 2, 3, 4]);
     * // => [4, 1, 3, 2]
     */
    function shuffle(collection) {
      var func = isArray(collection) ? arrayShuffle : baseShuffle;
      return func(collection);
    }

    /**
     * Gets the size of `collection` by returning its length for array-like
     * values or the number of own enumerable string keyed properties for objects.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Collection
     * @param {Array|Object|string} collection The collection to inspect.
     * @returns {number} Returns the collection size.
     * @example
     *
     * _.size([1, 2, 3]);
     * // => 3
     *
     * _.size({ 'a': 1, 'b': 2 });
     * // => 2
     *
     * _.size('pebbles');
     * // => 7
     */
    function size(collection) {
      if (collection == null) {
        return 0;
      }
      if (isArrayLike(collection)) {
        return isString(collection) ? stringSize(collection) : collection.length;
      }
      var tag = getTag(collection);
      if (tag == mapTag || tag == setTag) {
        return collection.size;
      }
      return baseKeys(collection).length;
    }

    /**
     * Checks if `predicate` returns truthy for **any** element of `collection`.
     * Iteration is stopped once `predicate` returns truthy. The predicate is
     * invoked with three arguments: (value, index|key, collection).
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} [predicate=_.identity] The function invoked per iteration.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {boolean} Returns `true` if any element passes the predicate check,
     *  else `false`.
     * @example
     *
     * _.some([null, 0, 'yes', false], Boolean);
     * // => true
     *
     * var users = [
     *   { 'user': 'barney', 'active': true },
     *   { 'user': 'fred',   'active': false }
     * ];
     *
     * // The `_.matches` iteratee shorthand.
     * _.some(users, { 'user': 'barney', 'active': false });
     * // => false
     *
     * // The `_.matchesProperty` iteratee shorthand.
     * _.some(users, ['active', false]);
     * // => true
     *
     * // The `_.property` iteratee shorthand.
     * _.some(users, 'active');
     * // => true
     */
    function some(collection, predicate, guard) {
      var func = isArray(collection) ? arraySome : baseSome;
      if (guard && isIterateeCall(collection, predicate, guard)) {
        predicate = undefined;
      }
      return func(collection, getIteratee(predicate, 3));
    }

    /**
     * Creates an array of elements, sorted in ascending order by the results of
     * running each element in a collection thru each iteratee. This method
     * performs a stable sort, that is, it preserves the original sort order of
     * equal elements. The iteratees are invoked with one argument: (value).
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {...(Function|Function[])} [iteratees=[_.identity]]
     *  The iteratees to sort by.
     * @returns {Array} Returns the new sorted array.
     * @example
     *
     * var users = [
     *   { 'user': 'fred',   'age': 48 },
     *   { 'user': 'barney', 'age': 36 },
     *   { 'user': 'fred',   'age': 40 },
     *   { 'user': 'barney', 'age': 34 }
     * ];
     *
     * _.sortBy(users, [function(o) { return o.user; }]);
     * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]
     *
     * _.sortBy(users, ['user', 'age']);
     * // => objects for [['barney', 34], ['barney', 36], ['fred', 40], ['fred', 48]]
     */
    var sortBy = baseRest(function(collection, iteratees) {
      if (collection == null) {
        return [];
      }
      var length = iteratees.length;
      if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) {
        iteratees = [];
      } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) {
        iteratees = [iteratees[0]];
      }
      return baseOrderBy(collection, baseFlatten(iteratees, 1), []);
    });

    /*------------------------------------------------------------------------*/

    /**
     * Gets the timestamp of the number of milliseconds that have elapsed since
     * the Unix epoch (1 January 1970 00:00:00 UTC).
     *
     * @static
     * @memberOf _
     * @since 2.4.0
     * @category Date
     * @returns {number} Returns the timestamp.
     * @example
     *
     * _.defer(function(stamp) {
     *   console.log(_.now() - stamp);
     * }, _.now());
     * // => Logs the number of milliseconds it took for the deferred invocation.
     */
    var now = ctxNow || function() {
      return root.Date.now();
    };

    /*------------------------------------------------------------------------*/

    /**
     * The opposite of `_.before`; this method creates a function that invokes
     * `func` once it's called `n` or more times.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Function
     * @param {number} n The number of calls before `func` is invoked.
     * @param {Function} func The function to restrict.
     * @returns {Function} Returns the new restricted function.
     * @example
     *
     * var saves = ['profile', 'settings'];
     *
     * var done = _.after(saves.length, function() {
     *   console.log('done saving!');
     * });
     *
     * _.forEach(saves, function(type) {
     *   asyncSave({ 'type': type, 'complete': done });
     * });
     * // => Logs 'done saving!' after the two async saves have completed.
     */
    function after(n, func) {
      if (typeof func != 'function') {
        throw new TypeError(FUNC_ERROR_TEXT);
      }
      n = toInteger(n);
      return function() {
        if (--n < 1) {
          return func.apply(this, arguments);
        }
      };
    }

    /**
     * Creates a function that invokes `func`, with up to `n` arguments,
     * ignoring any additional arguments.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Function
     * @param {Function} func The function to cap arguments for.
     * @param {number} [n=func.length] The arity cap.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {Function} Returns the new capped function.
     * @example
     *
     * _.map(['6', '8', '10'], _.ary(parseInt, 1));
     * // => [6, 8, 10]
     */
    function ary(func, n, guard) {
      n = guard ? undefined : n;
      n = (func && n == null) ? func.length : n;
      return createWrap(func, WRAP_ARY_FLAG, undefined, undefined, undefined, undefined, n);
    }

    /**
     * Creates a function that invokes `func`, with the `this` binding and arguments
     * of the created function, while it's called less than `n` times. Subsequent
     * calls to the created function return the result of the last `func` invocation.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Function
     * @param {number} n The number of calls at which `func` is no longer invoked.
     * @param {Function} func The function to restrict.
     * @returns {Function} Returns the new restricted function.
     * @example
     *
     * jQuery(element).on('click', _.before(5, addContactToList));
     * // => Allows adding up to 4 contacts to the list.
     */
    function before(n, func) {
      var result;
      if (typeof func != 'function') {
        throw new TypeError(FUNC_ERROR_TEXT);
      }
      n = toInteger(n);
      return function() {
        if (--n > 0) {
          result = func.apply(this, arguments);
        }
        if (n <= 1) {
          func = undefined;
        }
        return result;
      };
    }

    /**
     * Creates a function that invokes `func` with the `this` binding of `thisArg`
     * and `partials` prepended to the arguments it receives.
     *
     * The `_.bind.placeholder` value, which defaults to `_` in monolithic builds,
     * may be used as a placeholder for partially applied arguments.
     *
     * **Note:** Unlike native `Function#bind`, this method doesn't set the "length"
     * property of bound functions.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Function
     * @param {Function} func The function to bind.
     * @param {*} thisArg The `this` binding of `func`.
     * @param {...*} [partials] The arguments to be partially applied.
     * @returns {Function} Returns the new bound function.
     * @example
     *
     * function greet(greeting, punctuation) {
     *   return greeting + ' ' + this.user + punctuation;
     * }
     *
     * var object = { 'user': 'fred' };
     *
     * var bound = _.bind(greet, object, 'hi');
     * bound('!');
     * // => 'hi fred!'
     *
     * // Bound with placeholders.
     * var bound = _.bind(greet, object, _, '!');
     * bound('hi');
     * // => 'hi fred!'
     */
    var bind = baseRest(function(func, thisArg, partials) {
      var bitmask = WRAP_BIND_FLAG;
      if (partials.length) {
        var holders = replaceHolders(partials, getHolder(bind));
        bitmask |= WRAP_PARTIAL_FLAG;
      }
      return createWrap(func, bitmask, thisArg, partials, holders);
    });

    /**
     * Creates a function that invokes the method at `object[key]` with `partials`
     * prepended to the arguments it receives.
     *
     * This method differs from `_.bind` by allowing bound functions to reference
     * methods that may be redefined or don't yet exist. See
     * [Peter Michaux's article](http://peter.michaux.ca/articles/lazy-function-definition-pattern)
     * for more details.
     *
     * The `_.bindKey.placeholder` value, which defaults to `_` in monolithic
     * builds, may be used as a placeholder for partially applied arguments.
     *
     * @static
     * @memberOf _
     * @since 0.10.0
     * @category Function
     * @param {Object} object The object to invoke the method on.
     * @param {string} key The key of the method.
     * @param {...*} [partials] The arguments to be partially applied.
     * @returns {Function} Returns the new bound function.
     * @example
     *
     * var object = {
     *   'user': 'fred',
     *   'greet': function(greeting, punctuation) {
     *     return greeting + ' ' + this.user + punctuation;
     *   }
     * };
     *
     * var bound = _.bindKey(object, 'greet', 'hi');
     * bound('!');
     * // => 'hi fred!'
     *
     * object.greet = function(greeting, punctuation) {
     *   return greeting + 'ya ' + this.user + punctuation;
     * };
     *
     * bound('!');
     * // => 'hiya fred!'
     *
     * // Bound with placeholders.
     * var bound = _.bindKey(object, 'greet', _, '!');
     * bound('hi');
     * // => 'hiya fred!'
     */
    var bindKey = baseRest(function(object, key, partials) {
      var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG;
      if (partials.length) {
        var holders = replaceHolders(partials, getHolder(bindKey));
        bitmask |= WRAP_PARTIAL_FLAG;
      }
      return createWrap(key, bitmask, object, partials, holders);
    });

    /**
     * Creates a function that accepts arguments of `func` and either invokes
     * `func` returning its result, if at least `arity` number of arguments have
     * been provided, or returns a function that accepts the remaining `func`
     * arguments, and so on. The arity of `func` may be specified if `func.length`
     * is not sufficient.
     *
     * The `_.curry.placeholder` value, which defaults to `_` in monolithic builds,
     * may be used as a placeholder for provided arguments.
     *
     * **Note:** This method doesn't set the "length" property of curried functions.
     *
     * @static
     * @memberOf _
     * @since 2.0.0
     * @category Function
     * @param {Function} func The function to curry.
     * @param {number} [arity=func.length] The arity of `func`.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {Function} Returns the new curried function.
     * @example
     *
     * var abc = function(a, b, c) {
     *   return [a, b, c];
     * };
     *
     * var curried = _.curry(abc);
     *
     * curried(1)(2)(3);
     * // => [1, 2, 3]
     *
     * curried(1, 2)(3);
     * // => [1, 2, 3]
     *
     * curried(1, 2, 3);
     * // => [1, 2, 3]
     *
     * // Curried with placeholders.
     * curried(1)(_, 3)(2);
     * // => [1, 2, 3]
     */
    function curry(func, arity, guard) {
      arity = guard ? undefined : arity;
      var result = createWrap(func, WRAP_CURRY_FLAG, undefined, undefined, undefined, undefined, undefined, arity);
      result.placeholder = curry.placeholder;
      return result;
    }

    /**
     * This method is like `_.curry` except that arguments are applied to `func`
     * in the manner of `_.partialRight` instead of `_.partial`.
     *
     * The `_.curryRight.placeholder` value, which defaults to `_` in monolithic
     * builds, may be used as a placeholder for provided arguments.
     *
     * **Note:** This method doesn't set the "length" property of curried functions.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Function
     * @param {Function} func The function to curry.
     * @param {number} [arity=func.length] The arity of `func`.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {Function} Returns the new curried function.
     * @example
     *
     * var abc = function(a, b, c) {
     *   return [a, b, c];
     * };
     *
     * var curried = _.curryRight(abc);
     *
     * curried(3)(2)(1);
     * // => [1, 2, 3]
     *
     * curried(2, 3)(1);
     * // => [1, 2, 3]
     *
     * curried(1, 2, 3);
     * // => [1, 2, 3]
     *
     * // Curried with placeholders.
     * curried(3)(1, _)(2);
     * // => [1, 2, 3]
     */
    function curryRight(func, arity, guard) {
      arity = guard ? undefined : arity;
      var result = createWrap(func, WRAP_CURRY_RIGHT_FLAG, undefined, undefined, undefined, undefined, undefined, arity);
      result.placeholder = curryRight.placeholder;
      return result;
    }

    /**
     * Creates a debounced function that delays invoking `func` until after `wait`
     * milliseconds have elapsed since the last time the debounced function was
     * invoked. The debounced function comes with a `cancel` method to cancel
     * delayed `func` invocations and a `flush` method to immediately invoke them.
     * Provide `options` to indicate whether `func` should be invoked on the
     * leading and/or trailing edge of the `wait` timeout. The `func` is invoked
     * with the last arguments provided to the debounced function. Subsequent
     * calls to the debounced function return the result of the last `func`
     * invocation.
     *
     * **Note:** If `leading` and `trailing` options are `true`, `func` is
     * invoked on the trailing edge of the timeout only if the debounced function
     * is invoked more than once during the `wait` timeout.
     *
     * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
     * until to the next tick, similar to `setTimeout` with a timeout of `0`.
     *
     * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
     * for details over the differences between `_.debounce` and `_.throttle`.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Function
     * @param {Function} func The function to debounce.
     * @param {number} [wait=0] The number of milliseconds to delay.
     * @param {Object} [options={}] The options object.
     * @param {boolean} [options.leading=false]
     *  Specify invoking on the leading edge of the timeout.
     * @param {number} [options.maxWait]
     *  The maximum time `func` is allowed to be delayed before it's invoked.
     * @param {boolean} [options.trailing=true]
     *  Specify invoking on the trailing edge of the timeout.
     * @returns {Function} Returns the new debounced function.
     * @example
     *
     * // Avoid costly calculations while the window size is in flux.
     * jQuery(window).on('resize', _.debounce(calculateLayout, 150));
     *
     * // Invoke `sendMail` when clicked, debouncing subsequent calls.
     * jQuery(element).on('click', _.debounce(sendMail, 300, {
     *   'leading': true,
     *   'trailing': false
     * }));
     *
     * // Ensure `batchLog` is invoked once after 1 second of debounced calls.
     * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
     * var source = new EventSource('/stream');
     * jQuery(source).on('message', debounced);
     *
     * // Cancel the trailing debounced invocation.
     * jQuery(window).on('popstate', debounced.cancel);
     */
    function debounce(func, wait, options) {
      var lastArgs,
          lastThis,
          maxWait,
          result,
          timerId,
          lastCallTime,
          lastInvokeTime = 0,
          leading = false,
          maxing = false,
          trailing = true;

      if (typeof func != 'function') {
        throw new TypeError(FUNC_ERROR_TEXT);
      }
      wait = toNumber(wait) || 0;
      if (isObject(options)) {
        leading = !!options.leading;
        maxing = 'maxWait' in options;
        maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
        trailing = 'trailing' in options ? !!options.trailing : trailing;
      }

      function invokeFunc(time) {
        var args = lastArgs,
            thisArg = lastThis;

        lastArgs = lastThis = undefined;
        lastInvokeTime = time;
        result = func.apply(thisArg, args);
        return result;
      }

      function leadingEdge(time) {
        // Reset any `maxWait` timer.
        lastInvokeTime = time;
        // Start the timer for the trailing edge.
        timerId = setTimeout(timerExpired, wait);
        // Invoke the leading edge.
        return leading ? invokeFunc(time) : result;
      }

      function remainingWait(time) {
        var timeSinceLastCall = time - lastCallTime,
            timeSinceLastInvoke = time - lastInvokeTime,
            result = wait - timeSinceLastCall;

        return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;
      }

      function shouldInvoke(time) {
        var timeSinceLastCall = time - lastCallTime,
            timeSinceLastInvoke = time - lastInvokeTime;

        // Either this is the first call, activity has stopped and we're at the
        // trailing edge, the system time has gone backwards and we're treating
        // it as the trailing edge, or we've hit the `maxWait` limit.
        return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||
          (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));
      }

      function timerExpired() {
        var time = now();
        if (shouldInvoke(time)) {
          return trailingEdge(time);
        }
        // Restart the timer.
        timerId = setTimeout(timerExpired, remainingWait(time));
      }

      function trailingEdge(time) {
        timerId = undefined;

        // Only invoke if we have `lastArgs` which means `func` has been
        // debounced at least once.
        if (trailing && lastArgs) {
          return invokeFunc(time);
        }
        lastArgs = lastThis = undefined;
        return result;
      }

      function cancel() {
        if (timerId !== undefined) {
          clearTimeout(timerId);
        }
        lastInvokeTime = 0;
        lastArgs = lastCallTime = lastThis = timerId = undefined;
      }

      function flush() {
        return timerId === undefined ? result : trailingEdge(now());
      }

      function debounced() {
        var time = now(),
            isInvoking = shouldInvoke(time);

        lastArgs = arguments;
        lastThis = this;
        lastCallTime = time;

        if (isInvoking) {
          if (timerId === undefined) {
            return leadingEdge(lastCallTime);
          }
          if (maxing) {
            // Handle invocations in a tight loop.
            timerId = setTimeout(timerExpired, wait);
            return invokeFunc(lastCallTime);
          }
        }
        if (timerId === undefined) {
          timerId = setTimeout(timerExpired, wait);
        }
        return result;
      }
      debounced.cancel = cancel;
      debounced.flush = flush;
      return debounced;
    }

    /**
     * Defers invoking the `func` until the current call stack has cleared. Any
     * additional arguments are provided to `func` when it's invoked.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Function
     * @param {Function} func The function to defer.
     * @param {...*} [args] The arguments to invoke `func` with.
     * @returns {number} Returns the timer id.
     * @example
     *
     * _.defer(function(text) {
     *   console.log(text);
     * }, 'deferred');
     * // => Logs 'deferred' after one millisecond.
     */
    var defer = baseRest(function(func, args) {
      return baseDelay(func, 1, args);
    });

    /**
     * Invokes `func` after `wait` milliseconds. Any additional arguments are
     * provided to `func` when it's invoked.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Function
     * @param {Function} func The function to delay.
     * @param {number} wait The number of milliseconds to delay invocation.
     * @param {...*} [args] The arguments to invoke `func` with.
     * @returns {number} Returns the timer id.
     * @example
     *
     * _.delay(function(text) {
     *   console.log(text);
     * }, 1000, 'later');
     * // => Logs 'later' after one second.
     */
    var delay = baseRest(function(func, wait, args) {
      return baseDelay(func, toNumber(wait) || 0, args);
    });

    /**
     * Creates a function that invokes `func` with arguments reversed.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Function
     * @param {Function} func The function to flip arguments for.
     * @returns {Function} Returns the new flipped function.
     * @example
     *
     * var flipped = _.flip(function() {
     *   return _.toArray(arguments);
     * });
     *
     * flipped('a', 'b', 'c', 'd');
     * // => ['d', 'c', 'b', 'a']
     */
    function flip(func) {
      return createWrap(func, WRAP_FLIP_FLAG);
    }

    /**
     * Creates a function that memoizes the result of `func`. If `resolver` is
     * provided, it determines the cache key for storing the result based on the
     * arguments provided to the memoized function. By default, the first argument
     * provided to the memoized function is used as the map cache key. The `func`
     * is invoked with the `this` binding of the memoized function.
     *
     * **Note:** The cache is exposed as the `cache` property on the memoized
     * function. Its creation may be customized by replacing the `_.memoize.Cache`
     * constructor with one whose instances implement the
     * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
     * method interface of `clear`, `delete`, `get`, `has`, and `set`.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Function
     * @param {Function} func The function to have its output memoized.
     * @param {Function} [resolver] The function to resolve the cache key.
     * @returns {Function} Returns the new memoized function.
     * @example
     *
     * var object = { 'a': 1, 'b': 2 };
     * var other = { 'c': 3, 'd': 4 };
     *
     * var values = _.memoize(_.values);
     * values(object);
     * // => [1, 2]
     *
     * values(other);
     * // => [3, 4]
     *
     * object.a = 2;
     * values(object);
     * // => [1, 2]
     *
     * // Modify the result cache.
     * values.cache.set(object, ['a', 'b']);
     * values(object);
     * // => ['a', 'b']
     *
     * // Replace `_.memoize.Cache`.
     * _.memoize.Cache = WeakMap;
     */
    function memoize(func, resolver) {
      if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {
        throw new TypeError(FUNC_ERROR_TEXT);
      }
      var memoized = function() {
        var args = arguments,
            key = resolver ? resolver.apply(this, args) : args[0],
            cache = memoized.cache;

        if (cache.has(key)) {
          return cache.get(key);
        }
        var result = func.apply(this, args);
        memoized.cache = cache.set(key, result) || cache;
        return result;
      };
      memoized.cache = new (memoize.Cache || MapCache);
      return memoized;
    }

    // Expose `MapCache`.
    memoize.Cache = MapCache;

    /**
     * Creates a function that negates the result of the predicate `func`. The
     * `func` predicate is invoked with the `this` binding and arguments of the
     * created function.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Function
     * @param {Function} predicate The predicate to negate.
     * @returns {Function} Returns the new negated function.
     * @example
     *
     * function isEven(n) {
     *   return n % 2 == 0;
     * }
     *
     * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven));
     * // => [1, 3, 5]
     */
    function negate(predicate) {
      if (typeof predicate != 'function') {
        throw new TypeError(FUNC_ERROR_TEXT);
      }
      return function() {
        var args = arguments;
        switch (args.length) {
          case 0: return !predicate.call(this);
          case 1: return !predicate.call(this, args[0]);
          case 2: return !predicate.call(this, args[0], args[1]);
          case 3: return !predicate.call(this, args[0], args[1], args[2]);
        }
        return !predicate.apply(this, args);
      };
    }

    /**
     * Creates a function that is restricted to invoking `func` once. Repeat calls
     * to the function return the value of the first invocation. The `func` is
     * invoked with the `this` binding and arguments of the created function.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Function
     * @param {Function} func The function to restrict.
     * @returns {Function} Returns the new restricted function.
     * @example
     *
     * var initialize = _.once(createApplication);
     * initialize();
     * initialize();
     * // => `createApplication` is invoked once
     */
    function once(func) {
      return before(2, func);
    }

    /**
     * Creates a function that invokes `func` with its arguments transformed.
     *
     * @static
     * @since 4.0.0
     * @memberOf _
     * @category Function
     * @param {Function} func The function to wrap.
     * @param {...(Function|Function[])} [transforms=[_.identity]]
     *  The argument transforms.
     * @returns {Function} Returns the new function.
     * @example
     *
     * function doubled(n) {
     *   return n * 2;
     * }
     *
     * function square(n) {
     *   return n * n;
     * }
     *
     * var func = _.overArgs(function(x, y) {
     *   return [x, y];
     * }, [square, doubled]);
     *
     * func(9, 3);
     * // => [81, 6]
     *
     * func(10, 5);
     * // => [100, 10]
     */
    var overArgs = castRest(function(func, transforms) {
      transforms = (transforms.length == 1 && isArray(transforms[0]))
        ? arrayMap(transforms[0], baseUnary(getIteratee()))
        : arrayMap(baseFlatten(transforms, 1), baseUnary(getIteratee()));

      var funcsLength = transforms.length;
      return baseRest(function(args) {
        var index = -1,
            length = nativeMin(args.length, funcsLength);

        while (++index < length) {
          args[index] = transforms[index].call(this, args[index]);
        }
        return apply(func, this, args);
      });
    });

    /**
     * Creates a function that invokes `func` with `partials` prepended to the
     * arguments it receives. This method is like `_.bind` except it does **not**
     * alter the `this` binding.
     *
     * The `_.partial.placeholder` value, which defaults to `_` in monolithic
     * builds, may be used as a placeholder for partially applied arguments.
     *
     * **Note:** This method doesn't set the "length" property of partially
     * applied functions.
     *
     * @static
     * @memberOf _
     * @since 0.2.0
     * @category Function
     * @param {Function} func The function to partially apply arguments to.
     * @param {...*} [partials] The arguments to be partially applied.
     * @returns {Function} Returns the new partially applied function.
     * @example
     *
     * function greet(greeting, name) {
     *   return greeting + ' ' + name;
     * }
     *
     * var sayHelloTo = _.partial(greet, 'hello');
     * sayHelloTo('fred');
     * // => 'hello fred'
     *
     * // Partially applied with placeholders.
     * var greetFred = _.partial(greet, _, 'fred');
     * greetFred('hi');
     * // => 'hi fred'
     */
    var partial = baseRest(function(func, partials) {
      var holders = replaceHolders(partials, getHolder(partial));
      return createWrap(func, WRAP_PARTIAL_FLAG, undefined, partials, holders);
    });

    /**
     * This method is like `_.partial` except that partially applied arguments
     * are appended to the arguments it receives.
     *
     * The `_.partialRight.placeholder` value, which defaults to `_` in monolithic
     * builds, may be used as a placeholder for partially applied arguments.
     *
     * **Note:** This method doesn't set the "length" property of partially
     * applied functions.
     *
     * @static
     * @memberOf _
     * @since 1.0.0
     * @category Function
     * @param {Function} func The function to partially apply arguments to.
     * @param {...*} [partials] The arguments to be partially applied.
     * @returns {Function} Returns the new partially applied function.
     * @example
     *
     * function greet(greeting, name) {
     *   return greeting + ' ' + name;
     * }
     *
     * var greetFred = _.partialRight(greet, 'fred');
     * greetFred('hi');
     * // => 'hi fred'
     *
     * // Partially applied with placeholders.
     * var sayHelloTo = _.partialRight(greet, 'hello', _);
     * sayHelloTo('fred');
     * // => 'hello fred'
     */
    var partialRight = baseRest(function(func, partials) {
      var holders = replaceHolders(partials, getHolder(partialRight));
      return createWrap(func, WRAP_PARTIAL_RIGHT_FLAG, undefined, partials, holders);
    });

    /**
     * Creates a function that invokes `func` with arguments arranged according
     * to the specified `indexes` where the argument value at the first index is
     * provided as the first argument, the argument value at the second index is
     * provided as the second argument, and so on.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Function
     * @param {Function} func The function to rearrange arguments for.
     * @param {...(number|number[])} indexes The arranged argument indexes.
     * @returns {Function} Returns the new function.
     * @example
     *
     * var rearged = _.rearg(function(a, b, c) {
     *   return [a, b, c];
     * }, [2, 0, 1]);
     *
     * rearged('b', 'c', 'a')
     * // => ['a', 'b', 'c']
     */
    var rearg = flatRest(function(func, indexes) {
      return createWrap(func, WRAP_REARG_FLAG, undefined, undefined, undefined, indexes);
    });

    /**
     * Creates a function that invokes `func` with the `this` binding of the
     * created function and arguments from `start` and beyond provided as
     * an array.
     *
     * **Note:** This method is based on the
     * [rest parameter](https://mdn.io/rest_parameters).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Function
     * @param {Function} func The function to apply a rest parameter to.
     * @param {number} [start=func.length-1] The start position of the rest parameter.
     * @returns {Function} Returns the new function.
     * @example
     *
     * var say = _.rest(function(what, names) {
     *   return what + ' ' + _.initial(names).join(', ') +
     *     (_.size(names) > 1 ? ', & ' : '') + _.last(names);
     * });
     *
     * say('hello', 'fred', 'barney', 'pebbles');
     * // => 'hello fred, barney, & pebbles'
     */
    function rest(func, start) {
      if (typeof func != 'function') {
        throw new TypeError(FUNC_ERROR_TEXT);
      }
      start = start === undefined ? start : toInteger(start);
      return baseRest(func, start);
    }

    /**
     * Creates a function that invokes `func` with the `this` binding of the
     * create function and an array of arguments much like
     * [`Function#apply`](http://www.ecma-international.org/ecma-262/7.0/#sec-function.prototype.apply).
     *
     * **Note:** This method is based on the
     * [spread operator](https://mdn.io/spread_operator).
     *
     * @static
     * @memberOf _
     * @since 3.2.0
     * @category Function
     * @param {Function} func The function to spread arguments over.
     * @param {number} [start=0] The start position of the spread.
     * @returns {Function} Returns the new function.
     * @example
     *
     * var say = _.spread(function(who, what) {
     *   return who + ' says ' + what;
     * });
     *
     * say(['fred', 'hello']);
     * // => 'fred says hello'
     *
     * var numbers = Promise.all([
     *   Promise.resolve(40),
     *   Promise.resolve(36)
     * ]);
     *
     * numbers.then(_.spread(function(x, y) {
     *   return x + y;
     * }));
     * // => a Promise of 76
     */
    function spread(func, start) {
      if (typeof func != 'function') {
        throw new TypeError(FUNC_ERROR_TEXT);
      }
      start = start == null ? 0 : nativeMax(toInteger(start), 0);
      return baseRest(function(args) {
        var array = args[start],
            otherArgs = castSlice(args, 0, start);

        if (array) {
          arrayPush(otherArgs, array);
        }
        return apply(func, this, otherArgs);
      });
    }

    /**
     * Creates a throttled function that only invokes `func` at most once per
     * every `wait` milliseconds. The throttled function comes with a `cancel`
     * method to cancel delayed `func` invocations and a `flush` method to
     * immediately invoke them. Provide `options` to indicate whether `func`
     * should be invoked on the leading and/or trailing edge of the `wait`
     * timeout. The `func` is invoked with the last arguments provided to the
     * throttled function. Subsequent calls to the throttled function return the
     * result of the last `func` invocation.
     *
     * **Note:** If `leading` and `trailing` options are `true`, `func` is
     * invoked on the trailing edge of the timeout only if the throttled function
     * is invoked more than once during the `wait` timeout.
     *
     * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
     * until to the next tick, similar to `setTimeout` with a timeout of `0`.
     *
     * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
     * for details over the differences between `_.throttle` and `_.debounce`.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Function
     * @param {Function} func The function to throttle.
     * @param {number} [wait=0] The number of milliseconds to throttle invocations to.
     * @param {Object} [options={}] The options object.
     * @param {boolean} [options.leading=true]
     *  Specify invoking on the leading edge of the timeout.
     * @param {boolean} [options.trailing=true]
     *  Specify invoking on the trailing edge of the timeout.
     * @returns {Function} Returns the new throttled function.
     * @example
     *
     * // Avoid excessively updating the position while scrolling.
     * jQuery(window).on('scroll', _.throttle(updatePosition, 100));
     *
     * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.
     * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });
     * jQuery(element).on('click', throttled);
     *
     * // Cancel the trailing throttled invocation.
     * jQuery(window).on('popstate', throttled.cancel);
     */
    function throttle(func, wait, options) {
      var leading = true,
          trailing = true;

      if (typeof func != 'function') {
        throw new TypeError(FUNC_ERROR_TEXT);
      }
      if (isObject(options)) {
        leading = 'leading' in options ? !!options.leading : leading;
        trailing = 'trailing' in options ? !!options.trailing : trailing;
      }
      return debounce(func, wait, {
        'leading': leading,
        'maxWait': wait,
        'trailing': trailing
      });
    }

    /**
     * Creates a function that accepts up to one argument, ignoring any
     * additional arguments.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Function
     * @param {Function} func The function to cap arguments for.
     * @returns {Function} Returns the new capped function.
     * @example
     *
     * _.map(['6', '8', '10'], _.unary(parseInt));
     * // => [6, 8, 10]
     */
    function unary(func) {
      return ary(func, 1);
    }

    /**
     * Creates a function that provides `value` to `wrapper` as its first
     * argument. Any additional arguments provided to the function are appended
     * to those provided to the `wrapper`. The wrapper is invoked with the `this`
     * binding of the created function.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Function
     * @param {*} value The value to wrap.
     * @param {Function} [wrapper=identity] The wrapper function.
     * @returns {Function} Returns the new function.
     * @example
     *
     * var p = _.wrap(_.escape, function(func, text) {
     *   return '<p>' + func(text) + '</p>';
     * });
     *
     * p('fred, barney, & pebbles');
     * // => '<p>fred, barney, &amp; pebbles</p>'
     */
    function wrap(value, wrapper) {
      return partial(castFunction(wrapper), value);
    }

    /*------------------------------------------------------------------------*/

    /**
     * Casts `value` as an array if it's not one.
     *
     * @static
     * @memberOf _
     * @since 4.4.0
     * @category Lang
     * @param {*} value The value to inspect.
     * @returns {Array} Returns the cast array.
     * @example
     *
     * _.castArray(1);
     * // => [1]
     *
     * _.castArray({ 'a': 1 });
     * // => [{ 'a': 1 }]
     *
     * _.castArray('abc');
     * // => ['abc']
     *
     * _.castArray(null);
     * // => [null]
     *
     * _.castArray(undefined);
     * // => [undefined]
     *
     * _.castArray();
     * // => []
     *
     * var array = [1, 2, 3];
     * console.log(_.castArray(array) === array);
     * // => true
     */
    function castArray() {
      if (!arguments.length) {
        return [];
      }
      var value = arguments[0];
      return isArray(value) ? value : [value];
    }

    /**
     * Creates a shallow clone of `value`.
     *
     * **Note:** This method is loosely based on the
     * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm)
     * and supports cloning arrays, array buffers, booleans, date objects, maps,
     * numbers, `Object` objects, regexes, sets, strings, symbols, and typed
     * arrays. The own enumerable properties of `arguments` objects are cloned
     * as plain objects. An empty object is returned for uncloneable values such
     * as error objects, functions, DOM nodes, and WeakMaps.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Lang
     * @param {*} value The value to clone.
     * @returns {*} Returns the cloned value.
     * @see _.cloneDeep
     * @example
     *
     * var objects = [{ 'a': 1 }, { 'b': 2 }];
     *
     * var shallow = _.clone(objects);
     * console.log(shallow[0] === objects[0]);
     * // => true
     */
    function clone(value) {
      return baseClone(value, CLONE_SYMBOLS_FLAG);
    }

    /**
     * This method is like `_.clone` except that it accepts `customizer` which
     * is invoked to produce the cloned value. If `customizer` returns `undefined`,
     * cloning is handled by the method instead. The `customizer` is invoked with
     * up to four arguments; (value [, index|key, object, stack]).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to clone.
     * @param {Function} [customizer] The function to customize cloning.
     * @returns {*} Returns the cloned value.
     * @see _.cloneDeepWith
     * @example
     *
     * function customizer(value) {
     *   if (_.isElement(value)) {
     *     return value.cloneNode(false);
     *   }
     * }
     *
     * var el = _.cloneWith(document.body, customizer);
     *
     * console.log(el === document.body);
     * // => false
     * console.log(el.nodeName);
     * // => 'BODY'
     * console.log(el.childNodes.length);
     * // => 0
     */
    function cloneWith(value, customizer) {
      customizer = typeof customizer == 'function' ? customizer : undefined;
      return baseClone(value, CLONE_SYMBOLS_FLAG, customizer);
    }

    /**
     * This method is like `_.clone` except that it recursively clones `value`.
     *
     * @static
     * @memberOf _
     * @since 1.0.0
     * @category Lang
     * @param {*} value The value to recursively clone.
     * @returns {*} Returns the deep cloned value.
     * @see _.clone
     * @example
     *
     * var objects = [{ 'a': 1 }, { 'b': 2 }];
     *
     * var deep = _.cloneDeep(objects);
     * console.log(deep[0] === objects[0]);
     * // => false
     */
    function cloneDeep(value) {
      return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);
    }

    /**
     * This method is like `_.cloneWith` except that it recursively clones `value`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to recursively clone.
     * @param {Function} [customizer] The function to customize cloning.
     * @returns {*} Returns the deep cloned value.
     * @see _.cloneWith
     * @example
     *
     * function customizer(value) {
     *   if (_.isElement(value)) {
     *     return value.cloneNode(true);
     *   }
     * }
     *
     * var el = _.cloneDeepWith(document.body, customizer);
     *
     * console.log(el === document.body);
     * // => false
     * console.log(el.nodeName);
     * // => 'BODY'
     * console.log(el.childNodes.length);
     * // => 20
     */
    function cloneDeepWith(value, customizer) {
      customizer = typeof customizer == 'function' ? customizer : undefined;
      return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer);
    }

    /**
     * Checks if `object` conforms to `source` by invoking the predicate
     * properties of `source` with the corresponding property values of `object`.
     *
     * **Note:** This method is equivalent to `_.conforms` when `source` is
     * partially applied.
     *
     * @static
     * @memberOf _
     * @since 4.14.0
     * @category Lang
     * @param {Object} object The object to inspect.
     * @param {Object} source The object of property predicates to conform to.
     * @returns {boolean} Returns `true` if `object` conforms, else `false`.
     * @example
     *
     * var object = { 'a': 1, 'b': 2 };
     *
     * _.conformsTo(object, { 'b': function(n) { return n > 1; } });
     * // => true
     *
     * _.conformsTo(object, { 'b': function(n) { return n > 2; } });
     * // => false
     */
    function conformsTo(object, source) {
      return source == null || baseConformsTo(object, source, keys(source));
    }

    /**
     * Performs a
     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
     * comparison between two values to determine if they are equivalent.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to compare.
     * @param {*} other The other value to compare.
     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
     * @example
     *
     * var object = { 'a': 1 };
     * var other = { 'a': 1 };
     *
     * _.eq(object, object);
     * // => true
     *
     * _.eq(object, other);
     * // => false
     *
     * _.eq('a', 'a');
     * // => true
     *
     * _.eq('a', Object('a'));
     * // => false
     *
     * _.eq(NaN, NaN);
     * // => true
     */
    function eq(value, other) {
      return value === other || (value !== value && other !== other);
    }

    /**
     * Checks if `value` is greater than `other`.
     *
     * @static
     * @memberOf _
     * @since 3.9.0
     * @category Lang
     * @param {*} value The value to compare.
     * @param {*} other The other value to compare.
     * @returns {boolean} Returns `true` if `value` is greater than `other`,
     *  else `false`.
     * @see _.lt
     * @example
     *
     * _.gt(3, 1);
     * // => true
     *
     * _.gt(3, 3);
     * // => false
     *
     * _.gt(1, 3);
     * // => false
     */
    var gt = createRelationalOperation(baseGt);

    /**
     * Checks if `value` is greater than or equal to `other`.
     *
     * @static
     * @memberOf _
     * @since 3.9.0
     * @category Lang
     * @param {*} value The value to compare.
     * @param {*} other The other value to compare.
     * @returns {boolean} Returns `true` if `value` is greater than or equal to
     *  `other`, else `false`.
     * @see _.lte
     * @example
     *
     * _.gte(3, 1);
     * // => true
     *
     * _.gte(3, 3);
     * // => true
     *
     * _.gte(1, 3);
     * // => false
     */
    var gte = createRelationalOperation(function(value, other) {
      return value >= other;
    });

    /**
     * Checks if `value` is likely an `arguments` object.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is an `arguments` object,
     *  else `false`.
     * @example
     *
     * _.isArguments(function() { return arguments; }());
     * // => true
     *
     * _.isArguments([1, 2, 3]);
     * // => false
     */
    var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {
      return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&
        !propertyIsEnumerable.call(value, 'callee');
    };

    /**
     * Checks if `value` is classified as an `Array` object.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is an array, else `false`.
     * @example
     *
     * _.isArray([1, 2, 3]);
     * // => true
     *
     * _.isArray(document.body.children);
     * // => false
     *
     * _.isArray('abc');
     * // => false
     *
     * _.isArray(_.noop);
     * // => false
     */
    var isArray = Array.isArray;

    /**
     * Checks if `value` is classified as an `ArrayBuffer` object.
     *
     * @static
     * @memberOf _
     * @since 4.3.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.
     * @example
     *
     * _.isArrayBuffer(new ArrayBuffer(2));
     * // => true
     *
     * _.isArrayBuffer(new Array(2));
     * // => false
     */
    var isArrayBuffer = nodeIsArrayBuffer ? baseUnary(nodeIsArrayBuffer) : baseIsArrayBuffer;

    /**
     * Checks if `value` is array-like. A value is considered array-like if it's
     * not a function and has a `value.length` that's an integer greater than or
     * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
     * @example
     *
     * _.isArrayLike([1, 2, 3]);
     * // => true
     *
     * _.isArrayLike(document.body.children);
     * // => true
     *
     * _.isArrayLike('abc');
     * // => true
     *
     * _.isArrayLike(_.noop);
     * // => false
     */
    function isArrayLike(value) {
      return value != null && isLength(value.length) && !isFunction(value);
    }

    /**
     * This method is like `_.isArrayLike` except that it also checks if `value`
     * is an object.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is an array-like object,
     *  else `false`.
     * @example
     *
     * _.isArrayLikeObject([1, 2, 3]);
     * // => true
     *
     * _.isArrayLikeObject(document.body.children);
     * // => true
     *
     * _.isArrayLikeObject('abc');
     * // => false
     *
     * _.isArrayLikeObject(_.noop);
     * // => false
     */
    function isArrayLikeObject(value) {
      return isObjectLike(value) && isArrayLike(value);
    }

    /**
     * Checks if `value` is classified as a boolean primitive or object.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a boolean, else `false`.
     * @example
     *
     * _.isBoolean(false);
     * // => true
     *
     * _.isBoolean(null);
     * // => false
     */
    function isBoolean(value) {
      return value === true || value === false ||
        (isObjectLike(value) && baseGetTag(value) == boolTag);
    }

    /**
     * Checks if `value` is a buffer.
     *
     * @static
     * @memberOf _
     * @since 4.3.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
     * @example
     *
     * _.isBuffer(new Buffer(2));
     * // => true
     *
     * _.isBuffer(new Uint8Array(2));
     * // => false
     */
    var isBuffer = nativeIsBuffer || stubFalse;

    /**
     * Checks if `value` is classified as a `Date` object.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a date object, else `false`.
     * @example
     *
     * _.isDate(new Date);
     * // => true
     *
     * _.isDate('Mon April 23 2012');
     * // => false
     */
    var isDate = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate;

    /**
     * Checks if `value` is likely a DOM element.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a DOM element, else `false`.
     * @example
     *
     * _.isElement(document.body);
     * // => true
     *
     * _.isElement('<body>');
     * // => false
     */
    function isElement(value) {
      return isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value);
    }

    /**
     * Checks if `value` is an empty object, collection, map, or set.
     *
     * Objects are considered empty if they have no own enumerable string keyed
     * properties.
     *
     * Array-like values such as `arguments` objects, arrays, buffers, strings, or
     * jQuery-like collections are considered empty if they have a `length` of `0`.
     * Similarly, maps and sets are considered empty if they have a `size` of `0`.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is empty, else `false`.
     * @example
     *
     * _.isEmpty(null);
     * // => true
     *
     * _.isEmpty(true);
     * // => true
     *
     * _.isEmpty(1);
     * // => true
     *
     * _.isEmpty([1, 2, 3]);
     * // => false
     *
     * _.isEmpty({ 'a': 1 });
     * // => false
     */
    function isEmpty(value) {
      if (value == null) {
        return true;
      }
      if (isArrayLike(value) &&
          (isArray(value) || typeof value == 'string' || typeof value.splice == 'function' ||
            isBuffer(value) || isTypedArray(value) || isArguments(value))) {
        return !value.length;
      }
      var tag = getTag(value);
      if (tag == mapTag || tag == setTag) {
        return !value.size;
      }
      if (isPrototype(value)) {
        return !baseKeys(value).length;
      }
      for (var key in value) {
        if (hasOwnProperty.call(value, key)) {
          return false;
        }
      }
      return true;
    }

    /**
     * Performs a deep comparison between two values to determine if they are
     * equivalent.
     *
     * **Note:** This method supports comparing arrays, array buffers, booleans,
     * date objects, error objects, maps, numbers, `Object` objects, regexes,
     * sets, strings, symbols, and typed arrays. `Object` objects are compared
     * by their own, not inherited, enumerable properties. Functions and DOM
     * nodes are compared by strict equality, i.e. `===`.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Lang
     * @param {*} value The value to compare.
     * @param {*} other The other value to compare.
     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
     * @example
     *
     * var object = { 'a': 1 };
     * var other = { 'a': 1 };
     *
     * _.isEqual(object, other);
     * // => true
     *
     * object === other;
     * // => false
     */
    function isEqual(value, other) {
      return baseIsEqual(value, other);
    }

    /**
     * This method is like `_.isEqual` except that it accepts `customizer` which
     * is invoked to compare values. If `customizer` returns `undefined`, comparisons
     * are handled by the method instead. The `customizer` is invoked with up to
     * six arguments: (objValue, othValue [, index|key, object, other, stack]).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to compare.
     * @param {*} other The other value to compare.
     * @param {Function} [customizer] The function to customize comparisons.
     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
     * @example
     *
     * function isGreeting(value) {
     *   return /^h(?:i|ello)$/.test(value);
     * }
     *
     * function customizer(objValue, othValue) {
     *   if (isGreeting(objValue) && isGreeting(othValue)) {
     *     return true;
     *   }
     * }
     *
     * var array = ['hello', 'goodbye'];
     * var other = ['hi', 'goodbye'];
     *
     * _.isEqualWith(array, other, customizer);
     * // => true
     */
    function isEqualWith(value, other, customizer) {
      customizer = typeof customizer == 'function' ? customizer : undefined;
      var result = customizer ? customizer(value, other) : undefined;
      return result === undefined ? baseIsEqual(value, other, undefined, customizer) : !!result;
    }

    /**
     * Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`,
     * `SyntaxError`, `TypeError`, or `URIError` object.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is an error object, else `false`.
     * @example
     *
     * _.isError(new Error);
     * // => true
     *
     * _.isError(Error);
     * // => false
     */
    function isError(value) {
      if (!isObjectLike(value)) {
        return false;
      }
      var tag = baseGetTag(value);
      return tag == errorTag || tag == domExcTag ||
        (typeof value.message == 'string' && typeof value.name == 'string' && !isPlainObject(value));
    }

    /**
     * Checks if `value` is a finite primitive number.
     *
     * **Note:** This method is based on
     * [`Number.isFinite`](https://mdn.io/Number/isFinite).
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a finite number, else `false`.
     * @example
     *
     * _.isFinite(3);
     * // => true
     *
     * _.isFinite(Number.MIN_VALUE);
     * // => true
     *
     * _.isFinite(Infinity);
     * // => false
     *
     * _.isFinite('3');
     * // => false
     */
    function isFinite(value) {
      return typeof value == 'number' && nativeIsFinite(value);
    }

    /**
     * Checks if `value` is classified as a `Function` object.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a function, else `false`.
     * @example
     *
     * _.isFunction(_);
     * // => true
     *
     * _.isFunction(/abc/);
     * // => false
     */
    function isFunction(value) {
      if (!isObject(value)) {
        return false;
      }
      // The use of `Object#toString` avoids issues with the `typeof` operator
      // in Safari 9 which returns 'object' for typed arrays and other constructors.
      var tag = baseGetTag(value);
      return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
    }

    /**
     * Checks if `value` is an integer.
     *
     * **Note:** This method is based on
     * [`Number.isInteger`](https://mdn.io/Number/isInteger).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is an integer, else `false`.
     * @example
     *
     * _.isInteger(3);
     * // => true
     *
     * _.isInteger(Number.MIN_VALUE);
     * // => false
     *
     * _.isInteger(Infinity);
     * // => false
     *
     * _.isInteger('3');
     * // => false
     */
    function isInteger(value) {
      return typeof value == 'number' && value == toInteger(value);
    }

    /**
     * Checks if `value` is a valid array-like length.
     *
     * **Note:** This method is loosely based on
     * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
     * @example
     *
     * _.isLength(3);
     * // => true
     *
     * _.isLength(Number.MIN_VALUE);
     * // => false
     *
     * _.isLength(Infinity);
     * // => false
     *
     * _.isLength('3');
     * // => false
     */
    function isLength(value) {
      return typeof value == 'number' &&
        value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
    }

    /**
     * Checks if `value` is the
     * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
     * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is an object, else `false`.
     * @example
     *
     * _.isObject({});
     * // => true
     *
     * _.isObject([1, 2, 3]);
     * // => true
     *
     * _.isObject(_.noop);
     * // => true
     *
     * _.isObject(null);
     * // => false
     */
    function isObject(value) {
      var type = typeof value;
      return value != null && (type == 'object' || type == 'function');
    }

    /**
     * Checks if `value` is object-like. A value is object-like if it's not `null`
     * and has a `typeof` result of "object".
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
     * @example
     *
     * _.isObjectLike({});
     * // => true
     *
     * _.isObjectLike([1, 2, 3]);
     * // => true
     *
     * _.isObjectLike(_.noop);
     * // => false
     *
     * _.isObjectLike(null);
     * // => false
     */
    function isObjectLike(value) {
      return value != null && typeof value == 'object';
    }

    /**
     * Checks if `value` is classified as a `Map` object.
     *
     * @static
     * @memberOf _
     * @since 4.3.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a map, else `false`.
     * @example
     *
     * _.isMap(new Map);
     * // => true
     *
     * _.isMap(new WeakMap);
     * // => false
     */
    var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;

    /**
     * Performs a partial deep comparison between `object` and `source` to
     * determine if `object` contains equivalent property values.
     *
     * **Note:** This method is equivalent to `_.matches` when `source` is
     * partially applied.
     *
     * Partial comparisons will match empty array and empty object `source`
     * values against any array or object value, respectively. See `_.isEqual`
     * for a list of supported value comparisons.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Lang
     * @param {Object} object The object to inspect.
     * @param {Object} source The object of property values to match.
     * @returns {boolean} Returns `true` if `object` is a match, else `false`.
     * @example
     *
     * var object = { 'a': 1, 'b': 2 };
     *
     * _.isMatch(object, { 'b': 2 });
     * // => true
     *
     * _.isMatch(object, { 'b': 1 });
     * // => false
     */
    function isMatch(object, source) {
      return object === source || baseIsMatch(object, source, getMatchData(source));
    }

    /**
     * This method is like `_.isMatch` except that it accepts `customizer` which
     * is invoked to compare values. If `customizer` returns `undefined`, comparisons
     * are handled by the method instead. The `customizer` is invoked with five
     * arguments: (objValue, srcValue, index|key, object, source).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {Object} object The object to inspect.
     * @param {Object} source The object of property values to match.
     * @param {Function} [customizer] The function to customize comparisons.
     * @returns {boolean} Returns `true` if `object` is a match, else `false`.
     * @example
     *
     * function isGreeting(value) {
     *   return /^h(?:i|ello)$/.test(value);
     * }
     *
     * function customizer(objValue, srcValue) {
     *   if (isGreeting(objValue) && isGreeting(srcValue)) {
     *     return true;
     *   }
     * }
     *
     * var object = { 'greeting': 'hello' };
     * var source = { 'greeting': 'hi' };
     *
     * _.isMatchWith(object, source, customizer);
     * // => true
     */
    function isMatchWith(object, source, customizer) {
      customizer = typeof customizer == 'function' ? customizer : undefined;
      return baseIsMatch(object, source, getMatchData(source), customizer);
    }

    /**
     * Checks if `value` is `NaN`.
     *
     * **Note:** This method is based on
     * [`Number.isNaN`](https://mdn.io/Number/isNaN) and is not the same as
     * global [`isNaN`](https://mdn.io/isNaN) which returns `true` for
     * `undefined` and other non-number values.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
     * @example
     *
     * _.isNaN(NaN);
     * // => true
     *
     * _.isNaN(new Number(NaN));
     * // => true
     *
     * isNaN(undefined);
     * // => true
     *
     * _.isNaN(undefined);
     * // => false
     */
    function isNaN(value) {
      // An `NaN` primitive is the only value that is not equal to itself.
      // Perform the `toStringTag` check first to avoid errors with some
      // ActiveX objects in IE.
      return isNumber(value) && value != +value;
    }

    /**
     * Checks if `value` is a pristine native function.
     *
     * **Note:** This method can't reliably detect native functions in the presence
     * of the core-js package because core-js circumvents this kind of detection.
     * Despite multiple requests, the core-js maintainer has made it clear: any
     * attempt to fix the detection will be obstructed. As a result, we're left
     * with little choice but to throw an error. Unfortunately, this also affects
     * packages, like [babel-polyfill](https://www.npmjs.com/package/babel-polyfill),
     * which rely on core-js.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a native function,
     *  else `false`.
     * @example
     *
     * _.isNative(Array.prototype.push);
     * // => true
     *
     * _.isNative(_);
     * // => false
     */
    function isNative(value) {
      if (isMaskable(value)) {
        throw new Error(CORE_ERROR_TEXT);
      }
      return baseIsNative(value);
    }

    /**
     * Checks if `value` is `null`.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is `null`, else `false`.
     * @example
     *
     * _.isNull(null);
     * // => true
     *
     * _.isNull(void 0);
     * // => false
     */
    function isNull(value) {
      return value === null;
    }

    /**
     * Checks if `value` is `null` or `undefined`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is nullish, else `false`.
     * @example
     *
     * _.isNil(null);
     * // => true
     *
     * _.isNil(void 0);
     * // => true
     *
     * _.isNil(NaN);
     * // => false
     */
    function isNil(value) {
      return value == null;
    }

    /**
     * Checks if `value` is classified as a `Number` primitive or object.
     *
     * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are
     * classified as numbers, use the `_.isFinite` method.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a number, else `false`.
     * @example
     *
     * _.isNumber(3);
     * // => true
     *
     * _.isNumber(Number.MIN_VALUE);
     * // => true
     *
     * _.isNumber(Infinity);
     * // => true
     *
     * _.isNumber('3');
     * // => false
     */
    function isNumber(value) {
      return typeof value == 'number' ||
        (isObjectLike(value) && baseGetTag(value) == numberTag);
    }

    /**
     * Checks if `value` is a plain object, that is, an object created by the
     * `Object` constructor or one with a `[[Prototype]]` of `null`.
     *
     * @static
     * @memberOf _
     * @since 0.8.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
     * @example
     *
     * function Foo() {
     *   this.a = 1;
     * }
     *
     * _.isPlainObject(new Foo);
     * // => false
     *
     * _.isPlainObject([1, 2, 3]);
     * // => false
     *
     * _.isPlainObject({ 'x': 0, 'y': 0 });
     * // => true
     *
     * _.isPlainObject(Object.create(null));
     * // => true
     */
    function isPlainObject(value) {
      if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
        return false;
      }
      var proto = getPrototype(value);
      if (proto === null) {
        return true;
      }
      var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;
      return typeof Ctor == 'function' && Ctor instanceof Ctor &&
        funcToString.call(Ctor) == objectCtorString;
    }

    /**
     * Checks if `value` is classified as a `RegExp` object.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.
     * @example
     *
     * _.isRegExp(/abc/);
     * // => true
     *
     * _.isRegExp('/abc/');
     * // => false
     */
    var isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp;

    /**
     * Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754
     * double precision number which isn't the result of a rounded unsafe integer.
     *
     * **Note:** This method is based on
     * [`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a safe integer, else `false`.
     * @example
     *
     * _.isSafeInteger(3);
     * // => true
     *
     * _.isSafeInteger(Number.MIN_VALUE);
     * // => false
     *
     * _.isSafeInteger(Infinity);
     * // => false
     *
     * _.isSafeInteger('3');
     * // => false
     */
    function isSafeInteger(value) {
      return isInteger(value) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER;
    }

    /**
     * Checks if `value` is classified as a `Set` object.
     *
     * @static
     * @memberOf _
     * @since 4.3.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a set, else `false`.
     * @example
     *
     * _.isSet(new Set);
     * // => true
     *
     * _.isSet(new WeakSet);
     * // => false
     */
    var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;

    /**
     * Checks if `value` is classified as a `String` primitive or object.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a string, else `false`.
     * @example
     *
     * _.isString('abc');
     * // => true
     *
     * _.isString(1);
     * // => false
     */
    function isString(value) {
      return typeof value == 'string' ||
        (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag);
    }

    /**
     * Checks if `value` is classified as a `Symbol` primitive or object.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
     * @example
     *
     * _.isSymbol(Symbol.iterator);
     * // => true
     *
     * _.isSymbol('abc');
     * // => false
     */
    function isSymbol(value) {
      return typeof value == 'symbol' ||
        (isObjectLike(value) && baseGetTag(value) == symbolTag);
    }

    /**
     * Checks if `value` is classified as a typed array.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
     * @example
     *
     * _.isTypedArray(new Uint8Array);
     * // => true
     *
     * _.isTypedArray([]);
     * // => false
     */
    var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;

    /**
     * Checks if `value` is `undefined`.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`.
     * @example
     *
     * _.isUndefined(void 0);
     * // => true
     *
     * _.isUndefined(null);
     * // => false
     */
    function isUndefined(value) {
      return value === undefined;
    }

    /**
     * Checks if `value` is classified as a `WeakMap` object.
     *
     * @static
     * @memberOf _
     * @since 4.3.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a weak map, else `false`.
     * @example
     *
     * _.isWeakMap(new WeakMap);
     * // => true
     *
     * _.isWeakMap(new Map);
     * // => false
     */
    function isWeakMap(value) {
      return isObjectLike(value) && getTag(value) == weakMapTag;
    }

    /**
     * Checks if `value` is classified as a `WeakSet` object.
     *
     * @static
     * @memberOf _
     * @since 4.3.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a weak set, else `false`.
     * @example
     *
     * _.isWeakSet(new WeakSet);
     * // => true
     *
     * _.isWeakSet(new Set);
     * // => false
     */
    function isWeakSet(value) {
      return isObjectLike(value) && baseGetTag(value) == weakSetTag;
    }

    /**
     * Checks if `value` is less than `other`.
     *
     * @static
     * @memberOf _
     * @since 3.9.0
     * @category Lang
     * @param {*} value The value to compare.
     * @param {*} other The other value to compare.
     * @returns {boolean} Returns `true` if `value` is less than `other`,
     *  else `false`.
     * @see _.gt
     * @example
     *
     * _.lt(1, 3);
     * // => true
     *
     * _.lt(3, 3);
     * // => false
     *
     * _.lt(3, 1);
     * // => false
     */
    var lt = createRelationalOperation(baseLt);

    /**
     * Checks if `value` is less than or equal to `other`.
     *
     * @static
     * @memberOf _
     * @since 3.9.0
     * @category Lang
     * @param {*} value The value to compare.
     * @param {*} other The other value to compare.
     * @returns {boolean} Returns `true` if `value` is less than or equal to
     *  `other`, else `false`.
     * @see _.gte
     * @example
     *
     * _.lte(1, 3);
     * // => true
     *
     * _.lte(3, 3);
     * // => true
     *
     * _.lte(3, 1);
     * // => false
     */
    var lte = createRelationalOperation(function(value, other) {
      return value <= other;
    });

    /**
     * Converts `value` to an array.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Lang
     * @param {*} value The value to convert.
     * @returns {Array} Returns the converted array.
     * @example
     *
     * _.toArray({ 'a': 1, 'b': 2 });
     * // => [1, 2]
     *
     * _.toArray('abc');
     * // => ['a', 'b', 'c']
     *
     * _.toArray(1);
     * // => []
     *
     * _.toArray(null);
     * // => []
     */
    function toArray(value) {
      if (!value) {
        return [];
      }
      if (isArrayLike(value)) {
        return isString(value) ? stringToArray(value) : copyArray(value);
      }
      if (symIterator && value[symIterator]) {
        return iteratorToArray(value[symIterator]());
      }
      var tag = getTag(value),
          func = tag == mapTag ? mapToArray : (tag == setTag ? setToArray : values);

      return func(value);
    }

    /**
     * Converts `value` to a finite number.
     *
     * @static
     * @memberOf _
     * @since 4.12.0
     * @category Lang
     * @param {*} value The value to convert.
     * @returns {number} Returns the converted number.
     * @example
     *
     * _.toFinite(3.2);
     * // => 3.2
     *
     * _.toFinite(Number.MIN_VALUE);
     * // => 5e-324
     *
     * _.toFinite(Infinity);
     * // => 1.7976931348623157e+308
     *
     * _.toFinite('3.2');
     * // => 3.2
     */
    function toFinite(value) {
      if (!value) {
        return value === 0 ? value : 0;
      }
      value = toNumber(value);
      if (value === INFINITY || value === -INFINITY) {
        var sign = (value < 0 ? -1 : 1);
        return sign * MAX_INTEGER;
      }
      return value === value ? value : 0;
    }

    /**
     * Converts `value` to an integer.
     *
     * **Note:** This method is loosely based on
     * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to convert.
     * @returns {number} Returns the converted integer.
     * @example
     *
     * _.toInteger(3.2);
     * // => 3
     *
     * _.toInteger(Number.MIN_VALUE);
     * // => 0
     *
     * _.toInteger(Infinity);
     * // => 1.7976931348623157e+308
     *
     * _.toInteger('3.2');
     * // => 3
     */
    function toInteger(value) {
      var result = toFinite(value),
          remainder = result % 1;

      return result === result ? (remainder ? result - remainder : result) : 0;
    }

    /**
     * Converts `value` to an integer suitable for use as the length of an
     * array-like object.
     *
     * **Note:** This method is based on
     * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to convert.
     * @returns {number} Returns the converted integer.
     * @example
     *
     * _.toLength(3.2);
     * // => 3
     *
     * _.toLength(Number.MIN_VALUE);
     * // => 0
     *
     * _.toLength(Infinity);
     * // => 4294967295
     *
     * _.toLength('3.2');
     * // => 3
     */
    function toLength(value) {
      return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH) : 0;
    }

    /**
     * Converts `value` to a number.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to process.
     * @returns {number} Returns the number.
     * @example
     *
     * _.toNumber(3.2);
     * // => 3.2
     *
     * _.toNumber(Number.MIN_VALUE);
     * // => 5e-324
     *
     * _.toNumber(Infinity);
     * // => Infinity
     *
     * _.toNumber('3.2');
     * // => 3.2
     */
    function toNumber(value) {
      if (typeof value == 'number') {
        return value;
      }
      if (isSymbol(value)) {
        return NAN;
      }
      if (isObject(value)) {
        var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
        value = isObject(other) ? (other + '') : other;
      }
      if (typeof value != 'string') {
        return value === 0 ? value : +value;
      }
      value = value.replace(reTrim, '');
      var isBinary = reIsBinary.test(value);
      return (isBinary || reIsOctal.test(value))
        ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
        : (reIsBadHex.test(value) ? NAN : +value);
    }

    /**
     * Converts `value` to a plain object flattening inherited enumerable string
     * keyed properties of `value` to own properties of the plain object.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Lang
     * @param {*} value The value to convert.
     * @returns {Object} Returns the converted plain object.
     * @example
     *
     * function Foo() {
     *   this.b = 2;
     * }
     *
     * Foo.prototype.c = 3;
     *
     * _.assign({ 'a': 1 }, new Foo);
     * // => { 'a': 1, 'b': 2 }
     *
     * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));
     * // => { 'a': 1, 'b': 2, 'c': 3 }
     */
    function toPlainObject(value) {
      return copyObject(value, keysIn(value));
    }

    /**
     * Converts `value` to a safe integer. A safe integer can be compared and
     * represented correctly.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to convert.
     * @returns {number} Returns the converted integer.
     * @example
     *
     * _.toSafeInteger(3.2);
     * // => 3
     *
     * _.toSafeInteger(Number.MIN_VALUE);
     * // => 0
     *
     * _.toSafeInteger(Infinity);
     * // => 9007199254740991
     *
     * _.toSafeInteger('3.2');
     * // => 3
     */
    function toSafeInteger(value) {
      return value
        ? baseClamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER)
        : (value === 0 ? value : 0);
    }

    /**
     * Converts `value` to a string. An empty string is returned for `null`
     * and `undefined` values. The sign of `-0` is preserved.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to convert.
     * @returns {string} Returns the converted string.
     * @example
     *
     * _.toString(null);
     * // => ''
     *
     * _.toString(-0);
     * // => '-0'
     *
     * _.toString([1, 2, 3]);
     * // => '1,2,3'
     */
    function toString(value) {
      return value == null ? '' : baseToString(value);
    }

    /*------------------------------------------------------------------------*/

    /**
     * Assigns own enumerable string keyed properties of source objects to the
     * destination object. Source objects are applied from left to right.
     * Subsequent sources overwrite property assignments of previous sources.
     *
     * **Note:** This method mutates `object` and is loosely based on
     * [`Object.assign`](https://mdn.io/Object/assign).
     *
     * @static
     * @memberOf _
     * @since 0.10.0
     * @category Object
     * @param {Object} object The destination object.
     * @param {...Object} [sources] The source objects.
     * @returns {Object} Returns `object`.
     * @see _.assignIn
     * @example
     *
     * function Foo() {
     *   this.a = 1;
     * }
     *
     * function Bar() {
     *   this.c = 3;
     * }
     *
     * Foo.prototype.b = 2;
     * Bar.prototype.d = 4;
     *
     * _.assign({ 'a': 0 }, new Foo, new Bar);
     * // => { 'a': 1, 'c': 3 }
     */
    var assign = createAssigner(function(object, source) {
      if (isPrototype(source) || isArrayLike(source)) {
        copyObject(source, keys(source), object);
        return;
      }
      for (var key in source) {
        if (hasOwnProperty.call(source, key)) {
          assignValue(object, key, source[key]);
        }
      }
    });

    /**
     * This method is like `_.assign` except that it iterates over own and
     * inherited source properties.
     *
     * **Note:** This method mutates `object`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @alias extend
     * @category Object
     * @param {Object} object The destination object.
     * @param {...Object} [sources] The source objects.
     * @returns {Object} Returns `object`.
     * @see _.assign
     * @example
     *
     * function Foo() {
     *   this.a = 1;
     * }
     *
     * function Bar() {
     *   this.c = 3;
     * }
     *
     * Foo.prototype.b = 2;
     * Bar.prototype.d = 4;
     *
     * _.assignIn({ 'a': 0 }, new Foo, new Bar);
     * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 }
     */
    var assignIn = createAssigner(function(object, source) {
      copyObject(source, keysIn(source), object);
    });

    /**
     * This method is like `_.assignIn` except that it accepts `customizer`
     * which is invoked to produce the assigned values. If `customizer` returns
     * `undefined`, assignment is handled by the method instead. The `customizer`
     * is invoked with five arguments: (objValue, srcValue, key, object, source).
     *
     * **Note:** This method mutates `object`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @alias extendWith
     * @category Object
     * @param {Object} object The destination object.
     * @param {...Object} sources The source objects.
     * @param {Function} [customizer] The function to customize assigned values.
     * @returns {Object} Returns `object`.
     * @see _.assignWith
     * @example
     *
     * function customizer(objValue, srcValue) {
     *   return _.isUndefined(objValue) ? srcValue : objValue;
     * }
     *
     * var defaults = _.partialRight(_.assignInWith, customizer);
     *
     * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
     * // => { 'a': 1, 'b': 2 }
     */
    var assignInWith = createAssigner(function(object, source, srcIndex, customizer) {
      copyObject(source, keysIn(source), object, customizer);
    });

    /**
     * This method is like `_.assign` except that it accepts `customizer`
     * which is invoked to produce the assigned values. If `customizer` returns
     * `undefined`, assignment is handled by the method instead. The `customizer`
     * is invoked with five arguments: (objValue, srcValue, key, object, source).
     *
     * **Note:** This method mutates `object`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Object
     * @param {Object} object The destination object.
     * @param {...Object} sources The source objects.
     * @param {Function} [customizer] The function to customize assigned values.
     * @returns {Object} Returns `object`.
     * @see _.assignInWith
     * @example
     *
     * function customizer(objValue, srcValue) {
     *   return _.isUndefined(objValue) ? srcValue : objValue;
     * }
     *
     * var defaults = _.partialRight(_.assignWith, customizer);
     *
     * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
     * // => { 'a': 1, 'b': 2 }
     */
    var assignWith = createAssigner(function(object, source, srcIndex, customizer) {
      copyObject(source, keys(source), object, customizer);
    });

    /**
     * Creates an array of values corresponding to `paths` of `object`.
     *
     * @static
     * @memberOf _
     * @since 1.0.0
     * @category Object
     * @param {Object} object The object to iterate over.
     * @param {...(string|string[])} [paths] The property paths to pick.
     * @returns {Array} Returns the picked values.
     * @example
     *
     * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };
     *
     * _.at(object, ['a[0].b.c', 'a[1]']);
     * // => [3, 4]
     */
    var at = flatRest(baseAt);

    /**
     * Creates an object that inherits from the `prototype` object. If a
     * `properties` object is given, its own enumerable string keyed properties
     * are assigned to the created object.
     *
     * @static
     * @memberOf _
     * @since 2.3.0
     * @category Object
     * @param {Object} prototype The object to inherit from.
     * @param {Object} [properties] The properties to assign to the object.
     * @returns {Object} Returns the new object.
     * @example
     *
     * function Shape() {
     *   this.x = 0;
     *   this.y = 0;
     * }
     *
     * function Circle() {
     *   Shape.call(this);
     * }
     *
     * Circle.prototype = _.create(Shape.prototype, {
     *   'constructor': Circle
     * });
     *
     * var circle = new Circle;
     * circle instanceof Circle;
     * // => true
     *
     * circle instanceof Shape;
     * // => true
     */
    function create(prototype, properties) {
      var result = baseCreate(prototype);
      return properties == null ? result : baseAssign(result, properties);
    }

    /**
     * Assigns own and inherited enumerable string keyed properties of source
     * objects to the destination object for all destination properties that
     * resolve to `undefined`. Source objects are applied from left to right.
     * Once a property is set, additional values of the same property are ignored.
     *
     * **Note:** This method mutates `object`.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Object
     * @param {Object} object The destination object.
     * @param {...Object} [sources] The source objects.
     * @returns {Object} Returns `object`.
     * @see _.defaultsDeep
     * @example
     *
     * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
     * // => { 'a': 1, 'b': 2 }
     */
    var defaults = baseRest(function(args) {
      args.push(undefined, customDefaultsAssignIn);
      return apply(assignInWith, undefined, args);
    });

    /**
     * This method is like `_.defaults` except that it recursively assigns
     * default properties.
     *
     * **Note:** This method mutates `object`.
     *
     * @static
     * @memberOf _
     * @since 3.10.0
     * @category Object
     * @param {Object} object The destination object.
     * @param {...Object} [sources] The source objects.
     * @returns {Object} Returns `object`.
     * @see _.defaults
     * @example
     *
     * _.defaultsDeep({ 'a': { 'b': 2 } }, { 'a': { 'b': 1, 'c': 3 } });
     * // => { 'a': { 'b': 2, 'c': 3 } }
     */
    var defaultsDeep = baseRest(function(args) {
      args.push(undefined, customDefaultsMerge);
      return apply(mergeWith, undefined, args);
    });

    /**
     * This method is like `_.find` except that it returns the key of the first
     * element `predicate` returns truthy for instead of the element itself.
     *
     * @static
     * @memberOf _
     * @since 1.1.0
     * @category Object
     * @param {Object} object The object to inspect.
     * @param {Function} [predicate=_.identity] The function invoked per iteration.
     * @returns {string|undefined} Returns the key of the matched element,
     *  else `undefined`.
     * @example
     *
     * var users = {
     *   'barney':  { 'age': 36, 'active': true },
     *   'fred':    { 'age': 40, 'active': false },
     *   'pebbles': { 'age': 1,  'active': true }
     * };
     *
     * _.findKey(users, function(o) { return o.age < 40; });
     * // => 'barney' (iteration order is not guaranteed)
     *
     * // The `_.matches` iteratee shorthand.
     * _.findKey(users, { 'age': 1, 'active': true });
     * // => 'pebbles'
     *
     * // The `_.matchesProperty` iteratee shorthand.
     * _.findKey(users, ['active', false]);
     * // => 'fred'
     *
     * // The `_.property` iteratee shorthand.
     * _.findKey(users, 'active');
     * // => 'barney'
     */
    function findKey(object, predicate) {
      return baseFindKey(object, getIteratee(predicate, 3), baseForOwn);
    }

    /**
     * This method is like `_.findKey` except that it iterates over elements of
     * a collection in the opposite order.
     *
     * @static
     * @memberOf _
     * @since 2.0.0
     * @category Object
     * @param {Object} object The object to inspect.
     * @param {Function} [predicate=_.identity] The function invoked per iteration.
     * @returns {string|undefined} Returns the key of the matched element,
     *  else `undefined`.
     * @example
     *
     * var users = {
     *   'barney':  { 'age': 36, 'active': true },
     *   'fred':    { 'age': 40, 'active': false },
     *   'pebbles': { 'age': 1,  'active': true }
     * };
     *
     * _.findLastKey(users, function(o) { return o.age < 40; });
     * // => returns 'pebbles' assuming `_.findKey` returns 'barney'
     *
     * // The `_.matches` iteratee shorthand.
     * _.findLastKey(users, { 'age': 36, 'active': true });
     * // => 'barney'
     *
     * // The `_.matchesProperty` iteratee shorthand.
     * _.findLastKey(users, ['active', false]);
     * // => 'fred'
     *
     * // The `_.property` iteratee shorthand.
     * _.findLastKey(users, 'active');
     * // => 'pebbles'
     */
    function findLastKey(object, predicate) {
      return baseFindKey(object, getIteratee(predicate, 3), baseForOwnRight);
    }

    /**
     * Iterates over own and inherited enumerable string keyed properties of an
     * object and invokes `iteratee` for each property. The iteratee is invoked
     * with three arguments: (value, key, object). Iteratee functions may exit
     * iteration early by explicitly returning `false`.
     *
     * @static
     * @memberOf _
     * @since 0.3.0
     * @category Object
     * @param {Object} object The object to iterate over.
     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
     * @returns {Object} Returns `object`.
     * @see _.forInRight
     * @example
     *
     * function Foo() {
     *   this.a = 1;
     *   this.b = 2;
     * }
     *
     * Foo.prototype.c = 3;
     *
     * _.forIn(new Foo, function(value, key) {
     *   console.log(key);
     * });
     * // => Logs 'a', 'b', then 'c' (iteration order is not guaranteed).
     */
    function forIn(object, iteratee) {
      return object == null
        ? object
        : baseFor(object, getIteratee(iteratee, 3), keysIn);
    }

    /**
     * This method is like `_.forIn` except that it iterates over properties of
     * `object` in the opposite order.
     *
     * @static
     * @memberOf _
     * @since 2.0.0
     * @category Object
     * @param {Object} object The object to iterate over.
     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
     * @returns {Object} Returns `object`.
     * @see _.forIn
     * @example
     *
     * function Foo() {
     *   this.a = 1;
     *   this.b = 2;
     * }
     *
     * Foo.prototype.c = 3;
     *
     * _.forInRight(new Foo, function(value, key) {
     *   console.log(key);
     * });
     * // => Logs 'c', 'b', then 'a' assuming `_.forIn` logs 'a', 'b', then 'c'.
     */
    function forInRight(object, iteratee) {
      return object == null
        ? object
        : baseForRight(object, getIteratee(iteratee, 3), keysIn);
    }

    /**
     * Iterates over own enumerable string keyed properties of an object and
     * invokes `iteratee` for each property. The iteratee is invoked with three
     * arguments: (value, key, object). Iteratee functions may exit iteration
     * early by explicitly returning `false`.
     *
     * @static
     * @memberOf _
     * @since 0.3.0
     * @category Object
     * @param {Object} object The object to iterate over.
     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
     * @returns {Object} Returns `object`.
     * @see _.forOwnRight
     * @example
     *
     * function Foo() {
     *   this.a = 1;
     *   this.b = 2;
     * }
     *
     * Foo.prototype.c = 3;
     *
     * _.forOwn(new Foo, function(value, key) {
     *   console.log(key);
     * });
     * // => Logs 'a' then 'b' (iteration order is not guaranteed).
     */
    function forOwn(object, iteratee) {
      return object && baseForOwn(object, getIteratee(iteratee, 3));
    }

    /**
     * This method is like `_.forOwn` except that it iterates over properties of
     * `object` in the opposite order.
     *
     * @static
     * @memberOf _
     * @since 2.0.0
     * @category Object
     * @param {Object} object The object to iterate over.
     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
     * @returns {Object} Returns `object`.
     * @see _.forOwn
     * @example
     *
     * function Foo() {
     *   this.a = 1;
     *   this.b = 2;
     * }
     *
     * Foo.prototype.c = 3;
     *
     * _.forOwnRight(new Foo, function(value, key) {
     *   console.log(key);
     * });
     * // => Logs 'b' then 'a' assuming `_.forOwn` logs 'a' then 'b'.
     */
    function forOwnRight(object, iteratee) {
      return object && baseForOwnRight(object, getIteratee(iteratee, 3));
    }

    /**
     * Creates an array of function property names from own enumerable properties
     * of `object`.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Object
     * @param {Object} object The object to inspect.
     * @returns {Array} Returns the function names.
     * @see _.functionsIn
     * @example
     *
     * function Foo() {
     *   this.a = _.constant('a');
     *   this.b = _.constant('b');
     * }
     *
     * Foo.prototype.c = _.constant('c');
     *
     * _.functions(new Foo);
     * // => ['a', 'b']
     */
    function functions(object) {
      return object == null ? [] : baseFunctions(object, keys(object));
    }

    /**
     * Creates an array of function property names from own and inherited
     * enumerable properties of `object`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Object
     * @param {Object} object The object to inspect.
     * @returns {Array} Returns the function names.
     * @see _.functions
     * @example
     *
     * function Foo() {
     *   this.a = _.constant('a');
     *   this.b = _.constant('b');
     * }
     *
     * Foo.prototype.c = _.constant('c');
     *
     * _.functionsIn(new Foo);
     * // => ['a', 'b', 'c']
     */
    function functionsIn(object) {
      return object == null ? [] : baseFunctions(object, keysIn(object));
    }

    /**
     * Gets the value at `path` of `object`. If the resolved value is
     * `undefined`, the `defaultValue` is returned in its place.
     *
     * @static
     * @memberOf _
     * @since 3.7.0
     * @category Object
     * @param {Object} object The object to query.
     * @param {Array|string} path The path of the property to get.
     * @param {*} [defaultValue] The value returned for `undefined` resolved values.
     * @returns {*} Returns the resolved value.
     * @example
     *
     * var object = { 'a': [{ 'b': { 'c': 3 } }] };
     *
     * _.get(object, 'a[0].b.c');
     * // => 3
     *
     * _.get(object, ['a', '0', 'b', 'c']);
     * // => 3
     *
     * _.get(object, 'a.b.c', 'default');
     * // => 'default'
     */
    function get(object, path, defaultValue) {
      var result = object == null ? undefined : baseGet(object, path);
      return result === undefined ? defaultValue : result;
    }

    /**
     * Checks if `path` is a direct property of `object`.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Object
     * @param {Object} object The object to query.
     * @param {Array|string} path The path to check.
     * @returns {boolean} Returns `true` if `path` exists, else `false`.
     * @example
     *
     * var object = { 'a': { 'b': 2 } };
     * var other = _.create({ 'a': _.create({ 'b': 2 }) });
     *
     * _.has(object, 'a');
     * // => true
     *
     * _.has(object, 'a.b');
     * // => true
     *
     * _.has(object, ['a', 'b']);
     * // => true
     *
     * _.has(other, 'a');
     * // => false
     */
    function has(object, path) {
      return object != null && hasPath(object, path, baseHas);
    }

    /**
     * Checks if `path` is a direct or inherited property of `object`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Object
     * @param {Object} object The object to query.
     * @param {Array|string} path The path to check.
     * @returns {boolean} Returns `true` if `path` exists, else `false`.
     * @example
     *
     * var object = _.create({ 'a': _.create({ 'b': 2 }) });
     *
     * _.hasIn(object, 'a');
     * // => true
     *
     * _.hasIn(object, 'a.b');
     * // => true
     *
     * _.hasIn(object, ['a', 'b']);
     * // => true
     *
     * _.hasIn(object, 'b');
     * // => false
     */
    function hasIn(object, path) {
      return object != null && hasPath(object, path, baseHasIn);
    }

    /**
     * Creates an object composed of the inverted keys and values of `object`.
     * If `object` contains duplicate values, subsequent values overwrite
     * property assignments of previous values.
     *
     * @static
     * @memberOf _
     * @since 0.7.0
     * @category Object
     * @param {Object} object The object to invert.
     * @returns {Object} Returns the new inverted object.
     * @example
     *
     * var object = { 'a': 1, 'b': 2, 'c': 1 };
     *
     * _.invert(object);
     * // => { '1': 'c', '2': 'b' }
     */
    var invert = createInverter(function(result, value, key) {
      result[value] = key;
    }, constant(identity));

    /**
     * This method is like `_.invert` except that the inverted object is generated
     * from the results of running each element of `object` thru `iteratee`. The
     * corresponding inverted value of each inverted key is an array of keys
     * responsible for generating the inverted value. The iteratee is invoked
     * with one argument: (value).
     *
     * @static
     * @memberOf _
     * @since 4.1.0
     * @category Object
     * @param {Object} object The object to invert.
     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
     * @returns {Object} Returns the new inverted object.
     * @example
     *
     * var object = { 'a': 1, 'b': 2, 'c': 1 };
     *
     * _.invertBy(object);
     * // => { '1': ['a', 'c'], '2': ['b'] }
     *
     * _.invertBy(object, function(value) {
     *   return 'group' + value;
     * });
     * // => { 'group1': ['a', 'c'], 'group2': ['b'] }
     */
    var invertBy = createInverter(function(result, value, key) {
      if (hasOwnProperty.call(result, value)) {
        result[value].push(key);
      } else {
        result[value] = [key];
      }
    }, getIteratee);

    /**
     * Invokes the method at `path` of `object`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Object
     * @param {Object} object The object to query.
     * @param {Array|string} path The path of the method to invoke.
     * @param {...*} [args] The arguments to invoke the method with.
     * @returns {*} Returns the result of the invoked method.
     * @example
     *
     * var object = { 'a': [{ 'b': { 'c': [1, 2, 3, 4] } }] };
     *
     * _.invoke(object, 'a[0].b.c.slice', 1, 3);
     * // => [2, 3]
     */
    var invoke = baseRest(baseInvoke);

    /**
     * Creates an array of the own enumerable property names of `object`.
     *
     * **Note:** Non-object values are coerced to objects. See the
     * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
     * for more details.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Object
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of property names.
     * @example
     *
     * function Foo() {
     *   this.a = 1;
     *   this.b = 2;
     * }
     *
     * Foo.prototype.c = 3;
     *
     * _.keys(new Foo);
     * // => ['a', 'b'] (iteration order is not guaranteed)
     *
     * _.keys('hi');
     * // => ['0', '1']
     */
    function keys(object) {
      return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
    }

    /**
     * Creates an array of the own and inherited enumerable property names of `object`.
     *
     * **Note:** Non-object values are coerced to objects.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Object
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of property names.
     * @example
     *
     * function Foo() {
     *   this.a = 1;
     *   this.b = 2;
     * }
     *
     * Foo.prototype.c = 3;
     *
     * _.keysIn(new Foo);
     * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
     */
    function keysIn(object) {
      return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
    }

    /**
     * The opposite of `_.mapValues`; this method creates an object with the
     * same values as `object` and keys generated by running each own enumerable
     * string keyed property of `object` thru `iteratee`. The iteratee is invoked
     * with three arguments: (value, key, object).
     *
     * @static
     * @memberOf _
     * @since 3.8.0
     * @category Object
     * @param {Object} object The object to iterate over.
     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
     * @returns {Object} Returns the new mapped object.
     * @see _.mapValues
     * @example
     *
     * _.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) {
     *   return key + value;
     * });
     * // => { 'a1': 1, 'b2': 2 }
     */
    function mapKeys(object, iteratee) {
      var result = {};
      iteratee = getIteratee(iteratee, 3);

      baseForOwn(object, function(value, key, object) {
        baseAssignValue(result, iteratee(value, key, object), value);
      });
      return result;
    }

    /**
     * Creates an object with the same keys as `object` and values generated
     * by running each own enumerable string keyed property of `object` thru
     * `iteratee`. The iteratee is invoked with three arguments:
     * (value, key, object).
     *
     * @static
     * @memberOf _
     * @since 2.4.0
     * @category Object
     * @param {Object} object The object to iterate over.
     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
     * @returns {Object} Returns the new mapped object.
     * @see _.mapKeys
     * @example
     *
     * var users = {
     *   'fred':    { 'user': 'fred',    'age': 40 },
     *   'pebbles': { 'user': 'pebbles', 'age': 1 }
     * };
     *
     * _.mapValues(users, function(o) { return o.age; });
     * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
     *
     * // The `_.property` iteratee shorthand.
     * _.mapValues(users, 'age');
     * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
     */
    function mapValues(object, iteratee) {
      var result = {};
      iteratee = getIteratee(iteratee, 3);

      baseForOwn(object, function(value, key, object) {
        baseAssignValue(result, key, iteratee(value, key, object));
      });
      return result;
    }

    /**
     * This method is like `_.assign` except that it recursively merges own and
     * inherited enumerable string keyed properties of source objects into the
     * destination object. Source properties that resolve to `undefined` are
     * skipped if a destination value exists. Array and plain object properties
     * are merged recursively. Other objects and value types are overridden by
     * assignment. Source objects are applied from left to right. Subsequent
     * sources overwrite property assignments of previous sources.
     *
     * **Note:** This method mutates `object`.
     *
     * @static
     * @memberOf _
     * @since 0.5.0
     * @category Object
     * @param {Object} object The destination object.
     * @param {...Object} [sources] The source objects.
     * @returns {Object} Returns `object`.
     * @example
     *
     * var object = {
     *   'a': [{ 'b': 2 }, { 'd': 4 }]
     * };
     *
     * var other = {
     *   'a': [{ 'c': 3 }, { 'e': 5 }]
     * };
     *
     * _.merge(object, other);
     * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }
     */
    var merge = createAssigner(function(object, source, srcIndex) {
      baseMerge(object, source, srcIndex);
    });

    /**
     * This method is like `_.merge` except that it accepts `customizer` which
     * is invoked to produce the merged values of the destination and source
     * properties. If `customizer` returns `undefined`, merging is handled by the
     * method instead. The `customizer` is invoked with six arguments:
     * (objValue, srcValue, key, object, source, stack).
     *
     * **Note:** This method mutates `object`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Object
     * @param {Object} object The destination object.
     * @param {...Object} sources The source objects.
     * @param {Function} customizer The function to customize assigned values.
     * @returns {Object} Returns `object`.
     * @example
     *
     * function customizer(objValue, srcValue) {
     *   if (_.isArray(objValue)) {
     *     return objValue.concat(srcValue);
     *   }
     * }
     *
     * var object = { 'a': [1], 'b': [2] };
     * var other = { 'a': [3], 'b': [4] };
     *
     * _.mergeWith(object, other, customizer);
     * // => { 'a': [1, 3], 'b': [2, 4] }
     */
    var mergeWith = createAssigner(function(object, source, srcIndex, customizer) {
      baseMerge(object, source, srcIndex, customizer);
    });

    /**
     * The opposite of `_.pick`; this method creates an object composed of the
     * own and inherited enumerable property paths of `object` that are not omitted.
     *
     * **Note:** This method is considerably slower than `_.pick`.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Object
     * @param {Object} object The source object.
     * @param {...(string|string[])} [paths] The property paths to omit.
     * @returns {Object} Returns the new object.
     * @example
     *
     * var object = { 'a': 1, 'b': '2', 'c': 3 };
     *
     * _.omit(object, ['a', 'c']);
     * // => { 'b': '2' }
     */
    var omit = flatRest(function(object, paths) {
      var result = {};
      if (object == null) {
        return result;
      }
      var isDeep = false;
      paths = arrayMap(paths, function(path) {
        path = castPath(path, object);
        isDeep || (isDeep = path.length > 1);
        return path;
      });
      copyObject(object, getAllKeysIn(object), result);
      if (isDeep) {
        result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);
      }
      var length = paths.length;
      while (length--) {
        baseUnset(result, paths[length]);
      }
      return result;
    });

    /**
     * The opposite of `_.pickBy`; this method creates an object composed of
     * the own and inherited enumerable string keyed properties of `object` that
     * `predicate` doesn't return truthy for. The predicate is invoked with two
     * arguments: (value, key).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Object
     * @param {Object} object The source object.
     * @param {Function} [predicate=_.identity] The function invoked per property.
     * @returns {Object} Returns the new object.
     * @example
     *
     * var object = { 'a': 1, 'b': '2', 'c': 3 };
     *
     * _.omitBy(object, _.isNumber);
     * // => { 'b': '2' }
     */
    function omitBy(object, predicate) {
      return pickBy(object, negate(getIteratee(predicate)));
    }

    /**
     * Creates an object composed of the picked `object` properties.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Object
     * @param {Object} object The source object.
     * @param {...(string|string[])} [paths] The property paths to pick.
     * @returns {Object} Returns the new object.
     * @example
     *
     * var object = { 'a': 1, 'b': '2', 'c': 3 };
     *
     * _.pick(object, ['a', 'c']);
     * // => { 'a': 1, 'c': 3 }
     */
    var pick = flatRest(function(object, paths) {
      return object == null ? {} : basePick(object, paths);
    });

    /**
     * Creates an object composed of the `object` properties `predicate` returns
     * truthy for. The predicate is invoked with two arguments: (value, key).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Object
     * @param {Object} object The source object.
     * @param {Function} [predicate=_.identity] The function invoked per property.
     * @returns {Object} Returns the new object.
     * @example
     *
     * var object = { 'a': 1, 'b': '2', 'c': 3 };
     *
     * _.pickBy(object, _.isNumber);
     * // => { 'a': 1, 'c': 3 }
     */
    function pickBy(object, predicate) {
      if (object == null) {
        return {};
      }
      var props = arrayMap(getAllKeysIn(object), function(prop) {
        return [prop];
      });
      predicate = getIteratee(predicate);
      return basePickBy(object, props, function(value, path) {
        return predicate(value, path[0]);
      });
    }

    /**
     * This method is like `_.get` except that if the resolved value is a
     * function it's invoked with the `this` binding of its parent object and
     * its result is returned.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Object
     * @param {Object} object The object to query.
     * @param {Array|string} path The path of the property to resolve.
     * @param {*} [defaultValue] The value returned for `undefined` resolved values.
     * @returns {*} Returns the resolved value.
     * @example
     *
     * var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] };
     *
     * _.result(object, 'a[0].b.c1');
     * // => 3
     *
     * _.result(object, 'a[0].b.c2');
     * // => 4
     *
     * _.result(object, 'a[0].b.c3', 'default');
     * // => 'default'
     *
     * _.result(object, 'a[0].b.c3', _.constant('default'));
     * // => 'default'
     */
    function result(object, path, defaultValue) {
      path = castPath(path, object);

      var index = -1,
          length = path.length;

      // Ensure the loop is entered when path is empty.
      if (!length) {
        length = 1;
        object = undefined;
      }
      while (++index < length) {
        var value = object == null ? undefined : object[toKey(path[index])];
        if (value === undefined) {
          index = length;
          value = defaultValue;
        }
        object = isFunction(value) ? value.call(object) : value;
      }
      return object;
    }

    /**
     * Sets the value at `path` of `object`. If a portion of `path` doesn't exist,
     * it's created. Arrays are created for missing index properties while objects
     * are created for all other missing properties. Use `_.setWith` to customize
     * `path` creation.
     *
     * **Note:** This method mutates `object`.
     *
     * @static
     * @memberOf _
     * @since 3.7.0
     * @category Object
     * @param {Object} object The object to modify.
     * @param {Array|string} path The path of the property to set.
     * @param {*} value The value to set.
     * @returns {Object} Returns `object`.
     * @example
     *
     * var object = { 'a': [{ 'b': { 'c': 3 } }] };
     *
     * _.set(object, 'a[0].b.c', 4);
     * console.log(object.a[0].b.c);
     * // => 4
     *
     * _.set(object, ['x', '0', 'y', 'z'], 5);
     * console.log(object.x[0].y.z);
     * // => 5
     */
    function set(object, path, value) {
      return object == null ? object : baseSet(object, path, value);
    }

    /**
     * This method is like `_.set` except that it accepts `customizer` which is
     * invoked to produce the objects of `path`.  If `customizer` returns `undefined`
     * path creation is handled by the method instead. The `customizer` is invoked
     * with three arguments: (nsValue, key, nsObject).
     *
     * **Note:** This method mutates `object`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Object
     * @param {Object} object The object to modify.
     * @param {Array|string} path The path of the property to set.
     * @param {*} value The value to set.
     * @param {Function} [customizer] The function to customize assigned values.
     * @returns {Object} Returns `object`.
     * @example
     *
     * var object = {};
     *
     * _.setWith(object, '[0][1]', 'a', Object);
     * // => { '0': { '1': 'a' } }
     */
    function setWith(object, path, value, customizer) {
      customizer = typeof customizer == 'function' ? customizer : undefined;
      return object == null ? object : baseSet(object, path, value, customizer);
    }

    /**
     * Creates an array of own enumerable string keyed-value pairs for `object`
     * which can be consumed by `_.fromPairs`. If `object` is a map or set, its
     * entries are returned.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @alias entries
     * @category Object
     * @param {Object} object The object to query.
     * @returns {Array} Returns the key-value pairs.
     * @example
     *
     * function Foo() {
     *   this.a = 1;
     *   this.b = 2;
     * }
     *
     * Foo.prototype.c = 3;
     *
     * _.toPairs(new Foo);
     * // => [['a', 1], ['b', 2]] (iteration order is not guaranteed)
     */
    var toPairs = createToPairs(keys);

    /**
     * Creates an array of own and inherited enumerable string keyed-value pairs
     * for `object` which can be consumed by `_.fromPairs`. If `object` is a map
     * or set, its entries are returned.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @alias entriesIn
     * @category Object
     * @param {Object} object The object to query.
     * @returns {Array} Returns the key-value pairs.
     * @example
     *
     * function Foo() {
     *   this.a = 1;
     *   this.b = 2;
     * }
     *
     * Foo.prototype.c = 3;
     *
     * _.toPairsIn(new Foo);
     * // => [['a', 1], ['b', 2], ['c', 3]] (iteration order is not guaranteed)
     */
    var toPairsIn = createToPairs(keysIn);

    /**
     * An alternative to `_.reduce`; this method transforms `object` to a new
     * `accumulator` object which is the result of running each of its own
     * enumerable string keyed properties thru `iteratee`, with each invocation
     * potentially mutating the `accumulator` object. If `accumulator` is not
     * provided, a new object with the same `[[Prototype]]` will be used. The
     * iteratee is invoked with four arguments: (accumulator, value, key, object).
     * Iteratee functions may exit iteration early by explicitly returning `false`.
     *
     * @static
     * @memberOf _
     * @since 1.3.0
     * @category Object
     * @param {Object} object The object to iterate over.
     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
     * @param {*} [accumulator] The custom accumulator value.
     * @returns {*} Returns the accumulated value.
     * @example
     *
     * _.transform([2, 3, 4], function(result, n) {
     *   result.push(n *= n);
     *   return n % 2 == 0;
     * }, []);
     * // => [4, 9]
     *
     * _.transform({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {
     *   (result[value] || (result[value] = [])).push(key);
     * }, {});
     * // => { '1': ['a', 'c'], '2': ['b'] }
     */
    function transform(object, iteratee, accumulator) {
      var isArr = isArray(object),
          isArrLike = isArr || isBuffer(object) || isTypedArray(object);

      iteratee = getIteratee(iteratee, 4);
      if (accumulator == null) {
        var Ctor = object && object.constructor;
        if (isArrLike) {
          accumulator = isArr ? new Ctor : [];
        }
        else if (isObject(object)) {
          accumulator = isFunction(Ctor) ? baseCreate(getPrototype(object)) : {};
        }
        else {
          accumulator = {};
        }
      }
      (isArrLike ? arrayEach : baseForOwn)(object, function(value, index, object) {
        return iteratee(accumulator, value, index, object);
      });
      return accumulator;
    }

    /**
     * Removes the property at `path` of `object`.
     *
     * **Note:** This method mutates `object`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Object
     * @param {Object} object The object to modify.
     * @param {Array|string} path The path of the property to unset.
     * @returns {boolean} Returns `true` if the property is deleted, else `false`.
     * @example
     *
     * var object = { 'a': [{ 'b': { 'c': 7 } }] };
     * _.unset(object, 'a[0].b.c');
     * // => true
     *
     * console.log(object);
     * // => { 'a': [{ 'b': {} }] };
     *
     * _.unset(object, ['a', '0', 'b', 'c']);
     * // => true
     *
     * console.log(object);
     * // => { 'a': [{ 'b': {} }] };
     */
    function unset(object, path) {
      return object == null ? true : baseUnset(object, path);
    }

    /**
     * This method is like `_.set` except that accepts `updater` to produce the
     * value to set. Use `_.updateWith` to customize `path` creation. The `updater`
     * is invoked with one argument: (value).
     *
     * **Note:** This method mutates `object`.
     *
     * @static
     * @memberOf _
     * @since 4.6.0
     * @category Object
     * @param {Object} object The object to modify.
     * @param {Array|string} path The path of the property to set.
     * @param {Function} updater The function to produce the updated value.
     * @returns {Object} Returns `object`.
     * @example
     *
     * var object = { 'a': [{ 'b': { 'c': 3 } }] };
     *
     * _.update(object, 'a[0].b.c', function(n) { return n * n; });
     * console.log(object.a[0].b.c);
     * // => 9
     *
     * _.update(object, 'x[0].y.z', function(n) { return n ? n + 1 : 0; });
     * console.log(object.x[0].y.z);
     * // => 0
     */
    function update(object, path, updater) {
      return object == null ? object : baseUpdate(object, path, castFunction(updater));
    }

    /**
     * This method is like `_.update` except that it accepts `customizer` which is
     * invoked to produce the objects of `path`.  If `customizer` returns `undefined`
     * path creation is handled by the method instead. The `customizer` is invoked
     * with three arguments: (nsValue, key, nsObject).
     *
     * **Note:** This method mutates `object`.
     *
     * @static
     * @memberOf _
     * @since 4.6.0
     * @category Object
     * @param {Object} object The object to modify.
     * @param {Array|string} path The path of the property to set.
     * @param {Function} updater The function to produce the updated value.
     * @param {Function} [customizer] The function to customize assigned values.
     * @returns {Object} Returns `object`.
     * @example
     *
     * var object = {};
     *
     * _.updateWith(object, '[0][1]', _.constant('a'), Object);
     * // => { '0': { '1': 'a' } }
     */
    function updateWith(object, path, updater, customizer) {
      customizer = typeof customizer == 'function' ? customizer : undefined;
      return object == null ? object : baseUpdate(object, path, castFunction(updater), customizer);
    }

    /**
     * Creates an array of the own enumerable string keyed property values of `object`.
     *
     * **Note:** Non-object values are coerced to objects.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Object
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of property values.
     * @example
     *
     * function Foo() {
     *   this.a = 1;
     *   this.b = 2;
     * }
     *
     * Foo.prototype.c = 3;
     *
     * _.values(new Foo);
     * // => [1, 2] (iteration order is not guaranteed)
     *
     * _.values('hi');
     * // => ['h', 'i']
     */
    function values(object) {
      return object == null ? [] : baseValues(object, keys(object));
    }

    /**
     * Creates an array of the own and inherited enumerable string keyed property
     * values of `object`.
     *
     * **Note:** Non-object values are coerced to objects.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Object
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of property values.
     * @example
     *
     * function Foo() {
     *   this.a = 1;
     *   this.b = 2;
     * }
     *
     * Foo.prototype.c = 3;
     *
     * _.valuesIn(new Foo);
     * // => [1, 2, 3] (iteration order is not guaranteed)
     */
    function valuesIn(object) {
      return object == null ? [] : baseValues(object, keysIn(object));
    }

    /*------------------------------------------------------------------------*/

    /**
     * Clamps `number` within the inclusive `lower` and `upper` bounds.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Number
     * @param {number} number The number to clamp.
     * @param {number} [lower] The lower bound.
     * @param {number} upper The upper bound.
     * @returns {number} Returns the clamped number.
     * @example
     *
     * _.clamp(-10, -5, 5);
     * // => -5
     *
     * _.clamp(10, -5, 5);
     * // => 5
     */
    function clamp(number, lower, upper) {
      if (upper === undefined) {
        upper = lower;
        lower = undefined;
      }
      if (upper !== undefined) {
        upper = toNumber(upper);
        upper = upper === upper ? upper : 0;
      }
      if (lower !== undefined) {
        lower = toNumber(lower);
        lower = lower === lower ? lower : 0;
      }
      return baseClamp(toNumber(number), lower, upper);
    }

    /**
     * Checks if `n` is between `start` and up to, but not including, `end`. If
     * `end` is not specified, it's set to `start` with `start` then set to `0`.
     * If `start` is greater than `end` the params are swapped to support
     * negative ranges.
     *
     * @static
     * @memberOf _
     * @since 3.3.0
     * @category Number
     * @param {number} number The number to check.
     * @param {number} [start=0] The start of the range.
     * @param {number} end The end of the range.
     * @returns {boolean} Returns `true` if `number` is in the range, else `false`.
     * @see _.range, _.rangeRight
     * @example
     *
     * _.inRange(3, 2, 4);
     * // => true
     *
     * _.inRange(4, 8);
     * // => true
     *
     * _.inRange(4, 2);
     * // => false
     *
     * _.inRange(2, 2);
     * // => false
     *
     * _.inRange(1.2, 2);
     * // => true
     *
     * _.inRange(5.2, 4);
     * // => false
     *
     * _.inRange(-3, -2, -6);
     * // => true
     */
    function inRange(number, start, end) {
      start = toFinite(start);
      if (end === undefined) {
        end = start;
        start = 0;
      } else {
        end = toFinite(end);
      }
      number = toNumber(number);
      return baseInRange(number, start, end);
    }

    /**
     * Produces a random number between the inclusive `lower` and `upper` bounds.
     * If only one argument is provided a number between `0` and the given number
     * is returned. If `floating` is `true`, or either `lower` or `upper` are
     * floats, a floating-point number is returned instead of an integer.
     *
     * **Note:** JavaScript follows the IEEE-754 standard for resolving
     * floating-point values which can produce unexpected results.
     *
     * @static
     * @memberOf _
     * @since 0.7.0
     * @category Number
     * @param {number} [lower=0] The lower bound.
     * @param {number} [upper=1] The upper bound.
     * @param {boolean} [floating] Specify returning a floating-point number.
     * @returns {number} Returns the random number.
     * @example
     *
     * _.random(0, 5);
     * // => an integer between 0 and 5
     *
     * _.random(5);
     * // => also an integer between 0 and 5
     *
     * _.random(5, true);
     * // => a floating-point number between 0 and 5
     *
     * _.random(1.2, 5.2);
     * // => a floating-point number between 1.2 and 5.2
     */
    function random(lower, upper, floating) {
      if (floating && typeof floating != 'boolean' && isIterateeCall(lower, upper, floating)) {
        upper = floating = undefined;
      }
      if (floating === undefined) {
        if (typeof upper == 'boolean') {
          floating = upper;
          upper = undefined;
        }
        else if (typeof lower == 'boolean') {
          floating = lower;
          lower = undefined;
        }
      }
      if (lower === undefined && upper === undefined) {
        lower = 0;
        upper = 1;
      }
      else {
        lower = toFinite(lower);
        if (upper === undefined) {
          upper = lower;
          lower = 0;
        } else {
          upper = toFinite(upper);
        }
      }
      if (lower > upper) {
        var temp = lower;
        lower = upper;
        upper = temp;
      }
      if (floating || lower % 1 || upper % 1) {
        var rand = nativeRandom();
        return nativeMin(lower + (rand * (upper - lower + freeParseFloat('1e-' + ((rand + '').length - 1)))), upper);
      }
      return baseRandom(lower, upper);
    }

    /*------------------------------------------------------------------------*/

    /**
     * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase).
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category String
     * @param {string} [string=''] The string to convert.
     * @returns {string} Returns the camel cased string.
     * @example
     *
     * _.camelCase('Foo Bar');
     * // => 'fooBar'
     *
     * _.camelCase('--foo-bar--');
     * // => 'fooBar'
     *
     * _.camelCase('__FOO_BAR__');
     * // => 'fooBar'
     */
    var camelCase = createCompounder(function(result, word, index) {
      word = word.toLowerCase();
      return result + (index ? capitalize(word) : word);
    });

    /**
     * Converts the first character of `string` to upper case and the remaining
     * to lower case.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category String
     * @param {string} [string=''] The string to capitalize.
     * @returns {string} Returns the capitalized string.
     * @example
     *
     * _.capitalize('FRED');
     * // => 'Fred'
     */
    function capitalize(string) {
      return upperFirst(toString(string).toLowerCase());
    }

    /**
     * Deburrs `string` by converting
     * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)
     * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)
     * letters to basic Latin letters and removing
     * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category String
     * @param {string} [string=''] The string to deburr.
     * @returns {string} Returns the deburred string.
     * @example
     *
     * _.deburr('déjà vu');
     * // => 'deja vu'
     */
    function deburr(string) {
      string = toString(string);
      return string && string.replace(reLatin, deburrLetter).replace(reComboMark, '');
    }

    /**
     * Checks if `string` ends with the given target string.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category String
     * @param {string} [string=''] The string to inspect.
     * @param {string} [target] The string to search for.
     * @param {number} [position=string.length] The position to search up to.
     * @returns {boolean} Returns `true` if `string` ends with `target`,
     *  else `false`.
     * @example
     *
     * _.endsWith('abc', 'c');
     * // => true
     *
     * _.endsWith('abc', 'b');
     * // => false
     *
     * _.endsWith('abc', 'b', 2);
     * // => true
     */
    function endsWith(string, target, position) {
      string = toString(string);
      target = baseToString(target);

      var length = string.length;
      position = position === undefined
        ? length
        : baseClamp(toInteger(position), 0, length);

      var end = position;
      position -= target.length;
      return position >= 0 && string.slice(position, end) == target;
    }

    /**
     * Converts the characters "&", "<", ">", '"', and "'" in `string` to their
     * corresponding HTML entities.
     *
     * **Note:** No other characters are escaped. To escape additional
     * characters use a third-party library like [_he_](https://mths.be/he).
     *
     * Though the ">" character is escaped for symmetry, characters like
     * ">" and "/" don't need escaping in HTML and have no special meaning
     * unless they're part of a tag or unquoted attribute value. See
     * [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands)
     * (under "semi-related fun fact") for more details.
     *
     * When working with HTML you should always
     * [quote attribute values](http://wonko.com/post/html-escaping) to reduce
     * XSS vectors.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category String
     * @param {string} [string=''] The string to escape.
     * @returns {string} Returns the escaped string.
     * @example
     *
     * _.escape('fred, barney, & pebbles');
     * // => 'fred, barney, &amp; pebbles'
     */
    function escape(string) {
      string = toString(string);
      return (string && reHasUnescapedHtml.test(string))
        ? string.replace(reUnescapedHtml, escapeHtmlChar)
        : string;
    }

    /**
     * Escapes the `RegExp` special characters "^", "$", "\", ".", "*", "+",
     * "?", "(", ")", "[", "]", "{", "}", and "|" in `string`.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category String
     * @param {string} [string=''] The string to escape.
     * @returns {string} Returns the escaped string.
     * @example
     *
     * _.escapeRegExp('[lodash](https://lodash.com/)');
     * // => '\[lodash\]\(https://lodash\.com/\)'
     */
    function escapeRegExp(string) {
      string = toString(string);
      return (string && reHasRegExpChar.test(string))
        ? string.replace(reRegExpChar, '\\$&')
        : string;
    }

    /**
     * Converts `string` to
     * [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles).
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category String
     * @param {string} [string=''] The string to convert.
     * @returns {string} Returns the kebab cased string.
     * @example
     *
     * _.kebabCase('Foo Bar');
     * // => 'foo-bar'
     *
     * _.kebabCase('fooBar');
     * // => 'foo-bar'
     *
     * _.kebabCase('__FOO_BAR__');
     * // => 'foo-bar'
     */
    var kebabCase = createCompounder(function(result, word, index) {
      return result + (index ? '-' : '') + word.toLowerCase();
    });

    /**
     * Converts `string`, as space separated words, to lower case.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category String
     * @param {string} [string=''] The string to convert.
     * @returns {string} Returns the lower cased string.
     * @example
     *
     * _.lowerCase('--Foo-Bar--');
     * // => 'foo bar'
     *
     * _.lowerCase('fooBar');
     * // => 'foo bar'
     *
     * _.lowerCase('__FOO_BAR__');
     * // => 'foo bar'
     */
    var lowerCase = createCompounder(function(result, word, index) {
      return result + (index ? ' ' : '') + word.toLowerCase();
    });

    /**
     * Converts the first character of `string` to lower case.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category String
     * @param {string} [string=''] The string to convert.
     * @returns {string} Returns the converted string.
     * @example
     *
     * _.lowerFirst('Fred');
     * // => 'fred'
     *
     * _.lowerFirst('FRED');
     * // => 'fRED'
     */
    var lowerFirst = createCaseFirst('toLowerCase');

    /**
     * Pads `string` on the left and right sides if it's shorter than `length`.
     * Padding characters are truncated if they can't be evenly divided by `length`.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category String
     * @param {string} [string=''] The string to pad.
     * @param {number} [length=0] The padding length.
     * @param {string} [chars=' '] The string used as padding.
     * @returns {string} Returns the padded string.
     * @example
     *
     * _.pad('abc', 8);
     * // => '  abc   '
     *
     * _.pad('abc', 8, '_-');
     * // => '_-abc_-_'
     *
     * _.pad('abc', 3);
     * // => 'abc'
     */
    function pad(string, length, chars) {
      string = toString(string);
      length = toInteger(length);

      var strLength = length ? stringSize(string) : 0;
      if (!length || strLength >= length) {
        return string;
      }
      var mid = (length - strLength) / 2;
      return (
        createPadding(nativeFloor(mid), chars) +
        string +
        createPadding(nativeCeil(mid), chars)
      );
    }

    /**
     * Pads `string` on the right side if it's shorter than `length`. Padding
     * characters are truncated if they exceed `length`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category String
     * @param {string} [string=''] The string to pad.
     * @param {number} [length=0] The padding length.
     * @param {string} [chars=' '] The string used as padding.
     * @returns {string} Returns the padded string.
     * @example
     *
     * _.padEnd('abc', 6);
     * // => 'abc   '
     *
     * _.padEnd('abc', 6, '_-');
     * // => 'abc_-_'
     *
     * _.padEnd('abc', 3);
     * // => 'abc'
     */
    function padEnd(string, length, chars) {
      string = toString(string);
      length = toInteger(length);

      var strLength = length ? stringSize(string) : 0;
      return (length && strLength < length)
        ? (string + createPadding(length - strLength, chars))
        : string;
    }

    /**
     * Pads `string` on the left side if it's shorter than `length`. Padding
     * characters are truncated if they exceed `length`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category String
     * @param {string} [string=''] The string to pad.
     * @param {number} [length=0] The padding length.
     * @param {string} [chars=' '] The string used as padding.
     * @returns {string} Returns the padded string.
     * @example
     *
     * _.padStart('abc', 6);
     * // => '   abc'
     *
     * _.padStart('abc', 6, '_-');
     * // => '_-_abc'
     *
     * _.padStart('abc', 3);
     * // => 'abc'
     */
    function padStart(string, length, chars) {
      string = toString(string);
      length = toInteger(length);

      var strLength = length ? stringSize(string) : 0;
      return (length && strLength < length)
        ? (createPadding(length - strLength, chars) + string)
        : string;
    }

    /**
     * Converts `string` to an integer of the specified radix. If `radix` is
     * `undefined` or `0`, a `radix` of `10` is used unless `value` is a
     * hexadecimal, in which case a `radix` of `16` is used.
     *
     * **Note:** This method aligns with the
     * [ES5 implementation](https://es5.github.io/#x15.1.2.2) of `parseInt`.
     *
     * @static
     * @memberOf _
     * @since 1.1.0
     * @category String
     * @param {string} string The string to convert.
     * @param {number} [radix=10] The radix to interpret `value` by.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {number} Returns the converted integer.
     * @example
     *
     * _.parseInt('08');
     * // => 8
     *
     * _.map(['6', '08', '10'], _.parseInt);
     * // => [6, 8, 10]
     */
    function parseInt(string, radix, guard) {
      if (guard || radix == null) {
        radix = 0;
      } else if (radix) {
        radix = +radix;
      }
      return nativeParseInt(toString(string).replace(reTrimStart, ''), radix || 0);
    }

    /**
     * Repeats the given string `n` times.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category String
     * @param {string} [string=''] The string to repeat.
     * @param {number} [n=1] The number of times to repeat the string.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {string} Returns the repeated string.
     * @example
     *
     * _.repeat('*', 3);
     * // => '***'
     *
     * _.repeat('abc', 2);
     * // => 'abcabc'
     *
     * _.repeat('abc', 0);
     * // => ''
     */
    function repeat(string, n, guard) {
      if ((guard ? isIterateeCall(string, n, guard) : n === undefined)) {
        n = 1;
      } else {
        n = toInteger(n);
      }
      return baseRepeat(toString(string), n);
    }

    /**
     * Replaces matches for `pattern` in `string` with `replacement`.
     *
     * **Note:** This method is based on
     * [`String#replace`](https://mdn.io/String/replace).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category String
     * @param {string} [string=''] The string to modify.
     * @param {RegExp|string} pattern The pattern to replace.
     * @param {Function|string} replacement The match replacement.
     * @returns {string} Returns the modified string.
     * @example
     *
     * _.replace('Hi Fred', 'Fred', 'Barney');
     * // => 'Hi Barney'
     */
    function replace() {
      var args = arguments,
          string = toString(args[0]);

      return args.length < 3 ? string : string.replace(args[1], args[2]);
    }

    /**
     * Converts `string` to
     * [snake case](https://en.wikipedia.org/wiki/Snake_case).
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category String
     * @param {string} [string=''] The string to convert.
     * @returns {string} Returns the snake cased string.
     * @example
     *
     * _.snakeCase('Foo Bar');
     * // => 'foo_bar'
     *
     * _.snakeCase('fooBar');
     * // => 'foo_bar'
     *
     * _.snakeCase('--FOO-BAR--');
     * // => 'foo_bar'
     */
    var snakeCase = createCompounder(function(result, word, index) {
      return result + (index ? '_' : '') + word.toLowerCase();
    });

    /**
     * Splits `string` by `separator`.
     *
     * **Note:** This method is based on
     * [`String#split`](https://mdn.io/String/split).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category String
     * @param {string} [string=''] The string to split.
     * @param {RegExp|string} separator The separator pattern to split by.
     * @param {number} [limit] The length to truncate results to.
     * @returns {Array} Returns the string segments.
     * @example
     *
     * _.split('a-b-c', '-', 2);
     * // => ['a', 'b']
     */
    function split(string, separator, limit) {
      if (limit && typeof limit != 'number' && isIterateeCall(string, separator, limit)) {
        separator = limit = undefined;
      }
      limit = limit === undefined ? MAX_ARRAY_LENGTH : limit >>> 0;
      if (!limit) {
        return [];
      }
      string = toString(string);
      if (string && (
            typeof separator == 'string' ||
            (separator != null && !isRegExp(separator))
          )) {
        separator = baseToString(separator);
        if (!separator && hasUnicode(string)) {
          return castSlice(stringToArray(string), 0, limit);
        }
      }
      return string.split(separator, limit);
    }

    /**
     * Converts `string` to
     * [start case](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage).
     *
     * @static
     * @memberOf _
     * @since 3.1.0
     * @category String
     * @param {string} [string=''] The string to convert.
     * @returns {string} Returns the start cased string.
     * @example
     *
     * _.startCase('--foo-bar--');
     * // => 'Foo Bar'
     *
     * _.startCase('fooBar');
     * // => 'Foo Bar'
     *
     * _.startCase('__FOO_BAR__');
     * // => 'FOO BAR'
     */
    var startCase = createCompounder(function(result, word, index) {
      return result + (index ? ' ' : '') + upperFirst(word);
    });

    /**
     * Checks if `string` starts with the given target string.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category String
     * @param {string} [string=''] The string to inspect.
     * @param {string} [target] The string to search for.
     * @param {number} [position=0] The position to search from.
     * @returns {boolean} Returns `true` if `string` starts with `target`,
     *  else `false`.
     * @example
     *
     * _.startsWith('abc', 'a');
     * // => true
     *
     * _.startsWith('abc', 'b');
     * // => false
     *
     * _.startsWith('abc', 'b', 1);
     * // => true
     */
    function startsWith(string, target, position) {
      string = toString(string);
      position = position == null
        ? 0
        : baseClamp(toInteger(position), 0, string.length);

      target = baseToString(target);
      return string.slice(position, position + target.length) == target;
    }

    /**
     * Creates a compiled template function that can interpolate data properties
     * in "interpolate" delimiters, HTML-escape interpolated data properties in
     * "escape" delimiters, and execute JavaScript in "evaluate" delimiters. Data
     * properties may be accessed as free variables in the template. If a setting
     * object is given, it takes precedence over `_.templateSettings` values.
     *
     * **Note:** In the development build `_.template` utilizes
     * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl)
     * for easier debugging.
     *
     * For more information on precompiling templates see
     * [lodash's custom builds documentation](https://lodash.com/custom-builds).
     *
     * For more information on Chrome extension sandboxes see
     * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval).
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category String
     * @param {string} [string=''] The template string.
     * @param {Object} [options={}] The options object.
     * @param {RegExp} [options.escape=_.templateSettings.escape]
     *  The HTML "escape" delimiter.
     * @param {RegExp} [options.evaluate=_.templateSettings.evaluate]
     *  The "evaluate" delimiter.
     * @param {Object} [options.imports=_.templateSettings.imports]
     *  An object to import into the template as free variables.
     * @param {RegExp} [options.interpolate=_.templateSettings.interpolate]
     *  The "interpolate" delimiter.
     * @param {string} [options.sourceURL='lodash.templateSources[n]']
     *  The sourceURL of the compiled template.
     * @param {string} [options.variable='obj']
     *  The data object variable name.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {Function} Returns the compiled template function.
     * @example
     *
     * // Use the "interpolate" delimiter to create a compiled template.
     * var compiled = _.template('hello <%= user %>!');
     * compiled({ 'user': 'fred' });
     * // => 'hello fred!'
     *
     * // Use the HTML "escape" delimiter to escape data property values.
     * var compiled = _.template('<b><%- value %></b>');
     * compiled({ 'value': '<script>' });
     * // => '<b>&lt;script&gt;</b>'
     *
     * // Use the "evaluate" delimiter to execute JavaScript and generate HTML.
     * var compiled = _.template('<% _.forEach(users, function(user) { %><li><%- user %></li><% }); %>');
     * compiled({ 'users': ['fred', 'barney'] });
     * // => '<li>fred</li><li>barney</li>'
     *
     * // Use the internal `print` function in "evaluate" delimiters.
     * var compiled = _.template('<% print("hello " + user); %>!');
     * compiled({ 'user': 'barney' });
     * // => 'hello barney!'
     *
     * // Use the ES template literal delimiter as an "interpolate" delimiter.
     * // Disable support by replacing the "interpolate" delimiter.
     * var compiled = _.template('hello ${ user }!');
     * compiled({ 'user': 'pebbles' });
     * // => 'hello pebbles!'
     *
     * // Use backslashes to treat delimiters as plain text.
     * var compiled = _.template('<%= "\\<%- value %\\>" %>');
     * compiled({ 'value': 'ignored' });
     * // => '<%- value %>'
     *
     * // Use the `imports` option to import `jQuery` as `jq`.
     * var text = '<% jq.each(users, function(user) { %><li><%- user %></li><% }); %>';
     * var compiled = _.template(text, { 'imports': { 'jq': jQuery } });
     * compiled({ 'users': ['fred', 'barney'] });
     * // => '<li>fred</li><li>barney</li>'
     *
     * // Use the `sourceURL` option to specify a custom sourceURL for the template.
     * var compiled = _.template('hello <%= user %>!', { 'sourceURL': '/basic/greeting.jst' });
     * compiled(data);
     * // => Find the source of "greeting.jst" under the Sources tab or Resources panel of the web inspector.
     *
     * // Use the `variable` option to ensure a with-statement isn't used in the compiled template.
     * var compiled = _.template('hi <%= data.user %>!', { 'variable': 'data' });
     * compiled.source;
     * // => function(data) {
     * //   var __t, __p = '';
     * //   __p += 'hi ' + ((__t = ( data.user )) == null ? '' : __t) + '!';
     * //   return __p;
     * // }
     *
     * // Use custom template delimiters.
     * _.templateSettings.interpolate = /{{([\s\S]+?)}}/g;
     * var compiled = _.template('hello {{ user }}!');
     * compiled({ 'user': 'mustache' });
     * // => 'hello mustache!'
     *
     * // Use the `source` property to inline compiled templates for meaningful
     * // line numbers in error messages and stack traces.
     * fs.writeFileSync(path.join(process.cwd(), 'jst.js'), '\
     *   var JST = {\
     *     "main": ' + _.template(mainText).source + '\
     *   };\
     * ');
     */
    function template(string, options, guard) {
      // Based on John Resig's `tmpl` implementation
      // (http://ejohn.org/blog/javascript-micro-templating/)
      // and Laura Doktorova's doT.js (https://github.com/olado/doT).
      var settings = lodash.templateSettings;

      if (guard && isIterateeCall(string, options, guard)) {
        options = undefined;
      }
      string = toString(string);
      options = assignInWith({}, options, settings, customDefaultsAssignIn);

      var imports = assignInWith({}, options.imports, settings.imports, customDefaultsAssignIn),
          importsKeys = keys(imports),
          importsValues = baseValues(imports, importsKeys);

      var isEscaping,
          isEvaluating,
          index = 0,
          interpolate = options.interpolate || reNoMatch,
          source = "__p += '";

      // Compile the regexp to match each delimiter.
      var reDelimiters = RegExp(
        (options.escape || reNoMatch).source + '|' +
        interpolate.source + '|' +
        (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + '|' +
        (options.evaluate || reNoMatch).source + '|$'
      , 'g');

      // Use a sourceURL for easier debugging.
      var sourceURL = '//# sourceURL=' +
        ('sourceURL' in options
          ? options.sourceURL
          : ('lodash.templateSources[' + (++templateCounter) + ']')
        ) + '\n';

      string.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {
        interpolateValue || (interpolateValue = esTemplateValue);

        // Escape characters that can't be included in string literals.
        source += string.slice(index, offset).replace(reUnescapedString, escapeStringChar);

        // Replace delimiters with snippets.
        if (escapeValue) {
          isEscaping = true;
          source += "' +\n__e(" + escapeValue + ") +\n'";
        }
        if (evaluateValue) {
          isEvaluating = true;
          source += "';\n" + evaluateValue + ";\n__p += '";
        }
        if (interpolateValue) {
          source += "' +\n((__t = (" + interpolateValue + ")) == null ? '' : __t) +\n'";
        }
        index = offset + match.length;

        // The JS engine embedded in Adobe products needs `match` returned in
        // order to produce the correct `offset` value.
        return match;
      });

      source += "';\n";

      // If `variable` is not specified wrap a with-statement around the generated
      // code to add the data object to the top of the scope chain.
      var variable = options.variable;
      if (!variable) {
        source = 'with (obj) {\n' + source + '\n}\n';
      }
      // Cleanup code by stripping empty strings.
      source = (isEvaluating ? source.replace(reEmptyStringLeading, '') : source)
        .replace(reEmptyStringMiddle, '$1')
        .replace(reEmptyStringTrailing, '$1;');

      // Frame code as the function body.
      source = 'function(' + (variable || 'obj') + ') {\n' +
        (variable
          ? ''
          : 'obj || (obj = {});\n'
        ) +
        "var __t, __p = ''" +
        (isEscaping
           ? ', __e = _.escape'
           : ''
        ) +
        (isEvaluating
          ? ', __j = Array.prototype.join;\n' +
            "function print() { __p += __j.call(arguments, '') }\n"
          : ';\n'
        ) +
        source +
        'return __p\n}';

      var result = attempt(function() {
        return Function(importsKeys, sourceURL + 'return ' + source)
          .apply(undefined, importsValues);
      });

      // Provide the compiled function's source by its `toString` method or
      // the `source` property as a convenience for inlining compiled templates.
      result.source = source;
      if (isError(result)) {
        throw result;
      }
      return result;
    }

    /**
     * Converts `string`, as a whole, to lower case just like
     * [String#toLowerCase](https://mdn.io/toLowerCase).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category String
     * @param {string} [string=''] The string to convert.
     * @returns {string} Returns the lower cased string.
     * @example
     *
     * _.toLower('--Foo-Bar--');
     * // => '--foo-bar--'
     *
     * _.toLower('fooBar');
     * // => 'foobar'
     *
     * _.toLower('__FOO_BAR__');
     * // => '__foo_bar__'
     */
    function toLower(value) {
      return toString(value).toLowerCase();
    }

    /**
     * Converts `string`, as a whole, to upper case just like
     * [String#toUpperCase](https://mdn.io/toUpperCase).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category String
     * @param {string} [string=''] The string to convert.
     * @returns {string} Returns the upper cased string.
     * @example
     *
     * _.toUpper('--foo-bar--');
     * // => '--FOO-BAR--'
     *
     * _.toUpper('fooBar');
     * // => 'FOOBAR'
     *
     * _.toUpper('__foo_bar__');
     * // => '__FOO_BAR__'
     */
    function toUpper(value) {
      return toString(value).toUpperCase();
    }

    /**
     * Removes leading and trailing whitespace or specified characters from `string`.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category String
     * @param {string} [string=''] The string to trim.
     * @param {string} [chars=whitespace] The characters to trim.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {string} Returns the trimmed string.
     * @example
     *
     * _.trim('  abc  ');
     * // => 'abc'
     *
     * _.trim('-_-abc-_-', '_-');
     * // => 'abc'
     *
     * _.map(['  foo  ', '  bar  '], _.trim);
     * // => ['foo', 'bar']
     */
    function trim(string, chars, guard) {
      string = toString(string);
      if (string && (guard || chars === undefined)) {
        return string.replace(reTrim, '');
      }
      if (!string || !(chars = baseToString(chars))) {
        return string;
      }
      var strSymbols = stringToArray(string),
          chrSymbols = stringToArray(chars),
          start = charsStartIndex(strSymbols, chrSymbols),
          end = charsEndIndex(strSymbols, chrSymbols) + 1;

      return castSlice(strSymbols, start, end).join('');
    }

    /**
     * Removes trailing whitespace or specified characters from `string`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category String
     * @param {string} [string=''] The string to trim.
     * @param {string} [chars=whitespace] The characters to trim.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {string} Returns the trimmed string.
     * @example
     *
     * _.trimEnd('  abc  ');
     * // => '  abc'
     *
     * _.trimEnd('-_-abc-_-', '_-');
     * // => '-_-abc'
     */
    function trimEnd(string, chars, guard) {
      string = toString(string);
      if (string && (guard || chars === undefined)) {
        return string.replace(reTrimEnd, '');
      }
      if (!string || !(chars = baseToString(chars))) {
        return string;
      }
      var strSymbols = stringToArray(string),
          end = charsEndIndex(strSymbols, stringToArray(chars)) + 1;

      return castSlice(strSymbols, 0, end).join('');
    }

    /**
     * Removes leading whitespace or specified characters from `string`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category String
     * @param {string} [string=''] The string to trim.
     * @param {string} [chars=whitespace] The characters to trim.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {string} Returns the trimmed string.
     * @example
     *
     * _.trimStart('  abc  ');
     * // => 'abc  '
     *
     * _.trimStart('-_-abc-_-', '_-');
     * // => 'abc-_-'
     */
    function trimStart(string, chars, guard) {
      string = toString(string);
      if (string && (guard || chars === undefined)) {
        return string.replace(reTrimStart, '');
      }
      if (!string || !(chars = baseToString(chars))) {
        return string;
      }
      var strSymbols = stringToArray(string),
          start = charsStartIndex(strSymbols, stringToArray(chars));

      return castSlice(strSymbols, start).join('');
    }

    /**
     * Truncates `string` if it's longer than the given maximum string length.
     * The last characters of the truncated string are replaced with the omission
     * string which defaults to "...".
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category String
     * @param {string} [string=''] The string to truncate.
     * @param {Object} [options={}] The options object.
     * @param {number} [options.length=30] The maximum string length.
     * @param {string} [options.omission='...'] The string to indicate text is omitted.
     * @param {RegExp|string} [options.separator] The separator pattern to truncate to.
     * @returns {string} Returns the truncated string.
     * @example
     *
     * _.truncate('hi-diddly-ho there, neighborino');
     * // => 'hi-diddly-ho there, neighbo...'
     *
     * _.truncate('hi-diddly-ho there, neighborino', {
     *   'length': 24,
     *   'separator': ' '
     * });
     * // => 'hi-diddly-ho there,...'
     *
     * _.truncate('hi-diddly-ho there, neighborino', {
     *   'length': 24,
     *   'separator': /,? +/
     * });
     * // => 'hi-diddly-ho there...'
     *
     * _.truncate('hi-diddly-ho there, neighborino', {
     *   'omission': ' [...]'
     * });
     * // => 'hi-diddly-ho there, neig [...]'
     */
    function truncate(string, options) {
      var length = DEFAULT_TRUNC_LENGTH,
          omission = DEFAULT_TRUNC_OMISSION;

      if (isObject(options)) {
        var separator = 'separator' in options ? options.separator : separator;
        length = 'length' in options ? toInteger(options.length) : length;
        omission = 'omission' in options ? baseToString(options.omission) : omission;
      }
      string = toString(string);

      var strLength = string.length;
      if (hasUnicode(string)) {
        var strSymbols = stringToArray(string);
        strLength = strSymbols.length;
      }
      if (length >= strLength) {
        return string;
      }
      var end = length - stringSize(omission);
      if (end < 1) {
        return omission;
      }
      var result = strSymbols
        ? castSlice(strSymbols, 0, end).join('')
        : string.slice(0, end);

      if (separator === undefined) {
        return result + omission;
      }
      if (strSymbols) {
        end += (result.length - end);
      }
      if (isRegExp(separator)) {
        if (string.slice(end).search(separator)) {
          var match,
              substring = result;

          if (!separator.global) {
            separator = RegExp(separator.source, toString(reFlags.exec(separator)) + 'g');
          }
          separator.lastIndex = 0;
          while ((match = separator.exec(substring))) {
            var newEnd = match.index;
          }
          result = result.slice(0, newEnd === undefined ? end : newEnd);
        }
      } else if (string.indexOf(baseToString(separator), end) != end) {
        var index = result.lastIndexOf(separator);
        if (index > -1) {
          result = result.slice(0, index);
        }
      }
      return result + omission;
    }

    /**
     * The inverse of `_.escape`; this method converts the HTML entities
     * `&amp;`, `&lt;`, `&gt;`, `&quot;`, and `&#39;` in `string` to
     * their corresponding characters.
     *
     * **Note:** No other HTML entities are unescaped. To unescape additional
     * HTML entities use a third-party library like [_he_](https://mths.be/he).
     *
     * @static
     * @memberOf _
     * @since 0.6.0
     * @category String
     * @param {string} [string=''] The string to unescape.
     * @returns {string} Returns the unescaped string.
     * @example
     *
     * _.unescape('fred, barney, &amp; pebbles');
     * // => 'fred, barney, & pebbles'
     */
    function unescape(string) {
      string = toString(string);
      return (string && reHasEscapedHtml.test(string))
        ? string.replace(reEscapedHtml, unescapeHtmlChar)
        : string;
    }

    /**
     * Converts `string`, as space separated words, to upper case.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category String
     * @param {string} [string=''] The string to convert.
     * @returns {string} Returns the upper cased string.
     * @example
     *
     * _.upperCase('--foo-bar');
     * // => 'FOO BAR'
     *
     * _.upperCase('fooBar');
     * // => 'FOO BAR'
     *
     * _.upperCase('__foo_bar__');
     * // => 'FOO BAR'
     */
    var upperCase = createCompounder(function(result, word, index) {
      return result + (index ? ' ' : '') + word.toUpperCase();
    });

    /**
     * Converts the first character of `string` to upper case.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category String
     * @param {string} [string=''] The string to convert.
     * @returns {string} Returns the converted string.
     * @example
     *
     * _.upperFirst('fred');
     * // => 'Fred'
     *
     * _.upperFirst('FRED');
     * // => 'FRED'
     */
    var upperFirst = createCaseFirst('toUpperCase');

    /**
     * Splits `string` into an array of its words.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category String
     * @param {string} [string=''] The string to inspect.
     * @param {RegExp|string} [pattern] The pattern to match words.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {Array} Returns the words of `string`.
     * @example
     *
     * _.words('fred, barney, & pebbles');
     * // => ['fred', 'barney', 'pebbles']
     *
     * _.words('fred, barney, & pebbles', /[^, ]+/g);
     * // => ['fred', 'barney', '&', 'pebbles']
     */
    function words(string, pattern, guard) {
      string = toString(string);
      pattern = guard ? undefined : pattern;

      if (pattern === undefined) {
        return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);
      }
      return string.match(pattern) || [];
    }

    /*------------------------------------------------------------------------*/

    /**
     * Attempts to invoke `func`, returning either the result or the caught error
     * object. Any additional arguments are provided to `func` when it's invoked.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Util
     * @param {Function} func The function to attempt.
     * @param {...*} [args] The arguments to invoke `func` with.
     * @returns {*} Returns the `func` result or error object.
     * @example
     *
     * // Avoid throwing errors for invalid selectors.
     * var elements = _.attempt(function(selector) {
     *   return document.querySelectorAll(selector);
     * }, '>_>');
     *
     * if (_.isError(elements)) {
     *   elements = [];
     * }
     */
    var attempt = baseRest(function(func, args) {
      try {
        return apply(func, undefined, args);
      } catch (e) {
        return isError(e) ? e : new Error(e);
      }
    });

    /**
     * Binds methods of an object to the object itself, overwriting the existing
     * method.
     *
     * **Note:** This method doesn't set the "length" property of bound functions.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Util
     * @param {Object} object The object to bind and assign the bound methods to.
     * @param {...(string|string[])} methodNames The object method names to bind.
     * @returns {Object} Returns `object`.
     * @example
     *
     * var view = {
     *   'label': 'docs',
     *   'click': function() {
     *     console.log('clicked ' + this.label);
     *   }
     * };
     *
     * _.bindAll(view, ['click']);
     * jQuery(element).on('click', view.click);
     * // => Logs 'clicked docs' when clicked.
     */
    var bindAll = flatRest(function(object, methodNames) {
      arrayEach(methodNames, function(key) {
        key = toKey(key);
        baseAssignValue(object, key, bind(object[key], object));
      });
      return object;
    });

    /**
     * Creates a function that iterates over `pairs` and invokes the corresponding
     * function of the first predicate to return truthy. The predicate-function
     * pairs are invoked with the `this` binding and arguments of the created
     * function.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Util
     * @param {Array} pairs The predicate-function pairs.
     * @returns {Function} Returns the new composite function.
     * @example
     *
     * var func = _.cond([
     *   [_.matches({ 'a': 1 }),           _.constant('matches A')],
     *   [_.conforms({ 'b': _.isNumber }), _.constant('matches B')],
     *   [_.stubTrue,                      _.constant('no match')]
     * ]);
     *
     * func({ 'a': 1, 'b': 2 });
     * // => 'matches A'
     *
     * func({ 'a': 0, 'b': 1 });
     * // => 'matches B'
     *
     * func({ 'a': '1', 'b': '2' });
     * // => 'no match'
     */
    function cond(pairs) {
      var length = pairs == null ? 0 : pairs.length,
          toIteratee = getIteratee();

      pairs = !length ? [] : arrayMap(pairs, function(pair) {
        if (typeof pair[1] != 'function') {
          throw new TypeError(FUNC_ERROR_TEXT);
        }
        return [toIteratee(pair[0]), pair[1]];
      });

      return baseRest(function(args) {
        var index = -1;
        while (++index < length) {
          var pair = pairs[index];
          if (apply(pair[0], this, args)) {
            return apply(pair[1], this, args);
          }
        }
      });
    }

    /**
     * Creates a function that invokes the predicate properties of `source` with
     * the corresponding property values of a given object, returning `true` if
     * all predicates return truthy, else `false`.
     *
     * **Note:** The created function is equivalent to `_.conformsTo` with
     * `source` partially applied.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Util
     * @param {Object} source The object of property predicates to conform to.
     * @returns {Function} Returns the new spec function.
     * @example
     *
     * var objects = [
     *   { 'a': 2, 'b': 1 },
     *   { 'a': 1, 'b': 2 }
     * ];
     *
     * _.filter(objects, _.conforms({ 'b': function(n) { return n > 1; } }));
     * // => [{ 'a': 1, 'b': 2 }]
     */
    function conforms(source) {
      return baseConforms(baseClone(source, CLONE_DEEP_FLAG));
    }

    /**
     * Creates a function that returns `value`.
     *
     * @static
     * @memberOf _
     * @since 2.4.0
     * @category Util
     * @param {*} value The value to return from the new function.
     * @returns {Function} Returns the new constant function.
     * @example
     *
     * var objects = _.times(2, _.constant({ 'a': 1 }));
     *
     * console.log(objects);
     * // => [{ 'a': 1 }, { 'a': 1 }]
     *
     * console.log(objects[0] === objects[1]);
     * // => true
     */
    function constant(value) {
      return function() {
        return value;
      };
    }

    /**
     * Checks `value` to determine whether a default value should be returned in
     * its place. The `defaultValue` is returned if `value` is `NaN`, `null`,
     * or `undefined`.
     *
     * @static
     * @memberOf _
     * @since 4.14.0
     * @category Util
     * @param {*} value The value to check.
     * @param {*} defaultValue The default value.
     * @returns {*} Returns the resolved value.
     * @example
     *
     * _.defaultTo(1, 10);
     * // => 1
     *
     * _.defaultTo(undefined, 10);
     * // => 10
     */
    function defaultTo(value, defaultValue) {
      return (value == null || value !== value) ? defaultValue : value;
    }

    /**
     * Creates a function that returns the result of invoking the given functions
     * with the `this` binding of the created function, where each successive
     * invocation is supplied the return value of the previous.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Util
     * @param {...(Function|Function[])} [funcs] The functions to invoke.
     * @returns {Function} Returns the new composite function.
     * @see _.flowRight
     * @example
     *
     * function square(n) {
     *   return n * n;
     * }
     *
     * var addSquare = _.flow([_.add, square]);
     * addSquare(1, 2);
     * // => 9
     */
    var flow = createFlow();

    /**
     * This method is like `_.flow` except that it creates a function that
     * invokes the given functions from right to left.
     *
     * @static
     * @since 3.0.0
     * @memberOf _
     * @category Util
     * @param {...(Function|Function[])} [funcs] The functions to invoke.
     * @returns {Function} Returns the new composite function.
     * @see _.flow
     * @example
     *
     * function square(n) {
     *   return n * n;
     * }
     *
     * var addSquare = _.flowRight([square, _.add]);
     * addSquare(1, 2);
     * // => 9
     */
    var flowRight = createFlow(true);

    /**
     * This method returns the first argument it receives.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Util
     * @param {*} value Any value.
     * @returns {*} Returns `value`.
     * @example
     *
     * var object = { 'a': 1 };
     *
     * console.log(_.identity(object) === object);
     * // => true
     */
    function identity(value) {
      return value;
    }

    /**
     * Creates a function that invokes `func` with the arguments of the created
     * function. If `func` is a property name, the created function returns the
     * property value for a given element. If `func` is an array or object, the
     * created function returns `true` for elements that contain the equivalent
     * source properties, otherwise it returns `false`.
     *
     * @static
     * @since 4.0.0
     * @memberOf _
     * @category Util
     * @param {*} [func=_.identity] The value to convert to a callback.
     * @returns {Function} Returns the callback.
     * @example
     *
     * var users = [
     *   { 'user': 'barney', 'age': 36, 'active': true },
     *   { 'user': 'fred',   'age': 40, 'active': false }
     * ];
     *
     * // The `_.matches` iteratee shorthand.
     * _.filter(users, _.iteratee({ 'user': 'barney', 'active': true }));
     * // => [{ 'user': 'barney', 'age': 36, 'active': true }]
     *
     * // The `_.matchesProperty` iteratee shorthand.
     * _.filter(users, _.iteratee(['user', 'fred']));
     * // => [{ 'user': 'fred', 'age': 40 }]
     *
     * // The `_.property` iteratee shorthand.
     * _.map(users, _.iteratee('user'));
     * // => ['barney', 'fred']
     *
     * // Create custom iteratee shorthands.
     * _.iteratee = _.wrap(_.iteratee, function(iteratee, func) {
     *   return !_.isRegExp(func) ? iteratee(func) : function(string) {
     *     return func.test(string);
     *   };
     * });
     *
     * _.filter(['abc', 'def'], /ef/);
     * // => ['def']
     */
    function iteratee(func) {
      return baseIteratee(typeof func == 'function' ? func : baseClone(func, CLONE_DEEP_FLAG));
    }

    /**
     * Creates a function that performs a partial deep comparison between a given
     * object and `source`, returning `true` if the given object has equivalent
     * property values, else `false`.
     *
     * **Note:** The created function is equivalent to `_.isMatch` with `source`
     * partially applied.
     *
     * Partial comparisons will match empty array and empty object `source`
     * values against any array or object value, respectively. See `_.isEqual`
     * for a list of supported value comparisons.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Util
     * @param {Object} source The object of property values to match.
     * @returns {Function} Returns the new spec function.
     * @example
     *
     * var objects = [
     *   { 'a': 1, 'b': 2, 'c': 3 },
     *   { 'a': 4, 'b': 5, 'c': 6 }
     * ];
     *
     * _.filter(objects, _.matches({ 'a': 4, 'c': 6 }));
     * // => [{ 'a': 4, 'b': 5, 'c': 6 }]
     */
    function matches(source) {
      return baseMatches(baseClone(source, CLONE_DEEP_FLAG));
    }

    /**
     * Creates a function that performs a partial deep comparison between the
     * value at `path` of a given object to `srcValue`, returning `true` if the
     * object value is equivalent, else `false`.
     *
     * **Note:** Partial comparisons will match empty array and empty object
     * `srcValue` values against any array or object value, respectively. See
     * `_.isEqual` for a list of supported value comparisons.
     *
     * @static
     * @memberOf _
     * @since 3.2.0
     * @category Util
     * @param {Array|string} path The path of the property to get.
     * @param {*} srcValue The value to match.
     * @returns {Function} Returns the new spec function.
     * @example
     *
     * var objects = [
     *   { 'a': 1, 'b': 2, 'c': 3 },
     *   { 'a': 4, 'b': 5, 'c': 6 }
     * ];
     *
     * _.find(objects, _.matchesProperty('a', 4));
     * // => { 'a': 4, 'b': 5, 'c': 6 }
     */
    function matchesProperty(path, srcValue) {
      return baseMatchesProperty(path, baseClone(srcValue, CLONE_DEEP_FLAG));
    }

    /**
     * Creates a function that invokes the method at `path` of a given object.
     * Any additional arguments are provided to the invoked method.
     *
     * @static
     * @memberOf _
     * @since 3.7.0
     * @category Util
     * @param {Array|string} path The path of the method to invoke.
     * @param {...*} [args] The arguments to invoke the method with.
     * @returns {Function} Returns the new invoker function.
     * @example
     *
     * var objects = [
     *   { 'a': { 'b': _.constant(2) } },
     *   { 'a': { 'b': _.constant(1) } }
     * ];
     *
     * _.map(objects, _.method('a.b'));
     * // => [2, 1]
     *
     * _.map(objects, _.method(['a', 'b']));
     * // => [2, 1]
     */
    var method = baseRest(function(path, args) {
      return function(object) {
        return baseInvoke(object, path, args);
      };
    });

    /**
     * The opposite of `_.method`; this method creates a function that invokes
     * the method at a given path of `object`. Any additional arguments are
     * provided to the invoked method.
     *
     * @static
     * @memberOf _
     * @since 3.7.0
     * @category Util
     * @param {Object} object The object to query.
     * @param {...*} [args] The arguments to invoke the method with.
     * @returns {Function} Returns the new invoker function.
     * @example
     *
     * var array = _.times(3, _.constant),
     *     object = { 'a': array, 'b': array, 'c': array };
     *
     * _.map(['a[2]', 'c[0]'], _.methodOf(object));
     * // => [2, 0]
     *
     * _.map([['a', '2'], ['c', '0']], _.methodOf(object));
     * // => [2, 0]
     */
    var methodOf = baseRest(function(object, args) {
      return function(path) {
        return baseInvoke(object, path, args);
      };
    });

    /**
     * Adds all own enumerable string keyed function properties of a source
     * object to the destination object. If `object` is a function, then methods
     * are added to its prototype as well.
     *
     * **Note:** Use `_.runInContext` to create a pristine `lodash` function to
     * avoid conflicts caused by modifying the original.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Util
     * @param {Function|Object} [object=lodash] The destination object.
     * @param {Object} source The object of functions to add.
     * @param {Object} [options={}] The options object.
     * @param {boolean} [options.chain=true] Specify whether mixins are chainable.
     * @returns {Function|Object} Returns `object`.
     * @example
     *
     * function vowels(string) {
     *   return _.filter(string, function(v) {
     *     return /[aeiou]/i.test(v);
     *   });
     * }
     *
     * _.mixin({ 'vowels': vowels });
     * _.vowels('fred');
     * // => ['e']
     *
     * _('fred').vowels().value();
     * // => ['e']
     *
     * _.mixin({ 'vowels': vowels }, { 'chain': false });
     * _('fred').vowels();
     * // => ['e']
     */
    function mixin(object, source, options) {
      var props = keys(source),
          methodNames = baseFunctions(source, props);

      if (options == null &&
          !(isObject(source) && (methodNames.length || !props.length))) {
        options = source;
        source = object;
        object = this;
        methodNames = baseFunctions(source, keys(source));
      }
      var chain = !(isObject(options) && 'chain' in options) || !!options.chain,
          isFunc = isFunction(object);

      arrayEach(methodNames, function(methodName) {
        var func = source[methodName];
        object[methodName] = func;
        if (isFunc) {
          object.prototype[methodName] = function() {
            var chainAll = this.__chain__;
            if (chain || chainAll) {
              var result = object(this.__wrapped__),
                  actions = result.__actions__ = copyArray(this.__actions__);

              actions.push({ 'func': func, 'args': arguments, 'thisArg': object });
              result.__chain__ = chainAll;
              return result;
            }
            return func.apply(object, arrayPush([this.value()], arguments));
          };
        }
      });

      return object;
    }

    /**
     * Reverts the `_` variable to its previous value and returns a reference to
     * the `lodash` function.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Util
     * @returns {Function} Returns the `lodash` function.
     * @example
     *
     * var lodash = _.noConflict();
     */
    function noConflict() {
      if (root._ === this) {
        root._ = oldDash;
      }
      return this;
    }

    /**
     * This method returns `undefined`.
     *
     * @static
     * @memberOf _
     * @since 2.3.0
     * @category Util
     * @example
     *
     * _.times(2, _.noop);
     * // => [undefined, undefined]
     */
    function noop() {
      // No operation performed.
    }

    /**
     * Creates a function that gets the argument at index `n`. If `n` is negative,
     * the nth argument from the end is returned.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Util
     * @param {number} [n=0] The index of the argument to return.
     * @returns {Function} Returns the new pass-thru function.
     * @example
     *
     * var func = _.nthArg(1);
     * func('a', 'b', 'c', 'd');
     * // => 'b'
     *
     * var func = _.nthArg(-2);
     * func('a', 'b', 'c', 'd');
     * // => 'c'
     */
    function nthArg(n) {
      n = toInteger(n);
      return baseRest(function(args) {
        return baseNth(args, n);
      });
    }

    /**
     * Creates a function that invokes `iteratees` with the arguments it receives
     * and returns their results.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Util
     * @param {...(Function|Function[])} [iteratees=[_.identity]]
     *  The iteratees to invoke.
     * @returns {Function} Returns the new function.
     * @example
     *
     * var func = _.over([Math.max, Math.min]);
     *
     * func(1, 2, 3, 4);
     * // => [4, 1]
     */
    var over = createOver(arrayMap);

    /**
     * Creates a function that checks if **all** of the `predicates` return
     * truthy when invoked with the arguments it receives.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Util
     * @param {...(Function|Function[])} [predicates=[_.identity]]
     *  The predicates to check.
     * @returns {Function} Returns the new function.
     * @example
     *
     * var func = _.overEvery([Boolean, isFinite]);
     *
     * func('1');
     * // => true
     *
     * func(null);
     * // => false
     *
     * func(NaN);
     * // => false
     */
    var overEvery = createOver(arrayEvery);

    /**
     * Creates a function that checks if **any** of the `predicates` return
     * truthy when invoked with the arguments it receives.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Util
     * @param {...(Function|Function[])} [predicates=[_.identity]]
     *  The predicates to check.
     * @returns {Function} Returns the new function.
     * @example
     *
     * var func = _.overSome([Boolean, isFinite]);
     *
     * func('1');
     * // => true
     *
     * func(null);
     * // => true
     *
     * func(NaN);
     * // => false
     */
    var overSome = createOver(arraySome);

    /**
     * Creates a function that returns the value at `path` of a given object.
     *
     * @static
     * @memberOf _
     * @since 2.4.0
     * @category Util
     * @param {Array|string} path The path of the property to get.
     * @returns {Function} Returns the new accessor function.
     * @example
     *
     * var objects = [
     *   { 'a': { 'b': 2 } },
     *   { 'a': { 'b': 1 } }
     * ];
     *
     * _.map(objects, _.property('a.b'));
     * // => [2, 1]
     *
     * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');
     * // => [1, 2]
     */
    function property(path) {
      return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
    }

    /**
     * The opposite of `_.property`; this method creates a function that returns
     * the value at a given path of `object`.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Util
     * @param {Object} object The object to query.
     * @returns {Function} Returns the new accessor function.
     * @example
     *
     * var array = [0, 1, 2],
     *     object = { 'a': array, 'b': array, 'c': array };
     *
     * _.map(['a[2]', 'c[0]'], _.propertyOf(object));
     * // => [2, 0]
     *
     * _.map([['a', '2'], ['c', '0']], _.propertyOf(object));
     * // => [2, 0]
     */
    function propertyOf(object) {
      return function(path) {
        return object == null ? undefined : baseGet(object, path);
      };
    }

    /**
     * Creates an array of numbers (positive and/or negative) progressing from
     * `start` up to, but not including, `end`. A step of `-1` is used if a negative
     * `start` is specified without an `end` or `step`. If `end` is not specified,
     * it's set to `start` with `start` then set to `0`.
     *
     * **Note:** JavaScript follows the IEEE-754 standard for resolving
     * floating-point values which can produce unexpected results.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Util
     * @param {number} [start=0] The start of the range.
     * @param {number} end The end of the range.
     * @param {number} [step=1] The value to increment or decrement by.
     * @returns {Array} Returns the range of numbers.
     * @see _.inRange, _.rangeRight
     * @example
     *
     * _.range(4);
     * // => [0, 1, 2, 3]
     *
     * _.range(-4);
     * // => [0, -1, -2, -3]
     *
     * _.range(1, 5);
     * // => [1, 2, 3, 4]
     *
     * _.range(0, 20, 5);
     * // => [0, 5, 10, 15]
     *
     * _.range(0, -4, -1);
     * // => [0, -1, -2, -3]
     *
     * _.range(1, 4, 0);
     * // => [1, 1, 1]
     *
     * _.range(0);
     * // => []
     */
    var range = createRange();

    /**
     * This method is like `_.range` except that it populates values in
     * descending order.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Util
     * @param {number} [start=0] The start of the range.
     * @param {number} end The end of the range.
     * @param {number} [step=1] The value to increment or decrement by.
     * @returns {Array} Returns the range of numbers.
     * @see _.inRange, _.range
     * @example
     *
     * _.rangeRight(4);
     * // => [3, 2, 1, 0]
     *
     * _.rangeRight(-4);
     * // => [-3, -2, -1, 0]
     *
     * _.rangeRight(1, 5);
     * // => [4, 3, 2, 1]
     *
     * _.rangeRight(0, 20, 5);
     * // => [15, 10, 5, 0]
     *
     * _.rangeRight(0, -4, -1);
     * // => [-3, -2, -1, 0]
     *
     * _.rangeRight(1, 4, 0);
     * // => [1, 1, 1]
     *
     * _.rangeRight(0);
     * // => []
     */
    var rangeRight = createRange(true);

    /**
     * This method returns a new empty array.
     *
     * @static
     * @memberOf _
     * @since 4.13.0
     * @category Util
     * @returns {Array} Returns the new empty array.
     * @example
     *
     * var arrays = _.times(2, _.stubArray);
     *
     * console.log(arrays);
     * // => [[], []]
     *
     * console.log(arrays[0] === arrays[1]);
     * // => false
     */
    function stubArray() {
      return [];
    }

    /**
     * This method returns `false`.
     *
     * @static
     * @memberOf _
     * @since 4.13.0
     * @category Util
     * @returns {boolean} Returns `false`.
     * @example
     *
     * _.times(2, _.stubFalse);
     * // => [false, false]
     */
    function stubFalse() {
      return false;
    }

    /**
     * This method returns a new empty object.
     *
     * @static
     * @memberOf _
     * @since 4.13.0
     * @category Util
     * @returns {Object} Returns the new empty object.
     * @example
     *
     * var objects = _.times(2, _.stubObject);
     *
     * console.log(objects);
     * // => [{}, {}]
     *
     * console.log(objects[0] === objects[1]);
     * // => false
     */
    function stubObject() {
      return {};
    }

    /**
     * This method returns an empty string.
     *
     * @static
     * @memberOf _
     * @since 4.13.0
     * @category Util
     * @returns {string} Returns the empty string.
     * @example
     *
     * _.times(2, _.stubString);
     * // => ['', '']
     */
    function stubString() {
      return '';
    }

    /**
     * This method returns `true`.
     *
     * @static
     * @memberOf _
     * @since 4.13.0
     * @category Util
     * @returns {boolean} Returns `true`.
     * @example
     *
     * _.times(2, _.stubTrue);
     * // => [true, true]
     */
    function stubTrue() {
      return true;
    }

    /**
     * Invokes the iteratee `n` times, returning an array of the results of
     * each invocation. The iteratee is invoked with one argument; (index).
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Util
     * @param {number} n The number of times to invoke `iteratee`.
     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
     * @returns {Array} Returns the array of results.
     * @example
     *
     * _.times(3, String);
     * // => ['0', '1', '2']
     *
     *  _.times(4, _.constant(0));
     * // => [0, 0, 0, 0]
     */
    function times(n, iteratee) {
      n = toInteger(n);
      if (n < 1 || n > MAX_SAFE_INTEGER) {
        return [];
      }
      var index = MAX_ARRAY_LENGTH,
          length = nativeMin(n, MAX_ARRAY_LENGTH);

      iteratee = getIteratee(iteratee);
      n -= MAX_ARRAY_LENGTH;

      var result = baseTimes(length, iteratee);
      while (++index < n) {
        iteratee(index);
      }
      return result;
    }

    /**
     * Converts `value` to a property path array.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Util
     * @param {*} value The value to convert.
     * @returns {Array} Returns the new property path array.
     * @example
     *
     * _.toPath('a.b.c');
     * // => ['a', 'b', 'c']
     *
     * _.toPath('a[0].b.c');
     * // => ['a', '0', 'b', 'c']
     */
    function toPath(value) {
      if (isArray(value)) {
        return arrayMap(value, toKey);
      }
      return isSymbol(value) ? [value] : copyArray(stringToPath(toString(value)));
    }

    /**
     * Generates a unique ID. If `prefix` is given, the ID is appended to it.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Util
     * @param {string} [prefix=''] The value to prefix the ID with.
     * @returns {string} Returns the unique ID.
     * @example
     *
     * _.uniqueId('contact_');
     * // => 'contact_104'
     *
     * _.uniqueId();
     * // => '105'
     */
    function uniqueId(prefix) {
      var id = ++idCounter;
      return toString(prefix) + id;
    }

    /*------------------------------------------------------------------------*/

    /**
     * Adds two numbers.
     *
     * @static
     * @memberOf _
     * @since 3.4.0
     * @category Math
     * @param {number} augend The first number in an addition.
     * @param {number} addend The second number in an addition.
     * @returns {number} Returns the total.
     * @example
     *
     * _.add(6, 4);
     * // => 10
     */
    var add = createMathOperation(function(augend, addend) {
      return augend + addend;
    }, 0);

    /**
     * Computes `number` rounded up to `precision`.
     *
     * @static
     * @memberOf _
     * @since 3.10.0
     * @category Math
     * @param {number} number The number to round up.
     * @param {number} [precision=0] The precision to round up to.
     * @returns {number} Returns the rounded up number.
     * @example
     *
     * _.ceil(4.006);
     * // => 5
     *
     * _.ceil(6.004, 2);
     * // => 6.01
     *
     * _.ceil(6040, -2);
     * // => 6100
     */
    var ceil = createRound('ceil');

    /**
     * Divide two numbers.
     *
     * @static
     * @memberOf _
     * @since 4.7.0
     * @category Math
     * @param {number} dividend The first number in a division.
     * @param {number} divisor The second number in a division.
     * @returns {number} Returns the quotient.
     * @example
     *
     * _.divide(6, 4);
     * // => 1.5
     */
    var divide = createMathOperation(function(dividend, divisor) {
      return dividend / divisor;
    }, 1);

    /**
     * Computes `number` rounded down to `precision`.
     *
     * @static
     * @memberOf _
     * @since 3.10.0
     * @category Math
     * @param {number} number The number to round down.
     * @param {number} [precision=0] The precision to round down to.
     * @returns {number} Returns the rounded down number.
     * @example
     *
     * _.floor(4.006);
     * // => 4
     *
     * _.floor(0.046, 2);
     * // => 0.04
     *
     * _.floor(4060, -2);
     * // => 4000
     */
    var floor = createRound('floor');

    /**
     * Computes the maximum value of `array`. If `array` is empty or falsey,
     * `undefined` is returned.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Math
     * @param {Array} array The array to iterate over.
     * @returns {*} Returns the maximum value.
     * @example
     *
     * _.max([4, 2, 8, 6]);
     * // => 8
     *
     * _.max([]);
     * // => undefined
     */
    function max(array) {
      return (array && array.length)
        ? baseExtremum(array, identity, baseGt)
        : undefined;
    }

    /**
     * This method is like `_.max` except that it accepts `iteratee` which is
     * invoked for each element in `array` to generate the criterion by which
     * the value is ranked. The iteratee is invoked with one argument: (value).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Math
     * @param {Array} array The array to iterate over.
     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
     * @returns {*} Returns the maximum value.
     * @example
     *
     * var objects = [{ 'n': 1 }, { 'n': 2 }];
     *
     * _.maxBy(objects, function(o) { return o.n; });
     * // => { 'n': 2 }
     *
     * // The `_.property` iteratee shorthand.
     * _.maxBy(objects, 'n');
     * // => { 'n': 2 }
     */
    function maxBy(array, iteratee) {
      return (array && array.length)
        ? baseExtremum(array, getIteratee(iteratee, 2), baseGt)
        : undefined;
    }

    /**
     * Computes the mean of the values in `array`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Math
     * @param {Array} array The array to iterate over.
     * @returns {number} Returns the mean.
     * @example
     *
     * _.mean([4, 2, 8, 6]);
     * // => 5
     */
    function mean(array) {
      return baseMean(array, identity);
    }

    /**
     * This method is like `_.mean` except that it accepts `iteratee` which is
     * invoked for each element in `array` to generate the value to be averaged.
     * The iteratee is invoked with one argument: (value).
     *
     * @static
     * @memberOf _
     * @since 4.7.0
     * @category Math
     * @param {Array} array The array to iterate over.
     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
     * @returns {number} Returns the mean.
     * @example
     *
     * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];
     *
     * _.meanBy(objects, function(o) { return o.n; });
     * // => 5
     *
     * // The `_.property` iteratee shorthand.
     * _.meanBy(objects, 'n');
     * // => 5
     */
    function meanBy(array, iteratee) {
      return baseMean(array, getIteratee(iteratee, 2));
    }

    /**
     * Computes the minimum value of `array`. If `array` is empty or falsey,
     * `undefined` is returned.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Math
     * @param {Array} array The array to iterate over.
     * @returns {*} Returns the minimum value.
     * @example
     *
     * _.min([4, 2, 8, 6]);
     * // => 2
     *
     * _.min([]);
     * // => undefined
     */
    function min(array) {
      return (array && array.length)
        ? baseExtremum(array, identity, baseLt)
        : undefined;
    }

    /**
     * This method is like `_.min` except that it accepts `iteratee` which is
     * invoked for each element in `array` to generate the criterion by which
     * the value is ranked. The iteratee is invoked with one argument: (value).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Math
     * @param {Array} array The array to iterate over.
     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
     * @returns {*} Returns the minimum value.
     * @example
     *
     * var objects = [{ 'n': 1 }, { 'n': 2 }];
     *
     * _.minBy(objects, function(o) { return o.n; });
     * // => { 'n': 1 }
     *
     * // The `_.property` iteratee shorthand.
     * _.minBy(objects, 'n');
     * // => { 'n': 1 }
     */
    function minBy(array, iteratee) {
      return (array && array.length)
        ? baseExtremum(array, getIteratee(iteratee, 2), baseLt)
        : undefined;
    }

    /**
     * Multiply two numbers.
     *
     * @static
     * @memberOf _
     * @since 4.7.0
     * @category Math
     * @param {number} multiplier The first number in a multiplication.
     * @param {number} multiplicand The second number in a multiplication.
     * @returns {number} Returns the product.
     * @example
     *
     * _.multiply(6, 4);
     * // => 24
     */
    var multiply = createMathOperation(function(multiplier, multiplicand) {
      return multiplier * multiplicand;
    }, 1);

    /**
     * Computes `number` rounded to `precision`.
     *
     * @static
     * @memberOf _
     * @since 3.10.0
     * @category Math
     * @param {number} number The number to round.
     * @param {number} [precision=0] The precision to round to.
     * @returns {number} Returns the rounded number.
     * @example
     *
     * _.round(4.006);
     * // => 4
     *
     * _.round(4.006, 2);
     * // => 4.01
     *
     * _.round(4060, -2);
     * // => 4100
     */
    var round = createRound('round');

    /**
     * Subtract two numbers.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Math
     * @param {number} minuend The first number in a subtraction.
     * @param {number} subtrahend The second number in a subtraction.
     * @returns {number} Returns the difference.
     * @example
     *
     * _.subtract(6, 4);
     * // => 2
     */
    var subtract = createMathOperation(function(minuend, subtrahend) {
      return minuend - subtrahend;
    }, 0);

    /**
     * Computes the sum of the values in `array`.
     *
     * @static
     * @memberOf _
     * @since 3.4.0
     * @category Math
     * @param {Array} array The array to iterate over.
     * @returns {number} Returns the sum.
     * @example
     *
     * _.sum([4, 2, 8, 6]);
     * // => 20
     */
    function sum(array) {
      return (array && array.length)
        ? baseSum(array, identity)
        : 0;
    }

    /**
     * This method is like `_.sum` except that it accepts `iteratee` which is
     * invoked for each element in `array` to generate the value to be summed.
     * The iteratee is invoked with one argument: (value).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Math
     * @param {Array} array The array to iterate over.
     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
     * @returns {number} Returns the sum.
     * @example
     *
     * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];
     *
     * _.sumBy(objects, function(o) { return o.n; });
     * // => 20
     *
     * // The `_.property` iteratee shorthand.
     * _.sumBy(objects, 'n');
     * // => 20
     */
    function sumBy(array, iteratee) {
      return (array && array.length)
        ? baseSum(array, getIteratee(iteratee, 2))
        : 0;
    }

    /*------------------------------------------------------------------------*/

    // Add methods that return wrapped values in chain sequences.
    lodash.after = after;
    lodash.ary = ary;
    lodash.assign = assign;
    lodash.assignIn = assignIn;
    lodash.assignInWith = assignInWith;
    lodash.assignWith = assignWith;
    lodash.at = at;
    lodash.before = before;
    lodash.bind = bind;
    lodash.bindAll = bindAll;
    lodash.bindKey = bindKey;
    lodash.castArray = castArray;
    lodash.chain = chain;
    lodash.chunk = chunk;
    lodash.compact = compact;
    lodash.concat = concat;
    lodash.cond = cond;
    lodash.conforms = conforms;
    lodash.constant = constant;
    lodash.countBy = countBy;
    lodash.create = create;
    lodash.curry = curry;
    lodash.curryRight = curryRight;
    lodash.debounce = debounce;
    lodash.defaults = defaults;
    lodash.defaultsDeep = defaultsDeep;
    lodash.defer = defer;
    lodash.delay = delay;
    lodash.difference = difference;
    lodash.differenceBy = differenceBy;
    lodash.differenceWith = differenceWith;
    lodash.drop = drop;
    lodash.dropRight = dropRight;
    lodash.dropRightWhile = dropRightWhile;
    lodash.dropWhile = dropWhile;
    lodash.fill = fill;
    lodash.filter = filter;
    lodash.flatMap = flatMap;
    lodash.flatMapDeep = flatMapDeep;
    lodash.flatMapDepth = flatMapDepth;
    lodash.flatten = flatten;
    lodash.flattenDeep = flattenDeep;
    lodash.flattenDepth = flattenDepth;
    lodash.flip = flip;
    lodash.flow = flow;
    lodash.flowRight = flowRight;
    lodash.fromPairs = fromPairs;
    lodash.functions = functions;
    lodash.functionsIn = functionsIn;
    lodash.groupBy = groupBy;
    lodash.initial = initial;
    lodash.intersection = intersection;
    lodash.intersectionBy = intersectionBy;
    lodash.intersectionWith = intersectionWith;
    lodash.invert = invert;
    lodash.invertBy = invertBy;
    lodash.invokeMap = invokeMap;
    lodash.iteratee = iteratee;
    lodash.keyBy = keyBy;
    lodash.keys = keys;
    lodash.keysIn = keysIn;
    lodash.map = map;
    lodash.mapKeys = mapKeys;
    lodash.mapValues = mapValues;
    lodash.matches = matches;
    lodash.matchesProperty = matchesProperty;
    lodash.memoize = memoize;
    lodash.merge = merge;
    lodash.mergeWith = mergeWith;
    lodash.method = method;
    lodash.methodOf = methodOf;
    lodash.mixin = mixin;
    lodash.negate = negate;
    lodash.nthArg = nthArg;
    lodash.omit = omit;
    lodash.omitBy = omitBy;
    lodash.once = once;
    lodash.orderBy = orderBy;
    lodash.over = over;
    lodash.overArgs = overArgs;
    lodash.overEvery = overEvery;
    lodash.overSome = overSome;
    lodash.partial = partial;
    lodash.partialRight = partialRight;
    lodash.partition = partition;
    lodash.pick = pick;
    lodash.pickBy = pickBy;
    lodash.property = property;
    lodash.propertyOf = propertyOf;
    lodash.pull = pull;
    lodash.pullAll = pullAll;
    lodash.pullAllBy = pullAllBy;
    lodash.pullAllWith = pullAllWith;
    lodash.pullAt = pullAt;
    lodash.range = range;
    lodash.rangeRight = rangeRight;
    lodash.rearg = rearg;
    lodash.reject = reject;
    lodash.remove = remove;
    lodash.rest = rest;
    lodash.reverse = reverse;
    lodash.sampleSize = sampleSize;
    lodash.set = set;
    lodash.setWith = setWith;
    lodash.shuffle = shuffle;
    lodash.slice = slice;
    lodash.sortBy = sortBy;
    lodash.sortedUniq = sortedUniq;
    lodash.sortedUniqBy = sortedUniqBy;
    lodash.split = split;
    lodash.spread = spread;
    lodash.tail = tail;
    lodash.take = take;
    lodash.takeRight = takeRight;
    lodash.takeRightWhile = takeRightWhile;
    lodash.takeWhile = takeWhile;
    lodash.tap = tap;
    lodash.throttle = throttle;
    lodash.thru = thru;
    lodash.toArray = toArray;
    lodash.toPairs = toPairs;
    lodash.toPairsIn = toPairsIn;
    lodash.toPath = toPath;
    lodash.toPlainObject = toPlainObject;
    lodash.transform = transform;
    lodash.unary = unary;
    lodash.union = union;
    lodash.unionBy = unionBy;
    lodash.unionWith = unionWith;
    lodash.uniq = uniq;
    lodash.uniqBy = uniqBy;
    lodash.uniqWith = uniqWith;
    lodash.unset = unset;
    lodash.unzip = unzip;
    lodash.unzipWith = unzipWith;
    lodash.update = update;
    lodash.updateWith = updateWith;
    lodash.values = values;
    lodash.valuesIn = valuesIn;
    lodash.without = without;
    lodash.words = words;
    lodash.wrap = wrap;
    lodash.xor = xor;
    lodash.xorBy = xorBy;
    lodash.xorWith = xorWith;
    lodash.zip = zip;
    lodash.zipObject = zipObject;
    lodash.zipObjectDeep = zipObjectDeep;
    lodash.zipWith = zipWith;

    // Add aliases.
    lodash.entries = toPairs;
    lodash.entriesIn = toPairsIn;
    lodash.extend = assignIn;
    lodash.extendWith = assignInWith;

    // Add methods to `lodash.prototype`.
    mixin(lodash, lodash);

    /*------------------------------------------------------------------------*/

    // Add methods that return unwrapped values in chain sequences.
    lodash.add = add;
    lodash.attempt = attempt;
    lodash.camelCase = camelCase;
    lodash.capitalize = capitalize;
    lodash.ceil = ceil;
    lodash.clamp = clamp;
    lodash.clone = clone;
    lodash.cloneDeep = cloneDeep;
    lodash.cloneDeepWith = cloneDeepWith;
    lodash.cloneWith = cloneWith;
    lodash.conformsTo = conformsTo;
    lodash.deburr = deburr;
    lodash.defaultTo = defaultTo;
    lodash.divide = divide;
    lodash.endsWith = endsWith;
    lodash.eq = eq;
    lodash.escape = escape;
    lodash.escapeRegExp = escapeRegExp;
    lodash.every = every;
    lodash.find = find;
    lodash.findIndex = findIndex;
    lodash.findKey = findKey;
    lodash.findLast = findLast;
    lodash.findLastIndex = findLastIndex;
    lodash.findLastKey = findLastKey;
    lodash.floor = floor;
    lodash.forEach = forEach;
    lodash.forEachRight = forEachRight;
    lodash.forIn = forIn;
    lodash.forInRight = forInRight;
    lodash.forOwn = forOwn;
    lodash.forOwnRight = forOwnRight;
    lodash.get = get;
    lodash.gt = gt;
    lodash.gte = gte;
    lodash.has = has;
    lodash.hasIn = hasIn;
    lodash.head = head;
    lodash.identity = identity;
    lodash.includes = includes;
    lodash.indexOf = indexOf;
    lodash.inRange = inRange;
    lodash.invoke = invoke;
    lodash.isArguments = isArguments;
    lodash.isArray = isArray;
    lodash.isArrayBuffer = isArrayBuffer;
    lodash.isArrayLike = isArrayLike;
    lodash.isArrayLikeObject = isArrayLikeObject;
    lodash.isBoolean = isBoolean;
    lodash.isBuffer = isBuffer;
    lodash.isDate = isDate;
    lodash.isElement = isElement;
    lodash.isEmpty = isEmpty;
    lodash.isEqual = isEqual;
    lodash.isEqualWith = isEqualWith;
    lodash.isError = isError;
    lodash.isFinite = isFinite;
    lodash.isFunction = isFunction;
    lodash.isInteger = isInteger;
    lodash.isLength = isLength;
    lodash.isMap = isMap;
    lodash.isMatch = isMatch;
    lodash.isMatchWith = isMatchWith;
    lodash.isNaN = isNaN;
    lodash.isNative = isNative;
    lodash.isNil = isNil;
    lodash.isNull = isNull;
    lodash.isNumber = isNumber;
    lodash.isObject = isObject;
    lodash.isObjectLike = isObjectLike;
    lodash.isPlainObject = isPlainObject;
    lodash.isRegExp = isRegExp;
    lodash.isSafeInteger = isSafeInteger;
    lodash.isSet = isSet;
    lodash.isString = isString;
    lodash.isSymbol = isSymbol;
    lodash.isTypedArray = isTypedArray;
    lodash.isUndefined = isUndefined;
    lodash.isWeakMap = isWeakMap;
    lodash.isWeakSet = isWeakSet;
    lodash.join = join;
    lodash.kebabCase = kebabCase;
    lodash.last = last;
    lodash.lastIndexOf = lastIndexOf;
    lodash.lowerCase = lowerCase;
    lodash.lowerFirst = lowerFirst;
    lodash.lt = lt;
    lodash.lte = lte;
    lodash.max = max;
    lodash.maxBy = maxBy;
    lodash.mean = mean;
    lodash.meanBy = meanBy;
    lodash.min = min;
    lodash.minBy = minBy;
    lodash.stubArray = stubArray;
    lodash.stubFalse = stubFalse;
    lodash.stubObject = stubObject;
    lodash.stubString = stubString;
    lodash.stubTrue = stubTrue;
    lodash.multiply = multiply;
    lodash.nth = nth;
    lodash.noConflict = noConflict;
    lodash.noop = noop;
    lodash.now = now;
    lodash.pad = pad;
    lodash.padEnd = padEnd;
    lodash.padStart = padStart;
    lodash.parseInt = parseInt;
    lodash.random = random;
    lodash.reduce = reduce;
    lodash.reduceRight = reduceRight;
    lodash.repeat = repeat;
    lodash.replace = replace;
    lodash.result = result;
    lodash.round = round;
    lodash.runInContext = runInContext;
    lodash.sample = sample;
    lodash.size = size;
    lodash.snakeCase = snakeCase;
    lodash.some = some;
    lodash.sortedIndex = sortedIndex;
    lodash.sortedIndexBy = sortedIndexBy;
    lodash.sortedIndexOf = sortedIndexOf;
    lodash.sortedLastIndex = sortedLastIndex;
    lodash.sortedLastIndexBy = sortedLastIndexBy;
    lodash.sortedLastIndexOf = sortedLastIndexOf;
    lodash.startCase = startCase;
    lodash.startsWith = startsWith;
    lodash.subtract = subtract;
    lodash.sum = sum;
    lodash.sumBy = sumBy;
    lodash.template = template;
    lodash.times = times;
    lodash.toFinite = toFinite;
    lodash.toInteger = toInteger;
    lodash.toLength = toLength;
    lodash.toLower = toLower;
    lodash.toNumber = toNumber;
    lodash.toSafeInteger = toSafeInteger;
    lodash.toString = toString;
    lodash.toUpper = toUpper;
    lodash.trim = trim;
    lodash.trimEnd = trimEnd;
    lodash.trimStart = trimStart;
    lodash.truncate = truncate;
    lodash.unescape = unescape;
    lodash.uniqueId = uniqueId;
    lodash.upperCase = upperCase;
    lodash.upperFirst = upperFirst;

    // Add aliases.
    lodash.each = forEach;
    lodash.eachRight = forEachRight;
    lodash.first = head;

    mixin(lodash, (function() {
      var source = {};
      baseForOwn(lodash, function(func, methodName) {
        if (!hasOwnProperty.call(lodash.prototype, methodName)) {
          source[methodName] = func;
        }
      });
      return source;
    }()), { 'chain': false });

    /*------------------------------------------------------------------------*/

    /**
     * The semantic version number.
     *
     * @static
     * @memberOf _
     * @type {string}
     */
    lodash.VERSION = VERSION;

    // Assign default placeholders.
    arrayEach(['bind', 'bindKey', 'curry', 'curryRight', 'partial', 'partialRight'], function(methodName) {
      lodash[methodName].placeholder = lodash;
    });

    // Add `LazyWrapper` methods for `_.drop` and `_.take` variants.
    arrayEach(['drop', 'take'], function(methodName, index) {
      LazyWrapper.prototype[methodName] = function(n) {
        n = n === undefined ? 1 : nativeMax(toInteger(n), 0);

        var result = (this.__filtered__ && !index)
          ? new LazyWrapper(this)
          : this.clone();

        if (result.__filtered__) {
          result.__takeCount__ = nativeMin(n, result.__takeCount__);
        } else {
          result.__views__.push({
            'size': nativeMin(n, MAX_ARRAY_LENGTH),
            'type': methodName + (result.__dir__ < 0 ? 'Right' : '')
          });
        }
        return result;
      };

      LazyWrapper.prototype[methodName + 'Right'] = function(n) {
        return this.reverse()[methodName](n).reverse();
      };
    });

    // Add `LazyWrapper` methods that accept an `iteratee` value.
    arrayEach(['filter', 'map', 'takeWhile'], function(methodName, index) {
      var type = index + 1,
          isFilter = type == LAZY_FILTER_FLAG || type == LAZY_WHILE_FLAG;

      LazyWrapper.prototype[methodName] = function(iteratee) {
        var result = this.clone();
        result.__iteratees__.push({
          'iteratee': getIteratee(iteratee, 3),
          'type': type
        });
        result.__filtered__ = result.__filtered__ || isFilter;
        return result;
      };
    });

    // Add `LazyWrapper` methods for `_.head` and `_.last`.
    arrayEach(['head', 'last'], function(methodName, index) {
      var takeName = 'take' + (index ? 'Right' : '');

      LazyWrapper.prototype[methodName] = function() {
        return this[takeName](1).value()[0];
      };
    });

    // Add `LazyWrapper` methods for `_.initial` and `_.tail`.
    arrayEach(['initial', 'tail'], function(methodName, index) {
      var dropName = 'drop' + (index ? '' : 'Right');

      LazyWrapper.prototype[methodName] = function() {
        return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1);
      };
    });

    LazyWrapper.prototype.compact = function() {
      return this.filter(identity);
    };

    LazyWrapper.prototype.find = function(predicate) {
      return this.filter(predicate).head();
    };

    LazyWrapper.prototype.findLast = function(predicate) {
      return this.reverse().find(predicate);
    };

    LazyWrapper.prototype.invokeMap = baseRest(function(path, args) {
      if (typeof path == 'function') {
        return new LazyWrapper(this);
      }
      return this.map(function(value) {
        return baseInvoke(value, path, args);
      });
    });

    LazyWrapper.prototype.reject = function(predicate) {
      return this.filter(negate(getIteratee(predicate)));
    };

    LazyWrapper.prototype.slice = function(start, end) {
      start = toInteger(start);

      var result = this;
      if (result.__filtered__ && (start > 0 || end < 0)) {
        return new LazyWrapper(result);
      }
      if (start < 0) {
        result = result.takeRight(-start);
      } else if (start) {
        result = result.drop(start);
      }
      if (end !== undefined) {
        end = toInteger(end);
        result = end < 0 ? result.dropRight(-end) : result.take(end - start);
      }
      return result;
    };

    LazyWrapper.prototype.takeRightWhile = function(predicate) {
      return this.reverse().takeWhile(predicate).reverse();
    };

    LazyWrapper.prototype.toArray = function() {
      return this.take(MAX_ARRAY_LENGTH);
    };

    // Add `LazyWrapper` methods to `lodash.prototype`.
    baseForOwn(LazyWrapper.prototype, function(func, methodName) {
      var checkIteratee = /^(?:filter|find|map|reject)|While$/.test(methodName),
          isTaker = /^(?:head|last)$/.test(methodName),
          lodashFunc = lodash[isTaker ? ('take' + (methodName == 'last' ? 'Right' : '')) : methodName],
          retUnwrapped = isTaker || /^find/.test(methodName);

      if (!lodashFunc) {
        return;
      }
      lodash.prototype[methodName] = function() {
        var value = this.__wrapped__,
            args = isTaker ? [1] : arguments,
            isLazy = value instanceof LazyWrapper,
            iteratee = args[0],
            useLazy = isLazy || isArray(value);

        var interceptor = function(value) {
          var result = lodashFunc.apply(lodash, arrayPush([value], args));
          return (isTaker && chainAll) ? result[0] : result;
        };

        if (useLazy && checkIteratee && typeof iteratee == 'function' && iteratee.length != 1) {
          // Avoid lazy use if the iteratee has a "length" value other than `1`.
          isLazy = useLazy = false;
        }
        var chainAll = this.__chain__,
            isHybrid = !!this.__actions__.length,
            isUnwrapped = retUnwrapped && !chainAll,
            onlyLazy = isLazy && !isHybrid;

        if (!retUnwrapped && useLazy) {
          value = onlyLazy ? value : new LazyWrapper(this);
          var result = func.apply(value, args);
          result.__actions__.push({ 'func': thru, 'args': [interceptor], 'thisArg': undefined });
          return new LodashWrapper(result, chainAll);
        }
        if (isUnwrapped && onlyLazy) {
          return func.apply(this, args);
        }
        result = this.thru(interceptor);
        return isUnwrapped ? (isTaker ? result.value()[0] : result.value()) : result;
      };
    });

    // Add `Array` methods to `lodash.prototype`.
    arrayEach(['pop', 'push', 'shift', 'sort', 'splice', 'unshift'], function(methodName) {
      var func = arrayProto[methodName],
          chainName = /^(?:push|sort|unshift)$/.test(methodName) ? 'tap' : 'thru',
          retUnwrapped = /^(?:pop|shift)$/.test(methodName);

      lodash.prototype[methodName] = function() {
        var args = arguments;
        if (retUnwrapped && !this.__chain__) {
          var value = this.value();
          return func.apply(isArray(value) ? value : [], args);
        }
        return this[chainName](function(value) {
          return func.apply(isArray(value) ? value : [], args);
        });
      };
    });

    // Map minified method names to their real names.
    baseForOwn(LazyWrapper.prototype, function(func, methodName) {
      var lodashFunc = lodash[methodName];
      if (lodashFunc) {
        var key = (lodashFunc.name + ''),
            names = realNames[key] || (realNames[key] = []);

        names.push({ 'name': methodName, 'func': lodashFunc });
      }
    });

    realNames[createHybrid(undefined, WRAP_BIND_KEY_FLAG).name] = [{
      'name': 'wrapper',
      'func': undefined
    }];

    // Add methods to `LazyWrapper`.
    LazyWrapper.prototype.clone = lazyClone;
    LazyWrapper.prototype.reverse = lazyReverse;
    LazyWrapper.prototype.value = lazyValue;

    // Add chain sequence methods to the `lodash` wrapper.
    lodash.prototype.at = wrapperAt;
    lodash.prototype.chain = wrapperChain;
    lodash.prototype.commit = wrapperCommit;
    lodash.prototype.next = wrapperNext;
    lodash.prototype.plant = wrapperPlant;
    lodash.prototype.reverse = wrapperReverse;
    lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = wrapperValue;

    // Add lazy aliases.
    lodash.prototype.first = lodash.prototype.head;

    if (symIterator) {
      lodash.prototype[symIterator] = wrapperToIterator;
    }
    return lodash;
  });

  /*--------------------------------------------------------------------------*/

  // Export lodash.
  var _ = runInContext();

  // Some AMD build optimizers, like r.js, check for condition patterns like:
  if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {
    // Expose Lodash on the global object to prevent errors when Lodash is
    // loaded by a script tag in the presence of an AMD loader.
    // See http://requirejs.org/docs/errors.html#mismatch for more details.
    // Use `_.noConflict` to remove Lodash from the global object.
    root._ = _;

    // Define as an anonymous module so, through path mapping, it can be
    // referenced as the "underscore" module.
    define(function() {
      return _;
    });
  }
  // Check for `exports` after `define` in case a build optimizer adds it.
  else if (freeModule) {
    // Export for Node.js.
    (freeModule.exports = _)._ = _;
    // Export for CommonJS support.
    freeExports._ = _;
  }
  else {
    // Export to the global object.
    root._ = _;
  }
}.call(this));

}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{}],693:[function(require,module,exports){
(function (process){
'use strict';
var chalk = require('chalk');

var main = {
	info: chalk.blue('ℹ'),
	success: chalk.green('✔'),
	warning: chalk.yellow('⚠'),
	error: chalk.red('✖')
};

var win = {
	info: chalk.blue('i'),
	success: chalk.green('√'),
	warning: chalk.yellow('‼'),
	error: chalk.red('×')
};

module.exports = process.platform === 'win32' ? win : main;

}).call(this,require('_process'))
},{"_process":16,"chalk":695}],694:[function(require,module,exports){
'use strict';

function assembleStyles () {
	var styles = {
		modifiers: {
			reset: [0, 0],
			bold: [1, 22], // 21 isn't widely supported and 22 does the same thing
			dim: [2, 22],
			italic: [3, 23],
			underline: [4, 24],
			inverse: [7, 27],
			hidden: [8, 28],
			strikethrough: [9, 29]
		},
		colors: {
			black: [30, 39],
			red: [31, 39],
			green: [32, 39],
			yellow: [33, 39],
			blue: [34, 39],
			magenta: [35, 39],
			cyan: [36, 39],
			white: [37, 39],
			gray: [90, 39]
		},
		bgColors: {
			bgBlack: [40, 49],
			bgRed: [41, 49],
			bgGreen: [42, 49],
			bgYellow: [43, 49],
			bgBlue: [44, 49],
			bgMagenta: [45, 49],
			bgCyan: [46, 49],
			bgWhite: [47, 49]
		}
	};

	// fix humans
	styles.colors.grey = styles.colors.gray;

	Object.keys(styles).forEach(function (groupName) {
		var group = styles[groupName];

		Object.keys(group).forEach(function (styleName) {
			var style = group[styleName];

			styles[styleName] = group[styleName] = {
				open: '\u001b[' + style[0] + 'm',
				close: '\u001b[' + style[1] + 'm'
			};
		});

		Object.defineProperty(styles, groupName, {
			value: group,
			enumerable: false
		});
	});

	return styles;
}

Object.defineProperty(module, 'exports', {
	enumerable: true,
	get: assembleStyles
});

},{}],695:[function(require,module,exports){
(function (process){
'use strict';
var escapeStringRegexp = require('escape-string-regexp');
var ansiStyles = require('ansi-styles');
var stripAnsi = require('strip-ansi');
var hasAnsi = require('has-ansi');
var supportsColor = require('supports-color');
var defineProps = Object.defineProperties;
var isSimpleWindowsTerm = process.platform === 'win32' && !/^xterm/i.test(process.env.TERM);

function Chalk(options) {
	// detect mode if not set manually
	this.enabled = !options || options.enabled === undefined ? supportsColor : options.enabled;
}

// use bright blue on Windows as the normal blue color is illegible
if (isSimpleWindowsTerm) {
	ansiStyles.blue.open = '\u001b[94m';
}

var styles = (function () {
	var ret = {};

	Object.keys(ansiStyles).forEach(function (key) {
		ansiStyles[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles[key].close), 'g');

		ret[key] = {
			get: function () {
				return build.call(this, this._styles.concat(key));
			}
		};
	});

	return ret;
})();

var proto = defineProps(function chalk() {}, styles);

function build(_styles) {
	var builder = function () {
		return applyStyle.apply(builder, arguments);
	};

	builder._styles = _styles;
	builder.enabled = this.enabled;
	// __proto__ is used because we must return a function, but there is
	// no way to create a function with a different prototype.
	/* eslint-disable no-proto */
	builder.__proto__ = proto;

	return builder;
}

function applyStyle() {
	// support varags, but simply cast to string in case there's only one arg
	var args = arguments;
	var argsLen = args.length;
	var str = argsLen !== 0 && String(arguments[0]);

	if (argsLen > 1) {
		// don't slice `arguments`, it prevents v8 optimizations
		for (var a = 1; a < argsLen; a++) {
			str += ' ' + args[a];
		}
	}

	if (!this.enabled || !str) {
		return str;
	}

	var nestedStyles = this._styles;
	var i = nestedStyles.length;

	// Turns out that on Windows dimmed gray text becomes invisible in cmd.exe,
	// see https://github.com/chalk/chalk/issues/58
	// If we're on Windows and we're dealing with a gray color, temporarily make 'dim' a noop.
	var originalDim = ansiStyles.dim.open;
	if (isSimpleWindowsTerm && (nestedStyles.indexOf('gray') !== -1 || nestedStyles.indexOf('grey') !== -1)) {
		ansiStyles.dim.open = '';
	}

	while (i--) {
		var code = ansiStyles[nestedStyles[i]];

		// Replace any instances already present with a re-opening code
		// otherwise only the part of the string until said closing code
		// will be colored, and the rest will simply be 'plain'.
		str = code.open + str.replace(code.closeRe, code.open) + code.close;
	}

	// Reset the original 'dim' if we changed it to work around the Windows dimmed gray issue.
	ansiStyles.dim.open = originalDim;

	return str;
}

function init() {
	var ret = {};

	Object.keys(styles).forEach(function (name) {
		ret[name] = {
			get: function () {
				return build.call(this, [name]);
			}
		};
	});

	return ret;
}

defineProps(Chalk.prototype, init());

module.exports = new Chalk();
module.exports.styles = ansiStyles;
module.exports.hasColor = hasAnsi;
module.exports.stripColor = stripAnsi;
module.exports.supportsColor = supportsColor;

}).call(this,require('_process'))
},{"_process":16,"ansi-styles":694,"escape-string-regexp":604,"has-ansi":631,"strip-ansi":869,"supports-color":696}],696:[function(require,module,exports){
(function (process){
'use strict';
var argv = process.argv;

var terminator = argv.indexOf('--');
var hasFlag = function (flag) {
	flag = '--' + flag;
	var pos = argv.indexOf(flag);
	return pos !== -1 && (terminator !== -1 ? pos < terminator : true);
};

module.exports = (function () {
	if ('FORCE_COLOR' in process.env) {
		return true;
	}

	if (hasFlag('no-color') ||
		hasFlag('no-colors') ||
		hasFlag('color=false')) {
		return false;
	}

	if (hasFlag('color') ||
		hasFlag('colors') ||
		hasFlag('color=true') ||
		hasFlag('color=always')) {
		return true;
	}

	if (process.stdout && !process.stdout.isTTY) {
		return false;
	}

	if (process.platform === 'win32') {
		return true;
	}

	if ('COLORTERM' in process.env) {
		return true;
	}

	if (process.env.TERM === 'dumb') {
		return false;
	}

	if (/^screen|^xterm|^vt100|color|ansi|cygwin|linux/i.test(process.env.TERM)) {
		return true;
	}

	return false;
})();

}).call(this,require('_process'))
},{"_process":16}],697:[function(require,module,exports){
module.exports=[
  "abs",
  "and",
  "annotation",
  "annotation-xml",
  "apply",
  "approx",
  "arccos",
  "arccosh",
  "arccot",
  "arccoth",
  "arccsc",
  "arccsch",
  "arcsec",
  "arcsech",
  "arcsin",
  "arcsinh",
  "arctan",
  "arctanh",
  "arg",
  "bind",
  "bvar",
  "card",
  "cartesianproduct",
  "cbytes",
  "ceiling",
  "cerror",
  "ci",
  "cn",
  "codomain",
  "complexes",
  "compose",
  "condition",
  "conjugate",
  "cos",
  "cosh",
  "cot",
  "coth",
  "cs",
  "csc",
  "csch",
  "csymbol",
  "curl",
  "declare",
  "degree",
  "determinant",
  "diff",
  "divergence",
  "divide",
  "domain",
  "domainofapplication",
  "emptyset",
  "encoding",
  "eq",
  "equivalent",
  "eulergamma",
  "exists",
  "exp",
  "exponentiale",
  "factorial",
  "factorof",
  "false",
  "floor",
  "fn",
  "forall",
  "function",
  "gcd",
  "geq",
  "grad",
  "gt",
  "ident",
  "image",
  "imaginary",
  "imaginaryi",
  "implies",
  "in",
  "infinity",
  "int",
  "integers",
  "intersect",
  "interval",
  "inverse",
  "lambda",
  "laplacian",
  "lcm",
  "leq",
  "limit",
  "list",
  "ln",
  "log",
  "logbase",
  "lowlimit",
  "lt",
  "m:apply",
  "m:mrow",
  "maction",
  "malign",
  "maligngroup",
  "malignmark",
  "malignscope",
  "math",
  "matrix",
  "matrixrow",
  "max",
  "mean",
  "median",
  "menclose",
  "merror",
  "mfenced",
  "mfrac",
  "mfraction",
  "mglyph",
  "mi",
  "mi\"",
  "min",
  "minus",
  "mlabeledtr",
  "mlongdiv",
  "mmultiscripts",
  "mn",
  "mo",
  "mode",
  "moment",
  "momentabout",
  "mover",
  "mpadded",
  "mphantom",
  "mprescripts",
  "mroot",
  "mrow",
  "ms",
  "mscarries",
  "mscarry",
  "msgroup",
  "msline",
  "mspace",
  "msqrt",
  "msrow",
  "mstack",
  "mstyle",
  "msub",
  "msubsup",
  "msup",
  "mtable",
  "mtd",
  "mtext",
  "mtr",
  "munder",
  "munderover",
  "naturalnumbers",
  "neq",
  "none",
  "not",
  "notanumber",
  "notin",
  "notprsubset",
  "notsubset",
  "or",
  "otherwise",
  "outerproduct",
  "partialdiff",
  "pi",
  "piece",
  "piecewice",
  "piecewise",
  "plus",
  "power",
  "primes",
  "product",
  "prsubset",
  "quotient",
  "rationals",
  "real",
  "reals",
  "reln",
  "rem",
  "root",
  "scalarproduct",
  "sdev",
  "sec",
  "sech",
  "select",
  "selector",
  "semantics",
  "sep",
  "set",
  "setdiff",
  "share",
  "sin",
  "sinh",
  "span",
  "subset",
  "sum",
  "tan",
  "tanh",
  "tendsto",
  "times",
  "transpose",
  "true",
  "union",
  "uplimit",
  "var",
  "variance",
  "vector",
  "vectorproduct",
  "xor"
]

},{}],698:[function(require,module,exports){
/*!
 * micromatch <https://github.com/jonschlinkert/micromatch>
 *
 * Copyright (c) 2014-2015, Jon Schlinkert.
 * Licensed under the MIT License.
 */

'use strict';

var expand = require('./lib/expand');
var utils = require('./lib/utils');

/**
 * The main function. Pass an array of filepaths,
 * and a string or array of glob patterns
 *
 * @param  {Array|String} `files`
 * @param  {Array|String} `patterns`
 * @param  {Object} `opts`
 * @return {Array} Array of matches
 */

function micromatch(files, patterns, opts) {
  if (!files || !patterns) return [];
  opts = opts || {};

  if (typeof opts.cache === 'undefined') {
    opts.cache = true;
  }

  if (!Array.isArray(patterns)) {
    return match(files, patterns, opts);
  }

  var len = patterns.length, i = 0;
  var omit = [], keep = [];

  while (len--) {
    var glob = patterns[i++];
    if (typeof glob === 'string' && glob.charCodeAt(0) === 33 /* ! */) {
      omit.push.apply(omit, match(files, glob.slice(1), opts));
    } else {
      keep.push.apply(keep, match(files, glob, opts));
    }
  }
  return utils.diff(keep, omit);
}

/**
 * Return an array of files that match the given glob pattern.
 *
 * This function is called by the main `micromatch` function If you only
 * need to pass a single pattern you might get very minor speed improvements
 * using this function.
 *
 * @param  {Array} `files`
 * @param  {String} `pattern`
 * @param  {Object} `options`
 * @return {Array}
 */

function match(files, pattern, opts) {
  if (utils.typeOf(files) !== 'string' && !Array.isArray(files)) {
    throw new Error(msg('match', 'files', 'a string or array'));
  }

  files = utils.arrayify(files);
  opts = opts || {};

  var negate = opts.negate || false;
  var orig = pattern;

  if (typeof pattern === 'string') {
    negate = pattern.charAt(0) === '!';
    if (negate) {
      pattern = pattern.slice(1);
    }

    // we need to remove the character regardless,
    // so the above logic is still needed
    if (opts.nonegate === true) {
      negate = false;
    }
  }

  var _isMatch = matcher(pattern, opts);
  var len = files.length, i = 0;
  var res = [];

  while (i < len) {
    var file = files[i++];
    var fp = utils.unixify(file, opts);

    if (!_isMatch(fp)) { continue; }
    res.push(fp);
  }

  if (res.length === 0) {
    if (opts.failglob === true) {
      throw new Error('micromatch.match() found no matches for: "' + orig + '".');
    }

    if (opts.nonull || opts.nullglob) {
      res.push(utils.unescapeGlob(orig));
    }
  }

  // if `negate` was defined, diff negated files
  if (negate) { res = utils.diff(files, res); }

  // if `ignore` was defined, diff ignored filed
  if (opts.ignore && opts.ignore.length) {
    pattern = opts.ignore;
    opts = utils.omit(opts, ['ignore']);
    res = utils.diff(res, micromatch(res, pattern, opts));
  }

  if (opts.nodupes) {
    return utils.unique(res);
  }
  return res;
}

/**
 * Returns a function that takes a glob pattern or array of glob patterns
 * to be used with `Array#filter()`. (Internally this function generates
 * the matching function using the [matcher] method).
 *
 * ```js
 * var fn = mm.filter('[a-c]');
 * ['a', 'b', 'c', 'd', 'e'].filter(fn);
 * //=> ['a', 'b', 'c']
 * ```
 * @param  {String|Array} `patterns` Can be a glob or array of globs.
 * @param  {Options} `opts` Options to pass to the [matcher] method.
 * @return {Function} Filter function to be passed to `Array#filter()`.
 */

function filter(patterns, opts) {
  if (!Array.isArray(patterns) && typeof patterns !== 'string') {
    throw new TypeError(msg('filter', 'patterns', 'a string or array'));
  }

  patterns = utils.arrayify(patterns);
  var len = patterns.length, i = 0;
  var patternMatchers = Array(len);
  while (i < len) {
    patternMatchers[i] = matcher(patterns[i++], opts);
  }

  return function(fp) {
    if (fp == null) return [];
    var len = patternMatchers.length, i = 0;
    var res = true;

    fp = utils.unixify(fp, opts);
    while (i < len) {
      var fn = patternMatchers[i++];
      if (!fn(fp)) {
        res = false;
        break;
      }
    }
    return res;
  };
}

/**
 * Returns true if the filepath contains the given
 * pattern. Can also return a function for matching.
 *
 * ```js
 * isMatch('foo.md', '*.md', {});
 * //=> true
 *
 * isMatch('*.md', {})('foo.md')
 * //=> true
 * ```
 * @param  {String} `fp`
 * @param  {String} `pattern`
 * @param  {Object} `opts`
 * @return {Boolean}
 */

function isMatch(fp, pattern, opts) {
  if (typeof fp !== 'string') {
    throw new TypeError(msg('isMatch', 'filepath', 'a string'));
  }

  fp = utils.unixify(fp, opts);
  if (utils.typeOf(pattern) === 'object') {
    return matcher(fp, pattern);
  }
  return matcher(pattern, opts)(fp);
}

/**
 * Returns true if the filepath matches the
 * given pattern.
 */

function contains(fp, pattern, opts) {
  if (typeof fp !== 'string') {
    throw new TypeError(msg('contains', 'pattern', 'a string'));
  }

  opts = opts || {};
  opts.contains = (pattern !== '');
  fp = utils.unixify(fp, opts);

  if (opts.contains && !utils.isGlob(pattern)) {
    return fp.indexOf(pattern) !== -1;
  }
  return matcher(pattern, opts)(fp);
}

/**
 * Returns true if a file path matches any of the
 * given patterns.
 *
 * @param  {String} `fp` The filepath to test.
 * @param  {String|Array} `patterns` Glob patterns to use.
 * @param  {Object} `opts` Options to pass to the `matcher()` function.
 * @return {String}
 */

function any(fp, patterns, opts) {
  if (!Array.isArray(patterns) && typeof patterns !== 'string') {
    throw new TypeError(msg('any', 'patterns', 'a string or array'));
  }

  patterns = utils.arrayify(patterns);
  var len = patterns.length;

  fp = utils.unixify(fp, opts);
  while (len--) {
    var isMatch = matcher(patterns[len], opts);
    if (isMatch(fp)) {
      return true;
    }
  }
  return false;
}

/**
 * Filter the keys of an object with the given `glob` pattern
 * and `options`
 *
 * @param  {Object} `object`
 * @param  {Pattern} `object`
 * @return {Array}
 */

function matchKeys(obj, glob, options) {
  if (utils.typeOf(obj) !== 'object') {
    throw new TypeError(msg('matchKeys', 'first argument', 'an object'));
  }

  var fn = matcher(glob, options);
  var res = {};

  for (var key in obj) {
    if (obj.hasOwnProperty(key) && fn(key)) {
      res[key] = obj[key];
    }
  }
  return res;
}

/**
 * Return a function for matching based on the
 * given `pattern` and `options`.
 *
 * @param  {String} `pattern`
 * @param  {Object} `options`
 * @return {Function}
 */

function matcher(pattern, opts) {
  // pattern is a function
  if (typeof pattern === 'function') {
    return pattern;
  }
  // pattern is a regex
  if (pattern instanceof RegExp) {
    return function(fp) {
      return pattern.test(fp);
    };
  }

  if (typeof pattern !== 'string') {
    throw new TypeError(msg('matcher', 'pattern', 'a string, regex, or function'));
  }

  // strings, all the way down...
  pattern = utils.unixify(pattern, opts);

  // pattern is a non-glob string
  if (!utils.isGlob(pattern)) {
    return utils.matchPath(pattern, opts);
  }
  // pattern is a glob string
  var re = makeRe(pattern, opts);

  // `matchBase` is defined
  if (opts && opts.matchBase) {
    return utils.hasFilename(re, opts);
  }
  // `matchBase` is not defined
  return function(fp) {
    fp = utils.unixify(fp, opts);
    return re.test(fp);
  };
}

/**
 * Create and cache a regular expression for matching
 * file paths.
 *
 * If the leading character in the `glob` is `!`, a negation
 * regex is returned.
 *
 * @param  {String} `glob`
 * @param  {Object} `options`
 * @return {RegExp}
 */

function toRegex(glob, options) {
  // clone options to prevent  mutating the original object
  var opts = Object.create(options || {});
  var flags = opts.flags || '';
  if (opts.nocase && flags.indexOf('i') === -1) {
    flags += 'i';
  }

  var parsed = expand(glob, opts);

  // pass in tokens to avoid parsing more than once
  opts.negated = opts.negated || parsed.negated;
  opts.negate = opts.negated;
  glob = wrapGlob(parsed.pattern, opts);
  var re;

  try {
    re = new RegExp(glob, flags);
    return re;
  } catch (err) {
    err.reason = 'micromatch invalid regex: (' + re + ')';
    if (opts.strict) throw new SyntaxError(err);
  }

  // we're only here if a bad pattern was used and the user
  // passed `options.silent`, so match nothing
  return /$^/;
}

/**
 * Create the regex to do the matching. If the leading
 * character in the `glob` is `!` a negation regex is returned.
 *
 * @param {String} `glob`
 * @param {Boolean} `negate`
 */

function wrapGlob(glob, opts) {
  var prefix = (opts && !opts.contains) ? '^' : '';
  var after = (opts && !opts.contains) ? '$' : '';
  glob = ('(?:' + glob + ')' + after);
  if (opts && opts.negate) {
    return prefix + ('(?!^' + glob + ').*$');
  }
  return prefix + glob;
}

/**
 * Create and cache a regular expression for matching file paths.
 * If the leading character in the `glob` is `!`, a negation
 * regex is returned.
 *
 * @param  {String} `glob`
 * @param  {Object} `options`
 * @return {RegExp}
 */

function makeRe(glob, opts) {
  if (utils.typeOf(glob) !== 'string') {
    throw new Error(msg('makeRe', 'glob', 'a string'));
  }
  return utils.cache(toRegex, glob, opts);
}

/**
 * Make error messages consistent. Follows this format:
 *
 * ```js
 * msg(methodName, argNumber, nativeType);
 * // example:
 * msg('matchKeys', 'first', 'an object');
 * ```
 *
 * @param  {String} `method`
 * @param  {String} `num`
 * @param  {String} `type`
 * @return {String}
 */

function msg(method, what, type) {
  return 'micromatch.' + method + '(): ' + what + ' should be ' + type + '.';
}

/**
 * Public methods
 */

/* eslint no-multi-spaces: 0 */
micromatch.any       = any;
micromatch.braces    = micromatch.braceExpand = utils.braces;
micromatch.contains  = contains;
micromatch.expand    = expand;
micromatch.filter    = filter;
micromatch.isMatch   = isMatch;
micromatch.makeRe    = makeRe;
micromatch.match     = match;
micromatch.matcher   = matcher;
micromatch.matchKeys = matchKeys;

/**
 * Expose `micromatch`
 */

module.exports = micromatch;

},{"./lib/expand":700,"./lib/utils":702}],699:[function(require,module,exports){
'use strict';

var chars = {}, unesc, temp;

function reverse(object, prepender) {
  return Object.keys(object).reduce(function(reversed, key) {
    var newKey = prepender ? prepender + key : key; // Optionally prepend a string to key.
    reversed[object[key]] = newKey; // Swap key and value.
    return reversed; // Return the result.
  }, {});
}

/**
 * Regex for common characters
 */

chars.escapeRegex = {
  '?': /\?/g,
  '@': /\@/g,
  '!': /\!/g,
  '+': /\+/g,
  '*': /\*/g,
  '(': /\(/g,
  ')': /\)/g,
  '[': /\[/g,
  ']': /\]/g
};

/**
 * Escape characters
 */

chars.ESC = {
  '?': '__UNESC_QMRK__',
  '@': '__UNESC_AMPE__',
  '!': '__UNESC_EXCL__',
  '+': '__UNESC_PLUS__',
  '*': '__UNESC_STAR__',
  ',': '__UNESC_COMMA__',
  '(': '__UNESC_LTPAREN__',
  ')': '__UNESC_RTPAREN__',
  '[': '__UNESC_LTBRACK__',
  ']': '__UNESC_RTBRACK__'
};

/**
 * Unescape characters
 */

chars.UNESC = unesc || (unesc = reverse(chars.ESC, '\\'));

chars.ESC_TEMP = {
  '?': '__TEMP_QMRK__',
  '@': '__TEMP_AMPE__',
  '!': '__TEMP_EXCL__',
  '*': '__TEMP_STAR__',
  '+': '__TEMP_PLUS__',
  ',': '__TEMP_COMMA__',
  '(': '__TEMP_LTPAREN__',
  ')': '__TEMP_RTPAREN__',
  '[': '__TEMP_LTBRACK__',
  ']': '__TEMP_RTBRACK__'
};

chars.TEMP = temp || (temp = reverse(chars.ESC_TEMP));

module.exports = chars;

},{}],700:[function(require,module,exports){
/*!
 * micromatch <https://github.com/jonschlinkert/micromatch>
 *
 * Copyright (c) 2014-2015, Jon Schlinkert.
 * Licensed under the MIT License.
 */

'use strict';

var utils = require('./utils');
var Glob = require('./glob');

/**
 * Expose `expand`
 */

module.exports = expand;

/**
 * Expand a glob pattern to resolve braces and
 * similar patterns before converting to regex.
 *
 * @param  {String|Array} `pattern`
 * @param  {Array} `files`
 * @param  {Options} `opts`
 * @return {Array}
 */

function expand(pattern, options) {
  if (typeof pattern !== 'string') {
    throw new TypeError('micromatch.expand(): argument should be a string.');
  }

  var glob = new Glob(pattern, options || {});
  var opts = glob.options;

  if (!utils.isGlob(pattern)) {
    glob.pattern = glob.pattern.replace(/([\/.])/g, '\\$1');
    return glob;
  }

  glob.pattern = glob.pattern.replace(/(\+)(?!\()/g, '\\$1');
  glob.pattern = glob.pattern.split('$').join('\\$');

  if (typeof opts.braces !== 'boolean' && typeof opts.nobraces !== 'boolean') {
    opts.braces = true;
  }

  if (glob.pattern === '.*') {
    return {
      pattern: '\\.' + star,
      tokens: tok,
      options: opts
    };
  }

  if (glob.pattern === '*') {
    return {
      pattern: oneStar(opts.dot),
      tokens: tok,
      options: opts
    };
  }

  // parse the glob pattern into tokens
  glob.parse();
  var tok = glob.tokens;
  tok.is.negated = opts.negated;

  // dotfile handling
  if ((opts.dotfiles === true || tok.is.dotfile) && opts.dot !== false) {
    opts.dotfiles = true;
    opts.dot = true;
  }

  if ((opts.dotdirs === true || tok.is.dotdir) && opts.dot !== false) {
    opts.dotdirs = true;
    opts.dot = true;
  }

  // check for braces with a dotfile pattern
  if (/[{,]\./.test(glob.pattern)) {
    opts.makeRe = false;
    opts.dot = true;
  }

  if (opts.nonegate !== true) {
    opts.negated = glob.negated;
  }

  // if the leading character is a dot or a slash, escape it
  if (glob.pattern.charAt(0) === '.' && glob.pattern.charAt(1) !== '/') {
    glob.pattern = '\\' + glob.pattern;
  }

  /**
   * Extended globs
   */

  // expand braces, e.g `{1..5}`
  glob.track('before braces');
  if (tok.is.braces) {
    glob.braces();
  }
  glob.track('after braces');

  // expand extglobs, e.g `foo/!(a|b)`
  glob.track('before extglob');
  if (tok.is.extglob) {
    glob.extglob();
  }
  glob.track('after extglob');

  // expand brackets, e.g `[[:alpha:]]`
  glob.track('before brackets');
  if (tok.is.brackets) {
    glob.brackets();
  }
  glob.track('after brackets');

  // special patterns
  glob._replace('[!', '[^');
  glob._replace('(?', '(%~');
  glob._replace(/\[\]/, '\\[\\]');
  glob._replace('/[', '/' + (opts.dot ? dotfiles : nodot) + '[', true);
  glob._replace('/?', '/' + (opts.dot ? dotfiles : nodot) + '[^/]', true);
  glob._replace('/.', '/(?=.)\\.', true);

  // windows drives
  glob._replace(/^(\w):([\\\/]+?)/gi, '(?=.)$1:$2', true);

  // negate slashes in exclusion ranges
  if (glob.pattern.indexOf('[^') !== -1) {
    glob.pattern = negateSlash(glob.pattern);
  }

  if (opts.globstar !== false && glob.pattern === '**') {
    glob.pattern = globstar(opts.dot);

  } else {
    glob.pattern = balance(glob.pattern, '[', ']');
    glob.escape(glob.pattern);

    // if the pattern has `**`
    if (tok.is.globstar) {
      glob.pattern = collapse(glob.pattern, '/**');
      glob.pattern = collapse(glob.pattern, '**/');
      glob._replace('/**/', '(?:/' + globstar(opts.dot) + '/|/)', true);
      glob._replace(/\*{2,}/g, '**');

      // 'foo/*'
      glob._replace(/(\w+)\*(?!\/)/g, '$1[^/]*?', true);
      glob._replace(/\*\*\/\*(\w)/g, globstar(opts.dot) + '\\/' + (opts.dot ? dotfiles : nodot) + '[^/]*?$1', true);

      if (opts.dot !== true) {
        glob._replace(/\*\*\/(.)/g, '(?:**\\/|)$1');
      }

      // 'foo/**' or '{**,*}', but not 'foo**'
      if (tok.path.dirname !== '' || /,\*\*|\*\*,/.test(glob.orig)) {
        glob._replace('**', globstar(opts.dot), true);
      }
    }

    // ends with /*
    glob._replace(/\/\*$/, '\\/' + oneStar(opts.dot), true);
    // ends with *, no slashes
    glob._replace(/(?!\/)\*$/, star, true);
    // has 'n*.' (partial wildcard w/ file extension)
    glob._replace(/([^\/]+)\*/, '$1' + oneStar(true), true);
    // has '*'
    glob._replace('*', oneStar(opts.dot), true);
    glob._replace('?.', '?\\.', true);
    glob._replace('?:', '?:', true);

    glob._replace(/\?+/g, function(match) {
      var len = match.length;
      if (len === 1) {
        return qmark;
      }
      return qmark + '{' + len + '}';
    });

    // escape '.abc' => '\\.abc'
    glob._replace(/\.([*\w]+)/g, '\\.$1');
    // fix '[^\\\\/]'
    glob._replace(/\[\^[\\\/]+\]/g, qmark);
    // '///' => '\/'
    glob._replace(/\/+/g, '\\/');
    // '\\\\\\' => '\\'
    glob._replace(/\\{2,}/g, '\\');
  }

  // unescape previously escaped patterns
  glob.unescape(glob.pattern);
  glob._replace('__UNESC_STAR__', '*');

  // escape dots that follow qmarks
  glob._replace('?.', '?\\.');

  // remove unnecessary slashes in character classes
  glob._replace('[^\\/]', qmark);

  if (glob.pattern.length > 1) {
    if (/^[\[?*]/.test(glob.pattern)) {
      // only prepend the string if we don't want to match dotfiles
      glob.pattern = (opts.dot ? dotfiles : nodot) + glob.pattern;
    }
  }

  return glob;
}

/**
 * Collapse repeated character sequences.
 *
 * ```js
 * collapse('a/../../../b', '../');
 * //=> 'a/../b'
 * ```
 *
 * @param  {String} `str`
 * @param  {String} `ch` Character sequence to collapse
 * @return {String}
 */

function collapse(str, ch) {
  var res = str.split(ch);
  var isFirst = res[0] === '';
  var isLast = res[res.length - 1] === '';
  res = res.filter(Boolean);
  if (isFirst) res.unshift('');
  if (isLast) res.push('');
  return res.join(ch);
}

/**
 * Negate slashes in exclusion ranges, per glob spec:
 *
 * ```js
 * negateSlash('[^foo]');
 * //=> '[^\\/foo]'
 * ```
 *
 * @param  {String} `str` glob pattern
 * @return {String}
 */

function negateSlash(str) {
  return str.replace(/\[\^([^\]]*?)\]/g, function(match, inner) {
    if (inner.indexOf('/') === -1) {
      inner = '\\/' + inner;
    }
    return '[^' + inner + ']';
  });
}

/**
 * Escape imbalanced braces/bracket. This is a very
 * basic, naive implementation that only does enough
 * to serve the purpose.
 */

function balance(str, a, b) {
  var aarr = str.split(a);
  var alen = aarr.join('').length;
  var blen = str.split(b).join('').length;

  if (alen !== blen) {
    str = aarr.join('\\' + a);
    return str.split(b).join('\\' + b);
  }
  return str;
}

/**
 * Special patterns to be converted to regex.
 * Heuristics are used to simplify patterns
 * and speed up processing.
 */

/* eslint no-multi-spaces: 0 */
var qmark       = '[^/]';
var star        = qmark + '*?';
var nodot       = '(?!\\.)(?=.)';
var dotfileGlob = '(?:\\/|^)\\.{1,2}($|\\/)';
var dotfiles    = '(?!' + dotfileGlob + ')(?=.)';
var twoStarDot  = '(?:(?!' + dotfileGlob + ').)*?';

/**
 * Create a regex for `*`.
 *
 * If `dot` is true, or the pattern does not begin with
 * a leading star, then return the simpler regex.
 */

function oneStar(dotfile) {
  return dotfile ? '(?!' + dotfileGlob + ')(?=.)' + star : (nodot + star);
}

function globstar(dotfile) {
  if (dotfile) { return twoStarDot; }
  return '(?:(?!(?:\\/|^)\\.).)*?';
}

},{"./glob":701,"./utils":702}],701:[function(require,module,exports){
'use strict';

var chars = require('./chars');
var utils = require('./utils');

/**
 * Expose `Glob`
 */

var Glob = module.exports = function Glob(pattern, options) {
  if (!(this instanceof Glob)) {
    return new Glob(pattern, options);
  }
  this.options = options || {};
  this.pattern = pattern;
  this.history = [];
  this.tokens = {};
  this.init(pattern);
};

/**
 * Initialize defaults
 */

Glob.prototype.init = function(pattern) {
  this.orig = pattern;
  this.negated = this.isNegated();
  this.options.track = this.options.track || false;
  this.options.makeRe = true;
};

/**
 * Push a change into `glob.history`. Useful
 * for debugging.
 */

Glob.prototype.track = function(msg) {
  if (this.options.track) {
    this.history.push({msg: msg, pattern: this.pattern});
  }
};

/**
 * Return true if `glob.pattern` was negated
 * with `!`, also remove the `!` from the pattern.
 *
 * @return {Boolean}
 */

Glob.prototype.isNegated = function() {
  if (this.pattern.charCodeAt(0) === 33 /* '!' */) {
    this.pattern = this.pattern.slice(1);
    return true;
  }
  return false;
};

/**
 * Expand braces in the given glob pattern.
 *
 * We only need to use the [braces] lib when
 * patterns are nested.
 */

Glob.prototype.braces = function() {
  if (this.options.nobraces !== true && this.options.nobrace !== true) {
    // naive/fast check for imbalanced characters
    var a = this.pattern.match(/[\{\(\[]/g);
    var b = this.pattern.match(/[\}\)\]]/g);

    // if imbalanced, don't optimize the pattern
    if (a && b && (a.length !== b.length)) {
      this.options.makeRe = false;
    }

    // expand brace patterns and join the resulting array
    var expanded = utils.braces(this.pattern, this.options);
    this.pattern = expanded.join('|');
  }
};

/**
 * Expand bracket expressions in `glob.pattern`
 */

Glob.prototype.brackets = function() {
  if (this.options.nobrackets !== true) {
    this.pattern = utils.brackets(this.pattern);
  }
};

/**
 * Expand bracket expressions in `glob.pattern`
 */

Glob.prototype.extglob = function() {
  if (this.options.noextglob === true) return;

  if (utils.isExtglob(this.pattern)) {
    this.pattern = utils.extglob(this.pattern, {escape: true});
  }
};

/**
 * Parse the given pattern
 */

Glob.prototype.parse = function(pattern) {
  this.tokens = utils.parseGlob(pattern || this.pattern, true);
  return this.tokens;
};

/**
 * Replace `a` with `b`. Also tracks the change before and
 * after each replacement. This is disabled by default, but
 * can be enabled by setting `options.track` to true.
 *
 * Also, when the pattern is a string, `.split()` is used,
 * because it's much faster than replace.
 *
 * @param  {RegExp|String} `a`
 * @param  {String} `b`
 * @param  {Boolean} `escape` When `true`, escapes `*` and `?` in the replacement.
 * @return {String}
 */

Glob.prototype._replace = function(a, b, escape) {
  this.track('before (find): "' + a + '" (replace with): "' + b + '"');
  if (escape) b = esc(b);
  if (a && b && typeof a === 'string') {
    this.pattern = this.pattern.split(a).join(b);
  } else {
    this.pattern = this.pattern.replace(a, b);
  }
  this.track('after');
};

/**
 * Escape special characters in the given string.
 *
 * @param  {String} `str` Glob pattern
 * @return {String}
 */

Glob.prototype.escape = function(str) {
  this.track('before escape: ');
  var re = /["\\](['"]?[^"'\\]['"]?)/g;

  this.pattern = str.replace(re, function($0, $1) {
    var o = chars.ESC;
    var ch = o && o[$1];
    if (ch) {
      return ch;
    }
    if (/[a-z]/i.test($0)) {
      return $0.split('\\').join('');
    }
    return $0;
  });

  this.track('after escape: ');
};

/**
 * Unescape special characters in the given string.
 *
 * @param  {String} `str`
 * @return {String}
 */

Glob.prototype.unescape = function(str) {
  var re = /__([A-Z]+)_([A-Z]+)__/g;
  this.pattern = str.replace(re, function($0, $1) {
    return chars[$1][$0];
  });
  this.pattern = unesc(this.pattern);
};

/**
 * Escape/unescape utils
 */

function esc(str) {
  str = str.split('?').join('%~');
  str = str.split('*').join('%%');
  return str;
}

function unesc(str) {
  str = str.split('%~').join('?');
  str = str.split('%%').join('*');
  return str;
}

},{"./chars":699,"./utils":702}],702:[function(require,module,exports){
(function (process){
'use strict';

var win32 = process && process.platform === 'win32';
var path = require('path');
var fileRe = require('filename-regex');
var utils = module.exports;

/**
 * Module dependencies
 */

utils.diff = require('arr-diff');
utils.unique = require('array-unique');
utils.braces = require('braces');
utils.brackets = require('expand-brackets');
utils.extglob = require('extglob');
utils.isExtglob = require('is-extglob');
utils.isGlob = require('is-glob');
utils.typeOf = require('kind-of');
utils.normalize = require('normalize-path');
utils.omit = require('object.omit');
utils.parseGlob = require('parse-glob');
utils.cache = require('regex-cache');

/**
 * Get the filename of a filepath
 *
 * @param {String} `string`
 * @return {String}
 */

utils.filename = function filename(fp) {
  var seg = fp.match(fileRe());
  return seg && seg[0];
};

/**
 * Returns a function that returns true if the given
 * pattern is the same as a given `filepath`
 *
 * @param {String} `pattern`
 * @return {Function}
 */

utils.isPath = function isPath(pattern, opts) {
  opts = opts || {};
  return function(fp) {
    var unixified = utils.unixify(fp, opts);
    if(opts.nocase){
      return pattern.toLowerCase() === unixified.toLowerCase();
    }
    return pattern === unixified;
  };
};

/**
 * Returns a function that returns true if the given
 * pattern contains a `filepath`
 *
 * @param {String} `pattern`
 * @return {Function}
 */

utils.hasPath = function hasPath(pattern, opts) {
  return function(fp) {
    return utils.unixify(pattern, opts).indexOf(fp) !== -1;
  };
};

/**
 * Returns a function that returns true if the given
 * pattern matches or contains a `filepath`
 *
 * @param {String} `pattern`
 * @return {Function}
 */

utils.matchPath = function matchPath(pattern, opts) {
  var fn = (opts && opts.contains)
    ? utils.hasPath(pattern, opts)
    : utils.isPath(pattern, opts);
  return fn;
};

/**
 * Returns a function that returns true if the given
 * regex matches the `filename` of a file path.
 *
 * @param {RegExp} `re`
 * @return {Boolean}
 */

utils.hasFilename = function hasFilename(re) {
  return function(fp) {
    var name = utils.filename(fp);
    return name && re.test(name);
  };
};

/**
 * Coerce `val` to an array
 *
 * @param  {*} val
 * @return {Array}
 */

utils.arrayify = function arrayify(val) {
  return !Array.isArray(val)
    ? [val]
    : val;
};

/**
 * Normalize all slashes in a file path or glob pattern to
 * forward slashes.
 */

utils.unixify = function unixify(fp, opts) {
  if (opts && opts.unixify === false) return fp;
  if (opts && opts.unixify === true || win32 || path.sep === '\\') {
    return utils.normalize(fp, false);
  }
  if (opts && opts.unescape === true) {
    return fp ? fp.toString().replace(/\\(\w)/g, '$1') : '';
  }
  return fp;
};

/**
 * Escape/unescape utils
 */

utils.escapePath = function escapePath(fp) {
  return fp.replace(/[\\.]/g, '\\$&');
};

utils.unescapeGlob = function unescapeGlob(fp) {
  return fp.replace(/[\\"']/g, '');
};

utils.escapeRe = function escapeRe(str) {
  return str.replace(/[-[\\$*+?.#^\s{}(|)\]]/g, '\\$&');
};

/**
 * Expose `utils`
 */

module.exports = utils;

}).call(this,require('_process'))
},{"_process":16,"arr-diff":46,"array-unique":50,"braces":115,"expand-brackets":606,"extglob":608,"filename-regex":610,"is-extglob":645,"is-glob":647,"kind-of":689,"normalize-path":707,"object.omit":712,"parse-glob":715,"path":14,"regex-cache":846}],703:[function(require,module,exports){
module.exports = minimatch
minimatch.Minimatch = Minimatch

var path = { sep: '/' }
try {
  path = require('path')
} catch (er) {}

var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {}
var expand = require('brace-expansion')

var plTypes = {
  '!': { open: '(?:(?!(?:', close: '))[^/]*?)'},
  '?': { open: '(?:', close: ')?' },
  '+': { open: '(?:', close: ')+' },
  '*': { open: '(?:', close: ')*' },
  '@': { open: '(?:', close: ')' }
}

// any single thing other than /
// don't need to escape / when using new RegExp()
var qmark = '[^/]'

// * => any number of characters
var star = qmark + '*?'

// ** when dots are allowed.  Anything goes, except .. and .
// not (^ or / followed by one or two dots followed by $ or /),
// followed by anything, any number of times.
var twoStarDot = '(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?'

// not a ^ or / followed by a dot,
// followed by anything, any number of times.
var twoStarNoDot = '(?:(?!(?:\\\/|^)\\.).)*?'

// characters that need to be escaped in RegExp.
var reSpecials = charSet('().*{}+?[]^$\\!')

// "abc" -> { a:true, b:true, c:true }
function charSet (s) {
  return s.split('').reduce(function (set, c) {
    set[c] = true
    return set
  }, {})
}

// normalizes slashes.
var slashSplit = /\/+/

minimatch.filter = filter
function filter (pattern, options) {
  options = options || {}
  return function (p, i, list) {
    return minimatch(p, pattern, options)
  }
}

function ext (a, b) {
  a = a || {}
  b = b || {}
  var t = {}
  Object.keys(b).forEach(function (k) {
    t[k] = b[k]
  })
  Object.keys(a).forEach(function (k) {
    t[k] = a[k]
  })
  return t
}

minimatch.defaults = function (def) {
  if (!def || !Object.keys(def).length) return minimatch

  var orig = minimatch

  var m = function minimatch (p, pattern, options) {
    return orig.minimatch(p, pattern, ext(def, options))
  }

  m.Minimatch = function Minimatch (pattern, options) {
    return new orig.Minimatch(pattern, ext(def, options))
  }

  return m
}

Minimatch.defaults = function (def) {
  if (!def || !Object.keys(def).length) return Minimatch
  return minimatch.defaults(def).Minimatch
}

function minimatch (p, pattern, options) {
  if (typeof pattern !== 'string') {
    throw new TypeError('glob pattern string required')
  }

  if (!options) options = {}

  // shortcut: comments match nothing.
  if (!options.nocomment && pattern.charAt(0) === '#') {
    return false
  }

  // "" only matches ""
  if (pattern.trim() === '') return p === ''

  return new Minimatch(pattern, options).match(p)
}

function Minimatch (pattern, options) {
  if (!(this instanceof Minimatch)) {
    return new Minimatch(pattern, options)
  }

  if (typeof pattern !== 'string') {
    throw new TypeError('glob pattern string required')
  }

  if (!options) options = {}
  pattern = pattern.trim()

  // windows support: need to use /, not \
  if (path.sep !== '/') {
    pattern = pattern.split(path.sep).join('/')
  }

  this.options = options
  this.set = []
  this.pattern = pattern
  this.regexp = null
  this.negate = false
  this.comment = false
  this.empty = false

  // make the set of regexps etc.
  this.make()
}

Minimatch.prototype.debug = function () {}

Minimatch.prototype.make = make
function make () {
  // don't do it more than once.
  if (this._made) return

  var pattern = this.pattern
  var options = this.options

  // empty patterns and comments match nothing.
  if (!options.nocomment && pattern.charAt(0) === '#') {
    this.comment = true
    return
  }
  if (!pattern) {
    this.empty = true
    return
  }

  // step 1: figure out negation, etc.
  this.parseNegate()

  // step 2: expand braces
  var set = this.globSet = this.braceExpand()

  if (options.debug) this.debug = console.error

  this.debug(this.pattern, set)

  // step 3: now we have a set, so turn each one into a series of path-portion
  // matching patterns.
  // These will be regexps, except in the case of "**", which is
  // set to the GLOBSTAR object for globstar behavior,
  // and will not contain any / characters
  set = this.globParts = set.map(function (s) {
    return s.split(slashSplit)
  })

  this.debug(this.pattern, set)

  // glob --> regexps
  set = set.map(function (s, si, set) {
    return s.map(this.parse, this)
  }, this)

  this.debug(this.pattern, set)

  // filter out everything that didn't compile properly.
  set = set.filter(function (s) {
    return s.indexOf(false) === -1
  })

  this.debug(this.pattern, set)

  this.set = set
}

Minimatch.prototype.parseNegate = parseNegate
function parseNegate () {
  var pattern = this.pattern
  var negate = false
  var options = this.options
  var negateOffset = 0

  if (options.nonegate) return

  for (var i = 0, l = pattern.length
    ; i < l && pattern.charAt(i) === '!'
    ; i++) {
    negate = !negate
    negateOffset++
  }

  if (negateOffset) this.pattern = pattern.substr(negateOffset)
  this.negate = negate
}

// Brace expansion:
// a{b,c}d -> abd acd
// a{b,}c -> abc ac
// a{0..3}d -> a0d a1d a2d a3d
// a{b,c{d,e}f}g -> abg acdfg acefg
// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg
//
// Invalid sets are not expanded.
// a{2..}b -> a{2..}b
// a{b}c -> a{b}c
minimatch.braceExpand = function (pattern, options) {
  return braceExpand(pattern, options)
}

Minimatch.prototype.braceExpand = braceExpand

function braceExpand (pattern, options) {
  if (!options) {
    if (this instanceof Minimatch) {
      options = this.options
    } else {
      options = {}
    }
  }

  pattern = typeof pattern === 'undefined'
    ? this.pattern : pattern

  if (typeof pattern === 'undefined') {
    throw new TypeError('undefined pattern')
  }

  if (options.nobrace ||
    !pattern.match(/\{.*\}/)) {
    // shortcut. no need to expand.
    return [pattern]
  }

  return expand(pattern)
}

// parse a component of the expanded set.
// At this point, no pattern may contain "/" in it
// so we're going to return a 2d array, where each entry is the full
// pattern, split on '/', and then turned into a regular expression.
// A regexp is made at the end which joins each array with an
// escaped /, and another full one which joins each regexp with |.
//
// Following the lead of Bash 4.1, note that "**" only has special meaning
// when it is the *only* thing in a path portion.  Otherwise, any series
// of * is equivalent to a single *.  Globstar behavior is enabled by
// default, and can be disabled by setting options.noglobstar.
Minimatch.prototype.parse = parse
var SUBPARSE = {}
function parse (pattern, isSub) {
  if (pattern.length > 1024 * 64) {
    throw new TypeError('pattern is too long')
  }

  var options = this.options

  // shortcuts
  if (!options.noglobstar && pattern === '**') return GLOBSTAR
  if (pattern === '') return ''

  var re = ''
  var hasMagic = !!options.nocase
  var escaping = false
  // ? => one single character
  var patternListStack = []
  var negativeLists = []
  var stateChar
  var inClass = false
  var reClassStart = -1
  var classStart = -1
  // . and .. never match anything that doesn't start with .,
  // even when options.dot is set.
  var patternStart = pattern.charAt(0) === '.' ? '' // anything
  // not (start or / followed by . or .. followed by / or end)
  : options.dot ? '(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))'
  : '(?!\\.)'
  var self = this

  function clearStateChar () {
    if (stateChar) {
      // we had some state-tracking character
      // that wasn't consumed by this pass.
      switch (stateChar) {
        case '*':
          re += star
          hasMagic = true
        break
        case '?':
          re += qmark
          hasMagic = true
        break
        default:
          re += '\\' + stateChar
        break
      }
      self.debug('clearStateChar %j %j', stateChar, re)
      stateChar = false
    }
  }

  for (var i = 0, len = pattern.length, c
    ; (i < len) && (c = pattern.charAt(i))
    ; i++) {
    this.debug('%s\t%s %s %j', pattern, i, re, c)

    // skip over any that are escaped.
    if (escaping && reSpecials[c]) {
      re += '\\' + c
      escaping = false
      continue
    }

    switch (c) {
      case '/':
        // completely not allowed, even escaped.
        // Should already be path-split by now.
        return false

      case '\\':
        clearStateChar()
        escaping = true
      continue

      // the various stateChar values
      // for the "extglob" stuff.
      case '?':
      case '*':
      case '+':
      case '@':
      case '!':
        this.debug('%s\t%s %s %j <-- stateChar', pattern, i, re, c)

        // all of those are literals inside a class, except that
        // the glob [!a] means [^a] in regexp
        if (inClass) {
          this.debug('  in class')
          if (c === '!' && i === classStart + 1) c = '^'
          re += c
          continue
        }

        // if we already have a stateChar, then it means
        // that there was something like ** or +? in there.
        // Handle the stateChar, then proceed with this one.
        self.debug('call clearStateChar %j', stateChar)
        clearStateChar()
        stateChar = c
        // if extglob is disabled, then +(asdf|foo) isn't a thing.
        // just clear the statechar *now*, rather than even diving into
        // the patternList stuff.
        if (options.noext) clearStateChar()
      continue

      case '(':
        if (inClass) {
          re += '('
          continue
        }

        if (!stateChar) {
          re += '\\('
          continue
        }

        patternListStack.push({
          type: stateChar,
          start: i - 1,
          reStart: re.length,
          open: plTypes[stateChar].open,
          close: plTypes[stateChar].close
        })
        // negation is (?:(?!js)[^/]*)
        re += stateChar === '!' ? '(?:(?!(?:' : '(?:'
        this.debug('plType %j %j', stateChar, re)
        stateChar = false
      continue

      case ')':
        if (inClass || !patternListStack.length) {
          re += '\\)'
          continue
        }

        clearStateChar()
        hasMagic = true
        var pl = patternListStack.pop()
        // negation is (?:(?!js)[^/]*)
        // The others are (?:<pattern>)<type>
        re += pl.close
        if (pl.type === '!') {
          negativeLists.push(pl)
        }
        pl.reEnd = re.length
      continue

      case '|':
        if (inClass || !patternListStack.length || escaping) {
          re += '\\|'
          escaping = false
          continue
        }

        clearStateChar()
        re += '|'
      continue

      // these are mostly the same in regexp and glob
      case '[':
        // swallow any state-tracking char before the [
        clearStateChar()

        if (inClass) {
          re += '\\' + c
          continue
        }

        inClass = true
        classStart = i
        reClassStart = re.length
        re += c
      continue

      case ']':
        //  a right bracket shall lose its special
        //  meaning and represent itself in
        //  a bracket expression if it occurs
        //  first in the list.  -- POSIX.2 2.8.3.2
        if (i === classStart + 1 || !inClass) {
          re += '\\' + c
          escaping = false
          continue
        }

        // handle the case where we left a class open.
        // "[z-a]" is valid, equivalent to "\[z-a\]"
        if (inClass) {
          // split where the last [ was, make sure we don't have
          // an invalid re. if so, re-walk the contents of the
          // would-be class to re-translate any characters that
          // were passed through as-is
          // TODO: It would probably be faster to determine this
          // without a try/catch and a new RegExp, but it's tricky
          // to do safely.  For now, this is safe and works.
          var cs = pattern.substring(classStart + 1, i)
          try {
            RegExp('[' + cs + ']')
          } catch (er) {
            // not a valid class!
            var sp = this.parse(cs, SUBPARSE)
            re = re.substr(0, reClassStart) + '\\[' + sp[0] + '\\]'
            hasMagic = hasMagic || sp[1]
            inClass = false
            continue
          }
        }

        // finish up the class.
        hasMagic = true
        inClass = false
        re += c
      continue

      default:
        // swallow any state char that wasn't consumed
        clearStateChar()

        if (escaping) {
          // no need
          escaping = false
        } else if (reSpecials[c]
          && !(c === '^' && inClass)) {
          re += '\\'
        }

        re += c

    } // switch
  } // for

  // handle the case where we left a class open.
  // "[abc" is valid, equivalent to "\[abc"
  if (inClass) {
    // split where the last [ was, and escape it
    // this is a huge pita.  We now have to re-walk
    // the contents of the would-be class to re-translate
    // any characters that were passed through as-is
    cs = pattern.substr(classStart + 1)
    sp = this.parse(cs, SUBPARSE)
    re = re.substr(0, reClassStart) + '\\[' + sp[0]
    hasMagic = hasMagic || sp[1]
  }

  // handle the case where we had a +( thing at the *end*
  // of the pattern.
  // each pattern list stack adds 3 chars, and we need to go through
  // and escape any | chars that were passed through as-is for the regexp.
  // Go through and escape them, taking care not to double-escape any
  // | chars that were already escaped.
  for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
    var tail = re.slice(pl.reStart + pl.open.length)
    this.debug('setting tail', re, pl)
    // maybe some even number of \, then maybe 1 \, followed by a |
    tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function (_, $1, $2) {
      if (!$2) {
        // the | isn't already escaped, so escape it.
        $2 = '\\'
      }

      // need to escape all those slashes *again*, without escaping the
      // one that we need for escaping the | character.  As it works out,
      // escaping an even number of slashes can be done by simply repeating
      // it exactly after itself.  That's why this trick works.
      //
      // I am sorry that you have to see this.
      return $1 + $1 + $2 + '|'
    })

    this.debug('tail=%j\n   %s', tail, tail, pl, re)
    var t = pl.type === '*' ? star
      : pl.type === '?' ? qmark
      : '\\' + pl.type

    hasMagic = true
    re = re.slice(0, pl.reStart) + t + '\\(' + tail
  }

  // handle trailing things that only matter at the very end.
  clearStateChar()
  if (escaping) {
    // trailing \\
    re += '\\\\'
  }

  // only need to apply the nodot start if the re starts with
  // something that could conceivably capture a dot
  var addPatternStart = false
  switch (re.charAt(0)) {
    case '.':
    case '[':
    case '(': addPatternStart = true
  }

  // Hack to work around lack of negative lookbehind in JS
  // A pattern like: *.!(x).!(y|z) needs to ensure that a name
  // like 'a.xyz.yz' doesn't match.  So, the first negative
  // lookahead, has to look ALL the way ahead, to the end of
  // the pattern.
  for (var n = negativeLists.length - 1; n > -1; n--) {
    var nl = negativeLists[n]

    var nlBefore = re.slice(0, nl.reStart)
    var nlFirst = re.slice(nl.reStart, nl.reEnd - 8)
    var nlLast = re.slice(nl.reEnd - 8, nl.reEnd)
    var nlAfter = re.slice(nl.reEnd)

    nlLast += nlAfter

    // Handle nested stuff like *(*.js|!(*.json)), where open parens
    // mean that we should *not* include the ) in the bit that is considered
    // "after" the negated section.
    var openParensBefore = nlBefore.split('(').length - 1
    var cleanAfter = nlAfter
    for (i = 0; i < openParensBefore; i++) {
      cleanAfter = cleanAfter.replace(/\)[+*?]?/, '')
    }
    nlAfter = cleanAfter

    var dollar = ''
    if (nlAfter === '' && isSub !== SUBPARSE) {
      dollar = '$'
    }
    var newRe = nlBefore + nlFirst + nlAfter + dollar + nlLast
    re = newRe
  }

  // if the re is not "" at this point, then we need to make sure
  // it doesn't match against an empty path part.
  // Otherwise a/* will match a/, which it should not.
  if (re !== '' && hasMagic) {
    re = '(?=.)' + re
  }

  if (addPatternStart) {
    re = patternStart + re
  }

  // parsing just a piece of a larger pattern.
  if (isSub === SUBPARSE) {
    return [re, hasMagic]
  }

  // skip the regexp for non-magical patterns
  // unescape anything in it, though, so that it'll be
  // an exact match against a file etc.
  if (!hasMagic) {
    return globUnescape(pattern)
  }

  var flags = options.nocase ? 'i' : ''
  try {
    var regExp = new RegExp('^' + re + '$', flags)
  } catch (er) {
    // If it was an invalid regular expression, then it can't match
    // anything.  This trick looks for a character after the end of
    // the string, which is of course impossible, except in multi-line
    // mode, but it's not a /m regex.
    return new RegExp('$.')
  }

  regExp._glob = pattern
  regExp._src = re

  return regExp
}

minimatch.makeRe = function (pattern, options) {
  return new Minimatch(pattern, options || {}).makeRe()
}

Minimatch.prototype.makeRe = makeRe
function makeRe () {
  if (this.regexp || this.regexp === false) return this.regexp

  // at this point, this.set is a 2d array of partial
  // pattern strings, or "**".
  //
  // It's better to use .match().  This function shouldn't
  // be used, really, but it's pretty convenient sometimes,
  // when you just want to work with a regex.
  var set = this.set

  if (!set.length) {
    this.regexp = false
    return this.regexp
  }
  var options = this.options

  var twoStar = options.noglobstar ? star
    : options.dot ? twoStarDot
    : twoStarNoDot
  var flags = options.nocase ? 'i' : ''

  var re = set.map(function (pattern) {
    return pattern.map(function (p) {
      return (p === GLOBSTAR) ? twoStar
      : (typeof p === 'string') ? regExpEscape(p)
      : p._src
    }).join('\\\/')
  }).join('|')

  // must match entire pattern
  // ending in a * or ** will make it less strict.
  re = '^(?:' + re + ')$'

  // can match anything, as long as it's not this.
  if (this.negate) re = '^(?!' + re + ').*$'

  try {
    this.regexp = new RegExp(re, flags)
  } catch (ex) {
    this.regexp = false
  }
  return this.regexp
}

minimatch.match = function (list, pattern, options) {
  options = options || {}
  var mm = new Minimatch(pattern, options)
  list = list.filter(function (f) {
    return mm.match(f)
  })
  if (mm.options.nonull && !list.length) {
    list.push(pattern)
  }
  return list
}

Minimatch.prototype.match = match
function match (f, partial) {
  this.debug('match', f, this.pattern)
  // short-circuit in the case of busted things.
  // comments, etc.
  if (this.comment) return false
  if (this.empty) return f === ''

  if (f === '/' && partial) return true

  var options = this.options

  // windows: need to use /, not \
  if (path.sep !== '/') {
    f = f.split(path.sep).join('/')
  }

  // treat the test path as a set of pathparts.
  f = f.split(slashSplit)
  this.debug(this.pattern, 'split', f)

  // just ONE of the pattern sets in this.set needs to match
  // in order for it to be valid.  If negating, then just one
  // match means that we have failed.
  // Either way, return on the first hit.

  var set = this.set
  this.debug(this.pattern, 'set', set)

  // Find the basename of the path by looking for the last non-empty segment
  var filename
  var i
  for (i = f.length - 1; i >= 0; i--) {
    filename = f[i]
    if (filename) break
  }

  for (i = 0; i < set.length; i++) {
    var pattern = set[i]
    var file = f
    if (options.matchBase && pattern.length === 1) {
      file = [filename]
    }
    var hit = this.matchOne(file, pattern, partial)
    if (hit) {
      if (options.flipNegate) return true
      return !this.negate
    }
  }

  // didn't get any hits.  this is success if it's a negative
  // pattern, failure otherwise.
  if (options.flipNegate) return false
  return this.negate
}

// set partial to true to test if, for example,
// "/a/b" matches the start of "/*/b/*/d"
// Partial means, if you run out of file before you run
// out of pattern, then that's fine, as long as all
// the parts match.
Minimatch.prototype.matchOne = function (file, pattern, partial) {
  var options = this.options

  this.debug('matchOne',
    { 'this': this, file: file, pattern: pattern })

  this.debug('matchOne', file.length, pattern.length)

  for (var fi = 0,
      pi = 0,
      fl = file.length,
      pl = pattern.length
      ; (fi < fl) && (pi < pl)
      ; fi++, pi++) {
    this.debug('matchOne loop')
    var p = pattern[pi]
    var f = file[fi]

    this.debug(pattern, p, f)

    // should be impossible.
    // some invalid regexp stuff in the set.
    if (p === false) return false

    if (p === GLOBSTAR) {
      this.debug('GLOBSTAR', [pattern, p, f])

      // "**"
      // a/**/b/**/c would match the following:
      // a/b/x/y/z/c
      // a/x/y/z/b/c
      // a/b/x/b/x/c
      // a/b/c
      // To do this, take the rest of the pattern after
      // the **, and see if it would match the file remainder.
      // If so, return success.
      // If not, the ** "swallows" a segment, and try again.
      // This is recursively awful.
      //
      // a/**/b/**/c matching a/b/x/y/z/c
      // - a matches a
      // - doublestar
      //   - matchOne(b/x/y/z/c, b/**/c)
      //     - b matches b
      //     - doublestar
      //       - matchOne(x/y/z/c, c) -> no
      //       - matchOne(y/z/c, c) -> no
      //       - matchOne(z/c, c) -> no
      //       - matchOne(c, c) yes, hit
      var fr = fi
      var pr = pi + 1
      if (pr === pl) {
        this.debug('** at the end')
        // a ** at the end will just swallow the rest.
        // We have found a match.
        // however, it will not swallow /.x, unless
        // options.dot is set.
        // . and .. are *never* matched by **, for explosively
        // exponential reasons.
        for (; fi < fl; fi++) {
          if (file[fi] === '.' || file[fi] === '..' ||
            (!options.dot && file[fi].charAt(0) === '.')) return false
        }
        return true
      }

      // ok, let's see if we can swallow whatever we can.
      while (fr < fl) {
        var swallowee = file[fr]

        this.debug('\nglobstar while', file, fr, pattern, pr, swallowee)

        // XXX remove this slice.  Just pass the start index.
        if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
          this.debug('globstar found match!', fr, fl, swallowee)
          // found a match.
          return true
        } else {
          // can't swallow "." or ".." ever.
          // can only swallow ".foo" when explicitly asked.
          if (swallowee === '.' || swallowee === '..' ||
            (!options.dot && swallowee.charAt(0) === '.')) {
            this.debug('dot detected!', file, fr, pattern, pr)
            break
          }

          // ** swallows a segment, and continue.
          this.debug('globstar swallow a segment, and continue')
          fr++
        }
      }

      // no match was found.
      // However, in partial mode, we can't say this is necessarily over.
      // If there's more *pattern* left, then
      if (partial) {
        // ran out of file
        this.debug('\n>>> no match, partial?', file, fr, pattern, pr)
        if (fr === fl) return true
      }
      return false
    }

    // something other than **
    // non-magic patterns just have to match exactly
    // patterns with magic have been turned into regexps.
    var hit
    if (typeof p === 'string') {
      if (options.nocase) {
        hit = f.toLowerCase() === p.toLowerCase()
      } else {
        hit = f === p
      }
      this.debug('string match', p, f, hit)
    } else {
      hit = f.match(p)
      this.debug('pattern match', p, f, hit)
    }

    if (!hit) return false
  }

  // Note: ending in / means that we'll get a final ""
  // at the end of the pattern.  This can only match a
  // corresponding "" at the end of the file.
  // If the file ends in /, then it can only match a
  // a pattern that ends in /, unless the pattern just
  // doesn't have any more for it. But, a/b/ should *not*
  // match "a/b/*", even though "" matches against the
  // [^/]*? pattern, except in partial mode, where it might
  // simply not be reached yet.
  // However, a/b/ should still satisfy a/*

  // now either we fell off the end of the pattern, or we're done.
  if (fi === fl && pi === pl) {
    // ran out of pattern and filename at the same time.
    // an exact hit!
    return true
  } else if (fi === fl) {
    // ran out of file, but still had pattern left.
    // this is ok if we're doing the match as part of
    // a glob fs traversal.
    return partial
  } else if (pi === pl) {
    // ran out of pattern, still have file left.
    // this is only acceptable if we're on the very last
    // empty segment of a file with a trailing slash.
    // a/* should match a/b/
    var emptyFileEnd = (fi === fl - 1) && (file[fi] === '')
    return emptyFileEnd
  }

  // should be unreachable.
  throw new Error('wtf?')
}

// replace stuff like \* with *
function globUnescape (s) {
  return s.replace(/\\(.)/g, '$1')
}

function regExpEscape (s) {
  return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&')
}

},{"brace-expansion":114,"path":14}],704:[function(require,module,exports){
module.exports = function (args, opts) {
    if (!opts) opts = {};

    var flags = { bools : {}, strings : {}, unknownFn: null };

    if (typeof opts['unknown'] === 'function') {
        flags.unknownFn = opts['unknown'];
    }

    if (typeof opts['boolean'] === 'boolean' && opts['boolean']) {
      flags.allBools = true;
    } else {
      [].concat(opts['boolean']).filter(Boolean).forEach(function (key) {
          flags.bools[key] = true;
      });
    }

    var aliases = {};
    Object.keys(opts.alias || {}).forEach(function (key) {
        aliases[key] = [].concat(opts.alias[key]);
        aliases[key].forEach(function (x) {
            aliases[x] = [key].concat(aliases[key].filter(function (y) {
                return x !== y;
            }));
        });
    });

    [].concat(opts.string).filter(Boolean).forEach(function (key) {
        flags.strings[key] = true;
        if (aliases[key]) {
            flags.strings[aliases[key]] = true;
        }
     });

    var defaults = opts['default'] || {};

    var argv = { _ : [] };
    Object.keys(flags.bools).forEach(function (key) {
        setArg(key, defaults[key] === undefined ? false : defaults[key]);
    });

    var notFlags = [];

    if (args.indexOf('--') !== -1) {
        notFlags = args.slice(args.indexOf('--')+1);
        args = args.slice(0, args.indexOf('--'));
    }

    function argDefined(key, arg) {
        return (flags.allBools && /^--[^=]+$/.test(arg)) ||
            flags.strings[key] || flags.bools[key] || aliases[key];
    }

    function setArg (key, val, arg) {
        if (arg && flags.unknownFn && !argDefined(key, arg)) {
            if (flags.unknownFn(arg) === false) return;
        }

        var value = !flags.strings[key] && isNumber(val)
            ? Number(val) : val
        ;
        setKey(argv, key.split('.'), value);

        (aliases[key] || []).forEach(function (x) {
            setKey(argv, x.split('.'), value);
        });
    }

    function setKey (obj, keys, value) {
        var o = obj;
        keys.slice(0,-1).forEach(function (key) {
            if (o[key] === undefined) o[key] = {};
            o = o[key];
        });

        var key = keys[keys.length - 1];
        if (o[key] === undefined || flags.bools[key] || typeof o[key] === 'boolean') {
            o[key] = value;
        }
        else if (Array.isArray(o[key])) {
            o[key].push(value);
        }
        else {
            o[key] = [ o[key], value ];
        }
    }

    function aliasIsBoolean(key) {
      return aliases[key].some(function (x) {
          return flags.bools[x];
      });
    }

    for (var i = 0; i < args.length; i++) {
        var arg = args[i];

        if (/^--.+=/.test(arg)) {
            // Using [\s\S] instead of . because js doesn't support the
            // 'dotall' regex modifier. See:
            // http://stackoverflow.com/a/1068308/13216
            var m = arg.match(/^--([^=]+)=([\s\S]*)$/);
            var key = m[1];
            var value = m[2];
            if (flags.bools[key]) {
                value = value !== 'false';
            }
            setArg(key, value, arg);
        }
        else if (/^--no-.+/.test(arg)) {
            var key = arg.match(/^--no-(.+)/)[1];
            setArg(key, false, arg);
        }
        else if (/^--.+/.test(arg)) {
            var key = arg.match(/^--(.+)/)[1];
            var next = args[i + 1];
            if (next !== undefined && !/^-/.test(next)
            && !flags.bools[key]
            && !flags.allBools
            && (aliases[key] ? !aliasIsBoolean(key) : true)) {
                setArg(key, next, arg);
                i++;
            }
            else if (/^(true|false)$/.test(next)) {
                setArg(key, next === 'true', arg);
                i++;
            }
            else {
                setArg(key, flags.strings[key] ? '' : true, arg);
            }
        }
        else if (/^-[^-]+/.test(arg)) {
            var letters = arg.slice(1,-1).split('');

            var broken = false;
            for (var j = 0; j < letters.length; j++) {
                var next = arg.slice(j+2);

                if (next === '-') {
                    setArg(letters[j], next, arg)
                    continue;
                }

                if (/[A-Za-z]/.test(letters[j]) && /=/.test(next)) {
                    setArg(letters[j], next.split('=')[1], arg);
                    broken = true;
                    break;
                }

                if (/[A-Za-z]/.test(letters[j])
                && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
                    setArg(letters[j], next, arg);
                    broken = true;
                    break;
                }

                if (letters[j+1] && letters[j+1].match(/\W/)) {
                    setArg(letters[j], arg.slice(j+2), arg);
                    broken = true;
                    break;
                }
                else {
                    setArg(letters[j], flags.strings[letters[j]] ? '' : true, arg);
                }
            }

            var key = arg.slice(-1)[0];
            if (!broken && key !== '-') {
                if (args[i+1] && !/^(-|--)[^-]/.test(args[i+1])
                && !flags.bools[key]
                && (aliases[key] ? !aliasIsBoolean(key) : true)) {
                    setArg(key, args[i+1], arg);
                    i++;
                }
                else if (args[i+1] && /true|false/.test(args[i+1])) {
                    setArg(key, args[i+1] === 'true', arg);
                    i++;
                }
                else {
                    setArg(key, flags.strings[key] ? '' : true, arg);
                }
            }
        }
        else {
            if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
                argv._.push(
                    flags.strings['_'] || !isNumber(arg) ? arg : Number(arg)
                );
            }
            if (opts.stopEarly) {
                argv._.push.apply(argv._, args.slice(i + 1));
                break;
            }
        }
    }

    Object.keys(defaults).forEach(function (key) {
        if (!hasKey(argv, key.split('.'))) {
            setKey(argv, key.split('.'), defaults[key]);

            (aliases[key] || []).forEach(function (x) {
                setKey(argv, x.split('.'), defaults[key]);
            });
        }
    });

    if (opts['--']) {
        argv['--'] = new Array();
        notFlags.forEach(function(key) {
            argv['--'].push(key);
        });
    }
    else {
        notFlags.forEach(function(key) {
            argv._.push(key);
        });
    }

    return argv;
};

function hasKey (obj, keys) {
    var o = obj;
    keys.slice(0,-1).forEach(function (key) {
        o = (o[key] || {});
    });

    var key = keys[keys.length - 1];
    return key in o;
}

function isNumber (x) {
    if (typeof x === 'number') return true;
    if (/^0x[0-9a-f]+$/i.test(x)) return true;
    return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
}


},{}],705:[function(require,module,exports){
(function (process){
var path = require('path');
var fs = require('fs');
var _0777 = parseInt('0777', 8);

module.exports = mkdirP.mkdirp = mkdirP.mkdirP = mkdirP;

function mkdirP (p, opts, f, made) {
    if (typeof opts === 'function') {
        f = opts;
        opts = {};
    }
    else if (!opts || typeof opts !== 'object') {
        opts = { mode: opts };
    }

    var mode = opts.mode;
    var xfs = opts.fs || fs;

    if (mode === undefined) {
        mode = _0777 & (~process.umask());
    }
    if (!made) made = null;

    var cb = f || function () {};
    p = path.resolve(p);

    xfs.mkdir(p, mode, function (er) {
        if (!er) {
            made = made || p;
            return cb(null, made);
        }
        switch (er.code) {
            case 'ENOENT':
                mkdirP(path.dirname(p), opts, function (er, made) {
                    if (er) cb(er, made);
                    else mkdirP(p, opts, cb, made);
                });
                break;

            // In the case of any other error, just see if there's a dir
            // there already.  If so, then hooray!  If not, then something
            // is borked.
            default:
                xfs.stat(p, function (er2, stat) {
                    // if the stat fails, then that's super weird.
                    // let the original error be the failure reason.
                    if (er2 || !stat.isDirectory()) cb(er, made)
                    else cb(null, made);
                });
                break;
        }
    });
}

mkdirP.sync = function sync (p, opts, made) {
    if (!opts || typeof opts !== 'object') {
        opts = { mode: opts };
    }

    var mode = opts.mode;
    var xfs = opts.fs || fs;

    if (mode === undefined) {
        mode = _0777 & (~process.umask());
    }
    if (!made) made = null;

    p = path.resolve(p);

    try {
        xfs.mkdirSync(p, mode);
        made = made || p;
    }
    catch (err0) {
        switch (err0.code) {
            case 'ENOENT' :
                made = sync(path.dirname(p), opts, made);
                sync(p, opts, made);
                break;

            // In the case of any other error, just see if there's a dir
            // there already.  If so, then hooray!  If not, then something
            // is borked.
            default:
                var stat;
                try {
                    stat = xfs.statSync(p);
                }
                catch (err1) {
                    throw err0;
                }
                if (!stat.isDirectory()) throw err0;
                break;
        }
    }

    return made;
};

}).call(this,require('_process'))
},{"_process":16,"fs":1,"path":14}],706:[function(require,module,exports){
/**
 * Helpers.
 */

var s = 1000;
var m = s * 60;
var h = m * 60;
var d = h * 24;
var y = d * 365.25;

/**
 * Parse or format the given `val`.
 *
 * Options:
 *
 *  - `long` verbose formatting [false]
 *
 * @param {String|Number} val
 * @param {Object} [options]
 * @throws {Error} throw an error if val is not a non-empty string or a number
 * @return {String|Number}
 * @api public
 */

module.exports = function(val, options) {
  options = options || {};
  var type = typeof val;
  if (type === 'string' && val.length > 0) {
    return parse(val);
  } else if (type === 'number' && isNaN(val) === false) {
    return options.long ? fmtLong(val) : fmtShort(val);
  }
  throw new Error(
    'val is not a non-empty string or a valid number. val=' +
      JSON.stringify(val)
  );
};

/**
 * Parse the given `str` and return milliseconds.
 *
 * @param {String} str
 * @return {Number}
 * @api private
 */

function parse(str) {
  str = String(str);
  if (str.length > 100) {
    return;
  }
  var match = /^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(
    str
  );
  if (!match) {
    return;
  }
  var n = parseFloat(match[1]);
  var type = (match[2] || 'ms').toLowerCase();
  switch (type) {
    case 'years':
    case 'year':
    case 'yrs':
    case 'yr':
    case 'y':
      return n * y;
    case 'days':
    case 'day':
    case 'd':
      return n * d;
    case 'hours':
    case 'hour':
    case 'hrs':
    case 'hr':
    case 'h':
      return n * h;
    case 'minutes':
    case 'minute':
    case 'mins':
    case 'min':
    case 'm':
      return n * m;
    case 'seconds':
    case 'second':
    case 'secs':
    case 'sec':
    case 's':
      return n * s;
    case 'milliseconds':
    case 'millisecond':
    case 'msecs':
    case 'msec':
    case 'ms':
      return n;
    default:
      return undefined;
  }
}

/**
 * Short format for `ms`.
 *
 * @param {Number} ms
 * @return {String}
 * @api private
 */

function fmtShort(ms) {
  if (ms >= d) {
    return Math.round(ms / d) + 'd';
  }
  if (ms >= h) {
    return Math.round(ms / h) + 'h';
  }
  if (ms >= m) {
    return Math.round(ms / m) + 'm';
  }
  if (ms >= s) {
    return Math.round(ms / s) + 's';
  }
  return ms + 'ms';
}

/**
 * Long format for `ms`.
 *
 * @param {Number} ms
 * @return {String}
 * @api private
 */

function fmtLong(ms) {
  return plural(ms, d, 'day') ||
    plural(ms, h, 'hour') ||
    plural(ms, m, 'minute') ||
    plural(ms, s, 'second') ||
    ms + ' ms';
}

/**
 * Pluralization helper.
 */

function plural(ms, n, name) {
  if (ms < n) {
    return;
  }
  if (ms < n * 1.5) {
    return Math.floor(ms / n) + ' ' + name;
  }
  return Math.ceil(ms / n) + ' ' + name + 's';
}

},{}],707:[function(require,module,exports){
/*!
 * normalize-path <https://github.com/jonschlinkert/normalize-path>
 *
 * Copyright (c) 2014-2017, Jon Schlinkert.
 * Released under the MIT License.
 */

var removeTrailingSeparator = require('remove-trailing-separator');

module.exports = function normalizePath(str, stripTrailing) {
  if (typeof str !== 'string') {
    throw new TypeError('expected a string');
  }
  str = str.replace(/[\\\/]+/g, '/');
  if (stripTrailing !== false) {
    str = removeTrailingSeparator(str);
  }
  return str;
};

},{"remove-trailing-separator":847}],708:[function(require,module,exports){
'use strict';
module.exports = {
  wrap: wrapRange,
  limit: limitRange,
  validate: validateRange,
  test: testRange,
  curry: curry,
  name: name
};

function wrapRange(min, max, value) {
  var maxLessMin = max - min;
  return ((value - min) % maxLessMin + maxLessMin) % maxLessMin + min;
}

function limitRange(min, max, value) {
  return Math.max(min, Math.min(max, value));
}

function validateRange(min, max, value, minExclusive, maxExclusive) {
  if (!testRange(min, max, value, minExclusive, maxExclusive)) {
    throw new Error(value + ' is outside of range [' + min + ',' + max + ')');
  }
  return value;
}

function testRange(min, max, value, minExclusive, maxExclusive) {
  return !(
       value < min ||
       value > max ||
       (maxExclusive && (value === max)) ||
       (minExclusive && (value === min))
  );
}

function name(min, max, minExcl, maxExcl) {
  return (minExcl ? '(' : '[') + min + ',' + max + (maxExcl ? ')' : ']');
}

function curry(min, max, minExclusive, maxExclusive) {
  var boundNameFn = name.bind(null, min, max, minExclusive, maxExclusive);
  return {
    wrap: wrapRange.bind(null, min, max),
    limit: limitRange.bind(null, min, max),
    validate: function(value) {
      return validateRange(min, max, value, minExclusive, maxExclusive);
    },
    test: function(value) {
      return testRange(min, max, value, minExclusive, maxExclusive);
    },
    toString: boundNameFn,
    name: boundNameFn
  };
}

},{}],709:[function(require,module,exports){
/* normalize-selector v0.1.0 (c) 2014 Kyle Simpson */

(function UMD(name,context,definition){
	if (typeof module !== "undefined" && module.exports) { module.exports = definition(); }
	else if (typeof define === "function" && define.amd) { define(definition); }
	else { context[name] = definition(name,context); }
})("normalizeSelector",this,function DEF(name,context){
	"use strict";

	function normalizeSelector(sel) {

		// save unmatched text, if any
		function saveUnmatched() {
			if (unmatched) {
				// whitespace needed after combinator?
				if (tokens.length > 0 &&
					/^[~+>]$/.test(tokens[tokens.length-1])
				) {
					tokens.push(" ");
				}

				// save unmatched text
				tokens.push(unmatched);
			}
		}

		var tokens = [], match, unmatched, regex, state = [0],
			next_match_idx = 0, prev_match_idx,
			not_escaped_pattern = /(?:[^\\]|(?:^|[^\\])(?:\\\\)+)$/,
			whitespace_pattern = /^\s+$/,
			attribute_nonspecial_pattern = /[^\s=~!^|$*\[\]\(\)]{2}/,
			state_patterns = [
				/\s+|\/\*|["'>~+\[\(]/g, // general
				/\s+|\/\*|["'\[\]\(\)]/g, // [..] set
				/\s+|\/\*|["'\[\]\(\)]/g, // (..) set
				null, // string literal (placeholder)
				/\*\//g // comment
			]
		;

		sel = sel.trim();

		while (true) {
			unmatched = "";

			regex = state_patterns[state[state.length-1]];

			regex.lastIndex = next_match_idx;
			match = regex.exec(sel);

			// matched text to process?
			if (match) {
				prev_match_idx = next_match_idx;
				next_match_idx = regex.lastIndex;

				// collect the previous string chunk not matched before this token
				if (prev_match_idx < next_match_idx - match[0].length) {
					unmatched = sel.substring(prev_match_idx,next_match_idx - match[0].length);
				}

				// need to force a space (possibly skipped
				// previously by the parser)?
				if (
					state[state.length-1] === 1 &&
					attribute_nonspecial_pattern.test(
						tokens[tokens.length-1].substr(-1) +
						unmatched.charAt(0)
					)
				) {
					tokens.push(" ");
				}

				// general, [ ] pair, ( ) pair?
				if (state[state.length-1] < 3) {
					saveUnmatched();

					// starting a [ ] pair?
					if (match[0] === "[") {
						state.push(1);
					}
					// starting a ( ) pair?
					else if (match[0] === "(") {
						state.push(2);
					}
					// starting a string literal?
					else if (/^["']$/.test(match[0])) {
						state.push(3);
						state_patterns[3] = new RegExp(match[0],"g");
					}
					// starting a comment?
					else if (match[0] === "/*") {
						state.push(4);
					}
					// ending a [ ] or ( ) pair?
					else if (/^[\]\)]$/.test(match[0]) && state.length > 0) {
						state.pop();
					}
					// handling whitespace or a combinator?
					else if (/^(?:\s+|[~+>])$/.test(match[0])) {
						// need to insert whitespace before?
						if (tokens.length > 0 &&
							!whitespace_pattern.test(tokens[tokens.length-1]) &&
							state[state.length-1] === 0
						) {
							// add normalized whitespace
							tokens.push(" ");
						}

						// whitespace token we can skip?
						if (whitespace_pattern.test(match[0])) {
							continue;
						}
					}

					// save matched text
					tokens.push(match[0]);
				}
				// otherwise, string literal or comment
				else {
					// save unmatched text
					tokens[tokens.length-1] += unmatched;

					// unescaped terminator to string literal or comment?
					if (not_escaped_pattern.test(tokens[tokens.length-1])) {
						// comment terminator?
						if (state[state.length-1] === 4) {
							// ok to drop comment?
							if (tokens.length < 2 ||
								whitespace_pattern.test(tokens[tokens.length-2])
							) {
								tokens.pop();
							}
							// otherwise, turn comment into whitespace
							else {
								tokens[tokens.length-1] = " ";
							}

							// handled already
							match[0] = "";
						}

						state.pop();
					}

					// append matched text to existing token
					tokens[tokens.length-1] += match[0];
				}
			}
			// otherwise, end of processing (no more matches)
			else {
				unmatched = sel.substr(next_match_idx);
				saveUnmatched();

				break;
			}
		}

		return tokens.join("").trim();
	}

	return normalizeSelector;
});


},{}],710:[function(require,module,exports){
'use strict'

var abs = Math.abs
var round = Math.round

function almostEq(a, b) {
  return abs(a - b) <= 9.5367432e-7
}

//最大公约数 Greatest Common Divisor
function GCD(a, b) {
  if (almostEq(b, 0)) return a
  return GCD(b, a % b)
}

function findPrecision(n) {
  var e = 1

  while (!almostEq(round(n * e) / e, n)) {
    e *= 10
  }

  return e
}

function num2fraction(num) {
  if (num === 0 || num === '0') return '0'

  if (typeof num === 'string') {
    num = parseFloat(num)
  }


  var precision = findPrecision(num) //精确度
  var number = num * precision
  var gcd = abs(GCD(number, precision))

  //分子
  var numerator = number / gcd
  //分母
  var denominator = precision / gcd

  //分数
  return round(numerator) + '/' + round(denominator)
}

module.exports = num2fraction


},{}],711:[function(require,module,exports){
/*
object-assign
(c) Sindre Sorhus
@license MIT
*/

'use strict';
/* eslint-disable no-unused-vars */
var getOwnPropertySymbols = Object.getOwnPropertySymbols;
var hasOwnProperty = Object.prototype.hasOwnProperty;
var propIsEnumerable = Object.prototype.propertyIsEnumerable;

function toObject(val) {
	if (val === null || val === undefined) {
		throw new TypeError('Object.assign cannot be called with null or undefined');
	}

	return Object(val);
}

function shouldUseNative() {
	try {
		if (!Object.assign) {
			return false;
		}

		// Detect buggy property enumeration order in older V8 versions.

		// https://bugs.chromium.org/p/v8/issues/detail?id=4118
		var test1 = new String('abc');  // eslint-disable-line no-new-wrappers
		test1[5] = 'de';
		if (Object.getOwnPropertyNames(test1)[0] === '5') {
			return false;
		}

		// https://bugs.chromium.org/p/v8/issues/detail?id=3056
		var test2 = {};
		for (var i = 0; i < 10; i++) {
			test2['_' + String.fromCharCode(i)] = i;
		}
		var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
			return test2[n];
		});
		if (order2.join('') !== '0123456789') {
			return false;
		}

		// https://bugs.chromium.org/p/v8/issues/detail?id=3056
		var test3 = {};
		'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
			test3[letter] = letter;
		});
		if (Object.keys(Object.assign({}, test3)).join('') !==
				'abcdefghijklmnopqrst') {
			return false;
		}

		return true;
	} catch (err) {
		// We don't expect any of the above to throw, but better to be safe.
		return false;
	}
}

module.exports = shouldUseNative() ? Object.assign : function (target, source) {
	var from;
	var to = toObject(target);
	var symbols;

	for (var s = 1; s < arguments.length; s++) {
		from = Object(arguments[s]);

		for (var key in from) {
			if (hasOwnProperty.call(from, key)) {
				to[key] = from[key];
			}
		}

		if (getOwnPropertySymbols) {
			symbols = getOwnPropertySymbols(from);
			for (var i = 0; i < symbols.length; i++) {
				if (propIsEnumerable.call(from, symbols[i])) {
					to[symbols[i]] = from[symbols[i]];
				}
			}
		}
	}

	return to;
};

},{}],712:[function(require,module,exports){
/*!
 * object.omit <https://github.com/jonschlinkert/object.omit>
 *
 * Copyright (c) 2014-2015, Jon Schlinkert.
 * Licensed under the MIT License.
 */

'use strict';

var isObject = require('is-extendable');
var forOwn = require('for-own');

module.exports = function omit(obj, keys) {
  if (!isObject(obj)) return {};

  keys = [].concat.apply([], [].slice.call(arguments, 1));
  var last = keys[keys.length - 1];
  var res = {}, fn;

  if (typeof last === 'function') {
    fn = keys.pop();
  }

  var isFunction = typeof fn === 'function';
  if (!keys.length && !isFunction) {
    return obj;
  }

  forOwn(obj, function(value, key) {
    if (keys.indexOf(key) === -1) {

      if (!isFunction) {
        res[key] = value;
      } else if (fn(value, key, obj)) {
        res[key] = value;
      }
    }
  });
  return res;
};

},{"for-own":616,"is-extendable":644}],713:[function(require,module,exports){
var wrappy = require('wrappy')
module.exports = wrappy(once)
module.exports.strict = wrappy(onceStrict)

once.proto = once(function () {
  Object.defineProperty(Function.prototype, 'once', {
    value: function () {
      return once(this)
    },
    configurable: true
  })

  Object.defineProperty(Function.prototype, 'onceStrict', {
    value: function () {
      return onceStrict(this)
    },
    configurable: true
  })
})

function once (fn) {
  var f = function () {
    if (f.called) return f.value
    f.called = true
    return f.value = fn.apply(this, arguments)
  }
  f.called = false
  return f
}

function onceStrict (fn) {
  var f = function () {
    if (f.called)
      throw new Error(f.onceError)
    f.called = true
    return f.value = fn.apply(this, arguments)
  }
  var name = fn.name || 'Function wrapped with `once`'
  f.onceError = name + " shouldn't be called more than once"
  f.called = false
  return f
}

},{"wrappy":1182}],714:[function(require,module,exports){
(function (process){
'use strict';
var os = require('os');

function homedir() {
	var env = process.env;
	var home = env.HOME;
	var user = env.LOGNAME || env.USER || env.LNAME || env.USERNAME;

	if (process.platform === 'win32') {
		return env.USERPROFILE || env.HOMEDRIVE + env.HOMEPATH || home || null;
	}

	if (process.platform === 'darwin') {
		return home || (user ? '/Users/' + user : null);
	}

	if (process.platform === 'linux') {
		return home || (process.getuid() === 0 ? '/root' : (user ? '/home/' + user : null));
	}

	return home || null;
}

module.exports = typeof os.homedir === 'function' ? os.homedir : homedir;

}).call(this,require('_process'))
},{"_process":16,"os":13}],715:[function(require,module,exports){
/*!
 * parse-glob <https://github.com/jonschlinkert/parse-glob>
 *
 * Copyright (c) 2015, Jon Schlinkert.
 * Licensed under the MIT License.
 */

'use strict';

var isGlob = require('is-glob');
var findBase = require('glob-base');
var extglob = require('is-extglob');
var dotfile = require('is-dotfile');

/**
 * Expose `cache`
 */

var cache = module.exports.cache = {};

/**
 * Parse a glob pattern into tokens.
 *
 * When no paths or '**' are in the glob, we use a
 * different strategy for parsing the filename, since
 * file names can contain braces and other difficult
 * patterns. such as:
 *
 *  - `*.{a,b}`
 *  - `(**|*.js)`
 */

module.exports = function parseGlob(glob) {
  if (cache.hasOwnProperty(glob)) {
    return cache[glob];
  }

  var tok = {};
  tok.orig = glob;
  tok.is = {};

  // unescape dots and slashes in braces/brackets
  glob = escape(glob);

  var parsed = findBase(glob);
  tok.is.glob = parsed.isGlob;

  tok.glob = parsed.glob;
  tok.base = parsed.base;
  var segs = /([^\/]*)$/.exec(glob);

  tok.path = {};
  tok.path.dirname = '';
  tok.path.basename = segs[1] || '';
  tok.path.dirname = glob.split(tok.path.basename).join('') || '';
  var basename = (tok.path.basename || '').split('.') || '';
  tok.path.filename = basename[0] || '';
  tok.path.extname = basename.slice(1).join('.') || '';
  tok.path.ext = '';

  if (isGlob(tok.path.dirname) && !tok.path.basename) {
    if (!/\/$/.test(tok.glob)) {
      tok.path.basename = tok.glob;
    }
    tok.path.dirname = tok.base;
  }

  if (glob.indexOf('/') === -1 && !tok.is.globstar) {
    tok.path.dirname = '';
    tok.path.basename = tok.orig;
  }

  var dot = tok.path.basename.indexOf('.');
  if (dot !== -1) {
    tok.path.filename = tok.path.basename.slice(0, dot);
    tok.path.extname = tok.path.basename.slice(dot);
  }

  if (tok.path.extname.charAt(0) === '.') {
    var exts = tok.path.extname.split('.');
    tok.path.ext = exts[exts.length - 1];
  }

  // unescape dots and slashes in braces/brackets
  tok.glob = unescape(tok.glob);
  tok.path.dirname = unescape(tok.path.dirname);
  tok.path.basename = unescape(tok.path.basename);
  tok.path.filename = unescape(tok.path.filename);
  tok.path.extname = unescape(tok.path.extname);

  // Booleans
  var is = (glob && tok.is.glob);
  tok.is.negated  = glob && glob.charAt(0) === '!';
  tok.is.extglob  = glob && extglob(glob);
  tok.is.braces   = has(is, glob, '{');
  tok.is.brackets = has(is, glob, '[:');
  tok.is.globstar = has(is, glob, '**');
  tok.is.dotfile  = dotfile(tok.path.basename) || dotfile(tok.path.filename);
  tok.is.dotdir   = dotdir(tok.path.dirname);
  return (cache[glob] = tok);
}

/**
 * Returns true if the glob matches dot-directories.
 *
 * @param  {Object} `tok` The tokens object
 * @param  {Object} `path` The path object
 * @return {Object}
 */

function dotdir(base) {
  if (base.indexOf('/.') !== -1) {
    return true;
  }
  if (base.charAt(0) === '.' && base.charAt(1) !== '/') {
    return true;
  }
  return false;
}

/**
 * Returns true if the pattern has the given `ch`aracter(s)
 *
 * @param  {Object} `glob` The glob pattern.
 * @param  {Object} `ch` The character to test for
 * @return {Object}
 */

function has(is, glob, ch) {
  return is && glob.indexOf(ch) !== -1;
}

/**
 * Escape/unescape utils
 */

function escape(str) {
  var re = /\{([^{}]*?)}|\(([^()]*?)\)|\[([^\[\]]*?)\]/g;
  return str.replace(re, function (outter, braces, parens, brackets) {
    var inner = braces || parens || brackets;
    if (!inner) { return outter; }
    return outter.split(inner).join(esc(inner));
  });
}

function esc(str) {
  str = str.split('/').join('__SLASH__');
  str = str.split('.').join('__DOT__');
  return str;
}

function unescape(str) {
  str = str.split('__SLASH__').join('/');
  str = str.split('__DOT__').join('.');
  return str;
}

},{"glob-base":619,"is-dotfile":642,"is-extglob":645,"is-glob":647}],716:[function(require,module,exports){
'use strict';
var errorEx = require('error-ex');
var fallback = require('./vendor/parse');

var JSONError = errorEx('JSONError', {
	fileName: errorEx.append('in %s')
});

module.exports = function (x, reviver, filename) {
	if (typeof reviver === 'string') {
		filename = reviver;
		reviver = null;
	}

	try {
		try {
			return JSON.parse(x, reviver);
		} catch (err) {
			fallback.parse(x, {
				mode: 'json',
				reviver: reviver
			});

			throw err;
		}
	} catch (err) {
		var jsonErr = new JSONError(err);

		if (filename) {
			jsonErr.fileName = filename;
		}

		throw jsonErr;
	}
};

},{"./vendor/parse":717,"error-ex":603}],717:[function(require,module,exports){
/*
 * Author: Alex Kocharin <alex@kocharin.ru>
 * GIT: https://github.com/rlidwka/jju
 * License: WTFPL, grab your copy here: http://www.wtfpl.net/txt/copying/
 */

// RTFM: http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf

var Uni = require('./unicode')

function isHexDigit(x) {
  return (x >= '0' && x <= '9')
      || (x >= 'A' && x <= 'F')
      || (x >= 'a' && x <= 'f')
}

function isOctDigit(x) {
  return x >= '0' && x <= '7'
}

function isDecDigit(x) {
  return x >= '0' && x <= '9'
}

var unescapeMap = {
  '\'': '\'',
  '"' : '"',
  '\\': '\\',
  'b' : '\b',
  'f' : '\f',
  'n' : '\n',
  'r' : '\r',
  't' : '\t',
  'v' : '\v',
  '/' : '/',
}

function formatError(input, msg, position, lineno, column, json5) {
  var result = msg + ' at ' + (lineno + 1) + ':' + (column + 1)
    , tmppos = position - column - 1
    , srcline = ''
    , underline = ''

  var isLineTerminator = json5 ? Uni.isLineTerminator : Uni.isLineTerminatorJSON

  // output no more than 70 characters before the wrong ones
  if (tmppos < position - 70) {
    tmppos = position - 70
  }

  while (1) {
    var chr = input[++tmppos]

    if (isLineTerminator(chr) || tmppos === input.length) {
      if (position >= tmppos) {
        // ending line error, so show it after the last char
        underline += '^'
      }
      break
    }
    srcline += chr

    if (position === tmppos) {
      underline += '^'
    } else if (position > tmppos) {
      underline += input[tmppos] === '\t' ? '\t' : ' '
    }

    // output no more than 78 characters on the string
    if (srcline.length > 78) break
  }

  return result + '\n' + srcline + '\n' + underline
}

function parse(input, options) {
  // parse as a standard JSON mode
  var json5 = !(options.mode === 'json' || options.legacy)
  var isLineTerminator = json5 ? Uni.isLineTerminator : Uni.isLineTerminatorJSON
  var isWhiteSpace = json5 ? Uni.isWhiteSpace : Uni.isWhiteSpaceJSON

  var length = input.length
    , lineno = 0
    , linestart = 0
    , position = 0
    , stack = []

  var tokenStart = function() {}
  var tokenEnd = function(v) {return v}

  /* tokenize({
       raw: '...',
       type: 'whitespace'|'comment'|'key'|'literal'|'separator'|'newline',
       value: 'number'|'string'|'whatever',
       path: [...],
     })
  */
  if (options._tokenize) {
    ;(function() {
      var start = null
      tokenStart = function() {
        if (start !== null) throw Error('internal error, token overlap')
        start = position
      }

      tokenEnd = function(v, type) {
        if (start != position) {
          var hash = {
            raw: input.substr(start, position-start),
            type: type,
            stack: stack.slice(0),
          }
          if (v !== undefined) hash.value = v
          options._tokenize.call(null, hash)
        }
        start = null
        return v
      }
    })()
  }

  function fail(msg) {
    var column = position - linestart

    if (!msg) {
      if (position < length) {
        var token = '\'' +
          JSON
            .stringify(input[position])
            .replace(/^"|"$/g, '')
            .replace(/'/g, "\\'")
            .replace(/\\"/g, '"')
          + '\''

        if (!msg) msg = 'Unexpected token ' + token
      } else {
        if (!msg) msg = 'Unexpected end of input'
      }
    }

    var error = SyntaxError(formatError(input, msg, position, lineno, column, json5))
    error.row = lineno + 1
    error.column = column + 1
    throw error
  }

  function newline(chr) {
    // account for <cr><lf>
    if (chr === '\r' && input[position] === '\n') position++
    linestart = position
    lineno++
  }

  function parseGeneric() {
    var result

    while (position < length) {
      tokenStart()
      var chr = input[position++]

      if (chr === '"' || (chr === '\'' && json5)) {
        return tokenEnd(parseString(chr), 'literal')

      } else if (chr === '{') {
        tokenEnd(undefined, 'separator')
        return parseObject()

      } else if (chr === '[') {
        tokenEnd(undefined, 'separator')
        return parseArray()

      } else if (chr === '-'
             ||  chr === '.'
             ||  isDecDigit(chr)
                 //           + number       Infinity          NaN
             ||  (json5 && (chr === '+' || chr === 'I' || chr === 'N'))
      ) {
        return tokenEnd(parseNumber(), 'literal')

      } else if (chr === 'n') {
        parseKeyword('null')
        return tokenEnd(null, 'literal')

      } else if (chr === 't') {
        parseKeyword('true')
        return tokenEnd(true, 'literal')

      } else if (chr === 'f') {
        parseKeyword('false')
        return tokenEnd(false, 'literal')

      } else {
        position--
        return tokenEnd(undefined)
      }
    }
  }

  function parseKey() {
    var result

    while (position < length) {
      tokenStart()
      var chr = input[position++]

      if (chr === '"' || (chr === '\'' && json5)) {
        return tokenEnd(parseString(chr), 'key')

      } else if (chr === '{') {
        tokenEnd(undefined, 'separator')
        return parseObject()

      } else if (chr === '[') {
        tokenEnd(undefined, 'separator')
        return parseArray()

      } else if (chr === '.'
             ||  isDecDigit(chr)
      ) {
        return tokenEnd(parseNumber(true), 'key')

      } else if (json5
             &&  Uni.isIdentifierStart(chr) || (chr === '\\' && input[position] === 'u')) {
        // unicode char or a unicode sequence
        var rollback = position - 1
        var result = parseIdentifier()

        if (result === undefined) {
          position = rollback
          return tokenEnd(undefined)
        } else {
          return tokenEnd(result, 'key')
        }

      } else {
        position--
        return tokenEnd(undefined)
      }
    }
  }

  function skipWhiteSpace() {
    tokenStart()
    while (position < length) {
      var chr = input[position++]

      if (isLineTerminator(chr)) {
        position--
        tokenEnd(undefined, 'whitespace')
        tokenStart()
        position++
        newline(chr)
        tokenEnd(undefined, 'newline')
        tokenStart()

      } else if (isWhiteSpace(chr)) {
        // nothing

      } else if (chr === '/'
             && json5
             && (input[position] === '/' || input[position] === '*')
      ) {
        position--
        tokenEnd(undefined, 'whitespace')
        tokenStart()
        position++
        skipComment(input[position++] === '*')
        tokenEnd(undefined, 'comment')
        tokenStart()

      } else {
        position--
        break
      }
    }
    return tokenEnd(undefined, 'whitespace')
  }

  function skipComment(multi) {
    while (position < length) {
      var chr = input[position++]

      if (isLineTerminator(chr)) {
        // LineTerminator is an end of singleline comment
        if (!multi) {
          // let parent function deal with newline
          position--
          return
        }

        newline(chr)

      } else if (chr === '*' && multi) {
        // end of multiline comment
        if (input[position] === '/') {
          position++
          return
        }

      } else {
        // nothing
      }
    }

    if (multi) {
      fail('Unclosed multiline comment')
    }
  }

  function parseKeyword(keyword) {
    // keyword[0] is not checked because it should've checked earlier
    var _pos = position
    var len = keyword.length
    for (var i=1; i<len; i++) {
      if (position >= length || keyword[i] != input[position]) {
        position = _pos-1
        fail()
      }
      position++
    }
  }

  function parseObject() {
    var result = options.null_prototype ? Object.create(null) : {}
      , empty_object = {}
      , is_non_empty = false

    while (position < length) {
      skipWhiteSpace()
      var item1 = parseKey()
      skipWhiteSpace()
      tokenStart()
      var chr = input[position++]
      tokenEnd(undefined, 'separator')

      if (chr === '}' && item1 === undefined) {
        if (!json5 && is_non_empty) {
          position--
          fail('Trailing comma in object')
        }
        return result

      } else if (chr === ':' && item1 !== undefined) {
        skipWhiteSpace()
        stack.push(item1)
        var item2 = parseGeneric()
        stack.pop()

        if (item2 === undefined) fail('No value found for key ' + item1)
        if (typeof(item1) !== 'string') {
          if (!json5 || typeof(item1) !== 'number') {
            fail('Wrong key type: ' + item1)
          }
        }

        if ((item1 in empty_object || empty_object[item1] != null) && options.reserved_keys !== 'replace') {
          if (options.reserved_keys === 'throw') {
            fail('Reserved key: ' + item1)
          } else {
            // silently ignore it
          }
        } else {
          if (typeof(options.reviver) === 'function') {
            item2 = options.reviver.call(null, item1, item2)
          }

          if (item2 !== undefined) {
            is_non_empty = true
            Object.defineProperty(result, item1, {
              value: item2,
              enumerable: true,
              configurable: true,
              writable: true,
            })
          }
        }

        skipWhiteSpace()

        tokenStart()
        var chr = input[position++]
        tokenEnd(undefined, 'separator')

        if (chr === ',') {
          continue

        } else if (chr === '}') {
          return result

        } else {
          fail()
        }

      } else {
        position--
        fail()
      }
    }

    fail()
  }

  function parseArray() {
    var result = []

    while (position < length) {
      skipWhiteSpace()
      stack.push(result.length)
      var item = parseGeneric()
      stack.pop()
      skipWhiteSpace()
      tokenStart()
      var chr = input[position++]
      tokenEnd(undefined, 'separator')

      if (item !== undefined) {
        if (typeof(options.reviver) === 'function') {
          item = options.reviver.call(null, String(result.length), item)
        }
        if (item === undefined) {
          result.length++
          item = true // hack for check below, not included into result
        } else {
          result.push(item)
        }
      }

      if (chr === ',') {
        if (item === undefined) {
          fail('Elisions are not supported')
        }

      } else if (chr === ']') {
        if (!json5 && item === undefined && result.length) {
          position--
          fail('Trailing comma in array')
        }
        return result

      } else {
        position--
        fail()
      }
    }
  }

  function parseNumber() {
    // rewind because we don't know first char
    position--

    var start = position
      , chr = input[position++]
      , t

    var to_num = function(is_octal) {
      var str = input.substr(start, position - start)

      if (is_octal) {
        var result = parseInt(str.replace(/^0o?/, ''), 8)
      } else {
        var result = Number(str)
      }

      if (Number.isNaN(result)) {
        position--
        fail('Bad numeric literal - "' + input.substr(start, position - start + 1) + '"')
      } else if (!json5 && !str.match(/^-?(0|[1-9][0-9]*)(\.[0-9]+)?(e[+-]?[0-9]+)?$/i)) {
        // additional restrictions imposed by json
        position--
        fail('Non-json numeric literal - "' + input.substr(start, position - start + 1) + '"')
      } else {
        return result
      }
    }

    // ex: -5982475.249875e+29384
    //     ^ skipping this
    if (chr === '-' || (chr === '+' && json5)) chr = input[position++]

    if (chr === 'N' && json5) {
      parseKeyword('NaN')
      return NaN
    }

    if (chr === 'I' && json5) {
      parseKeyword('Infinity')

      // returning +inf or -inf
      return to_num()
    }

    if (chr >= '1' && chr <= '9') {
      // ex: -5982475.249875e+29384
      //        ^^^ skipping these
      while (position < length && isDecDigit(input[position])) position++
      chr = input[position++]
    }

    // special case for leading zero: 0.123456
    if (chr === '0') {
      chr = input[position++]

      //             new syntax, "0o777"           old syntax, "0777"
      var is_octal = chr === 'o' || chr === 'O' || isOctDigit(chr)
      var is_hex = chr === 'x' || chr === 'X'

      if (json5 && (is_octal || is_hex)) {
        while (position < length
           &&  (is_hex ? isHexDigit : isOctDigit)( input[position] )
        ) position++

        var sign = 1
        if (input[start] === '-') {
          sign = -1
          start++
        } else if (input[start] === '+') {
          start++
        }

        return sign * to_num(is_octal)
      }
    }

    if (chr === '.') {
      // ex: -5982475.249875e+29384
      //                ^^^ skipping these
      while (position < length && isDecDigit(input[position])) position++
      chr = input[position++]
    }

    if (chr === 'e' || chr === 'E') {
      chr = input[position++]
      if (chr === '-' || chr === '+') position++
      // ex: -5982475.249875e+29384
      //                       ^^^ skipping these
      while (position < length && isDecDigit(input[position])) position++
      chr = input[position++]
    }

    // we have char in the buffer, so count for it
    position--
    return to_num()
  }

  function parseIdentifier() {
    // rewind because we don't know first char
    position--

    var result = ''

    while (position < length) {
      var chr = input[position++]

      if (chr === '\\'
      &&  input[position] === 'u'
      &&  isHexDigit(input[position+1])
      &&  isHexDigit(input[position+2])
      &&  isHexDigit(input[position+3])
      &&  isHexDigit(input[position+4])
      ) {
        // UnicodeEscapeSequence
        chr = String.fromCharCode(parseInt(input.substr(position+1, 4), 16))
        position += 5
      }

      if (result.length) {
        // identifier started
        if (Uni.isIdentifierPart(chr)) {
          result += chr
        } else {
          position--
          return result
        }

      } else {
        if (Uni.isIdentifierStart(chr)) {
          result += chr
        } else {
          return undefined
        }
      }
    }

    fail()
  }

  function parseString(endChar) {
    // 7.8.4 of ES262 spec
    var result = ''

    while (position < length) {
      var chr = input[position++]

      if (chr === endChar) {
        return result

      } else if (chr === '\\') {
        if (position >= length) fail()
        chr = input[position++]

        if (unescapeMap[chr] && (json5 || (chr != 'v' && chr != "'"))) {
          result += unescapeMap[chr]

        } else if (json5 && isLineTerminator(chr)) {
          // line continuation
          newline(chr)

        } else if (chr === 'u' || (chr === 'x' && json5)) {
          // unicode/character escape sequence
          var off = chr === 'u' ? 4 : 2

          // validation for \uXXXX
          for (var i=0; i<off; i++) {
            if (position >= length) fail()
            if (!isHexDigit(input[position])) fail('Bad escape sequence')
            position++
          }

          result += String.fromCharCode(parseInt(input.substr(position-off, off), 16))
        } else if (json5 && isOctDigit(chr)) {
          if (chr < '4' && isOctDigit(input[position]) && isOctDigit(input[position+1])) {
            // three-digit octal
            var digits = 3
          } else if (isOctDigit(input[position])) {
            // two-digit octal
            var digits = 2
          } else {
            var digits = 1
          }
          position += digits - 1
          result += String.fromCharCode(parseInt(input.substr(position-digits, digits), 8))
          /*if (!isOctDigit(input[position])) {
            // \0 is allowed still
            result += '\0'
          } else {
            fail('Octal literals are not supported')
          }*/

        } else if (json5) {
          // \X -> x
          result += chr

        } else {
          position--
          fail()
        }

      } else if (isLineTerminator(chr)) {
        fail()

      } else {
        if (!json5 && chr.charCodeAt(0) < 32) {
          position--
          fail('Unexpected control character')
        }

        // SourceCharacter but not one of " or \ or LineTerminator
        result += chr
      }
    }

    fail()
  }

  skipWhiteSpace()
  var return_value = parseGeneric()
  if (return_value !== undefined || position < length) {
    skipWhiteSpace()

    if (position >= length) {
      if (typeof(options.reviver) === 'function') {
        return_value = options.reviver.call(null, '', return_value)
      }
      return return_value
    } else {
      fail()
    }

  } else {
    if (position) {
      fail('No data, only a whitespace')
    } else {
      fail('No data, empty input')
    }
  }
}

/*
 * parse(text, options)
 * or
 * parse(text, reviver)
 *
 * where:
 * text - string
 * options - object
 * reviver - function
 */
module.exports.parse = function parseJSON(input, options) {
  // support legacy functions
  if (typeof(options) === 'function') {
    options = {
      reviver: options
    }
  }

  if (input === undefined) {
    // parse(stringify(x)) should be equal x
    // with JSON functions it is not 'cause of undefined
    // so we're fixing it
    return undefined
  }

  // JSON.parse compat
  if (typeof(input) !== 'string') input = String(input)
  if (options == null) options = {}
  if (options.reserved_keys == null) options.reserved_keys = 'ignore'

  if (options.reserved_keys === 'throw' || options.reserved_keys === 'ignore') {
    if (options.null_prototype == null) {
      options.null_prototype = true
    }
  }

  try {
    return parse(input, options)
  } catch(err) {
    // jju is a recursive parser, so JSON.parse("{{{{{{{") could blow up the stack
    //
    // this catch is used to skip all those internal calls
    if (err instanceof SyntaxError && err.row != null && err.column != null) {
      var old_err = err
      err = SyntaxError(old_err.message)
      err.column = old_err.column
      err.row = old_err.row
    }
    throw err
  }
}

module.exports.tokenize = function tokenizeJSON(input, options) {
  if (options == null) options = {}

  options._tokenize = function(smth) {
    if (options._addstack) smth.stack.unshift.apply(smth.stack, options._addstack)
    tokens.push(smth)
  }

  var tokens = []
  tokens.data = module.exports.parse(input, options)
  return tokens
}


},{"./unicode":718}],718:[function(require,module,exports){

// This is autogenerated with esprima tools, see:
// https://github.com/ariya/esprima/blob/master/esprima.js
//
// PS: oh God, I hate Unicode

// ECMAScript 5.1/Unicode v6.3.0 NonAsciiIdentifierStart:

var Uni = module.exports

module.exports.isWhiteSpace = function isWhiteSpace(x) {
  // section 7.2, table 2
  return x === '\u0020'
      || x === '\u00A0'
      || x === '\uFEFF' // <-- this is not a Unicode WS, only a JS one
      || (x >= '\u0009' && x <= '\u000D') // 9 A B C D

      // + whitespace characters from unicode, category Zs
      || x === '\u1680'
      || x === '\u180E'
      || (x >= '\u2000' && x <= '\u200A') // 0 1 2 3 4 5 6 7 8 9 A
      || x === '\u2028'
      || x === '\u2029'
      || x === '\u202F'
      || x === '\u205F'
      || x === '\u3000'
}

module.exports.isWhiteSpaceJSON = function isWhiteSpaceJSON(x) {
  return x === '\u0020'
      || x === '\u0009'
      || x === '\u000A'
      || x === '\u000D'
}

module.exports.isLineTerminator = function isLineTerminator(x) {
  // ok, here is the part when JSON is wrong
  // section 7.3, table 3
  return x === '\u000A'
      || x === '\u000D'
      || x === '\u2028'
      || x === '\u2029'
}

module.exports.isLineTerminatorJSON = function isLineTerminatorJSON(x) {
  return x === '\u000A'
      || x === '\u000D'
}

module.exports.isIdentifierStart = function isIdentifierStart(x) {
  return x === '$'
      || x === '_'
      || (x >= 'A' && x <= 'Z')
      || (x >= 'a' && x <= 'z')
      || (x >= '\u0080' && Uni.NonAsciiIdentifierStart.test(x))
}

module.exports.isIdentifierPart = function isIdentifierPart(x) {
  return x === '$'
      || x === '_'
      || (x >= 'A' && x <= 'Z')
      || (x >= 'a' && x <= 'z')
      || (x >= '0' && x <= '9') // <-- addition to Start
      || (x >= '\u0080' && Uni.NonAsciiIdentifierPart.test(x))
}

module.exports.NonAsciiIdentifierStart = /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0\u08A2-\u08AC\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097F\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C33\u0C35-\u0C39\u0C3D\u0C58\u0C59\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D60\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F0\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191C\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19C1-\u19C7\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA697\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA793\uA7A0-\uA7AA\uA7F8-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA80-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]/

// ECMAScript 5.1/Unicode v6.3.0 NonAsciiIdentifierPart:

module.exports.NonAsciiIdentifierPart = /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u0527\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0\u08A2-\u08AC\u08E4-\u08FE\u0900-\u0963\u0966-\u096F\u0971-\u0977\u0979-\u097F\u0981-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C01-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C33\u0C35-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58\u0C59\u0C60-\u0C63\u0C66-\u0C6F\u0C82\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D02\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D57\u0D60-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F0\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191C\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19D9\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1CD0-\u1CD2\u1CD4-\u1CF6\u1D00-\u1DE6\u1DFC-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u2E2F\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099\u309A\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA697\uA69F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA793\uA7A0-\uA7AA\uA7F8-\uA827\uA840-\uA873\uA880-\uA8C4\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A\uAA7B\uAA80-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uABC0-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE26\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]/

},{}],719:[function(require,module,exports){
(function (process){
'use strict';

function posix(path) {
	return path.charAt(0) === '/';
}

function win32(path) {
	// https://github.com/nodejs/node/blob/b3fcc245fb25539909ef1d5eaa01dbf92e168633/lib/path.js#L56
	var splitDeviceRe = /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
	var result = splitDeviceRe.exec(path);
	var device = result[1] || '';
	var isUnc = Boolean(device && device.charAt(1) !== ':');

	// UNC paths are always absolute
	return Boolean(result[2] || isUnc);
}

module.exports = process.platform === 'win32' ? win32 : posix;
module.exports.posix = posix;
module.exports.win32 = win32;

}).call(this,require('_process'))
},{"_process":16}],720:[function(require,module,exports){
(function (process){
"use strict";

var path = require("path");

module.exports = function (thePath, potentialParent) {
    // For inside-directory checking, we want to allow trailing slashes, so normalize.
    thePath = stripTrailingSep(thePath);
    potentialParent = stripTrailingSep(potentialParent);

    // Node treats only Windows as case-insensitive in its path module; we follow those conventions.
    if (process.platform === "win32") {
        thePath = thePath.toLowerCase();
        potentialParent = potentialParent.toLowerCase();
    }

    return thePath.lastIndexOf(potentialParent, 0) === 0 &&
		(
			thePath[potentialParent.length] === path.sep ||
			thePath[potentialParent.length] === undefined
		);
};

function stripTrailingSep(thePath) {
    if (thePath[thePath.length - 1] === path.sep) {
        return thePath.slice(0, -1);
    }
    return thePath;
}

}).call(this,require('_process'))
},{"_process":16,"path":14}],721:[function(require,module,exports){
'use strict';

const processFn = (fn, opts) => function () {
	const P = opts.promiseModule;
	const args = new Array(arguments.length);

	for (let i = 0; i < arguments.length; i++) {
		args[i] = arguments[i];
	}

	return new P((resolve, reject) => {
		if (opts.errorFirst) {
			args.push(function (err, result) {
				if (opts.multiArgs) {
					const results = new Array(arguments.length - 1);

					for (let i = 1; i < arguments.length; i++) {
						results[i - 1] = arguments[i];
					}

					if (err) {
						results.unshift(err);
						reject(results);
					} else {
						resolve(results);
					}
				} else if (err) {
					reject(err);
				} else {
					resolve(result);
				}
			});
		} else {
			args.push(function (result) {
				if (opts.multiArgs) {
					const results = new Array(arguments.length - 1);

					for (let i = 0; i < arguments.length; i++) {
						results[i] = arguments[i];
					}

					resolve(results);
				} else {
					resolve(result);
				}
			});
		}

		fn.apply(this, args);
	});
};

module.exports = (obj, opts) => {
	opts = Object.assign({
		exclude: [/.+(Sync|Stream)$/],
		errorFirst: true,
		promiseModule: Promise
	}, opts);

	const filter = key => {
		const match = pattern => typeof pattern === 'string' ? key === pattern : pattern.test(key);
		return opts.include ? opts.include.some(match) : !opts.exclude.some(match);
	};

	let ret;
	if (typeof obj === 'function') {
		ret = function () {
			if (opts.excludeMain) {
				return obj.apply(this, arguments);
			}

			return processFn(obj, opts).apply(this, arguments);
		};
	} else {
		ret = Object.create(Object.getPrototypeOf(obj));
	}

	for (const key in obj) { // eslint-disable-line guard-for-in
		const x = obj[key];
		ret[key] = typeof x === 'function' && filter(key) ? processFn(x, opts) : x;
	}

	return ret;
};

},{}],722:[function(require,module,exports){
'use strict';

module.exports = typeof Promise === 'function' ? Promise : require('pinkie');

},{"pinkie":723}],723:[function(require,module,exports){
(function (global){
'use strict';

var PENDING = 'pending';
var SETTLED = 'settled';
var FULFILLED = 'fulfilled';
var REJECTED = 'rejected';
var NOOP = function () {};
var isNode = typeof global !== 'undefined' && typeof global.process !== 'undefined' && typeof global.process.emit === 'function';

var asyncSetTimer = typeof setImmediate === 'undefined' ? setTimeout : setImmediate;
var asyncQueue = [];
var asyncTimer;

function asyncFlush() {
	// run promise callbacks
	for (var i = 0; i < asyncQueue.length; i++) {
		asyncQueue[i][0](asyncQueue[i][1]);
	}

	// reset async asyncQueue
	asyncQueue = [];
	asyncTimer = false;
}

function asyncCall(callback, arg) {
	asyncQueue.push([callback, arg]);

	if (!asyncTimer) {
		asyncTimer = true;
		asyncSetTimer(asyncFlush, 0);
	}
}

function invokeResolver(resolver, promise) {
	function resolvePromise(value) {
		resolve(promise, value);
	}

	function rejectPromise(reason) {
		reject(promise, reason);
	}

	try {
		resolver(resolvePromise, rejectPromise);
	} catch (e) {
		rejectPromise(e);
	}
}

function invokeCallback(subscriber) {
	var owner = subscriber.owner;
	var settled = owner._state;
	var value = owner._data;
	var callback = subscriber[settled];
	var promise = subscriber.then;

	if (typeof callback === 'function') {
		settled = FULFILLED;
		try {
			value = callback(value);
		} catch (e) {
			reject(promise, e);
		}
	}

	if (!handleThenable(promise, value)) {
		if (settled === FULFILLED) {
			resolve(promise, value);
		}

		if (settled === REJECTED) {
			reject(promise, value);
		}
	}
}

function handleThenable(promise, value) {
	var resolved;

	try {
		if (promise === value) {
			throw new TypeError('A promises callback cannot return that same promise.');
		}

		if (value && (typeof value === 'function' || typeof value === 'object')) {
			// then should be retrieved only once
			var then = value.then;

			if (typeof then === 'function') {
				then.call(value, function (val) {
					if (!resolved) {
						resolved = true;

						if (value === val) {
							fulfill(promise, val);
						} else {
							resolve(promise, val);
						}
					}
				}, function (reason) {
					if (!resolved) {
						resolved = true;

						reject(promise, reason);
					}
				});

				return true;
			}
		}
	} catch (e) {
		if (!resolved) {
			reject(promise, e);
		}

		return true;
	}

	return false;
}

function resolve(promise, value) {
	if (promise === value || !handleThenable(promise, value)) {
		fulfill(promise, value);
	}
}

function fulfill(promise, value) {
	if (promise._state === PENDING) {
		promise._state = SETTLED;
		promise._data = value;

		asyncCall(publishFulfillment, promise);
	}
}

function reject(promise, reason) {
	if (promise._state === PENDING) {
		promise._state = SETTLED;
		promise._data = reason;

		asyncCall(publishRejection, promise);
	}
}

function publish(promise) {
	promise._then = promise._then.forEach(invokeCallback);
}

function publishFulfillment(promise) {
	promise._state = FULFILLED;
	publish(promise);
}

function publishRejection(promise) {
	promise._state = REJECTED;
	publish(promise);
	if (!promise._handled && isNode) {
		global.process.emit('unhandledRejection', promise._data, promise);
	}
}

function notifyRejectionHandled(promise) {
	global.process.emit('rejectionHandled', promise);
}

/**
 * @class
 */
function Promise(resolver) {
	if (typeof resolver !== 'function') {
		throw new TypeError('Promise resolver ' + resolver + ' is not a function');
	}

	if (this instanceof Promise === false) {
		throw new TypeError('Failed to construct \'Promise\': Please use the \'new\' operator, this object constructor cannot be called as a function.');
	}

	this._then = [];

	invokeResolver(resolver, this);
}

Promise.prototype = {
	constructor: Promise,

	_state: PENDING,
	_then: null,
	_data: undefined,
	_handled: false,

	then: function (onFulfillment, onRejection) {
		var subscriber = {
			owner: this,
			then: new this.constructor(NOOP),
			fulfilled: onFulfillment,
			rejected: onRejection
		};

		if ((onRejection || onFulfillment) && !this._handled) {
			this._handled = true;
			if (this._state === REJECTED && isNode) {
				asyncCall(notifyRejectionHandled, this);
			}
		}

		if (this._state === FULFILLED || this._state === REJECTED) {
			// already resolved, call callback async
			asyncCall(invokeCallback, subscriber);
		} else {
			// subscribe
			this._then.push(subscriber);
		}

		return subscriber.then;
	},

	catch: function (onRejection) {
		return this.then(null, onRejection);
	}
};

Promise.all = function (promises) {
	if (!Array.isArray(promises)) {
		throw new TypeError('You must pass an array to Promise.all().');
	}

	return new Promise(function (resolve, reject) {
		var results = [];
		var remaining = 0;

		function resolver(index) {
			remaining++;
			return function (value) {
				results[index] = value;
				if (!--remaining) {
					resolve(results);
				}
			};
		}

		for (var i = 0, promise; i < promises.length; i++) {
			promise = promises[i];

			if (promise && typeof promise.then === 'function') {
				promise.then(resolver(i), reject);
			} else {
				results[i] = promise;
			}
		}

		if (!remaining) {
			resolve(results);
		}
	});
};

Promise.race = function (promises) {
	if (!Array.isArray(promises)) {
		throw new TypeError('You must pass an array to Promise.race().');
	}

	return new Promise(function (resolve, reject) {
		for (var i = 0, promise; i < promises.length; i++) {
			promise = promises[i];

			if (promise && typeof promise.then === 'function') {
				promise.then(resolve, reject);
			} else {
				resolve(promise);
			}
		}
	});
};

Promise.resolve = function (value) {
	if (value && typeof value === 'object' && value.constructor === Promise) {
		return value;
	}

	return new Promise(function (resolve) {
		resolve(value);
	});
};

Promise.reject = function (reason) {
	return new Promise(function (resolve, reject) {
		reject(reason);
	});
};

module.exports = Promise;

}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{}],724:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = findExtendRule;
var extendRuleKeyWords = ['&', ':', 'extend'];
var extendRuleKeyWordsCount = extendRuleKeyWords.length;

function findExtendRule(tokens) {
  var start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;

  var stack = [];
  var len = tokens.length;
  var end = start;

  while (end < len) {
    var token = tokens[end];

    if (extendRuleKeyWords.indexOf(token[1]) >= 0) {
      stack.push(token[1]);
    } else if (token[0] !== 'space') {
      break;
    }

    end++;
  }

  for (var index = 0; index < extendRuleKeyWordsCount; index++) {
    if (stack[index] !== extendRuleKeyWords[index]) {
      return null;
    }
  }

  return tokens.slice(start, end);
}
module.exports = exports['default'];
},{}],725:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };

var _rule = require('postcss/lib/rule');

var _rule2 = _interopRequireDefault(_rule);

var _lessStringify = require('./less-stringify');

var _lessStringify2 = _interopRequireDefault(_lessStringify);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Import = function (_PostCssRule) {
  _inherits(Import, _PostCssRule);

  function Import(defaults) {
    _classCallCheck(this, Import);

    var _this = _possibleConstructorReturn(this, (Import.__proto__ || Object.getPrototypeOf(Import)).call(this, defaults));

    _this.type = 'import';
    return _this;
  }

  _createClass(Import, [{
    key: 'toString',
    value: function toString(stringifier) {
      if (!stringifier) {
        stringifier = {
          stringify: _lessStringify2.default
        };
      }

      return _get(Import.prototype.__proto__ || Object.getPrototypeOf(Import.prototype), 'toString', this).call(this, stringifier);
    }
  }]);

  return Import;
}(_rule2.default);

exports.default = Import;
module.exports = exports['default'];
},{"./less-stringify":730,"postcss/lib/rule":769}],726:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = isMixinToken;

var _globals = require('./tokenizer/globals');

var unpaddedFractionalNumbersPattern = /\.[0-9]/;

function isMixinToken(token) {
  var symbol = token[1];
  var firstSymbolCode = symbol ? symbol[0].charCodeAt(0) : null;

  return (firstSymbolCode === _globals.dot || firstSymbolCode === _globals.hash) &&
  // ignore hashes used for colors
  _globals.hashColorPattern.test(symbol) === false &&
  // ignore dots used for unpadded fractional numbers
  unpaddedFractionalNumbersPattern.test(symbol) === false;
}
module.exports = exports['default'];
},{"./tokenizer/globals":736}],727:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = lessParse;

var _input = require('postcss/lib/input');

var _input2 = _interopRequireDefault(_input);

var _lessParser = require('./less-parser');

var _lessParser2 = _interopRequireDefault(_lessParser);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function lessParse(less, opts) {
  var input = new _input2.default(less, opts);
  var parser = new _lessParser2.default(input, opts);
  // const parser = new Parser(input, opts);

  parser.tokenize();
  parser.loop();

  return parser.root;
}
// import Parser from 'postcss/lib/parser';

module.exports = exports['default'];
},{"./less-parser":728,"postcss/lib/input":758}],728:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };

var _comment = require('postcss/lib/comment');

var _comment2 = _interopRequireDefault(_comment);

var _import2 = require('./import');

var _import3 = _interopRequireDefault(_import2);

var _parser = require('postcss/lib/parser');

var _parser2 = _interopRequireDefault(_parser);

var _rule = require('./rule');

var _rule2 = _interopRequireDefault(_rule);

var _root = require('./root');

var _root2 = _interopRequireDefault(_root);

var _findExtendRule = require('./find-extend-rule');

var _findExtendRule2 = _interopRequireDefault(_findExtendRule);

var _isMixinToken = require('./is-mixin-token');

var _isMixinToken2 = _interopRequireDefault(_isMixinToken);

var _lessTokenize = require('./less-tokenize');

var _lessTokenize2 = _interopRequireDefault(_lessTokenize);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var blockCommentEndPattern = /\*\/$/;

var LessParser = function (_Parser) {
  _inherits(LessParser, _Parser);

  function LessParser(input) {
    _classCallCheck(this, LessParser);

    var _this = _possibleConstructorReturn(this, (LessParser.__proto__ || Object.getPrototypeOf(LessParser)).call(this, input));

    _this.root = new _root2.default();
    _this.current = _this.root;
    _this.root.source = { input: input, start: { line: 1, column: 1 } };
    return _this;
  }

  _createClass(LessParser, [{
    key: 'atrule',
    value: function atrule(token) {
      if (token[1] === '@import') {
        this.import(token);
      } else {
        _get(LessParser.prototype.__proto__ || Object.getPrototypeOf(LessParser.prototype), 'atrule', this).call(this, token);
      }
    }
  }, {
    key: 'comment',
    value: function comment(token) {
      var node = new _comment2.default();
      var content = token[1];
      var text = content.slice(2).replace(blockCommentEndPattern, '');

      this.init(node, token[2], token[3]);
      node.source.end = {
        line: token[4],
        column: token[5]
      };

      node.raws.content = content;
      node.raws.begin = content[0] + content[1];
      node.inline = token[6] === 'inline';
      node.block = !node.inline;

      if (/^\s*$/.test(text)) {
        node.text = '';
        node.raws.left = text;
        node.raws.right = '';
      } else {
        var match = text.match(/^(\s*)([^]*[^\s])(\s*)$/);

        node.text = match[2];

        // Add extra spaces to generate a comment in a common style /*[space][text][space]*/
        node.raws.left = match[1] || ' ';
        node.raws.right = match[3] || ' ';
      }
    }

    /**
     * @description Create a Declaration
     * @param options {{start: number}}
     */

  }, {
    key: 'createDeclaration',
    value: function createDeclaration(options) {
      this.decl(this.tokens.slice(options.start, this.pos + 1));
    }

    /**
     * @description Create a Rule node
     * @param options {{start: number, params: Array}}
     */

  }, {
    key: 'createRule',
    value: function createRule(options) {

      var semi = this.tokens[this.pos][0] === ';';
      var end = this.pos + (options.empty && semi ? 2 : 1);
      var tokens = this.tokens.slice(options.start, end);
      var node = this.rule(tokens);

      /**
       * By default in PostCSS `Rule.params` is `undefined`.
       * To preserve compability with PostCSS:
       *  - Don't set empty params for a Rule.
       *  - Set params for a Rule only if it can be a mixin or &:extend rule.
       */
      if (options.params[0] && (options.mixin || options.extend)) {
        this.raw(node, 'params', options.params);
      }

      if (options.empty) {
        // if it's an empty mixin or extend, it must have a semicolon
        // (that's the only way we get to this point)
        if (semi) {
          node.raws.semicolon = this.semicolon = true;
          node.selector = node.selector.replace(/;$/, '');
        }

        if (options.extend) {
          node.extend = true;
        }

        if (options.mixin) {
          node.mixin = true;
        }

        /**
         * @description Mark mixin without declarations.
         * @type {boolean}
         */
        node.empty = true;

        // eslint-disable-next-line
        delete this.current.nodes;

        if (node.selector.indexOf('!important') >= 0) {
          node.important = true;
          node.selector = node.selector.replace(/\s!important/, '');
        }

        // rules don't have trailing semicolons in vanilla css, so they get
        // added to this.spaces by the parser loop, so don't step back.
        if (!semi) {
          this.pos--;
        }

        this.end(this.tokens[this.pos]);
      }
    }
  }, {
    key: 'end',
    value: function end(token) {
      var node = this.current;

      // if a Rule contains other Rules (mixins, extends) and those have
      // semicolons, assert that the parent Rule has a semicolon
      if (node.nodes && node.nodes.length && node.last.raws.semicolon && !node.last.nodes) {
        this.semicolon = true;
      }

      _get(LessParser.prototype.__proto__ || Object.getPrototypeOf(LessParser.prototype), 'end', this).call(this, token);
    }
  }, {
    key: 'import',
    value: function _import(token) {
      /* eslint complexity: 0 */
      var last = false,
          open = false,
          end = { line: 0, column: 0 };

      var directives = [];
      var node = new _import3.default();

      node.name = token[1].slice(1);

      this.init(node, token[2], token[3]);

      this.pos += 1;

      while (this.pos < this.tokens.length) {
        var tokn = this.tokens[this.pos];

        if (tokn[0] === ';') {
          end = { line: tokn[2], column: tokn[3] };
          node.raws.semicolon = true;
          break;
        } else if (tokn[0] === '{') {
          open = true;
          break;
        } else if (tokn[0] === '}') {
          this.end(tokn);
          break;
        } else if (tokn[0] === 'brackets') {
          if (node.urlFunc) {
            node.importPath = tokn[1].replace(/[()]/g, '');
          } else {
            directives.push(tokn);
          }
        } else if (tokn[0] === 'space') {
          if (directives.length) {
            node.raws.between = tokn[1];
          } else if (node.urlFunc) {
            node.raws.beforeUrl = tokn[1];
          } else if (node.importPath) {
            if (node.urlFunc) {
              node.raws.afterUrl = tokn[1];
            } else {
              node.raws.after = tokn[1];
            }
          } else {
            node.raws.afterName = tokn[1];
          }
        } else if (tokn[0] === 'word' && tokn[1] === 'url') {
          node.urlFunc = true;
        } else {
          if (tokn[0] !== '(' && tokn[0] !== ')') {
            node.importPath = tokn[1];
          }
        }

        if (this.pos === this.tokens.length) {
          last = true;
          break;
        }

        this.pos += 1;
      }

      if (node.raws.between && !node.raws.afterName) {
        node.raws.afterName = node.raws.between;
        node.raws.between = '';
      }

      node.source.end = end;

      if (directives.length) {
        this.raw(node, 'directives', directives);

        if (last) {
          token = directives[directives.length - 1];
          node.source.end = { line: token[4], column: token[5] };
          this.spaces = node.raws.between;
          node.raws.between = '';
        }
      } else {
        node.directives = '';
      }

      if (open) {
        node.nodes = [];
        this.current = node;
      }
    }

    /* eslint-disable max-statements, complexity */

  }, {
    key: 'other',
    value: function other() {
      var brackets = [];
      var params = [];
      var start = this.pos;

      var end = false,
          colon = false,
          bracket = null;

      // we need pass "()" as spaces
      // However we can override method Parser.loop, but it seems less maintainable
      if (this.tokens[start][0] === 'brackets') {
        this.spaces += this.tokens[start][1];
        return;
      }

      var mixin = (0, _isMixinToken2.default)(this.tokens[start]);
      var extend = Boolean((0, _findExtendRule2.default)(this.tokens, start));

      while (this.pos < this.tokens.length) {
        var token = this.tokens[this.pos];
        var type = token[0];

        if (type === '(' || type === '[') {
          if (!bracket) {
            bracket = token;
          }

          brackets.push(type === '(' ? ')' : ']');
        } else if (brackets.length === 0) {
          if (type === ';') {
            var foundEndOfRule = this.ruleEnd({
              start: start,
              params: params,
              colon: colon,
              mixin: mixin,
              extend: extend
            });

            if (foundEndOfRule) {
              return;
            }

            break;
          } else if (type === '{') {
            this.createRule({ start: start, params: params, mixin: mixin });
            return;
          } else if (type === '}') {
            this.pos -= 1;
            end = true;
            break;
          } else if (type === ':') {
            colon = true;
          }
        } else if (type === brackets[brackets.length - 1]) {
          brackets.pop();
          if (brackets.length === 0) {
            bracket = null;
          }
        }

        // we don't want to add params for pseudo-selectors that utilize parens (#56)
        if ((extend || !colon) && (brackets.length > 0 || type === 'brackets' || params[0])) {
          params.push(token);
        }

        this.pos += 1;
      }

      if (this.pos === this.tokens.length) {
        this.pos -= 1;
        end = true;
      }

      if (brackets.length > 0) {
        this.unclosedBracket(bracket);
      }

      // dont process an end of rule if there's only one token and it's unknown (#64)
      if (end && this.tokens.length > 1) {
        // Handle the case where the there is only a single token in the end rule.
        if (start === this.pos) {
          this.pos += 1;
        }

        var _foundEndOfRule = this.ruleEnd({
          start: start,
          params: params,
          colon: colon,
          mixin: mixin,
          extend: extend,
          isEndOfBlock: true
        });

        if (_foundEndOfRule) {
          return;
        }
      }

      this.unknownWord(start);
    }
  }, {
    key: 'rule',
    value: function rule(tokens) {
      tokens.pop();

      var node = new _rule2.default();

      this.init(node, tokens[0][2], tokens[0][3]);

      //node.raws.between = this.spacesFromEnd(tokens);
      node.raws.between = this.spacesAndCommentsFromEnd(tokens);

      this.raw(node, 'selector', tokens);
      this.current = node;

      return node;
    }
  }, {
    key: 'ruleEnd',
    value: function ruleEnd(options) {
      var start = options.start;


      if (options.extend || options.mixin) {
        this.createRule(Object.assign(options, { empty: true }));
        return true;
      }

      if (options.colon) {
        if (options.isEndOfBlock) {
          while (this.pos > start) {
            var token = this.tokens[this.pos][0];

            if (token !== 'space' && token !== 'comment') {
              break;
            }

            this.pos -= 1;
          }
        }

        this.createDeclaration({ start: start });
        return true;
      }

      return false;
    }
  }, {
    key: 'tokenize',
    value: function tokenize() {
      this.tokens = (0, _lessTokenize2.default)(this.input);
    }

    /* eslint-enable max-statements, complexity */

  }]);

  return LessParser;
}(_parser2.default);

exports.default = LessParser;
module.exports = exports['default'];
},{"./find-extend-rule":724,"./import":725,"./is-mixin-token":726,"./less-tokenize":732,"./root":733,"./rule":734,"postcss/lib/comment":754,"postcss/lib/parser":764}],729:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };

var _stringifier = require('postcss/lib/stringifier');

var _stringifier2 = _interopRequireDefault(_stringifier);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var LessStringifier = function (_Stringifier) {
  _inherits(LessStringifier, _Stringifier);

  function LessStringifier() {
    _classCallCheck(this, LessStringifier);

    return _possibleConstructorReturn(this, (LessStringifier.__proto__ || Object.getPrototypeOf(LessStringifier)).apply(this, arguments));
  }

  _createClass(LessStringifier, [{
    key: 'comment',
    value: function comment(node) {
      this.builder(node.raws.content, node);
    }
  }, {
    key: 'import',
    value: function _import(node) {
      this.builder('@' + node.name);
      this.builder((node.raws.afterName || '') + (node.directives || '') + (node.raws.between || '') + (node.urlFunc ? 'url(' : '') + (node.raws.beforeUrl || '') + (node.importPath || '') + (node.raws.afterUrl || '') + (node.urlFunc ? ')' : '') + (node.raws.after || ''));

      if (node.raws.semicolon) {
        this.builder(';');
      }
    }
  }, {
    key: 'rule',
    value: function rule(node) {
      _get(LessStringifier.prototype.__proto__ || Object.getPrototypeOf(LessStringifier.prototype), 'rule', this).call(this, node);

      if (node.empty && node.raws.semicolon) {
        if (node.important) {
          this.builder(' !important');
        }

        if (node.raws.semicolon) {
          this.builder(';');
        }
      }
    }
  }, {
    key: 'block',
    value: function block(node, start) {
      var empty = node.empty;

      var between = this.raw(node, 'between', 'beforeOpen');
      var after = '';

      if (empty) {
        this.builder(start + between, node, 'start');
      } else {
        this.builder(start + between + '{', node, 'start');
      }

      if (node.nodes && node.nodes.length) {
        this.body(node);
        after = this.raw(node, 'after');
      } else {
        after = this.raw(node, 'after', 'emptyBody');
      }

      if (after) {
        this.builder(after);
      }

      if (!empty) {
        this.builder('}', node, 'end');
      }
    }
  }]);

  return LessStringifier;
}(_stringifier2.default);

exports.default = LessStringifier;
module.exports = exports['default'];
},{"postcss/lib/stringifier":770}],730:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = lessStringify;

var _lessStringifier = require('./less-stringifier');

var _lessStringifier2 = _interopRequireDefault(_lessStringifier);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function lessStringify(node, builder) {
  var str = new _lessStringifier2.default(builder);

  str.stringify(node);
}
module.exports = exports['default'];
},{"./less-stringifier":729}],731:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _lessParse = require('./less-parse');

var _lessParse2 = _interopRequireDefault(_lessParse);

var _lessStringify = require('./less-stringify');

var _lessStringify2 = _interopRequireDefault(_lessStringify);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = { parse: _lessParse2.default, stringify: _lessStringify2.default };
module.exports = exports['default'];
},{"./less-parse":727,"./less-stringify":730}],732:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = lessTokenize;

var _globals = require('./tokenizer/globals');

var _tokenizeSymbol = require('./tokenizer/tokenize-symbol');

var _tokenizeSymbol2 = _interopRequireDefault(_tokenizeSymbol);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function lessTokenize(input) {
  var state = {
    input: input,
    tokens: [],
    css: input.css.valueOf(),
    offset: -1,
    line: 1,
    pos: 0
  };

  state.length = state.css.length;

  while (state.pos < state.length) {
    state.symbolCode = state.css.charCodeAt(state.pos);
    state.symbol = state.css[state.pos];
    state.nextPos = null;
    state.escaped = null;
    state.lines = null;
    state.lastLine = null;
    state.cssPart = null;
    state.escape = null;
    state.nextLine = null;
    state.nextOffset = null;
    state.escapePos = null;
    state.token = null;

    if (state.symbolCode === _globals.newline) {
      state.offset = state.pos;
      state.line += 1;
    }

    (0, _tokenizeSymbol2.default)(state);

    state.pos++;
  }

  return state.tokens;
}
module.exports = exports['default'];
},{"./tokenizer/globals":736,"./tokenizer/tokenize-symbol":747}],733:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };

var _root = require('postcss/lib/root');

var _root2 = _interopRequireDefault(_root);

var _lessStringify = require('./less-stringify');

var _lessStringify2 = _interopRequireDefault(_lessStringify);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Root = function (_PostCssRoot) {
  _inherits(Root, _PostCssRoot);

  function Root() {
    _classCallCheck(this, Root);

    return _possibleConstructorReturn(this, (Root.__proto__ || Object.getPrototypeOf(Root)).apply(this, arguments));
  }

  _createClass(Root, [{
    key: 'toString',
    value: function toString(stringifier) {
      if (!stringifier) {
        stringifier = {
          stringify: _lessStringify2.default
        };
      }

      return _get(Root.prototype.__proto__ || Object.getPrototypeOf(Root.prototype), 'toString', this).call(this, stringifier);
    }
  }]);

  return Root;
}(_root2.default);

exports.default = Root;
module.exports = exports['default'];
},{"./less-stringify":730,"postcss/lib/root":768}],734:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };

var _rule = require('postcss/lib/rule');

var _rule2 = _interopRequireDefault(_rule);

var _lessStringify = require('./less-stringify');

var _lessStringify2 = _interopRequireDefault(_lessStringify);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Rule = function (_PostCssRule) {
  _inherits(Rule, _PostCssRule);

  function Rule() {
    _classCallCheck(this, Rule);

    return _possibleConstructorReturn(this, (Rule.__proto__ || Object.getPrototypeOf(Rule)).apply(this, arguments));
  }

  _createClass(Rule, [{
    key: 'toString',
    value: function toString(stringifier) {
      if (!stringifier) {
        stringifier = {
          stringify: _lessStringify2.default
        };
      }

      return _get(Rule.prototype.__proto__ || Object.getPrototypeOf(Rule.prototype), 'toString', this).call(this, stringifier);
    }
  }]);

  return Rule;
}(_rule2.default);

exports.default = Rule;
module.exports = exports['default'];
},{"./less-stringify":730,"postcss/lib/rule":769}],735:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = findEndOfEscaping;

var _globals = require('./globals');

/**
 * @param state
 * @returns {number}
 */
function findEndOfEscaping(state) {
  var openQuotesCount = 0,
      quoteCode = -1;

  for (var i = state.pos + 1; i < state.length; i++) {
    var symbolCode = state.css.charCodeAt(i);
    var prevSymbolCode = state.css.charCodeAt(i - 1);

    if (prevSymbolCode !== _globals.backslash && (symbolCode === _globals.singleQuote || symbolCode === _globals.doubleQuote || symbolCode === _globals.backTick)) {
      if (quoteCode === -1) {
        quoteCode = symbolCode;
        openQuotesCount++;
      } else if (symbolCode === quoteCode) {
        openQuotesCount--;

        if (!openQuotesCount) {
          return i;
        }
      }
    }
  }

  return -1;
}
module.exports = exports['default'];
},{"./globals":736}],736:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
var singleQuote = exports.singleQuote = '\''.charCodeAt(0);
var doubleQuote = exports.doubleQuote = '"'.charCodeAt(0);
var backslash = exports.backslash = '\\'.charCodeAt(0);
var backTick = exports.backTick = '`'.charCodeAt(0);
var slash = exports.slash = '/'.charCodeAt(0);
var newline = exports.newline = '\n'.charCodeAt(0);
var space = exports.space = ' '.charCodeAt(0);
var feed = exports.feed = '\f'.charCodeAt(0);
var tab = exports.tab = '\t'.charCodeAt(0);
var carriageReturn = exports.carriageReturn = '\r'.charCodeAt(0);
var openedParenthesis = exports.openedParenthesis = '('.charCodeAt(0);
var closedParenthesis = exports.closedParenthesis = ')'.charCodeAt(0);
var openedCurlyBracket = exports.openedCurlyBracket = '{'.charCodeAt(0);
var closedCurlyBracket = exports.closedCurlyBracket = '}'.charCodeAt(0);
var openSquareBracket = exports.openSquareBracket = '['.charCodeAt(0);
var closeSquareBracket = exports.closeSquareBracket = ']'.charCodeAt(0);
var semicolon = exports.semicolon = ';'.charCodeAt(0);
var asterisk = exports.asterisk = '*'.charCodeAt(0);
var colon = exports.colon = ':'.charCodeAt(0);
var comma = exports.comma = ','.charCodeAt(0);
var dot = exports.dot = '.'.charCodeAt(0);
var atRule = exports.atRule = '@'.charCodeAt(0);
var tilde = exports.tilde = '~'.charCodeAt(0);
var hash = exports.hash = '#'.charCodeAt(0);

var atEndPattern = exports.atEndPattern = /[ \n\t\r\f\{\(\)'"\\;/\[\]#]/g;
var wordEndPattern = exports.wordEndPattern = /[ \n\t\r\f\(\)\{\}:,;@!'"\\\]\[#]|\/(?=\*)/g;
var badBracketPattern = exports.badBracketPattern = /.[\\\/\("'\n]/;

var variablePattern = exports.variablePattern = /^@[^:\(\{]+:/;
var hashColorPattern = exports.hashColorPattern = /^#[0-9a-fA-F]{6}$|^#[0-9a-fA-F]{3}$/;
},{}],737:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = isEscaping;

var _globals = require('./globals');

var nextSymbolVariants = [_globals.backTick, _globals.doubleQuote, _globals.singleQuote];

function isEscaping(state) {
  var nextSymbolCode = state.css.charCodeAt(state.pos + 1);

  return state.symbolCode === _globals.tilde && nextSymbolVariants.indexOf(nextSymbolCode) >= 0;
}
module.exports = exports['default'];
},{"./globals":736}],738:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = tokenizeAtRule;

var _globals = require('./globals');

var _unclosed = require('./unclosed');

var _unclosed2 = _interopRequireDefault(_unclosed);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function tokenizeAtRule(state) {
  // it's an interpolation
  if (state.css.charCodeAt(state.pos + 1) === _globals.openedCurlyBracket) {
    state.nextPos = state.css.indexOf('}', state.pos + 2);

    if (state.nextPos === -1) {
      (0, _unclosed2.default)(state, 'interpolation');
    }

    state.cssPart = state.css.slice(state.pos, state.nextPos + 1);
    state.lines = state.cssPart.split('\n');
    state.lastLine = state.lines.length - 1;

    if (state.lastLine > 0) {
      state.nextLine = state.line + state.lastLine;
      state.nextOffset = state.nextPos - state.lines[state.lastLine].length;
    } else {
      state.nextLine = state.line;
      state.nextOffset = state.offset;
    }

    state.tokens.push(['word', state.cssPart, state.line, state.pos - state.offset, state.nextLine, state.nextPos - state.nextOffset]);

    state.offset = state.nextOffset;
    state.line = state.nextLine;
  } else {
    _globals.atEndPattern.lastIndex = state.pos + 1;
    _globals.atEndPattern.test(state.css);

    if (_globals.atEndPattern.lastIndex === 0) {
      state.nextPos = state.css.length - 1;
    } else {
      state.nextPos = _globals.atEndPattern.lastIndex - 2;
    }

    state.cssPart = state.css.slice(state.pos, state.nextPos + 1);
    state.token = 'at-word';

    // check if it's a variable
    if (_globals.variablePattern.test(state.cssPart)) {
      _globals.wordEndPattern.lastIndex = state.pos + 1;
      _globals.wordEndPattern.test(state.css);
      if (_globals.wordEndPattern.lastIndex === 0) {
        state.nextPos = state.css.length - 1;
      } else {
        state.nextPos = _globals.wordEndPattern.lastIndex - 2;
      }

      state.cssPart = state.css.slice(state.pos, state.nextPos + 1);
      state.token = 'word';
    }

    state.tokens.push([state.token, state.cssPart, state.line, state.pos - state.offset, state.line, state.nextPos - state.offset]);
  }

  state.pos = state.nextPos;
}
module.exports = exports['default'];
},{"./globals":736,"./unclosed":749}],739:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = tokenizeBackslash;

var _globals = require('./globals');

function tokenizeBackslash(state) {
  state.nextPos = state.pos;
  state.escape = true;

  while (state.css.charCodeAt(state.nextPos + 1) === _globals.backslash) {
    state.nextPos += 1;
    state.escape = !state.escape;
  }

  state.symbolCode = state.css.charCodeAt(state.nextPos + 1);

  if (state.escape && state.symbolCode !== _globals.slash && state.symbolCode !== _globals.space && state.symbolCode !== _globals.newline && state.symbolCode !== _globals.tab && state.symbolCode !== _globals.carriageReturn && state.symbolCode !== _globals.feed) {
    state.nextPos += 1;
  }

  state.tokens.push(['word', state.css.slice(state.pos, state.nextPos + 1), state.line, state.pos - state.offset, state.line, state.nextPos - state.offset]);

  state.pos = state.nextPos;
}
module.exports = exports['default'];
},{"./globals":736}],740:[function(require,module,exports){
"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = tokenizeBasicSymbol;
function tokenizeBasicSymbol(state) {
  state.tokens.push([state.symbol, state.symbol, state.line, state.pos - state.offset]);
}
module.exports = exports["default"];
},{}],741:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = tokenizeComma;
function tokenizeComma(state) {
  state.tokens.push(['word', state.symbol, state.line, state.pos - state.offset, state.line, state.pos - state.offset + 1]);
}
module.exports = exports['default'];
},{}],742:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = tokenizeDefault;

var _globals = require('./globals');

var _findEndOfEscaping = require('./find-end-of-escaping');

var _findEndOfEscaping2 = _interopRequireDefault(_findEndOfEscaping);

var _isEscaping = require('./is-escaping');

var _isEscaping2 = _interopRequireDefault(_isEscaping);

var _tokenizeInlineComment = require('./tokenize-inline-comment');

var _tokenizeInlineComment2 = _interopRequireDefault(_tokenizeInlineComment);

var _tokenizeMultilineComment = require('./tokenize-multiline-comment');

var _tokenizeMultilineComment2 = _interopRequireDefault(_tokenizeMultilineComment);

var _unclosed = require('./unclosed');

var _unclosed2 = _interopRequireDefault(_unclosed);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function tokenizeDefault(state) {
  var nextSymbolCode = state.css.charCodeAt(state.pos + 1);

  if (state.symbolCode === _globals.slash && nextSymbolCode === _globals.asterisk) {
    (0, _tokenizeMultilineComment2.default)(state);
  } else if (state.symbolCode === _globals.slash && nextSymbolCode === _globals.slash) {
    (0, _tokenizeInlineComment2.default)(state);
  } else {
    if ((0, _isEscaping2.default)(state)) {
      var pos = (0, _findEndOfEscaping2.default)(state);

      if (pos < 0) {
        (0, _unclosed2.default)(state, 'escaping');
      } else {
        state.nextPos = pos;
      }
    } else {
      _globals.wordEndPattern.lastIndex = state.pos + 1;
      _globals.wordEndPattern.test(state.css);

      if (_globals.wordEndPattern.lastIndex === 0) {
        state.nextPos = state.css.length - 1;
      } else {
        state.nextPos = _globals.wordEndPattern.lastIndex - 2;
      }
    }

    state.cssPart = state.css.slice(state.pos, state.nextPos + 1);

    state.tokens.push(['word', state.cssPart, state.line, state.pos - state.offset, state.line, state.nextPos - state.offset]);

    state.pos = state.nextPos;
  }
}
module.exports = exports['default'];
},{"./find-end-of-escaping":735,"./globals":736,"./is-escaping":737,"./tokenize-inline-comment":743,"./tokenize-multiline-comment":744,"./unclosed":749}],743:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = tokenizeInlineComment;
function tokenizeInlineComment(state) {
  state.nextPos = state.css.indexOf('\n', state.pos + 2) - 1;

  if (state.nextPos === -2) {
    state.nextPos = state.css.length - 1;
  }

  state.tokens.push(['comment', state.css.slice(state.pos, state.nextPos + 1), state.line, state.pos - state.offset, state.line, state.nextPos - state.offset, 'inline']);

  state.pos = state.nextPos;
}
module.exports = exports['default'];
},{}],744:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = tokenizeMultilineComment;

var _unclosed = require('./unclosed');

var _unclosed2 = _interopRequireDefault(_unclosed);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function tokenizeMultilineComment(state) {
  state.nextPos = state.css.indexOf('*/', state.pos + 2) + 1;

  if (state.nextPos === 0) {
    (0, _unclosed2.default)(state, 'comment');
  }

  state.cssPart = state.css.slice(state.pos, state.nextPos + 1);
  state.lines = state.cssPart.split('\n');
  state.lastLine = state.lines.length - 1;

  if (state.lastLine > 0) {
    state.nextLine = state.line + state.lastLine;
    state.nextOffset = state.nextPos - state.lines[state.lastLine].length;
  } else {
    state.nextLine = state.line;
    state.nextOffset = state.offset;
  }

  state.tokens.push(['comment', state.cssPart, state.line, state.pos - state.offset, state.nextLine, state.nextPos - state.nextOffset]);

  state.offset = state.nextOffset;
  state.line = state.nextLine;
  state.pos = state.nextPos;
}
module.exports = exports['default'];
},{"./unclosed":749}],745:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = tokenizeOpenedParenthesis;

var _globals = require('./globals');

var _unclosed = require('./unclosed');

var _unclosed2 = _interopRequireDefault(_unclosed);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function findClosedParenthesisPosition(css, length, start) {
  var openedParenthesisCount = 0;

  for (var i = start; i < length; i++) {
    var symbol = css[i];

    if (symbol === '(') {
      openedParenthesisCount++;
    } else if (symbol === ')') {
      openedParenthesisCount--;

      if (!openedParenthesisCount) {
        return i;
      }
    }
  }

  return -1;
}

// it is not very reasonable to reduce complexity beyond this level
// eslint-disable-next-line complexity
function tokenizeOpenedParenthesis(state) {
  var nextSymbolCode = state.css.charCodeAt(state.pos + 1);
  var tokensCount = state.tokens.length;
  var prevTokenCssPart = tokensCount ? state.tokens[tokensCount - 1][1] : '';

  if (prevTokenCssPart === 'url' && nextSymbolCode !== _globals.singleQuote && nextSymbolCode !== _globals.doubleQuote && nextSymbolCode !== _globals.space && nextSymbolCode !== _globals.newline && nextSymbolCode !== _globals.tab && nextSymbolCode !== _globals.feed && nextSymbolCode !== _globals.carriageReturn) {
    state.nextPos = state.pos;

    do {
      state.escaped = false;
      state.nextPos = state.css.indexOf(')', state.nextPos + 1);

      if (state.nextPos === -1) {
        (0, _unclosed2.default)(state, 'bracket');
      }

      state.escapePos = state.nextPos;

      while (state.css.charCodeAt(state.escapePos - 1) === _globals.backslash) {
        state.escapePos -= 1;
        state.escaped = !state.escaped;
      }
    } while (state.escaped);

    state.tokens.push(['brackets', state.css.slice(state.pos, state.nextPos + 1), state.line, state.pos - state.offset, state.line, state.nextPos - state.offset]);
    state.pos = state.nextPos;
  } else {
    state.nextPos = findClosedParenthesisPosition(state.css, state.length, state.pos);
    state.cssPart = state.css.slice(state.pos, state.nextPos + 1);

    var foundParam = state.cssPart.indexOf('@') >= 0;
    var foundString = /['"]/.test(state.cssPart);

    if (state.cssPart.length === 0 || state.cssPart === '...' || foundParam && !foundString) {
      // we're dealing with a mixin param block
      if (state.nextPos === -1) {
        (0, _unclosed2.default)(state, 'bracket');
      }

      state.tokens.push([state.symbol, state.symbol, state.line, state.pos - state.offset]);
    } else {
      var badBracket = _globals.badBracketPattern.test(state.cssPart);

      if (state.nextPos === -1 || badBracket) {
        state.tokens.push([state.symbol, state.symbol, state.line, state.pos - state.offset]);
      } else {
        state.tokens.push(['brackets', state.cssPart, state.line, state.pos - state.offset, state.line, state.nextPos - state.offset]);
        state.pos = state.nextPos;
      }
    }
  }
}
module.exports = exports['default'];
},{"./globals":736,"./unclosed":749}],746:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = tokenizeQuotes;

var _globals = require('./globals');

var _unclosed = require('./unclosed');

var _unclosed2 = _interopRequireDefault(_unclosed);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function tokenizeQuotes(state) {
  state.nextPos = state.pos;

  do {
    state.escaped = false;
    state.nextPos = state.css.indexOf(state.symbol, state.nextPos + 1);

    if (state.nextPos === -1) {
      (0, _unclosed2.default)(state, 'quote');
    }

    state.escapePos = state.nextPos;

    while (state.css.charCodeAt(state.escapePos - 1) === _globals.backslash) {
      state.escapePos -= 1;
      state.escaped = !state.escaped;
    }
  } while (state.escaped);

  state.tokens.push(['string', state.css.slice(state.pos, state.nextPos + 1), state.line, state.pos - state.offset, state.line, state.nextPos - state.offset]);

  state.pos = state.nextPos;
}
module.exports = exports['default'];
},{"./globals":736,"./unclosed":749}],747:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = tokenizeSymbol;

var _globals = require('./globals');

var _tokenizeAtRule = require('./tokenize-at-rule');

var _tokenizeAtRule2 = _interopRequireDefault(_tokenizeAtRule);

var _tokenizeBackslash = require('./tokenize-backslash');

var _tokenizeBackslash2 = _interopRequireDefault(_tokenizeBackslash);

var _tokenizeBasicSymbol = require('./tokenize-basic-symbol');

var _tokenizeBasicSymbol2 = _interopRequireDefault(_tokenizeBasicSymbol);

var _tokenizeComma = require('./tokenize-comma');

var _tokenizeComma2 = _interopRequireDefault(_tokenizeComma);

var _tokenizeDefault = require('./tokenize-default');

var _tokenizeDefault2 = _interopRequireDefault(_tokenizeDefault);

var _tokenizeOpenedParenthesis = require('./tokenize-opened-parenthesis');

var _tokenizeOpenedParenthesis2 = _interopRequireDefault(_tokenizeOpenedParenthesis);

var _tokenizeQuotes = require('./tokenize-quotes');

var _tokenizeQuotes2 = _interopRequireDefault(_tokenizeQuotes);

var _tokenizeWhitespace = require('./tokenize-whitespace');

var _tokenizeWhitespace2 = _interopRequireDefault(_tokenizeWhitespace);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

// we cannot reduce complexity beyond this level
// eslint-disable-next-line complexity
function tokenizeSymbol(state) {
  switch (state.symbolCode) {
    case _globals.newline:
    case _globals.space:
    case _globals.tab:
    case _globals.carriageReturn:
    case _globals.feed:
      (0, _tokenizeWhitespace2.default)(state);
      break;

    case _globals.comma:
      (0, _tokenizeComma2.default)(state);
      break;

    case _globals.colon:
    case _globals.semicolon:
    case _globals.openedCurlyBracket:
    case _globals.closedCurlyBracket:
    case _globals.closedParenthesis:
    case _globals.openSquareBracket:
    case _globals.closeSquareBracket:
      (0, _tokenizeBasicSymbol2.default)(state);
      break;

    case _globals.openedParenthesis:
      (0, _tokenizeOpenedParenthesis2.default)(state);
      break;

    case _globals.singleQuote:
    case _globals.doubleQuote:
      (0, _tokenizeQuotes2.default)(state);
      break;

    case _globals.atRule:
      (0, _tokenizeAtRule2.default)(state);
      break;

    case _globals.backslash:
      (0, _tokenizeBackslash2.default)(state);
      break;

    default:
      (0, _tokenizeDefault2.default)(state);
      break;
  }
}
module.exports = exports['default'];
},{"./globals":736,"./tokenize-at-rule":738,"./tokenize-backslash":739,"./tokenize-basic-symbol":740,"./tokenize-comma":741,"./tokenize-default":742,"./tokenize-opened-parenthesis":745,"./tokenize-quotes":746,"./tokenize-whitespace":748}],748:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = tokenizeWhitespace;

var _globals = require('./globals');

function tokenizeWhitespace(state) {
  state.nextPos = state.pos;

  // collect all neighbour space symbols
  do {
    state.nextPos += 1;
    state.symbolCode = state.css.charCodeAt(state.nextPos);
    if (state.symbolCode === _globals.newline) {
      state.offset = state.nextPos;
      state.line += 1;
    }
  } while (state.symbolCode === _globals.space || state.symbolCode === _globals.newline || state.symbolCode === _globals.tab || state.symbolCode === _globals.carriageReturn || state.symbolCode === _globals.feed);

  state.tokens.push(['space', state.css.slice(state.pos, state.nextPos)]);
  state.pos = state.nextPos - 1;
}
module.exports = exports['default'];
},{"./globals":736}],749:[function(require,module,exports){
"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = unclosed;
function unclosed(state, what) {
  throw state.input.error("Unclosed " + what, state.line, state.pos - state.offset);
}
module.exports = exports["default"];
},{}],750:[function(require,module,exports){
arguments[4][694][0].apply(exports,arguments)
},{"dup":694}],751:[function(require,module,exports){
arguments[4][695][0].apply(exports,arguments)
},{"_process":16,"ansi-styles":750,"dup":695,"escape-string-regexp":604,"has-ansi":631,"strip-ansi":869,"supports-color":752}],752:[function(require,module,exports){
arguments[4][696][0].apply(exports,arguments)
},{"_process":16,"dup":696}],753:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _container = require('./container');

var _container2 = _interopRequireDefault(_container);

var _warnOnce = require('./warn-once');

var _warnOnce2 = _interopRequireDefault(_warnOnce);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

/**
 * Represents an at-rule.
 *
 * If it’s followed in the CSS by a {} block, this node will have
 * a nodes property representing its children.
 *
 * @extends Container
 *
 * @example
 * const root = postcss.parse('@charset "UTF-8"; @media print {}');
 *
 * const charset = root.first;
 * charset.type  //=> 'atrule'
 * charset.nodes //=> undefined
 *
 * const media = root.last;
 * media.nodes   //=> []
 */
var AtRule = function (_Container) {
    _inherits(AtRule, _Container);

    function AtRule(defaults) {
        _classCallCheck(this, AtRule);

        var _this = _possibleConstructorReturn(this, _Container.call(this, defaults));

        _this.type = 'atrule';
        return _this;
    }

    AtRule.prototype.append = function append() {
        var _Container$prototype$;

        if (!this.nodes) this.nodes = [];

        for (var _len = arguments.length, children = Array(_len), _key = 0; _key < _len; _key++) {
            children[_key] = arguments[_key];
        }

        return (_Container$prototype$ = _Container.prototype.append).call.apply(_Container$prototype$, [this].concat(children));
    };

    AtRule.prototype.prepend = function prepend() {
        var _Container$prototype$2;

        if (!this.nodes) this.nodes = [];

        for (var _len2 = arguments.length, children = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
            children[_key2] = arguments[_key2];
        }

        return (_Container$prototype$2 = _Container.prototype.prepend).call.apply(_Container$prototype$2, [this].concat(children));
    };

    _createClass(AtRule, [{
        key: 'afterName',
        get: function get() {
            (0, _warnOnce2.default)('AtRule#afterName was deprecated. Use AtRule#raws.afterName');
            return this.raws.afterName;
        },
        set: function set(val) {
            (0, _warnOnce2.default)('AtRule#afterName was deprecated. Use AtRule#raws.afterName');
            this.raws.afterName = val;
        }
    }, {
        key: '_params',
        get: function get() {
            (0, _warnOnce2.default)('AtRule#_params was deprecated. Use AtRule#raws.params');
            return this.raws.params;
        },
        set: function set(val) {
            (0, _warnOnce2.default)('AtRule#_params was deprecated. Use AtRule#raws.params');
            this.raws.params = val;
        }

        /**
         * @memberof AtRule#
         * @member {string} name - the at-rule’s name immediately follows the `@`
         *
         * @example
         * const root  = postcss.parse('@media print {}');
         * media.name //=> 'media'
         * const media = root.first;
         */

        /**
         * @memberof AtRule#
         * @member {string} params - the at-rule’s parameters, the values
         *                           that follow the at-rule’s name but precede
         *                           any {} block
         *
         * @example
         * const root  = postcss.parse('@media print, screen {}');
         * const media = root.first;
         * media.params //=> 'print, screen'
         */

        /**
         * @memberof AtRule#
         * @member {object} raws - Information to generate byte-to-byte equal
         *                         node string as it was in the origin input.
         *
         * Every parser saves its own properties,
         * but the default CSS parser uses:
         *
         * * `before`: the space symbols before the node. It also stores `*`
         *   and `_` symbols before the declaration (IE hack).
         * * `after`: the space symbols after the last child of the node
         *   to the end of the node.
         * * `between`: the symbols between the property and value
         *   for declarations, selector and `{` for rules, or last parameter
         *   and `{` for at-rules.
         * * `semicolon`: contains true if the last child has
         *   an (optional) semicolon.
         * * `afterName`: the space between the at-rule name and its parameters.
         *
         * PostCSS cleans at-rule parameters from comments and extra spaces,
         * but it stores origin content in raws properties.
         * As such, if you don’t change a declaration’s value,
         * PostCSS will use the raw value with comments.
         *
         * @example
         * const root = postcss.parse('  @media\nprint {\n}')
         * root.first.first.raws //=> { before: '  ',
         *                       //     between: ' ',
         *                       //     afterName: '\n',
         *                       //     after: '\n' }
         */

    }]);

    return AtRule;
}(_container2.default);

exports.default = AtRule;
module.exports = exports['default'];


},{"./container":755,"./warn-once":774}],754:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _warnOnce = require('./warn-once');

var _warnOnce2 = _interopRequireDefault(_warnOnce);

var _node = require('./node');

var _node2 = _interopRequireDefault(_node);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

/**
 * Represents a comment between declarations or statements (rule and at-rules).
 *
 * Comments inside selectors, at-rule parameters, or declaration values
 * will be stored in the `raws` properties explained above.
 *
 * @extends Node
 */
var Comment = function (_Node) {
    _inherits(Comment, _Node);

    function Comment(defaults) {
        _classCallCheck(this, Comment);

        var _this = _possibleConstructorReturn(this, _Node.call(this, defaults));

        _this.type = 'comment';
        return _this;
    }

    _createClass(Comment, [{
        key: 'left',
        get: function get() {
            (0, _warnOnce2.default)('Comment#left was deprecated. Use Comment#raws.left');
            return this.raws.left;
        },
        set: function set(val) {
            (0, _warnOnce2.default)('Comment#left was deprecated. Use Comment#raws.left');
            this.raws.left = val;
        }
    }, {
        key: 'right',
        get: function get() {
            (0, _warnOnce2.default)('Comment#right was deprecated. Use Comment#raws.right');
            return this.raws.right;
        },
        set: function set(val) {
            (0, _warnOnce2.default)('Comment#right was deprecated. Use Comment#raws.right');
            this.raws.right = val;
        }

        /**
         * @memberof Comment#
         * @member {string} text - the comment’s text
         */

        /**
         * @memberof Comment#
         * @member {object} raws - Information to generate byte-to-byte equal
         *                         node string as it was in the origin input.
         *
         * Every parser saves its own properties,
         * but the default CSS parser uses:
         *
         * * `before`: the space symbols before the node.
         * * `left`: the space symbols between `/*` and the comment’s text.
         * * `right`: the space symbols between the comment’s text.
         */

    }]);

    return Comment;
}(_node2.default);

exports.default = Comment;
module.exports = exports['default'];


},{"./node":762,"./warn-once":774}],755:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _declaration = require('./declaration');

var _declaration2 = _interopRequireDefault(_declaration);

var _warnOnce = require('./warn-once');

var _warnOnce2 = _interopRequireDefault(_warnOnce);

var _comment = require('./comment');

var _comment2 = _interopRequireDefault(_comment);

var _node = require('./node');

var _node2 = _interopRequireDefault(_node);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

function cleanSource(nodes) {
    return nodes.map(function (i) {
        if (i.nodes) i.nodes = cleanSource(i.nodes);
        delete i.source;
        return i;
    });
}

/**
 * The {@link Root}, {@link AtRule}, and {@link Rule} container nodes
 * inherit some common methods to help work with their children.
 *
 * Note that all containers can store any content. If you write a rule inside
 * a rule, PostCSS will parse it.
 *
 * @extends Node
 * @abstract
 */

var Container = function (_Node) {
    _inherits(Container, _Node);

    function Container() {
        _classCallCheck(this, Container);

        return _possibleConstructorReturn(this, _Node.apply(this, arguments));
    }

    Container.prototype.push = function push(child) {
        child.parent = this;
        this.nodes.push(child);
        return this;
    };

    /**
     * Iterates through the container’s immediate children,
     * calling `callback` for each child.
     *
     * Returning `false` in the callback will break iteration.
     *
     * This method only iterates through the container’s immediate children.
     * If you need to recursively iterate through all the container’s descendant
     * nodes, use {@link Container#walk}.
     *
     * Unlike the for `{}`-cycle or `Array#forEach` this iterator is safe
     * if you are mutating the array of child nodes during iteration.
     * PostCSS will adjust the current index to match the mutations.
     *
     * @param {childIterator} callback - iterator receives each node and index
     *
     * @return {false|undefined} returns `false` if iteration was broke
     *
     * @example
     * const root = postcss.parse('a { color: black; z-index: 1 }');
     * const rule = root.first;
     *
     * for ( let decl of rule.nodes ) {
     *     decl.cloneBefore({ prop: '-webkit-' + decl.prop });
     *     // Cycle will be infinite, because cloneBefore moves the current node
     *     // to the next index
     * }
     *
     * rule.each(decl => {
     *     decl.cloneBefore({ prop: '-webkit-' + decl.prop });
     *     // Will be executed only for color and z-index
     * });
     */


    Container.prototype.each = function each(callback) {
        if (!this.lastEach) this.lastEach = 0;
        if (!this.indexes) this.indexes = {};

        this.lastEach += 1;
        var id = this.lastEach;
        this.indexes[id] = 0;

        if (!this.nodes) return undefined;

        var index = void 0,
            result = void 0;
        while (this.indexes[id] < this.nodes.length) {
            index = this.indexes[id];
            result = callback(this.nodes[index], index);
            if (result === false) break;

            this.indexes[id] += 1;
        }

        delete this.indexes[id];

        return result;
    };

    /**
     * Traverses the container’s descendant nodes, calling callback
     * for each node.
     *
     * Like container.each(), this method is safe to use
     * if you are mutating arrays during iteration.
     *
     * If you only need to iterate through the container’s immediate children,
     * use {@link Container#each}.
     *
     * @param {childIterator} callback - iterator receives each node and index
     *
     * @return {false|undefined} returns `false` if iteration was broke
     *
     * @example
     * root.walk(node => {
     *   // Traverses all descendant nodes.
     * });
     */


    Container.prototype.walk = function walk(callback) {
        return this.each(function (child, i) {
            var result = callback(child, i);
            if (result !== false && child.walk) {
                result = child.walk(callback);
            }
            return result;
        });
    };

    /**
     * Traverses the container’s descendant nodes, calling callback
     * for each declaration node.
     *
     * If you pass a filter, iteration will only happen over declarations
     * with matching properties.
     *
     * Like {@link Container#each}, this method is safe
     * to use if you are mutating arrays during iteration.
     *
     * @param {string|RegExp} [prop]   - string or regular expression
     *                                   to filter declarations by property name
     * @param {childIterator} callback - iterator receives each node and index
     *
     * @return {false|undefined} returns `false` if iteration was broke
     *
     * @example
     * root.walkDecls(decl => {
     *   checkPropertySupport(decl.prop);
     * });
     *
     * root.walkDecls('border-radius', decl => {
     *   decl.remove();
     * });
     *
     * root.walkDecls(/^background/, decl => {
     *   decl.value = takeFirstColorFromGradient(decl.value);
     * });
     */


    Container.prototype.walkDecls = function walkDecls(prop, callback) {
        if (!callback) {
            callback = prop;
            return this.walk(function (child, i) {
                if (child.type === 'decl') {
                    return callback(child, i);
                }
            });
        } else if (prop instanceof RegExp) {
            return this.walk(function (child, i) {
                if (child.type === 'decl' && prop.test(child.prop)) {
                    return callback(child, i);
                }
            });
        } else {
            return this.walk(function (child, i) {
                if (child.type === 'decl' && child.prop === prop) {
                    return callback(child, i);
                }
            });
        }
    };

    /**
     * Traverses the container’s descendant nodes, calling callback
     * for each rule node.
     *
     * If you pass a filter, iteration will only happen over rules
     * with matching selectors.
     *
     * Like {@link Container#each}, this method is safe
     * to use if you are mutating arrays during iteration.
     *
     * @param {string|RegExp} [selector] - string or regular expression
     *                                     to filter rules by selector
     * @param {childIterator} callback   - iterator receives each node and index
     *
     * @return {false|undefined} returns `false` if iteration was broke
     *
     * @example
     * const selectors = [];
     * root.walkRules(rule => {
     *   selectors.push(rule.selector);
     * });
     * console.log(`Your CSS uses ${selectors.length} selectors`);
     */


    Container.prototype.walkRules = function walkRules(selector, callback) {
        if (!callback) {
            callback = selector;

            return this.walk(function (child, i) {
                if (child.type === 'rule') {
                    return callback(child, i);
                }
            });
        } else if (selector instanceof RegExp) {
            return this.walk(function (child, i) {
                if (child.type === 'rule' && selector.test(child.selector)) {
                    return callback(child, i);
                }
            });
        } else {
            return this.walk(function (child, i) {
                if (child.type === 'rule' && child.selector === selector) {
                    return callback(child, i);
                }
            });
        }
    };

    /**
     * Traverses the container’s descendant nodes, calling callback
     * for each at-rule node.
     *
     * If you pass a filter, iteration will only happen over at-rules
     * that have matching names.
     *
     * Like {@link Container#each}, this method is safe
     * to use if you are mutating arrays during iteration.
     *
     * @param {string|RegExp} [name]   - string or regular expression
     *                                   to filter at-rules by name
     * @param {childIterator} callback - iterator receives each node and index
     *
     * @return {false|undefined} returns `false` if iteration was broke
     *
     * @example
     * root.walkAtRules(rule => {
     *   if ( isOld(rule.name) ) rule.remove();
     * });
     *
     * let first = false;
     * root.walkAtRules('charset', rule => {
     *   if ( !first ) {
     *     first = true;
     *   } else {
     *     rule.remove();
     *   }
     * });
     */


    Container.prototype.walkAtRules = function walkAtRules(name, callback) {
        if (!callback) {
            callback = name;
            return this.walk(function (child, i) {
                if (child.type === 'atrule') {
                    return callback(child, i);
                }
            });
        } else if (name instanceof RegExp) {
            return this.walk(function (child, i) {
                if (child.type === 'atrule' && name.test(child.name)) {
                    return callback(child, i);
                }
            });
        } else {
            return this.walk(function (child, i) {
                if (child.type === 'atrule' && child.name === name) {
                    return callback(child, i);
                }
            });
        }
    };

    /**
     * Traverses the container’s descendant nodes, calling callback
     * for each comment node.
     *
     * Like {@link Container#each}, this method is safe
     * to use if you are mutating arrays during iteration.
     *
     * @param {childIterator} callback - iterator receives each node and index
     *
     * @return {false|undefined} returns `false` if iteration was broke
     *
     * @example
     * root.walkComments(comment => {
     *   comment.remove();
     * });
     */


    Container.prototype.walkComments = function walkComments(callback) {
        return this.walk(function (child, i) {
            if (child.type === 'comment') {
                return callback(child, i);
            }
        });
    };

    /**
     * Inserts new nodes to the end of the container.
     *
     * @param {...(Node|object|string|Node[])} children - new nodes
     *
     * @return {Node} this node for methods chain
     *
     * @example
     * const decl1 = postcss.decl({ prop: 'color', value: 'black' });
     * const decl2 = postcss.decl({ prop: 'background-color', value: 'white' });
     * rule.append(decl1, decl2);
     *
     * root.append({ name: 'charset', params: '"UTF-8"' });  // at-rule
     * root.append({ selector: 'a' });                       // rule
     * rule.append({ prop: 'color', value: 'black' });       // declaration
     * rule.append({ text: 'Comment' })                      // comment
     *
     * root.append('a {}');
     * root.first.append('color: black; z-index: 1');
     */


    Container.prototype.append = function append() {
        for (var _len = arguments.length, children = Array(_len), _key = 0; _key < _len; _key++) {
            children[_key] = arguments[_key];
        }

        for (var _iterator = children, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
            var _ref;

            if (_isArray) {
                if (_i >= _iterator.length) break;
                _ref = _iterator[_i++];
            } else {
                _i = _iterator.next();
                if (_i.done) break;
                _ref = _i.value;
            }

            var child = _ref;

            var nodes = this.normalize(child, this.last);
            for (var _iterator2 = nodes, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
                var _ref2;

                if (_isArray2) {
                    if (_i2 >= _iterator2.length) break;
                    _ref2 = _iterator2[_i2++];
                } else {
                    _i2 = _iterator2.next();
                    if (_i2.done) break;
                    _ref2 = _i2.value;
                }

                var node = _ref2;
                this.nodes.push(node);
            }
        }
        return this;
    };

    /**
     * Inserts new nodes to the start of the container.
     *
     * @param {...(Node|object|string|Node[])} children - new nodes
     *
     * @return {Node} this node for methods chain
     *
     * @example
     * const decl1 = postcss.decl({ prop: 'color', value: 'black' });
     * const decl2 = postcss.decl({ prop: 'background-color', value: 'white' });
     * rule.prepend(decl1, decl2);
     *
     * root.append({ name: 'charset', params: '"UTF-8"' });  // at-rule
     * root.append({ selector: 'a' });                       // rule
     * rule.append({ prop: 'color', value: 'black' });       // declaration
     * rule.append({ text: 'Comment' })                      // comment
     *
     * root.append('a {}');
     * root.first.append('color: black; z-index: 1');
     */


    Container.prototype.prepend = function prepend() {
        for (var _len2 = arguments.length, children = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
            children[_key2] = arguments[_key2];
        }

        children = children.reverse();
        for (var _iterator3 = children, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
            var _ref3;

            if (_isArray3) {
                if (_i3 >= _iterator3.length) break;
                _ref3 = _iterator3[_i3++];
            } else {
                _i3 = _iterator3.next();
                if (_i3.done) break;
                _ref3 = _i3.value;
            }

            var child = _ref3;

            var nodes = this.normalize(child, this.first, 'prepend').reverse();
            for (var _iterator4 = nodes, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) {
                var _ref4;

                if (_isArray4) {
                    if (_i4 >= _iterator4.length) break;
                    _ref4 = _iterator4[_i4++];
                } else {
                    _i4 = _iterator4.next();
                    if (_i4.done) break;
                    _ref4 = _i4.value;
                }

                var node = _ref4;
                this.nodes.unshift(node);
            }for (var id in this.indexes) {
                this.indexes[id] = this.indexes[id] + nodes.length;
            }
        }
        return this;
    };

    Container.prototype.cleanRaws = function cleanRaws(keepBetween) {
        _Node.prototype.cleanRaws.call(this, keepBetween);
        if (this.nodes) {
            for (var _iterator5 = this.nodes, _isArray5 = Array.isArray(_iterator5), _i5 = 0, _iterator5 = _isArray5 ? _iterator5 : _iterator5[Symbol.iterator]();;) {
                var _ref5;

                if (_isArray5) {
                    if (_i5 >= _iterator5.length) break;
                    _ref5 = _iterator5[_i5++];
                } else {
                    _i5 = _iterator5.next();
                    if (_i5.done) break;
                    _ref5 = _i5.value;
                }

                var node = _ref5;
                node.cleanRaws(keepBetween);
            }
        }
    };

    /**
     * Insert new node before old node within the container.
     *
     * @param {Node|number} exist             - child or child’s index.
     * @param {Node|object|string|Node[]} add - new node
     *
     * @return {Node} this node for methods chain
     *
     * @example
     * rule.insertBefore(decl, decl.clone({ prop: '-webkit-' + decl.prop }));
     */


    Container.prototype.insertBefore = function insertBefore(exist, add) {
        exist = this.index(exist);

        var type = exist === 0 ? 'prepend' : false;
        var nodes = this.normalize(add, this.nodes[exist], type).reverse();
        for (var _iterator6 = nodes, _isArray6 = Array.isArray(_iterator6), _i6 = 0, _iterator6 = _isArray6 ? _iterator6 : _iterator6[Symbol.iterator]();;) {
            var _ref6;

            if (_isArray6) {
                if (_i6 >= _iterator6.length) break;
                _ref6 = _iterator6[_i6++];
            } else {
                _i6 = _iterator6.next();
                if (_i6.done) break;
                _ref6 = _i6.value;
            }

            var node = _ref6;
            this.nodes.splice(exist, 0, node);
        }var index = void 0;
        for (var id in this.indexes) {
            index = this.indexes[id];
            if (exist <= index) {
                this.indexes[id] = index + nodes.length;
            }
        }

        return this;
    };

    /**
     * Insert new node after old node within the container.
     *
     * @param {Node|number} exist             - child or child’s index
     * @param {Node|object|string|Node[]} add - new node
     *
     * @return {Node} this node for methods chain
     */


    Container.prototype.insertAfter = function insertAfter(exist, add) {
        exist = this.index(exist);

        var nodes = this.normalize(add, this.nodes[exist]).reverse();
        for (var _iterator7 = nodes, _isArray7 = Array.isArray(_iterator7), _i7 = 0, _iterator7 = _isArray7 ? _iterator7 : _iterator7[Symbol.iterator]();;) {
            var _ref7;

            if (_isArray7) {
                if (_i7 >= _iterator7.length) break;
                _ref7 = _iterator7[_i7++];
            } else {
                _i7 = _iterator7.next();
                if (_i7.done) break;
                _ref7 = _i7.value;
            }

            var node = _ref7;
            this.nodes.splice(exist + 1, 0, node);
        }var index = void 0;
        for (var id in this.indexes) {
            index = this.indexes[id];
            if (exist < index) {
                this.indexes[id] = index + nodes.length;
            }
        }

        return this;
    };

    Container.prototype.remove = function remove(child) {
        if (typeof child !== 'undefined') {
            (0, _warnOnce2.default)('Container#remove is deprecated. ' + 'Use Container#removeChild');
            this.removeChild(child);
        } else {
            _Node.prototype.remove.call(this);
        }
        return this;
    };

    /**
     * Removes node from the container and cleans the parent properties
     * from the node and its children.
     *
     * @param {Node|number} child - child or child’s index
     *
     * @return {Node} this node for methods chain
     *
     * @example
     * rule.nodes.length  //=> 5
     * rule.removeChild(decl);
     * rule.nodes.length  //=> 4
     * decl.parent        //=> undefined
     */


    Container.prototype.removeChild = function removeChild(child) {
        child = this.index(child);
        this.nodes[child].parent = undefined;
        this.nodes.splice(child, 1);

        var index = void 0;
        for (var id in this.indexes) {
            index = this.indexes[id];
            if (index >= child) {
                this.indexes[id] = index - 1;
            }
        }

        return this;
    };

    /**
     * Removes all children from the container
     * and cleans their parent properties.
     *
     * @return {Node} this node for methods chain
     *
     * @example
     * rule.removeAll();
     * rule.nodes.length //=> 0
     */


    Container.prototype.removeAll = function removeAll() {
        for (var _iterator8 = this.nodes, _isArray8 = Array.isArray(_iterator8), _i8 = 0, _iterator8 = _isArray8 ? _iterator8 : _iterator8[Symbol.iterator]();;) {
            var _ref8;

            if (_isArray8) {
                if (_i8 >= _iterator8.length) break;
                _ref8 = _iterator8[_i8++];
            } else {
                _i8 = _iterator8.next();
                if (_i8.done) break;
                _ref8 = _i8.value;
            }

            var node = _ref8;
            node.parent = undefined;
        }this.nodes = [];
        return this;
    };

    /**
     * Passes all declaration values within the container that match pattern
     * through callback, replacing those values with the returned result
     * of callback.
     *
     * This method is useful if you are using a custom unit or function
     * and need to iterate through all values.
     *
     * @param {string|RegExp} pattern      - replace pattern
     * @param {object} opts                - options to speed up the search
     * @param {string|string[]} opts.props - an array of property names
     * @param {string} opts.fast           - string that’s used
     *                                       to narrow down values and speed up
                                             the regexp search
     * @param {function|string} callback   - string to replace pattern
     *                                       or callback that returns a new
     *                                       value.
     *                                       The callback will receive
     *                                       the same arguments as those
     *                                       passed to a function parameter
     *                                       of `String#replace`.
     *
     * @return {Node} this node for methods chain
     *
     * @example
     * root.replaceValues(/\d+rem/, { fast: 'rem' }, string => {
     *   return 15 * parseInt(string) + 'px';
     * });
     */


    Container.prototype.replaceValues = function replaceValues(pattern, opts, callback) {
        if (!callback) {
            callback = opts;
            opts = {};
        }

        this.walkDecls(function (decl) {
            if (opts.props && opts.props.indexOf(decl.prop) === -1) return;
            if (opts.fast && decl.value.indexOf(opts.fast) === -1) return;

            decl.value = decl.value.replace(pattern, callback);
        });

        return this;
    };

    /**
     * Returns `true` if callback returns `true`
     * for all of the container’s children.
     *
     * @param {childCondition} condition - iterator returns true or false.
     *
     * @return {boolean} is every child pass condition
     *
     * @example
     * const noPrefixes = rule.every(i => i.prop[0] !== '-');
     */


    Container.prototype.every = function every(condition) {
        return this.nodes.every(condition);
    };

    /**
     * Returns `true` if callback returns `true` for (at least) one
     * of the container’s children.
     *
     * @param {childCondition} condition - iterator returns true or false.
     *
     * @return {boolean} is some child pass condition
     *
     * @example
     * const hasPrefix = rule.some(i => i.prop[0] === '-');
     */


    Container.prototype.some = function some(condition) {
        return this.nodes.some(condition);
    };

    /**
     * Returns a `child`’s index within the {@link Container#nodes} array.
     *
     * @param {Node} child - child of the current container.
     *
     * @return {number} child index
     *
     * @example
     * rule.index( rule.nodes[2] ) //=> 2
     */


    Container.prototype.index = function index(child) {
        if (typeof child === 'number') {
            return child;
        } else {
            return this.nodes.indexOf(child);
        }
    };

    /**
     * The container’s first child.
     *
     * @type {Node}
     *
     * @example
     * rule.first == rules.nodes[0];
     */


    Container.prototype.normalize = function normalize(nodes, sample) {
        var _this2 = this;

        if (typeof nodes === 'string') {
            var parse = require('./parse');
            nodes = cleanSource(parse(nodes).nodes);
        } else if (!Array.isArray(nodes)) {
            if (nodes.type === 'root') {
                nodes = nodes.nodes;
            } else if (nodes.type) {
                nodes = [nodes];
            } else if (nodes.prop) {
                if (typeof nodes.value === 'undefined') {
                    throw new Error('Value field is missed in node creation');
                } else if (typeof nodes.value !== 'string') {
                    nodes.value = String(nodes.value);
                }
                nodes = [new _declaration2.default(nodes)];
            } else if (nodes.selector) {
                var Rule = require('./rule');
                nodes = [new Rule(nodes)];
            } else if (nodes.name) {
                var AtRule = require('./at-rule');
                nodes = [new AtRule(nodes)];
            } else if (nodes.text) {
                nodes = [new _comment2.default(nodes)];
            } else {
                throw new Error('Unknown node type in node creation');
            }
        }

        var processed = nodes.map(function (i) {
            if (typeof i.raws === 'undefined') i = _this2.rebuild(i);

            if (i.parent) i = i.clone();
            if (typeof i.raws.before === 'undefined') {
                if (sample && typeof sample.raws.before !== 'undefined') {
                    i.raws.before = sample.raws.before.replace(/[^\s]/g, '');
                }
            }
            i.parent = _this2;
            return i;
        });

        return processed;
    };

    Container.prototype.rebuild = function rebuild(node, parent) {
        var _this3 = this;

        var fix = void 0;
        if (node.type === 'root') {
            var Root = require('./root');
            fix = new Root();
        } else if (node.type === 'atrule') {
            var AtRule = require('./at-rule');
            fix = new AtRule();
        } else if (node.type === 'rule') {
            var Rule = require('./rule');
            fix = new Rule();
        } else if (node.type === 'decl') {
            fix = new _declaration2.default();
        } else if (node.type === 'comment') {
            fix = new _comment2.default();
        }

        for (var i in node) {
            if (i === 'nodes') {
                fix.nodes = node.nodes.map(function (j) {
                    return _this3.rebuild(j, fix);
                });
            } else if (i === 'parent' && parent) {
                fix.parent = parent;
            } else if (node.hasOwnProperty(i)) {
                fix[i] = node[i];
            }
        }

        return fix;
    };

    Container.prototype.eachInside = function eachInside(callback) {
        (0, _warnOnce2.default)('Container#eachInside is deprecated. ' + 'Use Container#walk instead.');
        return this.walk(callback);
    };

    Container.prototype.eachDecl = function eachDecl(prop, callback) {
        (0, _warnOnce2.default)('Container#eachDecl is deprecated. ' + 'Use Container#walkDecls instead.');
        return this.walkDecls(prop, callback);
    };

    Container.prototype.eachRule = function eachRule(selector, callback) {
        (0, _warnOnce2.default)('Container#eachRule is deprecated. ' + 'Use Container#walkRules instead.');
        return this.walkRules(selector, callback);
    };

    Container.prototype.eachAtRule = function eachAtRule(name, callback) {
        (0, _warnOnce2.default)('Container#eachAtRule is deprecated. ' + 'Use Container#walkAtRules instead.');
        return this.walkAtRules(name, callback);
    };

    Container.prototype.eachComment = function eachComment(callback) {
        (0, _warnOnce2.default)('Container#eachComment is deprecated. ' + 'Use Container#walkComments instead.');
        return this.walkComments(callback);
    };

    _createClass(Container, [{
        key: 'first',
        get: function get() {
            if (!this.nodes) return undefined;
            return this.nodes[0];
        }

        /**
         * The container’s last child.
         *
         * @type {Node}
         *
         * @example
         * rule.last == rule.nodes[rule.nodes.length - 1];
         */

    }, {
        key: 'last',
        get: function get() {
            if (!this.nodes) return undefined;
            return this.nodes[this.nodes.length - 1];
        }
    }, {
        key: 'semicolon',
        get: function get() {
            (0, _warnOnce2.default)('Node#semicolon is deprecated. Use Node#raws.semicolon');
            return this.raws.semicolon;
        },
        set: function set(val) {
            (0, _warnOnce2.default)('Node#semicolon is deprecated. Use Node#raws.semicolon');
            this.raws.semicolon = val;
        }
    }, {
        key: 'after',
        get: function get() {
            (0, _warnOnce2.default)('Node#after is deprecated. Use Node#raws.after');
            return this.raws.after;
        },
        set: function set(val) {
            (0, _warnOnce2.default)('Node#after is deprecated. Use Node#raws.after');
            this.raws.after = val;
        }

        /**
         * @memberof Container#
         * @member {Node[]} nodes - an array containing the container’s children
         *
         * @example
         * const root = postcss.parse('a { color: black }');
         * root.nodes.length           //=> 1
         * root.nodes[0].selector      //=> 'a'
         * root.nodes[0].nodes[0].prop //=> 'color'
         */

    }]);

    return Container;
}(_node2.default);

exports.default = Container;

/**
 * @callback childCondition
 * @param {Node} node    - container child
 * @param {number} index - child index
 * @param {Node[]} nodes - all container children
 * @return {boolean}
 */

/**
 * @callback childIterator
 * @param {Node} node    - container child
 * @param {number} index - child index
 * @return {false|undefined} returning `false` will break iteration
 */

module.exports = exports['default'];


},{"./at-rule":753,"./comment":754,"./declaration":757,"./node":762,"./parse":763,"./root":768,"./rule":769,"./warn-once":774}],756:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _supportsColor = require('supports-color');

var _supportsColor2 = _interopRequireDefault(_supportsColor);

var _chalk = require('chalk');

var _chalk2 = _interopRequireDefault(_chalk);

var _terminalHighlight = require('./terminal-highlight');

var _terminalHighlight2 = _interopRequireDefault(_terminalHighlight);

var _warnOnce = require('./warn-once');

var _warnOnce2 = _interopRequireDefault(_warnOnce);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

/**
 * The CSS parser throws this error for broken CSS.
 *
 * Custom parsers can throw this error for broken custom syntax using
 * the {@link Node#error} method.
 *
 * PostCSS will use the input source map to detect the original error location.
 * If you wrote a Sass file, compiled it to CSS and then parsed it with PostCSS,
 * PostCSS will show the original position in the Sass file.
 *
 * If you need the position in the PostCSS input
 * (e.g., to debug the previous compiler), use `error.input.file`.
 *
 * @example
 * // Catching and checking syntax error
 * try {
 *   postcss.parse('a{')
 * } catch (error) {
 *   if ( error.name === 'CssSyntaxError' ) {
 *     error //=> CssSyntaxError
 *   }
 * }
 *
 * @example
 * // Raising error from plugin
 * throw node.error('Unknown variable', { plugin: 'postcss-vars' });
 */
var CssSyntaxError = function () {

    /**
     * @param {string} message  - error message
     * @param {number} [line]   - source line of the error
     * @param {number} [column] - source column of the error
     * @param {string} [source] - source code of the broken file
     * @param {string} [file]   - absolute path to the broken file
     * @param {string} [plugin] - PostCSS plugin name, if error came from plugin
     */
    function CssSyntaxError(message, line, column, source, file, plugin) {
        _classCallCheck(this, CssSyntaxError);

        /**
         * @member {string} - Always equal to `'CssSyntaxError'`. You should
         *                    always check error type
         *                    by `error.name === 'CssSyntaxError'` instead of
         *                    `error instanceof CssSyntaxError`, because
         *                    npm could have several PostCSS versions.
         *
         * @example
         * if ( error.name === 'CssSyntaxError' ) {
         *   error //=> CssSyntaxError
         * }
         */
        this.name = 'CssSyntaxError';
        /**
         * @member {string} - Error message.
         *
         * @example
         * error.message //=> 'Unclosed block'
         */
        this.reason = message;

        if (file) {
            /**
             * @member {string} - Absolute path to the broken file.
             *
             * @example
             * error.file       //=> 'a.sass'
             * error.input.file //=> 'a.css'
             */
            this.file = file;
        }
        if (source) {
            /**
             * @member {string} - Source code of the broken file.
             *
             * @example
             * error.source       //=> 'a { b {} }'
             * error.input.column //=> 'a b { }'
             */
            this.source = source;
        }
        if (plugin) {
            /**
             * @member {string} - Plugin name, if error came from plugin.
             *
             * @example
             * error.plugin //=> 'postcss-vars'
             */
            this.plugin = plugin;
        }
        if (typeof line !== 'undefined' && typeof column !== 'undefined') {
            /**
             * @member {number} - Source line of the error.
             *
             * @example
             * error.line       //=> 2
             * error.input.line //=> 4
             */
            this.line = line;
            /**
             * @member {number} - Source column of the error.
             *
             * @example
             * error.column       //=> 1
             * error.input.column //=> 4
             */
            this.column = column;
        }

        this.setMessage();

        if (Error.captureStackTrace) {
            Error.captureStackTrace(this, CssSyntaxError);
        }
    }

    CssSyntaxError.prototype.setMessage = function setMessage() {
        /**
         * @member {string} - Full error text in the GNU error format
         *                    with plugin, file, line and column.
         *
         * @example
         * error.message //=> 'a.css:1:1: Unclosed block'
         */
        this.message = this.plugin ? this.plugin + ': ' : '';
        this.message += this.file ? this.file : '<css input>';
        if (typeof this.line !== 'undefined') {
            this.message += ':' + this.line + ':' + this.column;
        }
        this.message += ': ' + this.reason;
    };

    /**
     * Returns a few lines of CSS source that caused the error.
     *
     * If the CSS has an input source map without `sourceContent`,
     * this method will return an empty string.
     *
     * @param {boolean} [color] whether arrow will be colored red by terminal
     *                          color codes. By default, PostCSS will detect
     *                          color support by `process.stdout.isTTY`
     *                          and `process.env.NODE_DISABLE_COLORS`.
     *
     * @example
     * error.showSourceCode() //=> "  4 | }
     *                        //      5 | a {
     *                        //    > 6 |   bad
     *                        //        |   ^
     *                        //      7 | }
     *                        //      8 | b {"
     *
     * @return {string} few lines of CSS source that caused the error
     */


    CssSyntaxError.prototype.showSourceCode = function showSourceCode(color) {
        var _this = this;

        if (!this.source) return '';

        var css = this.source;
        if (typeof color === 'undefined') color = _supportsColor2.default;
        if (color) css = (0, _terminalHighlight2.default)(css);

        var lines = css.split(/\r?\n/);
        var start = Math.max(this.line - 3, 0);
        var end = Math.min(this.line + 2, lines.length);

        var maxWidth = String(end).length;
        var colors = new _chalk2.default.constructor({ enabled: true });

        function mark(text) {
            if (color) {
                return colors.red.bold(text);
            } else {
                return text;
            }
        }
        function aside(text) {
            if (color) {
                return colors.gray(text);
            } else {
                return text;
            }
        }

        return lines.slice(start, end).map(function (line, index) {
            var number = start + 1 + index;
            var gutter = ' ' + (' ' + number).slice(-maxWidth) + ' | ';
            if (number === _this.line) {
                var spacing = aside(gutter.replace(/\d/g, ' ')) + line.slice(0, _this.column - 1).replace(/[^\t]/g, ' ');
                return mark('>') + aside(gutter) + line + '\n ' + spacing + mark('^');
            } else {
                return ' ' + aside(gutter) + line;
            }
        }).join('\n');
    };

    /**
     * Returns error position, message and source code of the broken part.
     *
     * @example
     * error.toString() //=> "CssSyntaxError: app.css:1:1: Unclosed block
     *                  //    > 1 | a {
     *                  //        | ^"
     *
     * @return {string} error position, message and source code
     */


    CssSyntaxError.prototype.toString = function toString() {
        var code = this.showSourceCode();
        if (code) {
            code = '\n\n' + code + '\n';
        }
        return this.name + ': ' + this.message + code;
    };

    _createClass(CssSyntaxError, [{
        key: 'generated',
        get: function get() {
            (0, _warnOnce2.default)('CssSyntaxError#generated is deprecated. Use input instead.');
            return this.input;
        }

        /**
         * @memberof CssSyntaxError#
         * @member {Input} input - Input object with PostCSS internal information
         *                         about input file. If input has source map
         *                         from previous tool, PostCSS will use origin
         *                         (for example, Sass) source. You can use this
         *                         object to get PostCSS input source.
         *
         * @example
         * error.input.file //=> 'a.css'
         * error.file       //=> 'a.sass'
         */

    }]);

    return CssSyntaxError;
}();

exports.default = CssSyntaxError;
module.exports = exports['default'];


},{"./terminal-highlight":772,"./warn-once":774,"chalk":751,"supports-color":776}],757:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _warnOnce = require('./warn-once');

var _warnOnce2 = _interopRequireDefault(_warnOnce);

var _node = require('./node');

var _node2 = _interopRequireDefault(_node);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

/**
 * Represents a CSS declaration.
 *
 * @extends Node
 *
 * @example
 * const root = postcss.parse('a { color: black }');
 * const decl = root.first.first;
 * decl.type       //=> 'decl'
 * decl.toString() //=> ' color: black'
 */
var Declaration = function (_Node) {
    _inherits(Declaration, _Node);

    function Declaration(defaults) {
        _classCallCheck(this, Declaration);

        var _this = _possibleConstructorReturn(this, _Node.call(this, defaults));

        _this.type = 'decl';
        return _this;
    }

    _createClass(Declaration, [{
        key: '_value',
        get: function get() {
            (0, _warnOnce2.default)('Node#_value was deprecated. Use Node#raws.value');
            return this.raws.value;
        },
        set: function set(val) {
            (0, _warnOnce2.default)('Node#_value was deprecated. Use Node#raws.value');
            this.raws.value = val;
        }
    }, {
        key: '_important',
        get: function get() {
            (0, _warnOnce2.default)('Node#_important was deprecated. Use Node#raws.important');
            return this.raws.important;
        },
        set: function set(val) {
            (0, _warnOnce2.default)('Node#_important was deprecated. Use Node#raws.important');
            this.raws.important = val;
        }

        /**
         * @memberof Declaration#
         * @member {string} prop - the declaration’s property name
         *
         * @example
         * const root = postcss.parse('a { color: black }');
         * const decl = root.first.first;
         * decl.prop //=> 'color'
         */

        /**
         * @memberof Declaration#
         * @member {string} value - the declaration’s value
         *
         * @example
         * const root = postcss.parse('a { color: black }');
         * const decl = root.first.first;
         * decl.value //=> 'black'
         */

        /**
         * @memberof Declaration#
         * @member {boolean} important - `true` if the declaration
         *                               has an !important annotation.
         *
         * @example
         * const root = postcss.parse('a { color: black !important; color: red }');
         * root.first.first.important //=> true
         * root.first.last.important  //=> undefined
         */

        /**
         * @memberof Declaration#
         * @member {object} raws - Information to generate byte-to-byte equal
         *                         node string as it was in the origin input.
         *
         * Every parser saves its own properties,
         * but the default CSS parser uses:
         *
         * * `before`: the space symbols before the node. It also stores `*`
         *   and `_` symbols before the declaration (IE hack).
         * * `between`: the symbols between the property and value
         *   for declarations.
         * * `important`: the content of the important statement,
         *   if it is not just `!important`.
         *
         * PostCSS cleans declaration from comments and extra spaces,
         * but it stores origin content in raws properties.
         * As such, if you don’t change a declaration’s value,
         * PostCSS will use the raw value with comments.
         *
         * @example
         * const root = postcss.parse('a {\n  color:black\n}')
         * root.first.first.raws //=> { before: '\n  ', between: ':' }
         */

    }]);

    return Declaration;
}(_node2.default);

exports.default = Declaration;
module.exports = exports['default'];


},{"./node":762,"./warn-once":774}],758:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _cssSyntaxError = require('./css-syntax-error');

var _cssSyntaxError2 = _interopRequireDefault(_cssSyntaxError);

var _previousMap = require('./previous-map');

var _previousMap2 = _interopRequireDefault(_previousMap);

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var sequence = 0;

/**
 * Represents the source CSS.
 *
 * @example
 * const root  = postcss.parse(css, { from: file });
 * const input = root.source.input;
 */

var Input = function () {

    /**
     * @param {string} css    - input CSS source
     * @param {object} [opts] - {@link Processor#process} options
     */
    function Input(css) {
        var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

        _classCallCheck(this, Input);

        /**
         * @member {string} - input CSS source
         *
         * @example
         * const input = postcss.parse('a{}', { from: file }).input;
         * input.css //=> "a{}";
         */
        this.css = css.toString();

        if (this.css[0] === '\uFEFF' || this.css[0] === '\uFFFE') {
            this.css = this.css.slice(1);
        }

        if (opts.from) {
            if (/^\w+:\/\//.test(opts.from)) {
                /**
                 * @member {string} - The absolute path to the CSS source file
                 *                    defined with the `from` option.
                 *
                 * @example
                 * const root = postcss.parse(css, { from: 'a.css' });
                 * root.source.input.file //=> '/home/ai/a.css'
                 */
                this.file = opts.from;
            } else {
                this.file = _path2.default.resolve(opts.from);
            }
        }

        var map = new _previousMap2.default(this.css, opts);
        if (map.text) {
            /**
             * @member {PreviousMap} - The input source map passed from
             *                         a compilation step before PostCSS
             *                         (for example, from Sass compiler).
             *
             * @example
             * root.source.input.map.consumer().sources //=> ['a.sass']
             */
            this.map = map;
            var file = map.consumer().file;
            if (!this.file && file) this.file = this.mapResolve(file);
        }

        if (!this.file) {
            sequence += 1;
            /**
             * @member {string} - The unique ID of the CSS source. It will be
             *                    created if `from` option is not provided
             *                    (because PostCSS does not know the file path).
             *
             * @example
             * const root = postcss.parse(css);
             * root.source.input.file //=> undefined
             * root.source.input.id   //=> "<input css 1>"
             */
            this.id = '<input css ' + sequence + '>';
        }
        if (this.map) this.map.file = this.from;
    }

    Input.prototype.error = function error(message, line, column) {
        var opts = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};

        var result = void 0;
        var origin = this.origin(line, column);
        if (origin) {
            result = new _cssSyntaxError2.default(message, origin.line, origin.column, origin.source, origin.file, opts.plugin);
        } else {
            result = new _cssSyntaxError2.default(message, line, column, this.css, this.file, opts.plugin);
        }

        result.input = { line: line, column: column, source: this.css };
        if (this.file) result.input.file = this.file;

        return result;
    };

    /**
     * Reads the input source map and returns a symbol position
     * in the input source (e.g., in a Sass file that was compiled
     * to CSS before being passed to PostCSS).
     *
     * @param {number} line   - line in input CSS
     * @param {number} column - column in input CSS
     *
     * @return {filePosition} position in input source
     *
     * @example
     * root.source.input.origin(1, 1) //=> { file: 'a.css', line: 3, column: 1 }
     */


    Input.prototype.origin = function origin(line, column) {
        if (!this.map) return false;
        var consumer = this.map.consumer();

        var from = consumer.originalPositionFor({ line: line, column: column });
        if (!from.source) return false;

        var result = {
            file: this.mapResolve(from.source),
            line: from.line,
            column: from.column
        };

        var source = consumer.sourceContentFor(from.source);
        if (source) result.source = source;

        return result;
    };

    Input.prototype.mapResolve = function mapResolve(file) {
        if (/^\w+:\/\//.test(file)) {
            return file;
        } else {
            return _path2.default.resolve(this.map.consumer().sourceRoot || '.', file);
        }
    };

    /**
     * The CSS source identifier. Contains {@link Input#file} if the user
     * set the `from` option, or {@link Input#id} if they did not.
     * @type {string}
     *
     * @example
     * const root = postcss.parse(css, { from: 'a.css' });
     * root.source.input.from //=> "/home/ai/a.css"
     *
     * const root = postcss.parse(css);
     * root.source.input.from //=> "<input css 1>"
     */


    _createClass(Input, [{
        key: 'from',
        get: function get() {
            return this.file || this.id;
        }
    }]);

    return Input;
}();

exports.default = Input;

/**
 * @typedef  {object} filePosition
 * @property {string} file   - path to file
 * @property {number} line   - source line in file
 * @property {number} column - source column in file
 */

module.exports = exports['default'];


},{"./css-syntax-error":756,"./previous-map":765,"path":14}],759:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

var _mapGenerator = require('./map-generator');

var _mapGenerator2 = _interopRequireDefault(_mapGenerator);

var _stringify2 = require('./stringify');

var _stringify3 = _interopRequireDefault(_stringify2);

var _warnOnce = require('./warn-once');

var _warnOnce2 = _interopRequireDefault(_warnOnce);

var _result = require('./result');

var _result2 = _interopRequireDefault(_result);

var _parse = require('./parse');

var _parse2 = _interopRequireDefault(_parse);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function isPromise(obj) {
    return (typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) === 'object' && typeof obj.then === 'function';
}

/**
 * A Promise proxy for the result of PostCSS transformations.
 *
 * A `LazyResult` instance is returned by {@link Processor#process}.
 *
 * @example
 * const lazy = postcss([cssnext]).process(css);
 */

var LazyResult = function () {
    function LazyResult(processor, css, opts) {
        _classCallCheck(this, LazyResult);

        this.stringified = false;
        this.processed = false;

        var root = void 0;
        if ((typeof css === 'undefined' ? 'undefined' : _typeof(css)) === 'object' && css.type === 'root') {
            root = css;
        } else if (css instanceof LazyResult || css instanceof _result2.default) {
            root = css.root;
            if (css.map) {
                if (typeof opts.map === 'undefined') opts.map = {};
                if (!opts.map.inline) opts.map.inline = false;
                opts.map.prev = css.map;
            }
        } else {
            var parser = _parse2.default;
            if (opts.syntax) parser = opts.syntax.parse;
            if (opts.parser) parser = opts.parser;
            if (parser.parse) parser = parser.parse;

            try {
                root = parser(css, opts);
            } catch (error) {
                this.error = error;
            }
        }

        this.result = new _result2.default(processor, root, opts);
    }

    /**
     * Returns a {@link Processor} instance, which will be used
     * for CSS transformations.
     * @type {Processor}
     */


    /**
     * Processes input CSS through synchronous plugins
     * and calls {@link Result#warnings()}.
     *
     * @return {Warning[]} warnings from plugins
     */
    LazyResult.prototype.warnings = function warnings() {
        return this.sync().warnings();
    };

    /**
     * Alias for the {@link LazyResult#css} property.
     *
     * @example
     * lazy + '' === lazy.css;
     *
     * @return {string} output CSS
     */


    LazyResult.prototype.toString = function toString() {
        return this.css;
    };

    /**
     * Processes input CSS through synchronous and asynchronous plugins
     * and calls `onFulfilled` with a Result instance. If a plugin throws
     * an error, the `onRejected` callback will be executed.
     *
     * It implements standard Promise API.
     *
     * @param {onFulfilled} onFulfilled - callback will be executed
     *                                    when all plugins will finish work
     * @param {onRejected}  onRejected  - callback will be executed on any error
     *
     * @return {Promise} Promise API to make queue
     *
     * @example
     * postcss([cssnext]).process(css).then(result => {
     *   console.log(result.css);
     * });
     */


    LazyResult.prototype.then = function then(onFulfilled, onRejected) {
        return this.async().then(onFulfilled, onRejected);
    };

    /**
     * Processes input CSS through synchronous and asynchronous plugins
     * and calls onRejected for each error thrown in any plugin.
     *
     * It implements standard Promise API.
     *
     * @param {onRejected} onRejected - callback will be executed on any error
     *
     * @return {Promise} Promise API to make queue
     *
     * @example
     * postcss([cssnext]).process(css).then(result => {
     *   console.log(result.css);
     * }).catch(error => {
     *   console.error(error);
     * });
     */


    LazyResult.prototype.catch = function _catch(onRejected) {
        return this.async().catch(onRejected);
    };

    LazyResult.prototype.handleError = function handleError(error, plugin) {
        try {
            this.error = error;
            if (error.name === 'CssSyntaxError' && !error.plugin) {
                error.plugin = plugin.postcssPlugin;
                error.setMessage();
            } else if (plugin.postcssVersion) {
                var pluginName = plugin.postcssPlugin;
                var pluginVer = plugin.postcssVersion;
                var runtimeVer = this.result.processor.version;
                var a = pluginVer.split('.');
                var b = runtimeVer.split('.');

                if (a[0] !== b[0] || parseInt(a[1]) > parseInt(b[1])) {
                    (0, _warnOnce2.default)('Your current PostCSS version ' + 'is ' + runtimeVer + ', but ' + pluginName + ' ' + 'uses ' + pluginVer + '. Perhaps this is ' + 'the source of the error below.');
                }
            }
        } catch (err) {
            if (console && console.error) console.error(err);
        }
    };

    LazyResult.prototype.asyncTick = function asyncTick(resolve, reject) {
        var _this = this;

        if (this.plugin >= this.processor.plugins.length) {
            this.processed = true;
            return resolve();
        }

        try {
            var plugin = this.processor.plugins[this.plugin];
            var promise = this.run(plugin);
            this.plugin += 1;

            if (isPromise(promise)) {
                promise.then(function () {
                    _this.asyncTick(resolve, reject);
                }).catch(function (error) {
                    _this.handleError(error, plugin);
                    _this.processed = true;
                    reject(error);
                });
            } else {
                this.asyncTick(resolve, reject);
            }
        } catch (error) {
            this.processed = true;
            reject(error);
        }
    };

    LazyResult.prototype.async = function async() {
        var _this2 = this;

        if (this.processed) {
            return new Promise(function (resolve, reject) {
                if (_this2.error) {
                    reject(_this2.error);
                } else {
                    resolve(_this2.stringify());
                }
            });
        }
        if (this.processing) {
            return this.processing;
        }

        this.processing = new Promise(function (resolve, reject) {
            if (_this2.error) return reject(_this2.error);
            _this2.plugin = 0;
            _this2.asyncTick(resolve, reject);
        }).then(function () {
            _this2.processed = true;
            return _this2.stringify();
        });

        return this.processing;
    };

    LazyResult.prototype.sync = function sync() {
        if (this.processed) return this.result;
        this.processed = true;

        if (this.processing) {
            throw new Error('Use process(css).then(cb) to work with async plugins');
        }

        if (this.error) throw this.error;

        for (var _iterator = this.result.processor.plugins, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
            var _ref;

            if (_isArray) {
                if (_i >= _iterator.length) break;
                _ref = _iterator[_i++];
            } else {
                _i = _iterator.next();
                if (_i.done) break;
                _ref = _i.value;
            }

            var plugin = _ref;

            var promise = this.run(plugin);
            if (isPromise(promise)) {
                throw new Error('Use process(css).then(cb) to work with async plugins');
            }
        }

        return this.result;
    };

    LazyResult.prototype.run = function run(plugin) {
        this.result.lastPlugin = plugin;

        try {
            return plugin(this.result.root, this.result);
        } catch (error) {
            this.handleError(error, plugin);
            throw error;
        }
    };

    LazyResult.prototype.stringify = function stringify() {
        if (this.stringified) return this.result;
        this.stringified = true;

        this.sync();

        var opts = this.result.opts;
        var str = _stringify3.default;
        if (opts.syntax) str = opts.syntax.stringify;
        if (opts.stringifier) str = opts.stringifier;
        if (str.stringify) str = str.stringify;

        var map = new _mapGenerator2.default(str, this.result.root, this.result.opts);
        var data = map.generate();
        this.result.css = data[0];
        this.result.map = data[1];

        return this.result;
    };

    _createClass(LazyResult, [{
        key: 'processor',
        get: function get() {
            return this.result.processor;
        }

        /**
         * Options from the {@link Processor#process} call.
         * @type {processOptions}
         */

    }, {
        key: 'opts',
        get: function get() {
            return this.result.opts;
        }

        /**
         * Processes input CSS through synchronous plugins, converts `Root`
         * to a CSS string and returns {@link Result#css}.
         *
         * This property will only work with synchronous plugins.
         * If the processor contains any asynchronous plugins
         * it will throw an error. This is why this method is only
         * for debug purpose, you should always use {@link LazyResult#then}.
         *
         * @type {string}
         * @see Result#css
         */

    }, {
        key: 'css',
        get: function get() {
            return this.stringify().css;
        }

        /**
         * An alias for the `css` property. Use it with syntaxes
         * that generate non-CSS output.
         *
         * This property will only work with synchronous plugins.
         * If the processor contains any asynchronous plugins
         * it will throw an error. This is why this method is only
         * for debug purpose, you should always use {@link LazyResult#then}.
         *
         * @type {string}
         * @see Result#content
         */

    }, {
        key: 'content',
        get: function get() {
            return this.stringify().content;
        }

        /**
         * Processes input CSS through synchronous plugins
         * and returns {@link Result#map}.
         *
         * This property will only work with synchronous plugins.
         * If the processor contains any asynchronous plugins
         * it will throw an error. This is why this method is only
         * for debug purpose, you should always use {@link LazyResult#then}.
         *
         * @type {SourceMapGenerator}
         * @see Result#map
         */

    }, {
        key: 'map',
        get: function get() {
            return this.stringify().map;
        }

        /**
         * Processes input CSS through synchronous plugins
         * and returns {@link Result#root}.
         *
         * This property will only work with synchronous plugins. If the processor
         * contains any asynchronous plugins it will throw an error.
         *
         * This is why this method is only for debug purpose,
         * you should always use {@link LazyResult#then}.
         *
         * @type {Root}
         * @see Result#root
         */

    }, {
        key: 'root',
        get: function get() {
            return this.sync().root;
        }

        /**
         * Processes input CSS through synchronous plugins
         * and returns {@link Result#messages}.
         *
         * This property will only work with synchronous plugins. If the processor
         * contains any asynchronous plugins it will throw an error.
         *
         * This is why this method is only for debug purpose,
         * you should always use {@link LazyResult#then}.
         *
         * @type {Message[]}
         * @see Result#messages
         */

    }, {
        key: 'messages',
        get: function get() {
            return this.sync().messages;
        }
    }]);

    return LazyResult;
}();

exports.default = LazyResult;

/**
 * @callback onFulfilled
 * @param {Result} result
 */

/**
 * @callback onRejected
 * @param {Error} error
 */

module.exports = exports['default'];


},{"./map-generator":761,"./parse":763,"./result":767,"./stringify":771,"./warn-once":774}],760:[function(require,module,exports){
'use strict';

exports.__esModule = true;
/**
 * Contains helpers for safely splitting lists of CSS values,
 * preserving parentheses and quotes.
 *
 * @example
 * const list = postcss.list;
 *
 * @namespace list
 */
var list = {
    split: function split(string, separators, last) {
        var array = [];
        var current = '';
        var split = false;

        var func = 0;
        var quote = false;
        var escape = false;

        for (var i = 0; i < string.length; i++) {
            var letter = string[i];

            if (quote) {
                if (escape) {
                    escape = false;
                } else if (letter === '\\') {
                    escape = true;
                } else if (letter === quote) {
                    quote = false;
                }
            } else if (letter === '"' || letter === '\'') {
                quote = letter;
            } else if (letter === '(') {
                func += 1;
            } else if (letter === ')') {
                if (func > 0) func -= 1;
            } else if (func === 0) {
                if (separators.indexOf(letter) !== -1) split = true;
            }

            if (split) {
                if (current !== '') array.push(current.trim());
                current = '';
                split = false;
            } else {
                current += letter;
            }
        }

        if (last || current !== '') array.push(current.trim());
        return array;
    },


    /**
     * Safely splits space-separated values (such as those for `background`,
     * `border-radius`, and other shorthand properties).
     *
     * @param {string} string - space-separated values
     *
     * @return {string[]} split values
     *
     * @example
     * postcss.list.space('1px calc(10% + 1px)') //=> ['1px', 'calc(10% + 1px)']
     */
    space: function space(string) {
        var spaces = [' ', '\n', '\t'];
        return list.split(string, spaces);
    },


    /**
     * Safely splits comma-separated values (such as those for `transition-*`
     * and `background` properties).
     *
     * @param {string} string - comma-separated values
     *
     * @return {string[]} split values
     *
     * @example
     * postcss.list.comma('black, linear-gradient(white, black)')
     * //=> ['black', 'linear-gradient(white, black)']
     */
    comma: function comma(string) {
        var comma = ',';
        return list.split(string, [comma], true);
    }
};

exports.default = list;
module.exports = exports['default'];


},{}],761:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _jsBase = require('js-base64');

var _sourceMap = require('source-map');

var _sourceMap2 = _interopRequireDefault(_sourceMap);

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var MapGenerator = function () {
    function MapGenerator(stringify, root, opts) {
        _classCallCheck(this, MapGenerator);

        this.stringify = stringify;
        this.mapOpts = opts.map || {};
        this.root = root;
        this.opts = opts;
    }

    MapGenerator.prototype.isMap = function isMap() {
        if (typeof this.opts.map !== 'undefined') {
            return !!this.opts.map;
        } else {
            return this.previous().length > 0;
        }
    };

    MapGenerator.prototype.previous = function previous() {
        var _this = this;

        if (!this.previousMaps) {
            this.previousMaps = [];
            this.root.walk(function (node) {
                if (node.source && node.source.input.map) {
                    var map = node.source.input.map;
                    if (_this.previousMaps.indexOf(map) === -1) {
                        _this.previousMaps.push(map);
                    }
                }
            });
        }

        return this.previousMaps;
    };

    MapGenerator.prototype.isInline = function isInline() {
        if (typeof this.mapOpts.inline !== 'undefined') {
            return this.mapOpts.inline;
        }

        var annotation = this.mapOpts.annotation;
        if (typeof annotation !== 'undefined' && annotation !== true) {
            return false;
        }

        if (this.previous().length) {
            return this.previous().some(function (i) {
                return i.inline;
            });
        } else {
            return true;
        }
    };

    MapGenerator.prototype.isSourcesContent = function isSourcesContent() {
        if (typeof this.mapOpts.sourcesContent !== 'undefined') {
            return this.mapOpts.sourcesContent;
        }
        if (this.previous().length) {
            return this.previous().some(function (i) {
                return i.withContent();
            });
        } else {
            return true;
        }
    };

    MapGenerator.prototype.clearAnnotation = function clearAnnotation() {
        if (this.mapOpts.annotation === false) return;

        var node = void 0;
        for (var i = this.root.nodes.length - 1; i >= 0; i--) {
            node = this.root.nodes[i];
            if (node.type !== 'comment') continue;
            if (node.text.indexOf('# sourceMappingURL=') === 0) {
                this.root.removeChild(i);
            }
        }
    };

    MapGenerator.prototype.setSourcesContent = function setSourcesContent() {
        var _this2 = this;

        var already = {};
        this.root.walk(function (node) {
            if (node.source) {
                var from = node.source.input.from;
                if (from && !already[from]) {
                    already[from] = true;
                    var relative = _this2.relative(from);
                    _this2.map.setSourceContent(relative, node.source.input.css);
                }
            }
        });
    };

    MapGenerator.prototype.applyPrevMaps = function applyPrevMaps() {
        for (var _iterator = this.previous(), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
            var _ref;

            if (_isArray) {
                if (_i >= _iterator.length) break;
                _ref = _iterator[_i++];
            } else {
                _i = _iterator.next();
                if (_i.done) break;
                _ref = _i.value;
            }

            var prev = _ref;

            var from = this.relative(prev.file);
            var root = prev.root || _path2.default.dirname(prev.file);
            var map = void 0;

            if (this.mapOpts.sourcesContent === false) {
                map = new _sourceMap2.default.SourceMapConsumer(prev.text);
                if (map.sourcesContent) {
                    map.sourcesContent = map.sourcesContent.map(function () {
                        return null;
                    });
                }
            } else {
                map = prev.consumer();
            }

            this.map.applySourceMap(map, from, this.relative(root));
        }
    };

    MapGenerator.prototype.isAnnotation = function isAnnotation() {
        if (this.isInline()) {
            return true;
        } else if (typeof this.mapOpts.annotation !== 'undefined') {
            return this.mapOpts.annotation;
        } else if (this.previous().length) {
            return this.previous().some(function (i) {
                return i.annotation;
            });
        } else {
            return true;
        }
    };

    MapGenerator.prototype.addAnnotation = function addAnnotation() {
        var content = void 0;

        if (this.isInline()) {
            content = 'data:application/json;base64,' + _jsBase.Base64.encode(this.map.toString());
        } else if (typeof this.mapOpts.annotation === 'string') {
            content = this.mapOpts.annotation;
        } else {
            content = this.outputFile() + '.map';
        }

        var eol = '\n';
        if (this.css.indexOf('\r\n') !== -1) eol = '\r\n';

        this.css += eol + '/*# sourceMappingURL=' + content + ' */';
    };

    MapGenerator.prototype.outputFile = function outputFile() {
        if (this.opts.to) {
            return this.relative(this.opts.to);
        } else if (this.opts.from) {
            return this.relative(this.opts.from);
        } else {
            return 'to.css';
        }
    };

    MapGenerator.prototype.generateMap = function generateMap() {
        this.generateString();
        if (this.isSourcesContent()) this.setSourcesContent();
        if (this.previous().length > 0) this.applyPrevMaps();
        if (this.isAnnotation()) this.addAnnotation();

        if (this.isInline()) {
            return [this.css];
        } else {
            return [this.css, this.map];
        }
    };

    MapGenerator.prototype.relative = function relative(file) {
        if (file.indexOf('<') === 0) return file;
        if (/^\w+:\/\//.test(file)) return file;

        var from = this.opts.to ? _path2.default.dirname(this.opts.to) : '.';

        if (typeof this.mapOpts.annotation === 'string') {
            from = _path2.default.dirname(_path2.default.resolve(from, this.mapOpts.annotation));
        }

        file = _path2.default.relative(from, file);
        if (_path2.default.sep === '\\') {
            return file.replace(/\\/g, '/');
        } else {
            return file;
        }
    };

    MapGenerator.prototype.sourcePath = function sourcePath(node) {
        if (this.mapOpts.from) {
            return this.mapOpts.from;
        } else {
            return this.relative(node.source.input.from);
        }
    };

    MapGenerator.prototype.generateString = function generateString() {
        var _this3 = this;

        this.css = '';
        this.map = new _sourceMap2.default.SourceMapGenerator({ file: this.outputFile() });

        var line = 1;
        var column = 1;

        var lines = void 0,
            last = void 0;
        this.stringify(this.root, function (str, node, type) {
            _this3.css += str;

            if (node && type !== 'end') {
                if (node.source && node.source.start) {
                    _this3.map.addMapping({
                        source: _this3.sourcePath(node),
                        generated: { line: line, column: column - 1 },
                        original: {
                            line: node.source.start.line,
                            column: node.source.start.column - 1
                        }
                    });
                } else {
                    _this3.map.addMapping({
                        source: '<no source>',
                        original: { line: 1, column: 0 },
                        generated: { line: line, column: column - 1 }
                    });
                }
            }

            lines = str.match(/\n/g);
            if (lines) {
                line += lines.length;
                last = str.lastIndexOf('\n');
                column = str.length - last;
            } else {
                column += str.length;
            }

            if (node && type !== 'start') {
                if (node.source && node.source.end) {
                    _this3.map.addMapping({
                        source: _this3.sourcePath(node),
                        generated: { line: line, column: column - 1 },
                        original: {
                            line: node.source.end.line,
                            column: node.source.end.column
                        }
                    });
                } else {
                    _this3.map.addMapping({
                        source: '<no source>',
                        original: { line: 1, column: 0 },
                        generated: { line: line, column: column - 1 }
                    });
                }
            }
        });
    };

    MapGenerator.prototype.generate = function generate() {
        this.clearAnnotation();

        if (this.isMap()) {
            return this.generateMap();
        } else {
            var result = '';
            this.stringify(this.root, function (i) {
                result += i;
            });
            return [result];
        }
    };

    return MapGenerator;
}();

exports.default = MapGenerator;
module.exports = exports['default'];


},{"js-base64":658,"path":14,"source-map":864}],762:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

var _cssSyntaxError = require('./css-syntax-error');

var _cssSyntaxError2 = _interopRequireDefault(_cssSyntaxError);

var _stringifier = require('./stringifier');

var _stringifier2 = _interopRequireDefault(_stringifier);

var _stringify = require('./stringify');

var _stringify2 = _interopRequireDefault(_stringify);

var _warnOnce = require('./warn-once');

var _warnOnce2 = _interopRequireDefault(_warnOnce);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var cloneNode = function cloneNode(obj, parent) {
    var cloned = new obj.constructor();

    for (var i in obj) {
        if (!obj.hasOwnProperty(i)) continue;
        var value = obj[i];
        var type = typeof value === 'undefined' ? 'undefined' : _typeof(value);

        if (i === 'parent' && type === 'object') {
            if (parent) cloned[i] = parent;
        } else if (i === 'source') {
            cloned[i] = value;
        } else if (value instanceof Array) {
            cloned[i] = value.map(function (j) {
                return cloneNode(j, cloned);
            });
        } else if (i !== 'before' && i !== 'after' && i !== 'between' && i !== 'semicolon') {
            if (type === 'object' && value !== null) value = cloneNode(value);
            cloned[i] = value;
        }
    }

    return cloned;
};

/**
 * All node classes inherit the following common methods.
 *
 * @abstract
 */

var Node = function () {

    /**
     * @param {object} [defaults] - value for node properties
     */
    function Node() {
        var defaults = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

        _classCallCheck(this, Node);

        this.raws = {};
        if ((typeof defaults === 'undefined' ? 'undefined' : _typeof(defaults)) !== 'object' && typeof defaults !== 'undefined') {
            throw new Error('PostCSS nodes constructor accepts object, not ' + JSON.stringify(defaults));
        }
        for (var name in defaults) {
            this[name] = defaults[name];
        }
    }

    /**
     * Returns a CssSyntaxError instance containing the original position
     * of the node in the source, showing line and column numbers and also
     * a small excerpt to facilitate debugging.
     *
     * If present, an input source map will be used to get the original position
     * of the source, even from a previous compilation step
     * (e.g., from Sass compilation).
     *
     * This method produces very useful error messages.
     *
     * @param {string} message     - error description
     * @param {object} [opts]      - options
     * @param {string} opts.plugin - plugin name that created this error.
     *                               PostCSS will set it automatically.
     * @param {string} opts.word   - a word inside a node’s string that should
     *                               be highlighted as the source of the error
     * @param {number} opts.index  - an index inside a node’s string that should
     *                               be highlighted as the source of the error
     *
     * @return {CssSyntaxError} error object to throw it
     *
     * @example
     * if ( !variables[name] ) {
     *   throw decl.error('Unknown variable ' + name, { word: name });
     *   // CssSyntaxError: postcss-vars:a.sass:4:3: Unknown variable $black
     *   //   color: $black
     *   // a
     *   //          ^
     *   //   background: white
     * }
     */


    Node.prototype.error = function error(message) {
        var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

        if (this.source) {
            var pos = this.positionBy(opts);
            return this.source.input.error(message, pos.line, pos.column, opts);
        } else {
            return new _cssSyntaxError2.default(message);
        }
    };

    /**
     * This method is provided as a convenience wrapper for {@link Result#warn}.
     *
     * @param {Result} result      - the {@link Result} instance
     *                               that will receive the warning
     * @param {string} text        - warning message
     * @param {object} [opts]      - options
     * @param {string} opts.plugin - plugin name that created this warning.
     *                               PostCSS will set it automatically.
     * @param {string} opts.word   - a word inside a node’s string that should
     *                               be highlighted as the source of the warning
     * @param {number} opts.index  - an index inside a node’s string that should
     *                               be highlighted as the source of the warning
     *
     * @return {Warning} created warning object
     *
     * @example
     * const plugin = postcss.plugin('postcss-deprecated', () => {
     *   return (root, result) => {
     *     root.walkDecls('bad', decl => {
     *       decl.warn(result, 'Deprecated property bad');
     *     });
     *   };
     * });
     */


    Node.prototype.warn = function warn(result, text, opts) {
        var data = { node: this };
        for (var i in opts) {
            data[i] = opts[i];
        }return result.warn(text, data);
    };

    /**
     * Removes the node from its parent and cleans the parent properties
     * from the node and its children.
     *
     * @example
     * if ( decl.prop.match(/^-webkit-/) ) {
     *   decl.remove();
     * }
     *
     * @return {Node} node to make calls chain
     */


    Node.prototype.remove = function remove() {
        if (this.parent) {
            this.parent.removeChild(this);
        }
        this.parent = undefined;
        return this;
    };

    /**
     * Returns a CSS string representing the node.
     *
     * @param {stringifier|syntax} [stringifier] - a syntax to use
     *                                             in string generation
     *
     * @return {string} CSS string of this node
     *
     * @example
     * postcss.rule({ selector: 'a' }).toString() //=> "a {}"
     */


    Node.prototype.toString = function toString() {
        var stringifier = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _stringify2.default;

        if (stringifier.stringify) stringifier = stringifier.stringify;
        var result = '';
        stringifier(this, function (i) {
            result += i;
        });
        return result;
    };

    /**
     * Returns a clone of the node.
     *
     * The resulting cloned node and its (cloned) children will have
     * a clean parent and code style properties.
     *
     * @param {object} [overrides] - new properties to override in the clone.
     *
     * @example
     * const cloned = decl.clone({ prop: '-moz-' + decl.prop });
     * cloned.raws.before  //=> undefined
     * cloned.parent       //=> undefined
     * cloned.toString()   //=> -moz-transform: scale(0)
     *
     * @return {Node} clone of the node
     */


    Node.prototype.clone = function clone() {
        var overrides = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

        var cloned = cloneNode(this);
        for (var name in overrides) {
            cloned[name] = overrides[name];
        }
        return cloned;
    };

    /**
     * Shortcut to clone the node and insert the resulting cloned node
     * before the current node.
     *
     * @param {object} [overrides] - new properties to override in the clone.
     *
     * @example
     * decl.cloneBefore({ prop: '-moz-' + decl.prop });
     *
     * @return {Node} - new node
     */


    Node.prototype.cloneBefore = function cloneBefore() {
        var overrides = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

        var cloned = this.clone(overrides);
        this.parent.insertBefore(this, cloned);
        return cloned;
    };

    /**
     * Shortcut to clone the node and insert the resulting cloned node
     * after the current node.
     *
     * @param {object} [overrides] - new properties to override in the clone.
     *
     * @return {Node} - new node
     */


    Node.prototype.cloneAfter = function cloneAfter() {
        var overrides = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

        var cloned = this.clone(overrides);
        this.parent.insertAfter(this, cloned);
        return cloned;
    };

    /**
     * Inserts node(s) before the current node and removes the current node.
     *
     * @param {...Node} nodes - node(s) to replace current one
     *
     * @example
     * if ( atrule.name == 'mixin' ) {
     *   atrule.replaceWith(mixinRules[atrule.params]);
     * }
     *
     * @return {Node} current node to methods chain
     */


    Node.prototype.replaceWith = function replaceWith() {
        if (this.parent) {
            for (var _len = arguments.length, nodes = Array(_len), _key = 0; _key < _len; _key++) {
                nodes[_key] = arguments[_key];
            }

            for (var _iterator = nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
                var _ref;

                if (_isArray) {
                    if (_i >= _iterator.length) break;
                    _ref = _iterator[_i++];
                } else {
                    _i = _iterator.next();
                    if (_i.done) break;
                    _ref = _i.value;
                }

                var node = _ref;

                this.parent.insertBefore(this, node);
            }

            this.remove();
        }

        return this;
    };

    /**
     * Removes the node from its current parent and inserts it
     * at the end of `newParent`.
     *
     * This will clean the `before` and `after` code {@link Node#raws} data
     * from the node and replace them with the indentation style of `newParent`.
     * It will also clean the `between` property
     * if `newParent` is in another {@link Root}.
     *
     * @param {Container} newParent - container node where the current node
     *                                will be moved
     *
     * @example
     * atrule.moveTo(atrule.root());
     *
     * @return {Node} current node to methods chain
     */


    Node.prototype.moveTo = function moveTo(newParent) {
        this.cleanRaws(this.root() === newParent.root());
        this.remove();
        newParent.append(this);
        return this;
    };

    /**
     * Removes the node from its current parent and inserts it into
     * a new parent before `otherNode`.
     *
     * This will also clean the node’s code style properties just as it would
     * in {@link Node#moveTo}.
     *
     * @param {Node} otherNode - node that will be before current node
     *
     * @return {Node} current node to methods chain
     */


    Node.prototype.moveBefore = function moveBefore(otherNode) {
        this.cleanRaws(this.root() === otherNode.root());
        this.remove();
        otherNode.parent.insertBefore(otherNode, this);
        return this;
    };

    /**
     * Removes the node from its current parent and inserts it into
     * a new parent after `otherNode`.
     *
     * This will also clean the node’s code style properties just as it would
     * in {@link Node#moveTo}.
     *
     * @param {Node} otherNode - node that will be after current node
     *
     * @return {Node} current node to methods chain
     */


    Node.prototype.moveAfter = function moveAfter(otherNode) {
        this.cleanRaws(this.root() === otherNode.root());
        this.remove();
        otherNode.parent.insertAfter(otherNode, this);
        return this;
    };

    /**
     * Returns the next child of the node’s parent.
     * Returns `undefined` if the current node is the last child.
     *
     * @return {Node|undefined} next node
     *
     * @example
     * if ( comment.text === 'delete next' ) {
     *   const next = comment.next();
     *   if ( next ) {
     *     next.remove();
     *   }
     * }
     */


    Node.prototype.next = function next() {
        var index = this.parent.index(this);
        return this.parent.nodes[index + 1];
    };

    /**
     * Returns the previous child of the node’s parent.
     * Returns `undefined` if the current node is the first child.
     *
     * @return {Node|undefined} previous node
     *
     * @example
     * const annotation = decl.prev();
     * if ( annotation.type == 'comment' ) {
     *  readAnnotation(annotation.text);
     * }
     */


    Node.prototype.prev = function prev() {
        var index = this.parent.index(this);
        return this.parent.nodes[index - 1];
    };

    Node.prototype.toJSON = function toJSON() {
        var fixed = {};

        for (var name in this) {
            if (!this.hasOwnProperty(name)) continue;
            if (name === 'parent') continue;
            var value = this[name];

            if (value instanceof Array) {
                fixed[name] = value.map(function (i) {
                    if ((typeof i === 'undefined' ? 'undefined' : _typeof(i)) === 'object' && i.toJSON) {
                        return i.toJSON();
                    } else {
                        return i;
                    }
                });
            } else if ((typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object' && value.toJSON) {
                fixed[name] = value.toJSON();
            } else {
                fixed[name] = value;
            }
        }

        return fixed;
    };

    /**
     * Returns a {@link Node#raws} value. If the node is missing
     * the code style property (because the node was manually built or cloned),
     * PostCSS will try to autodetect the code style property by looking
     * at other nodes in the tree.
     *
     * @param {string} prop          - name of code style property
     * @param {string} [defaultType] - name of default value, it can be missed
     *                                 if the value is the same as prop
     *
     * @example
     * const root = postcss.parse('a { background: white }');
     * root.nodes[0].append({ prop: 'color', value: 'black' });
     * root.nodes[0].nodes[1].raws.before   //=> undefined
     * root.nodes[0].nodes[1].raw('before') //=> ' '
     *
     * @return {string} code style value
     */


    Node.prototype.raw = function raw(prop, defaultType) {
        var str = new _stringifier2.default();
        return str.raw(this, prop, defaultType);
    };

    /**
     * Finds the Root instance of the node’s tree.
     *
     * @example
     * root.nodes[0].nodes[0].root() === root
     *
     * @return {Root} root parent
     */


    Node.prototype.root = function root() {
        var result = this;
        while (result.parent) {
            result = result.parent;
        }return result;
    };

    Node.prototype.cleanRaws = function cleanRaws(keepBetween) {
        delete this.raws.before;
        delete this.raws.after;
        if (!keepBetween) delete this.raws.between;
    };

    Node.prototype.positionInside = function positionInside(index) {
        var string = this.toString();
        var column = this.source.start.column;
        var line = this.source.start.line;

        for (var i = 0; i < index; i++) {
            if (string[i] === '\n') {
                column = 1;
                line += 1;
            } else {
                column += 1;
            }
        }

        return { line: line, column: column };
    };

    Node.prototype.positionBy = function positionBy(opts) {
        var pos = this.source.start;
        if (opts.index) {
            pos = this.positionInside(opts.index);
        } else if (opts.word) {
            var index = this.toString().indexOf(opts.word);
            if (index !== -1) pos = this.positionInside(index);
        }
        return pos;
    };

    Node.prototype.removeSelf = function removeSelf() {
        (0, _warnOnce2.default)('Node#removeSelf is deprecated. Use Node#remove.');
        return this.remove();
    };

    Node.prototype.replace = function replace(nodes) {
        (0, _warnOnce2.default)('Node#replace is deprecated. Use Node#replaceWith');
        return this.replaceWith(nodes);
    };

    Node.prototype.style = function style(own, detect) {
        (0, _warnOnce2.default)('Node#style() is deprecated. Use Node#raw()');
        return this.raw(own, detect);
    };

    Node.prototype.cleanStyles = function cleanStyles(keepBetween) {
        (0, _warnOnce2.default)('Node#cleanStyles() is deprecated. Use Node#cleanRaws()');
        return this.cleanRaws(keepBetween);
    };

    _createClass(Node, [{
        key: 'before',
        get: function get() {
            (0, _warnOnce2.default)('Node#before is deprecated. Use Node#raws.before');
            return this.raws.before;
        },
        set: function set(val) {
            (0, _warnOnce2.default)('Node#before is deprecated. Use Node#raws.before');
            this.raws.before = val;
        }
    }, {
        key: 'between',
        get: function get() {
            (0, _warnOnce2.default)('Node#between is deprecated. Use Node#raws.between');
            return this.raws.between;
        },
        set: function set(val) {
            (0, _warnOnce2.default)('Node#between is deprecated. Use Node#raws.between');
            this.raws.between = val;
        }

        /**
         * @memberof Node#
         * @member {string} type - String representing the node’s type.
         *                         Possible values are `root`, `atrule`, `rule`,
         *                         `decl`, or `comment`.
         *
         * @example
         * postcss.decl({ prop: 'color', value: 'black' }).type //=> 'decl'
         */

        /**
         * @memberof Node#
         * @member {Container} parent - the node’s parent node.
         *
         * @example
         * root.nodes[0].parent == root;
         */

        /**
         * @memberof Node#
         * @member {source} source - the input source of the node
         *
         * The property is used in source map generation.
         *
         * If you create a node manually (e.g., with `postcss.decl()`),
         * that node will not have a `source` property and will be absent
         * from the source map. For this reason, the plugin developer should
         * consider cloning nodes to create new ones (in which case the new node’s
         * source will reference the original, cloned node) or setting
         * the `source` property manually.
         *
         * ```js
         * // Bad
         * const prefixed = postcss.decl({
         *   prop: '-moz-' + decl.prop,
         *   value: decl.value
         * });
         *
         * // Good
         * const prefixed = decl.clone({ prop: '-moz-' + decl.prop });
         * ```
         *
         * ```js
         * if ( atrule.name == 'add-link' ) {
         *   const rule = postcss.rule({ selector: 'a', source: atrule.source });
         *   atrule.parent.insertBefore(atrule, rule);
         * }
         * ```
         *
         * @example
         * decl.source.input.from //=> '/home/ai/a.sass'
         * decl.source.start      //=> { line: 10, column: 2 }
         * decl.source.end        //=> { line: 10, column: 12 }
         */

        /**
         * @memberof Node#
         * @member {object} raws - Information to generate byte-to-byte equal
         *                         node string as it was in the origin input.
         *
         * Every parser saves its own properties,
         * but the default CSS parser uses:
         *
         * * `before`: the space symbols before the node. It also stores `*`
         *   and `_` symbols before the declaration (IE hack).
         * * `after`: the space symbols after the last child of the node
         *   to the end of the node.
         * * `between`: the symbols between the property and value
         *   for declarations, selector and `{` for rules, or last parameter
         *   and `{` for at-rules.
         * * `semicolon`: contains true if the last child has
         *   an (optional) semicolon.
         * * `afterName`: the space between the at-rule name and its parameters.
         * * `left`: the space symbols between `/*` and the comment’s text.
         * * `right`: the space symbols between the comment’s text
         *   and <code>*&#47;</code>.
         * * `important`: the content of the important statement,
         *   if it is not just `!important`.
         *
         * PostCSS cleans selectors, declaration values and at-rule parameters
         * from comments and extra spaces, but it stores origin content in raws
         * properties. As such, if you don’t change a declaration’s value,
         * PostCSS will use the raw value with comments.
         *
         * @example
         * const root = postcss.parse('a {\n  color:black\n}')
         * root.first.first.raws //=> { before: '\n  ', between: ':' }
         */

    }]);

    return Node;
}();

exports.default = Node;

/**
 * @typedef {object} position
 * @property {number} line   - source line in file
 * @property {number} column - source column in file
 */

/**
 * @typedef {object} source
 * @property {Input} input    - {@link Input} with input file
 * @property {position} start - The starting position of the node’s source
 * @property {position} end   - The ending position of the node’s source
 */

module.exports = exports['default'];


},{"./css-syntax-error":756,"./stringifier":770,"./stringify":771,"./warn-once":774}],763:[function(require,module,exports){
'use strict';

exports.__esModule = true;
exports.default = parse;

var _parser = require('./parser');

var _parser2 = _interopRequireDefault(_parser);

var _input = require('./input');

var _input2 = _interopRequireDefault(_input);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function parse(css, opts) {
    if (opts && opts.safe) {
        throw new Error('Option safe was removed. ' + 'Use parser: require("postcss-safe-parser")');
    }

    var input = new _input2.default(css, opts);

    var parser = new _parser2.default(input);
    try {
        parser.tokenize();
        parser.loop();
    } catch (e) {
        if (e.name === 'CssSyntaxError' && opts && opts.from) {
            if (/\.scss$/i.test(opts.from)) {
                e.message += '\nYou tried to parse SCSS with ' + 'the standard CSS parser; ' + 'try again with the postcss-scss parser';
            } else if (/\.sass/i.test(opts.from)) {
                e.message += '\nYou tried to parse Sass with ' + 'the standard CSS parser; ' + 'try again with the postcss-sass parser';
            } else if (/\.less$/i.test(opts.from)) {
                e.message += '\nYou tried to parse Less with ' + 'the standard CSS parser; ' + 'try again with the postcss-less parser';
            }
        }
        throw e;
    }

    return parser.root;
}
module.exports = exports['default'];


},{"./input":758,"./parser":764}],764:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _declaration = require('./declaration');

var _declaration2 = _interopRequireDefault(_declaration);

var _tokenize = require('./tokenize');

var _tokenize2 = _interopRequireDefault(_tokenize);

var _comment = require('./comment');

var _comment2 = _interopRequireDefault(_comment);

var _atRule = require('./at-rule');

var _atRule2 = _interopRequireDefault(_atRule);

var _root = require('./root');

var _root2 = _interopRequireDefault(_root);

var _rule = require('./rule');

var _rule2 = _interopRequireDefault(_rule);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Parser = function () {
    function Parser(input) {
        _classCallCheck(this, Parser);

        this.input = input;

        this.pos = 0;
        this.root = new _root2.default();
        this.current = this.root;
        this.spaces = '';
        this.semicolon = false;

        this.root.source = { input: input, start: { line: 1, column: 1 } };
    }

    Parser.prototype.tokenize = function tokenize() {
        this.tokens = (0, _tokenize2.default)(this.input);
    };

    Parser.prototype.loop = function loop() {
        var token = void 0;
        while (this.pos < this.tokens.length) {
            token = this.tokens[this.pos];

            switch (token[0]) {

                case 'space':
                case ';':
                    this.spaces += token[1];
                    break;

                case '}':
                    this.end(token);
                    break;

                case 'comment':
                    this.comment(token);
                    break;

                case 'at-word':
                    this.atrule(token);
                    break;

                case '{':
                    this.emptyRule(token);
                    break;

                default:
                    this.other();
                    break;
            }

            this.pos += 1;
        }
        this.endFile();
    };

    Parser.prototype.comment = function comment(token) {
        var node = new _comment2.default();
        this.init(node, token[2], token[3]);
        node.source.end = { line: token[4], column: token[5] };

        var text = token[1].slice(2, -2);
        if (/^\s*$/.test(text)) {
            node.text = '';
            node.raws.left = text;
            node.raws.right = '';
        } else {
            var match = text.match(/^(\s*)([^]*[^\s])(\s*)$/);
            node.text = match[2];
            node.raws.left = match[1];
            node.raws.right = match[3];
        }
    };

    Parser.prototype.emptyRule = function emptyRule(token) {
        var node = new _rule2.default();
        this.init(node, token[2], token[3]);
        node.selector = '';
        node.raws.between = '';
        this.current = node;
    };

    Parser.prototype.other = function other() {
        var token = void 0;
        var end = false;
        var type = null;
        var colon = false;
        var bracket = null;
        var brackets = [];

        var start = this.pos;
        while (this.pos < this.tokens.length) {
            token = this.tokens[this.pos];
            type = token[0];

            if (type === '(' || type === '[') {
                if (!bracket) bracket = token;
                brackets.push(type === '(' ? ')' : ']');
            } else if (brackets.length === 0) {
                if (type === ';') {
                    if (colon) {
                        this.decl(this.tokens.slice(start, this.pos + 1));
                        return;
                    } else {
                        break;
                    }
                } else if (type === '{') {
                    this.rule(this.tokens.slice(start, this.pos + 1));
                    return;
                } else if (type === '}') {
                    this.pos -= 1;
                    end = true;
                    break;
                } else if (type === ':') {
                    colon = true;
                }
            } else if (type === brackets[brackets.length - 1]) {
                brackets.pop();
                if (brackets.length === 0) bracket = null;
            }

            this.pos += 1;
        }
        if (this.pos === this.tokens.length) {
            this.pos -= 1;
            end = true;
        }

        if (brackets.length > 0) this.unclosedBracket(bracket);

        if (end && colon) {
            while (this.pos > start) {
                token = this.tokens[this.pos][0];
                if (token !== 'space' && token !== 'comment') break;
                this.pos -= 1;
            }
            this.decl(this.tokens.slice(start, this.pos + 1));
            return;
        }

        this.unknownWord(start);
    };

    Parser.prototype.rule = function rule(tokens) {
        tokens.pop();

        var node = new _rule2.default();
        this.init(node, tokens[0][2], tokens[0][3]);

        node.raws.between = this.spacesAndCommentsFromEnd(tokens);
        this.raw(node, 'selector', tokens);
        this.current = node;
    };

    Parser.prototype.decl = function decl(tokens) {
        var node = new _declaration2.default();
        this.init(node);

        var last = tokens[tokens.length - 1];
        if (last[0] === ';') {
            this.semicolon = true;
            tokens.pop();
        }
        if (last[4]) {
            node.source.end = { line: last[4], column: last[5] };
        } else {
            node.source.end = { line: last[2], column: last[3] };
        }

        while (tokens[0][0] !== 'word') {
            node.raws.before += tokens.shift()[1];
        }
        node.source.start = { line: tokens[0][2], column: tokens[0][3] };

        node.prop = '';
        while (tokens.length) {
            var type = tokens[0][0];
            if (type === ':' || type === 'space' || type === 'comment') {
                break;
            }
            node.prop += tokens.shift()[1];
        }

        node.raws.between = '';

        var token = void 0;
        while (tokens.length) {
            token = tokens.shift();

            if (token[0] === ':') {
                node.raws.between += token[1];
                break;
            } else {
                node.raws.between += token[1];
            }
        }

        if (node.prop[0] === '_' || node.prop[0] === '*') {
            node.raws.before += node.prop[0];
            node.prop = node.prop.slice(1);
        }
        node.raws.between += this.spacesAndCommentsFromStart(tokens);
        this.precheckMissedSemicolon(tokens);

        for (var i = tokens.length - 1; i > 0; i--) {
            token = tokens[i];
            if (token[1] === '!important') {
                node.important = true;
                var string = this.stringFrom(tokens, i);
                string = this.spacesFromEnd(tokens) + string;
                if (string !== ' !important') node.raws.important = string;
                break;
            } else if (token[1] === 'important') {
                var cache = tokens.slice(0);
                var str = '';
                for (var j = i; j > 0; j--) {
                    var _type = cache[j][0];
                    if (str.trim().indexOf('!') === 0 && _type !== 'space') {
                        break;
                    }
                    str = cache.pop()[1] + str;
                }
                if (str.trim().indexOf('!') === 0) {
                    node.important = true;
                    node.raws.important = str;
                    tokens = cache;
                }
            }

            if (token[0] !== 'space' && token[0] !== 'comment') {
                break;
            }
        }

        this.raw(node, 'value', tokens);

        if (node.value.indexOf(':') !== -1) this.checkMissedSemicolon(tokens);
    };

    Parser.prototype.atrule = function atrule(token) {
        var node = new _atRule2.default();
        node.name = token[1].slice(1);
        if (node.name === '') {
            this.unnamedAtrule(node, token);
        }
        this.init(node, token[2], token[3]);

        var last = false;
        var open = false;
        var params = [];

        this.pos += 1;
        while (this.pos < this.tokens.length) {
            token = this.tokens[this.pos];

            if (token[0] === ';') {
                node.source.end = { line: token[2], column: token[3] };
                this.semicolon = true;
                break;
            } else if (token[0] === '{') {
                open = true;
                break;
            } else if (token[0] === '}') {
                this.end(token);
                break;
            } else {
                params.push(token);
            }

            this.pos += 1;
        }
        if (this.pos === this.tokens.length) {
            last = true;
        }

        node.raws.between = this.spacesAndCommentsFromEnd(params);
        if (params.length) {
            node.raws.afterName = this.spacesAndCommentsFromStart(params);
            this.raw(node, 'params', params);
            if (last) {
                token = params[params.length - 1];
                node.source.end = { line: token[4], column: token[5] };
                this.spaces = node.raws.between;
                node.raws.between = '';
            }
        } else {
            node.raws.afterName = '';
            node.params = '';
        }

        if (open) {
            node.nodes = [];
            this.current = node;
        }
    };

    Parser.prototype.end = function end(token) {
        if (this.current.nodes && this.current.nodes.length) {
            this.current.raws.semicolon = this.semicolon;
        }
        this.semicolon = false;

        this.current.raws.after = (this.current.raws.after || '') + this.spaces;
        this.spaces = '';

        if (this.current.parent) {
            this.current.source.end = { line: token[2], column: token[3] };
            this.current = this.current.parent;
        } else {
            this.unexpectedClose(token);
        }
    };

    Parser.prototype.endFile = function endFile() {
        if (this.current.parent) this.unclosedBlock();
        if (this.current.nodes && this.current.nodes.length) {
            this.current.raws.semicolon = this.semicolon;
        }
        this.current.raws.after = (this.current.raws.after || '') + this.spaces;
    };

    // Helpers

    Parser.prototype.init = function init(node, line, column) {
        this.current.push(node);

        node.source = { start: { line: line, column: column }, input: this.input };
        node.raws.before = this.spaces;
        this.spaces = '';
        if (node.type !== 'comment') this.semicolon = false;
    };

    Parser.prototype.raw = function raw(node, prop, tokens) {
        var token = void 0,
            type = void 0;
        var length = tokens.length;
        var value = '';
        var clean = true;
        for (var i = 0; i < length; i += 1) {
            token = tokens[i];
            type = token[0];
            if (type === 'comment' || type === 'space' && i === length - 1) {
                clean = false;
            } else {
                value += token[1];
            }
        }
        if (!clean) {
            var raw = tokens.reduce(function (all, i) {
                return all + i[1];
            }, '');
            node.raws[prop] = { value: value, raw: raw };
        }
        node[prop] = value;
    };

    Parser.prototype.spacesAndCommentsFromEnd = function spacesAndCommentsFromEnd(tokens) {
        var lastTokenType = void 0;
        var spaces = '';
        while (tokens.length) {
            lastTokenType = tokens[tokens.length - 1][0];
            if (lastTokenType !== 'space' && lastTokenType !== 'comment') break;
            spaces = tokens.pop()[1] + spaces;
        }
        return spaces;
    };

    Parser.prototype.spacesAndCommentsFromStart = function spacesAndCommentsFromStart(tokens) {
        var next = void 0;
        var spaces = '';
        while (tokens.length) {
            next = tokens[0][0];
            if (next !== 'space' && next !== 'comment') break;
            spaces += tokens.shift()[1];
        }
        return spaces;
    };

    Parser.prototype.spacesFromEnd = function spacesFromEnd(tokens) {
        var lastTokenType = void 0;
        var spaces = '';
        while (tokens.length) {
            lastTokenType = tokens[tokens.length - 1][0];
            if (lastTokenType !== 'space') break;
            spaces = tokens.pop()[1] + spaces;
        }
        return spaces;
    };

    Parser.prototype.stringFrom = function stringFrom(tokens, from) {
        var result = '';
        for (var i = from; i < tokens.length; i++) {
            result += tokens[i][1];
        }
        tokens.splice(from, tokens.length - from);
        return result;
    };

    Parser.prototype.colon = function colon(tokens) {
        var brackets = 0;
        var token = void 0,
            type = void 0,
            prev = void 0;
        for (var i = 0; i < tokens.length; i++) {
            token = tokens[i];
            type = token[0];

            if (type === '(') {
                brackets += 1;
            } else if (type === ')') {
                brackets -= 1;
            } else if (brackets === 0 && type === ':') {
                if (!prev) {
                    this.doubleColon(token);
                } else if (prev[0] === 'word' && prev[1] === 'progid') {
                    continue;
                } else {
                    return i;
                }
            }

            prev = token;
        }
        return false;
    };

    // Errors

    Parser.prototype.unclosedBracket = function unclosedBracket(bracket) {
        throw this.input.error('Unclosed bracket', bracket[2], bracket[3]);
    };

    Parser.prototype.unknownWord = function unknownWord(start) {
        var token = this.tokens[start];
        throw this.input.error('Unknown word', token[2], token[3]);
    };

    Parser.prototype.unexpectedClose = function unexpectedClose(token) {
        throw this.input.error('Unexpected }', token[2], token[3]);
    };

    Parser.prototype.unclosedBlock = function unclosedBlock() {
        var pos = this.current.source.start;
        throw this.input.error('Unclosed block', pos.line, pos.column);
    };

    Parser.prototype.doubleColon = function doubleColon(token) {
        throw this.input.error('Double colon', token[2], token[3]);
    };

    Parser.prototype.unnamedAtrule = function unnamedAtrule(node, token) {
        throw this.input.error('At-rule without name', token[2], token[3]);
    };

    Parser.prototype.precheckMissedSemicolon = function precheckMissedSemicolon(tokens) {
        // Hook for Safe Parser
        tokens;
    };

    Parser.prototype.checkMissedSemicolon = function checkMissedSemicolon(tokens) {
        var colon = this.colon(tokens);
        if (colon === false) return;

        var founded = 0;
        var token = void 0;
        for (var j = colon - 1; j >= 0; j--) {
            token = tokens[j];
            if (token[0] !== 'space') {
                founded += 1;
                if (founded === 2) break;
            }
        }
        throw this.input.error('Missed semicolon', token[2], token[3]);
    };

    return Parser;
}();

exports.default = Parser;
module.exports = exports['default'];


},{"./at-rule":753,"./comment":754,"./declaration":757,"./root":768,"./rule":769,"./tokenize":773}],765:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

var _jsBase = require('js-base64');

var _sourceMap = require('source-map');

var _sourceMap2 = _interopRequireDefault(_sourceMap);

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _fs = require('fs');

var _fs2 = _interopRequireDefault(_fs);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

/**
 * Source map information from input CSS.
 * For example, source map after Sass compiler.
 *
 * This class will automatically find source map in input CSS or in file system
 * near input file (according `from` option).
 *
 * @example
 * const root = postcss.parse(css, { from: 'a.sass.css' });
 * root.input.map //=> PreviousMap
 */
var PreviousMap = function () {

    /**
     * @param {string}         css    - input CSS source
     * @param {processOptions} [opts] - {@link Processor#process} options
     */
    function PreviousMap(css, opts) {
        _classCallCheck(this, PreviousMap);

        this.loadAnnotation(css);
        /**
         * @member {boolean} - Was source map inlined by data-uri to input CSS.
         */
        this.inline = this.startWith(this.annotation, 'data:');

        var prev = opts.map ? opts.map.prev : undefined;
        var text = this.loadMap(opts.from, prev);
        if (text) this.text = text;
    }

    /**
     * Create a instance of `SourceMapGenerator` class
     * from the `source-map` library to work with source map information.
     *
     * It is lazy method, so it will create object only on first call
     * and then it will use cache.
     *
     * @return {SourceMapGenerator} object with source map information
     */


    PreviousMap.prototype.consumer = function consumer() {
        if (!this.consumerCache) {
            this.consumerCache = new _sourceMap2.default.SourceMapConsumer(this.text);
        }
        return this.consumerCache;
    };

    /**
     * Does source map contains `sourcesContent` with input source text.
     *
     * @return {boolean} Is `sourcesContent` present
     */


    PreviousMap.prototype.withContent = function withContent() {
        return !!(this.consumer().sourcesContent && this.consumer().sourcesContent.length > 0);
    };

    PreviousMap.prototype.startWith = function startWith(string, start) {
        if (!string) return false;
        return string.substr(0, start.length) === start;
    };

    PreviousMap.prototype.loadAnnotation = function loadAnnotation(css) {
        var match = css.match(/\/\*\s*# sourceMappingURL=(.*)\s*\*\//);
        if (match) this.annotation = match[1].trim();
    };

    PreviousMap.prototype.decodeInline = function decodeInline(text) {
        var utfd64 = 'data:application/json;charset=utf-8;base64,';
        var utf64 = 'data:application/json;charset=utf8;base64,';
        var b64 = 'data:application/json;base64,';
        var uri = 'data:application/json,';

        if (this.startWith(text, uri)) {
            return decodeURIComponent(text.substr(uri.length));
        } else if (this.startWith(text, b64)) {
            return _jsBase.Base64.decode(text.substr(b64.length));
        } else if (this.startWith(text, utf64)) {
            return _jsBase.Base64.decode(text.substr(utf64.length));
        } else if (this.startWith(text, utfd64)) {
            return _jsBase.Base64.decode(text.substr(utfd64.length));
        } else {
            var encoding = text.match(/data:application\/json;([^,]+),/)[1];
            throw new Error('Unsupported source map encoding ' + encoding);
        }
    };

    PreviousMap.prototype.loadMap = function loadMap(file, prev) {
        if (prev === false) return false;

        if (prev) {
            if (typeof prev === 'string') {
                return prev;
            } else if (typeof prev === 'function') {
                var prevPath = prev(file);
                if (prevPath && _fs2.default.existsSync && _fs2.default.existsSync(prevPath)) {
                    return _fs2.default.readFileSync(prevPath, 'utf-8').toString().trim();
                } else {
                    throw new Error('Unable to load previous source map: ' + prevPath.toString());
                }
            } else if (prev instanceof _sourceMap2.default.SourceMapConsumer) {
                return _sourceMap2.default.SourceMapGenerator.fromSourceMap(prev).toString();
            } else if (prev instanceof _sourceMap2.default.SourceMapGenerator) {
                return prev.toString();
            } else if (this.isMap(prev)) {
                return JSON.stringify(prev);
            } else {
                throw new Error('Unsupported previous source map format: ' + prev.toString());
            }
        } else if (this.inline) {
            return this.decodeInline(this.annotation);
        } else if (this.annotation) {
            var map = this.annotation;
            if (file) map = _path2.default.join(_path2.default.dirname(file), map);

            this.root = _path2.default.dirname(map);
            if (_fs2.default.existsSync && _fs2.default.existsSync(map)) {
                return _fs2.default.readFileSync(map, 'utf-8').toString().trim();
            } else {
                return false;
            }
        }
    };

    PreviousMap.prototype.isMap = function isMap(map) {
        if ((typeof map === 'undefined' ? 'undefined' : _typeof(map)) !== 'object') return false;
        return typeof map.mappings === 'string' || typeof map._mappings === 'string';
    };

    return PreviousMap;
}();

exports.default = PreviousMap;
module.exports = exports['default'];


},{"fs":4,"js-base64":658,"path":14,"source-map":864}],766:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

var _lazyResult = require('./lazy-result');

var _lazyResult2 = _interopRequireDefault(_lazyResult);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

/**
 * Contains plugins to process CSS. Create one `Processor` instance,
 * initialize its plugins, and then use that instance on numerous CSS files.
 *
 * @example
 * const processor = postcss([autoprefixer, precss]);
 * processor.process(css1).then(result => console.log(result.css));
 * processor.process(css2).then(result => console.log(result.css));
 */
var Processor = function () {

  /**
   * @param {Array.<Plugin|pluginFunction>|Processor} plugins - PostCSS
   *        plugins. See {@link Processor#use} for plugin format.
   */
  function Processor() {
    var plugins = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];

    _classCallCheck(this, Processor);

    /**
     * @member {string} - Current PostCSS version.
     *
     * @example
     * if ( result.processor.version.split('.')[0] !== '5' ) {
     *   throw new Error('This plugin works only with PostCSS 5');
     * }
     */
    this.version = '5.2.17';
    /**
     * @member {pluginFunction[]} - Plugins added to this processor.
     *
     * @example
     * const processor = postcss([autoprefixer, precss]);
     * processor.plugins.length //=> 2
     */
    this.plugins = this.normalize(plugins);
  }

  /**
   * Adds a plugin to be used as a CSS processor.
   *
   * PostCSS plugin can be in 4 formats:
   * * A plugin created by {@link postcss.plugin} method.
   * * A function. PostCSS will pass the function a @{link Root}
   *   as the first argument and current {@link Result} instance
   *   as the second.
   * * An object with a `postcss` method. PostCSS will use that method
   *   as described in #2.
   * * Another {@link Processor} instance. PostCSS will copy plugins
   *   from that instance into this one.
   *
   * Plugins can also be added by passing them as arguments when creating
   * a `postcss` instance (see [`postcss(plugins)`]).
   *
   * Asynchronous plugins should return a `Promise` instance.
   *
   * @param {Plugin|pluginFunction|Processor} plugin - PostCSS plugin
   *                                                   or {@link Processor}
   *                                                   with plugins
   *
   * @example
   * const processor = postcss()
   *   .use(autoprefixer)
   *   .use(precss);
   *
   * @return {Processes} current processor to make methods chain
   */


  Processor.prototype.use = function use(plugin) {
    this.plugins = this.plugins.concat(this.normalize([plugin]));
    return this;
  };

  /**
   * Parses source CSS and returns a {@link LazyResult} Promise proxy.
   * Because some plugins can be asynchronous it doesn’t make
   * any transformations. Transformations will be applied
   * in the {@link LazyResult} methods.
   *
   * @param {string|toString|Result} css - String with input CSS or
   *                                       any object with a `toString()`
   *                                       method, like a Buffer.
   *                                       Optionally, send a {@link Result}
   *                                       instance and the processor will
   *                                       take the {@link Root} from it.
   * @param {processOptions} [opts]      - options
   *
   * @return {LazyResult} Promise proxy
   *
   * @example
   * processor.process(css, { from: 'a.css', to: 'a.out.css' })
   *   .then(result => {
   *      console.log(result.css);
   *   });
   */


  Processor.prototype.process = function process(css) {
    var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

    return new _lazyResult2.default(this, css, opts);
  };

  Processor.prototype.normalize = function normalize(plugins) {
    var normalized = [];
    for (var _iterator = plugins, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
      var _ref;

      if (_isArray) {
        if (_i >= _iterator.length) break;
        _ref = _iterator[_i++];
      } else {
        _i = _iterator.next();
        if (_i.done) break;
        _ref = _i.value;
      }

      var i = _ref;

      if (i.postcss) i = i.postcss;

      if ((typeof i === 'undefined' ? 'undefined' : _typeof(i)) === 'object' && Array.isArray(i.plugins)) {
        normalized = normalized.concat(i.plugins);
      } else if (typeof i === 'function') {
        normalized.push(i);
      } else if ((typeof i === 'undefined' ? 'undefined' : _typeof(i)) === 'object' && (i.parse || i.stringify)) {
        throw new Error('PostCSS syntaxes cannot be used as plugins. ' + 'Instead, please use one of the ' + 'syntax/parser/stringifier options as ' + 'outlined in your PostCSS ' + 'runner documentation.');
      } else {
        throw new Error(i + ' is not a PostCSS plugin');
      }
    }
    return normalized;
  };

  return Processor;
}();

exports.default = Processor;

/**
 * @callback builder
 * @param {string} part          - part of generated CSS connected to this node
 * @param {Node}   node          - AST node
 * @param {"start"|"end"} [type] - node’s part type
 */

/**
 * @callback parser
 *
 * @param {string|toString} css   - string with input CSS or any object
 *                                  with toString() method, like a Buffer
 * @param {processOptions} [opts] - options with only `from` and `map` keys
 *
 * @return {Root} PostCSS AST
 */

/**
 * @callback stringifier
 *
 * @param {Node} node       - start node for stringifing. Usually {@link Root}.
 * @param {builder} builder - function to concatenate CSS from node’s parts
 *                            or generate string and source map
 *
 * @return {void}
 */

/**
 * @typedef {object} syntax
 * @property {parser} parse          - function to generate AST by string
 * @property {stringifier} stringify - function to generate string by AST
 */

/**
 * @typedef {object} toString
 * @property {function} toString
 */

/**
 * @callback pluginFunction
 * @param {Root} root     - parsed input CSS
 * @param {Result} result - result to set warnings or check other plugins
 */

/**
 * @typedef {object} Plugin
 * @property {function} postcss - PostCSS plugin function
 */

/**
 * @typedef {object} processOptions
 * @property {string} from             - the path of the CSS source file.
 *                                       You should always set `from`,
 *                                       because it is used in source map
 *                                       generation and syntax error messages.
 * @property {string} to               - the path where you’ll put the output
 *                                       CSS file. You should always set `to`
 *                                       to generate correct source maps.
 * @property {parser} parser           - function to generate AST by string
 * @property {stringifier} stringifier - class to generate string by AST
 * @property {syntax} syntax           - object with `parse` and `stringify`
 * @property {object} map              - source map options
 * @property {boolean} map.inline                    - does source map should
 *                                                     be embedded in the output
 *                                                     CSS as a base64-encoded
 *                                                     comment
 * @property {string|object|false|function} map.prev - source map content
 *                                                     from a previous
 *                                                     processing step
 *                                                     (for example, Sass).
 *                                                     PostCSS will try to find
 *                                                     previous map
 *                                                     automatically, so you
 *                                                     could disable it by
 *                                                     `false` value.
 * @property {boolean} map.sourcesContent            - does PostCSS should set
 *                                                     the origin content to map
 * @property {string|false} map.annotation           - does PostCSS should set
 *                                                     annotation comment to map
 * @property {string} map.from                       - override `from` in map’s
 *                                                     `sources`
 */

module.exports = exports['default'];


},{"./lazy-result":759}],767:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _warning = require('./warning');

var _warning2 = _interopRequireDefault(_warning);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

/**
 * Provides the result of the PostCSS transformations.
 *
 * A Result instance is returned by {@link LazyResult#then}
 * or {@link Root#toResult} methods.
 *
 * @example
 * postcss([cssnext]).process(css).then(function (result) {
 *    console.log(result.css);
 * });
 *
 * @example
 * var result2 = postcss.parse(css).toResult();
 */
var Result = function () {

  /**
   * @param {Processor} processor - processor used for this transformation.
   * @param {Root}      root      - Root node after all transformations.
   * @param {processOptions} opts - options from the {@link Processor#process}
   *                                or {@link Root#toResult}
   */
  function Result(processor, root, opts) {
    _classCallCheck(this, Result);

    /**
     * @member {Processor} - The Processor instance used
     *                       for this transformation.
     *
     * @example
     * for ( let plugin of result.processor.plugins) {
     *   if ( plugin.postcssPlugin === 'postcss-bad' ) {
     *     throw 'postcss-good is incompatible with postcss-bad';
     *   }
     * });
     */
    this.processor = processor;
    /**
     * @member {Message[]} - Contains messages from plugins
     *                       (e.g., warnings or custom messages).
     *                       Each message should have type
     *                       and plugin properties.
     *
     * @example
     * postcss.plugin('postcss-min-browser', () => {
     *   return (root, result) => {
     *     var browsers = detectMinBrowsersByCanIUse(root);
     *     result.messages.push({
     *       type:    'min-browser',
     *       plugin:  'postcss-min-browser',
     *       browsers: browsers
     *     });
     *   };
     * });
     */
    this.messages = [];
    /**
     * @member {Root} - Root node after all transformations.
     *
     * @example
     * root.toResult().root == root;
     */
    this.root = root;
    /**
     * @member {processOptions} - Options from the {@link Processor#process}
     *                            or {@link Root#toResult} call
     *                            that produced this Result instance.
     *
     * @example
     * root.toResult(opts).opts == opts;
     */
    this.opts = opts;
    /**
     * @member {string} - A CSS string representing of {@link Result#root}.
     *
     * @example
     * postcss.parse('a{}').toResult().css //=> "a{}"
     */
    this.css = undefined;
    /**
     * @member {SourceMapGenerator} - An instance of `SourceMapGenerator`
     *                                class from the `source-map` library,
     *                                representing changes
     *                                to the {@link Result#root} instance.
     *
     * @example
     * result.map.toJSON() //=> { version: 3, file: 'a.css', … }
     *
     * @example
     * if ( result.map ) {
     *   fs.writeFileSync(result.opts.to + '.map', result.map.toString());
     * }
     */
    this.map = undefined;
  }

  /**
   * Returns for @{link Result#css} content.
   *
   * @example
   * result + '' === result.css
   *
   * @return {string} string representing of {@link Result#root}
   */


  Result.prototype.toString = function toString() {
    return this.css;
  };

  /**
   * Creates an instance of {@link Warning} and adds it
   * to {@link Result#messages}.
   *
   * @param {string} text        - warning message
   * @param {Object} [opts]      - warning options
   * @param {Node}   opts.node   - CSS node that caused the warning
   * @param {string} opts.word   - word in CSS source that caused the warning
   * @param {number} opts.index  - index in CSS node string that caused
   *                               the warning
   * @param {string} opts.plugin - name of the plugin that created
   *                               this warning. {@link Result#warn} fills
   *                               this property automatically.
   *
   * @return {Warning} created warning
   */


  Result.prototype.warn = function warn(text) {
    var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

    if (!opts.plugin) {
      if (this.lastPlugin && this.lastPlugin.postcssPlugin) {
        opts.plugin = this.lastPlugin.postcssPlugin;
      }
    }

    var warning = new _warning2.default(text, opts);
    this.messages.push(warning);

    return warning;
  };

  /**
   * Returns warnings from plugins. Filters {@link Warning} instances
   * from {@link Result#messages}.
   *
   * @example
   * result.warnings().forEach(warn => {
   *   console.warn(warn.toString());
   * });
   *
   * @return {Warning[]} warnings from plugins
   */


  Result.prototype.warnings = function warnings() {
    return this.messages.filter(function (i) {
      return i.type === 'warning';
    });
  };

  /**
   * An alias for the {@link Result#css} property.
   * Use it with syntaxes that generate non-CSS output.
   * @type {string}
   *
   * @example
   * result.css === result.content;
   */


  _createClass(Result, [{
    key: 'content',
    get: function get() {
      return this.css;
    }
  }]);

  return Result;
}();

exports.default = Result;

/**
 * @typedef  {object} Message
 * @property {string} type   - message type
 * @property {string} plugin - source PostCSS plugin name
 */

module.exports = exports['default'];


},{"./warning":775}],768:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _container = require('./container');

var _container2 = _interopRequireDefault(_container);

var _warnOnce = require('./warn-once');

var _warnOnce2 = _interopRequireDefault(_warnOnce);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

/**
 * Represents a CSS file and contains all its parsed nodes.
 *
 * @extends Container
 *
 * @example
 * const root = postcss.parse('a{color:black} b{z-index:2}');
 * root.type         //=> 'root'
 * root.nodes.length //=> 2
 */
var Root = function (_Container) {
    _inherits(Root, _Container);

    function Root(defaults) {
        _classCallCheck(this, Root);

        var _this = _possibleConstructorReturn(this, _Container.call(this, defaults));

        _this.type = 'root';
        if (!_this.nodes) _this.nodes = [];
        return _this;
    }

    Root.prototype.removeChild = function removeChild(child) {
        child = this.index(child);

        if (child === 0 && this.nodes.length > 1) {
            this.nodes[1].raws.before = this.nodes[child].raws.before;
        }

        return _Container.prototype.removeChild.call(this, child);
    };

    Root.prototype.normalize = function normalize(child, sample, type) {
        var nodes = _Container.prototype.normalize.call(this, child);

        if (sample) {
            if (type === 'prepend') {
                if (this.nodes.length > 1) {
                    sample.raws.before = this.nodes[1].raws.before;
                } else {
                    delete sample.raws.before;
                }
            } else if (this.first !== sample) {
                for (var _iterator = nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
                    var _ref;

                    if (_isArray) {
                        if (_i >= _iterator.length) break;
                        _ref = _iterator[_i++];
                    } else {
                        _i = _iterator.next();
                        if (_i.done) break;
                        _ref = _i.value;
                    }

                    var node = _ref;

                    node.raws.before = sample.raws.before;
                }
            }
        }

        return nodes;
    };

    /**
     * Returns a {@link Result} instance representing the root’s CSS.
     *
     * @param {processOptions} [opts] - options with only `to` and `map` keys
     *
     * @return {Result} result with current root’s CSS
     *
     * @example
     * const root1 = postcss.parse(css1, { from: 'a.css' });
     * const root2 = postcss.parse(css2, { from: 'b.css' });
     * root1.append(root2);
     * const result = root1.toResult({ to: 'all.css', map: true });
     */


    Root.prototype.toResult = function toResult() {
        var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

        var LazyResult = require('./lazy-result');
        var Processor = require('./processor');

        var lazy = new LazyResult(new Processor(), this, opts);
        return lazy.stringify();
    };

    Root.prototype.remove = function remove(child) {
        (0, _warnOnce2.default)('Root#remove is deprecated. Use Root#removeChild');
        this.removeChild(child);
    };

    Root.prototype.prevMap = function prevMap() {
        (0, _warnOnce2.default)('Root#prevMap is deprecated. Use Root#source.input.map');
        return this.source.input.map;
    };

    /**
     * @memberof Root#
     * @member {object} raws - Information to generate byte-to-byte equal
     *                         node string as it was in the origin input.
     *
     * Every parser saves its own properties,
     * but the default CSS parser uses:
     *
     * * `after`: the space symbols after the last child to the end of file.
     * * `semicolon`: is the last child has an (optional) semicolon.
     *
     * @example
     * postcss.parse('a {}\n').raws //=> { after: '\n' }
     * postcss.parse('a {}').raws   //=> { after: '' }
     */

    return Root;
}(_container2.default);

exports.default = Root;
module.exports = exports['default'];


},{"./container":755,"./lazy-result":759,"./processor":766,"./warn-once":774}],769:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _container = require('./container');

var _container2 = _interopRequireDefault(_container);

var _warnOnce = require('./warn-once');

var _warnOnce2 = _interopRequireDefault(_warnOnce);

var _list = require('./list');

var _list2 = _interopRequireDefault(_list);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

/**
 * Represents a CSS rule: a selector followed by a declaration block.
 *
 * @extends Container
 *
 * @example
 * const root = postcss.parse('a{}');
 * const rule = root.first;
 * rule.type       //=> 'rule'
 * rule.toString() //=> 'a{}'
 */
var Rule = function (_Container) {
    _inherits(Rule, _Container);

    function Rule(defaults) {
        _classCallCheck(this, Rule);

        var _this = _possibleConstructorReturn(this, _Container.call(this, defaults));

        _this.type = 'rule';
        if (!_this.nodes) _this.nodes = [];
        return _this;
    }

    /**
     * An array containing the rule’s individual selectors.
     * Groups of selectors are split at commas.
     *
     * @type {string[]}
     *
     * @example
     * const root = postcss.parse('a, b { }');
     * const rule = root.first;
     *
     * rule.selector  //=> 'a, b'
     * rule.selectors //=> ['a', 'b']
     *
     * rule.selectors = ['a', 'strong'];
     * rule.selector //=> 'a, strong'
     */


    _createClass(Rule, [{
        key: 'selectors',
        get: function get() {
            return _list2.default.comma(this.selector);
        },
        set: function set(values) {
            var match = this.selector ? this.selector.match(/,\s*/) : null;
            var sep = match ? match[0] : ',' + this.raw('between', 'beforeOpen');
            this.selector = values.join(sep);
        }
    }, {
        key: '_selector',
        get: function get() {
            (0, _warnOnce2.default)('Rule#_selector is deprecated. Use Rule#raws.selector');
            return this.raws.selector;
        },
        set: function set(val) {
            (0, _warnOnce2.default)('Rule#_selector is deprecated. Use Rule#raws.selector');
            this.raws.selector = val;
        }

        /**
         * @memberof Rule#
         * @member {string} selector - the rule’s full selector represented
         *                             as a string
         *
         * @example
         * const root = postcss.parse('a, b { }');
         * const rule = root.first;
         * rule.selector //=> 'a, b'
         */

        /**
         * @memberof Rule#
         * @member {object} raws - Information to generate byte-to-byte equal
         *                         node string as it was in the origin input.
         *
         * Every parser saves its own properties,
         * but the default CSS parser uses:
         *
         * * `before`: the space symbols before the node. It also stores `*`
         *   and `_` symbols before the declaration (IE hack).
         * * `after`: the space symbols after the last child of the node
         *   to the end of the node.
         * * `between`: the symbols between the property and value
         *   for declarations, selector and `{` for rules, or last parameter
         *   and `{` for at-rules.
         * * `semicolon`: contains true if the last child has
         *   an (optional) semicolon.
         *
         * PostCSS cleans selectors from comments and extra spaces,
         * but it stores origin content in raws properties.
         * As such, if you don’t change a declaration’s value,
         * PostCSS will use the raw value with comments.
         *
         * @example
         * const root = postcss.parse('a {\n  color:black\n}')
         * root.first.first.raws //=> { before: '', between: ' ', after: '\n' }
         */

    }]);

    return Rule;
}(_container2.default);

exports.default = Rule;
module.exports = exports['default'];


},{"./container":755,"./list":760,"./warn-once":774}],770:[function(require,module,exports){
'use strict';

exports.__esModule = true;

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var defaultRaw = {
    colon: ': ',
    indent: '    ',
    beforeDecl: '\n',
    beforeRule: '\n',
    beforeOpen: ' ',
    beforeClose: '\n',
    beforeComment: '\n',
    after: '\n',
    emptyBody: '',
    commentLeft: ' ',
    commentRight: ' '
};

function capitalize(str) {
    return str[0].toUpperCase() + str.slice(1);
}

var Stringifier = function () {
    function Stringifier(builder) {
        _classCallCheck(this, Stringifier);

        this.builder = builder;
    }

    Stringifier.prototype.stringify = function stringify(node, semicolon) {
        this[node.type](node, semicolon);
    };

    Stringifier.prototype.root = function root(node) {
        this.body(node);
        if (node.raws.after) this.builder(node.raws.after);
    };

    Stringifier.prototype.comment = function comment(node) {
        var left = this.raw(node, 'left', 'commentLeft');
        var right = this.raw(node, 'right', 'commentRight');
        this.builder('/*' + left + node.text + right + '*/', node);
    };

    Stringifier.prototype.decl = function decl(node, semicolon) {
        var between = this.raw(node, 'between', 'colon');
        var string = node.prop + between + this.rawValue(node, 'value');

        if (node.important) {
            string += node.raws.important || ' !important';
        }

        if (semicolon) string += ';';
        this.builder(string, node);
    };

    Stringifier.prototype.rule = function rule(node) {
        this.block(node, this.rawValue(node, 'selector'));
    };

    Stringifier.prototype.atrule = function atrule(node, semicolon) {
        var name = '@' + node.name;
        var params = node.params ? this.rawValue(node, 'params') : '';

        if (typeof node.raws.afterName !== 'undefined') {
            name += node.raws.afterName;
        } else if (params) {
            name += ' ';
        }

        if (node.nodes) {
            this.block(node, name + params);
        } else {
            var end = (node.raws.between || '') + (semicolon ? ';' : '');
            this.builder(name + params + end, node);
        }
    };

    Stringifier.prototype.body = function body(node) {
        var last = node.nodes.length - 1;
        while (last > 0) {
            if (node.nodes[last].type !== 'comment') break;
            last -= 1;
        }

        var semicolon = this.raw(node, 'semicolon');
        for (var i = 0; i < node.nodes.length; i++) {
            var child = node.nodes[i];
            var before = this.raw(child, 'before');
            if (before) this.builder(before);
            this.stringify(child, last !== i || semicolon);
        }
    };

    Stringifier.prototype.block = function block(node, start) {
        var between = this.raw(node, 'between', 'beforeOpen');
        this.builder(start + between + '{', node, 'start');

        var after = void 0;
        if (node.nodes && node.nodes.length) {
            this.body(node);
            after = this.raw(node, 'after');
        } else {
            after = this.raw(node, 'after', 'emptyBody');
        }

        if (after) this.builder(after);
        this.builder('}', node, 'end');
    };

    Stringifier.prototype.raw = function raw(node, own, detect) {
        var value = void 0;
        if (!detect) detect = own;

        // Already had
        if (own) {
            value = node.raws[own];
            if (typeof value !== 'undefined') return value;
        }

        var parent = node.parent;

        // Hack for first rule in CSS
        if (detect === 'before') {
            if (!parent || parent.type === 'root' && parent.first === node) {
                return '';
            }
        }

        // Floating child without parent
        if (!parent) return defaultRaw[detect];

        // Detect style by other nodes
        var root = node.root();
        if (!root.rawCache) root.rawCache = {};
        if (typeof root.rawCache[detect] !== 'undefined') {
            return root.rawCache[detect];
        }

        if (detect === 'before' || detect === 'after') {
            return this.beforeAfter(node, detect);
        } else {
            var method = 'raw' + capitalize(detect);
            if (this[method]) {
                value = this[method](root, node);
            } else {
                root.walk(function (i) {
                    value = i.raws[own];
                    if (typeof value !== 'undefined') return false;
                });
            }
        }

        if (typeof value === 'undefined') value = defaultRaw[detect];

        root.rawCache[detect] = value;
        return value;
    };

    Stringifier.prototype.rawSemicolon = function rawSemicolon(root) {
        var value = void 0;
        root.walk(function (i) {
            if (i.nodes && i.nodes.length && i.last.type === 'decl') {
                value = i.raws.semicolon;
                if (typeof value !== 'undefined') return false;
            }
        });
        return value;
    };

    Stringifier.prototype.rawEmptyBody = function rawEmptyBody(root) {
        var value = void 0;
        root.walk(function (i) {
            if (i.nodes && i.nodes.length === 0) {
                value = i.raws.after;
                if (typeof value !== 'undefined') return false;
            }
        });
        return value;
    };

    Stringifier.prototype.rawIndent = function rawIndent(root) {
        if (root.raws.indent) return root.raws.indent;
        var value = void 0;
        root.walk(function (i) {
            var p = i.parent;
            if (p && p !== root && p.parent && p.parent === root) {
                if (typeof i.raws.before !== 'undefined') {
                    var parts = i.raws.before.split('\n');
                    value = parts[parts.length - 1];
                    value = value.replace(/[^\s]/g, '');
                    return false;
                }
            }
        });
        return value;
    };

    Stringifier.prototype.rawBeforeComment = function rawBeforeComment(root, node) {
        var value = void 0;
        root.walkComments(function (i) {
            if (typeof i.raws.before !== 'undefined') {
                value = i.raws.before;
                if (value.indexOf('\n') !== -1) {
                    value = value.replace(/[^\n]+$/, '');
                }
                return false;
            }
        });
        if (typeof value === 'undefined') {
            value = this.raw(node, null, 'beforeDecl');
        }
        return value;
    };

    Stringifier.prototype.rawBeforeDecl = function rawBeforeDecl(root, node) {
        var value = void 0;
        root.walkDecls(function (i) {
            if (typeof i.raws.before !== 'undefined') {
                value = i.raws.before;
                if (value.indexOf('\n') !== -1) {
                    value = value.replace(/[^\n]+$/, '');
                }
                return false;
            }
        });
        if (typeof value === 'undefined') {
            value = this.raw(node, null, 'beforeRule');
        }
        return value;
    };

    Stringifier.prototype.rawBeforeRule = function rawBeforeRule(root) {
        var value = void 0;
        root.walk(function (i) {
            if (i.nodes && (i.parent !== root || root.first !== i)) {
                if (typeof i.raws.before !== 'undefined') {
                    value = i.raws.before;
                    if (value.indexOf('\n') !== -1) {
                        value = value.replace(/[^\n]+$/, '');
                    }
                    return false;
                }
            }
        });
        return value;
    };

    Stringifier.prototype.rawBeforeClose = function rawBeforeClose(root) {
        var value = void 0;
        root.walk(function (i) {
            if (i.nodes && i.nodes.length > 0) {
                if (typeof i.raws.after !== 'undefined') {
                    value = i.raws.after;
                    if (value.indexOf('\n') !== -1) {
                        value = value.replace(/[^\n]+$/, '');
                    }
                    return false;
                }
            }
        });
        return value;
    };

    Stringifier.prototype.rawBeforeOpen = function rawBeforeOpen(root) {
        var value = void 0;
        root.walk(function (i) {
            if (i.type !== 'decl') {
                value = i.raws.between;
                if (typeof value !== 'undefined') return false;
            }
        });
        return value;
    };

    Stringifier.prototype.rawColon = function rawColon(root) {
        var value = void 0;
        root.walkDecls(function (i) {
            if (typeof i.raws.between !== 'undefined') {
                value = i.raws.between.replace(/[^\s:]/g, '');
                return false;
            }
        });
        return value;
    };

    Stringifier.prototype.beforeAfter = function beforeAfter(node, detect) {
        var value = void 0;
        if (node.type === 'decl') {
            value = this.raw(node, null, 'beforeDecl');
        } else if (node.type === 'comment') {
            value = this.raw(node, null, 'beforeComment');
        } else if (detect === 'before') {
            value = this.raw(node, null, 'beforeRule');
        } else {
            value = this.raw(node, null, 'beforeClose');
        }

        var buf = node.parent;
        var depth = 0;
        while (buf && buf.type !== 'root') {
            depth += 1;
            buf = buf.parent;
        }

        if (value.indexOf('\n') !== -1) {
            var indent = this.raw(node, null, 'indent');
            if (indent.length) {
                for (var step = 0; step < depth; step++) {
                    value += indent;
                }
            }
        }

        return value;
    };

    Stringifier.prototype.rawValue = function rawValue(node, prop) {
        var value = node[prop];
        var raw = node.raws[prop];
        if (raw && raw.value === value) {
            return raw.raw;
        } else {
            return value;
        }
    };

    return Stringifier;
}();

exports.default = Stringifier;
module.exports = exports['default'];


},{}],771:[function(require,module,exports){
'use strict';

exports.__esModule = true;
exports.default = stringify;

var _stringifier = require('./stringifier');

var _stringifier2 = _interopRequireDefault(_stringifier);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function stringify(node, builder) {
    var str = new _stringifier2.default(builder);
    str.stringify(node);
}
module.exports = exports['default'];


},{"./stringifier":770}],772:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _chalk = require('chalk');

var _chalk2 = _interopRequireDefault(_chalk);

var _tokenize = require('./tokenize');

var _tokenize2 = _interopRequireDefault(_tokenize);

var _input = require('./input');

var _input2 = _interopRequireDefault(_input);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var colors = new _chalk2.default.constructor({ enabled: true });

var HIGHLIGHT_THEME = {
    'brackets': colors.cyan,
    'at-word': colors.cyan,
    'call': colors.cyan,
    'comment': colors.gray,
    'string': colors.green,
    'class': colors.yellow,
    'hash': colors.magenta,
    '(': colors.cyan,
    ')': colors.cyan,
    '{': colors.yellow,
    '}': colors.yellow,
    '[': colors.yellow,
    ']': colors.yellow,
    ':': colors.yellow,
    ';': colors.yellow
};

function getTokenType(_ref, index, tokens) {
    var type = _ref[0],
        value = _ref[1];

    if (type === 'word') {
        if (value[0] === '.') {
            return 'class';
        }
        if (value[0] === '#') {
            return 'hash';
        }
    }

    var nextToken = tokens[index + 1];
    if (nextToken && (nextToken[0] === 'brackets' || nextToken[0] === '(')) {
        return 'call';
    }

    return type;
}

function terminalHighlight(css) {
    var tokens = (0, _tokenize2.default)(new _input2.default(css), { ignoreErrors: true });
    return tokens.map(function (token, index) {
        var color = HIGHLIGHT_THEME[getTokenType(token, index, tokens)];
        if (color) {
            return token[1].split(/\r?\n/).map(function (i) {
                return color(i);
            }).join('\n');
        } else {
            return token[1];
        }
    }).join('');
}

exports.default = terminalHighlight;
module.exports = exports['default'];


},{"./input":758,"./tokenize":773,"chalk":751}],773:[function(require,module,exports){
'use strict';

exports.__esModule = true;
exports.default = tokenize;
var SINGLE_QUOTE = 39;
var DOUBLE_QUOTE = 34;
var BACKSLASH = 92;
var SLASH = 47;
var NEWLINE = 10;
var SPACE = 32;
var FEED = 12;
var TAB = 9;
var CR = 13;
var OPEN_SQUARE = 91;
var CLOSE_SQUARE = 93;
var OPEN_PARENTHESES = 40;
var CLOSE_PARENTHESES = 41;
var OPEN_CURLY = 123;
var CLOSE_CURLY = 125;
var SEMICOLON = 59;
var ASTERISK = 42;
var COLON = 58;
var AT = 64;

var RE_AT_END = /[ \n\t\r\f\{\(\)'"\\;/\[\]#]/g;
var RE_WORD_END = /[ \n\t\r\f\(\)\{\}:;@!'"\\\]\[#]|\/(?=\*)/g;
var RE_BAD_BRACKET = /.[\\\/\("'\n]/;

function tokenize(input) {
    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

    var tokens = [];
    var css = input.css.valueOf();

    var ignore = options.ignoreErrors;

    var code = void 0,
        next = void 0,
        quote = void 0,
        lines = void 0,
        last = void 0,
        content = void 0,
        escape = void 0,
        nextLine = void 0,
        nextOffset = void 0,
        escaped = void 0,
        escapePos = void 0,
        prev = void 0,
        n = void 0;

    var length = css.length;
    var offset = -1;
    var line = 1;
    var pos = 0;

    function unclosed(what) {
        throw input.error('Unclosed ' + what, line, pos - offset);
    }

    while (pos < length) {
        code = css.charCodeAt(pos);

        if (code === NEWLINE || code === FEED || code === CR && css.charCodeAt(pos + 1) !== NEWLINE) {
            offset = pos;
            line += 1;
        }

        switch (code) {
            case NEWLINE:
            case SPACE:
            case TAB:
            case CR:
            case FEED:
                next = pos;
                do {
                    next += 1;
                    code = css.charCodeAt(next);
                    if (code === NEWLINE) {
                        offset = next;
                        line += 1;
                    }
                } while (code === SPACE || code === NEWLINE || code === TAB || code === CR || code === FEED);

                tokens.push(['space', css.slice(pos, next)]);
                pos = next - 1;
                break;

            case OPEN_SQUARE:
                tokens.push(['[', '[', line, pos - offset]);
                break;

            case CLOSE_SQUARE:
                tokens.push([']', ']', line, pos - offset]);
                break;

            case OPEN_CURLY:
                tokens.push(['{', '{', line, pos - offset]);
                break;

            case CLOSE_CURLY:
                tokens.push(['}', '}', line, pos - offset]);
                break;

            case COLON:
                tokens.push([':', ':', line, pos - offset]);
                break;

            case SEMICOLON:
                tokens.push([';', ';', line, pos - offset]);
                break;

            case OPEN_PARENTHESES:
                prev = tokens.length ? tokens[tokens.length - 1][1] : '';
                n = css.charCodeAt(pos + 1);
                if (prev === 'url' && n !== SINGLE_QUOTE && n !== DOUBLE_QUOTE && n !== SPACE && n !== NEWLINE && n !== TAB && n !== FEED && n !== CR) {
                    next = pos;
                    do {
                        escaped = false;
                        next = css.indexOf(')', next + 1);
                        if (next === -1) {
                            if (ignore) {
                                next = pos;
                                break;
                            } else {
                                unclosed('bracket');
                            }
                        }
                        escapePos = next;
                        while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
                            escapePos -= 1;
                            escaped = !escaped;
                        }
                    } while (escaped);

                    tokens.push(['brackets', css.slice(pos, next + 1), line, pos - offset, line, next - offset]);
                    pos = next;
                } else {
                    next = css.indexOf(')', pos + 1);
                    content = css.slice(pos, next + 1);

                    if (next === -1 || RE_BAD_BRACKET.test(content)) {
                        tokens.push(['(', '(', line, pos - offset]);
                    } else {
                        tokens.push(['brackets', content, line, pos - offset, line, next - offset]);
                        pos = next;
                    }
                }

                break;

            case CLOSE_PARENTHESES:
                tokens.push([')', ')', line, pos - offset]);
                break;

            case SINGLE_QUOTE:
            case DOUBLE_QUOTE:
                quote = code === SINGLE_QUOTE ? '\'' : '"';
                next = pos;
                do {
                    escaped = false;
                    next = css.indexOf(quote, next + 1);
                    if (next === -1) {
                        if (ignore) {
                            next = pos + 1;
                            break;
                        } else {
                            unclosed('string');
                        }
                    }
                    escapePos = next;
                    while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
                        escapePos -= 1;
                        escaped = !escaped;
                    }
                } while (escaped);

                content = css.slice(pos, next + 1);
                lines = content.split('\n');
                last = lines.length - 1;

                if (last > 0) {
                    nextLine = line + last;
                    nextOffset = next - lines[last].length;
                } else {
                    nextLine = line;
                    nextOffset = offset;
                }

                tokens.push(['string', css.slice(pos, next + 1), line, pos - offset, nextLine, next - nextOffset]);

                offset = nextOffset;
                line = nextLine;
                pos = next;
                break;

            case AT:
                RE_AT_END.lastIndex = pos + 1;
                RE_AT_END.test(css);
                if (RE_AT_END.lastIndex === 0) {
                    next = css.length - 1;
                } else {
                    next = RE_AT_END.lastIndex - 2;
                }
                tokens.push(['at-word', css.slice(pos, next + 1), line, pos - offset, line, next - offset]);
                pos = next;
                break;

            case BACKSLASH:
                next = pos;
                escape = true;
                while (css.charCodeAt(next + 1) === BACKSLASH) {
                    next += 1;
                    escape = !escape;
                }
                code = css.charCodeAt(next + 1);
                if (escape && code !== SLASH && code !== SPACE && code !== NEWLINE && code !== TAB && code !== CR && code !== FEED) {
                    next += 1;
                }
                tokens.push(['word', css.slice(pos, next + 1), line, pos - offset, line, next - offset]);
                pos = next;
                break;

            default:
                if (code === SLASH && css.charCodeAt(pos + 1) === ASTERISK) {
                    next = css.indexOf('*/', pos + 2) + 1;
                    if (next === 0) {
                        if (ignore) {
                            next = css.length;
                        } else {
                            unclosed('comment');
                        }
                    }

                    content = css.slice(pos, next + 1);
                    lines = content.split('\n');
                    last = lines.length - 1;

                    if (last > 0) {
                        nextLine = line + last;
                        nextOffset = next - lines[last].length;
                    } else {
                        nextLine = line;
                        nextOffset = offset;
                    }

                    tokens.push(['comment', content, line, pos - offset, nextLine, next - nextOffset]);

                    offset = nextOffset;
                    line = nextLine;
                    pos = next;
                } else {
                    RE_WORD_END.lastIndex = pos + 1;
                    RE_WORD_END.test(css);
                    if (RE_WORD_END.lastIndex === 0) {
                        next = css.length - 1;
                    } else {
                        next = RE_WORD_END.lastIndex - 2;
                    }

                    tokens.push(['word', css.slice(pos, next + 1), line, pos - offset, line, next - offset]);
                    pos = next;
                }

                break;
        }

        pos++;
    }

    return tokens;
}
module.exports = exports['default'];


},{}],774:[function(require,module,exports){
'use strict';

exports.__esModule = true;
exports.default = warnOnce;
var printed = {};

function warnOnce(message) {
    if (printed[message]) return;
    printed[message] = true;

    if (typeof console !== 'undefined' && console.warn) console.warn(message);
}
module.exports = exports['default'];


},{}],775:[function(require,module,exports){
'use strict';

exports.__esModule = true;

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

/**
 * Represents a plugin’s warning. It can be created using {@link Node#warn}.
 *
 * @example
 * if ( decl.important ) {
 *     decl.warn(result, 'Avoid !important', { word: '!important' });
 * }
 */
var Warning = function () {

  /**
   * @param {string} text        - warning message
   * @param {Object} [opts]      - warning options
   * @param {Node}   opts.node   - CSS node that caused the warning
   * @param {string} opts.word   - word in CSS source that caused the warning
   * @param {number} opts.index  - index in CSS node string that caused
   *                               the warning
   * @param {string} opts.plugin - name of the plugin that created
   *                               this warning. {@link Result#warn} fills
   *                               this property automatically.
   */
  function Warning(text) {
    var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

    _classCallCheck(this, Warning);

    /**
     * @member {string} - Type to filter warnings from
     *                    {@link Result#messages}. Always equal
     *                    to `"warning"`.
     *
     * @example
     * const nonWarning = result.messages.filter(i => i.type !== 'warning')
     */
    this.type = 'warning';
    /**
     * @member {string} - The warning message.
     *
     * @example
     * warning.text //=> 'Try to avoid !important'
     */
    this.text = text;

    if (opts.node && opts.node.source) {
      var pos = opts.node.positionBy(opts);
      /**
       * @member {number} - Line in the input file
       *                    with this warning’s source
       *
       * @example
       * warning.line //=> 5
       */
      this.line = pos.line;
      /**
       * @member {number} - Column in the input file
       *                    with this warning’s source.
       *
       * @example
       * warning.column //=> 6
       */
      this.column = pos.column;
    }

    for (var opt in opts) {
      this[opt] = opts[opt];
    }
  }

  /**
   * Returns a warning position and message.
   *
   * @example
   * warning.toString() //=> 'postcss-lint:a.css:10:14: Avoid !important'
   *
   * @return {string} warning position and message
   */


  Warning.prototype.toString = function toString() {
    if (this.node) {
      return this.node.error(this.text, {
        plugin: this.plugin,
        index: this.index,
        word: this.word
      }).message;
    } else if (this.plugin) {
      return this.plugin + ': ' + this.text;
    } else {
      return this.text;
    }
  };

  /**
   * @memberof Warning#
   * @member {string} plugin - The name of the plugin that created
   *                           it will fill this property automatically.
   *                           this warning. When you call {@link Node#warn}
   *
   * @example
   * warning.plugin //=> 'postcss-important'
   */

  /**
   * @memberof Warning#
   * @member {Node} node - Contains the CSS node that caused the warning.
   *
   * @example
   * warning.node.toString() //=> 'color: white !important'
   */

  return Warning;
}();

exports.default = Warning;
module.exports = exports['default'];


},{}],776:[function(require,module,exports){
'use strict';
module.exports = false;

},{}],777:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = parseMedia;

var _Container = require('./nodes/Container');

var _Container2 = _interopRequireDefault(_Container);

var _parsers = require('./parsers');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Parses a media query list into an array of nodes. A typical node signature:
 *  {string} node.type -- one of: 'media-query', 'media-type', 'keyword',
 *    'media-feature-expression', 'media-feature', 'colon', 'value'
 *  {string} node.value -- the contents of a particular element, trimmed
 *    e.g.: `screen`, `max-width`, `1024px`
 *  {string} node.after -- whitespaces that follow the element
 *  {string} node.before -- whitespaces that precede the element
 *  {string} node.sourceIndex -- the index of the element in a source media
 *    query list, 0-based
 *  {object} node.parent -- a link to the parent node (a container)
 *
 * Some nodes (media queries, media feature expressions) contain other nodes.
 * They additionally have:
 *  {array} node.nodes -- an array of nodes of the type described here
 *  {funciton} node.each -- traverses direct children of the node, calling
 *    a callback for each one
 *  {funciton} node.walk -- traverses ALL descendants of the node, calling
 *    a callback for each one
 */

function parseMedia(value) {
  return new _Container2.default({
    nodes: (0, _parsers.parseMediaList)(value),
    type: 'media-query-list',
    value: value.trim()
  });
}
},{"./nodes/Container":778,"./parsers":780}],778:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _Node = require('./Node');

var _Node2 = _interopRequireDefault(_Node);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function Container(opts) {
  var _this = this;

  this.constructor(opts);

  this.nodes = opts.nodes;

  if (this.after === undefined) {
    this.after = this.nodes.length > 0 ? this.nodes[this.nodes.length - 1].after : '';
  }

  if (this.before === undefined) {
    this.before = this.nodes.length > 0 ? this.nodes[0].before : '';
  }

  if (this.sourceIndex === undefined) {
    this.sourceIndex = this.before.length;
  }

  this.nodes.forEach(function (node) {
    node.parent = _this; // eslint-disable-line no-param-reassign
  });
} /**
   * A node that contains other nodes and support traversing over them
   */

Container.prototype = Object.create(_Node2.default.prototype);
Container.constructor = _Node2.default;

/**
 * Iterate over descendant nodes of the node
 *
 * @param {RegExp|string} filter - Optional. Only nodes with node.type that
 *    satisfies the filter will be traversed over
 * @param {function} cb - callback to call on each node. Takes theese params:
 *    node - the node being processed, i - it's index, nodes - the array
 *    of all nodes
 *    If false is returned, the iteration breaks
 *
 * @return (boolean) false, if the iteration was broken
 */
Container.prototype.walk = function walk(filter, cb) {
  var hasFilter = typeof filter === 'string' || filter instanceof RegExp;
  var callback = hasFilter ? cb : filter;
  var filterReg = typeof filter === 'string' ? new RegExp(filter) : filter;

  for (var i = 0; i < this.nodes.length; i++) {
    var node = this.nodes[i];
    var filtered = hasFilter ? filterReg.test(node.type) : true;
    if (filtered && callback && callback(node, i, this.nodes) === false) {
      return false;
    }
    if (node.nodes && node.walk(filter, cb) === false) {
      return false;
    }
  }
  return true;
};

/**
 * Iterate over immediate children of the node
 *
 * @param {function} cb - callback to call on each node. Takes theese params:
 *    node - the node being processed, i - it's index, nodes - the array
 *    of all nodes
 *    If false is returned, the iteration breaks
 *
 * @return (boolean) false, if the iteration was broken
 */
Container.prototype.each = function each() {
  var cb = arguments.length <= 0 || arguments[0] === undefined ? function () {} : arguments[0];

  for (var i = 0; i < this.nodes.length; i++) {
    var node = this.nodes[i];
    if (cb(node, i, this.nodes) === false) {
      return false;
    }
  }
  return true;
};

exports.default = Container;
},{"./Node":779}],779:[function(require,module,exports){
"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
/**
 * A very generic node. Pretty much any element of a media query
 */

function Node(opts) {
  this.after = opts.after;
  this.before = opts.before;
  this.type = opts.type;
  this.value = opts.value;
  this.sourceIndex = opts.sourceIndex;
}

exports.default = Node;
},{}],780:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.parseMediaFeature = parseMediaFeature;
exports.parseMediaQuery = parseMediaQuery;
exports.parseMediaList = parseMediaList;

var _Node = require('./nodes/Node');

var _Node2 = _interopRequireDefault(_Node);

var _Container = require('./nodes/Container');

var _Container2 = _interopRequireDefault(_Container);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Parses a media feature expression, e.g. `max-width: 10px`, `(color)`
 *
 * @param {string} string - the source expression string, can be inside parens
 * @param {Number} index - the index of `string` in the overall input
 *
 * @return {Array} an array of Nodes, the first element being a media feature,
 *    the secont - its value (may be missing)
 */

function parseMediaFeature(string) {
  var index = arguments.length <= 1 || arguments[1] === undefined ? 0 : arguments[1];

  var modesEntered = [{
    mode: 'normal',
    character: null
  }];
  var result = [];
  var lastModeIndex = 0;
  var mediaFeature = '';
  var colon = null;
  var mediaFeatureValue = null;
  var indexLocal = index;

  var stringNormalized = string;
  // Strip trailing parens (if any), and correct the starting index
  if (string[0] === '(' && string[string.length - 1] === ')') {
    stringNormalized = string.substring(1, string.length - 1);
    indexLocal++;
  }

  for (var i = 0; i < stringNormalized.length; i++) {
    var character = stringNormalized[i];

    // If entering/exiting a string
    if (character === '\'' || character === '"') {
      if (modesEntered[lastModeIndex].isCalculationEnabled === true) {
        modesEntered.push({
          mode: 'string',
          isCalculationEnabled: false,
          character: character
        });
        lastModeIndex++;
      } else if (modesEntered[lastModeIndex].mode === 'string' && modesEntered[lastModeIndex].character === character && stringNormalized[i - 1] !== '\\') {
        modesEntered.pop();
        lastModeIndex--;
      }
    }

    // If entering/exiting interpolation
    if (character === '{') {
      modesEntered.push({
        mode: 'interpolation',
        isCalculationEnabled: true
      });
      lastModeIndex++;
    } else if (character === '}') {
      modesEntered.pop();
      lastModeIndex--;
    }

    // If a : is met outside of a string, function call or interpolation, than
    // this : separates a media feature and a value
    if (modesEntered[lastModeIndex].mode === 'normal' && character === ':') {
      var mediaFeatureValueStr = stringNormalized.substring(i + 1);
      mediaFeatureValue = {
        type: 'value',
        before: /^(\s*)/.exec(mediaFeatureValueStr)[1],
        after: /(\s*)$/.exec(mediaFeatureValueStr)[1],
        value: mediaFeatureValueStr.trim()
      };
      // +1 for the colon
      mediaFeatureValue.sourceIndex = mediaFeatureValue.before.length + i + 1 + indexLocal;
      colon = {
        type: 'colon',
        sourceIndex: i + indexLocal,
        after: mediaFeatureValue.before,
        value: ':' };
      break;
    }

    mediaFeature += character;
  }

  // Forming a media feature node
  mediaFeature = {
    type: 'media-feature',
    before: /^(\s*)/.exec(mediaFeature)[1],
    after: /(\s*)$/.exec(mediaFeature)[1],
    value: mediaFeature.trim()
  };
  mediaFeature.sourceIndex = mediaFeature.before.length + indexLocal;
  result.push(mediaFeature);

  if (colon !== null) {
    colon.before = mediaFeature.after;
    result.push(colon);
  }

  if (mediaFeatureValue !== null) {
    result.push(mediaFeatureValue);
  }

  return result;
}

/**
 * Parses a media query, e.g. `screen and (color)`, `only tv`
 *
 * @param {string} string - the source media query string
 * @param {Number} index - the index of `string` in the overall input
 *
 * @return {Array} an array of Nodes and Containers
 */

function parseMediaQuery(string) {
  var index = arguments.length <= 1 || arguments[1] === undefined ? 0 : arguments[1];

  var result = [];

  // How many timies the parser entered parens/curly braces
  var localLevel = 0;
  // Has any keyword, media type, media feature expression or interpolation
  // ('element' hereafter) started
  var insideSomeValue = false;
  var node = void 0;

  function resetNode() {
    return {
      before: '',
      after: '',
      value: ''
    };
  }

  node = resetNode();

  for (var i = 0; i < string.length; i++) {
    var character = string[i];
    // If not yet entered any element
    if (!insideSomeValue) {
      if (character.search(/\s/) !== -1) {
        // A whitespace
        // Don't form 'after' yet; will do it later
        node.before += character;
      } else {
        // Not a whitespace - entering an element
        // Expression start
        if (character === '(') {
          node.type = 'media-feature-expression';
          localLevel++;
        }
        node.value = character;
        node.sourceIndex = index + i;
        insideSomeValue = true;
      }
    } else {
      // Already in the middle of some alement
      node.value += character;

      // Here parens just increase localLevel and don't trigger a start of
      // a media feature expression (since they can't be nested)
      // Interpolation start
      if (character === '{' || character === '(') {
        localLevel++;
      }
      // Interpolation/function call/media feature expression end
      if (character === ')' || character === '}') {
        localLevel--;
      }
    }

    // If exited all parens/curlies and the next symbol
    if (insideSomeValue && localLevel === 0 && (character === ')' || i === string.length - 1 || string[i + 1].search(/\s/) !== -1)) {
      if (['not', 'only', 'and'].indexOf(node.value) !== -1) {
        node.type = 'keyword';
      }
      // if it's an expression, parse its contents
      if (node.type === 'media-feature-expression') {
        node.nodes = parseMediaFeature(node.value, node.sourceIndex);
      }
      result.push(Array.isArray(node.nodes) ? new _Container2.default(node) : new _Node2.default(node));
      node = resetNode();
      insideSomeValue = false;
    }
  }

  // Now process the result array - to specify undefined types of the nodes
  // and specify the `after` prop
  for (var _i = 0; _i < result.length; _i++) {
    node = result[_i];
    if (_i > 0) {
      result[_i - 1].after = node.before;
    }

    // Node types. Might not be set because contains interpolation/function
    // calls or fully consists of them
    if (node.type === undefined) {
      if (_i > 0) {
        // only `and` can follow an expression
        if (result[_i - 1].type === 'media-feature-expression') {
          node.type = 'keyword';
          continue;
        }
        // Anything after 'only|not' is a media type
        if (result[_i - 1].value === 'not' || result[_i - 1].value === 'only') {
          node.type = 'media-type';
          continue;
        }
        // Anything after 'and' is an expression
        if (result[_i - 1].value === 'and') {
          node.type = 'media-feature-expression';
          continue;
        }

        if (result[_i - 1].type === 'media-type') {
          // if it is the last element - it might be an expression
          // or 'and' depending on what is after it
          if (!result[_i + 1]) {
            node.type = 'media-feature-expression';
          } else {
            node.type = result[_i + 1].type === 'media-feature-expression' ? 'keyword' : 'media-feature-expression';
          }
        }
      }

      if (_i === 0) {
        // `screen`, `fn( ... )`, `#{ ... }`. Not an expression, since then
        // its type would have been set by now
        if (!result[_i + 1]) {
          node.type = 'media-type';
          continue;
        }

        // `screen and` or `#{...} (max-width: 10px)`
        if (result[_i + 1] && (result[_i + 1].type === 'media-feature-expression' || result[_i + 1].type === 'keyword')) {
          node.type = 'media-type';
          continue;
        }
        if (result[_i + 2]) {
          // `screen and (color) ...`
          if (result[_i + 2].type === 'media-feature-expression') {
            node.type = 'media-type';
            result[_i + 1].type = 'keyword';
            continue;
          }
          // `only screen and ...`
          if (result[_i + 2].type === 'keyword') {
            node.type = 'keyword';
            result[_i + 1].type = 'media-type';
            continue;
          }
        }
        if (result[_i + 3]) {
          // `screen and (color) ...`
          if (result[_i + 3].type === 'media-feature-expression') {
            node.type = 'keyword';
            result[_i + 1].type = 'media-type';
            result[_i + 2].type = 'keyword';
            continue;
          }
        }
      }
    }
  }
  return result;
}

/**
 * Parses a media query list. Takes a possible `url()` at the start into
 * account, and divides the list into media queries that are parsed separately
 *
 * @param {string} string - the source media query list string
 *
 * @return {Array} an array of Nodes/Containers
 */

function parseMediaList(string) {
  var result = [];
  var interimIndex = 0;
  var levelLocal = 0;

  // Check for a `url(...)` part (if it is contents of an @import rule)
  var doesHaveUrl = /^(\s*)url\s*\(/.exec(string);
  if (doesHaveUrl !== null) {
    var i = doesHaveUrl[0].length;
    var parenthesesLv = 1;
    while (parenthesesLv > 0) {
      var character = string[i];
      if (character === '(') {
        parenthesesLv++;
      }
      if (character === ')') {
        parenthesesLv--;
      }
      i++;
    }
    result.unshift(new _Node2.default({
      type: 'url',
      value: string.substring(0, i).trim(),
      sourceIndex: doesHaveUrl[1].length,
      before: doesHaveUrl[1],
      after: /^(\s*)/.exec(string.substring(i))[1]
    }));
    interimIndex = i;
  }

  // Start processing the media query list
  for (var _i2 = interimIndex; _i2 < string.length; _i2++) {
    var _character = string[_i2];

    // Dividing the media query list into comma-separated media queries
    // Only count commas that are outside of any parens
    // (i.e., not part of function call params list, etc.)
    if (_character === '(') {
      levelLocal++;
    }
    if (_character === ')') {
      levelLocal--;
    }
    if (levelLocal === 0 && _character === ',') {
      var _mediaQueryString = string.substring(interimIndex, _i2);
      var _spaceBefore = /^(\s*)/.exec(_mediaQueryString)[1];
      result.push(new _Container2.default({
        type: 'media-query',
        value: _mediaQueryString.trim(),
        sourceIndex: interimIndex + _spaceBefore.length,
        nodes: parseMediaQuery(_mediaQueryString, interimIndex),
        before: _spaceBefore,
        after: /(\s*)$/.exec(_mediaQueryString)[1]
      }));
      interimIndex = _i2 + 1;
    }
  }

  var mediaQueryString = string.substring(interimIndex);
  var spaceBefore = /^(\s*)/.exec(mediaQueryString)[1];
  result.push(new _Container2.default({
    type: 'media-query',
    value: mediaQueryString.trim(),
    sourceIndex: interimIndex + spaceBefore.length,
    nodes: parseMediaQuery(mediaQueryString, interimIndex),
    before: spaceBefore,
    after: /(\s*)$/.exec(mediaQueryString)[1]
  }));

  return result;
}
},{"./nodes/Container":778,"./nodes/Node":779}],781:[function(require,module,exports){
var _ = require('lodash');

exports.getLocation = function(message) {
  var messageNode = message.node;

  var location = {
    line: message.line,
    column: message.column,
  };

  var messageInput = _.get(messageNode, 'source.input');

  if (!messageInput) return location;

  var originLocation = messageInput.origin && messageInput.origin(message.line, message.column)
  if (originLocation) return originLocation

  location.file = messageInput.file || messageInput.id;
  return location;
};

},{"lodash":692}],782:[function(require,module,exports){
module.exports = function resolveNestedSelector(selector, node) {
  var parent = node.parent;
  var parentIsNestAtRule = parent.type === 'atrule' && parent.name === 'nest';

  if (parent.type === 'root') return [selector];
  if (parent.type !== 'rule' && !parentIsNestAtRule) return resolveNestedSelector(selector, parent);

  var parentSelectors = (parentIsNestAtRule)
    ? parent.params.split(',').map(function(s) { return s.trim(); })
    : parent.selectors;

  var resolvedSelectors = parentSelectors.reduce(function(result, parentSelector) {
    if (selector.indexOf('&') !== -1) {
      var newlyResolvedSelectors = resolveNestedSelector(parentSelector, parent).map(function(resolvedParentSelector) {
        return selector.replace(/&/g, resolvedParentSelector);
      });
      return result.concat(newlyResolvedSelectors);
    }

    var combinedSelector = [ parentSelector, selector ].join(' ');
    return result.concat(resolveNestedSelector(combinedSelector, parent));
  }, []);

  return resolvedSelectors;
}

},{}],783:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _container = require('postcss/lib/container');

var _container2 = _interopRequireDefault(_container);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var NestedDeclaration = function (_Container) {
    _inherits(NestedDeclaration, _Container);

    function NestedDeclaration(defaults) {
        _classCallCheck(this, NestedDeclaration);

        var _this = _possibleConstructorReturn(this, _Container.call(this, defaults));

        _this.type = 'decl';
        _this.isNested = true;
        if (!_this.nodes) _this.nodes = [];
        return _this;
    }

    return NestedDeclaration;
}(_container2.default);

exports.default = NestedDeclaration;
module.exports = exports['default'];


},{"postcss/lib/container":818}],784:[function(require,module,exports){
'use strict';

exports.__esModule = true;
exports.default = scssParse;

var _input = require('postcss/lib/input');

var _input2 = _interopRequireDefault(_input);

var _scssParser = require('./scss-parser');

var _scssParser2 = _interopRequireDefault(_scssParser);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function scssParse(scss, opts) {
    var input = new _input2.default(scss, opts);

    var parser = new _scssParser2.default(input);
    parser.parse();

    return parser.root;
}
module.exports = exports['default'];


},{"./scss-parser":785,"postcss/lib/input":821}],785:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _comment = require('postcss/lib/comment');

var _comment2 = _interopRequireDefault(_comment);

var _parser = require('postcss/lib/parser');

var _parser2 = _interopRequireDefault(_parser);

var _nestedDeclaration = require('./nested-declaration');

var _nestedDeclaration2 = _interopRequireDefault(_nestedDeclaration);

var _scssTokenize = require('./scss-tokenize');

var _scssTokenize2 = _interopRequireDefault(_scssTokenize);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var ScssParser = function (_Parser) {
    _inherits(ScssParser, _Parser);

    function ScssParser() {
        _classCallCheck(this, ScssParser);

        return _possibleConstructorReturn(this, _Parser.apply(this, arguments));
    }

    ScssParser.prototype.createTokenizer = function createTokenizer() {
        this.tokenizer = (0, _scssTokenize2.default)(this.input);
    };

    ScssParser.prototype.rule = function rule(tokens) {
        var withColon = false;
        var brackets = 0;
        var value = '';
        for (var _iterator = tokens, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
            var _ref;

            if (_isArray) {
                if (_i >= _iterator.length) break;
                _ref = _iterator[_i++];
            } else {
                _i = _iterator.next();
                if (_i.done) break;
                _ref = _i.value;
            }

            var i = _ref;

            if (withColon) {
                if (i[0] !== 'comment' && i[0] !== '{') {
                    value += i[1];
                }
            } else if (i[0] === 'space' && i[1].indexOf('\n') !== -1) {
                break;
            } else if (i[0] === '(') {
                brackets += 1;
            } else if (i[0] === ')') {
                brackets -= 1;
            } else if (brackets === 0 && i[0] === ':') {
                withColon = true;
            }
        }

        if (!withColon || value.trim() === '' || /^[a-zA-Z-:#]/.test(value)) {
            _Parser.prototype.rule.call(this, tokens);
        } else {

            tokens.pop();
            var node = new _nestedDeclaration2.default();
            this.init(node);

            var last = tokens[tokens.length - 1];
            if (last[4]) {
                node.source.end = { line: last[4], column: last[5] };
            } else {
                node.source.end = { line: last[2], column: last[3] };
            }

            while (tokens[0][0] !== 'word') {
                node.raws.before += tokens.shift()[1];
            }
            node.source.start = { line: tokens[0][2], column: tokens[0][3] };

            node.prop = '';
            while (tokens.length) {
                var type = tokens[0][0];
                if (type === ':' || type === 'space' || type === 'comment') {
                    break;
                }
                node.prop += tokens.shift()[1];
            }

            node.raws.between = '';

            var token = void 0;
            while (tokens.length) {
                token = tokens.shift();

                if (token[0] === ':') {
                    node.raws.between += token[1];
                    break;
                } else {
                    node.raws.between += token[1];
                }
            }

            if (node.prop[0] === '_' || node.prop[0] === '*') {
                node.raws.before += node.prop[0];
                node.prop = node.prop.slice(1);
            }
            node.raws.between += this.spacesAndCommentsFromStart(tokens);
            this.precheckMissedSemicolon(tokens);

            for (var _i2 = tokens.length - 1; _i2 > 0; _i2--) {
                token = tokens[_i2];
                if (token[1] === '!important') {
                    node.important = true;
                    var string = this.stringFrom(tokens, _i2);
                    string = this.spacesFromEnd(tokens) + string;
                    if (string !== ' !important') {
                        node.raws.important = string;
                    }
                    break;
                } else if (token[1] === 'important') {
                    var cache = tokens.slice(0);
                    var str = '';
                    for (var j = _i2; j > 0; j--) {
                        var _type = cache[j][0];
                        if (str.trim().indexOf('!') === 0 && _type !== 'space') {
                            break;
                        }
                        str = cache.pop()[1] + str;
                    }
                    if (str.trim().indexOf('!') === 0) {
                        node.important = true;
                        node.raws.important = str;
                        tokens = cache;
                    }
                }

                if (token[0] !== 'space' && token[0] !== 'comment') {
                    break;
                }
            }

            this.raw(node, 'value', tokens);

            if (node.value.indexOf(':') !== -1) {
                this.checkMissedSemicolon(tokens);
            }

            this.current = node;
        }
    };

    ScssParser.prototype.comment = function comment(token) {
        if (token[6] === 'inline') {
            var node = new _comment2.default();
            this.init(node, token[2], token[3]);
            node.raws.inline = true;
            node.source.end = { line: token[4], column: token[5] };

            var text = token[1].slice(2);
            if (/^\s*$/.test(text)) {
                node.text = '';
                node.raws.left = text;
                node.raws.right = '';
            } else {
                var match = text.match(/^(\s*)([^]*[^\s])(\s*)$/);
                var fixed = match[2].replace(/(\*\/|\/\*)/g, '*//*');
                node.text = fixed;
                node.raws.left = match[1];
                node.raws.right = match[3];
                node.raws.text = match[2];
            }
        } else {
            _Parser.prototype.comment.call(this, token);
        }
    };

    return ScssParser;
}(_parser2.default);

exports.default = ScssParser;
module.exports = exports['default'];


},{"./nested-declaration":783,"./scss-tokenize":789,"postcss/lib/comment":817,"postcss/lib/parser":827}],786:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _stringifier = require('postcss/lib/stringifier');

var _stringifier2 = _interopRequireDefault(_stringifier);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var ScssStringifier = function (_Stringifier) {
    _inherits(ScssStringifier, _Stringifier);

    function ScssStringifier() {
        _classCallCheck(this, ScssStringifier);

        return _possibleConstructorReturn(this, _Stringifier.apply(this, arguments));
    }

    ScssStringifier.prototype.comment = function comment(node) {
        var left = this.raw(node, 'left', 'commentLeft');
        var right = this.raw(node, 'right', 'commentRight');

        if (node.raws.inline) {
            var text = node.raws.text || node.text;
            this.builder('//' + left + text + right, node);
        } else {
            this.builder('/*' + left + node.text + right + '*/', node);
        }
    };

    ScssStringifier.prototype.decl = function decl(node, semicolon) {
        if (!node.isNested) {
            _Stringifier.prototype.decl.call(this, node, semicolon);
        } else {

            var between = this.raw(node, 'between', 'colon');
            var string = node.prop + between + this.rawValue(node, 'value');
            if (node.important) {
                string += node.raws.important || ' !important';
            }

            this.builder(string + '{', node, 'start');

            var after = void 0;
            if (node.nodes && node.nodes.length) {
                this.body(node);
                after = this.raw(node, 'after');
            } else {
                after = this.raw(node, 'after', 'emptyBody');
            }
            if (after) this.builder(after);
            this.builder('}', node, 'end');
        }
    };

    return ScssStringifier;
}(_stringifier2.default);

exports.default = ScssStringifier;
module.exports = exports['default'];


},{"postcss/lib/stringifier":834}],787:[function(require,module,exports){
'use strict';

exports.__esModule = true;
exports.default = scssStringify;

var _scssStringifier = require('./scss-stringifier');

var _scssStringifier2 = _interopRequireDefault(_scssStringifier);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function scssStringify(node, builder) {
    var str = new _scssStringifier2.default(builder);
    str.stringify(node);
}
module.exports = exports['default'];


},{"./scss-stringifier":786}],788:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _scssStringify = require('./scss-stringify');

var _scssStringify2 = _interopRequireDefault(_scssStringify);

var _scssParse = require('./scss-parse');

var _scssParse2 = _interopRequireDefault(_scssParse);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = { parse: _scssParse2.default, stringify: _scssStringify2.default };
module.exports = exports['default'];


},{"./scss-parse":784,"./scss-stringify":787}],789:[function(require,module,exports){
'use strict';

exports.__esModule = true;
exports.default = scssTokenize;
var SINGLE_QUOTE = 39;
var DOUBLE_QUOTE = 34;
var BACKSLASH = 92;
var SLASH = 47;
var NEWLINE = 10;
var SPACE = 32;
var FEED = 12;
var TAB = 9;
var CR = 13;
var OPEN_SQUARE = 91;
var CLOSE_SQUARE = 93;
var OPEN_PARENTHESES = 40;
var CLOSE_PARENTHESES = 41;
var OPEN_CURLY = 123;
var CLOSE_CURLY = 125;
var SEMICOLON = 59;
var ASTERISK = 42;
var COLON = 58;
var AT = 64;

// SCSS PATCH {
var COMMA = 44;
var HASH = 35;
// } SCSS PATCH

var RE_AT_END = /[ \n\t\r\f\{\(\)'"\\;/\[\]#]/g;
var RE_WORD_END = /[ \n\t\r\f\(\)\{\}:;@!'"\\\]\[#]|\/(?=\*)/g;
var RE_BAD_BRACKET = /.[\\\/\("'\n]/;
var RE_HEX_ESCAPE = /[a-f0-9]/i;

var RE_NEW_LINE = /[\r\f\n]/g; // SCSS PATCH

// SCSS PATCH function name was changed
function scssTokenize(input) {
    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

    var css = input.css.valueOf();
    var ignore = options.ignoreErrors;

    var code = void 0,
        next = void 0,
        quote = void 0,
        lines = void 0,
        last = void 0,
        content = void 0,
        escape = void 0,
        nextLine = void 0,
        nextOffset = void 0,
        escaped = void 0,
        escapePos = void 0,
        prev = void 0,
        n = void 0,
        currentToken = void 0;

    var brackets = void 0; // SCSS PATCH

    var length = css.length;
    var offset = -1;
    var line = 1;
    var pos = 0;
    var buffer = [];
    var returned = [];

    function unclosed(what) {
        throw input.error('Unclosed ' + what, line, pos - offset);
    }

    function endOfFile() {
        return returned.length === 0 && pos >= length;
    }

    function nextToken() {
        if (returned.length) return returned.pop();
        if (pos >= length) return;

        code = css.charCodeAt(pos);
        if (code === NEWLINE || code === FEED || code === CR && css.charCodeAt(pos + 1) !== NEWLINE) {
            offset = pos;
            line += 1;
        }

        switch (code) {
            case NEWLINE:
            case SPACE:
            case TAB:
            case CR:
            case FEED:
                next = pos;
                do {
                    next += 1;
                    code = css.charCodeAt(next);
                    if (code === NEWLINE) {
                        offset = next;
                        line += 1;
                    }
                } while (code === SPACE || code === NEWLINE || code === TAB || code === CR || code === FEED);

                currentToken = ['space', css.slice(pos, next)];
                pos = next - 1;
                break;

            case OPEN_SQUARE:
                currentToken = ['[', '[', line, pos - offset];
                break;

            case CLOSE_SQUARE:
                currentToken = [']', ']', line, pos - offset];
                break;

            case OPEN_CURLY:
                currentToken = ['{', '{', line, pos - offset];
                break;

            case CLOSE_CURLY:
                currentToken = ['}', '}', line, pos - offset];
                break;

            // SCSS PATCH {
            case COMMA:
                currentToken = ['word', ',', line, pos - offset, line, pos - offset + 1];
                break;
            // } SCSS PATCH

            case COLON:
                currentToken = [':', ':', line, pos - offset];
                break;

            case SEMICOLON:
                currentToken = [';', ';', line, pos - offset];
                break;

            case OPEN_PARENTHESES:
                prev = buffer.length ? buffer.pop()[1] : '';
                n = css.charCodeAt(pos + 1);
                if (prev === 'url' && n !== SINGLE_QUOTE && n !== DOUBLE_QUOTE && n !== SPACE && n !== NEWLINE && n !== TAB && n !== FEED && n !== CR) {
                    // SCSS PATCH {
                    brackets = 1;
                    escaped = false;
                    next = pos + 1;
                    while (next <= css.length - 1) {
                        n = css.charCodeAt(next);
                        if (n === BACKSLASH) {
                            escaped = !escaped;
                        } else if (n === OPEN_PARENTHESES) {
                            brackets += 1;
                        } else if (n === CLOSE_PARENTHESES) {
                            brackets -= 1;
                            if (brackets === 0) break;
                        }
                        next += 1;
                    }

                    content = css.slice(pos, next + 1);
                    lines = content.split('\n');
                    last = lines.length - 1;

                    if (last > 0) {
                        nextLine = line + last;
                        nextOffset = next - lines[last].length;
                    } else {
                        nextLine = line;
                        nextOffset = offset;
                    }

                    currentToken = ['brackets', content, line, pos - offset, nextLine, next - nextOffset];

                    offset = nextOffset;
                    line = nextLine;
                    pos = next;
                    // } SCSS PATCH
                } else {
                    next = css.indexOf(')', pos + 1);
                    content = css.slice(pos, next + 1);

                    if (next === -1 || RE_BAD_BRACKET.test(content)) {
                        currentToken = ['(', '(', line, pos - offset];
                    } else {
                        currentToken = ['brackets', content, line, pos - offset, line, next - offset];
                        pos = next;
                    }
                }

                break;

            case CLOSE_PARENTHESES:
                currentToken = [')', ')', line, pos - offset];
                break;

            case SINGLE_QUOTE:
            case DOUBLE_QUOTE:
                quote = code === SINGLE_QUOTE ? '\'' : '"';
                next = pos;
                do {
                    escaped = false;
                    next = css.indexOf(quote, next + 1);
                    if (next === -1) {
                        if (ignore) {
                            next = pos + 1;
                            break;
                        } else {
                            unclosed('string');
                        }
                    }
                    escapePos = next;
                    while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
                        escapePos -= 1;
                        escaped = !escaped;
                    }
                } while (escaped);

                content = css.slice(pos, next + 1);
                lines = content.split('\n');
                last = lines.length - 1;

                if (last > 0) {
                    nextLine = line + last;
                    nextOffset = next - lines[last].length;
                } else {
                    nextLine = line;
                    nextOffset = offset;
                }

                currentToken = ['string', css.slice(pos, next + 1), line, pos - offset, nextLine, next - nextOffset];

                offset = nextOffset;
                line = nextLine;
                pos = next;
                break;

            case AT:
                RE_AT_END.lastIndex = pos + 1;
                RE_AT_END.test(css);
                if (RE_AT_END.lastIndex === 0) {
                    next = css.length - 1;
                } else {
                    next = RE_AT_END.lastIndex - 2;
                }

                currentToken = ['at-word', css.slice(pos, next + 1), line, pos - offset, line, next - offset];

                pos = next;
                break;

            case BACKSLASH:
                next = pos;
                escape = true;
                while (css.charCodeAt(next + 1) === BACKSLASH) {
                    next += 1;
                    escape = !escape;
                }
                code = css.charCodeAt(next + 1);
                if (escape && code !== SLASH && code !== SPACE && code !== NEWLINE && code !== TAB && code !== CR && code !== FEED) {
                    next += 1;
                    if (RE_HEX_ESCAPE.test(css.charAt(next))) {
                        while (RE_HEX_ESCAPE.test(css.charAt(next + 1))) {
                            next += 1;
                        }
                        if (css.charCodeAt(next + 1) === SPACE) {
                            next += 1;
                        }
                    }
                }

                currentToken = ['word', css.slice(pos, next + 1), line, pos - offset, line, next - offset];

                pos = next;
                break;

            default:
                // SCSS PATCH {
                n = css.charCodeAt(pos + 1);

                if (code === HASH && n === OPEN_CURLY) {
                    var deep = 1;
                    next = pos;
                    while (deep > 0) {
                        next += 1;
                        if (css.length <= next) unclosed('interpolation');

                        code = css.charCodeAt(next);
                        n = css.charCodeAt(next + 1);

                        if (code === CLOSE_CURLY) {
                            deep -= 1;
                        } else if (code === HASH && n === OPEN_CURLY) {
                            deep += 1;
                        }
                    }

                    content = css.slice(pos, next + 1);
                    lines = content.split('\n');
                    last = lines.length - 1;

                    if (last > 0) {
                        nextLine = line + last;
                        nextOffset = next - lines[last].length;
                    } else {
                        nextLine = line;
                        nextOffset = offset;
                    }

                    currentToken = ['word', content, line, pos - offset, nextLine, next - nextOffset];

                    offset = nextOffset;
                    line = nextLine;
                    pos = next;
                } else if (code === SLASH && n === ASTERISK) {
                    // } SCSS PATCH
                    next = css.indexOf('*/', pos + 2) + 1;
                    if (next === 0) {
                        if (ignore) {
                            next = css.length;
                        } else {
                            unclosed('comment');
                        }
                    }

                    content = css.slice(pos, next + 1);
                    lines = content.split('\n');
                    last = lines.length - 1;

                    if (last > 0) {
                        nextLine = line + last;
                        nextOffset = next - lines[last].length;
                    } else {
                        nextLine = line;
                        nextOffset = offset;
                    }

                    currentToken = ['comment', content, line, pos - offset, nextLine, next - nextOffset];

                    offset = nextOffset;
                    line = nextLine;
                    pos = next;

                    // SCSS PATCH {
                } else if (code === SLASH && n === SLASH) {
                    RE_NEW_LINE.lastIndex = pos + 1;
                    RE_NEW_LINE.test(css);
                    if (RE_NEW_LINE.lastIndex === 0) {
                        next = css.length - 1;
                    } else {
                        next = RE_NEW_LINE.lastIndex - 2;
                    }

                    content = css.slice(pos, next + 1);

                    currentToken = ['comment', content, line, pos - offset, line, next - offset, 'inline'];

                    pos = next;
                    // } SCSS PATCH
                } else {
                    RE_WORD_END.lastIndex = pos + 1;
                    RE_WORD_END.test(css);
                    if (RE_WORD_END.lastIndex === 0) {
                        next = css.length - 1;
                    } else {
                        next = RE_WORD_END.lastIndex - 2;
                    }

                    currentToken = ['word', css.slice(pos, next + 1), line, pos - offset, line, next - offset];

                    buffer.push(currentToken);

                    pos = next;
                }

                break;
        }

        pos++;
        return currentToken;
    }

    function back(token) {
        returned.push(token);
    }

    return {
        back: back,
        nextToken: nextToken,
        endOfFile: endOfFile
    };
}
module.exports = exports['default'];


},{}],790:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _processor = require('./processor');

var _processor2 = _interopRequireDefault(_processor);

var _attribute = require('./selectors/attribute');

var _attribute2 = _interopRequireDefault(_attribute);

var _className = require('./selectors/className');

var _className2 = _interopRequireDefault(_className);

var _combinator = require('./selectors/combinator');

var _combinator2 = _interopRequireDefault(_combinator);

var _comment = require('./selectors/comment');

var _comment2 = _interopRequireDefault(_comment);

var _id = require('./selectors/id');

var _id2 = _interopRequireDefault(_id);

var _nesting = require('./selectors/nesting');

var _nesting2 = _interopRequireDefault(_nesting);

var _pseudo = require('./selectors/pseudo');

var _pseudo2 = _interopRequireDefault(_pseudo);

var _root = require('./selectors/root');

var _root2 = _interopRequireDefault(_root);

var _selector = require('./selectors/selector');

var _selector2 = _interopRequireDefault(_selector);

var _string = require('./selectors/string');

var _string2 = _interopRequireDefault(_string);

var _tag = require('./selectors/tag');

var _tag2 = _interopRequireDefault(_tag);

var _universal = require('./selectors/universal');

var _universal2 = _interopRequireDefault(_universal);

var _types = require('./selectors/types');

var types = _interopRequireWildcard(_types);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var parser = function parser(processor) {
    return new _processor2.default(processor);
};

parser.attribute = function (opts) {
    return new _attribute2.default(opts);
};
parser.className = function (opts) {
    return new _className2.default(opts);
};
parser.combinator = function (opts) {
    return new _combinator2.default(opts);
};
parser.comment = function (opts) {
    return new _comment2.default(opts);
};
parser.id = function (opts) {
    return new _id2.default(opts);
};
parser.nesting = function (opts) {
    return new _nesting2.default(opts);
};
parser.pseudo = function (opts) {
    return new _pseudo2.default(opts);
};
parser.root = function (opts) {
    return new _root2.default(opts);
};
parser.selector = function (opts) {
    return new _selector2.default(opts);
};
parser.string = function (opts) {
    return new _string2.default(opts);
};
parser.tag = function (opts) {
    return new _tag2.default(opts);
};
parser.universal = function (opts) {
    return new _universal2.default(opts);
};

Object.keys(types).forEach(function (type) {
    if (type === '__esModule') {
        return;
    }
    parser[type] = types[type]; // eslint-disable-line
});

exports.default = parser;
module.exports = exports['default'];
},{"./processor":792,"./selectors/attribute":793,"./selectors/className":794,"./selectors/combinator":795,"./selectors/comment":796,"./selectors/id":798,"./selectors/nesting":800,"./selectors/pseudo":802,"./selectors/root":803,"./selectors/selector":804,"./selectors/string":805,"./selectors/tag":806,"./selectors/types":807,"./selectors/universal":808}],791:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _flatten = require('flatten');

var _flatten2 = _interopRequireDefault(_flatten);

var _indexesOf = require('indexes-of');

var _indexesOf2 = _interopRequireDefault(_indexesOf);

var _uniq = require('uniq');

var _uniq2 = _interopRequireDefault(_uniq);

var _root = require('./selectors/root');

var _root2 = _interopRequireDefault(_root);

var _selector = require('./selectors/selector');

var _selector2 = _interopRequireDefault(_selector);

var _className = require('./selectors/className');

var _className2 = _interopRequireDefault(_className);

var _comment = require('./selectors/comment');

var _comment2 = _interopRequireDefault(_comment);

var _id = require('./selectors/id');

var _id2 = _interopRequireDefault(_id);

var _tag = require('./selectors/tag');

var _tag2 = _interopRequireDefault(_tag);

var _string = require('./selectors/string');

var _string2 = _interopRequireDefault(_string);

var _pseudo = require('./selectors/pseudo');

var _pseudo2 = _interopRequireDefault(_pseudo);

var _attribute = require('./selectors/attribute');

var _attribute2 = _interopRequireDefault(_attribute);

var _universal = require('./selectors/universal');

var _universal2 = _interopRequireDefault(_universal);

var _combinator = require('./selectors/combinator');

var _combinator2 = _interopRequireDefault(_combinator);

var _nesting = require('./selectors/nesting');

var _nesting2 = _interopRequireDefault(_nesting);

var _sortAscending = require('./sortAscending');

var _sortAscending2 = _interopRequireDefault(_sortAscending);

var _tokenize = require('./tokenize');

var _tokenize2 = _interopRequireDefault(_tokenize);

var _types = require('./selectors/types');

var types = _interopRequireWildcard(_types);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Parser = function () {
    function Parser(input) {
        _classCallCheck(this, Parser);

        this.input = input;
        this.lossy = input.options.lossless === false;
        this.position = 0;
        this.root = new _root2.default();

        var selectors = new _selector2.default();
        this.root.append(selectors);

        this.current = selectors;
        if (this.lossy) {
            this.tokens = (0, _tokenize2.default)({ safe: input.safe, css: input.css.trim() });
        } else {
            this.tokens = (0, _tokenize2.default)(input);
        }

        return this.loop();
    }

    Parser.prototype.attribute = function attribute() {
        var str = '';
        var attr = void 0;
        var startingToken = this.currToken;
        this.position++;
        while (this.position < this.tokens.length && this.currToken[0] !== ']') {
            str += this.tokens[this.position][1];
            this.position++;
        }
        if (this.position === this.tokens.length && !~str.indexOf(']')) {
            this.error('Expected a closing square bracket.');
        }
        var parts = str.split(/((?:[*~^$|]?=))([^]*)/);
        var namespace = parts[0].split(/(\|)/g);
        var attributeProps = {
            operator: parts[1],
            value: parts[2],
            source: {
                start: {
                    line: startingToken[2],
                    column: startingToken[3]
                },
                end: {
                    line: this.currToken[2],
                    column: this.currToken[3]
                }
            },
            sourceIndex: startingToken[4]
        };
        if (namespace.length > 1) {
            if (namespace[0] === '') {
                namespace[0] = true;
            }
            attributeProps.attribute = this.parseValue(namespace[2]);
            attributeProps.namespace = this.parseNamespace(namespace[0]);
        } else {
            attributeProps.attribute = this.parseValue(parts[0]);
        }
        attr = new _attribute2.default(attributeProps);

        if (parts[2]) {
            var insensitive = parts[2].split(/(\s+i\s*?)$/);
            var trimmedValue = insensitive[0].trim();
            attr.value = this.lossy ? trimmedValue : insensitive[0];
            if (insensitive[1]) {
                attr.insensitive = true;
                if (!this.lossy) {
                    attr.raws.insensitive = insensitive[1];
                }
            }
            attr.quoted = trimmedValue[0] === '\'' || trimmedValue[0] === '"';
            attr.raws.unquoted = attr.quoted ? trimmedValue.slice(1, -1) : trimmedValue;
        }
        this.newNode(attr);
        this.position++;
    };

    Parser.prototype.combinator = function combinator() {
        if (this.currToken[1] === '|') {
            return this.namespace();
        }
        var node = new _combinator2.default({
            value: '',
            source: {
                start: {
                    line: this.currToken[2],
                    column: this.currToken[3]
                },
                end: {
                    line: this.currToken[2],
                    column: this.currToken[3]
                }
            },
            sourceIndex: this.currToken[4]
        });
        while (this.position < this.tokens.length && this.currToken && (this.currToken[0] === 'space' || this.currToken[0] === 'combinator')) {
            if (this.nextToken && this.nextToken[0] === 'combinator') {
                node.spaces.before = this.parseSpace(this.currToken[1]);
                node.source.start.line = this.nextToken[2];
                node.source.start.column = this.nextToken[3];
                node.source.end.column = this.nextToken[3];
                node.source.end.line = this.nextToken[2];
                node.sourceIndex = this.nextToken[4];
            } else if (this.prevToken && this.prevToken[0] === 'combinator') {
                node.spaces.after = this.parseSpace(this.currToken[1]);
            } else if (this.currToken[0] === 'combinator') {
                node.value = this.currToken[1];
            } else if (this.currToken[0] === 'space') {
                node.value = this.parseSpace(this.currToken[1], ' ');
            }
            this.position++;
        }
        return this.newNode(node);
    };

    Parser.prototype.comma = function comma() {
        if (this.position === this.tokens.length - 1) {
            this.root.trailingComma = true;
            this.position++;
            return;
        }
        var selectors = new _selector2.default();
        this.current.parent.append(selectors);
        this.current = selectors;
        this.position++;
    };

    Parser.prototype.comment = function comment() {
        var node = new _comment2.default({
            value: this.currToken[1],
            source: {
                start: {
                    line: this.currToken[2],
                    column: this.currToken[3]
                },
                end: {
                    line: this.currToken[4],
                    column: this.currToken[5]
                }
            },
            sourceIndex: this.currToken[6]
        });
        this.newNode(node);
        this.position++;
    };

    Parser.prototype.error = function error(message) {
        throw new this.input.error(message); // eslint-disable-line new-cap
    };

    Parser.prototype.missingBackslash = function missingBackslash() {
        return this.error('Expected a backslash preceding the semicolon.');
    };

    Parser.prototype.missingParenthesis = function missingParenthesis() {
        return this.error('Expected opening parenthesis.');
    };

    Parser.prototype.missingSquareBracket = function missingSquareBracket() {
        return this.error('Expected opening square bracket.');
    };

    Parser.prototype.namespace = function namespace() {
        var before = this.prevToken && this.prevToken[1] || true;
        if (this.nextToken[0] === 'word') {
            this.position++;
            return this.word(before);
        } else if (this.nextToken[0] === '*') {
            this.position++;
            return this.universal(before);
        }
    };

    Parser.prototype.nesting = function nesting() {
        this.newNode(new _nesting2.default({
            value: this.currToken[1],
            source: {
                start: {
                    line: this.currToken[2],
                    column: this.currToken[3]
                },
                end: {
                    line: this.currToken[2],
                    column: this.currToken[3]
                }
            },
            sourceIndex: this.currToken[4]
        }));
        this.position++;
    };

    Parser.prototype.parentheses = function parentheses() {
        var last = this.current.last;
        if (last && last.type === types.PSEUDO) {
            var selector = new _selector2.default();
            var cache = this.current;
            last.append(selector);
            this.current = selector;
            var balanced = 1;
            this.position++;
            while (this.position < this.tokens.length && balanced) {
                if (this.currToken[0] === '(') {
                    balanced++;
                }
                if (this.currToken[0] === ')') {
                    balanced--;
                }
                if (balanced) {
                    this.parse();
                } else {
                    selector.parent.source.end.line = this.currToken[2];
                    selector.parent.source.end.column = this.currToken[3];
                    this.position++;
                }
            }
            if (balanced) {
                this.error('Expected closing parenthesis.');
            }
            this.current = cache;
        } else {
            var _balanced = 1;
            this.position++;
            last.value += '(';
            while (this.position < this.tokens.length && _balanced) {
                if (this.currToken[0] === '(') {
                    _balanced++;
                }
                if (this.currToken[0] === ')') {
                    _balanced--;
                }
                last.value += this.parseParenthesisToken(this.currToken);
                this.position++;
            }
            if (_balanced) {
                this.error('Expected closing parenthesis.');
            }
        }
    };

    Parser.prototype.pseudo = function pseudo() {
        var _this = this;

        var pseudoStr = '';
        var startingToken = this.currToken;
        while (this.currToken && this.currToken[0] === ':') {
            pseudoStr += this.currToken[1];
            this.position++;
        }
        if (!this.currToken) {
            return this.error('Expected pseudo-class or pseudo-element');
        }
        if (this.currToken[0] === 'word') {
            var pseudo = void 0;
            this.splitWord(false, function (first, length) {
                pseudoStr += first;
                pseudo = new _pseudo2.default({
                    value: pseudoStr,
                    source: {
                        start: {
                            line: startingToken[2],
                            column: startingToken[3]
                        },
                        end: {
                            line: _this.currToken[4],
                            column: _this.currToken[5]
                        }
                    },
                    sourceIndex: startingToken[4]
                });
                _this.newNode(pseudo);
                if (length > 1 && _this.nextToken && _this.nextToken[0] === '(') {
                    _this.error('Misplaced parenthesis.');
                }
            });
        } else {
            this.error('Unexpected "' + this.currToken[0] + '" found.');
        }
    };

    Parser.prototype.space = function space() {
        var token = this.currToken;
        // Handle space before and after the selector
        if (this.position === 0 || this.prevToken[0] === ',' || this.prevToken[0] === '(') {
            this.spaces = this.parseSpace(token[1]);
            this.position++;
        } else if (this.position === this.tokens.length - 1 || this.nextToken[0] === ',' || this.nextToken[0] === ')') {
            this.current.last.spaces.after = this.parseSpace(token[1]);
            this.position++;
        } else {
            this.combinator();
        }
    };

    Parser.prototype.string = function string() {
        var token = this.currToken;
        this.newNode(new _string2.default({
            value: this.currToken[1],
            source: {
                start: {
                    line: token[2],
                    column: token[3]
                },
                end: {
                    line: token[4],
                    column: token[5]
                }
            },
            sourceIndex: token[6]
        }));
        this.position++;
    };

    Parser.prototype.universal = function universal(namespace) {
        var nextToken = this.nextToken;
        if (nextToken && nextToken[1] === '|') {
            this.position++;
            return this.namespace();
        }
        this.newNode(new _universal2.default({
            value: this.currToken[1],
            source: {
                start: {
                    line: this.currToken[2],
                    column: this.currToken[3]
                },
                end: {
                    line: this.currToken[2],
                    column: this.currToken[3]
                }
            },
            sourceIndex: this.currToken[4]
        }), namespace);
        this.position++;
    };

    Parser.prototype.splitWord = function splitWord(namespace, firstCallback) {
        var _this2 = this;

        var nextToken = this.nextToken;
        var word = this.currToken[1];
        while (nextToken && nextToken[0] === 'word') {
            this.position++;
            var current = this.currToken[1];
            word += current;
            if (current.lastIndexOf('\\') === current.length - 1) {
                var next = this.nextToken;
                if (next && next[0] === 'space') {
                    word += this.parseSpace(next[1], ' ');
                    this.position++;
                }
            }
            nextToken = this.nextToken;
        }
        var hasClass = (0, _indexesOf2.default)(word, '.');
        var hasId = (0, _indexesOf2.default)(word, '#');
        // Eliminate Sass interpolations from the list of id indexes
        var interpolations = (0, _indexesOf2.default)(word, '#{');
        if (interpolations.length) {
            hasId = hasId.filter(function (hashIndex) {
                return !~interpolations.indexOf(hashIndex);
            });
        }
        var indices = (0, _sortAscending2.default)((0, _uniq2.default)((0, _flatten2.default)([[0], hasClass, hasId])));
        indices.forEach(function (ind, i) {
            var index = indices[i + 1] || word.length;
            var value = word.slice(ind, index);
            if (i === 0 && firstCallback) {
                return firstCallback.call(_this2, value, indices.length);
            }
            var node = void 0;
            if (~hasClass.indexOf(ind)) {
                node = new _className2.default({
                    value: value.slice(1),
                    source: {
                        start: {
                            line: _this2.currToken[2],
                            column: _this2.currToken[3] + ind
                        },
                        end: {
                            line: _this2.currToken[4],
                            column: _this2.currToken[3] + (index - 1)
                        }
                    },
                    sourceIndex: _this2.currToken[6] + indices[i]
                });
            } else if (~hasId.indexOf(ind)) {
                node = new _id2.default({
                    value: value.slice(1),
                    source: {
                        start: {
                            line: _this2.currToken[2],
                            column: _this2.currToken[3] + ind
                        },
                        end: {
                            line: _this2.currToken[4],
                            column: _this2.currToken[3] + (index - 1)
                        }
                    },
                    sourceIndex: _this2.currToken[6] + indices[i]
                });
            } else {
                node = new _tag2.default({
                    value: value,
                    source: {
                        start: {
                            line: _this2.currToken[2],
                            column: _this2.currToken[3] + ind
                        },
                        end: {
                            line: _this2.currToken[4],
                            column: _this2.currToken[3] + (index - 1)
                        }
                    },
                    sourceIndex: _this2.currToken[6] + indices[i]
                });
            }
            _this2.newNode(node, namespace);
        });
        this.position++;
    };

    Parser.prototype.word = function word(namespace) {
        var nextToken = this.nextToken;
        if (nextToken && nextToken[1] === '|') {
            this.position++;
            return this.namespace();
        }
        return this.splitWord(namespace);
    };

    Parser.prototype.loop = function loop() {
        while (this.position < this.tokens.length) {
            this.parse(true);
        }
        return this.root;
    };

    Parser.prototype.parse = function parse(throwOnParenthesis) {
        switch (this.currToken[0]) {
            case 'space':
                this.space();
                break;
            case 'comment':
                this.comment();
                break;
            case '(':
                this.parentheses();
                break;
            case ')':
                if (throwOnParenthesis) {
                    this.missingParenthesis();
                }
                break;
            case '[':
                this.attribute();
                break;
            case ']':
                this.missingSquareBracket();
                break;
            case 'at-word':
            case 'word':
                this.word();
                break;
            case ':':
                this.pseudo();
                break;
            case ';':
                this.missingBackslash();
                break;
            case ',':
                this.comma();
                break;
            case '*':
                this.universal();
                break;
            case '&':
                this.nesting();
                break;
            case 'combinator':
                this.combinator();
                break;
            case 'string':
                this.string();
                break;
        }
    };

    /**
     * Helpers
     */

    Parser.prototype.parseNamespace = function parseNamespace(namespace) {
        if (this.lossy && typeof namespace === 'string') {
            var trimmed = namespace.trim();
            if (!trimmed.length) {
                return true;
            }

            return trimmed;
        }

        return namespace;
    };

    Parser.prototype.parseSpace = function parseSpace(space, replacement) {
        return this.lossy ? replacement || '' : space;
    };

    Parser.prototype.parseValue = function parseValue(value) {
        return this.lossy && value && typeof value === 'string' ? value.trim() : value;
    };

    Parser.prototype.parseParenthesisToken = function parseParenthesisToken(token) {
        if (!this.lossy) {
            return token[1];
        }

        if (token[0] === 'space') {
            return this.parseSpace(token[1], ' ');
        }

        return this.parseValue(token[1]);
    };

    Parser.prototype.newNode = function newNode(node, namespace) {
        if (namespace) {
            node.namespace = this.parseNamespace(namespace);
        }
        if (this.spaces) {
            node.spaces.before = this.spaces;
            this.spaces = '';
        }
        return this.current.append(node);
    };

    _createClass(Parser, [{
        key: 'currToken',
        get: function get() {
            return this.tokens[this.position];
        }
    }, {
        key: 'nextToken',
        get: function get() {
            return this.tokens[this.position + 1];
        }
    }, {
        key: 'prevToken',
        get: function get() {
            return this.tokens[this.position - 1];
        }
    }]);

    return Parser;
}();

exports.default = Parser;
module.exports = exports['default'];
},{"./selectors/attribute":793,"./selectors/className":794,"./selectors/combinator":795,"./selectors/comment":796,"./selectors/id":798,"./selectors/nesting":800,"./selectors/pseudo":802,"./selectors/root":803,"./selectors/selector":804,"./selectors/string":805,"./selectors/tag":806,"./selectors/types":807,"./selectors/universal":808,"./sortAscending":809,"./tokenize":810,"flatten":614,"indexes-of":636,"uniq":1181}],792:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _parser = require('./parser');

var _parser2 = _interopRequireDefault(_parser);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Processor = function () {
    function Processor(func) {
        _classCallCheck(this, Processor);

        this.func = func || function noop() {};
        return this;
    }

    Processor.prototype.process = function process(selectors) {
        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

        var input = new _parser2.default({
            css: selectors,
            error: function error(e) {
                throw new Error(e);
            },
            options: options
        });
        this.res = input;
        this.func(input);
        return this;
    };

    _createClass(Processor, [{
        key: 'result',
        get: function get() {
            return String(this.res);
        }
    }]);

    return Processor;
}();

exports.default = Processor;
module.exports = exports['default'];
},{"./parser":791}],793:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _namespace = require('./namespace');

var _namespace2 = _interopRequireDefault(_namespace);

var _types = require('./types');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Attribute = function (_Namespace) {
    _inherits(Attribute, _Namespace);

    function Attribute(opts) {
        _classCallCheck(this, Attribute);

        var _this = _possibleConstructorReturn(this, _Namespace.call(this, opts));

        _this.type = _types.ATTRIBUTE;
        _this.raws = {};
        return _this;
    }

    Attribute.prototype.toString = function toString() {
        var selector = [this.spaces.before, '[', this.ns, this.attribute];

        if (this.operator) {
            selector.push(this.operator);
        }
        if (this.value) {
            selector.push(this.value);
        }
        if (this.raws.insensitive) {
            selector.push(this.raws.insensitive);
        } else if (this.insensitive) {
            selector.push(' i');
        }
        selector.push(']');
        return selector.concat(this.spaces.after).join('');
    };

    return Attribute;
}(_namespace2.default);

exports.default = Attribute;
module.exports = exports['default'];
},{"./namespace":799,"./types":807}],794:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _namespace = require('./namespace');

var _namespace2 = _interopRequireDefault(_namespace);

var _types = require('./types');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var ClassName = function (_Namespace) {
    _inherits(ClassName, _Namespace);

    function ClassName(opts) {
        _classCallCheck(this, ClassName);

        var _this = _possibleConstructorReturn(this, _Namespace.call(this, opts));

        _this.type = _types.CLASS;
        return _this;
    }

    ClassName.prototype.toString = function toString() {
        return [this.spaces.before, this.ns, String('.' + this.value), this.spaces.after].join('');
    };

    return ClassName;
}(_namespace2.default);

exports.default = ClassName;
module.exports = exports['default'];
},{"./namespace":799,"./types":807}],795:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _node = require('./node');

var _node2 = _interopRequireDefault(_node);

var _types = require('./types');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Combinator = function (_Node) {
    _inherits(Combinator, _Node);

    function Combinator(opts) {
        _classCallCheck(this, Combinator);

        var _this = _possibleConstructorReturn(this, _Node.call(this, opts));

        _this.type = _types.COMBINATOR;
        return _this;
    }

    return Combinator;
}(_node2.default);

exports.default = Combinator;
module.exports = exports['default'];
},{"./node":801,"./types":807}],796:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _node = require('./node');

var _node2 = _interopRequireDefault(_node);

var _types = require('./types');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Comment = function (_Node) {
    _inherits(Comment, _Node);

    function Comment(opts) {
        _classCallCheck(this, Comment);

        var _this = _possibleConstructorReturn(this, _Node.call(this, opts));

        _this.type = _types.COMMENT;
        return _this;
    }

    return Comment;
}(_node2.default);

exports.default = Comment;
module.exports = exports['default'];
},{"./node":801,"./types":807}],797:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _node = require('./node');

var _node2 = _interopRequireDefault(_node);

var _types = require('./types');

var types = _interopRequireWildcard(_types);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Container = function (_Node) {
    _inherits(Container, _Node);

    function Container(opts) {
        _classCallCheck(this, Container);

        var _this = _possibleConstructorReturn(this, _Node.call(this, opts));

        if (!_this.nodes) {
            _this.nodes = [];
        }
        return _this;
    }

    Container.prototype.append = function append(selector) {
        selector.parent = this;
        this.nodes.push(selector);
        return this;
    };

    Container.prototype.prepend = function prepend(selector) {
        selector.parent = this;
        this.nodes.unshift(selector);
        return this;
    };

    Container.prototype.at = function at(index) {
        return this.nodes[index];
    };

    Container.prototype.index = function index(child) {
        if (typeof child === 'number') {
            return child;
        }
        return this.nodes.indexOf(child);
    };

    Container.prototype.removeChild = function removeChild(child) {
        child = this.index(child);
        this.at(child).parent = undefined;
        this.nodes.splice(child, 1);

        var index = void 0;
        for (var id in this.indexes) {
            index = this.indexes[id];
            if (index >= child) {
                this.indexes[id] = index - 1;
            }
        }

        return this;
    };

    Container.prototype.removeAll = function removeAll() {
        for (var _iterator = this.nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
            var _ref;

            if (_isArray) {
                if (_i >= _iterator.length) break;
                _ref = _iterator[_i++];
            } else {
                _i = _iterator.next();
                if (_i.done) break;
                _ref = _i.value;
            }

            var node = _ref;

            node.parent = undefined;
        }
        this.nodes = [];
        return this;
    };

    Container.prototype.empty = function empty() {
        return this.removeAll();
    };

    Container.prototype.insertAfter = function insertAfter(oldNode, newNode) {
        var oldIndex = this.index(oldNode);
        this.nodes.splice(oldIndex + 1, 0, newNode);

        var index = void 0;
        for (var id in this.indexes) {
            index = this.indexes[id];
            if (oldIndex <= index) {
                this.indexes[id] = index + this.nodes.length;
            }
        }

        return this;
    };

    Container.prototype.insertBefore = function insertBefore(oldNode, newNode) {
        var oldIndex = this.index(oldNode);
        this.nodes.splice(oldIndex, 0, newNode);

        var index = void 0;
        for (var id in this.indexes) {
            index = this.indexes[id];
            if (oldIndex <= index) {
                this.indexes[id] = index + this.nodes.length;
            }
        }

        return this;
    };

    Container.prototype.each = function each(callback) {
        if (!this.lastEach) {
            this.lastEach = 0;
        }
        if (!this.indexes) {
            this.indexes = {};
        }

        this.lastEach++;
        var id = this.lastEach;
        this.indexes[id] = 0;

        if (!this.length) {
            return undefined;
        }

        var index = void 0,
            result = void 0;
        while (this.indexes[id] < this.length) {
            index = this.indexes[id];
            result = callback(this.at(index), index);
            if (result === false) {
                break;
            }

            this.indexes[id] += 1;
        }

        delete this.indexes[id];

        if (result === false) {
            return false;
        }
    };

    Container.prototype.walk = function walk(callback) {
        return this.each(function (node, i) {
            var result = callback(node, i);

            if (result !== false && node.length) {
                result = node.walk(callback);
            }

            if (result === false) {
                return false;
            }
        });
    };

    Container.prototype.walkAttributes = function walkAttributes(callback) {
        var _this2 = this;

        return this.walk(function (selector) {
            if (selector.type === types.ATTRIBUTE) {
                return callback.call(_this2, selector);
            }
        });
    };

    Container.prototype.walkClasses = function walkClasses(callback) {
        var _this3 = this;

        return this.walk(function (selector) {
            if (selector.type === types.CLASS) {
                return callback.call(_this3, selector);
            }
        });
    };

    Container.prototype.walkCombinators = function walkCombinators(callback) {
        var _this4 = this;

        return this.walk(function (selector) {
            if (selector.type === types.COMBINATOR) {
                return callback.call(_this4, selector);
            }
        });
    };

    Container.prototype.walkComments = function walkComments(callback) {
        var _this5 = this;

        return this.walk(function (selector) {
            if (selector.type === types.COMMENT) {
                return callback.call(_this5, selector);
            }
        });
    };

    Container.prototype.walkIds = function walkIds(callback) {
        var _this6 = this;

        return this.walk(function (selector) {
            if (selector.type === types.ID) {
                return callback.call(_this6, selector);
            }
        });
    };

    Container.prototype.walkNesting = function walkNesting(callback) {
        var _this7 = this;

        return this.walk(function (selector) {
            if (selector.type === types.NESTING) {
                return callback.call(_this7, selector);
            }
        });
    };

    Container.prototype.walkPseudos = function walkPseudos(callback) {
        var _this8 = this;

        return this.walk(function (selector) {
            if (selector.type === types.PSEUDO) {
                return callback.call(_this8, selector);
            }
        });
    };

    Container.prototype.walkTags = function walkTags(callback) {
        var _this9 = this;

        return this.walk(function (selector) {
            if (selector.type === types.TAG) {
                return callback.call(_this9, selector);
            }
        });
    };

    Container.prototype.walkUniversals = function walkUniversals(callback) {
        var _this10 = this;

        return this.walk(function (selector) {
            if (selector.type === types.UNIVERSAL) {
                return callback.call(_this10, selector);
            }
        });
    };

    Container.prototype.split = function split(callback) {
        var _this11 = this;

        var current = [];
        return this.reduce(function (memo, node, index) {
            var split = callback.call(_this11, node);
            current.push(node);
            if (split) {
                memo.push(current);
                current = [];
            } else if (index === _this11.length - 1) {
                memo.push(current);
            }
            return memo;
        }, []);
    };

    Container.prototype.map = function map(callback) {
        return this.nodes.map(callback);
    };

    Container.prototype.reduce = function reduce(callback, memo) {
        return this.nodes.reduce(callback, memo);
    };

    Container.prototype.every = function every(callback) {
        return this.nodes.every(callback);
    };

    Container.prototype.some = function some(callback) {
        return this.nodes.some(callback);
    };

    Container.prototype.filter = function filter(callback) {
        return this.nodes.filter(callback);
    };

    Container.prototype.sort = function sort(callback) {
        return this.nodes.sort(callback);
    };

    Container.prototype.toString = function toString() {
        return this.map(String).join('');
    };

    _createClass(Container, [{
        key: 'first',
        get: function get() {
            return this.at(0);
        }
    }, {
        key: 'last',
        get: function get() {
            return this.at(this.length - 1);
        }
    }, {
        key: 'length',
        get: function get() {
            return this.nodes.length;
        }
    }]);

    return Container;
}(_node2.default);

exports.default = Container;
module.exports = exports['default'];
},{"./node":801,"./types":807}],798:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _namespace = require('./namespace');

var _namespace2 = _interopRequireDefault(_namespace);

var _types = require('./types');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var ID = function (_Namespace) {
    _inherits(ID, _Namespace);

    function ID(opts) {
        _classCallCheck(this, ID);

        var _this = _possibleConstructorReturn(this, _Namespace.call(this, opts));

        _this.type = _types.ID;
        return _this;
    }

    ID.prototype.toString = function toString() {
        return [this.spaces.before, this.ns, String('#' + this.value), this.spaces.after].join('');
    };

    return ID;
}(_namespace2.default);

exports.default = ID;
module.exports = exports['default'];
},{"./namespace":799,"./types":807}],799:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _node = require('./node');

var _node2 = _interopRequireDefault(_node);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Namespace = function (_Node) {
    _inherits(Namespace, _Node);

    function Namespace() {
        _classCallCheck(this, Namespace);

        return _possibleConstructorReturn(this, _Node.apply(this, arguments));
    }

    Namespace.prototype.toString = function toString() {
        return [this.spaces.before, this.ns, String(this.value), this.spaces.after].join('');
    };

    _createClass(Namespace, [{
        key: 'ns',
        get: function get() {
            var n = this.namespace;
            return n ? (typeof n === 'string' ? n : '') + '|' : '';
        }
    }]);

    return Namespace;
}(_node2.default);

exports.default = Namespace;
;
module.exports = exports['default'];
},{"./node":801}],800:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _node = require('./node');

var _node2 = _interopRequireDefault(_node);

var _types = require('./types');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Nesting = function (_Node) {
    _inherits(Nesting, _Node);

    function Nesting(opts) {
        _classCallCheck(this, Nesting);

        var _this = _possibleConstructorReturn(this, _Node.call(this, opts));

        _this.type = _types.NESTING;
        _this.value = '&';
        return _this;
    }

    return Nesting;
}(_node2.default);

exports.default = Nesting;
module.exports = exports['default'];
},{"./node":801,"./types":807}],801:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var cloneNode = function cloneNode(obj, parent) {
    if ((typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) !== 'object') {
        return obj;
    }

    var cloned = new obj.constructor();

    for (var i in obj) {
        if (!obj.hasOwnProperty(i)) {
            continue;
        }
        var value = obj[i];
        var type = typeof value === 'undefined' ? 'undefined' : _typeof(value);

        if (i === 'parent' && type === 'object') {
            if (parent) {
                cloned[i] = parent;
            }
        } else if (value instanceof Array) {
            cloned[i] = value.map(function (j) {
                return cloneNode(j, cloned);
            });
        } else {
            cloned[i] = cloneNode(value, cloned);
        }
    }

    return cloned;
};

var _class = function () {
    function _class() {
        var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

        _classCallCheck(this, _class);

        for (var key in opts) {
            this[key] = opts[key];
        }
        var _opts$spaces = opts.spaces;
        _opts$spaces = _opts$spaces === undefined ? {} : _opts$spaces;
        var _opts$spaces$before = _opts$spaces.before,
            before = _opts$spaces$before === undefined ? '' : _opts$spaces$before,
            _opts$spaces$after = _opts$spaces.after,
            after = _opts$spaces$after === undefined ? '' : _opts$spaces$after;

        this.spaces = { before: before, after: after };
    }

    _class.prototype.remove = function remove() {
        if (this.parent) {
            this.parent.removeChild(this);
        }
        this.parent = undefined;
        return this;
    };

    _class.prototype.replaceWith = function replaceWith() {
        if (this.parent) {
            for (var index in arguments) {
                this.parent.insertBefore(this, arguments[index]);
            }
            this.remove();
        }
        return this;
    };

    _class.prototype.next = function next() {
        return this.parent.at(this.parent.index(this) + 1);
    };

    _class.prototype.prev = function prev() {
        return this.parent.at(this.parent.index(this) - 1);
    };

    _class.prototype.clone = function clone() {
        var overrides = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

        var cloned = cloneNode(this);
        for (var name in overrides) {
            cloned[name] = overrides[name];
        }
        return cloned;
    };

    _class.prototype.toString = function toString() {
        return [this.spaces.before, String(this.value), this.spaces.after].join('');
    };

    return _class;
}();

exports.default = _class;
module.exports = exports['default'];
},{}],802:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _container = require('./container');

var _container2 = _interopRequireDefault(_container);

var _types = require('./types');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Pseudo = function (_Container) {
    _inherits(Pseudo, _Container);

    function Pseudo(opts) {
        _classCallCheck(this, Pseudo);

        var _this = _possibleConstructorReturn(this, _Container.call(this, opts));

        _this.type = _types.PSEUDO;
        return _this;
    }

    Pseudo.prototype.toString = function toString() {
        var params = this.length ? '(' + this.map(String).join(',') + ')' : '';
        return [this.spaces.before, String(this.value), params, this.spaces.after].join('');
    };

    return Pseudo;
}(_container2.default);

exports.default = Pseudo;
module.exports = exports['default'];
},{"./container":797,"./types":807}],803:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _container = require('./container');

var _container2 = _interopRequireDefault(_container);

var _types = require('./types');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Root = function (_Container) {
    _inherits(Root, _Container);

    function Root(opts) {
        _classCallCheck(this, Root);

        var _this = _possibleConstructorReturn(this, _Container.call(this, opts));

        _this.type = _types.ROOT;
        return _this;
    }

    Root.prototype.toString = function toString() {
        var str = this.reduce(function (memo, selector) {
            var sel = String(selector);
            return sel ? memo + sel + ',' : '';
        }, '').slice(0, -1);
        return this.trailingComma ? str + ',' : str;
    };

    return Root;
}(_container2.default);

exports.default = Root;
module.exports = exports['default'];
},{"./container":797,"./types":807}],804:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _container = require('./container');

var _container2 = _interopRequireDefault(_container);

var _types = require('./types');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Selector = function (_Container) {
    _inherits(Selector, _Container);

    function Selector(opts) {
        _classCallCheck(this, Selector);

        var _this = _possibleConstructorReturn(this, _Container.call(this, opts));

        _this.type = _types.SELECTOR;
        return _this;
    }

    return Selector;
}(_container2.default);

exports.default = Selector;
module.exports = exports['default'];
},{"./container":797,"./types":807}],805:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _node = require('./node');

var _node2 = _interopRequireDefault(_node);

var _types = require('./types');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var String = function (_Node) {
    _inherits(String, _Node);

    function String(opts) {
        _classCallCheck(this, String);

        var _this = _possibleConstructorReturn(this, _Node.call(this, opts));

        _this.type = _types.STRING;
        return _this;
    }

    return String;
}(_node2.default);

exports.default = String;
module.exports = exports['default'];
},{"./node":801,"./types":807}],806:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _namespace = require('./namespace');

var _namespace2 = _interopRequireDefault(_namespace);

var _types = require('./types');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Tag = function (_Namespace) {
    _inherits(Tag, _Namespace);

    function Tag(opts) {
        _classCallCheck(this, Tag);

        var _this = _possibleConstructorReturn(this, _Namespace.call(this, opts));

        _this.type = _types.TAG;
        return _this;
    }

    return Tag;
}(_namespace2.default);

exports.default = Tag;
module.exports = exports['default'];
},{"./namespace":799,"./types":807}],807:[function(require,module,exports){
'use strict';

exports.__esModule = true;
var TAG = exports.TAG = 'tag';
var STRING = exports.STRING = 'string';
var SELECTOR = exports.SELECTOR = 'selector';
var ROOT = exports.ROOT = 'root';
var PSEUDO = exports.PSEUDO = 'pseudo';
var NESTING = exports.NESTING = 'nesting';
var ID = exports.ID = 'id';
var COMMENT = exports.COMMENT = 'comment';
var COMBINATOR = exports.COMBINATOR = 'combinator';
var CLASS = exports.CLASS = 'class';
var ATTRIBUTE = exports.ATTRIBUTE = 'attribute';
var UNIVERSAL = exports.UNIVERSAL = 'universal';
},{}],808:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _namespace = require('./namespace');

var _namespace2 = _interopRequireDefault(_namespace);

var _types = require('./types');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Universal = function (_Namespace) {
    _inherits(Universal, _Namespace);

    function Universal(opts) {
        _classCallCheck(this, Universal);

        var _this = _possibleConstructorReturn(this, _Namespace.call(this, opts));

        _this.type = _types.UNIVERSAL;
        _this.value = '*';
        return _this;
    }

    return Universal;
}(_namespace2.default);

exports.default = Universal;
module.exports = exports['default'];
},{"./namespace":799,"./types":807}],809:[function(require,module,exports){
"use strict";

exports.__esModule = true;
exports.default = sortAscending;
function sortAscending(list) {
    return list.sort(function (a, b) {
        return a - b;
    });
};
module.exports = exports["default"];
},{}],810:[function(require,module,exports){
'use strict';

exports.__esModule = true;
exports.default = tokenize;
var singleQuote = 39,
    doubleQuote = 34,
    backslash = 92,
    slash = 47,
    newline = 10,
    space = 32,
    feed = 12,
    tab = 9,
    cr = 13,
    plus = 43,
    gt = 62,
    tilde = 126,
    pipe = 124,
    comma = 44,
    openBracket = 40,
    closeBracket = 41,
    openSq = 91,
    closeSq = 93,
    semicolon = 59,
    asterisk = 42,
    colon = 58,
    ampersand = 38,
    at = 64,
    atEnd = /[ \n\t\r\{\(\)'"\\;/]/g,
    wordEnd = /[ \n\t\r\(\)\*:;@!&'"\+\|~>,\[\]\\]|\/(?=\*)/g;

function tokenize(input) {
    var tokens = [];
    var css = input.css.valueOf();

    var code = void 0,
        next = void 0,
        quote = void 0,
        lines = void 0,
        last = void 0,
        content = void 0,
        escape = void 0,
        nextLine = void 0,
        nextOffset = void 0,
        escaped = void 0,
        escapePos = void 0;

    var length = css.length;
    var offset = -1;
    var line = 1;
    var pos = 0;

    var unclosed = function unclosed(what, end) {
        if (input.safe) {
            css += end;
            next = css.length - 1;
        } else {
            throw input.error('Unclosed ' + what, line, pos - offset, pos);
        }
    };

    while (pos < length) {
        code = css.charCodeAt(pos);

        if (code === newline) {
            offset = pos;
            line += 1;
        }

        switch (code) {
            case newline:
            case space:
            case tab:
            case cr:
            case feed:
                next = pos;
                do {
                    next += 1;
                    code = css.charCodeAt(next);
                    if (code === newline) {
                        offset = next;
                        line += 1;
                    }
                } while (code === space || code === newline || code === tab || code === cr || code === feed);

                tokens.push(['space', css.slice(pos, next), line, pos - offset, pos]);
                pos = next - 1;
                break;

            case plus:
            case gt:
            case tilde:
            case pipe:
                next = pos;
                do {
                    next += 1;
                    code = css.charCodeAt(next);
                } while (code === plus || code === gt || code === tilde || code === pipe);
                tokens.push(['combinator', css.slice(pos, next), line, pos - offset, pos]);
                pos = next - 1;
                break;

            case asterisk:
                tokens.push(['*', '*', line, pos - offset, pos]);
                break;

            case ampersand:
                tokens.push(['&', '&', line, pos - offset, pos]);
                break;

            case comma:
                tokens.push([',', ',', line, pos - offset, pos]);
                break;

            case openSq:
                tokens.push(['[', '[', line, pos - offset, pos]);
                break;

            case closeSq:
                tokens.push([']', ']', line, pos - offset, pos]);
                break;

            case colon:
                tokens.push([':', ':', line, pos - offset, pos]);
                break;

            case semicolon:
                tokens.push([';', ';', line, pos - offset, pos]);
                break;

            case openBracket:
                tokens.push(['(', '(', line, pos - offset, pos]);
                break;

            case closeBracket:
                tokens.push([')', ')', line, pos - offset, pos]);
                break;

            case singleQuote:
            case doubleQuote:
                quote = code === singleQuote ? "'" : '"';
                next = pos;
                do {
                    escaped = false;
                    next = css.indexOf(quote, next + 1);
                    if (next === -1) {
                        unclosed('quote', quote);
                    }
                    escapePos = next;
                    while (css.charCodeAt(escapePos - 1) === backslash) {
                        escapePos -= 1;
                        escaped = !escaped;
                    }
                } while (escaped);

                tokens.push(['string', css.slice(pos, next + 1), line, pos - offset, line, next - offset, pos]);
                pos = next;
                break;

            case at:
                atEnd.lastIndex = pos + 1;
                atEnd.test(css);
                if (atEnd.lastIndex === 0) {
                    next = css.length - 1;
                } else {
                    next = atEnd.lastIndex - 2;
                }
                tokens.push(['at-word', css.slice(pos, next + 1), line, pos - offset, line, next - offset, pos]);
                pos = next;
                break;

            case backslash:
                next = pos;
                escape = true;
                while (css.charCodeAt(next + 1) === backslash) {
                    next += 1;
                    escape = !escape;
                }
                code = css.charCodeAt(next + 1);
                if (escape && code !== slash && code !== space && code !== newline && code !== tab && code !== cr && code !== feed) {
                    next += 1;
                }
                tokens.push(['word', css.slice(pos, next + 1), line, pos - offset, line, next - offset, pos]);
                pos = next;
                break;

            default:
                if (code === slash && css.charCodeAt(pos + 1) === asterisk) {
                    next = css.indexOf('*/', pos + 2) + 1;
                    if (next === 0) {
                        unclosed('comment', '*/');
                    }

                    content = css.slice(pos, next + 1);
                    lines = content.split('\n');
                    last = lines.length - 1;

                    if (last > 0) {
                        nextLine = line + last;
                        nextOffset = next - lines[last].length;
                    } else {
                        nextLine = line;
                        nextOffset = offset;
                    }

                    tokens.push(['comment', content, line, pos - offset, nextLine, next - nextOffset, pos]);

                    offset = nextOffset;
                    line = nextLine;
                    pos = next;
                } else {
                    wordEnd.lastIndex = pos + 1;
                    wordEnd.test(css);
                    if (wordEnd.lastIndex === 0) {
                        next = css.length - 1;
                    } else {
                        next = wordEnd.lastIndex - 2;
                    }

                    tokens.push(['word', css.slice(pos, next + 1), line, pos - offset, line, next - offset, pos]);
                    pos = next;
                }

                break;
        }

        pos++;
    }

    return tokens;
}
module.exports = exports['default'];
},{}],811:[function(require,module,exports){
var parse = require('./parse');
var walk = require('./walk');
var stringify = require('./stringify');

function ValueParser(value) {
    if (this instanceof ValueParser) {
        this.nodes = parse(value);
        return this;
    }
    return new ValueParser(value);
}

ValueParser.prototype.toString = function () {
    return Array.isArray(this.nodes) ? stringify(this.nodes) : '';
};

ValueParser.prototype.walk = function (cb, bubble) {
    walk(this.nodes, cb, bubble);
    return this;
};

ValueParser.unit = require('./unit');

ValueParser.walk = walk;

ValueParser.stringify = stringify;

module.exports = ValueParser;

},{"./parse":812,"./stringify":813,"./unit":814,"./walk":815}],812:[function(require,module,exports){
var openParentheses = '('.charCodeAt(0);
var closeParentheses = ')'.charCodeAt(0);
var singleQuote = '\''.charCodeAt(0);
var doubleQuote = '"'.charCodeAt(0);
var backslash = '\\'.charCodeAt(0);
var slash = '/'.charCodeAt(0);
var comma = ','.charCodeAt(0);
var colon = ':'.charCodeAt(0);
var star = '*'.charCodeAt(0);

module.exports = function (input) {
    var tokens = [];
    var value = input;

    var next, quote, prev, token, escape, escapePos, whitespacePos;
    var pos = 0;
    var code = value.charCodeAt(pos);
    var max = value.length;
    var stack = [{ nodes: tokens }];
    var balanced = 0;
    var parent;

    var name = '';
    var before = '';
    var after = '';

    while (pos < max) {
        // Whitespaces
        if (code <= 32) {
            next = pos;
            do {
                next += 1;
                code = value.charCodeAt(next);
            } while (code <= 32);
            token = value.slice(pos, next);

            prev = tokens[tokens.length - 1];
            if (code === closeParentheses && balanced) {
                after = token;
            } else if (prev && prev.type === 'div') {
                prev.after = token;
            } else if (code === comma || code === colon || code === slash && value.charCodeAt(next + 1) !== star) {
                before = token;
            } else {
                tokens.push({
                    type: 'space',
                    sourceIndex: pos,
                    value: token
                });
            }

            pos = next;

        // Quotes
        } else if (code === singleQuote || code === doubleQuote) {
            next = pos;
            quote = code === singleQuote ? '\'' : '"';
            token = {
                type: 'string',
                sourceIndex: pos,
                quote: quote
            };
            do {
                escape = false;
                next = value.indexOf(quote, next + 1);
                if (~next) {
                    escapePos = next;
                    while (value.charCodeAt(escapePos - 1) === backslash) {
                        escapePos -= 1;
                        escape = !escape;
                    }
                } else {
                    value += quote;
                    next = value.length - 1;
                    token.unclosed = true;
                }
            } while (escape);
            token.value = value.slice(pos + 1, next);

            tokens.push(token);
            pos = next + 1;
            code = value.charCodeAt(pos);

        // Comments
        } else if (code === slash && value.charCodeAt(pos + 1) === star) {
            token = {
                type: 'comment',
                sourceIndex: pos
            };

            next = value.indexOf('*/', pos);
            if (next === -1) {
                token.unclosed = true;
                next = value.length;
            }

            token.value = value.slice(pos + 2, next);
            tokens.push(token);

            pos = next + 2;
            code = value.charCodeAt(pos);

        // Dividers
        } else if (code === slash || code === comma || code === colon) {
            token = value[pos];

            tokens.push({
                type: 'div',
                sourceIndex: pos - before.length,
                value: token,
                before: before,
                after: ''
            });
            before = '';

            pos += 1;
            code = value.charCodeAt(pos);

        // Open parentheses
        } else if (openParentheses === code) {
            // Whitespaces after open parentheses
            next = pos;
            do {
                next += 1;
                code = value.charCodeAt(next);
            } while (code <= 32);
            token = {
                type: 'function',
                sourceIndex: pos - name.length,
                value: name,
                before: value.slice(pos + 1, next)
            };
            pos = next;

            if (name === 'url' && code !== singleQuote && code !== doubleQuote) {
                next -= 1;
                do {
                    escape = false;
                    next = value.indexOf(')', next + 1);
                    if (~next) {
                        escapePos = next;
                        while (value.charCodeAt(escapePos - 1) === backslash) {
                            escapePos -= 1;
                            escape = !escape;
                        }
                    } else {
                        value += ')';
                        next = value.length - 1;
                        token.unclosed = true;
                    }
                } while (escape);
                // Whitespaces before closed
                whitespacePos = next;
                do {
                    whitespacePos -= 1;
                    code = value.charCodeAt(whitespacePos);
                } while (code <= 32);
                if (pos !== whitespacePos + 1) {
                    token.nodes = [{
                        type: 'word',
                        sourceIndex: pos,
                        value: value.slice(pos, whitespacePos + 1)
                    }];
                } else {
                    token.nodes = [];
                }
                if (token.unclosed && whitespacePos + 1 !== next) {
                    token.after = '';
                    token.nodes.push({
                        type: 'space',
                        sourceIndex: whitespacePos + 1,
                        value: value.slice(whitespacePos + 1, next)
                    });
                } else {
                    token.after = value.slice(whitespacePos + 1, next);
                }
                pos = next + 1;
                code = value.charCodeAt(pos);
                tokens.push(token);
            } else {
                balanced += 1;
                token.after = '';
                tokens.push(token);
                stack.push(token);
                tokens = token.nodes = [];
                parent = token;
            }
            name = '';

        // Close parentheses
        } else if (closeParentheses === code && balanced) {
            pos += 1;
            code = value.charCodeAt(pos);

            parent.after = after;
            after = '';
            balanced -= 1;
            stack.pop();
            parent = stack[balanced];
            tokens = parent.nodes;

        // Words
        } else {
            next = pos;
            do {
                if (code === backslash) {
                    next += 1;
                }
                next += 1;
                code = value.charCodeAt(next);
            } while (next < max && !(
                code <= 32 ||
                code === singleQuote ||
                code === doubleQuote ||
                code === comma ||
                code === colon ||
                code === slash ||
                code === openParentheses ||
                code === closeParentheses && balanced
            ));
            token = value.slice(pos, next);

            if (openParentheses === code) {
                name = token;
            } else {
                tokens.push({
                    type: 'word',
                    sourceIndex: pos,
                    value: token
                });
            }

            pos = next;
        }
    }

    for (pos = stack.length - 1; pos; pos -= 1) {
        stack[pos].unclosed = true;
    }

    return stack[0].nodes;
};

},{}],813:[function(require,module,exports){
function stringifyNode(node, custom) {
    var type = node.type;
    var value = node.value;
    var buf;
    var customResult;

    if (custom && (customResult = custom(node)) !== undefined) {
        return customResult;
    } else if (type === 'word' || type === 'space') {
        return value;
    } else if (type === 'string') {
        buf = node.quote || '';
        return buf + value + (node.unclosed ? '' : buf);
    } else if (type === 'comment') {
        return '/*' + value + (node.unclosed ? '' : '*/');
    } else if (type === 'div') {
        return (node.before || '') + value + (node.after || '');
    } else if (Array.isArray(node.nodes)) {
        buf = stringify(node.nodes);
        if (type !== 'function') {
            return buf;
        }
        return value + '(' + (node.before || '') + buf + (node.after || '') + (node.unclosed ? '' : ')');
    }
    return value;
}

function stringify(nodes, custom) {
    var result, i;

    if (Array.isArray(nodes)) {
        result = '';
        for (i = nodes.length - 1; ~i; i -= 1) {
            result = stringifyNode(nodes[i], custom) + result;
        }
        return result;
    }
    return stringifyNode(nodes, custom);
}

module.exports = stringify;

},{}],814:[function(require,module,exports){
var minus = '-'.charCodeAt(0);
var plus  = '+'.charCodeAt(0);
var dot   = '.'.charCodeAt(0);

module.exports = function (value) {
    var pos = 0;
    var length = value.length;
    var dotted = false;
    var containsNumber = false;
    var code;
    var number = '';

    while (pos < length) {
        code = value.charCodeAt(pos);

        if (code >= 48 && code <= 57) {
            number += value[pos];
            containsNumber = true;
        } else if (code === dot) {
            if (dotted) {
                break;
            }
            dotted = true;
            number += value[pos];
        } else if (code === plus || code === minus) {
            if (pos !== 0) {
                break;
            }
            number += value[pos];
        } else {
            break;
        }

        pos += 1;
    }

    return containsNumber ? {
        number: number,
        unit: value.slice(pos)
    } : false;
};

},{}],815:[function(require,module,exports){
module.exports = function walk(nodes, cb, bubble) {
    var i, max, node, result;

    for (i = 0, max = nodes.length; i < max; i += 1) {
        node = nodes[i];
        if (!bubble) {
            result = cb(node, i, nodes);
        }

        if (result !== false && node.type === 'function' && Array.isArray(node.nodes)) {
            walk(node.nodes, cb, bubble);
        }

        if (bubble) {
            cb(node, i, nodes);
        }
    }
};

},{}],816:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _container = require('./container');

var _container2 = _interopRequireDefault(_container);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

/**
 * Represents an at-rule.
 *
 * If it’s followed in the CSS by a {} block, this node will have
 * a nodes property representing its children.
 *
 * @extends Container
 *
 * @example
 * const root = postcss.parse('@charset "UTF-8"; @media print {}');
 *
 * const charset = root.first;
 * charset.type  //=> 'atrule'
 * charset.nodes //=> undefined
 *
 * const media = root.last;
 * media.nodes   //=> []
 */
var AtRule = function (_Container) {
  _inherits(AtRule, _Container);

  function AtRule(defaults) {
    _classCallCheck(this, AtRule);

    var _this = _possibleConstructorReturn(this, _Container.call(this, defaults));

    _this.type = 'atrule';
    return _this;
  }

  AtRule.prototype.append = function append() {
    var _Container$prototype$;

    if (!this.nodes) this.nodes = [];

    for (var _len = arguments.length, children = Array(_len), _key = 0; _key < _len; _key++) {
      children[_key] = arguments[_key];
    }

    return (_Container$prototype$ = _Container.prototype.append).call.apply(_Container$prototype$, [this].concat(children));
  };

  AtRule.prototype.prepend = function prepend() {
    var _Container$prototype$2;

    if (!this.nodes) this.nodes = [];

    for (var _len2 = arguments.length, children = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
      children[_key2] = arguments[_key2];
    }

    return (_Container$prototype$2 = _Container.prototype.prepend).call.apply(_Container$prototype$2, [this].concat(children));
  };

  /**
   * @memberof AtRule#
   * @member {string} name - the at-rule’s name immediately follows the `@`
   *
   * @example
   * const root  = postcss.parse('@media print {}');
   * media.name //=> 'media'
   * const media = root.first;
   */

  /**
   * @memberof AtRule#
   * @member {string} params - the at-rule’s parameters, the values
   *                           that follow the at-rule’s name but precede
   *                           any {} block
   *
   * @example
   * const root  = postcss.parse('@media print, screen {}');
   * const media = root.first;
   * media.params //=> 'print, screen'
   */

  /**
   * @memberof AtRule#
   * @member {object} raws - Information to generate byte-to-byte equal
   *                         node string as it was in the origin input.
   *
   * Every parser saves its own properties,
   * but the default CSS parser uses:
   *
   * * `before`: the space symbols before the node. It also stores `*`
   *   and `_` symbols before the declaration (IE hack).
   * * `after`: the space symbols after the last child of the node
   *   to the end of the node.
   * * `between`: the symbols between the property and value
   *   for declarations, selector and `{` for rules, or last parameter
   *   and `{` for at-rules.
   * * `semicolon`: contains true if the last child has
   *   an (optional) semicolon.
   * * `afterName`: the space between the at-rule name and its parameters.
   *
   * PostCSS cleans at-rule parameters from comments and extra spaces,
   * but it stores origin content in raws properties.
   * As such, if you don’t change a declaration’s value,
   * PostCSS will use the raw value with comments.
   *
   * @example
   * const root = postcss.parse('  @media\nprint {\n}')
   * root.first.first.raws //=> { before: '  ',
   *                       //     between: ' ',
   *                       //     afterName: '\n',
   *                       //     after: '\n' }
   */


  return AtRule;
}(_container2.default);

exports.default = AtRule;
module.exports = exports['default'];


},{"./container":818}],817:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _node = require('./node');

var _node2 = _interopRequireDefault(_node);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

/**
 * Represents a comment between declarations or statements (rule and at-rules).
 *
 * Comments inside selectors, at-rule parameters, or declaration values
 * will be stored in the `raws` properties explained above.
 *
 * @extends Node
 */
var Comment = function (_Node) {
  _inherits(Comment, _Node);

  function Comment(defaults) {
    _classCallCheck(this, Comment);

    var _this = _possibleConstructorReturn(this, _Node.call(this, defaults));

    _this.type = 'comment';
    return _this;
  }

  /**
   * @memberof Comment#
   * @member {string} text - the comment’s text
   */

  /**
   * @memberof Comment#
   * @member {object} raws - Information to generate byte-to-byte equal
   *                         node string as it was in the origin input.
   *
   * Every parser saves its own properties,
   * but the default CSS parser uses:
   *
   * * `before`: the space symbols before the node.
   * * `left`: the space symbols between `/*` and the comment’s text.
   * * `right`: the space symbols between the comment’s text.
   */


  return Comment;
}(_node2.default);

exports.default = Comment;
module.exports = exports['default'];


},{"./node":825}],818:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _declaration = require('./declaration');

var _declaration2 = _interopRequireDefault(_declaration);

var _comment = require('./comment');

var _comment2 = _interopRequireDefault(_comment);

var _node = require('./node');

var _node2 = _interopRequireDefault(_node);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

function cleanSource(nodes) {
    return nodes.map(function (i) {
        if (i.nodes) i.nodes = cleanSource(i.nodes);
        delete i.source;
        return i;
    });
}

/**
 * The {@link Root}, {@link AtRule}, and {@link Rule} container nodes
 * inherit some common methods to help work with their children.
 *
 * Note that all containers can store any content. If you write a rule inside
 * a rule, PostCSS will parse it.
 *
 * @extends Node
 * @abstract
 */

var Container = function (_Node) {
    _inherits(Container, _Node);

    function Container() {
        _classCallCheck(this, Container);

        return _possibleConstructorReturn(this, _Node.apply(this, arguments));
    }

    Container.prototype.push = function push(child) {
        child.parent = this;
        this.nodes.push(child);
        return this;
    };

    /**
     * Iterates through the container’s immediate children,
     * calling `callback` for each child.
     *
     * Returning `false` in the callback will break iteration.
     *
     * This method only iterates through the container’s immediate children.
     * If you need to recursively iterate through all the container’s descendant
     * nodes, use {@link Container#walk}.
     *
     * Unlike the for `{}`-cycle or `Array#forEach` this iterator is safe
     * if you are mutating the array of child nodes during iteration.
     * PostCSS will adjust the current index to match the mutations.
     *
     * @param {childIterator} callback - iterator receives each node and index
     *
     * @return {false|undefined} returns `false` if iteration was broke
     *
     * @example
     * const root = postcss.parse('a { color: black; z-index: 1 }');
     * const rule = root.first;
     *
     * for ( let decl of rule.nodes ) {
     *     decl.cloneBefore({ prop: '-webkit-' + decl.prop });
     *     // Cycle will be infinite, because cloneBefore moves the current node
     *     // to the next index
     * }
     *
     * rule.each(decl => {
     *     decl.cloneBefore({ prop: '-webkit-' + decl.prop });
     *     // Will be executed only for color and z-index
     * });
     */


    Container.prototype.each = function each(callback) {
        if (!this.lastEach) this.lastEach = 0;
        if (!this.indexes) this.indexes = {};

        this.lastEach += 1;
        var id = this.lastEach;
        this.indexes[id] = 0;

        if (!this.nodes) return undefined;

        var index = void 0,
            result = void 0;
        while (this.indexes[id] < this.nodes.length) {
            index = this.indexes[id];
            result = callback(this.nodes[index], index);
            if (result === false) break;

            this.indexes[id] += 1;
        }

        delete this.indexes[id];

        return result;
    };

    /**
     * Traverses the container’s descendant nodes, calling callback
     * for each node.
     *
     * Like container.each(), this method is safe to use
     * if you are mutating arrays during iteration.
     *
     * If you only need to iterate through the container’s immediate children,
     * use {@link Container#each}.
     *
     * @param {childIterator} callback - iterator receives each node and index
     *
     * @return {false|undefined} returns `false` if iteration was broke
     *
     * @example
     * root.walk(node => {
     *   // Traverses all descendant nodes.
     * });
     */


    Container.prototype.walk = function walk(callback) {
        return this.each(function (child, i) {
            var result = callback(child, i);
            if (result !== false && child.walk) {
                result = child.walk(callback);
            }
            return result;
        });
    };

    /**
     * Traverses the container’s descendant nodes, calling callback
     * for each declaration node.
     *
     * If you pass a filter, iteration will only happen over declarations
     * with matching properties.
     *
     * Like {@link Container#each}, this method is safe
     * to use if you are mutating arrays during iteration.
     *
     * @param {string|RegExp} [prop]   - string or regular expression
     *                                   to filter declarations by property name
     * @param {childIterator} callback - iterator receives each node and index
     *
     * @return {false|undefined} returns `false` if iteration was broke
     *
     * @example
     * root.walkDecls(decl => {
     *   checkPropertySupport(decl.prop);
     * });
     *
     * root.walkDecls('border-radius', decl => {
     *   decl.remove();
     * });
     *
     * root.walkDecls(/^background/, decl => {
     *   decl.value = takeFirstColorFromGradient(decl.value);
     * });
     */


    Container.prototype.walkDecls = function walkDecls(prop, callback) {
        if (!callback) {
            callback = prop;
            return this.walk(function (child, i) {
                if (child.type === 'decl') {
                    return callback(child, i);
                }
            });
        } else if (prop instanceof RegExp) {
            return this.walk(function (child, i) {
                if (child.type === 'decl' && prop.test(child.prop)) {
                    return callback(child, i);
                }
            });
        } else {
            return this.walk(function (child, i) {
                if (child.type === 'decl' && child.prop === prop) {
                    return callback(child, i);
                }
            });
        }
    };

    /**
     * Traverses the container’s descendant nodes, calling callback
     * for each rule node.
     *
     * If you pass a filter, iteration will only happen over rules
     * with matching selectors.
     *
     * Like {@link Container#each}, this method is safe
     * to use if you are mutating arrays during iteration.
     *
     * @param {string|RegExp} [selector] - string or regular expression
     *                                     to filter rules by selector
     * @param {childIterator} callback   - iterator receives each node and index
     *
     * @return {false|undefined} returns `false` if iteration was broke
     *
     * @example
     * const selectors = [];
     * root.walkRules(rule => {
     *   selectors.push(rule.selector);
     * });
     * console.log(`Your CSS uses ${selectors.length} selectors`);
     */


    Container.prototype.walkRules = function walkRules(selector, callback) {
        if (!callback) {
            callback = selector;

            return this.walk(function (child, i) {
                if (child.type === 'rule') {
                    return callback(child, i);
                }
            });
        } else if (selector instanceof RegExp) {
            return this.walk(function (child, i) {
                if (child.type === 'rule' && selector.test(child.selector)) {
                    return callback(child, i);
                }
            });
        } else {
            return this.walk(function (child, i) {
                if (child.type === 'rule' && child.selector === selector) {
                    return callback(child, i);
                }
            });
        }
    };

    /**
     * Traverses the container’s descendant nodes, calling callback
     * for each at-rule node.
     *
     * If you pass a filter, iteration will only happen over at-rules
     * that have matching names.
     *
     * Like {@link Container#each}, this method is safe
     * to use if you are mutating arrays during iteration.
     *
     * @param {string|RegExp} [name]   - string or regular expression
     *                                   to filter at-rules by name
     * @param {childIterator} callback - iterator receives each node and index
     *
     * @return {false|undefined} returns `false` if iteration was broke
     *
     * @example
     * root.walkAtRules(rule => {
     *   if ( isOld(rule.name) ) rule.remove();
     * });
     *
     * let first = false;
     * root.walkAtRules('charset', rule => {
     *   if ( !first ) {
     *     first = true;
     *   } else {
     *     rule.remove();
     *   }
     * });
     */


    Container.prototype.walkAtRules = function walkAtRules(name, callback) {
        if (!callback) {
            callback = name;
            return this.walk(function (child, i) {
                if (child.type === 'atrule') {
                    return callback(child, i);
                }
            });
        } else if (name instanceof RegExp) {
            return this.walk(function (child, i) {
                if (child.type === 'atrule' && name.test(child.name)) {
                    return callback(child, i);
                }
            });
        } else {
            return this.walk(function (child, i) {
                if (child.type === 'atrule' && child.name === name) {
                    return callback(child, i);
                }
            });
        }
    };

    /**
     * Traverses the container’s descendant nodes, calling callback
     * for each comment node.
     *
     * Like {@link Container#each}, this method is safe
     * to use if you are mutating arrays during iteration.
     *
     * @param {childIterator} callback - iterator receives each node and index
     *
     * @return {false|undefined} returns `false` if iteration was broke
     *
     * @example
     * root.walkComments(comment => {
     *   comment.remove();
     * });
     */


    Container.prototype.walkComments = function walkComments(callback) {
        return this.walk(function (child, i) {
            if (child.type === 'comment') {
                return callback(child, i);
            }
        });
    };

    /**
     * Inserts new nodes to the end of the container.
     *
     * @param {...(Node|object|string|Node[])} children - new nodes
     *
     * @return {Node} this node for methods chain
     *
     * @example
     * const decl1 = postcss.decl({ prop: 'color', value: 'black' });
     * const decl2 = postcss.decl({ prop: 'background-color', value: 'white' });
     * rule.append(decl1, decl2);
     *
     * root.append({ name: 'charset', params: '"UTF-8"' });  // at-rule
     * root.append({ selector: 'a' });                       // rule
     * rule.append({ prop: 'color', value: 'black' });       // declaration
     * rule.append({ text: 'Comment' })                      // comment
     *
     * root.append('a {}');
     * root.first.append('color: black; z-index: 1');
     */


    Container.prototype.append = function append() {
        for (var _len = arguments.length, children = Array(_len), _key = 0; _key < _len; _key++) {
            children[_key] = arguments[_key];
        }

        for (var _iterator = children, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
            var _ref;

            if (_isArray) {
                if (_i >= _iterator.length) break;
                _ref = _iterator[_i++];
            } else {
                _i = _iterator.next();
                if (_i.done) break;
                _ref = _i.value;
            }

            var child = _ref;

            var nodes = this.normalize(child, this.last);
            for (var _iterator2 = nodes, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
                var _ref2;

                if (_isArray2) {
                    if (_i2 >= _iterator2.length) break;
                    _ref2 = _iterator2[_i2++];
                } else {
                    _i2 = _iterator2.next();
                    if (_i2.done) break;
                    _ref2 = _i2.value;
                }

                var node = _ref2;
                this.nodes.push(node);
            }
        }
        return this;
    };

    /**
     * Inserts new nodes to the start of the container.
     *
     * @param {...(Node|object|string|Node[])} children - new nodes
     *
     * @return {Node} this node for methods chain
     *
     * @example
     * const decl1 = postcss.decl({ prop: 'color', value: 'black' });
     * const decl2 = postcss.decl({ prop: 'background-color', value: 'white' });
     * rule.prepend(decl1, decl2);
     *
     * root.append({ name: 'charset', params: '"UTF-8"' });  // at-rule
     * root.append({ selector: 'a' });                       // rule
     * rule.append({ prop: 'color', value: 'black' });       // declaration
     * rule.append({ text: 'Comment' })                      // comment
     *
     * root.append('a {}');
     * root.first.append('color: black; z-index: 1');
     */


    Container.prototype.prepend = function prepend() {
        for (var _len2 = arguments.length, children = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
            children[_key2] = arguments[_key2];
        }

        children = children.reverse();
        for (var _iterator3 = children, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
            var _ref3;

            if (_isArray3) {
                if (_i3 >= _iterator3.length) break;
                _ref3 = _iterator3[_i3++];
            } else {
                _i3 = _iterator3.next();
                if (_i3.done) break;
                _ref3 = _i3.value;
            }

            var child = _ref3;

            var nodes = this.normalize(child, this.first, 'prepend').reverse();
            for (var _iterator4 = nodes, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) {
                var _ref4;

                if (_isArray4) {
                    if (_i4 >= _iterator4.length) break;
                    _ref4 = _iterator4[_i4++];
                } else {
                    _i4 = _iterator4.next();
                    if (_i4.done) break;
                    _ref4 = _i4.value;
                }

                var node = _ref4;
                this.nodes.unshift(node);
            }for (var id in this.indexes) {
                this.indexes[id] = this.indexes[id] + nodes.length;
            }
        }
        return this;
    };

    Container.prototype.cleanRaws = function cleanRaws(keepBetween) {
        _Node.prototype.cleanRaws.call(this, keepBetween);
        if (this.nodes) {
            for (var _iterator5 = this.nodes, _isArray5 = Array.isArray(_iterator5), _i5 = 0, _iterator5 = _isArray5 ? _iterator5 : _iterator5[Symbol.iterator]();;) {
                var _ref5;

                if (_isArray5) {
                    if (_i5 >= _iterator5.length) break;
                    _ref5 = _iterator5[_i5++];
                } else {
                    _i5 = _iterator5.next();
                    if (_i5.done) break;
                    _ref5 = _i5.value;
                }

                var node = _ref5;
                node.cleanRaws(keepBetween);
            }
        }
    };

    /**
     * Insert new node before old node within the container.
     *
     * @param {Node|number} exist             - child or child’s index.
     * @param {Node|object|string|Node[]} add - new node
     *
     * @return {Node} this node for methods chain
     *
     * @example
     * rule.insertBefore(decl, decl.clone({ prop: '-webkit-' + decl.prop }));
     */


    Container.prototype.insertBefore = function insertBefore(exist, add) {
        exist = this.index(exist);

        var type = exist === 0 ? 'prepend' : false;
        var nodes = this.normalize(add, this.nodes[exist], type).reverse();
        for (var _iterator6 = nodes, _isArray6 = Array.isArray(_iterator6), _i6 = 0, _iterator6 = _isArray6 ? _iterator6 : _iterator6[Symbol.iterator]();;) {
            var _ref6;

            if (_isArray6) {
                if (_i6 >= _iterator6.length) break;
                _ref6 = _iterator6[_i6++];
            } else {
                _i6 = _iterator6.next();
                if (_i6.done) break;
                _ref6 = _i6.value;
            }

            var node = _ref6;
            this.nodes.splice(exist, 0, node);
        }var index = void 0;
        for (var id in this.indexes) {
            index = this.indexes[id];
            if (exist <= index) {
                this.indexes[id] = index + nodes.length;
            }
        }

        return this;
    };

    /**
     * Insert new node after old node within the container.
     *
     * @param {Node|number} exist             - child or child’s index
     * @param {Node|object|string|Node[]} add - new node
     *
     * @return {Node} this node for methods chain
     */


    Container.prototype.insertAfter = function insertAfter(exist, add) {
        exist = this.index(exist);

        var nodes = this.normalize(add, this.nodes[exist]).reverse();
        for (var _iterator7 = nodes, _isArray7 = Array.isArray(_iterator7), _i7 = 0, _iterator7 = _isArray7 ? _iterator7 : _iterator7[Symbol.iterator]();;) {
            var _ref7;

            if (_isArray7) {
                if (_i7 >= _iterator7.length) break;
                _ref7 = _iterator7[_i7++];
            } else {
                _i7 = _iterator7.next();
                if (_i7.done) break;
                _ref7 = _i7.value;
            }

            var node = _ref7;
            this.nodes.splice(exist + 1, 0, node);
        }var index = void 0;
        for (var id in this.indexes) {
            index = this.indexes[id];
            if (exist < index) {
                this.indexes[id] = index + nodes.length;
            }
        }

        return this;
    };

    /**
     * Removes node from the container and cleans the parent properties
     * from the node and its children.
     *
     * @param {Node|number} child - child or child’s index
     *
     * @return {Node} this node for methods chain
     *
     * @example
     * rule.nodes.length  //=> 5
     * rule.removeChild(decl);
     * rule.nodes.length  //=> 4
     * decl.parent        //=> undefined
     */


    Container.prototype.removeChild = function removeChild(child) {
        child = this.index(child);
        this.nodes[child].parent = undefined;
        this.nodes.splice(child, 1);

        var index = void 0;
        for (var id in this.indexes) {
            index = this.indexes[id];
            if (index >= child) {
                this.indexes[id] = index - 1;
            }
        }

        return this;
    };

    /**
     * Removes all children from the container
     * and cleans their parent properties.
     *
     * @return {Node} this node for methods chain
     *
     * @example
     * rule.removeAll();
     * rule.nodes.length //=> 0
     */


    Container.prototype.removeAll = function removeAll() {
        for (var _iterator8 = this.nodes, _isArray8 = Array.isArray(_iterator8), _i8 = 0, _iterator8 = _isArray8 ? _iterator8 : _iterator8[Symbol.iterator]();;) {
            var _ref8;

            if (_isArray8) {
                if (_i8 >= _iterator8.length) break;
                _ref8 = _iterator8[_i8++];
            } else {
                _i8 = _iterator8.next();
                if (_i8.done) break;
                _ref8 = _i8.value;
            }

            var node = _ref8;
            node.parent = undefined;
        }this.nodes = [];
        return this;
    };

    /**
     * Passes all declaration values within the container that match pattern
     * through callback, replacing those values with the returned result
     * of callback.
     *
     * This method is useful if you are using a custom unit or function
     * and need to iterate through all values.
     *
     * @param {string|RegExp} pattern      - replace pattern
     * @param {object} opts                - options to speed up the search
     * @param {string|string[]} opts.props - an array of property names
     * @param {string} opts.fast           - string that’s used
     *                                       to narrow down values and speed up
                                             the regexp search
     * @param {function|string} callback   - string to replace pattern
     *                                       or callback that returns a new
     *                                       value.
     *                                       The callback will receive
     *                                       the same arguments as those
     *                                       passed to a function parameter
     *                                       of `String#replace`.
     *
     * @return {Node} this node for methods chain
     *
     * @example
     * root.replaceValues(/\d+rem/, { fast: 'rem' }, string => {
     *   return 15 * parseInt(string) + 'px';
     * });
     */


    Container.prototype.replaceValues = function replaceValues(pattern, opts, callback) {
        if (!callback) {
            callback = opts;
            opts = {};
        }

        this.walkDecls(function (decl) {
            if (opts.props && opts.props.indexOf(decl.prop) === -1) return;
            if (opts.fast && decl.value.indexOf(opts.fast) === -1) return;

            decl.value = decl.value.replace(pattern, callback);
        });

        return this;
    };

    /**
     * Returns `true` if callback returns `true`
     * for all of the container’s children.
     *
     * @param {childCondition} condition - iterator returns true or false.
     *
     * @return {boolean} is every child pass condition
     *
     * @example
     * const noPrefixes = rule.every(i => i.prop[0] !== '-');
     */


    Container.prototype.every = function every(condition) {
        return this.nodes.every(condition);
    };

    /**
     * Returns `true` if callback returns `true` for (at least) one
     * of the container’s children.
     *
     * @param {childCondition} condition - iterator returns true or false.
     *
     * @return {boolean} is some child pass condition
     *
     * @example
     * const hasPrefix = rule.some(i => i.prop[0] === '-');
     */


    Container.prototype.some = function some(condition) {
        return this.nodes.some(condition);
    };

    /**
     * Returns a `child`’s index within the {@link Container#nodes} array.
     *
     * @param {Node} child - child of the current container.
     *
     * @return {number} child index
     *
     * @example
     * rule.index( rule.nodes[2] ) //=> 2
     */


    Container.prototype.index = function index(child) {
        if (typeof child === 'number') {
            return child;
        } else {
            return this.nodes.indexOf(child);
        }
    };

    /**
     * The container’s first child.
     *
     * @type {Node}
     *
     * @example
     * rule.first == rules.nodes[0];
     */


    Container.prototype.normalize = function normalize(nodes, sample) {
        var _this2 = this;

        if (typeof nodes === 'string') {
            var parse = require('./parse');
            nodes = cleanSource(parse(nodes).nodes);
        } else if (Array.isArray(nodes)) {
            nodes = nodes.slice(0);
            for (var _iterator9 = nodes, _isArray9 = Array.isArray(_iterator9), _i9 = 0, _iterator9 = _isArray9 ? _iterator9 : _iterator9[Symbol.iterator]();;) {
                var _ref9;

                if (_isArray9) {
                    if (_i9 >= _iterator9.length) break;
                    _ref9 = _iterator9[_i9++];
                } else {
                    _i9 = _iterator9.next();
                    if (_i9.done) break;
                    _ref9 = _i9.value;
                }

                var i = _ref9;

                if (i.parent) i.parent.removeChild(i, 'ignore');
            }
        } else if (nodes.type === 'root') {
            nodes = nodes.nodes.slice(0);
            for (var _iterator10 = nodes, _isArray10 = Array.isArray(_iterator10), _i11 = 0, _iterator10 = _isArray10 ? _iterator10 : _iterator10[Symbol.iterator]();;) {
                var _ref10;

                if (_isArray10) {
                    if (_i11 >= _iterator10.length) break;
                    _ref10 = _iterator10[_i11++];
                } else {
                    _i11 = _iterator10.next();
                    if (_i11.done) break;
                    _ref10 = _i11.value;
                }

                var _i10 = _ref10;

                if (_i10.parent) _i10.parent.removeChild(_i10, 'ignore');
            }
        } else if (nodes.type) {
            nodes = [nodes];
        } else if (nodes.prop) {
            if (typeof nodes.value === 'undefined') {
                throw new Error('Value field is missed in node creation');
            } else if (typeof nodes.value !== 'string') {
                nodes.value = String(nodes.value);
            }
            nodes = [new _declaration2.default(nodes)];
        } else if (nodes.selector) {
            var Rule = require('./rule');
            nodes = [new Rule(nodes)];
        } else if (nodes.name) {
            var AtRule = require('./at-rule');
            nodes = [new AtRule(nodes)];
        } else if (nodes.text) {
            nodes = [new _comment2.default(nodes)];
        } else {
            throw new Error('Unknown node type in node creation');
        }

        var processed = nodes.map(function (i) {
            if (typeof i.before !== 'function') i = _this2.rebuild(i);

            if (i.parent) i.parent.removeChild(i);
            if (typeof i.raws.before === 'undefined') {
                if (sample && typeof sample.raws.before !== 'undefined') {
                    i.raws.before = sample.raws.before.replace(/[^\s]/g, '');
                }
            }
            i.parent = _this2;
            return i;
        });

        return processed;
    };

    Container.prototype.rebuild = function rebuild(node, parent) {
        var _this3 = this;

        var fix = void 0;
        if (node.type === 'root') {
            var Root = require('./root');
            fix = new Root();
        } else if (node.type === 'atrule') {
            var AtRule = require('./at-rule');
            fix = new AtRule();
        } else if (node.type === 'rule') {
            var Rule = require('./rule');
            fix = new Rule();
        } else if (node.type === 'decl') {
            fix = new _declaration2.default();
        } else if (node.type === 'comment') {
            fix = new _comment2.default();
        }

        for (var i in node) {
            if (i === 'nodes') {
                fix.nodes = node.nodes.map(function (j) {
                    return _this3.rebuild(j, fix);
                });
            } else if (i === 'parent' && parent) {
                fix.parent = parent;
            } else if (node.hasOwnProperty(i)) {
                fix[i] = node[i];
            }
        }

        return fix;
    };

    /**
     * @memberof Container#
     * @member {Node[]} nodes - an array containing the container’s children
     *
     * @example
     * const root = postcss.parse('a { color: black }');
     * root.nodes.length           //=> 1
     * root.nodes[0].selector      //=> 'a'
     * root.nodes[0].nodes[0].prop //=> 'color'
     */

    _createClass(Container, [{
        key: 'first',
        get: function get() {
            if (!this.nodes) return undefined;
            return this.nodes[0];
        }

        /**
         * The container’s last child.
         *
         * @type {Node}
         *
         * @example
         * rule.last == rule.nodes[rule.nodes.length - 1];
         */

    }, {
        key: 'last',
        get: function get() {
            if (!this.nodes) return undefined;
            return this.nodes[this.nodes.length - 1];
        }
    }]);

    return Container;
}(_node2.default);

exports.default = Container;

/**
 * @callback childCondition
 * @param {Node} node    - container child
 * @param {number} index - child index
 * @param {Node[]} nodes - all container children
 * @return {boolean}
 */

/**
 * @callback childIterator
 * @param {Node} node    - container child
 * @param {number} index - child index
 * @return {false|undefined} returning `false` will break iteration
 */

module.exports = exports['default'];


},{"./at-rule":816,"./comment":817,"./declaration":820,"./node":825,"./parse":826,"./root":832,"./rule":833}],819:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _supportsColor = require('supports-color');

var _supportsColor2 = _interopRequireDefault(_supportsColor);

var _chalk = require('chalk');

var _chalk2 = _interopRequireDefault(_chalk);

var _terminalHighlight = require('./terminal-highlight');

var _terminalHighlight2 = _interopRequireDefault(_terminalHighlight);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

/**
 * The CSS parser throws this error for broken CSS.
 *
 * Custom parsers can throw this error for broken custom syntax using
 * the {@link Node#error} method.
 *
 * PostCSS will use the input source map to detect the original error location.
 * If you wrote a Sass file, compiled it to CSS and then parsed it with PostCSS,
 * PostCSS will show the original position in the Sass file.
 *
 * If you need the position in the PostCSS input
 * (e.g., to debug the previous compiler), use `error.input.file`.
 *
 * @example
 * // Catching and checking syntax error
 * try {
 *   postcss.parse('a{')
 * } catch (error) {
 *   if ( error.name === 'CssSyntaxError' ) {
 *     error //=> CssSyntaxError
 *   }
 * }
 *
 * @example
 * // Raising error from plugin
 * throw node.error('Unknown variable', { plugin: 'postcss-vars' });
 */
var CssSyntaxError = function () {

    /**
     * @param {string} message  - error message
     * @param {number} [line]   - source line of the error
     * @param {number} [column] - source column of the error
     * @param {string} [source] - source code of the broken file
     * @param {string} [file]   - absolute path to the broken file
     * @param {string} [plugin] - PostCSS plugin name, if error came from plugin
     */
    function CssSyntaxError(message, line, column, source, file, plugin) {
        _classCallCheck(this, CssSyntaxError);

        /**
         * @member {string} - Always equal to `'CssSyntaxError'`. You should
         *                    always check error type
         *                    by `error.name === 'CssSyntaxError'` instead of
         *                    `error instanceof CssSyntaxError`, because
         *                    npm could have several PostCSS versions.
         *
         * @example
         * if ( error.name === 'CssSyntaxError' ) {
         *   error //=> CssSyntaxError
         * }
         */
        this.name = 'CssSyntaxError';
        /**
         * @member {string} - Error message.
         *
         * @example
         * error.message //=> 'Unclosed block'
         */
        this.reason = message;

        if (file) {
            /**
             * @member {string} - Absolute path to the broken file.
             *
             * @example
             * error.file       //=> 'a.sass'
             * error.input.file //=> 'a.css'
             */
            this.file = file;
        }
        if (source) {
            /**
             * @member {string} - Source code of the broken file.
             *
             * @example
             * error.source       //=> 'a { b {} }'
             * error.input.column //=> 'a b { }'
             */
            this.source = source;
        }
        if (plugin) {
            /**
             * @member {string} - Plugin name, if error came from plugin.
             *
             * @example
             * error.plugin //=> 'postcss-vars'
             */
            this.plugin = plugin;
        }
        if (typeof line !== 'undefined' && typeof column !== 'undefined') {
            /**
             * @member {number} - Source line of the error.
             *
             * @example
             * error.line       //=> 2
             * error.input.line //=> 4
             */
            this.line = line;
            /**
             * @member {number} - Source column of the error.
             *
             * @example
             * error.column       //=> 1
             * error.input.column //=> 4
             */
            this.column = column;
        }

        this.setMessage();

        if (Error.captureStackTrace) {
            Error.captureStackTrace(this, CssSyntaxError);
        }
    }

    CssSyntaxError.prototype.setMessage = function setMessage() {
        /**
         * @member {string} - Full error text in the GNU error format
         *                    with plugin, file, line and column.
         *
         * @example
         * error.message //=> 'a.css:1:1: Unclosed block'
         */
        this.message = this.plugin ? this.plugin + ': ' : '';
        this.message += this.file ? this.file : '<css input>';
        if (typeof this.line !== 'undefined') {
            this.message += ':' + this.line + ':' + this.column;
        }
        this.message += ': ' + this.reason;
    };

    /**
     * Returns a few lines of CSS source that caused the error.
     *
     * If the CSS has an input source map without `sourceContent`,
     * this method will return an empty string.
     *
     * @param {boolean} [color] whether arrow will be colored red by terminal
     *                          color codes. By default, PostCSS will detect
     *                          color support by `process.stdout.isTTY`
     *                          and `process.env.NODE_DISABLE_COLORS`.
     *
     * @example
     * error.showSourceCode() //=> "  4 | }
     *                        //      5 | a {
     *                        //    > 6 |   bad
     *                        //        |   ^
     *                        //      7 | }
     *                        //      8 | b {"
     *
     * @return {string} few lines of CSS source that caused the error
     */


    CssSyntaxError.prototype.showSourceCode = function showSourceCode(color) {
        var _this = this;

        if (!this.source) return '';

        var css = this.source;
        if (typeof color === 'undefined') color = _supportsColor2.default;
        if (color) css = (0, _terminalHighlight2.default)(css);

        var lines = css.split(/\r?\n/);
        var start = Math.max(this.line - 3, 0);
        var end = Math.min(this.line + 2, lines.length);

        var maxWidth = String(end).length;

        function mark(text) {
            if (color) {
                return _chalk2.default.red.bold(text);
            } else {
                return text;
            }
        }
        function aside(text) {
            if (color) {
                return _chalk2.default.gray(text);
            } else {
                return text;
            }
        }

        return lines.slice(start, end).map(function (line, index) {
            var number = start + 1 + index;
            var gutter = ' ' + (' ' + number).slice(-maxWidth) + ' | ';
            if (number === _this.line) {
                var spacing = aside(gutter.replace(/\d/g, ' ')) + line.slice(0, _this.column - 1).replace(/[^\t]/g, ' ');
                return mark('>') + aside(gutter) + line + '\n ' + spacing + mark('^');
            } else {
                return ' ' + aside(gutter) + line;
            }
        }).join('\n');
    };

    /**
     * Returns error position, message and source code of the broken part.
     *
     * @example
     * error.toString() //=> "CssSyntaxError: app.css:1:1: Unclosed block
     *                  //    > 1 | a {
     *                  //        | ^"
     *
     * @return {string} error position, message and source code
     */


    CssSyntaxError.prototype.toString = function toString() {
        var code = this.showSourceCode();
        if (code) {
            code = '\n\n' + code + '\n';
        }
        return this.name + ': ' + this.message + code;
    };

    /**
     * @memberof CssSyntaxError#
     * @member {Input} input - Input object with PostCSS internal information
     *                         about input file. If input has source map
     *                         from previous tool, PostCSS will use origin
     *                         (for example, Sass) source. You can use this
     *                         object to get PostCSS input source.
     *
     * @example
     * error.input.file //=> 'a.css'
     * error.file       //=> 'a.sass'
     */

    return CssSyntaxError;
}();

exports.default = CssSyntaxError;
module.exports = exports['default'];


},{"./terminal-highlight":836,"chalk":580,"supports-color":1155}],820:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _node = require('./node');

var _node2 = _interopRequireDefault(_node);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

/**
 * Represents a CSS declaration.
 *
 * @extends Node
 *
 * @example
 * const root = postcss.parse('a { color: black }');
 * const decl = root.first.first;
 * decl.type       //=> 'decl'
 * decl.toString() //=> ' color: black'
 */
var Declaration = function (_Node) {
  _inherits(Declaration, _Node);

  function Declaration(defaults) {
    _classCallCheck(this, Declaration);

    var _this = _possibleConstructorReturn(this, _Node.call(this, defaults));

    _this.type = 'decl';
    return _this;
  }

  /**
   * @memberof Declaration#
   * @member {string} prop - the declaration’s property name
   *
   * @example
   * const root = postcss.parse('a { color: black }');
   * const decl = root.first.first;
   * decl.prop //=> 'color'
   */

  /**
   * @memberof Declaration#
   * @member {string} value - the declaration’s value
   *
   * @example
   * const root = postcss.parse('a { color: black }');
   * const decl = root.first.first;
   * decl.value //=> 'black'
   */

  /**
   * @memberof Declaration#
   * @member {boolean} important - `true` if the declaration
   *                               has an !important annotation.
   *
   * @example
   * const root = postcss.parse('a { color: black !important; color: red }');
   * root.first.first.important //=> true
   * root.first.last.important  //=> undefined
   */

  /**
   * @memberof Declaration#
   * @member {object} raws - Information to generate byte-to-byte equal
   *                         node string as it was in the origin input.
   *
   * Every parser saves its own properties,
   * but the default CSS parser uses:
   *
   * * `before`: the space symbols before the node. It also stores `*`
   *   and `_` symbols before the declaration (IE hack).
   * * `between`: the symbols between the property and value
   *   for declarations.
   * * `important`: the content of the important statement,
   *   if it is not just `!important`.
   *
   * PostCSS cleans declaration from comments and extra spaces,
   * but it stores origin content in raws properties.
   * As such, if you don’t change a declaration’s value,
   * PostCSS will use the raw value with comments.
   *
   * @example
   * const root = postcss.parse('a {\n  color:black\n}')
   * root.first.first.raws //=> { before: '\n  ', between: ':' }
   */

  return Declaration;
}(_node2.default);

exports.default = Declaration;
module.exports = exports['default'];


},{"./node":825}],821:[function(require,module,exports){
arguments[4][758][0].apply(exports,arguments)
},{"./css-syntax-error":819,"./previous-map":829,"dup":758,"path":14}],822:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

var _mapGenerator = require('./map-generator');

var _mapGenerator2 = _interopRequireDefault(_mapGenerator);

var _stringify2 = require('./stringify');

var _stringify3 = _interopRequireDefault(_stringify2);

var _result = require('./result');

var _result2 = _interopRequireDefault(_result);

var _parse = require('./parse');

var _parse2 = _interopRequireDefault(_parse);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function isPromise(obj) {
    return (typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) === 'object' && typeof obj.then === 'function';
}

/**
 * A Promise proxy for the result of PostCSS transformations.
 *
 * A `LazyResult` instance is returned by {@link Processor#process}.
 *
 * @example
 * const lazy = postcss([cssnext]).process(css);
 */

var LazyResult = function () {
    function LazyResult(processor, css, opts) {
        _classCallCheck(this, LazyResult);

        this.stringified = false;
        this.processed = false;

        var root = void 0;
        if ((typeof css === 'undefined' ? 'undefined' : _typeof(css)) === 'object' && css.type === 'root') {
            root = css;
        } else if (css instanceof LazyResult || css instanceof _result2.default) {
            root = css.root;
            if (css.map) {
                if (typeof opts.map === 'undefined') opts.map = {};
                if (!opts.map.inline) opts.map.inline = false;
                opts.map.prev = css.map;
            }
        } else {
            var parser = _parse2.default;
            if (opts.syntax) parser = opts.syntax.parse;
            if (opts.parser) parser = opts.parser;
            if (parser.parse) parser = parser.parse;

            try {
                root = parser(css, opts);
            } catch (error) {
                this.error = error;
            }
        }

        this.result = new _result2.default(processor, root, opts);
    }

    /**
     * Returns a {@link Processor} instance, which will be used
     * for CSS transformations.
     * @type {Processor}
     */


    /**
     * Processes input CSS through synchronous plugins
     * and calls {@link Result#warnings()}.
     *
     * @return {Warning[]} warnings from plugins
     */
    LazyResult.prototype.warnings = function warnings() {
        return this.sync().warnings();
    };

    /**
     * Alias for the {@link LazyResult#css} property.
     *
     * @example
     * lazy + '' === lazy.css;
     *
     * @return {string} output CSS
     */


    LazyResult.prototype.toString = function toString() {
        return this.css;
    };

    /**
     * Processes input CSS through synchronous and asynchronous plugins
     * and calls `onFulfilled` with a Result instance. If a plugin throws
     * an error, the `onRejected` callback will be executed.
     *
     * It implements standard Promise API.
     *
     * @param {onFulfilled} onFulfilled - callback will be executed
     *                                    when all plugins will finish work
     * @param {onRejected}  onRejected  - callback will be executed on any error
     *
     * @return {Promise} Promise API to make queue
     *
     * @example
     * postcss([cssnext]).process(css).then(result => {
     *   console.log(result.css);
     * });
     */


    LazyResult.prototype.then = function then(onFulfilled, onRejected) {
        return this.async().then(onFulfilled, onRejected);
    };

    /**
     * Processes input CSS through synchronous and asynchronous plugins
     * and calls onRejected for each error thrown in any plugin.
     *
     * It implements standard Promise API.
     *
     * @param {onRejected} onRejected - callback will be executed on any error
     *
     * @return {Promise} Promise API to make queue
     *
     * @example
     * postcss([cssnext]).process(css).then(result => {
     *   console.log(result.css);
     * }).catch(error => {
     *   console.error(error);
     * });
     */


    LazyResult.prototype.catch = function _catch(onRejected) {
        return this.async().catch(onRejected);
    };

    LazyResult.prototype.handleError = function handleError(error, plugin) {
        try {
            this.error = error;
            if (error.name === 'CssSyntaxError' && !error.plugin) {
                error.plugin = plugin.postcssPlugin;
                error.setMessage();
            } else if (plugin.postcssVersion) {
                var pluginName = plugin.postcssPlugin;
                var pluginVer = plugin.postcssVersion;
                var runtimeVer = this.result.processor.version;
                var a = pluginVer.split('.');
                var b = runtimeVer.split('.');

                if (a[0] !== b[0] || parseInt(a[1]) > parseInt(b[1])) {
                    console.error('Unknown error from PostCSS plugin. ' + 'Your current PostCSS version ' + 'is ' + runtimeVer + ', but ' + pluginName + ' ' + 'uses ' + pluginVer + '. Perhaps this is ' + 'the source of the error below.');
                }
            }
        } catch (err) {
            if (console && console.error) console.error(err);
        }
    };

    LazyResult.prototype.asyncTick = function asyncTick(resolve, reject) {
        var _this = this;

        if (this.plugin >= this.processor.plugins.length) {
            this.processed = true;
            return resolve();
        }

        try {
            var plugin = this.processor.plugins[this.plugin];
            var promise = this.run(plugin);
            this.plugin += 1;

            if (isPromise(promise)) {
                promise.then(function () {
                    _this.asyncTick(resolve, reject);
                }).catch(function (error) {
                    _this.handleError(error, plugin);
                    _this.processed = true;
                    reject(error);
                });
            } else {
                this.asyncTick(resolve, reject);
            }
        } catch (error) {
            this.processed = true;
            reject(error);
        }
    };

    LazyResult.prototype.async = function async() {
        var _this2 = this;

        if (this.processed) {
            return new Promise(function (resolve, reject) {
                if (_this2.error) {
                    reject(_this2.error);
                } else {
                    resolve(_this2.stringify());
                }
            });
        }
        if (this.processing) {
            return this.processing;
        }

        this.processing = new Promise(function (resolve, reject) {
            if (_this2.error) return reject(_this2.error);
            _this2.plugin = 0;
            _this2.asyncTick(resolve, reject);
        }).then(function () {
            _this2.processed = true;
            return _this2.stringify();
        });

        return this.processing;
    };

    LazyResult.prototype.sync = function sync() {
        if (this.processed) return this.result;
        this.processed = true;

        if (this.processing) {
            throw new Error('Use process(css).then(cb) to work with async plugins');
        }

        if (this.error) throw this.error;

        for (var _iterator = this.result.processor.plugins, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
            var _ref;

            if (_isArray) {
                if (_i >= _iterator.length) break;
                _ref = _iterator[_i++];
            } else {
                _i = _iterator.next();
                if (_i.done) break;
                _ref = _i.value;
            }

            var plugin = _ref;

            var promise = this.run(plugin);
            if (isPromise(promise)) {
                throw new Error('Use process(css).then(cb) to work with async plugins');
            }
        }

        return this.result;
    };

    LazyResult.prototype.run = function run(plugin) {
        this.result.lastPlugin = plugin;

        try {
            return plugin(this.result.root, this.result);
        } catch (error) {
            this.handleError(error, plugin);
            throw error;
        }
    };

    LazyResult.prototype.stringify = function stringify() {
        if (this.stringified) return this.result;
        this.stringified = true;

        this.sync();

        var opts = this.result.opts;
        var str = _stringify3.default;
        if (opts.syntax) str = opts.syntax.stringify;
        if (opts.stringifier) str = opts.stringifier;
        if (str.stringify) str = str.stringify;

        var map = new _mapGenerator2.default(str, this.result.root, this.result.opts);
        var data = map.generate();
        this.result.css = data[0];
        this.result.map = data[1];

        return this.result;
    };

    _createClass(LazyResult, [{
        key: 'processor',
        get: function get() {
            return this.result.processor;
        }

        /**
         * Options from the {@link Processor#process} call.
         * @type {processOptions}
         */

    }, {
        key: 'opts',
        get: function get() {
            return this.result.opts;
        }

        /**
         * Processes input CSS through synchronous plugins, converts `Root`
         * to a CSS string and returns {@link Result#css}.
         *
         * This property will only work with synchronous plugins.
         * If the processor contains any asynchronous plugins
         * it will throw an error. This is why this method is only
         * for debug purpose, you should always use {@link LazyResult#then}.
         *
         * @type {string}
         * @see Result#css
         */

    }, {
        key: 'css',
        get: function get() {
            return this.stringify().css;
        }

        /**
         * An alias for the `css` property. Use it with syntaxes
         * that generate non-CSS output.
         *
         * This property will only work with synchronous plugins.
         * If the processor contains any asynchronous plugins
         * it will throw an error. This is why this method is only
         * for debug purpose, you should always use {@link LazyResult#then}.
         *
         * @type {string}
         * @see Result#content
         */

    }, {
        key: 'content',
        get: function get() {
            return this.stringify().content;
        }

        /**
         * Processes input CSS through synchronous plugins
         * and returns {@link Result#map}.
         *
         * This property will only work with synchronous plugins.
         * If the processor contains any asynchronous plugins
         * it will throw an error. This is why this method is only
         * for debug purpose, you should always use {@link LazyResult#then}.
         *
         * @type {SourceMapGenerator}
         * @see Result#map
         */

    }, {
        key: 'map',
        get: function get() {
            return this.stringify().map;
        }

        /**
         * Processes input CSS through synchronous plugins
         * and returns {@link Result#root}.
         *
         * This property will only work with synchronous plugins. If the processor
         * contains any asynchronous plugins it will throw an error.
         *
         * This is why this method is only for debug purpose,
         * you should always use {@link LazyResult#then}.
         *
         * @type {Root}
         * @see Result#root
         */

    }, {
        key: 'root',
        get: function get() {
            return this.sync().root;
        }

        /**
         * Processes input CSS through synchronous plugins
         * and returns {@link Result#messages}.
         *
         * This property will only work with synchronous plugins. If the processor
         * contains any asynchronous plugins it will throw an error.
         *
         * This is why this method is only for debug purpose,
         * you should always use {@link LazyResult#then}.
         *
         * @type {Message[]}
         * @see Result#messages
         */

    }, {
        key: 'messages',
        get: function get() {
            return this.sync().messages;
        }
    }]);

    return LazyResult;
}();

exports.default = LazyResult;

/**
 * @callback onFulfilled
 * @param {Result} result
 */

/**
 * @callback onRejected
 * @param {Error} error
 */

module.exports = exports['default'];


},{"./map-generator":824,"./parse":826,"./result":831,"./stringify":835}],823:[function(require,module,exports){
arguments[4][760][0].apply(exports,arguments)
},{"dup":760}],824:[function(require,module,exports){
(function (Buffer){
'use strict';

exports.__esModule = true;

var _sourceMap = require('source-map');

var _sourceMap2 = _interopRequireDefault(_sourceMap);

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var MapGenerator = function () {
    function MapGenerator(stringify, root, opts) {
        _classCallCheck(this, MapGenerator);

        this.stringify = stringify;
        this.mapOpts = opts.map || {};
        this.root = root;
        this.opts = opts;
    }

    MapGenerator.prototype.isMap = function isMap() {
        if (typeof this.opts.map !== 'undefined') {
            return !!this.opts.map;
        } else {
            return this.previous().length > 0;
        }
    };

    MapGenerator.prototype.previous = function previous() {
        var _this = this;

        if (!this.previousMaps) {
            this.previousMaps = [];
            this.root.walk(function (node) {
                if (node.source && node.source.input.map) {
                    var map = node.source.input.map;
                    if (_this.previousMaps.indexOf(map) === -1) {
                        _this.previousMaps.push(map);
                    }
                }
            });
        }

        return this.previousMaps;
    };

    MapGenerator.prototype.isInline = function isInline() {
        if (typeof this.mapOpts.inline !== 'undefined') {
            return this.mapOpts.inline;
        }

        var annotation = this.mapOpts.annotation;
        if (typeof annotation !== 'undefined' && annotation !== true) {
            return false;
        }

        if (this.previous().length) {
            return this.previous().some(function (i) {
                return i.inline;
            });
        } else {
            return true;
        }
    };

    MapGenerator.prototype.isSourcesContent = function isSourcesContent() {
        if (typeof this.mapOpts.sourcesContent !== 'undefined') {
            return this.mapOpts.sourcesContent;
        }
        if (this.previous().length) {
            return this.previous().some(function (i) {
                return i.withContent();
            });
        } else {
            return true;
        }
    };

    MapGenerator.prototype.clearAnnotation = function clearAnnotation() {
        if (this.mapOpts.annotation === false) return;

        var node = void 0;
        for (var i = this.root.nodes.length - 1; i >= 0; i--) {
            node = this.root.nodes[i];
            if (node.type !== 'comment') continue;
            if (node.text.indexOf('# sourceMappingURL=') === 0) {
                this.root.removeChild(i);
            }
        }
    };

    MapGenerator.prototype.setSourcesContent = function setSourcesContent() {
        var _this2 = this;

        var already = {};
        this.root.walk(function (node) {
            if (node.source) {
                var from = node.source.input.from;
                if (from && !already[from]) {
                    already[from] = true;
                    var relative = _this2.relative(from);
                    _this2.map.setSourceContent(relative, node.source.input.css);
                }
            }
        });
    };

    MapGenerator.prototype.applyPrevMaps = function applyPrevMaps() {
        for (var _iterator = this.previous(), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
            var _ref;

            if (_isArray) {
                if (_i >= _iterator.length) break;
                _ref = _iterator[_i++];
            } else {
                _i = _iterator.next();
                if (_i.done) break;
                _ref = _i.value;
            }

            var prev = _ref;

            var from = this.relative(prev.file);
            var root = prev.root || _path2.default.dirname(prev.file);
            var map = void 0;

            if (this.mapOpts.sourcesContent === false) {
                map = new _sourceMap2.default.SourceMapConsumer(prev.text);
                if (map.sourcesContent) {
                    map.sourcesContent = map.sourcesContent.map(function () {
                        return null;
                    });
                }
            } else {
                map = prev.consumer();
            }

            this.map.applySourceMap(map, from, this.relative(root));
        }
    };

    MapGenerator.prototype.isAnnotation = function isAnnotation() {
        if (this.isInline()) {
            return true;
        } else if (typeof this.mapOpts.annotation !== 'undefined') {
            return this.mapOpts.annotation;
        } else if (this.previous().length) {
            return this.previous().some(function (i) {
                return i.annotation;
            });
        } else {
            return true;
        }
    };

    MapGenerator.prototype.toBase64 = function toBase64(str) {
        if (Buffer) {
            if (Buffer.from && Buffer.from !== Uint8Array.from) {
                return Buffer.from(str).toString('base64');
            } else {
                return new Buffer(str).toString('base64');
            }
        } else {
            return window.btoa(unescape(encodeURIComponent(str)));
        }
    };

    MapGenerator.prototype.addAnnotation = function addAnnotation() {
        var content = void 0;

        if (this.isInline()) {

            content = 'data:application/json;base64,' + this.toBase64(this.map.toString());
        } else if (typeof this.mapOpts.annotation === 'string') {
            content = this.mapOpts.annotation;
        } else {
            content = this.outputFile() + '.map';
        }

        var eol = '\n';
        if (this.css.indexOf('\r\n') !== -1) eol = '\r\n';

        this.css += eol + '/*# sourceMappingURL=' + content + ' */';
    };

    MapGenerator.prototype.outputFile = function outputFile() {
        if (this.opts.to) {
            return this.relative(this.opts.to);
        } else if (this.opts.from) {
            return this.relative(this.opts.from);
        } else {
            return 'to.css';
        }
    };

    MapGenerator.prototype.generateMap = function generateMap() {
        this.generateString();
        if (this.isSourcesContent()) this.setSourcesContent();
        if (this.previous().length > 0) this.applyPrevMaps();
        if (this.isAnnotation()) this.addAnnotation();

        if (this.isInline()) {
            return [this.css];
        } else {
            return [this.css, this.map];
        }
    };

    MapGenerator.prototype.relative = function relative(file) {
        if (file.indexOf('<') === 0) return file;
        if (/^\w+:\/\//.test(file)) return file;

        var from = this.opts.to ? _path2.default.dirname(this.opts.to) : '.';

        if (typeof this.mapOpts.annotation === 'string') {
            from = _path2.default.dirname(_path2.default.resolve(from, this.mapOpts.annotation));
        }

        file = _path2.default.relative(from, file);
        if (_path2.default.sep === '\\') {
            return file.replace(/\\/g, '/');
        } else {
            return file;
        }
    };

    MapGenerator.prototype.sourcePath = function sourcePath(node) {
        if (this.mapOpts.from) {
            return this.mapOpts.from;
        } else {
            return this.relative(node.source.input.from);
        }
    };

    MapGenerator.prototype.generateString = function generateString() {
        var _this3 = this;

        this.css = '';
        this.map = new _sourceMap2.default.SourceMapGenerator({ file: this.outputFile() });

        var line = 1;
        var column = 1;

        var lines = void 0,
            last = void 0;
        this.stringify(this.root, function (str, node, type) {
            _this3.css += str;

            if (node && type !== 'end') {
                if (node.source && node.source.start) {
                    _this3.map.addMapping({
                        source: _this3.sourcePath(node),
                        generated: { line: line, column: column - 1 },
                        original: {
                            line: node.source.start.line,
                            column: node.source.start.column - 1
                        }
                    });
                } else {
                    _this3.map.addMapping({
                        source: '<no source>',
                        original: { line: 1, column: 0 },
                        generated: { line: line, column: column - 1 }
                    });
                }
            }

            lines = str.match(/\n/g);
            if (lines) {
                line += lines.length;
                last = str.lastIndexOf('\n');
                column = str.length - last;
            } else {
                column += str.length;
            }

            if (node && type !== 'start') {
                if (node.source && node.source.end) {
                    _this3.map.addMapping({
                        source: _this3.sourcePath(node),
                        generated: { line: line, column: column - 1 },
                        original: {
                            line: node.source.end.line,
                            column: node.source.end.column
                        }
                    });
                } else {
                    _this3.map.addMapping({
                        source: '<no source>',
                        original: { line: 1, column: 0 },
                        generated: { line: line, column: column - 1 }
                    });
                }
            }
        });
    };

    MapGenerator.prototype.generate = function generate() {
        this.clearAnnotation();

        if (this.isMap()) {
            return this.generateMap();
        } else {
            var result = '';
            this.stringify(this.root, function (i) {
                result += i;
            });
            return [result];
        }
    };

    return MapGenerator;
}();

exports.default = MapGenerator;
module.exports = exports['default'];


}).call(this,require("buffer").Buffer)
},{"buffer":5,"path":14,"source-map":864}],825:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

var _cssSyntaxError = require('./css-syntax-error');

var _cssSyntaxError2 = _interopRequireDefault(_cssSyntaxError);

var _stringifier = require('./stringifier');

var _stringifier2 = _interopRequireDefault(_stringifier);

var _stringify = require('./stringify');

var _stringify2 = _interopRequireDefault(_stringify);

var _warnOnce = require('./warn-once');

var _warnOnce2 = _interopRequireDefault(_warnOnce);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var cloneNode = function cloneNode(obj, parent) {
    var cloned = new obj.constructor();

    for (var i in obj) {
        if (!obj.hasOwnProperty(i)) continue;
        var value = obj[i];
        var type = typeof value === 'undefined' ? 'undefined' : _typeof(value);

        if (i === 'parent' && type === 'object') {
            if (parent) cloned[i] = parent;
        } else if (i === 'source') {
            cloned[i] = value;
        } else if (value instanceof Array) {
            cloned[i] = value.map(function (j) {
                return cloneNode(j, cloned);
            });
        } else {
            if (type === 'object' && value !== null) value = cloneNode(value);
            cloned[i] = value;
        }
    }

    return cloned;
};

/**
 * All node classes inherit the following common methods.
 *
 * @abstract
 */

var Node = function () {

    /**
     * @param {object} [defaults] - value for node properties
     */
    function Node() {
        var defaults = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

        _classCallCheck(this, Node);

        this.raws = {};
        if ((typeof defaults === 'undefined' ? 'undefined' : _typeof(defaults)) !== 'object' && typeof defaults !== 'undefined') {
            throw new Error('PostCSS nodes constructor accepts object, not ' + JSON.stringify(defaults));
        }
        for (var name in defaults) {
            this[name] = defaults[name];
        }
    }

    /**
     * Returns a CssSyntaxError instance containing the original position
     * of the node in the source, showing line and column numbers and also
     * a small excerpt to facilitate debugging.
     *
     * If present, an input source map will be used to get the original position
     * of the source, even from a previous compilation step
     * (e.g., from Sass compilation).
     *
     * This method produces very useful error messages.
     *
     * @param {string} message     - error description
     * @param {object} [opts]      - options
     * @param {string} opts.plugin - plugin name that created this error.
     *                               PostCSS will set it automatically.
     * @param {string} opts.word   - a word inside a node’s string that should
     *                               be highlighted as the source of the error
     * @param {number} opts.index  - an index inside a node’s string that should
     *                               be highlighted as the source of the error
     *
     * @return {CssSyntaxError} error object to throw it
     *
     * @example
     * if ( !variables[name] ) {
     *   throw decl.error('Unknown variable ' + name, { word: name });
     *   // CssSyntaxError: postcss-vars:a.sass:4:3: Unknown variable $black
     *   //   color: $black
     *   // a
     *   //          ^
     *   //   background: white
     * }
     */


    Node.prototype.error = function error(message) {
        var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

        if (this.source) {
            var pos = this.positionBy(opts);
            return this.source.input.error(message, pos.line, pos.column, opts);
        } else {
            return new _cssSyntaxError2.default(message);
        }
    };

    /**
     * This method is provided as a convenience wrapper for {@link Result#warn}.
     *
     * @param {Result} result      - the {@link Result} instance
     *                               that will receive the warning
     * @param {string} text        - warning message
     * @param {object} [opts]      - options
     * @param {string} opts.plugin - plugin name that created this warning.
     *                               PostCSS will set it automatically.
     * @param {string} opts.word   - a word inside a node’s string that should
     *                               be highlighted as the source of the warning
     * @param {number} opts.index  - an index inside a node’s string that should
     *                               be highlighted as the source of the warning
     *
     * @return {Warning} created warning object
     *
     * @example
     * const plugin = postcss.plugin('postcss-deprecated', () => {
     *   return (root, result) => {
     *     root.walkDecls('bad', decl => {
     *       decl.warn(result, 'Deprecated property bad');
     *     });
     *   };
     * });
     */


    Node.prototype.warn = function warn(result, text, opts) {
        var data = { node: this };
        for (var i in opts) {
            data[i] = opts[i];
        }return result.warn(text, data);
    };

    /**
     * Removes the node from its parent and cleans the parent properties
     * from the node and its children.
     *
     * @example
     * if ( decl.prop.match(/^-webkit-/) ) {
     *   decl.remove();
     * }
     *
     * @return {Node} node to make calls chain
     */


    Node.prototype.remove = function remove() {
        if (this.parent) {
            this.parent.removeChild(this);
        }
        this.parent = undefined;
        return this;
    };

    /**
     * Returns a CSS string representing the node.
     *
     * @param {stringifier|syntax} [stringifier] - a syntax to use
     *                                             in string generation
     *
     * @return {string} CSS string of this node
     *
     * @example
     * postcss.rule({ selector: 'a' }).toString() //=> "a {}"
     */


    Node.prototype.toString = function toString() {
        var stringifier = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _stringify2.default;

        if (stringifier.stringify) stringifier = stringifier.stringify;
        var result = '';
        stringifier(this, function (i) {
            result += i;
        });
        return result;
    };

    /**
     * Returns a clone of the node.
     *
     * The resulting cloned node and its (cloned) children will have
     * a clean parent and code style properties.
     *
     * @param {object} [overrides] - new properties to override in the clone.
     *
     * @example
     * const cloned = decl.clone({ prop: '-moz-' + decl.prop });
     * cloned.raws.before  //=> undefined
     * cloned.parent       //=> undefined
     * cloned.toString()   //=> -moz-transform: scale(0)
     *
     * @return {Node} clone of the node
     */


    Node.prototype.clone = function clone() {
        var overrides = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

        var cloned = cloneNode(this);
        for (var name in overrides) {
            cloned[name] = overrides[name];
        }
        return cloned;
    };

    /**
     * Shortcut to clone the node and insert the resulting cloned node
     * before the current node.
     *
     * @param {object} [overrides] - new properties to override in the clone.
     *
     * @example
     * decl.cloneBefore({ prop: '-moz-' + decl.prop });
     *
     * @return {Node} - new node
     */


    Node.prototype.cloneBefore = function cloneBefore() {
        var overrides = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

        var cloned = this.clone(overrides);
        this.parent.insertBefore(this, cloned);
        return cloned;
    };

    /**
     * Shortcut to clone the node and insert the resulting cloned node
     * after the current node.
     *
     * @param {object} [overrides] - new properties to override in the clone.
     *
     * @return {Node} - new node
     */


    Node.prototype.cloneAfter = function cloneAfter() {
        var overrides = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

        var cloned = this.clone(overrides);
        this.parent.insertAfter(this, cloned);
        return cloned;
    };

    /**
     * Inserts node(s) before the current node and removes the current node.
     *
     * @param {...Node} nodes - node(s) to replace current one
     *
     * @example
     * if ( atrule.name == 'mixin' ) {
     *   atrule.replaceWith(mixinRules[atrule.params]);
     * }
     *
     * @return {Node} current node to methods chain
     */


    Node.prototype.replaceWith = function replaceWith() {
        if (this.parent) {
            for (var _len = arguments.length, nodes = Array(_len), _key = 0; _key < _len; _key++) {
                nodes[_key] = arguments[_key];
            }

            for (var _iterator = nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
                var _ref;

                if (_isArray) {
                    if (_i >= _iterator.length) break;
                    _ref = _iterator[_i++];
                } else {
                    _i = _iterator.next();
                    if (_i.done) break;
                    _ref = _i.value;
                }

                var node = _ref;

                this.parent.insertBefore(this, node);
            }

            this.remove();
        }

        return this;
    };

    Node.prototype.moveTo = function moveTo(newParent) {
        (0, _warnOnce2.default)('Node#moveTo was deprecated. Use Container#append.');
        this.cleanRaws(this.root() === newParent.root());
        this.remove();
        newParent.append(this);
        return this;
    };

    Node.prototype.moveBefore = function moveBefore(otherNode) {
        (0, _warnOnce2.default)('Node#moveBefore was deprecated. Use Node#before.');
        this.cleanRaws(this.root() === otherNode.root());
        this.remove();
        otherNode.parent.insertBefore(otherNode, this);
        return this;
    };

    Node.prototype.moveAfter = function moveAfter(otherNode) {
        (0, _warnOnce2.default)('Node#moveAfter was deprecated. Use Node#after.');
        this.cleanRaws(this.root() === otherNode.root());
        this.remove();
        otherNode.parent.insertAfter(otherNode, this);
        return this;
    };

    /**
     * Returns the next child of the node’s parent.
     * Returns `undefined` if the current node is the last child.
     *
     * @return {Node|undefined} next node
     *
     * @example
     * if ( comment.text === 'delete next' ) {
     *   const next = comment.next();
     *   if ( next ) {
     *     next.remove();
     *   }
     * }
     */


    Node.prototype.next = function next() {
        var index = this.parent.index(this);
        return this.parent.nodes[index + 1];
    };

    /**
     * Returns the previous child of the node’s parent.
     * Returns `undefined` if the current node is the first child.
     *
     * @return {Node|undefined} previous node
     *
     * @example
     * const annotation = decl.prev();
     * if ( annotation.type == 'comment' ) {
     *  readAnnotation(annotation.text);
     * }
     */


    Node.prototype.prev = function prev() {
        var index = this.parent.index(this);
        return this.parent.nodes[index - 1];
    };

    /**
     * Insert new node before current node to current node’s parent.
     *
     * Just alias for `node.parent.insertBefore(node, add)`.
     *
     * @param {Node|object|string|Node[]} add - new node
     *
     * @return {Node} this node for methods chain.
     *
     * @example
     * decl.before('content: ""');
     */


    Node.prototype.before = function before(add) {
        this.parent.insertBefore(this, add);
        return this;
    };

    /**
     * Insert new node after current node to current node’s parent.
     *
     * Just alias for `node.parent.insertAfter(node, add)`.
     *
     * @param {Node|object|string|Node[]} add - new node
     *
     * @return {Node} this node for methods chain.
     *
     * @example
     * decl.after('color: black');
     */


    Node.prototype.after = function after(add) {
        this.parent.insertAfter(this, add);
        return this;
    };

    Node.prototype.toJSON = function toJSON() {
        var fixed = {};

        for (var name in this) {
            if (!this.hasOwnProperty(name)) continue;
            if (name === 'parent') continue;
            var value = this[name];

            if (value instanceof Array) {
                fixed[name] = value.map(function (i) {
                    if ((typeof i === 'undefined' ? 'undefined' : _typeof(i)) === 'object' && i.toJSON) {
                        return i.toJSON();
                    } else {
                        return i;
                    }
                });
            } else if ((typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object' && value.toJSON) {
                fixed[name] = value.toJSON();
            } else {
                fixed[name] = value;
            }
        }

        return fixed;
    };

    /**
     * Returns a {@link Node#raws} value. If the node is missing
     * the code style property (because the node was manually built or cloned),
     * PostCSS will try to autodetect the code style property by looking
     * at other nodes in the tree.
     *
     * @param {string} prop          - name of code style property
     * @param {string} [defaultType] - name of default value, it can be missed
     *                                 if the value is the same as prop
     *
     * @example
     * const root = postcss.parse('a { background: white }');
     * root.nodes[0].append({ prop: 'color', value: 'black' });
     * root.nodes[0].nodes[1].raws.before   //=> undefined
     * root.nodes[0].nodes[1].raw('before') //=> ' '
     *
     * @return {string} code style value
     */


    Node.prototype.raw = function raw(prop, defaultType) {
        var str = new _stringifier2.default();
        return str.raw(this, prop, defaultType);
    };

    /**
     * Finds the Root instance of the node’s tree.
     *
     * @example
     * root.nodes[0].nodes[0].root() === root
     *
     * @return {Root} root parent
     */


    Node.prototype.root = function root() {
        var result = this;
        while (result.parent) {
            result = result.parent;
        }return result;
    };

    Node.prototype.cleanRaws = function cleanRaws(keepBetween) {
        delete this.raws.before;
        delete this.raws.after;
        if (!keepBetween) delete this.raws.between;
    };

    Node.prototype.positionInside = function positionInside(index) {
        var string = this.toString();
        var column = this.source.start.column;
        var line = this.source.start.line;

        for (var i = 0; i < index; i++) {
            if (string[i] === '\n') {
                column = 1;
                line += 1;
            } else {
                column += 1;
            }
        }

        return { line: line, column: column };
    };

    Node.prototype.positionBy = function positionBy(opts) {
        var pos = this.source.start;
        if (opts.index) {
            pos = this.positionInside(opts.index);
        } else if (opts.word) {
            var index = this.toString().indexOf(opts.word);
            if (index !== -1) pos = this.positionInside(index);
        }
        return pos;
    };

    /**
     * @memberof Node#
     * @member {string} type - String representing the node’s type.
     *                         Possible values are `root`, `atrule`, `rule`,
     *                         `decl`, or `comment`.
     *
     * @example
     * postcss.decl({ prop: 'color', value: 'black' }).type //=> 'decl'
     */

    /**
     * @memberof Node#
     * @member {Container} parent - the node’s parent node.
     *
     * @example
     * root.nodes[0].parent == root;
     */

    /**
     * @memberof Node#
     * @member {source} source - the input source of the node
     *
     * The property is used in source map generation.
     *
     * If you create a node manually (e.g., with `postcss.decl()`),
     * that node will not have a `source` property and will be absent
     * from the source map. For this reason, the plugin developer should
     * consider cloning nodes to create new ones (in which case the new node’s
     * source will reference the original, cloned node) or setting
     * the `source` property manually.
     *
     * ```js
     * // Bad
     * const prefixed = postcss.decl({
     *   prop: '-moz-' + decl.prop,
     *   value: decl.value
     * });
     *
     * // Good
     * const prefixed = decl.clone({ prop: '-moz-' + decl.prop });
     * ```
     *
     * ```js
     * if ( atrule.name == 'add-link' ) {
     *   const rule = postcss.rule({ selector: 'a', source: atrule.source });
     *   atrule.parent.insertBefore(atrule, rule);
     * }
     * ```
     *
     * @example
     * decl.source.input.from //=> '/home/ai/a.sass'
     * decl.source.start      //=> { line: 10, column: 2 }
     * decl.source.end        //=> { line: 10, column: 12 }
     */

    /**
     * @memberof Node#
     * @member {object} raws - Information to generate byte-to-byte equal
     *                         node string as it was in the origin input.
     *
     * Every parser saves its own properties,
     * but the default CSS parser uses:
     *
     * * `before`: the space symbols before the node. It also stores `*`
     *   and `_` symbols before the declaration (IE hack).
     * * `after`: the space symbols after the last child of the node
     *   to the end of the node.
     * * `between`: the symbols between the property and value
     *   for declarations, selector and `{` for rules, or last parameter
     *   and `{` for at-rules.
     * * `semicolon`: contains true if the last child has
     *   an (optional) semicolon.
     * * `afterName`: the space between the at-rule name and its parameters.
     * * `left`: the space symbols between `/*` and the comment’s text.
     * * `right`: the space symbols between the comment’s text
     *   and <code>*&#47;</code>.
     * * `important`: the content of the important statement,
     *   if it is not just `!important`.
     *
     * PostCSS cleans selectors, declaration values and at-rule parameters
     * from comments and extra spaces, but it stores origin content in raws
     * properties. As such, if you don’t change a declaration’s value,
     * PostCSS will use the raw value with comments.
     *
     * @example
     * const root = postcss.parse('a {\n  color:black\n}')
     * root.first.first.raws //=> { before: '\n  ', between: ':' }
     */

    return Node;
}();

exports.default = Node;

/**
 * @typedef {object} position
 * @property {number} line   - source line in file
 * @property {number} column - source column in file
 */

/**
 * @typedef {object} source
 * @property {Input} input    - {@link Input} with input file
 * @property {position} start - The starting position of the node’s source
 * @property {position} end   - The ending position of the node’s source
 */

module.exports = exports['default'];


},{"./css-syntax-error":819,"./stringifier":834,"./stringify":835,"./warn-once":839}],826:[function(require,module,exports){
'use strict';

exports.__esModule = true;
exports.default = parse;

var _parser = require('./parser');

var _parser2 = _interopRequireDefault(_parser);

var _input = require('./input');

var _input2 = _interopRequireDefault(_input);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function parse(css, opts) {
    if (opts && opts.safe) {
        throw new Error('Option safe was removed. ' + 'Use parser: require("postcss-safe-parser")');
    }

    var input = new _input2.default(css, opts);
    var parser = new _parser2.default(input);
    try {
        parser.parse();
    } catch (e) {
        if (e.name === 'CssSyntaxError' && opts && opts.from) {
            if (/\.scss$/i.test(opts.from)) {
                e.message += '\nYou tried to parse SCSS with ' + 'the standard CSS parser; ' + 'try again with the postcss-scss parser';
            } else if (/\.sass/i.test(opts.from)) {
                e.message += '\nYou tried to parse Sass with ' + 'the standard CSS parser; ' + 'try again with the postcss-sass parser';
            } else if (/\.less$/i.test(opts.from)) {
                e.message += '\nYou tried to parse Less with ' + 'the standard CSS parser; ' + 'try again with the postcss-less parser';
            }
        }
        throw e;
    }

    return parser.root;
}
module.exports = exports['default'];


},{"./input":821,"./parser":827}],827:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _declaration = require('./declaration');

var _declaration2 = _interopRequireDefault(_declaration);

var _tokenize = require('./tokenize');

var _tokenize2 = _interopRequireDefault(_tokenize);

var _comment = require('./comment');

var _comment2 = _interopRequireDefault(_comment);

var _atRule = require('./at-rule');

var _atRule2 = _interopRequireDefault(_atRule);

var _root = require('./root');

var _root2 = _interopRequireDefault(_root);

var _rule = require('./rule');

var _rule2 = _interopRequireDefault(_rule);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Parser = function () {
    function Parser(input) {
        _classCallCheck(this, Parser);

        this.input = input;

        this.root = new _root2.default();
        this.current = this.root;
        this.spaces = '';
        this.semicolon = false;

        this.createTokenizer();
        this.root.source = { input: input, start: { line: 1, column: 1 } };
    }

    Parser.prototype.createTokenizer = function createTokenizer() {
        this.tokenizer = (0, _tokenize2.default)(this.input);
    };

    Parser.prototype.parse = function parse() {
        var token = void 0;
        while (!this.tokenizer.endOfFile()) {
            token = this.tokenizer.nextToken();

            switch (token[0]) {

                case 'space':
                    this.spaces += token[1];
                    break;

                case ';':
                    this.freeSemicolon(token);
                    break;

                case '}':
                    this.end(token);
                    break;

                case 'comment':
                    this.comment(token);
                    break;

                case 'at-word':
                    this.atrule(token);
                    break;

                case '{':
                    this.emptyRule(token);
                    break;

                default:
                    this.other(token);
                    break;
            }
        }
        this.endFile();
    };

    Parser.prototype.comment = function comment(token) {
        var node = new _comment2.default();
        this.init(node, token[2], token[3]);
        node.source.end = { line: token[4], column: token[5] };

        var text = token[1].slice(2, -2);
        if (/^\s*$/.test(text)) {
            node.text = '';
            node.raws.left = text;
            node.raws.right = '';
        } else {
            var match = text.match(/^(\s*)([^]*[^\s])(\s*)$/);
            node.text = match[2];
            node.raws.left = match[1];
            node.raws.right = match[3];
        }
    };

    Parser.prototype.emptyRule = function emptyRule(token) {
        var node = new _rule2.default();
        this.init(node, token[2], token[3]);
        node.selector = '';
        node.raws.between = '';
        this.current = node;
    };

    Parser.prototype.other = function other(start) {
        var end = false;
        var type = null;
        var colon = false;
        var bracket = null;
        var brackets = [];

        var tokens = [];
        var token = start;
        while (token) {
            type = token[0];
            tokens.push(token);

            if (type === '(' || type === '[') {
                if (!bracket) bracket = token;
                brackets.push(type === '(' ? ')' : ']');
            } else if (brackets.length === 0) {
                if (type === ';') {
                    if (colon) {
                        this.decl(tokens);
                        return;
                    } else {
                        break;
                    }
                } else if (type === '{') {
                    this.rule(tokens);
                    return;
                } else if (type === '}') {
                    this.tokenizer.back(tokens.pop());
                    end = true;
                    break;
                } else if (type === ':') {
                    colon = true;
                }
            } else if (type === brackets[brackets.length - 1]) {
                brackets.pop();
                if (brackets.length === 0) bracket = null;
            }

            token = this.tokenizer.nextToken();
        }

        if (this.tokenizer.endOfFile()) end = true;
        if (brackets.length > 0) this.unclosedBracket(bracket);

        if (end && colon) {
            while (tokens.length) {
                token = tokens[tokens.length - 1][0];
                if (token !== 'space' && token !== 'comment') break;
                this.tokenizer.back(tokens.pop());
            }
            this.decl(tokens);
            return;
        } else {
            this.unknownWord(tokens);
        }
    };

    Parser.prototype.rule = function rule(tokens) {
        tokens.pop();

        var node = new _rule2.default();
        this.init(node, tokens[0][2], tokens[0][3]);

        node.raws.between = this.spacesAndCommentsFromEnd(tokens);
        this.raw(node, 'selector', tokens);
        this.current = node;
    };

    Parser.prototype.decl = function decl(tokens) {
        var node = new _declaration2.default();
        this.init(node);

        var last = tokens[tokens.length - 1];
        if (last[0] === ';') {
            this.semicolon = true;
            tokens.pop();
        }
        if (last[4]) {
            node.source.end = { line: last[4], column: last[5] };
        } else {
            node.source.end = { line: last[2], column: last[3] };
        }

        while (tokens[0][0] !== 'word') {
            if (tokens.length === 1) this.unknownWord(tokens);
            node.raws.before += tokens.shift()[1];
        }
        node.source.start = { line: tokens[0][2], column: tokens[0][3] };

        node.prop = '';
        while (tokens.length) {
            var type = tokens[0][0];
            if (type === ':' || type === 'space' || type === 'comment') {
                break;
            }
            node.prop += tokens.shift()[1];
        }

        node.raws.between = '';

        var token = void 0;
        while (tokens.length) {
            token = tokens.shift();

            if (token[0] === ':') {
                node.raws.between += token[1];
                break;
            } else {
                node.raws.between += token[1];
            }
        }

        if (node.prop[0] === '_' || node.prop[0] === '*') {
            node.raws.before += node.prop[0];
            node.prop = node.prop.slice(1);
        }
        node.raws.between += this.spacesAndCommentsFromStart(tokens);
        this.precheckMissedSemicolon(tokens);

        for (var i = tokens.length - 1; i > 0; i--) {
            token = tokens[i];
            if (token[1] === '!important') {
                node.important = true;
                var string = this.stringFrom(tokens, i);
                string = this.spacesFromEnd(tokens) + string;
                if (string !== ' !important') node.raws.important = string;
                break;
            } else if (token[1] === 'important') {
                var cache = tokens.slice(0);
                var str = '';
                for (var j = i; j > 0; j--) {
                    var _type = cache[j][0];
                    if (str.trim().indexOf('!') === 0 && _type !== 'space') {
                        break;
                    }
                    str = cache.pop()[1] + str;
                }
                if (str.trim().indexOf('!') === 0) {
                    node.important = true;
                    node.raws.important = str;
                    tokens = cache;
                }
            }

            if (token[0] !== 'space' && token[0] !== 'comment') {
                break;
            }
        }

        this.raw(node, 'value', tokens);

        if (node.value.indexOf(':') !== -1) this.checkMissedSemicolon(tokens);
    };

    Parser.prototype.atrule = function atrule(token) {
        var node = new _atRule2.default();
        node.name = token[1].slice(1);
        if (node.name === '') {
            this.unnamedAtrule(node, token);
        }
        this.init(node, token[2], token[3]);

        var prev = void 0;
        var shift = void 0;
        var last = false;
        var open = false;
        var params = [];

        while (!this.tokenizer.endOfFile()) {
            token = this.tokenizer.nextToken();

            if (token[0] === ';') {
                node.source.end = { line: token[2], column: token[3] };
                this.semicolon = true;
                break;
            } else if (token[0] === '{') {
                open = true;
                break;
            } else if (token[0] === '}') {
                if (params.length > 0) {
                    shift = params.length - 1;
                    prev = params[shift];
                    while (prev && prev[0] === 'space') {
                        prev = params[--shift];
                    }
                    if (prev) {
                        node.source.end = { line: prev[4], column: prev[5] };
                    }
                }
                this.end(token);
                break;
            } else {
                params.push(token);
            }

            if (this.tokenizer.endOfFile()) {
                last = true;
                break;
            }
        }

        node.raws.between = this.spacesAndCommentsFromEnd(params);
        if (params.length) {
            node.raws.afterName = this.spacesAndCommentsFromStart(params);
            this.raw(node, 'params', params);
            if (last) {
                token = params[params.length - 1];
                node.source.end = { line: token[4], column: token[5] };
                this.spaces = node.raws.between;
                node.raws.between = '';
            }
        } else {
            node.raws.afterName = '';
            node.params = '';
        }

        if (open) {
            node.nodes = [];
            this.current = node;
        }
    };

    Parser.prototype.end = function end(token) {
        if (this.current.nodes && this.current.nodes.length) {
            this.current.raws.semicolon = this.semicolon;
        }
        this.semicolon = false;

        this.current.raws.after = (this.current.raws.after || '') + this.spaces;
        this.spaces = '';

        if (this.current.parent) {
            this.current.source.end = { line: token[2], column: token[3] };
            this.current = this.current.parent;
        } else {
            this.unexpectedClose(token);
        }
    };

    Parser.prototype.endFile = function endFile() {
        if (this.current.parent) this.unclosedBlock();
        if (this.current.nodes && this.current.nodes.length) {
            this.current.raws.semicolon = this.semicolon;
        }
        this.current.raws.after = (this.current.raws.after || '') + this.spaces;
    };

    Parser.prototype.freeSemicolon = function freeSemicolon(token) {
        this.spaces += token[1];
        if (this.current.nodes) {
            var prev = this.current.nodes[this.current.nodes.length - 1];
            if (prev && prev.type === 'rule' && !prev.raws.ownSemicolon) {
                prev.raws.ownSemicolon = this.spaces;
                this.spaces = '';
            }
        }
    };

    // Helpers

    Parser.prototype.init = function init(node, line, column) {
        this.current.push(node);

        node.source = { start: { line: line, column: column }, input: this.input };
        node.raws.before = this.spaces;
        this.spaces = '';
        if (node.type !== 'comment') this.semicolon = false;
    };

    Parser.prototype.raw = function raw(node, prop, tokens) {
        var token = void 0,
            type = void 0;
        var length = tokens.length;
        var value = '';
        var clean = true;
        for (var i = 0; i < length; i += 1) {
            token = tokens[i];
            type = token[0];
            if (type === 'comment' || type === 'space' && i === length - 1) {
                clean = false;
            } else {
                value += token[1];
            }
        }
        if (!clean) {
            var raw = tokens.reduce(function (all, i) {
                return all + i[1];
            }, '');
            node.raws[prop] = { value: value, raw: raw };
        }
        node[prop] = value;
    };

    Parser.prototype.spacesAndCommentsFromEnd = function spacesAndCommentsFromEnd(tokens) {
        var lastTokenType = void 0;
        var spaces = '';
        while (tokens.length) {
            lastTokenType = tokens[tokens.length - 1][0];
            if (lastTokenType !== 'space' && lastTokenType !== 'comment') break;
            spaces = tokens.pop()[1] + spaces;
        }
        return spaces;
    };

    Parser.prototype.spacesAndCommentsFromStart = function spacesAndCommentsFromStart(tokens) {
        var next = void 0;
        var spaces = '';
        while (tokens.length) {
            next = tokens[0][0];
            if (next !== 'space' && next !== 'comment') break;
            spaces += tokens.shift()[1];
        }
        return spaces;
    };

    Parser.prototype.spacesFromEnd = function spacesFromEnd(tokens) {
        var lastTokenType = void 0;
        var spaces = '';
        while (tokens.length) {
            lastTokenType = tokens[tokens.length - 1][0];
            if (lastTokenType !== 'space') break;
            spaces = tokens.pop()[1] + spaces;
        }
        return spaces;
    };

    Parser.prototype.stringFrom = function stringFrom(tokens, from) {
        var result = '';
        for (var i = from; i < tokens.length; i++) {
            result += tokens[i][1];
        }
        tokens.splice(from, tokens.length - from);
        return result;
    };

    Parser.prototype.colon = function colon(tokens) {
        var brackets = 0;
        var token = void 0,
            type = void 0,
            prev = void 0;
        for (var i = 0; i < tokens.length; i++) {
            token = tokens[i];
            type = token[0];

            if (type === '(') {
                brackets += 1;
            } else if (type === ')') {
                brackets -= 1;
            } else if (brackets === 0 && type === ':') {
                if (!prev) {
                    this.doubleColon(token);
                } else if (prev[0] === 'word' && prev[1] === 'progid') {
                    continue;
                } else {
                    return i;
                }
            }

            prev = token;
        }
        return false;
    };

    // Errors

    Parser.prototype.unclosedBracket = function unclosedBracket(bracket) {
        throw this.input.error('Unclosed bracket', bracket[2], bracket[3]);
    };

    Parser.prototype.unknownWord = function unknownWord(tokens) {
        throw this.input.error('Unknown word', tokens[0][2], tokens[0][3]);
    };

    Parser.prototype.unexpectedClose = function unexpectedClose(token) {
        throw this.input.error('Unexpected }', token[2], token[3]);
    };

    Parser.prototype.unclosedBlock = function unclosedBlock() {
        var pos = this.current.source.start;
        throw this.input.error('Unclosed block', pos.line, pos.column);
    };

    Parser.prototype.doubleColon = function doubleColon(token) {
        throw this.input.error('Double colon', token[2], token[3]);
    };

    Parser.prototype.unnamedAtrule = function unnamedAtrule(node, token) {
        throw this.input.error('At-rule without name', token[2], token[3]);
    };

    Parser.prototype.precheckMissedSemicolon = function precheckMissedSemicolon(tokens) {
        // Hook for Safe Parser
        tokens;
    };

    Parser.prototype.checkMissedSemicolon = function checkMissedSemicolon(tokens) {
        var colon = this.colon(tokens);
        if (colon === false) return;

        var founded = 0;
        var token = void 0;
        for (var j = colon - 1; j >= 0; j--) {
            token = tokens[j];
            if (token[0] !== 'space') {
                founded += 1;
                if (founded === 2) break;
            }
        }
        throw this.input.error('Missed semicolon', token[2], token[3]);
    };

    return Parser;
}();

exports.default = Parser;
module.exports = exports['default'];


},{"./at-rule":816,"./comment":817,"./declaration":820,"./root":832,"./rule":833,"./tokenize":837}],828:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _declaration = require('./declaration');

var _declaration2 = _interopRequireDefault(_declaration);

var _processor = require('./processor');

var _processor2 = _interopRequireDefault(_processor);

var _stringify = require('./stringify');

var _stringify2 = _interopRequireDefault(_stringify);

var _comment = require('./comment');

var _comment2 = _interopRequireDefault(_comment);

var _atRule = require('./at-rule');

var _atRule2 = _interopRequireDefault(_atRule);

var _vendor = require('./vendor');

var _vendor2 = _interopRequireDefault(_vendor);

var _parse = require('./parse');

var _parse2 = _interopRequireDefault(_parse);

var _list = require('./list');

var _list2 = _interopRequireDefault(_list);

var _rule = require('./rule');

var _rule2 = _interopRequireDefault(_rule);

var _root = require('./root');

var _root2 = _interopRequireDefault(_root);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Create a new {@link Processor} instance that will apply `plugins`
 * as CSS processors.
 *
 * @param {Array.<Plugin|pluginFunction>|Processor} plugins - PostCSS
 *        plugins. See {@link Processor#use} for plugin format.
 *
 * @return {Processor} Processor to process multiple CSS
 *
 * @example
 * import postcss from 'postcss';
 *
 * postcss(plugins).process(css, { from, to }).then(result => {
 *   console.log(result.css);
 * });
 *
 * @namespace postcss
 */
function postcss() {
  for (var _len = arguments.length, plugins = Array(_len), _key = 0; _key < _len; _key++) {
    plugins[_key] = arguments[_key];
  }

  if (plugins.length === 1 && Array.isArray(plugins[0])) {
    plugins = plugins[0];
  }
  return new _processor2.default(plugins);
}

/**
 * Creates a PostCSS plugin with a standard API.
 *
 * The newly-wrapped function will provide both the name and PostCSS
 * version of the plugin.
 *
 * ```js
 *  const processor = postcss([replace]);
 *  processor.plugins[0].postcssPlugin  //=> 'postcss-replace'
 *  processor.plugins[0].postcssVersion //=> '5.1.0'
 * ```
 *
 * The plugin function receives 2 arguments: {@link Root}
 * and {@link Result} instance. The function should mutate the provided
 * `Root` node. Alternatively, you can create a new `Root` node
 * and override the `result.root` property.
 *
 * ```js
 * const cleaner = postcss.plugin('postcss-cleaner', () => {
 *   return (root, result) => {
 *     result.root = postcss.root();
 *   };
 * });
 * ```
 *
 * As a convenience, plugins also expose a `process` method so that you can use
 * them as standalone tools.
 *
 * ```js
 * cleaner.process(css, processOpts, pluginOpts);
 * // This is equivalent to:
 * postcss([ cleaner(pluginOpts) ]).process(css, processOpts);
 * ```
 *
 * Asynchronous plugins should return a `Promise` instance.
 *
 * ```js
 * postcss.plugin('postcss-import', () => {
 *   return (root, result) => {
 *     return new Promise( (resolve, reject) => {
 *       fs.readFile('base.css', (base) => {
 *         root.prepend(base);
 *         resolve();
 *       });
 *     });
 *   };
 * });
 * ```
 *
 * Add warnings using the {@link Node#warn} method.
 * Send data to other plugins using the {@link Result#messages} array.
 *
 * ```js
 * postcss.plugin('postcss-caniuse-test', () => {
 *   return (root, result) => {
 *     css.walkDecls(decl => {
 *       if ( !caniuse.support(decl.prop) ) {
 *         decl.warn(result, 'Some browsers do not support ' + decl.prop);
 *       }
 *     });
 *   };
 * });
 * ```
 *
 * @param {string} name          - PostCSS plugin name. Same as in `name`
 *                                 property in `package.json`. It will be saved
 *                                 in `plugin.postcssPlugin` property.
 * @param {function} initializer - will receive plugin options
 *                                 and should return {@link pluginFunction}
 *
 * @return {Plugin} PostCSS plugin
 */
postcss.plugin = function plugin(name, initializer) {
  var creator = function creator() {
    var transformer = initializer.apply(undefined, arguments);
    transformer.postcssPlugin = name;
    transformer.postcssVersion = new _processor2.default().version;
    return transformer;
  };

  var cache = void 0;
  Object.defineProperty(creator, 'postcss', {
    get: function get() {
      if (!cache) cache = creator();
      return cache;
    }
  });

  creator.process = function (css, processOpts, pluginOpts) {
    return postcss([creator(pluginOpts)]).process(css, processOpts);
  };

  return creator;
};

/**
 * Default function to convert a node tree into a CSS string.
 *
 * @param {Node} node       - start node for stringifing. Usually {@link Root}.
 * @param {builder} builder - function to concatenate CSS from node’s parts
 *                            or generate string and source map
 *
 * @return {void}
 *
 * @function
 */
postcss.stringify = _stringify2.default;

/**
 * Parses source css and returns a new {@link Root} node,
 * which contains the source CSS nodes.
 *
 * @param {string|toString} css   - string with input CSS or any object
 *                                  with toString() method, like a Buffer
 * @param {processOptions} [opts] - options with only `from` and `map` keys
 *
 * @return {Root} PostCSS AST
 *
 * @example
 * // Simple CSS concatenation with source map support
 * const root1 = postcss.parse(css1, { from: file1 });
 * const root2 = postcss.parse(css2, { from: file2 });
 * root1.append(root2).toResult().css;
 *
 * @function
 */
postcss.parse = _parse2.default;

/**
 * @member {vendor} - Contains the {@link vendor} module.
 *
 * @example
 * postcss.vendor.unprefixed('-moz-tab') //=> ['tab']
 */
postcss.vendor = _vendor2.default;

/**
 * @member {list} - Contains the {@link list} module.
 *
 * @example
 * postcss.list.space('5px calc(10% + 5px)') //=> ['5px', 'calc(10% + 5px)']
 */
postcss.list = _list2.default;

/**
 * Creates a new {@link Comment} node.
 *
 * @param {object} [defaults] - properties for the new node.
 *
 * @return {Comment} new Comment node
 *
 * @example
 * postcss.comment({ text: 'test' })
 */
postcss.comment = function (defaults) {
  return new _comment2.default(defaults);
};

/**
 * Creates a new {@link AtRule} node.
 *
 * @param {object} [defaults] - properties for the new node.
 *
 * @return {AtRule} new AtRule node
 *
 * @example
 * postcss.atRule({ name: 'charset' }).toString() //=> "@charset"
 */
postcss.atRule = function (defaults) {
  return new _atRule2.default(defaults);
};

/**
 * Creates a new {@link Declaration} node.
 *
 * @param {object} [defaults] - properties for the new node.
 *
 * @return {Declaration} new Declaration node
 *
 * @example
 * postcss.decl({ prop: 'color', value: 'red' }).toString() //=> "color: red"
 */
postcss.decl = function (defaults) {
  return new _declaration2.default(defaults);
};

/**
 * Creates a new {@link Rule} node.
 *
 * @param {object} [defaults] - properties for the new node.
 *
 * @return {Rule} new Rule node
 *
 * @example
 * postcss.rule({ selector: 'a' }).toString() //=> "a {\n}"
 */
postcss.rule = function (defaults) {
  return new _rule2.default(defaults);
};

/**
 * Creates a new {@link Root} node.
 *
 * @param {object} [defaults] - properties for the new node.
 *
 * @return {Root} new Root node
 *
 * @example
 * postcss.root({ after: '\n' }).toString() //=> "\n"
 */
postcss.root = function (defaults) {
  return new _root2.default(defaults);
};

exports.default = postcss;
module.exports = exports['default'];


},{"./at-rule":816,"./comment":817,"./declaration":820,"./list":823,"./parse":826,"./processor":830,"./root":832,"./rule":833,"./stringify":835,"./vendor":838}],829:[function(require,module,exports){
(function (Buffer){
'use strict';

exports.__esModule = true;

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

var _sourceMap = require('source-map');

var _sourceMap2 = _interopRequireDefault(_sourceMap);

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _fs = require('fs');

var _fs2 = _interopRequireDefault(_fs);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function fromBase64(str) {
    if (Buffer) {
        if (Buffer.from && Buffer.from !== Uint8Array.from) {
            return Buffer.from(str, 'base64').toString();
        } else {
            return new Buffer(str, 'base64').toString();
        }
    } else {
        return window.atob(str);
    }
}

/**
 * Source map information from input CSS.
 * For example, source map after Sass compiler.
 *
 * This class will automatically find source map in input CSS or in file system
 * near input file (according `from` option).
 *
 * @example
 * const root = postcss.parse(css, { from: 'a.sass.css' });
 * root.input.map //=> PreviousMap
 */

var PreviousMap = function () {

    /**
     * @param {string}         css    - input CSS source
     * @param {processOptions} [opts] - {@link Processor#process} options
     */
    function PreviousMap(css, opts) {
        _classCallCheck(this, PreviousMap);

        this.loadAnnotation(css);
        /**
         * @member {boolean} - Was source map inlined by data-uri to input CSS.
         */
        this.inline = this.startWith(this.annotation, 'data:');

        var prev = opts.map ? opts.map.prev : undefined;
        var text = this.loadMap(opts.from, prev);
        if (text) this.text = text;
    }

    /**
     * Create a instance of `SourceMapGenerator` class
     * from the `source-map` library to work with source map information.
     *
     * It is lazy method, so it will create object only on first call
     * and then it will use cache.
     *
     * @return {SourceMapGenerator} object with source map information
     */


    PreviousMap.prototype.consumer = function consumer() {
        if (!this.consumerCache) {
            this.consumerCache = new _sourceMap2.default.SourceMapConsumer(this.text);
        }
        return this.consumerCache;
    };

    /**
     * Does source map contains `sourcesContent` with input source text.
     *
     * @return {boolean} Is `sourcesContent` present
     */


    PreviousMap.prototype.withContent = function withContent() {
        return !!(this.consumer().sourcesContent && this.consumer().sourcesContent.length > 0);
    };

    PreviousMap.prototype.startWith = function startWith(string, start) {
        if (!string) return false;
        return string.substr(0, start.length) === start;
    };

    PreviousMap.prototype.loadAnnotation = function loadAnnotation(css) {
        var match = css.match(/\/\*\s*# sourceMappingURL=(.*)\s*\*\//);
        if (match) this.annotation = match[1].trim();
    };

    PreviousMap.prototype.decodeInline = function decodeInline(text) {
        // data:application/json;charset=utf-8;base64,
        // data:application/json;charset=utf8;base64,
        // data:application/json;base64,
        var baseUri = /^data:application\/json;(?:charset=utf-?8;)?base64,/;
        var uri = 'data:application/json,';

        if (this.startWith(text, uri)) {
            return decodeURIComponent(text.substr(uri.length));
        } else if (baseUri.test(text)) {
            return fromBase64(text.substr(RegExp.lastMatch.length));
        } else {
            var encoding = text.match(/data:application\/json;([^,]+),/)[1];
            throw new Error('Unsupported source map encoding ' + encoding);
        }
    };

    PreviousMap.prototype.loadMap = function loadMap(file, prev) {
        if (prev === false) return false;

        if (prev) {
            if (typeof prev === 'string') {
                return prev;
            } else if (typeof prev === 'function') {
                var prevPath = prev(file);
                if (prevPath && _fs2.default.existsSync && _fs2.default.existsSync(prevPath)) {
                    return _fs2.default.readFileSync(prevPath, 'utf-8').toString().trim();
                } else {
                    throw new Error('Unable to load previous source map: ' + prevPath.toString());
                }
            } else if (prev instanceof _sourceMap2.default.SourceMapConsumer) {
                return _sourceMap2.default.SourceMapGenerator.fromSourceMap(prev).toString();
            } else if (prev instanceof _sourceMap2.default.SourceMapGenerator) {
                return prev.toString();
            } else if (this.isMap(prev)) {
                return JSON.stringify(prev);
            } else {
                throw new Error('Unsupported previous source map format: ' + prev.toString());
            }
        } else if (this.inline) {
            return this.decodeInline(this.annotation);
        } else if (this.annotation) {
            var map = this.annotation;
            if (file) map = _path2.default.join(_path2.default.dirname(file), map);

            this.root = _path2.default.dirname(map);
            if (_fs2.default.existsSync && _fs2.default.existsSync(map)) {
                return _fs2.default.readFileSync(map, 'utf-8').toString().trim();
            } else {
                return false;
            }
        }
    };

    PreviousMap.prototype.isMap = function isMap(map) {
        if ((typeof map === 'undefined' ? 'undefined' : _typeof(map)) !== 'object') return false;
        return typeof map.mappings === 'string' || typeof map._mappings === 'string';
    };

    return PreviousMap;
}();

exports.default = PreviousMap;
module.exports = exports['default'];


}).call(this,require("buffer").Buffer)
},{"buffer":5,"fs":4,"path":14,"source-map":864}],830:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

var _lazyResult = require('./lazy-result');

var _lazyResult2 = _interopRequireDefault(_lazyResult);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

/**
 * Contains plugins to process CSS. Create one `Processor` instance,
 * initialize its plugins, and then use that instance on numerous CSS files.
 *
 * @example
 * const processor = postcss([autoprefixer, precss]);
 * processor.process(css1).then(result => console.log(result.css));
 * processor.process(css2).then(result => console.log(result.css));
 */
var Processor = function () {

  /**
   * @param {Array.<Plugin|pluginFunction>|Processor} plugins - PostCSS
   *        plugins. See {@link Processor#use} for plugin format.
   */
  function Processor() {
    var plugins = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];

    _classCallCheck(this, Processor);

    /**
     * @member {string} - Current PostCSS version.
     *
     * @example
     * if ( result.processor.version.split('.')[0] !== '6' ) {
     *   throw new Error('This plugin works only with PostCSS 6');
     * }
     */
    this.version = '6.0.9';
    /**
     * @member {pluginFunction[]} - Plugins added to this processor.
     *
     * @example
     * const processor = postcss([autoprefixer, precss]);
     * processor.plugins.length //=> 2
     */
    this.plugins = this.normalize(plugins);
  }

  /**
   * Adds a plugin to be used as a CSS processor.
   *
   * PostCSS plugin can be in 4 formats:
   * * A plugin created by {@link postcss.plugin} method.
   * * A function. PostCSS will pass the function a @{link Root}
   *   as the first argument and current {@link Result} instance
   *   as the second.
   * * An object with a `postcss` method. PostCSS will use that method
   *   as described in #2.
   * * Another {@link Processor} instance. PostCSS will copy plugins
   *   from that instance into this one.
   *
   * Plugins can also be added by passing them as arguments when creating
   * a `postcss` instance (see [`postcss(plugins)`]).
   *
   * Asynchronous plugins should return a `Promise` instance.
   *
   * @param {Plugin|pluginFunction|Processor} plugin - PostCSS plugin
   *                                                   or {@link Processor}
   *                                                   with plugins
   *
   * @example
   * const processor = postcss()
   *   .use(autoprefixer)
   *   .use(precss);
   *
   * @return {Processes} current processor to make methods chain
   */


  Processor.prototype.use = function use(plugin) {
    this.plugins = this.plugins.concat(this.normalize([plugin]));
    return this;
  };

  /**
   * Parses source CSS and returns a {@link LazyResult} Promise proxy.
   * Because some plugins can be asynchronous it doesn’t make
   * any transformations. Transformations will be applied
   * in the {@link LazyResult} methods.
   *
   * @param {string|toString|Result} css - String with input CSS or
   *                                       any object with a `toString()`
   *                                       method, like a Buffer.
   *                                       Optionally, send a {@link Result}
   *                                       instance and the processor will
   *                                       take the {@link Root} from it.
   * @param {processOptions} [opts]      - options
   *
   * @return {LazyResult} Promise proxy
   *
   * @example
   * processor.process(css, { from: 'a.css', to: 'a.out.css' })
   *   .then(result => {
   *      console.log(result.css);
   *   });
   */


  Processor.prototype.process = function process(css) {
    var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

    return new _lazyResult2.default(this, css, opts);
  };

  Processor.prototype.normalize = function normalize(plugins) {
    var normalized = [];
    for (var _iterator = plugins, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
      var _ref;

      if (_isArray) {
        if (_i >= _iterator.length) break;
        _ref = _iterator[_i++];
      } else {
        _i = _iterator.next();
        if (_i.done) break;
        _ref = _i.value;
      }

      var i = _ref;

      if (i.postcss) i = i.postcss;

      if ((typeof i === 'undefined' ? 'undefined' : _typeof(i)) === 'object' && Array.isArray(i.plugins)) {
        normalized = normalized.concat(i.plugins);
      } else if (typeof i === 'function') {
        normalized.push(i);
      } else if ((typeof i === 'undefined' ? 'undefined' : _typeof(i)) === 'object' && (i.parse || i.stringify)) {
        throw new Error('PostCSS syntaxes cannot be used as plugins. ' + 'Instead, please use one of the ' + 'syntax/parser/stringifier options as ' + 'outlined in your PostCSS ' + 'runner documentation.');
      } else {
        throw new Error(i + ' is not a PostCSS plugin');
      }
    }
    return normalized;
  };

  return Processor;
}();

exports.default = Processor;

/**
 * @callback builder
 * @param {string} part          - part of generated CSS connected to this node
 * @param {Node}   node          - AST node
 * @param {"start"|"end"} [type] - node’s part type
 */

/**
 * @callback parser
 *
 * @param {string|toString} css   - string with input CSS or any object
 *                                  with toString() method, like a Buffer
 * @param {processOptions} [opts] - options with only `from` and `map` keys
 *
 * @return {Root} PostCSS AST
 */

/**
 * @callback stringifier
 *
 * @param {Node} node       - start node for stringifing. Usually {@link Root}.
 * @param {builder} builder - function to concatenate CSS from node’s parts
 *                            or generate string and source map
 *
 * @return {void}
 */

/**
 * @typedef {object} syntax
 * @property {parser} parse          - function to generate AST by string
 * @property {stringifier} stringify - function to generate string by AST
 */

/**
 * @typedef {object} toString
 * @property {function} toString
 */

/**
 * @callback pluginFunction
 * @param {Root} root     - parsed input CSS
 * @param {Result} result - result to set warnings or check other plugins
 */

/**
 * @typedef {object} Plugin
 * @property {function} postcss - PostCSS plugin function
 */

/**
 * @typedef {object} processOptions
 * @property {string} from             - the path of the CSS source file.
 *                                       You should always set `from`,
 *                                       because it is used in source map
 *                                       generation and syntax error messages.
 * @property {string} to               - the path where you’ll put the output
 *                                       CSS file. You should always set `to`
 *                                       to generate correct source maps.
 * @property {parser} parser           - function to generate AST by string
 * @property {stringifier} stringifier - class to generate string by AST
 * @property {syntax} syntax           - object with `parse` and `stringify`
 * @property {object} map              - source map options
 * @property {boolean} map.inline                    - does source map should
 *                                                     be embedded in the output
 *                                                     CSS as a base64-encoded
 *                                                     comment
 * @property {string|object|false|function} map.prev - source map content
 *                                                     from a previous
 *                                                     processing step
 *                                                     (for example, Sass).
 *                                                     PostCSS will try to find
 *                                                     previous map
 *                                                     automatically, so you
 *                                                     could disable it by
 *                                                     `false` value.
 * @property {boolean} map.sourcesContent            - does PostCSS should set
 *                                                     the origin content to map
 * @property {string|false} map.annotation           - does PostCSS should set
 *                                                     annotation comment to map
 * @property {string} map.from                       - override `from` in map’s
 *                                                     `sources`
 */

module.exports = exports['default'];


},{"./lazy-result":822}],831:[function(require,module,exports){
arguments[4][767][0].apply(exports,arguments)
},{"./warning":840,"dup":767}],832:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _container = require('./container');

var _container2 = _interopRequireDefault(_container);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

/**
 * Represents a CSS file and contains all its parsed nodes.
 *
 * @extends Container
 *
 * @example
 * const root = postcss.parse('a{color:black} b{z-index:2}');
 * root.type         //=> 'root'
 * root.nodes.length //=> 2
 */
var Root = function (_Container) {
    _inherits(Root, _Container);

    function Root(defaults) {
        _classCallCheck(this, Root);

        var _this = _possibleConstructorReturn(this, _Container.call(this, defaults));

        _this.type = 'root';
        if (!_this.nodes) _this.nodes = [];
        return _this;
    }

    Root.prototype.removeChild = function removeChild(child, ignore) {
        var index = this.index(child);

        if (!ignore && index === 0 && this.nodes.length > 1) {
            this.nodes[1].raws.before = this.nodes[index].raws.before;
        }

        return _Container.prototype.removeChild.call(this, child);
    };

    Root.prototype.normalize = function normalize(child, sample, type) {
        var nodes = _Container.prototype.normalize.call(this, child);

        if (sample) {
            if (type === 'prepend') {
                if (this.nodes.length > 1) {
                    sample.raws.before = this.nodes[1].raws.before;
                } else {
                    delete sample.raws.before;
                }
            } else if (this.first !== sample) {
                for (var _iterator = nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
                    var _ref;

                    if (_isArray) {
                        if (_i >= _iterator.length) break;
                        _ref = _iterator[_i++];
                    } else {
                        _i = _iterator.next();
                        if (_i.done) break;
                        _ref = _i.value;
                    }

                    var node = _ref;

                    node.raws.before = sample.raws.before;
                }
            }
        }

        return nodes;
    };

    /**
     * Returns a {@link Result} instance representing the root’s CSS.
     *
     * @param {processOptions} [opts] - options with only `to` and `map` keys
     *
     * @return {Result} result with current root’s CSS
     *
     * @example
     * const root1 = postcss.parse(css1, { from: 'a.css' });
     * const root2 = postcss.parse(css2, { from: 'b.css' });
     * root1.append(root2);
     * const result = root1.toResult({ to: 'all.css', map: true });
     */


    Root.prototype.toResult = function toResult() {
        var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

        var LazyResult = require('./lazy-result');
        var Processor = require('./processor');

        var lazy = new LazyResult(new Processor(), this, opts);
        return lazy.stringify();
    };

    /**
     * @memberof Root#
     * @member {object} raws - Information to generate byte-to-byte equal
     *                         node string as it was in the origin input.
     *
     * Every parser saves its own properties,
     * but the default CSS parser uses:
     *
     * * `after`: the space symbols after the last child to the end of file.
     * * `semicolon`: is the last child has an (optional) semicolon.
     *
     * @example
     * postcss.parse('a {}\n').raws //=> { after: '\n' }
     * postcss.parse('a {}').raws   //=> { after: '' }
     */

    return Root;
}(_container2.default);

exports.default = Root;
module.exports = exports['default'];


},{"./container":818,"./lazy-result":822,"./processor":830}],833:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _container = require('./container');

var _container2 = _interopRequireDefault(_container);

var _list = require('./list');

var _list2 = _interopRequireDefault(_list);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

/**
 * Represents a CSS rule: a selector followed by a declaration block.
 *
 * @extends Container
 *
 * @example
 * const root = postcss.parse('a{}');
 * const rule = root.first;
 * rule.type       //=> 'rule'
 * rule.toString() //=> 'a{}'
 */
var Rule = function (_Container) {
  _inherits(Rule, _Container);

  function Rule(defaults) {
    _classCallCheck(this, Rule);

    var _this = _possibleConstructorReturn(this, _Container.call(this, defaults));

    _this.type = 'rule';
    if (!_this.nodes) _this.nodes = [];
    return _this;
  }

  /**
   * An array containing the rule’s individual selectors.
   * Groups of selectors are split at commas.
   *
   * @type {string[]}
   *
   * @example
   * const root = postcss.parse('a, b { }');
   * const rule = root.first;
   *
   * rule.selector  //=> 'a, b'
   * rule.selectors //=> ['a', 'b']
   *
   * rule.selectors = ['a', 'strong'];
   * rule.selector //=> 'a, strong'
   */


  _createClass(Rule, [{
    key: 'selectors',
    get: function get() {
      return _list2.default.comma(this.selector);
    },
    set: function set(values) {
      var match = this.selector ? this.selector.match(/,\s*/) : null;
      var sep = match ? match[0] : ',' + this.raw('between', 'beforeOpen');
      this.selector = values.join(sep);
    }

    /**
     * @memberof Rule#
     * @member {string} selector - the rule’s full selector represented
     *                             as a string
     *
     * @example
     * const root = postcss.parse('a, b { }');
     * const rule = root.first;
     * rule.selector //=> 'a, b'
     */

    /**
     * @memberof Rule#
     * @member {object} raws - Information to generate byte-to-byte equal
     *                         node string as it was in the origin input.
     *
     * Every parser saves its own properties,
     * but the default CSS parser uses:
     *
     * * `before`: the space symbols before the node. It also stores `*`
     *   and `_` symbols before the declaration (IE hack).
     * * `after`: the space symbols after the last child of the node
     *   to the end of the node.
     * * `between`: the symbols between the property and value
     *   for declarations, selector and `{` for rules, or last parameter
     *   and `{` for at-rules.
     * * `semicolon`: contains `true` if the last child has
     *   an (optional) semicolon.
     * * `ownSemicolon`: contains `true` if there is semicolon after rule.
     *
     * PostCSS cleans selectors from comments and extra spaces,
     * but it stores origin content in raws properties.
     * As such, if you don’t change a declaration’s value,
     * PostCSS will use the raw value with comments.
     *
     * @example
     * const root = postcss.parse('a {\n  color:black\n}')
     * root.first.first.raws //=> { before: '', between: ' ', after: '\n' }
     */

  }]);

  return Rule;
}(_container2.default);

exports.default = Rule;
module.exports = exports['default'];


},{"./container":818,"./list":823}],834:[function(require,module,exports){
'use strict';

exports.__esModule = true;

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var defaultRaw = {
    colon: ': ',
    indent: '    ',
    beforeDecl: '\n',
    beforeRule: '\n',
    beforeOpen: ' ',
    beforeClose: '\n',
    beforeComment: '\n',
    after: '\n',
    emptyBody: '',
    commentLeft: ' ',
    commentRight: ' '
};

function capitalize(str) {
    return str[0].toUpperCase() + str.slice(1);
}

var Stringifier = function () {
    function Stringifier(builder) {
        _classCallCheck(this, Stringifier);

        this.builder = builder;
    }

    Stringifier.prototype.stringify = function stringify(node, semicolon) {
        this[node.type](node, semicolon);
    };

    Stringifier.prototype.root = function root(node) {
        this.body(node);
        if (node.raws.after) this.builder(node.raws.after);
    };

    Stringifier.prototype.comment = function comment(node) {
        var left = this.raw(node, 'left', 'commentLeft');
        var right = this.raw(node, 'right', 'commentRight');
        this.builder('/*' + left + node.text + right + '*/', node);
    };

    Stringifier.prototype.decl = function decl(node, semicolon) {
        var between = this.raw(node, 'between', 'colon');
        var string = node.prop + between + this.rawValue(node, 'value');

        if (node.important) {
            string += node.raws.important || ' !important';
        }

        if (semicolon) string += ';';
        this.builder(string, node);
    };

    Stringifier.prototype.rule = function rule(node) {
        this.block(node, this.rawValue(node, 'selector'));
        if (node.raws.ownSemicolon) {
            this.builder(node.raws.ownSemicolon, node, 'end');
        }
    };

    Stringifier.prototype.atrule = function atrule(node, semicolon) {
        var name = '@' + node.name;
        var params = node.params ? this.rawValue(node, 'params') : '';

        if (typeof node.raws.afterName !== 'undefined') {
            name += node.raws.afterName;
        } else if (params) {
            name += ' ';
        }

        if (node.nodes) {
            this.block(node, name + params);
        } else {
            var end = (node.raws.between || '') + (semicolon ? ';' : '');
            this.builder(name + params + end, node);
        }
    };

    Stringifier.prototype.body = function body(node) {
        var last = node.nodes.length - 1;
        while (last > 0) {
            if (node.nodes[last].type !== 'comment') break;
            last -= 1;
        }

        var semicolon = this.raw(node, 'semicolon');
        for (var i = 0; i < node.nodes.length; i++) {
            var child = node.nodes[i];
            var before = this.raw(child, 'before');
            if (before) this.builder(before);
            this.stringify(child, last !== i || semicolon);
        }
    };

    Stringifier.prototype.block = function block(node, start) {
        var between = this.raw(node, 'between', 'beforeOpen');
        this.builder(start + between + '{', node, 'start');

        var after = void 0;
        if (node.nodes && node.nodes.length) {
            this.body(node);
            after = this.raw(node, 'after');
        } else {
            after = this.raw(node, 'after', 'emptyBody');
        }

        if (after) this.builder(after);
        this.builder('}', node, 'end');
    };

    Stringifier.prototype.raw = function raw(node, own, detect) {
        var value = void 0;
        if (!detect) detect = own;

        // Already had
        if (own) {
            value = node.raws[own];
            if (typeof value !== 'undefined') return value;
        }

        var parent = node.parent;

        // Hack for first rule in CSS
        if (detect === 'before') {
            if (!parent || parent.type === 'root' && parent.first === node) {
                return '';
            }
        }

        // Floating child without parent
        if (!parent) return defaultRaw[detect];

        // Detect style by other nodes
        var root = node.root();
        if (!root.rawCache) root.rawCache = {};
        if (typeof root.rawCache[detect] !== 'undefined') {
            return root.rawCache[detect];
        }

        if (detect === 'before' || detect === 'after') {
            return this.beforeAfter(node, detect);
        } else {
            var method = 'raw' + capitalize(detect);
            if (this[method]) {
                value = this[method](root, node);
            } else {
                root.walk(function (i) {
                    value = i.raws[own];
                    if (typeof value !== 'undefined') return false;
                });
            }
        }

        if (typeof value === 'undefined') value = defaultRaw[detect];

        root.rawCache[detect] = value;
        return value;
    };

    Stringifier.prototype.rawSemicolon = function rawSemicolon(root) {
        var value = void 0;
        root.walk(function (i) {
            if (i.nodes && i.nodes.length && i.last.type === 'decl') {
                value = i.raws.semicolon;
                if (typeof value !== 'undefined') return false;
            }
        });
        return value;
    };

    Stringifier.prototype.rawEmptyBody = function rawEmptyBody(root) {
        var value = void 0;
        root.walk(function (i) {
            if (i.nodes && i.nodes.length === 0) {
                value = i.raws.after;
                if (typeof value !== 'undefined') return false;
            }
        });
        return value;
    };

    Stringifier.prototype.rawIndent = function rawIndent(root) {
        if (root.raws.indent) return root.raws.indent;
        var value = void 0;
        root.walk(function (i) {
            var p = i.parent;
            if (p && p !== root && p.parent && p.parent === root) {
                if (typeof i.raws.before !== 'undefined') {
                    var parts = i.raws.before.split('\n');
                    value = parts[parts.length - 1];
                    value = value.replace(/[^\s]/g, '');
                    return false;
                }
            }
        });
        return value;
    };

    Stringifier.prototype.rawBeforeComment = function rawBeforeComment(root, node) {
        var value = void 0;
        root.walkComments(function (i) {
            if (typeof i.raws.before !== 'undefined') {
                value = i.raws.before;
                if (value.indexOf('\n') !== -1) {
                    value = value.replace(/[^\n]+$/, '');
                }
                return false;
            }
        });
        if (typeof value === 'undefined') {
            value = this.raw(node, null, 'beforeDecl');
        }
        return value;
    };

    Stringifier.prototype.rawBeforeDecl = function rawBeforeDecl(root, node) {
        var value = void 0;
        root.walkDecls(function (i) {
            if (typeof i.raws.before !== 'undefined') {
                value = i.raws.before;
                if (value.indexOf('\n') !== -1) {
                    value = value.replace(/[^\n]+$/, '');
                }
                return false;
            }
        });
        if (typeof value === 'undefined') {
            value = this.raw(node, null, 'beforeRule');
        }
        return value;
    };

    Stringifier.prototype.rawBeforeRule = function rawBeforeRule(root) {
        var value = void 0;
        root.walk(function (i) {
            if (i.nodes && (i.parent !== root || root.first !== i)) {
                if (typeof i.raws.before !== 'undefined') {
                    value = i.raws.before;
                    if (value.indexOf('\n') !== -1) {
                        value = value.replace(/[^\n]+$/, '');
                    }
                    return false;
                }
            }
        });
        return value;
    };

    Stringifier.prototype.rawBeforeClose = function rawBeforeClose(root) {
        var value = void 0;
        root.walk(function (i) {
            if (i.nodes && i.nodes.length > 0) {
                if (typeof i.raws.after !== 'undefined') {
                    value = i.raws.after;
                    if (value.indexOf('\n') !== -1) {
                        value = value.replace(/[^\n]+$/, '');
                    }
                    return false;
                }
            }
        });
        return value;
    };

    Stringifier.prototype.rawBeforeOpen = function rawBeforeOpen(root) {
        var value = void 0;
        root.walk(function (i) {
            if (i.type !== 'decl') {
                value = i.raws.between;
                if (typeof value !== 'undefined') return false;
            }
        });
        return value;
    };

    Stringifier.prototype.rawColon = function rawColon(root) {
        var value = void 0;
        root.walkDecls(function (i) {
            if (typeof i.raws.between !== 'undefined') {
                value = i.raws.between.replace(/[^\s:]/g, '');
                return false;
            }
        });
        return value;
    };

    Stringifier.prototype.beforeAfter = function beforeAfter(node, detect) {
        var value = void 0;
        if (node.type === 'decl') {
            value = this.raw(node, null, 'beforeDecl');
        } else if (node.type === 'comment') {
            value = this.raw(node, null, 'beforeComment');
        } else if (detect === 'before') {
            value = this.raw(node, null, 'beforeRule');
        } else {
            value = this.raw(node, null, 'beforeClose');
        }

        var buf = node.parent;
        var depth = 0;
        while (buf && buf.type !== 'root') {
            depth += 1;
            buf = buf.parent;
        }

        if (value.indexOf('\n') !== -1) {
            var indent = this.raw(node, null, 'indent');
            if (indent.length) {
                for (var step = 0; step < depth; step++) {
                    value += indent;
                }
            }
        }

        return value;
    };

    Stringifier.prototype.rawValue = function rawValue(node, prop) {
        var value = node[prop];
        var raw = node.raws[prop];
        if (raw && raw.value === value) {
            return raw.raw;
        } else {
            return value;
        }
    };

    return Stringifier;
}();

exports.default = Stringifier;
module.exports = exports['default'];


},{}],835:[function(require,module,exports){
arguments[4][771][0].apply(exports,arguments)
},{"./stringifier":834,"dup":771}],836:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _chalk = require('chalk');

var _chalk2 = _interopRequireDefault(_chalk);

var _tokenize = require('./tokenize');

var _tokenize2 = _interopRequireDefault(_tokenize);

var _input = require('./input');

var _input2 = _interopRequireDefault(_input);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var HIGHLIGHT_THEME = {
    'brackets': _chalk2.default.cyan,
    'at-word': _chalk2.default.cyan,
    'call': _chalk2.default.cyan,
    'comment': _chalk2.default.gray,
    'string': _chalk2.default.green,
    'class': _chalk2.default.yellow,
    'hash': _chalk2.default.magenta,
    '(': _chalk2.default.cyan,
    ')': _chalk2.default.cyan,
    '{': _chalk2.default.yellow,
    '}': _chalk2.default.yellow,
    '[': _chalk2.default.yellow,
    ']': _chalk2.default.yellow,
    ':': _chalk2.default.yellow,
    ';': _chalk2.default.yellow
};

function getTokenType(_ref, processor) {
    var type = _ref[0],
        value = _ref[1];

    if (type === 'word') {
        if (value[0] === '.') {
            return 'class';
        }
        if (value[0] === '#') {
            return 'hash';
        }
    }

    if (!processor.endOfFile()) {
        var next = processor.nextToken();
        processor.back(next);
        if (next[0] === 'brackets' || next[0] === '(') return 'call';
    }

    return type;
}

function terminalHighlight(css) {
    var processor = (0, _tokenize2.default)(new _input2.default(css), { ignoreErrors: true });
    var result = '';

    var _loop = function _loop() {
        var token = processor.nextToken();
        var color = HIGHLIGHT_THEME[getTokenType(token, processor)];
        if (color) {
            result += token[1].split(/\r?\n/).map(function (i) {
                return color(i);
            }).join('\n');
        } else {
            result += token[1];
        }
    };

    while (!processor.endOfFile()) {
        _loop();
    }
    return result;
}

exports.default = terminalHighlight;
module.exports = exports['default'];


},{"./input":821,"./tokenize":837,"chalk":580}],837:[function(require,module,exports){
'use strict';

exports.__esModule = true;
exports.default = tokenizer;
var SINGLE_QUOTE = 39;
var DOUBLE_QUOTE = 34;
var BACKSLASH = 92;
var SLASH = 47;
var NEWLINE = 10;
var SPACE = 32;
var FEED = 12;
var TAB = 9;
var CR = 13;
var OPEN_SQUARE = 91;
var CLOSE_SQUARE = 93;
var OPEN_PARENTHESES = 40;
var CLOSE_PARENTHESES = 41;
var OPEN_CURLY = 123;
var CLOSE_CURLY = 125;
var SEMICOLON = 59;
var ASTERISK = 42;
var COLON = 58;
var AT = 64;

var RE_AT_END = /[ \n\t\r\f\{\(\)'"\\;/\[\]#]/g;
var RE_WORD_END = /[ \n\t\r\f\(\)\{\}:;@!'"\\\]\[#]|\/(?=\*)/g;
var RE_BAD_BRACKET = /.[\\\/\("'\n]/;
var RE_HEX_ESCAPE = /[a-f0-9]/i;

function tokenizer(input) {
    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

    var css = input.css.valueOf();
    var ignore = options.ignoreErrors;

    var code = void 0,
        next = void 0,
        quote = void 0,
        lines = void 0,
        last = void 0,
        content = void 0,
        escape = void 0,
        nextLine = void 0,
        nextOffset = void 0,
        escaped = void 0,
        escapePos = void 0,
        prev = void 0,
        n = void 0,
        currentToken = void 0;

    var length = css.length;
    var offset = -1;
    var line = 1;
    var pos = 0;
    var buffer = [];
    var returned = [];

    function unclosed(what) {
        throw input.error('Unclosed ' + what, line, pos - offset);
    }

    function endOfFile() {
        return returned.length === 0 && pos >= length;
    }

    function nextToken() {
        if (returned.length) return returned.pop();
        if (pos >= length) return;

        code = css.charCodeAt(pos);
        if (code === NEWLINE || code === FEED || code === CR && css.charCodeAt(pos + 1) !== NEWLINE) {
            offset = pos;
            line += 1;
        }

        switch (code) {
            case NEWLINE:
            case SPACE:
            case TAB:
            case CR:
            case FEED:
                next = pos;
                do {
                    next += 1;
                    code = css.charCodeAt(next);
                    if (code === NEWLINE) {
                        offset = next;
                        line += 1;
                    }
                } while (code === SPACE || code === NEWLINE || code === TAB || code === CR || code === FEED);

                currentToken = ['space', css.slice(pos, next)];
                pos = next - 1;
                break;

            case OPEN_SQUARE:
                currentToken = ['[', '[', line, pos - offset];
                break;

            case CLOSE_SQUARE:
                currentToken = [']', ']', line, pos - offset];
                break;

            case OPEN_CURLY:
                currentToken = ['{', '{', line, pos - offset];
                break;

            case CLOSE_CURLY:
                currentToken = ['}', '}', line, pos - offset];
                break;

            case COLON:
                currentToken = [':', ':', line, pos - offset];
                break;

            case SEMICOLON:
                currentToken = [';', ';', line, pos - offset];
                break;

            case OPEN_PARENTHESES:
                prev = buffer.length ? buffer.pop()[1] : '';
                n = css.charCodeAt(pos + 1);
                if (prev === 'url' && n !== SINGLE_QUOTE && n !== DOUBLE_QUOTE && n !== SPACE && n !== NEWLINE && n !== TAB && n !== FEED && n !== CR) {
                    next = pos;
                    do {
                        escaped = false;
                        next = css.indexOf(')', next + 1);
                        if (next === -1) {
                            if (ignore) {
                                next = pos;
                                break;
                            } else {
                                unclosed('bracket');
                            }
                        }
                        escapePos = next;
                        while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
                            escapePos -= 1;
                            escaped = !escaped;
                        }
                    } while (escaped);

                    currentToken = ['brackets', css.slice(pos, next + 1), line, pos - offset, line, next - offset];

                    pos = next;
                } else {
                    next = css.indexOf(')', pos + 1);
                    content = css.slice(pos, next + 1);

                    if (next === -1 || RE_BAD_BRACKET.test(content)) {
                        currentToken = ['(', '(', line, pos - offset];
                    } else {
                        currentToken = ['brackets', content, line, pos - offset, line, next - offset];
                        pos = next;
                    }
                }

                break;

            case CLOSE_PARENTHESES:
                currentToken = [')', ')', line, pos - offset];
                break;

            case SINGLE_QUOTE:
            case DOUBLE_QUOTE:
                quote = code === SINGLE_QUOTE ? '\'' : '"';
                next = pos;
                do {
                    escaped = false;
                    next = css.indexOf(quote, next + 1);
                    if (next === -1) {
                        if (ignore) {
                            next = pos + 1;
                            break;
                        } else {
                            unclosed('string');
                        }
                    }
                    escapePos = next;
                    while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
                        escapePos -= 1;
                        escaped = !escaped;
                    }
                } while (escaped);

                content = css.slice(pos, next + 1);
                lines = content.split('\n');
                last = lines.length - 1;

                if (last > 0) {
                    nextLine = line + last;
                    nextOffset = next - lines[last].length;
                } else {
                    nextLine = line;
                    nextOffset = offset;
                }

                currentToken = ['string', css.slice(pos, next + 1), line, pos - offset, nextLine, next - nextOffset];

                offset = nextOffset;
                line = nextLine;
                pos = next;
                break;

            case AT:
                RE_AT_END.lastIndex = pos + 1;
                RE_AT_END.test(css);
                if (RE_AT_END.lastIndex === 0) {
                    next = css.length - 1;
                } else {
                    next = RE_AT_END.lastIndex - 2;
                }

                currentToken = ['at-word', css.slice(pos, next + 1), line, pos - offset, line, next - offset];

                pos = next;
                break;

            case BACKSLASH:
                next = pos;
                escape = true;
                while (css.charCodeAt(next + 1) === BACKSLASH) {
                    next += 1;
                    escape = !escape;
                }
                code = css.charCodeAt(next + 1);
                if (escape && code !== SLASH && code !== SPACE && code !== NEWLINE && code !== TAB && code !== CR && code !== FEED) {
                    next += 1;
                    if (RE_HEX_ESCAPE.test(css.charAt(next))) {
                        while (RE_HEX_ESCAPE.test(css.charAt(next + 1))) {
                            next += 1;
                        }
                        if (css.charCodeAt(next + 1) === SPACE) {
                            next += 1;
                        }
                    }
                }

                currentToken = ['word', css.slice(pos, next + 1), line, pos - offset, line, next - offset];

                pos = next;
                break;

            default:
                if (code === SLASH && css.charCodeAt(pos + 1) === ASTERISK) {
                    next = css.indexOf('*/', pos + 2) + 1;
                    if (next === 0) {
                        if (ignore) {
                            next = css.length;
                        } else {
                            unclosed('comment');
                        }
                    }

                    content = css.slice(pos, next + 1);
                    lines = content.split('\n');
                    last = lines.length - 1;

                    if (last > 0) {
                        nextLine = line + last;
                        nextOffset = next - lines[last].length;
                    } else {
                        nextLine = line;
                        nextOffset = offset;
                    }

                    currentToken = ['comment', content, line, pos - offset, nextLine, next - nextOffset];

                    offset = nextOffset;
                    line = nextLine;
                    pos = next;
                } else {
                    RE_WORD_END.lastIndex = pos + 1;
                    RE_WORD_END.test(css);
                    if (RE_WORD_END.lastIndex === 0) {
                        next = css.length - 1;
                    } else {
                        next = RE_WORD_END.lastIndex - 2;
                    }

                    currentToken = ['word', css.slice(pos, next + 1), line, pos - offset, line, next - offset];

                    buffer.push(currentToken);

                    pos = next;
                }

                break;
        }

        pos++;
        return currentToken;
    }

    function back(token) {
        returned.push(token);
    }

    return {
        back: back,
        nextToken: nextToken,
        endOfFile: endOfFile
    };
}
module.exports = exports['default'];


},{}],838:[function(require,module,exports){
'use strict';

exports.__esModule = true;
/**
 * Contains helpers for working with vendor prefixes.
 *
 * @example
 * const vendor = postcss.vendor;
 *
 * @namespace vendor
 */
var vendor = {

    /**
     * Returns the vendor prefix extracted from an input string.
     *
     * @param {string} prop - string with or without vendor prefix
     *
     * @return {string} vendor prefix or empty string
     *
     * @example
     * postcss.vendor.prefix('-moz-tab-size') //=> '-moz-'
     * postcss.vendor.prefix('tab-size')      //=> ''
     */
    prefix: function prefix(prop) {
        var match = prop.match(/^(-\w+-)/);
        if (match) {
            return match[0];
        } else {
            return '';
        }
    },


    /**
     * Returns the input string stripped of its vendor prefix.
     *
     * @param {string} prop - string with or without vendor prefix
     *
     * @return {string} string name without vendor prefixes
     *
     * @example
     * postcss.vendor.unprefixed('-moz-tab-size') //=> 'tab-size'
     */
    unprefixed: function unprefixed(prop) {
        return prop.replace(/^-\w+-/, '');
    }
};

exports.default = vendor;
module.exports = exports['default'];


},{}],839:[function(require,module,exports){
arguments[4][774][0].apply(exports,arguments)
},{"dup":774}],840:[function(require,module,exports){
arguments[4][775][0].apply(exports,arguments)
},{"dup":775}],841:[function(require,module,exports){
/*!
 * preserve <https://github.com/jonschlinkert/preserve>
 *
 * Copyright (c) 2014-2015, Jon Schlinkert.
 * Licensed under the MIT license.
 */

'use strict';

/**
 * Replace tokens in `str` with a temporary, heuristic placeholder.
 *
 * ```js
 * tokens.before('{a\\,b}');
 * //=> '{__ID1__}'
 * ```
 *
 * @param  {String} `str`
 * @return {String} String with placeholders.
 * @api public
 */

exports.before = function before(str, re) {
  return str.replace(re, function (match) {
    var id = randomize();
    cache[id] = match;
    return '__ID' + id + '__';
  });
};

/**
 * Replace placeholders in `str` with original tokens.
 *
 * ```js
 * tokens.after('{__ID1__}');
 * //=> '{a\\,b}'
 * ```
 *
 * @param  {String} `str` String with placeholders
 * @return {String} `str` String with original tokens.
 * @api public
 */

exports.after = function after(str) {
  return str.replace(/__ID(.{5})__/g, function (_, id) {
    return cache[id];
  });
};

function randomize() {
  return Math.random().toString().slice(2, 7);
}

var cache = {};
},{}],842:[function(require,module,exports){
/*!
 * randomatic <https://github.com/jonschlinkert/randomatic>
 *
 * Copyright (c) 2014-2017, Jon Schlinkert.
 * Released under the MIT License.
 */

'use strict';

var isNumber = require('is-number');
var typeOf = require('kind-of');

/**
 * Expose `randomatic`
 */

module.exports = randomatic;

/**
 * Available mask characters
 */

var type = {
  lower: 'abcdefghijklmnopqrstuvwxyz',
  upper: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
  number: '0123456789',
  special: '~!@#$%^&()_+-={}[];\',.'
};

type.all = type.lower + type.upper + type.number + type.special;

/**
 * Generate random character sequences of a specified `length`,
 * based on the given `pattern`.
 *
 * @param {String} `pattern` The pattern to use for generating the random string.
 * @param {String} `length` The length of the string to generate.
 * @param {String} `options`
 * @return {String}
 * @api public
 */

function randomatic(pattern, length, options) {
  if (typeof pattern === 'undefined') {
    throw new Error('randomatic expects a string or number.');
  }

  var custom = false;
  if (arguments.length === 1) {
    if (typeof pattern === 'string') {
      length = pattern.length;

    } else if (isNumber(pattern)) {
      options = {}; length = pattern; pattern = '*';
    }
  }

  if (typeOf(length) === 'object' && length.hasOwnProperty('chars')) {
    options = length;
    pattern = options.chars;
    length = pattern.length;
    custom = true;
  }

  var opts = options || {};
  var mask = '';
  var res = '';

  // Characters to be used
  if (pattern.indexOf('?') !== -1) mask += opts.chars;
  if (pattern.indexOf('a') !== -1) mask += type.lower;
  if (pattern.indexOf('A') !== -1) mask += type.upper;
  if (pattern.indexOf('0') !== -1) mask += type.number;
  if (pattern.indexOf('!') !== -1) mask += type.special;
  if (pattern.indexOf('*') !== -1) mask += type.all;
  if (custom) mask += pattern;

  while (length--) {
    res += mask.charAt(parseInt(Math.random() * mask.length, 10));
  }
  return res;
};

},{"is-number":843,"kind-of":845}],843:[function(require,module,exports){
/*!
 * is-number <https://github.com/jonschlinkert/is-number>
 *
 * Copyright (c) 2014-2015, Jon Schlinkert.
 * Licensed under the MIT License.
 */

'use strict';

var typeOf = require('kind-of');

module.exports = function isNumber(num) {
  var type = typeOf(num);

  if (type === 'string') {
    if (!num.trim()) return false;
  } else if (type !== 'number') {
    return false;
  }

  return (num - num + 1) >= 0;
};

},{"kind-of":844}],844:[function(require,module,exports){
arguments[4][689][0].apply(exports,arguments)
},{"dup":689,"is-buffer":640}],845:[function(require,module,exports){
var isBuffer = require('is-buffer');
var toString = Object.prototype.toString;

/**
 * Get the native `typeof` a value.
 *
 * @param  {*} `val`
 * @return {*} Native javascript type
 */

module.exports = function kindOf(val) {
  // primitivies
  if (typeof val === 'undefined') {
    return 'undefined';
  }
  if (val === null) {
    return 'null';
  }
  if (val === true || val === false || val instanceof Boolean) {
    return 'boolean';
  }
  if (typeof val === 'string' || val instanceof String) {
    return 'string';
  }
  if (typeof val === 'number' || val instanceof Number) {
    return 'number';
  }

  // functions
  if (typeof val === 'function' || val instanceof Function) {
    return 'function';
  }

  // array
  if (typeof Array.isArray !== 'undefined' && Array.isArray(val)) {
    return 'array';
  }

  // check for instances of RegExp and Date before calling `toString`
  if (val instanceof RegExp) {
    return 'regexp';
  }
  if (val instanceof Date) {
    return 'date';
  }

  // other objects
  var type = toString.call(val);

  if (type === '[object RegExp]') {
    return 'regexp';
  }
  if (type === '[object Date]') {
    return 'date';
  }
  if (type === '[object Arguments]') {
    return 'arguments';
  }
  if (type === '[object Error]') {
    return 'error';
  }
  if (type === '[object Promise]') {
    return 'promise';
  }

  // buffer
  if (isBuffer(val)) {
    return 'buffer';
  }

  // es6: Map, WeakMap, Set, WeakSet
  if (type === '[object Set]') {
    return 'set';
  }
  if (type === '[object WeakSet]') {
    return 'weakset';
  }
  if (type === '[object Map]') {
    return 'map';
  }
  if (type === '[object WeakMap]') {
    return 'weakmap';
  }
  if (type === '[object Symbol]') {
    return 'symbol';
  }

  // typed arrays
  if (type === '[object Int8Array]') {
    return 'int8array';
  }
  if (type === '[object Uint8Array]') {
    return 'uint8array';
  }
  if (type === '[object Uint8ClampedArray]') {
    return 'uint8clampedarray';
  }
  if (type === '[object Int16Array]') {
    return 'int16array';
  }
  if (type === '[object Uint16Array]') {
    return 'uint16array';
  }
  if (type === '[object Int32Array]') {
    return 'int32array';
  }
  if (type === '[object Uint32Array]') {
    return 'uint32array';
  }
  if (type === '[object Float32Array]') {
    return 'float32array';
  }
  if (type === '[object Float64Array]') {
    return 'float64array';
  }

  // must be a plain object
  return 'object';
};

},{"is-buffer":640}],846:[function(require,module,exports){
/*!
 * regex-cache <https://github.com/jonschlinkert/regex-cache>
 *
 * Copyright (c) 2015 Jon Schlinkert.
 * Licensed under the MIT license.
 */

'use strict';

var isPrimitive = require('is-primitive');
var equal = require('is-equal-shallow');
var basic = {};
var cache = {};

/**
 * Expose `regexCache`
 */

module.exports = regexCache;

/**
 * Memoize the results of a call to the new RegExp constructor.
 *
 * @param  {Function} fn [description]
 * @param  {String} str [description]
 * @param  {Options} options [description]
 * @param  {Boolean} nocompare [description]
 * @return {RegExp}
 */

function regexCache(fn, str, opts) {
  var key = '_default_', regex, cached;

  if (!str && !opts) {
    if (typeof fn !== 'function') {
      return fn;
    }
    return basic[key] || (basic[key] = fn(str));
  }

  var isString = typeof str === 'string';
  if (isString) {
    if (!opts) {
      return basic[str] || (basic[str] = fn(str));
    }
    key = str;
  } else {
    opts = str;
  }

  cached = cache[key];
  if (cached && equal(cached.opts, opts)) {
    return cached.regex;
  }

  memo(key, opts, (regex = fn(str, opts)));
  return regex;
}

function memo(key, opts, regex) {
  cache[key] = {regex: regex, opts: opts};
}

/**
 * Expose `cache`
 */

module.exports.cache = cache;
module.exports.basic = basic;

},{"is-equal-shallow":643,"is-primitive":653}],847:[function(require,module,exports){
(function (process){
var isWin = process.platform === 'win32';

module.exports = function (str) {
	while (endsInSeparator(str)) {
		str = str.slice(0, -1);
	}
	return str;
};

function endsInSeparator(str) {
	var last = str[str.length - 1];
	return str.length > 1 && (last === '/' || (isWin && last === '\\'));
}

}).call(this,require('_process'))
},{"_process":16}],848:[function(require,module,exports){
/*!
 * repeat-element <https://github.com/jonschlinkert/repeat-element>
 *
 * Copyright (c) 2015 Jon Schlinkert.
 * Licensed under the MIT license.
 */

'use strict';

module.exports = function repeat(ele, num) {
  var arr = new Array(num);

  for (var i = 0; i < num; i++) {
    arr[i] = ele;
  }

  return arr;
};

},{}],849:[function(require,module,exports){
/*!
 * repeat-string <https://github.com/jonschlinkert/repeat-string>
 *
 * Copyright (c) 2014-2015, Jon Schlinkert.
 * Licensed under the MIT License.
 */

'use strict';

/**
 * Results cache
 */

var res = '';
var cache;

/**
 * Expose `repeat`
 */

module.exports = repeat;

/**
 * Repeat the given `string` the specified `number`
 * of times.
 *
 * **Example:**
 *
 * ```js
 * var repeat = require('repeat-string');
 * repeat('A', 5);
 * //=> AAAAA
 * ```
 *
 * @param {String} `string` The string to repeat
 * @param {Number} `number` The number of times to repeat the string
 * @return {String} Repeated string
 * @api public
 */

function repeat(str, num) {
  if (typeof str !== 'string') {
    throw new TypeError('expected a string');
  }

  // cover common, quick use cases
  if (num === 1) return str;
  if (num === 2) return str + str;

  var max = str.length * num;
  if (cache !== str || typeof cache === 'undefined') {
    cache = str;
    res = '';
  } else if (res.length >= max) {
    return res.substr(0, max);
  }

  while (max > res.length && num > 1) {
    if (num & 1) {
      res += str;
    }

    num >>= 1;
    str += str;
  }

  res += str;
  res = res.substr(0, max);
  return res;
}

},{}],850:[function(require,module,exports){
'use strict';

var Module = require('module');
var path = require('path');

module.exports = function requireFromString(code, filename, opts) {
	if (typeof filename === 'object') {
		opts = filename;
		filename = undefined;
	}

	opts = opts || {};
	filename = filename || '';

	opts.appendPaths = opts.appendPaths || [];
	opts.prependPaths = opts.prependPaths || [];

	if (typeof code !== 'string') {
		throw new Error('code must be a string, not ' + typeof code);
	}

	var paths = Module._nodeModulePaths(path.dirname(filename));

	var m = new Module(filename, module.parent);
	m.filename = filename;
	m.paths = [].concat(opts.prependPaths).concat(paths).concat(opts.appendPaths);
	m._compile(code, filename);

	return m.exports;
};

},{"module":1,"path":14}],851:[function(require,module,exports){
'use strict';
const path = require('path');
const Module = require('module');

const resolveFrom = (fromDir, moduleId, silent) => {
	if (typeof fromDir !== 'string') {
		throw new TypeError(`Expected \`fromDir\` to be of type \`string\`, got \`${typeof fromDir}\``);
	}

	if (typeof moduleId !== 'string') {
		throw new TypeError(`Expected \`moduleId\` to be of type \`string\`, got \`${typeof moduleId}\``);
	}

	fromDir = path.resolve(fromDir);
	const fromFile = path.join(fromDir, 'noop.js');

	const resolveFileName = () => Module._resolveFilename(moduleId, {
		id: fromFile,
		filename: fromFile,
		paths: Module._nodeModulePaths(fromDir)
	});

	if (silent) {
		try {
			return resolveFileName();
		} catch (err) {
			return null;
		}
	}

	return resolveFileName();
};

module.exports = (fromDir, moduleId) => resolveFrom(fromDir, moduleId);
module.exports.silent = (fromDir, moduleId) => resolveFrom(fromDir, moduleId, true);

},{"module":1,"path":14}],852:[function(require,module,exports){
(function (process){
module.exports = rimraf
rimraf.sync = rimrafSync

var assert = require("assert")
var path = require("path")
var fs = require("fs")
var glob = require("glob")

var defaultGlobOpts = {
  nosort: true,
  silent: true
}

// for EMFILE handling
var timeout = 0

var isWindows = (process.platform === "win32")

function defaults (options) {
  var methods = [
    'unlink',
    'chmod',
    'stat',
    'lstat',
    'rmdir',
    'readdir'
  ]
  methods.forEach(function(m) {
    options[m] = options[m] || fs[m]
    m = m + 'Sync'
    options[m] = options[m] || fs[m]
  })

  options.maxBusyTries = options.maxBusyTries || 3
  options.emfileWait = options.emfileWait || 1000
  if (options.glob === false) {
    options.disableGlob = true
  }
  options.disableGlob = options.disableGlob || false
  options.glob = options.glob || defaultGlobOpts
}

function rimraf (p, options, cb) {
  if (typeof options === 'function') {
    cb = options
    options = {}
  }

  assert(p, 'rimraf: missing path')
  assert.equal(typeof p, 'string', 'rimraf: path should be a string')
  assert.equal(typeof cb, 'function', 'rimraf: callback function required')
  assert(options, 'rimraf: invalid options argument provided')
  assert.equal(typeof options, 'object', 'rimraf: options should be object')

  defaults(options)

  var busyTries = 0
  var errState = null
  var n = 0

  if (options.disableGlob || !glob.hasMagic(p))
    return afterGlob(null, [p])

  options.lstat(p, function (er, stat) {
    if (!er)
      return afterGlob(null, [p])

    glob(p, options.glob, afterGlob)
  })

  function next (er) {
    errState = errState || er
    if (--n === 0)
      cb(errState)
  }

  function afterGlob (er, results) {
    if (er)
      return cb(er)

    n = results.length
    if (n === 0)
      return cb()

    results.forEach(function (p) {
      rimraf_(p, options, function CB (er) {
        if (er) {
          if ((er.code === "EBUSY" || er.code === "ENOTEMPTY" || er.code === "EPERM") &&
              busyTries < options.maxBusyTries) {
            busyTries ++
            var time = busyTries * 100
            // try again, with the same exact callback as this one.
            return setTimeout(function () {
              rimraf_(p, options, CB)
            }, time)
          }

          // this one won't happen if graceful-fs is used.
          if (er.code === "EMFILE" && timeout < options.emfileWait) {
            return setTimeout(function () {
              rimraf_(p, options, CB)
            }, timeout ++)
          }

          // already gone
          if (er.code === "ENOENT") er = null
        }

        timeout = 0
        next(er)
      })
    })
  }
}

// Two possible strategies.
// 1. Assume it's a file.  unlink it, then do the dir stuff on EPERM or EISDIR
// 2. Assume it's a directory.  readdir, then do the file stuff on ENOTDIR
//
// Both result in an extra syscall when you guess wrong.  However, there
// are likely far more normal files in the world than directories.  This
// is based on the assumption that a the average number of files per
// directory is >= 1.
//
// If anyone ever complains about this, then I guess the strategy could
// be made configurable somehow.  But until then, YAGNI.
function rimraf_ (p, options, cb) {
  assert(p)
  assert(options)
  assert(typeof cb === 'function')

  // sunos lets the root user unlink directories, which is... weird.
  // so we have to lstat here and make sure it's not a dir.
  options.lstat(p, function (er, st) {
    if (er && er.code === "ENOENT")
      return cb(null)

    // Windows can EPERM on stat.  Life is suffering.
    if (er && er.code === "EPERM" && isWindows)
      fixWinEPERM(p, options, er, cb)

    if (st && st.isDirectory())
      return rmdir(p, options, er, cb)

    options.unlink(p, function (er) {
      if (er) {
        if (er.code === "ENOENT")
          return cb(null)
        if (er.code === "EPERM")
          return (isWindows)
            ? fixWinEPERM(p, options, er, cb)
            : rmdir(p, options, er, cb)
        if (er.code === "EISDIR")
          return rmdir(p, options, er, cb)
      }
      return cb(er)
    })
  })
}

function fixWinEPERM (p, options, er, cb) {
  assert(p)
  assert(options)
  assert(typeof cb === 'function')
  if (er)
    assert(er instanceof Error)

  options.chmod(p, 666, function (er2) {
    if (er2)
      cb(er2.code === "ENOENT" ? null : er)
    else
      options.stat(p, function(er3, stats) {
        if (er3)
          cb(er3.code === "ENOENT" ? null : er)
        else if (stats.isDirectory())
          rmdir(p, options, er, cb)
        else
          options.unlink(p, cb)
      })
  })
}

function fixWinEPERMSync (p, options, er) {
  assert(p)
  assert(options)
  if (er)
    assert(er instanceof Error)

  try {
    options.chmodSync(p, 666)
  } catch (er2) {
    if (er2.code === "ENOENT")
      return
    else
      throw er
  }

  try {
    var stats = options.statSync(p)
  } catch (er3) {
    if (er3.code === "ENOENT")
      return
    else
      throw er
  }

  if (stats.isDirectory())
    rmdirSync(p, options, er)
  else
    options.unlinkSync(p)
}

function rmdir (p, options, originalEr, cb) {
  assert(p)
  assert(options)
  if (originalEr)
    assert(originalEr instanceof Error)
  assert(typeof cb === 'function')

  // try to rmdir first, and only readdir on ENOTEMPTY or EEXIST (SunOS)
  // if we guessed wrong, and it's not a directory, then
  // raise the original error.
  options.rmdir(p, function (er) {
    if (er && (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM"))
      rmkids(p, options, cb)
    else if (er && er.code === "ENOTDIR")
      cb(originalEr)
    else
      cb(er)
  })
}

function rmkids(p, options, cb) {
  assert(p)
  assert(options)
  assert(typeof cb === 'function')

  options.readdir(p, function (er, files) {
    if (er)
      return cb(er)
    var n = files.length
    if (n === 0)
      return options.rmdir(p, cb)
    var errState
    files.forEach(function (f) {
      rimraf(path.join(p, f), options, function (er) {
        if (errState)
          return
        if (er)
          return cb(errState = er)
        if (--n === 0)
          options.rmdir(p, cb)
      })
    })
  })
}

// this looks simpler, and is strictly *faster*, but will
// tie up the JavaScript thread and fail on excessively
// deep directory trees.
function rimrafSync (p, options) {
  options = options || {}
  defaults(options)

  assert(p, 'rimraf: missing path')
  assert.equal(typeof p, 'string', 'rimraf: path should be a string')
  assert(options, 'rimraf: missing options')
  assert.equal(typeof options, 'object', 'rimraf: options should be object')

  var results

  if (options.disableGlob || !glob.hasMagic(p)) {
    results = [p]
  } else {
    try {
      options.lstatSync(p)
      results = [p]
    } catch (er) {
      results = glob.sync(p, options.glob)
    }
  }

  if (!results.length)
    return

  for (var i = 0; i < results.length; i++) {
    var p = results[i]

    try {
      var st = options.lstatSync(p)
    } catch (er) {
      if (er.code === "ENOENT")
        return

      // Windows can EPERM on stat.  Life is suffering.
      if (er.code === "EPERM" && isWindows)
        fixWinEPERMSync(p, options, er)
    }

    try {
      // sunos lets the root user unlink directories, which is... weird.
      if (st && st.isDirectory())
        rmdirSync(p, options, null)
      else
        options.unlinkSync(p)
    } catch (er) {
      if (er.code === "ENOENT")
        return
      if (er.code === "EPERM")
        return isWindows ? fixWinEPERMSync(p, options, er) : rmdirSync(p, options, er)
      if (er.code !== "EISDIR")
        throw er

      rmdirSync(p, options, er)
    }
  }
}

function rmdirSync (p, options, originalEr) {
  assert(p)
  assert(options)
  if (originalEr)
    assert(originalEr instanceof Error)

  try {
    options.rmdirSync(p)
  } catch (er) {
    if (er.code === "ENOENT")
      return
    if (er.code === "ENOTDIR")
      throw originalEr
    if (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM")
      rmkidsSync(p, options)
  }
}

function rmkidsSync (p, options) {
  assert(p)
  assert(options)
  options.readdirSync(p).forEach(function (f) {
    rimrafSync(path.join(p, f), options)
  })

  // We only end up here once we got ENOTEMPTY at least once, and
  // at this point, we are guaranteed to have removed all the kids.
  // So, we know that it won't be ENOENT or ENOTDIR or anything else.
  // try really hard to delete stuff on windows, because it has a
  // PROFOUNDLY annoying habit of not closing handles promptly when
  // files are deleted, resulting in spurious ENOTEMPTY errors.
  var retries = isWindows ? 100 : 1
  var i = 0
  do {
    var threw = true
    try {
      var ret = options.rmdirSync(p, options)
      threw = false
      return ret
    } finally {
      if (++i < retries && threw)
        continue
    }
  } while (true)
}

}).call(this,require('_process'))
},{"_process":16,"assert":2,"fs":1,"glob":622,"path":14}],853:[function(require,module,exports){
'use strict';

var ESCAPES = [
	'\u001b',
	'\u009b'
];

var END_CODE = 39;

var ESCAPE_CODES = {
	0: 0,
	1: 22,
	2: 22,
	3: 23,
	4: 24,
	7: 27,
	8: 28,
	9: 29,
	30: 39,
	31: 39,
	32: 39,
	33: 39,
	34: 39,
	35: 39,
	36: 39,
	37: 39,
	90: 39,
	40: 49,
	41: 49,
	42: 49,
	43: 49,
	44: 49,
	45: 49,
	46: 49,
	47: 49
};

function wrapAnsi(code) {
	return ESCAPES[0] + '[' + code + 'm';
}

module.exports = function (str, begin, end) {
	end = end || str.length;
	var insideEscape = false;
	var escapeCode;
	var visible = 0;
	var output = '';

	for (var i = 0; i < str.length; i++) {
		var leftEscape = false;
		var x = str[i];

		if (ESCAPES.indexOf(x) !== -1) {
			insideEscape = true;
			var code = /[0-9][^m]*/.exec(str.slice(i, i + 4));
			escapeCode = code === END_CODE ? null : code;
		} else if (insideEscape && x === 'm') {
			insideEscape = false;
			leftEscape = true;
		}

		if (!insideEscape && !leftEscape) {
			++visible;
		}

		if (visible > begin && visible <= end) {
			output += x;
		} else if (visible === begin && escapeCode !== undefined && escapeCode !== END_CODE) {
			output += wrapAnsi(escapeCode);
		} else if (visible >= end) {
			if (escapeCode !== undefined) {
				output += wrapAnsi(ESCAPE_CODES[escapeCode] || END_CODE);
			}
			break;
		}
	}

	return output;
};


},{}],854:[function(require,module,exports){
/* -*- Mode: js; js-indent-level: 2; -*- */
/*
 * Copyright 2011 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE or:
 * http://opensource.org/licenses/BSD-3-Clause
 */

var util = require('./util');
var has = Object.prototype.hasOwnProperty;

/**
 * A data structure which is a combination of an array and a set. Adding a new
 * member is O(1), testing for membership is O(1), and finding the index of an
 * element is O(1). Removing elements from the set is not supported. Only
 * strings are supported for membership.
 */
function ArraySet() {
  this._array = [];
  this._set = Object.create(null);
}

/**
 * Static method for creating ArraySet instances from an existing array.
 */
ArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {
  var set = new ArraySet();
  for (var i = 0, len = aArray.length; i < len; i++) {
    set.add(aArray[i], aAllowDuplicates);
  }
  return set;
};

/**
 * Return how many unique items are in this ArraySet. If duplicates have been
 * added, than those do not count towards the size.
 *
 * @returns Number
 */
ArraySet.prototype.size = function ArraySet_size() {
  return Object.getOwnPropertyNames(this._set).length;
};

/**
 * Add the given string to this set.
 *
 * @param String aStr
 */
ArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {
  var sStr = util.toSetString(aStr);
  var isDuplicate = has.call(this._set, sStr);
  var idx = this._array.length;
  if (!isDuplicate || aAllowDuplicates) {
    this._array.push(aStr);
  }
  if (!isDuplicate) {
    this._set[sStr] = idx;
  }
};

/**
 * Is the given string a member of this set?
 *
 * @param String aStr
 */
ArraySet.prototype.has = function ArraySet_has(aStr) {
  var sStr = util.toSetString(aStr);
  return has.call(this._set, sStr);
};

/**
 * What is the index of the given string in the array?
 *
 * @param String aStr
 */
ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {
  var sStr = util.toSetString(aStr);
  if (has.call(this._set, sStr)) {
    return this._set[sStr];
  }
  throw new Error('"' + aStr + '" is not in the set.');
};

/**
 * What is the element at the given index?
 *
 * @param Number aIdx
 */
ArraySet.prototype.at = function ArraySet_at(aIdx) {
  if (aIdx >= 0 && aIdx < this._array.length) {
    return this._array[aIdx];
  }
  throw new Error('No element indexed by ' + aIdx);
};

/**
 * Returns the array representation of this set (which has the proper indices
 * indicated by indexOf). Note that this is a copy of the internal array used
 * for storing the members so that no one can mess with internal state.
 */
ArraySet.prototype.toArray = function ArraySet_toArray() {
  return this._array.slice();
};

exports.ArraySet = ArraySet;

},{"./util":863}],855:[function(require,module,exports){
/* -*- Mode: js; js-indent-level: 2; -*- */
/*
 * Copyright 2011 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE or:
 * http://opensource.org/licenses/BSD-3-Clause
 *
 * Based on the Base 64 VLQ implementation in Closure Compiler:
 * https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java
 *
 * Copyright 2011 The Closure Compiler Authors. All rights reserved.
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following
 *    disclaimer in the documentation and/or other materials provided
 *    with the distribution.
 *  * Neither the name of Google Inc. nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

var base64 = require('./base64');

// A single base 64 digit can contain 6 bits of data. For the base 64 variable
// length quantities we use in the source map spec, the first bit is the sign,
// the next four bits are the actual value, and the 6th bit is the
// continuation bit. The continuation bit tells us whether there are more
// digits in this value following this digit.
//
//   Continuation
//   |    Sign
//   |    |
//   V    V
//   101011

var VLQ_BASE_SHIFT = 5;

// binary: 100000
var VLQ_BASE = 1 << VLQ_BASE_SHIFT;

// binary: 011111
var VLQ_BASE_MASK = VLQ_BASE - 1;

// binary: 100000
var VLQ_CONTINUATION_BIT = VLQ_BASE;

/**
 * Converts from a two-complement value to a value where the sign bit is
 * placed in the least significant bit.  For example, as decimals:
 *   1 becomes 2 (10 binary), -1 becomes 3 (11 binary)
 *   2 becomes 4 (100 binary), -2 becomes 5 (101 binary)
 */
function toVLQSigned(aValue) {
  return aValue < 0
    ? ((-aValue) << 1) + 1
    : (aValue << 1) + 0;
}

/**
 * Converts to a two-complement value from a value where the sign bit is
 * placed in the least significant bit.  For example, as decimals:
 *   2 (10 binary) becomes 1, 3 (11 binary) becomes -1
 *   4 (100 binary) becomes 2, 5 (101 binary) becomes -2
 */
function fromVLQSigned(aValue) {
  var isNegative = (aValue & 1) === 1;
  var shifted = aValue >> 1;
  return isNegative
    ? -shifted
    : shifted;
}

/**
 * Returns the base 64 VLQ encoded value.
 */
exports.encode = function base64VLQ_encode(aValue) {
  var encoded = "";
  var digit;

  var vlq = toVLQSigned(aValue);

  do {
    digit = vlq & VLQ_BASE_MASK;
    vlq >>>= VLQ_BASE_SHIFT;
    if (vlq > 0) {
      // There are still more digits in this value, so we must make sure the
      // continuation bit is marked.
      digit |= VLQ_CONTINUATION_BIT;
    }
    encoded += base64.encode(digit);
  } while (vlq > 0);

  return encoded;
};

/**
 * Decodes the next base 64 VLQ value from the given string and returns the
 * value and the rest of the string via the out parameter.
 */
exports.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {
  var strLen = aStr.length;
  var result = 0;
  var shift = 0;
  var continuation, digit;

  do {
    if (aIndex >= strLen) {
      throw new Error("Expected more digits in base 64 VLQ value.");
    }

    digit = base64.decode(aStr.charCodeAt(aIndex++));
    if (digit === -1) {
      throw new Error("Invalid base64 digit: " + aStr.charAt(aIndex - 1));
    }

    continuation = !!(digit & VLQ_CONTINUATION_BIT);
    digit &= VLQ_BASE_MASK;
    result = result + (digit << shift);
    shift += VLQ_BASE_SHIFT;
  } while (continuation);

  aOutParam.value = fromVLQSigned(result);
  aOutParam.rest = aIndex;
};

},{"./base64":856}],856:[function(require,module,exports){
/* -*- Mode: js; js-indent-level: 2; -*- */
/*
 * Copyright 2011 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE or:
 * http://opensource.org/licenses/BSD-3-Clause
 */

var intToCharMap = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');

/**
 * Encode an integer in the range of 0 to 63 to a single base 64 digit.
 */
exports.encode = function (number) {
  if (0 <= number && number < intToCharMap.length) {
    return intToCharMap[number];
  }
  throw new TypeError("Must be between 0 and 63: " + number);
};

/**
 * Decode a single base 64 character code digit to an integer. Returns -1 on
 * failure.
 */
exports.decode = function (charCode) {
  var bigA = 65;     // 'A'
  var bigZ = 90;     // 'Z'

  var littleA = 97;  // 'a'
  var littleZ = 122; // 'z'

  var zero = 48;     // '0'
  var nine = 57;     // '9'

  var plus = 43;     // '+'
  var slash = 47;    // '/'

  var littleOffset = 26;
  var numberOffset = 52;

  // 0 - 25: ABCDEFGHIJKLMNOPQRSTUVWXYZ
  if (bigA <= charCode && charCode <= bigZ) {
    return (charCode - bigA);
  }

  // 26 - 51: abcdefghijklmnopqrstuvwxyz
  if (littleA <= charCode && charCode <= littleZ) {
    return (charCode - littleA + littleOffset);
  }

  // 52 - 61: 0123456789
  if (zero <= charCode && charCode <= nine) {
    return (charCode - zero + numberOffset);
  }

  // 62: +
  if (charCode == plus) {
    return 62;
  }

  // 63: /
  if (charCode == slash) {
    return 63;
  }

  // Invalid base64 digit.
  return -1;
};

},{}],857:[function(require,module,exports){
/* -*- Mode: js; js-indent-level: 2; -*- */
/*
 * Copyright 2011 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE or:
 * http://opensource.org/licenses/BSD-3-Clause
 */

exports.GREATEST_LOWER_BOUND = 1;
exports.LEAST_UPPER_BOUND = 2;

/**
 * Recursive implementation of binary search.
 *
 * @param aLow Indices here and lower do not contain the needle.
 * @param aHigh Indices here and higher do not contain the needle.
 * @param aNeedle The element being searched for.
 * @param aHaystack The non-empty array being searched.
 * @param aCompare Function which takes two elements and returns -1, 0, or 1.
 * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
 *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
 *     closest element that is smaller than or greater than the one we are
 *     searching for, respectively, if the exact element cannot be found.
 */
function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {
  // This function terminates when one of the following is true:
  //
  //   1. We find the exact element we are looking for.
  //
  //   2. We did not find the exact element, but we can return the index of
  //      the next-closest element.
  //
  //   3. We did not find the exact element, and there is no next-closest
  //      element than the one we are searching for, so we return -1.
  var mid = Math.floor((aHigh - aLow) / 2) + aLow;
  var cmp = aCompare(aNeedle, aHaystack[mid], true);
  if (cmp === 0) {
    // Found the element we are looking for.
    return mid;
  }
  else if (cmp > 0) {
    // Our needle is greater than aHaystack[mid].
    if (aHigh - mid > 1) {
      // The element is in the upper half.
      return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);
    }

    // The exact needle element was not found in this haystack. Determine if
    // we are in termination case (3) or (2) and return the appropriate thing.
    if (aBias == exports.LEAST_UPPER_BOUND) {
      return aHigh < aHaystack.length ? aHigh : -1;
    } else {
      return mid;
    }
  }
  else {
    // Our needle is less than aHaystack[mid].
    if (mid - aLow > 1) {
      // The element is in the lower half.
      return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);
    }

    // we are in termination case (3) or (2) and return the appropriate thing.
    if (aBias == exports.LEAST_UPPER_BOUND) {
      return mid;
    } else {
      return aLow < 0 ? -1 : aLow;
    }
  }
}

/**
 * This is an implementation of binary search which will always try and return
 * the index of the closest element if there is no exact hit. This is because
 * mappings between original and generated line/col pairs are single points,
 * and there is an implicit region between each of them, so a miss just means
 * that you aren't on the very start of a region.
 *
 * @param aNeedle The element you are looking for.
 * @param aHaystack The array that is being searched.
 * @param aCompare A function which takes the needle and an element in the
 *     array and returns -1, 0, or 1 depending on whether the needle is less
 *     than, equal to, or greater than the element, respectively.
 * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
 *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
 *     closest element that is smaller than or greater than the one we are
 *     searching for, respectively, if the exact element cannot be found.
 *     Defaults to 'binarySearch.GREATEST_LOWER_BOUND'.
 */
exports.search = function search(aNeedle, aHaystack, aCompare, aBias) {
  if (aHaystack.length === 0) {
    return -1;
  }

  var index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack,
                              aCompare, aBias || exports.GREATEST_LOWER_BOUND);
  if (index < 0) {
    return -1;
  }

  // We have found either the exact element, or the next-closest element than
  // the one we are searching for. However, there may be more than one such
  // element. Make sure we always return the smallest of these.
  while (index - 1 >= 0) {
    if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {
      break;
    }
    --index;
  }

  return index;
};

},{}],858:[function(require,module,exports){
/* -*- Mode: js; js-indent-level: 2; -*- */
/*
 * Copyright 2014 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE or:
 * http://opensource.org/licenses/BSD-3-Clause
 */

var util = require('./util');

/**
 * Determine whether mappingB is after mappingA with respect to generated
 * position.
 */
function generatedPositionAfter(mappingA, mappingB) {
  // Optimized for most common case
  var lineA = mappingA.generatedLine;
  var lineB = mappingB.generatedLine;
  var columnA = mappingA.generatedColumn;
  var columnB = mappingB.generatedColumn;
  return lineB > lineA || lineB == lineA && columnB >= columnA ||
         util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;
}

/**
 * A data structure to provide a sorted view of accumulated mappings in a
 * performance conscious manner. It trades a neglibable overhead in general
 * case for a large speedup in case of mappings being added in order.
 */
function MappingList() {
  this._array = [];
  this._sorted = true;
  // Serves as infimum
  this._last = {generatedLine: -1, generatedColumn: 0};
}

/**
 * Iterate through internal items. This method takes the same arguments that
 * `Array.prototype.forEach` takes.
 *
 * NOTE: The order of the mappings is NOT guaranteed.
 */
MappingList.prototype.unsortedForEach =
  function MappingList_forEach(aCallback, aThisArg) {
    this._array.forEach(aCallback, aThisArg);
  };

/**
 * Add the given source mapping.
 *
 * @param Object aMapping
 */
MappingList.prototype.add = function MappingList_add(aMapping) {
  if (generatedPositionAfter(this._last, aMapping)) {
    this._last = aMapping;
    this._array.push(aMapping);
  } else {
    this._sorted = false;
    this._array.push(aMapping);
  }
};

/**
 * Returns the flat, sorted array of mappings. The mappings are sorted by
 * generated position.
 *
 * WARNING: This method returns internal data without copying, for
 * performance. The return value must NOT be mutated, and should be treated as
 * an immutable borrow. If you want to take ownership, you must make your own
 * copy.
 */
MappingList.prototype.toArray = function MappingList_toArray() {
  if (!this._sorted) {
    this._array.sort(util.compareByGeneratedPositionsInflated);
    this._sorted = true;
  }
  return this._array;
};

exports.MappingList = MappingList;

},{"./util":863}],859:[function(require,module,exports){
/* -*- Mode: js; js-indent-level: 2; -*- */
/*
 * Copyright 2011 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE or:
 * http://opensource.org/licenses/BSD-3-Clause
 */

// It turns out that some (most?) JavaScript engines don't self-host
// `Array.prototype.sort`. This makes sense because C++ will likely remain
// faster than JS when doing raw CPU-intensive sorting. However, when using a
// custom comparator function, calling back and forth between the VM's C++ and
// JIT'd JS is rather slow *and* loses JIT type information, resulting in
// worse generated code for the comparator function than would be optimal. In
// fact, when sorting with a comparator, these costs outweigh the benefits of
// sorting in C++. By using our own JS-implemented Quick Sort (below), we get
// a ~3500ms mean speed-up in `bench/bench.html`.

/**
 * Swap the elements indexed by `x` and `y` in the array `ary`.
 *
 * @param {Array} ary
 *        The array.
 * @param {Number} x
 *        The index of the first item.
 * @param {Number} y
 *        The index of the second item.
 */
function swap(ary, x, y) {
  var temp = ary[x];
  ary[x] = ary[y];
  ary[y] = temp;
}

/**
 * Returns a random integer within the range `low .. high` inclusive.
 *
 * @param {Number} low
 *        The lower bound on the range.
 * @param {Number} high
 *        The upper bound on the range.
 */
function randomIntInRange(low, high) {
  return Math.round(low + (Math.random() * (high - low)));
}

/**
 * The Quick Sort algorithm.
 *
 * @param {Array} ary
 *        An array to sort.
 * @param {function} comparator
 *        Function to use to compare two items.
 * @param {Number} p
 *        Start index of the array
 * @param {Number} r
 *        End index of the array
 */
function doQuickSort(ary, comparator, p, r) {
  // If our lower bound is less than our upper bound, we (1) partition the
  // array into two pieces and (2) recurse on each half. If it is not, this is
  // the empty array and our base case.

  if (p < r) {
    // (1) Partitioning.
    //
    // The partitioning chooses a pivot between `p` and `r` and moves all
    // elements that are less than or equal to the pivot to the before it, and
    // all the elements that are greater than it after it. The effect is that
    // once partition is done, the pivot is in the exact place it will be when
    // the array is put in sorted order, and it will not need to be moved
    // again. This runs in O(n) time.

    // Always choose a random pivot so that an input array which is reverse
    // sorted does not cause O(n^2) running time.
    var pivotIndex = randomIntInRange(p, r);
    var i = p - 1;

    swap(ary, pivotIndex, r);
    var pivot = ary[r];

    // Immediately after `j` is incremented in this loop, the following hold
    // true:
    //
    //   * Every element in `ary[p .. i]` is less than or equal to the pivot.
    //
    //   * Every element in `ary[i+1 .. j-1]` is greater than the pivot.
    for (var j = p; j < r; j++) {
      if (comparator(ary[j], pivot) <= 0) {
        i += 1;
        swap(ary, i, j);
      }
    }

    swap(ary, i + 1, j);
    var q = i + 1;

    // (2) Recurse on each half.

    doQuickSort(ary, comparator, p, q - 1);
    doQuickSort(ary, comparator, q + 1, r);
  }
}

/**
 * Sort the given array in-place with the given comparator function.
 *
 * @param {Array} ary
 *        An array to sort.
 * @param {function} comparator
 *        Function to use to compare two items.
 */
exports.quickSort = function (ary, comparator) {
  doQuickSort(ary, comparator, 0, ary.length - 1);
};

},{}],860:[function(require,module,exports){
/* -*- Mode: js; js-indent-level: 2; -*- */
/*
 * Copyright 2011 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE or:
 * http://opensource.org/licenses/BSD-3-Clause
 */

var util = require('./util');
var binarySearch = require('./binary-search');
var ArraySet = require('./array-set').ArraySet;
var base64VLQ = require('./base64-vlq');
var quickSort = require('./quick-sort').quickSort;

function SourceMapConsumer(aSourceMap) {
  var sourceMap = aSourceMap;
  if (typeof aSourceMap === 'string') {
    sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/, ''));
  }

  return sourceMap.sections != null
    ? new IndexedSourceMapConsumer(sourceMap)
    : new BasicSourceMapConsumer(sourceMap);
}

SourceMapConsumer.fromSourceMap = function(aSourceMap) {
  return BasicSourceMapConsumer.fromSourceMap(aSourceMap);
}

/**
 * The version of the source mapping spec that we are consuming.
 */
SourceMapConsumer.prototype._version = 3;

// `__generatedMappings` and `__originalMappings` are arrays that hold the
// parsed mapping coordinates from the source map's "mappings" attribute. They
// are lazily instantiated, accessed via the `_generatedMappings` and
// `_originalMappings` getters respectively, and we only parse the mappings
// and create these arrays once queried for a source location. We jump through
// these hoops because there can be many thousands of mappings, and parsing
// them is expensive, so we only want to do it if we must.
//
// Each object in the arrays is of the form:
//
//     {
//       generatedLine: The line number in the generated code,
//       generatedColumn: The column number in the generated code,
//       source: The path to the original source file that generated this
//               chunk of code,
//       originalLine: The line number in the original source that
//                     corresponds to this chunk of generated code,
//       originalColumn: The column number in the original source that
//                       corresponds to this chunk of generated code,
//       name: The name of the original symbol which generated this chunk of
//             code.
//     }
//
// All properties except for `generatedLine` and `generatedColumn` can be
// `null`.
//
// `_generatedMappings` is ordered by the generated positions.
//
// `_originalMappings` is ordered by the original positions.

SourceMapConsumer.prototype.__generatedMappings = null;
Object.defineProperty(SourceMapConsumer.prototype, '_generatedMappings', {
  get: function () {
    if (!this.__generatedMappings) {
      this._parseMappings(this._mappings, this.sourceRoot);
    }

    return this.__generatedMappings;
  }
});

SourceMapConsumer.prototype.__originalMappings = null;
Object.defineProperty(SourceMapConsumer.prototype, '_originalMappings', {
  get: function () {
    if (!this.__originalMappings) {
      this._parseMappings(this._mappings, this.sourceRoot);
    }

    return this.__originalMappings;
  }
});

SourceMapConsumer.prototype._charIsMappingSeparator =
  function SourceMapConsumer_charIsMappingSeparator(aStr, index) {
    var c = aStr.charAt(index);
    return c === ";" || c === ",";
  };

/**
 * Parse the mappings in a string in to a data structure which we can easily
 * query (the ordered arrays in the `this.__generatedMappings` and
 * `this.__originalMappings` properties).
 */
SourceMapConsumer.prototype._parseMappings =
  function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
    throw new Error("Subclasses must implement _parseMappings");
  };

SourceMapConsumer.GENERATED_ORDER = 1;
SourceMapConsumer.ORIGINAL_ORDER = 2;

SourceMapConsumer.GREATEST_LOWER_BOUND = 1;
SourceMapConsumer.LEAST_UPPER_BOUND = 2;

/**
 * Iterate over each mapping between an original source/line/column and a
 * generated line/column in this source map.
 *
 * @param Function aCallback
 *        The function that is called with each mapping.
 * @param Object aContext
 *        Optional. If specified, this object will be the value of `this` every
 *        time that `aCallback` is called.
 * @param aOrder
 *        Either `SourceMapConsumer.GENERATED_ORDER` or
 *        `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to
 *        iterate over the mappings sorted by the generated file's line/column
 *        order or the original's source/line/column order, respectively. Defaults to
 *        `SourceMapConsumer.GENERATED_ORDER`.
 */
SourceMapConsumer.prototype.eachMapping =
  function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
    var context = aContext || null;
    var order = aOrder || SourceMapConsumer.GENERATED_ORDER;

    var mappings;
    switch (order) {
    case SourceMapConsumer.GENERATED_ORDER:
      mappings = this._generatedMappings;
      break;
    case SourceMapConsumer.ORIGINAL_ORDER:
      mappings = this._originalMappings;
      break;
    default:
      throw new Error("Unknown order of iteration.");
    }

    var sourceRoot = this.sourceRoot;
    mappings.map(function (mapping) {
      var source = mapping.source === null ? null : this._sources.at(mapping.source);
      if (source != null && sourceRoot != null) {
        source = util.join(sourceRoot, source);
      }
      return {
        source: source,
        generatedLine: mapping.generatedLine,
        generatedColumn: mapping.generatedColumn,
        originalLine: mapping.originalLine,
        originalColumn: mapping.originalColumn,
        name: mapping.name === null ? null : this._names.at(mapping.name)
      };
    }, this).forEach(aCallback, context);
  };

/**
 * Returns all generated line and column information for the original source,
 * line, and column provided. If no column is provided, returns all mappings
 * corresponding to a either the line we are searching for or the next
 * closest line that has any mappings. Otherwise, returns all mappings
 * corresponding to the given line and either the column we are searching for
 * or the next closest column that has any offsets.
 *
 * The only argument is an object with the following properties:
 *
 *   - source: The filename of the original source.
 *   - line: The line number in the original source.
 *   - column: Optional. the column number in the original source.
 *
 * and an array of objects is returned, each with the following properties:
 *
 *   - line: The line number in the generated source, or null.
 *   - column: The column number in the generated source, or null.
 */
SourceMapConsumer.prototype.allGeneratedPositionsFor =
  function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {
    var line = util.getArg(aArgs, 'line');

    // When there is no exact match, BasicSourceMapConsumer.prototype._findMapping
    // returns the index of the closest mapping less than the needle. By
    // setting needle.originalColumn to 0, we thus find the last mapping for
    // the given line, provided such a mapping exists.
    var needle = {
      source: util.getArg(aArgs, 'source'),
      originalLine: line,
      originalColumn: util.getArg(aArgs, 'column', 0)
    };

    if (this.sourceRoot != null) {
      needle.source = util.relative(this.sourceRoot, needle.source);
    }
    if (!this._sources.has(needle.source)) {
      return [];
    }
    needle.source = this._sources.indexOf(needle.source);

    var mappings = [];

    var index = this._findMapping(needle,
                                  this._originalMappings,
                                  "originalLine",
                                  "originalColumn",
                                  util.compareByOriginalPositions,
                                  binarySearch.LEAST_UPPER_BOUND);
    if (index >= 0) {
      var mapping = this._originalMappings[index];

      if (aArgs.column === undefined) {
        var originalLine = mapping.originalLine;

        // Iterate until either we run out of mappings, or we run into
        // a mapping for a different line than the one we found. Since
        // mappings are sorted, this is guaranteed to find all mappings for
        // the line we found.
        while (mapping && mapping.originalLine === originalLine) {
          mappings.push({
            line: util.getArg(mapping, 'generatedLine', null),
            column: util.getArg(mapping, 'generatedColumn', null),
            lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
          });

          mapping = this._originalMappings[++index];
        }
      } else {
        var originalColumn = mapping.originalColumn;

        // Iterate until either we run out of mappings, or we run into
        // a mapping for a different line than the one we were searching for.
        // Since mappings are sorted, this is guaranteed to find all mappings for
        // the line we are searching for.
        while (mapping &&
               mapping.originalLine === line &&
               mapping.originalColumn == originalColumn) {
          mappings.push({
            line: util.getArg(mapping, 'generatedLine', null),
            column: util.getArg(mapping, 'generatedColumn', null),
            lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
          });

          mapping = this._originalMappings[++index];
        }
      }
    }

    return mappings;
  };

exports.SourceMapConsumer = SourceMapConsumer;

/**
 * A BasicSourceMapConsumer instance represents a parsed source map which we can
 * query for information about the original file positions by giving it a file
 * position in the generated source.
 *
 * The only parameter is the raw source map (either as a JSON string, or
 * already parsed to an object). According to the spec, source maps have the
 * following attributes:
 *
 *   - version: Which version of the source map spec this map is following.
 *   - sources: An array of URLs to the original source files.
 *   - names: An array of identifiers which can be referrenced by individual mappings.
 *   - sourceRoot: Optional. The URL root from which all sources are relative.
 *   - sourcesContent: Optional. An array of contents of the original source files.
 *   - mappings: A string of base64 VLQs which contain the actual mappings.
 *   - file: Optional. The generated file this source map is associated with.
 *
 * Here is an example source map, taken from the source map spec[0]:
 *
 *     {
 *       version : 3,
 *       file: "out.js",
 *       sourceRoot : "",
 *       sources: ["foo.js", "bar.js"],
 *       names: ["src", "maps", "are", "fun"],
 *       mappings: "AA,AB;;ABCDE;"
 *     }
 *
 * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#
 */
function BasicSourceMapConsumer(aSourceMap) {
  var sourceMap = aSourceMap;
  if (typeof aSourceMap === 'string') {
    sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/, ''));
  }

  var version = util.getArg(sourceMap, 'version');
  var sources = util.getArg(sourceMap, 'sources');
  // Sass 3.3 leaves out the 'names' array, so we deviate from the spec (which
  // requires the array) to play nice here.
  var names = util.getArg(sourceMap, 'names', []);
  var sourceRoot = util.getArg(sourceMap, 'sourceRoot', null);
  var sourcesContent = util.getArg(sourceMap, 'sourcesContent', null);
  var mappings = util.getArg(sourceMap, 'mappings');
  var file = util.getArg(sourceMap, 'file', null);

  // Once again, Sass deviates from the spec and supplies the version as a
  // string rather than a number, so we use loose equality checking here.
  if (version != this._version) {
    throw new Error('Unsupported version: ' + version);
  }

  sources = sources
    .map(String)
    // Some source maps produce relative source paths like "./foo.js" instead of
    // "foo.js".  Normalize these first so that future comparisons will succeed.
    // See bugzil.la/1090768.
    .map(util.normalize)
    // Always ensure that absolute sources are internally stored relative to
    // the source root, if the source root is absolute. Not doing this would
    // be particularly problematic when the source root is a prefix of the
    // source (valid, but why??). See github issue #199 and bugzil.la/1188982.
    .map(function (source) {
      return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source)
        ? util.relative(sourceRoot, source)
        : source;
    });

  // Pass `true` below to allow duplicate names and sources. While source maps
  // are intended to be compressed and deduplicated, the TypeScript compiler
  // sometimes generates source maps with duplicates in them. See Github issue
  // #72 and bugzil.la/889492.
  this._names = ArraySet.fromArray(names.map(String), true);
  this._sources = ArraySet.fromArray(sources, true);

  this.sourceRoot = sourceRoot;
  this.sourcesContent = sourcesContent;
  this._mappings = mappings;
  this.file = file;
}

BasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;

/**
 * Create a BasicSourceMapConsumer from a SourceMapGenerator.
 *
 * @param SourceMapGenerator aSourceMap
 *        The source map that will be consumed.
 * @returns BasicSourceMapConsumer
 */
BasicSourceMapConsumer.fromSourceMap =
  function SourceMapConsumer_fromSourceMap(aSourceMap) {
    var smc = Object.create(BasicSourceMapConsumer.prototype);

    var names = smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);
    var sources = smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);
    smc.sourceRoot = aSourceMap._sourceRoot;
    smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(),
                                                            smc.sourceRoot);
    smc.file = aSourceMap._file;

    // Because we are modifying the entries (by converting string sources and
    // names to indices into the sources and names ArraySets), we have to make
    // a copy of the entry or else bad things happen. Shared mutable state
    // strikes again! See github issue #191.

    var generatedMappings = aSourceMap._mappings.toArray().slice();
    var destGeneratedMappings = smc.__generatedMappings = [];
    var destOriginalMappings = smc.__originalMappings = [];

    for (var i = 0, length = generatedMappings.length; i < length; i++) {
      var srcMapping = generatedMappings[i];
      var destMapping = new Mapping;
      destMapping.generatedLine = srcMapping.generatedLine;
      destMapping.generatedColumn = srcMapping.generatedColumn;

      if (srcMapping.source) {
        destMapping.source = sources.indexOf(srcMapping.source);
        destMapping.originalLine = srcMapping.originalLine;
        destMapping.originalColumn = srcMapping.originalColumn;

        if (srcMapping.name) {
          destMapping.name = names.indexOf(srcMapping.name);
        }

        destOriginalMappings.push(destMapping);
      }

      destGeneratedMappings.push(destMapping);
    }

    quickSort(smc.__originalMappings, util.compareByOriginalPositions);

    return smc;
  };

/**
 * The version of the source mapping spec that we are consuming.
 */
BasicSourceMapConsumer.prototype._version = 3;

/**
 * The list of original sources.
 */
Object.defineProperty(BasicSourceMapConsumer.prototype, 'sources', {
  get: function () {
    return this._sources.toArray().map(function (s) {
      return this.sourceRoot != null ? util.join(this.sourceRoot, s) : s;
    }, this);
  }
});

/**
 * Provide the JIT with a nice shape / hidden class.
 */
function Mapping() {
  this.generatedLine = 0;
  this.generatedColumn = 0;
  this.source = null;
  this.originalLine = null;
  this.originalColumn = null;
  this.name = null;
}

/**
 * Parse the mappings in a string in to a data structure which we can easily
 * query (the ordered arrays in the `this.__generatedMappings` and
 * `this.__originalMappings` properties).
 */
BasicSourceMapConsumer.prototype._parseMappings =
  function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
    var generatedLine = 1;
    var previousGeneratedColumn = 0;
    var previousOriginalLine = 0;
    var previousOriginalColumn = 0;
    var previousSource = 0;
    var previousName = 0;
    var length = aStr.length;
    var index = 0;
    var cachedSegments = {};
    var temp = {};
    var originalMappings = [];
    var generatedMappings = [];
    var mapping, str, segment, end, value;

    while (index < length) {
      if (aStr.charAt(index) === ';') {
        generatedLine++;
        index++;
        previousGeneratedColumn = 0;
      }
      else if (aStr.charAt(index) === ',') {
        index++;
      }
      else {
        mapping = new Mapping();
        mapping.generatedLine = generatedLine;

        // Because each offset is encoded relative to the previous one,
        // many segments often have the same encoding. We can exploit this
        // fact by caching the parsed variable length fields of each segment,
        // allowing us to avoid a second parse if we encounter the same
        // segment again.
        for (end = index; end < length; end++) {
          if (this._charIsMappingSeparator(aStr, end)) {
            break;
          }
        }
        str = aStr.slice(index, end);

        segment = cachedSegments[str];
        if (segment) {
          index += str.length;
        } else {
          segment = [];
          while (index < end) {
            base64VLQ.decode(aStr, index, temp);
            value = temp.value;
            index = temp.rest;
            segment.push(value);
          }

          if (segment.length === 2) {
            throw new Error('Found a source, but no line and column');
          }

          if (segment.length === 3) {
            throw new Error('Found a source and line, but no column');
          }

          cachedSegments[str] = segment;
        }

        // Generated column.
        mapping.generatedColumn = previousGeneratedColumn + segment[0];
        previousGeneratedColumn = mapping.generatedColumn;

        if (segment.length > 1) {
          // Original source.
          mapping.source = previousSource + segment[1];
          previousSource += segment[1];

          // Original line.
          mapping.originalLine = previousOriginalLine + segment[2];
          previousOriginalLine = mapping.originalLine;
          // Lines are stored 0-based
          mapping.originalLine += 1;

          // Original column.
          mapping.originalColumn = previousOriginalColumn + segment[3];
          previousOriginalColumn = mapping.originalColumn;

          if (segment.length > 4) {
            // Original name.
            mapping.name = previousName + segment[4];
            previousName += segment[4];
          }
        }

        generatedMappings.push(mapping);
        if (typeof mapping.originalLine === 'number') {
          originalMappings.push(mapping);
        }
      }
    }

    quickSort(generatedMappings, util.compareByGeneratedPositionsDeflated);
    this.__generatedMappings = generatedMappings;

    quickSort(originalMappings, util.compareByOriginalPositions);
    this.__originalMappings = originalMappings;
  };

/**
 * Find the mapping that best matches the hypothetical "needle" mapping that
 * we are searching for in the given "haystack" of mappings.
 */
BasicSourceMapConsumer.prototype._findMapping =
  function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName,
                                         aColumnName, aComparator, aBias) {
    // To return the position we are searching for, we must first find the
    // mapping for the given position and then return the opposite position it
    // points to. Because the mappings are sorted, we can use binary search to
    // find the best mapping.

    if (aNeedle[aLineName] <= 0) {
      throw new TypeError('Line must be greater than or equal to 1, got '
                          + aNeedle[aLineName]);
    }
    if (aNeedle[aColumnName] < 0) {
      throw new TypeError('Column must be greater than or equal to 0, got '
                          + aNeedle[aColumnName]);
    }

    return binarySearch.search(aNeedle, aMappings, aComparator, aBias);
  };

/**
 * Compute the last column for each generated mapping. The last column is
 * inclusive.
 */
BasicSourceMapConsumer.prototype.computeColumnSpans =
  function SourceMapConsumer_computeColumnSpans() {
    for (var index = 0; index < this._generatedMappings.length; ++index) {
      var mapping = this._generatedMappings[index];

      // Mappings do not contain a field for the last generated columnt. We
      // can come up with an optimistic estimate, however, by assuming that
      // mappings are contiguous (i.e. given two consecutive mappings, the
      // first mapping ends where the second one starts).
      if (index + 1 < this._generatedMappings.length) {
        var nextMapping = this._generatedMappings[index + 1];

        if (mapping.generatedLine === nextMapping.generatedLine) {
          mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;
          continue;
        }
      }

      // The last mapping for each line spans the entire line.
      mapping.lastGeneratedColumn = Infinity;
    }
  };

/**
 * Returns the original source, line, and column information for the generated
 * source's line and column positions provided. The only argument is an object
 * with the following properties:
 *
 *   - line: The line number in the generated source.
 *   - column: The column number in the generated source.
 *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
 *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
 *     closest element that is smaller than or greater than the one we are
 *     searching for, respectively, if the exact element cannot be found.
 *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
 *
 * and an object is returned with the following properties:
 *
 *   - source: The original source file, or null.
 *   - line: The line number in the original source, or null.
 *   - column: The column number in the original source, or null.
 *   - name: The original identifier, or null.
 */
BasicSourceMapConsumer.prototype.originalPositionFor =
  function SourceMapConsumer_originalPositionFor(aArgs) {
    var needle = {
      generatedLine: util.getArg(aArgs, 'line'),
      generatedColumn: util.getArg(aArgs, 'column')
    };

    var index = this._findMapping(
      needle,
      this._generatedMappings,
      "generatedLine",
      "generatedColumn",
      util.compareByGeneratedPositionsDeflated,
      util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)
    );

    if (index >= 0) {
      var mapping = this._generatedMappings[index];

      if (mapping.generatedLine === needle.generatedLine) {
        var source = util.getArg(mapping, 'source', null);
        if (source !== null) {
          source = this._sources.at(source);
          if (this.sourceRoot != null) {
            source = util.join(this.sourceRoot, source);
          }
        }
        var name = util.getArg(mapping, 'name', null);
        if (name !== null) {
          name = this._names.at(name);
        }
        return {
          source: source,
          line: util.getArg(mapping, 'originalLine', null),
          column: util.getArg(mapping, 'originalColumn', null),
          name: name
        };
      }
    }

    return {
      source: null,
      line: null,
      column: null,
      name: null
    };
  };

/**
 * Return true if we have the source content for every source in the source
 * map, false otherwise.
 */
BasicSourceMapConsumer.prototype.hasContentsOfAllSources =
  function BasicSourceMapConsumer_hasContentsOfAllSources() {
    if (!this.sourcesContent) {
      return false;
    }
    return this.sourcesContent.length >= this._sources.size() &&
      !this.sourcesContent.some(function (sc) { return sc == null; });
  };

/**
 * Returns the original source content. The only argument is the url of the
 * original source file. Returns null if no original source content is
 * available.
 */
BasicSourceMapConsumer.prototype.sourceContentFor =
  function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
    if (!this.sourcesContent) {
      return null;
    }

    if (this.sourceRoot != null) {
      aSource = util.relative(this.sourceRoot, aSource);
    }

    if (this._sources.has(aSource)) {
      return this.sourcesContent[this._sources.indexOf(aSource)];
    }

    var url;
    if (this.sourceRoot != null
        && (url = util.urlParse(this.sourceRoot))) {
      // XXX: file:// URIs and absolute paths lead to unexpected behavior for
      // many users. We can help them out when they expect file:// URIs to
      // behave like it would if they were running a local HTTP server. See
      // https://bugzilla.mozilla.org/show_bug.cgi?id=885597.
      var fileUriAbsPath = aSource.replace(/^file:\/\//, "");
      if (url.scheme == "file"
          && this._sources.has(fileUriAbsPath)) {
        return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]
      }

      if ((!url.path || url.path == "/")
          && this._sources.has("/" + aSource)) {
        return this.sourcesContent[this._sources.indexOf("/" + aSource)];
      }
    }

    // This function is used recursively from
    // IndexedSourceMapConsumer.prototype.sourceContentFor. In that case, we
    // don't want to throw if we can't find the source - we just want to
    // return null, so we provide a flag to exit gracefully.
    if (nullOnMissing) {
      return null;
    }
    else {
      throw new Error('"' + aSource + '" is not in the SourceMap.');
    }
  };

/**
 * Returns the generated line and column information for the original source,
 * line, and column positions provided. The only argument is an object with
 * the following properties:
 *
 *   - source: The filename of the original source.
 *   - line: The line number in the original source.
 *   - column: The column number in the original source.
 *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
 *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
 *     closest element that is smaller than or greater than the one we are
 *     searching for, respectively, if the exact element cannot be found.
 *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
 *
 * and an object is returned with the following properties:
 *
 *   - line: The line number in the generated source, or null.
 *   - column: The column number in the generated source, or null.
 */
BasicSourceMapConsumer.prototype.generatedPositionFor =
  function SourceMapConsumer_generatedPositionFor(aArgs) {
    var source = util.getArg(aArgs, 'source');
    if (this.sourceRoot != null) {
      source = util.relative(this.sourceRoot, source);
    }
    if (!this._sources.has(source)) {
      return {
        line: null,
        column: null,
        lastColumn: null
      };
    }
    source = this._sources.indexOf(source);

    var needle = {
      source: source,
      originalLine: util.getArg(aArgs, 'line'),
      originalColumn: util.getArg(aArgs, 'column')
    };

    var index = this._findMapping(
      needle,
      this._originalMappings,
      "originalLine",
      "originalColumn",
      util.compareByOriginalPositions,
      util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)
    );

    if (index >= 0) {
      var mapping = this._originalMappings[index];

      if (mapping.source === needle.source) {
        return {
          line: util.getArg(mapping, 'generatedLine', null),
          column: util.getArg(mapping, 'generatedColumn', null),
          lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
        };
      }
    }

    return {
      line: null,
      column: null,
      lastColumn: null
    };
  };

exports.BasicSourceMapConsumer = BasicSourceMapConsumer;

/**
 * An IndexedSourceMapConsumer instance represents a parsed source map which
 * we can query for information. It differs from BasicSourceMapConsumer in
 * that it takes "indexed" source maps (i.e. ones with a "sections" field) as
 * input.
 *
 * The only parameter is a raw source map (either as a JSON string, or already
 * parsed to an object). According to the spec for indexed source maps, they
 * have the following attributes:
 *
 *   - version: Which version of the source map spec this map is following.
 *   - file: Optional. The generated file this source map is associated with.
 *   - sections: A list of section definitions.
 *
 * Each value under the "sections" field has two fields:
 *   - offset: The offset into the original specified at which this section
 *       begins to apply, defined as an object with a "line" and "column"
 *       field.
 *   - map: A source map definition. This source map could also be indexed,
 *       but doesn't have to be.
 *
 * Instead of the "map" field, it's also possible to have a "url" field
 * specifying a URL to retrieve a source map from, but that's currently
 * unsupported.
 *
 * Here's an example source map, taken from the source map spec[0], but
 * modified to omit a section which uses the "url" field.
 *
 *  {
 *    version : 3,
 *    file: "app.js",
 *    sections: [{
 *      offset: {line:100, column:10},
 *      map: {
 *        version : 3,
 *        file: "section.js",
 *        sources: ["foo.js", "bar.js"],
 *        names: ["src", "maps", "are", "fun"],
 *        mappings: "AAAA,E;;ABCDE;"
 *      }
 *    }],
 *  }
 *
 * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgt
 */
function IndexedSourceMapConsumer(aSourceMap) {
  var sourceMap = aSourceMap;
  if (typeof aSourceMap === 'string') {
    sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/, ''));
  }

  var version = util.getArg(sourceMap, 'version');
  var sections = util.getArg(sourceMap, 'sections');

  if (version != this._version) {
    throw new Error('Unsupported version: ' + version);
  }

  this._sources = new ArraySet();
  this._names = new ArraySet();

  var lastOffset = {
    line: -1,
    column: 0
  };
  this._sections = sections.map(function (s) {
    if (s.url) {
      // The url field will require support for asynchronicity.
      // See https://github.com/mozilla/source-map/issues/16
      throw new Error('Support for url field in sections not implemented.');
    }
    var offset = util.getArg(s, 'offset');
    var offsetLine = util.getArg(offset, 'line');
    var offsetColumn = util.getArg(offset, 'column');

    if (offsetLine < lastOffset.line ||
        (offsetLine === lastOffset.line && offsetColumn < lastOffset.column)) {
      throw new Error('Section offsets must be ordered and non-overlapping.');
    }
    lastOffset = offset;

    return {
      generatedOffset: {
        // The offset fields are 0-based, but we use 1-based indices when
        // encoding/decoding from VLQ.
        generatedLine: offsetLine + 1,
        generatedColumn: offsetColumn + 1
      },
      consumer: new SourceMapConsumer(util.getArg(s, 'map'))
    }
  });
}

IndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
IndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;

/**
 * The version of the source mapping spec that we are consuming.
 */
IndexedSourceMapConsumer.prototype._version = 3;

/**
 * The list of original sources.
 */
Object.defineProperty(IndexedSourceMapConsumer.prototype, 'sources', {
  get: function () {
    var sources = [];
    for (var i = 0; i < this._sections.length; i++) {
      for (var j = 0; j < this._sections[i].consumer.sources.length; j++) {
        sources.push(this._sections[i].consumer.sources[j]);
      }
    }
    return sources;
  }
});

/**
 * Returns the original source, line, and column information for the generated
 * source's line and column positions provided. The only argument is an object
 * with the following properties:
 *
 *   - line: The line number in the generated source.
 *   - column: The column number in the generated source.
 *
 * and an object is returned with the following properties:
 *
 *   - source: The original source file, or null.
 *   - line: The line number in the original source, or null.
 *   - column: The column number in the original source, or null.
 *   - name: The original identifier, or null.
 */
IndexedSourceMapConsumer.prototype.originalPositionFor =
  function IndexedSourceMapConsumer_originalPositionFor(aArgs) {
    var needle = {
      generatedLine: util.getArg(aArgs, 'line'),
      generatedColumn: util.getArg(aArgs, 'column')
    };

    // Find the section containing the generated position we're trying to map
    // to an original position.
    var sectionIndex = binarySearch.search(needle, this._sections,
      function(needle, section) {
        var cmp = needle.generatedLine - section.generatedOffset.generatedLine;
        if (cmp) {
          return cmp;
        }

        return (needle.generatedColumn -
                section.generatedOffset.generatedColumn);
      });
    var section = this._sections[sectionIndex];

    if (!section) {
      return {
        source: null,
        line: null,
        column: null,
        name: null
      };
    }

    return section.consumer.originalPositionFor({
      line: needle.generatedLine -
        (section.generatedOffset.generatedLine - 1),
      column: needle.generatedColumn -
        (section.generatedOffset.generatedLine === needle.generatedLine
         ? section.generatedOffset.generatedColumn - 1
         : 0),
      bias: aArgs.bias
    });
  };

/**
 * Return true if we have the source content for every source in the source
 * map, false otherwise.
 */
IndexedSourceMapConsumer.prototype.hasContentsOfAllSources =
  function IndexedSourceMapConsumer_hasContentsOfAllSources() {
    return this._sections.every(function (s) {
      return s.consumer.hasContentsOfAllSources();
    });
  };

/**
 * Returns the original source content. The only argument is the url of the
 * original source file. Returns null if no original source content is
 * available.
 */
IndexedSourceMapConsumer.prototype.sourceContentFor =
  function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
    for (var i = 0; i < this._sections.length; i++) {
      var section = this._sections[i];

      var content = section.consumer.sourceContentFor(aSource, true);
      if (content) {
        return content;
      }
    }
    if (nullOnMissing) {
      return null;
    }
    else {
      throw new Error('"' + aSource + '" is not in the SourceMap.');
    }
  };

/**
 * Returns the generated line and column information for the original source,
 * line, and column positions provided. The only argument is an object with
 * the following properties:
 *
 *   - source: The filename of the original source.
 *   - line: The line number in the original source.
 *   - column: The column number in the original source.
 *
 * and an object is returned with the following properties:
 *
 *   - line: The line number in the generated source, or null.
 *   - column: The column number in the generated source, or null.
 */
IndexedSourceMapConsumer.prototype.generatedPositionFor =
  function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {
    for (var i = 0; i < this._sections.length; i++) {
      var section = this._sections[i];

      // Only consider this section if the requested source is in the list of
      // sources of the consumer.
      if (section.consumer.sources.indexOf(util.getArg(aArgs, 'source')) === -1) {
        continue;
      }
      var generatedPosition = section.consumer.generatedPositionFor(aArgs);
      if (generatedPosition) {
        var ret = {
          line: generatedPosition.line +
            (section.generatedOffset.generatedLine - 1),
          column: generatedPosition.column +
            (section.generatedOffset.generatedLine === generatedPosition.line
             ? section.generatedOffset.generatedColumn - 1
             : 0)
        };
        return ret;
      }
    }

    return {
      line: null,
      column: null
    };
  };

/**
 * Parse the mappings in a string in to a data structure which we can easily
 * query (the ordered arrays in the `this.__generatedMappings` and
 * `this.__originalMappings` properties).
 */
IndexedSourceMapConsumer.prototype._parseMappings =
  function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {
    this.__generatedMappings = [];
    this.__originalMappings = [];
    for (var i = 0; i < this._sections.length; i++) {
      var section = this._sections[i];
      var sectionMappings = section.consumer._generatedMappings;
      for (var j = 0; j < sectionMappings.length; j++) {
        var mapping = sectionMappings[j];

        var source = section.consumer._sources.at(mapping.source);
        if (section.consumer.sourceRoot !== null) {
          source = util.join(section.consumer.sourceRoot, source);
        }
        this._sources.add(source);
        source = this._sources.indexOf(source);

        var name = section.consumer._names.at(mapping.name);
        this._names.add(name);
        name = this._names.indexOf(name);

        // The mappings coming from the consumer for the section have
        // generated positions relative to the start of the section, so we
        // need to offset them to be relative to the start of the concatenated
        // generated file.
        var adjustedMapping = {
          source: source,
          generatedLine: mapping.generatedLine +
            (section.generatedOffset.generatedLine - 1),
          generatedColumn: mapping.generatedColumn +
            (section.generatedOffset.generatedLine === mapping.generatedLine
            ? section.generatedOffset.generatedColumn - 1
            : 0),
          originalLine: mapping.originalLine,
          originalColumn: mapping.originalColumn,
          name: name
        };

        this.__generatedMappings.push(adjustedMapping);
        if (typeof adjustedMapping.originalLine === 'number') {
          this.__originalMappings.push(adjustedMapping);
        }
      }
    }

    quickSort(this.__generatedMappings, util.compareByGeneratedPositionsDeflated);
    quickSort(this.__originalMappings, util.compareByOriginalPositions);
  };

exports.IndexedSourceMapConsumer = IndexedSourceMapConsumer;

},{"./array-set":854,"./base64-vlq":855,"./binary-search":857,"./quick-sort":859,"./util":863}],861:[function(require,module,exports){
/* -*- Mode: js; js-indent-level: 2; -*- */
/*
 * Copyright 2011 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE or:
 * http://opensource.org/licenses/BSD-3-Clause
 */

var base64VLQ = require('./base64-vlq');
var util = require('./util');
var ArraySet = require('./array-set').ArraySet;
var MappingList = require('./mapping-list').MappingList;

/**
 * An instance of the SourceMapGenerator represents a source map which is
 * being built incrementally. You may pass an object with the following
 * properties:
 *
 *   - file: The filename of the generated source.
 *   - sourceRoot: A root for all relative URLs in this source map.
 */
function SourceMapGenerator(aArgs) {
  if (!aArgs) {
    aArgs = {};
  }
  this._file = util.getArg(aArgs, 'file', null);
  this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null);
  this._skipValidation = util.getArg(aArgs, 'skipValidation', false);
  this._sources = new ArraySet();
  this._names = new ArraySet();
  this._mappings = new MappingList();
  this._sourcesContents = null;
}

SourceMapGenerator.prototype._version = 3;

/**
 * Creates a new SourceMapGenerator based on a SourceMapConsumer
 *
 * @param aSourceMapConsumer The SourceMap.
 */
SourceMapGenerator.fromSourceMap =
  function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {
    var sourceRoot = aSourceMapConsumer.sourceRoot;
    var generator = new SourceMapGenerator({
      file: aSourceMapConsumer.file,
      sourceRoot: sourceRoot
    });
    aSourceMapConsumer.eachMapping(function (mapping) {
      var newMapping = {
        generated: {
          line: mapping.generatedLine,
          column: mapping.generatedColumn
        }
      };

      if (mapping.source != null) {
        newMapping.source = mapping.source;
        if (sourceRoot != null) {
          newMapping.source = util.relative(sourceRoot, newMapping.source);
        }

        newMapping.original = {
          line: mapping.originalLine,
          column: mapping.originalColumn
        };

        if (mapping.name != null) {
          newMapping.name = mapping.name;
        }
      }

      generator.addMapping(newMapping);
    });
    aSourceMapConsumer.sources.forEach(function (sourceFile) {
      var content = aSourceMapConsumer.sourceContentFor(sourceFile);
      if (content != null) {
        generator.setSourceContent(sourceFile, content);
      }
    });
    return generator;
  };

/**
 * Add a single mapping from original source line and column to the generated
 * source's line and column for this source map being created. The mapping
 * object should have the following properties:
 *
 *   - generated: An object with the generated line and column positions.
 *   - original: An object with the original line and column positions.
 *   - source: The original source file (relative to the sourceRoot).
 *   - name: An optional original token name for this mapping.
 */
SourceMapGenerator.prototype.addMapping =
  function SourceMapGenerator_addMapping(aArgs) {
    var generated = util.getArg(aArgs, 'generated');
    var original = util.getArg(aArgs, 'original', null);
    var source = util.getArg(aArgs, 'source', null);
    var name = util.getArg(aArgs, 'name', null);

    if (!this._skipValidation) {
      this._validateMapping(generated, original, source, name);
    }

    if (source != null) {
      source = String(source);
      if (!this._sources.has(source)) {
        this._sources.add(source);
      }
    }

    if (name != null) {
      name = String(name);
      if (!this._names.has(name)) {
        this._names.add(name);
      }
    }

    this._mappings.add({
      generatedLine: generated.line,
      generatedColumn: generated.column,
      originalLine: original != null && original.line,
      originalColumn: original != null && original.column,
      source: source,
      name: name
    });
  };

/**
 * Set the source content for a source file.
 */
SourceMapGenerator.prototype.setSourceContent =
  function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {
    var source = aSourceFile;
    if (this._sourceRoot != null) {
      source = util.relative(this._sourceRoot, source);
    }

    if (aSourceContent != null) {
      // Add the source content to the _sourcesContents map.
      // Create a new _sourcesContents map if the property is null.
      if (!this._sourcesContents) {
        this._sourcesContents = Object.create(null);
      }
      this._sourcesContents[util.toSetString(source)] = aSourceContent;
    } else if (this._sourcesContents) {
      // Remove the source file from the _sourcesContents map.
      // If the _sourcesContents map is empty, set the property to null.
      delete this._sourcesContents[util.toSetString(source)];
      if (Object.keys(this._sourcesContents).length === 0) {
        this._sourcesContents = null;
      }
    }
  };

/**
 * Applies the mappings of a sub-source-map for a specific source file to the
 * source map being generated. Each mapping to the supplied source file is
 * rewritten using the supplied source map. Note: The resolution for the
 * resulting mappings is the minimium of this map and the supplied map.
 *
 * @param aSourceMapConsumer The source map to be applied.
 * @param aSourceFile Optional. The filename of the source file.
 *        If omitted, SourceMapConsumer's file property will be used.
 * @param aSourceMapPath Optional. The dirname of the path to the source map
 *        to be applied. If relative, it is relative to the SourceMapConsumer.
 *        This parameter is needed when the two source maps aren't in the same
 *        directory, and the source map to be applied contains relative source
 *        paths. If so, those relative source paths need to be rewritten
 *        relative to the SourceMapGenerator.
 */
SourceMapGenerator.prototype.applySourceMap =
  function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
    var sourceFile = aSourceFile;
    // If aSourceFile is omitted, we will use the file property of the SourceMap
    if (aSourceFile == null) {
      if (aSourceMapConsumer.file == null) {
        throw new Error(
          'SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, ' +
          'or the source map\'s "file" property. Both were omitted.'
        );
      }
      sourceFile = aSourceMapConsumer.file;
    }
    var sourceRoot = this._sourceRoot;
    // Make "sourceFile" relative if an absolute Url is passed.
    if (sourceRoot != null) {
      sourceFile = util.relative(sourceRoot, sourceFile);
    }
    // Applying the SourceMap can add and remove items from the sources and
    // the names array.
    var newSources = new ArraySet();
    var newNames = new ArraySet();

    // Find mappings for the "sourceFile"
    this._mappings.unsortedForEach(function (mapping) {
      if (mapping.source === sourceFile && mapping.originalLine != null) {
        // Check if it can be mapped by the source map, then update the mapping.
        var original = aSourceMapConsumer.originalPositionFor({
          line: mapping.originalLine,
          column: mapping.originalColumn
        });
        if (original.source != null) {
          // Copy mapping
          mapping.source = original.source;
          if (aSourceMapPath != null) {
            mapping.source = util.join(aSourceMapPath, mapping.source)
          }
          if (sourceRoot != null) {
            mapping.source = util.relative(sourceRoot, mapping.source);
          }
          mapping.originalLine = original.line;
          mapping.originalColumn = original.column;
          if (original.name != null) {
            mapping.name = original.name;
          }
        }
      }

      var source = mapping.source;
      if (source != null && !newSources.has(source)) {
        newSources.add(source);
      }

      var name = mapping.name;
      if (name != null && !newNames.has(name)) {
        newNames.add(name);
      }

    }, this);
    this._sources = newSources;
    this._names = newNames;

    // Copy sourcesContents of applied map.
    aSourceMapConsumer.sources.forEach(function (sourceFile) {
      var content = aSourceMapConsumer.sourceContentFor(sourceFile);
      if (content != null) {
        if (aSourceMapPath != null) {
          sourceFile = util.join(aSourceMapPath, sourceFile);
        }
        if (sourceRoot != null) {
          sourceFile = util.relative(sourceRoot, sourceFile);
        }
        this.setSourceContent(sourceFile, content);
      }
    }, this);
  };

/**
 * A mapping can have one of the three levels of data:
 *
 *   1. Just the generated position.
 *   2. The Generated position, original position, and original source.
 *   3. Generated and original position, original source, as well as a name
 *      token.
 *
 * To maintain consistency, we validate that any new mapping being added falls
 * in to one of these categories.
 */
SourceMapGenerator.prototype._validateMapping =
  function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource,
                                              aName) {
    if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
        && aGenerated.line > 0 && aGenerated.column >= 0
        && !aOriginal && !aSource && !aName) {
      // Case 1.
      return;
    }
    else if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
             && aOriginal && 'line' in aOriginal && 'column' in aOriginal
             && aGenerated.line > 0 && aGenerated.column >= 0
             && aOriginal.line > 0 && aOriginal.column >= 0
             && aSource) {
      // Cases 2 and 3.
      return;
    }
    else {
      throw new Error('Invalid mapping: ' + JSON.stringify({
        generated: aGenerated,
        source: aSource,
        original: aOriginal,
        name: aName
      }));
    }
  };

/**
 * Serialize the accumulated mappings in to the stream of base 64 VLQs
 * specified by the source map format.
 */
SourceMapGenerator.prototype._serializeMappings =
  function SourceMapGenerator_serializeMappings() {
    var previousGeneratedColumn = 0;
    var previousGeneratedLine = 1;
    var previousOriginalColumn = 0;
    var previousOriginalLine = 0;
    var previousName = 0;
    var previousSource = 0;
    var result = '';
    var next;
    var mapping;
    var nameIdx;
    var sourceIdx;

    var mappings = this._mappings.toArray();
    for (var i = 0, len = mappings.length; i < len; i++) {
      mapping = mappings[i];
      next = ''

      if (mapping.generatedLine !== previousGeneratedLine) {
        previousGeneratedColumn = 0;
        while (mapping.generatedLine !== previousGeneratedLine) {
          next += ';';
          previousGeneratedLine++;
        }
      }
      else {
        if (i > 0) {
          if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {
            continue;
          }
          next += ',';
        }
      }

      next += base64VLQ.encode(mapping.generatedColumn
                                 - previousGeneratedColumn);
      previousGeneratedColumn = mapping.generatedColumn;

      if (mapping.source != null) {
        sourceIdx = this._sources.indexOf(mapping.source);
        next += base64VLQ.encode(sourceIdx - previousSource);
        previousSource = sourceIdx;

        // lines are stored 0-based in SourceMap spec version 3
        next += base64VLQ.encode(mapping.originalLine - 1
                                   - previousOriginalLine);
        previousOriginalLine = mapping.originalLine - 1;

        next += base64VLQ.encode(mapping.originalColumn
                                   - previousOriginalColumn);
        previousOriginalColumn = mapping.originalColumn;

        if (mapping.name != null) {
          nameIdx = this._names.indexOf(mapping.name);
          next += base64VLQ.encode(nameIdx - previousName);
          previousName = nameIdx;
        }
      }

      result += next;
    }

    return result;
  };

SourceMapGenerator.prototype._generateSourcesContent =
  function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {
    return aSources.map(function (source) {
      if (!this._sourcesContents) {
        return null;
      }
      if (aSourceRoot != null) {
        source = util.relative(aSourceRoot, source);
      }
      var key = util.toSetString(source);
      return Object.prototype.hasOwnProperty.call(this._sourcesContents, key)
        ? this._sourcesContents[key]
        : null;
    }, this);
  };

/**
 * Externalize the source map.
 */
SourceMapGenerator.prototype.toJSON =
  function SourceMapGenerator_toJSON() {
    var map = {
      version: this._version,
      sources: this._sources.toArray(),
      names: this._names.toArray(),
      mappings: this._serializeMappings()
    };
    if (this._file != null) {
      map.file = this._file;
    }
    if (this._sourceRoot != null) {
      map.sourceRoot = this._sourceRoot;
    }
    if (this._sourcesContents) {
      map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);
    }

    return map;
  };

/**
 * Render the source map being generated to a string.
 */
SourceMapGenerator.prototype.toString =
  function SourceMapGenerator_toString() {
    return JSON.stringify(this.toJSON());
  };

exports.SourceMapGenerator = SourceMapGenerator;

},{"./array-set":854,"./base64-vlq":855,"./mapping-list":858,"./util":863}],862:[function(require,module,exports){
/* -*- Mode: js; js-indent-level: 2; -*- */
/*
 * Copyright 2011 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE or:
 * http://opensource.org/licenses/BSD-3-Clause
 */

var SourceMapGenerator = require('./source-map-generator').SourceMapGenerator;
var util = require('./util');

// Matches a Windows-style `\r\n` newline or a `\n` newline used by all other
// operating systems these days (capturing the result).
var REGEX_NEWLINE = /(\r?\n)/;

// Newline character code for charCodeAt() comparisons
var NEWLINE_CODE = 10;

// Private symbol for identifying `SourceNode`s when multiple versions of
// the source-map library are loaded. This MUST NOT CHANGE across
// versions!
var isSourceNode = "$$$isSourceNode$$$";

/**
 * SourceNodes provide a way to abstract over interpolating/concatenating
 * snippets of generated JavaScript source code while maintaining the line and
 * column information associated with the original source code.
 *
 * @param aLine The original line number.
 * @param aColumn The original column number.
 * @param aSource The original source's filename.
 * @param aChunks Optional. An array of strings which are snippets of
 *        generated JS, or other SourceNodes.
 * @param aName The original identifier.
 */
function SourceNode(aLine, aColumn, aSource, aChunks, aName) {
  this.children = [];
  this.sourceContents = {};
  this.line = aLine == null ? null : aLine;
  this.column = aColumn == null ? null : aColumn;
  this.source = aSource == null ? null : aSource;
  this.name = aName == null ? null : aName;
  this[isSourceNode] = true;
  if (aChunks != null) this.add(aChunks);
}

/**
 * Creates a SourceNode from generated code and a SourceMapConsumer.
 *
 * @param aGeneratedCode The generated code
 * @param aSourceMapConsumer The SourceMap for the generated code
 * @param aRelativePath Optional. The path that relative sources in the
 *        SourceMapConsumer should be relative to.
 */
SourceNode.fromStringWithSourceMap =
  function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {
    // The SourceNode we want to fill with the generated code
    // and the SourceMap
    var node = new SourceNode();

    // All even indices of this array are one line of the generated code,
    // while all odd indices are the newlines between two adjacent lines
    // (since `REGEX_NEWLINE` captures its match).
    // Processed fragments are removed from this array, by calling `shiftNextLine`.
    var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
    var shiftNextLine = function() {
      var lineContents = remainingLines.shift();
      // The last line of a file might not have a newline.
      var newLine = remainingLines.shift() || "";
      return lineContents + newLine;
    };

    // We need to remember the position of "remainingLines"
    var lastGeneratedLine = 1, lastGeneratedColumn = 0;

    // The generate SourceNodes we need a code range.
    // To extract it current and last mapping is used.
    // Here we store the last mapping.
    var lastMapping = null;

    aSourceMapConsumer.eachMapping(function (mapping) {
      if (lastMapping !== null) {
        // We add the code from "lastMapping" to "mapping":
        // First check if there is a new line in between.
        if (lastGeneratedLine < mapping.generatedLine) {
          // Associate first line with "lastMapping"
          addMappingWithCode(lastMapping, shiftNextLine());
          lastGeneratedLine++;
          lastGeneratedColumn = 0;
          // The remaining code is added without mapping
        } else {
          // There is no new line in between.
          // Associate the code between "lastGeneratedColumn" and
          // "mapping.generatedColumn" with "lastMapping"
          var nextLine = remainingLines[0];
          var code = nextLine.substr(0, mapping.generatedColumn -
                                        lastGeneratedColumn);
          remainingLines[0] = nextLine.substr(mapping.generatedColumn -
                                              lastGeneratedColumn);
          lastGeneratedColumn = mapping.generatedColumn;
          addMappingWithCode(lastMapping, code);
          // No more remaining code, continue
          lastMapping = mapping;
          return;
        }
      }
      // We add the generated code until the first mapping
      // to the SourceNode without any mapping.
      // Each line is added as separate string.
      while (lastGeneratedLine < mapping.generatedLine) {
        node.add(shiftNextLine());
        lastGeneratedLine++;
      }
      if (lastGeneratedColumn < mapping.generatedColumn) {
        var nextLine = remainingLines[0];
        node.add(nextLine.substr(0, mapping.generatedColumn));
        remainingLines[0] = nextLine.substr(mapping.generatedColumn);
        lastGeneratedColumn = mapping.generatedColumn;
      }
      lastMapping = mapping;
    }, this);
    // We have processed all mappings.
    if (remainingLines.length > 0) {
      if (lastMapping) {
        // Associate the remaining code in the current line with "lastMapping"
        addMappingWithCode(lastMapping, shiftNextLine());
      }
      // and add the remaining lines without any mapping
      node.add(remainingLines.join(""));
    }

    // Copy sourcesContent into SourceNode
    aSourceMapConsumer.sources.forEach(function (sourceFile) {
      var content = aSourceMapConsumer.sourceContentFor(sourceFile);
      if (content != null) {
        if (aRelativePath != null) {
          sourceFile = util.join(aRelativePath, sourceFile);
        }
        node.setSourceContent(sourceFile, content);
      }
    });

    return node;

    function addMappingWithCode(mapping, code) {
      if (mapping === null || mapping.source === undefined) {
        node.add(code);
      } else {
        var source = aRelativePath
          ? util.join(aRelativePath, mapping.source)
          : mapping.source;
        node.add(new SourceNode(mapping.originalLine,
                                mapping.originalColumn,
                                source,
                                code,
                                mapping.name));
      }
    }
  };

/**
 * Add a chunk of generated JS to this source node.
 *
 * @param aChunk A string snippet of generated JS code, another instance of
 *        SourceNode, or an array where each member is one of those things.
 */
SourceNode.prototype.add = function SourceNode_add(aChunk) {
  if (Array.isArray(aChunk)) {
    aChunk.forEach(function (chunk) {
      this.add(chunk);
    }, this);
  }
  else if (aChunk[isSourceNode] || typeof aChunk === "string") {
    if (aChunk) {
      this.children.push(aChunk);
    }
  }
  else {
    throw new TypeError(
      "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
    );
  }
  return this;
};

/**
 * Add a chunk of generated JS to the beginning of this source node.
 *
 * @param aChunk A string snippet of generated JS code, another instance of
 *        SourceNode, or an array where each member is one of those things.
 */
SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {
  if (Array.isArray(aChunk)) {
    for (var i = aChunk.length-1; i >= 0; i--) {
      this.prepend(aChunk[i]);
    }
  }
  else if (aChunk[isSourceNode] || typeof aChunk === "string") {
    this.children.unshift(aChunk);
  }
  else {
    throw new TypeError(
      "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
    );
  }
  return this;
};

/**
 * Walk over the tree of JS snippets in this node and its children. The
 * walking function is called once for each snippet of JS and is passed that
 * snippet and the its original associated source's line/column location.
 *
 * @param aFn The traversal function.
 */
SourceNode.prototype.walk = function SourceNode_walk(aFn) {
  var chunk;
  for (var i = 0, len = this.children.length; i < len; i++) {
    chunk = this.children[i];
    if (chunk[isSourceNode]) {
      chunk.walk(aFn);
    }
    else {
      if (chunk !== '') {
        aFn(chunk, { source: this.source,
                     line: this.line,
                     column: this.column,
                     name: this.name });
      }
    }
  }
};

/**
 * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
 * each of `this.children`.
 *
 * @param aSep The separator.
 */
SourceNode.prototype.join = function SourceNode_join(aSep) {
  var newChildren;
  var i;
  var len = this.children.length;
  if (len > 0) {
    newChildren = [];
    for (i = 0; i < len-1; i++) {
      newChildren.push(this.children[i]);
      newChildren.push(aSep);
    }
    newChildren.push(this.children[i]);
    this.children = newChildren;
  }
  return this;
};

/**
 * Call String.prototype.replace on the very right-most source snippet. Useful
 * for trimming whitespace from the end of a source node, etc.
 *
 * @param aPattern The pattern to replace.
 * @param aReplacement The thing to replace the pattern with.
 */
SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
  var lastChild = this.children[this.children.length - 1];
  if (lastChild[isSourceNode]) {
    lastChild.replaceRight(aPattern, aReplacement);
  }
  else if (typeof lastChild === 'string') {
    this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
  }
  else {
    this.children.push(''.replace(aPattern, aReplacement));
  }
  return this;
};

/**
 * Set the source content for a source file. This will be added to the SourceMapGenerator
 * in the sourcesContent field.
 *
 * @param aSourceFile The filename of the source file
 * @param aSourceContent The content of the source file
 */
SourceNode.prototype.setSourceContent =
  function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
    this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
  };

/**
 * Walk over the tree of SourceNodes. The walking function is called for each
 * source file content and is passed the filename and source content.
 *
 * @param aFn The traversal function.
 */
SourceNode.prototype.walkSourceContents =
  function SourceNode_walkSourceContents(aFn) {
    for (var i = 0, len = this.children.length; i < len; i++) {
      if (this.children[i][isSourceNode]) {
        this.children[i].walkSourceContents(aFn);
      }
    }

    var sources = Object.keys(this.sourceContents);
    for (var i = 0, len = sources.length; i < len; i++) {
      aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
    }
  };

/**
 * Return the string representation of this source node. Walks over the tree
 * and concatenates all the various snippets together to one string.
 */
SourceNode.prototype.toString = function SourceNode_toString() {
  var str = "";
  this.walk(function (chunk) {
    str += chunk;
  });
  return str;
};

/**
 * Returns the string representation of this source node along with a source
 * map.
 */
SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
  var generated = {
    code: "",
    line: 1,
    column: 0
  };
  var map = new SourceMapGenerator(aArgs);
  var sourceMappingActive = false;
  var lastOriginalSource = null;
  var lastOriginalLine = null;
  var lastOriginalColumn = null;
  var lastOriginalName = null;
  this.walk(function (chunk, original) {
    generated.code += chunk;
    if (original.source !== null
        && original.line !== null
        && original.column !== null) {
      if(lastOriginalSource !== original.source
         || lastOriginalLine !== original.line
         || lastOriginalColumn !== original.column
         || lastOriginalName !== original.name) {
        map.addMapping({
          source: original.source,
          original: {
            line: original.line,
            column: original.column
          },
          generated: {
            line: generated.line,
            column: generated.column
          },
          name: original.name
        });
      }
      lastOriginalSource = original.source;
      lastOriginalLine = original.line;
      lastOriginalColumn = original.column;
      lastOriginalName = original.name;
      sourceMappingActive = true;
    } else if (sourceMappingActive) {
      map.addMapping({
        generated: {
          line: generated.line,
          column: generated.column
        }
      });
      lastOriginalSource = null;
      sourceMappingActive = false;
    }
    for (var idx = 0, length = chunk.length; idx < length; idx++) {
      if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
        generated.line++;
        generated.column = 0;
        // Mappings end at eol
        if (idx + 1 === length) {
          lastOriginalSource = null;
          sourceMappingActive = false;
        } else if (sourceMappingActive) {
          map.addMapping({
            source: original.source,
            original: {
              line: original.line,
              column: original.column
            },
            generated: {
              line: generated.line,
              column: generated.column
            },
            name: original.name
          });
        }
      } else {
        generated.column++;
      }
    }
  });
  this.walkSourceContents(function (sourceFile, sourceContent) {
    map.setSourceContent(sourceFile, sourceContent);
  });

  return { code: generated.code, map: map };
};

exports.SourceNode = SourceNode;

},{"./source-map-generator":861,"./util":863}],863:[function(require,module,exports){
/* -*- Mode: js; js-indent-level: 2; -*- */
/*
 * Copyright 2011 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE or:
 * http://opensource.org/licenses/BSD-3-Clause
 */

/**
 * This is a helper function for getting values from parameter/options
 * objects.
 *
 * @param args The object we are extracting values from
 * @param name The name of the property we are getting.
 * @param defaultValue An optional value to return if the property is missing
 * from the object. If this is not specified and the property is missing, an
 * error will be thrown.
 */
function getArg(aArgs, aName, aDefaultValue) {
  if (aName in aArgs) {
    return aArgs[aName];
  } else if (arguments.length === 3) {
    return aDefaultValue;
  } else {
    throw new Error('"' + aName + '" is a required argument.');
  }
}
exports.getArg = getArg;

var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.]*)(?::(\d+))?(\S*)$/;
var dataUrlRegexp = /^data:.+\,.+$/;

function urlParse(aUrl) {
  var match = aUrl.match(urlRegexp);
  if (!match) {
    return null;
  }
  return {
    scheme: match[1],
    auth: match[2],
    host: match[3],
    port: match[4],
    path: match[5]
  };
}
exports.urlParse = urlParse;

function urlGenerate(aParsedUrl) {
  var url = '';
  if (aParsedUrl.scheme) {
    url += aParsedUrl.scheme + ':';
  }
  url += '//';
  if (aParsedUrl.auth) {
    url += aParsedUrl.auth + '@';
  }
  if (aParsedUrl.host) {
    url += aParsedUrl.host;
  }
  if (aParsedUrl.port) {
    url += ":" + aParsedUrl.port
  }
  if (aParsedUrl.path) {
    url += aParsedUrl.path;
  }
  return url;
}
exports.urlGenerate = urlGenerate;

/**
 * Normalizes a path, or the path portion of a URL:
 *
 * - Replaces consecutive slashes with one slash.
 * - Removes unnecessary '.' parts.
 * - Removes unnecessary '<dir>/..' parts.
 *
 * Based on code in the Node.js 'path' core module.
 *
 * @param aPath The path or url to normalize.
 */
function normalize(aPath) {
  var path = aPath;
  var url = urlParse(aPath);
  if (url) {
    if (!url.path) {
      return aPath;
    }
    path = url.path;
  }
  var isAbsolute = exports.isAbsolute(path);

  var parts = path.split(/\/+/);
  for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
    part = parts[i];
    if (part === '.') {
      parts.splice(i, 1);
    } else if (part === '..') {
      up++;
    } else if (up > 0) {
      if (part === '') {
        // The first part is blank if the path is absolute. Trying to go
        // above the root is a no-op. Therefore we can remove all '..' parts
        // directly after the root.
        parts.splice(i + 1, up);
        up = 0;
      } else {
        parts.splice(i, 2);
        up--;
      }
    }
  }
  path = parts.join('/');

  if (path === '') {
    path = isAbsolute ? '/' : '.';
  }

  if (url) {
    url.path = path;
    return urlGenerate(url);
  }
  return path;
}
exports.normalize = normalize;

/**
 * Joins two paths/URLs.
 *
 * @param aRoot The root path or URL.
 * @param aPath The path or URL to be joined with the root.
 *
 * - If aPath is a URL or a data URI, aPath is returned, unless aPath is a
 *   scheme-relative URL: Then the scheme of aRoot, if any, is prepended
 *   first.
 * - Otherwise aPath is a path. If aRoot is a URL, then its path portion
 *   is updated with the result and aRoot is returned. Otherwise the result
 *   is returned.
 *   - If aPath is absolute, the result is aPath.
 *   - Otherwise the two paths are joined with a slash.
 * - Joining for example 'http://' and 'www.example.com' is also supported.
 */
function join(aRoot, aPath) {
  if (aRoot === "") {
    aRoot = ".";
  }
  if (aPath === "") {
    aPath = ".";
  }
  var aPathUrl = urlParse(aPath);
  var aRootUrl = urlParse(aRoot);
  if (aRootUrl) {
    aRoot = aRootUrl.path || '/';
  }

  // `join(foo, '//www.example.org')`
  if (aPathUrl && !aPathUrl.scheme) {
    if (aRootUrl) {
      aPathUrl.scheme = aRootUrl.scheme;
    }
    return urlGenerate(aPathUrl);
  }

  if (aPathUrl || aPath.match(dataUrlRegexp)) {
    return aPath;
  }

  // `join('http://', 'www.example.com')`
  if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
    aRootUrl.host = aPath;
    return urlGenerate(aRootUrl);
  }

  var joined = aPath.charAt(0) === '/'
    ? aPath
    : normalize(aRoot.replace(/\/+$/, '') + '/' + aPath);

  if (aRootUrl) {
    aRootUrl.path = joined;
    return urlGenerate(aRootUrl);
  }
  return joined;
}
exports.join = join;

exports.isAbsolute = function (aPath) {
  return aPath.charAt(0) === '/' || !!aPath.match(urlRegexp);
};

/**
 * Make a path relative to a URL or another path.
 *
 * @param aRoot The root path or URL.
 * @param aPath The path or URL to be made relative to aRoot.
 */
function relative(aRoot, aPath) {
  if (aRoot === "") {
    aRoot = ".";
  }

  aRoot = aRoot.replace(/\/$/, '');

  // It is possible for the path to be above the root. In this case, simply
  // checking whether the root is a prefix of the path won't work. Instead, we
  // need to remove components from the root one by one, until either we find
  // a prefix that fits, or we run out of components to remove.
  var level = 0;
  while (aPath.indexOf(aRoot + '/') !== 0) {
    var index = aRoot.lastIndexOf("/");
    if (index < 0) {
      return aPath;
    }

    // If the only part of the root that is left is the scheme (i.e. http://,
    // file:///, etc.), one or more slashes (/), or simply nothing at all, we
    // have exhausted all components, so the path is not relative to the root.
    aRoot = aRoot.slice(0, index);
    if (aRoot.match(/^([^\/]+:\/)?\/*$/)) {
      return aPath;
    }

    ++level;
  }

  // Make sure we add a "../" for each component we removed from the root.
  return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
}
exports.relative = relative;

var supportsNullProto = (function () {
  var obj = Object.create(null);
  return !('__proto__' in obj);
}());

function identity (s) {
  return s;
}

/**
 * Because behavior goes wacky when you set `__proto__` on objects, we
 * have to prefix all the strings in our set with an arbitrary character.
 *
 * See https://github.com/mozilla/source-map/pull/31 and
 * https://github.com/mozilla/source-map/issues/30
 *
 * @param String aStr
 */
function toSetString(aStr) {
  if (isProtoString(aStr)) {
    return '$' + aStr;
  }

  return aStr;
}
exports.toSetString = supportsNullProto ? identity : toSetString;

function fromSetString(aStr) {
  if (isProtoString(aStr)) {
    return aStr.slice(1);
  }

  return aStr;
}
exports.fromSetString = supportsNullProto ? identity : fromSetString;

function isProtoString(s) {
  if (!s) {
    return false;
  }

  var length = s.length;

  if (length < 9 /* "__proto__".length */) {
    return false;
  }

  if (s.charCodeAt(length - 1) !== 95  /* '_' */ ||
      s.charCodeAt(length - 2) !== 95  /* '_' */ ||
      s.charCodeAt(length - 3) !== 111 /* 'o' */ ||
      s.charCodeAt(length - 4) !== 116 /* 't' */ ||
      s.charCodeAt(length - 5) !== 111 /* 'o' */ ||
      s.charCodeAt(length - 6) !== 114 /* 'r' */ ||
      s.charCodeAt(length - 7) !== 112 /* 'p' */ ||
      s.charCodeAt(length - 8) !== 95  /* '_' */ ||
      s.charCodeAt(length - 9) !== 95  /* '_' */) {
    return false;
  }

  for (var i = length - 10; i >= 0; i--) {
    if (s.charCodeAt(i) !== 36 /* '$' */) {
      return false;
    }
  }

  return true;
}

/**
 * Comparator between two mappings where the original positions are compared.
 *
 * Optionally pass in `true` as `onlyCompareGenerated` to consider two
 * mappings with the same original source/line/column, but different generated
 * line and column the same. Useful when searching for a mapping with a
 * stubbed out mapping.
 */
function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
  var cmp = mappingA.source - mappingB.source;
  if (cmp !== 0) {
    return cmp;
  }

  cmp = mappingA.originalLine - mappingB.originalLine;
  if (cmp !== 0) {
    return cmp;
  }

  cmp = mappingA.originalColumn - mappingB.originalColumn;
  if (cmp !== 0 || onlyCompareOriginal) {
    return cmp;
  }

  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
  if (cmp !== 0) {
    return cmp;
  }

  cmp = mappingA.generatedLine - mappingB.generatedLine;
  if (cmp !== 0) {
    return cmp;
  }

  return mappingA.name - mappingB.name;
}
exports.compareByOriginalPositions = compareByOriginalPositions;

/**
 * Comparator between two mappings with deflated source and name indices where
 * the generated positions are compared.
 *
 * Optionally pass in `true` as `onlyCompareGenerated` to consider two
 * mappings with the same generated line and column, but different
 * source/name/original line and column the same. Useful when searching for a
 * mapping with a stubbed out mapping.
 */
function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {
  var cmp = mappingA.generatedLine - mappingB.generatedLine;
  if (cmp !== 0) {
    return cmp;
  }

  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
  if (cmp !== 0 || onlyCompareGenerated) {
    return cmp;
  }

  cmp = mappingA.source - mappingB.source;
  if (cmp !== 0) {
    return cmp;
  }

  cmp = mappingA.originalLine - mappingB.originalLine;
  if (cmp !== 0) {
    return cmp;
  }

  cmp = mappingA.originalColumn - mappingB.originalColumn;
  if (cmp !== 0) {
    return cmp;
  }

  return mappingA.name - mappingB.name;
}
exports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;

function strcmp(aStr1, aStr2) {
  if (aStr1 === aStr2) {
    return 0;
  }

  if (aStr1 > aStr2) {
    return 1;
  }

  return -1;
}

/**
 * Comparator between two mappings with inflated source and name strings where
 * the generated positions are compared.
 */
function compareByGeneratedPositionsInflated(mappingA, mappingB) {
  var cmp = mappingA.generatedLine - mappingB.generatedLine;
  if (cmp !== 0) {
    return cmp;
  }

  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
  if (cmp !== 0) {
    return cmp;
  }

  cmp = strcmp(mappingA.source, mappingB.source);
  if (cmp !== 0) {
    return cmp;
  }

  cmp = mappingA.originalLine - mappingB.originalLine;
  if (cmp !== 0) {
    return cmp;
  }

  cmp = mappingA.originalColumn - mappingB.originalColumn;
  if (cmp !== 0) {
    return cmp;
  }

  return strcmp(mappingA.name, mappingB.name);
}
exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;

},{}],864:[function(require,module,exports){
/*
 * Copyright 2009-2011 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE.txt or:
 * http://opensource.org/licenses/BSD-3-Clause
 */
exports.SourceMapGenerator = require('./lib/source-map-generator').SourceMapGenerator;
exports.SourceMapConsumer = require('./lib/source-map-consumer').SourceMapConsumer;
exports.SourceNode = require('./lib/source-node').SourceNode;

},{"./lib/source-map-consumer":860,"./lib/source-map-generator":861,"./lib/source-node":862}],865:[function(require,module,exports){
var SPECIFICITY = (function() {
	var calculate,
		calculateSingle,
		compare;

	// Calculate the specificity for a selector by dividing it into simple selectors and counting them
	calculate = function(input) {
		var selectors,
			selector,
			i,
			len,
			results = [];

		// Separate input by commas
		selectors = input.split(',');

		for (i = 0, len = selectors.length; i < len; i += 1) {
			selector = selectors[i];
			if (selector.length > 0) {
				results.push(calculateSingle(selector));
			}
		}

		return results;
	};

	/**
	 * Calculates the specificity of CSS selectors
	 * http://www.w3.org/TR/css3-selectors/#specificity
	 *
	 * Returns an object with the following properties:
	 *  - selector: the input
	 *  - specificity: e.g. 0,1,0,0
	 *  - parts: array with details about each part of the selector that counts towards the specificity
	 *  - specificityArray: e.g. [0, 1, 0, 0]
	 */
	calculateSingle = function(input) {
		var selector = input,
			findMatch,
			typeCount = {
				'a': 0,
				'b': 0,
				'c': 0
			},
			parts = [],
			// The following regular expressions assume that selectors matching the preceding regular expressions have been removed
			attributeRegex = /(\[[^\]]+\])/g,
			idRegex = /(#[^\#\s\+>~\.\[:]+)/g,
			classRegex = /(\.[^\s\+>~\.\[:]+)/g,
			pseudoElementRegex = /(::[^\s\+>~\.\[:]+|:first-line|:first-letter|:before|:after)/gi,
			// A regex for pseudo classes with brackets - :nth-child(), :nth-last-child(), :nth-of-type(), :nth-last-type(), :lang()
			pseudoClassWithBracketsRegex = /(:[\w-]+\([^\)]*\))/gi,
			// A regex for other pseudo classes, which don't have brackets
			pseudoClassRegex = /(:[^\s\+>~\.\[:]+)/g,
			elementRegex = /([^\s\+>~\.\[:]+)/g;

		// Find matches for a regular expression in a string and push their details to parts
		// Type is "a" for IDs, "b" for classes, attributes and pseudo-classes and "c" for elements and pseudo-elements
		findMatch = function(regex, type) {
			var matches, i, len, match, index, length;
			if (regex.test(selector)) {
				matches = selector.match(regex);
				for (i = 0, len = matches.length; i < len; i += 1) {
					typeCount[type] += 1;
					match = matches[i];
					index = selector.indexOf(match);
					length = match.length;
					parts.push({
						selector: input.substr(index, length),
						type: type,
						index: index,
						length: length
					});
					// Replace this simple selector with whitespace so it won't be counted in further simple selectors
					selector = selector.replace(match, Array(length + 1).join(' '));
				}
			}
		};

		// Replace escaped characters with plain text, using the "A" character
		// https://www.w3.org/TR/CSS21/syndata.html#characters
		(function() {
			var replaceWithPlainText = function(regex) {
					var matches, i, len, match;
					if (regex.test(selector)) {
						matches = selector.match(regex);
						for (i = 0, len = matches.length; i < len; i += 1) {
							match = matches[i];
							selector = selector.replace(match, Array(match.length + 1).join('A'));
						}
					}
				},
				// Matches a backslash followed by six hexadecimal digits followed by an optional single whitespace character
				escapeHexadecimalRegex = /\\[0-9A-Fa-f]{6}\s?/g,
				// Matches a backslash followed by fewer than six hexadecimal digits followed by a mandatory single whitespace character
				escapeHexadecimalRegex2 = /\\[0-9A-Fa-f]{1,5}\s/g,
				// Matches a backslash followed by any character
				escapeSpecialCharacter = /\\./g;

			replaceWithPlainText(escapeHexadecimalRegex);
			replaceWithPlainText(escapeHexadecimalRegex2);
			replaceWithPlainText(escapeSpecialCharacter);
		}());

		// Remove the negation psuedo-class (:not) but leave its argument because specificity is calculated on its argument
		(function() {
			var regex = /:not\(([^\)]*)\)/g;
			if (regex.test(selector)) {
				selector = selector.replace(regex, '     $1 ');
			}
		}());

		// Remove anything after a left brace in case a user has pasted in a rule, not just a selector
		(function() {
			var regex = /{[^]*/gm,
				matches, i, len, match;
			if (regex.test(selector)) {
				matches = selector.match(regex);
				for (i = 0, len = matches.length; i < len; i += 1) {
					match = matches[i];
					selector = selector.replace(match, Array(match.length + 1).join(' '));
				}
			}
		}());

		// Add attribute selectors to parts collection (type b)
		findMatch(attributeRegex, 'b');

		// Add ID selectors to parts collection (type a)
		findMatch(idRegex, 'a');

		// Add class selectors to parts collection (type b)
		findMatch(classRegex, 'b');

		// Add pseudo-element selectors to parts collection (type c)
		findMatch(pseudoElementRegex, 'c');

		// Add pseudo-class selectors to parts collection (type b)
		findMatch(pseudoClassWithBracketsRegex, 'b');
		findMatch(pseudoClassRegex, 'b');

		// Remove universal selector and separator characters
		selector = selector.replace(/[\*\s\+>~]/g, ' ');

		// Remove any stray dots or hashes which aren't attached to words
		// These may be present if the user is live-editing this selector
		selector = selector.replace(/[#\.]/g, ' ');

		// The only things left should be element selectors (type c)
		findMatch(elementRegex, 'c');

		// Order the parts in the order they appear in the original selector
		// This is neater for external apps to deal with
		parts.sort(function(a, b) {
			return a.index - b.index;
		});

		return {
			selector: input,
			specificity: '0,' + typeCount.a.toString() + ',' + typeCount.b.toString() + ',' + typeCount.c.toString(),
			specificityArray: [0, typeCount.a, typeCount.b, typeCount.c],
			parts: parts
		};
	};

	/**
	 * Compares two CSS selectors for specificity
	 * Alternatively you can replace one of the CSS selectors with a specificity array
	 *
	 *  - it returns -1 if a has a lower specificity than b
	 *  - it returns 1 if a has a higher specificity than b
	 *  - it returns 0 if a has the same specificity than b
	 */
	compare = function(a, b) {
		var aSpecificity,
			bSpecificity,
			i;

		if (typeof a ==='string') {
			if (a.indexOf(',') !== -1) {
				throw 'Invalid CSS selector';
			} else {
				aSpecificity = calculateSingle(a)['specificityArray'];
			}
		} else if (Array.isArray(a)) {
			if (a.filter(function(e) { return (typeof e === 'number'); }).length !== 4) {
				throw 'Invalid specificity array';
			} else {
				aSpecificity = a;
			}
		} else {
			throw 'Invalid CSS selector or specificity array';
		}

		if (typeof b ==='string') {
			if (b.indexOf(',') !== -1) {
				throw 'Invalid CSS selector';
			} else {
				bSpecificity = calculateSingle(b)['specificityArray'];
			}
		} else if (Array.isArray(b)) {
			if (b.filter(function(e) { return (typeof e === 'number'); }).length !== 4) {
				throw 'Invalid specificity array';
			} else {
				bSpecificity = b;
			}
		} else {
			throw 'Invalid CSS selector or specificity array';
		}

		for (i = 0; i < 4; i += 1) {
			if (aSpecificity[i] < bSpecificity[i]) {
				return -1;
			} else if (aSpecificity[i] > bSpecificity[i]) {
				return 1;
			}
		}

		return 0;
	};

	return {
		calculate: calculate,
		compare: compare
	};
}());

// Export for Node JS
if (typeof exports !== 'undefined') {
	exports.calculate = SPECIFICITY.calculate;
	exports.compare = SPECIFICITY.compare;
}

},{}],866:[function(require,module,exports){
'use strict';
const stripAnsi = require('strip-ansi');
const isFullwidthCodePoint = require('is-fullwidth-code-point');

module.exports = str => {
	if (typeof str !== 'string' || str.length === 0) {
		return 0;
	}

	str = stripAnsi(str);

	let width = 0;

	for (let i = 0; i < str.length; i++) {
		const code = str.codePointAt(i);

		// Ignore control characters
		if (code <= 0x1F || (code >= 0x7F && code <= 0x9F)) {
			continue;
		}

		// Ignore combining characters
		if (code >= 0x300 && code <= 0x36F) {
			continue;
		}

		// Surrogates
		if (code > 0xFFFF) {
			i++;
		}

		width += isFullwidthCodePoint(code) ? 2 : 1;
	}

	return width;
};

},{"is-fullwidth-code-point":646,"strip-ansi":868}],867:[function(require,module,exports){
'use strict';

module.exports = () => {
	const pattern = [
		'[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[a-zA-Z\\d]*)*)?\\u0007)',
		'(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PRZcf-ntqry=><~]))'
	].join('|');

	return new RegExp(pattern, 'g');
};

},{}],868:[function(require,module,exports){
'use strict';
const ansiRegex = require('ansi-regex');

module.exports = input => typeof input === 'string' ? input.replace(ansiRegex(), '') : input;

},{"ansi-regex":867}],869:[function(require,module,exports){
'use strict';
var ansiRegex = require('ansi-regex')();

module.exports = function (str) {
	return typeof str === 'string' ? str.replace(ansiRegex, '') : str;
};

},{"ansi-regex":44}],870:[function(require,module,exports){
var SKIP = 'skip';
var CHECK = 'check';
var ONLY = 'only';

module.exports = function (options, callback) {
  var source = options.source;
  var target = options.target;

  var skipComments = (options.comments) ? options.comments === SKIP : true;
  var skipStrings = (options.strings) ? options.strings === SKIP : true;
  var skipFunctionNames = (options.functionNames) ? options.functionNames === SKIP : true;
  var skipFunctionArguments = options.functionArguments === SKIP;
  var skipParentheticals = options.parentheticals === SKIP;

  var onceOptionUsed = false;
  Object.keys(options).forEach(function(key) {
    if (options[key] !== ONLY) return;
    if (!onceOptionUsed) {
      onceOptionUsed = true;
    } else {
      throw new Error('Only one syntax feature option can be the "only" one to check');
    }
  });

  var onlyComments = options.comments === ONLY;
  var onlyStrings = options.strings === ONLY;
  var onlyFunctionNames = options.functionNames === ONLY;
  var onlyFunctionArguments = options.functionArguments === ONLY;
  var onlyParentheticals = options.parentheticals === ONLY;

  var insideString = false;
  var insideComment = false;
  var insideSingleLineComment = false;
  var insideParens = false;
  var insideFunctionArguments = false;
  var openingParenCount = 0;
  var matchCount = 0;
  var openingQuote;

  var targetIsArray = Array.isArray(target);

  // If the target is just a string, it is easy to check whether
  // some index of the source matches it.
  // If the target is an array of strings, though, we have to
  // check whether some index of the source matches *any* of
  // those target strings (stopping after the first match).
  var getMatch = (function () {
    if (!targetIsArray) {
      return getMatchBase.bind(null, target);
    }
    return function(index) {
      for (var ti = 0, tl = target.length; ti < tl; ti++) {
        var checkResult = getMatchBase(target[ti], index);
        if (checkResult) return checkResult;
      }
      return false;
    }
  })();

  function getMatchBase(targetString, index) {
    var targetStringLength = targetString.length;

    // Target is a single character
    if (targetStringLength === 1 && source[index] !== targetString) return false;

    // Target is multiple characters
    if (source.substr(index, targetStringLength) !== targetString) return false;

    return {
      insideParens: insideParens,
      insideFunctionArguments: insideFunctionArguments,
      insideComment: insideComment,
      insideString: insideString,
      startIndex: index,
      endIndex: index + targetStringLength,
      target: targetString,
    };
  }

  for (var i = 0, l = source.length; i < l; i++) {
    var currentChar = source[i];

    // Register the beginning of a comment
    if (
      !insideString && !insideComment
      && currentChar === "/"
      && source[i - 1] !== "\\" // escaping
    ) {
      // standard comments
      if (source[i + 1] === "*") {
        insideComment = true;
        continue;
      }
      // single-line comments
      if (source[i + 1] === "/") {
        insideComment = true;
        insideSingleLineComment = true;
        continue;
      }
    }

    if (insideComment) {
      // Register the end of a standard comment
      if (
        !insideSingleLineComment
        && currentChar === "*"
        && source[i - 1] !== "\\" // escaping
        && source[i + 1] === "/"
        && source[i - 1] !== "/" // don't end if it's /*/
      ) {
        insideComment = false;
        continue;
      }

      // Register the end of a single-line comment
      if (
        insideSingleLineComment
        && currentChar === "\n"
      ) {
        insideComment = false;
        insideSingleLineComment = false;
      }

      if (skipComments) continue;
    }

    // Register the beginning of a string
    if (!insideComment && !insideString && (currentChar === "\"" || currentChar === "'")) {
      if (source[i - 1] === "\\") continue; // escaping

      openingQuote = currentChar;
      insideString = true;

      // For string-quotes rule
      if (target === currentChar) handleMatch(getMatch(i));
      continue;
    }

    if (insideString) {
      // Register the end of a string
      if (currentChar === openingQuote) {
        if (source[i - 1] === "\\") continue; // escaping
        insideString = false;
        continue;
      }

      if (skipStrings) continue;
    }

    // Register the beginning of parens/functions
    if (!insideString && !insideComment && currentChar === "(") {
      // Keep track of opening parentheticals so that we
      // know when the outermost function (possibly
      // containing nested functions) is closing
      openingParenCount++;

      insideParens = true;
      // Only inside a function if there is a function name
      // before the opening paren
      if (/[a-zA-Z]/.test(source[i - 1])) {
        insideFunctionArguments = true;
      }

      if (target === "(") handleMatch(getMatch(i));
      continue;
    }

    if (insideParens) {
      // Register the end of a function
      if (currentChar === ")") {
        openingParenCount--;
        // Do this here so the match is still technically inside a function
        if (target === ")") handleMatch(getMatch(i));
        if (openingParenCount === 0) {
          insideParens = false;
          insideFunctionArguments = false;
        }
        continue;
      }
    }

    var isFunctionName = /^[a-zA-Z]*\(/.test(source.slice(i));
    if (skipFunctionNames && isFunctionName) continue;
    if (onlyFunctionNames && !isFunctionName) continue;

    var match = getMatch(i);

    if (!match) continue;
    handleMatch(match);
    if (options.once) return;
  }

  function handleMatch(match) {
    if (onlyParentheticals && !insideParens) return;
    if (skipParentheticals && insideParens) return;
    if (onlyFunctionArguments && !insideFunctionArguments) return;
    if (skipFunctionArguments && insideFunctionArguments) return;
    if (onlyStrings && !insideString) return;
    if (onlyComments && !insideComment) return;
    matchCount++;
    callback(match, matchCount);
  }
}

},{}],871:[function(require,module,exports){
/* @flow */
"use strict";
const _ = require("lodash");

const COMMAND_PREFIX = "stylelint-";
const disableCommand = COMMAND_PREFIX + "disable";
const enableCommand = COMMAND_PREFIX + "enable";
const disableLineCommand = COMMAND_PREFIX + "disable-line";
const disableNextLineCommand = COMMAND_PREFIX + "disable-next-line";
const ALL_RULES = "all";

/*:: type disabledRangeObject = {
  [ruleName: string]: Array<{
    start: number,
    end?: number,
  }>
}*/

// Run it like a plugin ...
module.exports = function(
  root /*: Object*/,
  result /*: Object*/
) /*: postcss$result*/ {
  result.stylelint = result.stylelint || {};

  // Most of the functions below work via side effects mutating
  // this object
  const disabledRanges /*: disabledRangeObject*/ = {
    all: []
  };
  result.stylelint.disabledRanges = disabledRanges;
  root.walkComments(checkComment);

  return result;

  function processDisableLineCommand(comment /*: postcss$comment*/) {
    getCommandRules(disableLineCommand, comment.text).forEach(ruleName => {
      disableLine(comment.source.start.line, ruleName, comment);
    });
  }

  function processDisableNextLineCommand(comment /*: postcss$comment*/) {
    getCommandRules(disableNextLineCommand, comment.text).forEach(ruleName => {
      disableLine(comment.source.start.line + 1, ruleName, comment);
    });
  }

  function disableLine(
    line /*: number*/,
    ruleName /*: string*/,
    comment /*: postcss$comment*/
  ) {
    if (ruleIsDisabled(ALL_RULES)) {
      throw comment.error("All rules have already been disabled", {
        plugin: "stylelint"
      });
    }
    if (ruleIsDisabled(ruleName)) {
      throw comment.error(`"${ruleName}" has already been disabled`, {
        plugin: "stylelint"
      });
    }
    if (ruleName === ALL_RULES) {
      Object.keys(disabledRanges).forEach(disabledRuleName => {
        startDisabledRange(line, disabledRuleName);
        endDisabledRange(line, disabledRuleName);
      });
    } else {
      startDisabledRange(line, ruleName);
      endDisabledRange(line, ruleName);
    }
  }

  function processDisableCommand(comment /*: postcss$comment*/) {
    getCommandRules(disableCommand, comment.text).forEach(ruleToDisable => {
      if (ruleToDisable === ALL_RULES) {
        if (ruleIsDisabled(ALL_RULES)) {
          throw comment.error("All rules have already been disabled", {
            plugin: "stylelint"
          });
        }
        Object.keys(disabledRanges).forEach(ruleName => {
          startDisabledRange(comment.source.start.line, ruleName);
        });
        return;
      }

      if (ruleIsDisabled(ruleToDisable)) {
        throw comment.error(`"${ruleToDisable}" has already been disabled`, {
          plugin: "stylelint"
        });
      }
      startDisabledRange(comment.source.start.line, ruleToDisable);
    });
  }

  function processEnableCommand(comment /*: postcss$comment*/) {
    getCommandRules(enableCommand, comment.text).forEach(ruleToEnable => {
      if (ruleToEnable === ALL_RULES) {
        if (
          _.values(disabledRanges).every(
            ranges => _.isEmpty(ranges) || !!_.last(ranges.end)
          )
        ) {
          throw comment.error("No rules have been disabled", {
            plugin: "stylelint"
          });
        }
        Object.keys(disabledRanges).forEach(ruleName => {
          if (!_.get(_.last(disabledRanges[ruleName]), "end")) {
            endDisabledRange(comment.source.end.line, ruleName);
          }
        });
        return;
      }

      if (
        ruleIsDisabled(ALL_RULES) &&
        disabledRanges[ruleToEnable] === undefined
      ) {
        // Get a starting point from the where all rules were disabled
        if (!disabledRanges[ruleToEnable]) {
          disabledRanges[ruleToEnable] = _.cloneDeep(disabledRanges.all);
        } else {
          disabledRanges[ruleToEnable].push(
            _.clone(_.last(disabledRanges[ALL_RULES]))
          );
        }
        endDisabledRange(comment.source.end.line, ruleToEnable);
        return;
      }

      if (ruleIsDisabled(ruleToEnable)) {
        endDisabledRange(comment.source.end.line, ruleToEnable);
        return;
      }

      throw comment.error(`"${ruleToEnable}" has not been disabled`, {
        plugin: "stylelint"
      });
    });
  }

  function checkComment(comment /*: postcss$comment*/) {
    const text = comment.text;

    // Ignore comments that are not relevant commands

    if (text.indexOf(COMMAND_PREFIX) !== 0) {
      return result;
    }

    if (text.indexOf(disableLineCommand) === 0) {
      processDisableLineCommand(comment);
    } else if (text.indexOf(disableNextLineCommand) === 0) {
      processDisableNextLineCommand(comment);
    } else if (text.indexOf(disableCommand) === 0) {
      processDisableCommand(comment);
    } else if (text.indexOf(enableCommand) === 0) {
      processEnableCommand(comment);
    }
  }

  function getCommandRules(
    command /*: string*/,
    fullText /*: string*/
  ) /*: Array<string>*/ {
    const rules = _.compact(fullText.slice(command.length).split(",")).map(r =>
      r.trim()
    );
    if (_.isEmpty(rules)) {
      return [ALL_RULES];
    }
    return rules;
  }

  function startDisabledRange(line /*: number*/, ruleName /*: string*/) {
    const rangeObj = { start: line };
    ensureRuleRanges(ruleName);
    disabledRanges[ruleName].push(rangeObj);
  }

  function endDisabledRange(line /*: number*/, ruleName /*: string*/) {
    const lastRangeForRule = _.last(disabledRanges[ruleName]);
    if (!lastRangeForRule) {
      return;
    }
    // Add an `end` prop to the last range of that rule
    lastRangeForRule.end = line;
  }

  function ensureRuleRanges(ruleName /*: string*/) {
    if (!disabledRanges[ruleName]) {
      disabledRanges[ruleName] = _.cloneDeep(disabledRanges.all);
    }
  }

  function ruleIsDisabled(ruleName /*: string*/) /*: boolean*/ {
    if (disabledRanges[ruleName] === undefined) return false;
    if (_.last(disabledRanges[ruleName]) === undefined) return false;
    if (_.get(_.last(disabledRanges[ruleName]), "end") === undefined)
      return true;
    return false;
  }
};

},{"lodash":692}],872:[function(require,module,exports){
/* @flow */
"use strict";
const _ = require("lodash");
const configurationError = require("./utils/configurationError");
const dynamicRequire = require("./dynamicRequire");
const getModulePath = require("./utils/getModulePath");
const globjoin = require("globjoin");
const normalizeRuleSettings = require("./normalizeRuleSettings");
const path = require("path");
const rules = require("./rules");

// - Merges config and configOverrides
// - Makes all paths absolute
// - Merges extends
function augmentConfigBasic(
  stylelint /*: stylelint$internalApi*/,
  config /*: stylelint$config*/,
  configDir /*: string*/,
  allowOverrides /*:: ?: boolean*/
) /*: Promise<stylelint$config>*/ {
  return Promise.resolve()
    .then(() => {
      if (!allowOverrides) return config;
      return _.merge(config, stylelint._options.configOverrides);
    })
    .then(augmentedConfig => {
      return extendConfig(stylelint, augmentedConfig, configDir);
    })
    .then(augmentedConfig => {
      return absolutizePaths(augmentedConfig, configDir);
    });
}

// Extended configs need to be run through augmentConfigBasic
// but do not need the full treatment. Things like pluginFunctions
// will be resolved and added by the parent config.
function augmentConfigExtended(
  stylelint /*: stylelint$internalApi*/,
  cosmiconfigResultArg /*: ?{
     config: stylelint$config,
     filepath: string,
   }*/
) /*: Promise<?{ config: stylelint$config, filepath: string }>*/ {
  const cosmiconfigResult = cosmiconfigResultArg; // Lock in for Flow
  if (!cosmiconfigResult) return Promise.resolve(null);

  const configDir = path.dirname(cosmiconfigResult.filepath || "");
  const cleanedConfig = _.omit(cosmiconfigResult.config, "ignoreFiles");
  return augmentConfigBasic(
    stylelint,
    cleanedConfig,
    configDir
  ).then(augmentedConfig => {
    return {
      config: augmentedConfig,
      filepath: cosmiconfigResult.filepath
    };
  });
}

function augmentConfigFull(
  stylelint /*: stylelint$internalApi*/,
  cosmiconfigResultArg /*: ?{
   config: stylelint$config,
   filepath: string,
  }*/
) /*: Promise<?{ config: stylelint$config, filepath: string }>*/ {
  const cosmiconfigResult = cosmiconfigResultArg; // Lock in for Flow
  if (!cosmiconfigResult) return Promise.resolve(null);

  const config = cosmiconfigResult.config,
    filepath = cosmiconfigResult.filepath;

  const configDir =
    stylelint._options.configBasedir || path.dirname(filepath || "");

  return augmentConfigBasic(stylelint, config, configDir, true)
    .then(augmentedConfig => {
      return addPluginFunctions(augmentedConfig);
    })
    .then(augmentedConfig => {
      return addProcessorFunctions(augmentedConfig);
    })
    .then(augmentedConfig => {
      if (!augmentedConfig.rules) {
        throw configurationError(
          'No rules found within configuration. Have you provided a "rules" property?'
        );
      }

      return normalizeAllRuleSettings(augmentedConfig);
    })
    .then(augmentedConfig => {
      return {
        config: augmentedConfig,
        filepath: cosmiconfigResult.filepath
      };
    });
}

// Make all paths in the config absolute:
// - ignoreFiles
// - plugins
// - processors
// (extends handled elsewhere)
function absolutizePaths(
  config /*: stylelint$config*/,
  configDir /*: string*/
) /*: stylelint$config*/ {
  if (config.ignoreFiles) {
    config.ignoreFiles = [].concat(config.ignoreFiles).map(glob => {
      if (path.isAbsolute(glob.replace(/^!/, ""))) return glob;
      return globjoin(configDir, glob);
    });
  }

  if (config.plugins) {
    config.plugins = [].concat(config.plugins).map(lookup => {
      return getModulePath(configDir, lookup);
    });
  }

  if (config.processors) {
    config.processors = absolutizeProcessors(config.processors, configDir);
  }

  return config;
}

// Processors are absolutized in their own way because
// they can be and return a string or an array
function absolutizeProcessors(
  processors /*: stylelint$configProcessors*/,
  configDir /*: string*/
) /*: stylelint$configProcessors*/ {
  const normalizedProcessors = Array.isArray(processors)
    ? processors
    : [processors];

  return normalizedProcessors.map(item => {
    if (typeof item === "string") {
      return getModulePath(configDir, item);
    }

    return [getModulePath(configDir, item[0]), item[1]];
  });
}

function extendConfig(
  stylelint /*: stylelint$internalApi*/,
  config /*: stylelint$config*/,
  configDir /*: string*/
) /*: Promise<stylelint$config>*/ {
  if (config.extends === undefined) return Promise.resolve(config);
  const normalizedExtends = Array.isArray(config.extends)
    ? config.extends
    : [config.extends];

  const originalWithoutExtends = _.omit(config, "extends");
  const loadExtends = normalizedExtends.reduce(
    (resultPromise, extendLookup) => {
      return resultPromise.then(resultConfig => {
        return loadExtendedConfig(
          stylelint,
          resultConfig,
          configDir,
          extendLookup
        ).then(extendResult => {
          if (!extendResult) return resultConfig;
          return mergeConfigs(resultConfig, extendResult.config);
        });
      });
    },
    Promise.resolve(originalWithoutExtends)
  );

  return loadExtends.then(resultConfig => {
    return mergeConfigs(resultConfig, originalWithoutExtends);
  });
}

function loadExtendedConfig(
  stylelint /*: stylelint$internalApi*/,
  config /*: stylelint$config*/,
  configDir /*: string*/,
  extendLookup /*: string*/
) /*: Promise<?{ config: stylelint$config, filepath: string }>*/ {
  const extendPath = getModulePath(configDir, extendLookup);
  return stylelint._extendExplorer.load(null, extendPath);
}

// When merging configs (via extends)
// - plugin and processor arrays are joined
// - rules are merged via Object.assign, so there is no attempt made to
//   merge any given rule's settings. If b contains the same rule as a,
//   b's rule settings will override a's rule settings entirely.
// - Everything else is merged via Object.assign
function mergeConfigs(
  a /*: stylelint$config*/,
  b /*: stylelint$config*/
) /*: stylelint$config*/ {
  const pluginMerger = {};
  if (a.plugins || b.plugins) {
    pluginMerger.plugins = [];
    if (a.plugins) {
      pluginMerger.plugins = pluginMerger.plugins.concat(a.plugins);
    }
    if (b.plugins) {
      pluginMerger.plugins = _.uniq(pluginMerger.plugins.concat(b.plugins));
    }
  }

  const processorMerger = {};
  if (a.processors || b.processors) {
    processorMerger.processors = [];
    if (a.processors) {
      processorMerger.processors = processorMerger.processors.concat(
        a.processors
      );
    }
    if (b.processors) {
      processorMerger.processors = _.uniq(
        processorMerger.processors.concat(b.processors)
      );
    }
  }

  const rulesMerger = {};
  if (a.rules || b.rules) {
    rulesMerger.rules = Object.assign({}, a.rules, b.rules);
  }

  const result = Object.assign(
    {},
    a,
    b,
    processorMerger,
    pluginMerger,
    rulesMerger
  );
  return result;
}

function addPluginFunctions(
  config /*: stylelint$config*/
) /*: stylelint$config*/ {
  if (!config.plugins) return config;

  const normalizedPlugins = Array.isArray(config.plugins)
    ? config.plugins
    : [config.plugins];

  const pluginFunctions = normalizedPlugins.reduce((result, pluginLookup) => {
    let pluginImport = dynamicRequire(pluginLookup);
    // Handle either ES6 or CommonJS modules
    pluginImport = pluginImport.default || pluginImport;

    // A plugin can export either a single rule definition
    // or an array of them
    const normalizedPluginImport = Array.isArray(pluginImport)
      ? pluginImport
      : [pluginImport];

    normalizedPluginImport.forEach(pluginRuleDefinition => {
      if (!pluginRuleDefinition.ruleName) {
        throw configurationError(
          "stylelint v3+ requires plugins to expose a ruleName. " +
            `The plugin "${pluginLookup}" is not doing this, so will not work ` +
            "with stylelint v3+. Please file an issue with the plugin."
        );
      }

      if (!_.includes(pluginRuleDefinition.ruleName, "/")) {
        throw configurationError(
          "stylelint v7+ requires plugin rules to be namspaced, " +
            "i.e. only `plugin-namespace/plugin-rule-name` plugin rule names are supported. " +
            `The plugin rule "${pluginRuleDefinition.ruleName}" does not do this, so will not work. ` +
            "Please file an issue with the plugin."
        );
      }

      result[pluginRuleDefinition.ruleName] = pluginRuleDefinition.rule;
    });

    return result;
  }, {});

  config.pluginFunctions = pluginFunctions;
  return config;
}

function normalizeAllRuleSettings(
  config /*: stylelint$config*/
) /*: stylelint$config*/ {
  const normalizedRules = {};
  if (!config.rules) return config;
  Object.keys(config.rules).forEach(ruleName => {
    const rawRuleSettings = _.get(config, ["rules", ruleName]);
    const rule =
      rules[ruleName] || _.get(config, ["pluginFunctions", ruleName]);
    if (!rule) {
      throw configurationError(`Undefined rule ${ruleName}`);
    }
    normalizedRules[ruleName] = normalizeRuleSettings(
      rawRuleSettings,
      ruleName,
      _.get(rule, "primaryOptionArray")
    );
  });
  config.rules = normalizedRules;
  return config;
}

// Given an array of processors strings, we want to add two
// properties to the augmented config:
// - codeProcessors: functions that will run on code as it comes in
// - resultProcessors: functions that will run on results as they go out
//
// To create these properties, we need to:
// - Find the processor module
// - Intialize the processor module by calling its functions with any
//   provided options
// - Push the processor's code and result processors to their respective arrays
const processorCache = new Map();
function addProcessorFunctions(
  config /*: stylelint$config*/
) /*: stylelint$config*/ {
  if (!config.processors) return config;

  const codeProcessors = [];
  const resultProcessors = [];
  [].concat(config.processors).forEach(processorConfig => {
    const processorKey = JSON.stringify(processorConfig);

    let initializedProcessor;
    if (processorCache.has(processorKey)) {
      initializedProcessor = processorCache.get(processorKey);
    } else {
      processorConfig = [].concat(processorConfig);
      const processorLookup = processorConfig[0];
      const processorOptions = processorConfig[1];
      let processor = dynamicRequire(processorLookup);
      processor = processor.default || processor;
      initializedProcessor = processor(processorOptions);
      processorCache.set(processorKey, initializedProcessor);
    }

    if (initializedProcessor && initializedProcessor.code) {
      codeProcessors.push(initializedProcessor.code);
    }
    if (initializedProcessor && initializedProcessor.result) {
      resultProcessors.push(initializedProcessor.result);
    }
  });

  config.codeProcessors = codeProcessors;
  config.resultProcessors = resultProcessors;
  return config;
}

module.exports = { augmentConfigExtended, augmentConfigFull };

},{"./dynamicRequire":876,"./normalizeRuleSettings":886,"./rules":971,"./utils/configurationError":1078,"./utils/getModulePath":1086,"globjoin":626,"lodash":692,"path":14}],873:[function(require,module,exports){
"use strict";

module.exports = function(ruleName, rule) {
  return {
    ruleName,
    rule
  };
};

},{}],874:[function(require,module,exports){
/* @flow */
"use strict";
const _ = require("lodash");
const augmentConfig = require("./augmentConfig");
const cosmiconfig = require("cosmiconfig");
const createStylelintResult = require("./createStylelintResult");
const getConfigForFile = require("./getConfigForFile");
const getPostcssResult = require("./getPostcssResult");
const isPathIgnored = require("./isPathIgnored");
const lintSource = require("./lintSource");

// The stylelint "internal API" is passed among functions
// so that methods on a stylelint instance can invoke
// each other while sharing options and caches
module.exports = function(
  options /*: stylelint$options*/
) /*: stylelint$internalApi*/ {
  options = options || {};
  const stylelint /*: Object*/ = { _options: options };

  // Two separate explorers so they can each have their own transform
  // function whose results are cached by cosmiconfig
  stylelint._fullExplorer = cosmiconfig("stylelint", {
    argv: false,
    rcExtensions: true,
    transform: _.partial(augmentConfig.augmentConfigFull, stylelint)
  });
  stylelint._extendExplorer = cosmiconfig(null, {
    argv: false,
    transform: _.partial(augmentConfig.augmentConfigExtended, stylelint)
  });

  stylelint._specifiedConfigCache = new Map();
  stylelint._postcssResultCache = new Map();
  stylelint._createStylelintResult = _.partial(
    createStylelintResult,
    stylelint
  );
  stylelint._getPostcssResult = _.partial(getPostcssResult, stylelint);
  stylelint._lintSource = _.partial(lintSource, stylelint);

  stylelint.getConfigForFile = _.partial(getConfigForFile, stylelint);
  stylelint.isPathIgnored = _.partial(isPathIgnored, stylelint);

  return stylelint;
};

},{"./augmentConfig":872,"./createStylelintResult":875,"./getConfigForFile":881,"./getPostcssResult":882,"./isPathIgnored":883,"./lintSource":884,"cosmiconfig":589,"lodash":692}],875:[function(require,module,exports){
/* @flow */
"use strict";
const _ = require("lodash");

module.exports = function(
  stylelint /*: stylelint$internalApi*/,
  postcssResult /*: Object*/,
  filePath /*:: ?: string*/
) /*: Promise<stylelint$result>*/ {
  const source = !postcssResult.root.source
    ? undefined
    : postcssResult.root.source.input.file ||
      postcssResult.root.source.input.id;

  // Strip out deprecation warnings from the messages
  const deprecationMessages = _.remove(postcssResult.messages, {
    stylelintType: "deprecation"
  });
  const deprecations = deprecationMessages.map(deprecationMessage => {
    return {
      text: deprecationMessage.text,
      reference: deprecationMessage.stylelintReference
    };
  });

  // Also strip out invalid options
  const invalidOptionMessages = _.remove(postcssResult.messages, {
    stylelintType: "invalidOption"
  });
  const invalidOptionWarnings = invalidOptionMessages.map(
    invalidOptionMessage => {
      return {
        text: invalidOptionMessage.text
      };
    }
  );

  const parseErrors = _.remove(postcssResult.messages, {
    stylelintType: "parseError"
  });

  // This defines the stylelint result object that formatters receive
  let stylelintResult = {
    source,
    deprecations,
    invalidOptionWarnings,
    parseErrors,
    errored: postcssResult.stylelint.stylelintError,
    warnings: postcssResult.messages.map(message => {
      return {
        line: message.line,
        column: message.column,
        rule: message.rule,
        severity: message.severity,
        text: message.text
      };
    }),
    ignored: postcssResult.stylelint.ignored,
    _postcssResult: postcssResult
  };

  return stylelint.getConfigForFile(filePath).then(result => {
    const config = result.config;

    if (config.resultProcessors) {
      config.resultProcessors.forEach(resultProcessor => {
        // Result processors might just mutate the result object,
        // or might return a new one
        const returned = resultProcessor(stylelintResult, source);
        if (returned) {
          stylelintResult = returned;
        }
      });
    }

    return stylelintResult;
  });
};

},{"lodash":692}],876:[function(require,module,exports){
"use strict";
// This file exists to remove the need for Flow's ignore_non_literal_requires option

module.exports = function(name) {
  return require(name);
};

},{}],877:[function(require,module,exports){
"use strict";

module.exports = {
  json: require("./jsonFormatter"),
  string: require("./stringFormatter"),
  verbose: require("./verboseFormatter")
};

},{"./jsonFormatter":878,"./stringFormatter":879,"./verboseFormatter":880}],878:[function(require,module,exports){
"use strict";

const _ = require("lodash");

// Omit any properties starting with `_`, which are fake-private
module.exports = function(results) {
  const cleanedResults = results.map(result => {
    return _.omitBy(result, (value, key) => key[0] === "_");
  });
  return JSON.stringify(cleanedResults);
};

},{"lodash":692}],879:[function(require,module,exports){
(function (process){
"use strict";

const _ = require("lodash");
const chalk = require("chalk");
const path = require("path");
const stringWidth = require("string-width");
const symbols = require("log-symbols");
const table = require("table");
const utils = require("postcss-reporter/lib/util");

const MARGIN_WIDTHS = 9;

const levelColors = {
  info: "blue",
  warning: "yellow",
  error: "red"
};

function deprecationsFormatter(results) {
  const allDeprecationWarnings = _.flatMap(results, "deprecations");
  const uniqueDeprecationWarnings = _.uniqBy(allDeprecationWarnings, "text");

  if (!uniqueDeprecationWarnings || !uniqueDeprecationWarnings.length) {
    return "";
  }

  return uniqueDeprecationWarnings.reduce((output, warning) => {
    output += chalk.yellow("Deprecation Warning: ");
    output += warning.text;
    if (warning.reference) {
      output += chalk.dim(" See: ");
      output += chalk.dim.underline(warning.reference);
    }
    return output + "\n";
  }, "\n");
}

function invalidOptionsFormatter(results) {
  const allInvalidOptionWarnings = _.flatMap(results, r =>
    r.invalidOptionWarnings.map(w => w.text)
  );
  const uniqueInvalidOptionWarnings = _.uniq(allInvalidOptionWarnings);

  return uniqueInvalidOptionWarnings.reduce((output, warning) => {
    output += chalk.red("Invalid Option: ");
    output += warning;
    return output + "\n";
  }, "\n");
}

function logFrom(fromValue) {
  if (fromValue.charAt(0) === "<") return fromValue;
  return path.relative(process.cwd(), fromValue).split(path.sep).join("/");
}

function getMessageWidth(columnWidths) {
  if (!process.stdout.isTTY) {
    return columnWidths[3];
  }

  const availableWidth =
    process.stdout.columns < 80 ? 80 : process.stdout.columns;
  const fullWidth = _.sum(_.values(columnWidths));

  // If there is no reason to wrap the text, we won't align the last column to the right
  if (availableWidth > fullWidth + MARGIN_WIDTHS) {
    return columnWidths[3];
  }

  return availableWidth - (fullWidth - columnWidths[3] + MARGIN_WIDTHS);
}

function formatter(messages, source) {
  if (!messages.length) return "";

  const orderedMessages = _.sortBy(
    messages,
    m => (m.line ? 2 : 1), // positionless first
    m => m.line,
    m => m.column
  );

  // Create a list of column widths, needed to calculate
  // the size of the message column and if needed wrap it.
  const columnWidths = { 0: 1, 1: 1, 2: 1, 3: 1, 4: 1 };

  const calculateWidths = function(columns) {
    _.forOwn(columns, (value, key) => {
      const normalisedValue = value ? value.toString() : value;
      columnWidths[key] = Math.max(
        columnWidths[key],
        stringWidth(normalisedValue)
      );
    });

    return columns;
  };

  let output = "\n";

  if (source) {
    output += chalk.underline(logFrom(source)) + "\n";
  }

  const cleanedMessages = orderedMessages.map(message => {
    const location = utils.getLocation(message);
    const severity = message.severity;
    const row = [
      location.line || "",
      location.column || "",
      symbols[severity]
        ? chalk[levelColors[severity]](symbols[severity])
        : severity,
      message.text
        // Remove all control characters (newline, tab and etc)
        .replace(/[\x01-\x1A]+/g, " ") // eslint-disable-line
        .replace(/\.$/, "")
        .replace(
          new RegExp(_.escapeRegExp("(" + message.rule + ")") + "$"),
          ""
        ),
      chalk.dim(message.rule || "")
    ];

    calculateWidths(row);

    return row;
  });

  output += table
    .table(cleanedMessages, {
      border: table.getBorderCharacters("void"),
      columns: {
        0: { alignment: "right", width: columnWidths[0], paddingRight: 0 },
        1: { alignment: "left", width: columnWidths[1] },
        2: { alignment: "center", width: columnWidths[2] },
        3: {
          alignment: "left",
          width: getMessageWidth(columnWidths),
          wrapWord: true
        },
        4: { alignment: "left", width: columnWidths[4], paddingRight: 0 }
      },
      drawHorizontalLine: () => false
    })
    .split("\n")
    .map(el =>
      el.replace(/(\d+)\s+(\d+)/, (m, p1, p2) => chalk.dim(p1 + ":" + p2))
    )
    .join("\n");

  return output;
}

module.exports = function(results) {
  let output = invalidOptionsFormatter(results);
  output += deprecationsFormatter(results);

  output = results.reduce((output, result) => {
    // Treat parseErrors as warnings
    if (result.parseErrors) {
      result.parseErrors.forEach(error =>
        result.warnings.push({
          line: error.line,
          column: error.column,
          rule: error.stylelintType,
          severity: "error",
          text: `${error.text} (${error.stylelintType})`
        })
      );
    }
    output += formatter(result.warnings, result.source);
    return output;
  }, output);

  // Ensure consistent padding
  output = output.trim();

  if (output !== "") {
    output = "\n" + output + "\n\n";
  }

  return output;
};

}).call(this,require('_process'))
},{"_process":16,"chalk":580,"lodash":692,"log-symbols":693,"path":14,"postcss-reporter/lib/util":781,"string-width":866,"table":1169}],880:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const chalk = require("chalk");
const stringFormatter = require("./stringFormatter");

module.exports = function(results) {
  let output = stringFormatter(results);

  if (output === "") {
    output = "\n";
  }

  const sourceWord = results.length > 1 ? "sources" : "source";
  const ignoredCount = results.filter(result => result.ignored).length;
  const checkedDisplay = ignoredCount
    ? `${results.length - ignoredCount} of ${results.length}`
    : results.length;
  output += chalk.underline(`${checkedDisplay} ${sourceWord} checked\n`);
  results.forEach(result => {
    let formatting = "green";
    if (result.errored) {
      formatting = "red";
    } else if (result.warnings.length) {
      formatting = "yellow";
    } else if (result.ignored) {
      formatting = "dim";
    }
    let sourceText = `${result.source}`;
    if (result.ignored) {
      sourceText += " (ignored)";
    }
    output += _.get(chalk, formatting)(` ${sourceText}\n`);
  });

  const warnings = _.flatten(results.map(r => r.warnings));
  const warningsBySeverity = _.groupBy(warnings, "severity");
  const problemWord = warnings.length === 1 ? "problem" : "problems";

  output += chalk.underline(`\n${warnings.length} ${problemWord} found\n`);

  _.forOwn(warningsBySeverity, (warningList, severityLevel) => {
    const warningsByRule = _.groupBy(warningList, "rule");
    output += ` severity level "${severityLevel}": ${warningList.length}\n`;
    _.forOwn(warningsByRule, (list, rule) => {
      output += chalk.dim(`  ${rule}: ${list.length}\n`);
    });
  });

  return output + "\n";
};

},{"./stringFormatter":879,"chalk":580,"lodash":692}],881:[function(require,module,exports){
(function (process){
/* @flow */
"use strict";
const augmentConfigFull = require("./augmentConfig").augmentConfigFull;
const configurationError = require("./utils/configurationError");
const path = require("path");

module.exports = function(
  stylelint /*: stylelint$internalApi*/,
  searchPath /*:: ?: string*/
) /*: Promise<?{ config: stylelint$config, filepath: string }>*/ {
  searchPath = searchPath || process.cwd();

  const optionsConfig = stylelint._options.config;

  if (optionsConfig !== undefined) {
    const cached = stylelint._specifiedConfigCache.get(optionsConfig);
    if (cached) return cached;

    // stylelint._fullExplorer (cosmiconfig) is already configured to
    // run augmentConfigFull; but since we're making up the result here,
    // we need to manually run the transform
    const augmentedResult = augmentConfigFull(stylelint, {
      config: optionsConfig,
      // Add the extra path part so that we can get the directory without being
      // confused
      filepath: path.join(process.cwd(), "argument-config")
    });
    stylelint._specifiedConfigCache.set(optionsConfig, augmentedResult);
    return augmentedResult;
  }

  return stylelint._fullExplorer
    .load(searchPath, stylelint._options.configFile)
    .then(config => {
      // If no config was found, try looking from process.cwd
      if (!config) return stylelint._fullExplorer.load(process.cwd());
      return config;
    })
    .then(config => {
      if (!config) {
        const ending = searchPath ? ` for ${searchPath}` : "";
        throw configurationError(`No configuration provided${ending}`);
      }
      return config;
    });
};

}).call(this,require('_process'))
},{"./augmentConfig":872,"./utils/configurationError":1078,"_process":16,"path":14}],882:[function(require,module,exports){
/* @flow */
"use strict";

const dynamicRequire = require("./dynamicRequire");
const fs = require("fs");
const lessSyntax = require("postcss-less");
const path = require("path");
const postcss = require("postcss");
const scssSyntax = require("postcss-scss");
const sugarssSyntax = require("sugarss");

const postcssProcessor = postcss();

module.exports = function(
  stylelint /*: stylelint$internalApi*/
) /*: Promise<?Object>*/ {
  const options /*: {
    code?: string,
    codeFilename?: string,
    filePath?: string,
    codeProcessors?: Array<Function>,
    syntax?: stylelint$syntaxes,
    customSyntax?: string
  }*/ =
    arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

  const cached /*: ?postcss$result*/ = stylelint._postcssResultCache.get(
    options.filePath
  );
  if (cached) return Promise.resolve(cached);

  let getCode;
  if (options.code !== undefined) {
    getCode = Promise.resolve(options.code);
  } else if (options.filePath) {
    getCode = readFile(options.filePath);
  }

  if (!getCode) {
    throw new Error("code or filePath required");
  }

  return getCode
    .then(code => {
      const customSyntax = stylelint._options.customSyntax;
      let syntax = stylelint._options.syntax;

      if (customSyntax) {
        try {
          syntax = dynamicRequire(customSyntax);
        } catch (e) {
          throw new Error(
            `Cannot resolve custom syntax module ${customSyntax}`
          );
        }
      } else {
        const fileExtension = path.extname(options.filePath || "");
        if (syntax === "scss" || (!syntax && fileExtension === ".scss")) {
          syntax = scssSyntax;
        } else if (
          syntax === "less" ||
          (!syntax && fileExtension === ".less")
        ) {
          syntax = lessSyntax;
        } else if (
          syntax === "sugarss" ||
          (!syntax && fileExtension === ".sss")
        ) {
          syntax = sugarssSyntax;
        } else if (syntax) {
          throw new Error(
            "You must use a valid syntax option, either: scss, less or sugarss"
          );
        }
      }

      const postcssOptions /*: postcss$options*/ = {};

      postcssOptions.from = options.filePath;

      /*
     * PostCSS allows for syntaxes that only contain a parser, however,
     * it then expects the syntax to be set as the `parser` option rather than `syntax.
     */
      if (syntax && !syntax.stringify) {
        postcssOptions.parser = syntax;
      } else {
        postcssOptions.syntax = syntax;
      }

      const source = options.code ? options.codeFilename : options.filePath;
      let preProcessedCode = code;
      if (options.codeProcessors) {
        options.codeProcessors.forEach(codeProcessor => {
          preProcessedCode = codeProcessor(preProcessedCode, source);
        });
      }

      return postcssProcessor.process(preProcessedCode, postcssOptions);
    })
    .then(postcssResult => {
      stylelint._postcssResultCache.set(options.filePath, postcssResult);
      return postcssResult;
    });
};

function readFile(filePath /*: string*/) /*: Promise<string>*/ {
  return new Promise((resolve, reject) => {
    fs.readFile(filePath, "utf8", (err, content) => {
      if (err) {
        return reject(err);
      }
      resolve(content);
    });
  });
}

},{"./dynamicRequire":876,"fs":1,"path":14,"postcss":828,"postcss-less":731,"postcss-scss":788,"sugarss":1147}],883:[function(require,module,exports){
(function (process){
/* @flow */
"use strict";
const micromatch = require("micromatch");
const path = require("path");

// To find out if a path is ignored, we need to load the config,
// which may have an ignoreFiles property. We then check the path
// against these.
module.exports = function(
  stylelint /*: stylelint$internalApi*/,
  filePathArg /*:: ?: string*/
) /*: Promise<boolean>*/ {
  const filePath = filePathArg; // to please Flow
  if (!filePath) {
    return Promise.resolve(false);
  }

  return stylelint.getConfigForFile(filePath).then(result => {
    const config = result.config;
    const absoluteFilePath = path.isAbsolute(filePath)
      ? filePath
      : path.resolve(process.cwd(), filePath);
    if (micromatch(absoluteFilePath, config.ignoreFiles).length) {
      return true;
    }
    return false;
  });
};

}).call(this,require('_process'))
},{"_process":16,"micromatch":698,"path":14}],884:[function(require,module,exports){
(function (process){
/* @flow */
"use strict";

const _ = require("lodash");
const assignDisabledRanges = require("./assignDisabledRanges");
const configurationError = require("./utils/configurationError");
const getOsEol = require("./utils/getOsEol");
const path = require("path");
const ruleDefinitions = require("./rules");

// Run stylelint on a PostCSS Result, either one that is provided
// or one that we create
module.exports = function lintSource(
  stylelint /*: stylelint$internalApi*/,
  options /*: {
    code?: string,
    codeFilename?: string, // Must be an absolute file path
    filePath?: string, // Must be an absolute file path
    existingPostcssResult?: Object,
  }*/
) /*: Promise<Object>*/ {
  options = options || {};

  if (
    !options.filePath &&
    options.code === undefined &&
    !options.existingPostcssResult
  ) {
    return Promise.reject(
      new Error("You must provide filePath, code, or existingPostcssResult")
    );
  }

  const isCodeNotFile = options.code !== undefined;

  const inputFilePath = isCodeNotFile ? options.codeFilename : options.filePath;
  if (inputFilePath !== undefined && !path.isAbsolute(inputFilePath)) {
    if (isCodeNotFile) {
      return Promise.reject(new Error("codeFilename must be an absolute path"));
    } else {
      return Promise.reject(new Error("filePath must be an absolute path"));
    }
  }

  const getIsIgnored = stylelint.isPathIgnored(inputFilePath).catch(err => {
    if (isCodeNotFile && err.code === "ENOENT") return false;
    throw err;
  });

  return getIsIgnored.then(isIgnored => {
    if (isIgnored) {
      const postcssResult =
        options.existingPostcssResult ||
        createEmptyPostcssResult(inputFilePath);
      postcssResult.stylelint = postcssResult.stylelint || {};
      postcssResult.stylelint.ignored = true;
      return postcssResult;
    }

    const configSearchPath = stylelint._options.configFile || inputFilePath;

    const getConfig = stylelint
      .getConfigForFile(configSearchPath)
      .catch(err => {
        if (isCodeNotFile && err.code === "ENOENT")
          return stylelint.getConfigForFile(process.cwd());
        throw err;
      });

    return getConfig.then(result => {
      const config = result.config;
      const existingPostcssResult = options.existingPostcssResult;

      if (existingPostcssResult) {
        return lintPostcssResult(stylelint, existingPostcssResult, config).then(
          () => existingPostcssResult
        );
      }

      return stylelint
        ._getPostcssResult({
          code: options.code,
          codeFilename: options.codeFilename,
          filePath: inputFilePath,
          codeProcessors: config.codeProcessors
        })
        .then(postcssResult => {
          return lintPostcssResult(stylelint, postcssResult, config).then(
            () => postcssResult
          );
        });
    });
  });
};

function lintPostcssResult(
  stylelint /*: stylelint$internalApi*/,
  postcssResult /*: Object*/,
  config /*: stylelint$config*/
) /*: Promise<Array<*>>*/ {
  postcssResult.stylelint = postcssResult.stylelint || {};
  postcssResult.stylelint.ruleSeverities = {};
  postcssResult.stylelint.customMessages = {};
  postcssResult.stylelint.quiet = config.quiet;

  const newlineMatch = postcssResult.root
    .toResult({
      stringifier: postcssResult.opts.syntax
    })
    .css.match(/\r?\n/);
  const newline = newlineMatch ? newlineMatch[0] : getOsEol();

  const postcssRoot = postcssResult.root;
  assignDisabledRanges(postcssRoot, postcssResult);
  if (
    stylelint._options.reportNeedlessDisables ||
    stylelint._options.ignoreDisables
  ) {
    postcssResult.stylelint.ignoreDisables = true;
  }

  // Promises for the rules. Although the rule code runs synchronously now,
  // the use of Promises makes it compatible with the possibility of async
  // rules down the line.
  const performRules = [];

  const rules = config.rules ? Object.keys(config.rules) : [];

  rules.forEach(ruleName => {
    const ruleFunction =
      ruleDefinitions[ruleName] || _.get(config, ["pluginFunctions", ruleName]);

    if (ruleFunction === undefined) {
      throw configurationError(`Undefined rule ${ruleName}`);
    }

    const ruleSettings = _.get(config, ["rules", ruleName]);
    if (ruleSettings === null || ruleSettings[0] === null) {
      return;
    }

    const primaryOption = ruleSettings[0];
    const secondaryOptions = ruleSettings[1];

    // Log the rule's severity in the PostCSS result
    const defaultSeverity = config.defaultSeverity || "error";
    postcssResult.stylelint.ruleSeverities[ruleName] = _.get(
      secondaryOptions,
      "severity",
      defaultSeverity
    );
    postcssResult.stylelint.customMessages[ruleName] = _.get(
      secondaryOptions,
      "message"
    );

    const performRule = Promise.resolve().then(() => {
      return ruleFunction(primaryOption, secondaryOptions, {
        fix: stylelint._options.fix,
        newline
      })(postcssRoot, postcssResult);
    });
    performRules.push(performRule);
  });

  return Promise.all(performRules);
}

function createEmptyPostcssResult(filePath /*:: ?: string*/) /*: Object*/ {
  return {
    root: {
      source: {
        input: { file: filePath }
      }
    },
    messages: [],
    stylelint: { stylelintError: null }
  };
}

}).call(this,require('_process'))
},{"./assignDisabledRanges":871,"./rules":971,"./utils/configurationError":1078,"./utils/getOsEol":1088,"_process":16,"lodash":692,"path":14}],885:[function(require,module,exports){
/* @flow */
"use strict";

const _ = require("lodash");

module.exports = function(
  results /*: Array<stylelint$result>*/
) /*: stylelint$needlessDisablesReport*/ {
  const report = [];

  results.forEach(result => {
    // File with `CssSyntaxError` have not `_postcssResult`
    if (!result._postcssResult) {
      return;
    }

    const unused = { source: result.source, ranges: [] };
    const rangeData = _.cloneDeep(
      result._postcssResult.stylelint.disabledRanges
    );

    if (!rangeData) {
      return;
    }

    result.warnings.forEach(warning => {
      const rule /*: string*/ = warning.rule;

      const ruleRanges = rangeData[rule];
      if (ruleRanges) {
        // Back to front so we get the *last* range that applies to the warning
        for (const range of ruleRanges.reverse()) {
          if (isWarningInRange(warning, range)) {
            range.used = true;
            return;
          }
        }
      }

      for (const range of rangeData.all.reverse()) {
        if (isWarningInRange(warning, range)) {
          range.used = true;
          return;
        }
      }
    });

    Object.keys(rangeData).forEach(rule => {
      rangeData[rule].forEach(range => {
        // Is an equivalent range already marked as unused?
        const alreadyMarkedUnused = unused.ranges.find(unusedRange => {
          return (
            unusedRange.start === range.start && unusedRange.end === range.end
          );
        });

        // If this range is unused and no equivalent is marked,
        // mark this range as unused
        if (!range.used && !alreadyMarkedUnused) {
          unused.ranges.push(range);
        }

        // If this range is used but an equivalent has been marked as unused,
        // remove that equivalent. This can happen because of the duplication
        // of ranges in rule-specific range sets and the "all" range set
        if (range.used && alreadyMarkedUnused) {
          _.remove(unused.ranges, alreadyMarkedUnused);
        }
      });
    });

    unused.ranges = _.sortBy(unused.ranges, ["start", "end"]);

    report.push(unused);
  });

  return report;
};

function isWarningInRange(
  warning /*: {
    rule: string,
    line: number,
  }*/,
  range /*: {
    rules?: Array<string>,
    start: number,
    end?: number,
  }*/
) /*: boolean*/ {
  const rule = warning.rule,
    line = warning.line;

  // Need to check if range.end exist, because line number type cannot be compared to undefined
  return (
    range.start <= line &&
    ((range.end !== undefined && range.end >= line) ||
      range.end === undefined) &&
    (!range.rules || range.rules.indexOf(rule) !== -1)
  );
}

},{"lodash":692}],886:[function(require,module,exports){
/* @flow */
"use strict";
const _ = require("lodash");
const rules = require("./rules");

// Rule settings can take a number of forms, e.g.
// a. "rule-name": null
// b. "rule-name": [null, ...]
// c. "rule-name": primaryOption
// d. "rule-name": [primaryOption]
// e. "rule-name": [primaryOption, secondaryOption]
// Where primaryOption can be anything: primitive, Object, or Array.
//
// This function normalizes all the possibilities into the
// standard form: [primaryOption, secondaryOption]
// Except in the cases with null, a & b, in which case
// null is returned
module.exports = function(
  rawSettings /*: stylelint$configRuleSettings*/,
  ruleName /*: string*/,
  // If primaryOptionArray is not provided, we try to get it from the
  // rules themselves, which will not work for plugins
  primaryOptionArray /*:: ?: boolean*/
) /*: [any, Object] | Array<any | [any, Object]> | null*/ {
  if (rawSettings === null) {
    return null;
  }

  if (!Array.isArray(rawSettings)) {
    return [rawSettings];
  }
  // Everything below is an array ...

  if (rawSettings[0] === null) {
    return null;
  }

  if (primaryOptionArray === undefined) {
    const rule = rules[ruleName];
    primaryOptionArray = _.get(rule, "primaryOptionArray");
  }

  if (!primaryOptionArray) {
    return rawSettings;
  }
  // Everything below is a rule that CAN have an array for a primary option ...
  // (they might also have something else, e.g. rule-properties-order can
  // have the string "alphabetical")

  if (rawSettings.length === 1 && Array.isArray(rawSettings[0])) {
    return rawSettings;
  }

  if (
    rawSettings.length === 2 &&
    !_.isPlainObject(rawSettings[0]) &&
    _.isPlainObject(rawSettings[1])
  ) {
    return rawSettings;
  }

  return [rawSettings];
};

},{"./rules":971,"lodash":692}],887:[function(require,module,exports){
(function (process){
/* @flow */
"use strict";
const _ = require("lodash");
const createStylelint = require("./createStylelint");
const path = require("path");
const postcss = require("postcss");

module.exports = postcss.plugin("stylelint", function(options) {
  options = options || {};

  const tailoredOptions /*: Object*/ = options.rules
    ? { config: options }
    : options;
  const stylelint = createStylelint(tailoredOptions);

  return (root, result) => {
    let filePath = options.from || _.get(root, "source.input.file");
    if (filePath !== undefined && !path.isAbsolute(filePath)) {
      filePath = path.join(process.cwd(), filePath);
    }

    return stylelint._lintSource({
      filePath,
      existingPostcssResult: result
    });
  };
});

}).call(this,require('_process'))
},{"./createStylelint":874,"_process":16,"lodash":692,"path":14,"postcss":828}],888:[function(require,module,exports){
"use strict";

const _ = require("lodash");

const keywordSets = {};

keywordSets.nonLengthUnits = new Set([
  // Relative length units
  "%",
  // Time length units
  "s",
  "ms",
  // Angle
  "deg",
  "grad",
  "turn",
  "rad",
  // Frequency
  "Hz",
  "kHz",
  // Resolution
  "dpi",
  "dpcm",
  "dppx"
]);

keywordSets.lengthUnits = new Set([
  // Relative length units
  "em",
  "ex",
  "ch",
  "rem",
  // Viewport-percentage lengths
  "vh",
  "vw",
  "vmin",
  "vmax",
  "vm",
  // Absolute length units
  "px",
  "mm",
  "cm",
  "in",
  "pt",
  "pc",
  "q",
  // Flexible length units
  "fr"
]);

keywordSets.units = uniteSets(
  keywordSets.nonLengthUnits,
  keywordSets.lengthUnits
);

keywordSets.colorFunctionNames = new Set([
  "rgb",
  "rgba",
  "hsl",
  "hsla",
  "hwb",
  "gray"
]);

keywordSets.camelCaseFunctionNames = new Set([
  "translateX",
  "translateY",
  "translateZ",
  "scaleX",
  "scaleY",
  "scaleZ",
  "rotateX",
  "rotateY",
  "rotateZ",
  "skewX",
  "skewY"
]);

keywordSets.basicKeywords = new Set(["initial", "inherit", "unset"]);

keywordSets.fontFamilyKeywords = uniteSets(keywordSets.basicKeywords, [
  "serif",
  "sans-serif",
  "cursive",
  "fantasy",
  "monospace"
]);

keywordSets.fontWeightRelativeKeywords = new Set(["bolder", "lighter"]);

keywordSets.fontWeightAbsoluteKeywords = new Set(["bold"]);

keywordSets.fontWeightNumericKeywords = new Set([
  "100",
  "200",
  "300",
  "400",
  "500",
  "600",
  "700",
  "800",
  "900"
]);

keywordSets.fontWeightKeywords = uniteSets(
  keywordSets.basicKeywords,
  keywordSets.fontWeightRelativeKeywords,
  keywordSets.fontWeightAbsoluteKeywords,
  keywordSets.fontWeightNumericKeywords
);

keywordSets.animationNameKeywords = uniteSets(keywordSets.basicKeywords, [
  "none"
]);

keywordSets.animationTimingFunctionKeywords = uniteSets(
  keywordSets.basicKeywords,
  [
    "linear",
    "ease",
    "ease-in",
    "ease-in-out",
    "ease-out",
    "step-start",
    "step-end",
    "steps",
    "cubic-bezier"
  ]
);

keywordSets.animationIterationCountKeywords = new Set(["infinite"]);

keywordSets.animationDirectionKeywords = uniteSets(keywordSets.basicKeywords, [
  "normal",
  "reverse",
  "alternate",
  "alternate-reverse"
]);

keywordSets.animationFillModeKeywords = new Set([
  "none",
  "forwards",
  "backwards",
  "both"
]);

keywordSets.animationPlayStateKeywords = uniteSets(keywordSets.basicKeywords, [
  "running",
  "paused"
]);

// cf. https://developer.mozilla.org/en-US/docs/Web/CSS/animation
keywordSets.animationShorthandKeywords = uniteSets(
  keywordSets.basicKeywords,
  keywordSets.animationNameKeywords,
  keywordSets.animationTimingFunctionKeywords,
  keywordSets.animationIterationCountKeywords,
  keywordSets.animationDirectionKeywords,
  keywordSets.animationFillModeKeywords,
  keywordSets.animationPlayStateKeywords
);

// These are the ones that can have single-colon notation
keywordSets.levelOneAndTwoPseudoElements = new Set([
  "before",
  "after",
  "first-line",
  "first-letter"
]);

// These are the ones that require double-colon notation
keywordSets.levelThreePseudoElements = new Set([
  "before",
  "after",
  "first-line",
  "first-letter",
  "selection",
  "spelling-error",
  "grammar-error",
  "backdrop",
  "marker",
  "placeholder",
  "shadow",
  "slotted",
  "content"
]);

keywordSets.pseudoElements = uniteSets(
  keywordSets.levelOneAndTwoPseudoElements,
  keywordSets.levelThreePseudoElements
);

keywordSets.aNPlusBNotationPseudoClasses = new Set([
  "nth-child",
  "nth-column",
  "nth-last-child",
  "nth-last-column",
  "nth-last-of-type",
  "nth-of-type"
]);

keywordSets.linguisticPseudoClasses = new Set(["dir", "lang"]);

keywordSets.atRulePagePseudoClasses = new Set([
  "first",
  "right",
  "left",
  "blank"
]);

keywordSets.otherPseudoClasses = new Set([
  "active",
  "any-link",
  "blank",
  "checked",
  "contains",
  "current",
  "default",
  "disabled",
  "drop",
  "empty",
  "enabled",
  "first-child",
  "first-of-type",
  "focus",
  "focus-ring",
  "focus-within",
  "fullscreen",
  "future",
  "has",
  "host",
  "host-context",
  "hover",
  "indeterminate",
  "in-range",
  "invalid",
  "last-child",
  "last-of-type",
  "link",
  "matches",
  "not",
  "only-child",
  "only-of-type",
  "optional",
  "out-of-range",
  "past",
  "placeholder-shown",
  "playing",
  "paused",
  "read-only",
  "read-write",
  "required",
  "root",
  "scope",
  "target",
  "user-error",
  "user-invalid",
  "val",
  "valid",
  "visited"
]);

keywordSets.webkitProprietaryPseudoElements = new Set([
  "scrollbar",
  "scrollbar-button",
  "scrollbar-track",
  "scrollbar-track-piece",
  "scrollbar-thumb",
  "scrollbar-corner",
  "resize"
]);

keywordSets.webkitProprietaryPseudoClasses = new Set([
  "horizontal",
  "vertical",
  "decrement",
  "increment",
  "start",
  "end",
  "double-button",
  "single-button",
  "no-button",
  "corner-present",
  "window-inactive"
]);

keywordSets.pseudoClasses = uniteSets(
  keywordSets.aNPlusBNotationPseudoClasses,
  keywordSets.linguisticPseudoClasses,
  keywordSets.otherPseudoClasses
);

keywordSets.shorthandTimeProperties = new Set(["transition", "animation"]);

keywordSets.longhandTimeProperties = new Set([
  "transition-duration",
  "transition-delay",
  "animation-duration",
  "animation-delay"
]);

keywordSets.timeProperties = uniteSets(
  keywordSets.shorthandTimeProperties,
  keywordSets.longhandTimeProperties
);

keywordSets.camelCaseKeywords = new Set([
  "optimizeSpeed",
  "optimizeQuality",
  "optimizeLegibility",
  "geometricPrecision",
  "currentColor",
  "crispEdges",
  "visiblePainted",
  "visibleFill",
  "visibleStroke",
  "sRGB",
  "linearRGB"
]);

// https://developer.mozilla.org/docs/Web/CSS/counter-increment
keywordSets.counterIncrementKeywords = uniteSets(keywordSets.basicKeywords, [
  "none"
]);

keywordSets.counterResetKeywords = uniteSets(keywordSets.basicKeywords, [
  "none"
]);

keywordSets.gridRowKeywords = uniteSets(keywordSets.basicKeywords, [
  "auto",
  "span"
]);

keywordSets.gridColumnKeywords = uniteSets(keywordSets.basicKeywords, [
  "auto",
  "span"
]);

keywordSets.gridAreaKeywords = uniteSets(keywordSets.basicKeywords, [
  "auto",
  "span"
]);

// https://developer.mozilla.org/ru/docs/Web/CSS/list-style-type
keywordSets.listStyleTypeKeywords = uniteSets(keywordSets.basicKeywords, [
  "none",
  "disc",
  "circle",
  "square",
  "decimal",
  "cjk-decimal",
  "decimal-leading-zero",
  "lower-roman",
  "upper-roman",
  "lower-greek",
  "lower-alpha",
  "lower-latin",
  "upper-alpha",
  "upper-latin",
  "arabic-indic",
  "armenian",
  "bengali",
  "cambodian",
  "cjk-earthly-branch",
  "cjk-ideographic",
  "devanagari",
  "ethiopic-numeric",
  "georgian",
  "gujarati",
  "gurmukhi",
  "hebrew",
  "hiragana",
  "hiragana-iroha",
  "japanese-formal",
  "japanese-informal",
  "kannada",
  "katakana",
  "katakana-iroha",
  "khmer",
  "korean-hangul-formal",
  "korean-hanja-formal",
  "korean-hanja-informal",
  "lao",
  "lower-armenian",
  "malayalam",
  "mongolian",
  "myanmar",
  "oriya",
  "persian",
  "simp-chinese-formal",
  "simp-chinese-informal",
  "tamil",
  "telugu",
  "thai",
  "tibetan",
  "trad-chinese-formal",
  "trad-chinese-informal",
  "upper-armenian",
  "disclosure-open",
  "disclosure-closed",
  // Non-standard extensions (without prefixe)
  "ethiopic-halehame",
  "ethiopic-halehame-am",
  "ethiopic-halehame-ti-er",
  "ethiopic-halehame-ti-et",
  "hangul",
  "hangul-consonant",
  "urdu"
]);

keywordSets.listStylePositionKeywords = uniteSets(keywordSets.basicKeywords, [
  "inside",
  "outside"
]);

keywordSets.listStyleImageKeywords = uniteSets(keywordSets.basicKeywords, [
  "none"
]);

keywordSets.listStyleShorthandKeywords = uniteSets(
  keywordSets.basicKeywords,
  keywordSets.listStyleTypeKeywords,
  keywordSets.listStylePositionKeywords,
  keywordSets.listStyleImageKeywords
);

keywordSets.fontStyleKeywords = uniteSets(keywordSets.basicKeywords, [
  "normal",
  "italic",
  "oblique"
]);

keywordSets.fontVariantKeywords = uniteSets(keywordSets.basicKeywords, [
  "normal",
  "none",
  "historical-forms",
  "none",
  "common-ligatures",
  "no-common-ligatures",
  "discretionary-ligatures",
  "no-discretionary-ligatures",
  "historical-ligatures",
  "no-historical-ligatures",
  "contextual",
  "no-contextual",
  "small-caps",
  "small-caps",
  "all-small-caps",
  "petite-caps",
  "all-petite-caps",
  "unicase",
  "titling-caps",
  "lining-nums",
  "oldstyle-nums",
  "proportional-nums",
  "tabular-nums",
  "diagonal-fractions",
  "stacked-fractions",
  "ordinal",
  "slashed-zero",
  "jis78",
  "jis83",
  "jis90",
  "jis04",
  "simplified",
  "traditional",
  "full-width",
  "proportional-width",
  "ruby"
]);

keywordSets.fontStretchKeywords = uniteSets(keywordSets.basicKeywords, [
  "semi-condensed",
  "condensed",
  "extra-condensed",
  "ultra-condensed",
  "semi-expanded",
  "expanded",
  "extra-expanded",
  "ultra-expanded"
]);

keywordSets.fontSizeKeywords = uniteSets(keywordSets.basicKeywords, [
  "xx-small",
  "x-small",
  "small",
  "medium",
  "large",
  "x-large",
  "xx-large",
  "larger",
  "smaller"
]);

keywordSets.lineHeightKeywords = uniteSets(keywordSets.basicKeywords, [
  "normal"
]);

keywordSets.fontShorthandKeywords = uniteSets(
  keywordSets.basicKeywords,
  keywordSets.fontStyleKeywords,
  keywordSets.fontVariantKeywords,
  keywordSets.fontWeightKeywords,
  keywordSets.fontStretchKeywords,
  keywordSets.fontSizeKeywords,
  keywordSets.lineHeightKeywords,
  keywordSets.fontFamilyKeywords
);

keywordSets.keyframeSelectorKeywords = new Set(["from", "to"]);

// https://developer.mozilla.org/en/docs/Web/CSS/At-rule
keywordSets.atRules = new Set([
  "apply",
  "annotation",
  "character-variant",
  "charset",
  "counter-style",
  "custom-media",
  "custom-selector",
  "document",
  "font-face",
  "font-feature-values",
  "import",
  "keyframes",
  "media",
  "namespace",
  "nest",
  "ornaments",
  "page",
  "styleset",
  "stylistic",
  "supports",
  "swash",
  "viewport"
]);

// https://drafts.csswg.org/mediaqueries/#descdef-media-update
keywordSets.deprecatedMediaFeatureNames = new Set([
  "device-aspect-ratio",
  "device-height",
  "device-width",
  "max-device-aspect-ratio",
  "max-device-height",
  "max-device-width",
  "min-device-aspect-ratio",
  "min-device-height",
  "min-device-width"
]);

// https://drafts.csswg.org/mediaqueries/#descdef-media-update
keywordSets.mediaFeatureNames = uniteSets(
  keywordSets.deprecatedMediaFeatureNames,
  [
    "any-hover",
    "any-pointer",
    "aspect-ratio",
    "color",
    "color-gamut",
    "color-index",
    "grid",
    "height",
    "hover",
    "max-aspect-ratio",
    "max-color",
    "max-color-index",
    "max-height",
    "max-monochrome",
    "max-resolution",
    "max-width",
    "min-aspect-ratio",
    "min-color",
    "min-color-index",
    "min-height",
    "min-monochrome",
    "min-resolution",
    "min-width",
    "monochrome",
    "orientation",
    "overflow-block",
    "overflow-inline",
    "pointer",
    "resolution",
    "scan",
    "scripting",
    "update",
    "width"
  ]
);

// https://www.w3.org/TR/CSS22/ui.html#system-colors
keywordSets.systemColors = new Set([
  "activeborder",
  "activecaption",
  "appworkspace",
  "background",
  "buttonface",
  "buttonhighlight",
  "buttonshadow",
  "buttontext",
  "captiontext",
  "graytext",
  "highlight",
  "highlighttext",
  "inactiveborder",
  "inactivecaption",
  "inactivecaptiontext",
  "infobackground",
  "infotext",
  "menu",
  "menutext",
  "scrollbar",
  "threeddarkshadow",
  "threedface",
  "threedhighlight",
  "threedlightshadow",
  "threedshadow",
  "window",
  "windowframe",
  "windowtext"
]);

// htmlTags includes only "standard" tags. So we augment it with older tags etc.
keywordSets.nonStandardHtmlTags = new Set([
  "acronym",
  "applet",
  "basefont",
  "big",
  "blink",
  "center",
  "content",
  "dir",
  "font",
  "frame",
  "frameset",
  "hgroup",
  "isindex",
  "keygen",
  "listing",
  "marquee",
  "noembed",
  "plaintext",
  "spacer",
  "strike",
  "tt",
  "xmp"
]);

function uniteSets() {
  const sets = Array.from(arguments);

  return new Set(
    sets.reduce((result, set) => {
      return result.concat(_.toArray(set));
    }, [])
  );
}

module.exports = keywordSets;

},{"lodash":692}],889:[function(require,module,exports){
"use strict";

module.exports = {
  aliceblue: {
    hex: ["#f0f8ff", "#fff0f8ff"],
    func: [
      "rgb(240,248,255)",
      "rgba(240,248,255,1)",
      "rgba(240,248,255,100%)",
      "rgb(94%,97%,100%)",
      "rgba(94%,97%,100%,1)",
      "rgba(94%,97%,100%,100%)",
      "hsl(208,100%,97%)",
      "hsla(208,100%,97%,1)",
      "hsla(208,100%,97%,100%)",
      "hwb(208,94%,0%)",
      "hwb(208,94%,0%,1)",
      "hwb(208,94%,0%,100%)"
    ]
  },
  antiquewhite: {
    hex: ["#faebd7", "#fffaebd7"],
    func: [
      "rgb(250,235,215)",
      "rgba(250,235,215,1)",
      "rgba(250,235,215,100%)",
      "rgb(98%,92%,84%)",
      "rgba(98%,92%,84%,1)",
      "rgba(98%,92%,84%,100%)",
      "hsl(34,78%,91%)",
      "hsla(34,78%,91%,1)",
      "hsla(34,78%,91%,100%)",
      "hwb(34,84%,2%)",
      "hwb(34,84%,2%,1)",
      "hwb(34,84%,2%,100%)"
    ]
  },
  aqua: {
    hex: ["#00ffff", "#ff00ffff", "#0ff", "#f0ff"],
    func: [
      "rgb(0,255,255)",
      "rgba(0,255,255,1)",
      "rgba(0,255,255,100%)",
      "rgb(0%,100%,100%)",
      "rgba(0%,100%,100%,1)",
      "rgba(0%,100%,100%,100%)",
      "hsl(180,100%,50%)",
      "hsla(180,100%,50%,1)",
      "hsla(180,100%,50%,100%)",
      "hwb(180,0%,0%)",
      "hwb(180,0%,0%,1)",
      "hwb(180,0%,0%,100%)"
    ]
  },
  aquamarine: {
    hex: ["#7fffd4", "#ff7fffd4"],
    func: [
      "rgb(127,255,212)",
      "rgba(127,255,212,1)",
      "rgba(127,255,212,100%)",
      "rgb(50%,100%,83%)",
      "rgba(50%,100%,83%,1)",
      "rgba(50%,100%,83%,100%)",
      "hsl(160,100%,75%)",
      "hsla(160,100%,75%,1)",
      "hsla(160,100%,75%,100%)",
      "hwb(160,50%,0%)",
      "hwb(160,50%,0%,1)",
      "hwb(160,50%,0%,100%)"
    ]
  },
  azure: {
    hex: ["#f0ffff", "#fff0ffff"],
    func: [
      "rgb(240,255,255)",
      "rgba(240,255,255,1)",
      "rgba(240,255,255,100%)",
      "rgb(94%,100%,100%)",
      "rgba(94%,100%,100%,1)",
      "rgba(94%,100%,100%,100%)",
      "hsl(180,100%,97%)",
      "hsla(180,100%,97%,1)",
      "hsla(180,100%,97%,100%)",
      "hwb(180,94%,0%)",
      "hwb(180,94%,0%,1)",
      "hwb(180,94%,0%,100%)"
    ]
  },
  beige: {
    hex: ["#f5f5dc", "#fff5f5dc"],
    func: [
      "rgb(245,245,220)",
      "rgba(245,245,220,1)",
      "rgba(245,245,220,100%)",
      "rgb(96%,96%,86%)",
      "rgba(96%,96%,86%,1)",
      "rgba(96%,96%,86%,100%)",
      "hsl(60,56%,91%)",
      "hsla(60,56%,91%,1)",
      "hsla(60,56%,91%,100%)",
      "hwb(60,86%,4%)",
      "hwb(60,86%,4%,1)",
      "hwb(60,86%,4%,100%)"
    ]
  },
  bisque: {
    hex: ["#ffe4c4", "#ffffe4c4"],
    func: [
      "rgb(255,228,196)",
      "rgba(255,228,196,1)",
      "rgba(255,228,196,100%)",
      "rgb(100%,89%,77%)",
      "rgba(100%,89%,77%,1)",
      "rgba(100%,89%,77%,100%)",
      "hsl(33,100%,88%)",
      "hsla(33,100%,88%,1)",
      "hsla(33,100%,88%,100%)",
      "hwb(33,77%,0%)",
      "hwb(33,77%,0%,1)",
      "hwb(33,77%,0%,100%)"
    ]
  },
  black: {
    hex: ["#000000", "#ff000000", "#000", "#f000"],
    func: [
      "rgb(0,0,0)",
      "rgba(0,0,0,1)",
      "rgba(0,0,0,100%)",
      "rgb(0%,0%,0%)",
      "rgba(0%,0%,0%,1)",
      "rgba(0%,0%,0%,100%)",
      "hsl(0,0%,0%)",
      "hsla(0,0%,0%,1)",
      "hsla(0,0%,0%,100%)",
      "hwb(0,0%,100%)",
      "hwb(0,0%,100%,1)",
      "hwb(0,0%,100%,100%)",
      "gray(0)",
      "gray(0,1)",
      "gray(0,100%)",
      "gray(0%)",
      "gray(0%,1)",
      "gray(0%,100%)"
    ]
  },
  blanchedalmond: {
    hex: ["#ffebcd", "#ffffebcd"],
    func: [
      "rgb(255,235,205)",
      "rgba(255,235,205,1)",
      "rgba(255,235,205,100%)",
      "rgb(100%,92%,80%)",
      "rgba(100%,92%,80%,1)",
      "rgba(100%,92%,80%,100%)",
      "hsl(36,100%,90%)",
      "hsla(36,100%,90%,1)",
      "hsla(36,100%,90%,100%)",
      "hwb(36,80%,0%)",
      "hwb(36,80%,0%,1)",
      "hwb(36,80%,0%,100%)"
    ]
  },
  blue: {
    hex: ["#0000ff", "#ff0000ff", "#00f", "#f00f"],
    func: [
      "rgb(0,0,255)",
      "rgba(0,0,255,1)",
      "rgba(0,0,255,100%)",
      "rgb(0%,0%,100%)",
      "rgba(0%,0%,100%,1)",
      "rgba(0%,0%,100%,100%)",
      "hsl(240,100%,50%)",
      "hsla(240,100%,50%,1)",
      "hsla(240,100%,50%,100%)",
      "hwb(240,0%,0%)",
      "hwb(240,0%,0%,1)",
      "hwb(240,0%,0%,100%)"
    ]
  },
  blueviolet: {
    hex: ["#8a2be2", "#ff8a2be2"],
    func: [
      "rgb(138,43,226)",
      "rgba(138,43,226,1)",
      "rgba(138,43,226,100%)",
      "rgb(54%,17%,89%)",
      "rgba(54%,17%,89%,1)",
      "rgba(54%,17%,89%,100%)",
      "hsl(271,76%,53%)",
      "hsla(271,76%,53%,1)",
      "hsla(271,76%,53%,100%)",
      "hwb(271,17%,11%)",
      "hwb(271,17%,11%,1)",
      "hwb(271,17%,11%,100%)"
    ]
  },
  brown: {
    hex: ["#a52a2a", "#ffa52a2a"],
    func: [
      "rgb(165,42,42)",
      "rgba(165,42,42,1)",
      "rgba(165,42,42,100%)",
      "rgb(65%,16%,16%)",
      "rgba(65%,16%,16%,1)",
      "rgba(65%,16%,16%,100%)",
      "hsl(0,59%,41%)",
      "hsla(0,59%,41%,1)",
      "hsla(0,59%,41%,100%)",
      "hwb(0,16%,35%)",
      "hwb(0,16%,35%,1)",
      "hwb(0,16%,35%,100%)"
    ]
  },
  burlywood: {
    hex: ["#deb887", "#ffdeb887"],
    func: [
      "rgb(222,184,135)",
      "rgba(222,184,135,1)",
      "rgba(222,184,135,100%)",
      "rgb(87%,72%,53%)",
      "rgba(87%,72%,53%,1)",
      "rgba(87%,72%,53%,100%)",
      "hsl(34,57%,70%)",
      "hsla(34,57%,70%,1)",
      "hsla(34,57%,70%,100%)",
      "hwb(34,53%,13%)",
      "hwb(34,53%,13%,1)",
      "hwb(34,53%,13%,100%)"
    ]
  },
  cadetblue: {
    hex: ["#5f9ea0", "#ff5f9ea0"],
    func: [
      "rgb(95,158,160)",
      "rgba(95,158,160,1)",
      "rgba(95,158,160,100%)",
      "rgb(37%,62%,63%)",
      "rgba(37%,62%,63%,1)",
      "rgba(37%,62%,63%,100%)",
      "hsl(182,25%,50%)",
      "hsla(182,25%,50%,1)",
      "hsla(182,25%,50%,100%)",
      "hwb(182,37%,37%)",
      "hwb(182,37%,37%,1)",
      "hwb(182,37%,37%,100%)"
    ]
  },
  chartreuse: {
    hex: ["#7fff00", "#ff7fff00"],
    func: [
      "rgb(127,255,0)",
      "rgba(127,255,0,1)",
      "rgba(127,255,0,100%)",
      "rgb(50%,100%,0%)",
      "rgba(50%,100%,0%,1)",
      "rgba(50%,100%,0%,100%)",
      "hsl(90,100%,50%)",
      "hsla(90,100%,50%,1)",
      "hsla(90,100%,50%,100%)",
      "hwb(90,0%,0%)",
      "hwb(90,0%,0%,1)",
      "hwb(90,0%,0%,100%)"
    ]
  },
  chocolate: {
    hex: ["#d2691e", "#ffd2691e"],
    func: [
      "rgb(210,105,30)",
      "rgba(210,105,30,1)",
      "rgba(210,105,30,100%)",
      "rgb(82%,41%,12%)",
      "rgba(82%,41%,12%,1)",
      "rgba(82%,41%,12%,100%)",
      "hsl(25,75%,47%)",
      "hsla(25,75%,47%,1)",
      "hsla(25,75%,47%,100%)",
      "hwb(25,12%,18%)",
      "hwb(25,12%,18%,1)",
      "hwb(25,12%,18%,100%)"
    ]
  },
  coral: {
    hex: ["#ff7f50", "#ffff7f50"],
    func: [
      "rgb(255,127,80)",
      "rgba(255,127,80,1)",
      "rgba(255,127,80,100%)",
      "rgb(100%,50%,31%)",
      "rgba(100%,50%,31%,1)",
      "rgba(100%,50%,31%,100%)",
      "hsl(16,100%,66%)",
      "hsla(16,100%,66%,1)",
      "hsla(16,100%,66%,100%)",
      "hwb(16,31%,0%)",
      "hwb(16,31%,0%,1)",
      "hwb(16,31%,0%,100%)"
    ]
  },
  cornflowerblue: {
    hex: ["#6495ed", "#ff6495ed"],
    func: [
      "rgb(100,149,237)",
      "rgba(100,149,237,1)",
      "rgba(100,149,237,100%)",
      "rgb(39%,58%,93%)",
      "rgba(39%,58%,93%,1)",
      "rgba(39%,58%,93%,100%)",
      "hsl(219,79%,66%)",
      "hsla(219,79%,66%,1)",
      "hsla(219,79%,66%,100%)",
      "hwb(219,39%,7%)",
      "hwb(219,39%,7%,1)",
      "hwb(219,39%,7%,100%)"
    ]
  },
  cornsilk: {
    hex: ["#fff8dc", "#fffff8dc"],
    func: [
      "rgb(255,248,220)",
      "rgba(255,248,220,1)",
      "rgba(255,248,220,100%)",
      "rgb(100%,97%,86%)",
      "rgba(100%,97%,86%,1)",
      "rgba(100%,97%,86%,100%)",
      "hsl(48,100%,93%)",
      "hsla(48,100%,93%,1)",
      "hsla(48,100%,93%,100%)",
      "hwb(48,86%,0%)",
      "hwb(48,86%,0%,1)",
      "hwb(48,86%,0%,100%)"
    ]
  },
  crimson: {
    hex: ["#dc143c", "#ffdc143c"],
    func: [
      "rgb(220,20,60)",
      "rgba(220,20,60,1)",
      "rgba(220,20,60,100%)",
      "rgb(86%,8%,24%)",
      "rgba(86%,8%,24%,1)",
      "rgba(86%,8%,24%,100%)",
      "hsl(348,83%,47%)",
      "hsla(348,83%,47%,1)",
      "hsla(348,83%,47%,100%)",
      "hwb(348,8%,14%)",
      "hwb(348,8%,14%,1)",
      "hwb(348,8%,14%,100%)"
    ]
  },
  cyan: {
    hex: ["#00ffff", "#ff00ffff", "#0ff", "#f0ff"],
    func: [
      "rgb(0,255,255)",
      "rgba(0,255,255,1)",
      "rgba(0,255,255,100%)",
      "rgb(0%,100%,100%)",
      "rgba(0%,100%,100%,1)",
      "rgba(0%,100%,100%,100%)",
      "hsl(180,100%,50%)",
      "hsla(180,100%,50%,1)",
      "hsla(180,100%,50%,100%)",
      "hwb(180,0%,0%)",
      "hwb(180,0%,0%,1)",
      "hwb(180,0%,0%,100%)"
    ]
  },
  darkblue: {
    hex: ["#00008b", "#ff00008b"],
    func: [
      "rgb(0,0,139)",
      "rgba(0,0,139,1)",
      "rgba(0,0,139,100%)",
      "rgb(0%,0%,55%)",
      "rgba(0%,0%,55%,1)",
      "rgba(0%,0%,55%,100%)",
      "hsl(240,100%,27%)",
      "hsla(240,100%,27%,1)",
      "hsla(240,100%,27%,100%)",
      "hwb(240,0%,45%)",
      "hwb(240,0%,45%,1)",
      "hwb(240,0%,45%,100%)"
    ]
  },
  darkcyan: {
    hex: ["#008b8b", "#ff008b8b"],
    func: [
      "rgb(0,139,139)",
      "rgba(0,139,139,1)",
      "rgba(0,139,139,100%)",
      "rgb(0%,55%,55%)",
      "rgba(0%,55%,55%,1)",
      "rgba(0%,55%,55%,100%)",
      "hsl(180,100%,27%)",
      "hsla(180,100%,27%,1)",
      "hsla(180,100%,27%,100%)",
      "hwb(180,0%,45%)",
      "hwb(180,0%,45%,1)",
      "hwb(180,0%,45%,100%)"
    ]
  },
  darkgoldenrod: {
    hex: ["#b8860b", "#ffb8860b"],
    func: [
      "rgb(184,134,11)",
      "rgba(184,134,11,1)",
      "rgba(184,134,11,100%)",
      "rgb(72%,53%,4%)",
      "rgba(72%,53%,4%,1)",
      "rgba(72%,53%,4%,100%)",
      "hsl(43,89%,38%)",
      "hsla(43,89%,38%,1)",
      "hsla(43,89%,38%,100%)",
      "hwb(43,4%,28%)",
      "hwb(43,4%,28%,1)",
      "hwb(43,4%,28%,100%)"
    ]
  },
  darkgray: {
    hex: ["#a9a9a9", "#ffa9a9a9"],
    func: [
      "rgb(169,169,169)",
      "rgba(169,169,169,1)",
      "rgba(169,169,169,100%)",
      "rgb(66%,66%,66%)",
      "rgba(66%,66%,66%,1)",
      "rgba(66%,66%,66%,100%)",
      "hsl(0,0%,66%)",
      "hsla(0,0%,66%,1)",
      "hsla(0,0%,66%,100%)",
      "hwb(0,66%,34%)",
      "hwb(0,66%,34%,1)",
      "hwb(0,66%,34%,100%)"
    ]
  },
  darkgreen: {
    hex: ["#006400", "#ff006400"],
    func: [
      "rgb(0,100,0)",
      "rgba(0,100,0,1)",
      "rgba(0,100,0,100%)",
      "rgb(0%,39%,0%)",
      "rgba(0%,39%,0%,1)",
      "rgba(0%,39%,0%,100%)",
      "hsl(120,100%,20%)",
      "hsla(120,100%,20%,1)",
      "hsla(120,100%,20%,100%)",
      "hwb(120,0%,61%)",
      "hwb(120,0%,61%,1)",
      "hwb(120,0%,61%,100%)"
    ]
  },
  darkgrey: {
    hex: ["#a9a9a9", "#ffa9a9a9"],
    func: [
      "rgb(169,169,169)",
      "rgba(169,169,169,1)",
      "rgba(169,169,169,100%)",
      "rgb(66%,66%,66%)",
      "rgba(66%,66%,66%,1)",
      "rgba(66%,66%,66%,100%)",
      "hsl(0,0%,66%)",
      "hsla(0,0%,66%,1)",
      "hsla(0,0%,66%,100%)",
      "hwb(0,66%,34%)",
      "hwb(0,66%,34%,1)",
      "hwb(0,66%,34%,100%)",
      "gray(169)",
      "gray(169,1)",
      "gray(169,100%)",
      "gray(169%)",
      "gray(169%,1)",
      "gray(169%,100%)"
    ]
  },
  darkkhaki: {
    hex: ["#bdb76b", "#ffbdb76b"],
    func: [
      "rgb(189,183,107)",
      "rgba(189,183,107,1)",
      "rgba(189,183,107,100%)",
      "rgb(74%,72%,42%)",
      "rgba(74%,72%,42%,1)",
      "rgba(74%,72%,42%,100%)",
      "hsl(56,38%,58%)",
      "hsla(56,38%,58%,1)",
      "hsla(56,38%,58%,100%)",
      "hwb(56,42%,26%)",
      "hwb(56,42%,26%,1)",
      "hwb(56,42%,26%,100%)"
    ]
  },
  darkmagenta: {
    hex: ["#8b008b", "#ff8b008b"],
    func: [
      "rgb(139,0,139)",
      "rgba(139,0,139,1)",
      "rgba(139,0,139,100%)",
      "rgb(55%,0%,55%)",
      "rgba(55%,0%,55%,1)",
      "rgba(55%,0%,55%,100%)",
      "hsl(300,100%,27%)",
      "hsla(300,100%,27%,1)",
      "hsla(300,100%,27%,100%)",
      "hwb(300,0%,45%)",
      "hwb(300,0%,45%,1)",
      "hwb(300,0%,45%,100%)"
    ]
  },
  darkolivegreen: {
    hex: ["#556b2f", "#ff556b2f"],
    func: [
      "rgb(85,107,47)",
      "rgba(85,107,47,1)",
      "rgba(85,107,47,100%)",
      "rgb(33%,42%,18%)",
      "rgba(33%,42%,18%,1)",
      "rgba(33%,42%,18%,100%)",
      "hsl(82,39%,30%)",
      "hsla(82,39%,30%,1)",
      "hsla(82,39%,30%,100%)",
      "hwb(82,18%,58%)",
      "hwb(82,18%,58%,1)",
      "hwb(82,18%,58%,100%)"
    ]
  },
  darkorange: {
    hex: ["#ff8c00", "#ffff8c00"],
    func: [
      "rgb(255,140,0)",
      "rgba(255,140,0,1)",
      "rgba(255,140,0,100%)",
      "rgb(100%,55%,0%)",
      "rgba(100%,55%,0%,1)",
      "rgba(100%,55%,0%,100%)",
      "hsl(33,100%,50%)",
      "hsla(33,100%,50%,1)",
      "hsla(33,100%,50%,100%)",
      "hwb(33,0%,0%)",
      "hwb(33,0%,0%,1)",
      "hwb(33,0%,0%,100%)"
    ]
  },
  darkorchid: {
    hex: ["#9932cc", "#ff9932cc"],
    func: [
      "rgb(153,50,204)",
      "rgba(153,50,204,1)",
      "rgba(153,50,204,100%)",
      "rgb(60%,20%,80%)",
      "rgba(60%,20%,80%,1)",
      "rgba(60%,20%,80%,100%)",
      "hsl(280,61%,50%)",
      "hsla(280,61%,50%,1)",
      "hsla(280,61%,50%,100%)",
      "hwb(280,20%,20%)",
      "hwb(280,20%,20%,1)",
      "hwb(280,20%,20%,100%)"
    ]
  },
  darkred: {
    hex: ["#8b0000", "#ff8b0000"],
    func: [
      "rgb(139,0,0)",
      "rgba(139,0,0,1)",
      "rgba(139,0,0,100%)",
      "rgb(55%,0%,0%)",
      "rgba(55%,0%,0%,1)",
      "rgba(55%,0%,0%,100%)",
      "hsl(0,100%,27%)",
      "hsla(0,100%,27%,1)",
      "hsla(0,100%,27%,100%)",
      "hwb(0,0%,45%)",
      "hwb(0,0%,45%,1)",
      "hwb(0,0%,45%,100%)"
    ]
  },
  darksalmon: {
    hex: ["#e9967a", "#ffe9967a"],
    func: [
      "rgb(233,150,122)",
      "rgba(233,150,122,1)",
      "rgba(233,150,122,100%)",
      "rgb(91%,59%,48%)",
      "rgba(91%,59%,48%,1)",
      "rgba(91%,59%,48%,100%)",
      "hsl(15,72%,70%)",
      "hsla(15,72%,70%,1)",
      "hsla(15,72%,70%,100%)",
      "hwb(15,48%,9%)",
      "hwb(15,48%,9%,1)",
      "hwb(15,48%,9%,100%)"
    ]
  },
  darkseagreen: {
    hex: ["#8fbc8f", "#ff8fbc8f"],
    func: [
      "rgb(143,188,143)",
      "rgba(143,188,143,1)",
      "rgba(143,188,143,100%)",
      "rgb(56%,74%,56%)",
      "rgba(56%,74%,56%,1)",
      "rgba(56%,74%,56%,100%)",
      "hsl(120,25%,65%)",
      "hsla(120,25%,65%,1)",
      "hsla(120,25%,65%,100%)",
      "hwb(120,56%,26%)",
      "hwb(120,56%,26%,1)",
      "hwb(120,56%,26%,100%)"
    ]
  },
  darkslateblue: {
    hex: ["#483d8b", "#ff483d8b"],
    func: [
      "rgb(72,61,139)",
      "rgba(72,61,139,1)",
      "rgba(72,61,139,100%)",
      "rgb(28%,24%,55%)",
      "rgba(28%,24%,55%,1)",
      "rgba(28%,24%,55%,100%)",
      "hsl(248,39%,39%)",
      "hsla(248,39%,39%,1)",
      "hsla(248,39%,39%,100%)",
      "hwb(248,24%,45%)",
      "hwb(248,24%,45%,1)",
      "hwb(248,24%,45%,100%)"
    ]
  },
  darkslategray: {
    hex: ["#2f4f4f", "#ff2f4f4f"],
    func: [
      "rgb(47,79,79)",
      "rgba(47,79,79,1)",
      "rgba(47,79,79,100%)",
      "rgb(18%,31%,31%)",
      "rgba(18%,31%,31%,1)",
      "rgba(18%,31%,31%,100%)",
      "hsl(180,25%,25%)",
      "hsla(180,25%,25%,1)",
      "hsla(180,25%,25%,100%)",
      "hwb(180,18%,69%)",
      "hwb(180,18%,69%,1)",
      "hwb(180,18%,69%,100%)"
    ]
  },
  darkslategrey: {
    hex: ["#2f4f4f", "#ff2f4f4f"],
    func: [
      "rgb(47,79,79)",
      "rgba(47,79,79,1)",
      "rgba(47,79,79,100%)",
      "rgb(18%,31%,31%)",
      "rgba(18%,31%,31%,1)",
      "rgba(18%,31%,31%,100%)",
      "hsl(180,25%,25%)",
      "hsla(180,25%,25%,1)",
      "hsla(180,25%,25%,100%)",
      "hwb(180,18%,69%)",
      "hwb(180,18%,69%,1)",
      "hwb(180,18%,69%,100%)"
    ]
  },
  darkturquoise: {
    hex: ["#00ced1", "#ff00ced1"],
    func: [
      "rgb(0,206,209)",
      "rgba(0,206,209,1)",
      "rgba(0,206,209,100%)",
      "rgb(0%,81%,82%)",
      "rgba(0%,81%,82%,1)",
      "rgba(0%,81%,82%,100%)",
      "hsl(181,100%,41%)",
      "hsla(181,100%,41%,1)",
      "hsla(181,100%,41%,100%)",
      "hwb(181,0%,18%)",
      "hwb(181,0%,18%,1)",
      "hwb(181,0%,18%,100%)"
    ]
  },
  darkviolet: {
    hex: ["#9400d3", "#ff9400d3"],
    func: [
      "rgb(148,0,211)",
      "rgba(148,0,211,1)",
      "rgba(148,0,211,100%)",
      "rgb(58%,0%,83%)",
      "rgba(58%,0%,83%,1)",
      "rgba(58%,0%,83%,100%)",
      "hsl(282,100%,41%)",
      "hsla(282,100%,41%,1)",
      "hsla(282,100%,41%,100%)",
      "hwb(282,0%,17%)",
      "hwb(282,0%,17%,1)",
      "hwb(282,0%,17%,100%)"
    ]
  },
  deeppink: {
    hex: ["#ff1493", "#ffff1493"],
    func: [
      "rgb(255,20,147)",
      "rgba(255,20,147,1)",
      "rgba(255,20,147,100%)",
      "rgb(100%,8%,58%)",
      "rgba(100%,8%,58%,1)",
      "rgba(100%,8%,58%,100%)",
      "hsl(328,100%,54%)",
      "hsla(328,100%,54%,1)",
      "hsla(328,100%,54%,100%)",
      "hwb(328,8%,0%)",
      "hwb(328,8%,0%,1)",
      "hwb(328,8%,0%,100%)"
    ]
  },
  deepskyblue: {
    hex: ["#00bfff", "#ff00bfff"],
    func: [
      "rgb(0,191,255)",
      "rgba(0,191,255,1)",
      "rgba(0,191,255,100%)",
      "rgb(0%,75%,100%)",
      "rgba(0%,75%,100%,1)",
      "rgba(0%,75%,100%,100%)",
      "hsl(195,100%,50%)",
      "hsla(195,100%,50%,1)",
      "hsla(195,100%,50%,100%)",
      "hwb(195,0%,0%)",
      "hwb(195,0%,0%,1)",
      "hwb(195,0%,0%,100%)"
    ]
  },
  dimgray: {
    hex: ["#696969", "#ff696969"],
    func: [
      "rgb(105,105,105)",
      "rgba(105,105,105,1)",
      "rgba(105,105,105,100%)",
      "rgb(41%,41%,41%)",
      "rgba(41%,41%,41%,1)",
      "rgba(41%,41%,41%,100%)",
      "hsl(0,0%,41%)",
      "hsla(0,0%,41%,1)",
      "hsla(0,0%,41%,100%)",
      "hwb(0,41%,59%)",
      "hwb(0,41%,59%,1)",
      "hwb(0,41%,59%,100%)"
    ]
  },
  dimgrey: {
    hex: ["#696969", "#ff696969"],
    func: [
      "rgb(105,105,105)",
      "rgba(105,105,105,1)",
      "rgba(105,105,105,100%)",
      "rgb(41%,41%,41%)",
      "rgba(41%,41%,41%,1)",
      "rgba(41%,41%,41%,100%)",
      "hsl(0,0%,41%)",
      "hsla(0,0%,41%,1)",
      "hsla(0,0%,41%,100%)",
      "hwb(0,41%,59%)",
      "hwb(0,41%,59%,1)",
      "hwb(0,41%,59%,100%)",
      "gray(105)",
      "gray(105,1)",
      "gray(105,100%)",
      "gray(105%)",
      "gray(105%,1)",
      "gray(105%,100%)"
    ]
  },
  dodgerblue: {
    hex: ["#1e90ff", "#ff1e90ff"],
    func: [
      "rgb(30,144,255)",
      "rgba(30,144,255,1)",
      "rgba(30,144,255,100%)",
      "rgb(12%,56%,100%)",
      "rgba(12%,56%,100%,1)",
      "rgba(12%,56%,100%,100%)",
      "hsl(210,100%,56%)",
      "hsla(210,100%,56%,1)",
      "hsla(210,100%,56%,100%)",
      "hwb(210,12%,0%)",
      "hwb(210,12%,0%,1)",
      "hwb(210,12%,0%,100%)"
    ]
  },
  firebrick: {
    hex: ["#b22222", "#ffb22222"],
    func: [
      "rgb(178,34,34)",
      "rgba(178,34,34,1)",
      "rgba(178,34,34,100%)",
      "rgb(70%,13%,13%)",
      "rgba(70%,13%,13%,1)",
      "rgba(70%,13%,13%,100%)",
      "hsl(0,68%,42%)",
      "hsla(0,68%,42%,1)",
      "hsla(0,68%,42%,100%)",
      "hwb(0,13%,30%)",
      "hwb(0,13%,30%,1)",
      "hwb(0,13%,30%,100%)"
    ]
  },
  floralwhite: {
    hex: ["#fffaf0", "#fffffaf0"],
    func: [
      "rgb(255,250,240)",
      "rgba(255,250,240,1)",
      "rgba(255,250,240,100%)",
      "rgb(100%,98%,94%)",
      "rgba(100%,98%,94%,1)",
      "rgba(100%,98%,94%,100%)",
      "hsl(40,100%,97%)",
      "hsla(40,100%,97%,1)",
      "hsla(40,100%,97%,100%)",
      "hwb(40,94%,0%)",
      "hwb(40,94%,0%,1)",
      "hwb(40,94%,0%,100%)"
    ]
  },
  forestgreen: {
    hex: ["#228b22", "#ff228b22"],
    func: [
      "rgb(34,139,34)",
      "rgba(34,139,34,1)",
      "rgba(34,139,34,100%)",
      "rgb(13%,55%,13%)",
      "rgba(13%,55%,13%,1)",
      "rgba(13%,55%,13%,100%)",
      "hsl(120,61%,34%)",
      "hsla(120,61%,34%,1)",
      "hsla(120,61%,34%,100%)",
      "hwb(120,13%,45%)",
      "hwb(120,13%,45%,1)",
      "hwb(120,13%,45%,100%)"
    ]
  },
  fuchsia: {
    hex: ["#ff00ff", "#ffff00ff", "#f0f", "#ff0f"],
    func: [
      "rgb(255,0,255)",
      "rgba(255,0,255,1)",
      "rgba(255,0,255,100%)",
      "rgb(100%,0%,100%)",
      "rgba(100%,0%,100%,1)",
      "rgba(100%,0%,100%,100%)",
      "hsl(300,100%,50%)",
      "hsla(300,100%,50%,1)",
      "hsla(300,100%,50%,100%)",
      "hwb(300,0%,0%)",
      "hwb(300,0%,0%,1)",
      "hwb(300,0%,0%,100%)"
    ]
  },
  gainsboro: {
    hex: ["#dcdcdc", "#ffdcdcdc"],
    func: [
      "rgb(220,220,220)",
      "rgba(220,220,220,1)",
      "rgba(220,220,220,100%)",
      "rgb(86%,86%,86%)",
      "rgba(86%,86%,86%,1)",
      "rgba(86%,86%,86%,100%)",
      "hsl(0,0%,86%)",
      "hsla(0,0%,86%,1)",
      "hsla(0,0%,86%,100%)",
      "hwb(0,86%,14%)",
      "hwb(0,86%,14%,1)",
      "hwb(0,86%,14%,100%)"
    ]
  },
  ghostwhite: {
    hex: ["#f8f8ff", "#fff8f8ff"],
    func: [
      "rgb(248,248,255)",
      "rgba(248,248,255,1)",
      "rgba(248,248,255,100%)",
      "rgb(97%,97%,100%)",
      "rgba(97%,97%,100%,1)",
      "rgba(97%,97%,100%,100%)",
      "hsl(240,100%,99%)",
      "hsla(240,100%,99%,1)",
      "hsla(240,100%,99%,100%)",
      "hwb(240,97%,0%)",
      "hwb(240,97%,0%,1)",
      "hwb(240,97%,0%,100%)"
    ]
  },
  gold: {
    hex: ["#ffd700", "#ffffd700"],
    func: [
      "rgb(255,215,0)",
      "rgba(255,215,0,1)",
      "rgba(255,215,0,100%)",
      "rgb(100%,84%,0%)",
      "rgba(100%,84%,0%,1)",
      "rgba(100%,84%,0%,100%)",
      "hsl(51,100%,50%)",
      "hsla(51,100%,50%,1)",
      "hsla(51,100%,50%,100%)",
      "hwb(51,0%,0%)",
      "hwb(51,0%,0%,1)",
      "hwb(51,0%,0%,100%)"
    ]
  },
  goldenrod: {
    hex: ["#daa520", "#ffdaa520"],
    func: [
      "rgb(218,165,32)",
      "rgba(218,165,32,1)",
      "rgba(218,165,32,100%)",
      "rgb(85%,65%,13%)",
      "rgba(85%,65%,13%,1)",
      "rgba(85%,65%,13%,100%)",
      "hsl(43,74%,49%)",
      "hsla(43,74%,49%,1)",
      "hsla(43,74%,49%,100%)",
      "hwb(43,13%,15%)",
      "hwb(43,13%,15%,1)",
      "hwb(43,13%,15%,100%)"
    ]
  },
  gray: {
    hex: ["#808080", "#ff808080"],
    func: [
      "rgb(128,128,128)",
      "rgba(128,128,128,1)",
      "rgba(128,128,128,100%)",
      "rgb(50%,50%,50%)",
      "rgba(50%,50%,50%,1)",
      "rgba(50%,50%,50%,100%)",
      "hsl(0,0%,50%)",
      "hsla(0,0%,50%,1)",
      "hsla(0,0%,50%,100%)",
      "hwb(0,50%,50%)",
      "hwb(0,50%,50%,1)",
      "hwb(0,50%,50%,100%)"
    ]
  },
  green: {
    hex: ["#008000", "#ff008000"],
    func: [
      "rgb(0,128,0)",
      "rgba(0,128,0,1)",
      "rgba(0,128,0,100%)",
      "rgb(0%,50%,0%)",
      "rgba(0%,50%,0%,1)",
      "rgba(0%,50%,0%,100%)",
      "hsl(120,100%,25%)",
      "hsla(120,100%,25%,1)",
      "hsla(120,100%,25%,100%)",
      "hwb(120,0%,50%)",
      "hwb(120,0%,50%,1)",
      "hwb(120,0%,50%,100%)"
    ]
  },
  greenyellow: {
    hex: ["#adff2f", "#ffadff2f"],
    func: [
      "rgb(173,255,47)",
      "rgba(173,255,47,1)",
      "rgba(173,255,47,100%)",
      "rgb(68%,100%,18%)",
      "rgba(68%,100%,18%,1)",
      "rgba(68%,100%,18%,100%)",
      "hsl(84,100%,59%)",
      "hsla(84,100%,59%,1)",
      "hsla(84,100%,59%,100%)",
      "hwb(84,18%,0%)",
      "hwb(84,18%,0%,1)",
      "hwb(84,18%,0%,100%)"
    ]
  },
  grey: {
    hex: ["#808080", "#ff808080"],
    func: [
      "rgb(128,128,128)",
      "rgba(128,128,128,1)",
      "rgba(128,128,128,100%)",
      "rgb(50%,50%,50%)",
      "rgba(50%,50%,50%,1)",
      "rgba(50%,50%,50%,100%)",
      "hsl(0,0%,50%)",
      "hsla(0,0%,50%,1)",
      "hsla(0,0%,50%,100%)",
      "hwb(0,50%,50%)",
      "hwb(0,50%,50%,1)",
      "hwb(0,50%,50%,100%)",
      "gray(128)",
      "gray(128,1)",
      "gray(128,100%)",
      "gray(128%)",
      "gray(128%,1)",
      "gray(128%,100%)"
    ]
  },
  honeydew: {
    hex: ["#f0fff0", "#fff0fff0"],
    func: [
      "rgb(240,255,240)",
      "rgba(240,255,240,1)",
      "rgba(240,255,240,100%)",
      "rgb(94%,100%,94%)",
      "rgba(94%,100%,94%,1)",
      "rgba(94%,100%,94%,100%)",
      "hsl(120,100%,97%)",
      "hsla(120,100%,97%,1)",
      "hsla(120,100%,97%,100%)",
      "hwb(120,94%,0%)",
      "hwb(120,94%,0%,1)",
      "hwb(120,94%,0%,100%)"
    ]
  },
  hotpink: {
    hex: ["#ff69b4", "#ffff69b4"],
    func: [
      "rgb(255,105,180)",
      "rgba(255,105,180,1)",
      "rgba(255,105,180,100%)",
      "rgb(100%,41%,71%)",
      "rgba(100%,41%,71%,1)",
      "rgba(100%,41%,71%,100%)",
      "hsl(330,100%,71%)",
      "hsla(330,100%,71%,1)",
      "hsla(330,100%,71%,100%)",
      "hwb(330,41%,0%)",
      "hwb(330,41%,0%,1)",
      "hwb(330,41%,0%,100%)"
    ]
  },
  indianred: {
    hex: ["#cd5c5c", "#ffcd5c5c"],
    func: [
      "rgb(205,92,92)",
      "rgba(205,92,92,1)",
      "rgba(205,92,92,100%)",
      "rgb(80%,36%,36%)",
      "rgba(80%,36%,36%,1)",
      "rgba(80%,36%,36%,100%)",
      "hsl(0,53%,58%)",
      "hsla(0,53%,58%,1)",
      "hsla(0,53%,58%,100%)",
      "hwb(0,36%,20%)",
      "hwb(0,36%,20%,1)",
      "hwb(0,36%,20%,100%)"
    ]
  },
  indigo: {
    hex: ["#4b0082", "#ff4b0082"],
    func: [
      "rgb(75,0,130)",
      "rgba(75,0,130,1)",
      "rgba(75,0,130,100%)",
      "rgb(29%,0%,51%)",
      "rgba(29%,0%,51%,1)",
      "rgba(29%,0%,51%,100%)",
      "hsl(275,100%,25%)",
      "hsla(275,100%,25%,1)",
      "hsla(275,100%,25%,100%)",
      "hwb(275,0%,49%)",
      "hwb(275,0%,49%,1)",
      "hwb(275,0%,49%,100%)"
    ]
  },
  ivory: {
    hex: ["#fffff0", "#fffffff0"],
    func: [
      "rgb(255,255,240)",
      "rgba(255,255,240,1)",
      "rgba(255,255,240,100%)",
      "rgb(100%,100%,94%)",
      "rgba(100%,100%,94%,1)",
      "rgba(100%,100%,94%,100%)",
      "hsl(60,100%,97%)",
      "hsla(60,100%,97%,1)",
      "hsla(60,100%,97%,100%)",
      "hwb(60,94%,0%)",
      "hwb(60,94%,0%,1)",
      "hwb(60,94%,0%,100%)"
    ]
  },
  khaki: {
    hex: ["#f0e68c", "#fff0e68c"],
    func: [
      "rgb(240,230,140)",
      "rgba(240,230,140,1)",
      "rgba(240,230,140,100%)",
      "rgb(94%,90%,55%)",
      "rgba(94%,90%,55%,1)",
      "rgba(94%,90%,55%,100%)",
      "hsl(54,77%,75%)",
      "hsla(54,77%,75%,1)",
      "hsla(54,77%,75%,100%)",
      "hwb(54,55%,6%)",
      "hwb(54,55%,6%,1)",
      "hwb(54,55%,6%,100%)"
    ]
  },
  lavender: {
    hex: ["#e6e6fa", "#ffe6e6fa"],
    func: [
      "rgb(230,230,250)",
      "rgba(230,230,250,1)",
      "rgba(230,230,250,100%)",
      "rgb(90%,90%,98%)",
      "rgba(90%,90%,98%,1)",
      "rgba(90%,90%,98%,100%)",
      "hsl(240,67%,94%)",
      "hsla(240,67%,94%,1)",
      "hsla(240,67%,94%,100%)",
      "hwb(240,90%,2%)",
      "hwb(240,90%,2%,1)",
      "hwb(240,90%,2%,100%)"
    ]
  },
  lavenderblush: {
    hex: ["#fff0f5", "#fffff0f5"],
    func: [
      "rgb(255,240,245)",
      "rgba(255,240,245,1)",
      "rgba(255,240,245,100%)",
      "rgb(100%,94%,96%)",
      "rgba(100%,94%,96%,1)",
      "rgba(100%,94%,96%,100%)",
      "hsl(340,100%,97%)",
      "hsla(340,100%,97%,1)",
      "hsla(340,100%,97%,100%)",
      "hwb(340,94%,0%)",
      "hwb(340,94%,0%,1)",
      "hwb(340,94%,0%,100%)"
    ]
  },
  lawngreen: {
    hex: ["#7cfc00", "#ff7cfc00"],
    func: [
      "rgb(124,252,0)",
      "rgba(124,252,0,1)",
      "rgba(124,252,0,100%)",
      "rgb(49%,99%,0%)",
      "rgba(49%,99%,0%,1)",
      "rgba(49%,99%,0%,100%)",
      "hsl(90,100%,49%)",
      "hsla(90,100%,49%,1)",
      "hsla(90,100%,49%,100%)",
      "hwb(90,0%,1%)",
      "hwb(90,0%,1%,1)",
      "hwb(90,0%,1%,100%)"
    ]
  },
  lemonchiffon: {
    hex: ["#fffacd", "#fffffacd"],
    func: [
      "rgb(255,250,205)",
      "rgba(255,250,205,1)",
      "rgba(255,250,205,100%)",
      "rgb(100%,98%,80%)",
      "rgba(100%,98%,80%,1)",
      "rgba(100%,98%,80%,100%)",
      "hsl(54,100%,90%)",
      "hsla(54,100%,90%,1)",
      "hsla(54,100%,90%,100%)",
      "hwb(54,80%,0%)",
      "hwb(54,80%,0%,1)",
      "hwb(54,80%,0%,100%)"
    ]
  },
  lightblue: {
    hex: ["#add8e6", "#ffadd8e6"],
    func: [
      "rgb(173,216,230)",
      "rgba(173,216,230,1)",
      "rgba(173,216,230,100%)",
      "rgb(68%,85%,90%)",
      "rgba(68%,85%,90%,1)",
      "rgba(68%,85%,90%,100%)",
      "hsl(195,53%,79%)",
      "hsla(195,53%,79%,1)",
      "hsla(195,53%,79%,100%)",
      "hwb(195,68%,10%)",
      "hwb(195,68%,10%,1)",
      "hwb(195,68%,10%,100%)"
    ]
  },
  lightcoral: {
    hex: ["#f08080", "#fff08080"],
    func: [
      "rgb(240,128,128)",
      "rgba(240,128,128,1)",
      "rgba(240,128,128,100%)",
      "rgb(94%,50%,50%)",
      "rgba(94%,50%,50%,1)",
      "rgba(94%,50%,50%,100%)",
      "hsl(0,79%,72%)",
      "hsla(0,79%,72%,1)",
      "hsla(0,79%,72%,100%)",
      "hwb(0,50%,6%)",
      "hwb(0,50%,6%,1)",
      "hwb(0,50%,6%,100%)"
    ]
  },
  lightcyan: {
    hex: ["#e0ffff", "#ffe0ffff"],
    func: [
      "rgb(224,255,255)",
      "rgba(224,255,255,1)",
      "rgba(224,255,255,100%)",
      "rgb(88%,100%,100%)",
      "rgba(88%,100%,100%,1)",
      "rgba(88%,100%,100%,100%)",
      "hsl(180,100%,94%)",
      "hsla(180,100%,94%,1)",
      "hsla(180,100%,94%,100%)",
      "hwb(180,88%,0%)",
      "hwb(180,88%,0%,1)",
      "hwb(180,88%,0%,100%)"
    ]
  },
  lightgoldenrodyellow: {
    hex: ["#fafad2", "#fffafad2"],
    func: [
      "rgb(250,250,210)",
      "rgba(250,250,210,1)",
      "rgba(250,250,210,100%)",
      "rgb(98%,98%,82%)",
      "rgba(98%,98%,82%,1)",
      "rgba(98%,98%,82%,100%)",
      "hsl(60,80%,90%)",
      "hsla(60,80%,90%,1)",
      "hsla(60,80%,90%,100%)",
      "hwb(60,82%,2%)",
      "hwb(60,82%,2%,1)",
      "hwb(60,82%,2%,100%)"
    ]
  },
  lightgray: {
    hex: ["#d3d3d3", "#ffd3d3d3"],
    func: [
      "rgb(211,211,211)",
      "rgba(211,211,211,1)",
      "rgba(211,211,211,100%)",
      "rgb(83%,83%,83%)",
      "rgba(83%,83%,83%,1)",
      "rgba(83%,83%,83%,100%)",
      "hsl(0,0%,83%)",
      "hsla(0,0%,83%,1)",
      "hsla(0,0%,83%,100%)",
      "hwb(0,83%,17%)",
      "hwb(0,83%,17%,1)",
      "hwb(0,83%,17%,100%)"
    ]
  },
  lightgreen: {
    hex: ["#90ee90", "#ff90ee90"],
    func: [
      "rgb(144,238,144)",
      "rgba(144,238,144,1)",
      "rgba(144,238,144,100%)",
      "rgb(56%,93%,56%)",
      "rgba(56%,93%,56%,1)",
      "rgba(56%,93%,56%,100%)",
      "hsl(120,73%,75%)",
      "hsla(120,73%,75%,1)",
      "hsla(120,73%,75%,100%)",
      "hwb(120,56%,7%)",
      "hwb(120,56%,7%,1)",
      "hwb(120,56%,7%,100%)"
    ]
  },
  lightgrey: {
    hex: ["#d3d3d3", "#ffd3d3d3"],
    func: [
      "rgb(211,211,211)",
      "rgba(211,211,211,1)",
      "rgba(211,211,211,100%)",
      "rgb(83%,83%,83%)",
      "rgba(83%,83%,83%,1)",
      "rgba(83%,83%,83%,100%)",
      "hsl(0,0%,83%)",
      "hsla(0,0%,83%,1)",
      "hsla(0,0%,83%,100%)",
      "hwb(0,83%,17%)",
      "hwb(0,83%,17%,1)",
      "hwb(0,83%,17%,100%)",
      "gray(211)",
      "gray(211,1)",
      "gray(211,100%)",
      "gray(211%)",
      "gray(211%,1)",
      "gray(211%,100%)"
    ]
  },
  lightpink: {
    hex: ["#ffb6c1", "#ffffb6c1"],
    func: [
      "rgb(255,182,193)",
      "rgba(255,182,193,1)",
      "rgba(255,182,193,100%)",
      "rgb(100%,71%,76%)",
      "rgba(100%,71%,76%,1)",
      "rgba(100%,71%,76%,100%)",
      "hsl(351,100%,86%)",
      "hsla(351,100%,86%,1)",
      "hsla(351,100%,86%,100%)",
      "hwb(351,71%,0%)",
      "hwb(351,71%,0%,1)",
      "hwb(351,71%,0%,100%)"
    ]
  },
  lightsalmon: {
    hex: ["#ffa07a", "#ffffa07a"],
    func: [
      "rgb(255,160,122)",
      "rgba(255,160,122,1)",
      "rgba(255,160,122,100%)",
      "rgb(100%,63%,48%)",
      "rgba(100%,63%,48%,1)",
      "rgba(100%,63%,48%,100%)",
      "hsl(17,100%,74%)",
      "hsla(17,100%,74%,1)",
      "hsla(17,100%,74%,100%)",
      "hwb(17,48%,0%)",
      "hwb(17,48%,0%,1)",
      "hwb(17,48%,0%,100%)"
    ]
  },
  lightseagreen: {
    hex: ["#20b2aa", "#ff20b2aa"],
    func: [
      "rgb(32,178,170)",
      "rgba(32,178,170,1)",
      "rgba(32,178,170,100%)",
      "rgb(13%,70%,67%)",
      "rgba(13%,70%,67%,1)",
      "rgba(13%,70%,67%,100%)",
      "hsl(177,70%,41%)",
      "hsla(177,70%,41%,1)",
      "hsla(177,70%,41%,100%)",
      "hwb(177,13%,30%)",
      "hwb(177,13%,30%,1)",
      "hwb(177,13%,30%,100%)"
    ]
  },
  lightskyblue: {
    hex: ["#87cefa", "#ff87cefa"],
    func: [
      "rgb(135,206,250)",
      "rgba(135,206,250,1)",
      "rgba(135,206,250,100%)",
      "rgb(53%,81%,98%)",
      "rgba(53%,81%,98%,1)",
      "rgba(53%,81%,98%,100%)",
      "hsl(203,92%,75%)",
      "hsla(203,92%,75%,1)",
      "hsla(203,92%,75%,100%)",
      "hwb(203,53%,2%)",
      "hwb(203,53%,2%,1)",
      "hwb(203,53%,2%,100%)"
    ]
  },
  lightslategray: {
    hex: ["#778899", "#ff778899", "#789", "#f789"],
    func: [
      "rgb(119,136,153)",
      "rgba(119,136,153,1)",
      "rgba(119,136,153,100%)",
      "rgb(47%,53%,60%)",
      "rgba(47%,53%,60%,1)",
      "rgba(47%,53%,60%,100%)",
      "hsl(210,14%,53%)",
      "hsla(210,14%,53%,1)",
      "hsla(210,14%,53%,100%)",
      "hwb(210,47%,40%)",
      "hwb(210,47%,40%,1)",
      "hwb(210,47%,40%,100%)"
    ]
  },
  lightslategrey: {
    hex: ["#778899", "#ff778899", "#789", "#f789"],
    func: [
      "rgb(119,136,153)",
      "rgba(119,136,153,1)",
      "rgba(119,136,153,100%)",
      "rgb(47%,53%,60%)",
      "rgba(47%,53%,60%,1)",
      "rgba(47%,53%,60%,100%)",
      "hsl(210,14%,53%)",
      "hsla(210,14%,53%,1)",
      "hsla(210,14%,53%,100%)",
      "hwb(210,47%,40%)",
      "hwb(210,47%,40%,1)",
      "hwb(210,47%,40%,100%)"
    ]
  },
  lightsteelblue: {
    hex: ["#b0c4de", "#ffb0c4de"],
    func: [
      "rgb(176,196,222)",
      "rgba(176,196,222,1)",
      "rgba(176,196,222,100%)",
      "rgb(69%,77%,87%)",
      "rgba(69%,77%,87%,1)",
      "rgba(69%,77%,87%,100%)",
      "hsl(214,41%,78%)",
      "hsla(214,41%,78%,1)",
      "hsla(214,41%,78%,100%)",
      "hwb(214,69%,13%)",
      "hwb(214,69%,13%,1)",
      "hwb(214,69%,13%,100%)"
    ]
  },
  lightyellow: {
    hex: ["#ffffe0", "#ffffffe0"],
    func: [
      "rgb(255,255,224)",
      "rgba(255,255,224,1)",
      "rgba(255,255,224,100%)",
      "rgb(100%,100%,88%)",
      "rgba(100%,100%,88%,1)",
      "rgba(100%,100%,88%,100%)",
      "hsl(60,100%,94%)",
      "hsla(60,100%,94%,1)",
      "hsla(60,100%,94%,100%)",
      "hwb(60,88%,0%)",
      "hwb(60,88%,0%,1)",
      "hwb(60,88%,0%,100%)"
    ]
  },
  lime: {
    hex: ["#00ff00", "#ff00ff00", "#0f0", "#f0f0"],
    func: [
      "rgb(0,255,0)",
      "rgba(0,255,0,1)",
      "rgba(0,255,0,100%)",
      "rgb(0%,100%,0%)",
      "rgba(0%,100%,0%,1)",
      "rgba(0%,100%,0%,100%)",
      "hsl(120,100%,50%)",
      "hsla(120,100%,50%,1)",
      "hsla(120,100%,50%,100%)",
      "hwb(120,0%,0%)",
      "hwb(120,0%,0%,1)",
      "hwb(120,0%,0%,100%)"
    ]
  },
  limegreen: {
    hex: ["#32cd32", "#ff32cd32"],
    func: [
      "rgb(50,205,50)",
      "rgba(50,205,50,1)",
      "rgba(50,205,50,100%)",
      "rgb(20%,80%,20%)",
      "rgba(20%,80%,20%,1)",
      "rgba(20%,80%,20%,100%)",
      "hsl(120,61%,50%)",
      "hsla(120,61%,50%,1)",
      "hsla(120,61%,50%,100%)",
      "hwb(120,20%,20%)",
      "hwb(120,20%,20%,1)",
      "hwb(120,20%,20%,100%)"
    ]
  },
  linen: {
    hex: ["#faf0e6", "#fffaf0e6"],
    func: [
      "rgb(250,240,230)",
      "rgba(250,240,230,1)",
      "rgba(250,240,230,100%)",
      "rgb(98%,94%,90%)",
      "rgba(98%,94%,90%,1)",
      "rgba(98%,94%,90%,100%)",
      "hsl(30,67%,94%)",
      "hsla(30,67%,94%,1)",
      "hsla(30,67%,94%,100%)",
      "hwb(30,90%,2%)",
      "hwb(30,90%,2%,1)",
      "hwb(30,90%,2%,100%)"
    ]
  },
  magenta: {
    hex: ["#ff00ff", "#ffff00ff", "#f0f", "#ff0f"],
    func: [
      "rgb(255,0,255)",
      "rgba(255,0,255,1)",
      "rgba(255,0,255,100%)",
      "rgb(100%,0%,100%)",
      "rgba(100%,0%,100%,1)",
      "rgba(100%,0%,100%,100%)",
      "hsl(300,100%,50%)",
      "hsla(300,100%,50%,1)",
      "hsla(300,100%,50%,100%)",
      "hwb(300,0%,0%)",
      "hwb(300,0%,0%,1)",
      "hwb(300,0%,0%,100%)"
    ]
  },
  maroon: {
    hex: ["#800000", "#ff800000"],
    func: [
      "rgb(128,0,0)",
      "rgba(128,0,0,1)",
      "rgba(128,0,0,100%)",
      "rgb(50%,0%,0%)",
      "rgba(50%,0%,0%,1)",
      "rgba(50%,0%,0%,100%)",
      "hsl(0,100%,25%)",
      "hsla(0,100%,25%,1)",
      "hsla(0,100%,25%,100%)",
      "hwb(0,0%,50%)",
      "hwb(0,0%,50%,1)",
      "hwb(0,0%,50%,100%)"
    ]
  },
  mediumaquamarine: {
    hex: ["#66cdaa", "#ff66cdaa"],
    func: [
      "rgb(102,205,170)",
      "rgba(102,205,170,1)",
      "rgba(102,205,170,100%)",
      "rgb(40%,80%,67%)",
      "rgba(40%,80%,67%,1)",
      "rgba(40%,80%,67%,100%)",
      "hsl(160,51%,60%)",
      "hsla(160,51%,60%,1)",
      "hsla(160,51%,60%,100%)",
      "hwb(160,40%,20%)",
      "hwb(160,40%,20%,1)",
      "hwb(160,40%,20%,100%)"
    ]
  },
  mediumblue: {
    hex: ["#0000cd", "#ff0000cd"],
    func: [
      "rgb(0,0,205)",
      "rgba(0,0,205,1)",
      "rgba(0,0,205,100%)",
      "rgb(0%,0%,80%)",
      "rgba(0%,0%,80%,1)",
      "rgba(0%,0%,80%,100%)",
      "hsl(240,100%,40%)",
      "hsla(240,100%,40%,1)",
      "hsla(240,100%,40%,100%)",
      "hwb(240,0%,20%)",
      "hwb(240,0%,20%,1)",
      "hwb(240,0%,20%,100%)"
    ]
  },
  mediumorchid: {
    hex: ["#ba55d3", "#ffba55d3"],
    func: [
      "rgb(186,85,211)",
      "rgba(186,85,211,1)",
      "rgba(186,85,211,100%)",
      "rgb(73%,33%,83%)",
      "rgba(73%,33%,83%,1)",
      "rgba(73%,33%,83%,100%)",
      "hsl(288,59%,58%)",
      "hsla(288,59%,58%,1)",
      "hsla(288,59%,58%,100%)",
      "hwb(288,33%,17%)",
      "hwb(288,33%,17%,1)",
      "hwb(288,33%,17%,100%)"
    ]
  },
  mediumpurple: {
    hex: ["#9370db", "#ff9370db"],
    func: [
      "rgb(147,112,219)",
      "rgba(147,112,219,1)",
      "rgba(147,112,219,100%)",
      "rgb(58%,44%,86%)",
      "rgba(58%,44%,86%,1)",
      "rgba(58%,44%,86%,100%)",
      "hsl(260,60%,65%)",
      "hsla(260,60%,65%,1)",
      "hsla(260,60%,65%,100%)",
      "hwb(260,44%,14%)",
      "hwb(260,44%,14%,1)",
      "hwb(260,44%,14%,100%)"
    ]
  },
  mediumseagreen: {
    hex: ["#3cb371", "#ff3cb371"],
    func: [
      "rgb(60,179,113)",
      "rgba(60,179,113,1)",
      "rgba(60,179,113,100%)",
      "rgb(24%,70%,44%)",
      "rgba(24%,70%,44%,1)",
      "rgba(24%,70%,44%,100%)",
      "hsl(147,50%,47%)",
      "hsla(147,50%,47%,1)",
      "hsla(147,50%,47%,100%)",
      "hwb(147,24%,30%)",
      "hwb(147,24%,30%,1)",
      "hwb(147,24%,30%,100%)"
    ]
  },
  mediumslateblue: {
    hex: ["#7b68ee", "#ff7b68ee"],
    func: [
      "rgb(123,104,238)",
      "rgba(123,104,238,1)",
      "rgba(123,104,238,100%)",
      "rgb(48%,41%,93%)",
      "rgba(48%,41%,93%,1)",
      "rgba(48%,41%,93%,100%)",
      "hsl(249,80%,67%)",
      "hsla(249,80%,67%,1)",
      "hsla(249,80%,67%,100%)",
      "hwb(249,41%,7%)",
      "hwb(249,41%,7%,1)",
      "hwb(249,41%,7%,100%)"
    ]
  },
  mediumspringgreen: {
    hex: ["#00fa9a", "#ff00fa9a"],
    func: [
      "rgb(0,250,154)",
      "rgba(0,250,154,1)",
      "rgba(0,250,154,100%)",
      "rgb(0%,98%,60%)",
      "rgba(0%,98%,60%,1)",
      "rgba(0%,98%,60%,100%)",
      "hsl(157,100%,49%)",
      "hsla(157,100%,49%,1)",
      "hsla(157,100%,49%,100%)",
      "hwb(157,0%,2%)",
      "hwb(157,0%,2%,1)",
      "hwb(157,0%,2%,100%)"
    ]
  },
  mediumturquoise: {
    hex: ["#48d1cc", "#ff48d1cc"],
    func: [
      "rgb(72,209,204)",
      "rgba(72,209,204,1)",
      "rgba(72,209,204,100%)",
      "rgb(28%,82%,80%)",
      "rgba(28%,82%,80%,1)",
      "rgba(28%,82%,80%,100%)",
      "hsl(178,60%,55%)",
      "hsla(178,60%,55%,1)",
      "hsla(178,60%,55%,100%)",
      "hwb(178,28%,18%)",
      "hwb(178,28%,18%,1)",
      "hwb(178,28%,18%,100%)"
    ]
  },
  mediumvioletred: {
    hex: ["#c71585", "#ffc71585"],
    func: [
      "rgb(199,21,133)",
      "rgba(199,21,133,1)",
      "rgba(199,21,133,100%)",
      "rgb(78%,8%,52%)",
      "rgba(78%,8%,52%,1)",
      "rgba(78%,8%,52%,100%)",
      "hsl(322,81%,43%)",
      "hsla(322,81%,43%,1)",
      "hsla(322,81%,43%,100%)",
      "hwb(322,8%,22%)",
      "hwb(322,8%,22%,1)",
      "hwb(322,8%,22%,100%)"
    ]
  },
  midnightblue: {
    hex: ["#191970", "#ff191970"],
    func: [
      "rgb(25,25,112)",
      "rgba(25,25,112,1)",
      "rgba(25,25,112,100%)",
      "rgb(10%,10%,44%)",
      "rgba(10%,10%,44%,1)",
      "rgba(10%,10%,44%,100%)",
      "hsl(240,64%,27%)",
      "hsla(240,64%,27%,1)",
      "hsla(240,64%,27%,100%)",
      "hwb(240,10%,56%)",
      "hwb(240,10%,56%,1)",
      "hwb(240,10%,56%,100%)"
    ]
  },
  mintcream: {
    hex: ["#f5fffa", "#fff5fffa"],
    func: [
      "rgb(245,255,250)",
      "rgba(245,255,250,1)",
      "rgba(245,255,250,100%)",
      "rgb(96%,100%,98%)",
      "rgba(96%,100%,98%,1)",
      "rgba(96%,100%,98%,100%)",
      "hsl(150,100%,98%)",
      "hsla(150,100%,98%,1)",
      "hsla(150,100%,98%,100%)",
      "hwb(150,96%,0%)",
      "hwb(150,96%,0%,1)",
      "hwb(150,96%,0%,100%)"
    ]
  },
  mistyrose: {
    hex: ["#ffe4e1", "#ffffe4e1"],
    func: [
      "rgb(255,228,225)",
      "rgba(255,228,225,1)",
      "rgba(255,228,225,100%)",
      "rgb(100%,89%,88%)",
      "rgba(100%,89%,88%,1)",
      "rgba(100%,89%,88%,100%)",
      "hsl(6,100%,94%)",
      "hsla(6,100%,94%,1)",
      "hsla(6,100%,94%,100%)",
      "hwb(6,88%,0%)",
      "hwb(6,88%,0%,1)",
      "hwb(6,88%,0%,100%)"
    ]
  },
  moccasin: {
    hex: ["#ffe4b5", "#ffffe4b5"],
    func: [
      "rgb(255,228,181)",
      "rgba(255,228,181,1)",
      "rgba(255,228,181,100%)",
      "rgb(100%,89%,71%)",
      "rgba(100%,89%,71%,1)",
      "rgba(100%,89%,71%,100%)",
      "hsl(38,100%,85%)",
      "hsla(38,100%,85%,1)",
      "hsla(38,100%,85%,100%)",
      "hwb(38,71%,0%)",
      "hwb(38,71%,0%,1)",
      "hwb(38,71%,0%,100%)"
    ]
  },
  navajowhite: {
    hex: ["#ffdead", "#ffffdead"],
    func: [
      "rgb(255,222,173)",
      "rgba(255,222,173,1)",
      "rgba(255,222,173,100%)",
      "rgb(100%,87%,68%)",
      "rgba(100%,87%,68%,1)",
      "rgba(100%,87%,68%,100%)",
      "hsl(36,100%,84%)",
      "hsla(36,100%,84%,1)",
      "hsla(36,100%,84%,100%)",
      "hwb(36,68%,0%)",
      "hwb(36,68%,0%,1)",
      "hwb(36,68%,0%,100%)"
    ]
  },
  navy: {
    hex: ["#000080", "#ff000080"],
    func: [
      "rgb(0,0,128)",
      "rgba(0,0,128,1)",
      "rgba(0,0,128,100%)",
      "rgb(0%,0%,50%)",
      "rgba(0%,0%,50%,1)",
      "rgba(0%,0%,50%,100%)",
      "hsl(240,100%,25%)",
      "hsla(240,100%,25%,1)",
      "hsla(240,100%,25%,100%)",
      "hwb(240,0%,50%)",
      "hwb(240,0%,50%,1)",
      "hwb(240,0%,50%,100%)"
    ]
  },
  oldlace: {
    hex: ["#fdf5e6", "#fffdf5e6"],
    func: [
      "rgb(253,245,230)",
      "rgba(253,245,230,1)",
      "rgba(253,245,230,100%)",
      "rgb(99%,96%,90%)",
      "rgba(99%,96%,90%,1)",
      "rgba(99%,96%,90%,100%)",
      "hsl(39,85%,95%)",
      "hsla(39,85%,95%,1)",
      "hsla(39,85%,95%,100%)",
      "hwb(39,90%,1%)",
      "hwb(39,90%,1%,1)",
      "hwb(39,90%,1%,100%)"
    ]
  },
  olive: {
    hex: ["#808000", "#ff808000"],
    func: [
      "rgb(128,128,0)",
      "rgba(128,128,0,1)",
      "rgba(128,128,0,100%)",
      "rgb(50%,50%,0%)",
      "rgba(50%,50%,0%,1)",
      "rgba(50%,50%,0%,100%)",
      "hsl(60,100%,25%)",
      "hsla(60,100%,25%,1)",
      "hsla(60,100%,25%,100%)",
      "hwb(60,0%,50%)",
      "hwb(60,0%,50%,1)",
      "hwb(60,0%,50%,100%)"
    ]
  },
  olivedrab: {
    hex: ["#6b8e23", "#ff6b8e23"],
    func: [
      "rgb(107,142,35)",
      "rgba(107,142,35,1)",
      "rgba(107,142,35,100%)",
      "rgb(42%,56%,14%)",
      "rgba(42%,56%,14%,1)",
      "rgba(42%,56%,14%,100%)",
      "hsl(80,60%,35%)",
      "hsla(80,60%,35%,1)",
      "hsla(80,60%,35%,100%)",
      "hwb(80,14%,44%)",
      "hwb(80,14%,44%,1)",
      "hwb(80,14%,44%,100%)"
    ]
  },
  orange: {
    hex: ["#ffa500", "#ffffa500"],
    func: [
      "rgb(255,165,0)",
      "rgba(255,165,0,1)",
      "rgba(255,165,0,100%)",
      "rgb(100%,65%,0%)",
      "rgba(100%,65%,0%,1)",
      "rgba(100%,65%,0%,100%)",
      "hsl(39,100%,50%)",
      "hsla(39,100%,50%,1)",
      "hsla(39,100%,50%,100%)",
      "hwb(39,0%,0%)",
      "hwb(39,0%,0%,1)",
      "hwb(39,0%,0%,100%)"
    ]
  },
  orangered: {
    hex: ["#ff4500", "#ffff4500"],
    func: [
      "rgb(255,69,0)",
      "rgba(255,69,0,1)",
      "rgba(255,69,0,100%)",
      "rgb(100%,27%,0%)",
      "rgba(100%,27%,0%,1)",
      "rgba(100%,27%,0%,100%)",
      "hsl(16,100%,50%)",
      "hsla(16,100%,50%,1)",
      "hsla(16,100%,50%,100%)",
      "hwb(16,0%,0%)",
      "hwb(16,0%,0%,1)",
      "hwb(16,0%,0%,100%)"
    ]
  },
  orchid: {
    hex: ["#da70d6", "#ffda70d6"],
    func: [
      "rgb(218,112,214)",
      "rgba(218,112,214,1)",
      "rgba(218,112,214,100%)",
      "rgb(85%,44%,84%)",
      "rgba(85%,44%,84%,1)",
      "rgba(85%,44%,84%,100%)",
      "hsl(302,59%,65%)",
      "hsla(302,59%,65%,1)",
      "hsla(302,59%,65%,100%)",
      "hwb(302,44%,15%)",
      "hwb(302,44%,15%,1)",
      "hwb(302,44%,15%,100%)"
    ]
  },
  palegoldenrod: {
    hex: ["#eee8aa", "#ffeee8aa"],
    func: [
      "rgb(238,232,170)",
      "rgba(238,232,170,1)",
      "rgba(238,232,170,100%)",
      "rgb(93%,91%,67%)",
      "rgba(93%,91%,67%,1)",
      "rgba(93%,91%,67%,100%)",
      "hsl(55,67%,80%)",
      "hsla(55,67%,80%,1)",
      "hsla(55,67%,80%,100%)",
      "hwb(55,67%,7%)",
      "hwb(55,67%,7%,1)",
      "hwb(55,67%,7%,100%)"
    ]
  },
  palegreen: {
    hex: ["#98fb98", "#ff98fb98"],
    func: [
      "rgb(152,251,152)",
      "rgba(152,251,152,1)",
      "rgba(152,251,152,100%)",
      "rgb(60%,98%,60%)",
      "rgba(60%,98%,60%,1)",
      "rgba(60%,98%,60%,100%)",
      "hsl(120,93%,79%)",
      "hsla(120,93%,79%,1)",
      "hsla(120,93%,79%,100%)",
      "hwb(120,60%,2%)",
      "hwb(120,60%,2%,1)",
      "hwb(120,60%,2%,100%)"
    ]
  },
  paleturquoise: {
    hex: ["#afeeee", "#ffafeeee"],
    func: [
      "rgb(175,238,238)",
      "rgba(175,238,238,1)",
      "rgba(175,238,238,100%)",
      "rgb(69%,93%,93%)",
      "rgba(69%,93%,93%,1)",
      "rgba(69%,93%,93%,100%)",
      "hsl(180,65%,81%)",
      "hsla(180,65%,81%,1)",
      "hsla(180,65%,81%,100%)",
      "hwb(180,69%,7%)",
      "hwb(180,69%,7%,1)",
      "hwb(180,69%,7%,100%)"
    ]
  },
  palevioletred: {
    hex: ["#db7093", "#ffdb7093"],
    func: [
      "rgb(219,112,147)",
      "rgba(219,112,147,1)",
      "rgba(219,112,147,100%)",
      "rgb(86%,44%,58%)",
      "rgba(86%,44%,58%,1)",
      "rgba(86%,44%,58%,100%)",
      "hsl(340,60%,65%)",
      "hsla(340,60%,65%,1)",
      "hsla(340,60%,65%,100%)",
      "hwb(340,44%,14%)",
      "hwb(340,44%,14%,1)",
      "hwb(340,44%,14%,100%)"
    ]
  },
  papayawhip: {
    hex: ["#ffefd5", "#ffffefd5"],
    func: [
      "rgb(255,239,213)",
      "rgba(255,239,213,1)",
      "rgba(255,239,213,100%)",
      "rgb(100%,94%,84%)",
      "rgba(100%,94%,84%,1)",
      "rgba(100%,94%,84%,100%)",
      "hsl(37,100%,92%)",
      "hsla(37,100%,92%,1)",
      "hsla(37,100%,92%,100%)",
      "hwb(37,84%,0%)",
      "hwb(37,84%,0%,1)",
      "hwb(37,84%,0%,100%)"
    ]
  },
  peachpuff: {
    hex: ["#ffdab9", "#ffffdab9"],
    func: [
      "rgb(255,218,185)",
      "rgba(255,218,185,1)",
      "rgba(255,218,185,100%)",
      "rgb(100%,85%,73%)",
      "rgba(100%,85%,73%,1)",
      "rgba(100%,85%,73%,100%)",
      "hsl(28,100%,86%)",
      "hsla(28,100%,86%,1)",
      "hsla(28,100%,86%,100%)",
      "hwb(28,73%,0%)",
      "hwb(28,73%,0%,1)",
      "hwb(28,73%,0%,100%)"
    ]
  },
  peru: {
    hex: ["#cd853f", "#ffcd853f"],
    func: [
      "rgb(205,133,63)",
      "rgba(205,133,63,1)",
      "rgba(205,133,63,100%)",
      "rgb(80%,52%,25%)",
      "rgba(80%,52%,25%,1)",
      "rgba(80%,52%,25%,100%)",
      "hsl(30,59%,53%)",
      "hsla(30,59%,53%,1)",
      "hsla(30,59%,53%,100%)",
      "hwb(30,25%,20%)",
      "hwb(30,25%,20%,1)",
      "hwb(30,25%,20%,100%)"
    ]
  },
  pink: {
    hex: ["#ffc0cb", "#ffffc0cb"],
    func: [
      "rgb(255,192,203)",
      "rgba(255,192,203,1)",
      "rgba(255,192,203,100%)",
      "rgb(100%,75%,80%)",
      "rgba(100%,75%,80%,1)",
      "rgba(100%,75%,80%,100%)",
      "hsl(350,100%,88%)",
      "hsla(350,100%,88%,1)",
      "hsla(350,100%,88%,100%)",
      "hwb(350,75%,0%)",
      "hwb(350,75%,0%,1)",
      "hwb(350,75%,0%,100%)"
    ]
  },
  plum: {
    hex: ["#dda0dd", "#ffdda0dd"],
    func: [
      "rgb(221,160,221)",
      "rgba(221,160,221,1)",
      "rgba(221,160,221,100%)",
      "rgb(87%,63%,87%)",
      "rgba(87%,63%,87%,1)",
      "rgba(87%,63%,87%,100%)",
      "hsl(300,47%,75%)",
      "hsla(300,47%,75%,1)",
      "hsla(300,47%,75%,100%)",
      "hwb(300,63%,13%)",
      "hwb(300,63%,13%,1)",
      "hwb(300,63%,13%,100%)"
    ]
  },
  powderblue: {
    hex: ["#b0e0e6", "#ffb0e0e6"],
    func: [
      "rgb(176,224,230)",
      "rgba(176,224,230,1)",
      "rgba(176,224,230,100%)",
      "rgb(69%,88%,90%)",
      "rgba(69%,88%,90%,1)",
      "rgba(69%,88%,90%,100%)",
      "hsl(187,52%,80%)",
      "hsla(187,52%,80%,1)",
      "hsla(187,52%,80%,100%)",
      "hwb(187,69%,10%)",
      "hwb(187,69%,10%,1)",
      "hwb(187,69%,10%,100%)"
    ]
  },
  purple: {
    hex: ["#800080", "#ff800080"],
    func: [
      "rgb(128,0,128)",
      "rgba(128,0,128,1)",
      "rgba(128,0,128,100%)",
      "rgb(50%,0%,50%)",
      "rgba(50%,0%,50%,1)",
      "rgba(50%,0%,50%,100%)",
      "hsl(300,100%,25%)",
      "hsla(300,100%,25%,1)",
      "hsla(300,100%,25%,100%)",
      "hwb(300,0%,50%)",
      "hwb(300,0%,50%,1)",
      "hwb(300,0%,50%,100%)"
    ]
  },
  rebeccapurple: {
    hex: ["#663399", "#ff663399", "#639", "#f639"],
    func: [
      "rgb(102,51,153)",
      "rgba(102,51,153,1)",
      "rgba(102,51,153,100%)",
      "rgb(40%,20%,60%)",
      "rgba(40%,20%,60%,1)",
      "rgba(40%,20%,60%,100%)",
      "hsl(270,50%,40%)",
      "hsla(270,50%,40%,1)",
      "hsla(270,50%,40%,100%)",
      "hwb(270,20%,40%)",
      "hwb(270,20%,40%,1)",
      "hwb(270,20%,40%,100%)"
    ]
  },
  red: {
    hex: ["#ff0000", "#ffff0000", "#f00", "#ff00"],
    func: [
      "rgb(255,0,0)",
      "rgba(255,0,0,1)",
      "rgba(255,0,0,100%)",
      "rgb(100%,0%,0%)",
      "rgba(100%,0%,0%,1)",
      "rgba(100%,0%,0%,100%)",
      "hsl(0,100%,50%)",
      "hsla(0,100%,50%,1)",
      "hsla(0,100%,50%,100%)",
      "hwb(0,0%,0%)",
      "hwb(0,0%,0%,1)",
      "hwb(0,0%,0%,100%)"
    ]
  },
  rosybrown: {
    hex: ["#bc8f8f", "#ffbc8f8f"],
    func: [
      "rgb(188,143,143)",
      "rgba(188,143,143,1)",
      "rgba(188,143,143,100%)",
      "rgb(74%,56%,56%)",
      "rgba(74%,56%,56%,1)",
      "rgba(74%,56%,56%,100%)",
      "hsl(0,25%,65%)",
      "hsla(0,25%,65%,1)",
      "hsla(0,25%,65%,100%)",
      "hwb(0,56%,26%)",
      "hwb(0,56%,26%,1)",
      "hwb(0,56%,26%,100%)"
    ]
  },
  royalblue: {
    hex: ["#4169e1", "#ff4169e1"],
    func: [
      "rgb(65,105,225)",
      "rgba(65,105,225,1)",
      "rgba(65,105,225,100%)",
      "rgb(25%,41%,88%)",
      "rgba(25%,41%,88%,1)",
      "rgba(25%,41%,88%,100%)",
      "hsl(225,73%,57%)",
      "hsla(225,73%,57%,1)",
      "hsla(225,73%,57%,100%)",
      "hwb(225,25%,12%)",
      "hwb(225,25%,12%,1)",
      "hwb(225,25%,12%,100%)"
    ]
  },
  saddlebrown: {
    hex: ["#8b4513", "#ff8b4513"],
    func: [
      "rgb(139,69,19)",
      "rgba(139,69,19,1)",
      "rgba(139,69,19,100%)",
      "rgb(55%,27%,7%)",
      "rgba(55%,27%,7%,1)",
      "rgba(55%,27%,7%,100%)",
      "hsl(25,76%,31%)",
      "hsla(25,76%,31%,1)",
      "hsla(25,76%,31%,100%)",
      "hwb(25,7%,45%)",
      "hwb(25,7%,45%,1)",
      "hwb(25,7%,45%,100%)"
    ]
  },
  salmon: {
    hex: ["#fa8072", "#fffa8072"],
    func: [
      "rgb(250,128,114)",
      "rgba(250,128,114,1)",
      "rgba(250,128,114,100%)",
      "rgb(98%,50%,45%)",
      "rgba(98%,50%,45%,1)",
      "rgba(98%,50%,45%,100%)",
      "hsl(6,93%,71%)",
      "hsla(6,93%,71%,1)",
      "hsla(6,93%,71%,100%)",
      "hwb(6,45%,2%)",
      "hwb(6,45%,2%,1)",
      "hwb(6,45%,2%,100%)"
    ]
  },
  sandybrown: {
    hex: ["#f4a460", "#fff4a460"],
    func: [
      "rgb(244,164,96)",
      "rgba(244,164,96,1)",
      "rgba(244,164,96,100%)",
      "rgb(96%,64%,38%)",
      "rgba(96%,64%,38%,1)",
      "rgba(96%,64%,38%,100%)",
      "hsl(28,87%,67%)",
      "hsla(28,87%,67%,1)",
      "hsla(28,87%,67%,100%)",
      "hwb(28,38%,4%)",
      "hwb(28,38%,4%,1)",
      "hwb(28,38%,4%,100%)"
    ]
  },
  seagreen: {
    hex: ["#2e8b57", "#ff2e8b57"],
    func: [
      "rgb(46,139,87)",
      "rgba(46,139,87,1)",
      "rgba(46,139,87,100%)",
      "rgb(18%,55%,34%)",
      "rgba(18%,55%,34%,1)",
      "rgba(18%,55%,34%,100%)",
      "hsl(146,50%,36%)",
      "hsla(146,50%,36%,1)",
      "hsla(146,50%,36%,100%)",
      "hwb(146,18%,45%)",
      "hwb(146,18%,45%,1)",
      "hwb(146,18%,45%,100%)"
    ]
  },
  seashell: {
    hex: ["#fff5ee", "#fffff5ee"],
    func: [
      "rgb(255,245,238)",
      "rgba(255,245,238,1)",
      "rgba(255,245,238,100%)",
      "rgb(100%,96%,93%)",
      "rgba(100%,96%,93%,1)",
      "rgba(100%,96%,93%,100%)",
      "hsl(25,100%,97%)",
      "hsla(25,100%,97%,1)",
      "hsla(25,100%,97%,100%)",
      "hwb(25,93%,0%)",
      "hwb(25,93%,0%,1)",
      "hwb(25,93%,0%,100%)"
    ]
  },
  sienna: {
    hex: ["#a0522d", "#ffa0522d"],
    func: [
      "rgb(160,82,45)",
      "rgba(160,82,45,1)",
      "rgba(160,82,45,100%)",
      "rgb(63%,32%,18%)",
      "rgba(63%,32%,18%,1)",
      "rgba(63%,32%,18%,100%)",
      "hsl(19,56%,40%)",
      "hsla(19,56%,40%,1)",
      "hsla(19,56%,40%,100%)",
      "hwb(19,18%,37%)",
      "hwb(19,18%,37%,1)",
      "hwb(19,18%,37%,100%)"
    ]
  },
  silver: {
    hex: ["#c0c0c0", "#ffc0c0c0"],
    func: [
      "rgb(192,192,192)",
      "rgba(192,192,192,1)",
      "rgba(192,192,192,100%)",
      "rgb(75%,75%,75%)",
      "rgba(75%,75%,75%,1)",
      "rgba(75%,75%,75%,100%)",
      "hsl(0,0%,75%)",
      "hsla(0,0%,75%,1)",
      "hsla(0,0%,75%,100%)",
      "hwb(0,75%,25%)",
      "hwb(0,75%,25%,1)",
      "hwb(0,75%,25%,100%)"
    ]
  },
  skyblue: {
    hex: ["#87ceeb", "#ff87ceeb"],
    func: [
      "rgb(135,206,235)",
      "rgba(135,206,235,1)",
      "rgba(135,206,235,100%)",
      "rgb(53%,81%,92%)",
      "rgba(53%,81%,92%,1)",
      "rgba(53%,81%,92%,100%)",
      "hsl(197,71%,73%)",
      "hsla(197,71%,73%,1)",
      "hsla(197,71%,73%,100%)",
      "hwb(197,53%,8%)",
      "hwb(197,53%,8%,1)",
      "hwb(197,53%,8%,100%)"
    ]
  },
  slateblue: {
    hex: ["#6a5acd", "#ff6a5acd"],
    func: [
      "rgb(106,90,205)",
      "rgba(106,90,205,1)",
      "rgba(106,90,205,100%)",
      "rgb(42%,35%,80%)",
      "rgba(42%,35%,80%,1)",
      "rgba(42%,35%,80%,100%)",
      "hsl(248,53%,58%)",
      "hsla(248,53%,58%,1)",
      "hsla(248,53%,58%,100%)",
      "hwb(248,35%,20%)",
      "hwb(248,35%,20%,1)",
      "hwb(248,35%,20%,100%)"
    ]
  },
  slategray: {
    hex: ["#708090", "#ff708090"],
    func: [
      "rgb(112,128,144)",
      "rgba(112,128,144,1)",
      "rgba(112,128,144,100%)",
      "rgb(44%,50%,56%)",
      "rgba(44%,50%,56%,1)",
      "rgba(44%,50%,56%,100%)",
      "hsl(210,13%,50%)",
      "hsla(210,13%,50%,1)",
      "hsla(210,13%,50%,100%)",
      "hwb(210,44%,44%)",
      "hwb(210,44%,44%,1)",
      "hwb(210,44%,44%,100%)"
    ]
  },
  slategrey: {
    hex: ["#708090", "#ff708090"],
    func: [
      "rgb(112,128,144)",
      "rgba(112,128,144,1)",
      "rgba(112,128,144,100%)",
      "rgb(44%,50%,56%)",
      "rgba(44%,50%,56%,1)",
      "rgba(44%,50%,56%,100%)",
      "hsl(210,13%,50%)",
      "hsla(210,13%,50%,1)",
      "hsla(210,13%,50%,100%)",
      "hwb(210,44%,44%)",
      "hwb(210,44%,44%,1)",
      "hwb(210,44%,44%,100%)"
    ]
  },
  snow: {
    hex: ["#fffafa", "#fffffafa"],
    func: [
      "rgb(255,250,250)",
      "rgba(255,250,250,1)",
      "rgba(255,250,250,100%)",
      "rgb(100%,98%,98%)",
      "rgba(100%,98%,98%,1)",
      "rgba(100%,98%,98%,100%)",
      "hsl(0,100%,99%)",
      "hsla(0,100%,99%,1)",
      "hsla(0,100%,99%,100%)",
      "hwb(0,98%,0%)",
      "hwb(0,98%,0%,1)",
      "hwb(0,98%,0%,100%)"
    ]
  },
  springgreen: {
    hex: ["#00ff7f", "#ff00ff7f"],
    func: [
      "rgb(0,255,127)",
      "rgba(0,255,127,1)",
      "rgba(0,255,127,100%)",
      "rgb(0%,100%,50%)",
      "rgba(0%,100%,50%,1)",
      "rgba(0%,100%,50%,100%)",
      "hsl(150,100%,50%)",
      "hsla(150,100%,50%,1)",
      "hsla(150,100%,50%,100%)",
      "hwb(150,0%,0%)",
      "hwb(150,0%,0%,1)",
      "hwb(150,0%,0%,100%)"
    ]
  },
  steelblue: {
    hex: ["#4682b4", "#ff4682b4"],
    func: [
      "rgb(70,130,180)",
      "rgba(70,130,180,1)",
      "rgba(70,130,180,100%)",
      "rgb(27%,51%,71%)",
      "rgba(27%,51%,71%,1)",
      "rgba(27%,51%,71%,100%)",
      "hsl(207,44%,49%)",
      "hsla(207,44%,49%,1)",
      "hsla(207,44%,49%,100%)",
      "hwb(207,27%,29%)",
      "hwb(207,27%,29%,1)",
      "hwb(207,27%,29%,100%)"
    ]
  },
  tan: {
    hex: ["#d2b48c", "#ffd2b48c"],
    func: [
      "rgb(210,180,140)",
      "rgba(210,180,140,1)",
      "rgba(210,180,140,100%)",
      "rgb(82%,71%,55%)",
      "rgba(82%,71%,55%,1)",
      "rgba(82%,71%,55%,100%)",
      "hsl(34,44%,69%)",
      "hsla(34,44%,69%,1)",
      "hsla(34,44%,69%,100%)",
      "hwb(34,55%,18%)",
      "hwb(34,55%,18%,1)",
      "hwb(34,55%,18%,100%)"
    ]
  },
  teal: {
    hex: ["#008080", "#ff008080"],
    func: [
      "rgb(0,128,128)",
      "rgba(0,128,128,1)",
      "rgba(0,128,128,100%)",
      "rgb(0%,50%,50%)",
      "rgba(0%,50%,50%,1)",
      "rgba(0%,50%,50%,100%)",
      "hsl(180,100%,25%)",
      "hsla(180,100%,25%,1)",
      "hsla(180,100%,25%,100%)",
      "hwb(180,0%,50%)",
      "hwb(180,0%,50%,1)",
      "hwb(180,0%,50%,100%)"
    ]
  },
  thistle: {
    hex: ["#d8bfd8", "#ffd8bfd8"],
    func: [
      "rgb(216,191,216)",
      "rgba(216,191,216,1)",
      "rgba(216,191,216,100%)",
      "rgb(85%,75%,85%)",
      "rgba(85%,75%,85%,1)",
      "rgba(85%,75%,85%,100%)",
      "hsl(300,24%,80%)",
      "hsla(300,24%,80%,1)",
      "hsla(300,24%,80%,100%)",
      "hwb(300,75%,15%)",
      "hwb(300,75%,15%,1)",
      "hwb(300,75%,15%,100%)"
    ]
  },
  tomato: {
    hex: ["#ff6347", "#ffff6347"],
    func: [
      "rgb(255,99,71)",
      "rgba(255,99,71,1)",
      "rgba(255,99,71,100%)",
      "rgb(100%,39%,28%)",
      "rgba(100%,39%,28%,1)",
      "rgba(100%,39%,28%,100%)",
      "hsl(9,100%,64%)",
      "hsla(9,100%,64%,1)",
      "hsla(9,100%,64%,100%)",
      "hwb(9,28%,0%)",
      "hwb(9,28%,0%,1)",
      "hwb(9,28%,0%,100%)"
    ]
  },
  turquoise: {
    hex: ["#40e0d0", "#ff40e0d0"],
    func: [
      "rgb(64,224,208)",
      "rgba(64,224,208,1)",
      "rgba(64,224,208,100%)",
      "rgb(25%,88%,82%)",
      "rgba(25%,88%,82%,1)",
      "rgba(25%,88%,82%,100%)",
      "hsl(174,72%,56%)",
      "hsla(174,72%,56%,1)",
      "hsla(174,72%,56%,100%)",
      "hwb(174,25%,12%)",
      "hwb(174,25%,12%,1)",
      "hwb(174,25%,12%,100%)"
    ]
  },
  violet: {
    hex: ["#ee82ee", "#ffee82ee"],
    func: [
      "rgb(238,130,238)",
      "rgba(238,130,238,1)",
      "rgba(238,130,238,100%)",
      "rgb(93%,51%,93%)",
      "rgba(93%,51%,93%,1)",
      "rgba(93%,51%,93%,100%)",
      "hsl(300,76%,72%)",
      "hsla(300,76%,72%,1)",
      "hsla(300,76%,72%,100%)",
      "hwb(300,51%,7%)",
      "hwb(300,51%,7%,1)",
      "hwb(300,51%,7%,100%)"
    ]
  },
  wheat: {
    hex: ["#f5deb3", "#fff5deb3"],
    func: [
      "rgb(245,222,179)",
      "rgba(245,222,179,1)",
      "rgba(245,222,179,100%)",
      "rgb(96%,87%,70%)",
      "rgba(96%,87%,70%,1)",
      "rgba(96%,87%,70%,100%)",
      "hsl(39,77%,83%)",
      "hsla(39,77%,83%,1)",
      "hsla(39,77%,83%,100%)",
      "hwb(39,70%,4%)",
      "hwb(39,70%,4%,1)",
      "hwb(39,70%,4%,100%)"
    ]
  },
  white: {
    hex: ["#ffffff", "#ffffffff", "#fff", "#ffff"],
    func: [
      "rgb(255,255,255)",
      "rgba(255,255,255,1)",
      "rgba(255,255,255,100%)",
      "rgb(100%,100%,100%)",
      "rgba(100%,100%,100%,1)",
      "rgba(100%,100%,100%,100%)",
      "hsl(0,0%,100%)",
      "hsla(0,0%,100%,1)",
      "hsla(0,0%,100%,100%)",
      "hwb(0,100%,0%)",
      "hwb(0,100%,0%,1)",
      "hwb(0,100%,0%,100%)",
      "gray(255)",
      "gray(255,1)",
      "gray(255,100%)",
      "gray(255%)",
      "gray(255%,1)",
      "gray(255%,100%)"
    ]
  },
  whitesmoke: {
    hex: ["#f5f5f5", "#fff5f5f5"],
    func: [
      "rgb(245,245,245)",
      "rgba(245,245,245,1)",
      "rgba(245,245,245,100%)",
      "rgb(96%,96%,96%)",
      "rgba(96%,96%,96%,1)",
      "rgba(96%,96%,96%,100%)",
      "hsl(0,0%,96%)",
      "hsla(0,0%,96%,1)",
      "hsla(0,0%,96%,100%)",
      "hwb(0,96%,4%)",
      "hwb(0,96%,4%,1)",
      "hwb(0,96%,4%,100%)",
      "gray(245)",
      "gray(245,1)",
      "gray(245,100%)",
      "gray(245%)",
      "gray(245%,1)",
      "gray(245%,100%)"
    ]
  },
  yellow: {
    hex: ["#ffff00", "#ffffff00", "#ff0", "#fff0"],
    func: [
      "rgb(255,255,0)",
      "rgba(255,255,0,1)",
      "rgba(255,255,0,100%)",
      "rgb(100%,100%,0%)",
      "rgba(100%,100%,0%,1)",
      "rgba(100%,100%,0%,100%)",
      "hsl(60,100%,50%)",
      "hsla(60,100%,50%,1)",
      "hsla(60,100%,50%,100%)",
      "hwb(60,0%,0%)",
      "hwb(60,0%,0%,1)",
      "hwb(60,0%,0%,100%)"
    ]
  },
  yellowgreen: {
    hex: ["#9acd32", "#ff9acd32"],
    func: [
      "rgb(154,205,50)",
      "rgba(154,205,50,1)",
      "rgba(154,205,50,100%)",
      "rgb(60%,80%,20%)",
      "rgba(60%,80%,20%,1)",
      "rgba(60%,80%,20%,100%)",
      "hsl(80,61%,50%)",
      "hsla(80,61%,50%,1)",
      "hsla(80,61%,50%,100%)",
      "hwb(80,20%,20%)",
      "hwb(80,20%,20%,1)",
      "hwb(80,20%,20%,100%)"
    ]
  }
};

},{}],890:[function(require,module,exports){
"use strict";

const propertySets = {};

propertySets.acceptCustomIdents = new Set([
  "animation",
  "animation-name",
  "font",
  "font-family",
  "counter-increment",
  "grid-row",
  "grid-column",
  "grid-area",
  "list-style",
  "list-style-type"
]);

module.exports = propertySets;

},{}],891:[function(require,module,exports){
"use strict";

const punctuationSets = {};

punctuationSets.mediaFeaturePunctuation = new Set([
  ":",
  "=",
  ">",
  ">=",
  "<",
  "<="
]);

punctuationSets.nonSpaceCombinators = new Set([">", "+", "~", ">>>", "/deep/"]);

module.exports = punctuationSets;

},{}],892:[function(require,module,exports){
"use strict";

module.exports = {
  margin: ["margin-top", "margin-bottom", "margin-left", "margin-right"],
  padding: ["padding-top", "padding-bottom", "padding-left", "padding-right"],
  background: [
    "background-image",
    "background-size",
    "background-position",
    "background-repeat",
    "background-origin",
    "background-clip",
    "background-attachment",
    "background-color"
  ],
  font: [
    "font-style",
    "font-variant",
    "font-weight",
    "font-stretch",
    "font-size",
    "font-family",
    "line-height"
  ],
  border: [
    "border-top-width",
    "border-bottom-width",
    "border-left-width",
    "border-right-width",
    "border-top-style",
    "border-bottom-style",
    "border-left-style",
    "border-right-style",
    "border-top-color",
    "border-bottom-color",
    "border-left-color",
    "border-right-color"
  ],
  "border-top": ["border-top-width", "border-top-style", "border-top-color"],
  "border-bottom": [
    "border-bottom-width",
    "border-bottom-style",
    "border-bottom-color"
  ],
  "border-left": [
    "border-left-width",
    "border-left-style",
    "border-left-color"
  ],
  "border-right": [
    "border-right-width",
    "border-right-style",
    "border-right-color"
  ],
  "border-width": [
    "border-top-width",
    "border-bottom-width",
    "border-left-width",
    "border-right-width"
  ],
  "border-style": [
    "border-top-style",
    "border-bottom-style",
    "border-left-style",
    "border-right-style"
  ],
  "border-color": [
    "border-top-color",
    "border-bottom-color",
    "border-left-color",
    "border-right-color"
  ],
  "list-style": ["list-style-type", "list-style-position", "list-style-image"],
  "border-radius": [
    "border-top-right-radius",
    "border-top-left-radius",
    "border-bottom-right-radius",
    "border-bottom-left-radius"
  ],
  transition: [
    "transition-delay",
    "transition-duration",
    "transition-property",
    "transition-timing-function"
  ],
  animation: [
    "animation-name",
    "animation-duration",
    "animation-timing-function",
    "animation-delay",
    "animation-iteration-count",
    "animation-direction",
    "animation-fill-mode",
    "animation-play-state"
  ],
  "border-block-end": [
    "border-block-end-width",
    "border-block-end-style",
    "border-block-end-color"
  ],
  "border-block-start": [
    "border-block-start-width",
    "border-block-start-style",
    "border-block-start-color"
  ],
  "border-image": [
    "border-image-source",
    "border-image-slice",
    "border-image-width",
    "border-image-outset",
    "border-image-repeat"
  ],
  "border-inline-end": [
    "border-inline-end-width",
    "border-inline-end-style",
    "border-inline-end-color"
  ],
  "border-inline-start": [
    "border-inline-start-width",
    "border-inline-start-style",
    "border-inline-start-color"
  ],
  "column-rule": [
    "column-rule-width",
    "column-rule-style",
    "column-rule-color"
  ],
  columns: ["column-width", "column-count"],
  flex: ["flex-grow", "flex-shrink", "flex-basis"],
  "flex-flow": ["flex-direction", "flex-wrap"],
  grid: [
    "grid-template-rows",
    "grid-template-columns",
    "grid-template-areas",
    "grid-auto-rows",
    "grid-auto-columns",
    "grid-auto-flow",
    "grid-column-gap",
    "grid-row-gap"
  ],
  "grid-area": [
    "grid-row-start",
    "grid-column-start",
    "grid-row-end",
    "grid-column-end"
  ],
  "grid-column": ["grid-column-start", "grid-column-end"],
  "grid-gap": ["grid-row-gap", "grid-column-gap"],
  "grid-row": ["grid-row-start", "grid-row-end"],
  "grid-template": [
    "grid-template-columns",
    "grid-template-rows",
    "grid-template-areas"
  ],
  outline: ["outline-color", "outline-style", "outline-width"],
  "text-decoration": [
    "text-decoration-color",
    "text-decoration-style",
    "text-decoration-line"
  ],
  "text-emphasis": ["text-emphasis-style", "text-emphasis-color"],
  mask: [
    "mask-image",
    "mask-mode",
    "mask-position",
    "mask-size",
    "mask-repeat",
    "mask-origin",
    "mask-clip",
    "mask-composite"
  ]
};

},{}],893:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const postcss = require("postcss");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "at-rule-blacklist";

const messages = ruleMessages(ruleName, {
  rejected: name => `Unexpected at-rule "${name}"`
});

const rule = function(blacklistInput) {
  // To allow for just a string as a parameter (not only arrays of strings)
  const blacklist = [].concat(blacklistInput);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: blacklist,
      possible: [_.isString]
    });
    if (!validOptions) {
      return;
    }

    root.walkAtRules(atRule => {
      const name = atRule.name;

      if (
        blacklist.indexOf(postcss.vendor.unprefixed(name).toLowerCase()) === -1
      ) {
        return;
      }

      report({
        message: messages.rejected(name),
        node: atRule,
        result,
        ruleName
      });
    });
  };
};

rule.primaryOptionArray = true;

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"postcss":828}],894:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const addEmptyLineBefore = require("../../utils/addEmptyLineBefore");
const getPreviousNonSharedLineCommentNode = require("../../utils/getPreviousNonSharedLineCommentNode");
const hasEmptyLine = require("../../utils/hasEmptyLine");
const isAfterCommentLine = require("../../utils/isAfterCommentLine");
const isBlocklessAtRuleAfterBlocklessAtRule = require("../../utils/isBlocklessAtRuleAfterBlocklessAtRule");
const isBlocklessAtRuleAfterSameNameBlocklessAtRule = require("../../utils/isBlocklessAtRuleAfterSameNameBlocklessAtRule");
const isFirstNested = require("../../utils/isFirstNested");
const optionsMatches = require("../../utils/optionsMatches");
const removeEmptyLinesBefore = require("../../utils/removeEmptyLinesBefore");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "at-rule-empty-line-before";

const messages = ruleMessages(ruleName, {
  expected: "Expected empty line before at-rule",
  rejected: "Unexpected empty line before at-rule"
});

const rule = function(expectation, options, context) {
  return (root, result) => {
    const validOptions = validateOptions(
      result,
      ruleName,
      {
        actual: expectation,
        possible: ["always", "never"]
      },
      {
        actual: options,
        possible: {
          except: [
            "after-same-name",
            "inside-block",
            "blockless-after-same-name-blockless",
            "blockless-after-blockless",
            "first-nested"
          ],
          ignore: [
            "after-comment",
            "inside-block",
            "blockless-after-same-name-blockless",
            "blockless-after-blockless"
          ],
          ignoreAtRules: [_.isString]
        },
        optional: true
      }
    );
    if (!validOptions) {
      return;
    }

    root.walkAtRules(atRule => {
      const isNested = atRule.parent !== root;

      // Ignore the first node
      if (atRule === root.first) {
        return;
      }

      // Return early if at-rule is to be ignored
      if (optionsMatches(options, "ignoreAtRules", atRule.name)) {
        return;
      }

      // Optionally ignore the expectation if the node is blockless
      if (
        optionsMatches(options, "ignore", "blockless-after-blockless") &&
        isBlocklessAtRuleAfterBlocklessAtRule(atRule)
      ) {
        return;
      }

      // Optionally ignore the expection if the node is blockless
      // and following another blockless at-rule with the same name
      if (
        optionsMatches(
          options,
          "ignore",
          "blockless-after-same-name-blockless"
        ) &&
        isBlocklessAtRuleAfterSameNameBlocklessAtRule(atRule)
      ) {
        return;
      }

      // Optionally ignore the expectation if the node is inside a block
      if (optionsMatches(options, "ignore", "inside-block") && isNested) {
        return;
      }

      // Optionally ignore the expectation if a comment precedes this node
      if (
        optionsMatches(options, "ignore", "after-comment") &&
        isAfterCommentLine(atRule)
      ) {
        return;
      }

      const hasEmptyLineBefore = hasEmptyLine(atRule.raws.before);
      let expectEmptyLineBefore = expectation === "always" ? true : false;

      // Optionally reverse the expectation if any exceptions apply
      if (
        (optionsMatches(options, "except", "after-same-name") &&
          isAtRuleAfterSameNameAtRule(atRule)) ||
        (optionsMatches(options, "except", "inside-block") && isNested) ||
        (optionsMatches(options, "except", "first-nested") &&
          isFirstNested(atRule)) ||
        (optionsMatches(options, "except", "blockless-after-blockless") &&
          isBlocklessAtRuleAfterBlocklessAtRule(atRule)) ||
        (optionsMatches(
          options,
          "except",
          "blockless-after-same-name-blockless"
        ) &&
          isBlocklessAtRuleAfterSameNameBlocklessAtRule(atRule))
      ) {
        expectEmptyLineBefore = !expectEmptyLineBefore;
      }

      // Return if the expectation is met
      if (expectEmptyLineBefore === hasEmptyLineBefore) {
        return;
      }

      // Fix
      if (context.fix) {
        if (expectEmptyLineBefore) {
          addEmptyLineBefore(atRule, context.newline);
        } else {
          removeEmptyLinesBefore(atRule, context.newline);
        }

        return;
      }

      const message = expectEmptyLineBefore
        ? messages.expected
        : messages.rejected;

      report({ message, node: atRule, result, ruleName });
    });
  };
};

function isAtRuleAfterSameNameAtRule(atRule) {
  const previousNode = getPreviousNonSharedLineCommentNode(atRule);
  return (
    previousNode &&
    previousNode.type === "atrule" &&
    previousNode.name === atRule.name
  );
}

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/addEmptyLineBefore":1070,"../../utils/getPreviousNonSharedLineCommentNode":1089,"../../utils/hasEmptyLine":1094,"../../utils/isAfterCommentLine":1100,"../../utils/isBlocklessAtRuleAfterBlocklessAtRule":1103,"../../utils/isBlocklessAtRuleAfterSameNameBlocklessAtRule":1104,"../../utils/isFirstNested":1112,"../../utils/optionsMatches":1137,"../../utils/removeEmptyLinesBefore":1140,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692}],895:[function(require,module,exports){
"use strict";

const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "at-rule-name-case";

const messages = ruleMessages(ruleName, {
  expected: (actual, expected) => `Expected "${actual}" to be "${expected}"`
});

const rule = function(expectation, options, context) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["lower", "upper"]
    });
    if (!validOptions) {
      return;
    }

    root.walkAtRules(atRule => {
      const name = atRule.name;

      const expectedName =
        expectation === "lower" ? name.toLowerCase() : name.toUpperCase();

      if (name === expectedName) {
        return;
      }

      if (context.fix) {
        atRule.name = expectedName;
        return;
      }

      report({
        message: messages.expected(name, expectedName),
        node: atRule,
        ruleName,
        result
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144}],896:[function(require,module,exports){
"use strict";

const atRuleNameSpaceChecker = require("../atRuleNameSpaceChecker");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "at-rule-name-newline-after";

const messages = ruleMessages(ruleName, {
  expectedAfter: name => `Expected newline after at-rule name "${name}"`
});

const rule = function(expectation) {
  const checker = whitespaceChecker("newline", expectation, messages);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "always-multi-line"]
    });
    if (!validOptions) {
      return;
    }

    atRuleNameSpaceChecker({
      root,
      result,
      locationChecker: checker.afterOneOnly,
      checkedRuleName: ruleName
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145,"../atRuleNameSpaceChecker":903}],897:[function(require,module,exports){
"use strict";

const atRuleNameSpaceChecker = require("../atRuleNameSpaceChecker");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "at-rule-name-space-after";

const messages = ruleMessages(ruleName, {
  expectedAfter: name => `Expected single space after at-rule name "${name}"`
});

const rule = function(expectation) {
  const checker = whitespaceChecker("space", expectation, messages);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "always-single-line"]
    });
    if (!validOptions) {
      return;
    }

    atRuleNameSpaceChecker({
      root,
      result,
      locationChecker: checker.after,
      checkedRuleName: ruleName
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145,"../atRuleNameSpaceChecker":903}],898:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const keywordSets = require("../../reference/keywordSets");
const optionsMatches = require("../../utils/optionsMatches");
const postcss = require("postcss");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "at-rule-no-unknown";

const messages = ruleMessages(ruleName, {
  rejected: atRule => `Unexpected unknown at-rule "${atRule}"`
});

const rule = function(actual, options) {
  return (root, result) => {
    const validOptions = validateOptions(
      result,
      ruleName,
      { actual },
      {
        actual: options,
        possible: {
          ignoreAtRules: [_.isString]
        },
        optional: true
      }
    );

    if (!validOptions) {
      return;
    }

    root.walkAtRules(atRule => {
      const name = atRule.name;

      // Return early if at-rule is to be ignored
      if (optionsMatches(options, "ignoreAtRules", atRule.name)) {
        return;
      }

      if (
        postcss.vendor.prefix(name) ||
        keywordSets.atRules.has(name.toLowerCase())
      ) {
        return;
      }

      report({
        message: messages.rejected(`@${name}`),
        node: atRule,
        ruleName,
        result
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../reference/keywordSets":888,"../../utils/optionsMatches":1137,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"postcss":828}],899:[function(require,module,exports){
"use strict";

const isAutoprefixable = require("../../utils/isAutoprefixable");
const isStandardSyntaxAtRule = require("../../utils/isStandardSyntaxAtRule");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "at-rule-no-vendor-prefix";

const messages = ruleMessages(ruleName, {
  rejected: p => `Unexpected vendor-prefixed at-rule "@${p}"`
});

const rule = function(actual) {
  return function(root, result) {
    const validOptions = validateOptions(result, ruleName, { actual });
    if (!validOptions) {
      return;
    }

    root.walkAtRules(atRule => {
      if (!isStandardSyntaxAtRule(atRule)) {
        return;
      }

      const name = atRule.name;

      if (name[0] !== "-") {
        return;
      }

      if (!isAutoprefixable.atRuleName(name)) {
        return;
      }

      report({
        message: messages.rejected(name),
        node: atRule,
        result,
        ruleName
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isAutoprefixable":1102,"../../utils/isStandardSyntaxAtRule":1120,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144}],900:[function(require,module,exports){
"use strict";

const hasBlock = require("../../utils/hasBlock");
const nextNonCommentNode = require("../../utils/nextNonCommentNode");
const rawNodeString = require("../../utils/rawNodeString");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "at-rule-semicolon-newline-after";

const messages = ruleMessages(ruleName, {
  expectedAfter: () => 'Expected newline after ";"'
});

const rule = function(actual) {
  const checker = whitespaceChecker("newline", actual, messages);

  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual,
      possible: ["always"]
    });
    if (!validOptions) {
      return;
    }

    root.walkAtRules(atRule => {
      const nextNode = atRule.next();
      if (!nextNode) {
        return;
      }
      if (hasBlock(atRule)) {
        return;
      }

      // Allow an end-of-line comment
      const nodeToCheck = nextNonCommentNode(nextNode);
      if (!nodeToCheck) {
        return;
      }

      checker.afterOneOnly({
        source: rawNodeString(nodeToCheck),
        index: -1,
        err: msg => {
          report({
            message: msg,
            node: atRule,
            index: atRule.toString().length + 1,
            result,
            ruleName
          });
        }
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/hasBlock":1092,"../../utils/nextNonCommentNode":1135,"../../utils/rawNodeString":1139,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145}],901:[function(require,module,exports){
"use strict";

const hasBlock = require("../../utils/hasBlock");
const rawNodeString = require("../../utils/rawNodeString");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "at-rule-semicolon-space-before";

const messages = ruleMessages(ruleName, {
  expectedBefore: () => 'Expected single space before ";"',
  rejectedBefore: () => 'Unexpected whitespace before ";"'
});

const rule = function(expectation) {
  const checker = whitespaceChecker("space", expectation, messages);

  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "never"]
    });
    if (!validOptions) {
      return;
    }

    root.walkAtRules(atRule => {
      if (hasBlock(atRule)) {
        return;
      }
      const nodeString = rawNodeString(atRule);

      checker.before({
        source: nodeString,
        index: nodeString.length,
        err: m => {
          report({
            message: m,
            node: atRule,
            index: nodeString.length - 1,
            result,
            ruleName
          });
        }
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/hasBlock":1092,"../../utils/rawNodeString":1139,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145}],902:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const postcss = require("postcss");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "at-rule-whitelist";

const messages = ruleMessages(ruleName, {
  rejected: name => `Unexpected at-rule "${name}"`
});

const rule = function(whitelistInput) {
  // To allow for just a string as a parameter (not only arrays of strings)
  const whitelist = [].concat(whitelistInput);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: whitelist,
      possible: [_.isString]
    });
    if (!validOptions) {
      return;
    }

    root.walkAtRules(atRule => {
      const name = atRule.name;

      if (
        whitelist.indexOf(postcss.vendor.unprefixed(name).toLowerCase()) !== -1
      ) {
        return;
      }

      report({
        message: messages.rejected(name),
        node: atRule,
        result,
        ruleName
      });
    });
  };
};

rule.primaryOptionArray = true;

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"postcss":828}],903:[function(require,module,exports){
"use strict";

const isStandardSyntaxAtRule = require("../utils/isStandardSyntaxAtRule");
const report = require("../utils/report");

module.exports = function(options) {
  options.root.walkAtRules(atRule => {
    if (!isStandardSyntaxAtRule(atRule)) {
      return;
    }

    checkColon(
      `@${atRule.name}${atRule.raws.afterName || ""}${atRule.params}`,
      atRule.name.length,
      atRule
    );
  });

  function checkColon(source, index, node) {
    options.locationChecker({
      source,
      index,
      err: m =>
        report({
          message: m,
          node,
          index,
          result: options.result,
          ruleName: options.checkedRuleName
        }),
      errTarget: `@${node.name}`
    });
  }
};

},{"../utils/isStandardSyntaxAtRule":1120,"../utils/report":1141}],904:[function(require,module,exports){
"use strict";

const blockString = require("../../utils/blockString");
const hasBlock = require("../../utils/hasBlock");
const hasEmptyBlock = require("../../utils/hasEmptyBlock");
const hasEmptyLine = require("../../utils/hasEmptyLine");
const isSingleLineString = require("../../utils/isSingleLineString");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "block-closing-brace-empty-line-before";

const messages = ruleMessages(ruleName, {
  expected: "Expected empty line before closing brace",
  rejected: "Unexpected empty line before closing brace"
});

const rule = function(expectation) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always-multi-line", "never"]
    });
    if (!validOptions) {
      return;
    }

    // Check both kinds of statements: rules and at-rules
    root.walkRules(check);
    root.walkAtRules(check);

    function check(statement) {
      // Return early if blockless or has empty block
      if (!hasBlock(statement) || hasEmptyBlock(statement)) {
        return;
      }

      // Get whitespace after ""}", ignoring extra semicolon
      const before = (statement.raws.after || "").replace(/;+/, "");
      if (before === undefined) {
        return;
      }

      // Calculate index
      const statementString = statement.toString();
      let index = statementString.length - 1;
      if (statementString[index - 1] === "\r") {
        index -= 1;
      }

      // Set expectation
      const expectEmptyLineBefore =
        expectation === "always-multi-line" &&
        !isSingleLineString(blockString(statement))
          ? true
          : false;

      // Check for at least one empty line
      const hasEmptyLineBefore = hasEmptyLine(before);

      // Return if the expectation is met
      if (expectEmptyLineBefore === hasEmptyLineBefore) {
        return;
      }

      const message = expectEmptyLineBefore
        ? messages.expected
        : messages.rejected;

      report({
        message,
        result,
        ruleName,
        node: statement,
        index
      });
    }
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/blockString":1073,"../../utils/hasBlock":1092,"../../utils/hasEmptyBlock":1093,"../../utils/hasEmptyLine":1094,"../../utils/isSingleLineString":1119,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144}],905:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const blockString = require("../../utils/blockString");
const hasBlock = require("../../utils/hasBlock");
const optionsMatches = require("../../utils/optionsMatches");
const rawNodeString = require("../../utils/rawNodeString");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "block-closing-brace-newline-after";

const messages = ruleMessages(ruleName, {
  expectedAfter: () => 'Expected newline after "}"',
  expectedAfterSingleLine: () =>
    'Expected newline after "}" of a single-line block',
  rejectedAfterSingleLine: () =>
    'Unexpected whitespace after "}" of a single-line block',
  expectedAfterMultiLine: () =>
    'Expected newline after "}" of a multi-line block',
  rejectedAfterMultiLine: () =>
    'Unexpected whitespace after "}" of a multi-line block'
});

const rule = function(expectation, options) {
  const checker = whitespaceChecker("newline", expectation, messages);
  return (root, result) => {
    const validOptions = validateOptions(
      result,
      ruleName,
      {
        actual: expectation,
        possible: [
          "always",
          "always-single-line",
          "never-single-line",
          "always-multi-line",
          "never-multi-line"
        ]
      },
      {
        actual: options,
        possible: {
          ignoreAtRules: [_.isString]
        },
        optional: true
      }
    );
    if (!validOptions) {
      return;
    }

    // Check both kinds of statements: rules and at-rules
    root.walkRules(check);
    root.walkAtRules(check);

    function check(statement) {
      if (!hasBlock(statement)) {
        return;
      }
      if (optionsMatches(options, "ignoreAtRules", statement.name)) {
        return;
      }

      const nextNode = statement.next();
      if (!nextNode) {
        return;
      }

      // Allow an end-of-line comment x spaces after the brace
      const nextNodeIsSingleLineComment =
        nextNode.type === "comment" &&
        !/[^ ]/.test(nextNode.raws.before || "") &&
        nextNode.toString().indexOf("\n") === -1;

      const nodeToCheck = nextNodeIsSingleLineComment
        ? nextNode.next()
        : nextNode;

      if (!nodeToCheck) {
        return;
      }

      let reportIndex = statement.toString().length;
      let source = rawNodeString(nodeToCheck);

      // Skip a semicolon at the beginning, if any
      if (source && source[0] === ";") {
        source = source.slice(1);
        reportIndex++;
      }

      // Only check one after, because there might be other
      // spaces handled by the indentation rule
      checker.afterOneOnly({
        source,
        index: -1,
        lineCheckStr: blockString(statement),
        err: msg => {
          report({
            message: msg,
            node: statement,
            index: reportIndex,
            result,
            ruleName
          });
        }
      });
    }
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/blockString":1073,"../../utils/hasBlock":1092,"../../utils/optionsMatches":1137,"../../utils/rawNodeString":1139,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145,"lodash":692}],906:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const blockString = require("../../utils/blockString");
const hasBlock = require("../../utils/hasBlock");
const hasEmptyBlock = require("../../utils/hasEmptyBlock");
const isSingleLineString = require("../../utils/isSingleLineString");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "block-closing-brace-newline-before";

const messages = ruleMessages(ruleName, {
  expectedBefore: 'Expected newline before "}"',
  expectedBeforeMultiLine: 'Expected newline before "}" of a multi-line block',
  rejectedBeforeMultiLine:
    'Unexpected whitespace before "}" of a multi-line block'
});

const rule = function(expectation) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "always-multi-line", "never-multi-line"]
    });
    if (!validOptions) {
      return;
    }

    // Check both kinds of statements: rules and at-rules
    root.walkRules(check);
    root.walkAtRules(check);

    function check(statement) {
      // Return early if blockless or has empty block
      if (!hasBlock(statement) || hasEmptyBlock(statement)) {
        return;
      }

      // Ignore extra semicolon
      const after = (statement.raws.after || "").replace(/;+/, "");
      if (after === undefined) {
        return;
      }

      const blockIsMultiLine = !isSingleLineString(blockString(statement));
      const statementString = statement.toString();

      let index = statementString.length - 2;
      if (statementString[index - 1] === "\r") {
        index -= 1;
      }

      // We're really just checking whether a
      // newline *starts* the block's final space -- between
      // the last declaration and the closing brace. We can
      // ignore any other whitespace between them, because that
      // will be checked by the indentation rule.
      if (!_.startsWith(after, "\n") && !_.startsWith(after, "\r\n")) {
        if (expectation === "always") {
          complain(messages.expectedBefore);
        } else if (blockIsMultiLine && expectation === "always-multi-line") {
          complain(messages.expectedBeforeMultiLine);
        }
      }

      if (
        after !== "" &&
        blockIsMultiLine &&
        expectation === "never-multi-line"
      ) {
        complain(messages.rejectedBeforeMultiLine);
      }

      function complain(message) {
        report({
          message,
          result,
          ruleName,
          node: statement,
          index
        });
      }
    }
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/blockString":1073,"../../utils/hasBlock":1092,"../../utils/hasEmptyBlock":1093,"../../utils/isSingleLineString":1119,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692}],907:[function(require,module,exports){
"use strict";

const blockString = require("../../utils/blockString");
const hasBlock = require("../../utils/hasBlock");
const rawNodeString = require("../../utils/rawNodeString");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "block-closing-brace-space-after";

const messages = ruleMessages(ruleName, {
  expectedAfter: () => 'Expected single space after "}"',
  rejectedAfter: () => 'Unexpected whitespace after "}"',
  expectedAfterSingleLine: () =>
    'Expected single space after "}" of a single-line block',
  rejectedAfterSingleLine: () =>
    'Unexpected whitespace after "}" of a single-line block',
  expectedAfterMultiLine: () =>
    'Expected single space after "}" of a multi-line block',
  rejectedAfterMultiLine: () =>
    'Unexpected whitespace after "}" of a multi-line block'
});

const rule = function(expectation) {
  const checker = whitespaceChecker("space", expectation, messages);

  return function(root, result) {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: [
        "always",
        "never",
        "always-single-line",
        "never-single-line",
        "always-multi-line",
        "never-multi-line"
      ]
    });
    if (!validOptions) {
      return;
    }

    // Check both kinds of statements: rules and at-rules
    root.walkRules(check);
    root.walkAtRules(check);

    function check(statement) {
      const nextNode = statement.next();
      if (!nextNode) {
        return;
      }
      if (!hasBlock(statement)) {
        return;
      }

      let reportIndex = statement.toString().length;
      let source = rawNodeString(nextNode);

      // Skip a semicolon at the beginning, if any
      if (source && source[0] === ";") {
        source = source.slice(1);
        reportIndex++;
      }

      checker.after({
        source,
        index: -1,
        lineCheckStr: blockString(statement),
        err: msg => {
          report({
            message: msg,
            node: statement,
            index: reportIndex,
            result,
            ruleName
          });
        }
      });
    }
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/blockString":1073,"../../utils/hasBlock":1092,"../../utils/rawNodeString":1139,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145}],908:[function(require,module,exports){
"use strict";

const blockString = require("../../utils/blockString");
const hasBlock = require("../../utils/hasBlock");
const hasEmptyBlock = require("../../utils/hasEmptyBlock");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "block-closing-brace-space-before";

const messages = ruleMessages(ruleName, {
  expectedBefore: () => 'Expected single space before "}"',
  rejectedBefore: () => 'Unexpected whitespace before "}"',
  expectedBeforeSingleLine: () =>
    'Expected single space before "}" of a single-line block',
  rejectedBeforeSingleLine: () =>
    'Unexpected whitespace before "}" of a single-line block',
  expectedBeforeMultiLine: () =>
    'Expected single space before "}" of a multi-line block',
  rejectedBeforeMultiLine: () =>
    'Unexpected whitespace before "}" of a multi-line block'
});

const rule = function(expectation) {
  const checker = whitespaceChecker("space", expectation, messages);

  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: [
        "always",
        "never",
        "always-single-line",
        "never-single-line",
        "always-multi-line",
        "never-multi-line"
      ]
    });
    if (!validOptions) {
      return;
    }

    // Check both kinds of statement: rules and at-rules
    root.walkRules(check);
    root.walkAtRules(check);

    function check(statement) {
      // Return early if blockless or has empty block
      if (!hasBlock(statement) || hasEmptyBlock(statement)) {
        return;
      }

      const source = blockString(statement);
      const statementString = statement.toString();

      let index = statementString.length - 2;
      if (statementString[index - 1] === "\r") {
        index -= 1;
      }

      checker.before({
        source,
        index: source.length - 1,
        err: msg => {
          report({
            message: msg,
            node: statement,
            index,
            result,
            ruleName
          });
        }
      });
    }
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/blockString":1073,"../../utils/hasBlock":1092,"../../utils/hasEmptyBlock":1093,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145}],909:[function(require,module,exports){
"use strict";

const beforeBlockString = require("../../utils/beforeBlockString");
const hasEmptyBlock = require("../../utils/hasEmptyBlock");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "block-no-empty";

const messages = ruleMessages(ruleName, {
  rejected: "Unexpected empty block"
});

const rule = function(actual) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, { actual });
    if (!validOptions) {
      return;
    }

    // Check both kinds of statements: rules and at-rules
    root.walkRules(check);
    root.walkAtRules(check);

    function check(statement) {
      if (!hasEmptyBlock(statement)) {
        return;
      }

      let index = beforeBlockString(statement, { noRawBefore: true }).length;

      // For empty blocks when using SugarSS parser
      if (statement.raws.between === undefined) {
        index--;
      }

      report({
        message: messages.rejected,
        node: statement,
        index,
        result,
        ruleName
      });
    }
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/beforeBlockString":1072,"../../utils/hasEmptyBlock":1093,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144}],910:[function(require,module,exports){
"use strict";

const beforeBlockString = require("../../utils/beforeBlockString");
const blockString = require("../../utils/blockString");
const hasBlock = require("../../utils/hasBlock");
const hasEmptyBlock = require("../../utils/hasEmptyBlock");
const nextNonCommentNode = require("../../utils/nextNonCommentNode");
const rawNodeString = require("../../utils/rawNodeString");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "block-opening-brace-newline-after";

const messages = ruleMessages(ruleName, {
  expectedAfter: () => 'Expected newline after "{"',
  expectedAfterMultiLine: () =>
    'Expected newline after "{" of a multi-line block',
  rejectedAfterMultiLine: () =>
    'Unexpected whitespace after "{" of a multi-line block'
});

const rule = function(expectation) {
  const checker = whitespaceChecker("newline", expectation, messages);

  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "always-multi-line", "never-multi-line"]
    });
    if (!validOptions) {
      return;
    }

    // Check both kinds of statement: rules and at-rules
    root.walkRules(check);
    root.walkAtRules(check);

    function check(statement) {
      // Return early if blockless or has an empty block
      if (!hasBlock(statement) || hasEmptyBlock(statement)) {
        return;
      }

      // Allow an end-of-line comment
      const nodeToCheck = nextNonCommentNode(statement.first);
      if (!nodeToCheck) {
        return;
      }

      checker.afterOneOnly({
        source: rawNodeString(nodeToCheck),
        index: -1,
        lineCheckStr: blockString(statement),
        err: m => {
          report({
            message: m,
            node: statement,
            index:
              beforeBlockString(statement, { noRawBefore: true }).length + 1,
            result,
            ruleName
          });
        }
      });
    }
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/beforeBlockString":1072,"../../utils/blockString":1073,"../../utils/hasBlock":1092,"../../utils/hasEmptyBlock":1093,"../../utils/nextNonCommentNode":1135,"../../utils/rawNodeString":1139,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145}],911:[function(require,module,exports){
"use strict";

const beforeBlockString = require("../../utils/beforeBlockString");
const blockString = require("../../utils/blockString");
const hasBlock = require("../../utils/hasBlock");
const hasEmptyBlock = require("../../utils/hasEmptyBlock");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "block-opening-brace-newline-before";

const messages = ruleMessages(ruleName, {
  expectedBefore: () => 'Expected newline before "{"',
  expectedBeforeSingleLine: () =>
    'Expected newline before "{" of a single-line block',
  rejectedBeforeSingleLine: () =>
    'Unexpected whitespace before "{" of a single-line block',
  expectedBeforeMultiLine: () =>
    'Expected newline before "{" of a multi-line block',
  rejectedBeforeMultiLine: () =>
    'Unexpected whitespace before "{" of a multi-line block'
});

const rule = function(expectation) {
  const checker = whitespaceChecker("newline", expectation, messages);

  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: [
        "always",
        "always-single-line",
        "never-single-line",
        "always-multi-line",
        "never-multi-line"
      ]
    });
    if (!validOptions) {
      return;
    }

    // Check both kinds of statement: rules and at-rules
    root.walkRules(check);
    root.walkAtRules(check);

    function check(statement) {
      // Return early if blockless or has an empty block
      if (!hasBlock(statement) || hasEmptyBlock(statement)) {
        return;
      }

      const source = beforeBlockString(statement);
      const beforeBraceNoRaw = beforeBlockString(statement, {
        noRawBefore: true
      });

      let index = beforeBraceNoRaw.length - 1;
      if (beforeBraceNoRaw[index - 1] === "\r") {
        index -= 1;
      }

      checker.beforeAllowingIndentation({
        lineCheckStr: blockString(statement),
        source,
        index: source.length,
        err: m => {
          report({
            message: m,
            node: statement,
            index,
            result,
            ruleName
          });
        }
      });
    }
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/beforeBlockString":1072,"../../utils/blockString":1073,"../../utils/hasBlock":1092,"../../utils/hasEmptyBlock":1093,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145}],912:[function(require,module,exports){
"use strict";

const beforeBlockString = require("../../utils/beforeBlockString");
const blockString = require("../../utils/blockString");
const hasBlock = require("../../utils/hasBlock");
const hasEmptyBlock = require("../../utils/hasEmptyBlock");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "block-opening-brace-space-after";

const messages = ruleMessages(ruleName, {
  expectedAfter: () => 'Expected single space after "{"',
  rejectedAfter: () => 'Unexpected whitespace after "{"',
  expectedAfterSingleLine: () =>
    'Expected single space after "{" of a single-line block',
  rejectedAfterSingleLine: () =>
    'Unexpected whitespace after "{" of a single-line block',
  expectedAfterMultiLine: () =>
    'Expected single space after "{" of a multi-line block',
  rejectedAfterMultiLine: () =>
    'Unexpected whitespace after "{" of a multi-line block'
});

const rule = function(expectation) {
  const checker = whitespaceChecker("space", expectation, messages);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: [
        "always",
        "never",
        "always-single-line",
        "never-single-line",
        "always-multi-line",
        "never-multi-line"
      ]
    });
    if (!validOptions) {
      return;
    }

    // Check both kinds of statements: rules and at-rules
    root.walkRules(check);
    root.walkAtRules(check);

    function check(statement) {
      // Return early if blockless or has an empty block
      if (!hasBlock(statement) || hasEmptyBlock(statement)) {
        return;
      }

      checker.after({
        source: blockString(statement),
        index: 0,
        err: m => {
          report({
            message: m,
            node: statement,
            index:
              beforeBlockString(statement, { noRawBefore: true }).length + 1,
            result,
            ruleName
          });
        }
      });
    }
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/beforeBlockString":1072,"../../utils/blockString":1073,"../../utils/hasBlock":1092,"../../utils/hasEmptyBlock":1093,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145}],913:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const beforeBlockString = require("../../utils/beforeBlockString");
const blockString = require("../../utils/blockString");
const hasBlock = require("../../utils/hasBlock");
const hasEmptyBlock = require("../../utils/hasEmptyBlock");
const optionsMatches = require("../../utils/optionsMatches");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "block-opening-brace-space-before";

const messages = ruleMessages(ruleName, {
  expectedBefore: () => 'Expected single space before "{"',
  rejectedBefore: () => 'Unexpected whitespace before "{"',
  expectedBeforeSingleLine: () =>
    'Expected single space before "{" of a single-line block',
  rejectedBeforeSingleLine: () =>
    'Unexpected whitespace before "{" of a single-line block',
  expectedBeforeMultiLine: () =>
    'Expected single space before "{" of a multi-line block',
  rejectedBeforeMultiLine: () =>
    'Unexpected whitespace before "{" of a multi-line block'
});

const rule = function(expectation, options) {
  const checker = whitespaceChecker("space", expectation, messages);
  return (root, result) => {
    const validOptions = validateOptions(
      result,
      ruleName,
      {
        actual: expectation,
        possible: [
          "always",
          "never",
          "always-single-line",
          "never-single-line",
          "always-multi-line",
          "never-multi-line"
        ]
      },
      {
        actual: options,
        possible: {
          ignoreAtRules: [_.isString]
        },
        optional: true
      }
    );
    if (!validOptions) {
      return;
    }

    // Check both kinds of statements: rules and at-rules
    root.walkRules(check);
    root.walkAtRules(check);

    function check(statement) {
      // Return early if blockless or has an empty block
      if (!hasBlock(statement) || hasEmptyBlock(statement)) {
        return;
      }

      // Return early if at-rule is to be ignored
      if (optionsMatches(options, "ignoreAtRules", statement.name)) {
        return;
      }

      const source = beforeBlockString(statement);
      const beforeBraceNoRaw = beforeBlockString(statement, {
        noRawBefore: true
      });

      let index = beforeBraceNoRaw.length - 1;
      if (beforeBraceNoRaw[index - 1] === "\r") {
        index -= 1;
      }

      checker.before({
        source,
        index: source.length,
        lineCheckStr: blockString(statement),
        err: m => {
          report({
            message: m,
            node: statement,
            index,
            result,
            ruleName
          });
        }
      });
    }
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/beforeBlockString":1072,"../../utils/blockString":1073,"../../utils/hasBlock":1092,"../../utils/hasEmptyBlock":1093,"../../utils/optionsMatches":1137,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145,"lodash":692}],914:[function(require,module,exports){
"use strict";

const blurFunctionArguments = require("../../utils/blurFunctionArguments");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const styleSearch = require("style-search");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "color-hex-case";

const messages = ruleMessages(ruleName, {
  expected: (actual, expected) => `Expected "${actual}" to be "${expected}"`
});

const rule = function(expectation, options, context) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["lower", "upper"]
    });
    if (!validOptions) {
      return;
    }

    root.walkDecls(decl => {
      const declString = blurFunctionArguments(decl.toString(), "url");
      const fixPositions = [];

      styleSearch({ source: declString, target: "#" }, match => {
        const hexMatch = /^#[0-9A-Za-z]+/.exec(
          declString.substr(match.startIndex)
        );
        if (!hexMatch) {
          return;
        }

        const hexValue = hexMatch[0];
        const hexValueLower = hexValue.toLowerCase();
        const hexValueUpper = hexValue.toUpperCase();
        const expectedHex =
          expectation === "lower" ? hexValueLower : hexValueUpper;

        if (hexValue === expectedHex) {
          return;
        }

        if (context.fix) {
          fixPositions.unshift({
            expectedHex,
            currentHex: hexValue,
            startIndex: match.startIndex
          });

          return;
        }

        report({
          message: messages.expected(hexValue, expectedHex),
          node: decl,
          index: match.startIndex,
          result,
          ruleName
        });
      });

      if (fixPositions.length) {
        const declProp = decl.prop;
        const declBetween = decl.raws.between;

        fixPositions.forEach(function(fixPosition) {
          // 1 — it's a # length
          decl.value = replaceHex(
            decl.value,
            fixPosition.currentHex,
            fixPosition.expectedHex,
            fixPosition.startIndex - declProp.length - declBetween.length - 1
          );
        });
      }
    });
  };
};

function replaceHex(input, searchString, replaceString, startIndex) {
  const offset = startIndex + 1;
  const stringStart = input.slice(0, offset);
  const stringEnd = input.slice(offset + searchString.length);

  return stringStart + replaceString + stringEnd;
}

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/blurFunctionArguments":1075,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"style-search":870}],915:[function(require,module,exports){
"use strict";

const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const styleSearch = require("style-search");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "color-hex-length";

const messages = ruleMessages(ruleName, {
  expected: (actual, expected) => `Expected "${actual}" to be "${expected}"`
});

const rule = function(expectation) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["short", "long"]
    });
    if (!validOptions) {
      return;
    }

    root.walkDecls(decl => {
      const declString = decl.toString();

      styleSearch({ source: declString, target: "#" }, match => {
        const hexMatch = /^#[0-9A-Za-z]+/.exec(
          declString.substr(match.startIndex)
        );
        if (!hexMatch) {
          return;
        }

        const hexValue = hexMatch[0];

        if (
          expectation === "long" &&
          hexValue.length !== 4 &&
          hexValue.length !== 5
        ) {
          return;
        }

        if (
          expectation === "short" &&
          (hexValue.length < 6 || !canShrink(hexValue))
        ) {
          return;
        }

        const variant = expectation === "long" ? longer : shorter;

        report({
          message: messages.expected(hexValue, variant(hexValue)),
          node: decl,
          index: match.startIndex,
          result,
          ruleName
        });
      });
    });
  };
};

function canShrink(hex) {
  hex = hex.toLowerCase();

  return (
    hex[1] === hex[2] &&
    hex[3] === hex[4] &&
    hex[5] === hex[6] &&
    (hex.length === 7 || (hex.length === 9 && hex[7] === hex[8]))
  );
}

function shorter(hex) {
  let hexVariant = "#";
  for (let i = 1; i < hex.length; i = i + 2) {
    hexVariant += hex[i];
  }
  return hexVariant;
}

function longer(hex) {
  let hexVariant = "#";
  for (let i = 1; i < hex.length; i++) {
    hexVariant += hex[i] + hex[i];
  }
  return hexVariant;
}

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"style-search":870}],916:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const declarationValueIndex = require("../../utils/declarationValueIndex");
const isStandardSyntaxFunction = require("../../utils/isStandardSyntaxFunction");
const isStandardSyntaxValue = require("../../utils/isStandardSyntaxValue");
const keywordSets = require("../../reference/keywordSets");
const namedColorData = require("../../reference/namedColorData");
const optionsMatches = require("../../utils/optionsMatches");
const propertySets = require("../../reference/propertySets");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const valueParser = require("postcss-value-parser");

const ruleName = "color-named";

const messages = ruleMessages(ruleName, {
  expected: (named, original) => `Expected "${original}" to be "${named}"`,
  rejected: named => `Unexpected named color "${named}"`
});

// Todo tested on case insensivity
const NODE_TYPES = ["word", "function"];

const rule = function(expectation, options) {
  return (root, result) => {
    const validOptions = validateOptions(
      result,
      ruleName,
      {
        actual: expectation,
        possible: ["never", "always-where-possible"]
      },
      {
        actual: options,
        possible: {
          ignoreProperties: [_.isString],
          ignore: ["inside-function"]
        },
        optional: true
      }
    );

    if (!validOptions) {
      return;
    }

    const namedColors = Object.keys(namedColorData);

    root.walkDecls(decl => {
      if (propertySets.acceptCustomIdents.has(decl.prop)) {
        return;
      }

      // Return early if the property is to be ignored
      if (optionsMatches(options, "ignoreProperties", decl.prop)) {
        return;
      }

      valueParser(decl.value).walk(node => {
        const value = node.value,
          type = node.type,
          sourceIndex = node.sourceIndex;

        if (
          optionsMatches(options, "ignore", "inside-function") &&
          type === "function"
        ) {
          return false;
        }

        if (!isStandardSyntaxFunction(node)) {
          return false;
        }

        if (!isStandardSyntaxValue(value)) {
          return;
        }
        // Return early if neither a word nor a function
        if (NODE_TYPES.indexOf(type) === -1) {
          return;
        }

        // Check for named colors for "never" option
        if (
          expectation === "never" &&
          type === "word" &&
          namedColors.indexOf(value.toLowerCase()) !== -1
        ) {
          complain(
            messages.rejected(value),
            decl,
            declarationValueIndex(decl) + sourceIndex
          );
          return;
        }

        // Check "always-where-possible" option ...
        if (expectation !== "always-where-possible") {
          return;
        }

        // First by checking for alternative color function representations ...
        if (
          type === "function" &&
          keywordSets.colorFunctionNames.has(value.toLowerCase())
        ) {
          // Remove all spaces to match what's in `representations`
          const normalizedFunctionString = valueParser
            .stringify(node)
            .replace(/\s+/g, "");
          let namedColor;
          for (let i = 0, l = namedColors.length; i < l; i++) {
            namedColor = namedColors[i];
            if (
              namedColorData[namedColor].func.indexOf(
                normalizedFunctionString.toLowerCase()
              ) !== -1
            ) {
              complain(
                messages.expected(namedColor, normalizedFunctionString),
                decl,
                declarationValueIndex(decl) + sourceIndex
              );
              return; // Exit as soon as a problem is found
            }
          }
          return;
        }

        // Then by checking for alternative hex representations
        let namedColor;
        for (let i = 0, l = namedColors.length; i < l; i++) {
          namedColor = namedColors[i];
          if (
            namedColorData[namedColor].hex.indexOf(value.toLowerCase()) !== -1
          ) {
            complain(
              messages.expected(namedColor, value),
              decl,
              declarationValueIndex(decl) + sourceIndex
            );
            return; // Exit as soon as a problem is found
          }
        }
      });
    });

    function complain(message, node, index) {
      report({
        result,
        ruleName,
        message,
        node,
        index
      });
    }
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../reference/keywordSets":888,"../../reference/namedColorData":889,"../../reference/propertySets":890,"../../utils/declarationValueIndex":1080,"../../utils/isStandardSyntaxFunction":1122,"../../utils/isStandardSyntaxValue":1129,"../../utils/optionsMatches":1137,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"postcss-value-parser":811}],917:[function(require,module,exports){
"use strict";

const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const styleSearch = require("style-search");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "color-no-hex";

const messages = ruleMessages(ruleName, {
  rejected: hex => `Unexpected hex color "${hex}"`
});

const rule = function(actual) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, { actual });
    if (!validOptions) {
      return;
    }

    root.walkDecls(decl => {
      const declString = decl.toString();

      styleSearch({ source: declString, target: "#" }, match => {
        // If there's not a colon, comma, or whitespace character before, we'll assume this is
        // not intended to be a hex color, but is instead something like the
        // hash in a url() argument
        if (!/[:,\s]/.test(declString[match.startIndex - 1])) {
          return;
        }

        const hexMatch = /^#[0-9A-Za-z]+/.exec(
          declString.substr(match.startIndex)
        );
        if (!hexMatch) {
          return;
        }
        const hexValue = hexMatch[0];

        report({
          message: messages.rejected(hexValue),
          node: decl,
          index: match.startIndex,
          result,
          ruleName
        });
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"style-search":870}],918:[function(require,module,exports){
"use strict";

const isValidHex = require("../../utils/isValidHex");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const styleSearch = require("style-search");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "color-no-invalid-hex";

const messages = ruleMessages(ruleName, {
  rejected: hex => `Unexpected invalid hex color "${hex}"`
});

const rule = function(actual) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, { actual });
    if (!validOptions) {
      return;
    }

    root.walkDecls(decl => {
      const declString = decl.toString();

      styleSearch({ source: declString, target: "#" }, match => {
        // If there's not a colon, comma, or whitespace character before, we'll assume this is
        // not intended to be a hex color, but is instead something like the
        // hash in a url() argument
        if (!/[:,\s]/.test(declString[match.startIndex - 1])) {
          return;
        }

        const hexMatch = /^#[0-9A-Za-z]+/.exec(
          declString.substr(match.startIndex)
        );
        if (!hexMatch) {
          return;
        }

        const hexValue = hexMatch[0];
        if (isValidHex(hexValue)) {
          return;
        }

        report({
          message: messages.rejected(hexValue),
          node: decl,
          index: match.startIndex,
          result,
          ruleName
        });
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isValidHex":1131,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"style-search":870}],919:[function(require,module,exports){
"use strict";

const addEmptyLineBefore = require("../../utils/addEmptyLineBefore");
const hasEmptyLine = require("../../utils/hasEmptyLine");
const isAfterCommentLine = require("../../utils/isAfterCommentLine");
const isFirstNested = require("../../utils/isFirstNested");
const isSharedLineComment = require("../../utils/isSharedLineComment");
const optionsMatches = require("../../utils/optionsMatches");
const removeEmptyLinesBefore = require("../../utils/removeEmptyLinesBefore");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "comment-empty-line-before";

const messages = ruleMessages(ruleName, {
  expected: "Expected empty line before comment",
  rejected: "Unexpected empty line before comment"
});

const stylelintCommandPrefix = "stylelint-";

const rule = function(expectation, options, context) {
  return (root, result) => {
    const validOptions = validateOptions(
      result,
      ruleName,
      {
        actual: expectation,
        possible: ["always", "never"]
      },
      {
        actual: options,
        possible: {
          except: ["first-nested"],
          ignore: ["stylelint-commands", "after-comment"]
        },
        optional: true
      }
    );
    if (!validOptions) {
      return;
    }

    root.walkComments(comment => {
      // Ignore the first node
      if (comment === root.first) {
        return;
      }

      // Optionally ignore stylelint commands
      if (
        comment.text.indexOf(stylelintCommandPrefix) === 0 &&
        optionsMatches(options, "ignore", "stylelint-commands")
      ) {
        return;
      }

      // Optionally ignore newlines between comments
      if (
        optionsMatches(options, "ignore", "after-comment") &&
        isAfterCommentLine(comment)
      ) {
        return;
      }

      // Ignore shared-line comments
      if (isSharedLineComment(comment)) {
        return;
      }

      // Ignore SCSS comments
      if (comment.raws.inline || comment.inline) {
        return;
      }

      const expectEmptyLineBefore = (() => {
        if (
          optionsMatches(options, "except", "first-nested") &&
          isFirstNested(comment)
        ) {
          return false;
        }
        return expectation === "always";
      })();

      const before = comment.raws.before || "";
      const hasEmptyLineBefore = hasEmptyLine(before);

      // Return if the expectation is met
      if (expectEmptyLineBefore === hasEmptyLineBefore) {
        return;
      }

      // Fix
      if (context.fix) {
        if (expectEmptyLineBefore) {
          addEmptyLineBefore(comment, context.newline);
        } else {
          removeEmptyLinesBefore(comment, context.newline);
        }

        return;
      }

      const message = expectEmptyLineBefore
        ? messages.expected
        : messages.rejected;

      report({
        message,
        node: comment,
        result,
        ruleName
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/addEmptyLineBefore":1070,"../../utils/hasEmptyLine":1094,"../../utils/isAfterCommentLine":1100,"../../utils/isFirstNested":1112,"../../utils/isSharedLineComment":1118,"../../utils/optionsMatches":1137,"../../utils/removeEmptyLinesBefore":1140,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144}],920:[function(require,module,exports){
"use strict";

const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "comment-no-empty";

const messages = ruleMessages(ruleName, {
  rejected: "Unexpected empty comment"
});

const rule = function(actual) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, { actual });
    if (!validOptions) {
      return;
    }

    root.walkComments(comment => {
      // To ignore inline SCSS comments
      if (comment.raws.inline || comment.inline) {
        return;
      }

      // To ignore comments that are not empty
      if (comment.text && comment.text.length !== 0) {
        return;
      }

      report({
        message: messages.rejected,
        node: comment,
        result,
        ruleName
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144}],921:[function(require,module,exports){
"use strict";

const isWhitespace = require("../../utils/isWhitespace");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "comment-whitespace-inside";

const messages = ruleMessages(ruleName, {
  expectedOpening: 'Expected whitespace after "/*"',
  rejectedOpening: 'Unexpected whitespace after "/*"',
  expectedClosing: 'Expected whitespace before "*/"',
  rejectedClosing: 'Unexpected whitespace before "*/"'
});

const rule = function(expectation) {
  return function(root, result) {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "never"]
    });
    if (!validOptions) {
      return;
    }

    root.walkComments(function(comment) {
      if (comment.raws.inline || comment.inline) {
        return;
      }

      const rawComment = comment.toString();
      const firstFourChars = rawComment.substr(0, 4);

      // Return early if sourcemap or copyright comment
      if (/^\/\*[#!]\s/.test(firstFourChars)) {
        return;
      }

      const leftMatches = rawComment.match(/(^\/\*+)(\s)?/);
      const rightMatches = rawComment.match(/(\s)?(\*+\/)$/);
      const opener = leftMatches[1];
      const leftSpace = leftMatches[2] || "";
      const rightSpace = rightMatches[1] || "";
      const closer = rightMatches[2];

      if (expectation === "never" && leftSpace !== "") {
        complain(messages.rejectedOpening, opener.length);
      }

      if (expectation === "always" && !isWhitespace(leftSpace)) {
        complain(messages.expectedOpening, opener.length);
      }

      if (expectation === "never" && rightSpace !== "") {
        complain(
          messages.rejectedClosing,
          comment.toString().length - closer.length - 1
        );
      }

      if (expectation === "always" && !isWhitespace(rightSpace)) {
        complain(
          messages.expectedClosing,
          comment.toString().length - closer.length - 1
        );
      }

      function complain(message, index) {
        report({
          message,
          index,
          result,
          ruleName,
          node: comment
        });
      }
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isWhitespace":1133,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144}],922:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const containsString = require("../../utils/containsString");
const matchesStringOrRegExp = require("../../utils/matchesStringOrRegExp");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "comment-word-blacklist";

const messages = ruleMessages(ruleName, {
  rejected: pattern => `Unexpected word matching pattern "${pattern}"`
});

const rule = function(blacklist) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: blacklist,
      possible: [_.isString]
    });
    if (!validOptions) {
      return;
    }

    root.walkComments(comment => {
      const text = comment.text;
      const rawComment = comment.toString();
      const firstFourChars = rawComment.substr(0, 4);

      // Return early if sourcemap
      if (firstFourChars === "/*# ") {
        return;
      }

      const matchesWord =
        matchesStringOrRegExp(text, blacklist) ||
        containsString(text, blacklist);

      if (!matchesWord) {
        return;
      }

      report({
        message: messages.rejected(matchesWord.pattern),
        node: comment,
        result,
        ruleName
      });
    });
  };
};

rule.primaryOptionArray = true;

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/containsString":1079,"../../utils/matchesStringOrRegExp":1134,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692}],923:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const atRuleParamIndex = require("../../utils/atRuleParamIndex");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "custom-media-pattern";

const messages = ruleMessages(ruleName, {
  expected: "Expected custom media query name to match specified pattern"
});

const rule = function(pattern) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: pattern,
      possible: [_.isRegExp, _.isString]
    });
    if (!validOptions) {
      return;
    }

    const regexpPattern = _.isString(pattern) ? new RegExp(pattern) : pattern;

    root.walkAtRules(atRule => {
      if (atRule.name.toLowerCase() !== "custom-media") {
        return;
      }

      const customMediaName = atRule.params.match(/^--(\S+)\b/)[1];

      if (regexpPattern.test(customMediaName)) {
        return;
      }

      report({
        message: messages.expected,
        node: atRule,
        index: atRuleParamIndex(atRule),
        result,
        ruleName
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/atRuleParamIndex":1071,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692}],924:[function(require,module,exports){
"use strict";

const addEmptyLineBefore = require("../../utils/addEmptyLineBefore");
const blockString = require("../../utils/blockString");
const getPreviousNonSharedLineCommentNode = require("../../utils/getPreviousNonSharedLineCommentNode");
const hasEmptyLine = require("../../utils/hasEmptyLine");
const isAfterCommentLine = require("../../utils/isAfterCommentLine");
const isCustomProperty = require("../../utils/isCustomProperty");
const isFirstNested = require("../../utils/isFirstNested");
const isSingleLineString = require("../../utils/isSingleLineString");
const isStandardSyntaxDeclaration = require("../../utils/isStandardSyntaxDeclaration");
const optionsMatches = require("../../utils/optionsMatches");
const removeEmptyLinesBefore = require("../../utils/removeEmptyLinesBefore");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "custom-property-empty-line-before";

const messages = ruleMessages(ruleName, {
  expected: "Expected empty line before custom property",
  rejected: "Unexpected empty line before custom property"
});

const rule = function(expectation, options, context) {
  return (root, result) => {
    const validOptions = validateOptions(
      result,
      ruleName,
      {
        actual: expectation,
        possible: ["always", "never"]
      },
      {
        actual: options,
        possible: {
          except: ["first-nested", "after-comment", "after-custom-property"],
          ignore: ["after-comment", "inside-single-line-block"]
        },
        optional: true
      }
    );
    if (!validOptions) {
      return;
    }

    root.walkDecls(decl => {
      const prop = decl.prop,
        parent = decl.parent;

      if (!isStandardSyntaxDeclaration(decl)) {
        return;
      }
      if (!isCustomProperty(prop)) {
        return;
      }

      // Optionally ignore the node if a comment precedes it
      if (
        optionsMatches(options, "ignore", "after-comment") &&
        isAfterCommentLine(decl)
      ) {
        return;
      }

      // Optionally ignore nodes inside single-line blocks
      if (
        optionsMatches(options, "ignore", "inside-single-line-block") &&
        isSingleLineString(blockString(parent))
      ) {
        return;
      }

      let expectEmptyLineBefore = expectation === "always" ? true : false;

      // Optionally reverse the expectation for the first nested node
      if (
        optionsMatches(options, "except", "first-nested") &&
        isFirstNested(decl)
      ) {
        expectEmptyLineBefore = !expectEmptyLineBefore;
      }

      // Optionally reverse the expectation if a comment precedes this node
      if (
        optionsMatches(options, "except", "after-comment") &&
        isAfterCommentLine(decl)
      ) {
        expectEmptyLineBefore = !expectEmptyLineBefore;
      }

      // Optionally reverse the expectation if a custom property precedes this node
      const prevNode = getPreviousNonSharedLineCommentNode(decl);
      if (
        optionsMatches(options, "except", "after-custom-property") &&
        prevNode &&
        prevNode.prop &&
        isCustomProperty(prevNode.prop)
      ) {
        expectEmptyLineBefore = !expectEmptyLineBefore;
      }

      const hasEmptyLineBefore = hasEmptyLine(decl.raws.before);

      // Return if the expectation is met
      if (expectEmptyLineBefore === hasEmptyLineBefore) {
        return;
      }

      // Fix
      if (context.fix) {
        if (expectEmptyLineBefore) {
          addEmptyLineBefore(decl, context.newline);
        } else {
          removeEmptyLinesBefore(decl, context.newline);
        }

        return;
      }

      const message = expectEmptyLineBefore
        ? messages.expected
        : messages.rejected;
      report({
        message,
        node: decl,
        result,
        ruleName
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/addEmptyLineBefore":1070,"../../utils/blockString":1073,"../../utils/getPreviousNonSharedLineCommentNode":1089,"../../utils/hasEmptyLine":1094,"../../utils/isAfterCommentLine":1100,"../../utils/isCustomProperty":1109,"../../utils/isFirstNested":1112,"../../utils/isSingleLineString":1119,"../../utils/isStandardSyntaxDeclaration":1121,"../../utils/optionsMatches":1137,"../../utils/removeEmptyLinesBefore":1140,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144}],925:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const isCustomProperty = require("../../utils/isCustomProperty");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "custom-property-pattern";

const messages = ruleMessages(ruleName, {
  expected: "Expected custom property name to match specified pattern"
});

const rule = function(pattern) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: pattern,
      possible: [_.isRegExp, _.isString]
    });
    if (!validOptions) {
      return;
    }

    const regexpPattern = _.isString(pattern) ? new RegExp(pattern) : pattern;

    root.walkDecls(decl => {
      const prop = decl.prop;

      if (!isCustomProperty(prop)) {
        return;
      }
      if (regexpPattern.test(prop.slice(2))) {
        return;
      }

      report({
        message: messages.expected,
        node: decl,
        result,
        ruleName
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isCustomProperty":1109,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692}],926:[function(require,module,exports){
"use strict";

const declarationBangSpaceChecker = require("../declarationBangSpaceChecker");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "declaration-bang-space-after";

const messages = ruleMessages(ruleName, {
  expectedAfter: () => 'Expected single space after "!"',
  rejectedAfter: () => 'Unexpected whitespace after "!"'
});

const rule = function(expectation) {
  const checker = whitespaceChecker("space", expectation, messages);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "never"]
    });
    if (!validOptions) {
      return;
    }

    declarationBangSpaceChecker({
      root,
      result,
      locationChecker: checker.after,
      checkedRuleName: ruleName
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145,"../declarationBangSpaceChecker":946}],927:[function(require,module,exports){
"use strict";

const declarationBangSpaceChecker = require("../declarationBangSpaceChecker");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "declaration-bang-space-before";

const messages = ruleMessages(ruleName, {
  expectedBefore: () => 'Expected single space before "!"',
  rejectedBefore: () => 'Unexpected whitespace before "!"'
});

const rule = function(expectation) {
  const checker = whitespaceChecker("space", expectation, messages);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "never"]
    });
    if (!validOptions) {
      return;
    }

    declarationBangSpaceChecker({
      root,
      result,
      locationChecker: checker.before,
      checkedRuleName: ruleName
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145,"../declarationBangSpaceChecker":946}],928:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const isCustomProperty = require("../../utils/isCustomProperty");
const isStandardSyntaxProperty = require("../../utils/isStandardSyntaxProperty");
const optionsMatches = require("../../utils/optionsMatches");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "declaration-block-no-duplicate-properties";

const messages = ruleMessages(ruleName, {
  rejected: property => `Unexpected duplicate "${property}"`
});

const rule = function(on, options) {
  return (root, result) => {
    const validOptions = validateOptions(
      result,
      ruleName,
      { actual: on },
      {
        actual: options,
        possible: {
          ignore: [
            "consecutive-duplicates",
            "consecutive-duplicates-with-different-values"
          ],
          ignoreProperties: [_.isString]
        },
        optional: true
      }
    );
    if (!validOptions) {
      return;
    }

    // In order to accommodate nested blocks (postcss-nested),
    // we need to run a shallow loop (instead of eachDecl() or eachRule(),
    // which loop recursively) and allow each nested block to accumulate
    // its own list of properties -- so that a property in a nested rule
    // does not conflict with the same property in the parent rule
    root.each(node => {
      if (node.type === "rule" || node.type === "atrule") {
        checkRulesInNode(node);
      }
    });

    function checkRulesInNode(node) {
      const decls = [];
      const values = [];

      node.each(child => {
        if (child.nodes && child.nodes.length) {
          checkRulesInNode(child);
        }

        if (child.type !== "decl") {
          return;
        }

        const prop = child.prop;
        const value = child.value;

        if (!isStandardSyntaxProperty(prop)) {
          return;
        }
        if (isCustomProperty(prop)) {
          return;
        }

        // Return early if the property is to be ignored
        if (optionsMatches(options, "ignoreProperties", prop)) {
          return;
        }

        // Ignore the src property as commonly duplicated in at-fontface
        if (prop.toLowerCase() === "src") {
          return;
        }

        const indexDuplicate = decls.indexOf(prop.toLowerCase());

        if (indexDuplicate !== -1) {
          if (
            optionsMatches(
              options,
              "ignore",
              "consecutive-duplicates-with-different-values"
            )
          ) {
            // if duplicates are not consecutive
            if (indexDuplicate !== decls.length - 1) {
              report({
                message: messages.rejected(prop),
                node: child,
                result,
                ruleName
              });
              return;
            }
            // if values of consecutive duplicates are equal
            if (value === values[indexDuplicate]) {
              report({
                message: messages.rejected(value),
                node: child,
                result,
                ruleName
              });
              return;
            }
            return;
          }

          if (
            optionsMatches(options, "ignore", "consecutive-duplicates") &&
            indexDuplicate === decls.length - 1
          ) {
            return;
          }

          report({
            message: messages.rejected(prop),
            node: child,
            result,
            ruleName
          });
        }

        decls.push(prop.toLowerCase());
        values.push(value.toLowerCase());
      });
    }
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isCustomProperty":1109,"../../utils/isStandardSyntaxProperty":1124,"../../utils/optionsMatches":1137,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692}],929:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const optionsMatches = require("../../utils/optionsMatches");
const postcss = require("postcss");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const shorthandData = require("../../reference/shorthandData");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "declaration-block-no-redundant-longhand-properties";

const messages = ruleMessages(ruleName, {
  expected: props => `Expected shorthand property "${props}"`
});

const rule = function(actual, options) {
  return (root, result) => {
    const validOptions = validateOptions(
      result,
      ruleName,
      { actual },
      {
        actual: options,
        possible: {
          ignoreShorthands: [_.isString]
        },
        optional: true
      }
    );
    if (!validOptions) {
      return;
    }

    const longhandProperties = _.transform(
      shorthandData,
      (result, values, key) => {
        if (optionsMatches(options, "ignoreShorthands", key)) {
          return;
        }

        values.forEach(value => {
          (result[value] || (result[value] = [])).push(key);
        });
      }
    );

    root.walkRules(check);
    root.walkAtRules(check);

    function check(statement) {
      const longhandDeclarations = {};
      // Shallow iteration so nesting doesn't produce
      // false positives
      statement.each(node => {
        if (node.type !== "decl") {
          return;
        }

        const prop = node.prop.toLowerCase();
        const unprefixedProp = postcss.vendor.unprefixed(prop);
        const prefix = postcss.vendor.prefix(prop);

        const shorthandProperties = longhandProperties[unprefixedProp];

        if (!shorthandProperties) {
          return;
        }

        shorthandProperties.forEach(shorthandProperty => {
          const prefixedShorthandProperty = prefix + shorthandProperty;

          if (!longhandDeclarations[prefixedShorthandProperty]) {
            longhandDeclarations[prefixedShorthandProperty] = [];
          }

          longhandDeclarations[prefixedShorthandProperty].push(prop);

          const prefixedShorthandData = shorthandData[
            shorthandProperty
          ].map(item => {
            return prefix + item;
          });

          if (
            !_.isEqual(
              prefixedShorthandData.sort(),
              longhandDeclarations[prefixedShorthandProperty].sort()
            )
          ) {
            return;
          }

          report({
            ruleName,
            result,
            node,
            message: messages.expected(prefixedShorthandProperty)
          });
        });
      });
    }
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../reference/shorthandData":892,"../../utils/optionsMatches":1137,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"postcss":828}],930:[function(require,module,exports){
"use strict";

const postcss = require("postcss");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const shorthandData = require("../../reference/shorthandData");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "declaration-block-no-shorthand-property-overrides";

const messages = ruleMessages(ruleName, {
  rejected: (shorthand, original) =>
    `Unexpected shorthand "${shorthand}" after "${original}"`
});

const rule = function(actual) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, { actual });
    if (!validOptions) {
      return;
    }

    root.walkRules(check);
    root.walkAtRules(check);

    function check(statement) {
      const declarations = {};
      // Shallow iteration so nesting doesn't produce
      // false positives
      statement.each(node => {
        if (node.type !== "decl") {
          return;
        }

        const prop = node.prop;
        const unprefixedProp = postcss.vendor.unprefixed(prop);
        const prefix = postcss.vendor.prefix(prop).toLowerCase();

        const overrideables = shorthandData[unprefixedProp.toLowerCase()];
        if (!overrideables) {
          declarations[prop.toLowerCase()] = prop;
          return;
        }
        overrideables.forEach(longhandProp => {
          if (!declarations.hasOwnProperty(prefix + longhandProp)) {
            return;
          }
          report({
            ruleName,
            result,
            node,
            message: messages.rejected(
              prop,
              declarations[prefix + longhandProp]
            )
          });
        });
      });
    }
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../reference/shorthandData":892,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"postcss":828}],931:[function(require,module,exports){
"use strict";

const blockString = require("../../utils/blockString");
const nextNonCommentNode = require("../../utils/nextNonCommentNode");
const rawNodeString = require("../../utils/rawNodeString");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "declaration-block-semicolon-newline-after";

const messages = ruleMessages(ruleName, {
  expectedAfter: () => 'Expected newline after ";"',
  expectedAfterMultiLine: () =>
    'Expected newline after ";" in a multi-line declaration block',
  rejectedAfterMultiLine: () =>
    'Unexpected newline after ";" in a multi-line declaration block'
});

const rule = function(expectation) {
  const checker = whitespaceChecker("newline", expectation, messages);

  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "always-multi-line", "never-multi-line"]
    });
    if (!validOptions) {
      return;
    }

    root.walkDecls(decl => {
      // Ignore last declaration if there's no trailing semicolon
      const parentRule = decl.parent;
      if (!parentRule.raws.semicolon && parentRule.last === decl) {
        return;
      }

      const nextNode = decl.next();
      if (!nextNode) {
        return;
      }

      // Allow end-of-line comment
      const nodeToCheck = nextNonCommentNode(nextNode);
      if (!nodeToCheck) {
        return;
      }

      checker.afterOneOnly({
        source: rawNodeString(nodeToCheck),
        index: -1,
        lineCheckStr: blockString(parentRule),
        err: m => {
          report({
            message: m,
            node: decl,
            index: decl.toString().length + 1,
            result,
            ruleName
          });
        }
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/blockString":1073,"../../utils/nextNonCommentNode":1135,"../../utils/rawNodeString":1139,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145}],932:[function(require,module,exports){
"use strict";

const blockString = require("../../utils/blockString");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "declaration-block-semicolon-newline-before";

const messages = ruleMessages(ruleName, {
  expectedBefore: () => 'Expected newline before ";"',
  expectedBeforeMultiLine: () =>
    'Expected newline before ";" in a multi-line declaration block',
  rejectedBeforeMultiLine: () =>
    'Unexpected whitespace before ";" in a multi-line declaration block'
});

const rule = function(expectation) {
  const checker = whitespaceChecker("newline", expectation, messages);

  return function(root, result) {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "always-multi-line", "never-multi-line"]
    });
    if (!validOptions) {
      return;
    }

    root.walkDecls(function(decl) {
      const parentRule = decl.parent;
      if (!parentRule.raws.semicolon && parentRule.last === decl) {
        return;
      }

      const declString = decl.toString();

      checker.beforeAllowingIndentation({
        source: declString,
        index: declString.length,
        lineCheckStr: blockString(parentRule),
        err: m => {
          report({
            message: m,
            node: decl,
            index: decl.toString().length - 1,
            result,
            ruleName
          });
        }
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/blockString":1073,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145}],933:[function(require,module,exports){
"use strict";

const blockString = require("../../utils/blockString");
const rawNodeString = require("../../utils/rawNodeString");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "declaration-block-semicolon-space-after";

const messages = ruleMessages(ruleName, {
  expectedAfter: () => 'Expected single space after ";"',
  rejectedAfter: () => 'Unexpected whitespace after ";"',
  expectedAfterSingleLine: () =>
    'Expected single space after ";" in a single-line declaration block',
  rejectedAfterSingleLine: () =>
    'Unexpected whitespace after ";" in a single-line declaration block'
});

const rule = function(expectation) {
  const checker = whitespaceChecker("space", expectation, messages);

  return function(root, result) {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "never", "always-single-line", "never-single-line"]
    });
    if (!validOptions) {
      return;
    }

    root.walkDecls(function(decl) {
      // Ignore last declaration if there's no trailing semicolon
      const parentRule = decl.parent;
      if (!parentRule.raws.semicolon && parentRule.last === decl) {
        return;
      }

      const nextDecl = decl.next();
      if (!nextDecl) {
        return;
      }

      checker.after({
        source: rawNodeString(nextDecl),
        index: -1,
        lineCheckStr: blockString(parentRule),
        err: m => {
          report({
            message: m,
            node: decl,
            index: decl.toString().length + 1,
            result,
            ruleName
          });
        }
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/blockString":1073,"../../utils/rawNodeString":1139,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145}],934:[function(require,module,exports){
"use strict";

const blockString = require("../../utils/blockString");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "declaration-block-semicolon-space-before";

const messages = ruleMessages(ruleName, {
  expectedBefore: () => 'Expected single space before ";"',
  rejectedBefore: () => 'Unexpected whitespace before ";"',
  expectedBeforeSingleLine: () =>
    'Expected single space before ";" in a single-line declaration block',
  rejectedBeforeSingleLine: () =>
    'Unexpected whitespace before ";" in a single-line declaration block'
});

const rule = function(expectation) {
  const checker = whitespaceChecker("space", expectation, messages);

  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "never", "always-single-line", "never-single-line"]
    });
    if (!validOptions) {
      return;
    }

    root.walkDecls(decl => {
      // Ignore last declaration if there's no trailing semicolon
      const parentRule = decl.parent;
      if (!parentRule.raws.semicolon && parentRule.last === decl) {
        return;
      }

      const declString = decl.toString();

      checker.before({
        source: declString,
        index: declString.length,
        lineCheckStr: blockString(parentRule),
        err: m => {
          report({
            message: m,
            node: decl,
            index: decl.toString().length - 1,
            result,
            ruleName
          });
        }
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/blockString":1073,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145}],935:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const beforeBlockString = require("../../utils/beforeBlockString");
const blockString = require("../../utils/blockString");
const isSingleLineString = require("../../utils/isSingleLineString");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "declaration-block-single-line-max-declarations";

const messages = ruleMessages(ruleName, {
  expected: max =>
    `Expected no more than ${max} ${max === 1 ? "declaration" : "declarations"}`
});

const rule = function(quantity) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: quantity,
      possible: [_.isNumber]
    });
    if (!validOptions) {
      return;
    }

    root.walkRules(rule => {
      if (!isSingleLineString(blockString(rule))) {
        return;
      }
      if (!rule.nodes) {
        return;
      }

      const decls = rule.nodes.filter(node => node.type === "decl");

      if (decls.length <= quantity) {
        return;
      }

      report({
        message: messages.expected(quantity),
        node: rule,
        index: beforeBlockString(rule, { noRawBefore: true }).length,
        result,
        ruleName
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/beforeBlockString":1072,"../../utils/blockString":1073,"../../utils/isSingleLineString":1119,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692}],936:[function(require,module,exports){
"use strict";

const hasBlock = require("../../utils/hasBlock");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "declaration-block-trailing-semicolon";

const messages = ruleMessages(ruleName, {
  expected: "Expected a trailing semicolon",
  rejected: "Unexpected trailing semicolon"
});

const rule = function(expectation) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "never"]
    });
    if (!validOptions) {
      return;
    }

    root.walkAtRules(atRule => {
      if (atRule.parent === root) {
        return;
      }
      if (atRule !== atRule.parent.last) {
        return;
      }
      if (hasBlock(atRule)) {
        return;
      }
      checkLastNode(atRule);
    });

    root.walkDecls(decl => {
      if (decl !== decl.parent.last) {
        return;
      }
      checkLastNode(decl);
    });

    function checkLastNode(node) {
      let message;

      if (expectation === "always") {
        if (node.parent.raws.semicolon) {
          return;
        }
        message = messages.expected;
      }
      if (expectation === "never") {
        if (!node.parent.raws.semicolon) {
          return;
        }
        message = messages.rejected;
      }

      report({
        message,
        node,
        index: node.toString().trim().length - 1,
        result,
        ruleName
      });
    }
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/hasBlock":1092,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144}],937:[function(require,module,exports){
"use strict";

const declarationValueIndex = require("../../utils/declarationValueIndex");
const isStandardSyntaxDeclaration = require("../../utils/isStandardSyntaxDeclaration");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "declaration-colon-newline-after";

const messages = ruleMessages(ruleName, {
  expectedAfter: () => 'Expected newline after ":"',
  expectedAfterMultiLine: () =>
    'Expected newline after ":" with a multi-line declaration'
});

const rule = function(expectation) {
  const checker = whitespaceChecker("newline", expectation, messages);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "always-multi-line"]
    });
    if (!validOptions) {
      return;
    }

    root.walkDecls(decl => {
      if (!isStandardSyntaxDeclaration(decl)) {
        return;
      }

      // Get the raw prop, and only the prop
      const endOfPropIndex =
        declarationValueIndex(decl) + (decl.raws.between || "").length - 1;

      // The extra characters tacked onto the end ensure that there is a character to check
      // after the colon. Otherwise, with `background:pink` the character after the
      const propPlusColon = decl.toString().slice(0, endOfPropIndex) + "xxx";

      for (let i = 0, l = propPlusColon.length; i < l; i++) {
        if (propPlusColon[i] !== ":") {
          continue;
        }
        const indexToCheck =
          propPlusColon.substr(propPlusColon[i], 3) === "/*"
            ? propPlusColon.indexOf("*/", i) + 1
            : i;

        checker.afterOneOnly({
          source: propPlusColon,
          index: indexToCheck,
          lineCheckStr: decl.value,
          err: m => {
            report({
              message: m,
              node: decl,
              index: indexToCheck,
              result,
              ruleName
            });
          }
        });
      }
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/declarationValueIndex":1080,"../../utils/isStandardSyntaxDeclaration":1121,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145}],938:[function(require,module,exports){
"use strict";

const declarationColonSpaceChecker = require("../declarationColonSpaceChecker");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "declaration-colon-space-after";

const messages = ruleMessages(ruleName, {
  expectedAfter: () => 'Expected single space after ":"',
  rejectedAfter: () => 'Unexpected whitespace after ":"',
  expectedAfterSingleLine: () =>
    'Expected single space after ":" with a single-line declaration'
});

const rule = function(expectation) {
  const checker = whitespaceChecker("space", expectation, messages);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "never", "always-single-line"]
    });
    if (!validOptions) {
      return;
    }

    declarationColonSpaceChecker({
      root,
      result,
      locationChecker: checker.after,
      checkedRuleName: ruleName
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145,"../declarationColonSpaceChecker":947}],939:[function(require,module,exports){
"use strict";

const declarationColonSpaceChecker = require("../declarationColonSpaceChecker");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "declaration-colon-space-before";

const messages = ruleMessages(ruleName, {
  expectedBefore: () => 'Expected single space before ":"',
  rejectedBefore: () => 'Unexpected whitespace before ":"'
});

const rule = function(expectation) {
  const checker = whitespaceChecker("space", expectation, messages);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "never"]
    });
    if (!validOptions) {
      return;
    }

    declarationColonSpaceChecker({
      root,
      result,
      locationChecker: checker.before,
      checkedRuleName: ruleName
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145,"../declarationColonSpaceChecker":947}],940:[function(require,module,exports){
"use strict";

const addEmptyLineBefore = require("../../utils/addEmptyLineBefore");
const blockString = require("../../utils/blockString");
const hasEmptyLine = require("../../utils/hasEmptyLine");
const isAfterCommentLine = require("../../utils/isAfterCommentLine");
const isAfterStandardPropertyDeclaration = require("../../utils/isAfterStandardPropertyDeclaration");
const isCustomProperty = require("../../utils/isCustomProperty");
const isFirstNested = require("../../utils/isFirstNested");
const isSingleLineString = require("../../utils/isSingleLineString");
const isStandardSyntaxDeclaration = require("../../utils/isStandardSyntaxDeclaration");
const optionsMatches = require("../../utils/optionsMatches");
const removeEmptyLinesBefore = require("../../utils/removeEmptyLinesBefore");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "declaration-empty-line-before";

const messages = ruleMessages(ruleName, {
  expected: "Expected empty line before declaration",
  rejected: "Unexpected empty line before declaration"
});

const rule = function(expectation, options, context) {
  return (root, result) => {
    const validOptions = validateOptions(
      result,
      ruleName,
      {
        actual: expectation,
        possible: ["always", "never"]
      },
      {
        actual: options,
        possible: {
          except: ["first-nested", "after-comment", "after-declaration"],
          ignore: [
            "after-comment",
            "after-declaration",
            "inside-single-line-block"
          ]
        },
        optional: true
      }
    );
    if (!validOptions) {
      return;
    }

    root.walkDecls(decl => {
      const prop = decl.prop,
        parent = decl.parent;

      if (!isStandardSyntaxDeclaration(decl)) {
        return;
      }
      if (isCustomProperty(prop)) {
        return;
      }

      // Optionally ignore the node if a comment precedes it
      if (
        optionsMatches(options, "ignore", "after-comment") &&
        isAfterCommentLine(decl)
      ) {
        return;
      }

      // Optionally ignore the node if a declaration precedes it
      if (
        optionsMatches(options, "ignore", "after-declaration") &&
        isAfterStandardPropertyDeclaration(decl)
      ) {
        return;
      }

      // Optionally ignore nodes inside single-line blocks
      if (
        optionsMatches(options, "ignore", "inside-single-line-block") &&
        isSingleLineString(blockString(parent))
      ) {
        return;
      }

      let expectEmptyLineBefore = expectation === "always" ? true : false;

      // Optionally reverse the expectation for the first nested node
      if (
        optionsMatches(options, "except", "first-nested") &&
        isFirstNested(decl)
      ) {
        expectEmptyLineBefore = !expectEmptyLineBefore;
      }

      // Optionally reverse the expectation if a comment precedes this node
      if (
        optionsMatches(options, "except", "after-comment") &&
        isAfterCommentLine(decl)
      ) {
        expectEmptyLineBefore = !expectEmptyLineBefore;
      }

      // Optionally reverse the expectation if a declaration precedes this node
      if (
        optionsMatches(options, "except", "after-declaration") &&
        isAfterStandardPropertyDeclaration(decl)
      ) {
        expectEmptyLineBefore = !expectEmptyLineBefore;
      }

      // Check for at least one empty line
      const hasEmptyLineBefore = hasEmptyLine(decl.raws.before);

      // Return if the expectation is met
      if (expectEmptyLineBefore === hasEmptyLineBefore) {
        return;
      }

      // Fix
      if (context.fix) {
        if (expectEmptyLineBefore) {
          addEmptyLineBefore(decl, context.newline);
        } else {
          removeEmptyLinesBefore(decl, context.newline);
        }

        return;
      }

      const message = expectEmptyLineBefore
        ? messages.expected
        : messages.rejected;
      report({ message, node: decl, result, ruleName });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/addEmptyLineBefore":1070,"../../utils/blockString":1073,"../../utils/hasEmptyLine":1094,"../../utils/isAfterCommentLine":1100,"../../utils/isAfterStandardPropertyDeclaration":1101,"../../utils/isCustomProperty":1109,"../../utils/isFirstNested":1112,"../../utils/isSingleLineString":1119,"../../utils/isStandardSyntaxDeclaration":1121,"../../utils/optionsMatches":1137,"../../utils/removeEmptyLinesBefore":1140,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144}],941:[function(require,module,exports){
"use strict";

const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "declaration-no-important";

const messages = ruleMessages(ruleName, {
  rejected: "Unexpected !important"
});

const rule = function(actual) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, { actual });
    if (!validOptions) {
      return;
    }

    root.walkDecls(decl => {
      if (!decl.important) {
        return;
      }

      report({
        message: messages.rejected,
        node: decl,
        word: "important",
        result,
        ruleName
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144}],942:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const declarationValueIndex = require("../../utils/declarationValueIndex");
const getUnitFromValueNode = require("../../utils/getUnitFromValueNode");
const matchesStringOrRegExp = require("../../utils/matchesStringOrRegExp");
const postcss = require("postcss");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const valueParser = require("postcss-value-parser");

const ruleName = "declaration-property-unit-blacklist";

const messages = ruleMessages(ruleName, {
  rejected: (property, unit) =>
    `Unexpected unit "${unit}" for property "${property}"`
});

const rule = function(blacklist) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: blacklist,
      possible: [_.isObject]
    });
    if (!validOptions) {
      return;
    }

    root.walkDecls(decl => {
      const prop = decl.prop,
        value = decl.value;

      const unprefixedProp = postcss.vendor.unprefixed(prop);

      const propBlacklist = _.find(blacklist, (list, propIdentifier) =>
        matchesStringOrRegExp(unprefixedProp, propIdentifier)
      );

      if (!propBlacklist) {
        return;
      }

      valueParser(value).walk(function(node) {
        // Ignore wrong units within `url` function
        if (node.type === "function" && node.value.toLowerCase() === "url") {
          return false;
        }
        if (node.type === "string") {
          return;
        }

        const unit = getUnitFromValueNode(node);

        if (
          !unit ||
          (unit && propBlacklist.indexOf(unit.toLowerCase()) === -1)
        ) {
          return;
        }

        report({
          message: messages.rejected(prop, unit),
          node: decl,
          index: declarationValueIndex(decl) + node.sourceIndex,
          result,
          ruleName
        });
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/declarationValueIndex":1080,"../../utils/getUnitFromValueNode":1091,"../../utils/matchesStringOrRegExp":1134,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"postcss":828,"postcss-value-parser":811}],943:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const declarationValueIndex = require("../../utils/declarationValueIndex");
const getUnitFromValueNode = require("../../utils/getUnitFromValueNode");
const matchesStringOrRegExp = require("../../utils/matchesStringOrRegExp");
const postcss = require("postcss");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const valueParser = require("postcss-value-parser");

const ruleName = "declaration-property-unit-whitelist";

const messages = ruleMessages(ruleName, {
  rejected: (property, unit) =>
    `Unexpected unit "${unit}" for property "${property}"`
});

const rule = function(whitelist) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: whitelist,
      possible: [_.isObject]
    });
    if (!validOptions) {
      return;
    }

    root.walkDecls(decl => {
      const prop = decl.prop,
        value = decl.value;

      const unprefixedProp = postcss.vendor.unprefixed(prop);

      const propWhitelist = _.find(whitelist, (list, propIdentifier) =>
        matchesStringOrRegExp(unprefixedProp, propIdentifier)
      );

      if (!propWhitelist) {
        return;
      }

      valueParser(value).walk(function(node) {
        // Ignore wrong units within `url` function
        if (node.type === "function" && node.value.toLowerCase() === "url") {
          return false;
        }
        if (node.type === "string") {
          return;
        }

        const unit = getUnitFromValueNode(node);

        if (
          !unit ||
          (unit && propWhitelist.indexOf(unit.toLowerCase())) !== -1
        ) {
          return;
        }

        report({
          message: messages.rejected(prop, unit),
          node: decl,
          index: declarationValueIndex(decl) + node.sourceIndex,
          result,
          ruleName
        });
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/declarationValueIndex":1080,"../../utils/getUnitFromValueNode":1091,"../../utils/matchesStringOrRegExp":1134,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"postcss":828,"postcss-value-parser":811}],944:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const matchesStringOrRegExp = require("../../utils/matchesStringOrRegExp");
const postcss = require("postcss");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "declaration-property-value-blacklist";

const messages = ruleMessages(ruleName, {
  rejected: (property, value) =>
    `Unexpected value "${value}" for property "${property}"`
});

const rule = function(blacklist) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: blacklist,
      possible: [_.isObject]
    });
    if (!validOptions) {
      return;
    }

    root.walkDecls(decl => {
      const prop = decl.prop,
        value = decl.value;

      const unprefixedProp = postcss.vendor.unprefixed(prop);
      const propBlacklist = _.find(blacklist, (list, propIdentifier) =>
        matchesStringOrRegExp(unprefixedProp, propIdentifier)
      );

      if (_.isEmpty(propBlacklist)) {
        return;
      }

      if (!matchesStringOrRegExp(value, propBlacklist)) {
        return;
      }

      report({
        message: messages.rejected(prop, value),
        node: decl,
        result,
        ruleName
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/matchesStringOrRegExp":1134,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"postcss":828}],945:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const matchesStringOrRegExp = require("../../utils/matchesStringOrRegExp");
const postcss = require("postcss");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "declaration-property-value-whitelist";

const messages = ruleMessages(ruleName, {
  rejected: (property, value) =>
    `Unexpected value "${value}" for property "${property}"`
});

const rule = function(whitelist) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: whitelist,
      possible: [_.isObject]
    });
    if (!validOptions) {
      return;
    }

    root.walkDecls(decl => {
      const prop = decl.prop,
        value = decl.value;

      const unprefixedProp = postcss.vendor.unprefixed(prop);
      const propWhitelist = _.find(whitelist, (list, propIdentifier) =>
        matchesStringOrRegExp(unprefixedProp, propIdentifier)
      );

      if (_.isEmpty(propWhitelist)) {
        return;
      }

      if (matchesStringOrRegExp(value, propWhitelist)) {
        return;
      }

      report({
        message: messages.rejected(prop, value),
        node: decl,
        result,
        ruleName
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/matchesStringOrRegExp":1134,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"postcss":828}],946:[function(require,module,exports){
"use strict";

const declarationValueIndex = require("../utils/declarationValueIndex");
const report = require("../utils/report");
const styleSearch = require("style-search");

module.exports = function(opts) {
  opts.root.walkDecls(function(decl) {
    const indexOffset = declarationValueIndex(decl);
    const declString = decl.toString();
    const valueString = decl.toString().slice(indexOffset);
    if (valueString.indexOf("!") === -1) {
      return;
    }

    styleSearch({ source: valueString, target: "!" }, match => {
      check(declString, match.startIndex + indexOffset, decl);
    });
  });

  function check(source, index, node) {
    opts.locationChecker({
      source,
      index,
      err: m =>
        report({
          message: m,
          node,
          index,
          result: opts.result,
          ruleName: opts.checkedRuleName
        })
    });
  }
};

},{"../utils/declarationValueIndex":1080,"../utils/report":1141,"style-search":870}],947:[function(require,module,exports){
"use strict";

const declarationValueIndex = require("../utils/declarationValueIndex");
const isStandardSyntaxDeclaration = require("../utils/isStandardSyntaxDeclaration");
const report = require("../utils/report");

module.exports = function(opts) {
  opts.root.walkDecls(decl => {
    if (!isStandardSyntaxDeclaration(decl)) {
      return;
    }

    // Get the raw prop, and only the prop
    const endOfPropIndex =
      declarationValueIndex(decl) + (decl.raws.between || "").length - 1;

    // The extra characters tacked onto the end ensure that there is a character to check
    // after the colon. Otherwise, with `background:pink` the character after the
    const propPlusColon = decl.toString().slice(0, endOfPropIndex) + "xxx";

    for (let i = 0, l = propPlusColon.length; i < l; i++) {
      if (propPlusColon[i] !== ":") {
        continue;
      }
      opts.locationChecker({
        source: propPlusColon,
        index: i,
        lineCheckStr: decl.value,
        err: m => {
          report({
            message: m,
            node: decl,
            index: decl.prop.toString().length + 1,
            result: opts.result,
            ruleName: opts.checkedRuleName
          });
        }
      });
      break;
    }
  });
};

},{"../utils/declarationValueIndex":1080,"../utils/isStandardSyntaxDeclaration":1121,"../utils/report":1141}],948:[function(require,module,exports){
"use strict";

const rangeOperatorRegex = /[^><](>=?|<=?|=)/g;

module.exports = function(atRule, cb) {
  if (atRule.name.toLowerCase() !== "media") {
    return;
  }

  const params = atRule.params;
  let match;
  while ((match = rangeOperatorRegex.exec(params)) !== null) {
    cb(match, params, atRule);
  }
};

},{}],949:[function(require,module,exports){
"use strict";

const findFontFamily = require("../../utils/findFontFamily");
const isStandardSyntaxValue = require("../../utils/isStandardSyntaxValue");
const isVariable = require("../../utils/isVariable");
const keywordSets = require("../../reference/keywordSets");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "font-family-name-quotes";

const messages = ruleMessages(ruleName, {
  expected: family => `Expected quotes around "${family}"`,
  rejected: family => `Unexpected quotes around "${family}"`
});

function isSystemFontKeyword(font) {
  if (font.indexOf("-apple-") === 0) {
    return true;
  }
  if (font === "BlinkMacSystemFont") {
    return true;
  }
  return false;
}

// "To avoid mistakes in escaping, it is recommended to quote font family names
// that contain white space, digits, or punctuation characters other than hyphens"
// (https://www.w3.org/TR/CSS2/fonts.html#font-family-prop)
function quotesRecommended(family) {
  return !/^[-a-zA-Z]+$/.test(family);
}

// Quotes are required if the family is not a valid CSS identifier
// (regexes from https://mathiasbynens.be/notes/unquoted-font-family)
function quotesRequired(family) {
  return family.split(/\s+/).some(word => {
    return (
      /^(-?\d|--)/.test(word) || !/^[-_a-zA-Z0-9\u00A0-\u10FFFF]+$/.test(word)
    );
  });
}

const rule = function(expectation) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: [
        "always-where-required",
        "always-where-recommended",
        "always-unless-keyword"
      ]
    });
    if (!validOptions) {
      return;
    }

    root.walkDecls(/^font(-family)?$/i, decl => {
      const fontFamilies = findFontFamily(decl.value);

      if (fontFamilies.length === 0) {
        return;
      }

      fontFamilies.forEach(fontFamilyNode => {
        let rawFamily = fontFamilyNode.value;

        if (fontFamilyNode.quote) {
          rawFamily = fontFamilyNode.quote + rawFamily + fontFamilyNode.quote;
        }

        checkFamilyName(rawFamily, decl);
      });
    });

    function checkFamilyName(rawFamily, decl) {
      if (!isStandardSyntaxValue(rawFamily)) {
        return;
      }
      if (isVariable(rawFamily)) {
        return;
      }

      const hasQuotes = rawFamily[0] === "'" || rawFamily[0] === '"';

      // Clean the family of its quotes
      const family = rawFamily.replace(/^['"]|['"]$/g, "");

      // Disallow quotes around (case-insensitive) keywords
      // and system font keywords in all cases
      if (
        keywordSets.fontFamilyKeywords.has(family.toLowerCase()) ||
        isSystemFontKeyword(family)
      ) {
        if (hasQuotes) {
          return complain(messages.rejected(family), family, decl);
        }
        return;
      }

      const required = quotesRequired(family);
      const recommended = quotesRecommended(family);

      switch (expectation) {
        case "always-unless-keyword":
          if (!hasQuotes) {
            return complain(messages.expected(family), family, decl);
          }
          return;

        case "always-where-recommended":
          if (!recommended && hasQuotes) {
            return complain(messages.rejected(family), family, decl);
          }
          if (recommended && !hasQuotes) {
            return complain(messages.expected(family), family, decl);
          }
          return;

        case "always-where-required":
          if (!required && hasQuotes) {
            return complain(messages.rejected(family), family, decl);
          }
          if (required && !hasQuotes) {
            return complain(messages.expected(family), family, decl);
          }
          return;
      }
    }

    function complain(message, family, decl) {
      report({
        result,
        ruleName,
        message,
        node: decl,
        word: family
      });
    }
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../reference/keywordSets":888,"../../utils/findFontFamily":1083,"../../utils/isStandardSyntaxValue":1129,"../../utils/isVariable":1132,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144}],950:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const declarationValueIndex = require("../../utils/declarationValueIndex");
const findFontFamily = require("../../utils/findFontFamily");
const keywordSets = require("../../reference/keywordSets");
const optionsMatches = require("../../utils/optionsMatches");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "font-family-no-duplicate-names";

const messages = ruleMessages(ruleName, {
  rejected: name => `Unexpected duplicate name ${name}`
});

const isFamilyNameKeyword = node =>
  !node.quote && keywordSets.fontFamilyKeywords.has(node.value.toLowerCase());

const rule = function(actual, options) {
  return (root, result) => {
    const validOptions = validateOptions(
      result,
      ruleName,
      { actual },
      {
        actual: options,
        possible: {
          ignoreFontFamilyNames: [_.isString]
        },
        optional: true
      }
    );
    if (!validOptions) {
      return;
    }

    root.walkDecls(/^font(-family)?$/i, decl => {
      const keywords = new Set();
      const familyNames = new Set();

      const fontFamilies = findFontFamily(decl.value);

      if (fontFamilies.length === 0) {
        return;
      }

      fontFamilies.forEach(fontFamilyNode => {
        const family = fontFamilyNode.value.trim();

        if (
          optionsMatches(
            options,
            "ignoreFontFamilyNames",
            fontFamilyNode.value.trim()
          )
        ) {
          return;
        }

        if (isFamilyNameKeyword(fontFamilyNode)) {
          if (keywords.has(family.toLowerCase())) {
            complain(
              messages.rejected(family),
              declarationValueIndex(decl) + fontFamilyNode.sourceIndex,
              decl
            );
            return;
          }

          keywords.add(family);
          return;
        }

        if (familyNames.has(family)) {
          complain(
            messages.rejected(family),
            declarationValueIndex(decl) + fontFamilyNode.sourceIndex,
            decl
          );
          return;
        }

        familyNames.add(family);
      });
    });

    function complain(message, index, decl) {
      report({
        result,
        ruleName,
        message,
        node: decl,
        index
      });
    }
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../reference/keywordSets":888,"../../utils/declarationValueIndex":1080,"../../utils/findFontFamily":1083,"../../utils/optionsMatches":1137,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692}],951:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const declarationValueIndex = require("../../utils/declarationValueIndex");
const isNumbery = require("../../utils/isNumbery");
const isStandardSyntaxValue = require("../../utils/isStandardSyntaxValue");
const isVariable = require("../../utils/isVariable");
const keywordSets = require("../../reference/keywordSets");
const optionsMatches = require("../../utils/optionsMatches");
const postcss = require("postcss");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "font-weight-notation";

const messages = ruleMessages(ruleName, {
  expected: type => `Expected ${type} font-weight notation`,
  invalidNamed: name => `Unexpected invalid font-weight name "${name}"`
});

const INHERIT_KEYWORD = "inherit";
const INITIAL_KEYWORD = "initial";
const NORMAL_KEYWORD = "normal";
const WEIGHTS_WITH_KEYWORD_EQUIVALENTS = ["400", "700"];

const rule = function(expectation, options) {
  return (root, result) => {
    const validOptions = validateOptions(
      result,
      ruleName,
      {
        actual: expectation,
        possible: ["numeric", "named-where-possible"]
      },
      {
        actual: options,
        possible: {
          ignore: ["relative"]
        },
        optional: true
      }
    );
    if (!validOptions) {
      return;
    }

    root.walkDecls(decl => {
      if (decl.prop.toLowerCase() === "font-weight") {
        checkWeight(decl.value, decl);
      }

      if (decl.prop.toLowerCase() === "font") {
        checkFont(decl);
      }
    });

    function checkFont(decl) {
      const valueList = postcss.list.space(decl.value);
      // We do not need to more carefully distinguish font-weight
      // numbers from unitless line-heights because line-heights in
      // `font` values need to be part of a font-size/line-height pair
      const hasNumericFontWeight = valueList.some(isNumbery);

      for (const value of postcss.list.space(decl.value)) {
        if (
          (value.toLowerCase() === NORMAL_KEYWORD && !hasNumericFontWeight) ||
          isNumbery(value) ||
          (value.toLowerCase() !== NORMAL_KEYWORD &&
            keywordSets.fontWeightKeywords.has(value.toLowerCase()))
        ) {
          checkWeight(value, decl);
          return;
        }
      }
    }

    function checkWeight(weightValue, decl) {
      if (!isStandardSyntaxValue(weightValue)) {
        return;
      }
      if (isVariable(weightValue)) {
        return;
      }
      if (
        weightValue.toLowerCase() === INHERIT_KEYWORD ||
        weightValue.toLowerCase() === INITIAL_KEYWORD
      ) {
        return;
      }

      if (
        optionsMatches(options, "ignore", "relative") &&
        keywordSets.fontWeightRelativeKeywords.has(weightValue.toLowerCase())
      ) {
        return;
      }

      const weightValueOffset = decl.value.indexOf(weightValue);

      if (expectation === "numeric") {
        if (!isNumbery(weightValue)) {
          return complain(messages.expected("numeric"));
        }
      }

      if (expectation === "named-where-possible") {
        if (isNumbery(weightValue)) {
          if (_.includes(WEIGHTS_WITH_KEYWORD_EQUIVALENTS, weightValue)) {
            complain(messages.expected("named"));
          }
          return;
        }
        if (
          !keywordSets.fontWeightKeywords.has(weightValue.toLowerCase()) &&
          weightValue.toLowerCase() !== NORMAL_KEYWORD
        ) {
          return complain(messages.invalidNamed(weightValue));
        }
        return;
      }

      function complain(message) {
        report({
          ruleName,
          result,
          message,
          node: decl,
          index: declarationValueIndex(decl) + weightValueOffset
        });
      }
    }
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../reference/keywordSets":888,"../../utils/declarationValueIndex":1080,"../../utils/isNumbery":1115,"../../utils/isStandardSyntaxValue":1129,"../../utils/isVariable":1132,"../../utils/optionsMatches":1137,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"postcss":828}],952:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const declarationValueIndex = require("../../utils/declarationValueIndex");
const isStandardSyntaxFunction = require("../../utils/isStandardSyntaxFunction");
const matchesStringOrRegExp = require("../../utils/matchesStringOrRegExp");
const postcss = require("postcss");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const valueParser = require("postcss-value-parser");

const ruleName = "function-blacklist";

const messages = ruleMessages(ruleName, {
  rejected: name => `Unexpected function "${name}"`
});

const rule = function(blacklist) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: blacklist,
      possible: [_.isString]
    });
    if (!validOptions) {
      return;
    }
    root.walkDecls(decl => {
      const value = decl.value;

      valueParser(value).walk(function(node) {
        if (node.type !== "function") {
          return;
        }
        if (!isStandardSyntaxFunction(node)) {
          return;
        }
        if (
          !matchesStringOrRegExp(
            postcss.vendor.unprefixed(node.value),
            blacklist
          )
        ) {
          return;
        }

        report({
          message: messages.rejected(node.value),
          node: decl,
          index: declarationValueIndex(decl) + node.sourceIndex,
          result,
          ruleName
        });
      });
    });
  };
};

rule.primaryOptionArray = true;

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/declarationValueIndex":1080,"../../utils/isStandardSyntaxFunction":1122,"../../utils/matchesStringOrRegExp":1134,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"postcss":828,"postcss-value-parser":811}],953:[function(require,module,exports){
"use strict";

const balancedMatch = require("balanced-match");
const isWhitespace = require("../../utils/isWhitespace");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const styleSearch = require("style-search");
const validateOptions = require("../../utils/validateOptions");
const valueParser = require("postcss-value-parser");

const ruleName = "function-calc-no-unspaced-operator";

const messages = ruleMessages(ruleName, {
  expectedBefore: operator =>
    `Expected single space before "${operator}" operator`,
  expectedAfter: operator =>
    `Expected single space after "${operator}" operator`,
  expectedOperatorBeforeSign: operator =>
    `Expected an operator before sign "${operator}"`
});

const rule = function(actual) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, { actual });
    if (!validOptions) {
      return;
    }

    function complain(message, node, index) {
      report({ message, node, index, result, ruleName });
    }

    root.walkDecls(decl => {
      valueParser(decl.value).walk(node => {
        if (node.type !== "function" || node.value.toLowerCase() !== "calc") {
          return;
        }

        const parensMatch = balancedMatch(
          "(",
          ")",
          valueParser.stringify(node)
        );
        const rawExpression = parensMatch.body;
        const expressionIndex =
          decl.source.start.column +
          decl.prop.length +
          (decl.raws.between || "").length +
          node.sourceIndex;
        const expression = blurVariables(rawExpression);

        checkSymbol("+");
        checkSymbol("-");
        checkSymbol("*");
        checkSymbol("/");

        function checkSymbol(symbol) {
          const styleSearchOptions = {
            source: expression,
            target: symbol,
            functionArguments: "skip"
          };

          styleSearch(styleSearchOptions, match => {
            const index = match.startIndex;

            // Deal with signs.
            // (@ and $ are considered "digits" here to allow for variable syntaxes
            // that permit signs in front of variables, e.g. `-$number`)
            // As is "." to deal with fractional numbers without a leading zero
            if (
              (symbol === "+" || symbol === "-") &&
              /[\d@$.]/.test(expression[index + 1])
            ) {
              const expressionBeforeSign = expression.substr(0, index);

              // Ignore signs that directly follow a opening bracket
              if (
                expressionBeforeSign[expressionBeforeSign.length - 1] === "("
              ) {
                return;
              }

              // Ignore signs at the beginning of the expression
              if (/^\s*$/.test(expressionBeforeSign)) {
                return;
              }

              // Otherwise, ensure that there is a real operator preceeding them
              if (/[*/+-]\s*$/.test(expressionBeforeSign)) {
                return;
              }

              // And if not, complain
              complain(
                messages.expectedOperatorBeforeSign(symbol),
                decl,
                expressionIndex + index
              );
              return;
            }

            const beforeOk =
              (expression[index - 1] === " " &&
                !isWhitespace(expression[index - 2])) ||
              newlineBefore(expression, index - 1);
            if (!beforeOk) {
              complain(
                messages.expectedBefore(symbol),
                decl,
                expressionIndex + index
              );
            }

            const afterOk =
              (expression[index + 1] === " " &&
                !isWhitespace(expression[index + 2])) ||
              expression[index + 1] === "\n" ||
              expression.substr(index + 1, 2) === "\r\n";

            if (!afterOk) {
              complain(
                messages.expectedAfter(symbol),
                decl,
                expressionIndex + index
              );
            }
          });
        }
      });
    });
  };
};

function blurVariables(source) {
  return source.replace(/[$@][^)\s]+|#{.+?}/g, "0");
}

function newlineBefore(str, startIndex) {
  let index = startIndex;
  while (index && isWhitespace(str[index])) {
    if (str[index] === "\n") return true;
    index--;
  }
  return false;
}

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isWhitespace":1133,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"balanced-match":113,"postcss-value-parser":811,"style-search":870}],954:[function(require,module,exports){
"use strict";

const functionCommaSpaceChecker = require("../functionCommaSpaceChecker");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "function-comma-newline-after";

const messages = ruleMessages(ruleName, {
  expectedAfter: () => 'Expected newline after ","',
  expectedAfterMultiLine: () =>
    'Expected newline after "," in a multi-line function',
  rejectedAfterMultiLine: () =>
    'Unexpected whitespace after "," in a multi-line function'
});

const rule = function(expectation) {
  const checker = whitespaceChecker("newline", expectation, messages);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "always-multi-line", "never-multi-line"]
    });
    if (!validOptions) {
      return;
    }

    functionCommaSpaceChecker({
      root,
      result,
      locationChecker: checker.afterOneOnly,
      checkedRuleName: ruleName
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145,"../functionCommaSpaceChecker":969}],955:[function(require,module,exports){
"use strict";

const functionCommaSpaceChecker = require("../functionCommaSpaceChecker");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "function-comma-newline-before";

const messages = ruleMessages(ruleName, {
  expectedBefore: () => 'Expected newline before ","',
  expectedBeforeMultiLine: () =>
    'Expected newline before "," in a multi-line function',
  rejectedBeforeMultiLine: () =>
    'Unexpected whitespace before "," in a multi-line function'
});

const rule = function(expectation) {
  const checker = whitespaceChecker("newline", expectation, messages);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "always-multi-line", "never-multi-line"]
    });
    if (!validOptions) {
      return;
    }

    functionCommaSpaceChecker({
      root,
      result,
      locationChecker: checker.beforeAllowingIndentation,
      checkedRuleName: ruleName
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145,"../functionCommaSpaceChecker":969}],956:[function(require,module,exports){
"use strict";

const functionCommaSpaceChecker = require("../functionCommaSpaceChecker");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "function-comma-space-after";

const messages = ruleMessages(ruleName, {
  expectedAfter: () => 'Expected single space after ","',
  rejectedAfter: () => 'Unexpected whitespace after ","',
  expectedAfterSingleLine: () =>
    'Expected single space after "," in a single-line function',
  rejectedAfterSingleLine: () =>
    'Unexpected whitespace after "," in a single-line function'
});

const rule = function(expectation) {
  const checker = whitespaceChecker("space", expectation, messages);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "never", "always-single-line", "never-single-line"]
    });
    if (!validOptions) {
      return;
    }

    functionCommaSpaceChecker({
      root,
      result,
      locationChecker: checker.after,
      checkedRuleName: ruleName
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145,"../functionCommaSpaceChecker":969}],957:[function(require,module,exports){
"use strict";

const functionCommaSpaceChecker = require("../functionCommaSpaceChecker");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "function-comma-space-before";

const messages = ruleMessages(ruleName, {
  expectedBefore: () => 'Expected single space before ","',
  rejectedBefore: () => 'Unexpected whitespace before ","',
  expectedBeforeSingleLine: () =>
    'Expected single space before "," in a single-line function',
  rejectedBeforeSingleLine: () =>
    'Unexpected whitespace before "," in a single-line function'
});

const rule = function(expectation) {
  const checker = whitespaceChecker("space", expectation, messages);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "never", "always-single-line", "never-single-line"]
    });
    if (!validOptions) {
      return;
    }

    functionCommaSpaceChecker({
      root,
      result,
      locationChecker: checker.before,
      checkedRuleName: ruleName
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145,"../functionCommaSpaceChecker":969}],958:[function(require,module,exports){
"use strict";

const declarationValueIndex = require("../../utils/declarationValueIndex");
const functionArgumentsSearch = require("../../utils/functionArgumentsSearch");
const postcss = require("postcss");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const valueParser = require("postcss-value-parser");

const ruleName = "function-linear-gradient-no-nonstandard-direction";

const messages = ruleMessages(ruleName, {
  rejected: "Unexpected nonstandard direction"
});

function isStandardDirection(source, withToPrefix) {
  const regexp = withToPrefix
    ? /^to (top|left|bottom|right)(?: (top|left|bottom|right))?$/
    : /^(top|left|bottom|right)(?: (top|left|bottom|right))?$/;

  const matches = source.match(regexp);
  if (!matches) {
    return false;
  }
  if (matches.length === 2) {
    return true;
  }
  // Cannot repeat side-or-corner, e.g. "to top top"
  if (matches.length === 3 && matches[1] !== matches[2]) {
    return true;
  }
  return false;
}

const rule = function(actual) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, { actual });
    if (!validOptions) {
      return;
    }

    root.walkDecls(decl => {
      valueParser(decl.value).walk(valueNode => {
        if (valueNode.type !== "function") {
          return;
        }
        functionArgumentsSearch(
          valueParser.stringify(valueNode).toLowerCase(),
          "linear-gradient",
          (expression, expressionIndex) => {
            const firstArg = expression.split(",")[0].trim();

            // If the first character is a number, we can assume the user intends an angle
            if (/[\d.]/.test(firstArg[0])) {
              if (/^[\d.]+(?:deg|grad|rad|turn)$/.test(firstArg)) {
                return;
              }
              complain();
              return;
            }

            // The first argument may not be a direction: it may be an angle,
            // or a color stop (in which case user gets default direction, "to bottom")
            // cf. https://drafts.csswg.org/css-images-3/#linear-gradient-syntax
            if (!/left|right|top|bottom/.test(firstArg)) {
              return;
            }

            const withToPrefix = !postcss.vendor.prefix(valueNode.value);
            if (!isStandardDirection(firstArg, withToPrefix)) {
              complain();
              return;
            }

            function complain() {
              report({
                message: messages.rejected,
                node: decl,
                index:
                  declarationValueIndex(decl) +
                  valueNode.sourceIndex +
                  expressionIndex,
                result,
                ruleName
              });
            }
          }
        );
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/declarationValueIndex":1080,"../../utils/functionArgumentsSearch":1084,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"postcss":828,"postcss-value-parser":811}],959:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const styleSearch = require("style-search");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "function-max-empty-lines";

const messages = ruleMessages(ruleName, {
  expected: max =>
    `Expected no more than ${max} empty ${max === 1 ? "line" : "lines"}`
});

const rule = function(max) {
  const maxAdjacentNewlines = max + 1;

  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: max,
      possible: _.isNumber
    });
    if (!validOptions) {
      return;
    }

    root.walkDecls(decl => {
      if (decl.value.indexOf("(") === -1) {
        return;
      }

      const declString = decl.toString();
      const repeatLFNewLines = _.repeat("\n", maxAdjacentNewlines);
      const repeatCRLFNewLines = _.repeat("\r\n", maxAdjacentNewlines);

      styleSearch(
        {
          source: declString,
          target: "\n",
          functionArguments: "only"
        },
        match => {
          if (
            declString.substr(match.startIndex + 1, maxAdjacentNewlines) ===
              repeatLFNewLines ||
            declString.substr(match.startIndex + 1, maxAdjacentNewlines * 2) ===
              repeatCRLFNewLines
          ) {
            // Put index at `\r` if it's CRLF, otherwise leave it at `\n`
            let index = match.startIndex;
            if (declString[index - 1] === "\r") {
              index -= 1;
            }

            report({
              message: messages.expected(max),
              node: decl,
              index,
              result,
              ruleName
            });
          }
        }
      );
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"style-search":870}],960:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const declarationValueIndex = require("../../utils/declarationValueIndex");
const isStandardSyntaxFunction = require("../../utils/isStandardSyntaxFunction");
const keywordSets = require("../../reference/keywordSets");
const matchesStringOrRegExp = require("../../utils/matchesStringOrRegExp");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const valueParser = require("postcss-value-parser");

const ruleName = "function-name-case";

const messages = ruleMessages(ruleName, {
  expected: (actual, expected) => `Expected "${actual}" to be "${expected}"`
});

const mapLowercaseFunctionNamesToCamelCase = new Map();
keywordSets.camelCaseFunctionNames.forEach(func => {
  mapLowercaseFunctionNamesToCamelCase.set(func.toLowerCase(), func);
});

const rule = function(expectation, options) {
  return (root, result) => {
    const validOptions = validateOptions(
      result,
      ruleName,
      {
        actual: expectation,
        possible: ["lower", "upper"]
      },
      {
        actual: options,
        possible: {
          ignoreFunctions: [_.isString]
        },
        optional: true
      }
    );
    if (!validOptions) {
      return;
    }

    root.walkDecls(decl => {
      const value = decl.value;

      valueParser(value).walk(function(node) {
        if (node.type !== "function" || !isStandardSyntaxFunction(node)) {
          return;
        }

        const functionName = node.value;
        const functionNameLowerCase = functionName.toLowerCase();

        const ignoreFunctions = (options && options.ignoreFunctions) || [];

        if (
          ignoreFunctions.length > 0 &&
          matchesStringOrRegExp(functionName, ignoreFunctions)
        ) {
          return;
        }

        let expectedFunctionName = null;

        if (
          expectation === "lower" &&
          mapLowercaseFunctionNamesToCamelCase.has(functionNameLowerCase)
        ) {
          expectedFunctionName = mapLowercaseFunctionNamesToCamelCase.get(
            functionNameLowerCase
          );
        } else if (expectation === "lower") {
          expectedFunctionName = functionNameLowerCase;
        } else {
          expectedFunctionName = functionName.toUpperCase();
        }

        if (functionName === expectedFunctionName) {
          return;
        }

        report({
          message: messages.expected(functionName, expectedFunctionName),
          node: decl,
          index: declarationValueIndex(decl) + node.sourceIndex,
          result,
          ruleName
        });
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../reference/keywordSets":888,"../../utils/declarationValueIndex":1080,"../../utils/isStandardSyntaxFunction":1122,"../../utils/matchesStringOrRegExp":1134,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"postcss-value-parser":811}],961:[function(require,module,exports){
"use strict";

const declarationValueIndex = require("../../utils/declarationValueIndex");
const isSingleLineString = require("../../utils/isSingleLineString");
const isStandardSyntaxFunction = require("../../utils/isStandardSyntaxFunction");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const valueParser = require("postcss-value-parser");

const ruleName = "function-parentheses-newline-inside";

const messages = ruleMessages(ruleName, {
  expectedOpening: 'Expected newline after "("',
  expectedClosing: 'Expected newline before ")"',
  expectedOpeningMultiLine:
    'Expected newline after "(" in a multi-line function',
  rejectedOpeningMultiLine:
    'Unexpected whitespace after "(" in a multi-line function',
  expectedClosingMultiLine:
    'Expected newline before ")" in a multi-line function',
  rejectedClosingMultiLine:
    'Unexpected whitespace before ")" in a multi-line function'
});

const rule = function(expectation) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "always-multi-line", "never-multi-line"]
    });
    if (!validOptions) {
      return;
    }

    root.walkDecls(decl => {
      if (decl.value.indexOf("(") === -1) {
        return;
      }

      valueParser(decl.value).walk(valueNode => {
        if (valueNode.type !== "function") {
          return;
        }

        if (!isStandardSyntaxFunction(valueNode)) {
          return;
        }

        const functionString = valueParser.stringify(valueNode);
        const isMultiLine = !isSingleLineString(functionString);
        function containsNewline(str) {
          return str.indexOf("\n") !== -1;
        }

        // Check opening ...

        const openingIndex = valueNode.sourceIndex + valueNode.value.length + 1;

        if (expectation === "always" && !containsNewline(valueNode.before)) {
          complain(messages.expectedOpening, openingIndex);
        }

        if (
          isMultiLine &&
          expectation === "always-multi-line" &&
          !containsNewline(valueNode.before)
        ) {
          complain(messages.expectedOpeningMultiLine, openingIndex);
        }

        if (
          isMultiLine &&
          expectation === "never-multi-line" &&
          valueNode.before !== ""
        ) {
          complain(messages.rejectedOpeningMultiLine, openingIndex);
        }

        // Check closing ...

        const closingIndex = valueNode.sourceIndex + functionString.length - 2;

        if (expectation === "always" && !containsNewline(valueNode.after)) {
          complain(messages.expectedClosing, closingIndex);
        }

        if (
          isMultiLine &&
          expectation === "always-multi-line" &&
          !containsNewline(valueNode.after)
        ) {
          complain(messages.expectedClosingMultiLine, closingIndex);
        }

        if (
          isMultiLine &&
          expectation === "never-multi-line" &&
          valueNode.after !== ""
        ) {
          complain(messages.rejectedClosingMultiLine, closingIndex);
        }
      });

      function complain(message, offset) {
        report({
          ruleName,
          result,
          message,
          node: decl,
          index: declarationValueIndex(decl) + offset
        });
      }
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/declarationValueIndex":1080,"../../utils/isSingleLineString":1119,"../../utils/isStandardSyntaxFunction":1122,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"postcss-value-parser":811}],962:[function(require,module,exports){
"use strict";

const declarationValueIndex = require("../../utils/declarationValueIndex");
const isSingleLineString = require("../../utils/isSingleLineString");
const isStandardSyntaxFunction = require("../../utils/isStandardSyntaxFunction");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const valueParser = require("postcss-value-parser");

const ruleName = "function-parentheses-space-inside";

const messages = ruleMessages(ruleName, {
  expectedOpening: 'Expected single space after "("',
  rejectedOpening: 'Unexpected whitespace after "("',
  expectedClosing: 'Expected single space before ")"',
  rejectedClosing: 'Unexpected whitespace before ")"',
  expectedOpeningSingleLine:
    'Expected single space after "(" in a single-line function',
  rejectedOpeningSingleLine:
    'Unexpected whitespace after "(" in a single-line function',
  expectedClosingSingleLine:
    'Expected single space before ")" in a single-line function',
  rejectedClosingSingleLine:
    'Unexpected whitespace before ")" in a single-line function'
});

const rule = function(expectation) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "never", "always-single-line", "never-single-line"]
    });
    if (!validOptions) {
      return;
    }

    root.walkDecls(decl => {
      if (decl.value.indexOf("(") === -1) {
        return;
      }

      valueParser(decl.value).walk(valueNode => {
        if (valueNode.type !== "function") {
          return;
        }

        if (!isStandardSyntaxFunction(valueNode)) {
          return;
        }

        // Ignore function without parameters
        if (!valueNode.nodes.length) {
          return;
        }

        const functionString = valueParser.stringify(valueNode);
        const isSingleLine = isSingleLineString(functionString);

        // Check opening ...

        const openingIndex = valueNode.sourceIndex + valueNode.value.length + 1;

        if (expectation === "always" && valueNode.before !== " ") {
          complain(messages.expectedOpening, openingIndex);
        }

        if (expectation === "never" && valueNode.before !== "") {
          complain(messages.rejectedOpening, openingIndex);
        }

        if (
          isSingleLine &&
          expectation === "always-single-line" &&
          valueNode.before !== " "
        ) {
          complain(messages.expectedOpeningSingleLine, openingIndex);
        }

        if (
          isSingleLine &&
          expectation === "never-single-line" &&
          valueNode.before !== ""
        ) {
          complain(messages.rejectedOpeningSingleLine, openingIndex);
        }

        // Check closing ...

        const closingIndex = valueNode.sourceIndex + functionString.length - 2;

        if (expectation === "always" && valueNode.after !== " ") {
          complain(messages.expectedClosing, closingIndex);
        }

        if (expectation === "never" && valueNode.after !== "") {
          complain(messages.rejectedClosing, closingIndex);
        }

        if (
          isSingleLine &&
          expectation === "always-single-line" &&
          valueNode.after !== " "
        ) {
          complain(messages.expectedClosingSingleLine, closingIndex);
        }

        if (
          isSingleLine &&
          expectation === "never-single-line" &&
          valueNode.after !== ""
        ) {
          complain(messages.rejectedClosingSingleLine, closingIndex);
        }
      });

      function complain(message, offset) {
        report({
          ruleName,
          result,
          message,
          node: decl,
          index: declarationValueIndex(decl) + offset
        });
      }
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/declarationValueIndex":1080,"../../utils/isSingleLineString":1119,"../../utils/isStandardSyntaxFunction":1122,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"postcss-value-parser":811}],963:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const functionArgumentsSearch = require("../../utils/functionArgumentsSearch");
const isStandardSyntaxUrl = require("../../utils/isStandardSyntaxUrl");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "function-url-no-scheme-relative";

const messages = ruleMessages(ruleName, {
  rejected: "Unexpected scheme-relative url"
});

const rule = function(actual) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, { actual });
    if (!validOptions) {
      return;
    }

    root.walkDecls(function(decl) {
      functionArgumentsSearch(
        decl.toString().toLowerCase(),
        "url",
        (args, index) => {
          const url = _.trim(args, " '\"");

          if (!isStandardSyntaxUrl(url) || url.indexOf("//") !== 0) {
            return;
          }

          report({
            message: messages.rejected,
            node: decl,
            index,
            result,
            ruleName
          });
        }
      );
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/functionArgumentsSearch":1084,"../../utils/isStandardSyntaxUrl":1128,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692}],964:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const atRuleParamIndex = require("../../utils/atRuleParamIndex");
const functionArgumentsSearch = require("../../utils/functionArgumentsSearch");
const isStandardSyntaxUrl = require("../../utils/isStandardSyntaxUrl");
const optionsMatches = require("../../utils/optionsMatches");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "function-url-quotes";

const messages = ruleMessages(ruleName, {
  expected: () => "Expected quotes",
  rejected: () => "Unexpected quotes"
});

const rule = function(expectation, options) {
  return (root, result) => {
    const validOptions = validateOptions(
      result,
      ruleName,
      {
        actual: expectation,
        possible: ["always", "never"]
      },
      {
        actual: options,
        possible: {
          except: ["empty"]
        },
        optional: true
      }
    );
    if (!validOptions) {
      return;
    }

    root.walkAtRules(checkStatement);
    root.walkRules(checkStatement);

    function checkStatement(statement) {
      if (statement.type === "atrule") {
        checkAtRuleParams(statement);
      }

      statement.walkDecls(function(decl) {
        functionArgumentsSearch(
          decl.toString().toLowerCase(),
          "url",
          (args, index) => {
            checkArgs(args, decl, index, "url");
          }
        );
      });
    }

    function checkAtRuleParams(atRule) {
      const atRuleParamsLowerCase = atRule.params.toLowerCase();
      functionArgumentsSearch(atRuleParamsLowerCase, "url", (args, index) => {
        checkArgs(args, atRule, index + atRuleParamIndex(atRule), "url");
      });
      functionArgumentsSearch(
        atRuleParamsLowerCase,
        "url-prefix",
        (args, index) => {
          checkArgs(
            args,
            atRule,
            index + atRuleParamIndex(atRule),
            "url-prefix"
          );
        }
      );
      functionArgumentsSearch(
        atRuleParamsLowerCase,
        "domain",
        (args, index) => {
          checkArgs(args, atRule, index + atRuleParamIndex(atRule), "domain");
        }
      );
    }

    function checkArgs(args, node, index, functionName) {
      let shouldHasQuotes = expectation === "always";

      const leftTrimmedArgs = args.trimLeft();
      if (!isStandardSyntaxUrl(leftTrimmedArgs)) {
        return;
      }
      const complaintIndex = index + args.length - leftTrimmedArgs.length;
      const hasQuotes =
        leftTrimmedArgs[0] === "'" || leftTrimmedArgs[0] === '"';

      const trimmedArg = args.trim();
      const isEmptyArgument = _.includes(["", "''", '""'], trimmedArg);
      if (optionsMatches(options, "except", "empty") && isEmptyArgument) {
        shouldHasQuotes = !shouldHasQuotes;
      }

      if (shouldHasQuotes) {
        if (hasQuotes) {
          return;
        }
        complain(messages.expected(functionName), node, complaintIndex);
      } else {
        if (!hasQuotes) {
          return;
        }
        complain(messages.rejected(functionName), node, complaintIndex);
      }
    }

    function complain(message, node, index) {
      report({
        message,
        node,
        index,
        result,
        ruleName
      });
    }
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/atRuleParamIndex":1071,"../../utils/functionArgumentsSearch":1084,"../../utils/isStandardSyntaxUrl":1128,"../../utils/optionsMatches":1137,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692}],965:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const functionArgumentsSearch = require("../../utils/functionArgumentsSearch");
const getSchemeFromUrl = require("../../utils/getSchemeFromUrl");
const isStandardSyntaxUrl = require("../../utils/isStandardSyntaxUrl");
const matchesStringOrRegExp = require("../../utils/matchesStringOrRegExp");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "function-url-scheme-blacklist";

const messages = ruleMessages(ruleName, {
  rejected: scheme => `Unexpected URL scheme "${scheme}:"`
});

const rule = function(blacklist) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: blacklist,
      possible: [_.isString]
    });
    if (!validOptions) {
      return;
    }

    root.walkDecls(function(decl) {
      functionArgumentsSearch(
        decl.toString().toLowerCase(),
        "url",
        (args, index) => {
          const unspacedUrlString = _.trim(args, " ");
          if (!isStandardSyntaxUrl(unspacedUrlString)) {
            return;
          }
          const urlString = _.trim(unspacedUrlString, "'\"");
          const scheme = getSchemeFromUrl(urlString);

          if (scheme === null) {
            return;
          }

          if (!matchesStringOrRegExp(scheme, blacklist)) {
            return;
          }

          report({
            message: messages.rejected(scheme),
            node: decl,
            index,
            result,
            ruleName
          });
        }
      );
    });
  };
};

rule.primaryOptionArray = true;

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/functionArgumentsSearch":1084,"../../utils/getSchemeFromUrl":1090,"../../utils/isStandardSyntaxUrl":1128,"../../utils/matchesStringOrRegExp":1134,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692}],966:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const functionArgumentsSearch = require("../../utils/functionArgumentsSearch");
const getSchemeFromUrl = require("../../utils/getSchemeFromUrl");
const isStandardSyntaxUrl = require("../../utils/isStandardSyntaxUrl");
const matchesStringOrRegExp = require("../../utils/matchesStringOrRegExp");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "function-url-scheme-whitelist";

const messages = ruleMessages(ruleName, {
  rejected: scheme => `Unexpected URL scheme "${scheme}:"`
});

const rule = function(whitelist) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: whitelist,
      possible: [_.isString]
    });
    if (!validOptions) {
      return;
    }

    root.walkDecls(function(decl) {
      functionArgumentsSearch(
        decl.toString().toLowerCase(),
        "url",
        (args, index) => {
          const unspacedUrlString = _.trim(args, " ");
          if (!isStandardSyntaxUrl(unspacedUrlString)) {
            return;
          }
          const urlString = _.trim(unspacedUrlString, "'\"");
          const scheme = getSchemeFromUrl(urlString);

          if (scheme === null) {
            return;
          }

          if (matchesStringOrRegExp(scheme, whitelist)) {
            return;
          }

          report({
            message: messages.rejected(scheme),
            node: decl,
            index,
            result,
            ruleName
          });
        }
      );
    });
  };
};

rule.primaryOptionArray = true;

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/functionArgumentsSearch":1084,"../../utils/getSchemeFromUrl":1090,"../../utils/isStandardSyntaxUrl":1128,"../../utils/matchesStringOrRegExp":1134,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692}],967:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const declarationValueIndex = require("../../utils/declarationValueIndex");
const isStandardSyntaxFunction = require("../../utils/isStandardSyntaxFunction");
const matchesStringOrRegExp = require("../../utils/matchesStringOrRegExp");
const postcss = require("postcss");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const valueParser = require("postcss-value-parser");

const ruleName = "function-whitelist";

const messages = ruleMessages(ruleName, {
  rejected: name => `Unexpected function "${name}"`
});

const rule = function(whitelistInput) {
  const whitelist = [].concat(whitelistInput);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: whitelist,
      possible: [_.isString]
    });
    if (!validOptions) {
      return;
    }
    root.walkDecls(decl => {
      const value = decl.value;

      valueParser(value).walk(function(node) {
        if (node.type !== "function") {
          return;
        }
        if (!isStandardSyntaxFunction(node)) {
          return;
        }
        if (
          matchesStringOrRegExp(
            postcss.vendor.unprefixed(node.value),
            whitelist
          )
        ) {
          return;
        }
        report({
          message: messages.rejected(node.value),
          node: decl,
          index: declarationValueIndex(decl) + node.sourceIndex,
          result,
          ruleName
        });
      });
    });
  };
};

rule.primaryOptionArray = true;

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/declarationValueIndex":1080,"../../utils/isStandardSyntaxFunction":1122,"../../utils/matchesStringOrRegExp":1134,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"postcss":828,"postcss-value-parser":811}],968:[function(require,module,exports){
"use strict";

const isWhitespace = require("../../utils/isWhitespace");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const styleSearch = require("style-search");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "function-whitespace-after";

const messages = ruleMessages(ruleName, {
  expected: 'Expected whitespace after ")"',
  rejected: 'Unexpected whitespace after ")"'
});

const ACCEPTABLE_AFTER_CLOSING_PAREN = new Set([")", ",", "}", ":", undefined]);

const rule = function(expectation) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "never"]
    });
    if (!validOptions) {
      return;
    }

    root.walkDecls(decl => {
      const declString = decl.toString();

      styleSearch(
        {
          source: declString,
          target: ")",
          functionArguments: "only"
        },
        match => {
          checkClosingParen(declString, match.startIndex, decl);
        }
      );
    });

    function checkClosingParen(source, index, node) {
      const nextChar = source[index + 1];
      if (expectation === "always") {
        // Allow for the next character to be a single empty space,
        // another closing parenthesis, a comma, or the end of the value
        if (nextChar === " ") {
          return;
        }
        if (nextChar === "\n") {
          return;
        }
        if (source.substr(index + 1, 2) === "\r\n") {
          return;
        }
        if (ACCEPTABLE_AFTER_CLOSING_PAREN.has(nextChar)) {
          return;
        }
        report({
          message: messages.expected,
          node,
          index: index + 1,
          result,
          ruleName
        });
      } else if (expectation === "never") {
        if (isWhitespace(nextChar)) {
          report({
            message: messages.rejected,
            node,
            index: index + 1,
            result,
            ruleName
          });
        }
      }
    }
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isWhitespace":1133,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"style-search":870}],969:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const declarationValueIndex = require("../utils/declarationValueIndex");
const isStandardSyntaxFunction = require("../utils/isStandardSyntaxFunction");
const report = require("../utils/report");
const styleSearch = require("style-search");
const valueParser = require("postcss-value-parser");

module.exports = function(opts) {
  opts.root.walkDecls(decl => {
    const declValue = _.get(decl, "raws.value.raw", decl.value);

    valueParser(declValue).walk(valueNode => {
      if (valueNode.type !== "function") {
        return;
      }

      if (!isStandardSyntaxFunction(valueNode)) {
        return;
      }

      // Ignore `url()` arguments, which may contain data URIs or other funky stuff
      if (valueNode.value.toLowerCase() === "url") {
        return;
      }

      const functionArguments = (() => {
        let result = valueParser.stringify(valueNode);
        // Remove function name and opening paren
        result = result.slice(valueNode.value.length + 1);
        // Remove closing paren
        result = result.slice(0, result.length - 1);
        // 1. Remove comments including preceeding whitespace (when only succeeded by whitespace)
        // 2. Remove all other comments, but leave adjacent whitespace intact
        result = result.replace(
          /( *\/(\*.*\*\/(?!\S)|\/.*)|(\/(\*.*\*\/|\/.*)))/,
          ""
        );
        return result;
      })();

      styleSearch(
        {
          source: functionArguments,
          target: ",",
          functionArguments: "skip"
        },
        match => {
          opts.locationChecker({
            source: functionArguments,
            index: match.startIndex,
            err: message => {
              const index =
                declarationValueIndex(decl) +
                valueNode.value.length +
                1 +
                valueNode.sourceIndex +
                match.startIndex;
              report({
                index,
                message,
                node: decl,
                result: opts.result,
                ruleName: opts.checkedRuleName
              });
            }
          });
        }
      );
    });
  });
};

},{"../utils/declarationValueIndex":1080,"../utils/isStandardSyntaxFunction":1122,"../utils/report":1141,"lodash":692,"postcss-value-parser":811,"style-search":870}],970:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const beforeBlockString = require("../../utils/beforeBlockString");
const hasBlock = require("../../utils/hasBlock");
const optionsMatches = require("../../utils/optionsMatches");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const styleSearch = require("style-search");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "indentation";
const messages = ruleMessages(ruleName, {
  expected: x => `Expected indentation of ${x}`
});

/**
 * @param {number|"tab"} space - Number of whitespaces to expect, or else
 *   keyword "tab" for single `\t`
 * @param {object} [options]
 */
const rule = function(space, options, context) {
  options = options || {};

  const isTab = space === "tab";
  const indentChar = isTab ? "\t" : _.repeat(" ", space);
  const warningWord = isTab ? "tab" : "space";

  return (root, result) => {
    const validOptions = validateOptions(
      result,
      ruleName,
      {
        actual: space,
        possible: [_.isNumber, "tab"]
      },
      {
        actual: options,
        possible: {
          except: ["block", "value", "param"],
          ignore: ["value", "param", "inside-parens"],
          indentInsideParens: ["twice", "once-at-root-twice-in-block"],
          indentClosingBrace: [_.isBoolean]
        },
        optional: true
      }
    );
    if (!validOptions) {
      return;
    }

    // Cycle through all nodes using walk.
    root.walk(node => {
      const nodeLevel = indentationLevel(node);
      const expectedWhitespace = _.repeat(indentChar, nodeLevel);

      let before = node.raws.before || "";
      const after = node.raws.after || "";

      // Only inspect the spaces before the node
      // if this is the first node in root
      // or there is a newline in the `before` string.
      // (If there is no newline before a node,
      // there is no "indentation" to check.)
      const inspectBefore = root.first === node || before.indexOf("\n") !== -1;

      // Cut out any * and _ hacks from `before`
      if (
        before[before.length - 1] === "*" ||
        before[before.length - 1] === "_"
      ) {
        before = before.slice(0, before.length - 1);
      }

      // Inspect whitespace in the `before` string that is
      // *after* the *last* newline character,
      // because anything besides that is not indentation for this node:
      // it is some other kind of separation, checked by some separate rule
      if (
        inspectBefore &&
        before.slice(before.lastIndexOf("\n") + 1) !== expectedWhitespace
      ) {
        if (context.fix) {
          node.raws.before = fixIndentation(
            node.raws.before,
            expectedWhitespace
          );
        } else {
          report({
            message: messages.expected(legibleExpectation(nodeLevel)),
            node,
            result,
            ruleName
          });
        }
      }

      // Only blocks have the `after` string to check.
      // Only inspect `after` strings that start with a newline;
      // otherwise there's no indentation involved.
      // And check `indentClosingBrace` to see if it should be indented an extra level.
      const closingBraceLevel = options.indentClosingBrace
        ? nodeLevel + 1
        : nodeLevel;
      const expectedClosingBraceIndentation = _.repeat(
        indentChar,
        closingBraceLevel
      );
      if (
        hasBlock(node) &&
        after &&
        after.indexOf("\n") !== -1 &&
        after.slice(after.lastIndexOf("\n") + 1) !==
          expectedClosingBraceIndentation
      ) {
        if (context.fix) {
          node.raws.after = fixIndentation(
            node.raws.after,
            expectedClosingBraceIndentation
          );
        } else {
          report({
            message: messages.expected(legibleExpectation(closingBraceLevel)),
            node,
            index: node.toString().length - 1,
            result,
            ruleName
          });
        }
      }

      // If this is a declaration, check the value
      if (node.value) {
        checkValue(node, nodeLevel);
      }

      // If this is a rule, check the selector
      if (node.selector) {
        checkSelector(node, nodeLevel);
      }

      // If this is an at rule, check the params
      if (node.type === "atrule") {
        checkAtRuleParams(node, nodeLevel);
      }
    });

    function indentationLevel(node, level) {
      level = level || 0;

      if (node.parent.type === "root") {
        return level;
      }

      let calculatedLevel;

      // Indentation level equals the ancestor nodes
      // separating this node from root; so recursively
      // run this operation
      calculatedLevel = indentationLevel(node.parent, level + 1);

      // If options.except includes "block",
      // blocks are taken down one from their calculated level
      // (all blocks are the same level as their parents)
      if (
        optionsMatches(options, "except", "block") &&
        (node.type === "rule" || node.type === "atrule") &&
        hasBlock(node)
      ) {
        calculatedLevel--;
      }

      return calculatedLevel;
    }

    function checkValue(decl, declLevel) {
      if (decl.value.indexOf("\n") === -1) {
        return;
      }
      if (optionsMatches(options, "ignore", "value")) {
        return;
      }

      const declString = decl.toString();
      const valueLevel = optionsMatches(options, "except", "value")
        ? declLevel
        : declLevel + 1;

      checkMultilineBit(declString, valueLevel, decl);
    }

    function checkSelector(rule, ruleLevel) {
      const selector = rule.selector;

      // Less mixins have params, and they should be indented extra
      if (rule.params) {
        ruleLevel += 1;
      }

      checkMultilineBit(selector, ruleLevel, rule);
    }

    function checkAtRuleParams(atRule, ruleLevel) {
      if (optionsMatches(options, "ignore", "param")) {
        return;
      }

      // @nest rules should be treated like regular rules, not expected
      // to have their params (selectors) indented
      const paramLevel =
        optionsMatches(options, "except", "param") || atRule.name === "nest"
          ? ruleLevel
          : ruleLevel + 1;

      checkMultilineBit(beforeBlockString(atRule).trim(), paramLevel, atRule);
    }

    function checkMultilineBit(source, newlineIndentLevel, node) {
      if (source.indexOf("\n") === -1) {
        return;
      }

      // Data for current node fixing
      const fixPositions = [];

      // `outsideParens` because function arguments and also non-standard parenthesized stuff like
      // Sass maps are ignored to allow for arbitrary indentation
      let parentheticalDepth = 0;

      styleSearch(
        {
          source,
          target: "\n",
          outsideParens: optionsMatches(options, "ignore", "inside-parens")
        },
        (match, matchCount) => {
          const precedesClosingParenthesis = /^[ \t]*\)/.test(
            source.slice(match.startIndex + 1)
          );

          if (
            optionsMatches(options, "ignore", "inside-parens") &&
            (precedesClosingParenthesis || match.insideParens)
          ) {
            return;
          }

          let expectedIndentLevel = newlineIndentLevel;

          // Modififications for parenthetical content
          if (
            !optionsMatches(options, "ignore", "inside-parens") &&
            match.insideParens
          ) {
            // If the first match in is within parentheses, reduce the parenthesis penalty
            if (matchCount === 1) parentheticalDepth -= 1;

            // Account for windows line endings
            let newlineIndex = match.startIndex;
            if (source[match.startIndex - 1] === "\r") {
              newlineIndex--;
            }

            const followsOpeningParenthesis = /\([ \t]*$/.test(
              source.slice(0, newlineIndex)
            );
            if (followsOpeningParenthesis) {
              parentheticalDepth += 1;
            }

            expectedIndentLevel += parentheticalDepth;

            if (precedesClosingParenthesis) {
              parentheticalDepth -= 1;
            }

            switch (options.indentInsideParens) {
              case "twice":
                if (!precedesClosingParenthesis || options.indentClosingBrace) {
                  expectedIndentLevel += 1;
                }
                break;
              case "once-at-root-twice-in-block":
                if (node.parent === root) {
                  if (
                    precedesClosingParenthesis &&
                    !options.indentClosingBrace
                  ) {
                    expectedIndentLevel -= 1;
                  }
                  break;
                }
                if (!precedesClosingParenthesis || options.indentClosingBrace) {
                  expectedIndentLevel += 1;
                }
                break;
              default:
                if (precedesClosingParenthesis && !options.indentClosingBrace) {
                  expectedIndentLevel -= 1;
                }
            }
          }

          // Starting at the index after the newline, we want to
          // check that the whitespace characters (excluding newlines) before the first
          // non-whitespace character equal the expected indentation
          const afterNewlineSpaceMatches = /^([ \t]*)\S/.exec(
            source.slice(match.startIndex + 1)
          );

          if (!afterNewlineSpaceMatches) {
            return;
          }

          const afterNewlineSpace = afterNewlineSpaceMatches[1];
          const expectedIndentation = _.repeat(indentChar, expectedIndentLevel);

          if (afterNewlineSpace !== expectedIndentation) {
            if (context.fix) {
              // Adding fixes position in reverse order, because if we change indent in the beginning of the string it will break all following fixes for that string
              fixPositions.unshift({
                expectedIndentation,
                currentIndentation: afterNewlineSpace,
                startIndex: match.startIndex
              });
            } else {
              report({
                message: messages.expected(
                  legibleExpectation(expectedIndentLevel)
                ),
                node,
                index: match.startIndex + afterNewlineSpace.length + 1,
                result,
                ruleName
              });
            }
          }
        }
      );

      if (fixPositions.length) {
        if (node.type === "rule") {
          fixPositions.forEach(function(fixPosition) {
            node.selector = replaceIndentation(
              node.selector,
              fixPosition.currentIndentation,
              fixPosition.expectedIndentation,
              fixPosition.startIndex
            );
          });
        }

        if (node.type === "decl") {
          const declProp = node.prop;
          const declBetween = node.raws.between;

          fixPositions.forEach(function(fixPosition) {
            if (fixPosition.startIndex < declProp.length + declBetween.length) {
              node.raws.between = replaceIndentation(
                declBetween,
                fixPosition.currentIndentation,
                fixPosition.expectedIndentation,
                fixPosition.startIndex - declProp.length
              );
            } else {
              node.value = replaceIndentation(
                node.value,
                fixPosition.currentIndentation,
                fixPosition.expectedIndentation,
                fixPosition.startIndex - declProp.length - declBetween.length
              );
            }
          });
        }

        if (node.type === "atrule") {
          const atRuleName = node.name;
          const atRuleAfterName = node.raws.afterName;
          const atRuleParams = node.params;

          fixPositions.forEach(function(fixPosition) {
            // 1 — it's a @ length
            if (
              fixPosition.startIndex <
              1 + atRuleName.length + atRuleAfterName.length
            ) {
              node.raws.afterName = replaceIndentation(
                atRuleAfterName,
                fixPosition.currentIndentation,
                fixPosition.expectedIndentation,
                fixPosition.startIndex - atRuleName.length - 1
              );
            } else {
              node.params = replaceIndentation(
                atRuleParams,
                fixPosition.currentIndentation,
                fixPosition.expectedIndentation,
                fixPosition.startIndex -
                  atRuleName.length -
                  atRuleAfterName.length -
                  1
              );
            }
          });
        }
      }
    }
  };

  function legibleExpectation(level) {
    const count = isTab ? level : level * space;
    const quantifiedWarningWord = count === 1 ? warningWord : warningWord + "s";

    return `${count} ${quantifiedWarningWord}`;
  }
};

function fixIndentation(str, whitespace) {
  if (!_.isString(str)) {
    return str;
  }

  const strLength = str.length;

  if (!strLength) {
    return str;
  }

  let stringEnd = str[strLength - 1];

  if (stringEnd !== "*" && stringEnd !== "_") {
    stringEnd = "";
  }

  const stringStart = str.slice(0, str.lastIndexOf("\n") + 1);

  return stringStart + whitespace + stringEnd;
}

function replaceIndentation(input, searchString, replaceString, startIndex) {
  const offset = startIndex + 1;
  const stringStart = input.slice(0, offset);
  const stringEnd = input.slice(offset + searchString.length);

  return stringStart + replaceString + stringEnd;
}

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/beforeBlockString":1072,"../../utils/hasBlock":1092,"../../utils/optionsMatches":1137,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"style-search":870}],971:[function(require,module,exports){
"use strict";

const atRuleBlacklist = require("./at-rule-blacklist");
const atRuleEmptyLineBefore = require("./at-rule-empty-line-before");
const atRuleNameCase = require("./at-rule-name-case");
const atRuleNameNewlineAfter = require("./at-rule-name-newline-after");
const atRuleNameSpaceAfter = require("./at-rule-name-space-after");
const atRuleNoUnknown = require("./at-rule-no-unknown");
const atRuleNoVendorPrefix = require("./at-rule-no-vendor-prefix");
const atRuleSemicolonNewlineAfter = require("./at-rule-semicolon-newline-after");
const atRuleSemicolonSpaceBefore = require("./at-rule-semicolon-space-before");
const atRuleWhitelist = require("./at-rule-whitelist");
const blockClosingBraceEmptyLineBefore = require("./block-closing-brace-empty-line-before");
const blockClosingBraceNewlineAfter = require("./block-closing-brace-newline-after");
const blockClosingBraceNewlineBefore = require("./block-closing-brace-newline-before");
const blockClosingBraceSpaceAfter = require("./block-closing-brace-space-after");
const blockClosingBraceSpaceBefore = require("./block-closing-brace-space-before");
const blockNoEmpty = require("./block-no-empty");
const blockOpeningBraceNewlineAfter = require("./block-opening-brace-newline-after");
const blockOpeningBraceNewlineBefore = require("./block-opening-brace-newline-before");
const blockOpeningBraceSpaceAfter = require("./block-opening-brace-space-after");
const blockOpeningBraceSpaceBefore = require("./block-opening-brace-space-before");
const colorHexCase = require("./color-hex-case");
const colorHexLength = require("./color-hex-length");
const colorNamed = require("./color-named");
const colorNoHex = require("./color-no-hex");
const colorNoInvalidHex = require("./color-no-invalid-hex");
const commentEmptyLineBefore = require("./comment-empty-line-before");
const commentNoEmpty = require("./comment-no-empty");
const commentWhitespaceInside = require("./comment-whitespace-inside");
const commentWordBlacklist = require("./comment-word-blacklist");
const customMediaPattern = require("./custom-media-pattern");
const customPropertyEmptyLineBefore = require("./custom-property-empty-line-before");
const customPropertyPattern = require("./custom-property-pattern");
const declarationBangSpaceAfter = require("./declaration-bang-space-after");
const declarationBangSpaceBefore = require("./declaration-bang-space-before");
const declarationBlockNoDuplicateProperties = require("./declaration-block-no-duplicate-properties");
const declarationBlockNoRedundantLonghandProperties = require("./declaration-block-no-redundant-longhand-properties");
const declarationBlockNoShorthandPropertyOverrides = require("./declaration-block-no-shorthand-property-overrides");
const declarationBlockSemicolonNewlineAfter = require("./declaration-block-semicolon-newline-after");
const declarationBlockSemicolonNewlineBefore = require("./declaration-block-semicolon-newline-before");
const declarationBlockSemicolonSpaceAfter = require("./declaration-block-semicolon-space-after");
const declarationBlockSemicolonSpaceBefore = require("./declaration-block-semicolon-space-before");
const declarationBlockSingleLineMaxDeclarations = require("./declaration-block-single-line-max-declarations");
const declarationBlockTrailingSemicolon = require("./declaration-block-trailing-semicolon");
const declarationColonNewlineAfter = require("./declaration-colon-newline-after");
const declarationColonSpaceAfter = require("./declaration-colon-space-after");
const declarationColonSpaceBefore = require("./declaration-colon-space-before");
const declarationEmptyLineBefore = require("./declaration-empty-line-before");
const declarationNoImportant = require("./declaration-no-important");
const declarationPropertyUnitBlacklist = require("./declaration-property-unit-blacklist");
const declarationPropertyUnitWhitelist = require("./declaration-property-unit-whitelist");
const declarationPropertyValueBlacklist = require("./declaration-property-value-blacklist");
const declarationPropertyValueWhitelist = require("./declaration-property-value-whitelist");
const fontFamilyNameQuotes = require("./font-family-name-quotes");
const fontFamilyNoDuplicateNames = require("./font-family-no-duplicate-names");
const fontWeightNotation = require("./font-weight-notation");
const functionBlacklist = require("./function-blacklist");
const functionCalcNoUnspacedOperator = require("./function-calc-no-unspaced-operator");
const functionCommaNewlineAfter = require("./function-comma-newline-after");
const functionCommaNewlineBefore = require("./function-comma-newline-before");
const functionCommaSpaceAfter = require("./function-comma-space-after");
const functionCommaSpaceBefore = require("./function-comma-space-before");
const functionLinearGradientNoNonstandardDirection = require("./function-linear-gradient-no-nonstandard-direction");
const functionMaxEmptyLines = require("./function-max-empty-lines");
const functionNameCase = require("./function-name-case");
const functionParenthesesNewlineInside = require("./function-parentheses-newline-inside");
const functionParenthesesSpaceInside = require("./function-parentheses-space-inside");
const functionUrlNoSchemeRelative = require("./function-url-no-scheme-relative");
const functionUrlQuotes = require("./function-url-quotes");
const functionUrlSchemeBlacklist = require("./function-url-scheme-blacklist");
const functionUrlSchemeWhitelist = require("./function-url-scheme-whitelist");
const functionWhitelist = require("./function-whitelist");
const functionWhitespaceAfter = require("./function-whitespace-after");
const indentation = require("./indentation");
const keyframeDeclarationNoImportant = require("./keyframe-declaration-no-important");
const lengthZeroNoUnit = require("./length-zero-no-unit");
const maxEmptyLines = require("./max-empty-lines");
const maxLineLength = require("./max-line-length");
const maxNestingDepth = require("./max-nesting-depth");
const mediaFeatureColonSpaceAfter = require("./media-feature-colon-space-after");
const mediaFeatureColonSpaceBefore = require("./media-feature-colon-space-before");
const mediaFeatureNameBlacklist = require("./media-feature-name-blacklist");
const mediaFeatureNameCase = require("./media-feature-name-case");
const mediaFeatureNameNoUnknown = require("./media-feature-name-no-unknown");
const mediaFeatureNameNoVendorPrefix = require("./media-feature-name-no-vendor-prefix");
const mediaFeatureNameWhitelist = require("./media-feature-name-whitelist");
const mediaFeatureParenthesesSpaceInside = require("./media-feature-parentheses-space-inside");
const mediaFeatureRangeOperatorSpaceAfter = require("./media-feature-range-operator-space-after");
const mediaFeatureRangeOperatorSpaceBefore = require("./media-feature-range-operator-space-before");
const mediaQueryListCommaNewlineAfter = require("./media-query-list-comma-newline-after");
const mediaQueryListCommaNewlineBefore = require("./media-query-list-comma-newline-before");
const mediaQueryListCommaSpaceAfter = require("./media-query-list-comma-space-after");
const mediaQueryListCommaSpaceBefore = require("./media-query-list-comma-space-before");
const noDescendingSpecificity = require("./no-descending-specificity");
const noDuplicateSelectors = require("./no-duplicate-selectors");
const noEmptySource = require("./no-empty-source");
const noEolWhitespace = require("./no-eol-whitespace");
const noExtraSemicolons = require("./no-extra-semicolons");
const noInvalidDoubleSlashComments = require("./no-invalid-double-slash-comments");
const noMissingEndOfSourceNewline = require("./no-missing-end-of-source-newline");
const noUnknownAnimations = require("./no-unknown-animations");
const numberLeadingZero = require("./number-leading-zero");
const numberMaxPrecision = require("./number-max-precision");
const numberNoTrailingZeros = require("./number-no-trailing-zeros");
const propertyBlacklist = require("./property-blacklist");
const propertyCase = require("./property-case");
const propertyNoUnknown = require("./property-no-unknown");
const propertyNoVendorPrefix = require("./property-no-vendor-prefix");
const propertyWhitelist = require("./property-whitelist");
const ruleEmptyLineBefore = require("./rule-empty-line-before");
const selectorAttributeBracketsSpaceInside = require("./selector-attribute-brackets-space-inside");
const selectorAttributeOperatorBlacklist = require("./selector-attribute-operator-blacklist");
const selectorAttributeOperatorSpaceAfter = require("./selector-attribute-operator-space-after");
const selectorAttributeOperatorSpaceBefore = require("./selector-attribute-operator-space-before");
const selectorAttributeOperatorWhitelist = require("./selector-attribute-operator-whitelist");
const selectorAttributeQuotes = require("./selector-attribute-quotes");
const selectorClassPattern = require("./selector-class-pattern");
const selectorCombinatorSpaceAfter = require("./selector-combinator-space-after");
const selectorCombinatorSpaceBefore = require("./selector-combinator-space-before");
const selectorDescendantCombinatorNoNonSpace = require("./selector-descendant-combinator-no-non-space");
const selectorIdPattern = require("./selector-id-pattern");
const selectorListCommaNewlineAfter = require("./selector-list-comma-newline-after");
const selectorListCommaNewlineBefore = require("./selector-list-comma-newline-before");
const selectorListCommaSpaceAfter = require("./selector-list-comma-space-after");
const selectorListCommaSpaceBefore = require("./selector-list-comma-space-before");
const selectorMaxAttribute = require("./selector-max-attribute");
const selectorMaxClass = require("./selector-max-class");
const selectorMaxCombinators = require("./selector-max-combinators");
const selectorMaxCompoundSelectors = require("./selector-max-compound-selectors");
const selectorMaxEmptyLines = require("./selector-max-empty-lines");
const selectorMaxId = require("./selector-max-id");
const selectorMaxSpecificity = require("./selector-max-specificity");
const selectorMaxType = require("./selector-max-type");
const selectorMaxUniversal = require("./selector-max-universal");
const selectorNestedPattern = require("./selector-nested-pattern");
const selectorNoQualifyingType = require("./selector-no-qualifying-type");
const selectorNoVendorPrefix = require("./selector-no-vendor-prefix");
const selectorPseudoClassBlacklist = require("./selector-pseudo-class-blacklist");
const selectorPseudoClassCase = require("./selector-pseudo-class-case");
const selectorPseudoClassNoUnknown = require("./selector-pseudo-class-no-unknown");
const selectorPseudoClassParenthesesSpaceInside = require("./selector-pseudo-class-parentheses-space-inside");
const selectorPseudoClassWhitelist = require("./selector-pseudo-class-whitelist");
const selectorPseudoElementCase = require("./selector-pseudo-element-case");
const selectorPseudoElementColonNotation = require("./selector-pseudo-element-colon-notation");
const selectorPseudoElementNoUnknown = require("./selector-pseudo-element-no-unknown");
const selectorTypeCase = require("./selector-type-case");
const selectorTypeNoUnknown = require("./selector-type-no-unknown");
const shorthandPropertyNoRedundantValues = require("./shorthand-property-no-redundant-values");
const stringNoNewline = require("./string-no-newline");
const stringQuotes = require("./string-quotes");
const timeMinMilliseconds = require("./time-min-milliseconds");
const unitBlacklist = require("./unit-blacklist");
const unitCase = require("./unit-case");
const unitNoUnknown = require("./unit-no-unknown");
const unitWhitelist = require("./unit-whitelist");
const valueKeywordCase = require("./value-keyword-case");
const valueListCommaNewlineAfter = require("./value-list-comma-newline-after");
const valueListCommaNewlineBefore = require("./value-list-comma-newline-before");
const valueListCommaSpaceAfter = require("./value-list-comma-space-after");
const valueListCommaSpaceBefore = require("./value-list-comma-space-before");
const valueListMaxEmptyLines = require("./value-list-max-empty-lines");
const valueNoVendorPrefix = require("./value-no-vendor-prefix");

module.exports = {
  "at-rule-blacklist": atRuleBlacklist,
  "at-rule-empty-line-before": atRuleEmptyLineBefore,
  "at-rule-name-case": atRuleNameCase,
  "at-rule-name-newline-after": atRuleNameNewlineAfter,
  "at-rule-semicolon-space-before": atRuleSemicolonSpaceBefore,
  "at-rule-name-space-after": atRuleNameSpaceAfter,
  "at-rule-no-unknown": atRuleNoUnknown,
  "at-rule-no-vendor-prefix": atRuleNoVendorPrefix,
  "at-rule-semicolon-newline-after": atRuleSemicolonNewlineAfter,
  "at-rule-whitelist": atRuleWhitelist,
  "block-closing-brace-empty-line-before": blockClosingBraceEmptyLineBefore,
  "block-closing-brace-newline-after": blockClosingBraceNewlineAfter,
  "block-closing-brace-newline-before": blockClosingBraceNewlineBefore,
  "block-closing-brace-space-after": blockClosingBraceSpaceAfter,
  "block-closing-brace-space-before": blockClosingBraceSpaceBefore,
  "block-no-empty": blockNoEmpty,
  "block-opening-brace-newline-after": blockOpeningBraceNewlineAfter,
  "block-opening-brace-newline-before": blockOpeningBraceNewlineBefore,
  "block-opening-brace-space-after": blockOpeningBraceSpaceAfter,
  "block-opening-brace-space-before": blockOpeningBraceSpaceBefore,
  "color-hex-case": colorHexCase,
  "color-hex-length": colorHexLength,
  "color-named": colorNamed,
  "color-no-hex": colorNoHex,
  "color-no-invalid-hex": colorNoInvalidHex,
  "comment-empty-line-before": commentEmptyLineBefore,
  "comment-no-empty": commentNoEmpty,
  "comment-whitespace-inside": commentWhitespaceInside,
  "comment-word-blacklist": commentWordBlacklist,
  "custom-media-pattern": customMediaPattern,
  "custom-property-empty-line-before": customPropertyEmptyLineBefore,
  "custom-property-pattern": customPropertyPattern,
  "declaration-bang-space-after": declarationBangSpaceAfter,
  "declaration-bang-space-before": declarationBangSpaceBefore,
  "declaration-block-no-duplicate-properties": declarationBlockNoDuplicateProperties,
  "declaration-block-no-redundant-longhand-properties": declarationBlockNoRedundantLonghandProperties,
  "declaration-block-no-shorthand-property-overrides": declarationBlockNoShorthandPropertyOverrides,
  "declaration-block-semicolon-newline-after": declarationBlockSemicolonNewlineAfter,
  "declaration-block-semicolon-newline-before": declarationBlockSemicolonNewlineBefore,
  "declaration-block-semicolon-space-after": declarationBlockSemicolonSpaceAfter,
  "declaration-block-semicolon-space-before": declarationBlockSemicolonSpaceBefore,
  "declaration-block-single-line-max-declarations": declarationBlockSingleLineMaxDeclarations,
  "declaration-block-trailing-semicolon": declarationBlockTrailingSemicolon,
  "declaration-colon-newline-after": declarationColonNewlineAfter,
  "declaration-colon-space-after": declarationColonSpaceAfter,
  "declaration-colon-space-before": declarationColonSpaceBefore,
  "declaration-empty-line-before": declarationEmptyLineBefore,
  "declaration-no-important": declarationNoImportant,
  "declaration-property-unit-blacklist": declarationPropertyUnitBlacklist,
  "declaration-property-unit-whitelist": declarationPropertyUnitWhitelist,
  "declaration-property-value-blacklist": declarationPropertyValueBlacklist,
  "declaration-property-value-whitelist": declarationPropertyValueWhitelist,
  "font-family-name-quotes": fontFamilyNameQuotes,
  "font-family-no-duplicate-names": fontFamilyNoDuplicateNames,
  "font-weight-notation": fontWeightNotation,
  "function-blacklist": functionBlacklist,
  "function-calc-no-unspaced-operator": functionCalcNoUnspacedOperator,
  "function-comma-newline-after": functionCommaNewlineAfter,
  "function-comma-newline-before": functionCommaNewlineBefore,
  "function-comma-space-after": functionCommaSpaceAfter,
  "function-comma-space-before": functionCommaSpaceBefore,
  "function-linear-gradient-no-nonstandard-direction": functionLinearGradientNoNonstandardDirection,
  "function-max-empty-lines": functionMaxEmptyLines,
  "function-name-case": functionNameCase,
  "function-parentheses-newline-inside": functionParenthesesNewlineInside,
  "function-parentheses-space-inside": functionParenthesesSpaceInside,
  "function-url-no-scheme-relative": functionUrlNoSchemeRelative,
  "function-url-quotes": functionUrlQuotes,
  "function-url-scheme-blacklist": functionUrlSchemeBlacklist,
  "function-url-scheme-whitelist": functionUrlSchemeWhitelist,
  "function-whitelist": functionWhitelist,
  "function-whitespace-after": functionWhitespaceAfter,
  "keyframe-declaration-no-important": keyframeDeclarationNoImportant,
  "length-zero-no-unit": lengthZeroNoUnit,
  "max-empty-lines": maxEmptyLines,
  "max-line-length": maxLineLength,
  "max-nesting-depth": maxNestingDepth,
  "media-feature-colon-space-after": mediaFeatureColonSpaceAfter,
  "media-feature-colon-space-before": mediaFeatureColonSpaceBefore,
  "media-feature-name-blacklist": mediaFeatureNameBlacklist,
  "media-feature-name-case": mediaFeatureNameCase,
  "media-feature-name-no-unknown": mediaFeatureNameNoUnknown,
  "media-feature-name-no-vendor-prefix": mediaFeatureNameNoVendorPrefix,
  "media-feature-name-whitelist": mediaFeatureNameWhitelist,
  "media-feature-parentheses-space-inside": mediaFeatureParenthesesSpaceInside,
  "media-feature-range-operator-space-after": mediaFeatureRangeOperatorSpaceAfter,
  "media-feature-range-operator-space-before": mediaFeatureRangeOperatorSpaceBefore,
  "media-query-list-comma-newline-after": mediaQueryListCommaNewlineAfter,
  "media-query-list-comma-newline-before": mediaQueryListCommaNewlineBefore,
  "media-query-list-comma-space-after": mediaQueryListCommaSpaceAfter,
  "media-query-list-comma-space-before": mediaQueryListCommaSpaceBefore,
  "no-descending-specificity": noDescendingSpecificity,
  "no-duplicate-selectors": noDuplicateSelectors,
  "no-empty-source": noEmptySource,
  "no-eol-whitespace": noEolWhitespace,
  "no-extra-semicolons": noExtraSemicolons,
  "no-invalid-double-slash-comments": noInvalidDoubleSlashComments,
  "no-missing-end-of-source-newline": noMissingEndOfSourceNewline,
  "no-unknown-animations": noUnknownAnimations,
  "number-leading-zero": numberLeadingZero,
  "number-max-precision": numberMaxPrecision,
  "number-no-trailing-zeros": numberNoTrailingZeros,
  "property-blacklist": propertyBlacklist,
  "property-case": propertyCase,
  "property-no-unknown": propertyNoUnknown,
  "property-no-vendor-prefix": propertyNoVendorPrefix,
  "property-whitelist": propertyWhitelist,
  "rule-empty-line-before": ruleEmptyLineBefore,
  "selector-attribute-brackets-space-inside": selectorAttributeBracketsSpaceInside,
  "selector-attribute-operator-blacklist": selectorAttributeOperatorBlacklist,
  "selector-attribute-operator-space-after": selectorAttributeOperatorSpaceAfter,
  "selector-attribute-operator-space-before": selectorAttributeOperatorSpaceBefore,
  "selector-attribute-operator-whitelist": selectorAttributeOperatorWhitelist,
  "selector-attribute-quotes": selectorAttributeQuotes,
  "selector-class-pattern": selectorClassPattern,
  "selector-combinator-space-after": selectorCombinatorSpaceAfter,
  "selector-combinator-space-before": selectorCombinatorSpaceBefore,
  "selector-descendant-combinator-no-non-space": selectorDescendantCombinatorNoNonSpace,
  "selector-id-pattern": selectorIdPattern,
  "selector-list-comma-newline-after": selectorListCommaNewlineAfter,
  "selector-list-comma-newline-before": selectorListCommaNewlineBefore,
  "selector-list-comma-space-after": selectorListCommaSpaceAfter,
  "selector-list-comma-space-before": selectorListCommaSpaceBefore,
  "selector-max-attribute": selectorMaxAttribute,
  "selector-max-class": selectorMaxClass,
  "selector-max-combinators": selectorMaxCombinators,
  "selector-max-compound-selectors": selectorMaxCompoundSelectors,
  "selector-max-empty-lines": selectorMaxEmptyLines,
  "selector-max-id": selectorMaxId,
  "selector-max-specificity": selectorMaxSpecificity,
  "selector-max-type": selectorMaxType,
  "selector-max-universal": selectorMaxUniversal,
  "selector-nested-pattern": selectorNestedPattern,
  "selector-no-qualifying-type": selectorNoQualifyingType,
  "selector-no-vendor-prefix": selectorNoVendorPrefix,
  "selector-pseudo-class-blacklist": selectorPseudoClassBlacklist,
  "selector-pseudo-class-case": selectorPseudoClassCase,
  "selector-pseudo-class-no-unknown": selectorPseudoClassNoUnknown,
  "selector-pseudo-class-parentheses-space-inside": selectorPseudoClassParenthesesSpaceInside,
  "selector-pseudo-class-whitelist": selectorPseudoClassWhitelist,
  "selector-pseudo-element-case": selectorPseudoElementCase,
  "selector-pseudo-element-colon-notation": selectorPseudoElementColonNotation,
  "selector-pseudo-element-no-unknown": selectorPseudoElementNoUnknown,
  "selector-type-case": selectorTypeCase,
  "selector-type-no-unknown": selectorTypeNoUnknown,
  "shorthand-property-no-redundant-values": shorthandPropertyNoRedundantValues,
  "string-no-newline": stringNoNewline,
  "string-quotes": stringQuotes,
  "time-min-milliseconds": timeMinMilliseconds,
  "unit-blacklist": unitBlacklist,
  "unit-case": unitCase,
  "unit-no-unknown": unitNoUnknown,
  "unit-whitelist": unitWhitelist,
  "value-keyword-case": valueKeywordCase,
  "value-list-comma-newline-after": valueListCommaNewlineAfter,
  "value-list-comma-newline-before": valueListCommaNewlineBefore,
  "value-list-comma-space-after": valueListCommaSpaceAfter,
  "value-list-comma-space-before": valueListCommaSpaceBefore,
  "value-list-max-empty-lines": valueListMaxEmptyLines,
  "value-no-vendor-prefix": valueNoVendorPrefix,
  indentation: indentation /* Placed here for better autofixing */ // eslint-disable-line object-shorthand
};

},{"./at-rule-blacklist":893,"./at-rule-empty-line-before":894,"./at-rule-name-case":895,"./at-rule-name-newline-after":896,"./at-rule-name-space-after":897,"./at-rule-no-unknown":898,"./at-rule-no-vendor-prefix":899,"./at-rule-semicolon-newline-after":900,"./at-rule-semicolon-space-before":901,"./at-rule-whitelist":902,"./block-closing-brace-empty-line-before":904,"./block-closing-brace-newline-after":905,"./block-closing-brace-newline-before":906,"./block-closing-brace-space-after":907,"./block-closing-brace-space-before":908,"./block-no-empty":909,"./block-opening-brace-newline-after":910,"./block-opening-brace-newline-before":911,"./block-opening-brace-space-after":912,"./block-opening-brace-space-before":913,"./color-hex-case":914,"./color-hex-length":915,"./color-named":916,"./color-no-hex":917,"./color-no-invalid-hex":918,"./comment-empty-line-before":919,"./comment-no-empty":920,"./comment-whitespace-inside":921,"./comment-word-blacklist":922,"./custom-media-pattern":923,"./custom-property-empty-line-before":924,"./custom-property-pattern":925,"./declaration-bang-space-after":926,"./declaration-bang-space-before":927,"./declaration-block-no-duplicate-properties":928,"./declaration-block-no-redundant-longhand-properties":929,"./declaration-block-no-shorthand-property-overrides":930,"./declaration-block-semicolon-newline-after":931,"./declaration-block-semicolon-newline-before":932,"./declaration-block-semicolon-space-after":933,"./declaration-block-semicolon-space-before":934,"./declaration-block-single-line-max-declarations":935,"./declaration-block-trailing-semicolon":936,"./declaration-colon-newline-after":937,"./declaration-colon-space-after":938,"./declaration-colon-space-before":939,"./declaration-empty-line-before":940,"./declaration-no-important":941,"./declaration-property-unit-blacklist":942,"./declaration-property-unit-whitelist":943,"./declaration-property-value-blacklist":944,"./declaration-property-value-whitelist":945,"./font-family-name-quotes":949,"./font-family-no-duplicate-names":950,"./font-weight-notation":951,"./function-blacklist":952,"./function-calc-no-unspaced-operator":953,"./function-comma-newline-after":954,"./function-comma-newline-before":955,"./function-comma-space-after":956,"./function-comma-space-before":957,"./function-linear-gradient-no-nonstandard-direction":958,"./function-max-empty-lines":959,"./function-name-case":960,"./function-parentheses-newline-inside":961,"./function-parentheses-space-inside":962,"./function-url-no-scheme-relative":963,"./function-url-quotes":964,"./function-url-scheme-blacklist":965,"./function-url-scheme-whitelist":966,"./function-whitelist":967,"./function-whitespace-after":968,"./indentation":970,"./keyframe-declaration-no-important":972,"./length-zero-no-unit":973,"./max-empty-lines":974,"./max-line-length":975,"./max-nesting-depth":976,"./media-feature-colon-space-after":977,"./media-feature-colon-space-before":978,"./media-feature-name-blacklist":979,"./media-feature-name-case":980,"./media-feature-name-no-unknown":981,"./media-feature-name-no-vendor-prefix":982,"./media-feature-name-whitelist":983,"./media-feature-parentheses-space-inside":984,"./media-feature-range-operator-space-after":985,"./media-feature-range-operator-space-before":986,"./media-query-list-comma-newline-after":987,"./media-query-list-comma-newline-before":988,"./media-query-list-comma-space-after":989,"./media-query-list-comma-space-before":990,"./no-descending-specificity":993,"./no-duplicate-selectors":994,"./no-empty-source":995,"./no-eol-whitespace":996,"./no-extra-semicolons":997,"./no-invalid-double-slash-comments":998,"./no-missing-end-of-source-newline":999,"./no-unknown-animations":1000,"./number-leading-zero":1001,"./number-max-precision":1002,"./number-no-trailing-zeros":1003,"./property-blacklist":1004,"./property-case":1005,"./property-no-unknown":1006,"./property-no-vendor-prefix":1007,"./property-whitelist":1008,"./rule-empty-line-before":1009,"./selector-attribute-brackets-space-inside":1010,"./selector-attribute-operator-blacklist":1011,"./selector-attribute-operator-space-after":1012,"./selector-attribute-operator-space-before":1013,"./selector-attribute-operator-whitelist":1014,"./selector-attribute-quotes":1015,"./selector-class-pattern":1016,"./selector-combinator-space-after":1017,"./selector-combinator-space-before":1018,"./selector-descendant-combinator-no-non-space":1019,"./selector-id-pattern":1020,"./selector-list-comma-newline-after":1021,"./selector-list-comma-newline-before":1022,"./selector-list-comma-space-after":1023,"./selector-list-comma-space-before":1024,"./selector-max-attribute":1025,"./selector-max-class":1026,"./selector-max-combinators":1027,"./selector-max-compound-selectors":1028,"./selector-max-empty-lines":1029,"./selector-max-id":1030,"./selector-max-specificity":1031,"./selector-max-type":1032,"./selector-max-universal":1033,"./selector-nested-pattern":1034,"./selector-no-qualifying-type":1035,"./selector-no-vendor-prefix":1036,"./selector-pseudo-class-blacklist":1037,"./selector-pseudo-class-case":1038,"./selector-pseudo-class-no-unknown":1039,"./selector-pseudo-class-parentheses-space-inside":1040,"./selector-pseudo-class-whitelist":1041,"./selector-pseudo-element-case":1042,"./selector-pseudo-element-colon-notation":1043,"./selector-pseudo-element-no-unknown":1044,"./selector-type-case":1045,"./selector-type-no-unknown":1046,"./shorthand-property-no-redundant-values":1050,"./string-no-newline":1051,"./string-quotes":1052,"./time-min-milliseconds":1053,"./unit-blacklist":1054,"./unit-case":1055,"./unit-no-unknown":1056,"./unit-whitelist":1057,"./value-keyword-case":1058,"./value-list-comma-newline-after":1059,"./value-list-comma-newline-before":1060,"./value-list-comma-space-after":1061,"./value-list-comma-space-before":1062,"./value-list-max-empty-lines":1063,"./value-no-vendor-prefix":1064}],972:[function(require,module,exports){
"use strict";

const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "keyframe-declaration-no-important";

const messages = ruleMessages(ruleName, {
  rejected: "Unexpected !important"
});

const rule = function(actual) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, { actual });
    if (!validOptions) {
      return;
    }

    root.walkAtRules(/^(-(moz|webkit)-)?keyframes$/i, atRuleKeyframes => {
      atRuleKeyframes.walkDecls(decl => {
        if (!decl.important) {
          return;
        }
        report({
          message: messages.rejected,
          node: decl,
          word: "important",
          result,
          ruleName
        });
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144}],973:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const beforeBlockString = require("../../utils/beforeBlockString");
const blurComments = require("../../utils/blurComments");
const hasBlock = require("../../utils/hasBlock");
const keywordSets = require("../../reference/keywordSets");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const styleSearch = require("style-search");
const validateOptions = require("../../utils/validateOptions");
const valueParser = require("postcss-value-parser");

const ruleName = "length-zero-no-unit";

const messages = ruleMessages(ruleName, {
  rejected: "Unexpected unit"
});

const rule = function(actual) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, { actual });
    if (!validOptions) {
      return;
    }

    root.walkDecls(decl => {
      check(blurComments(decl.toString()), decl);
    });

    root.walkAtRules(atRule => {
      const source = hasBlock(atRule)
        ? beforeBlockString(atRule, { noRawBefore: true })
        : atRule.toString();
      check(source, atRule);
    });

    function check(value, node) {
      const ignorableIndexes = new Set();

      styleSearch({ source: value, target: "0" }, match => {
        const index = match.startIndex;

        // Given a 0 somewhere in the full property value (not in a string, thanks
        // to styleSearch) we need to isolate the value that contains the zero.
        // To do so, we'll find the last index before the 0 of a character that would
        // divide one value in a list from another, and the next index of such a
        // character; then we build a substring from those indexes, which we can
        // assess.

        // If a single value includes multiple 0's (e.g. 100.01px), we don't want
        // each 0 to be treated as a separate value, possibly resulting in multiple
        // warnings for the same value (e.g. 0.00px).
        //
        // This check prevents that from happening: we build and check against a
        // Set containing all the indexes that are part of a value already validated.
        if (ignorableIndexes.has(index)) {
          return;
        }

        const prevValueBreakIndex = _.findLastIndex(
          value.substr(0, index),
          char => {
            return (
              [" ", ",", ")", "(", "#", ":", "\n", "\t"].indexOf(char) !== -1
            );
          }
        );

        // Ignore hex colors
        if (value[prevValueBreakIndex] === "#") {
          return;
        }

        // If no prev break was found, this value starts at 0
        const valueWithZeroStart =
          prevValueBreakIndex === -1 ? 0 : prevValueBreakIndex + 1;

        const nextValueBreakIndex = _.findIndex(
          value.substr(valueWithZeroStart),
          char => {
            return [" ", ",", ")"].indexOf(char) !== -1;
          }
        );

        // If no next break was found, this value ends at the end of the string
        const valueWithZeroEnd =
          nextValueBreakIndex === -1
            ? value.length
            : nextValueBreakIndex + valueWithZeroStart;

        const valueWithZero = value.slice(valueWithZeroStart, valueWithZeroEnd);
        const parsedValue = valueParser.unit(valueWithZero);

        if (!parsedValue || (parsedValue && !parsedValue.unit)) {
          return;
        }

        // Add the indexes to ignorableIndexes so the same value will not
        // be checked multiple times.
        _.range(valueWithZeroStart, valueWithZeroEnd).forEach(i =>
          ignorableIndexes.add(i)
        );

        // Only pay attention if the value parses to 0
        // and units with lengths
        if (
          parseFloat(valueWithZero, 10) !== 0 ||
          !keywordSets.lengthUnits.has(parsedValue.unit.toLowerCase())
        ) {
          return;
        }

        report({
          message: messages.rejected,
          node,
          index: valueWithZeroEnd - parsedValue.unit.length,
          result,
          ruleName
        });
      });
    }
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../reference/keywordSets":888,"../../utils/beforeBlockString":1072,"../../utils/blurComments":1074,"../../utils/hasBlock":1092,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"postcss-value-parser":811,"style-search":870}],974:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const optionsMatches = require("../../utils/optionsMatches");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const styleSearch = require("style-search");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "max-empty-lines";

const messages = ruleMessages(ruleName, {
  expected: max =>
    `Expected no more than ${max} empty ${max === 1 ? "line" : "lines"}`
});

const rule = function(max, options) {
  const maxAdjacentNewlines = max + 1;

  return (root, result) => {
    const validOptions = validateOptions(
      result,
      ruleName,
      {
        actual: max,
        possible: _.isNumber
      },
      {
        actual: options,
        possible: {
          ignore: ["comments"]
        },
        optional: true
      }
    );
    if (!validOptions) {
      return;
    }

    const rootString = root.toString();
    const repeatLFNewLines = _.repeat("\n", maxAdjacentNewlines);
    const repeatCRLFNewLines = _.repeat("\r\n", maxAdjacentNewlines);
    const ignoreComments = optionsMatches(options, "ignore", "comments");

    styleSearch({ source: rootString, target: "\n" }, match => {
      checkMatch(rootString, match.endIndex, root);
    });

    // We must check comments separately in order to accommodate stupid
    // `//`-comments from SCSS, which postcss-scss converts to `/* ... */`,
    // which adds to extra characters at the end, which messes up our
    // warning position
    if (!ignoreComments) {
      root.walkComments(comment => {
        const source =
          (comment.raws.left || "") + comment.text + (comment.raws.right || "");
        styleSearch({ source, target: "\n" }, match => {
          checkMatch(source, match.endIndex, comment, 2);
        });
      });
    }

    function checkMatch(source, matchEndIndex, node) {
      const offset =
        arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;

      let violationIndex = false;
      if (
        source.substr(matchEndIndex, maxAdjacentNewlines) === repeatLFNewLines
      ) {
        violationIndex = matchEndIndex + maxAdjacentNewlines;
      } else if (
        source.substr(matchEndIndex, maxAdjacentNewlines * 2) ===
        repeatCRLFNewLines
      ) {
        violationIndex = matchEndIndex + maxAdjacentNewlines * 2;
      }

      if (!violationIndex) {
        return;
      }

      report({
        message: messages.expected(max),
        node,
        index: violationIndex + offset,
        result,
        ruleName
      });
    }
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/optionsMatches":1137,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"style-search":870}],975:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const execall = require("execall");
const optionsMatches = require("../../utils/optionsMatches");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const styleSearch = require("style-search");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "max-line-length";

const messages = ruleMessages(ruleName, {
  expected: max =>
    `Expected line length to be no more than ${max} ${max === 1
      ? "character"
      : "characters"}`
});

const rule = function(maxLength, options) {
  return (root, result) => {
    const validOptions = validateOptions(
      result,
      ruleName,
      {
        actual: maxLength,
        possible: _.isNumber
      },
      {
        actual: options,
        possible: {
          ignore: ["non-comments", "comments"],
          ignorePattern: [_.isString]
        },
        optional: true
      }
    );
    if (!validOptions) {
      return;
    }

    const rootString = root.source.input.css;

    const ignoreNonComments = optionsMatches(options, "ignore", "non-comments");
    const ignoreComments = optionsMatches(options, "ignore", "comments");

    // Check first line
    checkNewline({ endIndex: 0 });

    // Check subsequent lines
    styleSearch(
      { source: rootString, target: ["\n"], comments: "check" },
      checkNewline
    );

    function complain(index) {
      report({
        index,
        result,
        ruleName,
        message: messages.expected(maxLength),
        node: root
      });
    }

    function checkNewline(match) {
      let nextNewlineIndex = rootString.indexOf("\n", match.endIndex);
      if (rootString[nextNewlineIndex - 1] === "\r") {
        nextNewlineIndex -= 1;
      }

      // Accommodate last line
      if (nextNewlineIndex === -1) {
        nextNewlineIndex = rootString.length;
      }

      const rawLineLength = nextNewlineIndex - match.endIndex;
      const lineText = rootString.slice(match.endIndex, nextNewlineIndex);

      // Case sensitive ignorePattern match
      if (optionsMatches(options, "ignorePattern", lineText)) {
        return;
      }

      const urlArgumentsLength = execall(
        /url\((.*)\)/gi,
        lineText
      ).reduce((result, match) => {
        return result + _.get(match, "sub[0].length", 0);
      }, 0);

      const importUrlsLength = execall(
        /@import\s+(['"].*['"])/gi,
        lineText
      ).reduce((result, match) => {
        return result + _.get(match, "sub[0].length", 0);
      }, 0);

      // If the line's length is less than or equal to the specified
      // max, ignore it ... So anything below is liable to be complained about.
      // **Note that the length of any url arguments or import urls
      // are excluded from the calculation.**
      if (rawLineLength - urlArgumentsLength - importUrlsLength <= maxLength) {
        return;
      }

      const complaintIndex = nextNewlineIndex - 1;

      if (ignoreComments) {
        if (match.insideComment) {
          return;
        }

        // This trimming business is to notice when the line starts a
        // comment but that comment is indented, e.g.
        //       /* something here */
        const nextTwoChars = rootString
          .slice(match.endIndex)
          .trim()
          .slice(0, 2);
        if (nextTwoChars === "/*" || nextTwoChars === "//") {
          return;
        }
      }

      if (ignoreNonComments) {
        if (match.insideComment) {
          return complain(complaintIndex);
        }

        // This trimming business is to notice when the line starts a
        // comment but that comment is indented, e.g.
        //       /* something here */
        const nextTwoChars = rootString
          .slice(match.endIndex)
          .trim()
          .slice(0, 2);
        if (nextTwoChars !== "/*" && nextTwoChars !== "//") {
          return;
        }
        return complain(complaintIndex);
      }

      // If there are no spaces besides initial (indent) spaces, ignore it
      const lineString = rootString.slice(match.endIndex, nextNewlineIndex);
      if (lineString.replace(/^\s+/, "").indexOf(" ") === -1) {
        return;
      }

      return complain(complaintIndex);
    }
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/optionsMatches":1137,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"execall":605,"lodash":692,"style-search":870}],976:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const hasBlock = require("../../utils/hasBlock");
const optionsMatches = require("../../utils/optionsMatches");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "max-nesting-depth";

const messages = ruleMessages(ruleName, {
  expected: depth => `Expected nesting depth to be no more than ${depth}`
});

const rule = function(max, options) {
  const isIgnoreAtRule = node =>
    node.type === "atrule" &&
    optionsMatches(options, "ignoreAtRules", node.name);

  return (root, result) => {
    validateOptions(
      result,
      ruleName,
      {
        actual: max,
        possible: [_.isNumber]
      },
      {
        optional: true,
        actual: options,
        possible: {
          ignore: ["blockless-at-rules"],
          ignoreAtRules: [_.isString]
        }
      }
    );

    root.walkRules(checkStatement);
    root.walkAtRules(checkStatement);

    function checkStatement(statement) {
      if (isIgnoreAtRule(statement)) {
        return;
      }
      if (!hasBlock(statement)) {
        return;
      }
      const depth = nestingDepth(statement);
      if (depth > max) {
        report({
          ruleName,
          result,
          node: statement,
          message: messages.expected(max)
        });
      }
    }
  };

  function nestingDepth(node, level) {
    level = level || 0;
    const parent = node.parent;

    if (isIgnoreAtRule(parent)) {
      return 0;
    }

    // The nesting depth level's computation has finished
    // when this function, recursively called, receives
    // a node that is not nested -- a direct child of the
    // root node
    if (
      parent.type === "root" ||
      (parent.type === "atrule" && parent.parent.type === "root")
    ) {
      return level;
    }

    if (
      optionsMatches(options, "ignore", "blockless-at-rules") &&
      node.type === "atrule" &&
      node.every(child => child.type !== "decl")
    ) {
      return nestingDepth(parent, level);
    }

    // Unless any of the conditions above apply, we want to
    // add 1 to the nesting depth level and then check the parent,
    // continuing to add and move up the hierarchy
    // until we hit the root node
    return nestingDepth(parent, level + 1);
  }
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/hasBlock":1092,"../../utils/optionsMatches":1137,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692}],977:[function(require,module,exports){
"use strict";

const mediaFeatureColonSpaceChecker = require("../mediaFeatureColonSpaceChecker");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "media-feature-colon-space-after";

const messages = ruleMessages(ruleName, {
  expectedAfter: () => 'Expected single space after ":"',
  rejectedAfter: () => 'Unexpected whitespace after ":"'
});

const rule = function(expectation) {
  const checker = whitespaceChecker("space", expectation, messages);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "never"]
    });
    if (!validOptions) {
      return;
    }

    mediaFeatureColonSpaceChecker({
      root,
      result,
      locationChecker: checker.after,
      checkedRuleName: ruleName
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145,"../mediaFeatureColonSpaceChecker":991}],978:[function(require,module,exports){
"use strict";

const mediaFeatureColonSpaceChecker = require("../mediaFeatureColonSpaceChecker");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "media-feature-colon-space-before";

const messages = ruleMessages(ruleName, {
  expectedBefore: () => 'Expected single space before ":"',
  rejectedBefore: () => 'Unexpected whitespace before ":"'
});

const rule = function(expectation) {
  const checker = whitespaceChecker("space", expectation, messages);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "never"]
    });
    if (!validOptions) {
      return;
    }

    mediaFeatureColonSpaceChecker({
      root,
      result,
      locationChecker: checker.before,
      checkedRuleName: ruleName
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145,"../mediaFeatureColonSpaceChecker":991}],979:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const atRuleParamIndex = require("../../utils/atRuleParamIndex");
const isCustomMediaQuery = require("../../utils/isCustomMediaQuery");
const isRangeContextMediaFeature = require("../../utils/isRangeContextMediaFeature");
const isStandardSyntaxMediaFeatureName = require("../../utils/isStandardSyntaxMediaFeatureName");
const matchesStringOrRegExp = require("../../utils/matchesStringOrRegExp");
const mediaParser = require("postcss-media-query-parser").default;
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "media-feature-name-blacklist";

const messages = ruleMessages(ruleName, {
  rejected: name => `Unexpected media feature name "${name}"`
});

const rule = function(blacklist) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: blacklist,
      possible: [_.isString]
    });
    if (!validOptions) {
      return;
    }

    root.walkAtRules(/^media$/i, atRule => {
      mediaParser(atRule.params).walk(/^media-feature$/i, mediaFeatureNode => {
        const parent = mediaFeatureNode.parent,
          sourceIndex = mediaFeatureNode.sourceIndex,
          value = mediaFeatureNode.value;

        if (
          isRangeContextMediaFeature(parent.value) ||
          !isStandardSyntaxMediaFeatureName(value) ||
          isCustomMediaQuery(value)
        ) {
          return;
        }

        if (!matchesStringOrRegExp(value, blacklist)) {
          return;
        }

        report({
          index: atRuleParamIndex(atRule) + sourceIndex,
          message: messages.rejected(value),
          node: atRule,
          ruleName,
          result
        });
      });
    });
  };
};

rule.primaryOptionArray = true;

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/atRuleParamIndex":1071,"../../utils/isCustomMediaQuery":1108,"../../utils/isRangeContextMediaFeature":1117,"../../utils/isStandardSyntaxMediaFeatureName":1123,"../../utils/matchesStringOrRegExp":1134,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"postcss-media-query-parser":777}],980:[function(require,module,exports){
"use strict";

const atRuleParamIndex = require("../../utils/atRuleParamIndex");
const isCustomMediaQuery = require("../../utils/isCustomMediaQuery");
const isRangeContextMediaFeature = require("../../utils/isRangeContextMediaFeature");
const isStandardSyntaxMediaFeatureName = require("../../utils/isStandardSyntaxMediaFeatureName");
const mediaParser = require("postcss-media-query-parser").default;
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "media-feature-name-case";

const messages = ruleMessages(ruleName, {
  expected: (actual, expected) => `Expected "${actual}" to be "${expected}"`
});

const rule = function(expectation) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["lower", "upper"]
    });
    if (!validOptions) {
      return;
    }

    root.walkAtRules(/^media$/i, atRule => {
      mediaParser(atRule.params).walk(/^media-feature$/i, mediaFeatureNode => {
        const parent = mediaFeatureNode.parent,
          sourceIndex = mediaFeatureNode.sourceIndex,
          value = mediaFeatureNode.value;

        if (
          isRangeContextMediaFeature(parent.value) ||
          !isStandardSyntaxMediaFeatureName(value) ||
          isCustomMediaQuery(value)
        ) {
          return;
        }

        const expectedFeatureName =
          expectation === "lower" ? value.toLowerCase() : value.toUpperCase();

        if (value === expectedFeatureName) {
          return;
        }

        report({
          index: atRuleParamIndex(atRule) + sourceIndex,
          message: messages.expected(value, expectedFeatureName),
          node: atRule,
          ruleName,
          result
        });
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/atRuleParamIndex":1071,"../../utils/isCustomMediaQuery":1108,"../../utils/isRangeContextMediaFeature":1117,"../../utils/isStandardSyntaxMediaFeatureName":1123,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"postcss-media-query-parser":777}],981:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const atRuleParamIndex = require("../../utils/atRuleParamIndex");
const isCustomMediaQuery = require("../../utils/isCustomMediaQuery");
const isRangeContextMediaFeature = require("../../utils/isRangeContextMediaFeature");
const isStandardSyntaxMediaFeatureName = require("../../utils/isStandardSyntaxMediaFeatureName");
const keywordSets = require("../../reference/keywordSets");
const mediaParser = require("postcss-media-query-parser").default;
const optionsMatches = require("../../utils/optionsMatches");
const postcss = require("postcss");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "media-feature-name-no-unknown";

const messages = ruleMessages(ruleName, {
  rejected: mediaFeatureName =>
    `Unexpected unknown media feature name "${mediaFeatureName}"`
});

const rule = function(actual, options) {
  return (root, result) => {
    const validOptions = validateOptions(
      result,
      ruleName,
      { actual },
      {
        actual: options,
        possible: {
          ignoreMediaFeatureNames: [_.isString]
        },
        optional: true
      }
    );

    if (!validOptions) {
      return;
    }

    root.walkAtRules(/^media$/i, atRule => {
      mediaParser(atRule.params).walk(/^media-feature$/i, mediaFeatureNode => {
        const parent = mediaFeatureNode.parent,
          sourceIndex = mediaFeatureNode.sourceIndex,
          value = mediaFeatureNode.value;

        if (
          isRangeContextMediaFeature(parent.value) ||
          !isStandardSyntaxMediaFeatureName(value) ||
          isCustomMediaQuery(value)
        ) {
          return;
        }

        if (optionsMatches(options, "ignoreMediaFeatureNames", value)) {
          return;
        }

        if (
          postcss.vendor.prefix(value) ||
          keywordSets.mediaFeatureNames.has(value.toLowerCase())
        ) {
          return;
        }

        report({
          index: atRuleParamIndex(atRule) + sourceIndex,
          message: messages.rejected(value),
          node: atRule,
          ruleName,
          result
        });
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../reference/keywordSets":888,"../../utils/atRuleParamIndex":1071,"../../utils/isCustomMediaQuery":1108,"../../utils/isRangeContextMediaFeature":1117,"../../utils/isStandardSyntaxMediaFeatureName":1123,"../../utils/optionsMatches":1137,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"postcss":828,"postcss-media-query-parser":777}],982:[function(require,module,exports){
"use strict";

const isAutoprefixable = require("../../utils/isAutoprefixable");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "media-feature-name-no-vendor-prefix";

const messages = ruleMessages(ruleName, {
  rejected: "Unexpected vendor-prefix"
});

const rule = function(actual) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, { actual });
    if (!validOptions) {
      return;
    }

    root.walkAtRules(/^media$/i, atRule => {
      const params = atRule.params;

      if (!isAutoprefixable.mediaFeatureName(params)) {
        return;
      }
      const matches = atRule.toString().match(/[a-z-]+device-pixel-ratio/gi);

      if (!matches) {
        return;
      }

      matches.forEach(match => {
        report({
          message: messages.rejected,
          node: atRule,
          word: match,
          result,
          ruleName
        });
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isAutoprefixable":1102,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144}],983:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const atRuleParamIndex = require("../../utils/atRuleParamIndex");
const isCustomMediaQuery = require("../../utils/isCustomMediaQuery");
const isRangeContextMediaFeature = require("../../utils/isRangeContextMediaFeature");
const isStandardSyntaxMediaFeatureName = require("../../utils/isStandardSyntaxMediaFeatureName");
const matchesStringOrRegExp = require("../../utils/matchesStringOrRegExp");
const mediaParser = require("postcss-media-query-parser").default;
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "media-feature-name-whitelist";

const messages = ruleMessages(ruleName, {
  rejected: name => `Unexpected media feature name "${name}"`
});

const rule = function(whitelist) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: whitelist,
      possible: [_.isString]
    });
    if (!validOptions) {
      return;
    }

    root.walkAtRules(/^media$/i, atRule => {
      mediaParser(atRule.params).walk(/^media-feature$/i, mediaFeatureNode => {
        const parent = mediaFeatureNode.parent,
          sourceIndex = mediaFeatureNode.sourceIndex,
          value = mediaFeatureNode.value;

        if (
          isRangeContextMediaFeature(parent.value) ||
          !isStandardSyntaxMediaFeatureName(value) ||
          isCustomMediaQuery(value)
        ) {
          return;
        }

        if (matchesStringOrRegExp(value, whitelist)) {
          return;
        }

        report({
          index: atRuleParamIndex(atRule) + sourceIndex,
          message: messages.rejected(value),
          node: atRule,
          ruleName,
          result
        });
      });
    });
  };
};

rule.primaryOptionArray = true;

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/atRuleParamIndex":1071,"../../utils/isCustomMediaQuery":1108,"../../utils/isRangeContextMediaFeature":1117,"../../utils/isStandardSyntaxMediaFeatureName":1123,"../../utils/matchesStringOrRegExp":1134,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"postcss-media-query-parser":777}],984:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const atRuleParamIndex = require("../../utils/atRuleParamIndex");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const styleSearch = require("style-search");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "media-feature-parentheses-space-inside";

const messages = ruleMessages(ruleName, {
  expectedOpening: 'Expected single space after "("',
  rejectedOpening: 'Unexpected whitespace after "("',
  expectedClosing: 'Expected single space before ")"',
  rejectedClosing: 'Unexpected whitespace before ")"'
});

const rule = function(expectation) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "never"]
    });
    if (!validOptions) {
      return;
    }

    root.walkAtRules(/^media$/i, atRule => {
      // If there are comments in the params, the complete string
      // will be at atRule.raws.params.raw
      const params = _.get(atRule, "raws.params.raw", atRule.params);
      const indexBoost = atRuleParamIndex(atRule);

      styleSearch({ source: params, target: "(" }, match => {
        const nextCharIsSpace = params[match.startIndex + 1] === " ";
        if (nextCharIsSpace && expectation === "never") {
          report({
            message: messages.rejectedOpening,
            node: atRule,
            index: match.startIndex + 1 + indexBoost,
            result,
            ruleName
          });
        }
        if (!nextCharIsSpace && expectation === "always") {
          report({
            message: messages.expectedOpening,
            node: atRule,
            index: match.startIndex + 1 + indexBoost,
            result,
            ruleName
          });
        }
      });

      styleSearch({ source: params, target: ")" }, match => {
        const prevCharIsSpace = params[match.startIndex - 1] === " ";
        if (prevCharIsSpace && expectation === "never") {
          report({
            message: messages.rejectedClosing,
            node: atRule,
            index: match.startIndex - 1 + indexBoost,
            result,
            ruleName
          });
        }
        if (!prevCharIsSpace && expectation === "always") {
          report({
            message: messages.expectedClosing,
            node: atRule,
            index: match.startIndex - 1 + indexBoost,
            result,
            ruleName
          });
        }
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/atRuleParamIndex":1071,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"style-search":870}],985:[function(require,module,exports){
"use strict";

const atRuleParamIndex = require("../../utils/atRuleParamIndex");
const findMediaOperator = require("../findMediaOperator");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "media-feature-range-operator-space-after";

const messages = ruleMessages(ruleName, {
  expectedAfter: () => "Expected single space after range operator",
  rejectedAfter: () => "Unexpected whitespace after range operator"
});

const rule = function(expectation) {
  const checker = whitespaceChecker("space", expectation, messages);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "never"]
    });
    if (!validOptions) {
      return;
    }

    root.walkAtRules(/^media$/i, atRule => {
      findMediaOperator(atRule, checkAfterOperator);
    });

    function checkAfterOperator(match, params, node) {
      const endIndex = match.index + match[1].length;

      checker.after({
        source: params,
        index: endIndex,
        err: m => {
          report({
            message: m,
            node,
            index: endIndex + atRuleParamIndex(node) + 1,
            result,
            ruleName
          });
        }
      });
    }
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/atRuleParamIndex":1071,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145,"../findMediaOperator":948}],986:[function(require,module,exports){
"use strict";

const atRuleParamIndex = require("../../utils/atRuleParamIndex");
const findMediaOperator = require("../findMediaOperator");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "media-feature-range-operator-space-before";

const messages = ruleMessages(ruleName, {
  expectedBefore: () => "Expected single space before range operator",
  rejectedBefore: () => "Unexpected whitespace before range operator"
});

const rule = function(expectation) {
  const checker = whitespaceChecker("space", expectation, messages);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "never"]
    });
    if (!validOptions) {
      return;
    }

    root.walkAtRules(/^media$/i, atRule => {
      findMediaOperator(atRule, checkBeforeOperator);
    });

    function checkBeforeOperator(match, params, node) {
      // The extra `+ 1` is because the match itself contains
      // the character before the operator
      checker.before({
        source: params,
        index: match.index + 1,
        err: m => {
          report({
            message: m,
            node,
            index: match.index + atRuleParamIndex(node),
            result,
            ruleName
          });
        }
      });
    }
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/atRuleParamIndex":1071,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145,"../findMediaOperator":948}],987:[function(require,module,exports){
"use strict";

const mediaQueryListCommaWhitespaceChecker = require("../mediaQueryListCommaWhitespaceChecker");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "media-query-list-comma-newline-after";

const messages = ruleMessages(ruleName, {
  expectedAfter: () => 'Expected newline after ","',
  expectedAfterMultiLine: () =>
    'Expected newline after "," in a multi-line list',
  rejectedAfterMultiLine: () =>
    'Unexpected whitespace after "," in a multi-line list'
});

const rule = function(expectation) {
  const checker = whitespaceChecker("newline", expectation, messages);

  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "always-multi-line", "never-multi-line"]
    });
    if (!validOptions) {
      return;
    }

    // Only check for the newline after the comma, while allowing
    // arbitrary indentation after the newline
    mediaQueryListCommaWhitespaceChecker({
      root,
      result,
      locationChecker: checker.afterOneOnly,
      checkedRuleName: ruleName
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145,"../mediaQueryListCommaWhitespaceChecker":992}],988:[function(require,module,exports){
"use strict";

const mediaQueryListCommaWhitespaceChecker = require("../mediaQueryListCommaWhitespaceChecker");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "media-query-list-comma-newline-before";

const messages = ruleMessages(ruleName, {
  expectedBefore: () => 'Expected newline before ","',
  expectedBeforeMultiLine: () =>
    'Expected newline before "," in a multi-line list',
  rejectedBeforeMultiLine: () =>
    'Unexpected whitespace before "," in a multi-line list'
});

const rule = function(expectation) {
  const checker = whitespaceChecker("newline", expectation, messages);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "always-multi-line", "never-multi-line"]
    });
    if (!validOptions) {
      return;
    }
    mediaQueryListCommaWhitespaceChecker({
      root,
      result,
      locationChecker: checker.beforeAllowingIndentation,
      checkedRuleName: ruleName
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145,"../mediaQueryListCommaWhitespaceChecker":992}],989:[function(require,module,exports){
"use strict";

const mediaQueryListCommaWhitespaceChecker = require("../mediaQueryListCommaWhitespaceChecker");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "media-query-list-comma-space-after";

const messages = ruleMessages(ruleName, {
  expectedAfter: () => 'Expected single space after ","',
  rejectedAfter: () => 'Unexpected whitespace after ","',
  expectedAfterSingleLine: () =>
    'Expected single space after "," in a single-line list',
  rejectedAfterSingleLine: () =>
    'Unexpected whitespace after "," in a single-line list'
});

const rule = function(expectation) {
  const checker = whitespaceChecker("space", expectation, messages);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "never", "always-single-line", "never-single-line"]
    });
    if (!validOptions) {
      return;
    }
    mediaQueryListCommaWhitespaceChecker({
      root,
      result,
      locationChecker: checker.after,
      checkedRuleName: ruleName
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145,"../mediaQueryListCommaWhitespaceChecker":992}],990:[function(require,module,exports){
"use strict";

const mediaQueryListCommaWhitespaceChecker = require("../mediaQueryListCommaWhitespaceChecker");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "media-query-list-comma-space-before";

const messages = ruleMessages(ruleName, {
  expectedBefore: () => 'Expected single space before ","',
  rejectedBefore: () => 'Unexpected whitespace before ","',
  expectedBeforeSingleLine: () =>
    'Expected single space before "," in a single-line list',
  rejectedBeforeSingleLine: () =>
    'Unexpected whitespace before "," in a single-line list'
});

const rule = function(expectation) {
  const checker = whitespaceChecker("space", expectation, messages);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "never", "always-single-line", "never-single-line"]
    });
    if (!validOptions) {
      return;
    }

    mediaQueryListCommaWhitespaceChecker({
      root,
      result,
      locationChecker: checker.before,
      checkedRuleName: ruleName
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145,"../mediaQueryListCommaWhitespaceChecker":992}],991:[function(require,module,exports){
"use strict";

const atRuleParamIndex = require("../utils/atRuleParamIndex");
const report = require("../utils/report");
const styleSearch = require("style-search");

module.exports = function(opts) {
  opts.root.walkAtRules(/^media$/i, atRule => {
    const params = atRule.params;

    styleSearch({ source: params, target: ":" }, match => {
      checkColon(params, match.startIndex, atRule);
    });
  });

  function checkColon(source, index, node) {
    opts.locationChecker({
      source,
      index,
      err: m =>
        report({
          message: m,
          node,
          index: index + atRuleParamIndex(node),
          result: opts.result,
          ruleName: opts.checkedRuleName
        })
    });
  }
};

},{"../utils/atRuleParamIndex":1071,"../utils/report":1141,"style-search":870}],992:[function(require,module,exports){
"use strict";

const atRuleParamIndex = require("../utils/atRuleParamIndex");
const report = require("../utils/report");
const styleSearch = require("style-search");

module.exports = function(opts) {
  opts.root.walkAtRules(/^media$/i, atRule => {
    const params = atRule.params;
    styleSearch({ source: params, target: "," }, match => {
      checkComma(params, match.startIndex, atRule);
    });
  });

  function checkComma(source, index, node) {
    opts.locationChecker({
      source,
      index,
      err: m =>
        report({
          message: m,
          node,
          index: index + atRuleParamIndex(node),
          result: opts.result,
          ruleName: opts.checkedRuleName
        })
    });
  }
};

},{"../utils/atRuleParamIndex":1071,"../utils/report":1141,"style-search":870}],993:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const findAtRuleContext = require("../../utils/findAtRuleContext");
const isCustomPropertySet = require("../../utils/isCustomPropertySet");
const keywordSets = require("../../reference/keywordSets");
const nodeContextLookup = require("../../utils/nodeContextLookup");
const parseSelector = require("../../utils/parseSelector");
const report = require("../../utils/report");
const resolvedNestedSelector = require("postcss-resolve-nested-selector");
const ruleMessages = require("../../utils/ruleMessages");
const specificity = require("specificity");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "no-descending-specificity";

const messages = ruleMessages(ruleName, {
  rejected: (b, a) => `Expected selector "${b}" to come before selector "${a}"`
});

const rule = function(actual) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, { actual });
    if (!validOptions) {
      return;
    }

    const selectorContextLookup = nodeContextLookup();

    root.walkRules(rule => {
      // Ignore custom property set `--foo: {};`
      if (isCustomPropertySet(rule)) {
        return;
      }

      const comparisonContext = selectorContextLookup.getContext(
        rule,
        findAtRuleContext(rule)
      );

      rule.selectors.forEach(selector => {
        const trimSelector = selector.trim();
        // Ignore `.selector, { }`
        if (trimSelector === "") {
          return;
        }

        // The edge-case of duplicate selectors will act acceptably
        const index = rule.selector.indexOf(trimSelector);
        // Resolve any nested selectors before checking
        resolvedNestedSelector(selector, rule).forEach(resolvedSelector => {
          parseSelector(resolvedSelector, result, rule, s =>
            checkSelector(s, rule, index, comparisonContext)
          );
        });
      });
    });

    function checkSelector(selectorNode, rule, sourceIndex, comparisonContext) {
      const selector = selectorNode.toString();
      const referenceSelectorNode = lastCompoundSelectorWithoutPseudoClasses(
        selectorNode
      );
      const selectorSpecificity = specificity.calculate(selector)[0]
        .specificityArray;
      const entry = { selector, specificity: selectorSpecificity };

      if (!comparisonContext.has(referenceSelectorNode)) {
        comparisonContext.set(referenceSelectorNode, [entry]);
        return;
      }

      const priorComparableSelectors = comparisonContext.get(
        referenceSelectorNode
      );

      priorComparableSelectors.forEach(priorEntry => {
        if (
          specificity.compare(selectorSpecificity, priorEntry.specificity) ===
          -1
        ) {
          report({
            ruleName,
            result,
            node: rule,
            message: messages.rejected(selector, priorEntry.selector),
            index: sourceIndex
          });
        }
      });

      priorComparableSelectors.push(entry);
    }
  };
};

function lastCompoundSelectorWithoutPseudoClasses(selectorNode) {
  const nodesAfterLastCombinator = _.last(
    selectorNode.nodes[0].split(node => {
      return node.type === "combinator";
    })
  );

  const nodesWithoutPseudoClasses = nodesAfterLastCombinator
    .filter(node => {
      return (
        node.type !== "pseudo" ||
        keywordSets.pseudoElements.has(node.value.replace(/:/g, ""))
      );
    })
    .join("");

  return nodesWithoutPseudoClasses.toString();
}

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../reference/keywordSets":888,"../../utils/findAtRuleContext":1082,"../../utils/isCustomPropertySet":1110,"../../utils/nodeContextLookup":1136,"../../utils/parseSelector":1138,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"postcss-resolve-nested-selector":782,"specificity":865}],994:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const findAtRuleContext = require("../../utils/findAtRuleContext");
const isKeyframeRule = require("../../utils/isKeyframeRule");
const nodeContextLookup = require("../../utils/nodeContextLookup");
const normalizeSelector = require("normalize-selector");
const report = require("../../utils/report");
const resolvedNestedSelector = require("postcss-resolve-nested-selector");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "no-duplicate-selectors";

const messages = ruleMessages(ruleName, {
  rejected: (selector, firstDuplicateLine) =>
    `Unexpected duplicate selector "${selector}", first used at line ${firstDuplicateLine}`
});

const rule = function(actual) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, { actual });
    if (!validOptions) {
      return;
    }

    // The top level of this map will be rule sources.
    // Each source maps to another map, which maps rule parents to a set of selectors.
    // This ensures that selectors are only checked against selectors
    // from other rules that share the same parent and the same source.
    const selectorContextLookup = nodeContextLookup();

    root.walkRules(rule => {
      if (isKeyframeRule(rule)) {
        return;
      }

      const contextSelectorSet = selectorContextLookup.getContext(
        rule,
        findAtRuleContext(rule)
      );
      const resolvedSelectors = rule.selectors.reduce((result, selector) => {
        return _.union(result, resolvedNestedSelector(selector, rule));
      }, []);
      const normalizedSelectorList = resolvedSelectors.map(normalizeSelector);
      const selectorLine = rule.source.start.line;

      // Complain if the same selector list occurs twice

      // Sort the selectors list so that the order of the constituents
      // doesn't matter
      const sortedSelectorList = normalizedSelectorList
        .slice()
        .sort()
        .join(",");
      if (contextSelectorSet.has(sortedSelectorList)) {
        // If the selector isn't nested we can use its raw value; otherwise,
        // we have to approximate something for the message -- which is close enough
        const isNestedSelector =
          resolvedSelectors.join(",") !== rule.selectors.join(",");
        const selectorForMessage = isNestedSelector
          ? resolvedSelectors.join(", ")
          : rule.selector;
        const previousDuplicatePosition = contextSelectorSet.get(
          sortedSelectorList
        );

        return report({
          result,
          ruleName,
          node: rule,
          message: messages.rejected(
            selectorForMessage,
            previousDuplicatePosition
          )
        });
      }

      contextSelectorSet.set(sortedSelectorList, selectorLine);

      // Or complain if one selector list contains the same selector more than one
      rule.selectors.forEach((selector, i) => {
        if (
          _.includes(
            normalizedSelectorList.slice(0, i),
            normalizeSelector(selector)
          )
        ) {
          report({
            result,
            ruleName,
            node: rule,
            message: messages.rejected(selector, selectorLine)
          });
        }
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/findAtRuleContext":1082,"../../utils/isKeyframeRule":1113,"../../utils/nodeContextLookup":1136,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"normalize-selector":709,"postcss-resolve-nested-selector":782}],995:[function(require,module,exports){
"use strict";

const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "no-empty-source";

const messages = ruleMessages(ruleName, {
  rejected: "Unexpected empty source"
});

const rule = function(actual) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, { actual });
    if (!validOptions) {
      return;
    }

    if (!/^\s*$/.test(root.toString())) {
      return;
    }

    report({
      message: messages.rejected,
      node: root,
      result,
      ruleName
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144}],996:[function(require,module,exports){
"use strict";

const isOnlyWhitespace = require("../../utils/isOnlyWhitespace");
const optionsMatches = require("../../utils/optionsMatches");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const styleSearch = require("style-search");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "no-eol-whitespace";

const messages = ruleMessages(ruleName, {
  rejected: "Unexpected whitespace at end of line"
});

const whitespacesToReject = new Set([" ", "\t"]);

const rule = function(on, options) {
  return (root, result) => {
    const validOptions = validateOptions(
      result,
      ruleName,
      {
        actual: on
      },
      {
        optional: true,
        actual: options,
        possible: {
          ignore: ["empty-lines"]
        }
      }
    );
    if (!validOptions) {
      return;
    }

    const rootString = root.toString();
    styleSearch(
      {
        source: rootString,
        target: ["\n", "\r"],
        comments: "check"
      },
      match => {
        // If the character before newline is not whitespace, ignore
        if (!whitespacesToReject.has(rootString[match.startIndex - 1])) {
          return;
        }

        if (optionsMatches(options, "ignore", "empty-lines")) {
          // If there is only whitespace between the previous newline and
          // this newline, ignore
          const lineBefore = rootString.substring(
            match.startIndex + 1,
            rootString.lastIndexOf("\n", match.startIndex - 1)
          );
          if (isOnlyWhitespace(lineBefore)) {
            return;
          }
        }

        report({
          message: messages.rejected,
          node: root,
          index: match.startIndex - 1,
          result,
          ruleName
        });
      }
    );
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isOnlyWhitespace":1116,"../../utils/optionsMatches":1137,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"style-search":870}],997:[function(require,module,exports){
"use strict";

const isCustomPropertySet = require("../../utils/isCustomPropertySet");
const isStandardSyntaxRule = require("../../utils/isStandardSyntaxRule");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const styleSearch = require("style-search");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "no-extra-semicolons";

const messages = ruleMessages(ruleName, {
  rejected: "Unexpected extra semicolon"
});

function getOffsetByNode(node) {
  const string = node.root().source.input.css;
  const nodeColumn = node.source.start.column;
  const nodeLine = node.source.start.line;
  let line = 1;
  let column = 1;
  let index = 0;

  for (let i = 0; i < string.length; i++) {
    if (column === nodeColumn && nodeLine === line) {
      index = i;
      break;
    }

    if (string[i] === "\n") {
      column = 1;
      line += 1;
    } else {
      column += 1;
    }
  }

  return index;
}

const rule = function(actual) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, { actual });
    if (!validOptions) {
      return;
    }

    const rawAfterRoot = root.raws.after;

    if (rawAfterRoot && rawAfterRoot.trim().length !== 0) {
      styleSearch({ source: rawAfterRoot, target: ";" }, match => {
        complain(
          root.toString().length - rawAfterRoot.length + match.startIndex
        );
      });
    }

    root.walk(node => {
      if (
        node.type === "rule" &&
        !isCustomPropertySet(node) &&
        !isStandardSyntaxRule(node)
      ) {
        return;
      }

      let rawBeforeNode = node.raws.before;

      if (rawBeforeNode && rawBeforeNode.trim().length !== 0) {
        let allowedSemi = 0;

        const next = node.next();

        // Ignore semicolon before comment if next node is custom properties sets or comment
        if (
          node.type === "comment" &&
          next &&
          ((isCustomPropertySet(next) && node.parent.index(next) > 0) ||
            next.type === "comment")
        ) {
          allowedSemi = 1;
        }

        const prev = node.prev();

        // Adding previous node string to custom properties set if previous node is comment
        if (
          isCustomPropertySet(node) &&
          node.parent.index(node) > 0 &&
          prev &&
          prev.type === "comment"
        ) {
          rawBeforeNode = prev.toString() + rawBeforeNode;
          allowedSemi = 0;
        }

        styleSearch({ source: rawBeforeNode, target: ";" }, (match, count) => {
          if (count === allowedSemi) {
            return;
          }

          complain(
            getOffsetByNode(node) - rawBeforeNode.length + match.startIndex
          );
        });
      }

      const rawAfterNode = node.raws.after;

      if (rawAfterNode && rawAfterNode.trim().length !== 0) {
        /**
         * If the last child is a Less mixin followed by more than one semicolon,
         * node.raws.after will be populated with that semicolon.
         * Since we ignore Less mixins, exit here
         */
        if (
          node.last &&
          node.last.type === "rule" &&
          !isCustomPropertySet(node.last) &&
          !isStandardSyntaxRule(node.last)
        ) {
          return;
        }

        styleSearch({ source: rawAfterNode, target: ";" }, match => {
          const index =
            getOffsetByNode(node) +
            node.toString().length -
            1 -
            rawAfterNode.length +
            match.startIndex;

          complain(index);
        });
      }

      const rawOwnSemicolon = node.raws.ownSemicolon;

      if (rawOwnSemicolon) {
        let allowedSemi = 0;

        if (isCustomPropertySet(node)) {
          allowedSemi = 1;
        }

        styleSearch(
          { source: rawOwnSemicolon, target: ";" },
          (match, count) => {
            if (count === allowedSemi) {
              return;
            }

            const index =
              getOffsetByNode(node) +
              node.toString().length -
              rawOwnSemicolon.length +
              match.startIndex;
            complain(index);
          }
        );
      }
    });

    function complain(index) {
      report({
        message: messages.rejected,
        node: root,
        index,
        result,
        ruleName
      });
    }
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isCustomPropertySet":1110,"../../utils/isStandardSyntaxRule":1125,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"style-search":870}],998:[function(require,module,exports){
"use strict";

const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "no-invalid-double-slash-comments";

const messages = ruleMessages(ruleName, {
  rejected: "Unexpected double-slash CSS comment"
});

const rule = function(actual) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, { actual });
    if (!validOptions) {
      return;
    }

    root.walkDecls(decl => {
      if (decl.prop.indexOf("//") === 0) {
        report({
          message: messages.rejected,
          node: decl,
          result,
          ruleName
        });
      }
    });
    root.walkRules(rule => {
      rule.selectors.forEach(selector => {
        if (selector.indexOf("//") === 0) {
          report({
            message: messages.rejected,
            node: rule,
            result,
            ruleName
          });
        }
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144}],999:[function(require,module,exports){
"use strict";

const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "no-missing-end-of-source-newline";

const messages = ruleMessages(ruleName, {
  rejected: "Unexpected missing end-of-source newline"
});

const rule = function(actual) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, { actual });
    if (!validOptions) {
      return;
    }

    const sourceCss = root.source.input.css;
    if (sourceCss === "" || sourceCss.slice(-1) === "\n") {
      return;
    }

    report({
      message: messages.rejected,
      node: root,
      index: sourceCss.length - 1,
      result,
      ruleName
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144}],1000:[function(require,module,exports){
"use strict";

const declarationValueIndex = require("../../utils/declarationValueIndex");
const findAnimationName = require("../../utils/findAnimationName");
const keywordSets = require("../../reference/keywordSets");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "no-unknown-animations";

const messages = ruleMessages(ruleName, {
  rejected: animationName =>
    `Unexpected unknown animation name "${animationName}"`
});

const rule = function(actual) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, { actual });
    if (!validOptions) {
      return;
    }

    const declaredAnimations = new Set();
    root.walkAtRules(/(-(moz|webkit)-)?keyframes/i, atRule => {
      declaredAnimations.add(atRule.params);
    });

    root.walkDecls(decl => {
      if (
        decl.prop.toLowerCase() === "animation" ||
        decl.prop.toLowerCase() === "animation-name"
      ) {
        const animationNames = findAnimationName(decl.value);

        if (animationNames.length === 0) {
          return;
        }

        animationNames.forEach(animationNameNode => {
          if (
            keywordSets.animationNameKeywords.has(
              animationNameNode.value.toLowerCase()
            )
          ) {
            return;
          }
          if (declaredAnimations.has(animationNameNode.value)) {
            return;
          }

          report({
            result,
            ruleName,
            message: messages.rejected(animationNameNode.value),
            node: decl,
            index: declarationValueIndex(decl) + animationNameNode.sourceIndex
          });
        });
      }
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../reference/keywordSets":888,"../../utils/declarationValueIndex":1080,"../../utils/findAnimationName":1081,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144}],1001:[function(require,module,exports){
"use strict";

const atRuleParamIndex = require("../../utils/atRuleParamIndex");
const declarationValueIndex = require("../../utils/declarationValueIndex");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const valueParser = require("postcss-value-parser");

const ruleName = "number-leading-zero";

const messages = ruleMessages(ruleName, {
  expected: "Expected a leading zero",
  rejected: "Unexpected leading zero"
});

const rule = function(expectation) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "never"]
    });
    if (!validOptions) {
      return;
    }

    root.walkAtRules(atRule => {
      if (atRule.name.toLowerCase() === "import") {
        return;
      }

      check(atRule, atRule.params, atRuleParamIndex);
    });

    root.walkDecls(decl => check(decl, decl.value, declarationValueIndex));

    function check(node, value, getIndex) {
      // Get out quickly if there are no periods
      if (value.indexOf(".") === -1) {
        return;
      }

      valueParser(value).walk(valueNode => {
        // Ignore `url` function
        if (
          valueNode.type === "function" &&
          valueNode.value.toLowerCase() === "url"
        ) {
          return false;
        }

        // Ignore strings, comments, etc
        if (valueNode.type !== "word") {
          return;
        }

        // Check leading zero
        if (expectation === "always") {
          const match = /(?:\D|^)(\.\d+)/.exec(valueNode.value);

          if (match === null) {
            return;
          }

          // The regexp above consists of 2 capturing groups (or capturing parentheses).
          // We need the index of the second group. This makes sanse when we have "-.5" as an input
          // for regex. And we need the index of ".5".
          const capturingGroupIndex = match[0].length - match[1].length;
          complain(
            messages.expected,
            node,
            getIndex(node) +
              valueNode.sourceIndex +
              match.index +
              capturingGroupIndex
          );
        }

        if (expectation === "never") {
          const match = /(?:\D|^)(0+\.\d+)/.exec(valueNode.value);

          if (match === null) {
            return;
          }

          const capturingGroupIndex = match[0].length - match[1].length;
          complain(
            messages.rejected,
            node,
            getIndex(node) +
              valueNode.sourceIndex +
              match.index +
              capturingGroupIndex
          );
        }
      });
    }

    function complain(message, node, index) {
      report({
        result,
        ruleName,
        message,
        node,
        index
      });
    }
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/atRuleParamIndex":1071,"../../utils/declarationValueIndex":1080,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"postcss-value-parser":811}],1002:[function(require,module,exports){
"use strict";

const atRuleParamIndex = require("../../utils/atRuleParamIndex");
const declarationValueIndex = require("../../utils/declarationValueIndex");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const _ = require("lodash");
const valueParser = require("postcss-value-parser");

const ruleName = "number-max-precision";

const messages = ruleMessages(ruleName, {
  expected: (number, precision) =>
    `Expected "${number}" to be "${number.toFixed(precision)}"`
});

const rule = function(precision) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: precision,
      possible: [_.isNumber]
    });
    if (!validOptions) {
      return;
    }

    root.walkAtRules(atRule => {
      if (atRule.name.toLowerCase() === "import") {
        return;
      }

      check(atRule, atRule.params, atRuleParamIndex);
    });

    root.walkDecls(decl => check(decl, decl.value, declarationValueIndex));

    function check(node, value, getIndex) {
      // Get out quickly if there are no periods
      if (value.indexOf(".") === -1) {
        return;
      }

      valueParser(value).walk(valueNode => {
        // Ignore `url` function
        if (
          valueNode.type === "function" &&
          valueNode.value.toLowerCase() === "url"
        ) {
          return false;
        }

        // Ignore strings, comments, etc
        if (valueNode.type !== "word") {
          return;
        }

        const match = /\d*\.(\d+)/.exec(valueNode.value);

        if (match === null) {
          return;
        }

        if (match[1].length <= precision) {
          return;
        }

        report({
          result,
          ruleName,
          node,
          index: getIndex(node) + valueNode.sourceIndex + match.index,
          message: messages.expected(parseFloat(match[0]), precision)
        });
      });
    }
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/atRuleParamIndex":1071,"../../utils/declarationValueIndex":1080,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"postcss-value-parser":811}],1003:[function(require,module,exports){
"use strict";

const atRuleParamIndex = require("../../utils/atRuleParamIndex");
const declarationValueIndex = require("../../utils/declarationValueIndex");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const valueParser = require("postcss-value-parser");

const ruleName = "number-no-trailing-zeros";

const messages = ruleMessages(ruleName, {
  rejected: "Unexpected trailing zero(s)"
});

const rule = function(actual) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, { actual });
    if (!validOptions) {
      return;
    }

    root.walkAtRules(atRule => {
      if (atRule.name.toLowerCase() === "import") {
        return;
      }

      check(atRule, atRule.params, atRuleParamIndex);
    });

    root.walkDecls(decl => check(decl, decl.value, declarationValueIndex));

    function check(node, value, getIndex) {
      // Get out quickly if there are no periods
      if (value.indexOf(".") === -1) {
        return;
      }

      valueParser(value).walk(valueNode => {
        // Ignore `url` function
        if (
          valueNode.type === "function" &&
          valueNode.value.toLowerCase() === "url"
        ) {
          return false;
        }

        // Ignore strings, comments, etc
        if (valueNode.type !== "word") {
          return;
        }

        const match = /(\.\d*)0+(?:\D|$)/.exec(valueNode.value);

        if (match === null) {
          return;
        }

        report({
          message: messages.rejected,
          node,
          index:
            getIndex(node) +
            valueNode.sourceIndex +
            match.index +
            match[1].length,
          result,
          ruleName
        });
      });
    }
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/atRuleParamIndex":1071,"../../utils/declarationValueIndex":1080,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"postcss-value-parser":811}],1004:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const isCustomProperty = require("../../utils/isCustomProperty");
const isStandardSyntaxProperty = require("../../utils/isStandardSyntaxProperty");
const matchesStringOrRegExp = require("../../utils/matchesStringOrRegExp");
const postcss = require("postcss");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "property-blacklist";

const messages = ruleMessages(ruleName, {
  rejected: property => `Unexpected property "${property}"`
});

const rule = function(blacklist) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: blacklist,
      possible: [_.isString]
    });
    if (!validOptions) {
      return;
    }

    root.walkDecls(decl => {
      const prop = decl.prop;

      if (!isStandardSyntaxProperty(prop)) {
        return;
      }
      if (isCustomProperty(prop)) {
        return;
      }
      if (!matchesStringOrRegExp(postcss.vendor.unprefixed(prop), blacklist)) {
        return;
      }

      report({
        message: messages.rejected(prop),
        node: decl,
        result,
        ruleName
      });
    });
  };
};

rule.primaryOptionArray = true;

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isCustomProperty":1109,"../../utils/isStandardSyntaxProperty":1124,"../../utils/matchesStringOrRegExp":1134,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"postcss":828}],1005:[function(require,module,exports){
"use strict";

const isCustomProperty = require("../../utils/isCustomProperty");
const isStandardSyntaxProperty = require("../../utils/isStandardSyntaxProperty");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "property-case";

const messages = ruleMessages(ruleName, {
  expected: (actual, expected) => `Expected "${actual}" to be "${expected}"`
});

const rule = function(expectation) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["lower", "upper"]
    });
    if (!validOptions) {
      return;
    }

    root.walkDecls(decl => {
      const prop = decl.prop;

      if (!isStandardSyntaxProperty(prop)) {
        return;
      }
      if (isCustomProperty(prop)) {
        return;
      }

      const expectedProp =
        expectation === "lower" ? prop.toLowerCase() : prop.toUpperCase();
      if (prop === expectedProp) {
        return;
      }

      report({
        message: messages.expected(prop, expectedProp),
        node: decl,
        ruleName,
        result
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isCustomProperty":1109,"../../utils/isStandardSyntaxProperty":1124,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144}],1006:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const isCustomProperty = require("../../utils/isCustomProperty");
const isStandardSyntaxDeclaration = require("../../utils/isStandardSyntaxDeclaration");
const isStandardSyntaxProperty = require("../../utils/isStandardSyntaxProperty");
const optionsMatches = require("../../utils/optionsMatches");
const postcss = require("postcss");
const properties = require("known-css-properties").all;
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "property-no-unknown";

const messages = ruleMessages(ruleName, {
  rejected: property => `Unexpected unknown property "${property}"`
});

const rule = function(actual, options) {
  return (root, result) => {
    const validOptions = validateOptions(
      result,
      ruleName,
      { actual },
      {
        actual: options,
        possible: {
          ignoreProperties: [_.isString],
          checkPrefixed: _.isBoolean
        },
        optional: true
      }
    );

    if (!validOptions) {
      return;
    }

    const shouldCheckPrefixed = _.get(options, "checkPrefixed");

    root.walkDecls(decl => {
      const prop = decl.prop;

      if (!isStandardSyntaxProperty(prop)) {
        return;
      }
      if (!isStandardSyntaxDeclaration(decl)) {
        return;
      }
      if (isCustomProperty(prop)) {
        return;
      }

      if (!shouldCheckPrefixed && postcss.vendor.prefix(prop)) {
        return;
      }

      if (optionsMatches(options, "ignoreProperties", prop)) {
        return;
      }

      if (properties.indexOf(prop.toLowerCase()) !== -1) {
        return;
      }

      report({
        message: messages.rejected(prop),
        node: decl,
        result,
        ruleName
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isCustomProperty":1109,"../../utils/isStandardSyntaxDeclaration":1121,"../../utils/isStandardSyntaxProperty":1124,"../../utils/optionsMatches":1137,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"known-css-properties":691,"lodash":692,"postcss":828}],1007:[function(require,module,exports){
"use strict";

const isAutoprefixable = require("../../utils/isAutoprefixable");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "property-no-vendor-prefix";

const messages = ruleMessages(ruleName, {
  rejected: property => `Unexpected vendor-prefix "${property}"`
});

const rule = function(actual) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, { actual });
    if (!validOptions) {
      return;
    }

    root.walkDecls(decl => {
      const prop = decl.prop;

      // Make sure there's a vendor prefix,
      // but this isn't a custom property

      if (prop[0] !== "-" || prop[1] === "-") {
        return;
      }

      if (!isAutoprefixable.property(prop)) {
        return;
      }
      report({
        message: messages.rejected(prop),
        node: decl,
        result,
        ruleName
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isAutoprefixable":1102,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144}],1008:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const isCustomProperty = require("../../utils/isCustomProperty");
const isStandardSyntaxProperty = require("../../utils/isStandardSyntaxProperty");
const matchesStringOrRegExp = require("../../utils/matchesStringOrRegExp");
const postcss = require("postcss");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "property-whitelist";

const messages = ruleMessages(ruleName, {
  rejected: property => `Unexpected property "${property}"`
});

const rule = function(whitelist) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: whitelist,
      possible: [_.isString]
    });
    if (!validOptions) {
      return;
    }

    root.walkDecls(decl => {
      const prop = decl.prop;

      if (!isStandardSyntaxProperty(prop)) {
        return;
      }
      if (isCustomProperty(prop)) {
        return;
      }
      if (matchesStringOrRegExp(postcss.vendor.unprefixed(prop), whitelist)) {
        return;
      }

      report({
        message: messages.rejected(prop),
        node: decl,
        result,
        ruleName
      });
    });
  };
};

rule.primaryOptionArray = true;

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isCustomProperty":1109,"../../utils/isStandardSyntaxProperty":1124,"../../utils/matchesStringOrRegExp":1134,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"postcss":828}],1009:[function(require,module,exports){
"use strict";

const addEmptyLineBefore = require("../../utils/addEmptyLineBefore");
const hasEmptyLine = require("../../utils/hasEmptyLine");
const isSingleLineString = require("../../utils/isSingleLineString");
const isStandardSyntaxRule = require("../../utils/isStandardSyntaxRule");
const optionsMatches = require("../../utils/optionsMatches");
const removeEmptyLinesBefore = require("../../utils/removeEmptyLinesBefore");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "rule-empty-line-before";

const messages = ruleMessages(ruleName, {
  expected: "Expected empty line before rule",
  rejected: "Unexpected empty line before rule"
});

const rule = function(expectation, options, context) {
  return (root, result) => {
    const validOptions = validateOptions(
      result,
      ruleName,
      {
        actual: expectation,
        possible: ["always", "never", "always-multi-line", "never-multi-line"]
      },
      {
        actual: options,
        possible: {
          ignore: ["after-comment", "inside-block"],
          except: [
            "after-rule",
            "after-single-line-comment",
            "first-nested",
            "inside-block-and-after-rule"
          ]
        },
        optional: true
      }
    );

    if (!validOptions) {
      return;
    }

    root.walkRules(rule => {
      if (!isStandardSyntaxRule(rule)) {
        return;
      }

      // Ignore the first node
      if (rule === root.first) {
        return;
      }

      let expectEmptyLineBefore =
        expectation.indexOf("always") !== -1 ? true : false;

      // Optionally ignore the expectation if a comment precedes this node
      if (
        optionsMatches(options, "ignore", "after-comment") &&
        rule.prev() &&
        rule.prev().type === "comment"
      ) {
        return;
      }

      // Optionally ignore the expectation if inside a block
      if (
        optionsMatches(options, "ignore", "inside-block") &&
        rule.parent !== root
      ) {
        return;
      }

      // Ignore if the expectation is for multiple and the rule is single-line
      if (
        expectation.indexOf("multi-line") !== -1 &&
        isSingleLineString(rule.toString())
      ) {
        return;
      }

      // Optionally reverse the expectation for the first nested node
      if (
        optionsMatches(options, "except", "first-nested") &&
        rule === rule.parent.first
      ) {
        expectEmptyLineBefore = !expectEmptyLineBefore;
      }

      // Optionally reverse the expectation if a rule precedes this node
      if (
        optionsMatches(options, "except", "after-rule") &&
        rule.prev() &&
        rule.prev().type === "rule"
      ) {
        expectEmptyLineBefore = !expectEmptyLineBefore;
      }

      // Optionally reverse the expectation if a rule precedes this node and is inside a block
      if (
        optionsMatches(options, "except", "inside-block-and-after-rule") &&
        rule.prev() &&
        rule.prev().type === "rule" &&
        rule.parent !== root
      ) {
        expectEmptyLineBefore = !expectEmptyLineBefore;
      }

      // Optionally reverse the expectation for single line comments
      if (
        optionsMatches(options, "except", "after-single-line-comment") &&
        rule.prev() &&
        rule.prev().type === "comment" &&
        isSingleLineString(rule.prev().toString())
      ) {
        expectEmptyLineBefore = !expectEmptyLineBefore;
      }

      const hasEmptyLineBefore = hasEmptyLine(rule.raws.before);

      // Return if the expectation is met
      if (expectEmptyLineBefore === hasEmptyLineBefore) {
        return;
      }

      // Fix
      if (context.fix) {
        if (expectEmptyLineBefore) {
          addEmptyLineBefore(rule, context.newline);
        } else {
          removeEmptyLinesBefore(rule, context.newline);
        }

        return;
      }

      const message = expectEmptyLineBefore
        ? messages.expected
        : messages.rejected;

      report({
        message,
        node: rule,
        result,
        ruleName
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/addEmptyLineBefore":1070,"../../utils/hasEmptyLine":1094,"../../utils/isSingleLineString":1119,"../../utils/isStandardSyntaxRule":1125,"../../utils/optionsMatches":1137,"../../utils/removeEmptyLinesBefore":1140,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144}],1010:[function(require,module,exports){
"use strict";

const isStandardSyntaxRule = require("../../utils/isStandardSyntaxRule");
const parseSelector = require("../../utils/parseSelector");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const styleSearch = require("style-search");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "selector-attribute-brackets-space-inside";

const messages = ruleMessages(ruleName, {
  expectedOpening: 'Expected single space after "["',
  rejectedOpening: 'Unexpected whitespace after "["',
  expectedClosing: 'Expected single space before "]"',
  rejectedClosing: 'Unexpected whitespace before "]"'
});

const rule = function(expectation) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "never"]
    });
    if (!validOptions) {
      return;
    }

    root.walkRules(rule => {
      if (!isStandardSyntaxRule(rule)) {
        return;
      }
      if (rule.selector.indexOf("[") === -1) {
        return;
      }

      parseSelector(rule.selector, result, rule, selectorTree => {
        selectorTree.walkAttributes(attributeNode => {
          const attributeSelectorString = attributeNode.toString();

          styleSearch(
            { source: attributeSelectorString, target: "[" },
            match => {
              const nextCharIsSpace =
                attributeSelectorString[match.startIndex + 1] === " ";
              const index = attributeNode.sourceIndex + match.startIndex + 1;
              if (nextCharIsSpace && expectation === "never") {
                complain(messages.rejectedOpening, index);
              }
              if (!nextCharIsSpace && expectation === "always") {
                complain(messages.expectedOpening, index);
              }
            }
          );

          styleSearch(
            { source: attributeSelectorString, target: "]" },
            match => {
              const prevCharIsSpace =
                attributeSelectorString[match.startIndex - 1] === " ";
              const index = attributeNode.sourceIndex + match.startIndex - 1;
              if (prevCharIsSpace && expectation === "never") {
                complain(messages.rejectedClosing, index);
              }
              if (!prevCharIsSpace && expectation === "always") {
                complain(messages.expectedClosing, index);
              }
            }
          );
        });
      });

      function complain(message, index) {
        report({
          message,
          index,
          result,
          ruleName,
          node: rule
        });
      }
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isStandardSyntaxRule":1125,"../../utils/parseSelector":1138,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"style-search":870}],1011:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const isStandardSyntaxRule = require("../../utils/isStandardSyntaxRule");
const parseSelector = require("../../utils/parseSelector");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "selector-attribute-operator-blacklist";

const messages = ruleMessages(ruleName, {
  rejected: operator => `Unexpected operator "${operator}"`
});

const rule = function(blacklistInput) {
  const blacklist = [].concat(blacklistInput);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: blacklist,
      possible: [_.isString]
    });
    if (!validOptions) {
      return;
    }

    root.walkRules(rule => {
      if (!isStandardSyntaxRule(rule)) {
        return;
      }
      if (
        rule.selector.indexOf("[") === -1 ||
        rule.selector.indexOf("=") === -1
      ) {
        return;
      }

      parseSelector(rule.selector, result, rule, selectorTree => {
        selectorTree.walkAttributes(attributeNode => {
          const operator = attributeNode.operator;

          if (!operator || (operator && blacklist.indexOf(operator) === -1)) {
            return;
          }

          report({
            message: messages.rejected(operator),
            node: rule,
            index: attributeNode.attribute.length + 1,
            result,
            ruleName
          });
        });
      });
    });
  };
};

rule.primaryOptionArray = true;

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isStandardSyntaxRule":1125,"../../utils/parseSelector":1138,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692}],1012:[function(require,module,exports){
"use strict";

const ruleMessages = require("../../utils/ruleMessages");
const selectorAttributeOperatorSpaceChecker = require("../selectorAttributeOperatorSpaceChecker");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "selector-attribute-operator-space-after";

const messages = ruleMessages(ruleName, {
  expectedAfter: operator => `Expected single space after "${operator}"`,
  rejectedAfter: operator => `Unexpected whitespace after "${operator}"`
});

const rule = function(expectation) {
  return (root, result) => {
    const checker = whitespaceChecker("space", expectation, messages);
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "never"]
    });
    if (!validOptions) {
      return;
    }

    selectorAttributeOperatorSpaceChecker({
      root,
      result,
      locationChecker: checker.after,
      checkedRuleName: ruleName,
      checkBeforeOperator: false
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145,"../selectorAttributeOperatorSpaceChecker":1047}],1013:[function(require,module,exports){
"use strict";

const ruleMessages = require("../../utils/ruleMessages");
const selectorAttributeOperatorSpaceChecker = require("../selectorAttributeOperatorSpaceChecker");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "selector-attribute-operator-space-before";

const messages = ruleMessages(ruleName, {
  expectedBefore: operator => `Expected single space before "${operator}"`,
  rejectedBefore: operator => `Unexpected whitespace before "${operator}"`
});

const rule = function(expectation) {
  const checker = whitespaceChecker("space", expectation, messages);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "never"]
    });
    if (!validOptions) {
      return;
    }

    selectorAttributeOperatorSpaceChecker({
      root,
      result,
      locationChecker: checker.before,
      checkedRuleName: ruleName,
      checkBeforeOperator: true
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145,"../selectorAttributeOperatorSpaceChecker":1047}],1014:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const isStandardSyntaxRule = require("../../utils/isStandardSyntaxRule");
const parseSelector = require("../../utils/parseSelector");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "selector-attribute-operator-whitelist";

const messages = ruleMessages(ruleName, {
  rejected: operator => `Unexpected operator "${operator}"`
});

const rule = function(whitelistInput) {
  const whitelist = [].concat(whitelistInput);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: whitelist,
      possible: [_.isString]
    });
    if (!validOptions) {
      return;
    }

    root.walkRules(rule => {
      if (!isStandardSyntaxRule(rule)) {
        return;
      }
      if (
        rule.selector.indexOf("[") === -1 ||
        rule.selector.indexOf("=") === -1
      ) {
        return;
      }

      parseSelector(rule.selector, result, rule, selectorTree => {
        selectorTree.walkAttributes(attributeNode => {
          const operator = attributeNode.operator;

          if (!operator || (operator && whitelist.indexOf(operator) !== -1)) {
            return;
          }

          report({
            message: messages.rejected(operator),
            node: rule,
            index: attributeNode.attribute.length + 1,
            result,
            ruleName
          });
        });
      });
    });
  };
};

rule.primaryOptionArray = true;

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isStandardSyntaxRule":1125,"../../utils/parseSelector":1138,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692}],1015:[function(require,module,exports){
"use strict";

const isStandardSyntaxRule = require("../../utils/isStandardSyntaxRule");
const parseSelector = require("../../utils/parseSelector");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "selector-attribute-quotes";

const messages = ruleMessages(ruleName, {
  expected: value => `Expected quotes around "${value}"`,
  rejected: value => `Unexpected quotes around "${value}"`
});

const rule = function(expectation) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "never"]
    });
    if (!validOptions) {
      return;
    }

    root.walkRules(rule => {
      if (!isStandardSyntaxRule(rule)) {
        return;
      }
      if (
        rule.selector.indexOf("[") === -1 ||
        rule.selector.indexOf("=") === -1
      ) {
        return;
      }

      parseSelector(rule.selector, result, rule, selectorTree => {
        selectorTree.walkAttributes(attributeNode => {
          if (!attributeNode.operator) {
            return;
          }

          const attributeSelectorString = attributeNode.toString();

          if (!attributeNode.quoted && expectation === "always") {
            complain(
              messages.expected(attributeNode.raws.unquoted),
              attributeNode.sourceIndex +
                attributeSelectorString.indexOf(attributeNode.value)
            );
          }

          if (attributeNode.quoted && expectation === "never") {
            complain(
              messages.rejected(attributeNode.raws.unquoted),
              attributeNode.sourceIndex +
                attributeSelectorString.indexOf(attributeNode.value)
            );
          }
        });
      });

      function complain(message, index) {
        report({
          message,
          index,
          result,
          ruleName,
          node: rule
        });
      }
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isStandardSyntaxRule":1125,"../../utils/parseSelector":1138,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144}],1016:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const isKeyframeSelector = require("../../utils/isKeyframeSelector");
const isStandardSyntaxRule = require("../../utils/isStandardSyntaxRule");
const isStandardSyntaxSelector = require("../../utils/isStandardSyntaxSelector");
const parseSelector = require("../../utils/parseSelector");
const report = require("../../utils/report");
const resolveNestedSelector = require("postcss-resolve-nested-selector");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "selector-class-pattern";

const messages = ruleMessages(ruleName, {
  expected: selectorValue =>
    `Expected class selector ".${selectorValue}" to match specified pattern`
});

const rule = function(pattern, options) {
  return (root, result) => {
    const validOptions = validateOptions(
      result,
      ruleName,
      {
        actual: pattern,
        possible: [_.isRegExp, _.isString]
      },
      {
        actual: options,
        possible: {
          resolveNestedSelectors: _.isBoolean
        },
        optional: true
      }
    );
    if (!validOptions) {
      return;
    }

    const shouldResolveNestedSelectors = _.get(
      options,
      "resolveNestedSelectors"
    );
    const normalizedPattern = _.isString(pattern)
      ? new RegExp(pattern)
      : pattern;

    root.walkRules(rule => {
      const selector = rule.selector;
      const selectors = rule.selectors;

      if (!isStandardSyntaxRule(rule)) {
        return;
      }
      if (!isStandardSyntaxSelector(selector)) {
        return;
      }
      if (selectors.some(s => isKeyframeSelector(s))) {
        return;
      }

      // Only bother resolving selectors that have an interpolating &
      if (shouldResolveNestedSelectors && hasInterpolatingAmpersand(selector)) {
        resolveNestedSelector(selector, rule).forEach(selector => {
          if (!isStandardSyntaxSelector(selector)) {
            return;
          }

          parseSelector(selector, result, rule, s => checkSelector(s, rule));
        });
      } else {
        parseSelector(selector, result, rule, s => checkSelector(s, rule));
      }
    });

    function checkSelector(fullSelector, rule) {
      fullSelector.walkClasses(classNode => {
        const value = classNode.value;
        const sourceIndex = classNode.sourceIndex;

        if (normalizedPattern.test(value)) {
          return;
        }
        report({
          result,
          ruleName,
          message: messages.expected(value),
          node: rule,
          index: sourceIndex
        });
      });
    }
  };
};

// An "interpolating ampersand" means an "&" used to interpolate
// within another simple selector, rather than an "&" that
// stands on its own as a simple selector
function hasInterpolatingAmpersand(selector) {
  for (let i = 0, l = selector.length; i < l; i++) {
    if (selector[i] !== "&") {
      continue;
    }
    if (!_.isUndefined(selector[i - 1]) && !isCombinator(selector[i - 1])) {
      return true;
    }
    if (!_.isUndefined(selector[i + 1]) && !isCombinator(selector[i + 1])) {
      return true;
    }
  }
  return false;
}

function isCombinator(x) {
  return /[\s+>~]/.test(x);
}

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isKeyframeSelector":1114,"../../utils/isStandardSyntaxRule":1125,"../../utils/isStandardSyntaxSelector":1126,"../../utils/parseSelector":1138,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"postcss-resolve-nested-selector":782}],1017:[function(require,module,exports){
"use strict";

const ruleMessages = require("../../utils/ruleMessages");
const selectorCombinatorSpaceChecker = require("../selectorCombinatorSpaceChecker");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "selector-combinator-space-after";

const messages = ruleMessages(ruleName, {
  expectedAfter: combinator => `Expected single space after "${combinator}"`,
  rejectedAfter: combinator => `Unexpected whitespace after "${combinator}"`
});

const rule = function(expectation) {
  const checker = whitespaceChecker("space", expectation, messages);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "never"]
    });
    if (!validOptions) {
      return;
    }

    selectorCombinatorSpaceChecker({
      root,
      result,
      locationChecker: checker.after,
      locationType: "after",
      checkedRuleName: ruleName
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145,"../selectorCombinatorSpaceChecker":1048}],1018:[function(require,module,exports){
"use strict";

const ruleMessages = require("../../utils/ruleMessages");
const selectorCombinatorSpaceChecker = require("../selectorCombinatorSpaceChecker");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "selector-combinator-space-before";

const messages = ruleMessages(ruleName, {
  expectedBefore: combinator => `Expected single space before "${combinator}"`,
  rejectedBefore: combinator => `Unexpected whitespace before "${combinator}"`
});

const rule = function(expectation) {
  const checker = whitespaceChecker("space", expectation, messages);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "never"]
    });
    if (!validOptions) {
      return;
    }

    selectorCombinatorSpaceChecker({
      root,
      result,
      locationChecker: checker.before,
      locationType: "before",
      checkedRuleName: ruleName
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145,"../selectorCombinatorSpaceChecker":1048}],1019:[function(require,module,exports){
"use strict";

const isStandardSyntaxRule = require("../../utils/isStandardSyntaxRule");
const parseSelector = require("../../utils/parseSelector");
const punctuationSets = require("../../reference/punctuationSets");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "selector-descendant-combinator-no-non-space";

const messages = ruleMessages(ruleName, {
  rejected: nonSpaceCharacter => `Unexpected "${nonSpaceCharacter}"`
});

const rule = function(actual) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, { actual });
    if (!validOptions) {
      return;
    }

    root.walkRules(rule => {
      if (!isStandardSyntaxRule(rule)) {
        return;
      }

      const selector = rule.selector;

      parseSelector(selector, result, rule, fullSelector => {
        fullSelector.walkCombinators(combinatorNode => {
          const value = combinatorNode.value;

          if (punctuationSets.nonSpaceCombinators.has(value)) {
            return;
          }
          if (value === " ") {
            return;
          }

          report({
            result,
            ruleName,
            message: messages.rejected(value),
            node: rule,
            index: combinatorNode.sourceIndex
          });
        });
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../reference/punctuationSets":891,"../../utils/isStandardSyntaxRule":1125,"../../utils/parseSelector":1138,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144}],1020:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const isStandardSyntaxRule = require("../../utils/isStandardSyntaxRule");
const isStandardSyntaxSelector = require("../../utils/isStandardSyntaxSelector");
const parseSelector = require("../../utils/parseSelector");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "selector-id-pattern";

const messages = ruleMessages(ruleName, {
  expected: selectorValue =>
    `Expected id selector "#${selectorValue}" to match specified pattern`
});

const rule = function(pattern) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: pattern,
      possible: [_.isRegExp, _.isString]
    });
    if (!validOptions) {
      return;
    }

    const normalizedPattern = _.isString(pattern)
      ? new RegExp(pattern)
      : pattern;

    root.walkRules(rule => {
      if (!isStandardSyntaxRule(rule)) {
        return;
      }

      const selector = rule.selector;

      if (!isStandardSyntaxSelector(selector)) {
        return;
      }

      parseSelector(selector, result, rule, fullSelector => {
        fullSelector.walk(selectorNode => {
          if (selectorNode.type !== "id") {
            return;
          }
          const value = selectorNode.value,
            sourceIndex = selectorNode.sourceIndex;

          if (normalizedPattern.test(value)) {
            return;
          }

          report({
            result,
            ruleName,
            message: messages.expected(value),
            node: rule,
            index: sourceIndex
          });
        });
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isStandardSyntaxRule":1125,"../../utils/isStandardSyntaxSelector":1126,"../../utils/parseSelector":1138,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692}],1021:[function(require,module,exports){
"use strict";

const isStandardSyntaxRule = require("../../utils/isStandardSyntaxRule");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const styleSearch = require("style-search");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "selector-list-comma-newline-after";

const messages = ruleMessages(ruleName, {
  expectedAfter: () => 'Expected newline after ","',
  expectedAfterMultiLine: () =>
    'Expected newline after "," in a multi-line list',
  rejectedAfterMultiLine: () =>
    'Unexpected whitespace after "," in a multi-line list'
});

const rule = function(expectation) {
  const checker = whitespaceChecker("newline", expectation, messages);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "always-multi-line", "never-multi-line"]
    });
    if (!validOptions) {
      return;
    }

    root.walkRules(rule => {
      if (!isStandardSyntaxRule(rule)) {
        return;
      }
      // Get raw selector so we can allow end-of-line comments, e.g.
      // a, /* comment */
      // b {}
      const selector = rule.raws.selector
        ? rule.raws.selector.raw
        : rule.selector;
      styleSearch(
        {
          source: selector,
          target: ",",
          functionArguments: "skip"
        },
        match => {
          const nextThreeChars = selector.substr(match.endIndex, 3);

          // If there's a // comment, that means there has to be a newline
          // ending the comment so we're fine
          if (nextThreeChars === " //") {
            return;
          }

          // If there is a space and then a comment begins, look for the newline
          // after that comment
          const indextoCheckAfter =
            nextThreeChars === " /*"
              ? selector.indexOf("*/", match.endIndex) + 1
              : match.startIndex;
          checker.afterOneOnly({
            source: selector,
            index: indextoCheckAfter,
            err: m =>
              report({
                message: m,
                node: rule,
                index: match.startIndex,
                result,
                ruleName
              })
          });
        }
      );
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isStandardSyntaxRule":1125,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145,"style-search":870}],1022:[function(require,module,exports){
"use strict";

const ruleMessages = require("../../utils/ruleMessages");
const selectorListCommaWhitespaceChecker = require("../selectorListCommaWhitespaceChecker");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "selector-list-comma-newline-before";

const messages = ruleMessages(ruleName, {
  expectedBefore: () => 'Expected newline before ","',
  expectedBeforeMultiLine: () =>
    'Expected newline before "," in a multi-line list',
  rejectedBeforeMultiLine: () =>
    'Unexpected whitespace before "," in a multi-line list'
});

const rule = function(expectation) {
  const checker = whitespaceChecker("newline", expectation, messages);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "always-multi-line", "never-multi-line"]
    });
    if (!validOptions) {
      return;
    }

    selectorListCommaWhitespaceChecker({
      root,
      result,
      locationChecker: checker.beforeAllowingIndentation,
      checkedRuleName: ruleName
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145,"../selectorListCommaWhitespaceChecker":1049}],1023:[function(require,module,exports){
"use strict";

const ruleMessages = require("../../utils/ruleMessages");
const selectorListCommaWhitespaceChecker = require("../selectorListCommaWhitespaceChecker");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "selector-list-comma-space-after";

const messages = ruleMessages(ruleName, {
  expectedAfter: () => 'Expected single space after ","',
  rejectedAfter: () => 'Unexpected whitespace after ","',
  expectedAfterSingleLine: () =>
    'Expected single space after "," in a single-line list',
  rejectedAfterSingleLine: () =>
    'Unexpected whitespace after "," in a single-line list'
});

const rule = function(expectation) {
  const checker = whitespaceChecker("space", expectation, messages);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "never", "always-single-line", "never-single-line"]
    });
    if (!validOptions) {
      return;
    }

    selectorListCommaWhitespaceChecker({
      root,
      result,
      locationChecker: checker.after,
      checkedRuleName: ruleName
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145,"../selectorListCommaWhitespaceChecker":1049}],1024:[function(require,module,exports){
"use strict";

const ruleMessages = require("../../utils/ruleMessages");
const selectorListCommaWhitespaceChecker = require("../selectorListCommaWhitespaceChecker");
const validateOptions = require("../../utils/validateOptions");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "selector-list-comma-space-before";

const messages = ruleMessages(ruleName, {
  expectedBefore: () => 'Expected single space before ","',
  rejectedBefore: () => 'Unexpected whitespace before ","',
  expectedBeforeSingleLine: () =>
    'Expected single space before "," in a single-line list',
  rejectedBeforeSingleLine: () =>
    'Unexpected whitespace before "," in a single-line list'
});

const rule = function(expectation) {
  const checker = whitespaceChecker("space", expectation, messages);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "never", "always-single-line", "never-single-line"]
    });
    if (!validOptions) {
      return;
    }

    selectorListCommaWhitespaceChecker({
      root,
      result,
      locationChecker: checker.before,
      checkedRuleName: ruleName
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145,"../selectorListCommaWhitespaceChecker":1049}],1025:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const isStandardSyntaxRule = require("../../utils/isStandardSyntaxRule");
const isStandardSyntaxSelector = require("../../utils/isStandardSyntaxSelector");
const optionsMatches = require("../../utils/optionsMatches");
const parseSelector = require("../../utils/parseSelector");
const report = require("../../utils/report");
const resolvedNestedSelector = require("postcss-resolve-nested-selector");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "selector-max-attribute";

const messages = ruleMessages(ruleName, {
  expected: (selector, max) =>
    `Expected "${selector}" to have no more than ${max} attribute ${max === 1
      ? "selector"
      : "selectors"}`
});

function rule(max, options) {
  return (root, result) => {
    const validOptions = validateOptions(
      result,
      ruleName,
      {
        actual: max,
        possible: [
          function(max) {
            return typeof max === "number" && max >= 0;
          }
        ]
      },
      {
        actual: options,
        possible: {
          ignoreAttributes: [_.isString]
        },
        optional: true
      }
    );
    if (!validOptions) {
      return;
    }

    function checkSelector(selectorNode, ruleNode) {
      const count = selectorNode.reduce((total, childNode) => {
        // Only traverse inside actual selectors and :not()
        if (childNode.type === "selector" || childNode.value === ":not") {
          checkSelector(childNode, ruleNode);
        }

        if (childNode.type !== "attribute") {
          // Not an attribute node -> ignore
          return total;
        }
        if (optionsMatches(options, "ignoreAttributes", childNode.attribute)) {
          // it's an attribute that is supposed to be ignored
          return total;
        }

        return (total += 1);
      }, 0);

      if (
        selectorNode.type !== "root" &&
        selectorNode.type !== "pseudo" &&
        count > max
      ) {
        report({
          ruleName,
          result,
          node: ruleNode,
          message: messages.expected(selectorNode, max),
          word: selectorNode
        });
      }
    }

    root.walkRules(ruleNode => {
      if (!isStandardSyntaxRule(ruleNode)) {
        return;
      }
      if (!isStandardSyntaxSelector(ruleNode.selector)) {
        return;
      }
      if (
        ruleNode.nodes.some(
          node => ["rule", "atrule"].indexOf(node.type) !== -1
        )
      ) {
        // Skip unresolved nested selectors
        return;
      }

      ruleNode.selectors.forEach(selector => {
        resolvedNestedSelector(selector, ruleNode).forEach(resolvedSelector => {
          parseSelector(resolvedSelector, result, ruleNode, container =>
            checkSelector(container, ruleNode)
          );
        });
      });
    });
  };
}

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isStandardSyntaxRule":1125,"../../utils/isStandardSyntaxSelector":1126,"../../utils/optionsMatches":1137,"../../utils/parseSelector":1138,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"postcss-resolve-nested-selector":782}],1026:[function(require,module,exports){
"use strict";

const isStandardSyntaxRule = require("../../utils/isStandardSyntaxRule");
const isStandardSyntaxSelector = require("../../utils/isStandardSyntaxSelector");
const parseSelector = require("../../utils/parseSelector");
const report = require("../../utils/report");
const resolvedNestedSelector = require("postcss-resolve-nested-selector");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "selector-max-class";

const messages = ruleMessages(ruleName, {
  expected: (selector, max) =>
    `Expected "${selector}" to have no more than ${max} ${max === 1
      ? "class"
      : "classes"}`
});

function rule(max) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: max,
      possible: [
        function(max) {
          return typeof max === "number" && max >= 0;
        }
      ]
    });
    if (!validOptions) {
      return;
    }

    function checkSelector(selectorNode, ruleNode) {
      const count = selectorNode.reduce((total, childNode) => {
        // Only traverse inside actual selectors and :not()
        if (childNode.type === "selector" || childNode.value === ":not") {
          checkSelector(childNode, ruleNode);
        }

        return (total += childNode.type === "class" ? 1 : 0);
      }, 0);

      if (
        selectorNode.type !== "root" &&
        selectorNode.type !== "pseudo" &&
        count > max
      ) {
        report({
          ruleName,
          result,
          node: ruleNode,
          message: messages.expected(selectorNode, max),
          word: selectorNode
        });
      }
    }

    root.walkRules(ruleNode => {
      if (!isStandardSyntaxRule(ruleNode)) {
        return;
      }
      if (!isStandardSyntaxSelector(ruleNode.selector)) {
        return;
      }
      if (
        ruleNode.nodes.some(
          node => ["rule", "atrule"].indexOf(node.type) !== -1
        )
      ) {
        // Skip unresolved nested selectors
        return;
      }

      ruleNode.selectors.forEach(selector => {
        resolvedNestedSelector(selector, ruleNode).forEach(resolvedSelector => {
          parseSelector(resolvedSelector, result, ruleNode, container =>
            checkSelector(container, ruleNode)
          );
        });
      });
    });
  };
}

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isStandardSyntaxRule":1125,"../../utils/isStandardSyntaxSelector":1126,"../../utils/parseSelector":1138,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"postcss-resolve-nested-selector":782}],1027:[function(require,module,exports){
"use strict";

const isStandardSyntaxRule = require("../../utils/isStandardSyntaxRule");
const isStandardSyntaxSelector = require("../../utils/isStandardSyntaxSelector");
const parseSelector = require("../../utils/parseSelector");
const report = require("../../utils/report");
const resolvedNestedSelector = require("postcss-resolve-nested-selector");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "selector-max-combinators";

const messages = ruleMessages(ruleName, {
  expected: (selector, max) =>
    `Expected "${selector}" to have no more than ${max} ${max === 1
      ? "combinator"
      : "combinators"}`
});

function rule(max) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: max,
      possible: [
        function(max) {
          return typeof max === "number" && max >= 0;
        }
      ]
    });
    if (!validOptions) {
      return;
    }

    function checkSelector(selectorNode, ruleNode) {
      const count = selectorNode.reduce((total, childNode) => {
        // Only traverse inside actual selectors
        if (childNode.type === "selector") {
          checkSelector(childNode, ruleNode);
        }

        return (total += childNode.type === "combinator" ? 1 : 0);
      }, 0);

      if (
        selectorNode.type !== "root" &&
        selectorNode.type !== "pseudo" &&
        count > max
      ) {
        report({
          ruleName,
          result,
          node: ruleNode,
          message: messages.expected(selectorNode, max),
          word: selectorNode
        });
      }
    }

    root.walkRules(ruleNode => {
      if (!isStandardSyntaxRule(ruleNode)) {
        return;
      }
      if (!isStandardSyntaxSelector(ruleNode.selector)) {
        return;
      }
      if (
        ruleNode.nodes.some(
          node => ["rule", "atrule"].indexOf(node.type) !== -1
        )
      ) {
        // Skip unresolved nested selectors
        return;
      }

      ruleNode.selectors.forEach(selector => {
        resolvedNestedSelector(selector, ruleNode).forEach(resolvedSelector => {
          parseSelector(resolvedSelector, result, ruleNode, container =>
            checkSelector(container, ruleNode)
          );
        });
      });
    });
  };
}

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isStandardSyntaxRule":1125,"../../utils/isStandardSyntaxSelector":1126,"../../utils/parseSelector":1138,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"postcss-resolve-nested-selector":782}],1028:[function(require,module,exports){
"use strict";

const isStandardSyntaxRule = require("../../utils/isStandardSyntaxRule");
const isStandardSyntaxSelector = require("../../utils/isStandardSyntaxSelector");
const parseSelector = require("../../utils/parseSelector");
const report = require("../../utils/report");
const resolvedNestedSelector = require("postcss-resolve-nested-selector");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "selector-max-compound-selectors";

const messages = ruleMessages(ruleName, {
  expected: (selector, max) =>
    `Expected "${selector}" to have no more than ${max} compound ${max === 1
      ? "selector"
      : "selectors"}`
});

const rule = function(max) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: max,
      possible: [
        function(max) {
          return typeof max === "number" && max > 0;
        }
      ]
    });
    if (!validOptions) {
      return;
    }

    // Finds actual selectors in selectorNode object and checks them
    function checkSelector(selectorNode, rule) {
      let compoundCount = 1;

      selectorNode.each(childNode => {
        // Only traverse inside actual selectors and :not()
        if (childNode.type === "selector" || childNode.value === ":not") {
          checkSelector(childNode, rule);
        }

        // Compound selectors are separated by combinators, so increase count when meeting one
        if (childNode.type === "combinator") {
          compoundCount++;
        }
      });

      if (
        selectorNode.type !== "root" &&
        selectorNode.type !== "pseudo" &&
        compoundCount > max
      ) {
        report({
          ruleName,
          result,
          node: rule,
          message: messages.expected(selectorNode, max),
          word: selectorNode
        });
      }
    }

    root.walkRules(rule => {
      if (!isStandardSyntaxRule(rule)) {
        return;
      }
      if (!isStandardSyntaxSelector(rule.selector)) {
        return;
      }

      // Using `rule.selectors` gets us each selector if there is a comma separated set
      rule.selectors.forEach(selector => {
        resolvedNestedSelector(selector, rule).forEach(resolvedSelector => {
          // Process each resolved selector with `checkSelector` via postcss-selector-parser
          parseSelector(resolvedSelector, result, rule, s =>
            checkSelector(s, rule)
          );
        });
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isStandardSyntaxRule":1125,"../../utils/isStandardSyntaxSelector":1126,"../../utils/parseSelector":1138,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"postcss-resolve-nested-selector":782}],1029:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const styleSearch = require("style-search");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "selector-max-empty-lines";

const messages = ruleMessages(ruleName, {
  expected: max =>
    `Expected no more than ${max} empty ${max === 1 ? "line" : "lines"}`
});

const rule = function(max) {
  const maxAdjacentNewlines = max + 1;

  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: max,
      possible: _.isNumber
    });
    if (!validOptions) {
      return;
    }

    root.walkRules(rule => {
      const selector = rule.raws.selector
        ? rule.raws.selector.raw
        : rule.selector;
      const repeatLFNewLines = _.repeat("\n", maxAdjacentNewlines);
      const repeatCRLFNewLines = _.repeat("\r\n", maxAdjacentNewlines);

      styleSearch({ source: selector, target: "\n" }, match => {
        if (
          selector.substr(match.startIndex + 1, maxAdjacentNewlines) ===
            repeatLFNewLines ||
          selector.substr(match.startIndex + 1, maxAdjacentNewlines * 2) ===
            repeatCRLFNewLines
        ) {
          // Put index at `\r` if it's CRLF, otherwise leave it at `\n`
          let index = match.startIndex;
          if (selector[index - 1] === "\r") {
            index -= 1;
          }

          report({
            message: messages.expected(max),
            node: rule,
            index,
            result,
            ruleName
          });
        }
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"style-search":870}],1030:[function(require,module,exports){
"use strict";

const isStandardSyntaxRule = require("../../utils/isStandardSyntaxRule");
const isStandardSyntaxSelector = require("../../utils/isStandardSyntaxSelector");
const parseSelector = require("../../utils/parseSelector");
const report = require("../../utils/report");
const resolvedNestedSelector = require("postcss-resolve-nested-selector");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "selector-max-id";

const messages = ruleMessages(ruleName, {
  expected: (selector, max) =>
    `Expected "${selector}" to have no more than ${max} id ${max === 1
      ? "selector"
      : "selectors"}`
});

function rule(max) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: max,
      possible: [
        function(max) {
          return typeof max === "number" && max >= 0;
        }
      ]
    });
    if (!validOptions) {
      return;
    }

    function checkSelector(selectorNode, ruleNode) {
      const count = selectorNode.reduce((total, childNode) => {
        // Only traverse inside actual selectors and :not()
        if (childNode.type === "selector" || childNode.value === ":not") {
          checkSelector(childNode, ruleNode);
        }

        return (total += childNode.type === "id" ? 1 : 0);
      }, 0);

      if (
        selectorNode.type !== "root" &&
        selectorNode.type !== "pseudo" &&
        count > max
      ) {
        report({
          ruleName,
          result,
          node: ruleNode,
          message: messages.expected(selectorNode, max),
          word: selectorNode
        });
      }
    }

    root.walkRules(ruleNode => {
      if (!isStandardSyntaxRule(ruleNode)) {
        return;
      }
      if (!isStandardSyntaxSelector(ruleNode.selector)) {
        return;
      }
      if (
        ruleNode.nodes.some(
          node => ["rule", "atrule"].indexOf(node.type) !== -1
        )
      ) {
        // Skip unresolved nested selectors
        return;
      }

      ruleNode.selectors.forEach(selector => {
        resolvedNestedSelector(selector, ruleNode).forEach(resolvedSelector => {
          parseSelector(resolvedSelector, result, ruleNode, container =>
            checkSelector(container, ruleNode)
          );
        });
      });
    });
  };
}

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isStandardSyntaxRule":1125,"../../utils/isStandardSyntaxSelector":1126,"../../utils/parseSelector":1138,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"postcss-resolve-nested-selector":782}],1031:[function(require,module,exports){
"use strict";

const isStandardSyntaxRule = require("../../utils/isStandardSyntaxRule");
const isStandardSyntaxSelector = require("../../utils/isStandardSyntaxSelector");
const report = require("../../utils/report");
const resolvedNestedSelector = require("postcss-resolve-nested-selector");
const ruleMessages = require("../../utils/ruleMessages");
const specificity = require("specificity");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "selector-max-specificity";

const messages = ruleMessages(ruleName, {
  expected: (selector, specificity) =>
    `Expected "${selector}" to have a specificity no more than "${specificity}"`
});

const rule = function(max) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: max,
      possible: [
        function(max) {
          // Check that the max specificity is in the form "a,b,c"
          const pattern = new RegExp("^\\d+,\\d+,\\d+$");
          return pattern.test(max);
        }
      ]
    });
    if (!validOptions) {
      return;
    }

    const maxSpecificityArray = ("0," + max).split(",").map(parseFloat);
    root.walkRules(rule => {
      if (!isStandardSyntaxRule(rule)) {
        return;
      }
      if (!isStandardSyntaxSelector(rule.selector)) {
        return;
      }
      // Using rule.selectors gets us each selector in the eventuality we have a comma separated set
      rule.selectors.forEach(selector => {
        resolvedNestedSelector(selector, rule).forEach(resolvedSelector => {
          // Return early if selector contains a not pseudo-class
          if (selector.indexOf(":not(") !== -1) {
            return;
          }
          // Return early if selector contains a matches
          if (selector.indexOf(":matches(") !== -1) {
            return;
          }
          // Check if the selector specificity exceeds the allowed maximum
          try {
            if (!isStandardSyntaxSelector(resolvedSelector)) {
              return;
            }
            if (
              specificity.compare(resolvedSelector, maxSpecificityArray) === 1
            ) {
              report({
                ruleName,
                result,
                node: rule,
                message: messages.expected(resolvedSelector, max),
                word: selector
              });
            }
          } catch (e) {
            result.warn("Cannot parse selector", {
              node: rule,
              stylelintType: "parseError"
            });
          }
        });
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isStandardSyntaxRule":1125,"../../utils/isStandardSyntaxSelector":1126,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"postcss-resolve-nested-selector":782,"specificity":865}],1032:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const isKeyframeSelector = require("../../utils/isKeyframeSelector");
const isOnlyWhitespace = require("../../utils/isOnlyWhitespace");
const isStandardSyntaxRule = require("../../utils/isStandardSyntaxRule");
const isStandardSyntaxSelector = require("../../utils/isStandardSyntaxSelector");
const optionsMatches = require("../../utils/optionsMatches");
const parseSelector = require("../../utils/parseSelector");
const report = require("../../utils/report");
const resolvedNestedSelector = require("postcss-resolve-nested-selector");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "selector-max-type";

const messages = ruleMessages(ruleName, {
  expected: (selector, max) =>
    `Expected "${selector}" to have no more than ${max} type ${max === 1
      ? "selector"
      : "selectors"}`
});

function rule(max, options) {
  return (root, result) => {
    const validOptions = validateOptions(
      result,
      ruleName,
      {
        actual: max,
        possible(max) {
          return typeof max === "number" && max >= 0;
        }
      },
      {
        actual: options,
        possible: {
          ignore: ["descendant", "child", "compounded"],
          ignoreTypes: [_.isString]
        },
        optional: true
      }
    );
    if (!validOptions) {
      return;
    }

    const ignoreDescendant = optionsMatches(options, "ignore", "descendant");
    const ignoreChild = optionsMatches(options, "ignore", "child");
    const ignoreCompounded = optionsMatches(options, "ignore", "compounded");

    function checkSelector(selectorNode, ruleNode) {
      const count = selectorNode.reduce((total, childNode) => {
        // Only traverse inside actual selectors and :not()
        if (childNode.type === "selector" || childNode.value === ":not") {
          checkSelector(childNode, ruleNode);
        }

        if (optionsMatches(options, "ignoreTypes", childNode.value)) {
          return total;
        }

        if (ignoreDescendant && hasDescendantCombinatorBefore(childNode)) {
          return total;
        }

        if (ignoreChild && hasChildCombinatorBefore(childNode)) {
          return total;
        }

        if (ignoreCompounded && hasCompoundSelector(childNode)) {
          return total;
        }

        return (total += childNode.type === "tag" ? 1 : 0);
      }, 0);

      if (
        selectorNode.type !== "root" &&
        selectorNode.type !== "pseudo" &&
        count > max
      ) {
        report({
          ruleName,
          result,
          node: ruleNode,
          message: messages.expected(selectorNode, max),
          word: selectorNode
        });
      }
    }

    root.walkRules(ruleNode => {
      const selector = ruleNode.selector,
        selectors = ruleNode.selectors;

      if (!isStandardSyntaxRule(ruleNode)) {
        return;
      }
      if (!isStandardSyntaxSelector(selector)) {
        return;
      }
      if (selectors.some(s => isKeyframeSelector(s))) {
        return;
      }
      if (
        ruleNode.nodes.some(
          node => ["rule", "atrule"].indexOf(node.type) !== -1
        )
      ) {
        // Skip unresolved nested selectors
        return;
      }

      ruleNode.selectors.forEach(selector => {
        resolvedNestedSelector(selector, ruleNode).forEach(resolvedSelector => {
          if (!isStandardSyntaxSelector(resolvedSelector)) {
            return;
          }
          parseSelector(resolvedSelector, result, ruleNode, container =>
            checkSelector(container, ruleNode)
          );
        });
      });
    });
  };
}

function hasDescendantCombinatorBefore(node) {
  const nodeIndex = node.parent.nodes.indexOf(node);
  return node.parent.nodes.slice(0, nodeIndex).some(isDescendantCombinator);
}

function hasChildCombinatorBefore(node) {
  const nodeIndex = node.parent.nodes.indexOf(node);
  return node.parent.nodes.slice(0, nodeIndex).some(isChildCombinator);
}

function hasCompoundSelector(node) {
  if (node.prev() && !isCombinator(node.prev())) {
    return true;
  }
  if (node.next() && !isCombinator(node.next())) {
    return true;
  }
  return false;
}

function isCombinator(node) {
  if (!node) return false;
  return _.get(node, "type") === "combinator";
}

function isDescendantCombinator(node) {
  if (!node) return false;
  return isCombinator(node) && isOnlyWhitespace(node.value);
}

function isChildCombinator(node) {
  if (!node) return false;
  return isCombinator(node) && node.value.includes(">");
}

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isKeyframeSelector":1114,"../../utils/isOnlyWhitespace":1116,"../../utils/isStandardSyntaxRule":1125,"../../utils/isStandardSyntaxSelector":1126,"../../utils/optionsMatches":1137,"../../utils/parseSelector":1138,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"postcss-resolve-nested-selector":782}],1033:[function(require,module,exports){
"use strict";

const isStandardSyntaxRule = require("../../utils/isStandardSyntaxRule");
const isStandardSyntaxSelector = require("../../utils/isStandardSyntaxSelector");
const parseSelector = require("../../utils/parseSelector");
const report = require("../../utils/report");
const resolvedNestedSelector = require("postcss-resolve-nested-selector");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "selector-max-universal";

const messages = ruleMessages(ruleName, {
  expected: (selector, max) =>
    `Expected "${selector}" to have no more than ${max} universal ${max === 1
      ? "selector"
      : "selectors"}`
});

function rule(max) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: max,
      possible: [
        function(max) {
          return typeof max === "number" && max >= 0;
        }
      ]
    });
    if (!validOptions) {
      return;
    }

    function checkSelector(selectorNode, ruleNode) {
      const count = selectorNode.reduce((total, childNode) => {
        // Only traverse inside actual selectors and :not()
        if (childNode.type === "selector" || childNode.value === ":not") {
          checkSelector(childNode, ruleNode);
        }

        return (total += childNode.type === "universal" ? 1 : 0);
      }, 0);

      if (
        selectorNode.type !== "root" &&
        selectorNode.type !== "pseudo" &&
        count > max
      ) {
        report({
          ruleName,
          result,
          node: ruleNode,
          message: messages.expected(selectorNode, max),
          word: selectorNode
        });
      }
    }

    root.walkRules(ruleNode => {
      if (!isStandardSyntaxRule(ruleNode)) {
        return;
      }
      if (!isStandardSyntaxSelector(ruleNode.selector)) {
        return;
      }
      if (
        ruleNode.nodes.some(
          node => ["rule", "atrule"].indexOf(node.type) !== -1
        )
      ) {
        // Skip unresolved nested selectors
        return;
      }

      ruleNode.selectors.forEach(selector => {
        resolvedNestedSelector(selector, ruleNode).forEach(resolvedSelector => {
          parseSelector(resolvedSelector, result, ruleNode, container =>
            checkSelector(container, ruleNode)
          );
        });
      });
    });
  };
}

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isStandardSyntaxRule":1125,"../../utils/isStandardSyntaxSelector":1126,"../../utils/parseSelector":1138,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"postcss-resolve-nested-selector":782}],1034:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const isStandardSyntaxRule = require("../../utils/isStandardSyntaxRule");
const isStandardSyntaxSelector = require("../../utils/isStandardSyntaxSelector");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "selector-nested-pattern";

const messages = ruleMessages(ruleName, {
  expected: selector =>
    `Expected nested selector "${selector}" to match specified pattern`
});

const rule = function(pattern) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: pattern,
      possible: [_.isRegExp, _.isString]
    });
    if (!validOptions) {
      return;
    }

    const normalizedPattern = _.isString(pattern)
      ? new RegExp(pattern)
      : pattern;

    root.walkRules(rule => {
      if (rule.parent.type !== "rule") {
        return;
      }
      if (!isStandardSyntaxRule(rule)) {
        return;
      }

      const selector = rule.selector;

      if (!isStandardSyntaxSelector(selector)) {
        return;
      }

      if (normalizedPattern.test(selector)) {
        return;
      }

      report({
        result,
        ruleName,
        message: messages.expected(selector),
        node: rule
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isStandardSyntaxRule":1125,"../../utils/isStandardSyntaxSelector":1126,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692}],1035:[function(require,module,exports){
"use strict";

const isKeyframeRule = require("../../utils/isKeyframeRule");
const isStandardSyntaxRule = require("../../utils/isStandardSyntaxRule");
const isStandardSyntaxSelector = require("../../utils/isStandardSyntaxSelector");
const optionsMatches = require("../../utils/optionsMatches");
const parseSelector = require("../../utils/parseSelector");
const report = require("../../utils/report");
const resolvedNestedSelector = require("postcss-resolve-nested-selector");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "selector-no-qualifying-type";

const messages = ruleMessages(ruleName, {
  rejected: "Unexpected qualifying type selector"
});

const selectorCharacters = ["#", ".", "["];

function isSelectorCharacters(value) {
  return selectorCharacters.some(char => value.indexOf(char) !== -1);
}

function getRightNodes(node) {
  const result = [];
  let rightNode = node;

  while ((rightNode = rightNode.next())) {
    if (rightNode.type === "combinator") {
      break;
    }
    if (
      rightNode.type !== "id" &&
      rightNode.type !== "class" &&
      rightNode.type !== "attribute"
    ) {
      continue;
    }

    result.push(rightNode);
  }

  return result;
}

const rule = function(enabled, options) {
  return (root, result) => {
    const validOptions = validateOptions(
      result,
      ruleName,
      {
        actual: enabled,
        possible: [true, false]
      },
      {
        actual: options,
        possible: {
          ignore: ["attribute", "class", "id"]
        },
        optional: true
      }
    );
    if (!validOptions) {
      return;
    }

    root.walkRules(rule => {
      if (!isStandardSyntaxRule(rule)) {
        return;
      }
      if (isKeyframeRule(rule)) {
        return;
      }
      // Increasing performance
      if (!isStandardSyntaxSelector(rule.selector)) {
        return;
      }
      if (!isSelectorCharacters(rule.selector)) {
        return;
      }

      function checkSelector(selectorAST) {
        selectorAST.walkTags(selector => {
          const selectorParent = selector.parent;

          if (selectorParent.nodes.length === 1) {
            return;
          }

          const selectorNodes = getRightNodes(selector);
          const index = selector.sourceIndex;

          selectorNodes.forEach(selectorNode => {
            if (
              selectorNode.type === "id" &&
              !optionsMatches(options, "ignore", "id")
            ) {
              complain(index);
            }

            if (
              selectorNode.type === "class" &&
              !optionsMatches(options, "ignore", "class")
            ) {
              complain(index);
            }

            if (
              selectorNode.type === "attribute" &&
              !optionsMatches(options, "ignore", "attribute")
            ) {
              complain(index);
            }
          });
        });
      }

      resolvedNestedSelector(rule.selector, rule).forEach(resolvedSelector => {
        if (!isStandardSyntaxSelector(resolvedSelector)) {
          return;
        }

        parseSelector(resolvedSelector, result, rule, checkSelector);
      });

      function complain(index) {
        report({
          ruleName,
          result,
          node: rule,
          message: messages.rejected,
          index
        });
      }
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isKeyframeRule":1113,"../../utils/isStandardSyntaxRule":1125,"../../utils/isStandardSyntaxSelector":1126,"../../utils/optionsMatches":1137,"../../utils/parseSelector":1138,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"postcss-resolve-nested-selector":782}],1036:[function(require,module,exports){
"use strict";

const isAutoprefixable = require("../../utils/isAutoprefixable");
const isStandardSyntaxRule = require("../../utils/isStandardSyntaxRule");
const isStandardSyntaxSelector = require("../../utils/isStandardSyntaxSelector");
const parseSelector = require("../../utils/parseSelector");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "selector-no-vendor-prefix";

const messages = ruleMessages(ruleName, {
  rejected: selector => `Unexpected vendor-prefix "${selector}"`
});

const rule = function(actual) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, { actual });
    if (!validOptions) {
      return;
    }

    root.walkRules(rule => {
      if (!isStandardSyntaxRule(rule)) {
        return;
      }
      const selector = rule.selector;

      if (!isStandardSyntaxSelector(selector)) {
        return;
      }
      parseSelector(selector, result, rule, selectorTree => {
        selectorTree.walkPseudos(pseudoNode => {
          if (isAutoprefixable.selector(pseudoNode.value)) {
            report({
              result,
              ruleName,
              message: messages.rejected(pseudoNode.value),
              node: rule,
              index: (rule.raws.before || "").length + pseudoNode.sourceIndex
            });
          }
        });
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isAutoprefixable":1102,"../../utils/isStandardSyntaxRule":1125,"../../utils/isStandardSyntaxSelector":1126,"../../utils/parseSelector":1138,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144}],1037:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const isStandardSyntaxRule = require("../../utils/isStandardSyntaxRule");
const isStandardSyntaxSelector = require("../../utils/isStandardSyntaxSelector");
const matchesStringOrRegExp = require("../../utils/matchesStringOrRegExp");
const parseSelector = require("../../utils/parseSelector");
const postcss = require("postcss");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "selector-pseudo-class-blacklist";

const messages = ruleMessages(ruleName, {
  rejected: selector => `Unexpected pseudo-class "${selector}"`
});

const rule = function(blacklist) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: blacklist,
      possible: [_.isString]
    });
    if (!validOptions) {
      return;
    }

    root.walkRules(rule => {
      if (!isStandardSyntaxRule(rule)) {
        return;
      }

      const selector = rule.selector;

      if (!isStandardSyntaxSelector(selector)) {
        return;
      }

      if (selector.indexOf(":") === -1) {
        return;
      }

      parseSelector(selector, result, rule, selectorTree => {
        selectorTree.walkPseudos(pseudoNode => {
          const value = pseudoNode.value;

          // Ignore pseudo-elements

          if (value.slice(0, 2) === "::") {
            return;
          }

          const name = value.slice(1);

          if (
            !matchesStringOrRegExp(postcss.vendor.unprefixed(name), blacklist)
          ) {
            return;
          }

          report({
            index: pseudoNode.sourceIndex,
            message: messages.rejected(name),
            node: rule,
            result,
            ruleName
          });
        });
      });
    });
  };
};

rule.primaryOptionArray = true;

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isStandardSyntaxRule":1125,"../../utils/isStandardSyntaxSelector":1126,"../../utils/matchesStringOrRegExp":1134,"../../utils/parseSelector":1138,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"postcss":828}],1038:[function(require,module,exports){
"use strict";

const isStandardSyntaxRule = require("../../utils/isStandardSyntaxRule");
const isStandardSyntaxSelector = require("../../utils/isStandardSyntaxSelector");
const keywordSets = require("../../reference/keywordSets");
const parseSelector = require("../../utils/parseSelector");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "selector-pseudo-class-case";

const messages = ruleMessages(ruleName, {
  expected: (actual, expected) => `Expected "${actual}" to be "${expected}"`
});

const rule = function(expectation) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["lower", "upper"]
    });
    if (!validOptions) {
      return;
    }

    root.walkRules(rule => {
      if (!isStandardSyntaxRule(rule)) {
        return;
      }
      const selector = rule.selector;
      const startIndexPseudo = selector.indexOf(":");

      if (startIndexPseudo === -1) {
        return;
      }

      parseSelector(selector, result, rule, selectorTree => {
        selectorTree.walkPseudos(pseudoNode => {
          const pseudo = pseudoNode.value;

          if (!isStandardSyntaxSelector(pseudo)) {
            return;
          }

          if (
            pseudo.indexOf("::") !== -1 ||
            keywordSets.levelOneAndTwoPseudoElements.has(
              pseudo.toLowerCase().slice(1)
            )
          ) {
            return;
          }

          const expectedPseudo =
            expectation === "lower"
              ? pseudo.toLowerCase()
              : pseudo.toUpperCase();

          if (pseudo === expectedPseudo) {
            return;
          }

          report({
            message: messages.expected(pseudo, expectedPseudo),
            node: rule,
            index: pseudoNode.sourceIndex,
            ruleName,
            result
          });
        });
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../reference/keywordSets":888,"../../utils/isStandardSyntaxRule":1125,"../../utils/isStandardSyntaxSelector":1126,"../../utils/parseSelector":1138,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144}],1039:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const atRuleParamIndex = require("../../utils/atRuleParamIndex");
const isCustomSelector = require("../../utils/isCustomSelector");
const isStandardSyntaxAtRule = require("../../utils/isStandardSyntaxAtRule");
const isStandardSyntaxRule = require("../../utils/isStandardSyntaxRule");
const isStandardSyntaxSelector = require("../../utils/isStandardSyntaxSelector");
const keywordSets = require("../../reference/keywordSets");
const optionsMatches = require("../../utils/optionsMatches");
const parseSelector = require("../../utils/parseSelector");
const postcss = require("postcss");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "selector-pseudo-class-no-unknown";

const messages = ruleMessages(ruleName, {
  rejected: selector => `Unexpected unknown pseudo-class selector "${selector}"`
});

const rule = function(actual, options) {
  return (root, result) => {
    const validOptions = validateOptions(
      result,
      ruleName,
      { actual },
      {
        actual: options,
        possible: {
          ignorePseudoClasses: [_.isString]
        },
        optional: true
      }
    );
    if (!validOptions) {
      return;
    }

    function check(selector, result, node) {
      parseSelector(selector, result, node, selectorTree => {
        selectorTree.walkPseudos(pseudoNode => {
          const value = pseudoNode.value;

          if (!isStandardSyntaxSelector(value)) {
            return;
          }

          if (isCustomSelector(value)) {
            return;
          }

          // Ignore pseudo-elements
          if (value.slice(0, 2) === "::") {
            return;
          }

          if (
            optionsMatches(
              options,
              "ignorePseudoClasses",
              pseudoNode.value.slice(1)
            )
          ) {
            return;
          }

          let index = null;
          const name = value.slice(1).toLowerCase();

          if (node.type === "atrule" && node.name === "page") {
            if (keywordSets.atRulePagePseudoClasses.has(name)) {
              return;
            }

            index = atRuleParamIndex(node) + pseudoNode.sourceIndex;
          } else {
            if (
              postcss.vendor.prefix(name) ||
              keywordSets.pseudoClasses.has(name) ||
              keywordSets.pseudoElements.has(name)
            ) {
              return;
            }

            if (pseudoNode.prev()) {
              const prevPseudoNodeValue = postcss.vendor.unprefixed(
                pseudoNode.prev().value.toLowerCase().slice(2)
              );

              if (
                keywordSets.webkitProprietaryPseudoElements.has(
                  prevPseudoNodeValue
                ) &&
                keywordSets.webkitProprietaryPseudoClasses.has(name)
              ) {
                return;
              }
            }

            index = pseudoNode.sourceIndex;
          }

          report({
            message: messages.rejected(value),
            node,
            index,
            ruleName,
            result
          });
        });
      });
    }

    root.walk(node => {
      let selector = null;

      if (node.type === "rule") {
        if (!isStandardSyntaxRule(node)) {
          return;
        }

        selector = node.selector;
      } else if (
        node.type === "atrule" &&
        node.name === "page" &&
        node.params
      ) {
        if (!isStandardSyntaxAtRule(node)) {
          return;
        }

        selector = node.params;
      }

      // Return if selector empty, it is meaning node type is not a rule or a at-rule

      if (!selector) {
        return;
      }

      // Return early before parse if no pseudos for performance

      if (selector.indexOf(":") === -1) {
        return;
      }

      check(selector, result, node);
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../reference/keywordSets":888,"../../utils/atRuleParamIndex":1071,"../../utils/isCustomSelector":1111,"../../utils/isStandardSyntaxAtRule":1120,"../../utils/isStandardSyntaxRule":1125,"../../utils/isStandardSyntaxSelector":1126,"../../utils/optionsMatches":1137,"../../utils/parseSelector":1138,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"postcss":828}],1040:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const isStandardSyntaxRule = require("../../utils/isStandardSyntaxRule");
const parseSelector = require("../../utils/parseSelector");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const styleSearch = require("style-search");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "selector-pseudo-class-parentheses-space-inside";

const messages = ruleMessages(ruleName, {
  expectedOpening: 'Expected single space after "("',
  rejectedOpening: 'Unexpected whitespace after "("',
  expectedClosing: 'Expected single space before ")"',
  rejectedClosing: 'Unexpected whitespace before ")"'
});

const rule = function(expectation) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "never"]
    });
    if (!validOptions) {
      return;
    }

    root.walkRules(rule => {
      if (!isStandardSyntaxRule(rule)) {
        return;
      }
      if (rule.selector.indexOf("(") === -1) {
        return;
      }

      parseSelector(rule.selector, result, rule, selectorTree => {
        selectorTree.walkPseudos(pseudoNode => {
          if (_.get(pseudoNode, "parent.parent.type") === "pseudo") {
            return;
          }

          const pseudoSelectorString = pseudoNode.toString();

          styleSearch({ source: pseudoSelectorString, target: "(" }, match => {
            const nextCharIsSpace =
              pseudoSelectorString[match.startIndex + 1] === " ";
            const index = pseudoNode.sourceIndex + match.startIndex + 1;
            if (nextCharIsSpace && expectation === "never") {
              complain(messages.rejectedOpening, index);
            }
            if (!nextCharIsSpace && expectation === "always") {
              complain(messages.expectedOpening, index);
            }
          });

          styleSearch({ source: pseudoSelectorString, target: ")" }, match => {
            const prevCharIsSpace =
              pseudoSelectorString[match.startIndex - 1] === " ";
            const index = pseudoNode.sourceIndex + match.startIndex - 1;
            if (prevCharIsSpace && expectation === "never") {
              complain(messages.rejectedClosing, index);
            }
            if (!prevCharIsSpace && expectation === "always") {
              complain(messages.expectedClosing, index);
            }
          });
        });
      });

      function complain(message, index) {
        report({
          message,
          index,
          result,
          ruleName,
          node: rule
        });
      }
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isStandardSyntaxRule":1125,"../../utils/parseSelector":1138,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"style-search":870}],1041:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const isStandardSyntaxRule = require("../../utils/isStandardSyntaxRule");
const isStandardSyntaxSelector = require("../../utils/isStandardSyntaxSelector");
const matchesStringOrRegExp = require("../../utils/matchesStringOrRegExp");
const parseSelector = require("../../utils/parseSelector");
const postcss = require("postcss");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "selector-pseudo-class-whitelist";

const messages = ruleMessages(ruleName, {
  rejected: selector => `Unexpected pseudo-class "${selector}"`
});

const rule = function(whitelist) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: whitelist,
      possible: [_.isString]
    });
    if (!validOptions) {
      return;
    }

    root.walkRules(rule => {
      if (!isStandardSyntaxRule(rule)) {
        return;
      }

      const selector = rule.selector;

      if (!isStandardSyntaxSelector(selector)) {
        return;
      }
      if (selector.indexOf(":") === -1) {
        return;
      }

      parseSelector(selector, result, rule, selectorTree => {
        selectorTree.walkPseudos(pseudoNode => {
          const value = pseudoNode.value;

          // Ignore pseudo-elements
          if (value.slice(0, 2) === "::") {
            return;
          }

          const name = value.slice(1);

          if (
            matchesStringOrRegExp(postcss.vendor.unprefixed(name), whitelist)
          ) {
            return;
          }

          report({
            index: pseudoNode.sourceIndex,
            message: messages.rejected(name),
            node: rule,
            result,
            ruleName
          });
        });
      });
    });
  };
};

rule.primaryOptionArray = true;

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isStandardSyntaxRule":1125,"../../utils/isStandardSyntaxSelector":1126,"../../utils/matchesStringOrRegExp":1134,"../../utils/parseSelector":1138,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"postcss":828}],1042:[function(require,module,exports){
"use strict";

const isStandardSyntaxRule = require("../../utils/isStandardSyntaxRule");
const isStandardSyntaxSelector = require("../../utils/isStandardSyntaxSelector");
const keywordSets = require("../../reference/keywordSets");
const parseSelector = require("../../utils/parseSelector");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "selector-pseudo-element-case";

const messages = ruleMessages(ruleName, {
  expected: (actual, expected) => `Expected "${actual}" to be "${expected}"`
});

const rule = function(expectation) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["lower", "upper"]
    });
    if (!validOptions) {
      return;
    }

    root.walkRules(rule => {
      if (!isStandardSyntaxRule(rule)) {
        return;
      }
      const selector = rule.selector;
      const startIndexPseudoElement = selector.indexOf(":");

      if (startIndexPseudoElement === -1) {
        return;
      }

      parseSelector(selector, result, rule, selectorTree => {
        selectorTree.walkPseudos(pseudoNode => {
          const pseudoElement = pseudoNode.value;

          if (!isStandardSyntaxSelector(pseudoElement)) {
            return;
          }

          if (
            pseudoElement.indexOf("::") === -1 &&
            !keywordSets.levelOneAndTwoPseudoElements.has(
              pseudoElement.toLowerCase().slice(1)
            )
          ) {
            return;
          }

          const expectedPseudoElement =
            expectation === "lower"
              ? pseudoElement.toLowerCase()
              : pseudoElement.toUpperCase();

          if (pseudoElement === expectedPseudoElement) {
            return;
          }

          report({
            message: messages.expected(pseudoElement, expectedPseudoElement),
            node: rule,
            index: pseudoNode.sourceIndex,
            ruleName,
            result
          });
        });
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../reference/keywordSets":888,"../../utils/isStandardSyntaxRule":1125,"../../utils/isStandardSyntaxSelector":1126,"../../utils/parseSelector":1138,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144}],1043:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const isStandardSyntaxRule = require("../../utils/isStandardSyntaxRule");
const keywordSets = require("../../reference/keywordSets");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const styleSearch = require("style-search");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "selector-pseudo-element-colon-notation";

const messages = ruleMessages(ruleName, {
  expected: q => `Expected ${q} colon pseudo-element notation`
});

const rule = function(expectation) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["single", "double"]
    });
    if (!validOptions) {
      return;
    }

    root.walkRules(rule => {
      if (!isStandardSyntaxRule(rule)) {
        return;
      }
      const selector = rule.selector;

      // get out early if no pseudo elements or classes
      if (selector.indexOf(":") === -1) {
        return;
      }

      // match only level 1 and 2 pseudo elements
      const pseudoElementsWithColons = _.toArray(
        keywordSets.levelOneAndTwoPseudoElements
      ).map(x => `:${x}`);
      styleSearch(
        { source: selector.toLowerCase(), target: pseudoElementsWithColons },
        match => {
          const prevCharIsColon = selector[match.startIndex - 1] === ":";

          if (expectation === "single" && !prevCharIsColon) {
            return;
          }
          if (expectation === "double" && prevCharIsColon) {
            return;
          }

          report({
            message: messages.expected(expectation),
            node: rule,
            index: match.startIndex,
            result,
            ruleName
          });
        }
      );
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../reference/keywordSets":888,"../../utils/isStandardSyntaxRule":1125,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"style-search":870}],1044:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const isStandardSyntaxRule = require("../../utils/isStandardSyntaxRule");
const isStandardSyntaxSelector = require("../../utils/isStandardSyntaxSelector");
const keywordSets = require("../../reference/keywordSets");
const optionsMatches = require("../../utils/optionsMatches");
const parseSelector = require("../../utils/parseSelector");
const postcss = require("postcss");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "selector-pseudo-element-no-unknown";

const messages = ruleMessages(ruleName, {
  rejected: selector =>
    `Unexpected unknown pseudo-element selector "${selector}"`
});

const rule = function(actual, options) {
  return (root, result) => {
    const validOptions = validateOptions(
      result,
      ruleName,
      { actual },
      {
        actual: options,
        possible: {
          ignorePseudoElements: [_.isString]
        },
        optional: true
      }
    );
    if (!validOptions) {
      return;
    }

    root.walkRules(rule => {
      if (!isStandardSyntaxRule(rule)) {
        return;
      }
      const selector = rule.selector;

      // Return early before parse if no pseudos for performance

      if (selector.indexOf(":") === -1) {
        return;
      }

      parseSelector(selector, result, rule, selectorTree => {
        selectorTree.walkPseudos(pseudoNode => {
          const value = pseudoNode.value;

          if (!isStandardSyntaxSelector(value)) {
            return;
          }

          // Ignore pseudo-classes
          if (value.slice(0, 2) !== "::") {
            return;
          }

          if (
            optionsMatches(
              options,
              "ignorePseudoElements",
              pseudoNode.value.slice(2)
            )
          ) {
            return;
          }

          const name = value.slice(2);

          if (
            postcss.vendor.prefix(name) ||
            keywordSets.pseudoElements.has(name.toLowerCase())
          ) {
            return;
          }

          report({
            message: messages.rejected(value),
            node: rule,
            index: pseudoNode.sourceIndex,
            ruleName,
            result
          });
        });
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../reference/keywordSets":888,"../../utils/isStandardSyntaxRule":1125,"../../utils/isStandardSyntaxSelector":1126,"../../utils/optionsMatches":1137,"../../utils/parseSelector":1138,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"postcss":828}],1045:[function(require,module,exports){
"use strict";

const isKeyframeSelector = require("../../utils/isKeyframeSelector");
const isStandardSyntaxRule = require("../../utils/isStandardSyntaxRule");
const isStandardSyntaxSelector = require("../../utils/isStandardSyntaxSelector");
const isStandardSyntaxTypeSelector = require("../../utils/isStandardSyntaxTypeSelector");
const parseSelector = require("../../utils/parseSelector");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "selector-type-case";

const messages = ruleMessages(ruleName, {
  expected: (actual, expected) => `Expected "${actual}" to be "${expected}"`
});

const rule = function(expectation) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["lower", "upper"]
    });
    if (!validOptions) {
      return;
    }

    root.walkRules(rule => {
      const selector = rule.selector,
        selectors = rule.selectors;

      if (!isStandardSyntaxRule(rule)) {
        return;
      }
      if (!isStandardSyntaxSelector(selector)) {
        return;
      }
      if (selectors.some(s => isKeyframeSelector(s))) {
        return;
      }

      parseSelector(selector, result, rule, selectorAST => {
        selectorAST.walkTags(tag => {
          if (!isStandardSyntaxTypeSelector(tag)) {
            return;
          }

          const sourceIndex = tag.sourceIndex,
            value = tag.value;

          const expectedValue =
            expectation === "lower" ? value.toLowerCase() : value.toUpperCase();

          if (value === expectedValue) {
            return;
          }

          report({
            message: messages.expected(value, expectedValue),
            node: rule,
            index: sourceIndex,
            ruleName,
            result
          });
        });
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isKeyframeSelector":1114,"../../utils/isStandardSyntaxRule":1125,"../../utils/isStandardSyntaxSelector":1126,"../../utils/isStandardSyntaxTypeSelector":1127,"../../utils/parseSelector":1138,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144}],1046:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const htmlTags = require("html-tags");
const isCustomElement = require("../../utils/isCustomElement");
const isKeyframeSelector = require("../../utils/isKeyframeSelector");
const isStandardSyntaxRule = require("../../utils/isStandardSyntaxRule");
const isStandardSyntaxSelector = require("../../utils/isStandardSyntaxSelector");
const isStandardSyntaxTypeSelector = require("../../utils/isStandardSyntaxTypeSelector");
const keywordSets = require("../../reference/keywordSets");
const mathMLTags = require("mathml-tag-names");
const optionsMatches = require("../../utils/optionsMatches");
const parseSelector = require("../../utils/parseSelector");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const svgTags = require("svg-tags");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "selector-type-no-unknown";

const messages = ruleMessages(ruleName, {
  rejected: selector => `Unexpected unknown type selector "${selector}"`
});

const rule = function(actual, options) {
  return (root, result) => {
    const validOptions = validateOptions(
      result,
      ruleName,
      { actual },
      {
        actual: options,
        possible: {
          ignore: ["custom-elements", "default-namespace"],
          ignoreNamespaces: [_.isString],
          ignoreTypes: [_.isString]
        },
        optional: true
      }
    );
    if (!validOptions) {
      return;
    }

    root.walkRules(rule => {
      const selector = rule.selector,
        selectors = rule.selectors;

      if (!isStandardSyntaxRule(rule)) {
        return;
      }
      if (!isStandardSyntaxSelector(selector)) {
        return;
      }
      if (selectors.some(s => isKeyframeSelector(s))) {
        return;
      }

      parseSelector(selector, result, rule, selectorTree => {
        selectorTree.walkTags(tagNode => {
          if (!isStandardSyntaxTypeSelector(tagNode)) {
            return;
          }

          if (
            optionsMatches(options, "ignore", "custom-elements") &&
            isCustomElement(tagNode.value)
          ) {
            return;
          }

          if (
            optionsMatches(options, "ignore", "default-namespace") &&
            !tagNode.hasOwnProperty("namespace")
          ) {
            return;
          }

          if (optionsMatches(options, "ignoreNamespaces", tagNode.namespace)) {
            return;
          }

          if (optionsMatches(options, "ignoreTypes", tagNode.value)) {
            return;
          }

          const tagName = tagNode.value;
          const tagNameLowerCase = tagName.toLowerCase();

          if (
            htmlTags.indexOf(tagNameLowerCase) !== -1 ||
            svgTags.indexOf(tagNameLowerCase) !== -1 ||
            keywordSets.nonStandardHtmlTags.has(tagNameLowerCase) ||
            mathMLTags.indexOf(tagNameLowerCase) !== -1
          ) {
            return;
          }

          report({
            message: messages.rejected(tagName),
            node: rule,
            index: tagNode.sourceIndex,
            ruleName,
            result
          });
        });
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../reference/keywordSets":888,"../../utils/isCustomElement":1107,"../../utils/isKeyframeSelector":1114,"../../utils/isStandardSyntaxRule":1125,"../../utils/isStandardSyntaxSelector":1126,"../../utils/isStandardSyntaxTypeSelector":1127,"../../utils/optionsMatches":1137,"../../utils/parseSelector":1138,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"html-tags":633,"lodash":692,"mathml-tag-names":697,"svg-tags":1156}],1047:[function(require,module,exports){
"use strict";

const isStandardSyntaxRule = require("../utils/isStandardSyntaxRule");
const parseSelector = require("../utils/parseSelector");
const report = require("../utils/report");
const styleSearch = require("style-search");

module.exports = function(options) {
  options.root.walkRules(rule => {
    if (!isStandardSyntaxRule(rule)) {
      return;
    }
    if (
      rule.selector.indexOf("[") === -1 ||
      rule.selector.indexOf("=") === -1
    ) {
      return;
    }

    parseSelector(rule.selector, options.result, rule, selectorTree => {
      selectorTree.walkAttributes(attributeNode => {
        const operator = attributeNode.operator;

        if (!operator) {
          return;
        }

        const attributeNodeString = attributeNode.toString();

        styleSearch(
          { source: attributeNodeString, target: operator },
          match => {
            const index = options.checkBeforeOperator
              ? match.startIndex
              : match.endIndex - 1;
            checkOperator(
              attributeNodeString,
              index,
              rule,
              attributeNode.sourceIndex,
              operator
            );
          }
        );
      });
    });

    function checkOperator(source, index, node, attributeIndex, operator) {
      options.locationChecker({
        source,
        index,
        err: m =>
          report({
            message: m.replace(
              options.checkBeforeOperator
                ? operator[0]
                : operator[operator.length - 1],
              operator
            ),
            node,
            index: attributeIndex + index,
            result: options.result,
            ruleName: options.checkedRuleName
          })
      });
    }
  });
};

},{"../utils/isStandardSyntaxRule":1125,"../utils/parseSelector":1138,"../utils/report":1141,"style-search":870}],1048:[function(require,module,exports){
"use strict";

const isStandardSyntaxRule = require("../utils/isStandardSyntaxRule");
const parseSelector = require("../utils/parseSelector");
const report = require("../utils/report");

module.exports = function(opts) {
  opts.root.walkRules(rule => {
    if (!isStandardSyntaxRule(rule)) {
      return;
    }
    // Check each selector individually, instead of all as one string,
    // in case some that aren't the first begin with combinators (nesting syntax)
    rule.selectors.forEach(selector => {
      parseSelector(selector, opts.result, rule, selectorTree => {
        selectorTree.walkCombinators(node => {
          // Ignore spaced descendant combinator
          if (/\s/.test(node.value)) {
            return;
          }

          const parentParentNode = node.parent && node.parent.parent;

          // Ignore pseudo-classes selector like `.foo:nth-child(2n + 1) {}`
          if (parentParentNode && parentParentNode.type === "pseudo") {
            return;
          }

          const sourceIndex = node.sourceIndex;
          const index =
            node.value.length > 1 && opts.locationType === "before"
              ? sourceIndex
              : sourceIndex + node.value.length - 1;

          check(selector, node.value, index, rule, sourceIndex);
        });
      });
    });
  });

  function check(source, errTarget, index, node, sourceIndex) {
    opts.locationChecker({
      source,
      index,
      errTarget,
      err: m =>
        report({
          message: m,
          node,
          index: sourceIndex,
          result: opts.result,
          ruleName: opts.checkedRuleName
        })
    });
  }
};

},{"../utils/isStandardSyntaxRule":1125,"../utils/parseSelector":1138,"../utils/report":1141}],1049:[function(require,module,exports){
"use strict";

const isStandardSyntaxRule = require("../utils/isStandardSyntaxRule");
const report = require("../utils/report");
const styleSearch = require("style-search");

module.exports = function(opts) {
  opts.root.walkRules(rule => {
    if (!isStandardSyntaxRule(rule)) {
      return;
    }
    const selector = rule.selector;
    styleSearch(
      {
        source: selector,
        target: ",",
        functionArguments: "skip"
      },
      match => {
        checkDelimiter(selector, match.startIndex, rule);
      }
    );
  });

  function checkDelimiter(source, index, node) {
    opts.locationChecker({
      source,
      index,
      err: m =>
        report({
          message: m,
          node,
          index,
          result: opts.result,
          ruleName: opts.checkedRuleName
        })
    });
  }
};

},{"../utils/isStandardSyntaxRule":1125,"../utils/report":1141,"style-search":870}],1050:[function(require,module,exports){
"use strict";

const isStandardSyntaxDeclaration = require("../../utils/isStandardSyntaxDeclaration");
const isStandardSyntaxProperty = require("../../utils/isStandardSyntaxProperty");
const postcss = require("postcss");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const valueParser = require("postcss-value-parser");

const ruleName = "shorthand-property-no-redundant-values";

const messages = ruleMessages(ruleName, {
  rejected: (unexpected, expected) =>
    `Unexpected longhand value '${unexpected}' instead of '${expected}'`
});

// Only these shorthand properties can have values, that can be written in shorter form (remove repetitions)
const shorthandableProperties = new Set([
  "margin",
  "padding",
  "border-color",
  "border-radius",
  "border-style",
  "border-width",
  "grid-gap"
]);

const ignoredCharacters = [
  "+",
  "-",
  "*",
  "/",
  "(",
  ")",
  "$",
  "@",
  "--",
  "var("
];

function isIgnoredCharacters(value) {
  return ignoredCharacters.some(char => value.indexOf(char) !== -1);
}

function canCondense(top, right) {
  const bottom =
    arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
  const left =
    arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;

  const lowerTop = top.toLowerCase();
  const lowerRight = right.toLowerCase();
  const lowerBottom = bottom && bottom.toLowerCase();
  const lowerLeft = left && left.toLowerCase();

  if (canCondenseToOneValue(lowerTop, lowerRight, lowerBottom, lowerLeft)) {
    return [top];
  } else if (
    canCondenseToTwoValues(lowerTop, lowerRight, lowerBottom, lowerLeft)
  ) {
    return [top, right];
  } else if (
    canCondenseToThreeValues(lowerTop, lowerRight, lowerBottom, lowerLeft)
  ) {
    return [top, right, bottom];
  } else {
    return [top, right, bottom, left];
  }
}

function canCondenseToOneValue(top, right, bottom, left) {
  if (top !== right) {
    return false;
  }

  return (top === bottom && (bottom === left || !left)) || (!bottom && !left);
}

function canCondenseToTwoValues(top, right, bottom, left) {
  return (
    (top === bottom && right === left) ||
    (top === bottom && !left && top !== right)
  );
}

function canCondenseToThreeValues(top, right, bottom, left) {
  return right === left;
}

const rule = function(actual) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, { actual });
    if (!validOptions) {
      return;
    }

    root.walkDecls(decl => {
      if (
        !isStandardSyntaxDeclaration(decl) ||
        !isStandardSyntaxProperty(decl.prop)
      ) {
        return;
      }

      const prop = decl.prop,
        value = decl.value;

      const normalizedProp = postcss.vendor.unprefixed(prop.toLowerCase());

      // Ignore not shorthandable properties, and math operations
      if (
        isIgnoredCharacters(value) ||
        !shorthandableProperties.has(normalizedProp)
      ) {
        return;
      }

      const valuesToShorthand = [];

      valueParser(value).walk(valueNode => {
        if (valueNode.type !== "word") {
          return;
        }

        valuesToShorthand.push(valueParser.stringify(valueNode));
      });

      if (valuesToShorthand.length <= 1 || valuesToShorthand.length > 4) {
        return;
      }

      const shortestForm = canCondense.apply(undefined, valuesToShorthand);
      const shortestFormString = shortestForm
        .filter(value => {
          return value;
        })
        .join(" ");
      const valuesFormString = valuesToShorthand.join(" ");

      if (shortestFormString.toLowerCase() === valuesFormString.toLowerCase()) {
        return;
      }

      report({
        message: messages.rejected(value, shortestFormString),
        node: decl,
        result,
        ruleName
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isStandardSyntaxDeclaration":1121,"../../utils/isStandardSyntaxProperty":1124,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"postcss":828,"postcss-value-parser":811}],1051:[function(require,module,exports){
"use strict";

const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const styleSearch = require("style-search");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "string-no-newline";

const messages = ruleMessages(ruleName, {
  rejected: "Unexpected newline in string"
});

const rule = function(actual) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, { actual });
    if (!validOptions) {
      return;
    }

    const cssString = root.toString();
    styleSearch(
      {
        source: cssString,
        target: "\n",
        strings: "only"
      },
      match => {
        const charBefore = cssString[match.startIndex - 1];
        let index = match.startIndex;
        if (charBefore === "\\") {
          return;
        }
        if (charBefore === "\r") index -= 1;
        report({
          message: messages.rejected,
          node: root,
          index,
          result,
          ruleName
        });
      }
    );
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"style-search":870}],1052:[function(require,module,exports){
"use strict";

const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const styleSearch = require("style-search");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "string-quotes";

const messages = ruleMessages(ruleName, {
  expected: q => `Expected ${q} quotes`
});

const rule = function(expectation) {
  const erroneousQuote = expectation === "single" ? '"' : "'";

  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["single", "double"]
    });
    if (!validOptions) {
      return;
    }

    const cssString = root.toString();
    styleSearch({ source: cssString, target: erroneousQuote }, match => {
      report({
        message: messages.expected(expectation),
        node: root,
        index: match.startIndex,
        result,
        ruleName
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"style-search":870}],1053:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const declarationValueIndex = require("../../utils/declarationValueIndex");
const keywordSets = require("../../reference/keywordSets");
const postcss = require("postcss");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const valueParser = require("postcss-value-parser");

const ruleName = "time-min-milliseconds";

const messages = ruleMessages(ruleName, {
  expected: time => `Expected a minimum of ${time} milliseconds`
});

const rule = function(minimum) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: minimum,
      possible: _.isNumber
    });
    if (!validOptions) {
      return;
    }

    root.walkDecls(decl => {
      const propertyName = postcss.vendor.unprefixed(decl.prop.toLowerCase());

      if (
        keywordSets.longhandTimeProperties.has(propertyName) &&
        !isAcceptableTime(decl.value)
      ) {
        complain(decl);
      }

      if (keywordSets.shorthandTimeProperties.has(propertyName)) {
        const valueList = postcss.list.space(decl.value);

        for (const value of valueList) {
          if (!isAcceptableTime(value)) {
            complain(decl, decl.value.indexOf(value));
          }
        }
      }
    });

    function isAcceptableTime(time) {
      const parsedTime = valueParser.unit(time);

      if (!parsedTime) return true;

      if (parsedTime.number <= 0) {
        return true;
      }

      if (
        parsedTime.unit.toLowerCase() === "ms" &&
        parsedTime.number < minimum
      ) {
        return false;
      }

      if (
        parsedTime.unit.toLowerCase() === "s" &&
        parsedTime.number * 1000 < minimum
      ) {
        return false;
      }

      return true;
    }

    function complain(decl, offset) {
      offset = offset || 0;

      report({
        result,
        ruleName,
        message: messages.expected(minimum),
        index: declarationValueIndex(decl) + offset,
        node: decl
      });
    }
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../reference/keywordSets":888,"../../utils/declarationValueIndex":1080,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"postcss":828,"postcss-value-parser":811}],1054:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const atRuleParamIndex = require("../../utils/atRuleParamIndex");
const declarationValueIndex = require("../../utils/declarationValueIndex");
const getUnitFromValueNode = require("../../utils/getUnitFromValueNode");
const optionsMatches = require("../../utils/optionsMatches");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateObjectWithStringArrayProps = require("../../utils/validateObjectWithStringArrayProps");
const validateOptions = require("../../utils/validateOptions");
const valueParser = require("postcss-value-parser");

const ruleName = "unit-blacklist";

const messages = ruleMessages(ruleName, {
  rejected: unit => `Unexpected unit "${unit}"`
});

const rule = function(blacklistInput, options) {
  const blacklist = [].concat(blacklistInput);
  return (root, result) => {
    const validOptions = validateOptions(
      result,
      ruleName,
      {
        actual: blacklist,
        possible: [_.isString]
      },
      {
        optional: true,
        actual: options,
        possible: {
          ignoreProperties: validateObjectWithStringArrayProps
        }
      }
    );
    if (!validOptions) {
      return;
    }

    function check(node, value, getIndex) {
      valueParser(value).walk(function(valueNode) {
        // Ignore wrong units within `url` function
        if (
          valueNode.type === "function" &&
          valueNode.value.toLowerCase() === "url"
        ) {
          return false;
        }

        const unit = getUnitFromValueNode(valueNode);

        if (!unit || (unit && blacklist.indexOf(unit.toLowerCase()) === -1)) {
          return;
        }

        if (
          options &&
          optionsMatches(
            options.ignoreProperties,
            unit.toLowerCase(),
            node.prop
          )
        ) {
          return;
        }

        report({
          index: getIndex(node) + valueNode.sourceIndex,
          message: messages.rejected(unit),
          node,
          result,
          ruleName
        });
      });
    }

    root.walkAtRules(/^media$/i, atRule =>
      check(atRule, atRule.params, atRuleParamIndex)
    );
    root.walkDecls(decl => check(decl, decl.value, declarationValueIndex));
  };
};

rule.primaryOptionArray = true;

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/atRuleParamIndex":1071,"../../utils/declarationValueIndex":1080,"../../utils/getUnitFromValueNode":1091,"../../utils/optionsMatches":1137,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateObjectWithStringArrayProps":1143,"../../utils/validateOptions":1144,"lodash":692,"postcss-value-parser":811}],1055:[function(require,module,exports){
"use strict";

const atRuleParamIndex = require("../../utils/atRuleParamIndex");
const declarationValueIndex = require("../../utils/declarationValueIndex");
const getUnitFromValueNode = require("../../utils/getUnitFromValueNode");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const valueParser = require("postcss-value-parser");

const ruleName = "unit-case";

const messages = ruleMessages(ruleName, {
  expected: (actual, expected) => `Expected "${actual}" to be "${expected}"`
});

const rule = function(expectation) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["lower", "upper"]
    });
    if (!validOptions) {
      return;
    }

    function check(node, value, getIndex) {
      valueParser(value).walk(valueNode => {
        // Ignore wrong units within `url` function
        if (
          valueNode.type === "function" &&
          valueNode.value.toLowerCase() === "url"
        ) {
          return false;
        }

        const unit = getUnitFromValueNode(valueNode);

        if (!unit) {
          return;
        }

        const expectedUnit =
          expectation === "lower" ? unit.toLowerCase() : unit.toUpperCase();

        if (unit === expectedUnit) {
          return;
        }

        report({
          index: getIndex(node) + valueNode.sourceIndex,
          message: messages.expected(unit, expectedUnit),
          node,
          result,
          ruleName
        });
      });
    }

    root.walkAtRules(/^media$/i, atRule =>
      check(atRule, atRule.params, atRuleParamIndex)
    );
    root.walkDecls(decl => check(decl, decl.value, declarationValueIndex));
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/atRuleParamIndex":1071,"../../utils/declarationValueIndex":1080,"../../utils/getUnitFromValueNode":1091,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"postcss-value-parser":811}],1056:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const atRuleParamIndex = require("../../utils/atRuleParamIndex");
const declarationValueIndex = require("../../utils/declarationValueIndex");
const getUnitFromValueNode = require("../../utils/getUnitFromValueNode");
const keywordSets = require("../../reference/keywordSets");
const optionsMatches = require("../../utils/optionsMatches");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const valueParser = require("postcss-value-parser");

const ruleName = "unit-no-unknown";

const messages = ruleMessages(ruleName, {
  rejected: unit => `Unexpected unknown unit "${unit}"`
});

const rule = function(actual, options) {
  return (root, result) => {
    const validOptions = validateOptions(
      result,
      ruleName,
      { actual },
      {
        actual: options,
        possible: {
          ignoreUnits: [_.isString]
        },
        optional: true
      }
    );

    if (!validOptions) {
      return;
    }

    function check(node, value, getIndex) {
      valueParser(value).walk(function(valueNode) {
        // Ignore wrong units within `url` function
        if (
          valueNode.type === "function" &&
          valueNode.value.toLowerCase() === "url"
        ) {
          return false;
        }

        const unit = getUnitFromValueNode(valueNode);
        if (!unit) {
          return;
        }

        if (optionsMatches(options, "ignoreUnits", unit)) {
          return;
        }

        if (keywordSets.units.has(unit.toLowerCase())) {
          return;
        }

        report({
          index: getIndex(node) + valueNode.sourceIndex,
          message: messages.rejected(unit),
          node,
          result,
          ruleName
        });
      });
    }

    root.walkAtRules(/^media$/i, atRule =>
      check(atRule, atRule.params, atRuleParamIndex)
    );
    root.walkDecls(decl => check(decl, decl.value, declarationValueIndex));
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../reference/keywordSets":888,"../../utils/atRuleParamIndex":1071,"../../utils/declarationValueIndex":1080,"../../utils/getUnitFromValueNode":1091,"../../utils/optionsMatches":1137,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"postcss-value-parser":811}],1057:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const atRuleParamIndex = require("../../utils/atRuleParamIndex");
const declarationValueIndex = require("../../utils/declarationValueIndex");
const getUnitFromValueNode = require("../../utils/getUnitFromValueNode");
const optionsMatches = require("../../utils/optionsMatches");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateObjectWithStringArrayProps = require("../../utils/validateObjectWithStringArrayProps");
const validateOptions = require("../../utils/validateOptions");
const valueParser = require("postcss-value-parser");

const ruleName = "unit-whitelist";

const messages = ruleMessages(ruleName, {
  rejected: unit => `Unexpected unit "${unit}"`
});

const rule = function(whitelistInput, options) {
  const whitelist = [].concat(whitelistInput);
  return (root, result) => {
    const validOptions = validateOptions(
      result,
      ruleName,
      {
        actual: whitelist,
        possible: [_.isString]
      },
      {
        optional: true,
        actual: options,
        possible: {
          ignoreProperties: validateObjectWithStringArrayProps
        }
      }
    );
    if (!validOptions) {
      return;
    }

    function check(node, value, getIndex) {
      valueParser(value).walk(function(valueNode) {
        // Ignore wrong units within `url` function
        if (
          valueNode.type === "function" &&
          valueNode.value.toLowerCase() === "url"
        ) {
          return false;
        }

        const unit = getUnitFromValueNode(valueNode);

        if (!unit || (unit && whitelist.indexOf(unit.toLowerCase()) !== -1)) {
          return;
        }

        if (
          options &&
          optionsMatches(
            options["ignoreProperties"],
            unit.toLowerCase(),
            node.prop
          )
        ) {
          return;
        }

        report({
          index: getIndex(node) + valueNode.sourceIndex,
          message: messages.rejected(unit),
          node,
          result,
          ruleName
        });
      });
    }

    root.walkAtRules(/^media$/i, atRule =>
      check(atRule, atRule.params, atRuleParamIndex)
    );
    root.walkDecls(decl => check(decl, decl.value, declarationValueIndex));
  };
};

rule.primaryOptionArray = true;

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/atRuleParamIndex":1071,"../../utils/declarationValueIndex":1080,"../../utils/getUnitFromValueNode":1091,"../../utils/optionsMatches":1137,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateObjectWithStringArrayProps":1143,"../../utils/validateOptions":1144,"lodash":692,"postcss-value-parser":811}],1058:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const declarationValueIndex = require("../../utils/declarationValueIndex");
const getUnitFromValueNode = require("../../utils/getUnitFromValueNode");
const isCounterIncrementCustomIdentValue = require("../../utils/isCounterIncrementCustomIdentValue");
const isCounterResetCustomIdentValue = require("../../utils/isCounterResetCustomIdentValue");
const isStandardSyntaxValue = require("../../utils/isStandardSyntaxValue");
const keywordSets = require("../../reference/keywordSets");
const matchesStringOrRegExp = require("../../utils/matchesStringOrRegExp");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const valueParser = require("postcss-value-parser");

const ruleName = "value-keyword-case";

const messages = ruleMessages(ruleName, {
  expected: (actual, expected) => `Expected "${actual}" to be "${expected}"`
});

// Operators are interpreted as "words" by the value parser, so we want to make sure to ignore them.
const ignoredCharacters = new Set(["+", "-", "/", "*", "%"]);

const mapLowercaseKeywordsToCamelCase = new Map();
keywordSets.camelCaseKeywords.forEach(func => {
  mapLowercaseKeywordsToCamelCase.set(func.toLowerCase(), func);
});

const rule = function(expectation, options) {
  return (root, result) => {
    const validOptions = validateOptions(
      result,
      ruleName,
      {
        actual: expectation,
        possible: ["lower", "upper"]
      },
      {
        actual: options,
        possible: {
          ignoreKeywords: [_.isString]
        },
        optional: true
      }
    );
    if (!validOptions) {
      return;
    }

    root.walkDecls(decl => {
      const prop = decl.prop,
        value = decl.value;

      valueParser(value).walk(node => {
        const valueLowerCase = node.value.toLowerCase();

        // Ignore system colors
        if (keywordSets.systemColors.has(valueLowerCase)) {
          return;
        }

        // Ignore keywords within `url` and `var` function
        if (
          node.type === "function" &&
          (valueLowerCase === "url" ||
            valueLowerCase === "var" ||
            valueLowerCase === "counter" ||
            valueLowerCase === "counters" ||
            valueLowerCase === "attr")
        ) {
          return false;
        }

        const keyword = node.value;

        // Ignore css variables, and hex values, and math operators, and sass interpolation
        if (
          node.type !== "word" ||
          !isStandardSyntaxValue(node.value) ||
          value.indexOf("#") !== -1 ||
          ignoredCharacters.has(keyword) ||
          getUnitFromValueNode(node)
        ) {
          return;
        }

        if (
          prop === "animation" &&
          !keywordSets.animationShorthandKeywords.has(valueLowerCase) &&
          !keywordSets.animationNameKeywords.has(valueLowerCase)
        ) {
          return;
        }
        if (
          prop === "animation-name" &&
          !keywordSets.animationNameKeywords.has(valueLowerCase)
        ) {
          return;
        }
        if (
          prop === "font" &&
          !keywordSets.fontShorthandKeywords.has(valueLowerCase) &&
          !keywordSets.fontFamilyKeywords.has(valueLowerCase)
        ) {
          return;
        }
        if (
          prop === "font-family" &&
          !keywordSets.fontFamilyKeywords.has(valueLowerCase)
        ) {
          return;
        }
        if (
          prop === "counter-increment" &&
          isCounterIncrementCustomIdentValue(valueLowerCase)
        ) {
          return;
        }
        if (
          prop === "counter-reset" &&
          isCounterResetCustomIdentValue(valueLowerCase)
        ) {
          return;
        }
        if (
          prop === "grid-row" &&
          !keywordSets.gridRowKeywords.has(valueLowerCase)
        ) {
          return;
        }
        if (
          prop === "grid-column" &&
          !keywordSets.gridColumnKeywords.has(valueLowerCase)
        ) {
          return;
        }
        if (
          prop === "grid-area" &&
          !keywordSets.gridAreaKeywords.has(valueLowerCase)
        ) {
          return;
        }
        if (
          prop === "list-style" &&
          !keywordSets.listStyleShorthandKeywords.has(valueLowerCase) &&
          !keywordSets.listStyleTypeKeywords.has(valueLowerCase)
        ) {
          return;
        }
        if (
          prop === "list-style-type" &&
          !keywordSets.listStyleTypeKeywords.has(valueLowerCase)
        ) {
          return;
        }

        const ignoreKeywords = (options && options.ignoreKeywords) || [];

        if (
          ignoreKeywords.length > 0 &&
          matchesStringOrRegExp(keyword, ignoreKeywords)
        ) {
          return;
        }

        const keywordLowerCase = keyword.toLocaleLowerCase();
        let expectedKeyword = null;

        if (
          expectation === "lower" &&
          mapLowercaseKeywordsToCamelCase.has(keywordLowerCase)
        ) {
          expectedKeyword = mapLowercaseKeywordsToCamelCase.get(
            keywordLowerCase
          );
        } else if (expectation === "lower") {
          expectedKeyword = keyword.toLowerCase();
        } else {
          expectedKeyword = keyword.toUpperCase();
        }

        if (keyword === expectedKeyword) {
          return;
        }

        report({
          message: messages.expected(keyword, expectedKeyword),
          node: decl,
          index: declarationValueIndex(decl) + node.sourceIndex,
          result,
          ruleName
        });
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../reference/keywordSets":888,"../../utils/declarationValueIndex":1080,"../../utils/getUnitFromValueNode":1091,"../../utils/isCounterIncrementCustomIdentValue":1105,"../../utils/isCounterResetCustomIdentValue":1106,"../../utils/isStandardSyntaxValue":1129,"../../utils/matchesStringOrRegExp":1134,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"postcss-value-parser":811}],1059:[function(require,module,exports){
"use strict";

const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const valueListCommaWhitespaceChecker = require("../valueListCommaWhitespaceChecker");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "value-list-comma-newline-after";

const messages = ruleMessages(ruleName, {
  expectedAfter: () => 'Expected newline after ","',
  expectedAfterMultiLine: () =>
    'Expected newline after "," in a multi-line list',
  rejectedAfterMultiLine: () =>
    'Unexpected whitespace after "," in a multi-line list'
});

const rule = function(expectation) {
  const checker = whitespaceChecker("newline", expectation, messages);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "always-multi-line", "never-multi-line"]
    });
    if (!validOptions) {
      return;
    }

    valueListCommaWhitespaceChecker({
      root,
      result,
      locationChecker: checker.afterOneOnly,
      checkedRuleName: ruleName
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145,"../valueListCommaWhitespaceChecker":1065}],1060:[function(require,module,exports){
"use strict";

const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const valueListCommaWhitespaceChecker = require("../valueListCommaWhitespaceChecker");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "value-list-comma-newline-before";

const messages = ruleMessages(ruleName, {
  expectedBefore: () => 'Expected newline before ","',
  expectedBeforeMultiLine: () =>
    'Expected newline before "," in a multi-line list',
  rejectedBeforeMultiLine: () =>
    'Unexpected whitespace before "," in a multi-line list'
});

const rule = function(expectation) {
  const checker = whitespaceChecker("newline", expectation, messages);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "always-multi-line", "never-multi-line"]
    });
    if (!validOptions) {
      return;
    }

    valueListCommaWhitespaceChecker({
      root,
      result,
      locationChecker: checker.beforeAllowingIndentation,
      checkedRuleName: ruleName
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145,"../valueListCommaWhitespaceChecker":1065}],1061:[function(require,module,exports){
"use strict";

const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const valueListCommaWhitespaceChecker = require("../valueListCommaWhitespaceChecker");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "value-list-comma-space-after";

const messages = ruleMessages(ruleName, {
  expectedAfter: () => 'Expected single space after ","',
  rejectedAfter: () => 'Unexpected whitespace after ","',
  expectedAfterSingleLine: () =>
    'Expected single space after "," in a single-line list',
  rejectedAfterSingleLine: () =>
    'Unexpected whitespace after "," in a single-line list'
});

const rule = function(expectation) {
  const checker = whitespaceChecker("space", expectation, messages);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "never", "always-single-line", "never-single-line"]
    });
    if (!validOptions) {
      return;
    }

    valueListCommaWhitespaceChecker({
      root,
      result,
      locationChecker: checker.after,
      checkedRuleName: ruleName
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145,"../valueListCommaWhitespaceChecker":1065}],1062:[function(require,module,exports){
"use strict";

const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");
const valueListCommaWhitespaceChecker = require("../valueListCommaWhitespaceChecker");
const whitespaceChecker = require("../../utils/whitespaceChecker");

const ruleName = "value-list-comma-space-before";

const messages = ruleMessages(ruleName, {
  expectedBefore: () => 'Expected single space before ","',
  rejectedBefore: () => 'Unexpected whitespace before ","',
  expectedBeforeSingleLine: () =>
    'Unexpected whitespace before "," in a single-line list',
  rejectedBeforeSingleLine: () =>
    'Unexpected whitespace before "," in a single-line list'
});

const rule = function(expectation) {
  const checker = whitespaceChecker("space", expectation, messages);
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation,
      possible: ["always", "never", "always-single-line", "never-single-line"]
    });
    if (!validOptions) {
      return;
    }

    valueListCommaWhitespaceChecker({
      root,
      result,
      locationChecker: checker.before,
      checkedRuleName: ruleName
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"../../utils/whitespaceChecker":1145,"../valueListCommaWhitespaceChecker":1065}],1063:[function(require,module,exports){
"use strict";

const _ = require("lodash");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const styleSearch = require("style-search");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "value-list-max-empty-lines";

const messages = ruleMessages(ruleName, {
  expected: max =>
    `Expected no more than ${max} empty ${max === 1 ? "line" : "lines"}`
});

const rule = function(max) {
  const maxAdjacentNewlines = max + 1;

  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: max,
      possible: _.isNumber
    });
    if (!validOptions) {
      return;
    }

    root.walkDecls(decl => {
      const value = decl.value;
      const repeatLFNewLines = _.repeat("\n", maxAdjacentNewlines);
      const repeatCRLFNewLines = _.repeat("\r\n", maxAdjacentNewlines);

      styleSearch({ source: value, target: "\n" }, match => {
        if (
          value.substr(match.startIndex + 1, maxAdjacentNewlines) ===
            repeatLFNewLines ||
          value.substr(match.startIndex + 1, maxAdjacentNewlines * 2) ===
            repeatCRLFNewLines
        ) {
          // Put index at `\r` if it's CRLF, otherwise leave it at `\n`
          let index = match.startIndex;
          if (value[index - 1] === "\r") {
            index -= 1;
          }

          report({
            message: messages.expected(max),
            node: decl,
            index,
            result,
            ruleName
          });
        }
      });
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"lodash":692,"style-search":870}],1064:[function(require,module,exports){
"use strict";

const isAutoprefixable = require("../../utils/isAutoprefixable");
const isStandardSyntaxDeclaration = require("../../utils/isStandardSyntaxDeclaration");
const isStandardSyntaxProperty = require("../../utils/isStandardSyntaxProperty");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const styleSearch = require("style-search");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "value-no-vendor-prefix";

const messages = ruleMessages(ruleName, {
  rejected: value => `Unexpected vendor-prefix "${value}"`
});

const valuePrefixes = ["-webkit-", "-moz-", "-ms-", "-o-"];

const rule = function(actual) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, { actual });
    if (!validOptions) {
      return;
    }

    root.walkDecls(decl => {
      if (
        !isStandardSyntaxDeclaration(decl) ||
        !isStandardSyntaxProperty(decl.prop) ||
        decl.value[0] !== "-"
      ) {
        return;
      }

      const prop = decl.prop,
        value = decl.value;

      // Search the full declaration in order to get an accurate index

      styleSearch(
        { source: value.toLowerCase(), target: valuePrefixes },
        match => {
          const fullIdentifier = /^(-[a-z-]+)\b/i.exec(
            value.slice(match.startIndex)
          )[1];
          if (!isAutoprefixable.propertyValue(prop, fullIdentifier)) {
            return;
          }

          report({
            message: messages.rejected(fullIdentifier),
            node: decl,
            index:
              prop.length + (decl.raws.between || "").length + match.startIndex,
            result,
            ruleName
          });
        }
      );
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

},{"../../utils/isAutoprefixable":1102,"../../utils/isStandardSyntaxDeclaration":1121,"../../utils/isStandardSyntaxProperty":1124,"../../utils/report":1141,"../../utils/ruleMessages":1142,"../../utils/validateOptions":1144,"style-search":870}],1065:[function(require,module,exports){
"use strict";

const isStandardSyntaxDeclaration = require("../utils/isStandardSyntaxDeclaration");
const isStandardSyntaxProperty = require("../utils/isStandardSyntaxProperty");
const report = require("../utils/report");
const styleSearch = require("style-search");

module.exports = function(opts) {
  opts.root.walkDecls(decl => {
    if (
      !isStandardSyntaxDeclaration(decl) ||
      !isStandardSyntaxProperty(decl.prop)
    ) {
      return;
    }
    styleSearch(
      {
        source: decl.toString(),
        target: ",",
        functionArguments: "skip"
      },
      match => {
        checkComma(decl.toString(), match.startIndex, decl);
      }
    );
  });

  function checkComma(source, index, node) {
    opts.locationChecker({
      source,
      index,
      err: m => {
        report({
          message: m,
          node,
          index,
          result: opts.result,
          ruleName: opts.checkedRuleName
        });
      }
    });
  }
};

},{"../utils/isStandardSyntaxDeclaration":1121,"../utils/isStandardSyntaxProperty":1124,"../utils/report":1141,"style-search":870}],1066:[function(require,module,exports){
(function (process){
/* @flow */
"use strict";
const createStylelint = require("./createStylelint");
const debug = require("debug")("stylelint:standalone");
const FileCache = require("./utils/FileCache");
const formatters /*: Object*/ = require("./formatters");
const fs = require("fs");
const globby /*: Function*/ = require("globby");
const hash = require("./utils/hash");
const ignore = require("ignore");
const needlessDisables /*: Function*/ = require("./needlessDisables");
const path = require("path");
const pify = require("pify");
const pkg = require("../package.json");

const DEFAULT_IGNORE_FILENAME = ".stylelintignore";
const FILE_NOT_FOUND_ERROR_CODE = "ENOENT";
const ALWAYS_IGNORED_GLOBS = ["**/node_modules/**", "**/bower_components/**"];

/*::type CssSyntaxErrorT = {
  column: number;
  file?: string;
  input: {
    column: number;
    file?: string;
    line: number;
    source: string;
  };
  line: number;
  message: string;
  name: string;
  reason: string;
  source: string;
}*/

module.exports = function(
  options /*: stylelint$standaloneOptions */
) /*: Promise<stylelint$standaloneReturnValue>*/ {
  const cacheLocation = options.cacheLocation;
  const code = options.code;
  const codeFilename = options.codeFilename;
  const config = options.config;
  const configBasedir = options.configBasedir;
  const configFile = options.configFile;
  const configOverrides = options.configOverrides;
  const customSyntax = options.customSyntax;
  const files = options.files;
  const fix = options.fix;
  const formatter = options.formatter;
  const ignoreDisables = options.ignoreDisables;
  const reportNeedlessDisables = options.reportNeedlessDisables;
  const syntax = options.syntax;
  const useCache = options.cache || false;
  let fileCache;
  const startTime = Date.now();

  // The ignorer will be used to filter file paths after the glob is checked,
  // before any files are actually read
  const ignoreFilePath = options.ignorePath || DEFAULT_IGNORE_FILENAME;
  const absoluteIgnoreFilePath = path.isAbsolute(ignoreFilePath)
    ? ignoreFilePath
    : path.resolve(process.cwd(), ignoreFilePath);
  let ignoreText = "";
  /*
  try {
    ignoreText = fs.readFileSync(absoluteIgnoreFilePath, "utf8");
  } catch (readError) {
    if (readError.code !== FILE_NOT_FOUND_ERROR_CODE) throw readError;
  }
  */
  const ignorer = ignore().add(ignoreText);

  const isValidCode = typeof code === "string";
  if ((!files && !isValidCode) || (files && (code || isValidCode))) {
    throw new Error(
      "You must pass stylelint a `files` glob or a `code` string, though not both"
    );
  }

  let formatterFunction;
  if (typeof formatter === "string") {
    formatterFunction = formatters[formatter];
    if (formatterFunction === undefined) {
      return Promise.reject(
        new Error(
          "You must use a valid formatter option: 'json', 'string', 'verbose', or a function"
        )
      );
    }
  } else if (typeof formatter === "function") {
    formatterFunction = formatter;
  } else {
    formatterFunction = formatters.json;
  }

  const stylelint = createStylelint({
    config,
    configFile,
    configBasedir,
    configOverrides,
    ignoreDisables,
    reportNeedlessDisables,
    syntax,
    customSyntax,
    fix
  });

  if (!files) {
    const absoluteCodeFilename =
      codeFilename !== undefined && !path.isAbsolute(codeFilename)
        ? path.join(process.cwd(), codeFilename)
        : codeFilename;
    return stylelint
      ._lintSource({
        code,
        codeFilename: absoluteCodeFilename
      })
      .then(postcssResult => {
        return stylelint._createStylelintResult(postcssResult);
      })
      .catch(handleError)
      .then(stylelintResult => {
        return prepareReturnValue([stylelintResult]);
      });
  }

  let fileList = files;
  if (typeof fileList === "string") {
    fileList = [fileList];
  }
  if (!options.disableDefaultIgnores) {
    fileList = fileList.concat(ALWAYS_IGNORED_GLOBS.map(glob => "!" + glob));
  }

  if (useCache) {
    const stylelintVersion = pkg.version;
    const hashOfConfig = hash(`${stylelintVersion}_${JSON.stringify(config)}`);
    fileCache = new FileCache(cacheLocation, hashOfConfig);
  } else {
    // No need to calculate hash here, we just want to delete cache file.
    fileCache = new FileCache(cacheLocation);
    // Remove cache file if cache option is disabled
    fileCache.destroy();
  }

  return globby(fileList)
    .then(filePaths => {
      // The ignorer filter needs to check paths relative to cwd
      filePaths = ignorer.filter(
        filePaths.map(p => path.relative(process.cwd(), p))
      );

      if (!filePaths.length) {
        return Promise.all([]);
      }

      let absoluteFilePaths = filePaths.map(filePath => {
        const absoluteFilepath = !path.isAbsolute(filePath)
          ? path.join(process.cwd(), filePath)
          : path.normalize(filePath);
        return absoluteFilepath;
      });

      if (useCache) {
        absoluteFilePaths = absoluteFilePaths.filter(
          fileCache.hasFileChanged.bind(fileCache)
        );
      }

      const getStylelintResults = absoluteFilePaths.map(absoluteFilepath => {
        debug(`Processing ${absoluteFilepath}`);
        return stylelint
          ._lintSource({
            filePath: absoluteFilepath
          })
          .then(postcssResult => {
            if (postcssResult.stylelint.stylelintError && useCache) {
              debug(
                `${absoluteFilepath} contains linting errors and will not be cached.`
              );
              fileCache.removeEntry(absoluteFilepath);
            }

            // If we're fixing, save the file with changed code
            let fixFile = Promise.resolve();
            if (!postcssResult.stylelint.ignored && options.fix) {
              const fixedCss = postcssResult.root.toString(
                postcssResult.opts.syntax
              );
              fixFile = pify(fs.writeFile)(absoluteFilepath, fixedCss);
            }

            return fixFile.then(() =>
              stylelint._createStylelintResult(postcssResult, absoluteFilepath)
            );
          })
          .catch(handleError);
      });

      return Promise.all(getStylelintResults);
    })
    .then(stylelintResults => {
      if (useCache) {
        fileCache.reconcile();
      }
      return prepareReturnValue(stylelintResults);
    });

  function prepareReturnValue(
    stylelintResults /*: Array<stylelint$result>*/
  ) /*: stylelint$standaloneReturnValue*/ {
    const errored = stylelintResults.some(
      result => result.errored || result.parseErrors.length > 0
    );
    const returnValue /*: stylelint$standaloneReturnValue*/ = {
      errored,
      output: formatterFunction(stylelintResults),
      results: stylelintResults
    };
    if (reportNeedlessDisables) {
      returnValue.needlessDisables = needlessDisables(stylelintResults);
    }
    debug(`Linting complete in ${Date.now() - startTime}ms`);
    return returnValue;
  }
};

function handleError(error /*: Object*/) {
  if (error.name === "CssSyntaxError") {
    return convertCssSyntaxErrorToResult(error);
  } else {
    throw error;
  }
}

// By converting syntax errors to stylelint results,
// we can control their appearance in the formatted output
// and other tools like editor plugins can decide how to
// present them, as well
function convertCssSyntaxErrorToResult(
  error /*: CssSyntaxErrorT*/
) /*: stylelint$result*/ {
  if (error.name !== "CssSyntaxError") {
    throw error;
  }

  return {
    source: error.file || "<input css 1>",
    deprecations: [],
    invalidOptionWarnings: [],
    parseErrors: [],
    errored: true,
    warnings: [
      {
        line: error.line,
        column: error.column,
        rule: error.name,
        severity: "error",
        text: error.reason + " (" + error.name + ")"
      }
    ]
  };
}

}).call(this,require('_process'))
},{"../package.json":1146,"./createStylelint":874,"./formatters":877,"./needlessDisables":885,"./utils/FileCache":1069,"./utils/hash":1099,"_process":16,"debug":597,"fs":1,"globby":624,"ignore":634,"path":14,"pify":721}],1067:[function(require,module,exports){
"use strict";

// These should pass for *almost* every rule
module.exports = [
  {
    code: "",
    description: "empty stylesheet"
  },
  {
    code: "a {}",
    description: "empty rule"
  },
  {
    code: '@import "foo.css";',
    description: "blockless statement"
  },
  {
    code: ":global {}",
    description: "CSS Modules global empty rule set"
  }
];

},{}],1068:[function(require,module,exports){
(function (process){
"use strict";

const _ = require("lodash");
const assignDisabledRanges = require("../assignDisabledRanges");
const basicChecks = require("./basicChecks");
const lessSyntax = require("postcss-less");
const normalizeRuleSettings = require("../normalizeRuleSettings");
const postcss = require("postcss");
const scssSyntax = require("postcss-scss");
const sugarss = require("sugarss");

/**
 * Create a stylelint rule testing function.
 *
 * Pass in an `equalityCheck` function. Given some information,
 * this checker should use Whatever Test Runner to perform
 * equality checks.
 *
 * `equalityCheck` should accept two arguments:
 * - `processCss` {Promise}: A Promise that resolves with an array of
 *   comparisons that you need to check (documented below).
 * - `context` {object}: An object that contains additional information
 *   you may need:
 *   - `caseDescription` {string}: A description of the test case as a whole.
 *   	 Will look like this:
 *   	   > rule: value-list-comma-space-before
 *   	   > config: "always-single-line"
 *   	   > code: "a { background-size: 0 ,0;\n}"
 *   - `comparisonCount` {number}: The number of comparisons that
 *     will need to be performed (e.g. useful for tape).
 *   - `completeAssertionDescription` {string}: While each individual
 *   	 comparison may have its own description, this is a description
 *   	 of the whole assertion (e.g. useful for Mocha).
 *   - `only` {boolean}: If `true`, the test runner should only run this
 *     test case (e.g. `test.only` in tape, `describe.only` in Mocha).
 *
 * `processCss` is a Promsie that resolves with an array of comparisons.
 * Each comparison has the following properties:
 * - `actual` {any}: Some actual value.
 * - `expected` {any}: Some expected value.
 * - `description` {string}: A (possibly empty) description of the comparison.
 *
 * Within `equalityCheck`, you need to ensure that you:
 * - Set up the test case.
 * - When `processCss` resolves, loop through every comparison.
 * - For each comparison, make an assertion checking that `actual === expected`.
 *
 * The `testRule` function that you get has a simple signature:
 * `testRule(rule, testGroupDescription)`.
 *
 * `rule` is just the rule that you are testing (a function).
 *
 * `testGroupDescription` is an object fitting the following schema.
 *
 * Required properties:
 * - `ruleName` {string}: The name of the rule. Used in descriptions.
 * - `config` {any}: The rule's configuration for this test group.
 *   Should match the format you'd use in `.stylelintrc`.
 * - `accept` {array}: An array of objects describing test cases that
 *   should not violate the rule. Each object has these properties:
 *   - `code` {string}: The source CSS to check.
 *   - `description` {[string]}: An optional description of the case.
 * - `reject` {array}: An array of objects describing test cases that
 *   should violate the rule once. Each object has these properties:
 *   - `code` {string}: The source CSS to check.
 *   - `message` {string}: The message of the expected violation.
 *   - `line` {[number]}: The expected line number of the violation.
 *     If this is left out, the line won't be checked.
 *   - `column` {[number]}: The expected column number of the violation.
 *     If this is left out, the column won't be checked.
 *   - `description` {[string]}: An optional description of the case.
 *
 * Optional properties:
 * - `syntax` {"css"|"scss"|"less"|"sugarss"}: Defaults to `"css"`.
 * - `skipBasicChecks` {boolean}: Defaults to `false`. If `true`, a
 *   few rudimentary checks (that should almost always be included)
 *   will not be performed.
 * - `preceedingPlugins` {array}: An array of PostCSS plugins that
 *   should be run before the CSS is tested.
 *
 * @param {function} equalityCheck - Described above
 * @return {function} testRule - Decsribed above
 */
let onlyTest;

function checkCaseForOnly(caseType, testCase) {
  if (!testCase.only) {
    return;
  }
  /* istanbul ignore next */
  if (onlyTest) {
    throw new Error("Cannot use `only` on multiple test cases");
  }
  onlyTest = { case: testCase, type: caseType };
}

module.exports = function(equalityCheck) {
  return function(rule, schema) {
    const alreadyHadOnlyTest = !!onlyTest;
    if (schema.accept) {
      schema.accept.forEach(_.partial(checkCaseForOnly, "accept"));
    }

    if (schema.reject) {
      schema.reject.forEach(_.partial(checkCaseForOnly, "reject"));
    }

    if (onlyTest) {
      schema = _.assign(_.omit(schema, ["accept", "reject"]), {
        skipBasicChecks: true,
        [onlyTest.type]: [onlyTest.case]
      });
    }

    if (!alreadyHadOnlyTest) {
      process.nextTick(() => {
        processGroup(rule, schema, equalityCheck);
      });
    }
  };
};

function processGroup(rule, schema, equalityCheck) {
  const ruleName = schema.ruleName;

  const ruleOptions = normalizeRuleSettings(schema.config, ruleName);
  const rulePrimaryOptions = ruleOptions[0];
  const ruleSecondaryOptions = ruleOptions[1];

  let printableConfig = rulePrimaryOptions
    ? JSON.stringify(rulePrimaryOptions)
    : "";
  if (printableConfig && ruleSecondaryOptions) {
    printableConfig += ", " + JSON.stringify(ruleSecondaryOptions);
  }

  function createCaseDescription(code) {
    let text = `\n> rule: ${ruleName}\n`;
    text += `> config: ${printableConfig}\n`;
    text += `> code: ${JSON.stringify(code)}\n`;
    return text;
  }

  // Process the code through the rule and return
  // the PostCSS LazyResult promise
  function postcssProcess(code) {
    const postcssProcessOptions = {};

    switch (schema.syntax) {
      case "scss":
        postcssProcessOptions.syntax = scssSyntax;
        break;
      case "less":
        postcssProcessOptions.syntax = lessSyntax;
        break;
      case "sugarss":
        postcssProcessOptions.syntax = sugarss;
        break;
    }

    const processor = postcss();
    processor.use(assignDisabledRanges);

    if (schema.preceedingPlugins) {
      schema.preceedingPlugins.forEach(plugin => processor.use(plugin));
    }

    return processor
      .use(rule(rulePrimaryOptions, ruleSecondaryOptions))
      .process(code, postcssProcessOptions);
  }

  // Apply the basic positive checks unless
  // explicitly told not to
  const passingTestCases = schema.skipBasicChecks
    ? schema.accept
    : basicChecks.concat(schema.accept);

  if (passingTestCases && passingTestCases.length) {
    passingTestCases.forEach(acceptedCase => {
      if (!acceptedCase) {
        return;
      }
      const assertionDescription = spaceJoin(
        acceptedCase.description,
        "should be accepted"
      );
      const resultPromise = postcssProcess(acceptedCase.code)
        .then(postcssResult => {
          const warnings = postcssResult.warnings();
          return [
            {
              expected: 0,
              actual: warnings.length,
              description: assertionDescription
            }
          ];
        })
        .catch(err => console.log(err.stack)); // eslint-disable-line no-console

      equalityCheck(resultPromise, {
        comparisonCount: 1,
        caseDescription: createCaseDescription(acceptedCase.code),
        completeAssertionDescription: assertionDescription
      });
    });
  }

  if (schema.reject && schema.reject.length) {
    schema.reject.forEach(rejectedCase => {
      let completeAssertionDescription = "should register one warning";
      let comparisonCount = 1;
      if (rejectedCase.line) {
        comparisonCount++;
        completeAssertionDescription += ` on line ${rejectedCase.line}`;
      }
      if (rejectedCase.column !== undefined) {
        comparisonCount++;
        completeAssertionDescription += ` on column ${rejectedCase.column}`;
      }
      if (rejectedCase.message) {
        comparisonCount++;
        completeAssertionDescription += ` with message "${rejectedCase.message}"`;
      }

      const resultPromise = postcssProcess(rejectedCase.code)
        .then(postcssResult => {
          const warnings = postcssResult.warnings();
          const warning = warnings[0];

          const comparisons = [
            {
              expected: 1,
              actual: warnings.length,
              description: spaceJoin(
                rejectedCase.description,
                "should register one warning"
              )
            }
          ];

          if (rejectedCase.line) {
            comparisons.push({
              expected: rejectedCase.line,
              actual: _.get(warning, "line"),
              description: spaceJoin(
                rejectedCase.description,
                `should warn on line ${rejectedCase.line}`
              )
            });
          }
          if (rejectedCase.column !== undefined) {
            comparisons.push({
              expected: rejectedCase.column,
              actual: _.get(warning, "column"),
              description: spaceJoin(
                rejectedCase.description,
                `should warn on column ${rejectedCase.column}`
              )
            });
          }
          if (rejectedCase.message) {
            comparisons.push({
              expected: rejectedCase.message,
              actual: _.get(warning, "text"),
              description: spaceJoin(
                rejectedCase.description,
                `should warn with message ${rejectedCase.message}`
              )
            });
          }
          return comparisons;
        })
        .catch(err => console.log(err.stack)); // eslint-disable-line no-console

      equalityCheck(resultPromise, {
        comparisonCount,
        completeAssertionDescription,
        caseDescription: createCaseDescription(rejectedCase.code),
        only: rejectedCase.only
      });
    });
  }
}

function spaceJoin() {
  return _.compact(Array.from(arguments)).join(" ");
}

}).call(this,require('_process'))
},{"../assignDisabledRanges":871,"../normalizeRuleSettings":886,"./basicChecks":1067,"_process":16,"lodash":692,"postcss":828,"postcss-less":731,"postcss-scss":788,"sugarss":1147}],1069:[function(require,module,exports){
(function (process){
/* @flow */
"use strict";

const debug = require("debug")("stylelint:file-cache");
const fileEntryCache = require("file-entry-cache");
const getCacheFile = require("./getCacheFile");
const path = require("path");

const DEFAULT_CACHE_LOCATION = "./.stylelintcache";
const DEFAULT_HASH = "";

function FileCache(cacheLocation /*: ?string */, hashOfConfig /*: ?string */) {
  const cacheFile = path.resolve(
    getCacheFile(cacheLocation || DEFAULT_CACHE_LOCATION, process.cwd())
  );
  debug(`Cache file is created at ${cacheFile}`);
  this._fileCache = fileEntryCache.create(cacheFile);
  this._hashOfConfig = hashOfConfig || DEFAULT_HASH;
}

FileCache.prototype.hasFileChanged = function(absoluteFilepath) {
  // Get file descriptor compares current metadata against cached
  // one and stores the result to "changed" prop.w
  const descriptor = this._fileCache.getFileDescriptor(absoluteFilepath);
  const meta = descriptor.meta || {};
  const changed =
    descriptor.changed || meta.hashOfConfig !== this._hashOfConfig;
  if (!changed) {
    debug(`Skip linting ${absoluteFilepath}. File hasn't changed.`);
  }
  // Mutate file descriptor object and store config hash to each file.
  // Running lint with different config should invalidate the cache.
  if (meta.hashOfConfig !== this._hashOfConfig) {
    meta.hashOfConfig = this._hashOfConfig;
  }
  return changed;
};

FileCache.prototype.reconcile = function() {
  this._fileCache.reconcile();
};

FileCache.prototype.destroy = function() {
  this._fileCache.destroy();
};

FileCache.prototype.removeEntry = function(absoluteFilepath) {
  this._fileCache.removeEntry(absoluteFilepath);
};

module.exports = FileCache;

}).call(this,require('_process'))
},{"./getCacheFile":1085,"_process":16,"debug":597,"file-entry-cache":609,"path":14}],1070:[function(require,module,exports){
/* @flow */
"use strict";

const _ = require("lodash");

// Add an empty line before a node. Mutates the node.
function addEmptyLineBefore(
  node /*: postcss$node*/,
  newline /*: '\n' | '\r\n'*/
) /*: postcss$node*/ {
  if (!/\r?\n/.test(node.raws.before)) {
    node.raws.before = _.repeat(newline, 2) + node.raws.before;
  } else if (/^\r?\n/.test(node.raws.before)) {
    node.raws.before = newline + node.raws.before;
  } else if (/\r?\n$/.test(node.raws.before)) {
    node.raws.before = node.raws.before + newline;
  } else {
    node.raws.before = node.raws.before.replace(/(\r?\n)/, `${newline}$1`);
  }
  return node;
}

module.exports = addEmptyLineBefore;

},{"lodash":692}],1071:[function(require,module,exports){
/* @flow */
"use strict";
module.exports = function(atRule /*: postcss$atRule*/) /*: number*/ {
  // Initial 1 is for the `@`
  let index = 1 + atRule.name.length;
  if (atRule.raws.afterName) {
    index += atRule.raws.afterName.length;
  }
  return index;
};

},{}],1072:[function(require,module,exports){
/* @flow */
"use strict";
module.exports = function(
  statement /*: Object*/,
  options /*:: ?: Object*/
) /*: string*/ {
  options = options || {};

  let result = "";
  let rule; /*?: postcss$rule*/
  let atRule; /*?: postcss$atRule*/

  if (statement.type === "rule") {
    rule = statement;
  }
  if (statement.type === "atrule") {
    atRule = statement;
  }

  if (!rule && !atRule) {
    return result;
  }

  const before = statement.raws.before || "";

  if (!options.noRawBefore) {
    result += before;
  }
  if (rule) {
    result += rule.selector;
  }
  if (atRule) {
    result += "@" + atRule.name + (atRule.raws.afterName || "") + atRule.params;
  }

  const between = statement.raws.between;

  if (between !== undefined) {
    result += between;
  }

  return result;
};

},{}],1073:[function(require,module,exports){
/* @flow */
"use strict";
const beforeBlockString = require("./beforeBlockString");
const hasBlock = require("./hasBlock");
const rawNodeString = require("./rawNodeString");

/**
 * Return a CSS statement's block -- the string that starts and `{` and ends with `}`.
 *
 * If the statement has no block (e.g. `@import url(foo.css);`),
 * return undefined.
 *
 * @param {Rule|AtRule} statement - postcss rule or at-rule node
 * @return {string|undefined}
 */
module.exports = function(
  statement /*: postcss$rule | postcss$atRule*/
) /*: string | boolean*/ {
  if (!hasBlock(statement)) {
    return false;
  }
  return rawNodeString(statement).slice(beforeBlockString(statement).length);
};

},{"./beforeBlockString":1072,"./hasBlock":1092,"./rawNodeString":1139}],1074:[function(require,module,exports){
/* @flow */
"use strict";
module.exports = function(source /*: string*/) /*: string*/ {
  const blurChar /*: string*/ =
    arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "`";

  return source.replace(/\/\*.*\*\//g, blurChar);
};

},{}],1075:[function(require,module,exports){
/* @flow */
"use strict";
const _ = require("lodash");
const balancedMatch = require("balanced-match");

/**
 * Replace all of the characters that are arguments to a certain
 * CSS function with some innocuous character.
 *
 * This is useful if you need to use a RegExp to find a string
 * but want to ignore matches in certain functions (e.g. `url()`,
 * which might contain all kinds of false positives).
 *
 * For example:
 * blurFunctionArguments("abc url(abc) abc", "url") === "abc url(```) abc"
 *
 * @param {string} source
 * @param {string} functionName
 * @param {[string]} blurChar="`"
 * @return {string} - The result string, with the function arguments "blurred"
 */
module.exports = function(
  source /*: string*/,
  functionName /*: string*/
) /*: string*/ {
  const blurChar /*: string*/ =
    arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "`";

  const nameWithParen = `${functionName.toLowerCase()}(`;
  const lowerCaseSource = source.toLowerCase();
  if (!_.includes(lowerCaseSource, nameWithParen)) {
    return source;
  }

  const functionNameLength /*: number*/ = functionName.length;

  let result = source;
  let searchStartIndex = 0;
  while (lowerCaseSource.indexOf(nameWithParen, searchStartIndex) !== -1) {
    const openingParenIndex =
      lowerCaseSource.indexOf(nameWithParen, searchStartIndex) +
      functionNameLength;
    const closingParenIndex =
      balancedMatch("(", ")", lowerCaseSource.slice(openingParenIndex)).end +
      openingParenIndex;
    const argumentsLength = closingParenIndex - openingParenIndex - 1;
    result =
      result.slice(0, openingParenIndex + 1) +
      _.repeat(blurChar, argumentsLength) +
      result.slice(closingParenIndex);
    searchStartIndex = closingParenIndex;
  }
  return result;
};

},{"balanced-match":113,"lodash":692}],1076:[function(require,module,exports){
/* @flow */
"use strict";
module.exports = function(
  source /*: string, optionalblurChar ?: string*/
) /*: string*/ {
  const blurChar /*: string*/ =
    arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : " ";

  return source.replace(/[#@{}]+/g, blurChar);
};

},{}],1077:[function(require,module,exports){
/* @flow */
"use strict";

const normalizeRuleSettings = require("../normalizeRuleSettings");
const Result = require("postcss/lib/result");
const rules = require("../rules");

// Useful for third-party code (e.g. plugins) to run a PostCSS Root
// against a specific rule and do something with the warnings
module.exports = function(
  options /*: {
    ruleName: string,
    ruleSettings: stylelint$configRuleSettings,
    root: Object,
  }*/,
  callback /*: Function*/
) {
  if (!options)
    throw new Error(
      "checkAgainstRule requires an options object with 'ruleName', 'ruleSettings', and 'root' properties"
    );
  if (!callback) throw new Error("checkAgainstRule requires a callback");
  if (!options.ruleName)
    throw new Error("checkAgainstRule requires a 'ruleName' option");
  if (!rules[options.ruleName])
    throw new Error(`Rule '${options.ruleName}' does not exist`);
  if (!options.ruleSettings)
    throw new Error("checkAgainstRule requires a 'ruleSettings' option");
  if (!options.root)
    throw new Error("checkAgainstRule requires a 'root' option");

  const settings = normalizeRuleSettings(
    options.ruleSettings,
    options.ruleName
  );
  if (!settings) {
    return;
  }

  const tmpPostcssResult = new Result();
  rules[options.ruleName](settings[0], settings[1], {})(
    options.root,
    tmpPostcssResult
  );
  tmpPostcssResult.warnings().forEach(callback);
};

},{"../normalizeRuleSettings":886,"../rules":971,"postcss/lib/result":831}],1078:[function(require,module,exports){
/* @flow */
"use strict";

/**
 * Create configurationError from text and set CLI exit code
 */
module.exports = function(text /*: string */) /* Object */ {
  const err /*: Object*/ = new Error(text);
  err.code = 78;
  return err;
};

},{}],1079:[function(require,module,exports){
/* @flow */
"use strict";

/**
 * Checks if a string contains a value. The comparison value can be a string or
 * an array of strings.
 *
 * Any strings starting and ending with `/` are ignored. Use the
 * matchesStringOrRegExp() util to match regexes.
 */
module.exports = function containsString(
  input /*: string*/,
  comparison /*: string | Array<string>*/
) /*: false | { match: string, pattern: string }*/ {
  if (!Array.isArray(comparison)) {
    return testAgainstString(input, comparison);
  }

  for (const comparisonItem of comparison) {
    const testResult = testAgainstString(input, comparisonItem);
    if (testResult) {
      return testResult;
    }
  }
  return false;
};

function testAgainstString(value, comparison) {
  if (!comparison) return false;
  if (comparison[0] === "/" && comparison[comparison.length - 1] === "/") {
    return false;
  }

  if (value.indexOf(comparison) >= 0) {
    return { match: value, pattern: comparison };
  }

  return false;
}

},{}],1080:[function(require,module,exports){
/* @flow */
"use strict";

/**
 * Get the index of a declaration's value
 */
module.exports = function(decl /*: Object*/) /*: number*/ {
  const beforeColon = decl.toString().indexOf(":");
  const afterColon =
    decl.raw("between").length - decl.raw("between").indexOf(":");
  return beforeColon + afterColon;
};

},{}],1081:[function(require,module,exports){
/* @flow */
"use strict";

const getUnitFromValueNode = require("./getUnitFromValueNode");
const isStandardSyntaxValue = require("./isStandardSyntaxValue");
const isVariable = require("./isVariable");
const keywordSets = require("../reference/keywordSets");
const postcssValueParser = require("postcss-value-parser");

/**
 * Get the font-families within a `font` shorthand property value.
 */
module.exports = function findAnimationName(
  value /*: string*/
) /*: Array<Object>*/ {
  const animationNames = [];

  const valueNodes = postcssValueParser(value);

  // Handle `inherit`, `initial` and etc
  if (
    valueNodes.nodes.length === 1 &&
    keywordSets.basicKeywords.has(valueNodes.nodes[0].value.toLowerCase())
  ) {
    return [valueNodes.nodes[0]];
  }

  valueNodes.walk(valueNode => {
    if (valueNode.type === "function") {
      return false;
    }
    if (valueNode.type !== "word") {
      return;
    }

    const valueLowerCase = valueNode.value.toLowerCase();

    // Ignore non standard syntax
    if (!isStandardSyntaxValue(valueLowerCase)) {
      return;
    }
    // Ignore variables
    if (isVariable(valueLowerCase)) {
      return;
    }
    // Ignore keywords for other font parts
    if (keywordSets.animationShorthandKeywords.has(valueLowerCase)) {
      return;
    }
    // Ignore numbers with units
    const unit = getUnitFromValueNode(valueNode);
    if (unit || unit === "") {
      return;
    }

    animationNames.push(valueNode);
  });

  return animationNames;
};

},{"../reference/keywordSets":888,"./getUnitFromValueNode":1091,"./isStandardSyntaxValue":1129,"./isVariable":1132,"postcss-value-parser":811}],1082:[function(require,module,exports){
/* @flow */
"use strict";

/**
 * Find the at-rule in which a rule is nested.
 *
 * Returns `null` if the rule is not nested within an at-rule.
 */
module.exports = function findAtRuleContext(
  rule /*: postcss$rule */
) /*: ?postcss$node*/ {
  const parent = rule.parent;

  if (parent.type === "root") {
    return null;
  }
  if (parent.type === "atrule") {
    return parent;
  }
  return findAtRuleContext(parent);
};

},{}],1083:[function(require,module,exports){
/* @flow */
"use strict";

const isNumbery = require("./isNumbery");
const isStandardSyntaxValue = require("./isStandardSyntaxValue");
const isValidFontSize = require("./isValidFontSize");
const isVariable = require("./isVariable");
const keywordSets = require("../reference/keywordSets");
const postcssValueParser = require("postcss-value-parser");

const nodeTypesToCheck = new Set(["word", "string", "space", "div"]);

function joinValueNodes(firstNode, secondNode, charactersBetween) {
  firstNode.value = firstNode.value + charactersBetween + secondNode.value;

  return firstNode;
}

/**
 * Get the font-families within a `font` shorthand property value.
 *
 * @param {string} value
 * @return {object} Collection font-family nodes
 */
module.exports = function findFontFamily(
  value /*: string*/
) /*: Array<Object>*/ {
  const fontFamilies = [];

  const valueNodes = postcssValueParser(value);

  // Handle `inherit`, `initial` and etc
  if (
    valueNodes.nodes.length === 1 &&
    keywordSets.basicKeywords.has(valueNodes.nodes[0].value.toLowerCase())
  ) {
    return [valueNodes.nodes[0]];
  }

  let needMergeNodesByValue = false;
  let mergeCharacters = null;

  valueNodes.walk((valueNode, index, nodes) => {
    if (valueNode.type === "function") {
      return false;
    }
    if (!nodeTypesToCheck.has(valueNode.type)) {
      return;
    }

    const valueLowerCase = valueNode.value.toLowerCase();

    // Ignore non standard syntax
    if (!isStandardSyntaxValue(valueLowerCase)) {
      return;
    }

    // Ignore variables
    if (isVariable(valueLowerCase)) {
      return;
    }

    // Ignore keywords for other font parts
    if (
      keywordSets.fontShorthandKeywords.has(valueLowerCase) &&
      !keywordSets.fontFamilyKeywords.has(valueLowerCase)
    ) {
      return;
    }

    // Ignore font-sizes
    if (isValidFontSize(valueNode.value)) {
      return;
    }

    // Ignore anything come after a <font-size>/, because it's a line-height
    if (
      nodes[index - 1] &&
      nodes[index - 1].value === "/" &&
      nodes[index - 2] &&
      isValidFontSize(nodes[index - 2].value)
    ) {
      return;
    }

    // Ignore number values
    if (isNumbery(valueLowerCase)) {
      return;
    }

    // Detect when a space or comma is dividing a list of font-families, and save the joining character.
    if (
      (valueNode.type === "space" ||
        (valueNode.type === "div" && valueNode.value !== ",")) &&
      fontFamilies.length !== 0
    ) {
      needMergeNodesByValue = true;
      mergeCharacters = valueNode.value;
      return;
    } else if (valueNode.type === "space" || valueNode.type === "div") {
      return;
    }

    const fontFamily = valueNode;

    if (needMergeNodesByValue) {
      joinValueNodes(
        fontFamilies[fontFamilies.length - 1],
        valueNode,
        mergeCharacters
      );
      needMergeNodesByValue = false;
      mergeCharacters = null;
    } else {
      fontFamilies.push(fontFamily);
    }
  });

  return fontFamilies;
};

},{"../reference/keywordSets":888,"./isNumbery":1115,"./isStandardSyntaxValue":1129,"./isValidFontSize":1130,"./isVariable":1132,"postcss-value-parser":811}],1084:[function(require,module,exports){
/* @flow */
"use strict";

const balancedMatch = require("balanced-match");
const styleSearch = require("style-search");

/**
 * Search a CSS string for functions by name.
 * For every match, invoke the callback, passing the function's
 * "argument(s) string" (whatever is inside the parentheses)
 * as an argument.
 *
 * Callback will be called once for every matching function found,
 * with the function's "argument(s) string" and its starting index
 * as the arguments.
 */
module.exports = function(
  source /*: string*/,
  functionName /*: string*/,
  callback /*: Function*/
) {
  styleSearch(
    {
      source,
      target: functionName,
      functionNames: "check"
    },
    match => {
      if (source[match.endIndex] !== "(") {
        return;
      }
      const parensMatch = balancedMatch(
        "(",
        ")",
        source.substr(match.startIndex)
      );
      callback(parensMatch.body, match.endIndex + 1);
    }
  );
};

},{"balanced-match":113,"style-search":870}],1085:[function(require,module,exports){
"use strict";

const fs = require("fs");
const hash = require("./hash");
const path = require("path");
/**
 * Return the cacheFile to be used by stylelint, based on whether the provided parameter is
 * a directory or looks like a directory (ends in `path.sep`), in which case the file
 * name will be `cacheFile/.cache_hashOfCWD`.
 *
 * If cacheFile points to a file or looks like a file, then it will just use that file.
 *
 * @param {string} cacheFile - The name of file to be used to store the cache
 * @param {string} cwd - Current working directory. Used for tests
 * @returns {string} Resolved path to the cache file
 */
module.exports = function getCacheFile(cacheFile, cwd) {
  /*
   * Make sure path separators are normalized for environment/os.
   * Also, keep trailing path separator if present.
   */
  cacheFile = path.normalize(cacheFile);

  const resolvedCacheFile = path.resolve(cwd, cacheFile);
  // If the last character passed is a path separator, we assume is a directory.
  const looksLikeADirectory = cacheFile[cacheFile.length - 1] === path.sep;

  /**
   * Return the default cache file name when provided parameter is a directory.
   * @returns {string} - Resolved path to the cacheFile
   */
  function getCacheFileForDirectory() {
    return path.join(resolvedCacheFile, `.stylelintcache_${hash(cwd)}`);
  }

  let fileStats;

  try {
    fileStats = fs.lstatSync(resolvedCacheFile);
  } catch (ex) {
    fileStats = null;
  }

  if (looksLikeADirectory || (fileStats && fileStats.isDirectory())) {
    // Return path to provided directory with generated file name.
    return getCacheFileForDirectory();
  }

  // Return normalized path to cache file.
  return resolvedCacheFile;
};

},{"./hash":1099,"fs":1,"path":14}],1086:[function(require,module,exports){
(function (process){
/* @flow */
"use strict";

const configurationError = require("./configurationError");
const resolveFrom = require("resolve-from");

module.exports = function(
  basedir /*: string*/,
  lookup /*: string*/
) /*: string*/ {
  // First try to resolve from the provided directory,
  // then try to resolve from process.cwd.
  let path = resolveFrom.silent(basedir, lookup);
  if (!path) {
    path = resolveFrom.silent(process.cwd(), lookup);
  }
  if (!path) {
    throw configurationError(
      `Could not find "${lookup}". Do you need a \`configBasedir\`?`
    );
  }
  return path;
};

}).call(this,require('_process'))
},{"./configurationError":1078,"_process":16,"resolve-from":851}],1087:[function(require,module,exports){
/* @flow */
"use strict";

const _ = require("lodash");

function getNodeLine(node /*:: ?: postcss$node*/) /*: number | void*/ {
  return _.get(node, "source.start.line");
}

module.exports = function getNextNonSharedLineCommentNode(
  node /*:: ?: postcss$node*/
) /*: postcss$node | void*/ {
  if (node === undefined) {
    return undefined;
  }

  const nextNode = node.next();

  if (_.get(nextNode, "type") !== "comment") {
    return nextNode;
  }

  if (
    getNodeLine(node) === getNodeLine(nextNode) ||
    (nextNode !== undefined &&
      getNodeLine(nextNode) === getNodeLine(nextNode.next()))
  ) {
    return getNextNonSharedLineCommentNode(nextNode);
  }

  return nextNode;
};

},{"lodash":692}],1088:[function(require,module,exports){
/* @flow */
"use strict";

const os = require("os");

// This function simply provides roundabout way of getting os.EOL
// so we can mock this for Jest tests
function getOsEl() /*: string*/ {
  return os.EOL;
}

module.exports = getOsEl;

},{"os":13}],1089:[function(require,module,exports){
/* @flow */
"use strict";

const _ = require("lodash");

function getNodeLine(node /*:: ?: postcss$node*/) /*: number | void*/ {
  return _.get(node, "source.start.line");
}

module.exports = function getPreviousNonSharedLineCommentNode(
  node /*:: ?: postcss$node*/
) /*: postcss$node | void*/ {
  if (node === undefined) {
    return undefined;
  }

  const previousNode = node.prev();

  if (_.get(previousNode, "type") !== "comment") {
    return previousNode;
  }

  if (
    getNodeLine(node) === getNodeLine(previousNode) ||
    (previousNode !== undefined &&
      getNodeLine(previousNode) === getNodeLine(previousNode.prev()))
  ) {
    return getPreviousNonSharedLineCommentNode(previousNode);
  }

  return previousNode;
};

},{"lodash":692}],1090:[function(require,module,exports){
/* @flow */
"use strict";

const parse = require("url").parse;

/**
 * Get unit from value node
 *
 * Returns `null` if the unit is not found.
 */
module.exports = function(urlString /*: string*/) /*: ?string*/ {
  const url = parse(urlString);
  const protocol = url.protocol;
  if (protocol === null || typeof protocol === "undefined") {
    return null;
  }

  const scheme = protocol.slice(0, -1); // strip trailing `:`

  // The URL spec does not require a scheme to be followed by `//`, but checking
  // for it allows this rule to differentiate <scheme>:<hostname> urls from
  // <hostname>:<port> urls. `data:` scheme urls are an exception to this rule.
  const slashIndex = protocol.length;
  const expectedSlashes = urlString.slice(slashIndex, slashIndex + 2);
  const isSchemeLessUrl = expectedSlashes !== "//" && scheme !== "data";

  if (isSchemeLessUrl) {
    return null;
  }

  return scheme;
};

},{"url":37}],1091:[function(require,module,exports){
/* @flow */
"use strict";

const _ = require("lodash");
const blurInterpolation = require("./blurInterpolation");
const isStandardSyntaxValue = require("./isStandardSyntaxValue");
const valueParser = require("postcss-value-parser");

/**
 * Get unit from value node
 *
 * Returns `null` if the unit is not found.
 */
module.exports = function(node /*: Object*/) /*: ?string*/ {
  if (!node || (node && !node.value)) {
    return null;
  }

  const value = blurInterpolation(node.value, "")
    // ignore hack unit
    .replace("\\0", "")
    .replace("\\9", "")
    // ignore decimal place
    .replace(".", "");

  if (
    node.type !== "word" ||
    !isStandardSyntaxValue(value) ||
    !_.isFinite(parseInt(value)) ||
    node.value[0] === "#"
  ) {
    return null;
  }

  const parsedUnit = valueParser.unit(value);

  if (!parsedUnit) {
    return null;
  }

  return parsedUnit.unit;
};

},{"./blurInterpolation":1076,"./isStandardSyntaxValue":1129,"lodash":692,"postcss-value-parser":811}],1092:[function(require,module,exports){
/* @flow */
"use strict";

/**
 * Check if a statement has an block (empty or otherwise).
 *
 * @param {Rule|AtRule} statement - postcss rule or at-rule node
 * @return {boolean} True if `statement` has a block (empty or otherwise)
 */
module.exports = function(statement /*: postcss$node*/) /*: boolean*/ {
  return statement.nodes !== undefined;
};

},{}],1093:[function(require,module,exports){
/* @flow */
"use strict";

/**
 * Check if a statement has an empty block.
 *
 * @param {Rule|AtRule} statement - postcss rule or at-rule node
 * @return {boolean} True if the statement has a block and it is empty
 */
module.exports = function(
  statement /*: postcss$rule | postcss$atRule*/
) /*: boolean*/ {
  return (
    statement.nodes !== undefined && statement.nodes.length === 0 // has block
  ); // and is empty
};

},{}],1094:[function(require,module,exports){
/* @flow */
"use strict";

/**
 * Check if a string contains at least one empty line
 */
module.exports = function(string /*:: ?: string*/) /*: boolean*/ {
  if (string === "" || string === undefined) return false;

  return /\n[\r\t ]*\n/.test(string);
};

},{}],1095:[function(require,module,exports){
/* @flow */
"use strict";

const hasLessInterpolation = require("../utils/hasLessInterpolation");
const hasPsvInterpolation = require("../utils/hasPsvInterpolation");
const hasScssInterpolation = require("../utils/hasScssInterpolation");
/**
 * Check whether a string has interpolation
 *
 * @param {string} string
 * @return {boolean} If `true`, a string has interpolation
 */
module.exports = function(string /*: string*/) /*: boolean*/ {
  // SCSS or Less interpolation
  if (
    hasLessInterpolation(string) ||
    hasScssInterpolation(string) ||
    hasPsvInterpolation(string)
  ) {
    return true;
  }

  return false;
};

},{"../utils/hasLessInterpolation":1096,"../utils/hasPsvInterpolation":1097,"../utils/hasScssInterpolation":1098}],1096:[function(require,module,exports){
/* @flow */
"use strict";

/**
 * Check whether a string has less interpolation
 *
 * @param {string} string
 * @return {boolean} If `true`, a string has less interpolation
 */
module.exports = function(string /*: string*/) /*: boolean*/ {
  if (/@{.+?}/.test(string)) {
    return true;
  }

  return false;
};

},{}],1097:[function(require,module,exports){
/* @flow */
"use strict";

/**
 * Check whether a string has postcss-simple-vars interpolation
 */
module.exports = function(string /*: string*/) /*: boolean*/ {
  if (/\$\(.+?\)/.test(string)) {
    return true;
  }

  return false;
};

},{}],1098:[function(require,module,exports){
/* @flow */
"use strict";

/**
 * Check whether a string has scss interpolation
 */
module.exports = function(string /*: string*/) /*: boolean*/ {
  if (/#{.+?}/.test(string)) {
    return true;
  }

  return false;
};

},{}],1099:[function(require,module,exports){
"use strict";
const murmur = require("imurmurhash");

/**
 * hash the given string
 * @param  {string} str the string to hash
 * @returns {string}    the hash
 */
module.exports = function hash(str) {
  return murmur(str).result().toString(36);
};

},{"imurmurhash":635}],1100:[function(require,module,exports){
/* @flow */
"use strict";

const isSharedLineComment = require("./isSharedLineComment");

module.exports = function(node /*: postcss$node*/) /*: boolean*/ {
  const previousNode = node.prev();

  if (!previousNode || previousNode.type !== "comment") {
    return false;
  }

  return !isSharedLineComment(previousNode);
};

},{"./isSharedLineComment":1118}],1101:[function(require,module,exports){
/* @flow */
"use strict";

const _ = require("lodash");
const getPreviousNonSharedLineCommentNode = require("./getPreviousNonSharedLineCommentNode");
const isCustomProperty = require("./isCustomProperty");
const isStandardSyntaxDeclaration = require("./isStandardSyntaxDeclaration");

module.exports = function(node /*: postcss$node*/) /*: boolean*/ {
  const prevNode = getPreviousNonSharedLineCommentNode(node);

  return (
    prevNode !== undefined &&
    prevNode.type === "decl" &&
    isStandardSyntaxDeclaration(prevNode) &&
    !isCustomProperty(_.get(prevNode, "prop", ""))
  );
};

},{"./getPreviousNonSharedLineCommentNode":1089,"./isCustomProperty":1109,"./isStandardSyntaxDeclaration":1121,"lodash":692}],1102:[function(require,module,exports){
/* @flow */
"use strict";

const autoprefixer = require("autoprefixer");
const Browsers = require("autoprefixer/lib/browsers");
const Prefixes = require("autoprefixer/lib/prefixes");

/**
 * Use Autoprefixer's secret powers to determine whether or
 * not a certain CSS identifier contains a vendor prefix that
 * Autoprefixer, given the standardized identifier, could add itself.
 *
 * Used by `*-no-vendor-prefix-*` rules to find superfluous
 * vendor prefixes.
 */

const prefixes = new Prefixes(
  autoprefixer.data.prefixes,
  new Browsers(autoprefixer.data.browsers, [])
);

/**
 * Most identifier types have to be looked up in a unique way,
 * so we're exposing special functions for each.
 */
module.exports = {
  atRuleName(identifier /*: string*/) /*: boolean*/ {
    return prefixes.remove[`@${identifier.toLowerCase()}`];
  },

  selector(identifier /*: string*/) /*: boolean*/ {
    return prefixes.remove.selectors.some(selectorObj => {
      return identifier.toLowerCase() === selectorObj.prefixed;
    });
  },

  mediaFeatureName(identifier /*: string*/) /*: boolean*/ {
    return identifier.toLowerCase().indexOf("device-pixel-ratio") !== -1;
  },

  property(identifier /*: string*/) /*: boolean*/ {
    return autoprefixer.data.prefixes[
      prefixes.unprefixed(identifier.toLowerCase())
    ];
  },

  propertyValue(prop /*: string*/, value /*: string*/) /*: boolean*/ {
    const possiblePrefixableValues =
      prefixes.remove[prop.toLowerCase()] &&
      prefixes.remove[prop.toLowerCase()].values;
    return (
      possiblePrefixableValues &&
      possiblePrefixableValues.some(valueObj => {
        return value.toLowerCase() === valueObj.prefixed;
      })
    );
  }
};

},{"autoprefixer":54,"autoprefixer/lib/browsers":56,"autoprefixer/lib/prefixes":105}],1103:[function(require,module,exports){
/* @flow */
"use strict";

const getPreviousNonSharedLineCommentNode = require("./getPreviousNonSharedLineCommentNode");
const hasBlock = require("./hasBlock");

module.exports = function(atRule /*: postcss$atRule*/) /*: boolean*/ {
  if (atRule.type !== "atrule") {
    return false;
  }

  const previousNode = getPreviousNonSharedLineCommentNode(atRule);
  if (previousNode === undefined) {
    return false;
  }

  return (
    previousNode.type === "atrule" &&
    !hasBlock(previousNode) &&
    !hasBlock(atRule)
  );
};

},{"./getPreviousNonSharedLineCommentNode":1089,"./hasBlock":1092}],1104:[function(require,module,exports){
/* @flow */
"use strict";

const _ = require("lodash");
const getPreviousNonSharedLineCommentNode = require("./getPreviousNonSharedLineCommentNode");
const isBlocklessAtRuleAfterBlocklessAtRule = require("./isBlocklessAtRuleAfterBlocklessAtRule");

module.exports = function(atRule /*: postcss$atRule*/) /*: boolean*/ {
  if (!isBlocklessAtRuleAfterBlocklessAtRule(atRule)) {
    return false;
  }

  const previousNode = getPreviousNonSharedLineCommentNode(atRule);

  return _.get(previousNode, "name") === atRule.name;
};

},{"./getPreviousNonSharedLineCommentNode":1089,"./isBlocklessAtRuleAfterBlocklessAtRule":1103,"lodash":692}],1105:[function(require,module,exports){
/* @flow */
"use strict";

const _ = require("lodash");
const keywordSets = require("../reference/keywordSets");

/**
 * Check value is a custom ident
 */

module.exports = function(value /*: string*/) /*: boolean*/ {
  const valueLowerCase = value.toLowerCase();

  if (
    keywordSets.counterIncrementKeywords.has(valueLowerCase) ||
    _.isFinite(parseInt(valueLowerCase))
  ) {
    return false;
  }

  return true;
};

},{"../reference/keywordSets":888,"lodash":692}],1106:[function(require,module,exports){
/* @flow */
"use strict";

const _ = require("lodash");
const keywordSets = require("../reference/keywordSets");

/**
 * Check value is a custom ident
 */

module.exports = function(value /*: string*/) /*: boolean*/ {
  const valueLowerCase = value.toLowerCase();

  if (
    keywordSets.counterResetKeywords.has(valueLowerCase) ||
    _.isFinite(parseInt(valueLowerCase))
  ) {
    return false;
  }

  return true;
};

},{"../reference/keywordSets":888,"lodash":692}],1107:[function(require,module,exports){
/* @flow */
"use strict";

const htmlTags = require("html-tags");
const keywordSets = require("../reference/keywordSets");
const mathMLTags = require("mathml-tag-names");
const svgTags = require("svg-tags");

/**
 * Check whether a type selector is a custom element
 */
module.exports = function(selector /*: string*/) /*: boolean*/ {
  if (!/^[a-z]/.test(selector)) {
    return false;
  }

  if (selector.indexOf("-") === -1) {
    return false;
  }

  const selectorLowerCase = selector.toLowerCase();

  if (selectorLowerCase !== selector) {
    return false;
  }
  if (svgTags.indexOf(selectorLowerCase) !== -1) {
    return false;
  }
  if (htmlTags.indexOf(selectorLowerCase) !== -1) {
    return false;
  }
  if (keywordSets.nonStandardHtmlTags.has(selectorLowerCase)) {
    return false;
  }
  if (mathMLTags.indexOf(selectorLowerCase) !== -1) {
    return false;
  }

  return true;
};

},{"../reference/keywordSets":888,"html-tags":633,"mathml-tag-names":697,"svg-tags":1156}],1108:[function(require,module,exports){
/* @flow */
"use strict";

/**
 * Check whether a media query is a custom
 */
module.exports = function(mediaQuery /*: string*/) /*: boolean*/ {
  return mediaQuery.slice(0, 2) === "--";
};

},{}],1109:[function(require,module,exports){
/* @flow */
"use strict";

/**
 * Check whether a property is a custom one
 */
module.exports = function(property /*: string*/) /*: boolean*/ {
  return property.slice(0, 2) === "--";
};

},{}],1110:[function(require,module,exports){
/* @flow */
"use strict";

const _ = require("lodash");
const hasBlock = require("../utils/hasBlock");

/**
 * Check whether a Node is a custom property set
 */
module.exports = function(node /*: Object*/) /*: boolean*/ {
  const selector = _.get(node, "raws.selector.raw", node.selector);

  return (
    node.type === "rule" &&
    hasBlock(node) &&
    selector.slice(0, 2) === "--" &&
    selector.slice(-1) === ":"
  );
};

},{"../utils/hasBlock":1092,"lodash":692}],1111:[function(require,module,exports){
/* @flow */
"use strict";

/**
 * Check whether a selector is a custom one
 */
module.exports = function(selector /*: string*/) /*: boolean*/ {
  return selector.slice(0, 3) === ":--";
};

},{}],1112:[function(require,module,exports){
/* @flow */
"use strict";

module.exports = function(statement /*: postcss$node*/) /*: boolean*/ {
  const parentNode = statement.parent;

  return (
    parentNode !== undefined &&
    parentNode.type !== "root" &&
    statement === parentNode.first
  );
};

},{}],1113:[function(require,module,exports){
/* @flow */
"use strict";

/**
 * Check if a rule is a keyframe one
 */
module.exports = function(rule /*: postcss$rule*/) /*: boolean*/ {
  const parent = rule.parent;

  return parent.type === "atrule" && parent.name.toLowerCase() === "keyframes";
};

},{}],1114:[function(require,module,exports){
/* @flow */
"use strict";

const keywordSets = require("../reference/keywordSets");

/**
 * Check whether a string is a keyframe selector.
 */
module.exports = function(selector /*: string*/) /*: boolean*/ {
  if (keywordSets.keyframeSelectorKeywords.has(selector)) {
    return true;
  }

  // Percentages
  if (/^(?:\d+\.?\d*|\d*\.?\d+)%$/.test(selector)) {
    return true;
  }

  return false;
};

},{"../reference/keywordSets":888}],1115:[function(require,module,exports){
// Too weird for Flow
"use strict";

/**
 * Check whether it's a number or a number-like string:
 * i.e. when coerced to a number it == itself.
 */
module.exports = function(value) {
  /* eslint-disable eqeqeq */
  return value.trim().length !== 0 && Number(value) == value;
  /* eslint-enable eqeqeq */
};

},{}],1116:[function(require,module,exports){
/* @flow */
"use strict";

const isWhitespace = require("./isWhitespace");

/**
 * Returns a Boolean indicating whether the the input string is only whitespace.
 */
module.exports = function(input /*: string*/) /*: boolean*/ {
  let isOnlyWhitespace = true;
  for (let i = 0, l = input.length; i < l; i++) {
    if (!isWhitespace(input[i])) {
      isOnlyWhitespace = false;
      break;
    }
  }
  return isOnlyWhitespace;
};

},{"./isWhitespace":1133}],1117:[function(require,module,exports){
/* @flow */
"use strict";

/**
 * Check whether a media feature is a range context one
 *
 * @param {string} media feature
 * @return {boolean} If `true`, media feature is a range context one
 */
module.exports = function(mediaFeature /*: string*/) /*: boolean*/ {
  return (
    mediaFeature.indexOf("=") !== -1 ||
    mediaFeature.indexOf("<") !== -1 ||
    mediaFeature.indexOf(">") !== -1
  );
};

},{}],1118:[function(require,module,exports){
/* @flow */
"use strict";

const _ = require("lodash");
const getNextNonSharedLineCommentNode = require("./getNextNonSharedLineCommentNode");
const getPreviousNonSharedLineCommentNode = require("./getPreviousNonSharedLineCommentNode");

function nodesShareLines(a, b) {
  return _.get(a, "source.start.line") === _.get(b, "source.start.line");
}

module.exports = function isSharedLineComment(
  node /*: postcss$node*/
) /*: boolean*/ {
  if (node.type !== "comment") {
    return false;
  }

  const previousNonSharedLineCommentNode = getPreviousNonSharedLineCommentNode(
    node
  );
  if (nodesShareLines(node, previousNonSharedLineCommentNode)) {
    return true;
  }

  const nextNonSharedLineCommentNode = getNextNonSharedLineCommentNode(node);
  if (nodesShareLines(node, nextNonSharedLineCommentNode)) {
    return true;
  }

  const parentNode = node.parent;
  if (
    parentNode !== undefined &&
    parentNode.type !== "root" &&
    parentNode.source.start.line === node.source.start.line
  ) {
    return true;
  }

  return false;
};

},{"./getNextNonSharedLineCommentNode":1087,"./getPreviousNonSharedLineCommentNode":1089,"lodash":692}],1119:[function(require,module,exports){
/* @flow */
"use strict";

/**
 * Check if a string is a single line (i.e. does not contain
 * any newline characters).
 *
 * @param {string} input
 * @return {boolean}
 */
module.exports = function(input /*: string*/) /*: boolean*/ {
  return !/[\n\r]/.test(input);
};

},{}],1120:[function(require,module,exports){
/* @flow */
"use strict";

/**
 * Check whether a at-rule is standard
 *
 * @param {atRule} postcss at-rule node
 * @return {boolean} If `true`, the declaration is standard
 */
module.exports = function(atRule /*: postcss$atRule*/) /*: boolean*/ {
  // Ignore scss `@content` inside mixins
  if (!atRule.nodes && atRule.params === "") {
    return false;
  }

  // Ignore detached ruleset `@detached-ruleset: { background: red; }; .top { @detached-ruleset(); }`
  if (
    !atRule.nodes &&
    atRule.raws.afterName === "" &&
    atRule.params[0] === "("
  ) {
    return false;
  }

  return true;
};

},{}],1121:[function(require,module,exports){
/* @flow */
"use strict";

/**
 * Check whether a declaration is standard
 */
module.exports = function(decl /*: Object*/) /*: boolean*/ {
  const prop = decl.prop,
    parent = decl.parent;

  // Declarations belong in a declaration block

  if (parent.type === "root") {
    return false;
  }

  // SCSS var (e.g. $var: x), nested list (e.g. $list: (x)) or nested map (e.g. $map: (key:value))
  if (prop[0] === "$") {
    return false;
  }

  // Less var (e.g. @var: x), but exclude variable interpolation (e.g. @{var})
  if (prop[0] === "@" && prop[1] !== "{") {
    return false;
  }

  // SCSS nested properties (e.g. border: { style: solid; color: red; })
  if (
    parent.selector &&
    parent.selector[parent.selector.length - 1] === ":" &&
    parent.selector.substring(0, 2) !== "--"
  ) {
    return false;
  }

  return true;
};

},{}],1122:[function(require,module,exports){
/* @flow */
"use strict";

/**
 * Check whether a function is standard
 */
module.exports = function(node /*: Object*/) /*: boolean*/ {
  // Function nodes without names are things in parentheses like Sass lists
  if (!node.value) {
    return false;
  }

  return true;
};

},{}],1123:[function(require,module,exports){
/* @flow */
"use strict";

/**
 * Check whether a media feature name is standard
 */
module.exports = function(mediaFeatureName /*: string*/) /*: boolean*/ {
  // SCSS interpolation
  if (/#{.+?}|\$.+?/.test(mediaFeatureName)) {
    return false;
  }

  return true;
};

},{}],1124:[function(require,module,exports){
/* @flow */
"use strict";

const _ = require("lodash");
const hasInterpolation = require("../utils/hasInterpolation");
/**
 * Check whether a property is standard
 */
module.exports = function(property /*: string*/) /*: boolean*/ {
  // SCSS var (e.g. $var: x), list (e.g. $list: (x)) or map (e.g. $map: (key:value))
  if (property[0] === "$") {
    return false;
  }

  // Less var (e.g. @var: x)
  if (property[0] === "@") {
    return false;
  }

  // Less append property value with space (e.g. transform+_: scale(2))
  if (_.endsWith(property, "+") || _.endsWith(property, "+_")) {
    return false;
  }

  // SCSS or Less interpolation
  if (hasInterpolation(property)) {
    return false;
  }

  return true;
};

},{"../utils/hasInterpolation":1095,"lodash":692}],1125:[function(require,module,exports){
/* @flow */
"use strict";

const _ = require("lodash");
const isCustomPropertySet = require("../utils/isCustomPropertySet");

/**
 * Check whether a Node is a standard rule
 */
module.exports = function(rule /*: Object*/) /*: boolean*/ {
  // Get full selector
  const selector = _.get(rule, "raws.selector.raw", rule.selector);

  // Custom property set (e.g. --custom-property-set: {})
  if (isCustomPropertySet(rule)) {
    return false;
  }

  // Called Less mixin (e.g. a { .mixin() })
  if (rule.mixin) {
    return false;
  }

  // Less detached rulesets
  if (selector.slice(0, 1) === "@" && selector.slice(-1) === ":") {
    return false;
  }

  // Ignore Less &:extend rule
  if (rule.extend) {
    return false;
  }

  // Ignore mixin or &:extend rule
  // https://github.com/shellscape/postcss-less/blob/master/lib/less-parser.js#L52
  if (rule.params && rule.params[0]) {
    return false;
  }

  // Non-outputting Less mixin definition (e.g. .mixin() {})
  if (_.endsWith(selector, ")") && !_.includes(selector, ":")) {
    return false;
  }

  // Less guards
  if (/when\s+(not\s+)*\(/.test(selector)) {
    return false;
  }

  // Ignore Scss nested properties
  if (selector.slice(-1) === ":") {
    return false;
  }

  return true;
};

},{"../utils/isCustomPropertySet":1110,"lodash":692}],1126:[function(require,module,exports){
/* @flow */
"use strict";

const hasInterpolation = require("../utils/hasInterpolation");
/**
 * Check whether a selector is standard
 */
module.exports = function(selector /*: string*/) /*: boolean*/ {
  // SCSS or Less interpolation
  if (hasInterpolation(selector)) {
    return false;
  }

  // SCSS placeholder selectors
  if (selector.indexOf("%") === 0) {
    return false;
  }

  // Less :extend()
  if (/:extend(\(.*?\))?/.test(selector)) {
    return false;
  }

  return true;
};

},{"../utils/hasInterpolation":1095}],1127:[function(require,module,exports){
/* @flow */
"use strict";

/**
 * Check whether a type selector is standard
 *
 * @param {Node} postcss-selector-parser node (of type tag)
 * @return {boolean} If `true`, the type selector is standard
 */

const _ = require("lodash");
const keywordSets = require("../reference/keywordSets");

module.exports = function(node /*: Object*/) /*: boolean*/ {
  // postcss-selector-parser includes the arguments to nth-child() functions
  // as "tags", so we need to ignore them ourselves.
  // The fake-tag's "parent" is actually a selector node, whose parent
  // should be the :nth-child pseudo node.
  const _node$parent$parent = node.parent.parent;
  const parentType = _node$parent$parent.type,
    parentValue = _node$parent$parent.value;

  if (parentValue) {
    const normalisedParentName = parentValue.toLowerCase().replace(/:+/, "");
    if (
      parentType === "pseudo" &&
      (keywordSets.aNPlusBNotationPseudoClasses.has(normalisedParentName) ||
        keywordSets.linguisticPseudoClasses.has(normalisedParentName))
    ) {
      return false;
    }
  }

  // &-bar is a nesting selector combined with a suffix
  if (node.prev() && node.prev().type === "nesting") {
    return false;
  }

  if (node.value[0] === "%") {
    return false;
  }

  // Reference combinators like `/deep/`
  if (_.startsWith(node.value, "/") && _.endsWith(node.value, "/")) {
    return false;
  }

  return true;
};

},{"../reference/keywordSets":888,"lodash":692}],1128:[function(require,module,exports){
/* @flow */
"use strict";

const hasLessInterpolation = require("../utils/hasLessInterpolation");
const hasPsvInterpolation = require("../utils/hasPsvInterpolation");
const hasScssInterpolation = require("../utils/hasScssInterpolation");

/**
 * Check whether a URL is standard
 */
module.exports = function(url /*: string*/) /*: boolean*/ {
  if (url.length === 0) {
    return true;
  }

  // Sass interpolation works anywhere
  if (hasScssInterpolation(url) || hasPsvInterpolation(url)) {
    return false;
  }

  // Inside `'` and `"` work only LESS interpolation
  if (
    (url[0] === "'" && url[url.length - 1] === "'") ||
    (url[0] === '"' && url[url.length - 1] === '"')
  ) {
    if (hasLessInterpolation(url)) {
      return false;
    }

    return true;
  }

  // Less variable works only at the beginning
  // Check is less variable, allow use '@url/some/path'
  // https://github.com/less/less.js/blob/3.x/lib/less/parser/parser.js#L547
  if (url[0] === "@" && /^@@?[\w-]+$/.test(url)) {
    return false;
  }

  // In url without quotes scss variable can be everywhere
  // But in this case it is allowed to use only specific characters
  // Also forbidden "/" at the end of url
  if (
    url.indexOf("$") !== -1 &&
    /^[$\sA-Za-z0-9+-/*_'"/]+$/.test(url) &&
    url[url.length - 1] !== "/"
  ) {
    return false;
  }

  return true;
};

},{"../utils/hasLessInterpolation":1096,"../utils/hasPsvInterpolation":1097,"../utils/hasScssInterpolation":1098}],1129:[function(require,module,exports){
/* @flow */
"use strict";

const hasInterpolation = require("../utils/hasInterpolation");
/**
 * Check whether a value is standard
 */
module.exports = function(value /*: string*/) /*: boolean*/ {
  let normalizedValue = value;

  // Ignore operators before variables (example -$variable)
  if (/^[-+*/]/.test(value[0])) {
    normalizedValue = normalizedValue.slice(1);
  }

  // SCSS variable
  if (normalizedValue[0] === "$") {
    return false;
  }

  // Less variable
  if (normalizedValue[0] === "@") {
    return false;
  }

  // SCSS or Less interpolation
  if (hasInterpolation(normalizedValue)) {
    return false;
  }

  return true;
};

},{"../utils/hasInterpolation":1095}],1130:[function(require,module,exports){
/* @flow */
"use strict";

const keywordSets = require("../reference/keywordSets");
const valueParser = require("postcss-value-parser");

/**
 * Check if a word is a font-size value.
 */
module.exports = function(word /*: string*/) /*: boolean*/ {
  if (!word) {
    return false;
  }

  if (keywordSets.fontSizeKeywords.has(word)) {
    return true;
  }

  const numberUnit = valueParser.unit(word);
  if (!numberUnit) {
    return false;
  }

  const unit = numberUnit.unit;

  if (unit === "%") {
    return true;
  }
  if (keywordSets.lengthUnits.has(unit.toLowerCase())) {
    return true;
  }

  return false;
};

},{"../reference/keywordSets":888,"postcss-value-parser":811}],1131:[function(require,module,exports){
/* @flow */
"use strict";

/**
 * Check if a value is a valid 3, 4, 6 or 8 digit hex
 */
module.exports = function(value /*: string*/) /*: boolean*/ {
  return /^#(?:[0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/.test(value);
};

},{}],1132:[function(require,module,exports){
/* @flow */
"use strict";

/**
 * Check whether a word is a variable i.e var(--custom-property).
 */
module.exports = function(word /*: string*/) /*: boolean*/ {
  return word.toLowerCase().slice(0, 4) === "var(";
};

},{}],1133:[function(require,module,exports){
/* @flow */
"use strict";

/**
 * Check if a character is whitespace.
 */
module.exports = function(char /*: string*/) /*: boolean*/ {
  return [" ", "\n", "\t", "\r", "\f"].indexOf(char) !== -1;
};

},{}],1134:[function(require,module,exports){
/* @flow */
"use strict";

/**
 * Compares a string to a second value that, if it fits a certain convention,
 * is converted to a regular expression before the comparison.
 * If it doesn't fit the convention, then two strings are compared.
 *
 * Any strings starting and ending with `/` are interpreted
 * as regular expressions.
 */
module.exports = function matchesStringOrRegExp(
  input /*: string | Array<string>*/,
  comparison /*: string | Array<string>*/
) /*: false | { match: string, pattern: string}*/ {
  if (!Array.isArray(input)) {
    return testAgainstStringOrArray(input, comparison);
  }

  for (const inputItem of input) {
    const testResult = testAgainstStringOrArray(inputItem, comparison);
    if (testResult) {
      return testResult;
    }
  }

  return false;
};

function testAgainstStringOrArray(value, comparison) {
  if (!Array.isArray(comparison)) {
    return testAgainstString(value, comparison);
  }

  for (const comparisonItem of comparison) {
    const testResult = testAgainstString(value, comparisonItem);
    if (testResult) {
      return testResult;
    }
  }
  return false;
}

function testAgainstString(value, comparison) {
  const firstComparisonChar = comparison[0];
  const lastComparisonChar = comparison[comparison.length - 1];
  const secondToLastComparisonChar = comparison[comparison.length - 2];

  const comparisonIsRegex =
    firstComparisonChar === "/" &&
    (lastComparisonChar === "/" ||
      (secondToLastComparisonChar === "/" && lastComparisonChar === "i"));

  const hasCaseInsensitiveFlag =
    comparisonIsRegex && lastComparisonChar === "i";

  if (comparisonIsRegex) {
    const valueMatches = hasCaseInsensitiveFlag
      ? new RegExp(comparison.slice(1, -2), "i").test(value)
      : new RegExp(comparison.slice(1, -1)).test(value);
    return valueMatches ? { match: value, pattern: comparison } : false;
  }

  return value === comparison ? { match: value, pattern: comparison } : false;
}

},{}],1135:[function(require,module,exports){
/* @flow */
"use strict";

/**
 * Get the next non-comment node in a PostCSS AST
 * at or after a given node.
 */
module.exports = function nextNonCommentNode(
  startNode /*: Object*/
) /*: ?Object*/ {
  if (!startNode || !startNode.next) return null;

  if (startNode.type === "comment") {
    return nextNonCommentNode(startNode.next());
  }

  return startNode;
};

},{}],1136:[function(require,module,exports){
// Too weird for Flow
"use strict";

/**
 * Create a collection of Maps that serve to contextualize a given node.
 * This is useful to ensure that you only compare nodes that share a certain
 * context.
 *
 * All nodes are initially contextualized by their input source.
 * From there, you can contextualize them however you want.
 *
 * For a usage example, see `selector-no-descending-specificity`.
 */
module.exports = function() {
  const contextMap = new Map();

  return {
    getContext(node) {
      const nodeSource = node.source.input.from;
      const baseContext = creativeGetMap(contextMap, nodeSource);
      const subContexts = Array.from(arguments).slice(1);

      return subContexts.reduce((result, context) => {
        return creativeGetMap(result, context);
      }, baseContext);
    }
  };
};

function creativeGetMap(someMap, someThing) {
  if (!someMap.has(someThing)) {
    someMap.set(someThing, new Map());
  }
  return someMap.get(someThing);
}

},{}],1137:[function(require,module,exports){
/* @flow */
"use strict";

const matchesStringOrRegExp = require("./matchesStringOrRegExp");

/**
 * Check if an options object's propertyName contains a user-defined string or
 * regex that matches the passed in input.
 */
module.exports = function optionsMatches(
  options /*: Object*/,
  propertyName /*: string*/,
  input /*: string*/
) /*: boolean*/ {
  return !!(
    options &&
    options[propertyName] &&
    typeof input === "string" &&
    matchesStringOrRegExp(input, options[propertyName])
  );
};

},{"./matchesStringOrRegExp":1134}],1138:[function(require,module,exports){
/* @flow */
"use strict";

const selectorParser = require("postcss-selector-parser");

module.exports = function(
  selector /*: string*/,
  result /*: Object*/,
  node /*: Object*/,
  cb /*: Function*/
) {
  try {
    selectorParser(cb).process(selector);
  } catch (e) {
    result.warn("Cannot parse selector", { node, stylelintType: "parseError" });
  }
};

},{"postcss-selector-parser":790}],1139:[function(require,module,exports){
/* @flow */
"use strict";

/**
 * Stringify PostCSS node including its raw "before" string.
 */
module.exports = function(node /*: Object*/) /*: string*/ {
  let result = "";
  if (node.raws.before) {
    result += node.raws.before;
  }
  result += node.toString();
  return result;
};

},{}],1140:[function(require,module,exports){
/* @flow */
"use strict";

// Remove empty lines before a node. Mutates the node.
function removeEmptyLinesBefore(
  node /*: postcss$node*/,
  newline /*: '\n' | '\r\n'*/
) /*: postcss$node*/ {
  node.raws.before = node.raws.before.replace(/(\r?\n\s*\r?\n)+/g, newline);

  return node;
}

module.exports = removeEmptyLinesBefore;

},{}],1141:[function(require,module,exports){
/* @flow */
"use strict";

const _ = require("lodash");

/**
 * Report a violation.
 *
 * This function accounts for `disabledRanges` attached to the result.
 * That is, if the reported violation is within a disabledRange,
 * it is ignored. Otherwise, it is attached to the result as a
 * postcss warning.
 *
 * It also accounts for the rule's severity.
 *
 * You *must* pass *either* a node or a line number.
 */
module.exports = function(
  violation /*: {
  ruleName: string,
  result: Object,
  message: string,
  node: Object,
  index?: number,
  word?: string,
  line?: number
}*/
) {
  const ruleName = violation.ruleName;
  const result = violation.result;
  const message = violation.message;
  const line = violation.line;
  const node = violation.node;
  const index = violation.index;
  const word = violation.word;

  result.stylelint = result.stylelint || {};

  // In quiet mode, mere warnings are ignored
  if (
    result.stylelint.quiet &&
    result.stylelint.ruleSeverities[ruleName] !== "error"
  ) {
    return;
  }

  // If a line is not passed, use the node.positionBy method to get the
  // line number that the complaint pertains to
  const startLine = line || node.positionBy({ index }).line;

  if (result.stylelint.disabledRanges && !result.stylelint.ignoreDisables) {
    const ranges =
      result.stylelint.disabledRanges[ruleName] ||
      result.stylelint.disabledRanges.all;
    for (const range of ranges) {
      if (
        // If the violation is within a disabledRange,
        // and that disabledRange's rules include this one,
        // do not register a warning
        range.start <= startLine &&
        (range.end >= startLine || range.end === undefined) &&
        (!range.rules || range.rules.indexOf(ruleName) !== -1)
      ) {
        return;
      }
    }
  }

  const severity = _.get(
    result.stylelint,
    ["ruleSeverities", ruleName],
    "ignore"
  );

  if (!result.stylelint.stylelintError && severity === "error") {
    result.stylelint.stylelintError = true;
  }

  const warningProperties /*: Object*/ = {
    severity,
    rule: ruleName
  };
  if (node) {
    warningProperties.node = node;
  }
  if (index) {
    warningProperties.index = index;
  }
  if (word) {
    warningProperties.word = word;
  }

  const warningMessage = _.get(
    result.stylelint,
    ["customMessages", ruleName],
    message
  );
  result.warn(warningMessage, warningProperties);
};

},{"lodash":692}],1142:[function(require,module,exports){
/* @flow */
"use strict";

/**
 * Given an object of violation messages, return another
 * that provides the same messages postfixed with the rule
 * that has been violated.
 *
 * @param {string} ruleName
 * @param {object} messages - Object whose keys are message identifiers
 *   and values are either message strings or functions that return message strings
 * @return {object} New message object, whose messages will be marked with the rule name
 */
module.exports = function(
  ruleName /*: string*/,
  messages /*: Object*/
) /*: Object*/ {
  return Object.keys(messages).reduce((newMessages, messageId) => {
    const messageText = messages[messageId];
    if (typeof messageText === "string") {
      newMessages[messageId] = `${messageText} (${ruleName})`;
    } else {
      newMessages[messageId] = function() {
        return `${messageText.apply(null, arguments)} (${ruleName})`;
      };
    }
    return newMessages;
  }, {});
};

},{}],1143:[function(require,module,exports){
/* @flow */
"use strict";

const _ = require("lodash");

/**
 * Check whether the variable is an object and all it's properties are arrays of string values:
 *
 * ignoreProperties = {
 *   value1: ["item11", "item12", "item13"],
 *   value2: ["item21", "item22", "item23"],
 *   value3: ["item31", "item32", "item33"],
 * }
 */

module.exports = function(value /*: Object*/) /*: boolean*/ {
  if (!_.isPlainObject(value)) {
    return false;
  }

  return Object.keys(value).every(key => {
    if (!_.isArray(value[key])) {
      return false;
    }

    // Make sure the array items are strings
    return value[key].every(item => _.isString(item));
  });
};

},{"lodash":692}],1144:[function(require,module,exports){
/* @flow */
"use strict";

const _ = require("lodash");

const ignoredOptions = ["severity", "message"];

/**
 * Validate a rule's options.
 *
 * See existing rules for examples.
 *
 * @param {Result} result - postcss result
 * @param {string} ruleName
 * @param {...object} ...optionDescriptions - Each optionDescription can
 *   have the following properties:
 *   	- `actual` (required): the actual passed option value or object.
 *   	- `possible` (required): a schema representation of what values are
 *      valid for those options. `possible` should be an object if the
 *      options are an object, with corresponding keys; if the options are not an
 *      object, `possible` isn't, either. All `possible` value representations
 *      should be **arrays of either values or functions**. Values are === checked
 *      against `actual`. Functions are fed `actual` as an argument and their
 *      return value is interpreted: truthy = valid, falsy = invalid.
 *    - `optional` (optional): If this is `true`, `actual` can be undefined.
 * @return {boolean} Whether or not the options are valid (true = valid)
 */
module.exports = function(
  result /*: Object*/,
  ruleName /*: string*/
) /*: boolean*/ {
  let noErrors = true;

  const optionDescriptions = Array.from(arguments).slice(2);

  optionDescriptions.forEach(optionDescription => {
    validate(optionDescription, ruleName, complain);
  });

  function complain(message) {
    noErrors = false;
    result.warn(message, {
      stylelintType: "invalidOption"
    });
    _.set(result, "stylelint.stylelintError", true);
  }

  return noErrors;
};

function validate(opts, ruleName, complain) {
  const possible = opts.possible;
  const actual = opts.actual;
  const optional = opts.optional;

  if (actual === null || _.isEqual(actual, [null])) {
    return;
  }

  const nothingPossible =
    possible === undefined ||
    (Array.isArray(possible) && possible.length === 0);

  if (nothingPossible && actual === true) {
    return;
  }

  if (actual === undefined) {
    if (nothingPossible || optional) {
      return;
    }
    complain(`Expected option value for rule "${ruleName}"`);
    return;
  } else if (nothingPossible) {
    complain(`Unexpected option value "${actual}" for rule "${ruleName}"`);
    return;
  }

  // If `possible` is a function ...
  if (_.isFunction(possible)) {
    if (!possible(actual)) {
      complain(
        `Invalid option "${JSON.stringify(actual)}" for rule ${ruleName}`
      );
    }
    return;
  }

  // If `possible` is an array instead of an object ...
  if (!_.isPlainObject(possible)) {
    [].concat(actual).forEach(a => {
      if (isValid(possible, a)) {
        return;
      }
      complain(`Invalid option value "${a}" for rule "${ruleName}"`);
    });
    return;
  }

  // If possible is an object ...
  if (!_.isPlainObject(actual)) {
    complain(
      `Invalid option value ${JSON.stringify(
        actual
      )} for rule "${ruleName}": ` + "should be an object"
    );
    return;
  }

  Object.keys(actual).forEach(optionName => {
    if (ignoredOptions.indexOf(optionName) !== -1) {
      return;
    }

    if (!possible[optionName]) {
      complain(`Invalid option name "${optionName}" for rule "${ruleName}"`);
      return;
    }

    const actualOptionValue = actual[optionName];
    [].concat(actualOptionValue).forEach(a => {
      if (isValid(possible[optionName], a)) {
        return;
      }
      complain(
        `Invalid value "${a}" for option "${optionName}" of rule "${ruleName}"`
      );
    });
  });
}

function isValid(possible, actual) {
  const possibleList = [].concat(possible);
  for (let i = 0, l = possibleList.length; i < l; i++) {
    const possibility = possibleList[i];
    if (typeof possibility === "function" && possibility(actual)) {
      return true;
    }
    if (actual === possibility) {
      return true;
    }
  }
}

},{"lodash":692}],1145:[function(require,module,exports){
"use strict";

const configurationError = require("./configurationError");
const isSingleLineString = require("./isSingleLineString");
const isWhitespace = require("./isWhitespace");

/**
 * Create a whitespaceChecker, which exposes the following functions:
 * - `before()`
 * - `beforeAllowingIndentation()`
 * - `after()`
 * - `afterOneOnly()`
 *
 * @param {"space"|"newline"} targetWhitespace - This is a keyword instead
 *   of the actual character (e.g. " ") in order to accommodate
 *   different styles of newline ("\n" vs "\r\n")
 * @param {
 *     "always"|"never"
 *     |"always-single-line"|"always-multi-line"
 *     | "never-single-line"|"never-multi-line"
 *   } expectation
 * @param {object} messages - An object of message functions;
 *   calling `before*()` or `after*()` and the `expectation` that is passed
 *   determines which message functions are required
 * @param {function} [messages.exectedBefore]
 * @param {function} [messages.rejectedBefore]
 * @param {function} [messages.expectedAfter]
 * @param {function} [messages.rejectedAfter]
 * @param {function} [messages.expectedBeforeSingleLine]
 * @param {function} [messages.rejectedBeforeSingleLine]
 * @param {function} [messages.expectedBeforeMultiLine]
 * @param {function} [messages.rejectedBeforeMultiLine]
 * @return {object} The checker, with its exposed checking functions
 */
module.exports = function(
  targetWhitespace /*: "space" | "newline"*/,
  expectation /*: "always" | "never" | "always-single-line"
    | "always-multi-line" | "never-single-line"|"never-multi-line"*/,
  messages /*: Object*/
) /*: {
  before: Function,
  beforeAllowingIndentation: Function,
  after: Function,
  afterOneOnly: Function
}*/ {
  // Keep track of active arguments in order to avoid passing
  // too much stuff around, making signatures long and confusing.
  // This variable gets reset anytime a checking function is called.
  let activeArgs;

  /**
   * Check for whitespace *before* a character.
   *
   * @param {object} args - Named arguments object
   * @param {string} args.source - The source string
   * @param {number} args.index - The index of the character to check before
   * @param {function} args.err - If a violation is found, this callback
   *   will be invoked with the relevant warning message.
   *   Typically this callback will report() the violation.
   * @param {function} args.errTarget - If a violation is found, this string
   *   will be sent to the relevant warning message.
   * @param {string} [args.lineCheckStr] - Single- and multi-line checkers
   *   will use this string to determine whether they should proceed,
   *   i.e. if this string is one line only, single-line checkers will check,
   *   multi-line checkers will ignore.
   *   If none is passed, they will use `source`.
   * @param {boolean} [args.onlyOneChar=false] - Only check *one* character before.
   *   By default, "always-*" checks will look for the `targetWhitespace` one
   *   before and then ensure there is no whitespace two before. This option
   *   bypasses that second check.
   * @param {boolean} [args.allowIndentation=false] - Allow arbitrary indentation
   *   between the `targetWhitespace` (almost definitely a newline) and the `index`.
   *   With this option, the checker will see if a newline *begins* the whitespace before
   *   the `index`.
   */
  function before(args) {
    const source = args.source;
    const index = args.index;
    const err = args.err;
    const errTarget = args.errTarget;
    const lineCheckStr = args.lineCheckStr;
    const onlyOneChar =
      args.onlyOneChar === undefined ? false : args.onlyOneChar;
    const allowIndentation =
      args.allowIndentation === undefined ? false : args.allowIndentation;

    activeArgs = {
      source,
      index,
      err,
      errTarget,
      onlyOneChar,
      allowIndentation
    };
    switch (expectation) {
      case "always":
        expectBefore();
        break;
      case "never":
        rejectBefore();
        break;
      case "always-single-line":
        if (!isSingleLineString(lineCheckStr || source)) {
          return;
        }
        expectBefore(messages.expectedBeforeSingleLine);
        break;
      case "never-single-line":
        if (!isSingleLineString(lineCheckStr || source)) {
          return;
        }
        rejectBefore(messages.rejectedBeforeSingleLine);
        break;
      case "always-multi-line":
        if (isSingleLineString(lineCheckStr || source)) {
          return;
        }
        expectBefore(messages.expectedBeforeMultiLine);
        break;
      case "never-multi-line":
        if (isSingleLineString(lineCheckStr || source)) {
          return;
        }
        rejectBefore(messages.rejectedBeforeMultiLine);
        break;
      default:
        throw configurationError(`Unknown expectation "${expectation}"`);
    }
  }

  /**
   * Check for whitespace *after* a character.
   *
   * Parameters are pretty much the same as for `before()`, above, just substitute
   * the word "after" for "before".
   */
  function after(args) {
    const source = args.source;
    const index = args.index;
    const err = args.err;
    const errTarget = args.errTarget;
    const lineCheckStr = args.lineCheckStr;
    const onlyOneChar =
      args.onlyOneChar === undefined ? false : args.onlyOneChar;

    activeArgs = { source, index, err, errTarget, onlyOneChar };
    switch (expectation) {
      case "always":
        expectAfter();
        break;
      case "never":
        rejectAfter();
        break;
      case "always-single-line":
        if (!isSingleLineString(lineCheckStr || source)) {
          return;
        }
        expectAfter(messages.expectedAfterSingleLine);
        break;
      case "never-single-line":
        if (!isSingleLineString(lineCheckStr || source)) {
          return;
        }
        rejectAfter(messages.rejectedAfterSingleLine);
        break;
      case "always-multi-line":
        if (isSingleLineString(lineCheckStr || source)) {
          return;
        }
        expectAfter(messages.expectedAfterMultiLine);
        break;
      case "never-multi-line":
        if (isSingleLineString(lineCheckStr || source)) {
          return;
        }
        rejectAfter(messages.rejectedAfterMultiLine);
        break;
      default:
        throw configurationError(`Unknown expectation "${expectation}"`);
    }
  }

  function beforeAllowingIndentation(obj) {
    before(Object.assign({}, obj, { allowIndentation: true }));
  }

  function expectBefore() {
    const messageFunc =
      arguments.length > 0 && arguments[0] !== undefined
        ? arguments[0]
        : messages.expectedBefore;

    if (activeArgs.allowIndentation) {
      expectBeforeAllowingIndentation(messageFunc);
      return;
    }

    const _activeArgs = activeArgs;
    const source = _activeArgs.source,
      index = _activeArgs.index;

    const oneCharBefore = source[index - 1];
    const twoCharsBefore = source[index - 2];

    if (!isValue(oneCharBefore)) {
      return;
    }

    if (targetWhitespace === "space" && oneCharBefore === " ") {
      if (activeArgs.onlyOneChar || !isWhitespace(twoCharsBefore)) {
        return;
      }
    }

    activeArgs.err(
      messageFunc(activeArgs.errTarget ? activeArgs.errTarget : source[index])
    );
  }

  function expectBeforeAllowingIndentation() {
    const messageFunc =
      arguments.length > 0 && arguments[0] !== undefined
        ? arguments[0]
        : messages.expectedBefore;
    const _activeArgs2 = activeArgs;
    const source = _activeArgs2.source,
      index = _activeArgs2.index,
      err = _activeArgs2.err;

    const expectedChar = (function() {
      if (targetWhitespace === "newline") {
        return "\n";
      }
    })();
    let i = index - 1;
    while (source[i] !== expectedChar) {
      if (source[i] === "\t" || source[i] === " ") {
        i--;
        continue;
      }
      err(
        messageFunc(activeArgs.errTarget ? activeArgs.errTarget : source[index])
      );
      return;
    }
  }

  function rejectBefore() {
    const messageFunc =
      arguments.length > 0 && arguments[0] !== undefined
        ? arguments[0]
        : messages.rejectedBefore;
    const _activeArgs3 = activeArgs;
    const source = _activeArgs3.source,
      index = _activeArgs3.index;

    const oneCharBefore = source[index - 1];

    if (isValue(oneCharBefore) && isWhitespace(oneCharBefore)) {
      activeArgs.err(
        messageFunc(activeArgs.errTarget ? activeArgs.errTarget : source[index])
      );
    }
  }

  function afterOneOnly(obj) {
    after(Object.assign({}, obj, { onlyOneChar: true }));
  }

  function expectAfter() {
    const messageFunc =
      arguments.length > 0 && arguments[0] !== undefined
        ? arguments[0]
        : messages.expectedAfter;
    const _activeArgs4 = activeArgs;
    const source = _activeArgs4.source,
      index = _activeArgs4.index;

    const oneCharAfter = source[index + 1];
    const twoCharsAfter = source[index + 2];

    if (!isValue(oneCharAfter)) {
      return;
    }

    if (targetWhitespace === "newline") {
      // If index is followed by a Windows CR-LF ...
      if (oneCharAfter === "\r" && twoCharsAfter === "\n") {
        if (activeArgs.onlyOneChar || !isWhitespace(source[index + 3])) {
          return;
        }
      }

      // If index is followed by a Unix LF ...
      if (oneCharAfter === "\n") {
        if (activeArgs.onlyOneChar || !isWhitespace(twoCharsAfter)) {
          return;
        }
      }
    }

    if (targetWhitespace === "space" && oneCharAfter === " ") {
      if (activeArgs.onlyOneChar || !isWhitespace(twoCharsAfter)) {
        return;
      }
    }

    activeArgs.err(
      messageFunc(activeArgs.errTarget ? activeArgs.errTarget : source[index])
    );
  }

  function rejectAfter() {
    const messageFunc =
      arguments.length > 0 && arguments[0] !== undefined
        ? arguments[0]
        : messages.rejectedAfter;
    const _activeArgs5 = activeArgs;
    const source = _activeArgs5.source,
      index = _activeArgs5.index;

    const oneCharAfter = source[index + 1];

    if (isValue(oneCharAfter) && isWhitespace(oneCharAfter)) {
      activeArgs.err(
        messageFunc(activeArgs.errTarget ? activeArgs.errTarget : source[index])
      );
    }
  }

  return {
    before,
    beforeAllowingIndentation,
    after,
    afterOneOnly
  };
};

function isValue(x) {
  return x !== undefined && x !== null;
}

},{"./configurationError":1078,"./isSingleLineString":1119,"./isWhitespace":1133}],1146:[function(require,module,exports){
module.exports={
  "_from": "stylelint@^8.0.0",
  "_id": "stylelint@8.0.0",
  "_inBundle": false,
  "_integrity": "sha512-k1GkRhOtghvYu5PWCdec7SNN22KZZLq4TL1vVyykBvHr91oUS7eVfX2IAZJjBpYKh9Gdep+AnSZCwuUn+J76Bw==",
  "_location": "/stylelint",
  "_phantomChildren": {},
  "_requested": {
    "type": "range",
    "registry": true,
    "raw": "stylelint@^8.0.0",
    "name": "stylelint",
    "escapedName": "stylelint",
    "rawSpec": "^8.0.0",
    "saveSpec": null,
    "fetchSpec": "^8.0.0"
  },
  "_requiredBy": [
    "#USER",
    "/"
  ],
  "_resolved": "https://registry.npmjs.org/stylelint/-/stylelint-8.0.0.tgz",
  "_shasum": "87611211776cb315c93fcf6c58bc261d3c92612e",
  "_spec": "stylelint@^8.0.0",
  "_where": "Z:\\Repos\\+Misc\\stylelint.js",
  "authors": [
    "David Clark",
    "Maxime Thirouin",
    "Richard Hallows"
  ],
  "bin": {
    "stylelint": "bin/stylelint.js"
  },
  "bugs": {
    "url": "https://github.com/stylelint/stylelint/issues"
  },
  "bundleDependencies": false,
  "dependencies": {
    "autoprefixer": "^7.1.2",
    "balanced-match": "^1.0.0",
    "chalk": "^2.0.1",
    "cosmiconfig": "^2.1.3",
    "debug": "^2.6.8",
    "execall": "^1.0.0",
    "file-entry-cache": "^2.0.0",
    "get-stdin": "^5.0.1",
    "globby": "^6.1.0",
    "globjoin": "^0.1.4",
    "html-tags": "^2.0.0",
    "ignore": "^3.3.3",
    "imurmurhash": "^0.1.4",
    "known-css-properties": "^0.2.0",
    "lodash": "^4.17.4",
    "log-symbols": "^1.0.2",
    "mathml-tag-names": "^2.0.1",
    "meow": "^3.7.0",
    "micromatch": "^2.3.11",
    "normalize-selector": "^0.2.0",
    "pify": "^3.0.0",
    "postcss": "^6.0.6",
    "postcss-less": "^1.1.0",
    "postcss-media-query-parser": "^0.2.3",
    "postcss-reporter": "^4.0.0",
    "postcss-resolve-nested-selector": "^0.1.1",
    "postcss-scss": "^1.0.2",
    "postcss-selector-parser": "^2.2.3",
    "postcss-value-parser": "^3.3.0",
    "resolve-from": "^3.0.0",
    "specificity": "^0.3.1",
    "string-width": "^2.1.0",
    "style-search": "^0.1.0",
    "sugarss": "^1.0.0",
    "svg-tags": "^1.0.0",
    "table": "^4.0.1"
  },
  "deprecated": false,
  "description": "A mighty, modern CSS linter.",
  "devDependencies": {
    "benchmark": "^2.1.4",
    "common-tags": "^1.4.0",
    "coveralls": "^2.13.1",
    "cp-file": "^4.2.0",
    "d3-queue": "^3.0.7",
    "del": "^3.0.0",
    "eslint": "~4.2.0",
    "eslint-config-stylelint": "^7.0.0",
    "file-exists-promise": "^1.0.2",
    "flow-bin": "^0.50.0",
    "fs-promise": "^2.0.3",
    "husky": "^0.14.3",
    "jest": "^20.0.4",
    "lint-staged": "^4.0.1",
    "npm-run-all": "^4.0.2",
    "npmpub": "^3.1.0",
    "postcss-import": "^10.0.0",
    "postcss-safe-parser": "^3.0.1",
    "prettier": "^1.5.3",
    "remark-cli": "^3.0.1",
    "remark-preset-lint-consistent": "^2.0.0",
    "remark-preset-lint-recommended": "^2.0.0",
    "remark-validate-links": "^6.1.0",
    "request": "^2.81.0",
    "strip-ansi": "^4.0.0"
  },
  "engines": {
    "node": ">=4.2.1"
  },
  "eslintConfig": {
    "extends": [
      "stylelint"
    ],
    "globals": {
      "testRule": true
    }
  },
  "files": [
    "bin",
    "CONTRIBUTING.md",
    "decls/*.js",
    "docs",
    "lib",
    "VISION.md",
    "!**/__tests__"
  ],
  "greenkeeper": {
    "label": "PR: review needed"
  },
  "homepage": "https://stylelint.io",
  "jest": {
    "clearMocks": true,
    "collectCoverage": false,
    "collectCoverageFrom": [
      "lib/**/*.js"
    ],
    "coverageDirectory": "./.coverage/",
    "coverageReporters": [
      "lcov",
      "text-summary"
    ],
    "coverageThreshold": {
      "global": {
        "branches": 75,
        "functions": 75,
        "lines": 75,
        "statements": 75
      }
    },
    "setupFiles": [
      "./jest-setup.js"
    ],
    "testEnvironment": "node",
    "roots": [
      "lib",
      "system-tests"
    ],
    "testRegex": ".*\\.test\\.js$|rules/.*/__tests__/.*\\.js$"
  },
  "keywords": [
    "css",
    "less",
    "scss",
    "sugarss",
    "lint",
    "linter",
    "stylelint"
  ],
  "license": "MIT",
  "lint-staged": {
    "*.js": [
      "prettier --write",
      "git add"
    ]
  },
  "main": "lib/index.js",
  "name": "stylelint",
  "remarkConfig": {
    "plugins": [
      "preset-lint-recommended",
      "preset-lint-consistent",
      [
        "validate-links",
        {
          "repository": "stylelint/stylelint"
        }
      ]
    ]
  },
  "repository": {
    "type": "git",
    "url": "git+https://github.com/stylelint/stylelint.git"
  },
  "scripts": {
    "benchmark-rule": "node scripts/benchmark-rule.js",
    "dry-release": "npmpub  --dry --verbose",
    "flow": "flow",
    "jest": "jest",
    "lint": "npm-run-all --parallel lint:*",
    "lint:js": "eslint . --cache",
    "lint:md": "remark . --quiet --frail",
    "precommit": "lint-staged",
    "pretest": "npm-run-all --serial lint flow",
    "release": "npmpub",
    "test": "jest --coverage",
    "watch": "jest --watch"
  },
  "version": "8.0.0"
}

},{}],1147:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _stringify = require('./stringify');

var _stringify2 = _interopRequireDefault(_stringify);

var _parse = require('./parse');

var _parse2 = _interopRequireDefault(_parse);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = { stringify: _stringify2.default, parse: _parse2.default };
module.exports = exports['default'];

},{"./parse":1149,"./stringify":1153}],1148:[function(require,module,exports){
'use strict';

exports.__esModule = true;
exports.default = liner;
function liner(tokens) {
    var line = [];
    var result = [line];
    var brackets = 0;
    for (var _iterator = tokens, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
        var _ref;

        if (_isArray) {
            if (_i >= _iterator.length) break;
            _ref = _iterator[_i++];
        } else {
            _i = _iterator.next();
            if (_i.done) break;
            _ref = _i.value;
        }

        var token = _ref;

        line.push(token);
        if (token[0] === '(') {
            brackets += 1;
        } else if (token[0] === ')') {
            brackets -= 1;
        } else if (token[0] === 'newline' && brackets === 0) {
            line = [];
            result.push(line);
        }
    }
    return result;
}
module.exports = exports['default'];

},{}],1149:[function(require,module,exports){
'use strict';

exports.__esModule = true;
exports.default = parse;

var _input = require('postcss/lib/input');

var _input2 = _interopRequireDefault(_input);

var _preprocess = require('./preprocess');

var _preprocess2 = _interopRequireDefault(_preprocess);

var _tokenize = require('./tokenize');

var _tokenize2 = _interopRequireDefault(_tokenize);

var _parser = require('./parser');

var _parser2 = _interopRequireDefault(_parser);

var _liner = require('./liner');

var _liner2 = _interopRequireDefault(_liner);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function parse(source, opts) {
    var input = new _input2.default(source, opts);

    var parser = new _parser2.default(input);
    parser.tokens = (0, _tokenize2.default)(input);
    parser.parts = (0, _preprocess2.default)(input, (0, _liner2.default)(parser.tokens));
    parser.loop();

    return parser.root;
}
module.exports = exports['default'];

},{"./liner":1148,"./parser":1150,"./preprocess":1151,"./tokenize":1154,"postcss/lib/input":821}],1150:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _declaration = require('postcss/lib/declaration');

var _declaration2 = _interopRequireDefault(_declaration);

var _comment = require('postcss/lib/comment');

var _comment2 = _interopRequireDefault(_comment);

var _atRule = require('postcss/lib/at-rule');

var _atRule2 = _interopRequireDefault(_atRule);

var _rule = require('postcss/lib/rule');

var _rule2 = _interopRequireDefault(_rule);

var _root = require('postcss/lib/root');

var _root2 = _interopRequireDefault(_root);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Parser = function () {
    function Parser(input) {
        _classCallCheck(this, Parser);

        this.input = input;

        this.pos = 0;
        this.root = new _root2.default();
        this.current = this.root;
        this.spaces = '';

        this.prevIndent = undefined;
        this.step = undefined;

        this.root.source = { input: input, start: { line: 1, column: 1 } };
    }

    Parser.prototype.loop = function loop() {
        var part = void 0;
        while (this.pos < this.parts.length) {
            part = this.parts[this.pos];

            if (part.comment) {
                this.comment(part);
            } else if (part.atrule) {
                this.atrule(part);
            } else if (part.colon) {
                var next = this.nextNonComment(this.pos);

                if (next.end || next.atrule) {
                    this.decl(part);
                } else {
                    var moreIndent = next.indent.length > part.indent.length;
                    if (!moreIndent) {
                        this.decl(part);
                    } else if (moreIndent && next.colon) {
                        this.rule(part);
                    } else if (moreIndent && !next.colon) {
                        this.decl(part);
                    }
                }
            } else if (part.end) {
                this.root.raws.after = part.before;
            } else {
                this.rule(part);
            }

            this.pos += 1;
        }

        for (var i = this.tokens.length - 1; i >= 0; i--) {
            if (this.tokens[i].length > 3) {
                var last = this.tokens[i];
                this.root.source.end = {
                    line: last[4] || last[2],
                    column: last[5] || last[3]
                };
                break;
            }
        }
    };

    Parser.prototype.comment = function comment(part) {
        var token = part.tokens[0];
        var node = new _comment2.default();
        this.init(node, part);
        node.source.end = { line: token[4], column: token[5] };
        this.commentText(node, token);
    };

    Parser.prototype.atrule = function atrule(part) {
        var atword = part.tokens[0];
        var params = part.tokens.slice(1);

        var node = new _atRule2.default();
        node.name = atword[1].slice(1);
        this.init(node, part);

        if (node.name === '') this.unnamedAtrule(atword);

        while (!part.end && part.lastComma) {
            this.pos += 1;
            part = this.parts[this.pos];
            params.push(['space', part.before + part.indent]);
            params = params.concat(part.tokens);
        }

        node.raws.afterName = this.firstSpaces(params);
        this.keepTrailingSpace(node, params);
        this.checkSemicolon(params);
        this.checkCurly(params);
        this.raw(node, 'params', params, atword);
    };

    Parser.prototype.decl = function decl(part) {
        var node = new _declaration2.default();
        this.init(node, part);

        var between = '';
        var colon = 0;
        var value = [];
        var prop = '';
        for (var i = 0; i < part.tokens.length; i++) {
            var token = part.tokens[i];
            if (token[0] === ':') {
                between += token[1];
                colon = token;
                value = part.tokens.slice(i + 1);
                break;
            } else if (token[0] === 'comment' || token[0] === 'space') {
                between += token[1];
            } else if (between !== '') {
                this.badProp(token);
            } else {
                prop += token[1];
            }
        }

        if (prop === '') this.unnamedDecl(part.tokens[0]);
        node.prop = prop;

        var next = this.parts[this.pos + 1];

        while (!next.end && !next.atrule && !next.colon && next.indent.length > part.indent.length) {
            value.push(['space', next.before + next.indent]);
            value = value.concat(next.tokens);
            this.pos += 1;
            next = this.parts[this.pos + 1];
        }

        var last = value[value.length - 1];
        if (last && last[0] === 'comment') {
            value.pop();
            var comment = new _comment2.default();
            this.current.push(comment);
            comment.source = {
                input: this.input,
                start: { line: last[2], column: last[3] },
                end: { line: last[4], column: last[5] }
            };
            var prev = value[value.length - 1];
            if (prev && prev[0] === 'space') {
                value.pop();
                comment.raws.before = prev[1];
            }
            this.commentText(comment, last);
        }

        for (var _i = value.length - 1; _i > 0; _i--) {
            var t = value[_i][0];
            if (t === 'word' && value[_i][1] === '!important') {
                node.important = true;
                if (_i > 0 && value[_i - 1][0] === 'space') {
                    node.raws.important = value[_i - 1][1] + '!important';
                    value.splice(_i - 1, 2);
                } else {
                    node.raws.important = '!important';
                    value.splice(_i, 1);
                }
                break;
            } else if (t !== 'space' && t !== 'newline' && t !== 'comment') {
                break;
            }
        }

        node.raws.between = between + this.firstSpaces(value);
        this.checkSemicolon(value);
        this.raw(node, 'value', value, colon);
    };

    Parser.prototype.rule = function rule(part) {
        var node = new _rule2.default();
        this.init(node, part);

        var selector = part.tokens;
        var next = this.parts[this.pos + 1];

        while (!next.end && next.indent.length === part.indent.length) {
            selector.push(['space', next.before + next.indent]);
            selector = selector.concat(next.tokens);
            this.pos += 1;
            next = this.parts[this.pos + 1];
        }

        this.keepTrailingSpace(node, selector);
        this.checkCurly(selector);
        this.raw(node, 'selector', selector);
    };

    /* Helpers */

    Parser.prototype.indent = function indent(part) {
        var indent = part.indent.length;
        var isPrev = typeof this.prevIndent !== 'undefined';

        if (!isPrev && indent) this.indentedFirstLine(part);

        if (!this.step && indent) {
            this.step = indent;
            this.root.raws.indent = part.indent;
        }

        if (isPrev && this.prevIndent !== indent) {
            var diff = indent - this.prevIndent;
            if (diff > 0) {
                if (diff !== this.step) {
                    this.wrongIndent(this.prevIndent + this.step, indent, part);
                } else {
                    this.current = this.current.last;
                }
            } else if (diff % this.step !== 0) {
                var m = indent + diff % this.step;
                this.wrongIndent(m + ' or ' + (m + this.step), indent, part);
            } else {
                for (var i = 0; i < -diff / this.step; i++) {
                    this.current = this.current.parent;
                }
            }
        }

        this.prevIndent = indent;
    };

    Parser.prototype.init = function init(node, part) {
        this.indent(part);

        if (!this.current.nodes) this.current.nodes = [];
        this.current.push(node);

        node.raws.before = part.before + part.indent;
        node.source = {
            start: { line: part.tokens[0][2], column: part.tokens[0][3] },
            input: this.input
        };
    };

    Parser.prototype.checkCurly = function checkCurly(tokens) {
        for (var _iterator = tokens, _isArray = Array.isArray(_iterator), _i2 = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
            var _ref;

            if (_isArray) {
                if (_i2 >= _iterator.length) break;
                _ref = _iterator[_i2++];
            } else {
                _i2 = _iterator.next();
                if (_i2.done) break;
                _ref = _i2.value;
            }

            var token = _ref;

            if (token[0] === '{') {
                this.error('Unnecessary curly bracket', token[2], token[3]);
            }
        }
    };

    Parser.prototype.checkSemicolon = function checkSemicolon(tokens) {
        for (var _iterator2 = tokens, _isArray2 = Array.isArray(_iterator2), _i3 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
            var _ref2;

            if (_isArray2) {
                if (_i3 >= _iterator2.length) break;
                _ref2 = _iterator2[_i3++];
            } else {
                _i3 = _iterator2.next();
                if (_i3.done) break;
                _ref2 = _i3.value;
            }

            var token = _ref2;

            if (token[0] === ';') {
                this.error('Unnecessary semicolon', token[2], token[3]);
            }
        }
    };

    Parser.prototype.keepTrailingSpace = function keepTrailingSpace(node, tokens) {
        var lastSpace = tokens[tokens.length - 1];
        if (lastSpace && lastSpace[0] === 'space') {
            tokens.pop();
            node.raws.sssBetween = lastSpace[1];
        }
    };

    Parser.prototype.firstSpaces = function firstSpaces(tokens) {
        var result = '';
        for (var i = 0; i < tokens.length; i++) {
            if (tokens[i][0] === 'space' || tokens[i][0] === 'newline') {
                result += tokens.shift()[1];
                i -= 1;
            } else {
                break;
            }
        }
        return result;
    };

    Parser.prototype.raw = function raw(node, prop, tokens, altLast) {
        var token = void 0,
            type = void 0;
        var length = tokens.length;
        var value = '';
        var clean = true;
        for (var i = 0; i < length; i += 1) {
            token = tokens[i];
            type = token[0];
            if (type === 'comment' || type === 'space' && i === length - 1) {
                clean = false;
            } else {
                value += token[1];
            }
        }
        if (!clean) {
            var sss = tokens.reduce(function (all, i) {
                return all + i[1];
            }, '');
            var raw = tokens.reduce(function (all, i) {
                if (i[0] === 'comment' && i[6] === 'inline') {
                    return all + '/* ' + i[1].slice(2).trim() + ' */';
                } else {
                    return all + i[1];
                }
            }, '');
            node.raws[prop] = { value: value, raw: raw };
            if (sss !== raw) node.raws[prop].sss = sss;
        }
        node[prop] = value;

        var last = void 0;
        for (var _i4 = tokens.length - 1; _i4 >= 0; _i4--) {
            if (tokens[_i4].length > 2) {
                last = tokens[_i4];
                break;
            }
        }
        if (!last) last = altLast;

        node.source.end = {
            line: last[4] || last[2],
            column: last[5] || last[3]
        };
    };

    Parser.prototype.nextNonComment = function nextNonComment(pos) {
        var next = pos;
        var part = void 0;
        while (next < this.parts.length) {
            next += 1;
            part = this.parts[next];
            if (part.end || !part.comment) break;
        }
        return part;
    };

    Parser.prototype.commentText = function commentText(node, token) {
        var text = token[1];
        if (token[6] === 'inline') {
            node.raws.inline = true;
            text = text.slice(2);
        } else {
            text = text.slice(2, -2);
        }

        var match = text.match(/^(\s*)([^]*[^\s])(\s*)\n?$/);
        if (match) {
            node.text = match[2];
            node.raws.left = match[1];
            node.raws.inlineRight = match[3];
        } else {
            node.text = '';
            node.raws.left = '';
            node.raws.inlineRight = '';
        }
    };

    // Errors

    Parser.prototype.error = function error(msg, line, column) {
        throw this.input.error(msg, line, column);
    };

    Parser.prototype.unnamedAtrule = function unnamedAtrule(token) {
        this.error('At-rule without name', token[2], token[3]);
    };

    Parser.prototype.unnamedDecl = function unnamedDecl(token) {
        this.error('Declaration without name', token[2], token[3]);
    };

    Parser.prototype.indentedFirstLine = function indentedFirstLine(part) {
        this.error('First line should not have indent', part.number, 1);
    };

    Parser.prototype.wrongIndent = function wrongIndent(expected, real, part) {
        var msg = 'Expected ' + expected + ' indent, but get ' + real;
        this.error(msg, part.number, 1);
    };

    Parser.prototype.badProp = function badProp(token) {
        this.error('Unexpected separator in property', token[2], token[3]);
    };

    return Parser;
}();

exports.default = Parser;
module.exports = exports['default'];

},{"postcss/lib/at-rule":816,"postcss/lib/comment":817,"postcss/lib/declaration":820,"postcss/lib/root":832,"postcss/lib/rule":833}],1151:[function(require,module,exports){
'use strict';

exports.__esModule = true;
exports.default = preprocess;
function indentError(input, l, p) {
    throw input.error('Mixed tabs and spaces are not allowed', l, p + 1);
}

function preprocess(input, lines) {
    var indentType = void 0;
    var prevNumber = 0;
    var parts = lines.map(function (line) {
        var lastComma = false;
        var comment = false;
        var number = prevNumber + 1;
        var atrule = false;
        var indent = '';
        var tokens = [];
        var colon = false;

        if (line.length > 0) {
            if (line[0][0] === 'space') {
                indent = line[0][1];
                tokens = line.slice(1);
            } else {
                indent = '';
                tokens = line;
            }

            if (!indentType && indent.length) {
                indentType = indent[0] === ' ' ? 'space' : 'tab';
            }
            if (indentType === 'space') {
                if (indent.indexOf('\t') !== -1) {
                    indentError(input, number, indent.indexOf('\t'));
                }
            } else if (indentType === 'tab') {
                if (indent.indexOf(' ') !== -1) {
                    indentError(input, number, indent.indexOf(' '));
                }
            }

            if (tokens.length) {
                for (var i = tokens.length - 1; i >= 0; i--) {
                    var type = tokens[i][0];
                    if (type === ',') {
                        lastComma = true;
                        break;
                    } else if (type === 'space') {
                        continue;
                    } else if (type === 'comment') {
                        continue;
                    } else if (type === 'newline') {
                        continue;
                    } else {
                        break;
                    }
                }
                comment = tokens[0][0] === 'comment';
                atrule = tokens[0][0] === 'at-word';

                var brackets = 0;
                for (var _i = 0; _i < tokens.length - 1; _i++) {
                    var _type = tokens[_i][0];
                    var next = tokens[_i + 1][0];
                    if (_type === '(') {
                        brackets += 1;
                    } else if (_type === ')') {
                        brackets -= 1;
                    } else if (_type === ':' && brackets === 0 && (next === 'space' || next === 'newline')) {
                        colon = true;
                    }
                }
            }

            var last = tokens[tokens.length - 1];
            if (last && last[0] === 'newline') prevNumber = last[2];
        }

        return {
            number: number,
            indent: indent,
            colon: colon,
            tokens: tokens,
            atrule: atrule,
            comment: comment,
            lastComma: lastComma,
            before: ''
        };
    });

    parts = parts.reduceRight(function (all, i) {
        if (!i.tokens.length || i.tokens.every(function (j) {
            return j[0] === 'newline';
        })) {
            var prev = all[0];
            var before = i.indent + i.tokens.map(function (j) {
                return j[1];
            }).join('');
            prev.before = before + prev.before;
        } else {
            all.unshift(i);
        }
        return all;
    }, [{ end: true, before: '' }]);

    parts.forEach(function (part, i) {
        if (i === 0) return;

        var prev = parts[i - 1];
        var last = prev.tokens[prev.tokens.length - 1];
        if (last && last[0] === 'newline') {
            part.before = last[1] + part.before;
            prev.tokens.pop();
        }
    });

    return parts;
}
module.exports = exports['default'];

},{}],1152:[function(require,module,exports){
'use strict';

exports.__esModule = true;

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var defaultRaw = {
    colon: ': ',
    indent: '  ',
    commentLeft: ' ',
    commentRight: ' '
};

var Stringifier = function () {
    function Stringifier(builder) {
        _classCallCheck(this, Stringifier);

        this.builder = builder;
    }

    Stringifier.prototype.stringify = function stringify(node, semicolon) {
        this[node.type](node, semicolon);
    };

    Stringifier.prototype.root = function root(node) {
        this.body(node);
        if (node.raws.after) this.builder(node.raws.after);
    };

    Stringifier.prototype.comment = function comment(node) {
        var left = defaultRaw.commentLeft;
        var right = defaultRaw.commentRight;
        if (this.has(node.raws.left)) left = node.raws.left;

        if (node.raws.inline) {
            if (this.has(node.raws.inlineRight)) {
                right = node.raws.inlineRight;
            } else {
                right = '';
            }
            this.builder('//' + left + node.text + right, node);
        } else {
            if (this.has(node.raws.right)) right = node.raws.right;
            this.builder('/*' + left + node.text + right + '*/', node);
        }
    };

    Stringifier.prototype.decl = function decl(node) {
        var between = node.raws.between || defaultRaw.colon;
        var string = node.prop + between + this.rawValue(node, 'value');

        if (node.important) {
            string += node.raws.important || ' !important';
        }

        this.builder(string, node);
    };

    Stringifier.prototype.rule = function rule(node) {
        this.block(node, this.rawValue(node, 'selector'));
    };

    Stringifier.prototype.atrule = function atrule(node) {
        var name = '@' + node.name;
        var params = node.params ? this.rawValue(node, 'params') : '';

        if (this.has(node.raws.afterName)) {
            name += node.raws.afterName;
        } else if (params) {
            name += ' ';
        }

        this.block(node, name + params);
    };

    Stringifier.prototype.body = function body(node) {
        var indent = node.root().raws.indent || defaultRaw.indent;

        for (var i = 0; i < node.nodes.length; i++) {
            var child = node.nodes[i];
            var before = child.raws.before.replace(/[^\n]*$/, '') + this.indent(node, indent);
            if (child.type === 'comment' && child.raws.before.indexOf('\n') === -1) {
                before = child.raws.before;
            }
            if (before) this.builder(before);
            this.stringify(child);
        }
    };

    Stringifier.prototype.block = function block(node, start) {
        var between = node.raws.sssBetween || '';
        this.builder(start + between, node, 'start');
        if (this.has(node.nodes)) this.body(node);
    };

    Stringifier.prototype.indent = function indent(node, step) {
        var result = '';
        while (node.parent) {
            result += step;
            node = node.parent;
        }
        return result;
    };

    Stringifier.prototype.has = function has(value) {
        return typeof value !== 'undefined';
    };

    Stringifier.prototype.rawValue = function rawValue(node, prop) {
        var value = node[prop];
        var raw = node.raws[prop];
        if (raw && raw.value === value) {
            return raw.sss || raw.raw;
        } else {
            return value;
        }
    };

    return Stringifier;
}();

exports.default = Stringifier;
module.exports = exports['default'];

},{}],1153:[function(require,module,exports){
'use strict';

exports.__esModule = true;
exports.default = stringify;

var _stringifier = require('./stringifier');

var _stringifier2 = _interopRequireDefault(_stringifier);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function stringify(node, builder) {
    var str = new _stringifier2.default(builder);
    str.stringify(node);
}
module.exports = exports['default'];

},{"./stringifier":1152}],1154:[function(require,module,exports){
'use strict';

exports.__esModule = true;
exports.default = tokenize;
var SINGLE_QUOTE = 39;
var DOUBLE_QUOTE = 34;
var BACKSLASH = 92;
var SLASH = 47;
var NEWLINE = 10;
var SPACE = 32;
var FEED = 12;
var TAB = 9;
var CR = 13;
var OPEN_PARENTHESES = 40;
var CLOSE_PARENTHESES = 41;
var OPEN_CURLY = 123;
var CLOSE_CURLY = 125;
var SEMICOLON = 59;
var ASTERICK = 42;
var COLON = 58;
var AT = 64;
var COMMA = 44;

var RE_AT_END = /[ \n\t\r\f\{\(\)'"\\;/]/g;
var RE_NEW_LINE = /[\r\f\n]/g;
var RE_WORD_END = /[ \n\t\r\f\(\)\{\}:;@!'"\\,]|\/(?=\*)/g;
var RE_BAD_BRACKET = /.[\\\/\("'\n]/;

function tokenize(input) {
    var tokens = [];
    var css = input.css.valueOf();

    var code = void 0,
        next = void 0,
        quote = void 0,
        lines = void 0,
        last = void 0,
        content = void 0,
        escape = void 0,
        nextLine = void 0,
        nextOffset = void 0,
        escaped = void 0,
        escapePos = void 0,
        prev = void 0,
        n = void 0;

    var length = css.length;
    var offset = -1;
    var line = 1;
    var pos = 0;

    function unclosed(what) {
        throw input.error('Unclosed ' + what, line, pos - offset);
    }

    while (pos < length) {
        code = css.charCodeAt(pos);

        if (code === NEWLINE || code === FEED || code === CR && css.charCodeAt(pos + 1) !== NEWLINE) {
            offset = pos;
            line += 1;
        }

        switch (code) {
            case CR:
                if (css.charCodeAt(pos + 1) === NEWLINE) {
                    offset = pos;
                    line += 1;
                    pos += 1;
                    tokens.push(['newline', '\r\n', line - 1]);
                } else {
                    tokens.push(['newline', '\r', line - 1]);
                }
                break;

            case FEED:
            case NEWLINE:
                tokens.push(['newline', css.slice(pos, pos + 1), line - 1]);
                break;

            case SPACE:
            case TAB:
                next = pos;
                do {
                    next += 1;
                    code = css.charCodeAt(next);
                } while (code === SPACE || code === TAB);

                tokens.push(['space', css.slice(pos, next)]);
                pos = next - 1;
                break;

            case OPEN_CURLY:
                tokens.push(['{', '{', line, pos - offset]);
                break;

            case CLOSE_CURLY:
                tokens.push(['}', '}', line, pos - offset]);
                break;

            case COLON:
                tokens.push([':', ':', line, pos - offset]);
                break;

            case SEMICOLON:
                tokens.push([';', ';', line, pos - offset]);
                break;

            case COMMA:
                tokens.push([',', ',', line, pos - offset]);
                break;

            case OPEN_PARENTHESES:
                prev = tokens.length ? tokens[tokens.length - 1][1] : '';
                n = css.charCodeAt(pos + 1);
                if (prev === 'url' && n !== SINGLE_QUOTE && n !== DOUBLE_QUOTE && n !== SPACE && n !== NEWLINE && n !== TAB && n !== FEED && n !== CR) {
                    next = pos;
                    do {
                        escaped = false;
                        next = css.indexOf(')', next + 1);
                        if (next === -1) unclosed('bracket');
                        escapePos = next;
                        while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
                            escapePos -= 1;
                            escaped = !escaped;
                        }
                    } while (escaped);

                    tokens.push(['brackets', css.slice(pos, next + 1), line, pos - offset, line, next - offset]);
                    pos = next;
                } else {
                    next = css.indexOf(')', pos + 1);
                    content = css.slice(pos, next + 1);

                    if (next === -1 || RE_BAD_BRACKET.test(content)) {
                        tokens.push(['(', '(', line, pos - offset]);
                    } else {
                        tokens.push(['brackets', content, line, pos - offset, line, next - offset]);
                        pos = next;
                    }
                }

                break;

            case CLOSE_PARENTHESES:
                tokens.push([')', ')', line, pos - offset]);
                break;

            case SINGLE_QUOTE:
            case DOUBLE_QUOTE:
                quote = code === SINGLE_QUOTE ? '\'' : '"';
                next = pos;
                do {
                    escaped = false;
                    next = css.indexOf(quote, next + 1);
                    if (next === -1) unclosed('quote');
                    escapePos = next;
                    while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
                        escapePos -= 1;
                        escaped = !escaped;
                    }
                } while (escaped);

                content = css.slice(pos, next + 1);
                lines = content.split('\n');
                last = lines.length - 1;

                if (last > 0) {
                    nextLine = line + last;
                    nextOffset = next - lines[last].length;
                } else {
                    nextLine = line;
                    nextOffset = offset;
                }

                tokens.push(['string', css.slice(pos, next + 1), line, pos - offset, nextLine, next - nextOffset]);

                offset = nextOffset;
                line = nextLine;
                pos = next;
                break;

            case AT:
                RE_AT_END.lastIndex = pos + 1;
                RE_AT_END.test(css);
                if (RE_AT_END.lastIndex === 0) {
                    next = css.length - 1;
                } else {
                    next = RE_AT_END.lastIndex - 2;
                }
                tokens.push(['at-word', css.slice(pos, next + 1), line, pos - offset, line, next - offset]);
                pos = next;
                break;

            case BACKSLASH:
                next = pos;
                escape = true;

                nextLine = line;

                while (css.charCodeAt(next + 1) === BACKSLASH) {
                    next += 1;
                    escape = !escape;
                }
                code = css.charCodeAt(next + 1);
                if (escape) {
                    if (code === CR && css.charCodeAt(next + 2) === NEWLINE) {
                        next += 2;
                        nextLine += 1;
                        nextOffset = next;
                    } else if (code === CR || code === NEWLINE || code === FEED) {
                        next += 1;
                        nextLine += 1;
                        nextOffset = next;
                    } else {
                        next += 1;
                    }
                }
                tokens.push(['word', css.slice(pos, next + 1), line, pos - offset, line, next - offset]);
                if (nextLine !== line) {
                    line = nextLine;
                    offset = nextOffset;
                }
                pos = next;
                break;

            default:
                n = css.charCodeAt(pos + 1);

                if (code === SLASH && n === ASTERICK) {
                    next = css.indexOf('*/', pos + 2) + 1;
                    if (next === 0) unclosed('comment');

                    content = css.slice(pos, next + 1);
                    lines = content.split('\n');
                    last = lines.length - 1;

                    if (last > 0) {
                        nextLine = line + last;
                        nextOffset = next - lines[last].length;
                    } else {
                        nextLine = line;
                        nextOffset = offset;
                    }

                    tokens.push(['comment', content, line, pos - offset, nextLine, next - nextOffset]);

                    offset = nextOffset;
                    line = nextLine;
                    pos = next;
                } else if (code === SLASH && n === SLASH) {
                    RE_NEW_LINE.lastIndex = pos + 1;
                    RE_NEW_LINE.test(css);
                    if (RE_NEW_LINE.lastIndex === 0) {
                        next = css.length - 1;
                    } else {
                        next = RE_NEW_LINE.lastIndex - 2;
                    }

                    content = css.slice(pos, next + 1);

                    tokens.push(['comment', content, line, pos - offset, line, next - offset, 'inline']);

                    pos = next;
                } else {
                    RE_WORD_END.lastIndex = pos + 1;
                    RE_WORD_END.test(css);
                    if (RE_WORD_END.lastIndex === 0) {
                        next = css.length - 1;
                    } else {
                        next = RE_WORD_END.lastIndex - 2;
                    }

                    tokens.push(['word', css.slice(pos, next + 1), line, pos - offset, line, next - offset]);
                    pos = next;
                }

                break;
        }

        pos++;
    }

    return tokens;
}
module.exports = exports['default'];

},{}],1155:[function(require,module,exports){
arguments[4][776][0].apply(exports,arguments)
},{"dup":776}],1156:[function(require,module,exports){
module.exports = require( './svg-tags.json' );
},{"./svg-tags.json":1157}],1157:[function(require,module,exports){
module.exports=[
	"a",
	"altGlyph",
	"altGlyphDef",
	"altGlyphItem",
	"animate",
	"animateColor",
	"animateMotion",
	"animateTransform",
	"circle",
	"clipPath",
	"color-profile",
	"cursor",
	"defs",
	"desc",
	"ellipse",
	"feBlend",
	"feColorMatrix",
	"feComponentTransfer",
	"feComposite",
	"feConvolveMatrix",
	"feDiffuseLighting",
	"feDisplacementMap",
	"feDistantLight",
	"feFlood",
	"feFuncA",
	"feFuncB",
	"feFuncG",
	"feFuncR",
	"feGaussianBlur",
	"feImage",
	"feMerge",
	"feMergeNode",
	"feMorphology",
	"feOffset",
	"fePointLight",
	"feSpecularLighting",
	"feSpotLight",
	"feTile",
	"feTurbulence",
	"filter",
	"font",
	"font-face",
	"font-face-format",
	"font-face-name",
	"font-face-src",
	"font-face-uri",
	"foreignObject",
	"g",
	"glyph",
	"glyphRef",
	"hkern",
	"image",
	"line",
	"linearGradient",
	"marker",
	"mask",
	"metadata",
	"missing-glyph",
	"mpath",
	"path",
	"pattern",
	"polygon",
	"polyline",
	"radialGradient",
	"rect",
	"script",
	"set",
	"stop",
	"style",
	"svg",
	"switch",
	"symbol",
	"text",
	"textPath",
	"title",
	"tref",
	"tspan",
	"use",
	"view",
	"vkern"
]
},{}],1158:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _stringWidth = require('string-width');

var _stringWidth2 = _interopRequireDefault(_stringWidth);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

const alignments = ['left', 'right', 'center'];

/**
 * @param {string} subject
 * @param {number} width
 * @returns {string}
 */
const alignLeft = (subject, width) => {
  return subject + _lodash2.default.repeat(' ', width);
};

/**
 * @param {string} subject
 * @param {number} width
 * @returns {string}
 */
const alignRight = (subject, width) => {
  return _lodash2.default.repeat(' ', width) + subject;
};

/**
 * @param {string} subject
 * @param {number} width
 * @returns {string}
 */
const alignCenter = (subject, width) => {
  let halfWidth;

  halfWidth = width / 2;

  if (halfWidth % 2 === 0) {
    return _lodash2.default.repeat(' ', halfWidth) + subject + _lodash2.default.repeat(' ', halfWidth);
  } else {
    halfWidth = _lodash2.default.floor(halfWidth);

    return _lodash2.default.repeat(' ', halfWidth) + subject + _lodash2.default.repeat(' ', halfWidth + 1);
  }
};

/**
 * Pads a string to the left and/or right to position the subject
 * text in a desired alignment within a container.
 *
 * @param {string} subject
 * @param {number} containerWidth
 * @param {string} alignment One of the valid options (left, right, center).
 * @returns {string}
 */

exports.default = (subject, containerWidth, alignment) => {
  if (!_lodash2.default.isString(subject)) {
    throw new Error('Subject parameter value must be a string.');
  }

  if (!_lodash2.default.isNumber(containerWidth)) {
    throw new Error('Container width parameter value must be a number.');
  }

  const subjectWidth = (0, _stringWidth2.default)(subject);

  if (subjectWidth > containerWidth) {
    // console.log('subjectWidth', subjectWidth, 'containerWidth', containerWidth, 'subject', subject);

    throw new Error('Subject parameter value width cannot be greater than the container width.');
  }

  if (!_lodash2.default.isString(alignment)) {
    throw new Error('Alignment parameter value must be a string.');
  }

  if (alignments.indexOf(alignment) === -1) {
    throw new Error('Alignment parameter value must be a known alignment parameter value (left, right, center).');
  }

  if (subjectWidth === 0) {
    return _lodash2.default.repeat(' ', containerWidth);
  }

  const availableWidth = containerWidth - subjectWidth;

  if (alignment === 'left') {
    return alignLeft(subject, availableWidth);
  }

  if (alignment === 'right') {
    return alignRight(subject, availableWidth);
  }

  return alignCenter(subject, availableWidth);
};
},{"lodash":692,"string-width":866}],1159:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _stringWidth = require('string-width');

var _stringWidth2 = _interopRequireDefault(_stringWidth);

var _alignString = require('./alignString');

var _alignString2 = _interopRequireDefault(_alignString);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * @param {table~row[]} rows
 * @param {Object} config
 * @returns {table~row[]}
 */
exports.default = (rows, config) => {
  return _lodash2.default.map(rows, cells => {
    return _lodash2.default.map(cells, (value, index1) => {
      const column = config.columns[index1];

      if ((0, _stringWidth2.default)(value) === column.width) {
        return value;
      } else {
        return (0, _alignString2.default)(value, column.width, column.alignment);
      }
    });
  });
};
},{"./alignString":1158,"lodash":692,"string-width":866}],1160:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _stringWidth = require('string-width');

var _stringWidth2 = _interopRequireDefault(_stringWidth);

var _wrapWord = require('./wrapWord');

var _wrapWord2 = _interopRequireDefault(_wrapWord);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * @param {string} value
 * @param {number} columnWidth
 * @param {boolean} useWrapWord
 * @returns {number}
 */
exports.default = function (value, columnWidth) {
  let useWrapWord = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;

  if (!_lodash2.default.isString(value)) {
    throw new Error('Value must be a string.');
  }

  if (!_lodash2.default.isInteger(columnWidth)) {
    throw new Error('Column width must be an integer.');
  }

  if (columnWidth < 1) {
    throw new Error('Column width must be greater than 0.');
  }

  if (useWrapWord) {
    return (0, _wrapWord2.default)(value, columnWidth).length;
  }

  return _lodash2.default.ceil((0, _stringWidth2.default)(value) / columnWidth);
};
},{"./wrapWord":1180,"lodash":692,"string-width":866}],1161:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _stringWidth = require('string-width');

var _stringWidth2 = _interopRequireDefault(_stringWidth);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Calculates width of each cell contents.
 *
 * @param {string[]} cells
 * @returns {number[]}
 */
exports.default = cells => {
  return _lodash2.default.map(cells, value => {
    return (0, _stringWidth2.default)(value);
  });
};
},{"lodash":692,"string-width":866}],1162:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _calculateCellWidthIndex = require('./calculateCellWidthIndex');

var _calculateCellWidthIndex2 = _interopRequireDefault(_calculateCellWidthIndex);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Produces an array of values that describe the largest value length (width) in every column.
 *
 * @param {Array[]} rows
 * @returns {number[]}
 */
exports.default = rows => {
  if (!rows[0]) {
    throw new Error('Dataset must have at least one row.');
  }

  const columns = _lodash2.default.fill(Array(rows[0].length), 0);

  _lodash2.default.forEach(rows, row => {
    const columnWidthIndex = (0, _calculateCellWidthIndex2.default)(row);

    _lodash2.default.forEach(columnWidthIndex, (valueWidth, index0) => {
      if (columns[index0] < valueWidth) {
        columns[index0] = valueWidth;
      }
    });
  });

  return columns;
};
},{"./calculateCellWidthIndex":1161,"lodash":692}],1163:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _calculateCellHeight = require('./calculateCellHeight');

var _calculateCellHeight2 = _interopRequireDefault(_calculateCellHeight);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Calculates the vertical row span index.
 *
 * @param {Array[]} rows
 * @param {Object} config
 * @returns {number[]}
 */
exports.default = (rows, config) => {
  const tableWidth = rows[0].length;

  const rowSpanIndex = [];

  _lodash2.default.forEach(rows, cells => {
    const cellHeightIndex = _lodash2.default.fill(Array(tableWidth), 1);

    _lodash2.default.forEach(cells, (value, index1) => {
      if (!_lodash2.default.isNumber(config.columns[index1].width)) {
        throw new Error('column[index].width must be a number.');
      }

      if (!_lodash2.default.isBoolean(config.columns[index1].wrapWord)) {
        throw new Error('column[index].wrapWord must be a boolean.');
      }

      cellHeightIndex[index1] = (0, _calculateCellHeight2.default)(value, config.columns[index1].width, config.columns[index1].wrapWord);
    });

    rowSpanIndex.push(_lodash2.default.max(cellHeightIndex));
  });

  return rowSpanIndex;
};
},{"./calculateCellHeight":1160,"lodash":692}],1164:[function(require,module,exports){
(function (process){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _makeStreamConfig = require('./makeStreamConfig');

var _makeStreamConfig2 = _interopRequireDefault(_makeStreamConfig);

var _drawRow = require('./drawRow');

var _drawRow2 = _interopRequireDefault(_drawRow);

var _drawBorder = require('./drawBorder');

var _stringifyTableData = require('./stringifyTableData');

var _stringifyTableData2 = _interopRequireDefault(_stringifyTableData);

var _truncateTableData = require('./truncateTableData');

var _truncateTableData2 = _interopRequireDefault(_truncateTableData);

var _mapDataUsingRowHeightIndex = require('./mapDataUsingRowHeightIndex');

var _mapDataUsingRowHeightIndex2 = _interopRequireDefault(_mapDataUsingRowHeightIndex);

var _alignTableData = require('./alignTableData');

var _alignTableData2 = _interopRequireDefault(_alignTableData);

var _padTableData = require('./padTableData');

var _padTableData2 = _interopRequireDefault(_padTableData);

var _calculateRowHeightIndex = require('./calculateRowHeightIndex');

var _calculateRowHeightIndex2 = _interopRequireDefault(_calculateRowHeightIndex);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * @param {Array} data
 * @param {Object} config
 * @returns {Array}
 */
const prepareData = (data, config) => {
  let rows;

  rows = (0, _stringifyTableData2.default)(data);

  rows = (0, _truncateTableData2.default)(data, config);

  const rowHeightIndex = (0, _calculateRowHeightIndex2.default)(rows, config);

  rows = (0, _mapDataUsingRowHeightIndex2.default)(rows, rowHeightIndex, config);
  rows = (0, _alignTableData2.default)(rows, config);
  rows = (0, _padTableData2.default)(rows, config);

  return rows;
};

/**
 * @param {string[]} row
 * @param {number[]} columnWidthIndex
 * @param {Object} config
 * @returns {undefined}
 */
const create = (row, columnWidthIndex, config) => {
  const rows = prepareData([row], config);

  const body = _lodash2.default.map(rows, literalRow => {
    return (0, _drawRow2.default)(literalRow, config.border);
  }).join('');

  let output;

  output = '';

  output += (0, _drawBorder.drawBorderTop)(columnWidthIndex, config.border);
  output += body;
  output += (0, _drawBorder.drawBorderBottom)(columnWidthIndex, config.border);

  output = _lodash2.default.trimEnd(output);

  process.stdout.write(output);
};

/**
 * @param {string[]} row
 * @param {number[]} columnWidthIndex
 * @param {Object} config
 * @returns {undefined}
 */
const append = (row, columnWidthIndex, config) => {
  const rows = prepareData([row], config);

  const body = _lodash2.default.map(rows, literalRow => {
    return (0, _drawRow2.default)(literalRow, config.border);
  }).join('');

  let output;

  output = '\r\x1b[K';

  output += (0, _drawBorder.drawBorderJoin)(columnWidthIndex, config.border);
  output += body;
  output += (0, _drawBorder.drawBorderBottom)(columnWidthIndex, config.border);

  output = _lodash2.default.trimEnd(output);

  process.stdout.write(output);
};

/**
 * @param {Object} userConfig
 * @returns {Object}
 */

exports.default = function () {
  let userConfig = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

  const config = (0, _makeStreamConfig2.default)(userConfig);

  const columnWidthIndex = _lodash2.default.mapValues(config.columns, column => {
    return column.width + column.paddingLeft + column.paddingRight;
  });

  let empty;

  empty = true;

  return {
    /**
     * @param {string[]} row
     * @returns {undefined}
     */
    write: row => {
      if (row.length !== config.columnCount) {
        throw new Error('Row cell count does not match the config.columnCount.');
      }

      if (empty) {
        empty = false;

        return create(row, columnWidthIndex, config);
      } else {
        return append(row, columnWidthIndex, config);
      }
    }
  };
};
}).call(this,require('_process'))
},{"./alignTableData":1159,"./calculateRowHeightIndex":1163,"./drawBorder":1165,"./drawRow":1166,"./makeStreamConfig":1171,"./mapDataUsingRowHeightIndex":1172,"./padTableData":1173,"./stringifyTableData":1174,"./truncateTableData":1176,"_process":16,"lodash":692}],1165:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.drawBorderTop = exports.drawBorderJoin = exports.drawBorderBottom = exports.drawBorder = undefined;

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * @typedef drawBorder~parts
 * @property {string} left
 * @property {string} right
 * @property {string} body
 * @property {string} join
 */

/**
 * @param {number[]} columnSizeIndex
 * @param {drawBorder~parts} parts
 * @returns {string}
 */
const drawBorder = (columnSizeIndex, parts) => {
  const columns = _lodash2.default.map(columnSizeIndex, size => {
    return _lodash2.default.repeat(parts.body, size);
  }).join(parts.join);

  return parts.left + columns + parts.right + '\n';
};

/**
 * @typedef drawBorderTop~parts
 * @property {string} topLeft
 * @property {string} topRight
 * @property {string} topBody
 * @property {string} topJoin
 */

/**
 * @param {number[]} columnSizeIndex
 * @param {drawBorderTop~parts} parts
 * @returns {string}
 */
const drawBorderTop = (columnSizeIndex, parts) => {
  return drawBorder(columnSizeIndex, {
    body: parts.topBody,
    join: parts.topJoin,
    left: parts.topLeft,
    right: parts.topRight
  });
};

/**
 * @typedef drawBorderJoin~parts
 * @property {string} joinLeft
 * @property {string} joinRight
 * @property {string} joinBody
 * @property {string} joinJoin
 */

/**
 * @param {number[]} columnSizeIndex
 * @param {drawBorderJoin~parts} parts
 * @returns {string}
 */
const drawBorderJoin = (columnSizeIndex, parts) => {
  return drawBorder(columnSizeIndex, {
    body: parts.joinBody,
    join: parts.joinJoin,
    left: parts.joinLeft,
    right: parts.joinRight
  });
};

/**
 * @typedef drawBorderBottom~parts
 * @property {string} topLeft
 * @property {string} topRight
 * @property {string} topBody
 * @property {string} topJoin
 */

/**
 * @param {number[]} columnSizeIndex
 * @param {drawBorderBottom~parts} parts
 * @returns {string}
 */
const drawBorderBottom = (columnSizeIndex, parts) => {
  return drawBorder(columnSizeIndex, {
    body: parts.bottomBody,
    join: parts.bottomJoin,
    left: parts.bottomLeft,
    right: parts.bottomRight
  });
};

exports.drawBorder = drawBorder;
exports.drawBorderBottom = drawBorderBottom;
exports.drawBorderJoin = drawBorderJoin;
exports.drawBorderTop = drawBorderTop;
},{"lodash":692}],1166:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

/**
 * @typedef {Object} drawRow~border
 * @property {string} bodyLeft
 * @property {string} bodyRight
 * @property {string} bodyJoin
 */

/**
 * @param {number[]} columns
 * @param {drawRow~border} border
 * @returns {string}
 */
exports.default = (columns, border) => {
  return border.bodyLeft + columns.join(border.bodyJoin) + border.bodyRight + '\n';
};
},{}],1167:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _drawBorder = require('./drawBorder');

var _drawRow = require('./drawRow');

var _drawRow2 = _interopRequireDefault(_drawRow);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * @param {Array} rows
 * @param {Object} border
 * @param {Array} columnSizeIndex
 * @param {Array} rowSpanIndex
 * @param {Function} drawHorizontalLine
 * @returns {string}
 */
exports.default = (rows, border, columnSizeIndex, rowSpanIndex, drawHorizontalLine) => {
  let output, realRowIndex, rowHeight;

  const rowCount = rows.length;

  realRowIndex = 0;

  output = '';

  if (drawHorizontalLine(realRowIndex, rowCount)) {
    output += (0, _drawBorder.drawBorderTop)(columnSizeIndex, border);
  }

  _lodash2.default.forEach(rows, (row, index0) => {
    output += (0, _drawRow2.default)(row, border);

    if (!rowHeight) {
      rowHeight = rowSpanIndex[realRowIndex];

      realRowIndex++;
    }

    rowHeight--;

    if (rowHeight === 0 && index0 !== rowCount - 1 && drawHorizontalLine(realRowIndex, rowCount)) {
      output += (0, _drawBorder.drawBorderJoin)(columnSizeIndex, border);
    }
  });

  if (drawHorizontalLine(realRowIndex, rowCount)) {
    output += (0, _drawBorder.drawBorderBottom)(columnSizeIndex, border);
  }

  return output;
};
},{"./drawBorder":1165,"./drawRow":1166,"lodash":692}],1168:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

/* eslint-disable sort-keys */

/**
 * @typedef border
 * @property {string} topBody
 * @property {string} topJoin
 * @property {string} topLeft
 * @property {string} topRight
 * @property {string} bottomBody
 * @property {string} bottomJoin
 * @property {string} bottomLeft
 * @property {string} bottomRight
 * @property {string} bodyLeft
 * @property {string} bodyRight
 * @property {string} bodyJoin
 * @property {string} joinBody
 * @property {string} joinLeft
 * @property {string} joinRight
 * @property {string} joinJoin
 */

/**
 * @param {string} name
 * @returns {border}
 */
exports.default = name => {
  if (name === 'honeywell') {
    return {
      topBody: '═',
      topJoin: '╤',
      topLeft: '╔',
      topRight: '╗',

      bottomBody: '═',
      bottomJoin: '╧',
      bottomLeft: '╚',
      bottomRight: '╝',

      bodyLeft: '║',
      bodyRight: '║',
      bodyJoin: '│',

      joinBody: '─',
      joinLeft: '╟',
      joinRight: '╢',
      joinJoin: '┼'
    };
  }

  if (name === 'norc') {
    return {
      topBody: '─',
      topJoin: '┬',
      topLeft: '┌',
      topRight: '┐',

      bottomBody: '─',
      bottomJoin: '┴',
      bottomLeft: '└',
      bottomRight: '┘',

      bodyLeft: '│',
      bodyRight: '│',
      bodyJoin: '│',

      joinBody: '─',
      joinLeft: '├',
      joinRight: '┤',
      joinJoin: '┼'
    };
  }

  if (name === 'ramac') {
    return {
      topBody: '-',
      topJoin: '+',
      topLeft: '+',
      topRight: '+',

      bottomBody: '-',
      bottomJoin: '+',
      bottomLeft: '+',
      bottomRight: '+',

      bodyLeft: '|',
      bodyRight: '|',
      bodyJoin: '|',

      joinBody: '-',
      joinLeft: '|',
      joinRight: '|',
      joinJoin: '|'
    };
  }

  if (name === 'void') {
    return {
      topBody: '',
      topJoin: '',
      topLeft: '',
      topRight: '',

      bottomBody: '',
      bottomJoin: '',
      bottomLeft: '',
      bottomRight: '',

      bodyLeft: '',
      bodyRight: '',
      bodyJoin: '',

      joinBody: '',
      joinLeft: '',
      joinRight: '',
      joinJoin: ''
    };
  }

  throw new Error('Unknown border template "' + name + '".');
};
},{}],1169:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getBorderCharacters = exports.createStream = exports.table = undefined;

var _table = require('./table');

var _table2 = _interopRequireDefault(_table);

var _createStream = require('./createStream');

var _createStream2 = _interopRequireDefault(_createStream);

var _getBorderCharacters = require('./getBorderCharacters');

var _getBorderCharacters2 = _interopRequireDefault(_getBorderCharacters);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.table = _table2.default;
exports.createStream = _createStream2.default;
exports.getBorderCharacters = _getBorderCharacters2.default;
},{"./createStream":1164,"./getBorderCharacters":1168,"./table":1175}],1170:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _getBorderCharacters = require('./getBorderCharacters');

var _getBorderCharacters2 = _interopRequireDefault(_getBorderCharacters);

var _validateConfig = require('./validateConfig');

var _validateConfig2 = _interopRequireDefault(_validateConfig);

var _calculateMaximumColumnWidthIndex = require('./calculateMaximumColumnWidthIndex');

var _calculateMaximumColumnWidthIndex2 = _interopRequireDefault(_calculateMaximumColumnWidthIndex);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Merges user provided border characters with the default border ("honeywell") characters.
 *
 * @param {Object} border
 * @returns {Object}
 */
const makeBorder = function makeBorder() {
  let border = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

  return _lodash2.default.assign({}, (0, _getBorderCharacters2.default)('honeywell'), border);
};

/**
 * Creates a configuration for every column using default
 * values for the missing configuration properties.
 *
 * @param {Array[]} rows
 * @param {Object} columns
 * @param {Object} columnDefault
 * @returns {Object}
 */
const makeColumns = function makeColumns(rows) {
  let columns = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  let columnDefault = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};

  const maximumColumnWidthIndex = (0, _calculateMaximumColumnWidthIndex2.default)(rows);

  _lodash2.default.times(rows[0].length, index => {
    if (_lodash2.default.isUndefined(columns[index])) {
      columns[index] = {};
    }

    columns[index] = _lodash2.default.assign({
      alignment: 'left',
      paddingLeft: 1,
      paddingRight: 1,
      truncate: Infinity,
      width: maximumColumnWidthIndex[index],
      wrapWord: false
    }, columnDefault, columns[index]);
  });

  return columns;
};

/**
 * Makes a new configuration object out of the userConfig object
 * using default values for the missing configuration properties.
 *
 * @param {Array[]} rows
 * @param {Object} userConfig
 * @returns {Object}
 */

exports.default = function (rows) {
  let userConfig = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

  (0, _validateConfig2.default)('config.json', userConfig);

  const config = _lodash2.default.cloneDeep(userConfig);

  config.border = makeBorder(config.border);
  config.columns = makeColumns(rows, config.columns, config.columnDefault);

  if (!config.drawHorizontalLine) {
    /**
     * @returns {boolean}
     */
    config.drawHorizontalLine = () => {
      return true;
    };
  }

  return config;
};
},{"./calculateMaximumColumnWidthIndex":1162,"./getBorderCharacters":1168,"./validateConfig":1177,"lodash":692}],1171:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _getBorderCharacters = require('./getBorderCharacters');

var _getBorderCharacters2 = _interopRequireDefault(_getBorderCharacters);

var _validateConfig = require('./validateConfig');

var _validateConfig2 = _interopRequireDefault(_validateConfig);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Merges user provided border characters with the default border ("honeywell") characters.
 *
 * @param {Object} border
 * @returns {Object}
 */
const makeBorder = function makeBorder() {
  let border = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

  return _lodash2.default.assign({}, (0, _getBorderCharacters2.default)('honeywell'), border);
};

/**
 * Creates a configuration for every column using default
 * values for the missing configuration properties.
 *
 * @param {number} columnCount
 * @param {Object} columns
 * @param {Object} columnDefault
 * @returns {Object}
 */
const makeColumns = function makeColumns(columnCount) {
  let columns = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  let columnDefault = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};

  _lodash2.default.times(columnCount, index => {
    if (_lodash2.default.isUndefined(columns[index])) {
      columns[index] = {};
    }

    columns[index] = _lodash2.default.assign({
      alignment: 'left',
      paddingLeft: 1,
      paddingRight: 1,
      truncate: Infinity,
      wrapWord: false
    }, columnDefault, columns[index]);
  });

  return columns;
};

/**
 * @typedef {Object} columnConfig
 * @property {string} alignment
 * @property {number} width
 * @property {number} truncate
 * @property {number} paddingLeft
 * @property {number} paddingRight
 */

/**
 * @typedef {Object} streamConfig
 * @property {columnConfig} columnDefault
 * @property {Object} border
 * @property {columnConfig[]}
 * @property {number} columnCount Number of columns in the table (required).
 */

/**
 * Makes a new configuration object out of the userConfig object
 * using default values for the missing configuration properties.
 *
 * @param {streamConfig} userConfig
 * @returns {Object}
 */

exports.default = function () {
  let userConfig = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

  (0, _validateConfig2.default)('streamConfig.json', userConfig);

  const config = _lodash2.default.cloneDeep(userConfig);

  if (!config.columnDefault || !config.columnDefault.width) {
    throw new Error('Must provide config.columnDefault.width when creating a stream.');
  }

  if (!config.columnCount) {
    throw new Error('Must provide config.columnCount.');
  }

  config.border = makeBorder(config.border);
  config.columns = makeColumns(config.columnCount, config.columns, config.columnDefault);

  return config;
};
},{"./getBorderCharacters":1168,"./validateConfig":1177,"lodash":692}],1172:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _wrapString = require('./wrapString');

var _wrapString2 = _interopRequireDefault(_wrapString);

var _wrapWord = require('./wrapWord');

var _wrapWord2 = _interopRequireDefault(_wrapWord);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * @param {Array} unmappedRows
 * @param {number[]} rowHeightIndex
 * @param {Object} config
 * @returns {Array}
 */
exports.default = (unmappedRows, rowHeightIndex, config) => {
  const tableWidth = unmappedRows[0].length;

  const mappedRows = _lodash2.default.map(unmappedRows, (cells, index0) => {
    const rowHeight = _lodash2.default.times(rowHeightIndex[index0], () => {
      return _lodash2.default.fill(Array(tableWidth), '');
    });

    // rowHeight
    //     [{row index within rowSaw; index2}]
    //     [{cell index within a virtual row; index1}]

    _lodash2.default.forEach(cells, (value, index1) => {
      let chunkedValue;

      if (config.columns[index1].wrapWord) {
        chunkedValue = (0, _wrapWord2.default)(value, config.columns[index1].width);
      } else {
        chunkedValue = (0, _wrapString2.default)(value, config.columns[index1].width);
      }

      _lodash2.default.forEach(chunkedValue, (part, index2) => {
        rowHeight[index2][index1] = part;
      });
    });

    return rowHeight;
  });

  return _lodash2.default.flatten(mappedRows);
};
},{"./wrapString":1179,"./wrapWord":1180,"lodash":692}],1173:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * @param {table~row[]} rows
 * @param {Object} config
 * @returns {table~row[]}
 */
exports.default = (rows, config) => {
  return _lodash2.default.map(rows, cells => {
    return _lodash2.default.map(cells, (value, index1) => {
      const column = config.columns[index1];

      return _lodash2.default.repeat(' ', column.paddingLeft) + value + _lodash2.default.repeat(' ', column.paddingRight);
    });
  });
};
},{"lodash":692}],1174:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Casts all cell values to a string.
 *
 * @param {table~row[]} rows
 * @returns {table~row[]}
 */
exports.default = rows => {
  return _lodash2.default.map(rows, cells => {
    return _lodash2.default.map(cells, String);
  });
};
},{"lodash":692}],1175:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _drawTable = require('./drawTable');

var _drawTable2 = _interopRequireDefault(_drawTable);

var _calculateCellWidthIndex = require('./calculateCellWidthIndex');

var _calculateCellWidthIndex2 = _interopRequireDefault(_calculateCellWidthIndex);

var _makeConfig = require('./makeConfig');

var _makeConfig2 = _interopRequireDefault(_makeConfig);

var _calculateRowHeightIndex = require('./calculateRowHeightIndex');

var _calculateRowHeightIndex2 = _interopRequireDefault(_calculateRowHeightIndex);

var _mapDataUsingRowHeightIndex = require('./mapDataUsingRowHeightIndex');

var _mapDataUsingRowHeightIndex2 = _interopRequireDefault(_mapDataUsingRowHeightIndex);

var _alignTableData = require('./alignTableData');

var _alignTableData2 = _interopRequireDefault(_alignTableData);

var _padTableData = require('./padTableData');

var _padTableData2 = _interopRequireDefault(_padTableData);

var _validateTableData = require('./validateTableData');

var _validateTableData2 = _interopRequireDefault(_validateTableData);

var _stringifyTableData = require('./stringifyTableData');

var _stringifyTableData2 = _interopRequireDefault(_stringifyTableData);

var _truncateTableData = require('./truncateTableData');

var _truncateTableData2 = _interopRequireDefault(_truncateTableData);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * @typedef {string} table~cell
 */

/**
 * @typedef {table~cell[]} table~row
 */

/**
 * @typedef {Object} table~columns
 * @property {string} alignment Cell content alignment (enum: left, center, right) (default: left).
 * @property {number} width Column width (default: auto).
 * @property {number} truncate Number of characters are which the content will be truncated (default: Infinity).
 * @property {number} paddingLeft Cell content padding width left (default: 1).
 * @property {number} paddingRight Cell content padding width right (default: 1).
 */

/**
 * @typedef {Object} table~border
 * @property {string} topBody
 * @property {string} topJoin
 * @property {string} topLeft
 * @property {string} topRight
 * @property {string} bottomBody
 * @property {string} bottomJoin
 * @property {string} bottomLeft
 * @property {string} bottomRight
 * @property {string} bodyLeft
 * @property {string} bodyRight
 * @property {string} bodyJoin
 * @property {string} joinBody
 * @property {string} joinLeft
 * @property {string} joinRight
 * @property {string} joinJoin
 */

/**
 * Used to tell whether to draw a horizontal line.
 * This callback is called for each non-content line of the table.
 * The default behavior is to always return true.
 *
 * @typedef {Function} drawHorizontalLine
 * @param {number} index
 * @param {number} size
 * @returns {boolean}
 */

/**
 * @typedef {Object} table~config
 * @property {table~border} border
 * @property {table~columns[]} columns Column specific configuration.
 * @property {table~columns} columnDefault Default values for all columns. Column specific settings overwrite the default values.
 * @property {table~drawHorizontalLine} drawHorizontalLine
 */

/**
 * Generates a text table.
 *
 * @param {table~row[]} data
 * @param {table~config} userConfig
 * @returns {string}
 */
exports.default = function (data) {
  let userConfig = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

  let rows;

  (0, _validateTableData2.default)(data);

  rows = (0, _stringifyTableData2.default)(data);

  const config = (0, _makeConfig2.default)(rows, userConfig);

  rows = (0, _truncateTableData2.default)(data, config);

  const rowHeightIndex = (0, _calculateRowHeightIndex2.default)(rows, config);

  rows = (0, _mapDataUsingRowHeightIndex2.default)(rows, rowHeightIndex, config);
  rows = (0, _alignTableData2.default)(rows, config);
  rows = (0, _padTableData2.default)(rows, config);

  const cellWidthIndex = (0, _calculateCellWidthIndex2.default)(rows[0]);

  return (0, _drawTable2.default)(rows, config.border, cellWidthIndex, rowHeightIndex, config.drawHorizontalLine);
};
},{"./alignTableData":1159,"./calculateCellWidthIndex":1161,"./calculateRowHeightIndex":1163,"./drawTable":1167,"./makeConfig":1170,"./mapDataUsingRowHeightIndex":1172,"./padTableData":1173,"./stringifyTableData":1174,"./truncateTableData":1176,"./validateTableData":1178}],1176:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * @todo Make it work with ASCII content.
 * @param {table~row[]} rows
 * @param {Object} config
 * @returns {table~row[]}
 */
exports.default = (rows, config) => {
  return _lodash2.default.map(rows, cells => {
    return _lodash2.default.map(cells, (content, index) => {
      return _lodash2.default.truncate(content, {
        length: config.columns[index].truncate
      });
    });
  });
};
},{"lodash":692}],1177:[function(require,module,exports){
'use strict';
var equal = require('ajv/lib/compile/equal');
var validate = (function() {
  var pattern0 = new RegExp('^[0-9]+$');
  var refVal = [];
  var refVal1 = (function() {
    var pattern0 = new RegExp('^[0-9]+$');
    return function validate(data, dataPath, parentData, parentDataProperty, rootData) {
      'use strict';
      var vErrors = null;
      var errors = 0;
      if (rootData === undefined) rootData = data;
      if ((data && typeof data === "object" && !Array.isArray(data))) {
        var errs__0 = errors;
        var valid1 = true;
        for (var key0 in data) {
          var isAdditional0 = !(false || validate.schema.properties[key0]);
          if (isAdditional0) {
            valid1 = false;
            var err = {
              keyword: 'additionalProperties',
              dataPath: (dataPath || '') + "",
              schemaPath: '#/additionalProperties',
              params: {
                additionalProperty: '' + key0 + ''
              },
              message: 'should NOT have additional properties'
            };
            if (vErrors === null) vErrors = [err];
            else vErrors.push(err);
            errors++;
          }
        }
        if (data.topBody !== undefined) {
          var errs_1 = errors;
          if (!refVal2(data.topBody, (dataPath || '') + '.topBody', data, 'topBody', rootData)) {
            if (vErrors === null) vErrors = refVal2.errors;
            else vErrors = vErrors.concat(refVal2.errors);
            errors = vErrors.length;
          }
          var valid1 = errors === errs_1;
        }
        if (data.topJoin !== undefined) {
          var errs_1 = errors;
          if (!refVal[2](data.topJoin, (dataPath || '') + '.topJoin', data, 'topJoin', rootData)) {
            if (vErrors === null) vErrors = refVal[2].errors;
            else vErrors = vErrors.concat(refVal[2].errors);
            errors = vErrors.length;
          }
          var valid1 = errors === errs_1;
        }
        if (data.topLeft !== undefined) {
          var errs_1 = errors;
          if (!refVal[2](data.topLeft, (dataPath || '') + '.topLeft', data, 'topLeft', rootData)) {
            if (vErrors === null) vErrors = refVal[2].errors;
            else vErrors = vErrors.concat(refVal[2].errors);
            errors = vErrors.length;
          }
          var valid1 = errors === errs_1;
        }
        if (data.topRight !== undefined) {
          var errs_1 = errors;
          if (!refVal[2](data.topRight, (dataPath || '') + '.topRight', data, 'topRight', rootData)) {
            if (vErrors === null) vErrors = refVal[2].errors;
            else vErrors = vErrors.concat(refVal[2].errors);
            errors = vErrors.length;
          }
          var valid1 = errors === errs_1;
        }
        if (data.bottomBody !== undefined) {
          var errs_1 = errors;
          if (!refVal[2](data.bottomBody, (dataPath || '') + '.bottomBody', data, 'bottomBody', rootData)) {
            if (vErrors === null) vErrors = refVal[2].errors;
            else vErrors = vErrors.concat(refVal[2].errors);
            errors = vErrors.length;
          }
          var valid1 = errors === errs_1;
        }
        if (data.bottomJoin !== undefined) {
          var errs_1 = errors;
          if (!refVal[2](data.bottomJoin, (dataPath || '') + '.bottomJoin', data, 'bottomJoin', rootData)) {
            if (vErrors === null) vErrors = refVal[2].errors;
            else vErrors = vErrors.concat(refVal[2].errors);
            errors = vErrors.length;
          }
          var valid1 = errors === errs_1;
        }
        if (data.bottomLeft !== undefined) {
          var errs_1 = errors;
          if (!refVal[2](data.bottomLeft, (dataPath || '') + '.bottomLeft', data, 'bottomLeft', rootData)) {
            if (vErrors === null) vErrors = refVal[2].errors;
            else vErrors = vErrors.concat(refVal[2].errors);
            errors = vErrors.length;
          }
          var valid1 = errors === errs_1;
        }
        if (data.bottomRight !== undefined) {
          var errs_1 = errors;
          if (!refVal[2](data.bottomRight, (dataPath || '') + '.bottomRight', data, 'bottomRight', rootData)) {
            if (vErrors === null) vErrors = refVal[2].errors;
            else vErrors = vErrors.concat(refVal[2].errors);
            errors = vErrors.length;
          }
          var valid1 = errors === errs_1;
        }
        if (data.bodyLeft !== undefined) {
          var errs_1 = errors;
          if (!refVal[2](data.bodyLeft, (dataPath || '') + '.bodyLeft', data, 'bodyLeft', rootData)) {
            if (vErrors === null) vErrors = refVal[2].errors;
            else vErrors = vErrors.concat(refVal[2].errors);
            errors = vErrors.length;
          }
          var valid1 = errors === errs_1;
        }
        if (data.bodyRight !== undefined) {
          var errs_1 = errors;
          if (!refVal[2](data.bodyRight, (dataPath || '') + '.bodyRight', data, 'bodyRight', rootData)) {
            if (vErrors === null) vErrors = refVal[2].errors;
            else vErrors = vErrors.concat(refVal[2].errors);
            errors = vErrors.length;
          }
          var valid1 = errors === errs_1;
        }
        if (data.bodyJoin !== undefined) {
          var errs_1 = errors;
          if (!refVal[2](data.bodyJoin, (dataPath || '') + '.bodyJoin', data, 'bodyJoin', rootData)) {
            if (vErrors === null) vErrors = refVal[2].errors;
            else vErrors = vErrors.concat(refVal[2].errors);
            errors = vErrors.length;
          }
          var valid1 = errors === errs_1;
        }
        if (data.joinBody !== undefined) {
          var errs_1 = errors;
          if (!refVal[2](data.joinBody, (dataPath || '') + '.joinBody', data, 'joinBody', rootData)) {
            if (vErrors === null) vErrors = refVal[2].errors;
            else vErrors = vErrors.concat(refVal[2].errors);
            errors = vErrors.length;
          }
          var valid1 = errors === errs_1;
        }
        if (data.joinLeft !== undefined) {
          var errs_1 = errors;
          if (!refVal[2](data.joinLeft, (dataPath || '') + '.joinLeft', data, 'joinLeft', rootData)) {
            if (vErrors === null) vErrors = refVal[2].errors;
            else vErrors = vErrors.concat(refVal[2].errors);
            errors = vErrors.length;
          }
          var valid1 = errors === errs_1;
        }
        if (data.joinRight !== undefined) {
          var errs_1 = errors;
          if (!refVal[2](data.joinRight, (dataPath || '') + '.joinRight', data, 'joinRight', rootData)) {
            if (vErrors === null) vErrors = refVal[2].errors;
            else vErrors = vErrors.concat(refVal[2].errors);
            errors = vErrors.length;
          }
          var valid1 = errors === errs_1;
        }
        if (data.joinJoin !== undefined) {
          var errs_1 = errors;
          if (!refVal[2](data.joinJoin, (dataPath || '') + '.joinJoin', data, 'joinJoin', rootData)) {
            if (vErrors === null) vErrors = refVal[2].errors;
            else vErrors = vErrors.concat(refVal[2].errors);
            errors = vErrors.length;
          }
          var valid1 = errors === errs_1;
        }
      } else {
        var err = {
          keyword: 'type',
          dataPath: (dataPath || '') + "",
          schemaPath: '#/type',
          params: {
            type: 'object'
          },
          message: 'should be object'
        };
        if (vErrors === null) vErrors = [err];
        else vErrors.push(err);
        errors++;
      }
      validate.errors = vErrors;
      return errors === 0;
    };
  })();
  refVal1.schema = {
    "type": "object",
    "properties": {
      "topBody": {
        "$ref": "#/definitions/border"
      },
      "topJoin": {
        "$ref": "#/definitions/border"
      },
      "topLeft": {
        "$ref": "#/definitions/border"
      },
      "topRight": {
        "$ref": "#/definitions/border"
      },
      "bottomBody": {
        "$ref": "#/definitions/border"
      },
      "bottomJoin": {
        "$ref": "#/definitions/border"
      },
      "bottomLeft": {
        "$ref": "#/definitions/border"
      },
      "bottomRight": {
        "$ref": "#/definitions/border"
      },
      "bodyLeft": {
        "$ref": "#/definitions/border"
      },
      "bodyRight": {
        "$ref": "#/definitions/border"
      },
      "bodyJoin": {
        "$ref": "#/definitions/border"
      },
      "joinBody": {
        "$ref": "#/definitions/border"
      },
      "joinLeft": {
        "$ref": "#/definitions/border"
      },
      "joinRight": {
        "$ref": "#/definitions/border"
      },
      "joinJoin": {
        "$ref": "#/definitions/border"
      }
    },
    "additionalProperties": false
  };
  refVal1.errors = null;
  refVal[1] = refVal1;
  var refVal2 = (function() {
    var pattern0 = new RegExp('^[0-9]+$');
    return function validate(data, dataPath, parentData, parentDataProperty, rootData) {
      'use strict';
      var vErrors = null;
      var errors = 0;
      if (rootData === undefined) rootData = data;
      if (typeof data !== "string") {
        var err = {
          keyword: 'type',
          dataPath: (dataPath || '') + "",
          schemaPath: '#/type',
          params: {
            type: 'string'
          },
          message: 'should be string'
        };
        if (vErrors === null) vErrors = [err];
        else vErrors.push(err);
        errors++;
      }
      validate.errors = vErrors;
      return errors === 0;
    };
  })();
  refVal2.schema = {
    "type": "string"
  };
  refVal2.errors = null;
  refVal[2] = refVal2;
  var refVal3 = (function() {
    var pattern0 = new RegExp('^[0-9]+$');
    return function validate(data, dataPath, parentData, parentDataProperty, rootData) {
      'use strict';
      var vErrors = null;
      var errors = 0;
      if (rootData === undefined) rootData = data;
      if ((data && typeof data === "object" && !Array.isArray(data))) {
        var errs__0 = errors;
        var valid1 = true;
        for (var key0 in data) {
          var isAdditional0 = !(false || pattern0.test(key0));
          if (isAdditional0) {
            valid1 = false;
            var err = {
              keyword: 'additionalProperties',
              dataPath: (dataPath || '') + "",
              schemaPath: '#/additionalProperties',
              params: {
                additionalProperty: '' + key0 + ''
              },
              message: 'should NOT have additional properties'
            };
            if (vErrors === null) vErrors = [err];
            else vErrors.push(err);
            errors++;
          }
        }
        for (var key0 in data) {
          if (pattern0.test(key0)) {
            var errs_1 = errors;
            if (!refVal4(data[key0], (dataPath || '') + '[\'' + key0 + '\']', data, key0, rootData)) {
              if (vErrors === null) vErrors = refVal4.errors;
              else vErrors = vErrors.concat(refVal4.errors);
              errors = vErrors.length;
            }
            var valid1 = errors === errs_1;
          }
        }
      } else {
        var err = {
          keyword: 'type',
          dataPath: (dataPath || '') + "",
          schemaPath: '#/type',
          params: {
            type: 'object'
          },
          message: 'should be object'
        };
        if (vErrors === null) vErrors = [err];
        else vErrors.push(err);
        errors++;
      }
      validate.errors = vErrors;
      return errors === 0;
    };
  })();
  refVal3.schema = {
    "type": "object",
    "patternProperties": {
      "^[0-9]+$": {
        "$ref": "#/definitions/column"
      }
    },
    "additionalProperties": false
  };
  refVal3.errors = null;
  refVal[3] = refVal3;
  var refVal4 = (function() {
    var pattern0 = new RegExp('^[0-9]+$');
    return function validate(data, dataPath, parentData, parentDataProperty, rootData) {
      'use strict';
      var vErrors = null;
      var errors = 0;
      if (rootData === undefined) rootData = data;
      if ((data && typeof data === "object" && !Array.isArray(data))) {
        var errs__0 = errors;
        var valid1 = true;
        for (var key0 in data) {
          var isAdditional0 = !(false || validate.schema.properties[key0]);
          if (isAdditional0) {
            valid1 = false;
            var err = {
              keyword: 'additionalProperties',
              dataPath: (dataPath || '') + "",
              schemaPath: '#/additionalProperties',
              params: {
                additionalProperty: '' + key0 + ''
              },
              message: 'should NOT have additional properties'
            };
            if (vErrors === null) vErrors = [err];
            else vErrors.push(err);
            errors++;
          }
        }
        var data1 = data.alignment;
        if (data1 !== undefined) {
          var errs_1 = errors;
          var schema1 = validate.schema.properties.alignment.enum;
          var valid1;
          valid1 = false;
          for (var i1 = 0; i1 < schema1.length; i1++)
            if (equal(data1, schema1[i1])) {
              valid1 = true;
              break;
            }
          if (!valid1) {
            var err = {
              keyword: 'enum',
              dataPath: (dataPath || '') + '.alignment',
              schemaPath: '#/properties/alignment/enum',
              params: {
                allowedValues: schema1
              },
              message: 'should be equal to one of the allowed values'
            };
            if (vErrors === null) vErrors = [err];
            else vErrors.push(err);
            errors++;
          }
          if (typeof data1 !== "string") {
            var err = {
              keyword: 'type',
              dataPath: (dataPath || '') + '.alignment',
              schemaPath: '#/properties/alignment/type',
              params: {
                type: 'string'
              },
              message: 'should be string'
            };
            if (vErrors === null) vErrors = [err];
            else vErrors.push(err);
            errors++;
          }
          var valid1 = errors === errs_1;
        }
        if (data.width !== undefined) {
          var errs_1 = errors;
          if (typeof data.width !== "number") {
            var err = {
              keyword: 'type',
              dataPath: (dataPath || '') + '.width',
              schemaPath: '#/properties/width/type',
              params: {
                type: 'number'
              },
              message: 'should be number'
            };
            if (vErrors === null) vErrors = [err];
            else vErrors.push(err);
            errors++;
          }
          var valid1 = errors === errs_1;
        }
        if (data.wrapWord !== undefined) {
          var errs_1 = errors;
          if (typeof data.wrapWord !== "boolean") {
            var err = {
              keyword: 'type',
              dataPath: (dataPath || '') + '.wrapWord',
              schemaPath: '#/properties/wrapWord/type',
              params: {
                type: 'boolean'
              },
              message: 'should be boolean'
            };
            if (vErrors === null) vErrors = [err];
            else vErrors.push(err);
            errors++;
          }
          var valid1 = errors === errs_1;
        }
        if (data.truncate !== undefined) {
          var errs_1 = errors;
          if (typeof data.truncate !== "number") {
            var err = {
              keyword: 'type',
              dataPath: (dataPath || '') + '.truncate',
              schemaPath: '#/properties/truncate/type',
              params: {
                type: 'number'
              },
              message: 'should be number'
            };
            if (vErrors === null) vErrors = [err];
            else vErrors.push(err);
            errors++;
          }
          var valid1 = errors === errs_1;
        }
        if (data.paddingLeft !== undefined) {
          var errs_1 = errors;
          if (typeof data.paddingLeft !== "number") {
            var err = {
              keyword: 'type',
              dataPath: (dataPath || '') + '.paddingLeft',
              schemaPath: '#/properties/paddingLeft/type',
              params: {
                type: 'number'
              },
              message: 'should be number'
            };
            if (vErrors === null) vErrors = [err];
            else vErrors.push(err);
            errors++;
          }
          var valid1 = errors === errs_1;
        }
        if (data.paddingRight !== undefined) {
          var errs_1 = errors;
          if (typeof data.paddingRight !== "number") {
            var err = {
              keyword: 'type',
              dataPath: (dataPath || '') + '.paddingRight',
              schemaPath: '#/properties/paddingRight/type',
              params: {
                type: 'number'
              },
              message: 'should be number'
            };
            if (vErrors === null) vErrors = [err];
            else vErrors.push(err);
            errors++;
          }
          var valid1 = errors === errs_1;
        }
      } else {
        var err = {
          keyword: 'type',
          dataPath: (dataPath || '') + "",
          schemaPath: '#/type',
          params: {
            type: 'object'
          },
          message: 'should be object'
        };
        if (vErrors === null) vErrors = [err];
        else vErrors.push(err);
        errors++;
      }
      validate.errors = vErrors;
      return errors === 0;
    };
  })();
  refVal4.schema = {
    "type": "object",
    "properties": {
      "alignment": {
        "type": "string",
        "enum": ["left", "right", "center"]
      },
      "width": {
        "type": "number"
      },
      "wrapWord": {
        "type": "boolean"
      },
      "truncate": {
        "type": "number"
      },
      "paddingLeft": {
        "type": "number"
      },
      "paddingRight": {
        "type": "number"
      }
    },
    "additionalProperties": false
  };
  refVal4.errors = null;
  refVal[4] = refVal4;
  return function validate(data, dataPath, parentData, parentDataProperty, rootData) {
    'use strict';
    var vErrors = null;
    var errors = 0;
    if (rootData === undefined) rootData = data;
    if ((data && typeof data === "object" && !Array.isArray(data))) {
      var errs__0 = errors;
      var valid1 = true;
      for (var key0 in data) {
        var isAdditional0 = !(false || key0 == 'border' || key0 == 'columns' || key0 == 'columnDefault' || key0 == 'drawHorizontalLine');
        if (isAdditional0) {
          valid1 = false;
          var err = {
            keyword: 'additionalProperties',
            dataPath: (dataPath || '') + "",
            schemaPath: '#/additionalProperties',
            params: {
              additionalProperty: '' + key0 + ''
            },
            message: 'should NOT have additional properties'
          };
          if (vErrors === null) vErrors = [err];
          else vErrors.push(err);
          errors++;
        }
      }
      if (data.border !== undefined) {
        var errs_1 = errors;
        if (!refVal1(data.border, (dataPath || '') + '.border', data, 'border', rootData)) {
          if (vErrors === null) vErrors = refVal1.errors;
          else vErrors = vErrors.concat(refVal1.errors);
          errors = vErrors.length;
        }
        var valid1 = errors === errs_1;
      }
      if (data.columns !== undefined) {
        var errs_1 = errors;
        if (!refVal3(data.columns, (dataPath || '') + '.columns', data, 'columns', rootData)) {
          if (vErrors === null) vErrors = refVal3.errors;
          else vErrors = vErrors.concat(refVal3.errors);
          errors = vErrors.length;
        }
        var valid1 = errors === errs_1;
      }
      if (data.columnDefault !== undefined) {
        var errs_1 = errors;
        if (!refVal[4](data.columnDefault, (dataPath || '') + '.columnDefault', data, 'columnDefault', rootData)) {
          if (vErrors === null) vErrors = refVal[4].errors;
          else vErrors = vErrors.concat(refVal[4].errors);
          errors = vErrors.length;
        }
        var valid1 = errors === errs_1;
      }
      if (data.drawHorizontalLine !== undefined) {
        var errs_1 = errors;
        var errs__1 = errors;
        var valid1;
        if (!(typeof data.drawHorizontalLine == "function")) {
          if (errs__1 == errors) {
            var err = {
              keyword: 'typeof',
              dataPath: (dataPath || '') + '.drawHorizontalLine',
              schemaPath: '#/properties/drawHorizontalLine/typeof',
              params: {
                keyword: 'typeof'
              },
              message: 'should pass "typeof" keyword validation'
            };
            if (vErrors === null) vErrors = [err];
            else vErrors.push(err);
            errors++;
          } else {
            for (var i1 = errs__1; i1 < errors; i1++) {
              var ruleErr1 = vErrors[i1];
              if (ruleErr1.dataPath === undefined) {
                ruleErr1.dataPath = (dataPath || '') + '.drawHorizontalLine';
              }
              if (ruleErr1.schemaPath === undefined) {
                ruleErr1.schemaPath = "#/properties/drawHorizontalLine/typeof";
              }
            }
          }
        }
        var valid1 = errors === errs_1;
      }
    } else {
      var err = {
        keyword: 'type',
        dataPath: (dataPath || '') + "",
        schemaPath: '#/type',
        params: {
          type: 'object'
        },
        message: 'should be object'
      };
      if (vErrors === null) vErrors = [err];
      else vErrors.push(err);
      errors++;
    }
    validate.errors = vErrors;
    return errors === 0;
  };
})();
validate.schema = {
  "id": "config.json",
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
    "border": {
      "$ref": "#/definitions/borders"
    },
    "columns": {
      "$ref": "#/definitions/columns"
    },
    "columnDefault": {
      "$ref": "#/definitions/column"
    },
    "drawHorizontalLine": {
      "typeof": "function"
    }
  },
  "additionalProperties": false,
  "definitions": {
    "columns": {
      "type": "object",
      "patternProperties": {
        "^[0-9]+$": {
          "$ref": "#/definitions/column"
        }
      },
      "additionalProperties": false
    },
    "column": {
      "type": "object",
      "properties": {
        "alignment": {
          "type": "string",
          "enum": ["left", "right", "center"]
        },
        "width": {
          "type": "number"
        },
        "wrapWord": {
          "type": "boolean"
        },
        "truncate": {
          "type": "number"
        },
        "paddingLeft": {
          "type": "number"
        },
        "paddingRight": {
          "type": "number"
        }
      },
      "additionalProperties": false
    },
    "borders": {
      "type": "object",
      "properties": {
        "topBody": {
          "$ref": "#/definitions/border"
        },
        "topJoin": {
          "$ref": "#/definitions/border"
        },
        "topLeft": {
          "$ref": "#/definitions/border"
        },
        "topRight": {
          "$ref": "#/definitions/border"
        },
        "bottomBody": {
          "$ref": "#/definitions/border"
        },
        "bottomJoin": {
          "$ref": "#/definitions/border"
        },
        "bottomLeft": {
          "$ref": "#/definitions/border"
        },
        "bottomRight": {
          "$ref": "#/definitions/border"
        },
        "bodyLeft": {
          "$ref": "#/definitions/border"
        },
        "bodyRight": {
          "$ref": "#/definitions/border"
        },
        "bodyJoin": {
          "$ref": "#/definitions/border"
        },
        "joinBody": {
          "$ref": "#/definitions/border"
        },
        "joinLeft": {
          "$ref": "#/definitions/border"
        },
        "joinRight": {
          "$ref": "#/definitions/border"
        },
        "joinJoin": {
          "$ref": "#/definitions/border"
        }
      },
      "additionalProperties": false
    },
    "border": {
      "type": "string"
    }
  }
};
validate.errors = null;
module.exports = validate;
},{"ajv/lib/compile/equal":43}],1178:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * @typedef {string} cell
 */

/**
 * @typedef {cell[]} validateData~column
 */

/**
 * @param {column[]} rows
 * @returns {undefined}
 */
exports.default = rows => {
  if (!_lodash2.default.isArray(rows)) {
    throw new Error('Table data must be an array.');
  }

  if (rows.length === 0) {
    throw new Error('Table must define at least one row.');
  }

  if (rows[0].length === 0) {
    throw new Error('Table must define at least one column.');
  }

  const columnNumber = rows[0].length;

  _lodash2.default.forEach(rows, cells => {
    if (!_lodash2.default.isArray(cells)) {
      throw new Error('Table row data must be an array.');
    }

    if (cells.length !== columnNumber) {
      throw new Error('Table must have a consistent number of cells.');
    }

    // @todo Make an exception for newline characters.
    // @see https://github.com/gajus/table/issues/9
    _lodash2.default.forEach(cells, cell => {
      if (/[\x01-\x1A]/.test(cell)) {
        throw new Error('Table data must not contain control characters.');
      }
    });
  });
};
},{"lodash":692}],1179:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _sliceAnsi = require('slice-ansi');

var _sliceAnsi2 = _interopRequireDefault(_sliceAnsi);

var _stringWidth = require('string-width');

var _stringWidth2 = _interopRequireDefault(_stringWidth);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Creates an array of strings split into groups the length of size.
 * This function works with strings that contain ASCII characters.
 *
 * wrapText is different from would-be "chunk" implementation
 * in that whitespace characters that occur on a chunk size limit are trimmed.
 *
 * @param {string} subject
 * @param {number} size
 * @returns {Array}
 */
exports.default = (subject, size) => {
  let subjectSlice;

  subjectSlice = subject;

  const chunks = [];

  do {
    chunks.push((0, _sliceAnsi2.default)(subjectSlice, 0, size));

    subjectSlice = _lodash2.default.trim((0, _sliceAnsi2.default)(subjectSlice, size));
  } while ((0, _stringWidth2.default)(subjectSlice));

  return chunks;
};
},{"lodash":692,"slice-ansi":853,"string-width":866}],1180:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _sliceAnsi = require('slice-ansi');

var _sliceAnsi2 = _interopRequireDefault(_sliceAnsi);

var _stringWidth = require('string-width');

var _stringWidth2 = _interopRequireDefault(_stringWidth);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * @param {string} input
 * @param {number} size
 * @returns {Array}
 */
exports.default = (input, size) => {
  let subject;

  subject = input;

  const chunks = [];

  // https://regex101.com/r/gY5kZ1/1
  const re = new RegExp('(^.{1,' + size + '}(\\s+|$))|(^.{1,' + (size - 1) + '}(\\\\|/|_|\\.|,|;|-))');

  do {
    let chunk;

    chunk = subject.match(re);

    if (chunk) {
      chunk = chunk[0];

      subject = (0, _sliceAnsi2.default)(subject, (0, _stringWidth2.default)(chunk));

      chunk = _lodash2.default.trim(chunk);
    } else {
      chunk = (0, _sliceAnsi2.default)(subject, 0, size);
      subject = (0, _sliceAnsi2.default)(subject, size);
    }

    chunks.push(chunk);
  } while ((0, _stringWidth2.default)(subject));

  return chunks;
};
},{"lodash":692,"slice-ansi":853,"string-width":866}],1181:[function(require,module,exports){
"use strict"

function unique_pred(list, compare) {
  var ptr = 1
    , len = list.length
    , a=list[0], b=list[0]
  for(var i=1; i<len; ++i) {
    b = a
    a = list[i]
    if(compare(a, b)) {
      if(i === ptr) {
        ptr++
        continue
      }
      list[ptr++] = a
    }
  }
  list.length = ptr
  return list
}

function unique_eq(list) {
  var ptr = 1
    , len = list.length
    , a=list[0], b = list[0]
  for(var i=1; i<len; ++i, b=a) {
    b = a
    a = list[i]
    if(a !== b) {
      if(i === ptr) {
        ptr++
        continue
      }
      list[ptr++] = a
    }
  }
  list.length = ptr
  return list
}

function unique(list, compare, sorted) {
  if(list.length === 0) {
    return list
  }
  if(compare) {
    if(!sorted) {
      list.sort(compare)
    }
    return unique_pred(list, compare)
  }
  if(!sorted) {
    list.sort()
  }
  return unique_eq(list)
}

module.exports = unique

},{}],1182:[function(require,module,exports){
// Returns a wrapper function that returns a wrapped callback
// The wrapper function should do some stuff, and return a
// presumably different callback function.
// This makes sure that own properties are retained, so that
// decorations and such are not lost along the way.
module.exports = wrappy
function wrappy (fn, cb) {
  if (fn && cb) return wrappy(fn)(cb)

  if (typeof fn !== 'function')
    throw new TypeError('need wrapper function')

  Object.keys(fn).forEach(function (k) {
    wrapper[k] = fn[k]
  })

  return wrapper

  function wrapper() {
    var args = new Array(arguments.length)
    for (var i = 0; i < args.length; i++) {
      args[i] = arguments[i]
    }
    var ret = fn.apply(this, args)
    var cb = args[args.length-1]
    if (typeof ret === 'function' && ret !== cb) {
      Object.keys(cb).forEach(function (k) {
        ret[k] = cb[k]
      })
    }
    return ret
  }
}

},{}],1183:[function(require,module,exports){
/*!
 * write <https://github.com/jonschlinkert/write>
 *
 * Copyright (c) 2014-2015, Jon Schlinkert.
 * Licensed under the MIT License.
 */

'use strict';

var fs = require('fs');
var path = require('path');
var mkdir = require('mkdirp');

/**
 * Asynchronously write a file to disk. Creates any intermediate
 * directories if they don't already exist.
 *
 * ```js
 * var writeFile = require('write');
 * writeFile('foo.txt', 'This is content to write.', function(err) {
 *   if (err) console.log(err);
 * });
 * ```
 *
 * @name  writeFile
 * @param  {String} `dest` Destination file path
 * @param  {String} `str` String to write to disk.
 * @param  {Function} `callback`
 * @api public
 */

module.exports = function writeFile(dest, str, cb) {
  var dir = path.dirname(dest);
  fs.exists(dir, function (exists) {
    if (exists) {
      fs.writeFile(dest, str, cb);
    } else {
      mkdir(dir, function (err) {
        if (err) {
          return cb(err);
        } else {
          fs.writeFile(dest, str, cb);
        }
      });
    }
  });
};

/**
 * Synchronously write files to disk. Creates any intermediate
 * directories if they don't already exist.
 *
 * ```js
 * var writeFile = require('write');
 * writeFile.sync('foo.txt', 'This is content to write.');
 * ```
 *
 * @name  writeFile.sync
 * @param  {String} `dest` Destination file path
 * @param  {String} `str` String to write to disk.
 * @api public
 */

module.exports.sync = function writeFileSync(dest, str) {
  var dir = path.dirname(dest);
  if (!fs.existsSync(dir)) {
    mkdir.sync(dir);
  }
  fs.writeFileSync(dest, str);
};

/**
 * Uses `fs.createWriteStream`, but also creates any intermediate
 * directories if they don't already exist.
 *
 * ```js
 * var write = require('write');
 * write.stream('foo.txt');
 * ```
 *
 * @name  writeFile.stream
 * @param  {String} `dest` Destination file path
 * @return  {Stream} Returns a write stream.
 * @api public
 */

module.exports.stream = function writeFileStream(dest) {
  var dir = path.dirname(dest);
  if (!fs.existsSync(dir)) {
    mkdir.sync(dir);
  }
  return fs.createWriteStream(dest);
};

},{"fs":1,"mkdirp":705,"path":14}],"stylelint":[function(require,module,exports){
"use strict";

const checkAgainstRule = require("./utils/checkAgainstRule");
const createPlugin = require("./createPlugin");
const createRuleTester = require("./testUtils/createRuleTester");
const createStylelint = require("./createStylelint");
const formatters = require("./formatters");
const postcssPlugin = require("./postcssPlugin");
const report = require("./utils/report");
const ruleMessages = require("./utils/ruleMessages");
const rules = require("./rules");
const standalone = require("./standalone");
const validateOptions = require("./utils/validateOptions");

const api = postcssPlugin;

api.utils = {
  report,
  ruleMessages,
  validateOptions,
  checkAgainstRule
};

api.lint = standalone;
api.rules = rules;
api.formatters = formatters;
api.createPlugin = createPlugin;
api.createRuleTester = createRuleTester;
api.createLinter = createStylelint;

module.exports = api;

},{"./createPlugin":873,"./createStylelint":874,"./formatters":877,"./postcssPlugin":887,"./rules":971,"./standalone":1066,"./testUtils/createRuleTester":1068,"./utils/checkAgainstRule":1077,"./utils/report":1141,"./utils/ruleMessages":1142,"./utils/validateOptions":1144}]},{},[]);