☰

enhance-npm-community

一个用于增强npm官网的GM脚本

  1. // ==UserScript==
  2. // @name              enhance-npm-community
  3. // @author            Axetroy
  4. // @description       一个用于增强npm官网的GM脚本
  5. // @version           0.2.1
  6. // @grant             GM_xmlhttpRequest
  7. // @include           *www.npmjs.com*
  8. // @connect           *
  9. // @compatible        chrome  完美运行
  10. // @compatible        firefox  完美运行
  11. // @supportURL        http://www.burningall.com
  12. // @run-at            document-end
  13. // @contributionURL   troy450409405@gmail.com|alipay.com
  14. // @namespace         https://greasyfork.org/zh-CN/users/3400-axetroy
  15. // @license           The MIT License (MIT); http://opensource.org/licenses/MIT
  16. // ==/UserScript==
  17.  
  18. // Github源码: https://github.com/axetroy/enhance-npm-community
  19.  
  20. /**
  21. The MIT License (MIT)
  22.  
  23. Copyright (c) 2017 axetroy
  24.  
  25. Permission is hereby granted, free of charge, to any person obtaining a copy
  26. of this software and associated documentation files (the "Software"), to deal
  27. in the Software without restriction, including without limitation the rights
  28. to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  29. copies of the Software, and to permit persons to whom the Software is
  30. furnished to do so, subject to the following conditions:
  31.  
  32. The above copyright notice and this permission notice shall be included in all
  33. copies or substantial portions of the Software.
  34.  
  35. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  36. IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  37. FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  38. AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  39. LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  40. OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  41. SOFTWARE.
  42. **/
  43.  
  44. /******/ (function(modules) { // webpackBootstrap
  45. /******/ 	// The module cache
  46. /******/ 	var installedModules = {};
  47. /******/
  48. /******/ 	// The require function
  49. /******/ 	function __webpack_require__(moduleId) {
  50. /******/
  51. /******/ 		// Check if module is in cache
  52. /******/ 		if(installedModules[moduleId])
  53. /******/ 			return installedModules[moduleId].exports;
  54. /******/
  55. /******/ 		// Create a new module (and put it into the cache)
  56. /******/ 		var module = installedModules[moduleId] = {
  57. /******/ 			i: moduleId,
  58. /******/ 			l: false,
  59. /******/ 			exports: {}
  60. /******/ 		};
  61. /******/
  62. /******/ 		// Execute the module function
  63. /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  64. /******/
  65. /******/ 		// Flag the module as loaded
  66. /******/ 		module.l = true;
  67. /******/
  68. /******/ 		// Return the exports of the module
  69. /******/ 		return module.exports;
  70. /******/ 	}
  71. /******/
  72. /******/
  73. /******/ 	// expose the modules object (__webpack_modules__)
  74. /******/ 	__webpack_require__.m = modules;
  75. /******/
  76. /******/ 	// expose the module cache
  77. /******/ 	__webpack_require__.c = installedModules;
  78. /******/
  79. /******/ 	// identity function for calling harmony imports with the correct context
  80. /******/ 	__webpack_require__.i = function(value) { return value; };
  81. /******/
  82. /******/ 	// define getter function for harmony exports
  83. /******/ 	__webpack_require__.d = function(exports, name, getter) {
  84. /******/ 		if(!__webpack_require__.o(exports, name)) {
  85. /******/ 			Object.defineProperty(exports, name, {
  86. /******/ 				configurable: false,
  87. /******/ 				enumerable: true,
  88. /******/ 				get: getter
  89. /******/ 			});
  90. /******/ 		}
  91. /******/ 	};
  92. /******/
  93. /******/ 	// getDefaultExport function for compatibility with non-harmony modules
  94. /******/ 	__webpack_require__.n = function(module) {
  95. /******/ 		var getter = module && module.__esModule ?
  96. /******/ 			function getDefault() { return module['default']; } :
  97. /******/ 			function getModuleExports() { return module; };
  98. /******/ 		__webpack_require__.d(getter, 'a', getter);
  99. /******/ 		return getter;
  100. /******/ 	};
  101. /******/
  102. /******/ 	// Object.prototype.hasOwnProperty.call
  103. /******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
  104. /******/
  105. /******/ 	// __webpack_public_path__
  106. /******/ 	__webpack_require__.p = "";
  107. /******/
  108. /******/ 	// Load entry module and return exports
  109. /******/ 	return __webpack_require__(__webpack_require__.s = 117);
  110. /******/ })
  111. /************************************************************************/
  112. /******/ ([
  113. /* 0 */
  114. /***/ (function(module, exports, __webpack_require__) {
  115.  
  116. var store      = __webpack_require__(43)('wks')
  117.   , uid        = __webpack_require__(46)
  118.   , Symbol     = __webpack_require__(1).Symbol
  119.   , USE_SYMBOL = typeof Symbol == 'function';
  120.  
  121. var $exports = module.exports = function(name){
  122.   return store[name] || (store[name] =
  123.     USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));
  124. };
  125.  
  126. $exports.store = store;
  127.  
  128. /***/ }),
  129. /* 1 */
  130. /***/ (function(module, exports) {
  131.  
  132. // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
  133. var global = module.exports = typeof window != 'undefined' && window.Math == Math
  134.   ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();
  135. if(typeof __g == 'number')__g = global; // eslint-disable-line no-undef
  136.  
  137. /***/ }),
  138. /* 2 */
  139. /***/ (function(module, exports) {
  140.  
  141. var core = module.exports = {version: '2.4.0'};
  142. if(typeof __e == 'number')__e = core; // eslint-disable-line no-undef
  143.  
  144. /***/ }),
  145. /* 3 */
  146. /***/ (function(module, exports, __webpack_require__) {
  147.  
  148. /* WEBPACK VAR INJECTION */(function(process, global, setImmediate) {/* @preserve
  149.  * The MIT License (MIT)
  150.  * 
  151.  * Copyright (c) 2013-2017 Petka Antonov
  152.  * 
  153.  * Permission is hereby granted, free of charge, to any person obtaining a copy
  154.  * of this software and associated documentation files (the "Software"), to deal
  155.  * in the Software without restriction, including without limitation the rights
  156.  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  157.  * copies of the Software, and to permit persons to whom the Software is
  158.  * furnished to do so, subject to the following conditions:
  159.  * 
  160.  * The above copyright notice and this permission notice shall be included in
  161.  * all copies or substantial portions of the Software.
  162.  * 
  163.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  164.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  165.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  166.  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  167.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  168.  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  169.  * THE SOFTWARE.
  170.  * 
  171.  */
  172. /**
  173.  * bluebird build version 3.5.0
  174.  * Features enabled: core, race, call_get, generators, map, nodeify, promisify, props, reduce, settle, some, using, timers, filter, any, each
  175. */
  176. !function(e){if(true)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.Promise=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof _dereq_=="function"&&_dereq_;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 _dereq_=="function"&&_dereq_;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){
  177. "use strict";
  178. module.exports = function(Promise) {
  179. var SomePromiseArray = Promise._SomePromiseArray;
  180. function any(promises) {
  181.     var ret = new SomePromiseArray(promises);
  182.     var promise = ret.promise();
  183.     ret.setHowMany(1);
  184.     ret.setUnwrap();
  185.     ret.init();
  186.     return promise;
  187. }
  188.  
  189. Promise.any = function (promises) {
  190.     return any(promises);
  191. };
  192.  
  193. Promise.prototype.any = function () {
  194.     return any(this);
  195. };
  196.  
  197. };
  198.  
  199. },{}],2:[function(_dereq_,module,exports){
  200. "use strict";
  201. var firstLineError;
  202. try {throw new Error(); } catch (e) {firstLineError = e;}
  203. var schedule = _dereq_("./schedule");
  204. var Queue = _dereq_("./queue");
  205. var util = _dereq_("./util");
  206.  
  207. function Async() {
  208.     this._customScheduler = false;
  209.     this._isTickUsed = false;
  210.     this._lateQueue = new Queue(16);
  211.     this._normalQueue = new Queue(16);
  212.     this._haveDrainedQueues = false;
  213.     this._trampolineEnabled = true;
  214.     var self = this;
  215.     this.drainQueues = function () {
  216.         self._drainQueues();
  217.     };
  218.     this._schedule = schedule;
  219. }
  220.  
  221. Async.prototype.setScheduler = function(fn) {
  222.     var prev = this._schedule;
  223.     this._schedule = fn;
  224.     this._customScheduler = true;
  225.     return prev;
  226. };
  227.  
  228. Async.prototype.hasCustomScheduler = function() {
  229.     return this._customScheduler;
  230. };
  231.  
  232. Async.prototype.enableTrampoline = function() {
  233.     this._trampolineEnabled = true;
  234. };
  235.  
  236. Async.prototype.disableTrampolineIfNecessary = function() {
  237.     if (util.hasDevTools) {
  238.         this._trampolineEnabled = false;
  239.     }
  240. };
  241.  
  242. Async.prototype.haveItemsQueued = function () {
  243.     return this._isTickUsed || this._haveDrainedQueues;
  244. };
  245.  
  246.  
  247. Async.prototype.fatalError = function(e, isNode) {
  248.     if (isNode) {
  249.         process.stderr.write("Fatal " + (e instanceof Error ? e.stack : e) +
  250.             "\n");
  251.         process.exit(2);
  252.     } else {
  253.         this.throwLater(e);
  254.     }
  255. };
  256.  
  257. Async.prototype.throwLater = function(fn, arg) {
  258.     if (arguments.length === 1) {
  259.         arg = fn;
  260.         fn = function () { throw arg; };
  261.     }
  262.     if (typeof setTimeout !== "undefined") {
  263.         setTimeout(function() {
  264.             fn(arg);
  265.         }, 0);
  266.     } else try {
  267.         this._schedule(function() {
  268.             fn(arg);
  269.         });
  270.     } catch (e) {
  271.         throw new Error("No async scheduler available\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
  272.     }
  273. };
  274.  
  275. function AsyncInvokeLater(fn, receiver, arg) {
  276.     this._lateQueue.push(fn, receiver, arg);
  277.     this._queueTick();
  278. }
  279.  
  280. function AsyncInvoke(fn, receiver, arg) {
  281.     this._normalQueue.push(fn, receiver, arg);
  282.     this._queueTick();
  283. }
  284.  
  285. function AsyncSettlePromises(promise) {
  286.     this._normalQueue._pushOne(promise);
  287.     this._queueTick();
  288. }
  289.  
  290. if (!util.hasDevTools) {
  291.     Async.prototype.invokeLater = AsyncInvokeLater;
  292.     Async.prototype.invoke = AsyncInvoke;
  293.     Async.prototype.settlePromises = AsyncSettlePromises;
  294. } else {
  295.     Async.prototype.invokeLater = function (fn, receiver, arg) {
  296.         if (this._trampolineEnabled) {
  297.             AsyncInvokeLater.call(this, fn, receiver, arg);
  298.         } else {
  299.             this._schedule(function() {
  300.                 setTimeout(function() {
  301.                     fn.call(receiver, arg);
  302.                 }, 100);
  303.             });
  304.         }
  305.     };
  306.  
  307.     Async.prototype.invoke = function (fn, receiver, arg) {
  308.         if (this._trampolineEnabled) {
  309.             AsyncInvoke.call(this, fn, receiver, arg);
  310.         } else {
  311.             this._schedule(function() {
  312.                 fn.call(receiver, arg);
  313.             });
  314.         }
  315.     };
  316.  
  317.     Async.prototype.settlePromises = function(promise) {
  318.         if (this._trampolineEnabled) {
  319.             AsyncSettlePromises.call(this, promise);
  320.         } else {
  321.             this._schedule(function() {
  322.                 promise._settlePromises();
  323.             });
  324.         }
  325.     };
  326. }
  327.  
  328. Async.prototype._drainQueue = function(queue) {
  329.     while (queue.length() > 0) {
  330.         var fn = queue.shift();
  331.         if (typeof fn !== "function") {
  332.             fn._settlePromises();
  333.             continue;
  334.         }
  335.         var receiver = queue.shift();
  336.         var arg = queue.shift();
  337.         fn.call(receiver, arg);
  338.     }
  339. };
  340.  
  341. Async.prototype._drainQueues = function () {
  342.     this._drainQueue(this._normalQueue);
  343.     this._reset();
  344.     this._haveDrainedQueues = true;
  345.     this._drainQueue(this._lateQueue);
  346. };
  347.  
  348. Async.prototype._queueTick = function () {
  349.     if (!this._isTickUsed) {
  350.         this._isTickUsed = true;
  351.         this._schedule(this.drainQueues);
  352.     }
  353. };
  354.  
  355. Async.prototype._reset = function () {
  356.     this._isTickUsed = false;
  357. };
  358.  
  359. module.exports = Async;
  360. module.exports.firstLineError = firstLineError;
  361.  
  362. },{"./queue":26,"./schedule":29,"./util":36}],3:[function(_dereq_,module,exports){
  363. "use strict";
  364. module.exports = function(Promise, INTERNAL, tryConvertToPromise, debug) {
  365. var calledBind = false;
  366. var rejectThis = function(_, e) {
  367.     this._reject(e);
  368. };
  369.  
  370. var targetRejected = function(e, context) {
  371.     context.promiseRejectionQueued = true;
  372.     context.bindingPromise._then(rejectThis, rejectThis, null, this, e);
  373. };
  374.  
  375. var bindingResolved = function(thisArg, context) {
  376.     if (((this._bitField & 50397184) === 0)) {
  377.         this._resolveCallback(context.target);
  378.     }
  379. };
  380.  
  381. var bindingRejected = function(e, context) {
  382.     if (!context.promiseRejectionQueued) this._reject(e);
  383. };
  384.  
  385. Promise.prototype.bind = function (thisArg) {
  386.     if (!calledBind) {
  387.         calledBind = true;
  388.         Promise.prototype._propagateFrom = debug.propagateFromFunction();
  389.         Promise.prototype._boundValue = debug.boundValueFunction();
  390.     }
  391.     var maybePromise = tryConvertToPromise(thisArg);
  392.     var ret = new Promise(INTERNAL);
  393.     ret._propagateFrom(this, 1);
  394.     var target = this._target();
  395.     ret._setBoundTo(maybePromise);
  396.     if (maybePromise instanceof Promise) {
  397.         var context = {
  398.             promiseRejectionQueued: false,
  399.             promise: ret,
  400.             target: target,
  401.             bindingPromise: maybePromise
  402.         };
  403.         target._then(INTERNAL, targetRejected, undefined, ret, context);
  404.         maybePromise._then(
  405.             bindingResolved, bindingRejected, undefined, ret, context);
  406.         ret._setOnCancel(maybePromise);
  407.     } else {
  408.         ret._resolveCallback(target);
  409.     }
  410.     return ret;
  411. };
  412.  
  413. Promise.prototype._setBoundTo = function (obj) {
  414.     if (obj !== undefined) {
  415.         this._bitField = this._bitField | 2097152;
  416.         this._boundTo = obj;
  417.     } else {
  418.         this._bitField = this._bitField & (~2097152);
  419.     }
  420. };
  421.  
  422. Promise.prototype._isBound = function () {
  423.     return (this._bitField & 2097152) === 2097152;
  424. };
  425.  
  426. Promise.bind = function (thisArg, value) {
  427.     return Promise.resolve(value).bind(thisArg);
  428. };
  429. };
  430.  
  431. },{}],4:[function(_dereq_,module,exports){
  432. "use strict";
  433. var old;
  434. if (typeof Promise !== "undefined") old = Promise;
  435. function noConflict() {
  436.     try { if (Promise === bluebird) Promise = old; }
  437.     catch (e) {}
  438.     return bluebird;
  439. }
  440. var bluebird = _dereq_("./promise")();
  441. bluebird.noConflict = noConflict;
  442. module.exports = bluebird;
  443.  
  444. },{"./promise":22}],5:[function(_dereq_,module,exports){
  445. "use strict";
  446. var cr = Object.create;
  447. if (cr) {
  448.     var callerCache = cr(null);
  449.     var getterCache = cr(null);
  450.     callerCache[" size"] = getterCache[" size"] = 0;
  451. }
  452.  
  453. module.exports = function(Promise) {
  454. var util = _dereq_("./util");
  455. var canEvaluate = util.canEvaluate;
  456. var isIdentifier = util.isIdentifier;
  457.  
  458. var getMethodCaller;
  459. var getGetter;
  460. if (false) {
  461. var makeMethodCaller = function (methodName) {
  462.     return new Function("ensureMethod", "                                    \n\
  463.         return function(obj) {                                               \n\
  464.             'use strict'                                                     \n\
  465.             var len = this.length;                                           \n\
  466.             ensureMethod(obj, 'methodName');                                 \n\
  467.             switch(len) {                                                    \n\
  468.                 case 1: return obj.methodName(this[0]);                      \n\
  469.                 case 2: return obj.methodName(this[0], this[1]);             \n\
  470.                 case 3: return obj.methodName(this[0], this[1], this[2]);    \n\
  471.                 case 0: return obj.methodName();                             \n\
  472.                 default:                                                     \n\
  473.                     return obj.methodName.apply(obj, this);                  \n\
  474.             }                                                                \n\
  475.         };                                                                   \n\
  476.         ".replace(/methodName/g, methodName))(ensureMethod);
  477. };
  478.  
  479. var makeGetter = function (propertyName) {
  480.     return new Function("obj", "                                             \n\
  481.         'use strict';                                                        \n\
  482.         return obj.propertyName;                                             \n\
  483.         ".replace("propertyName", propertyName));
  484. };
  485.  
  486. var getCompiled = function(name, compiler, cache) {
  487.     var ret = cache[name];
  488.     if (typeof ret !== "function") {
  489.         if (!isIdentifier(name)) {
  490.             return null;
  491.         }
  492.         ret = compiler(name);
  493.         cache[name] = ret;
  494.         cache[" size"]++;
  495.         if (cache[" size"] > 512) {
  496.             var keys = Object.keys(cache);
  497.             for (var i = 0; i < 256; ++i) delete cache[keys[i]];
  498.             cache[" size"] = keys.length - 256;
  499.         }
  500.     }
  501.     return ret;
  502. };
  503.  
  504. getMethodCaller = function(name) {
  505.     return getCompiled(name, makeMethodCaller, callerCache);
  506. };
  507.  
  508. getGetter = function(name) {
  509.     return getCompiled(name, makeGetter, getterCache);
  510. };
  511. }
  512.  
  513. function ensureMethod(obj, methodName) {
  514.     var fn;
  515.     if (obj != null) fn = obj[methodName];
  516.     if (typeof fn !== "function") {
  517.         var message = "Object " + util.classString(obj) + " has no method '" +
  518.             util.toString(methodName) + "'";
  519.         throw new Promise.TypeError(message);
  520.     }
  521.     return fn;
  522. }
  523.  
  524. function caller(obj) {
  525.     var methodName = this.pop();
  526.     var fn = ensureMethod(obj, methodName);
  527.     return fn.apply(obj, this);
  528. }
  529. Promise.prototype.call = function (methodName) {
  530.     var args = [].slice.call(arguments, 1);;
  531.     if (false) {
  532.         if (canEvaluate) {
  533.             var maybeCaller = getMethodCaller(methodName);
  534.             if (maybeCaller !== null) {
  535.                 return this._then(
  536.                     maybeCaller, undefined, undefined, args, undefined);
  537.             }
  538.         }
  539.     }
  540.     args.push(methodName);
  541.     return this._then(caller, undefined, undefined, args, undefined);
  542. };
  543.  
  544. function namedGetter(obj) {
  545.     return obj[this];
  546. }
  547. function indexedGetter(obj) {
  548.     var index = +this;
  549.     if (index < 0) index = Math.max(0, index + obj.length);
  550.     return obj[index];
  551. }
  552. Promise.prototype.get = function (propertyName) {
  553.     var isIndex = (typeof propertyName === "number");
  554.     var getter;
  555.     if (!isIndex) {
  556.         if (canEvaluate) {
  557.             var maybeGetter = getGetter(propertyName);
  558.             getter = maybeGetter !== null ? maybeGetter : namedGetter;
  559.         } else {
  560.             getter = namedGetter;
  561.         }
  562.     } else {
  563.         getter = indexedGetter;
  564.     }
  565.     return this._then(getter, undefined, undefined, propertyName, undefined);
  566. };
  567. };
  568.  
  569. },{"./util":36}],6:[function(_dereq_,module,exports){
  570. "use strict";
  571. module.exports = function(Promise, PromiseArray, apiRejection, debug) {
  572. var util = _dereq_("./util");
  573. var tryCatch = util.tryCatch;
  574. var errorObj = util.errorObj;
  575. var async = Promise._async;
  576.  
  577. Promise.prototype["break"] = Promise.prototype.cancel = function() {
  578.     if (!debug.cancellation()) return this._warn("cancellation is disabled");
  579.  
  580.     var promise = this;
  581.     var child = promise;
  582.     while (promise._isCancellable()) {
  583.         if (!promise._cancelBy(child)) {
  584.             if (child._isFollowing()) {
  585.                 child._followee().cancel();
  586.             } else {
  587.                 child._cancelBranched();
  588.             }
  589.             break;
  590.         }
  591.  
  592.         var parent = promise._cancellationParent;
  593.         if (parent == null || !parent._isCancellable()) {
  594.             if (promise._isFollowing()) {
  595.                 promise._followee().cancel();
  596.             } else {
  597.                 promise._cancelBranched();
  598.             }
  599.             break;
  600.         } else {
  601.             if (promise._isFollowing()) promise._followee().cancel();
  602.             promise._setWillBeCancelled();
  603.             child = promise;
  604.             promise = parent;
  605.         }
  606.     }
  607. };
  608.  
  609. Promise.prototype._branchHasCancelled = function() {
  610.     this._branchesRemainingToCancel--;
  611. };
  612.  
  613. Promise.prototype._enoughBranchesHaveCancelled = function() {
  614.     return this._branchesRemainingToCancel === undefined ||
  615.            this._branchesRemainingToCancel <= 0;
  616. };
  617.  
  618. Promise.prototype._cancelBy = function(canceller) {
  619.     if (canceller === this) {
  620.         this._branchesRemainingToCancel = 0;
  621.         this._invokeOnCancel();
  622.         return true;
  623.     } else {
  624.         this._branchHasCancelled();
  625.         if (this._enoughBranchesHaveCancelled()) {
  626.             this._invokeOnCancel();
  627.             return true;
  628.         }
  629.     }
  630.     return false;
  631. };
  632.  
  633. Promise.prototype._cancelBranched = function() {
  634.     if (this._enoughBranchesHaveCancelled()) {
  635.         this._cancel();
  636.     }
  637. };
  638.  
  639. Promise.prototype._cancel = function() {
  640.     if (!this._isCancellable()) return;
  641.     this._setCancelled();
  642.     async.invoke(this._cancelPromises, this, undefined);
  643. };
  644.  
  645. Promise.prototype._cancelPromises = function() {
  646.     if (this._length() > 0) this._settlePromises();
  647. };
  648.  
  649. Promise.prototype._unsetOnCancel = function() {
  650.     this._onCancelField = undefined;
  651. };
  652.  
  653. Promise.prototype._isCancellable = function() {
  654.     return this.isPending() && !this._isCancelled();
  655. };
  656.  
  657. Promise.prototype.isCancellable = function() {
  658.     return this.isPending() && !this.isCancelled();
  659. };
  660.  
  661. Promise.prototype._doInvokeOnCancel = function(onCancelCallback, internalOnly) {
  662.     if (util.isArray(onCancelCallback)) {
  663.         for (var i = 0; i < onCancelCallback.length; ++i) {
  664.             this._doInvokeOnCancel(onCancelCallback[i], internalOnly);
  665.         }
  666.     } else if (onCancelCallback !== undefined) {
  667.         if (typeof onCancelCallback === "function") {
  668.             if (!internalOnly) {
  669.                 var e = tryCatch(onCancelCallback).call(this._boundValue());
  670.                 if (e === errorObj) {
  671.                     this._attachExtraTrace(e.e);
  672.                     async.throwLater(e.e);
  673.                 }
  674.             }
  675.         } else {
  676.             onCancelCallback._resultCancelled(this);
  677.         }
  678.     }
  679. };
  680.  
  681. Promise.prototype._invokeOnCancel = function() {
  682.     var onCancelCallback = this._onCancel();
  683.     this._unsetOnCancel();
  684.     async.invoke(this._doInvokeOnCancel, this, onCancelCallback);
  685. };
  686.  
  687. Promise.prototype._invokeInternalOnCancel = function() {
  688.     if (this._isCancellable()) {
  689.         this._doInvokeOnCancel(this._onCancel(), true);
  690.         this._unsetOnCancel();
  691.     }
  692. };
  693.  
  694. Promise.prototype._resultCancelled = function() {
  695.     this.cancel();
  696. };
  697.  
  698. };
  699.  
  700. },{"./util":36}],7:[function(_dereq_,module,exports){
  701. "use strict";
  702. module.exports = function(NEXT_FILTER) {
  703. var util = _dereq_("./util");
  704. var getKeys = _dereq_("./es5").keys;
  705. var tryCatch = util.tryCatch;
  706. var errorObj = util.errorObj;
  707.  
  708. function catchFilter(instances, cb, promise) {
  709.     return function(e) {
  710.         var boundTo = promise._boundValue();
  711.         predicateLoop: for (var i = 0; i < instances.length; ++i) {
  712.             var item = instances[i];
  713.  
  714.             if (item === Error ||
  715.                 (item != null && item.prototype instanceof Error)) {
  716.                 if (e instanceof item) {
  717.                     return tryCatch(cb).call(boundTo, e);
  718.                 }
  719.             } else if (typeof item === "function") {
  720.                 var matchesPredicate = tryCatch(item).call(boundTo, e);
  721.                 if (matchesPredicate === errorObj) {
  722.                     return matchesPredicate;
  723.                 } else if (matchesPredicate) {
  724.                     return tryCatch(cb).call(boundTo, e);
  725.                 }
  726.             } else if (util.isObject(e)) {
  727.                 var keys = getKeys(item);
  728.                 for (var j = 0; j < keys.length; ++j) {
  729.                     var key = keys[j];
  730.                     if (item[key] != e[key]) {
  731.                         continue predicateLoop;
  732.                     }
  733.                 }
  734.                 return tryCatch(cb).call(boundTo, e);
  735.             }
  736.         }
  737.         return NEXT_FILTER;
  738.     };
  739. }
  740.  
  741. return catchFilter;
  742. };
  743.  
  744. },{"./es5":13,"./util":36}],8:[function(_dereq_,module,exports){
  745. "use strict";
  746. module.exports = function(Promise) {
  747. var longStackTraces = false;
  748. var contextStack = [];
  749.  
  750. Promise.prototype._promiseCreated = function() {};
  751. Promise.prototype._pushContext = function() {};
  752. Promise.prototype._popContext = function() {return null;};
  753. Promise._peekContext = Promise.prototype._peekContext = function() {};
  754.  
  755. function Context() {
  756.     this._trace = new Context.CapturedTrace(peekContext());
  757. }
  758. Context.prototype._pushContext = function () {
  759.     if (this._trace !== undefined) {
  760.         this._trace._promiseCreated = null;
  761.         contextStack.push(this._trace);
  762.     }
  763. };
  764.  
  765. Context.prototype._popContext = function () {
  766.     if (this._trace !== undefined) {
  767.         var trace = contextStack.pop();
  768.         var ret = trace._promiseCreated;
  769.         trace._promiseCreated = null;
  770.         return ret;
  771.     }
  772.     return null;
  773. };
  774.  
  775. function createContext() {
  776.     if (longStackTraces) return new Context();
  777. }
  778.  
  779. function peekContext() {
  780.     var lastIndex = contextStack.length - 1;
  781.     if (lastIndex >= 0) {
  782.         return contextStack[lastIndex];
  783.     }
  784.     return undefined;
  785. }
  786. Context.CapturedTrace = null;
  787. Context.create = createContext;
  788. Context.deactivateLongStackTraces = function() {};
  789. Context.activateLongStackTraces = function() {
  790.     var Promise_pushContext = Promise.prototype._pushContext;
  791.     var Promise_popContext = Promise.prototype._popContext;
  792.     var Promise_PeekContext = Promise._peekContext;
  793.     var Promise_peekContext = Promise.prototype._peekContext;
  794.     var Promise_promiseCreated = Promise.prototype._promiseCreated;
  795.     Context.deactivateLongStackTraces = function() {
  796.         Promise.prototype._pushContext = Promise_pushContext;
  797.         Promise.prototype._popContext = Promise_popContext;
  798.         Promise._peekContext = Promise_PeekContext;
  799.         Promise.prototype._peekContext = Promise_peekContext;
  800.         Promise.prototype._promiseCreated = Promise_promiseCreated;
  801.         longStackTraces = false;
  802.     };
  803.     longStackTraces = true;
  804.     Promise.prototype._pushContext = Context.prototype._pushContext;
  805.     Promise.prototype._popContext = Context.prototype._popContext;
  806.     Promise._peekContext = Promise.prototype._peekContext = peekContext;
  807.     Promise.prototype._promiseCreated = function() {
  808.         var ctx = this._peekContext();
  809.         if (ctx && ctx._promiseCreated == null) ctx._promiseCreated = this;
  810.     };
  811. };
  812. return Context;
  813. };
  814.  
  815. },{}],9:[function(_dereq_,module,exports){
  816. "use strict";
  817. module.exports = function(Promise, Context) {
  818. var getDomain = Promise._getDomain;
  819. var async = Promise._async;
  820. var Warning = _dereq_("./errors").Warning;
  821. var util = _dereq_("./util");
  822. var canAttachTrace = util.canAttachTrace;
  823. var unhandledRejectionHandled;
  824. var possiblyUnhandledRejection;
  825. var bluebirdFramePattern =
  826.     /[\\\/]bluebird[\\\/]js[\\\/](release|debug|instrumented)/;
  827. var nodeFramePattern = /\((?:timers\.js):\d+:\d+\)/;
  828. var parseLinePattern = /[\/<\(](.+?):(\d+):(\d+)\)?\s*$/;
  829. var stackFramePattern = null;
  830. var formatStack = null;
  831. var indentStackFrames = false;
  832. var printWarning;
  833. var debugging = !!(util.env("BLUEBIRD_DEBUG") != 0 &&
  834.                         (true ||
  835.                          util.env("BLUEBIRD_DEBUG") ||
  836.                          util.env("NODE_ENV") === "development"));
  837.  
  838. var warnings = !!(util.env("BLUEBIRD_WARNINGS") != 0 &&
  839.     (debugging || util.env("BLUEBIRD_WARNINGS")));
  840.  
  841. var longStackTraces = !!(util.env("BLUEBIRD_LONG_STACK_TRACES") != 0 &&
  842.     (debugging || util.env("BLUEBIRD_LONG_STACK_TRACES")));
  843.  
  844. var wForgottenReturn = util.env("BLUEBIRD_W_FORGOTTEN_RETURN") != 0 &&
  845.     (warnings || !!util.env("BLUEBIRD_W_FORGOTTEN_RETURN"));
  846.  
  847. Promise.prototype.suppressUnhandledRejections = function() {
  848.     var target = this._target();
  849.     target._bitField = ((target._bitField & (~1048576)) |
  850.                       524288);
  851. };
  852.  
  853. Promise.prototype._ensurePossibleRejectionHandled = function () {
  854.     if ((this._bitField & 524288) !== 0) return;
  855.     this._setRejectionIsUnhandled();
  856.     async.invokeLater(this._notifyUnhandledRejection, this, undefined);
  857. };
  858.  
  859. Promise.prototype._notifyUnhandledRejectionIsHandled = function () {
  860.     fireRejectionEvent("rejectionHandled",
  861.                                   unhandledRejectionHandled, undefined, this);
  862. };
  863.  
  864. Promise.prototype._setReturnedNonUndefined = function() {
  865.     this._bitField = this._bitField | 268435456;
  866. };
  867.  
  868. Promise.prototype._returnedNonUndefined = function() {
  869.     return (this._bitField & 268435456) !== 0;
  870. };
  871.  
  872. Promise.prototype._notifyUnhandledRejection = function () {
  873.     if (this._isRejectionUnhandled()) {
  874.         var reason = this._settledValue();
  875.         this._setUnhandledRejectionIsNotified();
  876.         fireRejectionEvent("unhandledRejection",
  877.                                       possiblyUnhandledRejection, reason, this);
  878.     }
  879. };
  880.  
  881. Promise.prototype._setUnhandledRejectionIsNotified = function () {
  882.     this._bitField = this._bitField | 262144;
  883. };
  884.  
  885. Promise.prototype._unsetUnhandledRejectionIsNotified = function () {
  886.     this._bitField = this._bitField & (~262144);
  887. };
  888.  
  889. Promise.prototype._isUnhandledRejectionNotified = function () {
  890.     return (this._bitField & 262144) > 0;
  891. };
  892.  
  893. Promise.prototype._setRejectionIsUnhandled = function () {
  894.     this._bitField = this._bitField | 1048576;
  895. };
  896.  
  897. Promise.prototype._unsetRejectionIsUnhandled = function () {
  898.     this._bitField = this._bitField & (~1048576);
  899.     if (this._isUnhandledRejectionNotified()) {
  900.         this._unsetUnhandledRejectionIsNotified();
  901.         this._notifyUnhandledRejectionIsHandled();
  902.     }
  903. };
  904.  
  905. Promise.prototype._isRejectionUnhandled = function () {
  906.     return (this._bitField & 1048576) > 0;
  907. };
  908.  
  909. Promise.prototype._warn = function(message, shouldUseOwnTrace, promise) {
  910.     return warn(message, shouldUseOwnTrace, promise || this);
  911. };
  912.  
  913. Promise.onPossiblyUnhandledRejection = function (fn) {
  914.     var domain = getDomain();
  915.     possiblyUnhandledRejection =
  916.         typeof fn === "function" ? (domain === null ?
  917.                                             fn : util.domainBind(domain, fn))
  918.                                  : undefined;
  919. };
  920.  
  921. Promise.onUnhandledRejectionHandled = function (fn) {
  922.     var domain = getDomain();
  923.     unhandledRejectionHandled =
  924.         typeof fn === "function" ? (domain === null ?
  925.                                             fn : util.domainBind(domain, fn))
  926.                                  : undefined;
  927. };
  928.  
  929. var disableLongStackTraces = function() {};
  930. Promise.longStackTraces = function () {
  931.     if (async.haveItemsQueued() && !config.longStackTraces) {
  932.         throw new Error("cannot enable long stack traces after promises have been created\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
  933.     }
  934.     if (!config.longStackTraces && longStackTracesIsSupported()) {
  935.         var Promise_captureStackTrace = Promise.prototype._captureStackTrace;
  936.         var Promise_attachExtraTrace = Promise.prototype._attachExtraTrace;
  937.         config.longStackTraces = true;
  938.         disableLongStackTraces = function() {
  939.             if (async.haveItemsQueued() && !config.longStackTraces) {
  940.                 throw new Error("cannot enable long stack traces after promises have been created\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
  941.             }
  942.             Promise.prototype._captureStackTrace = Promise_captureStackTrace;
  943.             Promise.prototype._attachExtraTrace = Promise_attachExtraTrace;
  944.             Context.deactivateLongStackTraces();
  945.             async.enableTrampoline();
  946.             config.longStackTraces = false;
  947.         };
  948.         Promise.prototype._captureStackTrace = longStackTracesCaptureStackTrace;
  949.         Promise.prototype._attachExtraTrace = longStackTracesAttachExtraTrace;
  950.         Context.activateLongStackTraces();
  951.         async.disableTrampolineIfNecessary();
  952.     }
  953. };
  954.  
  955. Promise.hasLongStackTraces = function () {
  956.     return config.longStackTraces && longStackTracesIsSupported();
  957. };
  958.  
  959. var fireDomEvent = (function() {
  960.     try {
  961.         if (typeof CustomEvent === "function") {
  962.             var event = new CustomEvent("CustomEvent");
  963.             util.global.dispatchEvent(event);
  964.             return function(name, event) {
  965.                 var domEvent = new CustomEvent(name.toLowerCase(), {
  966.                     detail: event,
  967.                     cancelable: true
  968.                 });
  969.                 return !util.global.dispatchEvent(domEvent);
  970.             };
  971.         } else if (typeof Event === "function") {
  972.             var event = new Event("CustomEvent");
  973.             util.global.dispatchEvent(event);
  974.             return function(name, event) {
  975.                 var domEvent = new Event(name.toLowerCase(), {
  976.                     cancelable: true
  977.                 });
  978.                 domEvent.detail = event;
  979.                 return !util.global.dispatchEvent(domEvent);
  980.             };
  981.         } else {
  982.             var event = document.createEvent("CustomEvent");
  983.             event.initCustomEvent("testingtheevent", false, true, {});
  984.             util.global.dispatchEvent(event);
  985.             return function(name, event) {
  986.                 var domEvent = document.createEvent("CustomEvent");
  987.                 domEvent.initCustomEvent(name.toLowerCase(), false, true,
  988.                     event);
  989.                 return !util.global.dispatchEvent(domEvent);
  990.             };
  991.         }
  992.     } catch (e) {}
  993.     return function() {
  994.         return false;
  995.     };
  996. })();
  997.  
  998. var fireGlobalEvent = (function() {
  999.     if (util.isNode) {
  1000.         return function() {
  1001.             return process.emit.apply(process, arguments);
  1002.         };
  1003.     } else {
  1004.         if (!util.global) {
  1005.             return function() {
  1006.                 return false;
  1007.             };
  1008.         }
  1009.         return function(name) {
  1010.             var methodName = "on" + name.toLowerCase();
  1011.             var method = util.global[methodName];
  1012.             if (!method) return false;
  1013.             method.apply(util.global, [].slice.call(arguments, 1));
  1014.             return true;
  1015.         };
  1016.     }
  1017. })();
  1018.  
  1019. function generatePromiseLifecycleEventObject(name, promise) {
  1020.     return {promise: promise};
  1021. }
  1022.  
  1023. var eventToObjectGenerator = {
  1024.     promiseCreated: generatePromiseLifecycleEventObject,
  1025.     promiseFulfilled: generatePromiseLifecycleEventObject,
  1026.     promiseRejected: generatePromiseLifecycleEventObject,
  1027.     promiseResolved: generatePromiseLifecycleEventObject,
  1028.     promiseCancelled: generatePromiseLifecycleEventObject,
  1029.     promiseChained: function(name, promise, child) {
  1030.         return {promise: promise, child: child};
  1031.     },
  1032.     warning: function(name, warning) {
  1033.         return {warning: warning};
  1034.     },
  1035.     unhandledRejection: function (name, reason, promise) {
  1036.         return {reason: reason, promise: promise};
  1037.     },
  1038.     rejectionHandled: generatePromiseLifecycleEventObject
  1039. };
  1040.  
  1041. var activeFireEvent = function (name) {
  1042.     var globalEventFired = false;
  1043.     try {
  1044.         globalEventFired = fireGlobalEvent.apply(null, arguments);
  1045.     } catch (e) {
  1046.         async.throwLater(e);
  1047.         globalEventFired = true;
  1048.     }
  1049.  
  1050.     var domEventFired = false;
  1051.     try {
  1052.         domEventFired = fireDomEvent(name,
  1053.                     eventToObjectGenerator[name].apply(null, arguments));
  1054.     } catch (e) {
  1055.         async.throwLater(e);
  1056.         domEventFired = true;
  1057.     }
  1058.  
  1059.     return domEventFired || globalEventFired;
  1060. };
  1061.  
  1062. Promise.config = function(opts) {
  1063.     opts = Object(opts);
  1064.     if ("longStackTraces" in opts) {
  1065.         if (opts.longStackTraces) {
  1066.             Promise.longStackTraces();
  1067.         } else if (!opts.longStackTraces && Promise.hasLongStackTraces()) {
  1068.             disableLongStackTraces();
  1069.         }
  1070.     }
  1071.     if ("warnings" in opts) {
  1072.         var warningsOption = opts.warnings;
  1073.         config.warnings = !!warningsOption;
  1074.         wForgottenReturn = config.warnings;
  1075.  
  1076.         if (util.isObject(warningsOption)) {
  1077.             if ("wForgottenReturn" in warningsOption) {
  1078.                 wForgottenReturn = !!warningsOption.wForgottenReturn;
  1079.             }
  1080.         }
  1081.     }
  1082.     if ("cancellation" in opts && opts.cancellation && !config.cancellation) {
  1083.         if (async.haveItemsQueued()) {
  1084.             throw new Error(
  1085.                 "cannot enable cancellation after promises are in use");
  1086.         }
  1087.         Promise.prototype._clearCancellationData =
  1088.             cancellationClearCancellationData;
  1089.         Promise.prototype._propagateFrom = cancellationPropagateFrom;
  1090.         Promise.prototype._onCancel = cancellationOnCancel;
  1091.         Promise.prototype._setOnCancel = cancellationSetOnCancel;
  1092.         Promise.prototype._attachCancellationCallback =
  1093.             cancellationAttachCancellationCallback;
  1094.         Promise.prototype._execute = cancellationExecute;
  1095.         propagateFromFunction = cancellationPropagateFrom;
  1096.         config.cancellation = true;
  1097.     }
  1098.     if ("monitoring" in opts) {
  1099.         if (opts.monitoring && !config.monitoring) {
  1100.             config.monitoring = true;
  1101.             Promise.prototype._fireEvent = activeFireEvent;
  1102.         } else if (!opts.monitoring && config.monitoring) {
  1103.             config.monitoring = false;
  1104.             Promise.prototype._fireEvent = defaultFireEvent;
  1105.         }
  1106.     }
  1107.     return Promise;
  1108. };
  1109.  
  1110. function defaultFireEvent() { return false; }
  1111.  
  1112. Promise.prototype._fireEvent = defaultFireEvent;
  1113. Promise.prototype._execute = function(executor, resolve, reject) {
  1114.     try {
  1115.         executor(resolve, reject);
  1116.     } catch (e) {
  1117.         return e;
  1118.     }
  1119. };
  1120. Promise.prototype._onCancel = function () {};
  1121. Promise.prototype._setOnCancel = function (handler) { ; };
  1122. Promise.prototype._attachCancellationCallback = function(onCancel) {
  1123.     ;
  1124. };
  1125. Promise.prototype._captureStackTrace = function () {};
  1126. Promise.prototype._attachExtraTrace = function () {};
  1127. Promise.prototype._clearCancellationData = function() {};
  1128. Promise.prototype._propagateFrom = function (parent, flags) {
  1129.     ;
  1130.     ;
  1131. };
  1132.  
  1133. function cancellationExecute(executor, resolve, reject) {
  1134.     var promise = this;
  1135.     try {
  1136.         executor(resolve, reject, function(onCancel) {
  1137.             if (typeof onCancel !== "function") {
  1138.                 throw new TypeError("onCancel must be a function, got: " +
  1139.                                     util.toString(onCancel));
  1140.             }
  1141.             promise._attachCancellationCallback(onCancel);
  1142.         });
  1143.     } catch (e) {
  1144.         return e;
  1145.     }
  1146. }
  1147.  
  1148. function cancellationAttachCancellationCallback(onCancel) {
  1149.     if (!this._isCancellable()) return this;
  1150.  
  1151.     var previousOnCancel = this._onCancel();
  1152.     if (previousOnCancel !== undefined) {
  1153.         if (util.isArray(previousOnCancel)) {
  1154.             previousOnCancel.push(onCancel);
  1155.         } else {
  1156.             this._setOnCancel([previousOnCancel, onCancel]);
  1157.         }
  1158.     } else {
  1159.         this._setOnCancel(onCancel);
  1160.     }
  1161. }
  1162.  
  1163. function cancellationOnCancel() {
  1164.     return this._onCancelField;
  1165. }
  1166.  
  1167. function cancellationSetOnCancel(onCancel) {
  1168.     this._onCancelField = onCancel;
  1169. }
  1170.  
  1171. function cancellationClearCancellationData() {
  1172.     this._cancellationParent = undefined;
  1173.     this._onCancelField = undefined;
  1174. }
  1175.  
  1176. function cancellationPropagateFrom(parent, flags) {
  1177.     if ((flags & 1) !== 0) {
  1178.         this._cancellationParent = parent;
  1179.         var branchesRemainingToCancel = parent._branchesRemainingToCancel;
  1180.         if (branchesRemainingToCancel === undefined) {
  1181.             branchesRemainingToCancel = 0;
  1182.         }
  1183.         parent._branchesRemainingToCancel = branchesRemainingToCancel + 1;
  1184.     }
  1185.     if ((flags & 2) !== 0 && parent._isBound()) {
  1186.         this._setBoundTo(parent._boundTo);
  1187.     }
  1188. }
  1189.  
  1190. function bindingPropagateFrom(parent, flags) {
  1191.     if ((flags & 2) !== 0 && parent._isBound()) {
  1192.         this._setBoundTo(parent._boundTo);
  1193.     }
  1194. }
  1195. var propagateFromFunction = bindingPropagateFrom;
  1196.  
  1197. function boundValueFunction() {
  1198.     var ret = this._boundTo;
  1199.     if (ret !== undefined) {
  1200.         if (ret instanceof Promise) {
  1201.             if (ret.isFulfilled()) {
  1202.                 return ret.value();
  1203.             } else {
  1204.                 return undefined;
  1205.             }
  1206.         }
  1207.     }
  1208.     return ret;
  1209. }
  1210.  
  1211. function longStackTracesCaptureStackTrace() {
  1212.     this._trace = new CapturedTrace(this._peekContext());
  1213. }
  1214.  
  1215. function longStackTracesAttachExtraTrace(error, ignoreSelf) {
  1216.     if (canAttachTrace(error)) {
  1217.         var trace = this._trace;
  1218.         if (trace !== undefined) {
  1219.             if (ignoreSelf) trace = trace._parent;
  1220.         }
  1221.         if (trace !== undefined) {
  1222.             trace.attachExtraTrace(error);
  1223.         } else if (!error.__stackCleaned__) {
  1224.             var parsed = parseStackAndMessage(error);
  1225.             util.notEnumerableProp(error, "stack",
  1226.                 parsed.message + "\n" + parsed.stack.join("\n"));
  1227.             util.notEnumerableProp(error, "__stackCleaned__", true);
  1228.         }
  1229.     }
  1230. }
  1231.  
  1232. function checkForgottenReturns(returnValue, promiseCreated, name, promise,
  1233.                                parent) {
  1234.     if (returnValue === undefined && promiseCreated !== null &&
  1235.         wForgottenReturn) {
  1236.         if (parent !== undefined && parent._returnedNonUndefined()) return;
  1237.         if ((promise._bitField & 65535) === 0) return;
  1238.  
  1239.         if (name) name = name + " ";
  1240.         var handlerLine = "";
  1241.         var creatorLine = "";
  1242.         if (promiseCreated._trace) {
  1243.             var traceLines = promiseCreated._trace.stack.split("\n");
  1244.             var stack = cleanStack(traceLines);
  1245.             for (var i = stack.length - 1; i >= 0; --i) {
  1246.                 var line = stack[i];
  1247.                 if (!nodeFramePattern.test(line)) {
  1248.                     var lineMatches = line.match(parseLinePattern);
  1249.                     if (lineMatches) {
  1250.                         handlerLine  = "at " + lineMatches[1] +
  1251.                             ":" + lineMatches[2] + ":" + lineMatches[3] + " ";
  1252.                     }
  1253.                     break;
  1254.                 }
  1255.             }
  1256.  
  1257.             if (stack.length > 0) {
  1258.                 var firstUserLine = stack[0];
  1259.                 for (var i = 0; i < traceLines.length; ++i) {
  1260.  
  1261.                     if (traceLines[i] === firstUserLine) {
  1262.                         if (i > 0) {
  1263.                             creatorLine = "\n" + traceLines[i - 1];
  1264.                         }
  1265.                         break;
  1266.                     }
  1267.                 }
  1268.  
  1269.             }
  1270.         }
  1271.         var msg = "a promise was created in a " + name +
  1272.             "handler " + handlerLine + "but was not returned from it, " +
  1273.             "see http://goo.gl/rRqMUw" +
  1274.             creatorLine;
  1275.         promise._warn(msg, true, promiseCreated);
  1276.     }
  1277. }
  1278.  
  1279. function deprecated(name, replacement) {
  1280.     var message = name +
  1281.         " is deprecated and will be removed in a future version.";
  1282.     if (replacement) message += " Use " + replacement + " instead.";
  1283.     return warn(message);
  1284. }
  1285.  
  1286. function warn(message, shouldUseOwnTrace, promise) {
  1287.     if (!config.warnings) return;
  1288.     var warning = new Warning(message);
  1289.     var ctx;
  1290.     if (shouldUseOwnTrace) {
  1291.         promise._attachExtraTrace(warning);
  1292.     } else if (config.longStackTraces && (ctx = Promise._peekContext())) {
  1293.         ctx.attachExtraTrace(warning);
  1294.     } else {
  1295.         var parsed = parseStackAndMessage(warning);
  1296.         warning.stack = parsed.message + "\n" + parsed.stack.join("\n");
  1297.     }
  1298.  
  1299.     if (!activeFireEvent("warning", warning)) {
  1300.         formatAndLogError(warning, "", true);
  1301.     }
  1302. }
  1303.  
  1304. function reconstructStack(message, stacks) {
  1305.     for (var i = 0; i < stacks.length - 1; ++i) {
  1306.         stacks[i].push("From previous event:");
  1307.         stacks[i] = stacks[i].join("\n");
  1308.     }
  1309.     if (i < stacks.length) {
  1310.         stacks[i] = stacks[i].join("\n");
  1311.     }
  1312.     return message + "\n" + stacks.join("\n");
  1313. }
  1314.  
  1315. function removeDuplicateOrEmptyJumps(stacks) {
  1316.     for (var i = 0; i < stacks.length; ++i) {
  1317.         if (stacks[i].length === 0 ||
  1318.             ((i + 1 < stacks.length) && stacks[i][0] === stacks[i+1][0])) {
  1319.             stacks.splice(i, 1);
  1320.             i--;
  1321.         }
  1322.     }
  1323. }
  1324.  
  1325. function removeCommonRoots(stacks) {
  1326.     var current = stacks[0];
  1327.     for (var i = 1; i < stacks.length; ++i) {
  1328.         var prev = stacks[i];
  1329.         var currentLastIndex = current.length - 1;
  1330.         var currentLastLine = current[currentLastIndex];
  1331.         var commonRootMeetPoint = -1;
  1332.  
  1333.         for (var j = prev.length - 1; j >= 0; --j) {
  1334.             if (prev[j] === currentLastLine) {
  1335.                 commonRootMeetPoint = j;
  1336.                 break;
  1337.             }
  1338.         }
  1339.  
  1340.         for (var j = commonRootMeetPoint; j >= 0; --j) {
  1341.             var line = prev[j];
  1342.             if (current[currentLastIndex] === line) {
  1343.                 current.pop();
  1344.                 currentLastIndex--;
  1345.             } else {
  1346.                 break;
  1347.             }
  1348.         }
  1349.         current = prev;
  1350.     }
  1351. }
  1352.  
  1353. function cleanStack(stack) {
  1354.     var ret = [];
  1355.     for (var i = 0; i < stack.length; ++i) {
  1356.         var line = stack[i];
  1357.         var isTraceLine = "    (No stack trace)" === line ||
  1358.             stackFramePattern.test(line);
  1359.         var isInternalFrame = isTraceLine && shouldIgnore(line);
  1360.         if (isTraceLine && !isInternalFrame) {
  1361.             if (indentStackFrames && line.charAt(0) !== " ") {
  1362.                 line = "    " + line;
  1363.             }
  1364.             ret.push(line);
  1365.         }
  1366.     }
  1367.     return ret;
  1368. }
  1369.  
  1370. function stackFramesAsArray(error) {
  1371.     var stack = error.stack.replace(/\s+$/g, "").split("\n");
  1372.     for (var i = 0; i < stack.length; ++i) {
  1373.         var line = stack[i];
  1374.         if ("    (No stack trace)" === line || stackFramePattern.test(line)) {
  1375.             break;
  1376.         }
  1377.     }
  1378.     if (i > 0 && error.name != "SyntaxError") {
  1379.         stack = stack.slice(i);
  1380.     }
  1381.     return stack;
  1382. }
  1383.  
  1384. function parseStackAndMessage(error) {
  1385.     var stack = error.stack;
  1386.     var message = error.toString();
  1387.     stack = typeof stack === "string" && stack.length > 0
  1388.                 ? stackFramesAsArray(error) : ["    (No stack trace)"];
  1389.     return {
  1390.         message: message,
  1391.         stack: error.name == "SyntaxError" ? stack : cleanStack(stack)
  1392.     };
  1393. }
  1394.  
  1395. function formatAndLogError(error, title, isSoft) {
  1396.     if (typeof console !== "undefined") {
  1397.         var message;
  1398.         if (util.isObject(error)) {
  1399.             var stack = error.stack;
  1400.             message = title + formatStack(stack, error);
  1401.         } else {
  1402.             message = title + String(error);
  1403.         }
  1404.         if (typeof printWarning === "function") {
  1405.             printWarning(message, isSoft);
  1406.         } else if (typeof console.log === "function" ||
  1407.             typeof console.log === "object") {
  1408.             console.log(message);
  1409.         }
  1410.     }
  1411. }
  1412.  
  1413. function fireRejectionEvent(name, localHandler, reason, promise) {
  1414.     var localEventFired = false;
  1415.     try {
  1416.         if (typeof localHandler === "function") {
  1417.             localEventFired = true;
  1418.             if (name === "rejectionHandled") {
  1419.                 localHandler(promise);
  1420.             } else {
  1421.                 localHandler(reason, promise);
  1422.             }
  1423.         }
  1424.     } catch (e) {
  1425.         async.throwLater(e);
  1426.     }
  1427.  
  1428.     if (name === "unhandledRejection") {
  1429.         if (!activeFireEvent(name, reason, promise) && !localEventFired) {
  1430.             formatAndLogError(reason, "Unhandled rejection ");
  1431.         }
  1432.     } else {
  1433.         activeFireEvent(name, promise);
  1434.     }
  1435. }
  1436.  
  1437. function formatNonError(obj) {
  1438.     var str;
  1439.     if (typeof obj === "function") {
  1440.         str = "[function " +
  1441.             (obj.name || "anonymous") +
  1442.             "]";
  1443.     } else {
  1444.         str = obj && typeof obj.toString === "function"
  1445.             ? obj.toString() : util.toString(obj);
  1446.         var ruselessToString = /\[object [a-zA-Z0-9$_]+\]/;
  1447.         if (ruselessToString.test(str)) {
  1448.             try {
  1449.                 var newStr = JSON.stringify(obj);
  1450.                 str = newStr;
  1451.             }
  1452.             catch(e) {
  1453.  
  1454.             }
  1455.         }
  1456.         if (str.length === 0) {
  1457.             str = "(empty array)";
  1458.         }
  1459.     }
  1460.     return ("(<" + snip(str) + ">, no stack trace)");
  1461. }
  1462.  
  1463. function snip(str) {
  1464.     var maxChars = 41;
  1465.     if (str.length < maxChars) {
  1466.         return str;
  1467.     }
  1468.     return str.substr(0, maxChars - 3) + "...";
  1469. }
  1470.  
  1471. function longStackTracesIsSupported() {
  1472.     return typeof captureStackTrace === "function";
  1473. }
  1474.  
  1475. var shouldIgnore = function() { return false; };
  1476. var parseLineInfoRegex = /[\/<\(]([^:\/]+):(\d+):(?:\d+)\)?\s*$/;
  1477. function parseLineInfo(line) {
  1478.     var matches = line.match(parseLineInfoRegex);
  1479.     if (matches) {
  1480.         return {
  1481.             fileName: matches[1],
  1482.             line: parseInt(matches[2], 10)
  1483.         };
  1484.     }
  1485. }
  1486.  
  1487. function setBounds(firstLineError, lastLineError) {
  1488.     if (!longStackTracesIsSupported()) return;
  1489.     var firstStackLines = firstLineError.stack.split("\n");
  1490.     var lastStackLines = lastLineError.stack.split("\n");
  1491.     var firstIndex = -1;
  1492.     var lastIndex = -1;
  1493.     var firstFileName;
  1494.     var lastFileName;
  1495.     for (var i = 0; i < firstStackLines.length; ++i) {
  1496.         var result = parseLineInfo(firstStackLines[i]);
  1497.         if (result) {
  1498.             firstFileName = result.fileName;
  1499.             firstIndex = result.line;
  1500.             break;
  1501.         }
  1502.     }
  1503.     for (var i = 0; i < lastStackLines.length; ++i) {
  1504.         var result = parseLineInfo(lastStackLines[i]);
  1505.         if (result) {
  1506.             lastFileName = result.fileName;
  1507.             lastIndex = result.line;
  1508.             break;
  1509.         }
  1510.     }
  1511.     if (firstIndex < 0 || lastIndex < 0 || !firstFileName || !lastFileName ||
  1512.         firstFileName !== lastFileName || firstIndex >= lastIndex) {
  1513.         return;
  1514.     }
  1515.  
  1516.     shouldIgnore = function(line) {
  1517.         if (bluebirdFramePattern.test(line)) return true;
  1518.         var info = parseLineInfo(line);
  1519.         if (info) {
  1520.             if (info.fileName === firstFileName &&
  1521.                 (firstIndex <= info.line && info.line <= lastIndex)) {
  1522.                 return true;
  1523.             }
  1524.         }
  1525.         return false;
  1526.     };
  1527. }
  1528.  
  1529. function CapturedTrace(parent) {
  1530.     this._parent = parent;
  1531.     this._promisesCreated = 0;
  1532.     var length = this._length = 1 + (parent === undefined ? 0 : parent._length);
  1533.     captureStackTrace(this, CapturedTrace);
  1534.     if (length > 32) this.uncycle();
  1535. }
  1536. util.inherits(CapturedTrace, Error);
  1537. Context.CapturedTrace = CapturedTrace;
  1538.  
  1539. CapturedTrace.prototype.uncycle = function() {
  1540.     var length = this._length;
  1541.     if (length < 2) return;
  1542.     var nodes = [];
  1543.     var stackToIndex = {};
  1544.  
  1545.     for (var i = 0, node = this; node !== undefined; ++i) {
  1546.         nodes.push(node);
  1547.         node = node._parent;
  1548.     }
  1549.     length = this._length = i;
  1550.     for (var i = length - 1; i >= 0; --i) {
  1551.         var stack = nodes[i].stack;
  1552.         if (stackToIndex[stack] === undefined) {
  1553.             stackToIndex[stack] = i;
  1554.         }
  1555.     }
  1556.     for (var i = 0; i < length; ++i) {
  1557.         var currentStack = nodes[i].stack;
  1558.         var index = stackToIndex[currentStack];
  1559.         if (index !== undefined && index !== i) {
  1560.             if (index > 0) {
  1561.                 nodes[index - 1]._parent = undefined;
  1562.                 nodes[index - 1]._length = 1;
  1563.             }
  1564.             nodes[i]._parent = undefined;
  1565.             nodes[i]._length = 1;
  1566.             var cycleEdgeNode = i > 0 ? nodes[i - 1] : this;
  1567.  
  1568.             if (index < length - 1) {
  1569.                 cycleEdgeNode._parent = nodes[index + 1];
  1570.                 cycleEdgeNode._parent.uncycle();
  1571.                 cycleEdgeNode._length =
  1572.                     cycleEdgeNode._parent._length + 1;
  1573.             } else {
  1574.                 cycleEdgeNode._parent = undefined;
  1575.                 cycleEdgeNode._length = 1;
  1576.             }
  1577.             var currentChildLength = cycleEdgeNode._length + 1;
  1578.             for (var j = i - 2; j >= 0; --j) {
  1579.                 nodes[j]._length = currentChildLength;
  1580.                 currentChildLength++;
  1581.             }
  1582.             return;
  1583.         }
  1584.     }
  1585. };
  1586.  
  1587. CapturedTrace.prototype.attachExtraTrace = function(error) {
  1588.     if (error.__stackCleaned__) return;
  1589.     this.uncycle();
  1590.     var parsed = parseStackAndMessage(error);
  1591.     var message = parsed.message;
  1592.     var stacks = [parsed.stack];
  1593.  
  1594.     var trace = this;
  1595.     while (trace !== undefined) {
  1596.         stacks.push(cleanStack(trace.stack.split("\n")));
  1597.         trace = trace._parent;
  1598.     }
  1599.     removeCommonRoots(stacks);
  1600.     removeDuplicateOrEmptyJumps(stacks);
  1601.     util.notEnumerableProp(error, "stack", reconstructStack(message, stacks));
  1602.     util.notEnumerableProp(error, "__stackCleaned__", true);
  1603. };
  1604.  
  1605. var captureStackTrace = (function stackDetection() {
  1606.     var v8stackFramePattern = /^\s*at\s*/;
  1607.     var v8stackFormatter = function(stack, error) {
  1608.         if (typeof stack === "string") return stack;
  1609.  
  1610.         if (error.name !== undefined &&
  1611.             error.message !== undefined) {
  1612.             return error.toString();
  1613.         }
  1614.         return formatNonError(error);
  1615.     };
  1616.  
  1617.     if (typeof Error.stackTraceLimit === "number" &&
  1618.         typeof Error.captureStackTrace === "function") {
  1619.         Error.stackTraceLimit += 6;
  1620.         stackFramePattern = v8stackFramePattern;
  1621.         formatStack = v8stackFormatter;
  1622.         var captureStackTrace = Error.captureStackTrace;
  1623.  
  1624.         shouldIgnore = function(line) {
  1625.             return bluebirdFramePattern.test(line);
  1626.         };
  1627.         return function(receiver, ignoreUntil) {
  1628.             Error.stackTraceLimit += 6;
  1629.             captureStackTrace(receiver, ignoreUntil);
  1630.             Error.stackTraceLimit -= 6;
  1631.         };
  1632.     }
  1633.     var err = new Error();
  1634.  
  1635.     if (typeof err.stack === "string" &&
  1636.         err.stack.split("\n")[0].indexOf("stackDetection@") >= 0) {
  1637.         stackFramePattern = /@/;
  1638.         formatStack = v8stackFormatter;
  1639.         indentStackFrames = true;
  1640.         return function captureStackTrace(o) {
  1641.             o.stack = new Error().stack;
  1642.         };
  1643.     }
  1644.  
  1645.     var hasStackAfterThrow;
  1646.     try { throw new Error(); }
  1647.     catch(e) {
  1648.         hasStackAfterThrow = ("stack" in e);
  1649.     }
  1650.     if (!("stack" in err) && hasStackAfterThrow &&
  1651.         typeof Error.stackTraceLimit === "number") {
  1652.         stackFramePattern = v8stackFramePattern;
  1653.         formatStack = v8stackFormatter;
  1654.         return function captureStackTrace(o) {
  1655.             Error.stackTraceLimit += 6;
  1656.             try { throw new Error(); }
  1657.             catch(e) { o.stack = e.stack; }
  1658.             Error.stackTraceLimit -= 6;
  1659.         };
  1660.     }
  1661.  
  1662.     formatStack = function(stack, error) {
  1663.         if (typeof stack === "string") return stack;
  1664.  
  1665.         if ((typeof error === "object" ||
  1666.             typeof error === "function") &&
  1667.             error.name !== undefined &&
  1668.             error.message !== undefined) {
  1669.             return error.toString();
  1670.         }
  1671.         return formatNonError(error);
  1672.     };
  1673.  
  1674.     return null;
  1675.  
  1676. })([]);
  1677.  
  1678. if (typeof console !== "undefined" && typeof console.warn !== "undefined") {
  1679.     printWarning = function (message) {
  1680.         console.warn(message);
  1681.     };
  1682.     if (util.isNode && process.stderr.isTTY) {
  1683.         printWarning = function(message, isSoft) {
  1684.             var color = isSoft ? "\u001b[33m" : "\u001b[31m";
  1685.             console.warn(color + message + "\u001b[0m\n");
  1686.         };
  1687.     } else if (!util.isNode && typeof (new Error().stack) === "string") {
  1688.         printWarning = function(message, isSoft) {
  1689.             console.warn("%c" + message,
  1690.                         isSoft ? "color: darkorange" : "color: red");
  1691.         };
  1692.     }
  1693. }
  1694.  
  1695. var config = {
  1696.     warnings: warnings,
  1697.     longStackTraces: false,
  1698.     cancellation: false,
  1699.     monitoring: false
  1700. };
  1701.  
  1702. if (longStackTraces) Promise.longStackTraces();
  1703.  
  1704. return {
  1705.     longStackTraces: function() {
  1706.         return config.longStackTraces;
  1707.     },
  1708.     warnings: function() {
  1709.         return config.warnings;
  1710.     },
  1711.     cancellation: function() {
  1712.         return config.cancellation;
  1713.     },
  1714.     monitoring: function() {
  1715.         return config.monitoring;
  1716.     },
  1717.     propagateFromFunction: function() {
  1718.         return propagateFromFunction;
  1719.     },
  1720.     boundValueFunction: function() {
  1721.         return boundValueFunction;
  1722.     },
  1723.     checkForgottenReturns: checkForgottenReturns,
  1724.     setBounds: setBounds,
  1725.     warn: warn,
  1726.     deprecated: deprecated,
  1727.     CapturedTrace: CapturedTrace,
  1728.     fireDomEvent: fireDomEvent,
  1729.     fireGlobalEvent: fireGlobalEvent
  1730. };
  1731. };
  1732.  
  1733. },{"./errors":12,"./util":36}],10:[function(_dereq_,module,exports){
  1734. "use strict";
  1735. module.exports = function(Promise) {
  1736. function returner() {
  1737.     return this.value;
  1738. }
  1739. function thrower() {
  1740.     throw this.reason;
  1741. }
  1742.  
  1743. Promise.prototype["return"] =
  1744. Promise.prototype.thenReturn = function (value) {
  1745.     if (value instanceof Promise) value.suppressUnhandledRejections();
  1746.     return this._then(
  1747.         returner, undefined, undefined, {value: value}, undefined);
  1748. };
  1749.  
  1750. Promise.prototype["throw"] =
  1751. Promise.prototype.thenThrow = function (reason) {
  1752.     return this._then(
  1753.         thrower, undefined, undefined, {reason: reason}, undefined);
  1754. };
  1755.  
  1756. Promise.prototype.catchThrow = function (reason) {
  1757.     if (arguments.length <= 1) {
  1758.         return this._then(
  1759.             undefined, thrower, undefined, {reason: reason}, undefined);
  1760.     } else {
  1761.         var _reason = arguments[1];
  1762.         var handler = function() {throw _reason;};
  1763.         return this.caught(reason, handler);
  1764.     }
  1765. };
  1766.  
  1767. Promise.prototype.catchReturn = function (value) {
  1768.     if (arguments.length <= 1) {
  1769.         if (value instanceof Promise) value.suppressUnhandledRejections();
  1770.         return this._then(
  1771.             undefined, returner, undefined, {value: value}, undefined);
  1772.     } else {
  1773.         var _value = arguments[1];
  1774.         if (_value instanceof Promise) _value.suppressUnhandledRejections();
  1775.         var handler = function() {return _value;};
  1776.         return this.caught(value, handler);
  1777.     }
  1778. };
  1779. };
  1780.  
  1781. },{}],11:[function(_dereq_,module,exports){
  1782. "use strict";
  1783. module.exports = function(Promise, INTERNAL) {
  1784. var PromiseReduce = Promise.reduce;
  1785. var PromiseAll = Promise.all;
  1786.  
  1787. function promiseAllThis() {
  1788.     return PromiseAll(this);
  1789. }
  1790.  
  1791. function PromiseMapSeries(promises, fn) {
  1792.     return PromiseReduce(promises, fn, INTERNAL, INTERNAL);
  1793. }
  1794.  
  1795. Promise.prototype.each = function (fn) {
  1796.     return PromiseReduce(this, fn, INTERNAL, 0)
  1797.               ._then(promiseAllThis, undefined, undefined, this, undefined);
  1798. };
  1799.  
  1800. Promise.prototype.mapSeries = function (fn) {
  1801.     return PromiseReduce(this, fn, INTERNAL, INTERNAL);
  1802. };
  1803.  
  1804. Promise.each = function (promises, fn) {
  1805.     return PromiseReduce(promises, fn, INTERNAL, 0)
  1806.               ._then(promiseAllThis, undefined, undefined, promises, undefined);
  1807. };
  1808.  
  1809. Promise.mapSeries = PromiseMapSeries;
  1810. };
  1811.  
  1812.  
  1813. },{}],12:[function(_dereq_,module,exports){
  1814. "use strict";
  1815. var es5 = _dereq_("./es5");
  1816. var Objectfreeze = es5.freeze;
  1817. var util = _dereq_("./util");
  1818. var inherits = util.inherits;
  1819. var notEnumerableProp = util.notEnumerableProp;
  1820.  
  1821. function subError(nameProperty, defaultMessage) {
  1822.     function SubError(message) {
  1823.         if (!(this instanceof SubError)) return new SubError(message);
  1824.         notEnumerableProp(this, "message",
  1825.             typeof message === "string" ? message : defaultMessage);
  1826.         notEnumerableProp(this, "name", nameProperty);
  1827.         if (Error.captureStackTrace) {
  1828.             Error.captureStackTrace(this, this.constructor);
  1829.         } else {
  1830.             Error.call(this);
  1831.         }
  1832.     }
  1833.     inherits(SubError, Error);
  1834.     return SubError;
  1835. }
  1836.  
  1837. var _TypeError, _RangeError;
  1838. var Warning = subError("Warning", "warning");
  1839. var CancellationError = subError("CancellationError", "cancellation error");
  1840. var TimeoutError = subError("TimeoutError", "timeout error");
  1841. var AggregateError = subError("AggregateError", "aggregate error");
  1842. try {
  1843.     _TypeError = TypeError;
  1844.     _RangeError = RangeError;
  1845. } catch(e) {
  1846.     _TypeError = subError("TypeError", "type error");
  1847.     _RangeError = subError("RangeError", "range error");
  1848. }
  1849.  
  1850. var methods = ("join pop push shift unshift slice filter forEach some " +
  1851.     "every map indexOf lastIndexOf reduce reduceRight sort reverse").split(" ");
  1852.  
  1853. for (var i = 0; i < methods.length; ++i) {
  1854.     if (typeof Array.prototype[methods[i]] === "function") {
  1855.         AggregateError.prototype[methods[i]] = Array.prototype[methods[i]];
  1856.     }
  1857. }
  1858.  
  1859. es5.defineProperty(AggregateError.prototype, "length", {
  1860.     value: 0,
  1861.     configurable: false,
  1862.     writable: true,
  1863.     enumerable: true
  1864. });
  1865. AggregateError.prototype["isOperational"] = true;
  1866. var level = 0;
  1867. AggregateError.prototype.toString = function() {
  1868.     var indent = Array(level * 4 + 1).join(" ");
  1869.     var ret = "\n" + indent + "AggregateError of:" + "\n";
  1870.     level++;
  1871.     indent = Array(level * 4 + 1).join(" ");
  1872.     for (var i = 0; i < this.length; ++i) {
  1873.         var str = this[i] === this ? "[Circular AggregateError]" : this[i] + "";
  1874.         var lines = str.split("\n");
  1875.         for (var j = 0; j < lines.length; ++j) {
  1876.             lines[j] = indent + lines[j];
  1877.         }
  1878.         str = lines.join("\n");
  1879.         ret += str + "\n";
  1880.     }
  1881.     level--;
  1882.     return ret;
  1883. };
  1884.  
  1885. function OperationalError(message) {
  1886.     if (!(this instanceof OperationalError))
  1887.         return new OperationalError(message);
  1888.     notEnumerableProp(this, "name", "OperationalError");
  1889.     notEnumerableProp(this, "message", message);
  1890.     this.cause = message;
  1891.     this["isOperational"] = true;
  1892.  
  1893.     if (message instanceof Error) {
  1894.         notEnumerableProp(this, "message", message.message);
  1895.         notEnumerableProp(this, "stack", message.stack);
  1896.     } else if (Error.captureStackTrace) {
  1897.         Error.captureStackTrace(this, this.constructor);
  1898.     }
  1899.  
  1900. }
  1901. inherits(OperationalError, Error);
  1902.  
  1903. var errorTypes = Error["__BluebirdErrorTypes__"];
  1904. if (!errorTypes) {
  1905.     errorTypes = Objectfreeze({
  1906.         CancellationError: CancellationError,
  1907.         TimeoutError: TimeoutError,
  1908.         OperationalError: OperationalError,
  1909.         RejectionError: OperationalError,
  1910.         AggregateError: AggregateError
  1911.     });
  1912.     es5.defineProperty(Error, "__BluebirdErrorTypes__", {
  1913.         value: errorTypes,
  1914.         writable: false,
  1915.         enumerable: false,
  1916.         configurable: false
  1917.     });
  1918. }
  1919.  
  1920. module.exports = {
  1921.     Error: Error,
  1922.     TypeError: _TypeError,
  1923.     RangeError: _RangeError,
  1924.     CancellationError: errorTypes.CancellationError,
  1925.     OperationalError: errorTypes.OperationalError,
  1926.     TimeoutError: errorTypes.TimeoutError,
  1927.     AggregateError: errorTypes.AggregateError,
  1928.     Warning: Warning
  1929. };
  1930.  
  1931. },{"./es5":13,"./util":36}],13:[function(_dereq_,module,exports){
  1932. var isES5 = (function(){
  1933.     "use strict";
  1934.     return this === undefined;
  1935. })();
  1936.  
  1937. if (isES5) {
  1938.     module.exports = {
  1939.         freeze: Object.freeze,
  1940.         defineProperty: Object.defineProperty,
  1941.         getDescriptor: Object.getOwnPropertyDescriptor,
  1942.         keys: Object.keys,
  1943.         names: Object.getOwnPropertyNames,
  1944.         getPrototypeOf: Object.getPrototypeOf,
  1945.         isArray: Array.isArray,
  1946.         isES5: isES5,
  1947.         propertyIsWritable: function(obj, prop) {
  1948.             var descriptor = Object.getOwnPropertyDescriptor(obj, prop);
  1949.             return !!(!descriptor || descriptor.writable || descriptor.set);
  1950.         }
  1951.     };
  1952. } else {
  1953.     var has = {}.hasOwnProperty;
  1954.     var str = {}.toString;
  1955.     var proto = {}.constructor.prototype;
  1956.  
  1957.     var ObjectKeys = function (o) {
  1958.         var ret = [];
  1959.         for (var key in o) {
  1960.             if (has.call(o, key)) {
  1961.                 ret.push(key);
  1962.             }
  1963.         }
  1964.         return ret;
  1965.     };
  1966.  
  1967.     var ObjectGetDescriptor = function(o, key) {
  1968.         return {value: o[key]};
  1969.     };
  1970.  
  1971.     var ObjectDefineProperty = function (o, key, desc) {
  1972.         o[key] = desc.value;
  1973.         return o;
  1974.     };
  1975.  
  1976.     var ObjectFreeze = function (obj) {
  1977.         return obj;
  1978.     };
  1979.  
  1980.     var ObjectGetPrototypeOf = function (obj) {
  1981.         try {
  1982.             return Object(obj).constructor.prototype;
  1983.         }
  1984.         catch (e) {
  1985.             return proto;
  1986.         }
  1987.     };
  1988.  
  1989.     var ArrayIsArray = function (obj) {
  1990.         try {
  1991.             return str.call(obj) === "[object Array]";
  1992.         }
  1993.         catch(e) {
  1994.             return false;
  1995.         }
  1996.     };
  1997.  
  1998.     module.exports = {
  1999.         isArray: ArrayIsArray,
  2000.         keys: ObjectKeys,
  2001.         names: ObjectKeys,
  2002.         defineProperty: ObjectDefineProperty,
  2003.         getDescriptor: ObjectGetDescriptor,
  2004.         freeze: ObjectFreeze,
  2005.         getPrototypeOf: ObjectGetPrototypeOf,
  2006.         isES5: isES5,
  2007.         propertyIsWritable: function() {
  2008.             return true;
  2009.         }
  2010.     };
  2011. }
  2012.  
  2013. },{}],14:[function(_dereq_,module,exports){
  2014. "use strict";
  2015. module.exports = function(Promise, INTERNAL) {
  2016. var PromiseMap = Promise.map;
  2017.  
  2018. Promise.prototype.filter = function (fn, options) {
  2019.     return PromiseMap(this, fn, options, INTERNAL);
  2020. };
  2021.  
  2022. Promise.filter = function (promises, fn, options) {
  2023.     return PromiseMap(promises, fn, options, INTERNAL);
  2024. };
  2025. };
  2026.  
  2027. },{}],15:[function(_dereq_,module,exports){
  2028. "use strict";
  2029. module.exports = function(Promise, tryConvertToPromise, NEXT_FILTER) {
  2030. var util = _dereq_("./util");
  2031. var CancellationError = Promise.CancellationError;
  2032. var errorObj = util.errorObj;
  2033. var catchFilter = _dereq_("./catch_filter")(NEXT_FILTER);
  2034.  
  2035. function PassThroughHandlerContext(promise, type, handler) {
  2036.     this.promise = promise;
  2037.     this.type = type;
  2038.     this.handler = handler;
  2039.     this.called = false;
  2040.     this.cancelPromise = null;
  2041. }
  2042.  
  2043. PassThroughHandlerContext.prototype.isFinallyHandler = function() {
  2044.     return this.type === 0;
  2045. };
  2046.  
  2047. function FinallyHandlerCancelReaction(finallyHandler) {
  2048.     this.finallyHandler = finallyHandler;
  2049. }
  2050.  
  2051. FinallyHandlerCancelReaction.prototype._resultCancelled = function() {
  2052.     checkCancel(this.finallyHandler);
  2053. };
  2054.  
  2055. function checkCancel(ctx, reason) {
  2056.     if (ctx.cancelPromise != null) {
  2057.         if (arguments.length > 1) {
  2058.             ctx.cancelPromise._reject(reason);
  2059.         } else {
  2060.             ctx.cancelPromise._cancel();
  2061.         }
  2062.         ctx.cancelPromise = null;
  2063.         return true;
  2064.     }
  2065.     return false;
  2066. }
  2067.  
  2068. function succeed() {
  2069.     return finallyHandler.call(this, this.promise._target()._settledValue());
  2070. }
  2071. function fail(reason) {
  2072.     if (checkCancel(this, reason)) return;
  2073.     errorObj.e = reason;
  2074.     return errorObj;
  2075. }
  2076. function finallyHandler(reasonOrValue) {
  2077.     var promise = this.promise;
  2078.     var handler = this.handler;
  2079.  
  2080.     if (!this.called) {
  2081.         this.called = true;
  2082.         var ret = this.isFinallyHandler()
  2083.             ? handler.call(promise._boundValue())
  2084.             : handler.call(promise._boundValue(), reasonOrValue);
  2085.         if (ret === NEXT_FILTER) {
  2086.             return ret;
  2087.         } else if (ret !== undefined) {
  2088.             promise._setReturnedNonUndefined();
  2089.             var maybePromise = tryConvertToPromise(ret, promise);
  2090.             if (maybePromise instanceof Promise) {
  2091.                 if (this.cancelPromise != null) {
  2092.                     if (maybePromise._isCancelled()) {
  2093.                         var reason =
  2094.                             new CancellationError("late cancellation observer");
  2095.                         promise._attachExtraTrace(reason);
  2096.                         errorObj.e = reason;
  2097.                         return errorObj;
  2098.                     } else if (maybePromise.isPending()) {
  2099.                         maybePromise._attachCancellationCallback(
  2100.                             new FinallyHandlerCancelReaction(this));
  2101.                     }
  2102.                 }
  2103.                 return maybePromise._then(
  2104.                     succeed, fail, undefined, this, undefined);
  2105.             }
  2106.         }
  2107.     }
  2108.  
  2109.     if (promise.isRejected()) {
  2110.         checkCancel(this);
  2111.         errorObj.e = reasonOrValue;
  2112.         return errorObj;
  2113.     } else {
  2114.         checkCancel(this);
  2115.         return reasonOrValue;
  2116.     }
  2117. }
  2118.  
  2119. Promise.prototype._passThrough = function(handler, type, success, fail) {
  2120.     if (typeof handler !== "function") return this.then();
  2121.     return this._then(success,
  2122.                       fail,
  2123.                       undefined,
  2124.                       new PassThroughHandlerContext(this, type, handler),
  2125.                       undefined);
  2126. };
  2127.  
  2128. Promise.prototype.lastly =
  2129. Promise.prototype["finally"] = function (handler) {
  2130.     return this._passThrough(handler,
  2131.                              0,
  2132.                              finallyHandler,
  2133.                              finallyHandler);
  2134. };
  2135.  
  2136.  
  2137. Promise.prototype.tap = function (handler) {
  2138.     return this._passThrough(handler, 1, finallyHandler);
  2139. };
  2140.  
  2141. Promise.prototype.tapCatch = function (handlerOrPredicate) {
  2142.     var len = arguments.length;
  2143.     if(len === 1) {
  2144.         return this._passThrough(handlerOrPredicate,
  2145.                                  1,
  2146.                                  undefined,
  2147.                                  finallyHandler);
  2148.     } else {
  2149.          var catchInstances = new Array(len - 1),
  2150.             j = 0, i;
  2151.         for (i = 0; i < len - 1; ++i) {
  2152.             var item = arguments[i];
  2153.             if (util.isObject(item)) {
  2154.                 catchInstances[j++] = item;
  2155.             } else {
  2156.                 return Promise.reject(new TypeError(
  2157.                     "tapCatch statement predicate: "
  2158.                     + "expecting an object but got " + util.classString(item)
  2159.                 ));
  2160.             }
  2161.         }
  2162.         catchInstances.length = j;
  2163.         var handler = arguments[i];
  2164.         return this._passThrough(catchFilter(catchInstances, handler, this),
  2165.                                  1,
  2166.                                  undefined,
  2167.                                  finallyHandler);
  2168.     }
  2169.  
  2170. };
  2171.  
  2172. return PassThroughHandlerContext;
  2173. };
  2174.  
  2175. },{"./catch_filter":7,"./util":36}],16:[function(_dereq_,module,exports){
  2176. "use strict";
  2177. module.exports = function(Promise,
  2178.                           apiRejection,
  2179.                           INTERNAL,
  2180.                           tryConvertToPromise,
  2181.                           Proxyable,
  2182.                           debug) {
  2183. var errors = _dereq_("./errors");
  2184. var TypeError = errors.TypeError;
  2185. var util = _dereq_("./util");
  2186. var errorObj = util.errorObj;
  2187. var tryCatch = util.tryCatch;
  2188. var yieldHandlers = [];
  2189.  
  2190. function promiseFromYieldHandler(value, yieldHandlers, traceParent) {
  2191.     for (var i = 0; i < yieldHandlers.length; ++i) {
  2192.         traceParent._pushContext();
  2193.         var result = tryCatch(yieldHandlers[i])(value);
  2194.         traceParent._popContext();
  2195.         if (result === errorObj) {
  2196.             traceParent._pushContext();
  2197.             var ret = Promise.reject(errorObj.e);
  2198.             traceParent._popContext();
  2199.             return ret;
  2200.         }
  2201.         var maybePromise = tryConvertToPromise(result, traceParent);
  2202.         if (maybePromise instanceof Promise) return maybePromise;
  2203.     }
  2204.     return null;
  2205. }
  2206.  
  2207. function PromiseSpawn(generatorFunction, receiver, yieldHandler, stack) {
  2208.     if (debug.cancellation()) {
  2209.         var internal = new Promise(INTERNAL);
  2210.         var _finallyPromise = this._finallyPromise = new Promise(INTERNAL);
  2211.         this._promise = internal.lastly(function() {
  2212.             return _finallyPromise;
  2213.         });
  2214.         internal._captureStackTrace();
  2215.         internal._setOnCancel(this);
  2216.     } else {
  2217.         var promise = this._promise = new Promise(INTERNAL);
  2218.         promise._captureStackTrace();
  2219.     }
  2220.     this._stack = stack;
  2221.     this._generatorFunction = generatorFunction;
  2222.     this._receiver = receiver;
  2223.     this._generator = undefined;
  2224.     this._yieldHandlers = typeof yieldHandler === "function"
  2225.         ? [yieldHandler].concat(yieldHandlers)
  2226.         : yieldHandlers;
  2227.     this._yieldedPromise = null;
  2228.     this._cancellationPhase = false;
  2229. }
  2230. util.inherits(PromiseSpawn, Proxyable);
  2231.  
  2232. PromiseSpawn.prototype._isResolved = function() {
  2233.     return this._promise === null;
  2234. };
  2235.  
  2236. PromiseSpawn.prototype._cleanup = function() {
  2237.     this._promise = this._generator = null;
  2238.     if (debug.cancellation() && this._finallyPromise !== null) {
  2239.         this._finallyPromise._fulfill();
  2240.         this._finallyPromise = null;
  2241.     }
  2242. };
  2243.  
  2244. PromiseSpawn.prototype._promiseCancelled = function() {
  2245.     if (this._isResolved()) return;
  2246.     var implementsReturn = typeof this._generator["return"] !== "undefined";
  2247.  
  2248.     var result;
  2249.     if (!implementsReturn) {
  2250.         var reason = new Promise.CancellationError(
  2251.             "generator .return() sentinel");
  2252.         Promise.coroutine.returnSentinel = reason;
  2253.         this._promise._attachExtraTrace(reason);
  2254.         this._promise._pushContext();
  2255.         result = tryCatch(this._generator["throw"]).call(this._generator,
  2256.                                                          reason);
  2257.         this._promise._popContext();
  2258.     } else {
  2259.         this._promise._pushContext();
  2260.         result = tryCatch(this._generator["return"]).call(this._generator,
  2261.                                                           undefined);
  2262.         this._promise._popContext();
  2263.     }
  2264.     this._cancellationPhase = true;
  2265.     this._yieldedPromise = null;
  2266.     this._continue(result);
  2267. };
  2268.  
  2269. PromiseSpawn.prototype._promiseFulfilled = function(value) {
  2270.     this._yieldedPromise = null;
  2271.     this._promise._pushContext();
  2272.     var result = tryCatch(this._generator.next).call(this._generator, value);
  2273.     this._promise._popContext();
  2274.     this._continue(result);
  2275. };
  2276.  
  2277. PromiseSpawn.prototype._promiseRejected = function(reason) {
  2278.     this._yieldedPromise = null;
  2279.     this._promise._attachExtraTrace(reason);
  2280.     this._promise._pushContext();
  2281.     var result = tryCatch(this._generator["throw"])
  2282.         .call(this._generator, reason);
  2283.     this._promise._popContext();
  2284.     this._continue(result);
  2285. };
  2286.  
  2287. PromiseSpawn.prototype._resultCancelled = function() {
  2288.     if (this._yieldedPromise instanceof Promise) {
  2289.         var promise = this._yieldedPromise;
  2290.         this._yieldedPromise = null;
  2291.         promise.cancel();
  2292.     }
  2293. };
  2294.  
  2295. PromiseSpawn.prototype.promise = function () {
  2296.     return this._promise;
  2297. };
  2298.  
  2299. PromiseSpawn.prototype._run = function () {
  2300.     this._generator = this._generatorFunction.call(this._receiver);
  2301.     this._receiver =
  2302.         this._generatorFunction = undefined;
  2303.     this._promiseFulfilled(undefined);
  2304. };
  2305.  
  2306. PromiseSpawn.prototype._continue = function (result) {
  2307.     var promise = this._promise;
  2308.     if (result === errorObj) {
  2309.         this._cleanup();
  2310.         if (this._cancellationPhase) {
  2311.             return promise.cancel();
  2312.         } else {
  2313.             return promise._rejectCallback(result.e, false);
  2314.         }
  2315.     }
  2316.  
  2317.     var value = result.value;
  2318.     if (result.done === true) {
  2319.         this._cleanup();
  2320.         if (this._cancellationPhase) {
  2321.             return promise.cancel();
  2322.         } else {
  2323.             return promise._resolveCallback(value);
  2324.         }
  2325.     } else {
  2326.         var maybePromise = tryConvertToPromise(value, this._promise);
  2327.         if (!(maybePromise instanceof Promise)) {
  2328.             maybePromise =
  2329.                 promiseFromYieldHandler(maybePromise,
  2330.                                         this._yieldHandlers,
  2331.                                         this._promise);
  2332.             if (maybePromise === null) {
  2333.                 this._promiseRejected(
  2334.                     new TypeError(
  2335.                         "A value %s was yielded that could not be treated as a promise\u000a\u000a    See http://goo.gl/MqrFmX\u000a\u000a".replace("%s", String(value)) +
  2336.                         "From coroutine:\u000a" +
  2337.                         this._stack.split("\n").slice(1, -7).join("\n")
  2338.                     )
  2339.                 );
  2340.                 return;
  2341.             }
  2342.         }
  2343.         maybePromise = maybePromise._target();
  2344.         var bitField = maybePromise._bitField;
  2345.         ;
  2346.         if (((bitField & 50397184) === 0)) {
  2347.             this._yieldedPromise = maybePromise;
  2348.             maybePromise._proxy(this, null);
  2349.         } else if (((bitField & 33554432) !== 0)) {
  2350.             Promise._async.invoke(
  2351.                 this._promiseFulfilled, this, maybePromise._value()
  2352.             );
  2353.         } else if (((bitField & 16777216) !== 0)) {
  2354.             Promise._async.invoke(
  2355.                 this._promiseRejected, this, maybePromise._reason()
  2356.             );
  2357.         } else {
  2358.             this._promiseCancelled();
  2359.         }
  2360.     }
  2361. };
  2362.  
  2363. Promise.coroutine = function (generatorFunction, options) {
  2364.     if (typeof generatorFunction !== "function") {
  2365.         throw new TypeError("generatorFunction must be a function\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
  2366.     }
  2367.     var yieldHandler = Object(options).yieldHandler;
  2368.     var PromiseSpawn$ = PromiseSpawn;
  2369.     var stack = new Error().stack;
  2370.     return function () {
  2371.         var generator = generatorFunction.apply(this, arguments);
  2372.         var spawn = new PromiseSpawn$(undefined, undefined, yieldHandler,
  2373.                                       stack);
  2374.         var ret = spawn.promise();
  2375.         spawn._generator = generator;
  2376.         spawn._promiseFulfilled(undefined);
  2377.         return ret;
  2378.     };
  2379. };
  2380.  
  2381. Promise.coroutine.addYieldHandler = function(fn) {
  2382.     if (typeof fn !== "function") {
  2383.         throw new TypeError("expecting a function but got " + util.classString(fn));
  2384.     }
  2385.     yieldHandlers.push(fn);
  2386. };
  2387.  
  2388. Promise.spawn = function (generatorFunction) {
  2389.     debug.deprecated("Promise.spawn()", "Promise.coroutine()");
  2390.     if (typeof generatorFunction !== "function") {
  2391.         return apiRejection("generatorFunction must be a function\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
  2392.     }
  2393.     var spawn = new PromiseSpawn(generatorFunction, this);
  2394.     var ret = spawn.promise();
  2395.     spawn._run(Promise.spawn);
  2396.     return ret;
  2397. };
  2398. };
  2399.  
  2400. },{"./errors":12,"./util":36}],17:[function(_dereq_,module,exports){
  2401. "use strict";
  2402. module.exports =
  2403. function(Promise, PromiseArray, tryConvertToPromise, INTERNAL, async,
  2404.          getDomain) {
  2405. var util = _dereq_("./util");
  2406. var canEvaluate = util.canEvaluate;
  2407. var tryCatch = util.tryCatch;
  2408. var errorObj = util.errorObj;
  2409. var reject;
  2410.  
  2411. if (false) {
  2412. if (canEvaluate) {
  2413.     var thenCallback = function(i) {
  2414.         return new Function("value", "holder", "                             \n\
  2415.             'use strict';                                                    \n\
  2416.             holder.pIndex = value;                                           \n\
  2417.             holder.checkFulfillment(this);                                   \n\
  2418.             ".replace(/Index/g, i));
  2419.     };
  2420.  
  2421.     var promiseSetter = function(i) {
  2422.         return new Function("promise", "holder", "                           \n\
  2423.             'use strict';                                                    \n\
  2424.             holder.pIndex = promise;                                         \n\
  2425.             ".replace(/Index/g, i));
  2426.     };
  2427.  
  2428.     var generateHolderClass = function(total) {
  2429.         var props = new Array(total);
  2430.         for (var i = 0; i < props.length; ++i) {
  2431.             props[i] = "this.p" + (i+1);
  2432.         }
  2433.         var assignment = props.join(" = ") + " = null;";
  2434.         var cancellationCode= "var promise;\n" + props.map(function(prop) {
  2435.             return "                                                         \n\
  2436.                 promise = " + prop + ";                                      \n\
  2437.                 if (promise instanceof Promise) {                            \n\
  2438.                     promise.cancel();                                        \n\
  2439.                 }                                                            \n\
  2440.             ";
  2441.         }).join("\n");
  2442.         var passedArguments = props.join(", ");
  2443.         var name = "Holder$" + total;
  2444.  
  2445.  
  2446.         var code = "return function(tryCatch, errorObj, Promise, async) {    \n\
  2447.             'use strict';                                                    \n\
  2448.             function [TheName](fn) {                                         \n\
  2449.                 [TheProperties]                                              \n\
  2450.                 this.fn = fn;                                                \n\
  2451.                 this.asyncNeeded = true;                                     \n\
  2452.                 this.now = 0;                                                \n\
  2453.             }                                                                \n\
  2454.                                                                              \n\
  2455.             [TheName].prototype._callFunction = function(promise) {          \n\
  2456.                 promise._pushContext();                                      \n\
  2457.                 var ret = tryCatch(this.fn)([ThePassedArguments]);           \n\
  2458.                 promise._popContext();                                       \n\
  2459.                 if (ret === errorObj) {                                      \n\
  2460.                     promise._rejectCallback(ret.e, false);                   \n\
  2461.                 } else {                                                     \n\
  2462.                     promise._resolveCallback(ret);                           \n\
  2463.                 }                                                            \n\
  2464.             };                                                               \n\
  2465.                                                                              \n\
  2466.             [TheName].prototype.checkFulfillment = function(promise) {       \n\
  2467.                 var now = ++this.now;                                        \n\
  2468.                 if (now === [TheTotal]) {                                    \n\
  2469.                     if (this.asyncNeeded) {                                  \n\
  2470.                         async.invoke(this._callFunction, this, promise);     \n\
  2471.                     } else {                                                 \n\
  2472.                         this._callFunction(promise);                         \n\
  2473.                     }                                                        \n\
  2474.                                                                              \n\
  2475.                 }                                                            \n\
  2476.             };                                                               \n\
  2477.                                                                              \n\
  2478.             [TheName].prototype._resultCancelled = function() {              \n\
  2479.                 [CancellationCode]                                           \n\
  2480.             };                                                               \n\
  2481.                                                                              \n\
  2482.             return [TheName];                                                \n\
  2483.         }(tryCatch, errorObj, Promise, async);                               \n\
  2484.         ";
  2485.  
  2486.         code = code.replace(/\[TheName\]/g, name)
  2487.             .replace(/\[TheTotal\]/g, total)
  2488.             .replace(/\[ThePassedArguments\]/g, passedArguments)
  2489.             .replace(/\[TheProperties\]/g, assignment)
  2490.             .replace(/\[CancellationCode\]/g, cancellationCode);
  2491.  
  2492.         return new Function("tryCatch", "errorObj", "Promise", "async", code)
  2493.                            (tryCatch, errorObj, Promise, async);
  2494.     };
  2495.  
  2496.     var holderClasses = [];
  2497.     var thenCallbacks = [];
  2498.     var promiseSetters = [];
  2499.  
  2500.     for (var i = 0; i < 8; ++i) {
  2501.         holderClasses.push(generateHolderClass(i + 1));
  2502.         thenCallbacks.push(thenCallback(i + 1));
  2503.         promiseSetters.push(promiseSetter(i + 1));
  2504.     }
  2505.  
  2506.     reject = function (reason) {
  2507.         this._reject(reason);
  2508.     };
  2509. }}
  2510.  
  2511. Promise.join = function () {
  2512.     var last = arguments.length - 1;
  2513.     var fn;
  2514.     if (last > 0 && typeof arguments[last] === "function") {
  2515.         fn = arguments[last];
  2516.         if (false) {
  2517.             if (last <= 8 && canEvaluate) {
  2518.                 var ret = new Promise(INTERNAL);
  2519.                 ret._captureStackTrace();
  2520.                 var HolderClass = holderClasses[last - 1];
  2521.                 var holder = new HolderClass(fn);
  2522.                 var callbacks = thenCallbacks;
  2523.  
  2524.                 for (var i = 0; i < last; ++i) {
  2525.                     var maybePromise = tryConvertToPromise(arguments[i], ret);
  2526.                     if (maybePromise instanceof Promise) {
  2527.                         maybePromise = maybePromise._target();
  2528.                         var bitField = maybePromise._bitField;
  2529.                         ;
  2530.                         if (((bitField & 50397184) === 0)) {
  2531.                             maybePromise._then(callbacks[i], reject,
  2532.                                                undefined, ret, holder);
  2533.                             promiseSetters[i](maybePromise, holder);
  2534.                             holder.asyncNeeded = false;
  2535.                         } else if (((bitField & 33554432) !== 0)) {
  2536.                             callbacks[i].call(ret,
  2537.                                               maybePromise._value(), holder);
  2538.                         } else if (((bitField & 16777216) !== 0)) {
  2539.                             ret._reject(maybePromise._reason());
  2540.                         } else {
  2541.                             ret._cancel();
  2542.                         }
  2543.                     } else {
  2544.                         callbacks[i].call(ret, maybePromise, holder);
  2545.                     }
  2546.                 }
  2547.  
  2548.                 if (!ret._isFateSealed()) {
  2549.                     if (holder.asyncNeeded) {
  2550.                         var domain = getDomain();
  2551.                         if (domain !== null) {
  2552.                             holder.fn = util.domainBind(domain, holder.fn);
  2553.                         }
  2554.                     }
  2555.                     ret._setAsyncGuaranteed();
  2556.                     ret._setOnCancel(holder);
  2557.                 }
  2558.                 return ret;
  2559.             }
  2560.         }
  2561.     }
  2562.     var args = [].slice.call(arguments);;
  2563.     if (fn) args.pop();
  2564.     var ret = new PromiseArray(args).promise();
  2565.     return fn !== undefined ? ret.spread(fn) : ret;
  2566. };
  2567.  
  2568. };
  2569.  
  2570. },{"./util":36}],18:[function(_dereq_,module,exports){
  2571. "use strict";
  2572. module.exports = function(Promise,
  2573.                           PromiseArray,
  2574.                           apiRejection,
  2575.                           tryConvertToPromise,
  2576.                           INTERNAL,
  2577.                           debug) {
  2578. var getDomain = Promise._getDomain;
  2579. var util = _dereq_("./util");
  2580. var tryCatch = util.tryCatch;
  2581. var errorObj = util.errorObj;
  2582. var async = Promise._async;
  2583.  
  2584. function MappingPromiseArray(promises, fn, limit, _filter) {
  2585.     this.constructor$(promises);
  2586.     this._promise._captureStackTrace();
  2587.     var domain = getDomain();
  2588.     this._callback = domain === null ? fn : util.domainBind(domain, fn);
  2589.     this._preservedValues = _filter === INTERNAL
  2590.         ? new Array(this.length())
  2591.         : null;
  2592.     this._limit = limit;
  2593.     this._inFlight = 0;
  2594.     this._queue = [];
  2595.     async.invoke(this._asyncInit, this, undefined);
  2596. }
  2597. util.inherits(MappingPromiseArray, PromiseArray);
  2598.  
  2599. MappingPromiseArray.prototype._asyncInit = function() {
  2600.     this._init$(undefined, -2);
  2601. };
  2602.  
  2603. MappingPromiseArray.prototype._init = function () {};
  2604.  
  2605. MappingPromiseArray.prototype._promiseFulfilled = function (value, index) {
  2606.     var values = this._values;
  2607.     var length = this.length();
  2608.     var preservedValues = this._preservedValues;
  2609.     var limit = this._limit;
  2610.  
  2611.     if (index < 0) {
  2612.         index = (index * -1) - 1;
  2613.         values[index] = value;
  2614.         if (limit >= 1) {
  2615.             this._inFlight--;
  2616.             this._drainQueue();
  2617.             if (this._isResolved()) return true;
  2618.         }
  2619.     } else {
  2620.         if (limit >= 1 && this._inFlight >= limit) {
  2621.             values[index] = value;
  2622.             this._queue.push(index);
  2623.             return false;
  2624.         }
  2625.         if (preservedValues !== null) preservedValues[index] = value;
  2626.  
  2627.         var promise = this._promise;
  2628.         var callback = this._callback;
  2629.         var receiver = promise._boundValue();
  2630.         promise._pushContext();
  2631.         var ret = tryCatch(callback).call(receiver, value, index, length);
  2632.         var promiseCreated = promise._popContext();
  2633.         debug.checkForgottenReturns(
  2634.             ret,
  2635.             promiseCreated,
  2636.             preservedValues !== null ? "Promise.filter" : "Promise.map",
  2637.             promise
  2638.         );
  2639.         if (ret === errorObj) {
  2640.             this._reject(ret.e);
  2641.             return true;
  2642.         }
  2643.  
  2644.         var maybePromise = tryConvertToPromise(ret, this._promise);
  2645.         if (maybePromise instanceof Promise) {
  2646.             maybePromise = maybePromise._target();
  2647.             var bitField = maybePromise._bitField;
  2648.             ;
  2649.             if (((bitField & 50397184) === 0)) {
  2650.                 if (limit >= 1) this._inFlight++;
  2651.                 values[index] = maybePromise;
  2652.                 maybePromise._proxy(this, (index + 1) * -1);
  2653.                 return false;
  2654.             } else if (((bitField & 33554432) !== 0)) {
  2655.                 ret = maybePromise._value();
  2656.             } else if (((bitField & 16777216) !== 0)) {
  2657.                 this._reject(maybePromise._reason());
  2658.                 return true;
  2659.             } else {
  2660.                 this._cancel();
  2661.                 return true;
  2662.             }
  2663.         }
  2664.         values[index] = ret;
  2665.     }
  2666.     var totalResolved = ++this._totalResolved;
  2667.     if (totalResolved >= length) {
  2668.         if (preservedValues !== null) {
  2669.             this._filter(values, preservedValues);
  2670.         } else {
  2671.             this._resolve(values);
  2672.         }
  2673.         return true;
  2674.     }
  2675.     return false;
  2676. };
  2677.  
  2678. MappingPromiseArray.prototype._drainQueue = function () {
  2679.     var queue = this._queue;
  2680.     var limit = this._limit;
  2681.     var values = this._values;
  2682.     while (queue.length > 0 && this._inFlight < limit) {
  2683.         if (this._isResolved()) return;
  2684.         var index = queue.pop();
  2685.         this._promiseFulfilled(values[index], index);
  2686.     }
  2687. };
  2688.  
  2689. MappingPromiseArray.prototype._filter = function (booleans, values) {
  2690.     var len = values.length;
  2691.     var ret = new Array(len);
  2692.     var j = 0;
  2693.     for (var i = 0; i < len; ++i) {
  2694.         if (booleans[i]) ret[j++] = values[i];
  2695.     }
  2696.     ret.length = j;
  2697.     this._resolve(ret);
  2698. };
  2699.  
  2700. MappingPromiseArray.prototype.preservedValues = function () {
  2701.     return this._preservedValues;
  2702. };
  2703.  
  2704. function map(promises, fn, options, _filter) {
  2705.     if (typeof fn !== "function") {
  2706.         return apiRejection("expecting a function but got " + util.classString(fn));
  2707.     }
  2708.  
  2709.     var limit = 0;
  2710.     if (options !== undefined) {
  2711.         if (typeof options === "object" && options !== null) {
  2712.             if (typeof options.concurrency !== "number") {
  2713.                 return Promise.reject(
  2714.                     new TypeError("'concurrency' must be a number but it is " +
  2715.                                     util.classString(options.concurrency)));
  2716.             }
  2717.             limit = options.concurrency;
  2718.         } else {
  2719.             return Promise.reject(new TypeError(
  2720.                             "options argument must be an object but it is " +
  2721.                              util.classString(options)));
  2722.         }
  2723.     }
  2724.     limit = typeof limit === "number" &&
  2725.         isFinite(limit) && limit >= 1 ? limit : 0;
  2726.     return new MappingPromiseArray(promises, fn, limit, _filter).promise();
  2727. }
  2728.  
  2729. Promise.prototype.map = function (fn, options) {
  2730.     return map(this, fn, options, null);
  2731. };
  2732.  
  2733. Promise.map = function (promises, fn, options, _filter) {
  2734.     return map(promises, fn, options, _filter);
  2735. };
  2736.  
  2737.  
  2738. };
  2739.  
  2740. },{"./util":36}],19:[function(_dereq_,module,exports){
  2741. "use strict";
  2742. module.exports =
  2743. function(Promise, INTERNAL, tryConvertToPromise, apiRejection, debug) {
  2744. var util = _dereq_("./util");
  2745. var tryCatch = util.tryCatch;
  2746.  
  2747. Promise.method = function (fn) {
  2748.     if (typeof fn !== "function") {
  2749.         throw new Promise.TypeError("expecting a function but got " + util.classString(fn));
  2750.     }
  2751.     return function () {
  2752.         var ret = new Promise(INTERNAL);
  2753.         ret._captureStackTrace();
  2754.         ret._pushContext();
  2755.         var value = tryCatch(fn).apply(this, arguments);
  2756.         var promiseCreated = ret._popContext();
  2757.         debug.checkForgottenReturns(
  2758.             value, promiseCreated, "Promise.method", ret);
  2759.         ret._resolveFromSyncValue(value);
  2760.         return ret;
  2761.     };
  2762. };
  2763.  
  2764. Promise.attempt = Promise["try"] = function (fn) {
  2765.     if (typeof fn !== "function") {
  2766.         return apiRejection("expecting a function but got " + util.classString(fn));
  2767.     }
  2768.     var ret = new Promise(INTERNAL);
  2769.     ret._captureStackTrace();
  2770.     ret._pushContext();
  2771.     var value;
  2772.     if (arguments.length > 1) {
  2773.         debug.deprecated("calling Promise.try with more than 1 argument");
  2774.         var arg = arguments[1];
  2775.         var ctx = arguments[2];
  2776.         value = util.isArray(arg) ? tryCatch(fn).apply(ctx, arg)
  2777.                                   : tryCatch(fn).call(ctx, arg);
  2778.     } else {
  2779.         value = tryCatch(fn)();
  2780.     }
  2781.     var promiseCreated = ret._popContext();
  2782.     debug.checkForgottenReturns(
  2783.         value, promiseCreated, "Promise.try", ret);
  2784.     ret._resolveFromSyncValue(value);
  2785.     return ret;
  2786. };
  2787.  
  2788. Promise.prototype._resolveFromSyncValue = function (value) {
  2789.     if (value === util.errorObj) {
  2790.         this._rejectCallback(value.e, false);
  2791.     } else {
  2792.         this._resolveCallback(value, true);
  2793.     }
  2794. };
  2795. };
  2796.  
  2797. },{"./util":36}],20:[function(_dereq_,module,exports){
  2798. "use strict";
  2799. var util = _dereq_("./util");
  2800. var maybeWrapAsError = util.maybeWrapAsError;
  2801. var errors = _dereq_("./errors");
  2802. var OperationalError = errors.OperationalError;
  2803. var es5 = _dereq_("./es5");
  2804.  
  2805. function isUntypedError(obj) {
  2806.     return obj instanceof Error &&
  2807.         es5.getPrototypeOf(obj) === Error.prototype;
  2808. }
  2809.  
  2810. var rErrorKey = /^(?:name|message|stack|cause)$/;
  2811. function wrapAsOperationalError(obj) {
  2812.     var ret;
  2813.     if (isUntypedError(obj)) {
  2814.         ret = new OperationalError(obj);
  2815.         ret.name = obj.name;
  2816.         ret.message = obj.message;
  2817.         ret.stack = obj.stack;
  2818.         var keys = es5.keys(obj);
  2819.         for (var i = 0; i < keys.length; ++i) {
  2820.             var key = keys[i];
  2821.             if (!rErrorKey.test(key)) {
  2822.                 ret[key] = obj[key];
  2823.             }
  2824.         }
  2825.         return ret;
  2826.     }
  2827.     util.markAsOriginatingFromRejection(obj);
  2828.     return obj;
  2829. }
  2830.  
  2831. function nodebackForPromise(promise, multiArgs) {
  2832.     return function(err, value) {
  2833.         if (promise === null) return;
  2834.         if (err) {
  2835.             var wrapped = wrapAsOperationalError(maybeWrapAsError(err));
  2836.             promise._attachExtraTrace(wrapped);
  2837.             promise._reject(wrapped);
  2838.         } else if (!multiArgs) {
  2839.             promise._fulfill(value);
  2840.         } else {
  2841.             var args = [].slice.call(arguments, 1);;
  2842.             promise._fulfill(args);
  2843.         }
  2844.         promise = null;
  2845.     };
  2846. }
  2847.  
  2848. module.exports = nodebackForPromise;
  2849.  
  2850. },{"./errors":12,"./es5":13,"./util":36}],21:[function(_dereq_,module,exports){
  2851. "use strict";
  2852. module.exports = function(Promise) {
  2853. var util = _dereq_("./util");
  2854. var async = Promise._async;
  2855. var tryCatch = util.tryCatch;
  2856. var errorObj = util.errorObj;
  2857.  
  2858. function spreadAdapter(val, nodeback) {
  2859.     var promise = this;
  2860.     if (!util.isArray(val)) return successAdapter.call(promise, val, nodeback);
  2861.     var ret =
  2862.         tryCatch(nodeback).apply(promise._boundValue(), [null].concat(val));
  2863.     if (ret === errorObj) {
  2864.         async.throwLater(ret.e);
  2865.     }
  2866. }
  2867.  
  2868. function successAdapter(val, nodeback) {
  2869.     var promise = this;
  2870.     var receiver = promise._boundValue();
  2871.     var ret = val === undefined
  2872.         ? tryCatch(nodeback).call(receiver, null)
  2873.         : tryCatch(nodeback).call(receiver, null, val);
  2874.     if (ret === errorObj) {
  2875.         async.throwLater(ret.e);
  2876.     }
  2877. }
  2878. function errorAdapter(reason, nodeback) {
  2879.     var promise = this;
  2880.     if (!reason) {
  2881.         var newReason = new Error(reason + "");
  2882.         newReason.cause = reason;
  2883.         reason = newReason;
  2884.     }
  2885.     var ret = tryCatch(nodeback).call(promise._boundValue(), reason);
  2886.     if (ret === errorObj) {
  2887.         async.throwLater(ret.e);
  2888.     }
  2889. }
  2890.  
  2891. Promise.prototype.asCallback = Promise.prototype.nodeify = function (nodeback,
  2892.                                                                      options) {
  2893.     if (typeof nodeback == "function") {
  2894.         var adapter = successAdapter;
  2895.         if (options !== undefined && Object(options).spread) {
  2896.             adapter = spreadAdapter;
  2897.         }
  2898.         this._then(
  2899.             adapter,
  2900.             errorAdapter,
  2901.             undefined,
  2902.             this,
  2903.             nodeback
  2904.         );
  2905.     }
  2906.     return this;
  2907. };
  2908. };
  2909.  
  2910. },{"./util":36}],22:[function(_dereq_,module,exports){
  2911. "use strict";
  2912. module.exports = function() {
  2913. var makeSelfResolutionError = function () {
  2914.     return new TypeError("circular promise resolution chain\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
  2915. };
  2916. var reflectHandler = function() {
  2917.     return new Promise.PromiseInspection(this._target());
  2918. };
  2919. var apiRejection = function(msg) {
  2920.     return Promise.reject(new TypeError(msg));
  2921. };
  2922. function Proxyable() {}
  2923. var UNDEFINED_BINDING = {};
  2924. var util = _dereq_("./util");
  2925.  
  2926. var getDomain;
  2927. if (util.isNode) {
  2928.     getDomain = function() {
  2929.         var ret = process.domain;
  2930.         if (ret === undefined) ret = null;
  2931.         return ret;
  2932.     };
  2933. } else {
  2934.     getDomain = function() {
  2935.         return null;
  2936.     };
  2937. }
  2938. util.notEnumerableProp(Promise, "_getDomain", getDomain);
  2939.  
  2940. var es5 = _dereq_("./es5");
  2941. var Async = _dereq_("./async");
  2942. var async = new Async();
  2943. es5.defineProperty(Promise, "_async", {value: async});
  2944. var errors = _dereq_("./errors");
  2945. var TypeError = Promise.TypeError = errors.TypeError;
  2946. Promise.RangeError = errors.RangeError;
  2947. var CancellationError = Promise.CancellationError = errors.CancellationError;
  2948. Promise.TimeoutError = errors.TimeoutError;
  2949. Promise.OperationalError = errors.OperationalError;
  2950. Promise.RejectionError = errors.OperationalError;
  2951. Promise.AggregateError = errors.AggregateError;
  2952. var INTERNAL = function(){};
  2953. var APPLY = {};
  2954. var NEXT_FILTER = {};
  2955. var tryConvertToPromise = _dereq_("./thenables")(Promise, INTERNAL);
  2956. var PromiseArray =
  2957.     _dereq_("./promise_array")(Promise, INTERNAL,
  2958.                                tryConvertToPromise, apiRejection, Proxyable);
  2959. var Context = _dereq_("./context")(Promise);
  2960.  /*jshint unused:false*/
  2961. var createContext = Context.create;
  2962. var debug = _dereq_("./debuggability")(Promise, Context);
  2963. var CapturedTrace = debug.CapturedTrace;
  2964. var PassThroughHandlerContext =
  2965.     _dereq_("./finally")(Promise, tryConvertToPromise, NEXT_FILTER);
  2966. var catchFilter = _dereq_("./catch_filter")(NEXT_FILTER);
  2967. var nodebackForPromise = _dereq_("./nodeback");
  2968. var errorObj = util.errorObj;
  2969. var tryCatch = util.tryCatch;
  2970. function check(self, executor) {
  2971.     if (self == null || self.constructor !== Promise) {
  2972.         throw new TypeError("the promise constructor cannot be invoked directly\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
  2973.     }
  2974.     if (typeof executor !== "function") {
  2975.         throw new TypeError("expecting a function but got " + util.classString(executor));
  2976.     }
  2977.  
  2978. }
  2979.  
  2980. function Promise(executor) {
  2981.     if (executor !== INTERNAL) {
  2982.         check(this, executor);
  2983.     }
  2984.     this._bitField = 0;
  2985.     this._fulfillmentHandler0 = undefined;
  2986.     this._rejectionHandler0 = undefined;
  2987.     this._promise0 = undefined;
  2988.     this._receiver0 = undefined;
  2989.     this._resolveFromExecutor(executor);
  2990.     this._promiseCreated();
  2991.     this._fireEvent("promiseCreated", this);
  2992. }
  2993.  
  2994. Promise.prototype.toString = function () {
  2995.     return "[object Promise]";
  2996. };
  2997.  
  2998. Promise.prototype.caught = Promise.prototype["catch"] = function (fn) {
  2999.     var len = arguments.length;
  3000.     if (len > 1) {
  3001.         var catchInstances = new Array(len - 1),
  3002.             j = 0, i;
  3003.         for (i = 0; i < len - 1; ++i) {
  3004.             var item = arguments[i];
  3005.             if (util.isObject(item)) {
  3006.                 catchInstances[j++] = item;
  3007.             } else {
  3008.                 return apiRejection("Catch statement predicate: " +
  3009.                     "expecting an object but got " + util.classString(item));
  3010.             }
  3011.         }
  3012.         catchInstances.length = j;
  3013.         fn = arguments[i];
  3014.         return this.then(undefined, catchFilter(catchInstances, fn, this));
  3015.     }
  3016.     return this.then(undefined, fn);
  3017. };
  3018.  
  3019. Promise.prototype.reflect = function () {
  3020.     return this._then(reflectHandler,
  3021.         reflectHandler, undefined, this, undefined);
  3022. };
  3023.  
  3024. Promise.prototype.then = function (didFulfill, didReject) {
  3025.     if (debug.warnings() && arguments.length > 0 &&
  3026.         typeof didFulfill !== "function" &&
  3027.         typeof didReject !== "function") {
  3028.         var msg = ".then() only accepts functions but was passed: " +
  3029.                 util.classString(didFulfill);
  3030.         if (arguments.length > 1) {
  3031.             msg += ", " + util.classString(didReject);
  3032.         }
  3033.         this._warn(msg);
  3034.     }
  3035.     return this._then(didFulfill, didReject, undefined, undefined, undefined);
  3036. };
  3037.  
  3038. Promise.prototype.done = function (didFulfill, didReject) {
  3039.     var promise =
  3040.         this._then(didFulfill, didReject, undefined, undefined, undefined);
  3041.     promise._setIsFinal();
  3042. };
  3043.  
  3044. Promise.prototype.spread = function (fn) {
  3045.     if (typeof fn !== "function") {
  3046.         return apiRejection("expecting a function but got " + util.classString(fn));
  3047.     }
  3048.     return this.all()._then(fn, undefined, undefined, APPLY, undefined);
  3049. };
  3050.  
  3051. Promise.prototype.toJSON = function () {
  3052.     var ret = {
  3053.         isFulfilled: false,
  3054.         isRejected: false,
  3055.         fulfillmentValue: undefined,
  3056.         rejectionReason: undefined
  3057.     };
  3058.     if (this.isFulfilled()) {
  3059.         ret.fulfillmentValue = this.value();
  3060.         ret.isFulfilled = true;
  3061.     } else if (this.isRejected()) {
  3062.         ret.rejectionReason = this.reason();
  3063.         ret.isRejected = true;
  3064.     }
  3065.     return ret;
  3066. };
  3067.  
  3068. Promise.prototype.all = function () {
  3069.     if (arguments.length > 0) {
  3070.         this._warn(".all() was passed arguments but it does not take any");
  3071.     }
  3072.     return new PromiseArray(this).promise();
  3073. };
  3074.  
  3075. Promise.prototype.error = function (fn) {
  3076.     return this.caught(util.originatesFromRejection, fn);
  3077. };
  3078.  
  3079. Promise.getNewLibraryCopy = module.exports;
  3080.  
  3081. Promise.is = function (val) {
  3082.     return val instanceof Promise;
  3083. };
  3084.  
  3085. Promise.fromNode = Promise.fromCallback = function(fn) {
  3086.     var ret = new Promise(INTERNAL);
  3087.     ret._captureStackTrace();
  3088.     var multiArgs = arguments.length > 1 ? !!Object(arguments[1]).multiArgs
  3089.                                          : false;
  3090.     var result = tryCatch(fn)(nodebackForPromise(ret, multiArgs));
  3091.     if (result === errorObj) {
  3092.         ret._rejectCallback(result.e, true);
  3093.     }
  3094.     if (!ret._isFateSealed()) ret._setAsyncGuaranteed();
  3095.     return ret;
  3096. };
  3097.  
  3098. Promise.all = function (promises) {
  3099.     return new PromiseArray(promises).promise();
  3100. };
  3101.  
  3102. Promise.cast = function (obj) {
  3103.     var ret = tryConvertToPromise(obj);
  3104.     if (!(ret instanceof Promise)) {
  3105.         ret = new Promise(INTERNAL);
  3106.         ret._captureStackTrace();
  3107.         ret._setFulfilled();
  3108.         ret._rejectionHandler0 = obj;
  3109.     }
  3110.     return ret;
  3111. };
  3112.  
  3113. Promise.resolve = Promise.fulfilled = Promise.cast;
  3114.  
  3115. Promise.reject = Promise.rejected = function (reason) {
  3116.     var ret = new Promise(INTERNAL);
  3117.     ret._captureStackTrace();
  3118.     ret._rejectCallback(reason, true);
  3119.     return ret;
  3120. };
  3121.  
  3122. Promise.setScheduler = function(fn) {
  3123.     if (typeof fn !== "function") {
  3124.         throw new TypeError("expecting a function but got " + util.classString(fn));
  3125.     }
  3126.     return async.setScheduler(fn);
  3127. };
  3128.  
  3129. Promise.prototype._then = function (
  3130.     didFulfill,
  3131.     didReject,
  3132.     _,    receiver,
  3133.     internalData
  3134. ) {
  3135.     var haveInternalData = internalData !== undefined;
  3136.     var promise = haveInternalData ? internalData : new Promise(INTERNAL);
  3137.     var target = this._target();
  3138.     var bitField = target._bitField;
  3139.  
  3140.     if (!haveInternalData) {
  3141.         promise._propagateFrom(this, 3);
  3142.         promise._captureStackTrace();
  3143.         if (receiver === undefined &&
  3144.             ((this._bitField & 2097152) !== 0)) {
  3145.             if (!((bitField & 50397184) === 0)) {
  3146.                 receiver = this._boundValue();
  3147.             } else {
  3148.                 receiver = target === this ? undefined : this._boundTo;
  3149.             }
  3150.         }
  3151.         this._fireEvent("promiseChained", this, promise);
  3152.     }
  3153.  
  3154.     var domain = getDomain();
  3155.     if (!((bitField & 50397184) === 0)) {
  3156.         var handler, value, settler = target._settlePromiseCtx;
  3157.         if (((bitField & 33554432) !== 0)) {
  3158.             value = target._rejectionHandler0;
  3159.             handler = didFulfill;
  3160.         } else if (((bitField & 16777216) !== 0)) {
  3161.             value = target._fulfillmentHandler0;
  3162.             handler = didReject;
  3163.             target._unsetRejectionIsUnhandled();
  3164.         } else {
  3165.             settler = target._settlePromiseLateCancellationObserver;
  3166.             value = new CancellationError("late cancellation observer");
  3167.             target._attachExtraTrace(value);
  3168.             handler = didReject;
  3169.         }
  3170.  
  3171.         async.invoke(settler, target, {
  3172.             handler: domain === null ? handler
  3173.                 : (typeof handler === "function" &&
  3174.                     util.domainBind(domain, handler)),
  3175.             promise: promise,
  3176.             receiver: receiver,
  3177.             value: value
  3178.         });
  3179.     } else {
  3180.         target._addCallbacks(didFulfill, didReject, promise, receiver, domain);
  3181.     }
  3182.  
  3183.     return promise;
  3184. };
  3185.  
  3186. Promise.prototype._length = function () {
  3187.     return this._bitField & 65535;
  3188. };
  3189.  
  3190. Promise.prototype._isFateSealed = function () {
  3191.     return (this._bitField & 117506048) !== 0;
  3192. };
  3193.  
  3194. Promise.prototype._isFollowing = function () {
  3195.     return (this._bitField & 67108864) === 67108864;
  3196. };
  3197.  
  3198. Promise.prototype._setLength = function (len) {
  3199.     this._bitField = (this._bitField & -65536) |
  3200.         (len & 65535);
  3201. };
  3202.  
  3203. Promise.prototype._setFulfilled = function () {
  3204.     this._bitField = this._bitField | 33554432;
  3205.     this._fireEvent("promiseFulfilled", this);
  3206. };
  3207.  
  3208. Promise.prototype._setRejected = function () {
  3209.     this._bitField = this._bitField | 16777216;
  3210.     this._fireEvent("promiseRejected", this);
  3211. };
  3212.  
  3213. Promise.prototype._setFollowing = function () {
  3214.     this._bitField = this._bitField | 67108864;
  3215.     this._fireEvent("promiseResolved", this);
  3216. };
  3217.  
  3218. Promise.prototype._setIsFinal = function () {
  3219.     this._bitField = this._bitField | 4194304;
  3220. };
  3221.  
  3222. Promise.prototype._isFinal = function () {
  3223.     return (this._bitField & 4194304) > 0;
  3224. };
  3225.  
  3226. Promise.prototype._unsetCancelled = function() {
  3227.     this._bitField = this._bitField & (~65536);
  3228. };
  3229.  
  3230. Promise.prototype._setCancelled = function() {
  3231.     this._bitField = this._bitField | 65536;
  3232.     this._fireEvent("promiseCancelled", this);
  3233. };
  3234.  
  3235. Promise.prototype._setWillBeCancelled = function() {
  3236.     this._bitField = this._bitField | 8388608;
  3237. };
  3238.  
  3239. Promise.prototype._setAsyncGuaranteed = function() {
  3240.     if (async.hasCustomScheduler()) return;
  3241.     this._bitField = this._bitField | 134217728;
  3242. };
  3243.  
  3244. Promise.prototype._receiverAt = function (index) {
  3245.     var ret = index === 0 ? this._receiver0 : this[
  3246.             index * 4 - 4 + 3];
  3247.     if (ret === UNDEFINED_BINDING) {
  3248.         return undefined;
  3249.     } else if (ret === undefined && this._isBound()) {
  3250.         return this._boundValue();
  3251.     }
  3252.     return ret;
  3253. };
  3254.  
  3255. Promise.prototype._promiseAt = function (index) {
  3256.     return this[
  3257.             index * 4 - 4 + 2];
  3258. };
  3259.  
  3260. Promise.prototype._fulfillmentHandlerAt = function (index) {
  3261.     return this[
  3262.             index * 4 - 4 + 0];
  3263. };
  3264.  
  3265. Promise.prototype._rejectionHandlerAt = function (index) {
  3266.     return this[
  3267.             index * 4 - 4 + 1];
  3268. };
  3269.  
  3270. Promise.prototype._boundValue = function() {};
  3271.  
  3272. Promise.prototype._migrateCallback0 = function (follower) {
  3273.     var bitField = follower._bitField;
  3274.     var fulfill = follower._fulfillmentHandler0;
  3275.     var reject = follower._rejectionHandler0;
  3276.     var promise = follower._promise0;
  3277.     var receiver = follower._receiverAt(0);
  3278.     if (receiver === undefined) receiver = UNDEFINED_BINDING;
  3279.     this._addCallbacks(fulfill, reject, promise, receiver, null);
  3280. };
  3281.  
  3282. Promise.prototype._migrateCallbackAt = function (follower, index) {
  3283.     var fulfill = follower._fulfillmentHandlerAt(index);
  3284.     var reject = follower._rejectionHandlerAt(index);
  3285.     var promise = follower._promiseAt(index);
  3286.     var receiver = follower._receiverAt(index);
  3287.     if (receiver === undefined) receiver = UNDEFINED_BINDING;
  3288.     this._addCallbacks(fulfill, reject, promise, receiver, null);
  3289. };
  3290.  
  3291. Promise.prototype._addCallbacks = function (
  3292.     fulfill,
  3293.     reject,
  3294.     promise,
  3295.     receiver,
  3296.     domain
  3297. ) {
  3298.     var index = this._length();
  3299.  
  3300.     if (index >= 65535 - 4) {
  3301.         index = 0;
  3302.         this._setLength(0);
  3303.     }
  3304.  
  3305.     if (index === 0) {
  3306.         this._promise0 = promise;
  3307.         this._receiver0 = receiver;
  3308.         if (typeof fulfill === "function") {
  3309.             this._fulfillmentHandler0 =
  3310.                 domain === null ? fulfill : util.domainBind(domain, fulfill);
  3311.         }
  3312.         if (typeof reject === "function") {
  3313.             this._rejectionHandler0 =
  3314.                 domain === null ? reject : util.domainBind(domain, reject);
  3315.         }
  3316.     } else {
  3317.         var base = index * 4 - 4;
  3318.         this[base + 2] = promise;
  3319.         this[base + 3] = receiver;
  3320.         if (typeof fulfill === "function") {
  3321.             this[base + 0] =
  3322.                 domain === null ? fulfill : util.domainBind(domain, fulfill);
  3323.         }
  3324.         if (typeof reject === "function") {
  3325.             this[base + 1] =
  3326.                 domain === null ? reject : util.domainBind(domain, reject);
  3327.         }
  3328.     }
  3329.     this._setLength(index + 1);
  3330.     return index;
  3331. };
  3332.  
  3333. Promise.prototype._proxy = function (proxyable, arg) {
  3334.     this._addCallbacks(undefined, undefined, arg, proxyable, null);
  3335. };
  3336.  
  3337. Promise.prototype._resolveCallback = function(value, shouldBind) {
  3338.     if (((this._bitField & 117506048) !== 0)) return;
  3339.     if (value === this)
  3340.         return this._rejectCallback(makeSelfResolutionError(), false);
  3341.     var maybePromise = tryConvertToPromise(value, this);
  3342.     if (!(maybePromise instanceof Promise)) return this._fulfill(value);
  3343.  
  3344.     if (shouldBind) this._propagateFrom(maybePromise, 2);
  3345.  
  3346.     var promise = maybePromise._target();
  3347.  
  3348.     if (promise === this) {
  3349.         this._reject(makeSelfResolutionError());
  3350.         return;
  3351.     }
  3352.  
  3353.     var bitField = promise._bitField;
  3354.     if (((bitField & 50397184) === 0)) {
  3355.         var len = this._length();
  3356.         if (len > 0) promise._migrateCallback0(this);
  3357.         for (var i = 1; i < len; ++i) {
  3358.             promise._migrateCallbackAt(this, i);
  3359.         }
  3360.         this._setFollowing();
  3361.         this._setLength(0);
  3362.         this._setFollowee(promise);
  3363.     } else if (((bitField & 33554432) !== 0)) {
  3364.         this._fulfill(promise._value());
  3365.     } else if (((bitField & 16777216) !== 0)) {
  3366.         this._reject(promise._reason());
  3367.     } else {
  3368.         var reason = new CancellationError("late cancellation observer");
  3369.         promise._attachExtraTrace(reason);
  3370.         this._reject(reason);
  3371.     }
  3372. };
  3373.  
  3374. Promise.prototype._rejectCallback =
  3375. function(reason, synchronous, ignoreNonErrorWarnings) {
  3376.     var trace = util.ensureErrorObject(reason);
  3377.     var hasStack = trace === reason;
  3378.     if (!hasStack && !ignoreNonErrorWarnings && debug.warnings()) {
  3379.         var message = "a promise was rejected with a non-error: " +
  3380.             util.classString(reason);
  3381.         this._warn(message, true);
  3382.     }
  3383.     this._attachExtraTrace(trace, synchronous ? hasStack : false);
  3384.     this._reject(reason);
  3385. };
  3386.  
  3387. Promise.prototype._resolveFromExecutor = function (executor) {
  3388.     if (executor === INTERNAL) return;
  3389.     var promise = this;
  3390.     this._captureStackTrace();
  3391.     this._pushContext();
  3392.     var synchronous = true;
  3393.     var r = this._execute(executor, function(value) {
  3394.         promise._resolveCallback(value);
  3395.     }, function (reason) {
  3396.         promise._rejectCallback(reason, synchronous);
  3397.     });
  3398.     synchronous = false;
  3399.     this._popContext();
  3400.  
  3401.     if (r !== undefined) {
  3402.         promise._rejectCallback(r, true);
  3403.     }
  3404. };
  3405.  
  3406. Promise.prototype._settlePromiseFromHandler = function (
  3407.     handler, receiver, value, promise
  3408. ) {
  3409.     var bitField = promise._bitField;
  3410.     if (((bitField & 65536) !== 0)) return;
  3411.     promise._pushContext();
  3412.     var x;
  3413.     if (receiver === APPLY) {
  3414.         if (!value || typeof value.length !== "number") {
  3415.             x = errorObj;
  3416.             x.e = new TypeError("cannot .spread() a non-array: " +
  3417.                                     util.classString(value));
  3418.         } else {
  3419.             x = tryCatch(handler).apply(this._boundValue(), value);
  3420.         }
  3421.     } else {
  3422.         x = tryCatch(handler).call(receiver, value);
  3423.     }
  3424.     var promiseCreated = promise._popContext();
  3425.     bitField = promise._bitField;
  3426.     if (((bitField & 65536) !== 0)) return;
  3427.  
  3428.     if (x === NEXT_FILTER) {
  3429.         promise._reject(value);
  3430.     } else if (x === errorObj) {
  3431.         promise._rejectCallback(x.e, false);
  3432.     } else {
  3433.         debug.checkForgottenReturns(x, promiseCreated, "",  promise, this);
  3434.         promise._resolveCallback(x);
  3435.     }
  3436. };
  3437.  
  3438. Promise.prototype._target = function() {
  3439.     var ret = this;
  3440.     while (ret._isFollowing()) ret = ret._followee();
  3441.     return ret;
  3442. };
  3443.  
  3444. Promise.prototype._followee = function() {
  3445.     return this._rejectionHandler0;
  3446. };
  3447.  
  3448. Promise.prototype._setFollowee = function(promise) {
  3449.     this._rejectionHandler0 = promise;
  3450. };
  3451.  
  3452. Promise.prototype._settlePromise = function(promise, handler, receiver, value) {
  3453.     var isPromise = promise instanceof Promise;
  3454.     var bitField = this._bitField;
  3455.     var asyncGuaranteed = ((bitField & 134217728) !== 0);
  3456.     if (((bitField & 65536) !== 0)) {
  3457.         if (isPromise) promise._invokeInternalOnCancel();
  3458.  
  3459.         if (receiver instanceof PassThroughHandlerContext &&
  3460.             receiver.isFinallyHandler()) {
  3461.             receiver.cancelPromise = promise;
  3462.             if (tryCatch(handler).call(receiver, value) === errorObj) {
  3463.                 promise._reject(errorObj.e);
  3464.             }
  3465.         } else if (handler === reflectHandler) {
  3466.             promise._fulfill(reflectHandler.call(receiver));
  3467.         } else if (receiver instanceof Proxyable) {
  3468.             receiver._promiseCancelled(promise);
  3469.         } else if (isPromise || promise instanceof PromiseArray) {
  3470.             promise._cancel();
  3471.         } else {
  3472.             receiver.cancel();
  3473.         }
  3474.     } else if (typeof handler === "function") {
  3475.         if (!isPromise) {
  3476.             handler.call(receiver, value, promise);
  3477.         } else {
  3478.             if (asyncGuaranteed) promise._setAsyncGuaranteed();
  3479.             this._settlePromiseFromHandler(handler, receiver, value, promise);
  3480.         }
  3481.     } else if (receiver instanceof Proxyable) {
  3482.         if (!receiver._isResolved()) {
  3483.             if (((bitField & 33554432) !== 0)) {
  3484.                 receiver._promiseFulfilled(value, promise);
  3485.             } else {
  3486.                 receiver._promiseRejected(value, promise);
  3487.             }
  3488.         }
  3489.     } else if (isPromise) {
  3490.         if (asyncGuaranteed) promise._setAsyncGuaranteed();
  3491.         if (((bitField & 33554432) !== 0)) {
  3492.             promise._fulfill(value);
  3493.         } else {
  3494.             promise._reject(value);
  3495.         }
  3496.     }
  3497. };
  3498.  
  3499. Promise.prototype._settlePromiseLateCancellationObserver = function(ctx) {
  3500.     var handler = ctx.handler;
  3501.     var promise = ctx.promise;
  3502.     var receiver = ctx.receiver;
  3503.     var value = ctx.value;
  3504.     if (typeof handler === "function") {
  3505.         if (!(promise instanceof Promise)) {
  3506.             handler.call(receiver, value, promise);
  3507.         } else {
  3508.             this._settlePromiseFromHandler(handler, receiver, value, promise);
  3509.         }
  3510.     } else if (promise instanceof Promise) {
  3511.         promise._reject(value);
  3512.     }
  3513. };
  3514.  
  3515. Promise.prototype._settlePromiseCtx = function(ctx) {
  3516.     this._settlePromise(ctx.promise, ctx.handler, ctx.receiver, ctx.value);
  3517. };
  3518.  
  3519. Promise.prototype._settlePromise0 = function(handler, value, bitField) {
  3520.     var promise = this._promise0;
  3521.     var receiver = this._receiverAt(0);
  3522.     this._promise0 = undefined;
  3523.     this._receiver0 = undefined;
  3524.     this._settlePromise(promise, handler, receiver, value);
  3525. };
  3526.  
  3527. Promise.prototype._clearCallbackDataAtIndex = function(index) {
  3528.     var base = index * 4 - 4;
  3529.     this[base + 2] =
  3530.     this[base + 3] =
  3531.     this[base + 0] =
  3532.     this[base + 1] = undefined;
  3533. };
  3534.  
  3535. Promise.prototype._fulfill = function (value) {
  3536.     var bitField = this._bitField;
  3537.     if (((bitField & 117506048) >>> 16)) return;
  3538.     if (value === this) {
  3539.         var err = makeSelfResolutionError();
  3540.         this._attachExtraTrace(err);
  3541.         return this._reject(err);
  3542.     }
  3543.     this._setFulfilled();
  3544.     this._rejectionHandler0 = value;
  3545.  
  3546.     if ((bitField & 65535) > 0) {
  3547.         if (((bitField & 134217728) !== 0)) {
  3548.             this._settlePromises();
  3549.         } else {
  3550.             async.settlePromises(this);
  3551.         }
  3552.     }
  3553. };
  3554.  
  3555. Promise.prototype._reject = function (reason) {
  3556.     var bitField = this._bitField;
  3557.     if (((bitField & 117506048) >>> 16)) return;
  3558.     this._setRejected();
  3559.     this._fulfillmentHandler0 = reason;
  3560.  
  3561.     if (this._isFinal()) {
  3562.         return async.fatalError(reason, util.isNode);
  3563.     }
  3564.  
  3565.     if ((bitField & 65535) > 0) {
  3566.         async.settlePromises(this);
  3567.     } else {
  3568.         this._ensurePossibleRejectionHandled();
  3569.     }
  3570. };
  3571.  
  3572. Promise.prototype._fulfillPromises = function (len, value) {
  3573.     for (var i = 1; i < len; i++) {
  3574.         var handler = this._fulfillmentHandlerAt(i);
  3575.         var promise = this._promiseAt(i);
  3576.         var receiver = this._receiverAt(i);
  3577.         this._clearCallbackDataAtIndex(i);
  3578.         this._settlePromise(promise, handler, receiver, value);
  3579.     }
  3580. };
  3581.  
  3582. Promise.prototype._rejectPromises = function (len, reason) {
  3583.     for (var i = 1; i < len; i++) {
  3584.         var handler = this._rejectionHandlerAt(i);
  3585.         var promise = this._promiseAt(i);
  3586.         var receiver = this._receiverAt(i);
  3587.         this._clearCallbackDataAtIndex(i);
  3588.         this._settlePromise(promise, handler, receiver, reason);
  3589.     }
  3590. };
  3591.  
  3592. Promise.prototype._settlePromises = function () {
  3593.     var bitField = this._bitField;
  3594.     var len = (bitField & 65535);
  3595.  
  3596.     if (len > 0) {
  3597.         if (((bitField & 16842752) !== 0)) {
  3598.             var reason = this._fulfillmentHandler0;
  3599.             this._settlePromise0(this._rejectionHandler0, reason, bitField);
  3600.             this._rejectPromises(len, reason);
  3601.         } else {
  3602.             var value = this._rejectionHandler0;
  3603.             this._settlePromise0(this._fulfillmentHandler0, value, bitField);
  3604.             this._fulfillPromises(len, value);
  3605.         }
  3606.         this._setLength(0);
  3607.     }
  3608.     this._clearCancellationData();
  3609. };
  3610.  
  3611. Promise.prototype._settledValue = function() {
  3612.     var bitField = this._bitField;
  3613.     if (((bitField & 33554432) !== 0)) {
  3614.         return this._rejectionHandler0;
  3615.     } else if (((bitField & 16777216) !== 0)) {
  3616.         return this._fulfillmentHandler0;
  3617.     }
  3618. };
  3619.  
  3620. function deferResolve(v) {this.promise._resolveCallback(v);}
  3621. function deferReject(v) {this.promise._rejectCallback(v, false);}
  3622.  
  3623. Promise.defer = Promise.pending = function() {
  3624.     debug.deprecated("Promise.defer", "new Promise");
  3625.     var promise = new Promise(INTERNAL);
  3626.     return {
  3627.         promise: promise,
  3628.         resolve: deferResolve,
  3629.         reject: deferReject
  3630.     };
  3631. };
  3632.  
  3633. util.notEnumerableProp(Promise,
  3634.                        "_makeSelfResolutionError",
  3635.                        makeSelfResolutionError);
  3636.  
  3637. _dereq_("./method")(Promise, INTERNAL, tryConvertToPromise, apiRejection,
  3638.     debug);
  3639. _dereq_("./bind")(Promise, INTERNAL, tryConvertToPromise, debug);
  3640. _dereq_("./cancel")(Promise, PromiseArray, apiRejection, debug);
  3641. _dereq_("./direct_resolve")(Promise);
  3642. _dereq_("./synchronous_inspection")(Promise);
  3643. _dereq_("./join")(
  3644.     Promise, PromiseArray, tryConvertToPromise, INTERNAL, async, getDomain);
  3645. Promise.Promise = Promise;
  3646. Promise.version = "3.5.0";
  3647. _dereq_('./map.js')(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL, debug);
  3648. _dereq_('./call_get.js')(Promise);
  3649. _dereq_('./using.js')(Promise, apiRejection, tryConvertToPromise, createContext, INTERNAL, debug);
  3650. _dereq_('./timers.js')(Promise, INTERNAL, debug);
  3651. _dereq_('./generators.js')(Promise, apiRejection, INTERNAL, tryConvertToPromise, Proxyable, debug);
  3652. _dereq_('./nodeify.js')(Promise);
  3653. _dereq_('./promisify.js')(Promise, INTERNAL);
  3654. _dereq_('./props.js')(Promise, PromiseArray, tryConvertToPromise, apiRejection);
  3655. _dereq_('./race.js')(Promise, INTERNAL, tryConvertToPromise, apiRejection);
  3656. _dereq_('./reduce.js')(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL, debug);
  3657. _dereq_('./settle.js')(Promise, PromiseArray, debug);
  3658. _dereq_('./some.js')(Promise, PromiseArray, apiRejection);
  3659. _dereq_('./filter.js')(Promise, INTERNAL);
  3660. _dereq_('./each.js')(Promise, INTERNAL);
  3661. _dereq_('./any.js')(Promise);
  3662.                                                          
  3663.     util.toFastProperties(Promise);                                          
  3664.     util.toFastProperties(Promise.prototype);                                
  3665.     function fillTypes(value) {                                              
  3666.         var p = new Promise(INTERNAL);                                       
  3667.         p._fulfillmentHandler0 = value;                                      
  3668.         p._rejectionHandler0 = value;                                        
  3669.         p._promise0 = value;                                                 
  3670.         p._receiver0 = value;                                                
  3671.     }                                                                        
  3672.     // Complete slack tracking, opt out of field-type tracking and           
  3673.     // stabilize map                                                         
  3674.     fillTypes({a: 1});                                                       
  3675.     fillTypes({b: 2});                                                       
  3676.     fillTypes({c: 3});                                                       
  3677.     fillTypes(1);                                                            
  3678.     fillTypes(function(){});                                                 
  3679.     fillTypes(undefined);                                                    
  3680.     fillTypes(false);                                                        
  3681.     fillTypes(new Promise(INTERNAL));                                        
  3682.     debug.setBounds(Async.firstLineError, util.lastLineError);               
  3683.     return Promise;                                                          
  3684.  
  3685. };
  3686.  
  3687. },{"./any.js":1,"./async":2,"./bind":3,"./call_get.js":5,"./cancel":6,"./catch_filter":7,"./context":8,"./debuggability":9,"./direct_resolve":10,"./each.js":11,"./errors":12,"./es5":13,"./filter.js":14,"./finally":15,"./generators.js":16,"./join":17,"./map.js":18,"./method":19,"./nodeback":20,"./nodeify.js":21,"./promise_array":23,"./promisify.js":24,"./props.js":25,"./race.js":27,"./reduce.js":28,"./settle.js":30,"./some.js":31,"./synchronous_inspection":32,"./thenables":33,"./timers.js":34,"./using.js":35,"./util":36}],23:[function(_dereq_,module,exports){
  3688. "use strict";
  3689. module.exports = function(Promise, INTERNAL, tryConvertToPromise,
  3690.     apiRejection, Proxyable) {
  3691. var util = _dereq_("./util");
  3692. var isArray = util.isArray;
  3693.  
  3694. function toResolutionValue(val) {
  3695.     switch(val) {
  3696.     case -2: return [];
  3697.     case -3: return {};
  3698.     case -6: return new Map();
  3699.     }
  3700. }
  3701.  
  3702. function PromiseArray(values) {
  3703.     var promise = this._promise = new Promise(INTERNAL);
  3704.     if (values instanceof Promise) {
  3705.         promise._propagateFrom(values, 3);
  3706.     }
  3707.     promise._setOnCancel(this);
  3708.     this._values = values;
  3709.     this._length = 0;
  3710.     this._totalResolved = 0;
  3711.     this._init(undefined, -2);
  3712. }
  3713. util.inherits(PromiseArray, Proxyable);
  3714.  
  3715. PromiseArray.prototype.length = function () {
  3716.     return this._length;
  3717. };
  3718.  
  3719. PromiseArray.prototype.promise = function () {
  3720.     return this._promise;
  3721. };
  3722.  
  3723. PromiseArray.prototype._init = function init(_, resolveValueIfEmpty) {
  3724.     var values = tryConvertToPromise(this._values, this._promise);
  3725.     if (values instanceof Promise) {
  3726.         values = values._target();
  3727.         var bitField = values._bitField;
  3728.         ;
  3729.         this._values = values;
  3730.  
  3731.         if (((bitField & 50397184) === 0)) {
  3732.             this._promise._setAsyncGuaranteed();
  3733.             return values._then(
  3734.                 init,
  3735.                 this._reject,
  3736.                 undefined,
  3737.                 this,
  3738.                 resolveValueIfEmpty
  3739.            );
  3740.         } else if (((bitField & 33554432) !== 0)) {
  3741.             values = values._value();
  3742.         } else if (((bitField & 16777216) !== 0)) {
  3743.             return this._reject(values._reason());
  3744.         } else {
  3745.             return this._cancel();
  3746.         }
  3747.     }
  3748.     values = util.asArray(values);
  3749.     if (values === null) {
  3750.         var err = apiRejection(
  3751.             "expecting an array or an iterable object but got " + util.classString(values)).reason();
  3752.         this._promise._rejectCallback(err, false);
  3753.         return;
  3754.     }
  3755.  
  3756.     if (values.length === 0) {
  3757.         if (resolveValueIfEmpty === -5) {
  3758.             this._resolveEmptyArray();
  3759.         }
  3760.         else {
  3761.             this._resolve(toResolutionValue(resolveValueIfEmpty));
  3762.         }
  3763.         return;
  3764.     }
  3765.     this._iterate(values);
  3766. };
  3767.  
  3768. PromiseArray.prototype._iterate = function(values) {
  3769.     var len = this.getActualLength(values.length);
  3770.     this._length = len;
  3771.     this._values = this.shouldCopyValues() ? new Array(len) : this._values;
  3772.     var result = this._promise;
  3773.     var isResolved = false;
  3774.     var bitField = null;
  3775.     for (var i = 0; i < len; ++i) {
  3776.         var maybePromise = tryConvertToPromise(values[i], result);
  3777.  
  3778.         if (maybePromise instanceof Promise) {
  3779.             maybePromise = maybePromise._target();
  3780.             bitField = maybePromise._bitField;
  3781.         } else {
  3782.             bitField = null;
  3783.         }
  3784.  
  3785.         if (isResolved) {
  3786.             if (bitField !== null) {
  3787.                 maybePromise.suppressUnhandledRejections();
  3788.             }
  3789.         } else if (bitField !== null) {
  3790.             if (((bitField & 50397184) === 0)) {
  3791.                 maybePromise._proxy(this, i);
  3792.                 this._values[i] = maybePromise;
  3793.             } else if (((bitField & 33554432) !== 0)) {
  3794.                 isResolved = this._promiseFulfilled(maybePromise._value(), i);
  3795.             } else if (((bitField & 16777216) !== 0)) {
  3796.                 isResolved = this._promiseRejected(maybePromise._reason(), i);
  3797.             } else {
  3798.                 isResolved = this._promiseCancelled(i);
  3799.             }
  3800.         } else {
  3801.             isResolved = this._promiseFulfilled(maybePromise, i);
  3802.         }
  3803.     }
  3804.     if (!isResolved) result._setAsyncGuaranteed();
  3805. };
  3806.  
  3807. PromiseArray.prototype._isResolved = function () {
  3808.     return this._values === null;
  3809. };
  3810.  
  3811. PromiseArray.prototype._resolve = function (value) {
  3812.     this._values = null;
  3813.     this._promise._fulfill(value);
  3814. };
  3815.  
  3816. PromiseArray.prototype._cancel = function() {
  3817.     if (this._isResolved() || !this._promise._isCancellable()) return;
  3818.     this._values = null;
  3819.     this._promise._cancel();
  3820. };
  3821.  
  3822. PromiseArray.prototype._reject = function (reason) {
  3823.     this._values = null;
  3824.     this._promise._rejectCallback(reason, false);
  3825. };
  3826.  
  3827. PromiseArray.prototype._promiseFulfilled = function (value, index) {
  3828.     this._values[index] = value;
  3829.     var totalResolved = ++this._totalResolved;
  3830.     if (totalResolved >= this._length) {
  3831.         this._resolve(this._values);
  3832.         return true;
  3833.     }
  3834.     return false;
  3835. };
  3836.  
  3837. PromiseArray.prototype._promiseCancelled = function() {
  3838.     this._cancel();
  3839.     return true;
  3840. };
  3841.  
  3842. PromiseArray.prototype._promiseRejected = function (reason) {
  3843.     this._totalResolved++;
  3844.     this._reject(reason);
  3845.     return true;
  3846. };
  3847.  
  3848. PromiseArray.prototype._resultCancelled = function() {
  3849.     if (this._isResolved()) return;
  3850.     var values = this._values;
  3851.     this._cancel();
  3852.     if (values instanceof Promise) {
  3853.         values.cancel();
  3854.     } else {
  3855.         for (var i = 0; i < values.length; ++i) {
  3856.             if (values[i] instanceof Promise) {
  3857.                 values[i].cancel();
  3858.             }
  3859.         }
  3860.     }
  3861. };
  3862.  
  3863. PromiseArray.prototype.shouldCopyValues = function () {
  3864.     return true;
  3865. };
  3866.  
  3867. PromiseArray.prototype.getActualLength = function (len) {
  3868.     return len;
  3869. };
  3870.  
  3871. return PromiseArray;
  3872. };
  3873.  
  3874. },{"./util":36}],24:[function(_dereq_,module,exports){
  3875. "use strict";
  3876. module.exports = function(Promise, INTERNAL) {
  3877. var THIS = {};
  3878. var util = _dereq_("./util");
  3879. var nodebackForPromise = _dereq_("./nodeback");
  3880. var withAppended = util.withAppended;
  3881. var maybeWrapAsError = util.maybeWrapAsError;
  3882. var canEvaluate = util.canEvaluate;
  3883. var TypeError = _dereq_("./errors").TypeError;
  3884. var defaultSuffix = "Async";
  3885. var defaultPromisified = {__isPromisified__: true};
  3886. var noCopyProps = [
  3887.     "arity",    "length",
  3888.     "name",
  3889.     "arguments",
  3890.     "caller",
  3891.     "callee",
  3892.     "prototype",
  3893.     "__isPromisified__"
  3894. ];
  3895. var noCopyPropsPattern = new RegExp("^(?:" + noCopyProps.join("|") + ")$");
  3896.  
  3897. var defaultFilter = function(name) {
  3898.     return util.isIdentifier(name) &&
  3899.         name.charAt(0) !== "_" &&
  3900.         name !== "constructor";
  3901. };
  3902.  
  3903. function propsFilter(key) {
  3904.     return !noCopyPropsPattern.test(key);
  3905. }
  3906.  
  3907. function isPromisified(fn) {
  3908.     try {
  3909.         return fn.__isPromisified__ === true;
  3910.     }
  3911.     catch (e) {
  3912.         return false;
  3913.     }
  3914. }
  3915.  
  3916. function hasPromisified(obj, key, suffix) {
  3917.     var val = util.getDataPropertyOrDefault(obj, key + suffix,
  3918.                                             defaultPromisified);
  3919.     return val ? isPromisified(val) : false;
  3920. }
  3921. function checkValid(ret, suffix, suffixRegexp) {
  3922.     for (var i = 0; i < ret.length; i += 2) {
  3923.         var key = ret[i];
  3924.         if (suffixRegexp.test(key)) {
  3925.             var keyWithoutAsyncSuffix = key.replace(suffixRegexp, "");
  3926.             for (var j = 0; j < ret.length; j += 2) {
  3927.                 if (ret[j] === keyWithoutAsyncSuffix) {
  3928.                     throw new TypeError("Cannot promisify an API that has normal methods with '%s'-suffix\u000a\u000a    See http://goo.gl/MqrFmX\u000a"
  3929.                         .replace("%s", suffix));
  3930.                 }
  3931.             }
  3932.         }
  3933.     }
  3934. }
  3935.  
  3936. function promisifiableMethods(obj, suffix, suffixRegexp, filter) {
  3937.     var keys = util.inheritedDataKeys(obj);
  3938.     var ret = [];
  3939.     for (var i = 0; i < keys.length; ++i) {
  3940.         var key = keys[i];
  3941.         var value = obj[key];
  3942.         var passesDefaultFilter = filter === defaultFilter
  3943.             ? true : defaultFilter(key, value, obj);
  3944.         if (typeof value === "function" &&
  3945.             !isPromisified(value) &&
  3946.             !hasPromisified(obj, key, suffix) &&
  3947.             filter(key, value, obj, passesDefaultFilter)) {
  3948.             ret.push(key, value);
  3949.         }
  3950.     }
  3951.     checkValid(ret, suffix, suffixRegexp);
  3952.     return ret;
  3953. }
  3954.  
  3955. var escapeIdentRegex = function(str) {
  3956.     return str.replace(/([$])/, "\\$");
  3957. };
  3958.  
  3959. var makeNodePromisifiedEval;
  3960. if (false) {
  3961. var switchCaseArgumentOrder = function(likelyArgumentCount) {
  3962.     var ret = [likelyArgumentCount];
  3963.     var min = Math.max(0, likelyArgumentCount - 1 - 3);
  3964.     for(var i = likelyArgumentCount - 1; i >= min; --i) {
  3965.         ret.push(i);
  3966.     }
  3967.     for(var i = likelyArgumentCount + 1; i <= 3; ++i) {
  3968.         ret.push(i);
  3969.     }
  3970.     return ret;
  3971. };
  3972.  
  3973. var argumentSequence = function(argumentCount) {
  3974.     return util.filledRange(argumentCount, "_arg", "");
  3975. };
  3976.  
  3977. var parameterDeclaration = function(parameterCount) {
  3978.     return util.filledRange(
  3979.         Math.max(parameterCount, 3), "_arg", "");
  3980. };
  3981.  
  3982. var parameterCount = function(fn) {
  3983.     if (typeof fn.length === "number") {
  3984.         return Math.max(Math.min(fn.length, 1023 + 1), 0);
  3985.     }
  3986.     return 0;
  3987. };
  3988.  
  3989. makeNodePromisifiedEval =
  3990. function(callback, receiver, originalName, fn, _, multiArgs) {
  3991.     var newParameterCount = Math.max(0, parameterCount(fn) - 1);
  3992.     var argumentOrder = switchCaseArgumentOrder(newParameterCount);
  3993.     var shouldProxyThis = typeof callback === "string" || receiver === THIS;
  3994.  
  3995.     function generateCallForArgumentCount(count) {
  3996.         var args = argumentSequence(count).join(", ");
  3997.         var comma = count > 0 ? ", " : "";
  3998.         var ret;
  3999.         if (shouldProxyThis) {
  4000.             ret = "ret = callback.call(this, {{args}}, nodeback); break;\n";
  4001.         } else {
  4002.             ret = receiver === undefined
  4003.                 ? "ret = callback({{args}}, nodeback); break;\n"
  4004.                 : "ret = callback.call(receiver, {{args}}, nodeback); break;\n";
  4005.         }
  4006.         return ret.replace("{{args}}", args).replace(", ", comma);
  4007.     }
  4008.  
  4009.     function generateArgumentSwitchCase() {
  4010.         var ret = "";
  4011.         for (var i = 0; i < argumentOrder.length; ++i) {
  4012.             ret += "case " + argumentOrder[i] +":" +
  4013.                 generateCallForArgumentCount(argumentOrder[i]);
  4014.         }
  4015.  
  4016.         ret += "                                                             \n\
  4017.         default:                                                             \n\
  4018.             var args = new Array(len + 1);                                   \n\
  4019.             var i = 0;                                                       \n\
  4020.             for (var i = 0; i < len; ++i) {                                  \n\
  4021.                args[i] = arguments[i];                                       \n\
  4022.             }                                                                \n\
  4023.             args[i] = nodeback;                                              \n\
  4024.             [CodeForCall]                                                    \n\
  4025.             break;                                                           \n\
  4026.         ".replace("[CodeForCall]", (shouldProxyThis
  4027.                                 ? "ret = callback.apply(this, args);\n"
  4028.                                 : "ret = callback.apply(receiver, args);\n"));
  4029.         return ret;
  4030.     }
  4031.  
  4032.     var getFunctionCode = typeof callback === "string"
  4033.                                 ? ("this != null ? this['"+callback+"'] : fn")
  4034.                                 : "fn";
  4035.     var body = "'use strict';                                                \n\
  4036.         var ret = function (Parameters) {                                    \n\
  4037.             'use strict';                                                    \n\
  4038.             var len = arguments.length;                                      \n\
  4039.             var promise = new Promise(INTERNAL);                             \n\
  4040.             promise._captureStackTrace();                                    \n\
  4041.             var nodeback = nodebackForPromise(promise, " + multiArgs + ");   \n\
  4042.             var ret;                                                         \n\
  4043.             var callback = tryCatch([GetFunctionCode]);                      \n\
  4044.             switch(len) {                                                    \n\
  4045.                 [CodeForSwitchCase]                                          \n\
  4046.             }                                                                \n\
  4047.             if (ret === errorObj) {                                          \n\
  4048.                 promise._rejectCallback(maybeWrapAsError(ret.e), true, true);\n\
  4049.             }                                                                \n\
  4050.             if (!promise._isFateSealed()) promise._setAsyncGuaranteed();     \n\
  4051.             return promise;                                                  \n\
  4052.         };                                                                   \n\
  4053.         notEnumerableProp(ret, '__isPromisified__', true);                   \n\
  4054.         return ret;                                                          \n\
  4055.     ".replace("[CodeForSwitchCase]", generateArgumentSwitchCase())
  4056.         .replace("[GetFunctionCode]", getFunctionCode);
  4057.     body = body.replace("Parameters", parameterDeclaration(newParameterCount));
  4058.     return new Function("Promise",
  4059.                         "fn",
  4060.                         "receiver",
  4061.                         "withAppended",
  4062.                         "maybeWrapAsError",
  4063.                         "nodebackForPromise",
  4064.                         "tryCatch",
  4065.                         "errorObj",
  4066.                         "notEnumerableProp",
  4067.                         "INTERNAL",
  4068.                         body)(
  4069.                     Promise,
  4070.                     fn,
  4071.                     receiver,
  4072.                     withAppended,
  4073.                     maybeWrapAsError,
  4074.                     nodebackForPromise,
  4075.                     util.tryCatch,
  4076.                     util.errorObj,
  4077.                     util.notEnumerableProp,
  4078.                     INTERNAL);
  4079. };
  4080. }
  4081.  
  4082. function makeNodePromisifiedClosure(callback, receiver, _, fn, __, multiArgs) {
  4083.     var defaultThis = (function() {return this;})();
  4084.     var method = callback;
  4085.     if (typeof method === "string") {
  4086.         callback = fn;
  4087.     }
  4088.     function promisified() {
  4089.         var _receiver = receiver;
  4090.         if (receiver === THIS) _receiver = this;
  4091.         var promise = new Promise(INTERNAL);
  4092.         promise._captureStackTrace();
  4093.         var cb = typeof method === "string" && this !== defaultThis
  4094.             ? this[method] : callback;
  4095.         var fn = nodebackForPromise(promise, multiArgs);
  4096.         try {
  4097.             cb.apply(_receiver, withAppended(arguments, fn));
  4098.         } catch(e) {
  4099.             promise._rejectCallback(maybeWrapAsError(e), true, true);
  4100.         }
  4101.         if (!promise._isFateSealed()) promise._setAsyncGuaranteed();
  4102.         return promise;
  4103.     }
  4104.     util.notEnumerableProp(promisified, "__isPromisified__", true);
  4105.     return promisified;
  4106. }
  4107.  
  4108. var makeNodePromisified = canEvaluate
  4109.     ? makeNodePromisifiedEval
  4110.     : makeNodePromisifiedClosure;
  4111.  
  4112. function promisifyAll(obj, suffix, filter, promisifier, multiArgs) {
  4113.     var suffixRegexp = new RegExp(escapeIdentRegex(suffix) + "$");
  4114.     var methods =
  4115.         promisifiableMethods(obj, suffix, suffixRegexp, filter);
  4116.  
  4117.     for (var i = 0, len = methods.length; i < len; i+= 2) {
  4118.         var key = methods[i];
  4119.         var fn = methods[i+1];
  4120.         var promisifiedKey = key + suffix;
  4121.         if (promisifier === makeNodePromisified) {
  4122.             obj[promisifiedKey] =
  4123.                 makeNodePromisified(key, THIS, key, fn, suffix, multiArgs);
  4124.         } else {
  4125.             var promisified = promisifier(fn, function() {
  4126.                 return makeNodePromisified(key, THIS, key,
  4127.                                            fn, suffix, multiArgs);
  4128.             });
  4129.             util.notEnumerableProp(promisified, "__isPromisified__", true);
  4130.             obj[promisifiedKey] = promisified;
  4131.         }
  4132.     }
  4133.     util.toFastProperties(obj);
  4134.     return obj;
  4135. }
  4136.  
  4137. function promisify(callback, receiver, multiArgs) {
  4138.     return makeNodePromisified(callback, receiver, undefined,
  4139.                                 callback, null, multiArgs);
  4140. }
  4141.  
  4142. Promise.promisify = function (fn, options) {
  4143.     if (typeof fn !== "function") {
  4144.         throw new TypeError("expecting a function but got " + util.classString(fn));
  4145.     }
  4146.     if (isPromisified(fn)) {
  4147.         return fn;
  4148.     }
  4149.     options = Object(options);
  4150.     var receiver = options.context === undefined ? THIS : options.context;
  4151.     var multiArgs = !!options.multiArgs;
  4152.     var ret = promisify(fn, receiver, multiArgs);
  4153.     util.copyDescriptors(fn, ret, propsFilter);
  4154.     return ret;
  4155. };
  4156.  
  4157. Promise.promisifyAll = function (target, options) {
  4158.     if (typeof target !== "function" && typeof target !== "object") {
  4159.         throw new TypeError("the target of promisifyAll must be an object or a function\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
  4160.     }
  4161.     options = Object(options);
  4162.     var multiArgs = !!options.multiArgs;
  4163.     var suffix = options.suffix;
  4164.     if (typeof suffix !== "string") suffix = defaultSuffix;
  4165.     var filter = options.filter;
  4166.     if (typeof filter !== "function") filter = defaultFilter;
  4167.     var promisifier = options.promisifier;
  4168.     if (typeof promisifier !== "function") promisifier = makeNodePromisified;
  4169.  
  4170.     if (!util.isIdentifier(suffix)) {
  4171.         throw new RangeError("suffix must be a valid identifier\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
  4172.     }
  4173.  
  4174.     var keys = util.inheritedDataKeys(target);
  4175.     for (var i = 0; i < keys.length; ++i) {
  4176.         var value = target[keys[i]];
  4177.         if (keys[i] !== "constructor" &&
  4178.             util.isClass(value)) {
  4179.             promisifyAll(value.prototype, suffix, filter, promisifier,
  4180.                 multiArgs);
  4181.             promisifyAll(value, suffix, filter, promisifier, multiArgs);
  4182.         }
  4183.     }
  4184.  
  4185.     return promisifyAll(target, suffix, filter, promisifier, multiArgs);
  4186. };
  4187. };
  4188.  
  4189.  
  4190. },{"./errors":12,"./nodeback":20,"./util":36}],25:[function(_dereq_,module,exports){
  4191. "use strict";
  4192. module.exports = function(
  4193.     Promise, PromiseArray, tryConvertToPromise, apiRejection) {
  4194. var util = _dereq_("./util");
  4195. var isObject = util.isObject;
  4196. var es5 = _dereq_("./es5");
  4197. var Es6Map;
  4198. if (typeof Map === "function") Es6Map = Map;
  4199.  
  4200. var mapToEntries = (function() {
  4201.     var index = 0;
  4202.     var size = 0;
  4203.  
  4204.     function extractEntry(value, key) {
  4205.         this[index] = value;
  4206.         this[index + size] = key;
  4207.         index++;
  4208.     }
  4209.  
  4210.     return function mapToEntries(map) {
  4211.         size = map.size;
  4212.         index = 0;
  4213.         var ret = new Array(map.size * 2);
  4214.         map.forEach(extractEntry, ret);
  4215.         return ret;
  4216.     };
  4217. })();
  4218.  
  4219. var entriesToMap = function(entries) {
  4220.     var ret = new Es6Map();
  4221.     var length = entries.length / 2 | 0;
  4222.     for (var i = 0; i < length; ++i) {
  4223.         var key = entries[length + i];
  4224.         var value = entries[i];
  4225.         ret.set(key, value);
  4226.     }
  4227.     return ret;
  4228. };
  4229.  
  4230. function PropertiesPromiseArray(obj) {
  4231.     var isMap = false;
  4232.     var entries;
  4233.     if (Es6Map !== undefined && obj instanceof Es6Map) {
  4234.         entries = mapToEntries(obj);
  4235.         isMap = true;
  4236.     } else {
  4237.         var keys = es5.keys(obj);
  4238.         var len = keys.length;
  4239.         entries = new Array(len * 2);
  4240.         for (var i = 0; i < len; ++i) {
  4241.             var key = keys[i];
  4242.             entries[i] = obj[key];
  4243.             entries[i + len] = key;
  4244.         }
  4245.     }
  4246.     this.constructor$(entries);
  4247.     this._isMap = isMap;
  4248.     this._init$(undefined, isMap ? -6 : -3);
  4249. }
  4250. util.inherits(PropertiesPromiseArray, PromiseArray);
  4251.  
  4252. PropertiesPromiseArray.prototype._init = function () {};
  4253.  
  4254. PropertiesPromiseArray.prototype._promiseFulfilled = function (value, index) {
  4255.     this._values[index] = value;
  4256.     var totalResolved = ++this._totalResolved;
  4257.     if (totalResolved >= this._length) {
  4258.         var val;
  4259.         if (this._isMap) {
  4260.             val = entriesToMap(this._values);
  4261.         } else {
  4262.             val = {};
  4263.             var keyOffset = this.length();
  4264.             for (var i = 0, len = this.length(); i < len; ++i) {
  4265.                 val[this._values[i + keyOffset]] = this._values[i];
  4266.             }
  4267.         }
  4268.         this._resolve(val);
  4269.         return true;
  4270.     }
  4271.     return false;
  4272. };
  4273.  
  4274. PropertiesPromiseArray.prototype.shouldCopyValues = function () {
  4275.     return false;
  4276. };
  4277.  
  4278. PropertiesPromiseArray.prototype.getActualLength = function (len) {
  4279.     return len >> 1;
  4280. };
  4281.  
  4282. function props(promises) {
  4283.     var ret;
  4284.     var castValue = tryConvertToPromise(promises);
  4285.  
  4286.     if (!isObject(castValue)) {
  4287.         return apiRejection("cannot await properties of a non-object\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
  4288.     } else if (castValue instanceof Promise) {
  4289.         ret = castValue._then(
  4290.             Promise.props, undefined, undefined, undefined, undefined);
  4291.     } else {
  4292.         ret = new PropertiesPromiseArray(castValue).promise();
  4293.     }
  4294.  
  4295.     if (castValue instanceof Promise) {
  4296.         ret._propagateFrom(castValue, 2);
  4297.     }
  4298.     return ret;
  4299. }
  4300.  
  4301. Promise.prototype.props = function () {
  4302.     return props(this);
  4303. };
  4304.  
  4305. Promise.props = function (promises) {
  4306.     return props(promises);
  4307. };
  4308. };
  4309.  
  4310. },{"./es5":13,"./util":36}],26:[function(_dereq_,module,exports){
  4311. "use strict";
  4312. function arrayMove(src, srcIndex, dst, dstIndex, len) {
  4313.     for (var j = 0; j < len; ++j) {
  4314.         dst[j + dstIndex] = src[j + srcIndex];
  4315.         src[j + srcIndex] = void 0;
  4316.     }
  4317. }
  4318.  
  4319. function Queue(capacity) {
  4320.     this._capacity = capacity;
  4321.     this._length = 0;
  4322.     this._front = 0;
  4323. }
  4324.  
  4325. Queue.prototype._willBeOverCapacity = function (size) {
  4326.     return this._capacity < size;
  4327. };
  4328.  
  4329. Queue.prototype._pushOne = function (arg) {
  4330.     var length = this.length();
  4331.     this._checkCapacity(length + 1);
  4332.     var i = (this._front + length) & (this._capacity - 1);
  4333.     this[i] = arg;
  4334.     this._length = length + 1;
  4335. };
  4336.  
  4337. Queue.prototype.push = function (fn, receiver, arg) {
  4338.     var length = this.length() + 3;
  4339.     if (this._willBeOverCapacity(length)) {
  4340.         this._pushOne(fn);
  4341.         this._pushOne(receiver);
  4342.         this._pushOne(arg);
  4343.         return;
  4344.     }
  4345.     var j = this._front + length - 3;
  4346.     this._checkCapacity(length);
  4347.     var wrapMask = this._capacity - 1;
  4348.     this[(j + 0) & wrapMask] = fn;
  4349.     this[(j + 1) & wrapMask] = receiver;
  4350.     this[(j + 2) & wrapMask] = arg;
  4351.     this._length = length;
  4352. };
  4353.  
  4354. Queue.prototype.shift = function () {
  4355.     var front = this._front,
  4356.         ret = this[front];
  4357.  
  4358.     this[front] = undefined;
  4359.     this._front = (front + 1) & (this._capacity - 1);
  4360.     this._length--;
  4361.     return ret;
  4362. };
  4363.  
  4364. Queue.prototype.length = function () {
  4365.     return this._length;
  4366. };
  4367.  
  4368. Queue.prototype._checkCapacity = function (size) {
  4369.     if (this._capacity < size) {
  4370.         this._resizeTo(this._capacity << 1);
  4371.     }
  4372. };
  4373.  
  4374. Queue.prototype._resizeTo = function (capacity) {
  4375.     var oldCapacity = this._capacity;
  4376.     this._capacity = capacity;
  4377.     var front = this._front;
  4378.     var length = this._length;
  4379.     var moveItemsCount = (front + length) & (oldCapacity - 1);
  4380.     arrayMove(this, 0, this, oldCapacity, moveItemsCount);
  4381. };
  4382.  
  4383. module.exports = Queue;
  4384.  
  4385. },{}],27:[function(_dereq_,module,exports){
  4386. "use strict";
  4387. module.exports = function(
  4388.     Promise, INTERNAL, tryConvertToPromise, apiRejection) {
  4389. var util = _dereq_("./util");
  4390.  
  4391. var raceLater = function (promise) {
  4392.     return promise.then(function(array) {
  4393.         return race(array, promise);
  4394.     });
  4395. };
  4396.  
  4397. function race(promises, parent) {
  4398.     var maybePromise = tryConvertToPromise(promises);
  4399.  
  4400.     if (maybePromise instanceof Promise) {
  4401.         return raceLater(maybePromise);
  4402.     } else {
  4403.         promises = util.asArray(promises);
  4404.         if (promises === null)
  4405.             return apiRejection("expecting an array or an iterable object but got " + util.classString(promises));
  4406.     }
  4407.  
  4408.     var ret = new Promise(INTERNAL);
  4409.     if (parent !== undefined) {
  4410.         ret._propagateFrom(parent, 3);
  4411.     }
  4412.     var fulfill = ret._fulfill;
  4413.     var reject = ret._reject;
  4414.     for (var i = 0, len = promises.length; i < len; ++i) {
  4415.         var val = promises[i];
  4416.  
  4417.         if (val === undefined && !(i in promises)) {
  4418.             continue;
  4419.         }
  4420.  
  4421.         Promise.cast(val)._then(fulfill, reject, undefined, ret, null);
  4422.     }
  4423.     return ret;
  4424. }
  4425.  
  4426. Promise.race = function (promises) {
  4427.     return race(promises, undefined);
  4428. };
  4429.  
  4430. Promise.prototype.race = function () {
  4431.     return race(this, undefined);
  4432. };
  4433.  
  4434. };
  4435.  
  4436. },{"./util":36}],28:[function(_dereq_,module,exports){
  4437. "use strict";
  4438. module.exports = function(Promise,
  4439.                           PromiseArray,
  4440.                           apiRejection,
  4441.                           tryConvertToPromise,
  4442.                           INTERNAL,
  4443.                           debug) {
  4444. var getDomain = Promise._getDomain;
  4445. var util = _dereq_("./util");
  4446. var tryCatch = util.tryCatch;
  4447.  
  4448. function ReductionPromiseArray(promises, fn, initialValue, _each) {
  4449.     this.constructor$(promises);
  4450.     var domain = getDomain();
  4451.     this._fn = domain === null ? fn : util.domainBind(domain, fn);
  4452.     if (initialValue !== undefined) {
  4453.         initialValue = Promise.resolve(initialValue);
  4454.         initialValue._attachCancellationCallback(this);
  4455.     }
  4456.     this._initialValue = initialValue;
  4457.     this._currentCancellable = null;
  4458.     if(_each === INTERNAL) {
  4459.         this._eachValues = Array(this._length);
  4460.     } else if (_each === 0) {
  4461.         this._eachValues = null;
  4462.     } else {
  4463.         this._eachValues = undefined;
  4464.     }
  4465.     this._promise._captureStackTrace();
  4466.     this._init$(undefined, -5);
  4467. }
  4468. util.inherits(ReductionPromiseArray, PromiseArray);
  4469.  
  4470. ReductionPromiseArray.prototype._gotAccum = function(accum) {
  4471.     if (this._eachValues !== undefined && 
  4472.         this._eachValues !== null && 
  4473.         accum !== INTERNAL) {
  4474.         this._eachValues.push(accum);
  4475.     }
  4476. };
  4477.  
  4478. ReductionPromiseArray.prototype._eachComplete = function(value) {
  4479.     if (this._eachValues !== null) {
  4480.         this._eachValues.push(value);
  4481.     }
  4482.     return this._eachValues;
  4483. };
  4484.  
  4485. ReductionPromiseArray.prototype._init = function() {};
  4486.  
  4487. ReductionPromiseArray.prototype._resolveEmptyArray = function() {
  4488.     this._resolve(this._eachValues !== undefined ? this._eachValues
  4489.                                                  : this._initialValue);
  4490. };
  4491.  
  4492. ReductionPromiseArray.prototype.shouldCopyValues = function () {
  4493.     return false;
  4494. };
  4495.  
  4496. ReductionPromiseArray.prototype._resolve = function(value) {
  4497.     this._promise._resolveCallback(value);
  4498.     this._values = null;
  4499. };
  4500.  
  4501. ReductionPromiseArray.prototype._resultCancelled = function(sender) {
  4502.     if (sender === this._initialValue) return this._cancel();
  4503.     if (this._isResolved()) return;
  4504.     this._resultCancelled$();
  4505.     if (this._currentCancellable instanceof Promise) {
  4506.         this._currentCancellable.cancel();
  4507.     }
  4508.     if (this._initialValue instanceof Promise) {
  4509.         this._initialValue.cancel();
  4510.     }
  4511. };
  4512.  
  4513. ReductionPromiseArray.prototype._iterate = function (values) {
  4514.     this._values = values;
  4515.     var value;
  4516.     var i;
  4517.     var length = values.length;
  4518.     if (this._initialValue !== undefined) {
  4519.         value = this._initialValue;
  4520.         i = 0;
  4521.     } else {
  4522.         value = Promise.resolve(values[0]);
  4523.         i = 1;
  4524.     }
  4525.  
  4526.     this._currentCancellable = value;
  4527.  
  4528.     if (!value.isRejected()) {
  4529.         for (; i < length; ++i) {
  4530.             var ctx = {
  4531.                 accum: null,
  4532.                 value: values[i],
  4533.                 index: i,
  4534.                 length: length,
  4535.                 array: this
  4536.             };
  4537.             value = value._then(gotAccum, undefined, undefined, ctx, undefined);
  4538.         }
  4539.     }
  4540.  
  4541.     if (this._eachValues !== undefined) {
  4542.         value = value
  4543.             ._then(this._eachComplete, undefined, undefined, this, undefined);
  4544.     }
  4545.     value._then(completed, completed, undefined, value, this);
  4546. };
  4547.  
  4548. Promise.prototype.reduce = function (fn, initialValue) {
  4549.     return reduce(this, fn, initialValue, null);
  4550. };
  4551.  
  4552. Promise.reduce = function (promises, fn, initialValue, _each) {
  4553.     return reduce(promises, fn, initialValue, _each);
  4554. };
  4555.  
  4556. function completed(valueOrReason, array) {
  4557.     if (this.isFulfilled()) {
  4558.         array._resolve(valueOrReason);
  4559.     } else {
  4560.         array._reject(valueOrReason);
  4561.     }
  4562. }
  4563.  
  4564. function reduce(promises, fn, initialValue, _each) {
  4565.     if (typeof fn !== "function") {
  4566.         return apiRejection("expecting a function but got " + util.classString(fn));
  4567.     }
  4568.     var array = new ReductionPromiseArray(promises, fn, initialValue, _each);
  4569.     return array.promise();
  4570. }
  4571.  
  4572. function gotAccum(accum) {
  4573.     this.accum = accum;
  4574.     this.array._gotAccum(accum);
  4575.     var value = tryConvertToPromise(this.value, this.array._promise);
  4576.     if (value instanceof Promise) {
  4577.         this.array._currentCancellable = value;
  4578.         return value._then(gotValue, undefined, undefined, this, undefined);
  4579.     } else {
  4580.         return gotValue.call(this, value);
  4581.     }
  4582. }
  4583.  
  4584. function gotValue(value) {
  4585.     var array = this.array;
  4586.     var promise = array._promise;
  4587.     var fn = tryCatch(array._fn);
  4588.     promise._pushContext();
  4589.     var ret;
  4590.     if (array._eachValues !== undefined) {
  4591.         ret = fn.call(promise._boundValue(), value, this.index, this.length);
  4592.     } else {
  4593.         ret = fn.call(promise._boundValue(),
  4594.                               this.accum, value, this.index, this.length);
  4595.     }
  4596.     if (ret instanceof Promise) {
  4597.         array._currentCancellable = ret;
  4598.     }
  4599.     var promiseCreated = promise._popContext();
  4600.     debug.checkForgottenReturns(
  4601.         ret,
  4602.         promiseCreated,
  4603.         array._eachValues !== undefined ? "Promise.each" : "Promise.reduce",
  4604.         promise
  4605.     );
  4606.     return ret;
  4607. }
  4608. };
  4609.  
  4610. },{"./util":36}],29:[function(_dereq_,module,exports){
  4611. "use strict";
  4612. var util = _dereq_("./util");
  4613. var schedule;
  4614. var noAsyncScheduler = function() {
  4615.     throw new Error("No async scheduler available\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
  4616. };
  4617. var NativePromise = util.getNativePromise();
  4618. if (util.isNode && typeof MutationObserver === "undefined") {
  4619.     var GlobalSetImmediate = global.setImmediate;
  4620.     var ProcessNextTick = process.nextTick;
  4621.     schedule = util.isRecentNode
  4622.                 ? function(fn) { GlobalSetImmediate.call(global, fn); }
  4623.                 : function(fn) { ProcessNextTick.call(process, fn); };
  4624. } else if (typeof NativePromise === "function" &&
  4625.            typeof NativePromise.resolve === "function") {
  4626.     var nativePromise = NativePromise.resolve();
  4627.     schedule = function(fn) {
  4628.         nativePromise.then(fn);
  4629.     };
  4630. } else if ((typeof MutationObserver !== "undefined") &&
  4631.           !(typeof window !== "undefined" &&
  4632.             window.navigator &&
  4633.             (window.navigator.standalone || window.cordova))) {
  4634.     schedule = (function() {
  4635.         var div = document.createElement("div");
  4636.         var opts = {attributes: true};
  4637.         var toggleScheduled = false;
  4638.         var div2 = document.createElement("div");
  4639.         var o2 = new MutationObserver(function() {
  4640.             div.classList.toggle("foo");
  4641.             toggleScheduled = false;
  4642.         });
  4643.         o2.observe(div2, opts);
  4644.  
  4645.         var scheduleToggle = function() {
  4646.             if (toggleScheduled) return;
  4647.             toggleScheduled = true;
  4648.             div2.classList.toggle("foo");
  4649.         };
  4650.  
  4651.         return function schedule(fn) {
  4652.             var o = new MutationObserver(function() {
  4653.                 o.disconnect();
  4654.                 fn();
  4655.             });
  4656.             o.observe(div, opts);
  4657.             scheduleToggle();
  4658.         };
  4659.     })();
  4660. } else if (typeof setImmediate !== "undefined") {
  4661.     schedule = function (fn) {
  4662.         setImmediate(fn);
  4663.     };
  4664. } else if (typeof setTimeout !== "undefined") {
  4665.     schedule = function (fn) {
  4666.         setTimeout(fn, 0);
  4667.     };
  4668. } else {
  4669.     schedule = noAsyncScheduler;
  4670. }
  4671. module.exports = schedule;
  4672.  
  4673. },{"./util":36}],30:[function(_dereq_,module,exports){
  4674. "use strict";
  4675. module.exports =
  4676.     function(Promise, PromiseArray, debug) {
  4677. var PromiseInspection = Promise.PromiseInspection;
  4678. var util = _dereq_("./util");
  4679.  
  4680. function SettledPromiseArray(values) {
  4681.     this.constructor$(values);
  4682. }
  4683. util.inherits(SettledPromiseArray, PromiseArray);
  4684.  
  4685. SettledPromiseArray.prototype._promiseResolved = function (index, inspection) {
  4686.     this._values[index] = inspection;
  4687.     var totalResolved = ++this._totalResolved;
  4688.     if (totalResolved >= this._length) {
  4689.         this._resolve(this._values);
  4690.         return true;
  4691.     }
  4692.     return false;
  4693. };
  4694.  
  4695. SettledPromiseArray.prototype._promiseFulfilled = function (value, index) {
  4696.     var ret = new PromiseInspection();
  4697.     ret._bitField = 33554432;
  4698.     ret._settledValueField = value;
  4699.     return this._promiseResolved(index, ret);
  4700. };
  4701. SettledPromiseArray.prototype._promiseRejected = function (reason, index) {
  4702.     var ret = new PromiseInspection();
  4703.     ret._bitField = 16777216;
  4704.     ret._settledValueField = reason;
  4705.     return this._promiseResolved(index, ret);
  4706. };
  4707.  
  4708. Promise.settle = function (promises) {
  4709.     debug.deprecated(".settle()", ".reflect()");
  4710.     return new SettledPromiseArray(promises).promise();
  4711. };
  4712.  
  4713. Promise.prototype.settle = function () {
  4714.     return Promise.settle(this);
  4715. };
  4716. };
  4717.  
  4718. },{"./util":36}],31:[function(_dereq_,module,exports){
  4719. "use strict";
  4720. module.exports =
  4721. function(Promise, PromiseArray, apiRejection) {
  4722. var util = _dereq_("./util");
  4723. var RangeError = _dereq_("./errors").RangeError;
  4724. var AggregateError = _dereq_("./errors").AggregateError;
  4725. var isArray = util.isArray;
  4726. var CANCELLATION = {};
  4727.  
  4728.  
  4729. function SomePromiseArray(values) {
  4730.     this.constructor$(values);
  4731.     this._howMany = 0;
  4732.     this._unwrap = false;
  4733.     this._initialized = false;
  4734. }
  4735. util.inherits(SomePromiseArray, PromiseArray);
  4736.  
  4737. SomePromiseArray.prototype._init = function () {
  4738.     if (!this._initialized) {
  4739.         return;
  4740.     }
  4741.     if (this._howMany === 0) {
  4742.         this._resolve([]);
  4743.         return;
  4744.     }
  4745.     this._init$(undefined, -5);
  4746.     var isArrayResolved = isArray(this._values);
  4747.     if (!this._isResolved() &&
  4748.         isArrayResolved &&
  4749.         this._howMany > this._canPossiblyFulfill()) {
  4750.         this._reject(this._getRangeError(this.length()));
  4751.     }
  4752. };
  4753.  
  4754. SomePromiseArray.prototype.init = function () {
  4755.     this._initialized = true;
  4756.     this._init();
  4757. };
  4758.  
  4759. SomePromiseArray.prototype.setUnwrap = function () {
  4760.     this._unwrap = true;
  4761. };
  4762.  
  4763. SomePromiseArray.prototype.howMany = function () {
  4764.     return this._howMany;
  4765. };
  4766.  
  4767. SomePromiseArray.prototype.setHowMany = function (count) {
  4768.     this._howMany = count;
  4769. };
  4770.  
  4771. SomePromiseArray.prototype._promiseFulfilled = function (value) {
  4772.     this._addFulfilled(value);
  4773.     if (this._fulfilled() === this.howMany()) {
  4774.         this._values.length = this.howMany();
  4775.         if (this.howMany() === 1 && this._unwrap) {
  4776.             this._resolve(this._values[0]);
  4777.         } else {
  4778.             this._resolve(this._values);
  4779.         }
  4780.         return true;
  4781.     }
  4782.     return false;
  4783.  
  4784. };
  4785. SomePromiseArray.prototype._promiseRejected = function (reason) {
  4786.     this._addRejected(reason);
  4787.     return this._checkOutcome();
  4788. };
  4789.  
  4790. SomePromiseArray.prototype._promiseCancelled = function () {
  4791.     if (this._values instanceof Promise || this._values == null) {
  4792.         return this._cancel();
  4793.     }
  4794.     this._addRejected(CANCELLATION);
  4795.     return this._checkOutcome();
  4796. };
  4797.  
  4798. SomePromiseArray.prototype._checkOutcome = function() {
  4799.     if (this.howMany() > this._canPossiblyFulfill()) {
  4800.         var e = new AggregateError();
  4801.         for (var i = this.length(); i < this._values.length; ++i) {
  4802.             if (this._values[i] !== CANCELLATION) {
  4803.                 e.push(this._values[i]);
  4804.             }
  4805.         }
  4806.         if (e.length > 0) {
  4807.             this._reject(e);
  4808.         } else {
  4809.             this._cancel();
  4810.         }
  4811.         return true;
  4812.     }
  4813.     return false;
  4814. };
  4815.  
  4816. SomePromiseArray.prototype._fulfilled = function () {
  4817.     return this._totalResolved;
  4818. };
  4819.  
  4820. SomePromiseArray.prototype._rejected = function () {
  4821.     return this._values.length - this.length();
  4822. };
  4823.  
  4824. SomePromiseArray.prototype._addRejected = function (reason) {
  4825.     this._values.push(reason);
  4826. };
  4827.  
  4828. SomePromiseArray.prototype._addFulfilled = function (value) {
  4829.     this._values[this._totalResolved++] = value;
  4830. };
  4831.  
  4832. SomePromiseArray.prototype._canPossiblyFulfill = function () {
  4833.     return this.length() - this._rejected();
  4834. };
  4835.  
  4836. SomePromiseArray.prototype._getRangeError = function (count) {
  4837.     var message = "Input array must contain at least " +
  4838.             this._howMany + " items but contains only " + count + " items";
  4839.     return new RangeError(message);
  4840. };
  4841.  
  4842. SomePromiseArray.prototype._resolveEmptyArray = function () {
  4843.     this._reject(this._getRangeError(0));
  4844. };
  4845.  
  4846. function some(promises, howMany) {
  4847.     if ((howMany | 0) !== howMany || howMany < 0) {
  4848.         return apiRejection("expecting a positive integer\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
  4849.     }
  4850.     var ret = new SomePromiseArray(promises);
  4851.     var promise = ret.promise();
  4852.     ret.setHowMany(howMany);
  4853.     ret.init();
  4854.     return promise;
  4855. }
  4856.  
  4857. Promise.some = function (promises, howMany) {
  4858.     return some(promises, howMany);
  4859. };
  4860.  
  4861. Promise.prototype.some = function (howMany) {
  4862.     return some(this, howMany);
  4863. };
  4864.  
  4865. Promise._SomePromiseArray = SomePromiseArray;
  4866. };
  4867.  
  4868. },{"./errors":12,"./util":36}],32:[function(_dereq_,module,exports){
  4869. "use strict";
  4870. module.exports = function(Promise) {
  4871. function PromiseInspection(promise) {
  4872.     if (promise !== undefined) {
  4873.         promise = promise._target();
  4874.         this._bitField = promise._bitField;
  4875.         this._settledValueField = promise._isFateSealed()
  4876.             ? promise._settledValue() : undefined;
  4877.     }
  4878.     else {
  4879.         this._bitField = 0;
  4880.         this._settledValueField = undefined;
  4881.     }
  4882. }
  4883.  
  4884. PromiseInspection.prototype._settledValue = function() {
  4885.     return this._settledValueField;
  4886. };
  4887.  
  4888. var value = PromiseInspection.prototype.value = function () {
  4889.     if (!this.isFulfilled()) {
  4890.         throw new TypeError("cannot get fulfillment value of a non-fulfilled promise\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
  4891.     }
  4892.     return this._settledValue();
  4893. };
  4894.  
  4895. var reason = PromiseInspection.prototype.error =
  4896. PromiseInspection.prototype.reason = function () {
  4897.     if (!this.isRejected()) {
  4898.         throw new TypeError("cannot get rejection reason of a non-rejected promise\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
  4899.     }
  4900.     return this._settledValue();
  4901. };
  4902.  
  4903. var isFulfilled = PromiseInspection.prototype.isFulfilled = function() {
  4904.     return (this._bitField & 33554432) !== 0;
  4905. };
  4906.  
  4907. var isRejected = PromiseInspection.prototype.isRejected = function () {
  4908.     return (this._bitField & 16777216) !== 0;
  4909. };
  4910.  
  4911. var isPending = PromiseInspection.prototype.isPending = function () {
  4912.     return (this._bitField & 50397184) === 0;
  4913. };
  4914.  
  4915. var isResolved = PromiseInspection.prototype.isResolved = function () {
  4916.     return (this._bitField & 50331648) !== 0;
  4917. };
  4918.  
  4919. PromiseInspection.prototype.isCancelled = function() {
  4920.     return (this._bitField & 8454144) !== 0;
  4921. };
  4922.  
  4923. Promise.prototype.__isCancelled = function() {
  4924.     return (this._bitField & 65536) === 65536;
  4925. };
  4926.  
  4927. Promise.prototype._isCancelled = function() {
  4928.     return this._target().__isCancelled();
  4929. };
  4930.  
  4931. Promise.prototype.isCancelled = function() {
  4932.     return (this._target()._bitField & 8454144) !== 0;
  4933. };
  4934.  
  4935. Promise.prototype.isPending = function() {
  4936.     return isPending.call(this._target());
  4937. };
  4938.  
  4939. Promise.prototype.isRejected = function() {
  4940.     return isRejected.call(this._target());
  4941. };
  4942.  
  4943. Promise.prototype.isFulfilled = function() {
  4944.     return isFulfilled.call(this._target());
  4945. };
  4946.  
  4947. Promise.prototype.isResolved = function() {
  4948.     return isResolved.call(this._target());
  4949. };
  4950.  
  4951. Promise.prototype.value = function() {
  4952.     return value.call(this._target());
  4953. };
  4954.  
  4955. Promise.prototype.reason = function() {
  4956.     var target = this._target();
  4957.     target._unsetRejectionIsUnhandled();
  4958.     return reason.call(target);
  4959. };
  4960.  
  4961. Promise.prototype._value = function() {
  4962.     return this._settledValue();
  4963. };
  4964.  
  4965. Promise.prototype._reason = function() {
  4966.     this._unsetRejectionIsUnhandled();
  4967.     return this._settledValue();
  4968. };
  4969.  
  4970. Promise.PromiseInspection = PromiseInspection;
  4971. };
  4972.  
  4973. },{}],33:[function(_dereq_,module,exports){
  4974. "use strict";
  4975. module.exports = function(Promise, INTERNAL) {
  4976. var util = _dereq_("./util");
  4977. var errorObj = util.errorObj;
  4978. var isObject = util.isObject;
  4979.  
  4980. function tryConvertToPromise(obj, context) {
  4981.     if (isObject(obj)) {
  4982.         if (obj instanceof Promise) return obj;
  4983.         var then = getThen(obj);
  4984.         if (then === errorObj) {
  4985.             if (context) context._pushContext();
  4986.             var ret = Promise.reject(then.e);
  4987.             if (context) context._popContext();
  4988.             return ret;
  4989.         } else if (typeof then === "function") {
  4990.             if (isAnyBluebirdPromise(obj)) {
  4991.                 var ret = new Promise(INTERNAL);
  4992.                 obj._then(
  4993.                     ret._fulfill,
  4994.                     ret._reject,
  4995.                     undefined,
  4996.                     ret,
  4997.                     null
  4998.                 );
  4999.                 return ret;
  5000.             }
  5001.             return doThenable(obj, then, context);
  5002.         }
  5003.     }
  5004.     return obj;
  5005. }
  5006.  
  5007. function doGetThen(obj) {
  5008.     return obj.then;
  5009. }
  5010.  
  5011. function getThen(obj) {
  5012.     try {
  5013.         return doGetThen(obj);
  5014.     } catch (e) {
  5015.         errorObj.e = e;
  5016.         return errorObj;
  5017.     }
  5018. }
  5019.  
  5020. var hasProp = {}.hasOwnProperty;
  5021. function isAnyBluebirdPromise(obj) {
  5022.     try {
  5023.         return hasProp.call(obj, "_promise0");
  5024.     } catch (e) {
  5025.         return false;
  5026.     }
  5027. }
  5028.  
  5029. function doThenable(x, then, context) {
  5030.     var promise = new Promise(INTERNAL);
  5031.     var ret = promise;
  5032.     if (context) context._pushContext();
  5033.     promise._captureStackTrace();
  5034.     if (context) context._popContext();
  5035.     var synchronous = true;
  5036.     var result = util.tryCatch(then).call(x, resolve, reject);
  5037.     synchronous = false;
  5038.  
  5039.     if (promise && result === errorObj) {
  5040.         promise._rejectCallback(result.e, true, true);
  5041.         promise = null;
  5042.     }
  5043.  
  5044.     function resolve(value) {
  5045.         if (!promise) return;
  5046.         promise._resolveCallback(value);
  5047.         promise = null;
  5048.     }
  5049.  
  5050.     function reject(reason) {
  5051.         if (!promise) return;
  5052.         promise._rejectCallback(reason, synchronous, true);
  5053.         promise = null;
  5054.     }
  5055.     return ret;
  5056. }
  5057.  
  5058. return tryConvertToPromise;
  5059. };
  5060.  
  5061. },{"./util":36}],34:[function(_dereq_,module,exports){
  5062. "use strict";
  5063. module.exports = function(Promise, INTERNAL, debug) {
  5064. var util = _dereq_("./util");
  5065. var TimeoutError = Promise.TimeoutError;
  5066.  
  5067. function HandleWrapper(handle)  {
  5068.     this.handle = handle;
  5069. }
  5070.  
  5071. HandleWrapper.prototype._resultCancelled = function() {
  5072.     clearTimeout(this.handle);
  5073. };
  5074.  
  5075. var afterValue = function(value) { return delay(+this).thenReturn(value); };
  5076. var delay = Promise.delay = function (ms, value) {
  5077.     var ret;
  5078.     var handle;
  5079.     if (value !== undefined) {
  5080.         ret = Promise.resolve(value)
  5081.                 ._then(afterValue, null, null, ms, undefined);
  5082.         if (debug.cancellation() && value instanceof Promise) {
  5083.             ret._setOnCancel(value);
  5084.         }
  5085.     } else {
  5086.         ret = new Promise(INTERNAL);
  5087.         handle = setTimeout(function() { ret._fulfill(); }, +ms);
  5088.         if (debug.cancellation()) {
  5089.             ret._setOnCancel(new HandleWrapper(handle));
  5090.         }
  5091.         ret._captureStackTrace();
  5092.     }
  5093.     ret._setAsyncGuaranteed();
  5094.     return ret;
  5095. };
  5096.  
  5097. Promise.prototype.delay = function (ms) {
  5098.     return delay(ms, this);
  5099. };
  5100.  
  5101. var afterTimeout = function (promise, message, parent) {
  5102.     var err;
  5103.     if (typeof message !== "string") {
  5104.         if (message instanceof Error) {
  5105.             err = message;
  5106.         } else {
  5107.             err = new TimeoutError("operation timed out");
  5108.         }
  5109.     } else {
  5110.         err = new TimeoutError(message);
  5111.     }
  5112.     util.markAsOriginatingFromRejection(err);
  5113.     promise._attachExtraTrace(err);
  5114.     promise._reject(err);
  5115.  
  5116.     if (parent != null) {
  5117.         parent.cancel();
  5118.     }
  5119. };
  5120.  
  5121. function successClear(value) {
  5122.     clearTimeout(this.handle);
  5123.     return value;
  5124. }
  5125.  
  5126. function failureClear(reason) {
  5127.     clearTimeout(this.handle);
  5128.     throw reason;
  5129. }
  5130.  
  5131. Promise.prototype.timeout = function (ms, message) {
  5132.     ms = +ms;
  5133.     var ret, parent;
  5134.  
  5135.     var handleWrapper = new HandleWrapper(setTimeout(function timeoutTimeout() {
  5136.         if (ret.isPending()) {
  5137.             afterTimeout(ret, message, parent);
  5138.         }
  5139.     }, ms));
  5140.  
  5141.     if (debug.cancellation()) {
  5142.         parent = this.then();
  5143.         ret = parent._then(successClear, failureClear,
  5144.                             undefined, handleWrapper, undefined);
  5145.         ret._setOnCancel(handleWrapper);
  5146.     } else {
  5147.         ret = this._then(successClear, failureClear,
  5148.                             undefined, handleWrapper, undefined);
  5149.     }
  5150.  
  5151.     return ret;
  5152. };
  5153.  
  5154. };
  5155.  
  5156. },{"./util":36}],35:[function(_dereq_,module,exports){
  5157. "use strict";
  5158. module.exports = function (Promise, apiRejection, tryConvertToPromise,
  5159.     createContext, INTERNAL, debug) {
  5160.     var util = _dereq_("./util");
  5161.     var TypeError = _dereq_("./errors").TypeError;
  5162.     var inherits = _dereq_("./util").inherits;
  5163.     var errorObj = util.errorObj;
  5164.     var tryCatch = util.tryCatch;
  5165.     var NULL = {};
  5166.  
  5167.     function thrower(e) {
  5168.         setTimeout(function(){throw e;}, 0);
  5169.     }
  5170.  
  5171.     function castPreservingDisposable(thenable) {
  5172.         var maybePromise = tryConvertToPromise(thenable);
  5173.         if (maybePromise !== thenable &&
  5174.             typeof thenable._isDisposable === "function" &&
  5175.             typeof thenable._getDisposer === "function" &&
  5176.             thenable._isDisposable()) {
  5177.             maybePromise._setDisposable(thenable._getDisposer());
  5178.         }
  5179.         return maybePromise;
  5180.     }
  5181.     function dispose(resources, inspection) {
  5182.         var i = 0;
  5183.         var len = resources.length;
  5184.         var ret = new Promise(INTERNAL);
  5185.         function iterator() {
  5186.             if (i >= len) return ret._fulfill();
  5187.             var maybePromise = castPreservingDisposable(resources[i++]);
  5188.             if (maybePromise instanceof Promise &&
  5189.                 maybePromise._isDisposable()) {
  5190.                 try {
  5191.                     maybePromise = tryConvertToPromise(
  5192.                         maybePromise._getDisposer().tryDispose(inspection),
  5193.                         resources.promise);
  5194.                 } catch (e) {
  5195.                     return thrower(e);
  5196.                 }
  5197.                 if (maybePromise instanceof Promise) {
  5198.                     return maybePromise._then(iterator, thrower,
  5199.                                               null, null, null);
  5200.                 }
  5201.             }
  5202.             iterator();
  5203.         }
  5204.         iterator();
  5205.         return ret;
  5206.     }
  5207.  
  5208.     function Disposer(data, promise, context) {
  5209.         this._data = data;
  5210.         this._promise = promise;
  5211.         this._context = context;
  5212.     }
  5213.  
  5214.     Disposer.prototype.data = function () {
  5215.         return this._data;
  5216.     };
  5217.  
  5218.     Disposer.prototype.promise = function () {
  5219.         return this._promise;
  5220.     };
  5221.  
  5222.     Disposer.prototype.resource = function () {
  5223.         if (this.promise().isFulfilled()) {
  5224.             return this.promise().value();
  5225.         }
  5226.         return NULL;
  5227.     };
  5228.  
  5229.     Disposer.prototype.tryDispose = function(inspection) {
  5230.         var resource = this.resource();
  5231.         var context = this._context;
  5232.         if (context !== undefined) context._pushContext();
  5233.         var ret = resource !== NULL
  5234.             ? this.doDispose(resource, inspection) : null;
  5235.         if (context !== undefined) context._popContext();
  5236.         this._promise._unsetDisposable();
  5237.         this._data = null;
  5238.         return ret;
  5239.     };
  5240.  
  5241.     Disposer.isDisposer = function (d) {
  5242.         return (d != null &&
  5243.                 typeof d.resource === "function" &&
  5244.                 typeof d.tryDispose === "function");
  5245.     };
  5246.  
  5247.     function FunctionDisposer(fn, promise, context) {
  5248.         this.constructor$(fn, promise, context);
  5249.     }
  5250.     inherits(FunctionDisposer, Disposer);
  5251.  
  5252.     FunctionDisposer.prototype.doDispose = function (resource, inspection) {
  5253.         var fn = this.data();
  5254.         return fn.call(resource, resource, inspection);
  5255.     };
  5256.  
  5257.     function maybeUnwrapDisposer(value) {
  5258.         if (Disposer.isDisposer(value)) {
  5259.             this.resources[this.index]._setDisposable(value);
  5260.             return value.promise();
  5261.         }
  5262.         return value;
  5263.     }
  5264.  
  5265.     function ResourceList(length) {
  5266.         this.length = length;
  5267.         this.promise = null;
  5268.         this[length-1] = null;
  5269.     }
  5270.  
  5271.     ResourceList.prototype._resultCancelled = function() {
  5272.         var len = this.length;
  5273.         for (var i = 0; i < len; ++i) {
  5274.             var item = this[i];
  5275.             if (item instanceof Promise) {
  5276.                 item.cancel();
  5277.             }
  5278.         }
  5279.     };
  5280.  
  5281.     Promise.using = function () {
  5282.         var len = arguments.length;
  5283.         if (len < 2) return apiRejection(
  5284.                         "you must pass at least 2 arguments to Promise.using");
  5285.         var fn = arguments[len - 1];
  5286.         if (typeof fn !== "function") {
  5287.             return apiRejection("expecting a function but got " + util.classString(fn));
  5288.         }
  5289.         var input;
  5290.         var spreadArgs = true;
  5291.         if (len === 2 && Array.isArray(arguments[0])) {
  5292.             input = arguments[0];
  5293.             len = input.length;
  5294.             spreadArgs = false;
  5295.         } else {
  5296.             input = arguments;
  5297.             len--;
  5298.         }
  5299.         var resources = new ResourceList(len);
  5300.         for (var i = 0; i < len; ++i) {
  5301.             var resource = input[i];
  5302.             if (Disposer.isDisposer(resource)) {
  5303.                 var disposer = resource;
  5304.                 resource = resource.promise();
  5305.                 resource._setDisposable(disposer);
  5306.             } else {
  5307.                 var maybePromise = tryConvertToPromise(resource);
  5308.                 if (maybePromise instanceof Promise) {
  5309.                     resource =
  5310.                         maybePromise._then(maybeUnwrapDisposer, null, null, {
  5311.                             resources: resources,
  5312.                             index: i
  5313.                     }, undefined);
  5314.                 }
  5315.             }
  5316.             resources[i] = resource;
  5317.         }
  5318.  
  5319.         var reflectedResources = new Array(resources.length);
  5320.         for (var i = 0; i < reflectedResources.length; ++i) {
  5321.             reflectedResources[i] = Promise.resolve(resources[i]).reflect();
  5322.         }
  5323.  
  5324.         var resultPromise = Promise.all(reflectedResources)
  5325.             .then(function(inspections) {
  5326.                 for (var i = 0; i < inspections.length; ++i) {
  5327.                     var inspection = inspections[i];
  5328.                     if (inspection.isRejected()) {
  5329.                         errorObj.e = inspection.error();
  5330.                         return errorObj;
  5331.                     } else if (!inspection.isFulfilled()) {
  5332.                         resultPromise.cancel();
  5333.                         return;
  5334.                     }
  5335.                     inspections[i] = inspection.value();
  5336.                 }
  5337.                 promise._pushContext();
  5338.  
  5339.                 fn = tryCatch(fn);
  5340.                 var ret = spreadArgs
  5341.                     ? fn.apply(undefined, inspections) : fn(inspections);
  5342.                 var promiseCreated = promise._popContext();
  5343.                 debug.checkForgottenReturns(
  5344.                     ret, promiseCreated, "Promise.using", promise);
  5345.                 return ret;
  5346.             });
  5347.  
  5348.         var promise = resultPromise.lastly(function() {
  5349.             var inspection = new Promise.PromiseInspection(resultPromise);
  5350.             return dispose(resources, inspection);
  5351.         });
  5352.         resources.promise = promise;
  5353.         promise._setOnCancel(resources);
  5354.         return promise;
  5355.     };
  5356.  
  5357.     Promise.prototype._setDisposable = function (disposer) {
  5358.         this._bitField = this._bitField | 131072;
  5359.         this._disposer = disposer;
  5360.     };
  5361.  
  5362.     Promise.prototype._isDisposable = function () {
  5363.         return (this._bitField & 131072) > 0;
  5364.     };
  5365.  
  5366.     Promise.prototype._getDisposer = function () {
  5367.         return this._disposer;
  5368.     };
  5369.  
  5370.     Promise.prototype._unsetDisposable = function () {
  5371.         this._bitField = this._bitField & (~131072);
  5372.         this._disposer = undefined;
  5373.     };
  5374.  
  5375.     Promise.prototype.disposer = function (fn) {
  5376.         if (typeof fn === "function") {
  5377.             return new FunctionDisposer(fn, this, createContext());
  5378.         }
  5379.         throw new TypeError();
  5380.     };
  5381.  
  5382. };
  5383.  
  5384. },{"./errors":12,"./util":36}],36:[function(_dereq_,module,exports){
  5385. "use strict";
  5386. var es5 = _dereq_("./es5");
  5387. var canEvaluate = typeof navigator == "undefined";
  5388.  
  5389. var errorObj = {e: {}};
  5390. var tryCatchTarget;
  5391. var globalObject = typeof self !== "undefined" ? self :
  5392.     typeof window !== "undefined" ? window :
  5393.     typeof global !== "undefined" ? global :
  5394.     this !== undefined ? this : null;
  5395.  
  5396. function tryCatcher() {
  5397.     try {
  5398.         var target = tryCatchTarget;
  5399.         tryCatchTarget = null;
  5400.         return target.apply(this, arguments);
  5401.     } catch (e) {
  5402.         errorObj.e = e;
  5403.         return errorObj;
  5404.     }
  5405. }
  5406. function tryCatch(fn) {
  5407.     tryCatchTarget = fn;
  5408.     return tryCatcher;
  5409. }
  5410.  
  5411. var inherits = function(Child, Parent) {
  5412.     var hasProp = {}.hasOwnProperty;
  5413.  
  5414.     function T() {
  5415.         this.constructor = Child;
  5416.         this.constructor$ = Parent;
  5417.         for (var propertyName in Parent.prototype) {
  5418.             if (hasProp.call(Parent.prototype, propertyName) &&
  5419.                 propertyName.charAt(propertyName.length-1) !== "$"
  5420.            ) {
  5421.                 this[propertyName + "$"] = Parent.prototype[propertyName];
  5422.             }
  5423.         }
  5424.     }
  5425.     T.prototype = Parent.prototype;
  5426.     Child.prototype = new T();
  5427.     return Child.prototype;
  5428. };
  5429.  
  5430.  
  5431. function isPrimitive(val) {
  5432.     return val == null || val === true || val === false ||
  5433.         typeof val === "string" || typeof val === "number";
  5434.  
  5435. }
  5436.  
  5437. function isObject(value) {
  5438.     return typeof value === "function" ||
  5439.            typeof value === "object" && value !== null;
  5440. }
  5441.  
  5442. function maybeWrapAsError(maybeError) {
  5443.     if (!isPrimitive(maybeError)) return maybeError;
  5444.  
  5445.     return new Error(safeToString(maybeError));
  5446. }
  5447.  
  5448. function withAppended(target, appendee) {
  5449.     var len = target.length;
  5450.     var ret = new Array(len + 1);
  5451.     var i;
  5452.     for (i = 0; i < len; ++i) {
  5453.         ret[i] = target[i];
  5454.     }
  5455.     ret[i] = appendee;
  5456.     return ret;
  5457. }
  5458.  
  5459. function getDataPropertyOrDefault(obj, key, defaultValue) {
  5460.     if (es5.isES5) {
  5461.         var desc = Object.getOwnPropertyDescriptor(obj, key);
  5462.  
  5463.         if (desc != null) {
  5464.             return desc.get == null && desc.set == null
  5465.                     ? desc.value
  5466.                     : defaultValue;
  5467.         }
  5468.     } else {
  5469.         return {}.hasOwnProperty.call(obj, key) ? obj[key] : undefined;
  5470.     }
  5471. }
  5472.  
  5473. function notEnumerableProp(obj, name, value) {
  5474.     if (isPrimitive(obj)) return obj;
  5475.     var descriptor = {
  5476.         value: value,
  5477.         configurable: true,
  5478.         enumerable: false,
  5479.         writable: true
  5480.     };
  5481.     es5.defineProperty(obj, name, descriptor);
  5482.     return obj;
  5483. }
  5484.  
  5485. function thrower(r) {
  5486.     throw r;
  5487. }
  5488.  
  5489. var inheritedDataKeys = (function() {
  5490.     var excludedPrototypes = [
  5491.         Array.prototype,
  5492.         Object.prototype,
  5493.         Function.prototype
  5494.     ];
  5495.  
  5496.     var isExcludedProto = function(val) {
  5497.         for (var i = 0; i < excludedPrototypes.length; ++i) {
  5498.             if (excludedPrototypes[i] === val) {
  5499.                 return true;
  5500.             }
  5501.         }
  5502.         return false;
  5503.     };
  5504.  
  5505.     if (es5.isES5) {
  5506.         var getKeys = Object.getOwnPropertyNames;
  5507.         return function(obj) {
  5508.             var ret = [];
  5509.             var visitedKeys = Object.create(null);
  5510.             while (obj != null && !isExcludedProto(obj)) {
  5511.                 var keys;
  5512.                 try {
  5513.                     keys = getKeys(obj);
  5514.                 } catch (e) {
  5515.                     return ret;
  5516.                 }
  5517.                 for (var i = 0; i < keys.length; ++i) {
  5518.                     var key = keys[i];
  5519.                     if (visitedKeys[key]) continue;
  5520.                     visitedKeys[key] = true;
  5521.                     var desc = Object.getOwnPropertyDescriptor(obj, key);
  5522.                     if (desc != null && desc.get == null && desc.set == null) {
  5523.                         ret.push(key);
  5524.                     }
  5525.                 }
  5526.                 obj = es5.getPrototypeOf(obj);
  5527.             }
  5528.             return ret;
  5529.         };
  5530.     } else {
  5531.         var hasProp = {}.hasOwnProperty;
  5532.         return function(obj) {
  5533.             if (isExcludedProto(obj)) return [];
  5534.             var ret = [];
  5535.  
  5536.             /*jshint forin:false */
  5537.             enumeration: for (var key in obj) {
  5538.                 if (hasProp.call(obj, key)) {
  5539.                     ret.push(key);
  5540.                 } else {
  5541.                     for (var i = 0; i < excludedPrototypes.length; ++i) {
  5542.                         if (hasProp.call(excludedPrototypes[i], key)) {
  5543.                             continue enumeration;
  5544.                         }
  5545.                     }
  5546.                     ret.push(key);
  5547.                 }
  5548.             }
  5549.             return ret;
  5550.         };
  5551.     }
  5552.  
  5553. })();
  5554.  
  5555. var thisAssignmentPattern = /this\s*\.\s*\S+\s*=/;
  5556. function isClass(fn) {
  5557.     try {
  5558.         if (typeof fn === "function") {
  5559.             var keys = es5.names(fn.prototype);
  5560.  
  5561.             var hasMethods = es5.isES5 && keys.length > 1;
  5562.             var hasMethodsOtherThanConstructor = keys.length > 0 &&
  5563.                 !(keys.length === 1 && keys[0] === "constructor");
  5564.             var hasThisAssignmentAndStaticMethods =
  5565.                 thisAssignmentPattern.test(fn + "") && es5.names(fn).length > 0;
  5566.  
  5567.             if (hasMethods || hasMethodsOtherThanConstructor ||
  5568.                 hasThisAssignmentAndStaticMethods) {
  5569.                 return true;
  5570.             }
  5571.         }
  5572.         return false;
  5573.     } catch (e) {
  5574.         return false;
  5575.     }
  5576. }
  5577.  
  5578. function toFastProperties(obj) {
  5579.     /*jshint -W027,-W055,-W031*/
  5580.     function FakeConstructor() {}
  5581.     FakeConstructor.prototype = obj;
  5582.     var l = 8;
  5583.     while (l--) new FakeConstructor();
  5584.     return obj;
  5585.     eval(obj);
  5586. }
  5587.  
  5588. var rident = /^[a-z$_][a-z$_0-9]*$/i;
  5589. function isIdentifier(str) {
  5590.     return rident.test(str);
  5591. }
  5592.  
  5593. function filledRange(count, prefix, suffix) {
  5594.     var ret = new Array(count);
  5595.     for(var i = 0; i < count; ++i) {
  5596.         ret[i] = prefix + i + suffix;
  5597.     }
  5598.     return ret;
  5599. }
  5600.  
  5601. function safeToString(obj) {
  5602.     try {
  5603.         return obj + "";
  5604.     } catch (e) {
  5605.         return "[no string representation]";
  5606.     }
  5607. }
  5608.  
  5609. function isError(obj) {
  5610.     return obj !== null &&
  5611.            typeof obj === "object" &&
  5612.            typeof obj.message === "string" &&
  5613.            typeof obj.name === "string";
  5614. }
  5615.  
  5616. function markAsOriginatingFromRejection(e) {
  5617.     try {
  5618.         notEnumerableProp(e, "isOperational", true);
  5619.     }
  5620.     catch(ignore) {}
  5621. }
  5622.  
  5623. function originatesFromRejection(e) {
  5624.     if (e == null) return false;
  5625.     return ((e instanceof Error["__BluebirdErrorTypes__"].OperationalError) ||
  5626.         e["isOperational"] === true);
  5627. }
  5628.  
  5629. function canAttachTrace(obj) {
  5630.     return isError(obj) && es5.propertyIsWritable(obj, "stack");
  5631. }
  5632.  
  5633. var ensureErrorObject = (function() {
  5634.     if (!("stack" in new Error())) {
  5635.         return function(value) {
  5636.             if (canAttachTrace(value)) return value;
  5637.             try {throw new Error(safeToString(value));}
  5638.             catch(err) {return err;}
  5639.         };
  5640.     } else {
  5641.         return function(value) {
  5642.             if (canAttachTrace(value)) return value;
  5643.             return new Error(safeToString(value));
  5644.         };
  5645.     }
  5646. })();
  5647.  
  5648. function classString(obj) {
  5649.     return {}.toString.call(obj);
  5650. }
  5651.  
  5652. function copyDescriptors(from, to, filter) {
  5653.     var keys = es5.names(from);
  5654.     for (var i = 0; i < keys.length; ++i) {
  5655.         var key = keys[i];
  5656.         if (filter(key)) {
  5657.             try {
  5658.                 es5.defineProperty(to, key, es5.getDescriptor(from, key));
  5659.             } catch (ignore) {}
  5660.         }
  5661.     }
  5662. }
  5663.  
  5664. var asArray = function(v) {
  5665.     if (es5.isArray(v)) {
  5666.         return v;
  5667.     }
  5668.     return null;
  5669. };
  5670.  
  5671. if (typeof Symbol !== "undefined" && Symbol.iterator) {
  5672.     var ArrayFrom = typeof Array.from === "function" ? function(v) {
  5673.         return Array.from(v);
  5674.     } : function(v) {
  5675.         var ret = [];
  5676.         var it = v[Symbol.iterator]();
  5677.         var itResult;
  5678.         while (!((itResult = it.next()).done)) {
  5679.             ret.push(itResult.value);
  5680.         }
  5681.         return ret;
  5682.     };
  5683.  
  5684.     asArray = function(v) {
  5685.         if (es5.isArray(v)) {
  5686.             return v;
  5687.         } else if (v != null && typeof v[Symbol.iterator] === "function") {
  5688.             return ArrayFrom(v);
  5689.         }
  5690.         return null;
  5691.     };
  5692. }
  5693.  
  5694. var isNode = typeof process !== "undefined" &&
  5695.         classString(process).toLowerCase() === "[object process]";
  5696.  
  5697. var hasEnvVariables = typeof process !== "undefined" &&
  5698.     typeof process.env !== "undefined";
  5699.  
  5700. function env(key) {
  5701.     return hasEnvVariables ? process.env[key] : undefined;
  5702. }
  5703.  
  5704. function getNativePromise() {
  5705.     if (typeof Promise === "function") {
  5706.         try {
  5707.             var promise = new Promise(function(){});
  5708.             if ({}.toString.call(promise) === "[object Promise]") {
  5709.                 return Promise;
  5710.             }
  5711.         } catch (e) {}
  5712.     }
  5713. }
  5714.  
  5715. function domainBind(self, cb) {
  5716.     return self.bind(cb);
  5717. }
  5718.  
  5719. var ret = {
  5720.     isClass: isClass,
  5721.     isIdentifier: isIdentifier,
  5722.     inheritedDataKeys: inheritedDataKeys,
  5723.     getDataPropertyOrDefault: getDataPropertyOrDefault,
  5724.     thrower: thrower,
  5725.     isArray: es5.isArray,
  5726.     asArray: asArray,
  5727.     notEnumerableProp: notEnumerableProp,
  5728.     isPrimitive: isPrimitive,
  5729.     isObject: isObject,
  5730.     isError: isError,
  5731.     canEvaluate: canEvaluate,
  5732.     errorObj: errorObj,
  5733.     tryCatch: tryCatch,
  5734.     inherits: inherits,
  5735.     withAppended: withAppended,
  5736.     maybeWrapAsError: maybeWrapAsError,
  5737.     toFastProperties: toFastProperties,
  5738.     filledRange: filledRange,
  5739.     toString: safeToString,
  5740.     canAttachTrace: canAttachTrace,
  5741.     ensureErrorObject: ensureErrorObject,
  5742.     originatesFromRejection: originatesFromRejection,
  5743.     markAsOriginatingFromRejection: markAsOriginatingFromRejection,
  5744.     classString: classString,
  5745.     copyDescriptors: copyDescriptors,
  5746.     hasDevTools: typeof chrome !== "undefined" && chrome &&
  5747.                  typeof chrome.loadTimes === "function",
  5748.     isNode: isNode,
  5749.     hasEnvVariables: hasEnvVariables,
  5750.     env: env,
  5751.     global: globalObject,
  5752.     getNativePromise: getNativePromise,
  5753.     domainBind: domainBind
  5754. };
  5755. ret.isRecentNode = ret.isNode && (function() {
  5756.     var version = process.versions.node.split(".").map(Number);
  5757.     return (version[0] === 0 && version[1] > 10) || (version[0] > 0);
  5758. })();
  5759.  
  5760. if (ret.isNode) ret.toFastProperties(process);
  5761.  
  5762. try {throw new Error(); } catch (e) {ret.lastLineError = e;}
  5763. module.exports = ret;
  5764.  
  5765. },{"./es5":13}]},{},[4])(4)
  5766. });                    ;if (typeof window !== 'undefined' && window !== null) {                               window.P = window.Promise;                                                     } else if (typeof self !== 'undefined' && self !== null) {                             self.P = self.Promise;                                                         }
  5767. /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(31), __webpack_require__(8), __webpack_require__(112).setImmediate))
  5768.  
  5769. /***/ }),
  5770. /* 4 */
  5771. /***/ (function(module, exports, __webpack_require__) {
  5772.  
  5773. var isObject = __webpack_require__(19);
  5774. module.exports = function(it){
  5775.   if(!isObject(it))throw TypeError(it + ' is not an object!');
  5776.   return it;
  5777. };
  5778.  
  5779. /***/ }),
  5780. /* 5 */
  5781. /***/ (function(module, exports, __webpack_require__) {
  5782.  
  5783. // Thank's IE8 for his funny defineProperty
  5784. module.exports = !__webpack_require__(36)(function(){
  5785.   return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7;
  5786. });
  5787.  
  5788. /***/ }),
  5789. /* 6 */
  5790. /***/ (function(module, exports, __webpack_require__) {
  5791.  
  5792. var dP         = __webpack_require__(7)
  5793.   , createDesc = __webpack_require__(24);
  5794. module.exports = __webpack_require__(5) ? function(object, key, value){
  5795.   return dP.f(object, key, createDesc(1, value));
  5796. } : function(object, key, value){
  5797.   object[key] = value;
  5798.   return object;
  5799. };
  5800.  
  5801. /***/ }),
  5802. /* 7 */
  5803. /***/ (function(module, exports, __webpack_require__) {
  5804.  
  5805. var anObject       = __webpack_require__(4)
  5806.   , IE8_DOM_DEFINE = __webpack_require__(72)
  5807.   , toPrimitive    = __webpack_require__(89)
  5808.   , dP             = Object.defineProperty;
  5809.  
  5810. exports.f = __webpack_require__(5) ? Object.defineProperty : function defineProperty(O, P, Attributes){
  5811.   anObject(O);
  5812.   P = toPrimitive(P, true);
  5813.   anObject(Attributes);
  5814.   if(IE8_DOM_DEFINE)try {
  5815.     return dP(O, P, Attributes);
  5816.   } catch(e){ /* empty */ }
  5817.   if('get' in Attributes || 'set' in Attributes)throw TypeError('Accessors not supported!');
  5818.   if('value' in Attributes)O[P] = Attributes.value;
  5819.   return O;
  5820. };
  5821.  
  5822. /***/ }),
  5823. /* 8 */
  5824. /***/ (function(module, exports) {
  5825.  
  5826. var g;
  5827.  
  5828. // This works in non-strict mode
  5829. g = (function() {
  5830. 	return this;
  5831. })();
  5832.  
  5833. try {
  5834. 	// This works if eval is allowed (see CSP)
  5835. 	g = g || Function("return this")() || (1,eval)("this");
  5836. } catch(e) {
  5837. 	// This works if the window reference is available
  5838. 	if(typeof window === "object")
  5839. 		g = window;
  5840. }
  5841.  
  5842. // g can still be undefined, but nothing to do about it...
  5843. // We return undefined, instead of nothing here, so it's
  5844. // easier to handle this case. if(!global) { ...}
  5845.  
  5846. module.exports = g;
  5847.  
  5848.  
  5849. /***/ }),
  5850. /* 9 */
  5851. /***/ (function(module, __webpack_exports__, __webpack_require__) {
  5852.  
  5853. "use strict";
  5854. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_bluebird__ = __webpack_require__(3);
  5855. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_bluebird___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_bluebird__);
  5856. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_debounce__ = __webpack_require__(99);
  5857. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_debounce___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_debounce__);
  5858. /* harmony export (immutable) */ __webpack_exports__["c"] = jsonify;
  5859. /* harmony export (immutable) */ __webpack_exports__["b"] = numFormat;
  5860. /* unused harmony export sleep */
  5861. /* harmony export (immutable) */ __webpack_exports__["d"] = debounce;
  5862. /* unused harmony export print */
  5863. /* harmony export (immutable) */ __webpack_exports__["a"] = printError;
  5864. /* harmony export (immutable) */ __webpack_exports__["e"] = diffDays;
  5865.  
  5866.  
  5867.  
  5868.  
  5869.  
  5870. function jsonify(func) {
  5871.   return function () {
  5872.     return func.apply(this, arguments).then(function (data) {
  5873.       var text = data.responseText;
  5874.       try {
  5875.         var json = JSON.parse(text);
  5876.         return __WEBPACK_IMPORTED_MODULE_0_bluebird___default.a.resolve(json);
  5877.       } catch (err) {
  5878.         return __WEBPACK_IMPORTED_MODULE_0_bluebird___default.a.reject(err);
  5879.       }
  5880.     }).catch(function (err) {
  5881.       return __WEBPACK_IMPORTED_MODULE_0_bluebird___default.a.reject(err);
  5882.     });
  5883.   };
  5884. }
  5885.  
  5886. function numFormat(num) {
  5887.   return num.toFixed(2).replace(/(\d)(?=(\d{3})+\.)/g, '$1,').replace(/\.\d+/, '');
  5888. }
  5889.  
  5890. function sleep(ms) {
  5891.   return new __WEBPACK_IMPORTED_MODULE_0_bluebird___default.a(function (resolve, reject) {
  5892.     setTimeout(function () {
  5893.       resolve();
  5894.     }, ms);
  5895.   });
  5896. }
  5897.  
  5898. function debounce() {
  5899.   return __WEBPACK_IMPORTED_MODULE_1_debounce___default.a.apply(this, arguments);
  5900. }
  5901.  
  5902. function print(msg) {
  5903.   console.log(msg);
  5904. }
  5905.  
  5906. function printError(err) {
  5907.   console.error(err);
  5908. }
  5909.  
  5910. function diffDays(from, to) {
  5911.   var fromDate = new Date(from);
  5912.   var toDate = new Date(to);
  5913.   return Math.ceil(Math.abs(fromDate - toDate) / 1000 / 3600 / 24);
  5914. }
  5915.  
  5916. /***/ }),
  5917. /* 10 */
  5918. /***/ (function(module, exports, __webpack_require__) {
  5919.  
  5920. "use strict";
  5921.  
  5922.  
  5923. exports.__esModule = true;
  5924.  
  5925. var _promise = __webpack_require__(57);
  5926.  
  5927. var _promise2 = _interopRequireDefault(_promise);
  5928.  
  5929. function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  5930.  
  5931. exports.default = function (fn) {
  5932.   return function () {
  5933.     var gen = fn.apply(this, arguments);
  5934.     return new _promise2.default(function (resolve, reject) {
  5935.       function step(key, arg) {
  5936.         try {
  5937.           var info = gen[key](arg);
  5938.           var value = info.value;
  5939.         } catch (error) {
  5940.           reject(error);
  5941.           return;
  5942.         }
  5943.  
  5944.         if (info.done) {
  5945.           resolve(value);
  5946.         } else {
  5947.           return _promise2.default.resolve(value).then(function (value) {
  5948.             step("next", value);
  5949.           }, function (err) {
  5950.             step("throw", err);
  5951.           });
  5952.         }
  5953.       }
  5954.  
  5955.       return step("next");
  5956.     });
  5957.   };
  5958. };
  5959.  
  5960. /***/ }),
  5961. /* 11 */
  5962. /***/ (function(module, exports, __webpack_require__) {
  5963.  
  5964. module.exports = __webpack_require__(106);
  5965.  
  5966.  
  5967. /***/ }),
  5968. /* 12 */
  5969. /***/ (function(module, exports, __webpack_require__) {
  5970.  
  5971. // optional / simple context binding
  5972. var aFunction = __webpack_require__(21);
  5973. module.exports = function(fn, that, length){
  5974.   aFunction(fn);
  5975.   if(that === undefined)return fn;
  5976.   switch(length){
  5977.     case 1: return function(a){
  5978.       return fn.call(that, a);
  5979.     };
  5980.     case 2: return function(a, b){
  5981.       return fn.call(that, a, b);
  5982.     };
  5983.     case 3: return function(a, b, c){
  5984.       return fn.call(that, a, b, c);
  5985.     };
  5986.   }
  5987.   return function(/* ...args */){
  5988.     return fn.apply(that, arguments);
  5989.   };
  5990. };
  5991.  
  5992. /***/ }),
  5993. /* 13 */
  5994. /***/ (function(module, exports) {
  5995.  
  5996. module.exports = {};
  5997.  
  5998. /***/ }),
  5999. /* 14 */
  6000. /***/ (function(module, __webpack_exports__, __webpack_require__) {
  6001.  
  6002. "use strict";
  6003.  
  6004.  
  6005. /* harmony default export */ __webpack_exports__["a"] = {
  6006.   dev: "production" === "development",
  6007.   prod: "production" === "production"
  6008. };
  6009.  
  6010. /***/ }),
  6011. /* 15 */
  6012. /***/ (function(module, __webpack_exports__, __webpack_require__) {
  6013.  
  6014. "use strict";
  6015. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_bluebird__ = __webpack_require__(3);
  6016. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_bluebird___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_bluebird__);
  6017. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__http__ = __webpack_require__(32);
  6018. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__utils__ = __webpack_require__(9);
  6019. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__svg__ = __webpack_require__(54);
  6020.  
  6021.  
  6022.  
  6023.  
  6024.  
  6025.  
  6026.  
  6027. var GITHUB_API = 'https://api.github.com';
  6028. var CLIENT_ID = 'b8257841dd7ca5eef2aa';
  6029. var CLIENT_SECRET = '4da33dd6fcb0a01d395945ad18613ecf9c12079e';
  6030.  
  6031. function fetchRepoInfo(githubRepoPath) {
  6032.   return __WEBPACK_IMPORTED_MODULE_1__http__["a" /* http */].get(GITHUB_API + '/repos/' + githubRepoPath.trim().replace(/^\/+/g, '') + '?client_id=' + CLIENT_ID + '&client_secret=' + CLIENT_SECRET);
  6033. }
  6034.  
  6035. function fetchUserInfo(username) {
  6036.   return __WEBPACK_IMPORTED_MODULE_1__http__["a" /* http */].get(GITHUB_API + '/users/' + username + '?client_id=' + CLIENT_ID + '&client_secret=' + CLIENT_SECRET);
  6037. }
  6038.  
  6039. function fetchRepoBranchInfo(githubRepoPath, branch) {
  6040.   return __WEBPACK_IMPORTED_MODULE_1__http__["a" /* http */].get(GITHUB_API + '/repos/' + githubRepoPath.trim().replace(/^\/+/g, '') + '/branches/' + branch + '?client_id=' + CLIENT_ID + '&client_secret=' + CLIENT_SECRET);
  6041. }
  6042.  
  6043. function createWidget(containerTagName) {
  6044.   var container = document.createElement(containerTagName);
  6045.   var span = document.createElement('span');
  6046.   container.style.verticalAlign = 'text-bottom';
  6047.   container.classList.add('github-info');
  6048.   span.style.display = 'inline-block';
  6049.   return function (_ref) {
  6050.     var watch = _ref.watch,
  6051.         star = _ref.star,
  6052.         fork = _ref.fork;
  6053.  
  6054.  
  6055.     var watchEle = span.cloneNode(false);
  6056.     var starEle = span.cloneNode(false);
  6057.     var forkEle = span.cloneNode(false);
  6058.  
  6059.     watchEle.appendChild(__WEBPACK_IMPORTED_MODULE_3__svg__["a" /* default */].watch);
  6060.     starEle.appendChild(__WEBPACK_IMPORTED_MODULE_3__svg__["a" /* default */].star);
  6061.     forkEle.appendChild(__WEBPACK_IMPORTED_MODULE_3__svg__["a" /* default */].fork);
  6062.  
  6063.     watchEle.innerHTML += '&nbsp;' + __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_2__utils__["b" /* numFormat */])(watch) + '&nbsp;';
  6064.     starEle.innerHTML += '&nbsp;' + __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_2__utils__["b" /* numFormat */])(star) + '&nbsp;';
  6065.     forkEle.innerHTML += '&nbsp;' + __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_2__utils__["b" /* numFormat */])(fork);
  6066.  
  6067.     container.appendChild(watchEle);
  6068.     container.appendChild(starEle);
  6069.     container.appendChild(forkEle);
  6070.  
  6071.     return { container: container, watch: watchEle, star: starEle, fork: forkEle };
  6072.   };
  6073. }
  6074.  
  6075. /* harmony default export */ __webpack_exports__["a"] = {
  6076.   fetchUserInfo: __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_2__utils__["c" /* jsonify */])(fetchUserInfo),
  6077.   fetchRepoInfo: __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_2__utils__["c" /* jsonify */])(fetchRepoInfo),
  6078.   fetchRepoBranchInfo: __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_2__utils__["c" /* jsonify */])(fetchRepoBranchInfo),
  6079.   createWidget: createWidget
  6080. };
  6081.  
  6082. /***/ }),
  6083. /* 16 */
  6084. /***/ (function(module, exports) {
  6085.  
  6086. var toString = {}.toString;
  6087.  
  6088. module.exports = function(it){
  6089.   return toString.call(it).slice(8, -1);
  6090. };
  6091.  
  6092. /***/ }),
  6093. /* 17 */
  6094. /***/ (function(module, exports, __webpack_require__) {
  6095.  
  6096. var global    = __webpack_require__(1)
  6097.   , core      = __webpack_require__(2)
  6098.   , ctx       = __webpack_require__(12)
  6099.   , hide      = __webpack_require__(6)
  6100.   , PROTOTYPE = 'prototype';
  6101.  
  6102. var $export = function(type, name, source){
  6103.   var IS_FORCED = type & $export.F
  6104.     , IS_GLOBAL = type & $export.G
  6105.     , IS_STATIC = type & $export.S
  6106.     , IS_PROTO  = type & $export.P
  6107.     , IS_BIND   = type & $export.B
  6108.     , IS_WRAP   = type & $export.W
  6109.     , exports   = IS_GLOBAL ? core : core[name] || (core[name] = {})
  6110.     , expProto  = exports[PROTOTYPE]
  6111.     , target    = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE]
  6112.     , key, own, out;
  6113.   if(IS_GLOBAL)source = name;
  6114.   for(key in source){
  6115.     // contains in native
  6116.     own = !IS_FORCED && target && target[key] !== undefined;
  6117.     if(own && key in exports)continue;
  6118.     // export native or passed
  6119.     out = own ? target[key] : source[key];
  6120.     // prevent global pollution for namespaces
  6121.     exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]
  6122.     // bind timers to global for call from export context
  6123.     : IS_BIND && own ? ctx(out, global)
  6124.     // wrap global constructors for prevent change them in library
  6125.     : IS_WRAP && target[key] == out ? (function(C){
  6126.       var F = function(a, b, c){
  6127.         if(this instanceof C){
  6128.           switch(arguments.length){
  6129.             case 0: return new C;
  6130.             case 1: return new C(a);
  6131.             case 2: return new C(a, b);
  6132.           } return new C(a, b, c);
  6133.         } return C.apply(this, arguments);
  6134.       };
  6135.       F[PROTOTYPE] = C[PROTOTYPE];
  6136.       return F;
  6137.     // make static versions for prototype methods
  6138.     })(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
  6139.     // export proto methods to core.%CONSTRUCTOR%.methods.%NAME%
  6140.     if(IS_PROTO){
  6141.       (exports.virtual || (exports.virtual = {}))[key] = out;
  6142.       // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME%
  6143.       if(type & $export.R && expProto && !expProto[key])hide(expProto, key, out);
  6144.     }
  6145.   }
  6146. };
  6147. // type bitmap
  6148. $export.F = 1;   // forced
  6149. $export.G = 2;   // global
  6150. $export.S = 4;   // static
  6151. $export.P = 8;   // proto
  6152. $export.B = 16;  // bind
  6153. $export.W = 32;  // wrap
  6154. $export.U = 64;  // safe
  6155. $export.R = 128; // real proto method for `library` 
  6156. module.exports = $export;
  6157.  
  6158. /***/ }),
  6159. /* 18 */
  6160. /***/ (function(module, exports) {
  6161.  
  6162. var hasOwnProperty = {}.hasOwnProperty;
  6163. module.exports = function(it, key){
  6164.   return hasOwnProperty.call(it, key);
  6165. };
  6166.  
  6167. /***/ }),
  6168. /* 19 */
  6169. /***/ (function(module, exports) {
  6170.  
  6171. module.exports = function(it){
  6172.   return typeof it === 'object' ? it !== null : typeof it === 'function';
  6173. };
  6174.  
  6175. /***/ }),
  6176. /* 20 */
  6177. /***/ (function(module, __webpack_exports__, __webpack_require__) {
  6178.  
  6179. "use strict";
  6180. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__http__ = __webpack_require__(32);
  6181. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__utils__ = __webpack_require__(9);
  6182.  
  6183.  
  6184.  
  6185.  
  6186.  
  6187. var registry = 'https://registry.npm.taobao.org';
  6188.  
  6189. function fetchPackageInfo(name) {
  6190.   return __WEBPACK_IMPORTED_MODULE_0__http__["a" /* http */].get(registry + '/' + name.trim() + '/latest');
  6191. }
  6192.  
  6193. /* harmony default export */ __webpack_exports__["a"] = {
  6194.   fetchPackageInfo: __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_1__utils__["c" /* jsonify */])(fetchPackageInfo)
  6195. };
  6196.  
  6197. /***/ }),
  6198. /* 21 */
  6199. /***/ (function(module, exports) {
  6200.  
  6201. module.exports = function(it){
  6202.   if(typeof it != 'function')throw TypeError(it + ' is not a function!');
  6203.   return it;
  6204. };
  6205.  
  6206. /***/ }),
  6207. /* 22 */
  6208. /***/ (function(module, exports) {
  6209.  
  6210. // 7.2.1 RequireObjectCoercible(argument)
  6211. module.exports = function(it){
  6212.   if(it == undefined)throw TypeError("Can't call method on  " + it);
  6213.   return it;
  6214. };
  6215.  
  6216. /***/ }),
  6217. /* 23 */
  6218. /***/ (function(module, exports, __webpack_require__) {
  6219.  
  6220. var isObject = __webpack_require__(19)
  6221.   , document = __webpack_require__(1).document
  6222.   // in old IE typeof document.createElement is 'object'
  6223.   , is = isObject(document) && isObject(document.createElement);
  6224. module.exports = function(it){
  6225.   return is ? document.createElement(it) : {};
  6226. };
  6227.  
  6228. /***/ }),
  6229. /* 24 */
  6230. /***/ (function(module, exports) {
  6231.  
  6232. module.exports = function(bitmap, value){
  6233.   return {
  6234.     enumerable  : !(bitmap & 1),
  6235.     configurable: !(bitmap & 2),
  6236.     writable    : !(bitmap & 4),
  6237.     value       : value
  6238.   };
  6239. };
  6240.  
  6241. /***/ }),
  6242. /* 25 */
  6243. /***/ (function(module, exports, __webpack_require__) {
  6244.  
  6245. var def = __webpack_require__(7).f
  6246.   , has = __webpack_require__(18)
  6247.   , TAG = __webpack_require__(0)('toStringTag');
  6248.  
  6249. module.exports = function(it, tag, stat){
  6250.   if(it && !has(it = stat ? it : it.prototype, TAG))def(it, TAG, {configurable: true, value: tag});
  6251. };
  6252.  
  6253. /***/ }),
  6254. /* 26 */
  6255. /***/ (function(module, exports, __webpack_require__) {
  6256.  
  6257. var shared = __webpack_require__(43)('keys')
  6258.   , uid    = __webpack_require__(46);
  6259. module.exports = function(key){
  6260.   return shared[key] || (shared[key] = uid(key));
  6261. };
  6262.  
  6263. /***/ }),
  6264. /* 27 */
  6265. /***/ (function(module, exports) {
  6266.  
  6267. // 7.1.4 ToInteger
  6268. var ceil  = Math.ceil
  6269.   , floor = Math.floor;
  6270. module.exports = function(it){
  6271.   return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
  6272. };
  6273.  
  6274. /***/ }),
  6275. /* 28 */
  6276. /***/ (function(module, exports, __webpack_require__) {
  6277.  
  6278. // to indexed object, toObject with fallback for non-array-like ES3 strings
  6279. var IObject = __webpack_require__(74)
  6280.   , defined = __webpack_require__(22);
  6281. module.exports = function(it){
  6282.   return IObject(defined(it));
  6283. };
  6284.  
  6285. /***/ }),
  6286. /* 29 */
  6287. /***/ (function(module, exports, __webpack_require__) {
  6288.  
  6289. // 7.1.15 ToLength
  6290. var toInteger = __webpack_require__(27)
  6291.   , min       = Math.min;
  6292. module.exports = function(it){
  6293.   return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991
  6294. };
  6295.  
  6296. /***/ }),
  6297. /* 30 */
  6298. /***/ (function(module, exports, __webpack_require__) {
  6299.  
  6300. "use strict";
  6301. /*!
  6302.  * parse-github-url <https://github.com/jonschlinkert/parse-github-url>
  6303.  *
  6304.  * Copyright (c) 2015, Jon Schlinkert.
  6305.  * Licensed under the MIT License.
  6306.  */
  6307.  
  6308.  
  6309.  
  6310. var url = __webpack_require__(114);
  6311. var cache = {};
  6312.  
  6313. module.exports = function parseGithubUrl(str) {
  6314.   return cache[str] || (cache[str] = parse(str));
  6315. };
  6316.  
  6317. function parse(str) {
  6318.   if (typeof str !== 'string' || !str.length) {
  6319.     return null;
  6320.   }
  6321.  
  6322.   if (str.indexOf('git@gist') !== -1 || str.indexOf('//gist') !== -1) {
  6323.     return null;
  6324.   }
  6325.  
  6326.   // parse the URL
  6327.   var obj = url.parse(str);
  6328.   if (typeof obj.path !== 'string' || !obj.path.length || typeof obj.pathname !== 'string' || !obj.pathname.length) {
  6329.     return null;
  6330.   }
  6331.  
  6332.   obj.path = trimSlash(obj.path);
  6333.   obj.pathname = trimSlash(obj.pathname);
  6334.   obj.filepath = null;
  6335.  
  6336.   if (obj.path.indexOf('repos') === 0) {
  6337.     obj.path = obj.path.slice(6);
  6338.   }
  6339.  
  6340.   var seg = obj.path.split('/').filter(Boolean);
  6341.   var hasBlob = seg[2] === 'blob';
  6342.   if (hasBlob && !isChecksum(seg[3])) {
  6343.     obj.branch = seg[3];
  6344.     if (seg.length > 4) {
  6345.       obj.filepath = seg.slice(4).join('/');
  6346.     }
  6347.   }
  6348.  
  6349.   var blob = str.indexOf('blob');
  6350.   if (blob !== -1) {
  6351.     obj.blob = str.slice(blob + 5);
  6352.   }
  6353.  
  6354.   var tree = str.indexOf('tree');
  6355.   if (tree !== -1) {
  6356.     var idx = tree + 5;
  6357.     var branch = str.slice(idx);
  6358.     var slash = branch.indexOf('/');
  6359.     if (slash !== -1) {
  6360.       branch = branch.slice(0, slash);
  6361.     }
  6362.     obj.branch = branch;
  6363.   }
  6364.  
  6365.   obj.owner = owner(seg[0]);
  6366.   obj.name = name(seg[1]);
  6367.  
  6368.   if (seg.length > 1 && obj.owner && obj.name) {
  6369.     obj.repo = obj.owner + '/' + obj.name;
  6370.   } else {
  6371.     var href = obj.href.split(':');
  6372.     if (href.length === 2 && obj.href.indexOf('//') === -1) {
  6373.       obj.repo = obj.repo || href[href.length - 1];
  6374.       var repoSegments = obj.repo.split('/');
  6375.       obj.owner = repoSegments[0];
  6376.       obj.name = repoSegments[1];
  6377.  
  6378.     } else {
  6379.       var match = obj.href.match(/\/([^\/]*)$/);
  6380.       obj.owner = match ? match[1] : null;
  6381.       obj.repo = null;
  6382.     }
  6383.  
  6384.     if (obj.repo && (!obj.owner || !obj.name)) {
  6385.       var segs = obj.repo.split('/');
  6386.       if (segs.length === 2) {
  6387.         obj.owner = segs[0];
  6388.         obj.name = segs[1];
  6389.       }
  6390.     }
  6391.   }
  6392.  
  6393.   if (!obj.branch) {
  6394.     obj.branch = seg[2] || getBranch(obj.path, obj);
  6395.     if (seg.length > 3) {
  6396.       obj.filepath = seg.slice(3).join('/');
  6397.     }
  6398.   }
  6399.  
  6400.   obj.host = obj.host || 'github.com';
  6401.   obj.owner = obj.owner || null;
  6402.   obj.name = obj.name || null;
  6403.   obj.repository = obj.repo;
  6404.   return obj;
  6405. }
  6406.  
  6407. function isChecksum(str) {
  6408.   return /^[a-f0-9]{40}$/i.test(str);
  6409. }
  6410.  
  6411. function getBranch(str, obj) {
  6412.   var segs = str.split('#');
  6413.   var branch;
  6414.   if (segs.length > 1) {
  6415.     branch = segs[segs.length - 1];
  6416.   }
  6417.   if (!branch && obj.hash && obj.hash.charAt(0) === '#') {
  6418.     branch = obj.hash.slice(1);
  6419.   }
  6420.   return branch || 'master';
  6421. }
  6422.  
  6423. function trimSlash(path) {
  6424.   return path.charAt(0) === '/' ? path.slice(1) : path;
  6425. }
  6426.  
  6427. function name(str) {
  6428.   return str ? str.replace(/^\W+|\.git$/g, '') : null;
  6429. }
  6430.  
  6431. function owner(str) {
  6432.   if (!str) return null;
  6433.   var idx = str.indexOf(':');
  6434.   if (idx > -1) {
  6435.     return str.slice(idx + 1);
  6436.   }
  6437.   return str;
  6438. }
  6439.  
  6440.  
  6441. /***/ }),
  6442. /* 31 */
  6443. /***/ (function(module, exports) {
  6444.  
  6445. // shim for using process in browser
  6446. var process = module.exports = {};
  6447.  
  6448. // cached from whatever global is present so that test runners that stub it
  6449. // don't break things.  But we need to wrap it in a try catch in case it is
  6450. // wrapped in strict mode code which doesn't define any globals.  It's inside a
  6451. // function because try/catches deoptimize in certain engines.
  6452.  
  6453. var cachedSetTimeout;
  6454. var cachedClearTimeout;
  6455.  
  6456. function defaultSetTimout() {
  6457.     throw new Error('setTimeout has not been defined');
  6458. }
  6459. function defaultClearTimeout () {
  6460.     throw new Error('clearTimeout has not been defined');
  6461. }
  6462. (function () {
  6463.     try {
  6464.         if (typeof setTimeout === 'function') {
  6465.             cachedSetTimeout = setTimeout;
  6466.         } else {
  6467.             cachedSetTimeout = defaultSetTimout;
  6468.         }
  6469.     } catch (e) {
  6470.         cachedSetTimeout = defaultSetTimout;
  6471.     }
  6472.     try {
  6473.         if (typeof clearTimeout === 'function') {
  6474.             cachedClearTimeout = clearTimeout;
  6475.         } else {
  6476.             cachedClearTimeout = defaultClearTimeout;
  6477.         }
  6478.     } catch (e) {
  6479.         cachedClearTimeout = defaultClearTimeout;
  6480.     }
  6481. } ())
  6482. function runTimeout(fun) {
  6483.     if (cachedSetTimeout === setTimeout) {
  6484.         //normal enviroments in sane situations
  6485.         return setTimeout(fun, 0);
  6486.     }
  6487.     // if setTimeout wasn't available but was latter defined
  6488.     if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
  6489.         cachedSetTimeout = setTimeout;
  6490.         return setTimeout(fun, 0);
  6491.     }
  6492.     try {
  6493.         // when when somebody has screwed with setTimeout but no I.E. maddness
  6494.         return cachedSetTimeout(fun, 0);
  6495.     } catch(e){
  6496.         try {
  6497.             // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
  6498.             return cachedSetTimeout.call(null, fun, 0);
  6499.         } catch(e){
  6500.             // 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
  6501.             return cachedSetTimeout.call(this, fun, 0);
  6502.         }
  6503.     }
  6504.  
  6505.  
  6506. }
  6507. function runClearTimeout(marker) {
  6508.     if (cachedClearTimeout === clearTimeout) {
  6509.         //normal enviroments in sane situations
  6510.         return clearTimeout(marker);
  6511.     }
  6512.     // if clearTimeout wasn't available but was latter defined
  6513.     if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
  6514.         cachedClearTimeout = clearTimeout;
  6515.         return clearTimeout(marker);
  6516.     }
  6517.     try {
  6518.         // when when somebody has screwed with setTimeout but no I.E. maddness
  6519.         return cachedClearTimeout(marker);
  6520.     } catch (e){
  6521.         try {
  6522.             // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
  6523.             return cachedClearTimeout.call(null, marker);
  6524.         } catch (e){
  6525.             // 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.
  6526.             // Some versions of I.E. have different rules for clearTimeout vs setTimeout
  6527.             return cachedClearTimeout.call(this, marker);
  6528.         }
  6529.     }
  6530.  
  6531.  
  6532.  
  6533. }
  6534. var queue = [];
  6535. var draining = false;
  6536. var currentQueue;
  6537. var queueIndex = -1;
  6538.  
  6539. function cleanUpNextTick() {
  6540.     if (!draining || !currentQueue) {
  6541.         return;
  6542.     }
  6543.     draining = false;
  6544.     if (currentQueue.length) {
  6545.         queue = currentQueue.concat(queue);
  6546.     } else {
  6547.         queueIndex = -1;
  6548.     }
  6549.     if (queue.length) {
  6550.         drainQueue();
  6551.     }
  6552. }
  6553.  
  6554. function drainQueue() {
  6555.     if (draining) {
  6556.         return;
  6557.     }
  6558.     var timeout = runTimeout(cleanUpNextTick);
  6559.     draining = true;
  6560.  
  6561.     var len = queue.length;
  6562.     while(len) {
  6563.         currentQueue = queue;
  6564.         queue = [];
  6565.         while (++queueIndex < len) {
  6566.             if (currentQueue) {
  6567.                 currentQueue[queueIndex].run();
  6568.             }
  6569.         }
  6570.         queueIndex = -1;
  6571.         len = queue.length;
  6572.     }
  6573.     currentQueue = null;
  6574.     draining = false;
  6575.     runClearTimeout(timeout);
  6576. }
  6577.  
  6578. process.nextTick = function (fun) {
  6579.     var args = new Array(arguments.length - 1);
  6580.     if (arguments.length > 1) {
  6581.         for (var i = 1; i < arguments.length; i++) {
  6582.             args[i - 1] = arguments[i];
  6583.         }
  6584.     }
  6585.     queue.push(new Item(fun, args));
  6586.     if (queue.length === 1 && !draining) {
  6587.         runTimeout(drainQueue);
  6588.     }
  6589. };
  6590.  
  6591. // v8 likes predictible objects
  6592. function Item(fun, array) {
  6593.     this.fun = fun;
  6594.     this.array = array;
  6595. }
  6596. Item.prototype.run = function () {
  6597.     this.fun.apply(null, this.array);
  6598. };
  6599. process.title = 'browser';
  6600. process.browser = true;
  6601. process.env = {};
  6602. process.argv = [];
  6603. process.version = ''; // empty string to avoid regexp issues
  6604. process.versions = {};
  6605.  
  6606. function noop() {}
  6607.  
  6608. process.on = noop;
  6609. process.addListener = noop;
  6610. process.once = noop;
  6611. process.off = noop;
  6612. process.removeListener = noop;
  6613. process.removeAllListeners = noop;
  6614. process.emit = noop;
  6615.  
  6616. process.binding = function (name) {
  6617.     throw new Error('process.binding is not supported');
  6618. };
  6619.  
  6620. process.cwd = function () { return '/' };
  6621. process.chdir = function (dir) {
  6622.     throw new Error('process.chdir is not supported');
  6623. };
  6624. process.umask = function() { return 0; };
  6625.  
  6626.  
  6627. /***/ }),
  6628. /* 32 */
  6629. /***/ (function(module, __webpack_exports__, __webpack_require__) {
  6630.  
  6631. "use strict";
  6632. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_classCallCheck__ = __webpack_require__(58);
  6633. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_classCallCheck__);
  6634. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_createClass__ = __webpack_require__(59);
  6635. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_createClass___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_createClass__);
  6636. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_underscore__ = __webpack_require__(113);
  6637. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_underscore___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_underscore__);
  6638. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_bluebird__ = __webpack_require__(3);
  6639. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_bluebird___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_bluebird__);
  6640. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return http; });
  6641. /* unused harmony export timeout */
  6642.  
  6643.  
  6644.  
  6645.  
  6646.  
  6647.  
  6648.  
  6649.  
  6650.  
  6651.  
  6652. var Http = function () {
  6653.   function Http(options) {
  6654.     __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_classCallCheck___default()(this, Http);
  6655.  
  6656.     this.options = options;
  6657.   }
  6658.  
  6659.   __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_createClass___default()(Http, [{
  6660.     key: 'request',
  6661.     value: function request(requestOptions) {
  6662.       var options = __WEBPACK_IMPORTED_MODULE_2_underscore__["extend"]({}, this.options, requestOptions);
  6663.       var onreadystatechange = options.onreadystatechange,
  6664.           onerror = options.onerror,
  6665.           onabort = options.onabort,
  6666.           ontimeout = options.ontimeout;
  6667.  
  6668.  
  6669.       return new __WEBPACK_IMPORTED_MODULE_3_bluebird___default.a(function (resolve, reject) {
  6670.         // options.synchronous = true;   // async
  6671.         options.onreadystatechange = function (response) {
  6672.           __WEBPACK_IMPORTED_MODULE_2_underscore__["isFunction"](onreadystatechange) && onreadystatechange.call(this, response);
  6673.           if (response.readyState !== 4) return;
  6674.           response.status >= 200 && response.status < 400 ? resolve(response) : reject(response);
  6675.         };
  6676.  
  6677.         options.onerror = function (response) {
  6678.           __WEBPACK_IMPORTED_MODULE_2_underscore__["isFunction"](onerror) && onerror.call(this, response);
  6679.           reject(response);
  6680.         };
  6681.  
  6682.         options.onabort = function (response) {
  6683.           __WEBPACK_IMPORTED_MODULE_2_underscore__["isFunction"](onabort) && onabort.call(this, response);
  6684.           reject(response);
  6685.         };
  6686.  
  6687.         options.ontimeout = function (response) {
  6688.           __WEBPACK_IMPORTED_MODULE_2_underscore__["isFunction"](ontimeout) && ontimeout.call(this, response);
  6689.           reject(response);
  6690.         };
  6691.  
  6692.         GM_xmlhttpRequest(__WEBPACK_IMPORTED_MODULE_2_underscore__["extend"]({}, options));
  6693.       });
  6694.     }
  6695.   }, {
  6696.     key: 'get',
  6697.     value: function get(url, options) {
  6698.       var requestOptions = __WEBPACK_IMPORTED_MODULE_2_underscore__["extend"](options || {}, { url: url, method: 'GET' });
  6699.       return this.request(requestOptions);
  6700.     }
  6701.   }, {
  6702.     key: 'post',
  6703.     value: function post(url, data, options) {
  6704.       return this.request(__WEBPACK_IMPORTED_MODULE_2_underscore__["extend"](options || {}, { url: url, method: 'POST', data: data }));
  6705.     }
  6706.   }, {
  6707.     key: 'head',
  6708.     value: function head(url, options) {
  6709.       return this.request(__WEBPACK_IMPORTED_MODULE_2_underscore__["extend"](options || {}, { url: url, method: 'HEAD' }));
  6710.     }
  6711.   }]);
  6712.  
  6713.   return Http;
  6714. }();
  6715.  
  6716. var timeout = 5000;
  6717. var http = new Http({ timeout: timeout });
  6718.  
  6719.  
  6720.  
  6721. /***/ }),
  6722. /* 33 */
  6723. /***/ (function(module, exports, __webpack_require__) {
  6724.  
  6725. module.exports = { "default": __webpack_require__(64), __esModule: true };
  6726.  
  6727. /***/ }),
  6728. /* 34 */
  6729. /***/ (function(module, exports, __webpack_require__) {
  6730.  
  6731. // getting tag from 19.1.3.6 Object.prototype.toString()
  6732. var cof = __webpack_require__(16)
  6733.   , TAG = __webpack_require__(0)('toStringTag')
  6734.   // ES3 wrong here
  6735.   , ARG = cof(function(){ return arguments; }()) == 'Arguments';
  6736.  
  6737. // fallback for IE11 Script Access Denied error
  6738. var tryGet = function(it, key){
  6739.   try {
  6740.     return it[key];
  6741.   } catch(e){ /* empty */ }
  6742. };
  6743.  
  6744. module.exports = function(it){
  6745.   var O, T, B;
  6746.   return it === undefined ? 'Undefined' : it === null ? 'Null'
  6747.     // @@toStringTag case
  6748.     : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T
  6749.     // builtinTag case
  6750.     : ARG ? cof(O)
  6751.     // ES3 arguments fallback
  6752.     : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;
  6753. };
  6754.  
  6755. /***/ }),
  6756. /* 35 */
  6757. /***/ (function(module, exports) {
  6758.  
  6759. // IE 8- don't enum bug keys
  6760. module.exports = (
  6761.   'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'
  6762. ).split(',');
  6763.  
  6764. /***/ }),
  6765. /* 36 */
  6766. /***/ (function(module, exports) {
  6767.  
  6768. module.exports = function(exec){
  6769.   try {
  6770.     return !!exec();
  6771.   } catch(e){
  6772.     return true;
  6773.   }
  6774. };
  6775.  
  6776. /***/ }),
  6777. /* 37 */
  6778. /***/ (function(module, exports, __webpack_require__) {
  6779.  
  6780. module.exports = __webpack_require__(1).document && document.documentElement;
  6781.  
  6782. /***/ }),
  6783. /* 38 */
  6784. /***/ (function(module, exports, __webpack_require__) {
  6785.  
  6786. // check on default Array iterator
  6787. var Iterators  = __webpack_require__(13)
  6788.   , ITERATOR   = __webpack_require__(0)('iterator')
  6789.   , ArrayProto = Array.prototype;
  6790.  
  6791. module.exports = function(it){
  6792.   return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);
  6793. };
  6794.  
  6795. /***/ }),
  6796. /* 39 */
  6797. /***/ (function(module, exports, __webpack_require__) {
  6798.  
  6799. // call something on iterator step with safe closing on error
  6800. var anObject = __webpack_require__(4);
  6801. module.exports = function(iterator, fn, value, entries){
  6802.   try {
  6803.     return entries ? fn(anObject(value)[0], value[1]) : fn(value);
  6804.   // 7.4.6 IteratorClose(iterator, completion)
  6805.   } catch(e){
  6806.     var ret = iterator['return'];
  6807.     if(ret !== undefined)anObject(ret.call(iterator));
  6808.     throw e;
  6809.   }
  6810. };
  6811.  
  6812. /***/ }),
  6813. /* 40 */
  6814. /***/ (function(module, exports, __webpack_require__) {
  6815.  
  6816. "use strict";
  6817.  
  6818. var LIBRARY        = __webpack_require__(42)
  6819.   , $export        = __webpack_require__(17)
  6820.   , redefine       = __webpack_require__(84)
  6821.   , hide           = __webpack_require__(6)
  6822.   , has            = __webpack_require__(18)
  6823.   , Iterators      = __webpack_require__(13)
  6824.   , $iterCreate    = __webpack_require__(75)
  6825.   , setToStringTag = __webpack_require__(25)
  6826.   , getPrototypeOf = __webpack_require__(80)
  6827.   , ITERATOR       = __webpack_require__(0)('iterator')
  6828.   , BUGGY          = !([].keys && 'next' in [].keys()) // Safari has buggy iterators w/o `next`
  6829.   , FF_ITERATOR    = '@@iterator'
  6830.   , KEYS           = 'keys'
  6831.   , VALUES         = 'values';
  6832.  
  6833. var returnThis = function(){ return this; };
  6834.  
  6835. module.exports = function(Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED){
  6836.   $iterCreate(Constructor, NAME, next);
  6837.   var getMethod = function(kind){
  6838.     if(!BUGGY && kind in proto)return proto[kind];
  6839.     switch(kind){
  6840.       case KEYS: return function keys(){ return new Constructor(this, kind); };
  6841.       case VALUES: return function values(){ return new Constructor(this, kind); };
  6842.     } return function entries(){ return new Constructor(this, kind); };
  6843.   };
  6844.   var TAG        = NAME + ' Iterator'
  6845.     , DEF_VALUES = DEFAULT == VALUES
  6846.     , VALUES_BUG = false
  6847.     , proto      = Base.prototype
  6848.     , $native    = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT]
  6849.     , $default   = $native || getMethod(DEFAULT)
  6850.     , $entries   = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined
  6851.     , $anyNative = NAME == 'Array' ? proto.entries || $native : $native
  6852.     , methods, key, IteratorPrototype;
  6853.   // Fix native
  6854.   if($anyNative){
  6855.     IteratorPrototype = getPrototypeOf($anyNative.call(new Base));
  6856.     if(IteratorPrototype !== Object.prototype){
  6857.       // Set @@toStringTag to native iterators
  6858.       setToStringTag(IteratorPrototype, TAG, true);
  6859.       // fix for some old engines
  6860.       if(!LIBRARY && !has(IteratorPrototype, ITERATOR))hide(IteratorPrototype, ITERATOR, returnThis);
  6861.     }
  6862.   }
  6863.   // fix Array#{values, @@iterator}.name in V8 / FF
  6864.   if(DEF_VALUES && $native && $native.name !== VALUES){
  6865.     VALUES_BUG = true;
  6866.     $default = function values(){ return $native.call(this); };
  6867.   }
  6868.   // Define iterator
  6869.   if((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])){
  6870.     hide(proto, ITERATOR, $default);
  6871.   }
  6872.   // Plug for library
  6873.   Iterators[NAME] = $default;
  6874.   Iterators[TAG]  = returnThis;
  6875.   if(DEFAULT){
  6876.     methods = {
  6877.       values:  DEF_VALUES ? $default : getMethod(VALUES),
  6878.       keys:    IS_SET     ? $default : getMethod(KEYS),
  6879.       entries: $entries
  6880.     };
  6881.     if(FORCED)for(key in methods){
  6882.       if(!(key in proto))redefine(proto, key, methods[key]);
  6883.     } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);
  6884.   }
  6885.   return methods;
  6886. };
  6887.  
  6888. /***/ }),
  6889. /* 41 */
  6890. /***/ (function(module, exports, __webpack_require__) {
  6891.  
  6892. var ITERATOR     = __webpack_require__(0)('iterator')
  6893.   , SAFE_CLOSING = false;
  6894.  
  6895. try {
  6896.   var riter = [7][ITERATOR]();
  6897.   riter['return'] = function(){ SAFE_CLOSING = true; };
  6898.   Array.from(riter, function(){ throw 2; });
  6899. } catch(e){ /* empty */ }
  6900.  
  6901. module.exports = function(exec, skipClosing){
  6902.   if(!skipClosing && !SAFE_CLOSING)return false;
  6903.   var safe = false;
  6904.   try {
  6905.     var arr  = [7]
  6906.       , iter = arr[ITERATOR]();
  6907.     iter.next = function(){ return {done: safe = true}; };
  6908.     arr[ITERATOR] = function(){ return iter; };
  6909.     exec(arr);
  6910.   } catch(e){ /* empty */ }
  6911.   return safe;
  6912. };
  6913.  
  6914. /***/ }),
  6915. /* 42 */
  6916. /***/ (function(module, exports) {
  6917.  
  6918. module.exports = true;
  6919.  
  6920. /***/ }),
  6921. /* 43 */
  6922. /***/ (function(module, exports, __webpack_require__) {
  6923.  
  6924. var global = __webpack_require__(1)
  6925.   , SHARED = '__core-js_shared__'
  6926.   , store  = global[SHARED] || (global[SHARED] = {});
  6927. module.exports = function(key){
  6928.   return store[key] || (store[key] = {});
  6929. };
  6930.  
  6931. /***/ }),
  6932. /* 44 */
  6933. /***/ (function(module, exports, __webpack_require__) {
  6934.  
  6935. var ctx                = __webpack_require__(12)
  6936.   , invoke             = __webpack_require__(73)
  6937.   , html               = __webpack_require__(37)
  6938.   , cel                = __webpack_require__(23)
  6939.   , global             = __webpack_require__(1)
  6940.   , process            = global.process
  6941.   , setTask            = global.setImmediate
  6942.   , clearTask          = global.clearImmediate
  6943.   , MessageChannel     = global.MessageChannel
  6944.   , counter            = 0
  6945.   , queue              = {}
  6946.   , ONREADYSTATECHANGE = 'onreadystatechange'
  6947.   , defer, channel, port;
  6948. var run = function(){
  6949.   var id = +this;
  6950.   if(queue.hasOwnProperty(id)){
  6951.     var fn = queue[id];
  6952.     delete queue[id];
  6953.     fn();
  6954.   }
  6955. };
  6956. var listener = function(event){
  6957.   run.call(event.data);
  6958. };
  6959. // Node.js 0.9+ & IE10+ has setImmediate, otherwise:
  6960. if(!setTask || !clearTask){
  6961.   setTask = function setImmediate(fn){
  6962.     var args = [], i = 1;
  6963.     while(arguments.length > i)args.push(arguments[i++]);
  6964.     queue[++counter] = function(){
  6965.       invoke(typeof fn == 'function' ? fn : Function(fn), args);
  6966.     };
  6967.     defer(counter);
  6968.     return counter;
  6969.   };
  6970.   clearTask = function clearImmediate(id){
  6971.     delete queue[id];
  6972.   };
  6973.   // Node.js 0.8-
  6974.   if(__webpack_require__(16)(process) == 'process'){
  6975.     defer = function(id){
  6976.       process.nextTick(ctx(run, id, 1));
  6977.     };
  6978.   // Browsers with MessageChannel, includes WebWorkers
  6979.   } else if(MessageChannel){
  6980.     channel = new MessageChannel;
  6981.     port    = channel.port2;
  6982.     channel.port1.onmessage = listener;
  6983.     defer = ctx(port.postMessage, port, 1);
  6984.   // Browsers with postMessage, skip WebWorkers
  6985.   // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
  6986.   } else if(global.addEventListener && typeof postMessage == 'function' && !global.importScripts){
  6987.     defer = function(id){
  6988.       global.postMessage(id + '', '*');
  6989.     };
  6990.     global.addEventListener('message', listener, false);
  6991.   // IE8-
  6992.   } else if(ONREADYSTATECHANGE in cel('script')){
  6993.     defer = function(id){
  6994.       html.appendChild(cel('script'))[ONREADYSTATECHANGE] = function(){
  6995.         html.removeChild(this);
  6996.         run.call(id);
  6997.       };
  6998.     };
  6999.   // Rest old browsers
  7000.   } else {
  7001.     defer = function(id){
  7002.       setTimeout(ctx(run, id, 1), 0);
  7003.     };
  7004.   }
  7005. }
  7006. module.exports = {
  7007.   set:   setTask,
  7008.   clear: clearTask
  7009. };
  7010.  
  7011. /***/ }),
  7012. /* 45 */
  7013. /***/ (function(module, exports, __webpack_require__) {
  7014.  
  7015. // 7.1.13 ToObject(argument)
  7016. var defined = __webpack_require__(22);
  7017. module.exports = function(it){
  7018.   return Object(defined(it));
  7019. };
  7020.  
  7021. /***/ }),
  7022. /* 46 */
  7023. /***/ (function(module, exports) {
  7024.  
  7025. var id = 0
  7026.   , px = Math.random();
  7027. module.exports = function(key){
  7028.   return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
  7029. };
  7030.  
  7031. /***/ }),
  7032. /* 47 */
  7033. /***/ (function(module, exports, __webpack_require__) {
  7034.  
  7035. var classof   = __webpack_require__(34)
  7036.   , ITERATOR  = __webpack_require__(0)('iterator')
  7037.   , Iterators = __webpack_require__(13);
  7038. module.exports = __webpack_require__(2).getIteratorMethod = function(it){
  7039.   if(it != undefined)return it[ITERATOR]
  7040.     || it['@@iterator']
  7041.     || Iterators[classof(it)];
  7042. };
  7043.  
  7044. /***/ }),
  7045. /* 48 */
  7046. /***/ (function(module, exports, __webpack_require__) {
  7047.  
  7048. "use strict";
  7049.  
  7050. var $at  = __webpack_require__(87)(true);
  7051.  
  7052. // 21.1.3.27 String.prototype[@@iterator]()
  7053. __webpack_require__(40)(String, 'String', function(iterated){
  7054.   this._t = String(iterated); // target
  7055.   this._i = 0;                // next index
  7056. // 21.1.5.2.1 %StringIteratorPrototype%.next()
  7057. }, function(){
  7058.   var O     = this._t
  7059.     , index = this._i
  7060.     , point;
  7061.   if(index >= O.length)return {value: undefined, done: true};
  7062.   point = $at(O, index);
  7063.   this._i += point.length;
  7064.   return {value: point, done: false};
  7065. });
  7066.  
  7067. /***/ }),
  7068. /* 49 */
  7069. /***/ (function(module, __webpack_exports__, __webpack_require__) {
  7070.  
  7071. "use strict";
  7072. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator__ = __webpack_require__(11);
  7073. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator__);
  7074. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_core_js_json_stringify__ = __webpack_require__(33);
  7075. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_core_js_json_stringify___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_core_js_json_stringify__);
  7076. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_asyncToGenerator__ = __webpack_require__(10);
  7077. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_asyncToGenerator___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_asyncToGenerator__);
  7078. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_parse_github_url__ = __webpack_require__(30);
  7079. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_parse_github_url___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_parse_github_url__);
  7080. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_bluebird__ = __webpack_require__(3);
  7081. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_bluebird___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_bluebird__);
  7082. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__npm__ = __webpack_require__(20);
  7083. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__github__ = __webpack_require__(15);
  7084. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_7__env__ = __webpack_require__(14);
  7085.  
  7086.  
  7087.  
  7088.  
  7089.  
  7090.  
  7091.  
  7092.  
  7093.  
  7094.  
  7095.  
  7096. /* harmony default export */ __webpack_exports__["a"] = function () {
  7097.   return function () {
  7098.     var _ref = __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_asyncToGenerator___default()(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator___default.a.mark(function _callee2() {
  7099.       var _this = this;
  7100.  
  7101.       var span;
  7102.       return __WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator___default.a.wrap(function _callee2$(_context2) {
  7103.         while (1) {
  7104.           switch (_context2.prev = _context2.next) {
  7105.             case 0:
  7106.               span = document.createElement('span');
  7107.  
  7108.  
  7109.               document.querySelectorAll('ul.columnar>li .description').forEach(function (ele) {
  7110.                 return ele.title = ele.innerText || ele.textContent;
  7111.               });
  7112.  
  7113.               document.querySelectorAll('ul.columnar>li').forEach(function () {
  7114.                 var _ref2 = __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_asyncToGenerator___default()(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator___default.a.mark(function _callee(ele) {
  7115.                   var aEle, name, npmPackage, repoInfo, gitRepoInfo, _github$createWidget, container;
  7116.  
  7117.                   return __WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator___default.a.wrap(function _callee$(_context) {
  7118.                     while (1) {
  7119.                       switch (_context.prev = _context.next) {
  7120.                         case 0:
  7121.                           aEle = ele.querySelector('a.name');
  7122.                           name = aEle.innerText || aEle.textContent;
  7123.                           _context.next = 4;
  7124.                           return __WEBPACK_IMPORTED_MODULE_5__npm__["a" /* default */].fetchPackageInfo(name);
  7125.  
  7126.                         case 4:
  7127.                           npmPackage = _context.sent;
  7128.  
  7129.  
  7130.                           __WEBPACK_IMPORTED_MODULE_7__env__["a" /* default */].dev && ele.setAttribute('package', __WEBPACK_IMPORTED_MODULE_1_babel_runtime_core_js_json_stringify___default()(npmPackage));
  7131.  
  7132.                           if (npmPackage.repository) {
  7133.                             _context.next = 8;
  7134.                             break;
  7135.                           }
  7136.  
  7137.                           return _context.abrupt('return', console.error(npmPackage.name + ' doesn\'t has repository field'));
  7138.  
  7139.                         case 8:
  7140.                           repoInfo = __WEBPACK_IMPORTED_MODULE_3_parse_github_url___default()(npmPackage.repository.url);
  7141.  
  7142.  
  7143.                           __WEBPACK_IMPORTED_MODULE_7__env__["a" /* default */].dev && ele.setAttribute('repository-info', __WEBPACK_IMPORTED_MODULE_1_babel_runtime_core_js_json_stringify___default()(repoInfo));
  7144.  
  7145.                           if (repoInfo) {
  7146.                             _context.next = 12;
  7147.                             break;
  7148.                           }
  7149.  
  7150.                           return _context.abrupt('return', console.error('can\'t parse ' + npmPackage.repository.url));
  7151.  
  7152.                         case 12:
  7153.                           if (!(repoInfo.host !== 'github.com')) {
  7154.                             _context.next = 14;
  7155.                             break;
  7156.                           }
  7157.  
  7158.                           return _context.abrupt('return', console.error(repoInfo.href + ' is not a github repository'));
  7159.  
  7160.                         case 14:
  7161.                           _context.next = 16;
  7162.                           return __WEBPACK_IMPORTED_MODULE_6__github__["a" /* default */].fetchRepoInfo(repoInfo.repo);
  7163.  
  7164.                         case 16:
  7165.                           gitRepoInfo = _context.sent;
  7166.  
  7167.  
  7168.                           __WEBPACK_IMPORTED_MODULE_7__env__["a" /* default */].dev && ele.setAttribute('github-info', __WEBPACK_IMPORTED_MODULE_1_babel_runtime_core_js_json_stringify___default()(gitRepoInfo));
  7169.  
  7170.                           _github$createWidget = __WEBPACK_IMPORTED_MODULE_6__github__["a" /* default */].createWidget('span')({
  7171.                             watch: gitRepoInfo.subscribers_count,
  7172.                             star: gitRepoInfo.watchers_count,
  7173.                             fork: gitRepoInfo.forks_count
  7174.                           }), container = _github$createWidget.container;
  7175.  
  7176.                           container.classList.add('description');
  7177.                           ele.querySelector('.package-details h3').appendChild(container);
  7178.  
  7179.                         case 21:
  7180.                         case 'end':
  7181.                           return _context.stop();
  7182.                       }
  7183.                     }
  7184.                   }, _callee, _this);
  7185.                 }));
  7186.  
  7187.                 return function (_x) {
  7188.                   return _ref2.apply(this, arguments);
  7189.                 };
  7190.               }());
  7191.  
  7192.             case 3:
  7193.             case 'end':
  7194.               return _context2.stop();
  7195.           }
  7196.         }
  7197.       }, _callee2, this);
  7198.     }));
  7199.  
  7200.     function browserPageHandler() {
  7201.       return _ref.apply(this, arguments);
  7202.     }
  7203.  
  7204.     return browserPageHandler;
  7205.   }();
  7206. };
  7207.  
  7208. /***/ }),
  7209. /* 50 */
  7210. /***/ (function(module, __webpack_exports__, __webpack_require__) {
  7211.  
  7212. "use strict";
  7213. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_toConsumableArray__ = __webpack_require__(60);
  7214. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_toConsumableArray___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_toConsumableArray__);
  7215. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_regenerator__ = __webpack_require__(11);
  7216. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_regenerator___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_regenerator__);
  7217. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_asyncToGenerator__ = __webpack_require__(10);
  7218. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_asyncToGenerator___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_asyncToGenerator__);
  7219. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_bluebird__ = __webpack_require__(3);
  7220. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_bluebird___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_bluebird__);
  7221. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__github__ = __webpack_require__(15);
  7222. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_timeago_js__ = __webpack_require__(111);
  7223. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_timeago_js___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_timeago_js__);
  7224. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__utils__ = __webpack_require__(9);
  7225. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_7__env__ = __webpack_require__(14);
  7226.  
  7227.  
  7228.  
  7229.  
  7230.  
  7231.  
  7232.  
  7233.  
  7234.  
  7235.  
  7236.  
  7237. function generateOutdatedWarning(date, diffDays) {
  7238.   var span = document.createElement('span');
  7239.   var tags = {
  7240.     deprecated: { name: "Deprecated", color: "red" },
  7241.     outdated: { name: "Outdated", color: "blue" }
  7242.   };
  7243.   var tag = null;
  7244.   if (diffDays > 365) {
  7245.     tag = tags.deprecated;
  7246.   } else if (diffDays > 180) {
  7247.     tag = tags.outdated;
  7248.   }
  7249.   span.innerHTML = (tag ? '<strong style="color: ' + tag.color + '">@' + tag.name + '</strong> ' : '') + ('last commit at <strong style="color: #283546;">' + new __WEBPACK_IMPORTED_MODULE_5_timeago_js___default.a().format(date) + '</strong>');
  7250.   span.style.color = 'rgba(0, 0, 0, 0.6)';
  7251.   span.style.fontSize = '16px';
  7252.   span.style.verticalAlign = 'middle';
  7253.   return span;
  7254. }
  7255.  
  7256. /* harmony default export */ __webpack_exports__["a"] = function () {
  7257.  
  7258.   return function () {
  7259.     var _ref = __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_asyncToGenerator___default()(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_regenerator___default.a.mark(function _callee() {
  7260.       var githubLink, gitRepoInfo, _github$createWidget, container, gitBranchInfo, lastCommit, lastCommitter, commitFromNowDiffDays, span;
  7261.  
  7262.       return __WEBPACK_IMPORTED_MODULE_1_babel_runtime_regenerator___default.a.wrap(function _callee$(_context) {
  7263.         while (1) {
  7264.           switch (_context.prev = _context.next) {
  7265.             case 0:
  7266.  
  7267.               parseJSCodeBlock(); // parse require('xxx') | import xxx from
  7268.               parseShellCodeBlock(); // parse require('xxx') | import xxx from
  7269.  
  7270.               githubLink = window.document.querySelector('.box a[href*=github]');
  7271.  
  7272.               if (githubLink) {
  7273.                 _context.next = 5;
  7274.                 break;
  7275.               }
  7276.  
  7277.               return _context.abrupt('return');
  7278.  
  7279.             case 5:
  7280.               githubLink.title = githubLink.href;
  7281.               _context.next = 8;
  7282.               return __WEBPACK_IMPORTED_MODULE_4__github__["a" /* default */].fetchRepoInfo(githubLink.pathname);
  7283.  
  7284.             case 8:
  7285.               gitRepoInfo = _context.sent;
  7286.               _github$createWidget = __WEBPACK_IMPORTED_MODULE_4__github__["a" /* default */].createWidget('li')({
  7287.                 watch: gitRepoInfo.subscribers_count,
  7288.                 star: gitRepoInfo.watchers_count,
  7289.                 fork: gitRepoInfo.forks_count
  7290.               }), container = _github$createWidget.container;
  7291.               _context.next = 12;
  7292.               return __WEBPACK_IMPORTED_MODULE_4__github__["a" /* default */].fetchRepoBranchInfo(githubLink.pathname, 'master');
  7293.  
  7294.             case 12:
  7295.               gitBranchInfo = _context.sent;
  7296.               lastCommit = gitBranchInfo.commit.commit;
  7297.               lastCommitter = lastCommit.committer;
  7298.               commitFromNowDiffDays = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_6__utils__["e" /* diffDays */])(new Date(), lastCommitter.date);
  7299.  
  7300.               // warning
  7301.  
  7302.               span = generateOutdatedWarning(lastCommitter.date, commitFromNowDiffDays);
  7303.  
  7304.               document.querySelector('.package-name').appendChild(span);
  7305.  
  7306.               window.document.querySelector('.box').insertBefore(container, githubLink.parentNode);
  7307.  
  7308.             case 19:
  7309.             case 'end':
  7310.               return _context.stop();
  7311.           }
  7312.         }
  7313.       }, _callee, this);
  7314.     }));
  7315.  
  7316.     function detailPageHandler() {
  7317.       return _ref.apply(this, arguments);
  7318.     }
  7319.  
  7320.     return detailPageHandler;
  7321.   }();
  7322. };
  7323.  
  7324. function getElementText(ele) {
  7325.   return ele.innerText || ele.textContent;
  7326. }
  7327.  
  7328. function parseJSCodeBlock() {
  7329.   var _slice$call;
  7330.  
  7331.   var js = document.querySelectorAll('.highlight.js pre .line .source');
  7332.   var javascript = document.querySelectorAll('.highlight.javascript pre .line .source');
  7333.   var lines = (_slice$call = [].slice.call(js)).concat.apply(_slice$call, __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_toConsumableArray___default()(javascript));
  7334.  
  7335.   try {
  7336.     lines.forEach(function (line) {
  7337.       if (line.innerHTML.match(/require|from|import/g)) {
  7338.  
  7339.         (line.querySelectorAll('.string.quoted') || line.querySelectorAll('.import .string.quoted')).forEach(function (stringQuotedEle) {
  7340.           if (!stringQuotedEle) return;
  7341.  
  7342.           var requireName = getElementText(stringQuotedEle).trim().replace(/^['"]|['"]$/g, '');
  7343.  
  7344.           if (/^\./.test(requireName)) return; // 不支持相对路径
  7345.  
  7346.           var packageNameMatch = requireName.match(/(^\@[^\/]+\/[^\/]+)|([^\/]+)/) || [];
  7347.           var packageName = packageNameMatch[0];
  7348.  
  7349.           if (__WEBPACK_IMPORTED_MODULE_7__env__["a" /* default */].dev) {
  7350.             console.info('[Parse Javascript]: ' + requireName + ' >>> ' + packageName);
  7351.           }
  7352.  
  7353.           // 正确解析才渲染页面
  7354.           if (packageName) {
  7355.             var childNodes = stringQuotedEle.children;
  7356.             var stringQuotedStartEle = childNodes[0];
  7357.             var stringQuotedEndEle = childNodes[childNodes.length - 1];
  7358.             var packageUrl = 'https://www.npmjs.com/package/' + packageName;
  7359.             stringQuotedEle.innerHTML = stringQuotedStartEle.innerHTML + ('<a title="' + packageUrl + '" style="text-decoration: underline" href="' + packageUrl + '">' + requireName + '</a>') + stringQuotedEndEle.innerHTML;
  7360.           }
  7361.         });
  7362.       }
  7363.     });
  7364.   } catch (err) {
  7365.     console.error(err);
  7366.   }
  7367. }
  7368.  
  7369. function parseShellCodeBlock() {
  7370.   var _slice$call$concat, _slice$call2;
  7371.  
  7372.   var sh = document.querySelectorAll('.highlight.sh pre .line .source');
  7373.   var bash = document.querySelectorAll('.highlight.bash pre .line');
  7374.   var noTag = document.querySelectorAll('pre:not(.highlight) code');
  7375.   var lines = (_slice$call$concat = (_slice$call2 = [].slice.call(sh)).concat.apply(_slice$call2, __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_toConsumableArray___default()(bash))).concat.apply(_slice$call$concat, __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_toConsumableArray___default()(noTag));
  7376.  
  7377.   try {
  7378.     lines.forEach(function (line) {
  7379.       var match = getElementText(line).trim().replace(/^\$\s*/, '').match(/(npm)\s+(install)\s+((--?[\w]+\s)?|\s+)+([\w\-\@\.\_\/]+)/g);
  7380.       if (match && match.length) {
  7381.  
  7382.         var matchStr = match[0].trim();
  7383.  
  7384.         var commands = matchStr.split(/\s+/g).map(function (v) {
  7385.           return v.trim();
  7386.         });
  7387.         var command = '',
  7388.             action = '',
  7389.             target = '';
  7390.         var argv = [];
  7391.  
  7392.         commands.forEach(function (str, index) {
  7393.           if (index === 0) return command = str;
  7394.           if (index === 1) return action = str;
  7395.  
  7396.           // argv
  7397.           if (/^\-/.test(str)) {
  7398.             argv.push(str);
  7399.           } else {
  7400.             target = str;
  7401.           }
  7402.         });
  7403.  
  7404.         var packageName = (target || '').trim();
  7405.  
  7406.         // 处理一些带有版本的命令
  7407.         // example: npm install @reactivex/rxjs@5.0.0
  7408.         // example: npm install -g express-generator@4
  7409.         packageName = packageName.replace(/([^\s])\@[\.\w\-]+$/, '$1');
  7410.  
  7411.         if (__WEBPACK_IMPORTED_MODULE_7__env__["a" /* default */].dev) {
  7412.           console.log('[Parse Shell]: ' + matchStr + ' >>> ' + packageName);
  7413.         }
  7414.  
  7415.         if (packageName) {
  7416.           var packageUrl = 'https://www.npmjs.com/package/' + packageName;
  7417.           line.innerHTML = line.innerHTML.replace(/\&nbsp\;/g, ' ') // remove empty string
  7418.           .replace(target, '<a style="text-decoration: underline" title="' + packageUrl + '" href="' + packageUrl + '">' + target + '</a>');
  7419.         }
  7420.       }
  7421.     });
  7422.   } catch (err) {
  7423.     console.error(err);
  7424.   }
  7425. }
  7426.  
  7427. /***/ }),
  7428. /* 51 */
  7429. /***/ (function(module, __webpack_exports__, __webpack_require__) {
  7430.  
  7431. "use strict";
  7432. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator__ = __webpack_require__(11);
  7433. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator__);
  7434. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_asyncToGenerator__ = __webpack_require__(10);
  7435. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_asyncToGenerator___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_asyncToGenerator__);
  7436. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_parse_github_url__ = __webpack_require__(30);
  7437. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_parse_github_url___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_parse_github_url__);
  7438. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_bluebird__ = __webpack_require__(3);
  7439. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_bluebird___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_bluebird__);
  7440. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__npm__ = __webpack_require__(20);
  7441. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__github__ = __webpack_require__(15);
  7442. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__env__ = __webpack_require__(14);
  7443.  
  7444.  
  7445.  
  7446.  
  7447.  
  7448.  
  7449.  
  7450.  
  7451.  
  7452.  
  7453. /* harmony default export */ __webpack_exports__["a"] = function () {
  7454.   return function () {
  7455.     var _ref = __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_asyncToGenerator___default()(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator___default.a.mark(function _callee() {
  7456.       return __WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator___default.a.wrap(function _callee$(_context) {
  7457.         while (1) {
  7458.           switch (_context.prev = _context.next) {
  7459.             case 0:
  7460.               document.querySelectorAll('.package-details .description').forEach(function (ele) {
  7461.                 return ele.title = ele.innerText || ele.textContent;
  7462.               });
  7463.  
  7464.             case 1:
  7465.             case 'end':
  7466.               return _context.stop();
  7467.           }
  7468.         }
  7469.       }, _callee, this);
  7470.     }));
  7471.  
  7472.     function homePageHandler() {
  7473.       return _ref.apply(this, arguments);
  7474.     }
  7475.  
  7476.     return homePageHandler;
  7477.   }();
  7478. };
  7479.  
  7480. /***/ }),
  7481. /* 52 */
  7482. /***/ (function(module, __webpack_exports__, __webpack_require__) {
  7483.  
  7484. "use strict";
  7485. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator__ = __webpack_require__(11);
  7486. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator__);
  7487. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_core_js_json_stringify__ = __webpack_require__(33);
  7488. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_core_js_json_stringify___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_core_js_json_stringify__);
  7489. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_asyncToGenerator__ = __webpack_require__(10);
  7490. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_asyncToGenerator___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_asyncToGenerator__);
  7491. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_parse_github_url__ = __webpack_require__(30);
  7492. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_parse_github_url___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_parse_github_url__);
  7493. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_bluebird__ = __webpack_require__(3);
  7494. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_bluebird___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_bluebird__);
  7495. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__npm__ = __webpack_require__(20);
  7496. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__github__ = __webpack_require__(15);
  7497. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_7__utils__ = __webpack_require__(9);
  7498. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_8__env__ = __webpack_require__(14);
  7499.  
  7500.  
  7501.  
  7502.  
  7503.  
  7504.  
  7505. var searchPageHandler = function () {
  7506.   var _ref = __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_asyncToGenerator___default()(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator___default.a.mark(function _callee2() {
  7507.     var _this = this;
  7508.  
  7509.     var searchResults;
  7510.     return __WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator___default.a.wrap(function _callee2$(_context2) {
  7511.       while (1) {
  7512.         switch (_context2.prev = _context2.next) {
  7513.           case 0:
  7514.             document.querySelectorAll('.github-info').forEach(function (ele) {
  7515.               return ele.remove();
  7516.             });
  7517.             searchResults = document.querySelectorAll('.package-details');
  7518.  
  7519.             searchResults.forEach(function () {
  7520.               var _ref2 = __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_asyncToGenerator___default()(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator___default.a.mark(function _callee(detailEle) {
  7521.                 var nameEle, name, npmPackage, repoInfo, gitRepoInfo, _github$createWidget, container;
  7522.  
  7523.                 return __WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator___default.a.wrap(function _callee$(_context) {
  7524.                   while (1) {
  7525.                     switch (_context.prev = _context.next) {
  7526.                       case 0:
  7527.                         nameEle = detailEle.querySelector('.packageName');
  7528.                         name = nameEle.innerText || nameEle.textContent;
  7529.                         _context.next = 4;
  7530.                         return __WEBPACK_IMPORTED_MODULE_5__npm__["a" /* default */].fetchPackageInfo(name);
  7531.  
  7532.                       case 4:
  7533.                         npmPackage = _context.sent;
  7534.                         repoInfo = __WEBPACK_IMPORTED_MODULE_3_parse_github_url___default()(npmPackage.repository.url);
  7535.  
  7536.  
  7537.                         __WEBPACK_IMPORTED_MODULE_8__env__["a" /* default */].dev && detailEle.setAttribute('repository-info', __WEBPACK_IMPORTED_MODULE_1_babel_runtime_core_js_json_stringify___default()(repoInfo));
  7538.  
  7539.                         if (repoInfo) {
  7540.                           _context.next = 9;
  7541.                           break;
  7542.                         }
  7543.  
  7544.                         return _context.abrupt('return', console.error('can\'t parse ' + npmPackage.repository.url));
  7545.  
  7546.                       case 9:
  7547.                         if (!(repoInfo.host !== 'github.com')) {
  7548.                           _context.next = 11;
  7549.                           break;
  7550.                         }
  7551.  
  7552.                         return _context.abrupt('return', console.error(repoInfo.href + ' is not a github repository'));
  7553.  
  7554.                       case 11:
  7555.                         _context.next = 13;
  7556.                         return __WEBPACK_IMPORTED_MODULE_6__github__["a" /* default */].fetchRepoInfo(repoInfo.repo);
  7557.  
  7558.                       case 13:
  7559.                         gitRepoInfo = _context.sent;
  7560.  
  7561.  
  7562.                         __WEBPACK_IMPORTED_MODULE_8__env__["a" /* default */].dev && detailEle.setAttribute('github-info', __WEBPACK_IMPORTED_MODULE_1_babel_runtime_core_js_json_stringify___default()(gitRepoInfo));
  7563.  
  7564.                         _github$createWidget = __WEBPACK_IMPORTED_MODULE_6__github__["a" /* default */].createWidget('span')({
  7565.                           watch: gitRepoInfo.subscribers_count,
  7566.                           star: gitRepoInfo.watchers_count,
  7567.                           fork: gitRepoInfo.forks_count
  7568.                         }), container = _github$createWidget.container;
  7569.  
  7570.                         container.style.display = 'inline-block';
  7571.                         container.style.marginLeft = '5px';
  7572.                         detailEle.querySelector('h3').appendChild(container);
  7573.  
  7574.                       case 19:
  7575.                       case 'end':
  7576.                         return _context.stop();
  7577.                     }
  7578.                   }
  7579.                 }, _callee, _this);
  7580.               }));
  7581.  
  7582.               return function (_x) {
  7583.                 return _ref2.apply(this, arguments);
  7584.               };
  7585.             }());
  7586.  
  7587.           case 3:
  7588.           case 'end':
  7589.             return _context2.stop();
  7590.         }
  7591.       }
  7592.     }, _callee2, this);
  7593.   }));
  7594.  
  7595.   return function searchPageHandler() {
  7596.     return _ref.apply(this, arguments);
  7597.   };
  7598. }();
  7599.  
  7600.  
  7601.  
  7602.  
  7603.  
  7604.  
  7605.  
  7606.  
  7607. var __pushState__ = history.pushState;
  7608.  
  7609. window.history["pushState"] = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_7__utils__["d" /* debounce */])(function () {
  7610.   searchPageHandler();
  7611.   return __pushState__.apply(this, arguments);
  7612. }, 100);
  7613.  
  7614. /* harmony default export */ __webpack_exports__["a"] = function () {
  7615.   return searchPageHandler;
  7616. };
  7617.  
  7618. /***/ }),
  7619. /* 53 */
  7620. /***/ (function(module, exports, __webpack_require__) {
  7621.  
  7622. // style-loader: Adds some css to the DOM by adding a <style> tag
  7623.  
  7624. // load the styles
  7625. var content = __webpack_require__(96);
  7626. if(typeof content === 'string') content = [[module.i, content, '']];
  7627. // add the styles to the DOM
  7628. var update = __webpack_require__(109)(content, {});
  7629. if(content.locals) module.exports = content.locals;
  7630. // Hot Module Replacement
  7631. if(false) {
  7632. 	// When the styles change, update the <style> tags
  7633. 	if(!content.locals) {
  7634. 		module.hot.accept("!!../node_modules/css-loader/index.js!./index.css", function() {
  7635. 			var newContent = require("!!../node_modules/css-loader/index.js!./index.css");
  7636. 			if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
  7637. 			update(newContent);
  7638. 		});
  7639. 	}
  7640. 	// When the module is disposed, remove the <style> tags
  7641. 	module.hot.dispose(function() { update(); });
  7642. }
  7643.  
  7644. /***/ }),
  7645. /* 54 */
  7646. /***/ (function(module, __webpack_exports__, __webpack_require__) {
  7647.  
  7648. "use strict";
  7649.  
  7650.  
  7651. function createSvg(_ref) {
  7652.   var path = _ref.path,
  7653.       width = _ref.width,
  7654.       height = _ref.height;
  7655.  
  7656.   var NS = "http://www.w3.org/2000/svg";
  7657.   var svg = document.createElementNS(NS, "svg");
  7658.   var p = document.createElementNS(NS, "path");
  7659.   svg.setAttribute('version', '1.1');
  7660.   svg.setAttribute('width', width + '');
  7661.   svg.setAttribute('height', height + '');
  7662.  
  7663.   p.setAttributeNS(null, "fill-rule", "evenodd");
  7664.   p.setAttributeNS(null, "d", path);
  7665.   svg.appendChild(p);
  7666.   return svg;
  7667. }
  7668.  
  7669. var svg = {
  7670.   github: createSvg({
  7671.     path: 'M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59.4.07.55-.17.55-.38 0-.19-.01-.82-.01-1.49-2.01.37-2.53-.49-2.69-.94-.09-.23-.48-.94-.82-1.13-.28-.15-.68-.52-.01-.53.63-.01 1.08.58 1.23.82.72 1.21 1.87.87 2.33.66.07-.52.28-.87.51-1.07-1.78-.2-3.64-.89-3.64-3.95 0-.87.31-1.59.82-2.15-.08-.2-.36-1.02.08-2.12 0 0 .67-.21 2.2.82.64-.18 1.32-.27 2-.27.68 0 1.36.09 2 .27 1.53-1.04 2.2-.82 2.2-.82.44 1.1.16 1.92.08 2.12.51.56.82 1.27.82 2.15 0 3.07-1.87 3.75-3.65 3.95.29.25.54.73.54 1.48 0 1.07-.01 1.93-.01 2.2 0 .21.15.46.55.38A8.013 8.013 0 0 0 16 8c0-4.42-3.58-8-8-8z',
  7672.     width: 14,
  7673.     height: 14
  7674.   }),
  7675.   watch: createSvg({
  7676.     path: 'M8.06 2C3 2 0 8 0 8s3 6 8.06 6C13 14 16 8 16 8s-3-6-7.94-6zM8 12c-2.2 0-4-1.78-4-4 0-2.2 1.8-4 4-4 2.22 0 4 1.8 4 4 0 2.22-1.78 4-4 4zm2-4c0 1.11-.89 2-2 2-1.11 0-2-.89-2-2 0-1.11.89-2 2-2 1.11 0 2 .89 2 2z',
  7677.     width: 16,
  7678.     height: 14
  7679.   }),
  7680.   star: createSvg({
  7681.     path: 'M14 6l-4.9-.64L7 1 4.9 5.36 0 6l3.6 3.26L2.67 14 7 11.67 11.33 14l-.93-4.74z',
  7682.     width: 14,
  7683.     height: 14
  7684.   }),
  7685.   fork: createSvg({
  7686.     path: 'M8 1a1.993 1.993 0 0 0-1 3.72V6L5 8 3 6V4.72A1.993 1.993 0 0 0 2 1a1.993 1.993 0 0 0-1 3.72V6.5l3 3v1.78A1.993 1.993 0 0 0 5 15a1.993 1.993 0 0 0 1-3.72V9.5l3-3V4.72A1.993 1.993 0 0 0 8 1zM2 4.2C1.34 4.2.8 3.65.8 3c0-.65.55-1.2 1.2-1.2.65 0 1.2.55 1.2 1.2 0 .65-.55 1.2-1.2 1.2zm3 10c-.66 0-1.2-.55-1.2-1.2 0-.65.55-1.2 1.2-1.2.65 0 1.2.55 1.2 1.2 0 .65-.55 1.2-1.2 1.2zm3-10c-.66 0-1.2-.55-1.2-1.2 0-.65.55-1.2 1.2-1.2.65 0 1.2.55 1.2 1.2 0 .65-.55 1.2-1.2 1.2z',
  7687.     width: 12,
  7688.     height: 14
  7689.   })
  7690. };
  7691.  
  7692. /* harmony default export */ __webpack_exports__["a"] = svg;
  7693.  
  7694. /***/ }),
  7695. /* 55 */
  7696. /***/ (function(module, exports, __webpack_require__) {
  7697.  
  7698. module.exports = { "default": __webpack_require__(63), __esModule: true };
  7699.  
  7700. /***/ }),
  7701. /* 56 */
  7702. /***/ (function(module, exports, __webpack_require__) {
  7703.  
  7704. module.exports = { "default": __webpack_require__(65), __esModule: true };
  7705.  
  7706. /***/ }),
  7707. /* 57 */
  7708. /***/ (function(module, exports, __webpack_require__) {
  7709.  
  7710. module.exports = { "default": __webpack_require__(66), __esModule: true };
  7711.  
  7712. /***/ }),
  7713. /* 58 */
  7714. /***/ (function(module, exports, __webpack_require__) {
  7715.  
  7716. "use strict";
  7717.  
  7718.  
  7719. exports.__esModule = true;
  7720.  
  7721. exports.default = function (instance, Constructor) {
  7722.   if (!(instance instanceof Constructor)) {
  7723.     throw new TypeError("Cannot call a class as a function");
  7724.   }
  7725. };
  7726.  
  7727. /***/ }),
  7728. /* 59 */
  7729. /***/ (function(module, exports, __webpack_require__) {
  7730.  
  7731. "use strict";
  7732.  
  7733.  
  7734. exports.__esModule = true;
  7735.  
  7736. var _defineProperty = __webpack_require__(56);
  7737.  
  7738. var _defineProperty2 = _interopRequireDefault(_defineProperty);
  7739.  
  7740. function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  7741.  
  7742. exports.default = function () {
  7743.   function defineProperties(target, props) {
  7744.     for (var i = 0; i < props.length; i++) {
  7745.       var descriptor = props[i];
  7746.       descriptor.enumerable = descriptor.enumerable || false;
  7747.       descriptor.configurable = true;
  7748.       if ("value" in descriptor) descriptor.writable = true;
  7749.       (0, _defineProperty2.default)(target, descriptor.key, descriptor);
  7750.     }
  7751.   }
  7752.  
  7753.   return function (Constructor, protoProps, staticProps) {
  7754.     if (protoProps) defineProperties(Constructor.prototype, protoProps);
  7755.     if (staticProps) defineProperties(Constructor, staticProps);
  7756.     return Constructor;
  7757.   };
  7758. }();
  7759.  
  7760. /***/ }),
  7761. /* 60 */
  7762. /***/ (function(module, exports, __webpack_require__) {
  7763.  
  7764. "use strict";
  7765.  
  7766.  
  7767. exports.__esModule = true;
  7768.  
  7769. var _from = __webpack_require__(55);
  7770.  
  7771. var _from2 = _interopRequireDefault(_from);
  7772.  
  7773. function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  7774.  
  7775. exports.default = function (arr) {
  7776.   if (Array.isArray(arr)) {
  7777.     for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {
  7778.       arr2[i] = arr[i];
  7779.     }
  7780.  
  7781.     return arr2;
  7782.   } else {
  7783.     return (0, _from2.default)(arr);
  7784.   }
  7785. };
  7786.  
  7787. /***/ }),
  7788. /* 61 */
  7789. /***/ (function(module, exports, __webpack_require__) {
  7790.  
  7791. "use strict";
  7792.  
  7793.  
  7794. exports.byteLength = byteLength
  7795. exports.toByteArray = toByteArray
  7796. exports.fromByteArray = fromByteArray
  7797.  
  7798. var lookup = []
  7799. var revLookup = []
  7800. var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array
  7801.  
  7802. var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
  7803. for (var i = 0, len = code.length; i < len; ++i) {
  7804.   lookup[i] = code[i]
  7805.   revLookup[code.charCodeAt(i)] = i
  7806. }
  7807.  
  7808. revLookup['-'.charCodeAt(0)] = 62
  7809. revLookup['_'.charCodeAt(0)] = 63
  7810.  
  7811. function placeHoldersCount (b64) {
  7812.   var len = b64.length
  7813.   if (len % 4 > 0) {
  7814.     throw new Error('Invalid string. Length must be a multiple of 4')
  7815.   }
  7816.  
  7817.   // the number of equal signs (place holders)
  7818.   // if there are two placeholders, than the two characters before it
  7819.   // represent one byte
  7820.   // if there is only one, then the three characters before it represent 2 bytes
  7821.   // this is just a cheap hack to not do indexOf twice
  7822.   return b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0
  7823. }
  7824.  
  7825. function byteLength (b64) {
  7826.   // base64 is 4/3 + up to two characters of the original data
  7827.   return b64.length * 3 / 4 - placeHoldersCount(b64)
  7828. }
  7829.  
  7830. function toByteArray (b64) {
  7831.   var i, j, l, tmp, placeHolders, arr
  7832.   var len = b64.length
  7833.   placeHolders = placeHoldersCount(b64)
  7834.  
  7835.   arr = new Arr(len * 3 / 4 - placeHolders)
  7836.  
  7837.   // if there are placeholders, only get up to the last complete 4 chars
  7838.   l = placeHolders > 0 ? len - 4 : len
  7839.  
  7840.   var L = 0
  7841.  
  7842.   for (i = 0, j = 0; i < l; i += 4, j += 3) {
  7843.     tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]
  7844.     arr[L++] = (tmp >> 16) & 0xFF
  7845.     arr[L++] = (tmp >> 8) & 0xFF
  7846.     arr[L++] = tmp & 0xFF
  7847.   }
  7848.  
  7849.   if (placeHolders === 2) {
  7850.     tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4)
  7851.     arr[L++] = tmp & 0xFF
  7852.   } else if (placeHolders === 1) {
  7853.     tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2)
  7854.     arr[L++] = (tmp >> 8) & 0xFF
  7855.     arr[L++] = tmp & 0xFF
  7856.   }
  7857.  
  7858.   return arr
  7859. }
  7860.  
  7861. function tripletToBase64 (num) {
  7862.   return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F]
  7863. }
  7864.  
  7865. function encodeChunk (uint8, start, end) {
  7866.   var tmp
  7867.   var output = []
  7868.   for (var i = start; i < end; i += 3) {
  7869.     tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])
  7870.     output.push(tripletToBase64(tmp))
  7871.   }
  7872.   return output.join('')
  7873. }
  7874.  
  7875. function fromByteArray (uint8) {
  7876.   var tmp
  7877.   var len = uint8.length
  7878.   var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
  7879.   var output = ''
  7880.   var parts = []
  7881.   var maxChunkLength = 16383 // must be multiple of 3
  7882.  
  7883.   // go through the array every three bytes, we'll deal with trailing stuff later
  7884.   for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
  7885.     parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))
  7886.   }
  7887.  
  7888.   // pad the end with zeros, but make sure to not forget the extra bytes
  7889.   if (extraBytes === 1) {
  7890.     tmp = uint8[len - 1]
  7891.     output += lookup[tmp >> 2]
  7892.     output += lookup[(tmp << 4) & 0x3F]
  7893.     output += '=='
  7894.   } else if (extraBytes === 2) {
  7895.     tmp = (uint8[len - 2] << 8) + (uint8[len - 1])
  7896.     output += lookup[tmp >> 10]
  7897.     output += lookup[(tmp >> 4) & 0x3F]
  7898.     output += lookup[(tmp << 2) & 0x3F]
  7899.     output += '='
  7900.   }
  7901.  
  7902.   parts.push(output)
  7903.  
  7904.   return parts.join('')
  7905. }
  7906.  
  7907.  
  7908. /***/ }),
  7909. /* 62 */
  7910. /***/ (function(module, exports, __webpack_require__) {
  7911.  
  7912. "use strict";
  7913. /* WEBPACK VAR INJECTION */(function(global) {/*!
  7914.  * The buffer module from node.js, for the browser.
  7915.  *
  7916.  * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
  7917.  * @license  MIT
  7918.  */
  7919. /* eslint-disable no-proto */
  7920.  
  7921.  
  7922.  
  7923. var base64 = __webpack_require__(61)
  7924. var ieee754 = __webpack_require__(100)
  7925. var isArray = __webpack_require__(101)
  7926.  
  7927. exports.Buffer = Buffer
  7928. exports.SlowBuffer = SlowBuffer
  7929. exports.INSPECT_MAX_BYTES = 50
  7930.  
  7931. /**
  7932.  * If `Buffer.TYPED_ARRAY_SUPPORT`:
  7933.  *   === true    Use Uint8Array implementation (fastest)
  7934.  *   === false   Use Object implementation (most compatible, even IE6)
  7935.  *
  7936.  * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
  7937.  * Opera 11.6+, iOS 4.2+.
  7938.  *
  7939.  * Due to various browser bugs, sometimes the Object implementation will be used even
  7940.  * when the browser supports typed arrays.
  7941.  *
  7942.  * Note:
  7943.  *
  7944.  *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
  7945.  *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
  7946.  *
  7947.  *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
  7948.  *
  7949.  *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
  7950.  *     incorrect length in some situations.
  7951.  
  7952.  * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
  7953.  * get the Object implementation, which is slower but behaves correctly.
  7954.  */
  7955. Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined
  7956.   ? global.TYPED_ARRAY_SUPPORT
  7957.   : typedArraySupport()
  7958.  
  7959. /*
  7960.  * Export kMaxLength after typed array support is determined.
  7961.  */
  7962. exports.kMaxLength = kMaxLength()
  7963.  
  7964. function typedArraySupport () {
  7965.   try {
  7966.     var arr = new Uint8Array(1)
  7967.     arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}
  7968.     return arr.foo() === 42 && // typed array instances can be augmented
  7969.         typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
  7970.         arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`
  7971.   } catch (e) {
  7972.     return false
  7973.   }
  7974. }
  7975.  
  7976. function kMaxLength () {
  7977.   return Buffer.TYPED_ARRAY_SUPPORT
  7978.     ? 0x7fffffff
  7979.     : 0x3fffffff
  7980. }
  7981.  
  7982. function createBuffer (that, length) {
  7983.   if (kMaxLength() < length) {
  7984.     throw new RangeError('Invalid typed array length')
  7985.   }
  7986.   if (Buffer.TYPED_ARRAY_SUPPORT) {
  7987.     // Return an augmented `Uint8Array` instance, for best performance
  7988.     that = new Uint8Array(length)
  7989.     that.__proto__ = Buffer.prototype
  7990.   } else {
  7991.     // Fallback: Return an object instance of the Buffer class
  7992.     if (that === null) {
  7993.       that = new Buffer(length)
  7994.     }
  7995.     that.length = length
  7996.   }
  7997.  
  7998.   return that
  7999. }
  8000.  
  8001. /**
  8002.  * The Buffer constructor returns instances of `Uint8Array` that have their
  8003.  * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
  8004.  * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
  8005.  * and the `Uint8Array` methods. Square bracket notation works as expected -- it
  8006.  * returns a single octet.
  8007.  *
  8008.  * The `Uint8Array` prototype remains unmodified.
  8009.  */
  8010.  
  8011. function Buffer (arg, encodingOrOffset, length) {
  8012.   if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {
  8013.     return new Buffer(arg, encodingOrOffset, length)
  8014.   }
  8015.  
  8016.   // Common case.
  8017.   if (typeof arg === 'number') {
  8018.     if (typeof encodingOrOffset === 'string') {
  8019.       throw new Error(
  8020.         'If encoding is specified then the first argument must be a string'
  8021.       )
  8022.     }
  8023.     return allocUnsafe(this, arg)
  8024.   }
  8025.   return from(this, arg, encodingOrOffset, length)
  8026. }
  8027.  
  8028. Buffer.poolSize = 8192 // not used by this implementation
  8029.  
  8030. // TODO: Legacy, not needed anymore. Remove in next major version.
  8031. Buffer._augment = function (arr) {
  8032.   arr.__proto__ = Buffer.prototype
  8033.   return arr
  8034. }
  8035.  
  8036. function from (that, value, encodingOrOffset, length) {
  8037.   if (typeof value === 'number') {
  8038.     throw new TypeError('"value" argument must not be a number')
  8039.   }
  8040.  
  8041.   if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
  8042.     return fromArrayBuffer(that, value, encodingOrOffset, length)
  8043.   }
  8044.  
  8045.   if (typeof value === 'string') {
  8046.     return fromString(that, value, encodingOrOffset)
  8047.   }
  8048.  
  8049.   return fromObject(that, value)
  8050. }
  8051.  
  8052. /**
  8053.  * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
  8054.  * if value is a number.
  8055.  * Buffer.from(str[, encoding])
  8056.  * Buffer.from(array)
  8057.  * Buffer.from(buffer)
  8058.  * Buffer.from(arrayBuffer[, byteOffset[, length]])
  8059.  **/
  8060. Buffer.from = function (value, encodingOrOffset, length) {
  8061.   return from(null, value, encodingOrOffset, length)
  8062. }
  8063.  
  8064. if (Buffer.TYPED_ARRAY_SUPPORT) {
  8065.   Buffer.prototype.__proto__ = Uint8Array.prototype
  8066.   Buffer.__proto__ = Uint8Array
  8067.   if (typeof Symbol !== 'undefined' && Symbol.species &&
  8068.       Buffer[Symbol.species] === Buffer) {
  8069.     // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
  8070.     Object.defineProperty(Buffer, Symbol.species, {
  8071.       value: null,
  8072.       configurable: true
  8073.     })
  8074.   }
  8075. }
  8076.  
  8077. function assertSize (size) {
  8078.   if (typeof size !== 'number') {
  8079.     throw new TypeError('"size" argument must be a number')
  8080.   } else if (size < 0) {
  8081.     throw new RangeError('"size" argument must not be negative')
  8082.   }
  8083. }
  8084.  
  8085. function alloc (that, size, fill, encoding) {
  8086.   assertSize(size)
  8087.   if (size <= 0) {
  8088.     return createBuffer(that, size)
  8089.   }
  8090.   if (fill !== undefined) {
  8091.     // Only pay attention to encoding if it's a string. This
  8092.     // prevents accidentally sending in a number that would
  8093.     // be interpretted as a start offset.
  8094.     return typeof encoding === 'string'
  8095.       ? createBuffer(that, size).fill(fill, encoding)
  8096.       : createBuffer(that, size).fill(fill)
  8097.   }
  8098.   return createBuffer(that, size)
  8099. }
  8100.  
  8101. /**
  8102.  * Creates a new filled Buffer instance.
  8103.  * alloc(size[, fill[, encoding]])
  8104.  **/
  8105. Buffer.alloc = function (size, fill, encoding) {
  8106.   return alloc(null, size, fill, encoding)
  8107. }
  8108.  
  8109. function allocUnsafe (that, size) {
  8110.   assertSize(size)
  8111.   that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)
  8112.   if (!Buffer.TYPED_ARRAY_SUPPORT) {
  8113.     for (var i = 0; i < size; ++i) {
  8114.       that[i] = 0
  8115.     }
  8116.   }
  8117.   return that
  8118. }
  8119.  
  8120. /**
  8121.  * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
  8122.  * */
  8123. Buffer.allocUnsafe = function (size) {
  8124.   return allocUnsafe(null, size)
  8125. }
  8126. /**
  8127.  * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
  8128.  */
  8129. Buffer.allocUnsafeSlow = function (size) {
  8130.   return allocUnsafe(null, size)
  8131. }
  8132.  
  8133. function fromString (that, string, encoding) {
  8134.   if (typeof encoding !== 'string' || encoding === '') {
  8135.     encoding = 'utf8'
  8136.   }
  8137.  
  8138.   if (!Buffer.isEncoding(encoding)) {
  8139.     throw new TypeError('"encoding" must be a valid string encoding')
  8140.   }
  8141.  
  8142.   var length = byteLength(string, encoding) | 0
  8143.   that = createBuffer(that, length)
  8144.  
  8145.   var actual = that.write(string, encoding)
  8146.  
  8147.   if (actual !== length) {
  8148.     // Writing a hex string, for example, that contains invalid characters will
  8149.     // cause everything after the first invalid character to be ignored. (e.g.
  8150.     // 'abxxcd' will be treated as 'ab')
  8151.     that = that.slice(0, actual)
  8152.   }
  8153.  
  8154.   return that
  8155. }
  8156.  
  8157. function fromArrayLike (that, array) {
  8158.   var length = array.length < 0 ? 0 : checked(array.length) | 0
  8159.   that = createBuffer(that, length)
  8160.   for (var i = 0; i < length; i += 1) {
  8161.     that[i] = array[i] & 255
  8162.   }
  8163.   return that
  8164. }
  8165.  
  8166. function fromArrayBuffer (that, array, byteOffset, length) {
  8167.   array.byteLength // this throws if `array` is not a valid ArrayBuffer
  8168.  
  8169.   if (byteOffset < 0 || array.byteLength < byteOffset) {
  8170.     throw new RangeError('\'offset\' is out of bounds')
  8171.   }
  8172.  
  8173.   if (array.byteLength < byteOffset + (length || 0)) {
  8174.     throw new RangeError('\'length\' is out of bounds')
  8175.   }
  8176.  
  8177.   if (byteOffset === undefined && length === undefined) {
  8178.     array = new Uint8Array(array)
  8179.   } else if (length === undefined) {
  8180.     array = new Uint8Array(array, byteOffset)
  8181.   } else {
  8182.     array = new Uint8Array(array, byteOffset, length)
  8183.   }
  8184.  
  8185.   if (Buffer.TYPED_ARRAY_SUPPORT) {
  8186.     // Return an augmented `Uint8Array` instance, for best performance
  8187.     that = array
  8188.     that.__proto__ = Buffer.prototype
  8189.   } else {
  8190.     // Fallback: Return an object instance of the Buffer class
  8191.     that = fromArrayLike(that, array)
  8192.   }
  8193.   return that
  8194. }
  8195.  
  8196. function fromObject (that, obj) {
  8197.   if (Buffer.isBuffer(obj)) {
  8198.     var len = checked(obj.length) | 0
  8199.     that = createBuffer(that, len)
  8200.  
  8201.     if (that.length === 0) {
  8202.       return that
  8203.     }
  8204.  
  8205.     obj.copy(that, 0, 0, len)
  8206.     return that
  8207.   }
  8208.  
  8209.   if (obj) {
  8210.     if ((typeof ArrayBuffer !== 'undefined' &&
  8211.         obj.buffer instanceof ArrayBuffer) || 'length' in obj) {
  8212.       if (typeof obj.length !== 'number' || isnan(obj.length)) {
  8213.         return createBuffer(that, 0)
  8214.       }
  8215.       return fromArrayLike(that, obj)
  8216.     }
  8217.  
  8218.     if (obj.type === 'Buffer' && isArray(obj.data)) {
  8219.       return fromArrayLike(that, obj.data)
  8220.     }
  8221.   }
  8222.  
  8223.   throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')
  8224. }
  8225.  
  8226. function checked (length) {
  8227.   // Note: cannot use `length < kMaxLength()` here because that fails when
  8228.   // length is NaN (which is otherwise coerced to zero.)
  8229.   if (length >= kMaxLength()) {
  8230.     throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
  8231.                          'size: 0x' + kMaxLength().toString(16) + ' bytes')
  8232.   }
  8233.   return length | 0
  8234. }
  8235.  
  8236. function SlowBuffer (length) {
  8237.   if (+length != length) { // eslint-disable-line eqeqeq
  8238.     length = 0
  8239.   }
  8240.   return Buffer.alloc(+length)
  8241. }
  8242.  
  8243. Buffer.isBuffer = function isBuffer (b) {
  8244.   return !!(b != null && b._isBuffer)
  8245. }
  8246.  
  8247. Buffer.compare = function compare (a, b) {
  8248.   if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
  8249.     throw new TypeError('Arguments must be Buffers')
  8250.   }
  8251.  
  8252.   if (a === b) return 0
  8253.  
  8254.   var x = a.length
  8255.   var y = b.length
  8256.  
  8257.   for (var i = 0, len = Math.min(x, y); i < len; ++i) {
  8258.     if (a[i] !== b[i]) {
  8259.       x = a[i]
  8260.       y = b[i]
  8261.       break
  8262.     }
  8263.   }
  8264.  
  8265.   if (x < y) return -1
  8266.   if (y < x) return 1
  8267.   return 0
  8268. }
  8269.  
  8270. Buffer.isEncoding = function isEncoding (encoding) {
  8271.   switch (String(encoding).toLowerCase()) {
  8272.     case 'hex':
  8273.     case 'utf8':
  8274.     case 'utf-8':
  8275.     case 'ascii':
  8276.     case 'latin1':
  8277.     case 'binary':
  8278.     case 'base64':
  8279.     case 'ucs2':
  8280.     case 'ucs-2':
  8281.     case 'utf16le':
  8282.     case 'utf-16le':
  8283.       return true
  8284.     default:
  8285.       return false
  8286.   }
  8287. }
  8288.  
  8289. Buffer.concat = function concat (list, length) {
  8290.   if (!isArray(list)) {
  8291.     throw new TypeError('"list" argument must be an Array of Buffers')
  8292.   }
  8293.  
  8294.   if (list.length === 0) {
  8295.     return Buffer.alloc(0)
  8296.   }
  8297.  
  8298.   var i
  8299.   if (length === undefined) {
  8300.     length = 0
  8301.     for (i = 0; i < list.length; ++i) {
  8302.       length += list[i].length
  8303.     }
  8304.   }
  8305.  
  8306.   var buffer = Buffer.allocUnsafe(length)
  8307.   var pos = 0
  8308.   for (i = 0; i < list.length; ++i) {
  8309.     var buf = list[i]
  8310.     if (!Buffer.isBuffer(buf)) {
  8311.       throw new TypeError('"list" argument must be an Array of Buffers')
  8312.     }
  8313.     buf.copy(buffer, pos)
  8314.     pos += buf.length
  8315.   }
  8316.   return buffer
  8317. }
  8318.  
  8319. function byteLength (string, encoding) {
  8320.   if (Buffer.isBuffer(string)) {
  8321.     return string.length
  8322.   }
  8323.   if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&
  8324.       (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {
  8325.     return string.byteLength
  8326.   }
  8327.   if (typeof string !== 'string') {
  8328.     string = '' + string
  8329.   }
  8330.  
  8331.   var len = string.length
  8332.   if (len === 0) return 0
  8333.  
  8334.   // Use a for loop to avoid recursion
  8335.   var loweredCase = false
  8336.   for (;;) {
  8337.     switch (encoding) {
  8338.       case 'ascii':
  8339.       case 'latin1':
  8340.       case 'binary':
  8341.         return len
  8342.       case 'utf8':
  8343.       case 'utf-8':
  8344.       case undefined:
  8345.         return utf8ToBytes(string).length
  8346.       case 'ucs2':
  8347.       case 'ucs-2':
  8348.       case 'utf16le':
  8349.       case 'utf-16le':
  8350.         return len * 2
  8351.       case 'hex':
  8352.         return len >>> 1
  8353.       case 'base64':
  8354.         return base64ToBytes(string).length
  8355.       default:
  8356.         if (loweredCase) return utf8ToBytes(string).length // assume utf8
  8357.         encoding = ('' + encoding).toLowerCase()
  8358.         loweredCase = true
  8359.     }
  8360.   }
  8361. }
  8362. Buffer.byteLength = byteLength
  8363.  
  8364. function slowToString (encoding, start, end) {
  8365.   var loweredCase = false
  8366.  
  8367.   // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
  8368.   // property of a typed array.
  8369.  
  8370.   // This behaves neither like String nor Uint8Array in that we set start/end
  8371.   // to their upper/lower bounds if the value passed is out of range.
  8372.   // undefined is handled specially as per ECMA-262 6th Edition,
  8373.   // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
  8374.   if (start === undefined || start < 0) {
  8375.     start = 0
  8376.   }
  8377.   // Return early if start > this.length. Done here to prevent potential uint32
  8378.   // coercion fail below.
  8379.   if (start > this.length) {
  8380.     return ''
  8381.   }
  8382.  
  8383.   if (end === undefined || end > this.length) {
  8384.     end = this.length
  8385.   }
  8386.  
  8387.   if (end <= 0) {
  8388.     return ''
  8389.   }
  8390.  
  8391.   // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
  8392.   end >>>= 0
  8393.   start >>>= 0
  8394.  
  8395.   if (end <= start) {
  8396.     return ''
  8397.   }
  8398.  
  8399.   if (!encoding) encoding = 'utf8'
  8400.  
  8401.   while (true) {
  8402.     switch (encoding) {
  8403.       case 'hex':
  8404.         return hexSlice(this, start, end)
  8405.  
  8406.       case 'utf8':
  8407.       case 'utf-8':
  8408.         return utf8Slice(this, start, end)
  8409.  
  8410.       case 'ascii':
  8411.         return asciiSlice(this, start, end)
  8412.  
  8413.       case 'latin1':
  8414.       case 'binary':
  8415.         return latin1Slice(this, start, end)
  8416.  
  8417.       case 'base64':
  8418.         return base64Slice(this, start, end)
  8419.  
  8420.       case 'ucs2':
  8421.       case 'ucs-2':
  8422.       case 'utf16le':
  8423.       case 'utf-16le':
  8424.         return utf16leSlice(this, start, end)
  8425.  
  8426.       default:
  8427.         if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
  8428.         encoding = (encoding + '').toLowerCase()
  8429.         loweredCase = true
  8430.     }
  8431.   }
  8432. }
  8433.  
  8434. // The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect
  8435. // Buffer instances.
  8436. Buffer.prototype._isBuffer = true
  8437.  
  8438. function swap (b, n, m) {
  8439.   var i = b[n]
  8440.   b[n] = b[m]
  8441.   b[m] = i
  8442. }
  8443.  
  8444. Buffer.prototype.swap16 = function swap16 () {
  8445.   var len = this.length
  8446.   if (len % 2 !== 0) {
  8447.     throw new RangeError('Buffer size must be a multiple of 16-bits')
  8448.   }
  8449.   for (var i = 0; i < len; i += 2) {
  8450.     swap(this, i, i + 1)
  8451.   }
  8452.   return this
  8453. }
  8454.  
  8455. Buffer.prototype.swap32 = function swap32 () {
  8456.   var len = this.length
  8457.   if (len % 4 !== 0) {
  8458.     throw new RangeError('Buffer size must be a multiple of 32-bits')
  8459.   }
  8460.   for (var i = 0; i < len; i += 4) {
  8461.     swap(this, i, i + 3)
  8462.     swap(this, i + 1, i + 2)
  8463.   }
  8464.   return this
  8465. }
  8466.  
  8467. Buffer.prototype.swap64 = function swap64 () {
  8468.   var len = this.length
  8469.   if (len % 8 !== 0) {
  8470.     throw new RangeError('Buffer size must be a multiple of 64-bits')
  8471.   }
  8472.   for (var i = 0; i < len; i += 8) {
  8473.     swap(this, i, i + 7)
  8474.     swap(this, i + 1, i + 6)
  8475.     swap(this, i + 2, i + 5)
  8476.     swap(this, i + 3, i + 4)
  8477.   }
  8478.   return this
  8479. }
  8480.  
  8481. Buffer.prototype.toString = function toString () {
  8482.   var length = this.length | 0
  8483.   if (length === 0) return ''
  8484.   if (arguments.length === 0) return utf8Slice(this, 0, length)
  8485.   return slowToString.apply(this, arguments)
  8486. }
  8487.  
  8488. Buffer.prototype.equals = function equals (b) {
  8489.   if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
  8490.   if (this === b) return true
  8491.   return Buffer.compare(this, b) === 0
  8492. }
  8493.  
  8494. Buffer.prototype.inspect = function inspect () {
  8495.   var str = ''
  8496.   var max = exports.INSPECT_MAX_BYTES
  8497.   if (this.length > 0) {
  8498.     str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')
  8499.     if (this.length > max) str += ' ... '
  8500.   }
  8501.   return '<Buffer ' + str + '>'
  8502. }
  8503.  
  8504. Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
  8505.   if (!Buffer.isBuffer(target)) {
  8506.     throw new TypeError('Argument must be a Buffer')
  8507.   }
  8508.  
  8509.   if (start === undefined) {
  8510.     start = 0
  8511.   }
  8512.   if (end === undefined) {
  8513.     end = target ? target.length : 0
  8514.   }
  8515.   if (thisStart === undefined) {
  8516.     thisStart = 0
  8517.   }
  8518.   if (thisEnd === undefined) {
  8519.     thisEnd = this.length
  8520.   }
  8521.  
  8522.   if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
  8523.     throw new RangeError('out of range index')
  8524.   }
  8525.  
  8526.   if (thisStart >= thisEnd && start >= end) {
  8527.     return 0
  8528.   }
  8529.   if (thisStart >= thisEnd) {
  8530.     return -1
  8531.   }
  8532.   if (start >= end) {
  8533.     return 1
  8534.   }
  8535.  
  8536.   start >>>= 0
  8537.   end >>>= 0
  8538.   thisStart >>>= 0
  8539.   thisEnd >>>= 0
  8540.  
  8541.   if (this === target) return 0
  8542.  
  8543.   var x = thisEnd - thisStart
  8544.   var y = end - start
  8545.   var len = Math.min(x, y)
  8546.  
  8547.   var thisCopy = this.slice(thisStart, thisEnd)
  8548.   var targetCopy = target.slice(start, end)
  8549.  
  8550.   for (var i = 0; i < len; ++i) {
  8551.     if (thisCopy[i] !== targetCopy[i]) {
  8552.       x = thisCopy[i]
  8553.       y = targetCopy[i]
  8554.       break
  8555.     }
  8556.   }
  8557.  
  8558.   if (x < y) return -1
  8559.   if (y < x) return 1
  8560.   return 0
  8561. }
  8562.  
  8563. // Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
  8564. // OR the last index of `val` in `buffer` at offset <= `byteOffset`.
  8565. //
  8566. // Arguments:
  8567. // - buffer - a Buffer to search
  8568. // - val - a string, Buffer, or number
  8569. // - byteOffset - an index into `buffer`; will be clamped to an int32
  8570. // - encoding - an optional encoding, relevant is val is a string
  8571. // - dir - true for indexOf, false for lastIndexOf
  8572. function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
  8573.   // Empty buffer means no match
  8574.   if (buffer.length === 0) return -1
  8575.  
  8576.   // Normalize byteOffset
  8577.   if (typeof byteOffset === 'string') {
  8578.     encoding = byteOffset
  8579.     byteOffset = 0
  8580.   } else if (byteOffset > 0x7fffffff) {
  8581.     byteOffset = 0x7fffffff
  8582.   } else if (byteOffset < -0x80000000) {
  8583.     byteOffset = -0x80000000
  8584.   }
  8585.   byteOffset = +byteOffset  // Coerce to Number.
  8586.   if (isNaN(byteOffset)) {
  8587.     // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
  8588.     byteOffset = dir ? 0 : (buffer.length - 1)
  8589.   }
  8590.  
  8591.   // Normalize byteOffset: negative offsets start from the end of the buffer
  8592.   if (byteOffset < 0) byteOffset = buffer.length + byteOffset
  8593.   if (byteOffset >= buffer.length) {
  8594.     if (dir) return -1
  8595.     else byteOffset = buffer.length - 1
  8596.   } else if (byteOffset < 0) {
  8597.     if (dir) byteOffset = 0
  8598.     else return -1
  8599.   }
  8600.  
  8601.   // Normalize val
  8602.   if (typeof val === 'string') {
  8603.     val = Buffer.from(val, encoding)
  8604.   }
  8605.  
  8606.   // Finally, search either indexOf (if dir is true) or lastIndexOf
  8607.   if (Buffer.isBuffer(val)) {
  8608.     // Special case: looking for empty string/buffer always fails
  8609.     if (val.length === 0) {
  8610.       return -1
  8611.     }
  8612.     return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
  8613.   } else if (typeof val === 'number') {
  8614.     val = val & 0xFF // Search for a byte value [0-255]
  8615.     if (Buffer.TYPED_ARRAY_SUPPORT &&
  8616.         typeof Uint8Array.prototype.indexOf === 'function') {
  8617.       if (dir) {
  8618.         return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
  8619.       } else {
  8620.         return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
  8621.       }
  8622.     }
  8623.     return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
  8624.   }
  8625.  
  8626.   throw new TypeError('val must be string, number or Buffer')
  8627. }
  8628.  
  8629. function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
  8630.   var indexSize = 1
  8631.   var arrLength = arr.length
  8632.   var valLength = val.length
  8633.  
  8634.   if (encoding !== undefined) {
  8635.     encoding = String(encoding).toLowerCase()
  8636.     if (encoding === 'ucs2' || encoding === 'ucs-2' ||
  8637.         encoding === 'utf16le' || encoding === 'utf-16le') {
  8638.       if (arr.length < 2 || val.length < 2) {
  8639.         return -1
  8640.       }
  8641.       indexSize = 2
  8642.       arrLength /= 2
  8643.       valLength /= 2
  8644.       byteOffset /= 2
  8645.     }
  8646.   }
  8647.  
  8648.   function read (buf, i) {
  8649.     if (indexSize === 1) {
  8650.       return buf[i]
  8651.     } else {
  8652.       return buf.readUInt16BE(i * indexSize)
  8653.     }
  8654.   }
  8655.  
  8656.   var i
  8657.   if (dir) {
  8658.     var foundIndex = -1
  8659.     for (i = byteOffset; i < arrLength; i++) {
  8660.       if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
  8661.         if (foundIndex === -1) foundIndex = i
  8662.         if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
  8663.       } else {
  8664.         if (foundIndex !== -1) i -= i - foundIndex
  8665.         foundIndex = -1
  8666.       }
  8667.     }
  8668.   } else {
  8669.     if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
  8670.     for (i = byteOffset; i >= 0; i--) {
  8671.       var found = true
  8672.       for (var j = 0; j < valLength; j++) {
  8673.         if (read(arr, i + j) !== read(val, j)) {
  8674.           found = false
  8675.           break
  8676.         }
  8677.       }
  8678.       if (found) return i
  8679.     }
  8680.   }
  8681.  
  8682.   return -1
  8683. }
  8684.  
  8685. Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
  8686.   return this.indexOf(val, byteOffset, encoding) !== -1
  8687. }
  8688.  
  8689. Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
  8690.   return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
  8691. }
  8692.  
  8693. Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
  8694.   return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
  8695. }
  8696.  
  8697. function hexWrite (buf, string, offset, length) {
  8698.   offset = Number(offset) || 0
  8699.   var remaining = buf.length - offset
  8700.   if (!length) {
  8701.     length = remaining
  8702.   } else {
  8703.     length = Number(length)
  8704.     if (length > remaining) {
  8705.       length = remaining
  8706.     }
  8707.   }
  8708.  
  8709.   // must be an even number of digits
  8710.   var strLen = string.length
  8711.   if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')
  8712.  
  8713.   if (length > strLen / 2) {
  8714.     length = strLen / 2
  8715.   }
  8716.   for (var i = 0; i < length; ++i) {
  8717.     var parsed = parseInt(string.substr(i * 2, 2), 16)
  8718.     if (isNaN(parsed)) return i
  8719.     buf[offset + i] = parsed
  8720.   }
  8721.   return i
  8722. }
  8723.  
  8724. function utf8Write (buf, string, offset, length) {
  8725.   return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
  8726. }
  8727.  
  8728. function asciiWrite (buf, string, offset, length) {
  8729.   return blitBuffer(asciiToBytes(string), buf, offset, length)
  8730. }
  8731.  
  8732. function latin1Write (buf, string, offset, length) {
  8733.   return asciiWrite(buf, string, offset, length)
  8734. }
  8735.  
  8736. function base64Write (buf, string, offset, length) {
  8737.   return blitBuffer(base64ToBytes(string), buf, offset, length)
  8738. }
  8739.  
  8740. function ucs2Write (buf, string, offset, length) {
  8741.   return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
  8742. }
  8743.  
  8744. Buffer.prototype.write = function write (string, offset, length, encoding) {
  8745.   // Buffer#write(string)
  8746.   if (offset === undefined) {
  8747.     encoding = 'utf8'
  8748.     length = this.length
  8749.     offset = 0
  8750.   // Buffer#write(string, encoding)
  8751.   } else if (length === undefined && typeof offset === 'string') {
  8752.     encoding = offset
  8753.     length = this.length
  8754.     offset = 0
  8755.   // Buffer#write(string, offset[, length][, encoding])
  8756.   } else if (isFinite(offset)) {
  8757.     offset = offset | 0
  8758.     if (isFinite(length)) {
  8759.       length = length | 0
  8760.       if (encoding === undefined) encoding = 'utf8'
  8761.     } else {
  8762.       encoding = length
  8763.       length = undefined
  8764.     }
  8765.   // legacy write(string, encoding, offset, length) - remove in v0.13
  8766.   } else {
  8767.     throw new Error(
  8768.       'Buffer.write(string, encoding, offset[, length]) is no longer supported'
  8769.     )
  8770.   }
  8771.  
  8772.   var remaining = this.length - offset
  8773.   if (length === undefined || length > remaining) length = remaining
  8774.  
  8775.   if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
  8776.     throw new RangeError('Attempt to write outside buffer bounds')
  8777.   }
  8778.  
  8779.   if (!encoding) encoding = 'utf8'
  8780.  
  8781.   var loweredCase = false
  8782.   for (;;) {
  8783.     switch (encoding) {
  8784.       case 'hex':
  8785.         return hexWrite(this, string, offset, length)
  8786.  
  8787.       case 'utf8':
  8788.       case 'utf-8':
  8789.         return utf8Write(this, string, offset, length)
  8790.  
  8791.       case 'ascii':
  8792.         return asciiWrite(this, string, offset, length)
  8793.  
  8794.       case 'latin1':
  8795.       case 'binary':
  8796.         return latin1Write(this, string, offset, length)
  8797.  
  8798.       case 'base64':
  8799.         // Warning: maxLength not taken into account in base64Write
  8800.         return base64Write(this, string, offset, length)
  8801.  
  8802.       case 'ucs2':
  8803.       case 'ucs-2':
  8804.       case 'utf16le':
  8805.       case 'utf-16le':
  8806.         return ucs2Write(this, string, offset, length)
  8807.  
  8808.       default:
  8809.         if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
  8810.         encoding = ('' + encoding).toLowerCase()
  8811.         loweredCase = true
  8812.     }
  8813.   }
  8814. }
  8815.  
  8816. Buffer.prototype.toJSON = function toJSON () {
  8817.   return {
  8818.     type: 'Buffer',
  8819.     data: Array.prototype.slice.call(this._arr || this, 0)
  8820.   }
  8821. }
  8822.  
  8823. function base64Slice (buf, start, end) {
  8824.   if (start === 0 && end === buf.length) {
  8825.     return base64.fromByteArray(buf)
  8826.   } else {
  8827.     return base64.fromByteArray(buf.slice(start, end))
  8828.   }
  8829. }
  8830.  
  8831. function utf8Slice (buf, start, end) {
  8832.   end = Math.min(buf.length, end)
  8833.   var res = []
  8834.  
  8835.   var i = start
  8836.   while (i < end) {
  8837.     var firstByte = buf[i]
  8838.     var codePoint = null
  8839.     var bytesPerSequence = (firstByte > 0xEF) ? 4
  8840.       : (firstByte > 0xDF) ? 3
  8841.       : (firstByte > 0xBF) ? 2
  8842.       : 1
  8843.  
  8844.     if (i + bytesPerSequence <= end) {
  8845.       var secondByte, thirdByte, fourthByte, tempCodePoint
  8846.  
  8847.       switch (bytesPerSequence) {
  8848.         case 1:
  8849.           if (firstByte < 0x80) {
  8850.             codePoint = firstByte
  8851.           }
  8852.           break
  8853.         case 2:
  8854.           secondByte = buf[i + 1]
  8855.           if ((secondByte & 0xC0) === 0x80) {
  8856.             tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
  8857.             if (tempCodePoint > 0x7F) {
  8858.               codePoint = tempCodePoint
  8859.             }
  8860.           }
  8861.           break
  8862.         case 3:
  8863.           secondByte = buf[i + 1]
  8864.           thirdByte = buf[i + 2]
  8865.           if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
  8866.             tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
  8867.             if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
  8868.               codePoint = tempCodePoint
  8869.             }
  8870.           }
  8871.           break
  8872.         case 4:
  8873.           secondByte = buf[i + 1]
  8874.           thirdByte = buf[i + 2]
  8875.           fourthByte = buf[i + 3]
  8876.           if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
  8877.             tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
  8878.             if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
  8879.               codePoint = tempCodePoint
  8880.             }
  8881.           }
  8882.       }
  8883.     }
  8884.  
  8885.     if (codePoint === null) {
  8886.       // we did not generate a valid codePoint so insert a
  8887.       // replacement char (U+FFFD) and advance only 1 byte
  8888.       codePoint = 0xFFFD
  8889.       bytesPerSequence = 1
  8890.     } else if (codePoint > 0xFFFF) {
  8891.       // encode to utf16 (surrogate pair dance)
  8892.       codePoint -= 0x10000
  8893.       res.push(codePoint >>> 10 & 0x3FF | 0xD800)
  8894.       codePoint = 0xDC00 | codePoint & 0x3FF
  8895.     }
  8896.  
  8897.     res.push(codePoint)
  8898.     i += bytesPerSequence
  8899.   }
  8900.  
  8901.   return decodeCodePointsArray(res)
  8902. }
  8903.  
  8904. // Based on http://stackoverflow.com/a/22747272/680742, the browser with
  8905. // the lowest limit is Chrome, with 0x10000 args.
  8906. // We go 1 magnitude less, for safety
  8907. var MAX_ARGUMENTS_LENGTH = 0x1000
  8908.  
  8909. function decodeCodePointsArray (codePoints) {
  8910.   var len = codePoints.length
  8911.   if (len <= MAX_ARGUMENTS_LENGTH) {
  8912.     return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
  8913.   }
  8914.  
  8915.   // Decode in chunks to avoid "call stack size exceeded".
  8916.   var res = ''
  8917.   var i = 0
  8918.   while (i < len) {
  8919.     res += String.fromCharCode.apply(
  8920.       String,
  8921.       codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
  8922.     )
  8923.   }
  8924.   return res
  8925. }
  8926.  
  8927. function asciiSlice (buf, start, end) {
  8928.   var ret = ''
  8929.   end = Math.min(buf.length, end)
  8930.  
  8931.   for (var i = start; i < end; ++i) {
  8932.     ret += String.fromCharCode(buf[i] & 0x7F)
  8933.   }
  8934.   return ret
  8935. }
  8936.  
  8937. function latin1Slice (buf, start, end) {
  8938.   var ret = ''
  8939.   end = Math.min(buf.length, end)
  8940.  
  8941.   for (var i = start; i < end; ++i) {
  8942.     ret += String.fromCharCode(buf[i])
  8943.   }
  8944.   return ret
  8945. }
  8946.  
  8947. function hexSlice (buf, start, end) {
  8948.   var len = buf.length
  8949.  
  8950.   if (!start || start < 0) start = 0
  8951.   if (!end || end < 0 || end > len) end = len
  8952.  
  8953.   var out = ''
  8954.   for (var i = start; i < end; ++i) {
  8955.     out += toHex(buf[i])
  8956.   }
  8957.   return out
  8958. }
  8959.  
  8960. function utf16leSlice (buf, start, end) {
  8961.   var bytes = buf.slice(start, end)
  8962.   var res = ''
  8963.   for (var i = 0; i < bytes.length; i += 2) {
  8964.     res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)
  8965.   }
  8966.   return res
  8967. }
  8968.  
  8969. Buffer.prototype.slice = function slice (start, end) {
  8970.   var len = this.length
  8971.   start = ~~start
  8972.   end = end === undefined ? len : ~~end
  8973.  
  8974.   if (start < 0) {
  8975.     start += len
  8976.     if (start < 0) start = 0
  8977.   } else if (start > len) {
  8978.     start = len
  8979.   }
  8980.  
  8981.   if (end < 0) {
  8982.     end += len
  8983.     if (end < 0) end = 0
  8984.   } else if (end > len) {
  8985.     end = len
  8986.   }
  8987.  
  8988.   if (end < start) end = start
  8989.  
  8990.   var newBuf
  8991.   if (Buffer.TYPED_ARRAY_SUPPORT) {
  8992.     newBuf = this.subarray(start, end)
  8993.     newBuf.__proto__ = Buffer.prototype
  8994.   } else {
  8995.     var sliceLen = end - start
  8996.     newBuf = new Buffer(sliceLen, undefined)
  8997.     for (var i = 0; i < sliceLen; ++i) {
  8998.       newBuf[i] = this[i + start]
  8999.     }
  9000.   }
  9001.  
  9002.   return newBuf
  9003. }
  9004.  
  9005. /*
  9006.  * Need to make sure that buffer isn't trying to write out of bounds.
  9007.  */
  9008. function checkOffset (offset, ext, length) {
  9009.   if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
  9010.   if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
  9011. }
  9012.  
  9013. Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
  9014.   offset = offset | 0
  9015.   byteLength = byteLength | 0
  9016.   if (!noAssert) checkOffset(offset, byteLength, this.length)
  9017.  
  9018.   var val = this[offset]
  9019.   var mul = 1
  9020.   var i = 0
  9021.   while (++i < byteLength && (mul *= 0x100)) {
  9022.     val += this[offset + i] * mul
  9023.   }
  9024.  
  9025.   return val
  9026. }
  9027.  
  9028. Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
  9029.   offset = offset | 0
  9030.   byteLength = byteLength | 0
  9031.   if (!noAssert) {
  9032.     checkOffset(offset, byteLength, this.length)
  9033.   }
  9034.  
  9035.   var val = this[offset + --byteLength]
  9036.   var mul = 1
  9037.   while (byteLength > 0 && (mul *= 0x100)) {
  9038.     val += this[offset + --byteLength] * mul
  9039.   }
  9040.  
  9041.   return val
  9042. }
  9043.  
  9044. Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
  9045.   if (!noAssert) checkOffset(offset, 1, this.length)
  9046.   return this[offset]
  9047. }
  9048.  
  9049. Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
  9050.   if (!noAssert) checkOffset(offset, 2, this.length)
  9051.   return this[offset] | (this[offset + 1] << 8)
  9052. }
  9053.  
  9054. Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
  9055.   if (!noAssert) checkOffset(offset, 2, this.length)
  9056.   return (this[offset] << 8) | this[offset + 1]
  9057. }
  9058.  
  9059. Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
  9060.   if (!noAssert) checkOffset(offset, 4, this.length)
  9061.  
  9062.   return ((this[offset]) |
  9063.       (this[offset + 1] << 8) |
  9064.       (this[offset + 2] << 16)) +
  9065.       (this[offset + 3] * 0x1000000)
  9066. }
  9067.  
  9068. Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
  9069.   if (!noAssert) checkOffset(offset, 4, this.length)
  9070.  
  9071.   return (this[offset] * 0x1000000) +
  9072.     ((this[offset + 1] << 16) |
  9073.     (this[offset + 2] << 8) |
  9074.     this[offset + 3])
  9075. }
  9076.  
  9077. Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
  9078.   offset = offset | 0
  9079.   byteLength = byteLength | 0
  9080.   if (!noAssert) checkOffset(offset, byteLength, this.length)
  9081.  
  9082.   var val = this[offset]
  9083.   var mul = 1
  9084.   var i = 0
  9085.   while (++i < byteLength && (mul *= 0x100)) {
  9086.     val += this[offset + i] * mul
  9087.   }
  9088.   mul *= 0x80
  9089.  
  9090.   if (val >= mul) val -= Math.pow(2, 8 * byteLength)
  9091.  
  9092.   return val
  9093. }
  9094.  
  9095. Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
  9096.   offset = offset | 0
  9097.   byteLength = byteLength | 0
  9098.   if (!noAssert) checkOffset(offset, byteLength, this.length)
  9099.  
  9100.   var i = byteLength
  9101.   var mul = 1
  9102.   var val = this[offset + --i]
  9103.   while (i > 0 && (mul *= 0x100)) {
  9104.     val += this[offset + --i] * mul
  9105.   }
  9106.   mul *= 0x80
  9107.  
  9108.   if (val >= mul) val -= Math.pow(2, 8 * byteLength)
  9109.  
  9110.   return val
  9111. }
  9112.  
  9113. Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
  9114.   if (!noAssert) checkOffset(offset, 1, this.length)
  9115.   if (!(this[offset] & 0x80)) return (this[offset])
  9116.   return ((0xff - this[offset] + 1) * -1)
  9117. }
  9118.  
  9119. Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
  9120.   if (!noAssert) checkOffset(offset, 2, this.length)
  9121.   var val = this[offset] | (this[offset + 1] << 8)
  9122.   return (val & 0x8000) ? val | 0xFFFF0000 : val
  9123. }
  9124.  
  9125. Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
  9126.   if (!noAssert) checkOffset(offset, 2, this.length)
  9127.   var val = this[offset + 1] | (this[offset] << 8)
  9128.   return (val & 0x8000) ? val | 0xFFFF0000 : val
  9129. }
  9130.  
  9131. Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
  9132.   if (!noAssert) checkOffset(offset, 4, this.length)
  9133.  
  9134.   return (this[offset]) |
  9135.     (this[offset + 1] << 8) |
  9136.     (this[offset + 2] << 16) |
  9137.     (this[offset + 3] << 24)
  9138. }
  9139.  
  9140. Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
  9141.   if (!noAssert) checkOffset(offset, 4, this.length)
  9142.  
  9143.   return (this[offset] << 24) |
  9144.     (this[offset + 1] << 16) |
  9145.     (this[offset + 2] << 8) |
  9146.     (this[offset + 3])
  9147. }
  9148.  
  9149. Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
  9150.   if (!noAssert) checkOffset(offset, 4, this.length)
  9151.   return ieee754.read(this, offset, true, 23, 4)
  9152. }
  9153.  
  9154. Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
  9155.   if (!noAssert) checkOffset(offset, 4, this.length)
  9156.   return ieee754.read(this, offset, false, 23, 4)
  9157. }
  9158.  
  9159. Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
  9160.   if (!noAssert) checkOffset(offset, 8, this.length)
  9161.   return ieee754.read(this, offset, true, 52, 8)
  9162. }
  9163.  
  9164. Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
  9165.   if (!noAssert) checkOffset(offset, 8, this.length)
  9166.   return ieee754.read(this, offset, false, 52, 8)
  9167. }
  9168.  
  9169. function checkInt (buf, value, offset, ext, max, min) {
  9170.   if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
  9171.   if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
  9172.   if (offset + ext > buf.length) throw new RangeError('Index out of range')
  9173. }
  9174.  
  9175. Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
  9176.   value = +value
  9177.   offset = offset | 0
  9178.   byteLength = byteLength | 0
  9179.   if (!noAssert) {
  9180.     var maxBytes = Math.pow(2, 8 * byteLength) - 1
  9181.     checkInt(this, value, offset, byteLength, maxBytes, 0)
  9182.   }
  9183.  
  9184.   var mul = 1
  9185.   var i = 0
  9186.   this[offset] = value & 0xFF
  9187.   while (++i < byteLength && (mul *= 0x100)) {
  9188.     this[offset + i] = (value / mul) & 0xFF
  9189.   }
  9190.  
  9191.   return offset + byteLength
  9192. }
  9193.  
  9194. Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
  9195.   value = +value
  9196.   offset = offset | 0
  9197.   byteLength = byteLength | 0
  9198.   if (!noAssert) {
  9199.     var maxBytes = Math.pow(2, 8 * byteLength) - 1
  9200.     checkInt(this, value, offset, byteLength, maxBytes, 0)
  9201.   }
  9202.  
  9203.   var i = byteLength - 1
  9204.   var mul = 1
  9205.   this[offset + i] = value & 0xFF
  9206.   while (--i >= 0 && (mul *= 0x100)) {
  9207.     this[offset + i] = (value / mul) & 0xFF
  9208.   }
  9209.  
  9210.   return offset + byteLength
  9211. }
  9212.  
  9213. Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
  9214.   value = +value
  9215.   offset = offset | 0
  9216.   if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
  9217.   if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
  9218.   this[offset] = (value & 0xff)
  9219.   return offset + 1
  9220. }
  9221.  
  9222. function objectWriteUInt16 (buf, value, offset, littleEndian) {
  9223.   if (value < 0) value = 0xffff + value + 1
  9224.   for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {
  9225.     buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
  9226.       (littleEndian ? i : 1 - i) * 8
  9227.   }
  9228. }
  9229.  
  9230. Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
  9231.   value = +value
  9232.   offset = offset | 0
  9233.   if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
  9234.   if (Buffer.TYPED_ARRAY_SUPPORT) {
  9235.     this[offset] = (value & 0xff)
  9236.     this[offset + 1] = (value >>> 8)
  9237.   } else {
  9238.     objectWriteUInt16(this, value, offset, true)
  9239.   }
  9240.   return offset + 2
  9241. }
  9242.  
  9243. Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
  9244.   value = +value
  9245.   offset = offset | 0
  9246.   if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
  9247.   if (Buffer.TYPED_ARRAY_SUPPORT) {
  9248.     this[offset] = (value >>> 8)
  9249.     this[offset + 1] = (value & 0xff)
  9250.   } else {
  9251.     objectWriteUInt16(this, value, offset, false)
  9252.   }
  9253.   return offset + 2
  9254. }
  9255.  
  9256. function objectWriteUInt32 (buf, value, offset, littleEndian) {
  9257.   if (value < 0) value = 0xffffffff + value + 1
  9258.   for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {
  9259.     buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
  9260.   }
  9261. }
  9262.  
  9263. Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
  9264.   value = +value
  9265.   offset = offset | 0
  9266.   if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
  9267.   if (Buffer.TYPED_ARRAY_SUPPORT) {
  9268.     this[offset + 3] = (value >>> 24)
  9269.     this[offset + 2] = (value >>> 16)
  9270.     this[offset + 1] = (value >>> 8)
  9271.     this[offset] = (value & 0xff)
  9272.   } else {
  9273.     objectWriteUInt32(this, value, offset, true)
  9274.   }
  9275.   return offset + 4
  9276. }
  9277.  
  9278. Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
  9279.   value = +value
  9280.   offset = offset | 0
  9281.   if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
  9282.   if (Buffer.TYPED_ARRAY_SUPPORT) {
  9283.     this[offset] = (value >>> 24)
  9284.     this[offset + 1] = (value >>> 16)
  9285.     this[offset + 2] = (value >>> 8)
  9286.     this[offset + 3] = (value & 0xff)
  9287.   } else {
  9288.     objectWriteUInt32(this, value, offset, false)
  9289.   }
  9290.   return offset + 4
  9291. }
  9292.  
  9293. Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
  9294.   value = +value
  9295.   offset = offset | 0
  9296.   if (!noAssert) {
  9297.     var limit = Math.pow(2, 8 * byteLength - 1)
  9298.  
  9299.     checkInt(this, value, offset, byteLength, limit - 1, -limit)
  9300.   }
  9301.  
  9302.   var i = 0
  9303.   var mul = 1
  9304.   var sub = 0
  9305.   this[offset] = value & 0xFF
  9306.   while (++i < byteLength && (mul *= 0x100)) {
  9307.     if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
  9308.       sub = 1
  9309.     }
  9310.     this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
  9311.   }
  9312.  
  9313.   return offset + byteLength
  9314. }
  9315.  
  9316. Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
  9317.   value = +value
  9318.   offset = offset | 0
  9319.   if (!noAssert) {
  9320.     var limit = Math.pow(2, 8 * byteLength - 1)
  9321.  
  9322.     checkInt(this, value, offset, byteLength, limit - 1, -limit)
  9323.   }
  9324.  
  9325.   var i = byteLength - 1
  9326.   var mul = 1
  9327.   var sub = 0
  9328.   this[offset + i] = value & 0xFF
  9329.   while (--i >= 0 && (mul *= 0x100)) {
  9330.     if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
  9331.       sub = 1
  9332.     }
  9333.     this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
  9334.   }
  9335.  
  9336.   return offset + byteLength
  9337. }
  9338.  
  9339. Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
  9340.   value = +value
  9341.   offset = offset | 0
  9342.   if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
  9343.   if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
  9344.   if (value < 0) value = 0xff + value + 1
  9345.   this[offset] = (value & 0xff)
  9346.   return offset + 1
  9347. }
  9348.  
  9349. Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
  9350.   value = +value
  9351.   offset = offset | 0
  9352.   if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
  9353.   if (Buffer.TYPED_ARRAY_SUPPORT) {
  9354.     this[offset] = (value & 0xff)
  9355.     this[offset + 1] = (value >>> 8)
  9356.   } else {
  9357.     objectWriteUInt16(this, value, offset, true)
  9358.   }
  9359.   return offset + 2
  9360. }
  9361.  
  9362. Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
  9363.   value = +value
  9364.   offset = offset | 0
  9365.   if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
  9366.   if (Buffer.TYPED_ARRAY_SUPPORT) {
  9367.     this[offset] = (value >>> 8)
  9368.     this[offset + 1] = (value & 0xff)
  9369.   } else {
  9370.     objectWriteUInt16(this, value, offset, false)
  9371.   }
  9372.   return offset + 2
  9373. }
  9374.  
  9375. Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
  9376.   value = +value
  9377.   offset = offset | 0
  9378.   if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
  9379.   if (Buffer.TYPED_ARRAY_SUPPORT) {
  9380.     this[offset] = (value & 0xff)
  9381.     this[offset + 1] = (value >>> 8)
  9382.     this[offset + 2] = (value >>> 16)
  9383.     this[offset + 3] = (value >>> 24)
  9384.   } else {
  9385.     objectWriteUInt32(this, value, offset, true)
  9386.   }
  9387.   return offset + 4
  9388. }
  9389.  
  9390. Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
  9391.   value = +value
  9392.   offset = offset | 0
  9393.   if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
  9394.   if (value < 0) value = 0xffffffff + value + 1
  9395.   if (Buffer.TYPED_ARRAY_SUPPORT) {
  9396.     this[offset] = (value >>> 24)
  9397.     this[offset + 1] = (value >>> 16)
  9398.     this[offset + 2] = (value >>> 8)
  9399.     this[offset + 3] = (value & 0xff)
  9400.   } else {
  9401.     objectWriteUInt32(this, value, offset, false)
  9402.   }
  9403.   return offset + 4
  9404. }
  9405.  
  9406. function checkIEEE754 (buf, value, offset, ext, max, min) {
  9407.   if (offset + ext > buf.length) throw new RangeError('Index out of range')
  9408.   if (offset < 0) throw new RangeError('Index out of range')
  9409. }
  9410.  
  9411. function writeFloat (buf, value, offset, littleEndian, noAssert) {
  9412.   if (!noAssert) {
  9413.     checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
  9414.   }
  9415.   ieee754.write(buf, value, offset, littleEndian, 23, 4)
  9416.   return offset + 4
  9417. }
  9418.  
  9419. Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
  9420.   return writeFloat(this, value, offset, true, noAssert)
  9421. }
  9422.  
  9423. Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
  9424.   return writeFloat(this, value, offset, false, noAssert)
  9425. }
  9426.  
  9427. function writeDouble (buf, value, offset, littleEndian, noAssert) {
  9428.   if (!noAssert) {
  9429.     checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
  9430.   }
  9431.   ieee754.write(buf, value, offset, littleEndian, 52, 8)
  9432.   return offset + 8
  9433. }
  9434.  
  9435. Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
  9436.   return writeDouble(this, value, offset, true, noAssert)
  9437. }
  9438.  
  9439. Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
  9440.   return writeDouble(this, value, offset, false, noAssert)
  9441. }
  9442.  
  9443. // copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
  9444. Buffer.prototype.copy = function copy (target, targetStart, start, end) {
  9445.   if (!start) start = 0
  9446.   if (!end && end !== 0) end = this.length
  9447.   if (targetStart >= target.length) targetStart = target.length
  9448.   if (!targetStart) targetStart = 0
  9449.   if (end > 0 && end < start) end = start
  9450.  
  9451.   // Copy 0 bytes; we're done
  9452.   if (end === start) return 0
  9453.   if (target.length === 0 || this.length === 0) return 0
  9454.  
  9455.   // Fatal error conditions
  9456.   if (targetStart < 0) {
  9457.     throw new RangeError('targetStart out of bounds')
  9458.   }
  9459.   if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')
  9460.   if (end < 0) throw new RangeError('sourceEnd out of bounds')
  9461.  
  9462.   // Are we oob?
  9463.   if (end > this.length) end = this.length
  9464.   if (target.length - targetStart < end - start) {
  9465.     end = target.length - targetStart + start
  9466.   }
  9467.  
  9468.   var len = end - start
  9469.   var i
  9470.  
  9471.   if (this === target && start < targetStart && targetStart < end) {
  9472.     // descending copy from end
  9473.     for (i = len - 1; i >= 0; --i) {
  9474.       target[i + targetStart] = this[i + start]
  9475.     }
  9476.   } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
  9477.     // ascending copy from start
  9478.     for (i = 0; i < len; ++i) {
  9479.       target[i + targetStart] = this[i + start]
  9480.     }
  9481.   } else {
  9482.     Uint8Array.prototype.set.call(
  9483.       target,
  9484.       this.subarray(start, start + len),
  9485.       targetStart
  9486.     )
  9487.   }
  9488.  
  9489.   return len
  9490. }
  9491.  
  9492. // Usage:
  9493. //    buffer.fill(number[, offset[, end]])
  9494. //    buffer.fill(buffer[, offset[, end]])
  9495. //    buffer.fill(string[, offset[, end]][, encoding])
  9496. Buffer.prototype.fill = function fill (val, start, end, encoding) {
  9497.   // Handle string cases:
  9498.   if (typeof val === 'string') {
  9499.     if (typeof start === 'string') {
  9500.       encoding = start
  9501.       start = 0
  9502.       end = this.length
  9503.     } else if (typeof end === 'string') {
  9504.       encoding = end
  9505.       end = this.length
  9506.     }
  9507.     if (val.length === 1) {
  9508.       var code = val.charCodeAt(0)
  9509.       if (code < 256) {
  9510.         val = code
  9511.       }
  9512.     }
  9513.     if (encoding !== undefined && typeof encoding !== 'string') {
  9514.       throw new TypeError('encoding must be a string')
  9515.     }
  9516.     if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
  9517.       throw new TypeError('Unknown encoding: ' + encoding)
  9518.     }
  9519.   } else if (typeof val === 'number') {
  9520.     val = val & 255
  9521.   }
  9522.  
  9523.   // Invalid ranges are not set to a default, so can range check early.
  9524.   if (start < 0 || this.length < start || this.length < end) {
  9525.     throw new RangeError('Out of range index')
  9526.   }
  9527.  
  9528.   if (end <= start) {
  9529.     return this
  9530.   }
  9531.  
  9532.   start = start >>> 0
  9533.   end = end === undefined ? this.length : end >>> 0
  9534.  
  9535.   if (!val) val = 0
  9536.  
  9537.   var i
  9538.   if (typeof val === 'number') {
  9539.     for (i = start; i < end; ++i) {
  9540.       this[i] = val
  9541.     }
  9542.   } else {
  9543.     var bytes = Buffer.isBuffer(val)
  9544.       ? val
  9545.       : utf8ToBytes(new Buffer(val, encoding).toString())
  9546.     var len = bytes.length
  9547.     for (i = 0; i < end - start; ++i) {
  9548.       this[i + start] = bytes[i % len]
  9549.     }
  9550.   }
  9551.  
  9552.   return this
  9553. }
  9554.  
  9555. // HELPER FUNCTIONS
  9556. // ================
  9557.  
  9558. var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g
  9559.  
  9560. function base64clean (str) {
  9561.   // Node strips out invalid characters like \n and \t from the string, base64-js does not
  9562.   str = stringtrim(str).replace(INVALID_BASE64_RE, '')
  9563.   // Node converts strings with length < 2 to ''
  9564.   if (str.length < 2) return ''
  9565.   // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
  9566.   while (str.length % 4 !== 0) {
  9567.     str = str + '='
  9568.   }
  9569.   return str
  9570. }
  9571.  
  9572. function stringtrim (str) {
  9573.   if (str.trim) return str.trim()
  9574.   return str.replace(/^\s+|\s+$/g, '')
  9575. }
  9576.  
  9577. function toHex (n) {
  9578.   if (n < 16) return '0' + n.toString(16)
  9579.   return n.toString(16)
  9580. }
  9581.  
  9582. function utf8ToBytes (string, units) {
  9583.   units = units || Infinity
  9584.   var codePoint
  9585.   var length = string.length
  9586.   var leadSurrogate = null
  9587.   var bytes = []
  9588.  
  9589.   for (var i = 0; i < length; ++i) {
  9590.     codePoint = string.charCodeAt(i)
  9591.  
  9592.     // is surrogate component
  9593.     if (codePoint > 0xD7FF && codePoint < 0xE000) {
  9594.       // last char was a lead
  9595.       if (!leadSurrogate) {
  9596.         // no lead yet
  9597.         if (codePoint > 0xDBFF) {
  9598.           // unexpected trail
  9599.           if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
  9600.           continue
  9601.         } else if (i + 1 === length) {
  9602.           // unpaired lead
  9603.           if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
  9604.           continue
  9605.         }
  9606.  
  9607.         // valid lead
  9608.         leadSurrogate = codePoint
  9609.  
  9610.         continue
  9611.       }
  9612.  
  9613.       // 2 leads in a row
  9614.       if (codePoint < 0xDC00) {
  9615.         if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
  9616.         leadSurrogate = codePoint
  9617.         continue
  9618.       }
  9619.  
  9620.       // valid surrogate pair
  9621.       codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
  9622.     } else if (leadSurrogate) {
  9623.       // valid bmp char, but last char was a lead
  9624.       if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
  9625.     }
  9626.  
  9627.     leadSurrogate = null
  9628.  
  9629.     // encode utf8
  9630.     if (codePoint < 0x80) {
  9631.       if ((units -= 1) < 0) break
  9632.       bytes.push(codePoint)
  9633.     } else if (codePoint < 0x800) {
  9634.       if ((units -= 2) < 0) break
  9635.       bytes.push(
  9636.         codePoint >> 0x6 | 0xC0,
  9637.         codePoint & 0x3F | 0x80
  9638.       )
  9639.     } else if (codePoint < 0x10000) {
  9640.       if ((units -= 3) < 0) break
  9641.       bytes.push(
  9642.         codePoint >> 0xC | 0xE0,
  9643.         codePoint >> 0x6 & 0x3F | 0x80,
  9644.         codePoint & 0x3F | 0x80
  9645.       )
  9646.     } else if (codePoint < 0x110000) {
  9647.       if ((units -= 4) < 0) break
  9648.       bytes.push(
  9649.         codePoint >> 0x12 | 0xF0,
  9650.         codePoint >> 0xC & 0x3F | 0x80,
  9651.         codePoint >> 0x6 & 0x3F | 0x80,
  9652.         codePoint & 0x3F | 0x80
  9653.       )
  9654.     } else {
  9655.       throw new Error('Invalid code point')
  9656.     }
  9657.   }
  9658.  
  9659.   return bytes
  9660. }
  9661.  
  9662. function asciiToBytes (str) {
  9663.   var byteArray = []
  9664.   for (var i = 0; i < str.length; ++i) {
  9665.     // Node's code seems to be doing this and not & 0x7F..
  9666.     byteArray.push(str.charCodeAt(i) & 0xFF)
  9667.   }
  9668.   return byteArray
  9669. }
  9670.  
  9671. function utf16leToBytes (str, units) {
  9672.   var c, hi, lo
  9673.   var byteArray = []
  9674.   for (var i = 0; i < str.length; ++i) {
  9675.     if ((units -= 2) < 0) break
  9676.  
  9677.     c = str.charCodeAt(i)
  9678.     hi = c >> 8
  9679.     lo = c % 256
  9680.     byteArray.push(lo)
  9681.     byteArray.push(hi)
  9682.   }
  9683.  
  9684.   return byteArray
  9685. }
  9686.  
  9687. function base64ToBytes (str) {
  9688.   return base64.toByteArray(base64clean(str))
  9689. }
  9690.  
  9691. function blitBuffer (src, dst, offset, length) {
  9692.   for (var i = 0; i < length; ++i) {
  9693.     if ((i + offset >= dst.length) || (i >= src.length)) break
  9694.     dst[i + offset] = src[i]
  9695.   }
  9696.   return i
  9697. }
  9698.  
  9699. function isnan (val) {
  9700.   return val !== val // eslint-disable-line no-self-compare
  9701. }
  9702.  
  9703. /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(8)))
  9704.  
  9705. /***/ }),
  9706. /* 63 */
  9707. /***/ (function(module, exports, __webpack_require__) {
  9708.  
  9709. __webpack_require__(48);
  9710. __webpack_require__(90);
  9711. module.exports = __webpack_require__(2).Array.from;
  9712.  
  9713. /***/ }),
  9714. /* 64 */
  9715. /***/ (function(module, exports, __webpack_require__) {
  9716.  
  9717. var core  = __webpack_require__(2)
  9718.   , $JSON = core.JSON || (core.JSON = {stringify: JSON.stringify});
  9719. module.exports = function stringify(it){ // eslint-disable-line no-unused-vars
  9720.   return $JSON.stringify.apply($JSON, arguments);
  9721. };
  9722.  
  9723. /***/ }),
  9724. /* 65 */
  9725. /***/ (function(module, exports, __webpack_require__) {
  9726.  
  9727. __webpack_require__(92);
  9728. var $Object = __webpack_require__(2).Object;
  9729. module.exports = function defineProperty(it, key, desc){
  9730.   return $Object.defineProperty(it, key, desc);
  9731. };
  9732.  
  9733. /***/ }),
  9734. /* 66 */
  9735. /***/ (function(module, exports, __webpack_require__) {
  9736.  
  9737. __webpack_require__(93);
  9738. __webpack_require__(48);
  9739. __webpack_require__(95);
  9740. __webpack_require__(94);
  9741. module.exports = __webpack_require__(2).Promise;
  9742.  
  9743. /***/ }),
  9744. /* 67 */
  9745. /***/ (function(module, exports) {
  9746.  
  9747. module.exports = function(){ /* empty */ };
  9748.  
  9749. /***/ }),
  9750. /* 68 */
  9751. /***/ (function(module, exports) {
  9752.  
  9753. module.exports = function(it, Constructor, name, forbiddenField){
  9754.   if(!(it instanceof Constructor) || (forbiddenField !== undefined && forbiddenField in it)){
  9755.     throw TypeError(name + ': incorrect invocation!');
  9756.   } return it;
  9757. };
  9758.  
  9759. /***/ }),
  9760. /* 69 */
  9761. /***/ (function(module, exports, __webpack_require__) {
  9762.  
  9763. // false -> Array#indexOf
  9764. // true  -> Array#includes
  9765. var toIObject = __webpack_require__(28)
  9766.   , toLength  = __webpack_require__(29)
  9767.   , toIndex   = __webpack_require__(88);
  9768. module.exports = function(IS_INCLUDES){
  9769.   return function($this, el, fromIndex){
  9770.     var O      = toIObject($this)
  9771.       , length = toLength(O.length)
  9772.       , index  = toIndex(fromIndex, length)
  9773.       , value;
  9774.     // Array#includes uses SameValueZero equality algorithm
  9775.     if(IS_INCLUDES && el != el)while(length > index){
  9776.       value = O[index++];
  9777.       if(value != value)return true;
  9778.     // Array#toIndex ignores holes, Array#includes - not
  9779.     } else for(;length > index; index++)if(IS_INCLUDES || index in O){
  9780.       if(O[index] === el)return IS_INCLUDES || index || 0;
  9781.     } return !IS_INCLUDES && -1;
  9782.   };
  9783. };
  9784.  
  9785. /***/ }),
  9786. /* 70 */
  9787. /***/ (function(module, exports, __webpack_require__) {
  9788.  
  9789. "use strict";
  9790.  
  9791. var $defineProperty = __webpack_require__(7)
  9792.   , createDesc      = __webpack_require__(24);
  9793.  
  9794. module.exports = function(object, index, value){
  9795.   if(index in object)$defineProperty.f(object, index, createDesc(0, value));
  9796.   else object[index] = value;
  9797. };
  9798.  
  9799. /***/ }),
  9800. /* 71 */
  9801. /***/ (function(module, exports, __webpack_require__) {
  9802.  
  9803. var ctx         = __webpack_require__(12)
  9804.   , call        = __webpack_require__(39)
  9805.   , isArrayIter = __webpack_require__(38)
  9806.   , anObject    = __webpack_require__(4)
  9807.   , toLength    = __webpack_require__(29)
  9808.   , getIterFn   = __webpack_require__(47)
  9809.   , BREAK       = {}
  9810.   , RETURN      = {};
  9811. var exports = module.exports = function(iterable, entries, fn, that, ITERATOR){
  9812.   var iterFn = ITERATOR ? function(){ return iterable; } : getIterFn(iterable)
  9813.     , f      = ctx(fn, that, entries ? 2 : 1)
  9814.     , index  = 0
  9815.     , length, step, iterator, result;
  9816.   if(typeof iterFn != 'function')throw TypeError(iterable + ' is not iterable!');
  9817.   // fast case for arrays with default iterator
  9818.   if(isArrayIter(iterFn))for(length = toLength(iterable.length); length > index; index++){
  9819.     result = entries ? f(anObject(step = iterable[index])[0], step[1]) : f(iterable[index]);
  9820.     if(result === BREAK || result === RETURN)return result;
  9821.   } else for(iterator = iterFn.call(iterable); !(step = iterator.next()).done; ){
  9822.     result = call(iterator, f, step.value, entries);
  9823.     if(result === BREAK || result === RETURN)return result;
  9824.   }
  9825. };
  9826. exports.BREAK  = BREAK;
  9827. exports.RETURN = RETURN;
  9828.  
  9829. /***/ }),
  9830. /* 72 */
  9831. /***/ (function(module, exports, __webpack_require__) {
  9832.  
  9833. module.exports = !__webpack_require__(5) && !__webpack_require__(36)(function(){
  9834.   return Object.defineProperty(__webpack_require__(23)('div'), 'a', {get: function(){ return 7; }}).a != 7;
  9835. });
  9836.  
  9837. /***/ }),
  9838. /* 73 */
  9839. /***/ (function(module, exports) {
  9840.  
  9841. // fast apply, http://jsperf.lnkit.com/fast-apply/5
  9842. module.exports = function(fn, args, that){
  9843.   var un = that === undefined;
  9844.   switch(args.length){
  9845.     case 0: return un ? fn()
  9846.                       : fn.call(that);
  9847.     case 1: return un ? fn(args[0])
  9848.                       : fn.call(that, args[0]);
  9849.     case 2: return un ? fn(args[0], args[1])
  9850.                       : fn.call(that, args[0], args[1]);
  9851.     case 3: return un ? fn(args[0], args[1], args[2])
  9852.                       : fn.call(that, args[0], args[1], args[2]);
  9853.     case 4: return un ? fn(args[0], args[1], args[2], args[3])
  9854.                       : fn.call(that, args[0], args[1], args[2], args[3]);
  9855.   } return              fn.apply(that, args);
  9856. };
  9857.  
  9858. /***/ }),
  9859. /* 74 */
  9860. /***/ (function(module, exports, __webpack_require__) {
  9861.  
  9862. // fallback for non-array-like ES3 and non-enumerable old V8 strings
  9863. var cof = __webpack_require__(16);
  9864. module.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){
  9865.   return cof(it) == 'String' ? it.split('') : Object(it);
  9866. };
  9867.  
  9868. /***/ }),
  9869. /* 75 */
  9870. /***/ (function(module, exports, __webpack_require__) {
  9871.  
  9872. "use strict";
  9873.  
  9874. var create         = __webpack_require__(78)
  9875.   , descriptor     = __webpack_require__(24)
  9876.   , setToStringTag = __webpack_require__(25)
  9877.   , IteratorPrototype = {};
  9878.  
  9879. // 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
  9880. __webpack_require__(6)(IteratorPrototype, __webpack_require__(0)('iterator'), function(){ return this; });
  9881.  
  9882. module.exports = function(Constructor, NAME, next){
  9883.   Constructor.prototype = create(IteratorPrototype, {next: descriptor(1, next)});
  9884.   setToStringTag(Constructor, NAME + ' Iterator');
  9885. };
  9886.  
  9887. /***/ }),
  9888. /* 76 */
  9889. /***/ (function(module, exports) {
  9890.  
  9891. module.exports = function(done, value){
  9892.   return {value: value, done: !!done};
  9893. };
  9894.  
  9895. /***/ }),
  9896. /* 77 */
  9897. /***/ (function(module, exports, __webpack_require__) {
  9898.  
  9899. var global    = __webpack_require__(1)
  9900.   , macrotask = __webpack_require__(44).set
  9901.   , Observer  = global.MutationObserver || global.WebKitMutationObserver
  9902.   , process   = global.process
  9903.   , Promise   = global.Promise
  9904.   , isNode    = __webpack_require__(16)(process) == 'process';
  9905.  
  9906. module.exports = function(){
  9907.   var head, last, notify;
  9908.  
  9909.   var flush = function(){
  9910.     var parent, fn;
  9911.     if(isNode && (parent = process.domain))parent.exit();
  9912.     while(head){
  9913.       fn   = head.fn;
  9914.       head = head.next;
  9915.       try {
  9916.         fn();
  9917.       } catch(e){
  9918.         if(head)notify();
  9919.         else last = undefined;
  9920.         throw e;
  9921.       }
  9922.     } last = undefined;
  9923.     if(parent)parent.enter();
  9924.   };
  9925.  
  9926.   // Node.js
  9927.   if(isNode){
  9928.     notify = function(){
  9929.       process.nextTick(flush);
  9930.     };
  9931.   // browsers with MutationObserver
  9932.   } else if(Observer){
  9933.     var toggle = true
  9934.       , node   = document.createTextNode('');
  9935.     new Observer(flush).observe(node, {characterData: true}); // eslint-disable-line no-new
  9936.     notify = function(){
  9937.       node.data = toggle = !toggle;
  9938.     };
  9939.   // environments with maybe non-completely correct, but existent Promise
  9940.   } else if(Promise && Promise.resolve){
  9941.     var promise = Promise.resolve();
  9942.     notify = function(){
  9943.       promise.then(flush);
  9944.     };
  9945.   // for other environments - macrotask based on:
  9946.   // - setImmediate
  9947.   // - MessageChannel
  9948.   // - window.postMessag
  9949.   // - onreadystatechange
  9950.   // - setTimeout
  9951.   } else {
  9952.     notify = function(){
  9953.       // strange IE + webpack dev server bug - use .call(global)
  9954.       macrotask.call(global, flush);
  9955.     };
  9956.   }
  9957.  
  9958.   return function(fn){
  9959.     var task = {fn: fn, next: undefined};
  9960.     if(last)last.next = task;
  9961.     if(!head){
  9962.       head = task;
  9963.       notify();
  9964.     } last = task;
  9965.   };
  9966. };
  9967.  
  9968. /***/ }),
  9969. /* 78 */
  9970. /***/ (function(module, exports, __webpack_require__) {
  9971.  
  9972. // 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
  9973. var anObject    = __webpack_require__(4)
  9974.   , dPs         = __webpack_require__(79)
  9975.   , enumBugKeys = __webpack_require__(35)
  9976.   , IE_PROTO    = __webpack_require__(26)('IE_PROTO')
  9977.   , Empty       = function(){ /* empty */ }
  9978.   , PROTOTYPE   = 'prototype';
  9979.  
  9980. // Create object with fake `null` prototype: use iframe Object with cleared prototype
  9981. var createDict = function(){
  9982.   // Thrash, waste and sodomy: IE GC bug
  9983.   var iframe = __webpack_require__(23)('iframe')
  9984.     , i      = enumBugKeys.length
  9985.     , lt     = '<'
  9986.     , gt     = '>'
  9987.     , iframeDocument;
  9988.   iframe.style.display = 'none';
  9989.   __webpack_require__(37).appendChild(iframe);
  9990.   iframe.src = 'javascript:'; // eslint-disable-line no-script-url
  9991.   // createDict = iframe.contentWindow.Object;
  9992.   // html.removeChild(iframe);
  9993.   iframeDocument = iframe.contentWindow.document;
  9994.   iframeDocument.open();
  9995.   iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);
  9996.   iframeDocument.close();
  9997.   createDict = iframeDocument.F;
  9998.   while(i--)delete createDict[PROTOTYPE][enumBugKeys[i]];
  9999.   return createDict();
  10000. };
  10001.  
  10002. module.exports = Object.create || function create(O, Properties){
  10003.   var result;
  10004.   if(O !== null){
  10005.     Empty[PROTOTYPE] = anObject(O);
  10006.     result = new Empty;
  10007.     Empty[PROTOTYPE] = null;
  10008.     // add "__proto__" for Object.getPrototypeOf polyfill
  10009.     result[IE_PROTO] = O;
  10010.   } else result = createDict();
  10011.   return Properties === undefined ? result : dPs(result, Properties);
  10012. };
  10013.  
  10014.  
  10015. /***/ }),
  10016. /* 79 */
  10017. /***/ (function(module, exports, __webpack_require__) {
  10018.  
  10019. var dP       = __webpack_require__(7)
  10020.   , anObject = __webpack_require__(4)
  10021.   , getKeys  = __webpack_require__(82);
  10022.  
  10023. module.exports = __webpack_require__(5) ? Object.defineProperties : function defineProperties(O, Properties){
  10024.   anObject(O);
  10025.   var keys   = getKeys(Properties)
  10026.     , length = keys.length
  10027.     , i = 0
  10028.     , P;
  10029.   while(length > i)dP.f(O, P = keys[i++], Properties[P]);
  10030.   return O;
  10031. };
  10032.  
  10033. /***/ }),
  10034. /* 80 */
  10035. /***/ (function(module, exports, __webpack_require__) {
  10036.  
  10037. // 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)
  10038. var has         = __webpack_require__(18)
  10039.   , toObject    = __webpack_require__(45)
  10040.   , IE_PROTO    = __webpack_require__(26)('IE_PROTO')
  10041.   , ObjectProto = Object.prototype;
  10042.  
  10043. module.exports = Object.getPrototypeOf || function(O){
  10044.   O = toObject(O);
  10045.   if(has(O, IE_PROTO))return O[IE_PROTO];
  10046.   if(typeof O.constructor == 'function' && O instanceof O.constructor){
  10047.     return O.constructor.prototype;
  10048.   } return O instanceof Object ? ObjectProto : null;
  10049. };
  10050.  
  10051. /***/ }),
  10052. /* 81 */
  10053. /***/ (function(module, exports, __webpack_require__) {
  10054.  
  10055. var has          = __webpack_require__(18)
  10056.   , toIObject    = __webpack_require__(28)
  10057.   , arrayIndexOf = __webpack_require__(69)(false)
  10058.   , IE_PROTO     = __webpack_require__(26)('IE_PROTO');
  10059.  
  10060. module.exports = function(object, names){
  10061.   var O      = toIObject(object)
  10062.     , i      = 0
  10063.     , result = []
  10064.     , key;
  10065.   for(key in O)if(key != IE_PROTO)has(O, key) && result.push(key);
  10066.   // Don't enum bug & hidden keys
  10067.   while(names.length > i)if(has(O, key = names[i++])){
  10068.     ~arrayIndexOf(result, key) || result.push(key);
  10069.   }
  10070.   return result;
  10071. };
  10072.  
  10073. /***/ }),
  10074. /* 82 */
  10075. /***/ (function(module, exports, __webpack_require__) {
  10076.  
  10077. // 19.1.2.14 / 15.2.3.14 Object.keys(O)
  10078. var $keys       = __webpack_require__(81)
  10079.   , enumBugKeys = __webpack_require__(35);
  10080.  
  10081. module.exports = Object.keys || function keys(O){
  10082.   return $keys(O, enumBugKeys);
  10083. };
  10084.  
  10085. /***/ }),
  10086. /* 83 */
  10087. /***/ (function(module, exports, __webpack_require__) {
  10088.  
  10089. var hide = __webpack_require__(6);
  10090. module.exports = function(target, src, safe){
  10091.   for(var key in src){
  10092.     if(safe && target[key])target[key] = src[key];
  10093.     else hide(target, key, src[key]);
  10094.   } return target;
  10095. };
  10096.  
  10097. /***/ }),
  10098. /* 84 */
  10099. /***/ (function(module, exports, __webpack_require__) {
  10100.  
  10101. module.exports = __webpack_require__(6);
  10102.  
  10103. /***/ }),
  10104. /* 85 */
  10105. /***/ (function(module, exports, __webpack_require__) {
  10106.  
  10107. "use strict";
  10108.  
  10109. var global      = __webpack_require__(1)
  10110.   , core        = __webpack_require__(2)
  10111.   , dP          = __webpack_require__(7)
  10112.   , DESCRIPTORS = __webpack_require__(5)
  10113.   , SPECIES     = __webpack_require__(0)('species');
  10114.  
  10115. module.exports = function(KEY){
  10116.   var C = typeof core[KEY] == 'function' ? core[KEY] : global[KEY];
  10117.   if(DESCRIPTORS && C && !C[SPECIES])dP.f(C, SPECIES, {
  10118.     configurable: true,
  10119.     get: function(){ return this; }
  10120.   });
  10121. };
  10122.  
  10123. /***/ }),
  10124. /* 86 */
  10125. /***/ (function(module, exports, __webpack_require__) {
  10126.  
  10127. // 7.3.20 SpeciesConstructor(O, defaultConstructor)
  10128. var anObject  = __webpack_require__(4)
  10129.   , aFunction = __webpack_require__(21)
  10130.   , SPECIES   = __webpack_require__(0)('species');
  10131. module.exports = function(O, D){
  10132.   var C = anObject(O).constructor, S;
  10133.   return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? D : aFunction(S);
  10134. };
  10135.  
  10136. /***/ }),
  10137. /* 87 */
  10138. /***/ (function(module, exports, __webpack_require__) {
  10139.  
  10140. var toInteger = __webpack_require__(27)
  10141.   , defined   = __webpack_require__(22);
  10142. // true  -> String#at
  10143. // false -> String#codePointAt
  10144. module.exports = function(TO_STRING){
  10145.   return function(that, pos){
  10146.     var s = String(defined(that))
  10147.       , i = toInteger(pos)
  10148.       , l = s.length
  10149.       , a, b;
  10150.     if(i < 0 || i >= l)return TO_STRING ? '' : undefined;
  10151.     a = s.charCodeAt(i);
  10152.     return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff
  10153.       ? TO_STRING ? s.charAt(i) : a
  10154.       : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;
  10155.   };
  10156. };
  10157.  
  10158. /***/ }),
  10159. /* 88 */
  10160. /***/ (function(module, exports, __webpack_require__) {
  10161.  
  10162. var toInteger = __webpack_require__(27)
  10163.   , max       = Math.max
  10164.   , min       = Math.min;
  10165. module.exports = function(index, length){
  10166.   index = toInteger(index);
  10167.   return index < 0 ? max(index + length, 0) : min(index, length);
  10168. };
  10169.  
  10170. /***/ }),
  10171. /* 89 */
  10172. /***/ (function(module, exports, __webpack_require__) {
  10173.  
  10174. // 7.1.1 ToPrimitive(input [, PreferredType])
  10175. var isObject = __webpack_require__(19);
  10176. // instead of the ES6 spec version, we didn't implement @@toPrimitive case
  10177. // and the second argument - flag - preferred type is a string
  10178. module.exports = function(it, S){
  10179.   if(!isObject(it))return it;
  10180.   var fn, val;
  10181.   if(S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;
  10182.   if(typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it)))return val;
  10183.   if(!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;
  10184.   throw TypeError("Can't convert object to primitive value");
  10185. };
  10186.  
  10187. /***/ }),
  10188. /* 90 */
  10189. /***/ (function(module, exports, __webpack_require__) {
  10190.  
  10191. "use strict";
  10192.  
  10193. var ctx            = __webpack_require__(12)
  10194.   , $export        = __webpack_require__(17)
  10195.   , toObject       = __webpack_require__(45)
  10196.   , call           = __webpack_require__(39)
  10197.   , isArrayIter    = __webpack_require__(38)
  10198.   , toLength       = __webpack_require__(29)
  10199.   , createProperty = __webpack_require__(70)
  10200.   , getIterFn      = __webpack_require__(47);
  10201.  
  10202. $export($export.S + $export.F * !__webpack_require__(41)(function(iter){ Array.from(iter); }), 'Array', {
  10203.   // 22.1.2.1 Array.from(arrayLike, mapfn = undefined, thisArg = undefined)
  10204.   from: function from(arrayLike/*, mapfn = undefined, thisArg = undefined*/){
  10205.     var O       = toObject(arrayLike)
  10206.       , C       = typeof this == 'function' ? this : Array
  10207.       , aLen    = arguments.length
  10208.       , mapfn   = aLen > 1 ? arguments[1] : undefined
  10209.       , mapping = mapfn !== undefined
  10210.       , index   = 0
  10211.       , iterFn  = getIterFn(O)
  10212.       , length, result, step, iterator;
  10213.     if(mapping)mapfn = ctx(mapfn, aLen > 2 ? arguments[2] : undefined, 2);
  10214.     // if object isn't iterable or it's array with default iterator - use simple case
  10215.     if(iterFn != undefined && !(C == Array && isArrayIter(iterFn))){
  10216.       for(iterator = iterFn.call(O), result = new C; !(step = iterator.next()).done; index++){
  10217.         createProperty(result, index, mapping ? call(iterator, mapfn, [step.value, index], true) : step.value);
  10218.       }
  10219.     } else {
  10220.       length = toLength(O.length);
  10221.       for(result = new C(length); length > index; index++){
  10222.         createProperty(result, index, mapping ? mapfn(O[index], index) : O[index]);
  10223.       }
  10224.     }
  10225.     result.length = index;
  10226.     return result;
  10227.   }
  10228. });
  10229.  
  10230.  
  10231. /***/ }),
  10232. /* 91 */
  10233. /***/ (function(module, exports, __webpack_require__) {
  10234.  
  10235. "use strict";
  10236.  
  10237. var addToUnscopables = __webpack_require__(67)
  10238.   , step             = __webpack_require__(76)
  10239.   , Iterators        = __webpack_require__(13)
  10240.   , toIObject        = __webpack_require__(28);
  10241.  
  10242. // 22.1.3.4 Array.prototype.entries()
  10243. // 22.1.3.13 Array.prototype.keys()
  10244. // 22.1.3.29 Array.prototype.values()
  10245. // 22.1.3.30 Array.prototype[@@iterator]()
  10246. module.exports = __webpack_require__(40)(Array, 'Array', function(iterated, kind){
  10247.   this._t = toIObject(iterated); // target
  10248.   this._i = 0;                   // next index
  10249.   this._k = kind;                // kind
  10250. // 22.1.5.2.1 %ArrayIteratorPrototype%.next()
  10251. }, function(){
  10252.   var O     = this._t
  10253.     , kind  = this._k
  10254.     , index = this._i++;
  10255.   if(!O || index >= O.length){
  10256.     this._t = undefined;
  10257.     return step(1);
  10258.   }
  10259.   if(kind == 'keys'  )return step(0, index);
  10260.   if(kind == 'values')return step(0, O[index]);
  10261.   return step(0, [index, O[index]]);
  10262. }, 'values');
  10263.  
  10264. // argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)
  10265. Iterators.Arguments = Iterators.Array;
  10266.  
  10267. addToUnscopables('keys');
  10268. addToUnscopables('values');
  10269. addToUnscopables('entries');
  10270.  
  10271. /***/ }),
  10272. /* 92 */
  10273. /***/ (function(module, exports, __webpack_require__) {
  10274.  
  10275. var $export = __webpack_require__(17);
  10276. // 19.1.2.4 / 15.2.3.6 Object.defineProperty(O, P, Attributes)
  10277. $export($export.S + $export.F * !__webpack_require__(5), 'Object', {defineProperty: __webpack_require__(7).f});
  10278.  
  10279. /***/ }),
  10280. /* 93 */
  10281. /***/ (function(module, exports) {
  10282.  
  10283.  
  10284.  
  10285. /***/ }),
  10286. /* 94 */
  10287. /***/ (function(module, exports, __webpack_require__) {
  10288.  
  10289. "use strict";
  10290.  
  10291. var LIBRARY            = __webpack_require__(42)
  10292.   , global             = __webpack_require__(1)
  10293.   , ctx                = __webpack_require__(12)
  10294.   , classof            = __webpack_require__(34)
  10295.   , $export            = __webpack_require__(17)
  10296.   , isObject           = __webpack_require__(19)
  10297.   , aFunction          = __webpack_require__(21)
  10298.   , anInstance         = __webpack_require__(68)
  10299.   , forOf              = __webpack_require__(71)
  10300.   , speciesConstructor = __webpack_require__(86)
  10301.   , task               = __webpack_require__(44).set
  10302.   , microtask          = __webpack_require__(77)()
  10303.   , PROMISE            = 'Promise'
  10304.   , TypeError          = global.TypeError
  10305.   , process            = global.process
  10306.   , $Promise           = global[PROMISE]
  10307.   , process            = global.process
  10308.   , isNode             = classof(process) == 'process'
  10309.   , empty              = function(){ /* empty */ }
  10310.   , Internal, GenericPromiseCapability, Wrapper;
  10311.  
  10312. var USE_NATIVE = !!function(){
  10313.   try {
  10314.     // correct subclassing with @@species support
  10315.     var promise     = $Promise.resolve(1)
  10316.       , FakePromise = (promise.constructor = {})[__webpack_require__(0)('species')] = function(exec){ exec(empty, empty); };
  10317.     // unhandled rejections tracking support, NodeJS Promise without it fails @@species test
  10318.     return (isNode || typeof PromiseRejectionEvent == 'function') && promise.then(empty) instanceof FakePromise;
  10319.   } catch(e){ /* empty */ }
  10320. }();
  10321.  
  10322. // helpers
  10323. var sameConstructor = function(a, b){
  10324.   // with library wrapper special case
  10325.   return a === b || a === $Promise && b === Wrapper;
  10326. };
  10327. var isThenable = function(it){
  10328.   var then;
  10329.   return isObject(it) && typeof (then = it.then) == 'function' ? then : false;
  10330. };
  10331. var newPromiseCapability = function(C){
  10332.   return sameConstructor($Promise, C)
  10333.     ? new PromiseCapability(C)
  10334.     : new GenericPromiseCapability(C);
  10335. };
  10336. var PromiseCapability = GenericPromiseCapability = function(C){
  10337.   var resolve, reject;
  10338.   this.promise = new C(function($$resolve, $$reject){
  10339.     if(resolve !== undefined || reject !== undefined)throw TypeError('Bad Promise constructor');
  10340.     resolve = $$resolve;
  10341.     reject  = $$reject;
  10342.   });
  10343.   this.resolve = aFunction(resolve);
  10344.   this.reject  = aFunction(reject);
  10345. };
  10346. var perform = function(exec){
  10347.   try {
  10348.     exec();
  10349.   } catch(e){
  10350.     return {error: e};
  10351.   }
  10352. };
  10353. var notify = function(promise, isReject){
  10354.   if(promise._n)return;
  10355.   promise._n = true;
  10356.   var chain = promise._c;
  10357.   microtask(function(){
  10358.     var value = promise._v
  10359.       , ok    = promise._s == 1
  10360.       , i     = 0;
  10361.     var run = function(reaction){
  10362.       var handler = ok ? reaction.ok : reaction.fail
  10363.         , resolve = reaction.resolve
  10364.         , reject  = reaction.reject
  10365.         , domain  = reaction.domain
  10366.         , result, then;
  10367.       try {
  10368.         if(handler){
  10369.           if(!ok){
  10370.             if(promise._h == 2)onHandleUnhandled(promise);
  10371.             promise._h = 1;
  10372.           }
  10373.           if(handler === true)result = value;
  10374.           else {
  10375.             if(domain)domain.enter();
  10376.             result = handler(value);
  10377.             if(domain)domain.exit();
  10378.           }
  10379.           if(result === reaction.promise){
  10380.             reject(TypeError('Promise-chain cycle'));
  10381.           } else if(then = isThenable(result)){
  10382.             then.call(result, resolve, reject);
  10383.           } else resolve(result);
  10384.         } else reject(value);
  10385.       } catch(e){
  10386.         reject(e);
  10387.       }
  10388.     };
  10389.     while(chain.length > i)run(chain[i++]); // variable length - can't use forEach
  10390.     promise._c = [];
  10391.     promise._n = false;
  10392.     if(isReject && !promise._h)onUnhandled(promise);
  10393.   });
  10394. };
  10395. var onUnhandled = function(promise){
  10396.   task.call(global, function(){
  10397.     var value = promise._v
  10398.       , abrupt, handler, console;
  10399.     if(isUnhandled(promise)){
  10400.       abrupt = perform(function(){
  10401.         if(isNode){
  10402.           process.emit('unhandledRejection', value, promise);
  10403.         } else if(handler = global.onunhandledrejection){
  10404.           handler({promise: promise, reason: value});
  10405.         } else if((console = global.console) && console.error){
  10406.           console.error('Unhandled promise rejection', value);
  10407.         }
  10408.       });
  10409.       // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should
  10410.       promise._h = isNode || isUnhandled(promise) ? 2 : 1;
  10411.     } promise._a = undefined;
  10412.     if(abrupt)throw abrupt.error;
  10413.   });
  10414. };
  10415. var isUnhandled = function(promise){
  10416.   if(promise._h == 1)return false;
  10417.   var chain = promise._a || promise._c
  10418.     , i     = 0
  10419.     , reaction;
  10420.   while(chain.length > i){
  10421.     reaction = chain[i++];
  10422.     if(reaction.fail || !isUnhandled(reaction.promise))return false;
  10423.   } return true;
  10424. };
  10425. var onHandleUnhandled = function(promise){
  10426.   task.call(global, function(){
  10427.     var handler;
  10428.     if(isNode){
  10429.       process.emit('rejectionHandled', promise);
  10430.     } else if(handler = global.onrejectionhandled){
  10431.       handler({promise: promise, reason: promise._v});
  10432.     }
  10433.   });
  10434. };
  10435. var $reject = function(value){
  10436.   var promise = this;
  10437.   if(promise._d)return;
  10438.   promise._d = true;
  10439.   promise = promise._w || promise; // unwrap
  10440.   promise._v = value;
  10441.   promise._s = 2;
  10442.   if(!promise._a)promise._a = promise._c.slice();
  10443.   notify(promise, true);
  10444. };
  10445. var $resolve = function(value){
  10446.   var promise = this
  10447.     , then;
  10448.   if(promise._d)return;
  10449.   promise._d = true;
  10450.   promise = promise._w || promise; // unwrap
  10451.   try {
  10452.     if(promise === value)throw TypeError("Promise can't be resolved itself");
  10453.     if(then = isThenable(value)){
  10454.       microtask(function(){
  10455.         var wrapper = {_w: promise, _d: false}; // wrap
  10456.         try {
  10457.           then.call(value, ctx($resolve, wrapper, 1), ctx($reject, wrapper, 1));
  10458.         } catch(e){
  10459.           $reject.call(wrapper, e);
  10460.         }
  10461.       });
  10462.     } else {
  10463.       promise._v = value;
  10464.       promise._s = 1;
  10465.       notify(promise, false);
  10466.     }
  10467.   } catch(e){
  10468.     $reject.call({_w: promise, _d: false}, e); // wrap
  10469.   }
  10470. };
  10471.  
  10472. // constructor polyfill
  10473. if(!USE_NATIVE){
  10474.   // 25.4.3.1 Promise(executor)
  10475.   $Promise = function Promise(executor){
  10476.     anInstance(this, $Promise, PROMISE, '_h');
  10477.     aFunction(executor);
  10478.     Internal.call(this);
  10479.     try {
  10480.       executor(ctx($resolve, this, 1), ctx($reject, this, 1));
  10481.     } catch(err){
  10482.       $reject.call(this, err);
  10483.     }
  10484.   };
  10485.   Internal = function Promise(executor){
  10486.     this._c = [];             // <- awaiting reactions
  10487.     this._a = undefined;      // <- checked in isUnhandled reactions
  10488.     this._s = 0;              // <- state
  10489.     this._d = false;          // <- done
  10490.     this._v = undefined;      // <- value
  10491.     this._h = 0;              // <- rejection state, 0 - default, 1 - handled, 2 - unhandled
  10492.     this._n = false;          // <- notify
  10493.   };
  10494.   Internal.prototype = __webpack_require__(83)($Promise.prototype, {
  10495.     // 25.4.5.3 Promise.prototype.then(onFulfilled, onRejected)
  10496.     then: function then(onFulfilled, onRejected){
  10497.       var reaction    = newPromiseCapability(speciesConstructor(this, $Promise));
  10498.       reaction.ok     = typeof onFulfilled == 'function' ? onFulfilled : true;
  10499.       reaction.fail   = typeof onRejected == 'function' && onRejected;
  10500.       reaction.domain = isNode ? process.domain : undefined;
  10501.       this._c.push(reaction);
  10502.       if(this._a)this._a.push(reaction);
  10503.       if(this._s)notify(this, false);
  10504.       return reaction.promise;
  10505.     },
  10506.     // 25.4.5.1 Promise.prototype.catch(onRejected)
  10507.     'catch': function(onRejected){
  10508.       return this.then(undefined, onRejected);
  10509.     }
  10510.   });
  10511.   PromiseCapability = function(){
  10512.     var promise  = new Internal;
  10513.     this.promise = promise;
  10514.     this.resolve = ctx($resolve, promise, 1);
  10515.     this.reject  = ctx($reject, promise, 1);
  10516.   };
  10517. }
  10518.  
  10519. $export($export.G + $export.W + $export.F * !USE_NATIVE, {Promise: $Promise});
  10520. __webpack_require__(25)($Promise, PROMISE);
  10521. __webpack_require__(85)(PROMISE);
  10522. Wrapper = __webpack_require__(2)[PROMISE];
  10523.  
  10524. // statics
  10525. $export($export.S + $export.F * !USE_NATIVE, PROMISE, {
  10526.   // 25.4.4.5 Promise.reject(r)
  10527.   reject: function reject(r){
  10528.     var capability = newPromiseCapability(this)
  10529.       , $$reject   = capability.reject;
  10530.     $$reject(r);
  10531.     return capability.promise;
  10532.   }
  10533. });
  10534. $export($export.S + $export.F * (LIBRARY || !USE_NATIVE), PROMISE, {
  10535.   // 25.4.4.6 Promise.resolve(x)
  10536.   resolve: function resolve(x){
  10537.     // instanceof instead of internal slot check because we should fix it without replacement native Promise core
  10538.     if(x instanceof $Promise && sameConstructor(x.constructor, this))return x;
  10539.     var capability = newPromiseCapability(this)
  10540.       , $$resolve  = capability.resolve;
  10541.     $$resolve(x);
  10542.     return capability.promise;
  10543.   }
  10544. });
  10545. $export($export.S + $export.F * !(USE_NATIVE && __webpack_require__(41)(function(iter){
  10546.   $Promise.all(iter)['catch'](empty);
  10547. })), PROMISE, {
  10548.   // 25.4.4.1 Promise.all(iterable)
  10549.   all: function all(iterable){
  10550.     var C          = this
  10551.       , capability = newPromiseCapability(C)
  10552.       , resolve    = capability.resolve
  10553.       , reject     = capability.reject;
  10554.     var abrupt = perform(function(){
  10555.       var values    = []
  10556.         , index     = 0
  10557.         , remaining = 1;
  10558.       forOf(iterable, false, function(promise){
  10559.         var $index        = index++
  10560.           , alreadyCalled = false;
  10561.         values.push(undefined);
  10562.         remaining++;
  10563.         C.resolve(promise).then(function(value){
  10564.           if(alreadyCalled)return;
  10565.           alreadyCalled  = true;
  10566.           values[$index] = value;
  10567.           --remaining || resolve(values);
  10568.         }, reject);
  10569.       });
  10570.       --remaining || resolve(values);
  10571.     });
  10572.     if(abrupt)reject(abrupt.error);
  10573.     return capability.promise;
  10574.   },
  10575.   // 25.4.4.4 Promise.race(iterable)
  10576.   race: function race(iterable){
  10577.     var C          = this
  10578.       , capability = newPromiseCapability(C)
  10579.       , reject     = capability.reject;
  10580.     var abrupt = perform(function(){
  10581.       forOf(iterable, false, function(promise){
  10582.         C.resolve(promise).then(capability.resolve, reject);
  10583.       });
  10584.     });
  10585.     if(abrupt)reject(abrupt.error);
  10586.     return capability.promise;
  10587.   }
  10588. });
  10589.  
  10590. /***/ }),
  10591. /* 95 */
  10592. /***/ (function(module, exports, __webpack_require__) {
  10593.  
  10594. __webpack_require__(91);
  10595. var global        = __webpack_require__(1)
  10596.   , hide          = __webpack_require__(6)
  10597.   , Iterators     = __webpack_require__(13)
  10598.   , TO_STRING_TAG = __webpack_require__(0)('toStringTag');
  10599.  
  10600. for(var collections = ['NodeList', 'DOMTokenList', 'MediaList', 'StyleSheetList', 'CSSRuleList'], i = 0; i < 5; i++){
  10601.   var NAME       = collections[i]
  10602.     , Collection = global[NAME]
  10603.     , proto      = Collection && Collection.prototype;
  10604.   if(proto && !proto[TO_STRING_TAG])hide(proto, TO_STRING_TAG, NAME);
  10605.   Iterators[NAME] = Iterators.Array;
  10606. }
  10607.  
  10608. /***/ }),
  10609. /* 96 */
  10610. /***/ (function(module, exports, __webpack_require__) {
  10611.  
  10612. exports = module.exports = __webpack_require__(97)(undefined);
  10613. // imports
  10614.  
  10615.  
  10616. // module
  10617. exports.push([module.i, "", ""]);
  10618.  
  10619. // exports
  10620.  
  10621.  
  10622. /***/ }),
  10623. /* 97 */
  10624. /***/ (function(module, exports, __webpack_require__) {
  10625.  
  10626. /* WEBPACK VAR INJECTION */(function(Buffer) {/*
  10627. 	MIT License http://www.opensource.org/licenses/mit-license.php
  10628. 	Author Tobias Koppers @sokra
  10629. */
  10630. // css base code, injected by the css-loader
  10631. module.exports = function(useSourceMap) {
  10632. 	var list = [];
  10633.  
  10634. 	// return the list of modules as css string
  10635. 	list.toString = function toString() {
  10636. 		return this.map(function (item) {
  10637. 			var content = cssWithMappingToString(item, useSourceMap);
  10638. 			if(item[2]) {
  10639. 				return "@media " + item[2] + "{" + content + "}";
  10640. 			} else {
  10641. 				return content;
  10642. 			}
  10643. 		}).join("");
  10644. 	};
  10645.  
  10646. 	// import a list of modules into the list
  10647. 	list.i = function(modules, mediaQuery) {
  10648. 		if(typeof modules === "string")
  10649. 			modules = [[null, modules, ""]];
  10650. 		var alreadyImportedModules = {};
  10651. 		for(var i = 0; i < this.length; i++) {
  10652. 			var id = this[i][0];
  10653. 			if(typeof id === "number")
  10654. 				alreadyImportedModules[id] = true;
  10655. 		}
  10656. 		for(i = 0; i < modules.length; i++) {
  10657. 			var item = modules[i];
  10658. 			// skip already imported module
  10659. 			// this implementation is not 100% perfect for weird media query combinations
  10660. 			//  when a module is imported multiple times with different media queries.
  10661. 			//  I hope this will never occur (Hey this way we have smaller bundles)
  10662. 			if(typeof item[0] !== "number" || !alreadyImportedModules[item[0]]) {
  10663. 				if(mediaQuery && !item[2]) {
  10664. 					item[2] = mediaQuery;
  10665. 				} else if(mediaQuery) {
  10666. 					item[2] = "(" + item[2] + ") and (" + mediaQuery + ")";
  10667. 				}
  10668. 				list.push(item);
  10669. 			}
  10670. 		}
  10671. 	};
  10672. 	return list;
  10673. };
  10674.  
  10675. function cssWithMappingToString(item, useSourceMap) {
  10676. 	var content = item[1] || '';
  10677. 	var cssMapping = item[3];
  10678. 	if (!cssMapping) {
  10679. 		return content;
  10680. 	}
  10681.  
  10682. 	if (useSourceMap) {
  10683. 		var sourceMapping = toComment(cssMapping);
  10684. 		var sourceURLs = cssMapping.sources.map(function (source) {
  10685. 			return '/*# sourceURL=' + cssMapping.sourceRoot + source + ' */'
  10686. 		});
  10687.  
  10688. 		return [content].concat(sourceURLs).concat([sourceMapping]).join('\n');
  10689. 	}
  10690.  
  10691. 	return [content].join('\n');
  10692. }
  10693.  
  10694. // Adapted from convert-source-map (MIT)
  10695. function toComment(sourceMap) {
  10696.   var base64 = new Buffer(JSON.stringify(sourceMap)).toString('base64');
  10697.   var data = 'sourceMappingURL=data:application/json;charset=utf-8;base64,' + base64;
  10698.  
  10699.   return '/*# ' + data + ' */';
  10700. }
  10701.  
  10702. /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62).Buffer))
  10703.  
  10704. /***/ }),
  10705. /* 98 */
  10706. /***/ (function(module, exports) {
  10707.  
  10708. module.exports = Date.now || now
  10709.  
  10710. function now() {
  10711.     return new Date().getTime()
  10712. }
  10713.  
  10714.  
  10715. /***/ }),
  10716. /* 99 */
  10717. /***/ (function(module, exports, __webpack_require__) {
  10718.  
  10719.  
  10720. /**
  10721.  * Module dependencies.
  10722.  */
  10723.  
  10724. var now = __webpack_require__(98);
  10725.  
  10726. /**
  10727.  * Returns a function, that, as long as it continues to be invoked, will not
  10728.  * be triggered. The function will be called after it stops being called for
  10729.  * N milliseconds. If `immediate` is passed, trigger the function on the
  10730.  * leading edge, instead of the trailing.
  10731.  *
  10732.  * @source underscore.js
  10733.  * @see http://unscriptable.com/2009/03/20/debouncing-javascript-methods/
  10734.  * @param {Function} function to wrap
  10735.  * @param {Number} timeout in ms (`100`)
  10736.  * @param {Boolean} whether to execute at the beginning (`false`)
  10737.  * @api public
  10738.  */
  10739.  
  10740. module.exports = function debounce(func, wait, immediate){
  10741.   var timeout, args, context, timestamp, result;
  10742.   if (null == wait) wait = 100;
  10743.  
  10744.   function later() {
  10745.     var last = now() - timestamp;
  10746.  
  10747.     if (last < wait && last > 0) {
  10748.       timeout = setTimeout(later, wait - last);
  10749.     } else {
  10750.       timeout = null;
  10751.       if (!immediate) {
  10752.         result = func.apply(context, args);
  10753.         if (!timeout) context = args = null;
  10754.       }
  10755.     }
  10756.   };
  10757.  
  10758.   return function debounced() {
  10759.     context = this;
  10760.     args = arguments;
  10761.     timestamp = now();
  10762.     var callNow = immediate && !timeout;
  10763.     if (!timeout) timeout = setTimeout(later, wait);
  10764.     if (callNow) {
  10765.       result = func.apply(context, args);
  10766.       context = args = null;
  10767.     }
  10768.  
  10769.     return result;
  10770.   };
  10771. };
  10772.  
  10773.  
  10774. /***/ }),
  10775. /* 100 */
  10776. /***/ (function(module, exports) {
  10777.  
  10778. exports.read = function (buffer, offset, isLE, mLen, nBytes) {
  10779.   var e, m
  10780.   var eLen = nBytes * 8 - mLen - 1
  10781.   var eMax = (1 << eLen) - 1
  10782.   var eBias = eMax >> 1
  10783.   var nBits = -7
  10784.   var i = isLE ? (nBytes - 1) : 0
  10785.   var d = isLE ? -1 : 1
  10786.   var s = buffer[offset + i]
  10787.  
  10788.   i += d
  10789.  
  10790.   e = s & ((1 << (-nBits)) - 1)
  10791.   s >>= (-nBits)
  10792.   nBits += eLen
  10793.   for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}
  10794.  
  10795.   m = e & ((1 << (-nBits)) - 1)
  10796.   e >>= (-nBits)
  10797.   nBits += mLen
  10798.   for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}
  10799.  
  10800.   if (e === 0) {
  10801.     e = 1 - eBias
  10802.   } else if (e === eMax) {
  10803.     return m ? NaN : ((s ? -1 : 1) * Infinity)
  10804.   } else {
  10805.     m = m + Math.pow(2, mLen)
  10806.     e = e - eBias
  10807.   }
  10808.   return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
  10809. }
  10810.  
  10811. exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
  10812.   var e, m, c
  10813.   var eLen = nBytes * 8 - mLen - 1
  10814.   var eMax = (1 << eLen) - 1
  10815.   var eBias = eMax >> 1
  10816.   var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
  10817.   var i = isLE ? 0 : (nBytes - 1)
  10818.   var d = isLE ? 1 : -1
  10819.   var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0
  10820.  
  10821.   value = Math.abs(value)
  10822.  
  10823.   if (isNaN(value) || value === Infinity) {
  10824.     m = isNaN(value) ? 1 : 0
  10825.     e = eMax
  10826.   } else {
  10827.     e = Math.floor(Math.log(value) / Math.LN2)
  10828.     if (value * (c = Math.pow(2, -e)) < 1) {
  10829.       e--
  10830.       c *= 2
  10831.     }
  10832.     if (e + eBias >= 1) {
  10833.       value += rt / c
  10834.     } else {
  10835.       value += rt * Math.pow(2, 1 - eBias)
  10836.     }
  10837.     if (value * c >= 2) {
  10838.       e++
  10839.       c /= 2
  10840.     }
  10841.  
  10842.     if (e + eBias >= eMax) {
  10843.       m = 0
  10844.       e = eMax
  10845.     } else if (e + eBias >= 1) {
  10846.       m = (value * c - 1) * Math.pow(2, mLen)
  10847.       e = e + eBias
  10848.     } else {
  10849.       m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
  10850.       e = 0
  10851.     }
  10852.   }
  10853.  
  10854.   for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
  10855.  
  10856.   e = (e << mLen) | m
  10857.   eLen += mLen
  10858.   for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
  10859.  
  10860.   buffer[offset + i - d] |= s * 128
  10861. }
  10862.  
  10863.  
  10864. /***/ }),
  10865. /* 101 */
  10866. /***/ (function(module, exports) {
  10867.  
  10868. var toString = {}.toString;
  10869.  
  10870. module.exports = Array.isArray || function (arr) {
  10871.   return toString.call(arr) == '[object Array]';
  10872. };
  10873.  
  10874.  
  10875. /***/ }),
  10876. /* 102 */
  10877. /***/ (function(module, exports, __webpack_require__) {
  10878.  
  10879. /* WEBPACK VAR INJECTION */(function(module, global) {var __WEBPACK_AMD_DEFINE_RESULT__;/*! https://mths.be/punycode v1.4.1 by @mathias */
  10880. ;(function(root) {
  10881.  
  10882. 	/** Detect free variables */
  10883. 	var freeExports = typeof exports == 'object' && exports &&
  10884. 		!exports.nodeType && exports;
  10885. 	var freeModule = typeof module == 'object' && module &&
  10886. 		!module.nodeType && module;
  10887. 	var freeGlobal = typeof global == 'object' && global;
  10888. 	if (
  10889. 		freeGlobal.global === freeGlobal ||
  10890. 		freeGlobal.window === freeGlobal ||
  10891. 		freeGlobal.self === freeGlobal
  10892. 	) {
  10893. 		root = freeGlobal;
  10894. 	}
  10895.  
  10896. 	/**
  10897. 	 * The `punycode` object.
  10898. 	 * @name punycode
  10899. 	 * @type Object
  10900. 	 */
  10901. 	var punycode,
  10902.  
  10903. 	/** Highest positive signed 32-bit float value */
  10904. 	maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1
  10905.  
  10906. 	/** Bootstring parameters */
  10907. 	base = 36,
  10908. 	tMin = 1,
  10909. 	tMax = 26,
  10910. 	skew = 38,
  10911. 	damp = 700,
  10912. 	initialBias = 72,
  10913. 	initialN = 128, // 0x80
  10914. 	delimiter = '-', // '\x2D'
  10915.  
  10916. 	/** Regular expressions */
  10917. 	regexPunycode = /^xn--/,
  10918. 	regexNonASCII = /[^\x20-\x7E]/, // unprintable ASCII chars + non-ASCII chars
  10919. 	regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, // RFC 3490 separators
  10920.  
  10921. 	/** Error messages */
  10922. 	errors = {
  10923. 		'overflow': 'Overflow: input needs wider integers to process',
  10924. 		'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
  10925. 		'invalid-input': 'Invalid input'
  10926. 	},
  10927.  
  10928. 	/** Convenience shortcuts */
  10929. 	baseMinusTMin = base - tMin,
  10930. 	floor = Math.floor,
  10931. 	stringFromCharCode = String.fromCharCode,
  10932.  
  10933. 	/** Temporary variable */
  10934. 	key;
  10935.  
  10936. 	/*--------------------------------------------------------------------------*/
  10937.  
  10938. 	/**
  10939. 	 * A generic error utility function.
  10940. 	 * @private
  10941. 	 * @param {String} type The error type.
  10942. 	 * @returns {Error} Throws a `RangeError` with the applicable error message.
  10943. 	 */
  10944. 	function error(type) {
  10945. 		throw new RangeError(errors[type]);
  10946. 	}
  10947.  
  10948. 	/**
  10949. 	 * A generic `Array#map` utility function.
  10950. 	 * @private
  10951. 	 * @param {Array} array The array to iterate over.
  10952. 	 * @param {Function} callback The function that gets called for every array
  10953. 	 * item.
  10954. 	 * @returns {Array} A new array of values returned by the callback function.
  10955. 	 */
  10956. 	function map(array, fn) {
  10957. 		var length = array.length;
  10958. 		var result = [];
  10959. 		while (length--) {
  10960. 			result[length] = fn(array[length]);
  10961. 		}
  10962. 		return result;
  10963. 	}
  10964.  
  10965. 	/**
  10966. 	 * A simple `Array#map`-like wrapper to work with domain name strings or email
  10967. 	 * addresses.
  10968. 	 * @private
  10969. 	 * @param {String} domain The domain name or email address.
  10970. 	 * @param {Function} callback The function that gets called for every
  10971. 	 * character.
  10972. 	 * @returns {Array} A new string of characters returned by the callback
  10973. 	 * function.
  10974. 	 */
  10975. 	function mapDomain(string, fn) {
  10976. 		var parts = string.split('@');
  10977. 		var result = '';
  10978. 		if (parts.length > 1) {
  10979. 			// In email addresses, only the domain name should be punycoded. Leave
  10980. 			// the local part (i.e. everything up to `@`) intact.
  10981. 			result = parts[0] + '@';
  10982. 			string = parts[1];
  10983. 		}
  10984. 		// Avoid `split(regex)` for IE8 compatibility. See #17.
  10985. 		string = string.replace(regexSeparators, '\x2E');
  10986. 		var labels = string.split('.');
  10987. 		var encoded = map(labels, fn).join('.');
  10988. 		return result + encoded;
  10989. 	}
  10990.  
  10991. 	/**
  10992. 	 * Creates an array containing the numeric code points of each Unicode
  10993. 	 * character in the string. While JavaScript uses UCS-2 internally,
  10994. 	 * this function will convert a pair of surrogate halves (each of which
  10995. 	 * UCS-2 exposes as separate characters) into a single code point,
  10996. 	 * matching UTF-16.
  10997. 	 * @see `punycode.ucs2.encode`
  10998. 	 * @see <https://mathiasbynens.be/notes/javascript-encoding>
  10999. 	 * @memberOf punycode.ucs2
  11000. 	 * @name decode
  11001. 	 * @param {String} string The Unicode input string (UCS-2).
  11002. 	 * @returns {Array} The new array of code points.
  11003. 	 */
  11004. 	function ucs2decode(string) {
  11005. 		var output = [],
  11006. 		    counter = 0,
  11007. 		    length = string.length,
  11008. 		    value,
  11009. 		    extra;
  11010. 		while (counter < length) {
  11011. 			value = string.charCodeAt(counter++);
  11012. 			if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
  11013. 				// high surrogate, and there is a next character
  11014. 				extra = string.charCodeAt(counter++);
  11015. 				if ((extra & 0xFC00) == 0xDC00) { // low surrogate
  11016. 					output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
  11017. 				} else {
  11018. 					// unmatched surrogate; only append this code unit, in case the next
  11019. 					// code unit is the high surrogate of a surrogate pair
  11020. 					output.push(value);
  11021. 					counter--;
  11022. 				}
  11023. 			} else {
  11024. 				output.push(value);
  11025. 			}
  11026. 		}
  11027. 		return output;
  11028. 	}
  11029.  
  11030. 	/**
  11031. 	 * Creates a string based on an array of numeric code points.
  11032. 	 * @see `punycode.ucs2.decode`
  11033. 	 * @memberOf punycode.ucs2
  11034. 	 * @name encode
  11035. 	 * @param {Array} codePoints The array of numeric code points.
  11036. 	 * @returns {String} The new Unicode string (UCS-2).
  11037. 	 */
  11038. 	function ucs2encode(array) {
  11039. 		return map(array, function(value) {
  11040. 			var output = '';
  11041. 			if (value > 0xFFFF) {
  11042. 				value -= 0x10000;
  11043. 				output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
  11044. 				value = 0xDC00 | value & 0x3FF;
  11045. 			}
  11046. 			output += stringFromCharCode(value);
  11047. 			return output;
  11048. 		}).join('');
  11049. 	}
  11050.  
  11051. 	/**
  11052. 	 * Converts a basic code point into a digit/integer.
  11053. 	 * @see `digitToBasic()`
  11054. 	 * @private
  11055. 	 * @param {Number} codePoint The basic numeric code point value.
  11056. 	 * @returns {Number} The numeric value of a basic code point (for use in
  11057. 	 * representing integers) in the range `0` to `base - 1`, or `base` if
  11058. 	 * the code point does not represent a value.
  11059. 	 */
  11060. 	function basicToDigit(codePoint) {
  11061. 		if (codePoint - 48 < 10) {
  11062. 			return codePoint - 22;
  11063. 		}
  11064. 		if (codePoint - 65 < 26) {
  11065. 			return codePoint - 65;
  11066. 		}
  11067. 		if (codePoint - 97 < 26) {
  11068. 			return codePoint - 97;
  11069. 		}
  11070. 		return base;
  11071. 	}
  11072.  
  11073. 	/**
  11074. 	 * Converts a digit/integer into a basic code point.
  11075. 	 * @see `basicToDigit()`
  11076. 	 * @private
  11077. 	 * @param {Number} digit The numeric value of a basic code point.
  11078. 	 * @returns {Number} The basic code point whose value (when used for
  11079. 	 * representing integers) is `digit`, which needs to be in the range
  11080. 	 * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
  11081. 	 * used; else, the lowercase form is used. The behavior is undefined
  11082. 	 * if `flag` is non-zero and `digit` has no uppercase form.
  11083. 	 */
  11084. 	function digitToBasic(digit, flag) {
  11085. 		//  0..25 map to ASCII a..z or A..Z
  11086. 		// 26..35 map to ASCII 0..9
  11087. 		return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
  11088. 	}
  11089.  
  11090. 	/**
  11091. 	 * Bias adaptation function as per section 3.4 of RFC 3492.
  11092. 	 * https://tools.ietf.org/html/rfc3492#section-3.4
  11093. 	 * @private
  11094. 	 */
  11095. 	function adapt(delta, numPoints, firstTime) {
  11096. 		var k = 0;
  11097. 		delta = firstTime ? floor(delta / damp) : delta >> 1;
  11098. 		delta += floor(delta / numPoints);
  11099. 		for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {
  11100. 			delta = floor(delta / baseMinusTMin);
  11101. 		}
  11102. 		return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
  11103. 	}
  11104.  
  11105. 	/**
  11106. 	 * Converts a Punycode string of ASCII-only symbols to a string of Unicode
  11107. 	 * symbols.
  11108. 	 * @memberOf punycode
  11109. 	 * @param {String} input The Punycode string of ASCII-only symbols.
  11110. 	 * @returns {String} The resulting string of Unicode symbols.
  11111. 	 */
  11112. 	function decode(input) {
  11113. 		// Don't use UCS-2
  11114. 		var output = [],
  11115. 		    inputLength = input.length,
  11116. 		    out,
  11117. 		    i = 0,
  11118. 		    n = initialN,
  11119. 		    bias = initialBias,
  11120. 		    basic,
  11121. 		    j,
  11122. 		    index,
  11123. 		    oldi,
  11124. 		    w,
  11125. 		    k,
  11126. 		    digit,
  11127. 		    t,
  11128. 		    /** Cached calculation results */
  11129. 		    baseMinusT;
  11130.  
  11131. 		// Handle the basic code points: let `basic` be the number of input code
  11132. 		// points before the last delimiter, or `0` if there is none, then copy
  11133. 		// the first basic code points to the output.
  11134.  
  11135. 		basic = input.lastIndexOf(delimiter);
  11136. 		if (basic < 0) {
  11137. 			basic = 0;
  11138. 		}
  11139.  
  11140. 		for (j = 0; j < basic; ++j) {
  11141. 			// if it's not a basic code point
  11142. 			if (input.charCodeAt(j) >= 0x80) {
  11143. 				error('not-basic');
  11144. 			}
  11145. 			output.push(input.charCodeAt(j));
  11146. 		}
  11147.  
  11148. 		// Main decoding loop: start just after the last delimiter if any basic code
  11149. 		// points were copied; start at the beginning otherwise.
  11150.  
  11151. 		for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {
  11152.  
  11153. 			// `index` is the index of the next character to be consumed.
  11154. 			// Decode a generalized variable-length integer into `delta`,
  11155. 			// which gets added to `i`. The overflow checking is easier
  11156. 			// if we increase `i` as we go, then subtract off its starting
  11157. 			// value at the end to obtain `delta`.
  11158. 			for (oldi = i, w = 1, k = base; /* no condition */; k += base) {
  11159.  
  11160. 				if (index >= inputLength) {
  11161. 					error('invalid-input');
  11162. 				}
  11163.  
  11164. 				digit = basicToDigit(input.charCodeAt(index++));
  11165.  
  11166. 				if (digit >= base || digit > floor((maxInt - i) / w)) {
  11167. 					error('overflow');
  11168. 				}
  11169.  
  11170. 				i += digit * w;
  11171. 				t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
  11172.  
  11173. 				if (digit < t) {
  11174. 					break;
  11175. 				}
  11176.  
  11177. 				baseMinusT = base - t;
  11178. 				if (w > floor(maxInt / baseMinusT)) {
  11179. 					error('overflow');
  11180. 				}
  11181.  
  11182. 				w *= baseMinusT;
  11183.  
  11184. 			}
  11185.  
  11186. 			out = output.length + 1;
  11187. 			bias = adapt(i - oldi, out, oldi == 0);
  11188.  
  11189. 			// `i` was supposed to wrap around from `out` to `0`,
  11190. 			// incrementing `n` each time, so we'll fix that now:
  11191. 			if (floor(i / out) > maxInt - n) {
  11192. 				error('overflow');
  11193. 			}
  11194.  
  11195. 			n += floor(i / out);
  11196. 			i %= out;
  11197.  
  11198. 			// Insert `n` at position `i` of the output
  11199. 			output.splice(i++, 0, n);
  11200.  
  11201. 		}
  11202.  
  11203. 		return ucs2encode(output);
  11204. 	}
  11205.  
  11206. 	/**
  11207. 	 * Converts a string of Unicode symbols (e.g. a domain name label) to a
  11208. 	 * Punycode string of ASCII-only symbols.
  11209. 	 * @memberOf punycode
  11210. 	 * @param {String} input The string of Unicode symbols.
  11211. 	 * @returns {String} The resulting Punycode string of ASCII-only symbols.
  11212. 	 */
  11213. 	function encode(input) {
  11214. 		var n,
  11215. 		    delta,
  11216. 		    handledCPCount,
  11217. 		    basicLength,
  11218. 		    bias,
  11219. 		    j,
  11220. 		    m,
  11221. 		    q,
  11222. 		    k,
  11223. 		    t,
  11224. 		    currentValue,
  11225. 		    output = [],
  11226. 		    /** `inputLength` will hold the number of code points in `input`. */
  11227. 		    inputLength,
  11228. 		    /** Cached calculation results */
  11229. 		    handledCPCountPlusOne,
  11230. 		    baseMinusT,
  11231. 		    qMinusT;
  11232.  
  11233. 		// Convert the input in UCS-2 to Unicode
  11234. 		input = ucs2decode(input);
  11235.  
  11236. 		// Cache the length
  11237. 		inputLength = input.length;
  11238.  
  11239. 		// Initialize the state
  11240. 		n = initialN;
  11241. 		delta = 0;
  11242. 		bias = initialBias;
  11243.  
  11244. 		// Handle the basic code points
  11245. 		for (j = 0; j < inputLength; ++j) {
  11246. 			currentValue = input[j];
  11247. 			if (currentValue < 0x80) {
  11248. 				output.push(stringFromCharCode(currentValue));
  11249. 			}
  11250. 		}
  11251.  
  11252. 		handledCPCount = basicLength = output.length;
  11253.  
  11254. 		// `handledCPCount` is the number of code points that have been handled;
  11255. 		// `basicLength` is the number of basic code points.
  11256.  
  11257. 		// Finish the basic string - if it is not empty - with a delimiter
  11258. 		if (basicLength) {
  11259. 			output.push(delimiter);
  11260. 		}
  11261.  
  11262. 		// Main encoding loop:
  11263. 		while (handledCPCount < inputLength) {
  11264.  
  11265. 			// All non-basic code points < n have been handled already. Find the next
  11266. 			// larger one:
  11267. 			for (m = maxInt, j = 0; j < inputLength; ++j) {
  11268. 				currentValue = input[j];
  11269. 				if (currentValue >= n && currentValue < m) {
  11270. 					m = currentValue;
  11271. 				}
  11272. 			}
  11273.  
  11274. 			// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
  11275. 			// but guard against overflow
  11276. 			handledCPCountPlusOne = handledCPCount + 1;
  11277. 			if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
  11278. 				error('overflow');
  11279. 			}
  11280.  
  11281. 			delta += (m - n) * handledCPCountPlusOne;
  11282. 			n = m;
  11283.  
  11284. 			for (j = 0; j < inputLength; ++j) {
  11285. 				currentValue = input[j];
  11286.  
  11287. 				if (currentValue < n && ++delta > maxInt) {
  11288. 					error('overflow');
  11289. 				}
  11290.  
  11291. 				if (currentValue == n) {
  11292. 					// Represent delta as a generalized variable-length integer
  11293. 					for (q = delta, k = base; /* no condition */; k += base) {
  11294. 						t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
  11295. 						if (q < t) {
  11296. 							break;
  11297. 						}
  11298. 						qMinusT = q - t;
  11299. 						baseMinusT = base - t;
  11300. 						output.push(
  11301. 							stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
  11302. 						);
  11303. 						q = floor(qMinusT / baseMinusT);
  11304. 					}
  11305.  
  11306. 					output.push(stringFromCharCode(digitToBasic(q, 0)));
  11307. 					bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
  11308. 					delta = 0;
  11309. 					++handledCPCount;
  11310. 				}
  11311. 			}
  11312.  
  11313. 			++delta;
  11314. 			++n;
  11315.  
  11316. 		}
  11317. 		return output.join('');
  11318. 	}
  11319.  
  11320. 	/**
  11321. 	 * Converts a Punycode string representing a domain name or an email address
  11322. 	 * to Unicode. Only the Punycoded parts of the input will be converted, i.e.
  11323. 	 * it doesn't matter if you call it on a string that has already been
  11324. 	 * converted to Unicode.
  11325. 	 * @memberOf punycode
  11326. 	 * @param {String} input The Punycoded domain name or email address to
  11327. 	 * convert to Unicode.
  11328. 	 * @returns {String} The Unicode representation of the given Punycode
  11329. 	 * string.
  11330. 	 */
  11331. 	function toUnicode(input) {
  11332. 		return mapDomain(input, function(string) {
  11333. 			return regexPunycode.test(string)
  11334. 				? decode(string.slice(4).toLowerCase())
  11335. 				: string;
  11336. 		});
  11337. 	}
  11338.  
  11339. 	/**
  11340. 	 * Converts a Unicode string representing a domain name or an email address to
  11341. 	 * Punycode. Only the non-ASCII parts of the domain name will be converted,
  11342. 	 * i.e. it doesn't matter if you call it with a domain that's already in
  11343. 	 * ASCII.
  11344. 	 * @memberOf punycode
  11345. 	 * @param {String} input The domain name or email address to convert, as a
  11346. 	 * Unicode string.
  11347. 	 * @returns {String} The Punycode representation of the given domain name or
  11348. 	 * email address.
  11349. 	 */
  11350. 	function toASCII(input) {
  11351. 		return mapDomain(input, function(string) {
  11352. 			return regexNonASCII.test(string)
  11353. 				? 'xn--' + encode(string)
  11354. 				: string;
  11355. 		});
  11356. 	}
  11357.  
  11358. 	/*--------------------------------------------------------------------------*/
  11359.  
  11360. 	/** Define the public API */
  11361. 	punycode = {
  11362. 		/**
  11363. 		 * A string representing the current Punycode.js version number.
  11364. 		 * @memberOf punycode
  11365. 		 * @type String
  11366. 		 */
  11367. 		'version': '1.4.1',
  11368. 		/**
  11369. 		 * An object of methods to convert from JavaScript's internal character
  11370. 		 * representation (UCS-2) to Unicode code points, and back.
  11371. 		 * @see <https://mathiasbynens.be/notes/javascript-encoding>
  11372. 		 * @memberOf punycode
  11373. 		 * @type Object
  11374. 		 */
  11375. 		'ucs2': {
  11376. 			'decode': ucs2decode,
  11377. 			'encode': ucs2encode
  11378. 		},
  11379. 		'decode': decode,
  11380. 		'encode': encode,
  11381. 		'toASCII': toASCII,
  11382. 		'toUnicode': toUnicode
  11383. 	};
  11384.  
  11385. 	/** Expose `punycode` */
  11386. 	// Some AMD build optimizers, like r.js, check for specific condition patterns
  11387. 	// like the following:
  11388. 	if (
  11389. 		true
  11390. 	) {
  11391. 		!(__WEBPACK_AMD_DEFINE_RESULT__ = function() {
  11392. 			return punycode;
  11393. 		}.call(exports, __webpack_require__, exports, module),
  11394. 				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
  11395. 	} else if (freeExports && freeModule) {
  11396. 		if (module.exports == freeExports) {
  11397. 			// in Node.js, io.js, or RingoJS v0.8.0+
  11398. 			freeModule.exports = punycode;
  11399. 		} else {
  11400. 			// in Narwhal or RingoJS v0.7.0-
  11401. 			for (key in punycode) {
  11402. 				punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);
  11403. 			}
  11404. 		}
  11405. 	} else {
  11406. 		// in Rhino or a web browser
  11407. 		root.punycode = punycode;
  11408. 	}
  11409.  
  11410. }(this));
  11411.  
  11412. /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(116)(module), __webpack_require__(8)))
  11413.  
  11414. /***/ }),
  11415. /* 103 */
  11416. /***/ (function(module, exports, __webpack_require__) {
  11417.  
  11418. "use strict";
  11419. // Copyright Joyent, Inc. and other Node contributors.
  11420. //
  11421. // Permission is hereby granted, free of charge, to any person obtaining a
  11422. // copy of this software and associated documentation files (the
  11423. // "Software"), to deal in the Software without restriction, including
  11424. // without limitation the rights to use, copy, modify, merge, publish,
  11425. // distribute, sublicense, and/or sell copies of the Software, and to permit
  11426. // persons to whom the Software is furnished to do so, subject to the
  11427. // following conditions:
  11428. //
  11429. // The above copyright notice and this permission notice shall be included
  11430. // in all copies or substantial portions of the Software.
  11431. //
  11432. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  11433. // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  11434. // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  11435. // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  11436. // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  11437. // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  11438. // USE OR OTHER DEALINGS IN THE SOFTWARE.
  11439.  
  11440.  
  11441.  
  11442. // If obj.hasOwnProperty has been overridden, then calling
  11443. // obj.hasOwnProperty(prop) will break.
  11444. // See: https://github.com/joyent/node/issues/1707
  11445. function hasOwnProperty(obj, prop) {
  11446.   return Object.prototype.hasOwnProperty.call(obj, prop);
  11447. }
  11448.  
  11449. module.exports = function(qs, sep, eq, options) {
  11450.   sep = sep || '&';
  11451.   eq = eq || '=';
  11452.   var obj = {};
  11453.  
  11454.   if (typeof qs !== 'string' || qs.length === 0) {
  11455.     return obj;
  11456.   }
  11457.  
  11458.   var regexp = /\+/g;
  11459.   qs = qs.split(sep);
  11460.  
  11461.   var maxKeys = 1000;
  11462.   if (options && typeof options.maxKeys === 'number') {
  11463.     maxKeys = options.maxKeys;
  11464.   }
  11465.  
  11466.   var len = qs.length;
  11467.   // maxKeys <= 0 means that we should not limit keys count
  11468.   if (maxKeys > 0 && len > maxKeys) {
  11469.     len = maxKeys;
  11470.   }
  11471.  
  11472.   for (var i = 0; i < len; ++i) {
  11473.     var x = qs[i].replace(regexp, '%20'),
  11474.         idx = x.indexOf(eq),
  11475.         kstr, vstr, k, v;
  11476.  
  11477.     if (idx >= 0) {
  11478.       kstr = x.substr(0, idx);
  11479.       vstr = x.substr(idx + 1);
  11480.     } else {
  11481.       kstr = x;
  11482.       vstr = '';
  11483.     }
  11484.  
  11485.     k = decodeURIComponent(kstr);
  11486.     v = decodeURIComponent(vstr);
  11487.  
  11488.     if (!hasOwnProperty(obj, k)) {
  11489.       obj[k] = v;
  11490.     } else if (isArray(obj[k])) {
  11491.       obj[k].push(v);
  11492.     } else {
  11493.       obj[k] = [obj[k], v];
  11494.     }
  11495.   }
  11496.  
  11497.   return obj;
  11498. };
  11499.  
  11500. var isArray = Array.isArray || function (xs) {
  11501.   return Object.prototype.toString.call(xs) === '[object Array]';
  11502. };
  11503.  
  11504.  
  11505. /***/ }),
  11506. /* 104 */
  11507. /***/ (function(module, exports, __webpack_require__) {
  11508.  
  11509. "use strict";
  11510. // Copyright Joyent, Inc. and other Node contributors.
  11511. //
  11512. // Permission is hereby granted, free of charge, to any person obtaining a
  11513. // copy of this software and associated documentation files (the
  11514. // "Software"), to deal in the Software without restriction, including
  11515. // without limitation the rights to use, copy, modify, merge, publish,
  11516. // distribute, sublicense, and/or sell copies of the Software, and to permit
  11517. // persons to whom the Software is furnished to do so, subject to the
  11518. // following conditions:
  11519. //
  11520. // The above copyright notice and this permission notice shall be included
  11521. // in all copies or substantial portions of the Software.
  11522. //
  11523. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  11524. // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  11525. // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  11526. // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  11527. // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  11528. // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  11529. // USE OR OTHER DEALINGS IN THE SOFTWARE.
  11530.  
  11531.  
  11532.  
  11533. var stringifyPrimitive = function(v) {
  11534.   switch (typeof v) {
  11535.     case 'string':
  11536.       return v;
  11537.  
  11538.     case 'boolean':
  11539.       return v ? 'true' : 'false';
  11540.  
  11541.     case 'number':
  11542.       return isFinite(v) ? v : '';
  11543.  
  11544.     default:
  11545.       return '';
  11546.   }
  11547. };
  11548.  
  11549. module.exports = function(obj, sep, eq, name) {
  11550.   sep = sep || '&';
  11551.   eq = eq || '=';
  11552.   if (obj === null) {
  11553.     obj = undefined;
  11554.   }
  11555.  
  11556.   if (typeof obj === 'object') {
  11557.     return map(objectKeys(obj), function(k) {
  11558.       var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;
  11559.       if (isArray(obj[k])) {
  11560.         return map(obj[k], function(v) {
  11561.           return ks + encodeURIComponent(stringifyPrimitive(v));
  11562.         }).join(sep);
  11563.       } else {
  11564.         return ks + encodeURIComponent(stringifyPrimitive(obj[k]));
  11565.       }
  11566.     }).join(sep);
  11567.  
  11568.   }
  11569.  
  11570.   if (!name) return '';
  11571.   return encodeURIComponent(stringifyPrimitive(name)) + eq +
  11572.          encodeURIComponent(stringifyPrimitive(obj));
  11573. };
  11574.  
  11575. var isArray = Array.isArray || function (xs) {
  11576.   return Object.prototype.toString.call(xs) === '[object Array]';
  11577. };
  11578.  
  11579. function map (xs, f) {
  11580.   if (xs.map) return xs.map(f);
  11581.   var res = [];
  11582.   for (var i = 0; i < xs.length; i++) {
  11583.     res.push(f(xs[i], i));
  11584.   }
  11585.   return res;
  11586. }
  11587.  
  11588. var objectKeys = Object.keys || function (obj) {
  11589.   var res = [];
  11590.   for (var key in obj) {
  11591.     if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key);
  11592.   }
  11593.   return res;
  11594. };
  11595.  
  11596.  
  11597. /***/ }),
  11598. /* 105 */
  11599. /***/ (function(module, exports, __webpack_require__) {
  11600.  
  11601. "use strict";
  11602.  
  11603.  
  11604. exports.decode = exports.parse = __webpack_require__(103);
  11605. exports.encode = exports.stringify = __webpack_require__(104);
  11606.  
  11607.  
  11608. /***/ }),
  11609. /* 106 */
  11610. /***/ (function(module, exports, __webpack_require__) {
  11611.  
  11612. /* WEBPACK VAR INJECTION */(function(global) {// This method of obtaining a reference to the global object needs to be
  11613. // kept identical to the way it is obtained in runtime.js
  11614. var g =
  11615.   typeof global === "object" ? global :
  11616.   typeof window === "object" ? window :
  11617.   typeof self === "object" ? self : this;
  11618.  
  11619. // Use `getOwnPropertyNames` because not all browsers support calling
  11620. // `hasOwnProperty` on the global `self` object in a worker. See #183.
  11621. var hadRuntime = g.regeneratorRuntime &&
  11622.   Object.getOwnPropertyNames(g).indexOf("regeneratorRuntime") >= 0;
  11623.  
  11624. // Save the old regeneratorRuntime in case it needs to be restored later.
  11625. var oldRuntime = hadRuntime && g.regeneratorRuntime;
  11626.  
  11627. // Force reevalutation of runtime.js.
  11628. g.regeneratorRuntime = undefined;
  11629.  
  11630. module.exports = __webpack_require__(107);
  11631.  
  11632. if (hadRuntime) {
  11633.   // Restore the original runtime.
  11634.   g.regeneratorRuntime = oldRuntime;
  11635. } else {
  11636.   // Remove the global property added by runtime.js.
  11637.   try {
  11638.     delete g.regeneratorRuntime;
  11639.   } catch(e) {
  11640.     g.regeneratorRuntime = undefined;
  11641.   }
  11642. }
  11643.  
  11644. /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(8)))
  11645.  
  11646. /***/ }),
  11647. /* 107 */
  11648. /***/ (function(module, exports, __webpack_require__) {
  11649.  
  11650. /* WEBPACK VAR INJECTION */(function(global, process) {/**
  11651.  * Copyright (c) 2014, Facebook, Inc.
  11652.  * All rights reserved.
  11653.  *
  11654.  * This source code is licensed under the BSD-style license found in the
  11655.  * https://raw.github.com/facebook/regenerator/master/LICENSE file. An
  11656.  * additional grant of patent rights can be found in the PATENTS file in
  11657.  * the same directory.
  11658.  */
  11659.  
  11660. !(function(global) {
  11661.   "use strict";
  11662.  
  11663.   var Op = Object.prototype;
  11664.   var hasOwn = Op.hasOwnProperty;
  11665.   var undefined; // More compressible than void 0.
  11666.   var $Symbol = typeof Symbol === "function" ? Symbol : {};
  11667.   var iteratorSymbol = $Symbol.iterator || "@@iterator";
  11668.   var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
  11669.  
  11670.   var inModule = typeof module === "object";
  11671.   var runtime = global.regeneratorRuntime;
  11672.   if (runtime) {
  11673.     if (inModule) {
  11674.       // If regeneratorRuntime is defined globally and we're in a module,
  11675.       // make the exports object identical to regeneratorRuntime.
  11676.       module.exports = runtime;
  11677.     }
  11678.     // Don't bother evaluating the rest of this file if the runtime was
  11679.     // already defined globally.
  11680.     return;
  11681.   }
  11682.  
  11683.   // Define the runtime globally (as expected by generated code) as either
  11684.   // module.exports (if we're in a module) or a new, empty object.
  11685.   runtime = global.regeneratorRuntime = inModule ? module.exports : {};
  11686.  
  11687.   function wrap(innerFn, outerFn, self, tryLocsList) {
  11688.     // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
  11689.     var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
  11690.     var generator = Object.create(protoGenerator.prototype);
  11691.     var context = new Context(tryLocsList || []);
  11692.  
  11693.     // The ._invoke method unifies the implementations of the .next,
  11694.     // .throw, and .return methods.
  11695.     generator._invoke = makeInvokeMethod(innerFn, self, context);
  11696.  
  11697.     return generator;
  11698.   }
  11699.   runtime.wrap = wrap;
  11700.  
  11701.   // Try/catch helper to minimize deoptimizations. Returns a completion
  11702.   // record like context.tryEntries[i].completion. This interface could
  11703.   // have been (and was previously) designed to take a closure to be
  11704.   // invoked without arguments, but in all the cases we care about we
  11705.   // already have an existing method we want to call, so there's no need
  11706.   // to create a new function object. We can even get away with assuming
  11707.   // the method takes exactly one argument, since that happens to be true
  11708.   // in every case, so we don't have to touch the arguments object. The
  11709.   // only additional allocation required is the completion record, which
  11710.   // has a stable shape and so hopefully should be cheap to allocate.
  11711.   function tryCatch(fn, obj, arg) {
  11712.     try {
  11713.       return { type: "normal", arg: fn.call(obj, arg) };
  11714.     } catch (err) {
  11715.       return { type: "throw", arg: err };
  11716.     }
  11717.   }
  11718.  
  11719.   var GenStateSuspendedStart = "suspendedStart";
  11720.   var GenStateSuspendedYield = "suspendedYield";
  11721.   var GenStateExecuting = "executing";
  11722.   var GenStateCompleted = "completed";
  11723.  
  11724.   // Returning this object from the innerFn has the same effect as
  11725.   // breaking out of the dispatch switch statement.
  11726.   var ContinueSentinel = {};
  11727.  
  11728.   // Dummy constructor functions that we use as the .constructor and
  11729.   // .constructor.prototype properties for functions that return Generator
  11730.   // objects. For full spec compliance, you may wish to configure your
  11731.   // minifier not to mangle the names of these two functions.
  11732.   function Generator() {}
  11733.   function GeneratorFunction() {}
  11734.   function GeneratorFunctionPrototype() {}
  11735.  
  11736.   // This is a polyfill for %IteratorPrototype% for environments that
  11737.   // don't natively support it.
  11738.   var IteratorPrototype = {};
  11739.   IteratorPrototype[iteratorSymbol] = function () {
  11740.     return this;
  11741.   };
  11742.  
  11743.   var getProto = Object.getPrototypeOf;
  11744.   var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
  11745.   if (NativeIteratorPrototype &&
  11746.       NativeIteratorPrototype !== Op &&
  11747.       hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
  11748.     // This environment has a native %IteratorPrototype%; use it instead
  11749.     // of the polyfill.
  11750.     IteratorPrototype = NativeIteratorPrototype;
  11751.   }
  11752.  
  11753.   var Gp = GeneratorFunctionPrototype.prototype =
  11754.     Generator.prototype = Object.create(IteratorPrototype);
  11755.   GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
  11756.   GeneratorFunctionPrototype.constructor = GeneratorFunction;
  11757.   GeneratorFunctionPrototype[toStringTagSymbol] =
  11758.     GeneratorFunction.displayName = "GeneratorFunction";
  11759.  
  11760.   // Helper for defining the .next, .throw, and .return methods of the
  11761.   // Iterator interface in terms of a single ._invoke method.
  11762.   function defineIteratorMethods(prototype) {
  11763.     ["next", "throw", "return"].forEach(function(method) {
  11764.       prototype[method] = function(arg) {
  11765.         return this._invoke(method, arg);
  11766.       };
  11767.     });
  11768.   }
  11769.  
  11770.   runtime.isGeneratorFunction = function(genFun) {
  11771.     var ctor = typeof genFun === "function" && genFun.constructor;
  11772.     return ctor
  11773.       ? ctor === GeneratorFunction ||
  11774.         // For the native GeneratorFunction constructor, the best we can
  11775.         // do is to check its .name property.
  11776.         (ctor.displayName || ctor.name) === "GeneratorFunction"
  11777.       : false;
  11778.   };
  11779.  
  11780.   runtime.mark = function(genFun) {
  11781.     if (Object.setPrototypeOf) {
  11782.       Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
  11783.     } else {
  11784.       genFun.__proto__ = GeneratorFunctionPrototype;
  11785.       if (!(toStringTagSymbol in genFun)) {
  11786.         genFun[toStringTagSymbol] = "GeneratorFunction";
  11787.       }
  11788.     }
  11789.     genFun.prototype = Object.create(Gp);
  11790.     return genFun;
  11791.   };
  11792.  
  11793.   // Within the body of any async function, `await x` is transformed to
  11794.   // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
  11795.   // `hasOwn.call(value, "__await")` to determine if the yielded value is
  11796.   // meant to be awaited.
  11797.   runtime.awrap = function(arg) {
  11798.     return { __await: arg };
  11799.   };
  11800.  
  11801.   function AsyncIterator(generator) {
  11802.     function invoke(method, arg, resolve, reject) {
  11803.       var record = tryCatch(generator[method], generator, arg);
  11804.       if (record.type === "throw") {
  11805.         reject(record.arg);
  11806.       } else {
  11807.         var result = record.arg;
  11808.         var value = result.value;
  11809.         if (value &&
  11810.             typeof value === "object" &&
  11811.             hasOwn.call(value, "__await")) {
  11812.           return Promise.resolve(value.__await).then(function(value) {
  11813.             invoke("next", value, resolve, reject);
  11814.           }, function(err) {
  11815.             invoke("throw", err, resolve, reject);
  11816.           });
  11817.         }
  11818.  
  11819.         return Promise.resolve(value).then(function(unwrapped) {
  11820.           // When a yielded Promise is resolved, its final value becomes
  11821.           // the .value of the Promise<{value,done}> result for the
  11822.           // current iteration. If the Promise is rejected, however, the
  11823.           // result for this iteration will be rejected with the same
  11824.           // reason. Note that rejections of yielded Promises are not
  11825.           // thrown back into the generator function, as is the case
  11826.           // when an awaited Promise is rejected. This difference in
  11827.           // behavior between yield and await is important, because it
  11828.           // allows the consumer to decide what to do with the yielded
  11829.           // rejection (swallow it and continue, manually .throw it back
  11830.           // into the generator, abandon iteration, whatever). With
  11831.           // await, by contrast, there is no opportunity to examine the
  11832.           // rejection reason outside the generator function, so the
  11833.           // only option is to throw it from the await expression, and
  11834.           // let the generator function handle the exception.
  11835.           result.value = unwrapped;
  11836.           resolve(result);
  11837.         }, reject);
  11838.       }
  11839.     }
  11840.  
  11841.     if (typeof process === "object" && process.domain) {
  11842.       invoke = process.domain.bind(invoke);
  11843.     }
  11844.  
  11845.     var previousPromise;
  11846.  
  11847.     function enqueue(method, arg) {
  11848.       function callInvokeWithMethodAndArg() {
  11849.         return new Promise(function(resolve, reject) {
  11850.           invoke(method, arg, resolve, reject);
  11851.         });
  11852.       }
  11853.  
  11854.       return previousPromise =
  11855.         // If enqueue has been called before, then we want to wait until
  11856.         // all previous Promises have been resolved before calling invoke,
  11857.         // so that results are always delivered in the correct order. If
  11858.         // enqueue has not been called before, then it is important to
  11859.         // call invoke immediately, without waiting on a callback to fire,
  11860.         // so that the async generator function has the opportunity to do
  11861.         // any necessary setup in a predictable way. This predictability
  11862.         // is why the Promise constructor synchronously invokes its
  11863.         // executor callback, and why async functions synchronously
  11864.         // execute code before the first await. Since we implement simple
  11865.         // async functions in terms of async generators, it is especially
  11866.         // important to get this right, even though it requires care.
  11867.         previousPromise ? previousPromise.then(
  11868.           callInvokeWithMethodAndArg,
  11869.           // Avoid propagating failures to Promises returned by later
  11870.           // invocations of the iterator.
  11871.           callInvokeWithMethodAndArg
  11872.         ) : callInvokeWithMethodAndArg();
  11873.     }
  11874.  
  11875.     // Define the unified helper method that is used to implement .next,
  11876.     // .throw, and .return (see defineIteratorMethods).
  11877.     this._invoke = enqueue;
  11878.   }
  11879.  
  11880.   defineIteratorMethods(AsyncIterator.prototype);
  11881.   runtime.AsyncIterator = AsyncIterator;
  11882.  
  11883.   // Note that simple async functions are implemented on top of
  11884.   // AsyncIterator objects; they just return a Promise for the value of
  11885.   // the final result produced by the iterator.
  11886.   runtime.async = function(innerFn, outerFn, self, tryLocsList) {
  11887.     var iter = new AsyncIterator(
  11888.       wrap(innerFn, outerFn, self, tryLocsList)
  11889.     );
  11890.  
  11891.     return runtime.isGeneratorFunction(outerFn)
  11892.       ? iter // If outerFn is a generator, return the full iterator.
  11893.       : iter.next().then(function(result) {
  11894.           return result.done ? result.value : iter.next();
  11895.         });
  11896.   };
  11897.  
  11898.   function makeInvokeMethod(innerFn, self, context) {
  11899.     var state = GenStateSuspendedStart;
  11900.  
  11901.     return function invoke(method, arg) {
  11902.       if (state === GenStateExecuting) {
  11903.         throw new Error("Generator is already running");
  11904.       }
  11905.  
  11906.       if (state === GenStateCompleted) {
  11907.         if (method === "throw") {
  11908.           throw arg;
  11909.         }
  11910.  
  11911.         // Be forgiving, per 25.3.3.3.3 of the spec:
  11912.         // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
  11913.         return doneResult();
  11914.       }
  11915.  
  11916.       context.method = method;
  11917.       context.arg = arg;
  11918.  
  11919.       while (true) {
  11920.         var delegate = context.delegate;
  11921.         if (delegate) {
  11922.           var delegateResult = maybeInvokeDelegate(delegate, context);
  11923.           if (delegateResult) {
  11924.             if (delegateResult === ContinueSentinel) continue;
  11925.             return delegateResult;
  11926.           }
  11927.         }
  11928.  
  11929.         if (context.method === "next") {
  11930.           // Setting context._sent for legacy support of Babel's
  11931.           // function.sent implementation.
  11932.           context.sent = context._sent = context.arg;
  11933.  
  11934.         } else if (context.method === "throw") {
  11935.           if (state === GenStateSuspendedStart) {
  11936.             state = GenStateCompleted;
  11937.             throw context.arg;
  11938.           }
  11939.  
  11940.           context.dispatchException(context.arg);
  11941.  
  11942.         } else if (context.method === "return") {
  11943.           context.abrupt("return", context.arg);
  11944.         }
  11945.  
  11946.         state = GenStateExecuting;
  11947.  
  11948.         var record = tryCatch(innerFn, self, context);
  11949.         if (record.type === "normal") {
  11950.           // If an exception is thrown from innerFn, we leave state ===
  11951.           // GenStateExecuting and loop back for another invocation.
  11952.           state = context.done
  11953.             ? GenStateCompleted
  11954.             : GenStateSuspendedYield;
  11955.  
  11956.           if (record.arg === ContinueSentinel) {
  11957.             continue;
  11958.           }
  11959.  
  11960.           return {
  11961.             value: record.arg,
  11962.             done: context.done
  11963.           };
  11964.  
  11965.         } else if (record.type === "throw") {
  11966.           state = GenStateCompleted;
  11967.           // Dispatch the exception by looping back around to the
  11968.           // context.dispatchException(context.arg) call above.
  11969.           context.method = "throw";
  11970.           context.arg = record.arg;
  11971.         }
  11972.       }
  11973.     };
  11974.   }
  11975.  
  11976.   // Call delegate.iterator[context.method](context.arg) and handle the
  11977.   // result, either by returning a { value, done } result from the
  11978.   // delegate iterator, or by modifying context.method and context.arg,
  11979.   // setting context.delegate to null, and returning the ContinueSentinel.
  11980.   function maybeInvokeDelegate(delegate, context) {
  11981.     var method = delegate.iterator[context.method];
  11982.     if (method === undefined) {
  11983.       // A .throw or .return when the delegate iterator has no .throw
  11984.       // method always terminates the yield* loop.
  11985.       context.delegate = null;
  11986.  
  11987.       if (context.method === "throw") {
  11988.         if (delegate.iterator.return) {
  11989.           // If the delegate iterator has a return method, give it a
  11990.           // chance to clean up.
  11991.           context.method = "return";
  11992.           context.arg = undefined;
  11993.           maybeInvokeDelegate(delegate, context);
  11994.  
  11995.           if (context.method === "throw") {
  11996.             // If maybeInvokeDelegate(context) changed context.method from
  11997.             // "return" to "throw", let that override the TypeError below.
  11998.             return ContinueSentinel;
  11999.           }
  12000.         }
  12001.  
  12002.         context.method = "throw";
  12003.         context.arg = new TypeError(
  12004.           "The iterator does not provide a 'throw' method");
  12005.       }
  12006.  
  12007.       return ContinueSentinel;
  12008.     }
  12009.  
  12010.     var record = tryCatch(method, delegate.iterator, context.arg);
  12011.  
  12012.     if (record.type === "throw") {
  12013.       context.method = "throw";
  12014.       context.arg = record.arg;
  12015.       context.delegate = null;
  12016.       return ContinueSentinel;
  12017.     }
  12018.  
  12019.     var info = record.arg;
  12020.  
  12021.     if (! info) {
  12022.       context.method = "throw";
  12023.       context.arg = new TypeError("iterator result is not an object");
  12024.       context.delegate = null;
  12025.       return ContinueSentinel;
  12026.     }
  12027.  
  12028.     if (info.done) {
  12029.       // Assign the result of the finished delegate to the temporary
  12030.       // variable specified by delegate.resultName (see delegateYield).
  12031.       context[delegate.resultName] = info.value;
  12032.  
  12033.       // Resume execution at the desired location (see delegateYield).
  12034.       context.next = delegate.nextLoc;
  12035.  
  12036.       // If context.method was "throw" but the delegate handled the
  12037.       // exception, let the outer generator proceed normally. If
  12038.       // context.method was "next", forget context.arg since it has been
  12039.       // "consumed" by the delegate iterator. If context.method was
  12040.       // "return", allow the original .return call to continue in the
  12041.       // outer generator.
  12042.       if (context.method !== "return") {
  12043.         context.method = "next";
  12044.         context.arg = undefined;
  12045.       }
  12046.  
  12047.     } else {
  12048.       // Re-yield the result returned by the delegate method.
  12049.       return info;
  12050.     }
  12051.  
  12052.     // The delegate iterator is finished, so forget it and continue with
  12053.     // the outer generator.
  12054.     context.delegate = null;
  12055.     return ContinueSentinel;
  12056.   }
  12057.  
  12058.   // Define Generator.prototype.{next,throw,return} in terms of the
  12059.   // unified ._invoke helper method.
  12060.   defineIteratorMethods(Gp);
  12061.  
  12062.   Gp[toStringTagSymbol] = "Generator";
  12063.  
  12064.   Gp.toString = function() {
  12065.     return "[object Generator]";
  12066.   };
  12067.  
  12068.   function pushTryEntry(locs) {
  12069.     var entry = { tryLoc: locs[0] };
  12070.  
  12071.     if (1 in locs) {
  12072.       entry.catchLoc = locs[1];
  12073.     }
  12074.  
  12075.     if (2 in locs) {
  12076.       entry.finallyLoc = locs[2];
  12077.       entry.afterLoc = locs[3];
  12078.     }
  12079.  
  12080.     this.tryEntries.push(entry);
  12081.   }
  12082.  
  12083.   function resetTryEntry(entry) {
  12084.     var record = entry.completion || {};
  12085.     record.type = "normal";
  12086.     delete record.arg;
  12087.     entry.completion = record;
  12088.   }
  12089.  
  12090.   function Context(tryLocsList) {
  12091.     // The root entry object (effectively a try statement without a catch
  12092.     // or a finally block) gives us a place to store values thrown from
  12093.     // locations where there is no enclosing try statement.
  12094.     this.tryEntries = [{ tryLoc: "root" }];
  12095.     tryLocsList.forEach(pushTryEntry, this);
  12096.     this.reset(true);
  12097.   }
  12098.  
  12099.   runtime.keys = function(object) {
  12100.     var keys = [];
  12101.     for (var key in object) {
  12102.       keys.push(key);
  12103.     }
  12104.     keys.reverse();
  12105.  
  12106.     // Rather than returning an object with a next method, we keep
  12107.     // things simple and return the next function itself.
  12108.     return function next() {
  12109.       while (keys.length) {
  12110.         var key = keys.pop();
  12111.         if (key in object) {
  12112.           next.value = key;
  12113.           next.done = false;
  12114.           return next;
  12115.         }
  12116.       }
  12117.  
  12118.       // To avoid creating an additional object, we just hang the .value
  12119.       // and .done properties off the next function object itself. This
  12120.       // also ensures that the minifier will not anonymize the function.
  12121.       next.done = true;
  12122.       return next;
  12123.     };
  12124.   };
  12125.  
  12126.   function values(iterable) {
  12127.     if (iterable) {
  12128.       var iteratorMethod = iterable[iteratorSymbol];
  12129.       if (iteratorMethod) {
  12130.         return iteratorMethod.call(iterable);
  12131.       }
  12132.  
  12133.       if (typeof iterable.next === "function") {
  12134.         return iterable;
  12135.       }
  12136.  
  12137.       if (!isNaN(iterable.length)) {
  12138.         var i = -1, next = function next() {
  12139.           while (++i < iterable.length) {
  12140.             if (hasOwn.call(iterable, i)) {
  12141.               next.value = iterable[i];
  12142.               next.done = false;
  12143.               return next;
  12144.             }
  12145.           }
  12146.  
  12147.           next.value = undefined;
  12148.           next.done = true;
  12149.  
  12150.           return next;
  12151.         };
  12152.  
  12153.         return next.next = next;
  12154.       }
  12155.     }
  12156.  
  12157.     // Return an iterator with no values.
  12158.     return { next: doneResult };
  12159.   }
  12160.   runtime.values = values;
  12161.  
  12162.   function doneResult() {
  12163.     return { value: undefined, done: true };
  12164.   }
  12165.  
  12166.   Context.prototype = {
  12167.     constructor: Context,
  12168.  
  12169.     reset: function(skipTempReset) {
  12170.       this.prev = 0;
  12171.       this.next = 0;
  12172.       // Resetting context._sent for legacy support of Babel's
  12173.       // function.sent implementation.
  12174.       this.sent = this._sent = undefined;
  12175.       this.done = false;
  12176.       this.delegate = null;
  12177.  
  12178.       this.method = "next";
  12179.       this.arg = undefined;
  12180.  
  12181.       this.tryEntries.forEach(resetTryEntry);
  12182.  
  12183.       if (!skipTempReset) {
  12184.         for (var name in this) {
  12185.           // Not sure about the optimal order of these conditions:
  12186.           if (name.charAt(0) === "t" &&
  12187.               hasOwn.call(this, name) &&
  12188.               !isNaN(+name.slice(1))) {
  12189.             this[name] = undefined;
  12190.           }
  12191.         }
  12192.       }
  12193.     },
  12194.  
  12195.     stop: function() {
  12196.       this.done = true;
  12197.  
  12198.       var rootEntry = this.tryEntries[0];
  12199.       var rootRecord = rootEntry.completion;
  12200.       if (rootRecord.type === "throw") {
  12201.         throw rootRecord.arg;
  12202.       }
  12203.  
  12204.       return this.rval;
  12205.     },
  12206.  
  12207.     dispatchException: function(exception) {
  12208.       if (this.done) {
  12209.         throw exception;
  12210.       }
  12211.  
  12212.       var context = this;
  12213.       function handle(loc, caught) {
  12214.         record.type = "throw";
  12215.         record.arg = exception;
  12216.         context.next = loc;
  12217.  
  12218.         if (caught) {
  12219.           // If the dispatched exception was caught by a catch block,
  12220.           // then let that catch block handle the exception normally.
  12221.           context.method = "next";
  12222.           context.arg = undefined;
  12223.         }
  12224.  
  12225.         return !! caught;
  12226.       }
  12227.  
  12228.       for (var i = this.tryEntries.length - 1; i >= 0; --i) {
  12229.         var entry = this.tryEntries[i];
  12230.         var record = entry.completion;
  12231.  
  12232.         if (entry.tryLoc === "root") {
  12233.           // Exception thrown outside of any try block that could handle
  12234.           // it, so set the completion value of the entire function to
  12235.           // throw the exception.
  12236.           return handle("end");
  12237.         }
  12238.  
  12239.         if (entry.tryLoc <= this.prev) {
  12240.           var hasCatch = hasOwn.call(entry, "catchLoc");
  12241.           var hasFinally = hasOwn.call(entry, "finallyLoc");
  12242.  
  12243.           if (hasCatch && hasFinally) {
  12244.             if (this.prev < entry.catchLoc) {
  12245.               return handle(entry.catchLoc, true);
  12246.             } else if (this.prev < entry.finallyLoc) {
  12247.               return handle(entry.finallyLoc);
  12248.             }
  12249.  
  12250.           } else if (hasCatch) {
  12251.             if (this.prev < entry.catchLoc) {
  12252.               return handle(entry.catchLoc, true);
  12253.             }
  12254.  
  12255.           } else if (hasFinally) {
  12256.             if (this.prev < entry.finallyLoc) {
  12257.               return handle(entry.finallyLoc);
  12258.             }
  12259.  
  12260.           } else {
  12261.             throw new Error("try statement without catch or finally");
  12262.           }
  12263.         }
  12264.       }
  12265.     },
  12266.  
  12267.     abrupt: function(type, arg) {
  12268.       for (var i = this.tryEntries.length - 1; i >= 0; --i) {
  12269.         var entry = this.tryEntries[i];
  12270.         if (entry.tryLoc <= this.prev &&
  12271.             hasOwn.call(entry, "finallyLoc") &&
  12272.             this.prev < entry.finallyLoc) {
  12273.           var finallyEntry = entry;
  12274.           break;
  12275.         }
  12276.       }
  12277.  
  12278.       if (finallyEntry &&
  12279.           (type === "break" ||
  12280.            type === "continue") &&
  12281.           finallyEntry.tryLoc <= arg &&
  12282.           arg <= finallyEntry.finallyLoc) {
  12283.         // Ignore the finally entry if control is not jumping to a
  12284.         // location outside the try/catch block.
  12285.         finallyEntry = null;
  12286.       }
  12287.  
  12288.       var record = finallyEntry ? finallyEntry.completion : {};
  12289.       record.type = type;
  12290.       record.arg = arg;
  12291.  
  12292.       if (finallyEntry) {
  12293.         this.method = "next";
  12294.         this.next = finallyEntry.finallyLoc;
  12295.         return ContinueSentinel;
  12296.       }
  12297.  
  12298.       return this.complete(record);
  12299.     },
  12300.  
  12301.     complete: function(record, afterLoc) {
  12302.       if (record.type === "throw") {
  12303.         throw record.arg;
  12304.       }
  12305.  
  12306.       if (record.type === "break" ||
  12307.           record.type === "continue") {
  12308.         this.next = record.arg;
  12309.       } else if (record.type === "return") {
  12310.         this.rval = this.arg = record.arg;
  12311.         this.method = "return";
  12312.         this.next = "end";
  12313.       } else if (record.type === "normal" && afterLoc) {
  12314.         this.next = afterLoc;
  12315.       }
  12316.  
  12317.       return ContinueSentinel;
  12318.     },
  12319.  
  12320.     finish: function(finallyLoc) {
  12321.       for (var i = this.tryEntries.length - 1; i >= 0; --i) {
  12322.         var entry = this.tryEntries[i];
  12323.         if (entry.finallyLoc === finallyLoc) {
  12324.           this.complete(entry.completion, entry.afterLoc);
  12325.           resetTryEntry(entry);
  12326.           return ContinueSentinel;
  12327.         }
  12328.       }
  12329.     },
  12330.  
  12331.     "catch": function(tryLoc) {
  12332.       for (var i = this.tryEntries.length - 1; i >= 0; --i) {
  12333.         var entry = this.tryEntries[i];
  12334.         if (entry.tryLoc === tryLoc) {
  12335.           var record = entry.completion;
  12336.           if (record.type === "throw") {
  12337.             var thrown = record.arg;
  12338.             resetTryEntry(entry);
  12339.           }
  12340.           return thrown;
  12341.         }
  12342.       }
  12343.  
  12344.       // The context.catch method must only be called with a location
  12345.       // argument that corresponds to a known catch block.
  12346.       throw new Error("illegal catch attempt");
  12347.     },
  12348.  
  12349.     delegateYield: function(iterable, resultName, nextLoc) {
  12350.       this.delegate = {
  12351.         iterator: values(iterable),
  12352.         resultName: resultName,
  12353.         nextLoc: nextLoc
  12354.       };
  12355.  
  12356.       if (this.method === "next") {
  12357.         // Deliberately forget the last sent value so that we don't
  12358.         // accidentally pass it on to the delegate.
  12359.         this.arg = undefined;
  12360.       }
  12361.  
  12362.       return ContinueSentinel;
  12363.     }
  12364.   };
  12365. })(
  12366.   // Among the various tricks for obtaining a reference to the global
  12367.   // object, this seems to be the most reliable technique that does not
  12368.   // use indirect eval (which violates Content Security Policy).
  12369.   typeof global === "object" ? global :
  12370.   typeof window === "object" ? window :
  12371.   typeof self === "object" ? self : this
  12372. );
  12373.  
  12374. /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(8), __webpack_require__(31)))
  12375.  
  12376. /***/ }),
  12377. /* 108 */
  12378. /***/ (function(module, exports, __webpack_require__) {
  12379.  
  12380. /* WEBPACK VAR INJECTION */(function(global, process) {(function (global, undefined) {
  12381.     "use strict";
  12382.  
  12383.     if (global.setImmediate) {
  12384.         return;
  12385.     }
  12386.  
  12387.     var nextHandle = 1; // Spec says greater than zero
  12388.     var tasksByHandle = {};
  12389.     var currentlyRunningATask = false;
  12390.     var doc = global.document;
  12391.     var registerImmediate;
  12392.  
  12393.     function setImmediate(callback) {
  12394.       // Callback can either be a function or a string
  12395.       if (typeof callback !== "function") {
  12396.         callback = new Function("" + callback);
  12397.       }
  12398.       // Copy function arguments
  12399.       var args = new Array(arguments.length - 1);
  12400.       for (var i = 0; i < args.length; i++) {
  12401.           args[i] = arguments[i + 1];
  12402.       }
  12403.       // Store and register the task
  12404.       var task = { callback: callback, args: args };
  12405.       tasksByHandle[nextHandle] = task;
  12406.       registerImmediate(nextHandle);
  12407.       return nextHandle++;
  12408.     }
  12409.  
  12410.     function clearImmediate(handle) {
  12411.         delete tasksByHandle[handle];
  12412.     }
  12413.  
  12414.     function run(task) {
  12415.         var callback = task.callback;
  12416.         var args = task.args;
  12417.         switch (args.length) {
  12418.         case 0:
  12419.             callback();
  12420.             break;
  12421.         case 1:
  12422.             callback(args[0]);
  12423.             break;
  12424.         case 2:
  12425.             callback(args[0], args[1]);
  12426.             break;
  12427.         case 3:
  12428.             callback(args[0], args[1], args[2]);
  12429.             break;
  12430.         default:
  12431.             callback.apply(undefined, args);
  12432.             break;
  12433.         }
  12434.     }
  12435.  
  12436.     function runIfPresent(handle) {
  12437.         // From the spec: "Wait until any invocations of this algorithm started before this one have completed."
  12438.         // So if we're currently running a task, we'll need to delay this invocation.
  12439.         if (currentlyRunningATask) {
  12440.             // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a
  12441.             // "too much recursion" error.
  12442.             setTimeout(runIfPresent, 0, handle);
  12443.         } else {
  12444.             var task = tasksByHandle[handle];
  12445.             if (task) {
  12446.                 currentlyRunningATask = true;
  12447.                 try {
  12448.                     run(task);
  12449.                 } finally {
  12450.                     clearImmediate(handle);
  12451.                     currentlyRunningATask = false;
  12452.                 }
  12453.             }
  12454.         }
  12455.     }
  12456.  
  12457.     function installNextTickImplementation() {
  12458.         registerImmediate = function(handle) {
  12459.             process.nextTick(function () { runIfPresent(handle); });
  12460.         };
  12461.     }
  12462.  
  12463.     function canUsePostMessage() {
  12464.         // The test against `importScripts` prevents this implementation from being installed inside a web worker,
  12465.         // where `global.postMessage` means something completely different and can't be used for this purpose.
  12466.         if (global.postMessage && !global.importScripts) {
  12467.             var postMessageIsAsynchronous = true;
  12468.             var oldOnMessage = global.onmessage;
  12469.             global.onmessage = function() {
  12470.                 postMessageIsAsynchronous = false;
  12471.             };
  12472.             global.postMessage("", "*");
  12473.             global.onmessage = oldOnMessage;
  12474.             return postMessageIsAsynchronous;
  12475.         }
  12476.     }
  12477.  
  12478.     function installPostMessageImplementation() {
  12479.         // Installs an event handler on `global` for the `message` event: see
  12480.         // * https://developer.mozilla.org/en/DOM/window.postMessage
  12481.         // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages
  12482.  
  12483.         var messagePrefix = "setImmediate$" + Math.random() + "$";
  12484.         var onGlobalMessage = function(event) {
  12485.             if (event.source === global &&
  12486.                 typeof event.data === "string" &&
  12487.                 event.data.indexOf(messagePrefix) === 0) {
  12488.                 runIfPresent(+event.data.slice(messagePrefix.length));
  12489.             }
  12490.         };
  12491.  
  12492.         if (global.addEventListener) {
  12493.             global.addEventListener("message", onGlobalMessage, false);
  12494.         } else {
  12495.             global.attachEvent("onmessage", onGlobalMessage);
  12496.         }
  12497.  
  12498.         registerImmediate = function(handle) {
  12499.             global.postMessage(messagePrefix + handle, "*");
  12500.         };
  12501.     }
  12502.  
  12503.     function installMessageChannelImplementation() {
  12504.         var channel = new MessageChannel();
  12505.         channel.port1.onmessage = function(event) {
  12506.             var handle = event.data;
  12507.             runIfPresent(handle);
  12508.         };
  12509.  
  12510.         registerImmediate = function(handle) {
  12511.             channel.port2.postMessage(handle);
  12512.         };
  12513.     }
  12514.  
  12515.     function installReadyStateChangeImplementation() {
  12516.         var html = doc.documentElement;
  12517.         registerImmediate = function(handle) {
  12518.             // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted
  12519.             // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
  12520.             var script = doc.createElement("script");
  12521.             script.onreadystatechange = function () {
  12522.                 runIfPresent(handle);
  12523.                 script.onreadystatechange = null;
  12524.                 html.removeChild(script);
  12525.                 script = null;
  12526.             };
  12527.             html.appendChild(script);
  12528.         };
  12529.     }
  12530.  
  12531.     function installSetTimeoutImplementation() {
  12532.         registerImmediate = function(handle) {
  12533.             setTimeout(runIfPresent, 0, handle);
  12534.         };
  12535.     }
  12536.  
  12537.     // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.
  12538.     var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);
  12539.     attachTo = attachTo && attachTo.setTimeout ? attachTo : global;
  12540.  
  12541.     // Don't get fooled by e.g. browserify environments.
  12542.     if ({}.toString.call(global.process) === "[object process]") {
  12543.         // For Node.js before 0.9
  12544.         installNextTickImplementation();
  12545.  
  12546.     } else if (canUsePostMessage()) {
  12547.         // For non-IE10 modern browsers
  12548.         installPostMessageImplementation();
  12549.  
  12550.     } else if (global.MessageChannel) {
  12551.         // For web workers, where supported
  12552.         installMessageChannelImplementation();
  12553.  
  12554.     } else if (doc && "onreadystatechange" in doc.createElement("script")) {
  12555.         // For IE 6–8
  12556.         installReadyStateChangeImplementation();
  12557.  
  12558.     } else {
  12559.         // For older browsers
  12560.         installSetTimeoutImplementation();
  12561.     }
  12562.  
  12563.     attachTo.setImmediate = setImmediate;
  12564.     attachTo.clearImmediate = clearImmediate;
  12565. }(typeof self === "undefined" ? typeof global === "undefined" ? this : global : self));
  12566.  
  12567. /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(8), __webpack_require__(31)))
  12568.  
  12569. /***/ }),
  12570. /* 109 */
  12571. /***/ (function(module, exports, __webpack_require__) {
  12572.  
  12573. /*
  12574. 	MIT License http://www.opensource.org/licenses/mit-license.php
  12575. 	Author Tobias Koppers @sokra
  12576. */
  12577. var stylesInDom = {},
  12578. 	memoize = function(fn) {
  12579. 		var memo;
  12580. 		return function () {
  12581. 			if (typeof memo === "undefined") memo = fn.apply(this, arguments);
  12582. 			return memo;
  12583. 		};
  12584. 	},
  12585. 	isOldIE = memoize(function() {
  12586. 		return /msie [6-9]\b/.test(self.navigator.userAgent.toLowerCase());
  12587. 	}),
  12588. 	getElement = (function(fn) {
  12589. 		var memo = {};
  12590. 		return function(selector) {
  12591. 			if (typeof memo[selector] === "undefined") {
  12592. 				memo[selector] = fn.call(this, selector);
  12593. 			}
  12594. 			return memo[selector]
  12595. 		};
  12596. 	})(function (styleTarget) {
  12597. 		return document.querySelector(styleTarget)
  12598. 	}),
  12599. 	singletonElement = null,
  12600. 	singletonCounter = 0,
  12601. 	styleElementsInsertedAtTop = [],
  12602. 	fixUrls = __webpack_require__(110);
  12603.  
  12604. module.exports = function(list, options) {
  12605. 	if(typeof DEBUG !== "undefined" && DEBUG) {
  12606. 		if(typeof document !== "object") throw new Error("The style-loader cannot be used in a non-browser environment");
  12607. 	}
  12608.  
  12609. 	options = options || {};
  12610. 	options.attrs = typeof options.attrs === "object" ? options.attrs : {};
  12611.  
  12612. 	// Force single-tag solution on IE6-9, which has a hard limit on the # of <style>
  12613. 	// tags it will allow on a page
  12614. 	if (typeof options.singleton === "undefined") options.singleton = isOldIE();
  12615.  
  12616. 	// By default, add <style> tags to the <head> element
  12617. 	if (typeof options.insertInto === "undefined") options.insertInto = "head";
  12618.  
  12619. 	// By default, add <style> tags to the bottom of the target
  12620. 	if (typeof options.insertAt === "undefined") options.insertAt = "bottom";
  12621.  
  12622. 	var styles = listToStyles(list);
  12623. 	addStylesToDom(styles, options);
  12624.  
  12625. 	return function update(newList) {
  12626. 		var mayRemove = [];
  12627. 		for(var i = 0; i < styles.length; i++) {
  12628. 			var item = styles[i];
  12629. 			var domStyle = stylesInDom[item.id];
  12630. 			domStyle.refs--;
  12631. 			mayRemove.push(domStyle);
  12632. 		}
  12633. 		if(newList) {
  12634. 			var newStyles = listToStyles(newList);
  12635. 			addStylesToDom(newStyles, options);
  12636. 		}
  12637. 		for(var i = 0; i < mayRemove.length; i++) {
  12638. 			var domStyle = mayRemove[i];
  12639. 			if(domStyle.refs === 0) {
  12640. 				for(var j = 0; j < domStyle.parts.length; j++)
  12641. 					domStyle.parts[j]();
  12642. 				delete stylesInDom[domStyle.id];
  12643. 			}
  12644. 		}
  12645. 	};
  12646. };
  12647.  
  12648. function addStylesToDom(styles, options) {
  12649. 	for(var i = 0; i < styles.length; i++) {
  12650. 		var item = styles[i];
  12651. 		var domStyle = stylesInDom[item.id];
  12652. 		if(domStyle) {
  12653. 			domStyle.refs++;
  12654. 			for(var j = 0; j < domStyle.parts.length; j++) {
  12655. 				domStyle.parts[j](item.parts[j]);
  12656. 			}
  12657. 			for(; j < item.parts.length; j++) {
  12658. 				domStyle.parts.push(addStyle(item.parts[j], options));
  12659. 			}
  12660. 		} else {
  12661. 			var parts = [];
  12662. 			for(var j = 0; j < item.parts.length; j++) {
  12663. 				parts.push(addStyle(item.parts[j], options));
  12664. 			}
  12665. 			stylesInDom[item.id] = {id: item.id, refs: 1, parts: parts};
  12666. 		}
  12667. 	}
  12668. }
  12669.  
  12670. function listToStyles(list) {
  12671. 	var styles = [];
  12672. 	var newStyles = {};
  12673. 	for(var i = 0; i < list.length; i++) {
  12674. 		var item = list[i];
  12675. 		var id = item[0];
  12676. 		var css = item[1];
  12677. 		var media = item[2];
  12678. 		var sourceMap = item[3];
  12679. 		var part = {css: css, media: media, sourceMap: sourceMap};
  12680. 		if(!newStyles[id])
  12681. 			styles.push(newStyles[id] = {id: id, parts: [part]});
  12682. 		else
  12683. 			newStyles[id].parts.push(part);
  12684. 	}
  12685. 	return styles;
  12686. }
  12687.  
  12688. function insertStyleElement(options, styleElement) {
  12689. 	var styleTarget = getElement(options.insertInto)
  12690. 	if (!styleTarget) {
  12691. 		throw new Error("Couldn't find a style target. This probably means that the value for the 'insertInto' parameter is invalid.");
  12692. 	}
  12693. 	var lastStyleElementInsertedAtTop = styleElementsInsertedAtTop[styleElementsInsertedAtTop.length - 1];
  12694. 	if (options.insertAt === "top") {
  12695. 		if(!lastStyleElementInsertedAtTop) {
  12696. 			styleTarget.insertBefore(styleElement, styleTarget.firstChild);
  12697. 		} else if(lastStyleElementInsertedAtTop.nextSibling) {
  12698. 			styleTarget.insertBefore(styleElement, lastStyleElementInsertedAtTop.nextSibling);
  12699. 		} else {
  12700. 			styleTarget.appendChild(styleElement);
  12701. 		}
  12702. 		styleElementsInsertedAtTop.push(styleElement);
  12703. 	} else if (options.insertAt === "bottom") {
  12704. 		styleTarget.appendChild(styleElement);
  12705. 	} else {
  12706. 		throw new Error("Invalid value for parameter 'insertAt'. Must be 'top' or 'bottom'.");
  12707. 	}
  12708. }
  12709.  
  12710. function removeStyleElement(styleElement) {
  12711. 	styleElement.parentNode.removeChild(styleElement);
  12712. 	var idx = styleElementsInsertedAtTop.indexOf(styleElement);
  12713. 	if(idx >= 0) {
  12714. 		styleElementsInsertedAtTop.splice(idx, 1);
  12715. 	}
  12716. }
  12717.  
  12718. function createStyleElement(options) {
  12719. 	var styleElement = document.createElement("style");
  12720. 	options.attrs.type = "text/css";
  12721.  
  12722. 	attachTagAttrs(styleElement, options.attrs);
  12723. 	insertStyleElement(options, styleElement);
  12724. 	return styleElement;
  12725. }
  12726.  
  12727. function createLinkElement(options) {
  12728. 	var linkElement = document.createElement("link");
  12729. 	options.attrs.type = "text/css";
  12730. 	options.attrs.rel = "stylesheet";
  12731.  
  12732. 	attachTagAttrs(linkElement, options.attrs);
  12733. 	insertStyleElement(options, linkElement);
  12734. 	return linkElement;
  12735. }
  12736.  
  12737. function attachTagAttrs(element, attrs) {
  12738. 	Object.keys(attrs).forEach(function (key) {
  12739. 		element.setAttribute(key, attrs[key]);
  12740. 	});
  12741. }
  12742.  
  12743. function addStyle(obj, options) {
  12744. 	var styleElement, update, remove;
  12745.  
  12746. 	if (options.singleton) {
  12747. 		var styleIndex = singletonCounter++;
  12748. 		styleElement = singletonElement || (singletonElement = createStyleElement(options));
  12749. 		update = applyToSingletonTag.bind(null, styleElement, styleIndex, false);
  12750. 		remove = applyToSingletonTag.bind(null, styleElement, styleIndex, true);
  12751. 	} else if(obj.sourceMap &&
  12752. 		typeof URL === "function" &&
  12753. 		typeof URL.createObjectURL === "function" &&
  12754. 		typeof URL.revokeObjectURL === "function" &&
  12755. 		typeof Blob === "function" &&
  12756. 		typeof btoa === "function") {
  12757. 		styleElement = createLinkElement(options);
  12758. 		update = updateLink.bind(null, styleElement, options);
  12759. 		remove = function() {
  12760. 			removeStyleElement(styleElement);
  12761. 			if(styleElement.href)
  12762. 				URL.revokeObjectURL(styleElement.href);
  12763. 		};
  12764. 	} else {
  12765. 		styleElement = createStyleElement(options);
  12766. 		update = applyToTag.bind(null, styleElement);
  12767. 		remove = function() {
  12768. 			removeStyleElement(styleElement);
  12769. 		};
  12770. 	}
  12771.  
  12772. 	update(obj);
  12773.  
  12774. 	return function updateStyle(newObj) {
  12775. 		if(newObj) {
  12776. 			if(newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap)
  12777. 				return;
  12778. 			update(obj = newObj);
  12779. 		} else {
  12780. 			remove();
  12781. 		}
  12782. 	};
  12783. }
  12784.  
  12785. var replaceText = (function () {
  12786. 	var textStore = [];
  12787.  
  12788. 	return function (index, replacement) {
  12789. 		textStore[index] = replacement;
  12790. 		return textStore.filter(Boolean).join('\n');
  12791. 	};
  12792. })();
  12793.  
  12794. function applyToSingletonTag(styleElement, index, remove, obj) {
  12795. 	var css = remove ? "" : obj.css;
  12796.  
  12797. 	if (styleElement.styleSheet) {
  12798. 		styleElement.styleSheet.cssText = replaceText(index, css);
  12799. 	} else {
  12800. 		var cssNode = document.createTextNode(css);
  12801. 		var childNodes = styleElement.childNodes;
  12802. 		if (childNodes[index]) styleElement.removeChild(childNodes[index]);
  12803. 		if (childNodes.length) {
  12804. 			styleElement.insertBefore(cssNode, childNodes[index]);
  12805. 		} else {
  12806. 			styleElement.appendChild(cssNode);
  12807. 		}
  12808. 	}
  12809. }
  12810.  
  12811. function applyToTag(styleElement, obj) {
  12812. 	var css = obj.css;
  12813. 	var media = obj.media;
  12814.  
  12815. 	if(media) {
  12816. 		styleElement.setAttribute("media", media)
  12817. 	}
  12818.  
  12819. 	if(styleElement.styleSheet) {
  12820. 		styleElement.styleSheet.cssText = css;
  12821. 	} else {
  12822. 		while(styleElement.firstChild) {
  12823. 			styleElement.removeChild(styleElement.firstChild);
  12824. 		}
  12825. 		styleElement.appendChild(document.createTextNode(css));
  12826. 	}
  12827. }
  12828.  
  12829. function updateLink(linkElement, options, obj) {
  12830. 	var css = obj.css;
  12831. 	var sourceMap = obj.sourceMap;
  12832.  
  12833. 	/* If convertToAbsoluteUrls isn't defined, but sourcemaps are enabled
  12834. 	and there is no publicPath defined then lets turn convertToAbsoluteUrls
  12835. 	on by default.  Otherwise default to the convertToAbsoluteUrls option
  12836. 	directly
  12837. 	*/
  12838. 	var autoFixUrls = options.convertToAbsoluteUrls === undefined && sourceMap;
  12839.  
  12840. 	if (options.convertToAbsoluteUrls || autoFixUrls){
  12841. 		css = fixUrls(css);
  12842. 	}
  12843.  
  12844. 	if(sourceMap) {
  12845. 		// http://stackoverflow.com/a/26603875
  12846. 		css += "\n/*# sourceMappingURL=data:application/json;base64," + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) + " */";
  12847. 	}
  12848.  
  12849. 	var blob = new Blob([css], { type: "text/css" });
  12850.  
  12851. 	var oldSrc = linkElement.href;
  12852.  
  12853. 	linkElement.href = URL.createObjectURL(blob);
  12854.  
  12855. 	if(oldSrc)
  12856. 		URL.revokeObjectURL(oldSrc);
  12857. }
  12858.  
  12859.  
  12860. /***/ }),
  12861. /* 110 */
  12862. /***/ (function(module, exports) {
  12863.  
  12864.  
  12865. /**
  12866.  * When source maps are enabled, `style-loader` uses a link element with a data-uri to
  12867.  * embed the css on the page. This breaks all relative urls because now they are relative to a
  12868.  * bundle instead of the current page.
  12869.  *
  12870.  * One solution is to only use full urls, but that may be impossible.
  12871.  *
  12872.  * Instead, this function "fixes" the relative urls to be absolute according to the current page location.
  12873.  *
  12874.  * A rudimentary test suite is located at `test/fixUrls.js` and can be run via the `npm test` command.
  12875.  *
  12876.  */
  12877.  
  12878. module.exports = function (css) {
  12879.   // get current location
  12880.   var location = typeof window !== "undefined" && window.location;
  12881.  
  12882.   if (!location) {
  12883.     throw new Error("fixUrls requires window.location");
  12884.   }
  12885.  
  12886. 	// blank or null?
  12887. 	if (!css || typeof css !== "string") {
  12888. 	  return css;
  12889.   }
  12890.  
  12891.   var baseUrl = location.protocol + "//" + location.host;
  12892.   var currentDir = baseUrl + location.pathname.replace(/\/[^\/]*$/, "/");
  12893.  
  12894. 	// convert each url(...)
  12895. 	/*
  12896. 	This regular expression is just a way to recursively match brackets within
  12897. 	a string.
  12898.  
  12899. 	 /url\s*\(  = Match on the word "url" with any whitespace after it and then a parens
  12900. 	   (  = Start a capturing group
  12901. 	     (?:  = Start a non-capturing group
  12902. 	         [^)(]  = Match anything that isn't a parentheses
  12903. 	         |  = OR
  12904. 	         \(  = Match a start parentheses
  12905. 	             (?:  = Start another non-capturing groups
  12906. 	                 [^)(]+  = Match anything that isn't a parentheses
  12907. 	                 |  = OR
  12908. 	                 \(  = Match a start parentheses
  12909. 	                     [^)(]*  = Match anything that isn't a parentheses
  12910. 	                 \)  = Match a end parentheses
  12911. 	             )  = End Group
  12912.               *\) = Match anything and then a close parens
  12913.           )  = Close non-capturing group
  12914.           *  = Match anything
  12915.        )  = Close capturing group
  12916. 	 \)  = Match a close parens
  12917.  
  12918. 	 /gi  = Get all matches, not the first.  Be case insensitive.
  12919. 	 */
  12920. 	var fixedCss = css.replace(/url\s*\(((?:[^)(]|\((?:[^)(]+|\([^)(]*\))*\))*)\)/gi, function(fullMatch, origUrl) {
  12921. 		// strip quotes (if they exist)
  12922. 		var unquotedOrigUrl = origUrl
  12923. 			.trim()
  12924. 			.replace(/^"(.*)"$/, function(o, $1){ return $1; })
  12925. 			.replace(/^'(.*)'$/, function(o, $1){ return $1; });
  12926.  
  12927. 		// already a full url? no change
  12928. 		if (/^(#|data:|http:\/\/|https:\/\/|file:\/\/\/)/i.test(unquotedOrigUrl)) {
  12929. 		  return fullMatch;
  12930. 		}
  12931.  
  12932. 		// convert the url to a full url
  12933. 		var newUrl;
  12934.  
  12935. 		if (unquotedOrigUrl.indexOf("//") === 0) {
  12936. 		  	//TODO: should we add protocol?
  12937. 			newUrl = unquotedOrigUrl;
  12938. 		} else if (unquotedOrigUrl.indexOf("/") === 0) {
  12939. 			// path should be relative to the base url
  12940. 			newUrl = baseUrl + unquotedOrigUrl; // already starts with '/'
  12941. 		} else {
  12942. 			// path should be relative to current directory
  12943. 			newUrl = currentDir + unquotedOrigUrl.replace(/^\.\//, ""); // Strip leading './'
  12944. 		}
  12945.  
  12946. 		// send back the fixed url(...)
  12947. 		return "url(" + JSON.stringify(newUrl) + ")";
  12948. 	});
  12949.  
  12950. 	// send back the fixed css
  12951. 	return fixedCss;
  12952. };
  12953.  
  12954.  
  12955. /***/ }),
  12956. /* 111 */
  12957. /***/ (function(module, exports) {
  12958.  
  12959. !function(t,e){"object"==typeof module&&module.exports?(module.exports=e(),module.exports.default=module.exports):t.timeago=e()}("undefined"!=typeof window?window:this,function(){function t(t){return t instanceof Date?t:isNaN(t)?/^\d+$/.test(t)?new Date(e(t)):(t=(t||"").trim().replace(/\.\d+/,"").replace(/-/,"/").replace(/-/,"/").replace(/(\d)T(\d)/,"$1 $2").replace(/Z/," UTC").replace(/([\+\-]\d\d)\:?(\d\d)/," $1$2"),new Date(t)):new Date(e(t))}function e(t){return parseInt(t)}function n(t,n,r){n=p[n]?n:p[r]?r:"en";for(var o=0,i=t<0?1:0,a=t=Math.abs(t);t>=h[o]&&o<m;o++)t/=h[o];return t=e(t),o*=2,t>(0===o?9:1)&&(o+=1),p[n](t,o,a)[i].replace("%s",t)}function r(e,n){return((n=n?t(n):new Date)-t(e))/1e3}function o(t){for(var e=1,n=0,r=Math.abs(t);t>=h[n]&&n<m;n++)t/=h[n],e*=h[n];return r%=e,r=r?e-r:e,Math.ceil(r)}function i(t){return t.dataset.timeago?t.dataset.timeago:a(t,w)}function a(t,e){return t.getAttribute?t.getAttribute(e):t.attr?t.attr(e):void 0}function u(t,e){return t.setAttribute?t.setAttribute(_,e):t.attr?t.attr(_,e):void 0}function c(t){return a(t,_)}function d(t,e){this.nowDate=t,this.defaultLocale=e||"en"}function f(t,e){return new d(t,e)}var s="second_minute_hour_day_week_month_year".split("_"),l="秒_分钟_小时_天_周_月_年".split("_"),p={en:function(t,e){if(0===e)return["just now","right now"];var n=s[parseInt(e/2)];return t>1&&(n+="s"),[t+" "+n+" ago","in "+t+" "+n]},zh_CN:function(t,e){if(0===e)return["刚刚","片刻后"];var n=l[parseInt(e/2)];return[t+n+"前",t+n+"后"]}},h=[60,60,24,7,365/7/12,12],m=6,w="datetime",_="data-tid",v={};return d.prototype.doRender=function(t,e,i){var a,c=r(e,this.nowDate),d=this;t.innerHTML=n(c,i,this.defaultLocale),v[a=setTimeout(function(){d.doRender(t,e,i),delete v[a]},Math.min(1e3*o(c),2147483647))]=0,u(t,a)},d.prototype.format=function(t,e){return n(r(t,this.nowDate),e,this.defaultLocale)},d.prototype.render=function(t,e){void 0===t.length&&(t=[t]);for(var n=0,r=t.length;n<r;n++)this.doRender(t[n],i(t[n]),e)},d.prototype.setLocale=function(t){this.defaultLocale=t},f.register=function(t,e){p[t]=e},f.cancel=function(t){var e;if(t)(e=c(t))&&(clearTimeout(e),delete v[e]);else{for(e in v)clearTimeout(e);v={}}},f});
  12960.  
  12961. /***/ }),
  12962. /* 112 */
  12963. /***/ (function(module, exports, __webpack_require__) {
  12964.  
  12965. var apply = Function.prototype.apply;
  12966.  
  12967. // DOM APIs, for completeness
  12968.  
  12969. exports.setTimeout = function() {
  12970.   return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);
  12971. };
  12972. exports.setInterval = function() {
  12973.   return new Timeout(apply.call(setInterval, window, arguments), clearInterval);
  12974. };
  12975. exports.clearTimeout =
  12976. exports.clearInterval = function(timeout) {
  12977.   if (timeout) {
  12978.     timeout.close();
  12979.   }
  12980. };
  12981.  
  12982. function Timeout(id, clearFn) {
  12983.   this._id = id;
  12984.   this._clearFn = clearFn;
  12985. }
  12986. Timeout.prototype.unref = Timeout.prototype.ref = function() {};
  12987. Timeout.prototype.close = function() {
  12988.   this._clearFn.call(window, this._id);
  12989. };
  12990.  
  12991. // Does not start the time, just sets up the members needed.
  12992. exports.enroll = function(item, msecs) {
  12993.   clearTimeout(item._idleTimeoutId);
  12994.   item._idleTimeout = msecs;
  12995. };
  12996.  
  12997. exports.unenroll = function(item) {
  12998.   clearTimeout(item._idleTimeoutId);
  12999.   item._idleTimeout = -1;
  13000. };
  13001.  
  13002. exports._unrefActive = exports.active = function(item) {
  13003.   clearTimeout(item._idleTimeoutId);
  13004.  
  13005.   var msecs = item._idleTimeout;
  13006.   if (msecs >= 0) {
  13007.     item._idleTimeoutId = setTimeout(function onTimeout() {
  13008.       if (item._onTimeout)
  13009.         item._onTimeout();
  13010.     }, msecs);
  13011.   }
  13012. };
  13013.  
  13014. // setimmediate attaches itself to the global object
  13015. __webpack_require__(108);
  13016. exports.setImmediate = setImmediate;
  13017. exports.clearImmediate = clearImmediate;
  13018.  
  13019.  
  13020. /***/ }),
  13021. /* 113 */
  13022. /***/ (function(module, exports, __webpack_require__) {
  13023.  
  13024. var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;//     Underscore.js 1.8.3
  13025. //     http://underscorejs.org
  13026. //     (c) 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  13027. //     Underscore may be freely distributed under the MIT license.
  13028.  
  13029. (function() {
  13030.  
  13031.   // Baseline setup
  13032.   // --------------
  13033.  
  13034.   // Establish the root object, `window` in the browser, or `exports` on the server.
  13035.   var root = this;
  13036.  
  13037.   // Save the previous value of the `_` variable.
  13038.   var previousUnderscore = root._;
  13039.  
  13040.   // Save bytes in the minified (but not gzipped) version:
  13041.   var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;
  13042.  
  13043.   // Create quick reference variables for speed access to core prototypes.
  13044.   var
  13045.     push             = ArrayProto.push,
  13046.     slice            = ArrayProto.slice,
  13047.     toString         = ObjProto.toString,
  13048.     hasOwnProperty   = ObjProto.hasOwnProperty;
  13049.  
  13050.   // All **ECMAScript 5** native function implementations that we hope to use
  13051.   // are declared here.
  13052.   var
  13053.     nativeIsArray      = Array.isArray,
  13054.     nativeKeys         = Object.keys,
  13055.     nativeBind         = FuncProto.bind,
  13056.     nativeCreate       = Object.create;
  13057.  
  13058.   // Naked function reference for surrogate-prototype-swapping.
  13059.   var Ctor = function(){};
  13060.  
  13061.   // Create a safe reference to the Underscore object for use below.
  13062.   var _ = function(obj) {
  13063.     if (obj instanceof _) return obj;
  13064.     if (!(this instanceof _)) return new _(obj);
  13065.     this._wrapped = obj;
  13066.   };
  13067.  
  13068.   // Export the Underscore object for **Node.js**, with
  13069.   // backwards-compatibility for the old `require()` API. If we're in
  13070.   // the browser, add `_` as a global object.
  13071.   if (true) {
  13072.     if (typeof module !== 'undefined' && module.exports) {
  13073.       exports = module.exports = _;
  13074.     }
  13075.     exports._ = _;
  13076.   } else {
  13077.     root._ = _;
  13078.   }
  13079.  
  13080.   // Current version.
  13081.   _.VERSION = '1.8.3';
  13082.  
  13083.   // Internal function that returns an efficient (for current engines) version
  13084.   // of the passed-in callback, to be repeatedly applied in other Underscore
  13085.   // functions.
  13086.   var optimizeCb = function(func, context, argCount) {
  13087.     if (context === void 0) return func;
  13088.     switch (argCount == null ? 3 : argCount) {
  13089.       case 1: return function(value) {
  13090.         return func.call(context, value);
  13091.       };
  13092.       case 2: return function(value, other) {
  13093.         return func.call(context, value, other);
  13094.       };
  13095.       case 3: return function(value, index, collection) {
  13096.         return func.call(context, value, index, collection);
  13097.       };
  13098.       case 4: return function(accumulator, value, index, collection) {
  13099.         return func.call(context, accumulator, value, index, collection);
  13100.       };
  13101.     }
  13102.     return function() {
  13103.       return func.apply(context, arguments);
  13104.     };
  13105.   };
  13106.  
  13107.   // A mostly-internal function to generate callbacks that can be applied
  13108.   // to each element in a collection, returning the desired result — either
  13109.   // identity, an arbitrary callback, a property matcher, or a property accessor.
  13110.   var cb = function(value, context, argCount) {
  13111.     if (value == null) return _.identity;
  13112.     if (_.isFunction(value)) return optimizeCb(value, context, argCount);
  13113.     if (_.isObject(value)) return _.matcher(value);
  13114.     return _.property(value);
  13115.   };
  13116.   _.iteratee = function(value, context) {
  13117.     return cb(value, context, Infinity);
  13118.   };
  13119.  
  13120.   // An internal function for creating assigner functions.
  13121.   var createAssigner = function(keysFunc, undefinedOnly) {
  13122.     return function(obj) {
  13123.       var length = arguments.length;
  13124.       if (length < 2 || obj == null) return obj;
  13125.       for (var index = 1; index < length; index++) {
  13126.         var source = arguments[index],
  13127.             keys = keysFunc(source),
  13128.             l = keys.length;
  13129.         for (var i = 0; i < l; i++) {
  13130.           var key = keys[i];
  13131.           if (!undefinedOnly || obj[key] === void 0) obj[key] = source[key];
  13132.         }
  13133.       }
  13134.       return obj;
  13135.     };
  13136.   };
  13137.  
  13138.   // An internal function for creating a new object that inherits from another.
  13139.   var baseCreate = function(prototype) {
  13140.     if (!_.isObject(prototype)) return {};
  13141.     if (nativeCreate) return nativeCreate(prototype);
  13142.     Ctor.prototype = prototype;
  13143.     var result = new Ctor;
  13144.     Ctor.prototype = null;
  13145.     return result;
  13146.   };
  13147.  
  13148.   var property = function(key) {
  13149.     return function(obj) {
  13150.       return obj == null ? void 0 : obj[key];
  13151.     };
  13152.   };
  13153.  
  13154.   // Helper for collection methods to determine whether a collection
  13155.   // should be iterated as an array or as an object
  13156.   // Related: http://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength
  13157.   // Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094
  13158.   var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;
  13159.   var getLength = property('length');
  13160.   var isArrayLike = function(collection) {
  13161.     var length = getLength(collection);
  13162.     return typeof length == 'number' && length >= 0 && length <= MAX_ARRAY_INDEX;
  13163.   };
  13164.  
  13165.   // Collection Functions
  13166.   // --------------------
  13167.  
  13168.   // The cornerstone, an `each` implementation, aka `forEach`.
  13169.   // Handles raw objects in addition to array-likes. Treats all
  13170.   // sparse array-likes as if they were dense.
  13171.   _.each = _.forEach = function(obj, iteratee, context) {
  13172.     iteratee = optimizeCb(iteratee, context);
  13173.     var i, length;
  13174.     if (isArrayLike(obj)) {
  13175.       for (i = 0, length = obj.length; i < length; i++) {
  13176.         iteratee(obj[i], i, obj);
  13177.       }
  13178.     } else {
  13179.       var keys = _.keys(obj);
  13180.       for (i = 0, length = keys.length; i < length; i++) {
  13181.         iteratee(obj[keys[i]], keys[i], obj);
  13182.       }
  13183.     }
  13184.     return obj;
  13185.   };
  13186.  
  13187.   // Return the results of applying the iteratee to each element.
  13188.   _.map = _.collect = function(obj, iteratee, context) {
  13189.     iteratee = cb(iteratee, context);
  13190.     var keys = !isArrayLike(obj) && _.keys(obj),
  13191.         length = (keys || obj).length,
  13192.         results = Array(length);
  13193.     for (var index = 0; index < length; index++) {
  13194.       var currentKey = keys ? keys[index] : index;
  13195.       results[index] = iteratee(obj[currentKey], currentKey, obj);
  13196.     }
  13197.     return results;
  13198.   };
  13199.  
  13200.   // Create a reducing function iterating left or right.
  13201.   function createReduce(dir) {
  13202.     // Optimized iterator function as using arguments.length
  13203.     // in the main function will deoptimize the, see #1991.
  13204.     function iterator(obj, iteratee, memo, keys, index, length) {
  13205.       for (; index >= 0 && index < length; index += dir) {
  13206.         var currentKey = keys ? keys[index] : index;
  13207.         memo = iteratee(memo, obj[currentKey], currentKey, obj);
  13208.       }
  13209.       return memo;
  13210.     }
  13211.  
  13212.     return function(obj, iteratee, memo, context) {
  13213.       iteratee = optimizeCb(iteratee, context, 4);
  13214.       var keys = !isArrayLike(obj) && _.keys(obj),
  13215.           length = (keys || obj).length,
  13216.           index = dir > 0 ? 0 : length - 1;
  13217.       // Determine the initial value if none is provided.
  13218.       if (arguments.length < 3) {
  13219.         memo = obj[keys ? keys[index] : index];
  13220.         index += dir;
  13221.       }
  13222.       return iterator(obj, iteratee, memo, keys, index, length);
  13223.     };
  13224.   }
  13225.  
  13226.   // **Reduce** builds up a single result from a list of values, aka `inject`,
  13227.   // or `foldl`.
  13228.   _.reduce = _.foldl = _.inject = createReduce(1);
  13229.  
  13230.   // The right-associative version of reduce, also known as `foldr`.
  13231.   _.reduceRight = _.foldr = createReduce(-1);
  13232.  
  13233.   // Return the first value which passes a truth test. Aliased as `detect`.
  13234.   _.find = _.detect = function(obj, predicate, context) {
  13235.     var key;
  13236.     if (isArrayLike(obj)) {
  13237.       key = _.findIndex(obj, predicate, context);
  13238.     } else {
  13239.       key = _.findKey(obj, predicate, context);
  13240.     }
  13241.     if (key !== void 0 && key !== -1) return obj[key];
  13242.   };
  13243.  
  13244.   // Return all the elements that pass a truth test.
  13245.   // Aliased as `select`.
  13246.   _.filter = _.select = function(obj, predicate, context) {
  13247.     var results = [];
  13248.     predicate = cb(predicate, context);
  13249.     _.each(obj, function(value, index, list) {
  13250.       if (predicate(value, index, list)) results.push(value);
  13251.     });
  13252.     return results;
  13253.   };
  13254.  
  13255.   // Return all the elements for which a truth test fails.
  13256.   _.reject = function(obj, predicate, context) {
  13257.     return _.filter(obj, _.negate(cb(predicate)), context);
  13258.   };
  13259.  
  13260.   // Determine whether all of the elements match a truth test.
  13261.   // Aliased as `all`.
  13262.   _.every = _.all = function(obj, predicate, context) {
  13263.     predicate = cb(predicate, context);
  13264.     var keys = !isArrayLike(obj) && _.keys(obj),
  13265.         length = (keys || obj).length;
  13266.     for (var index = 0; index < length; index++) {
  13267.       var currentKey = keys ? keys[index] : index;
  13268.       if (!predicate(obj[currentKey], currentKey, obj)) return false;
  13269.     }
  13270.     return true;
  13271.   };
  13272.  
  13273.   // Determine if at least one element in the object matches a truth test.
  13274.   // Aliased as `any`.
  13275.   _.some = _.any = function(obj, predicate, context) {
  13276.     predicate = cb(predicate, context);
  13277.     var keys = !isArrayLike(obj) && _.keys(obj),
  13278.         length = (keys || obj).length;
  13279.     for (var index = 0; index < length; index++) {
  13280.       var currentKey = keys ? keys[index] : index;
  13281.       if (predicate(obj[currentKey], currentKey, obj)) return true;
  13282.     }
  13283.     return false;
  13284.   };
  13285.  
  13286.   // Determine if the array or object contains a given item (using `===`).
  13287.   // Aliased as `includes` and `include`.
  13288.   _.contains = _.includes = _.include = function(obj, item, fromIndex, guard) {
  13289.     if (!isArrayLike(obj)) obj = _.values(obj);
  13290.     if (typeof fromIndex != 'number' || guard) fromIndex = 0;
  13291.     return _.indexOf(obj, item, fromIndex) >= 0;
  13292.   };
  13293.  
  13294.   // Invoke a method (with arguments) on every item in a collection.
  13295.   _.invoke = function(obj, method) {
  13296.     var args = slice.call(arguments, 2);
  13297.     var isFunc = _.isFunction(method);
  13298.     return _.map(obj, function(value) {
  13299.       var func = isFunc ? method : value[method];
  13300.       return func == null ? func : func.apply(value, args);
  13301.     });
  13302.   };
  13303.  
  13304.   // Convenience version of a common use case of `map`: fetching a property.
  13305.   _.pluck = function(obj, key) {
  13306.     return _.map(obj, _.property(key));
  13307.   };
  13308.  
  13309.   // Convenience version of a common use case of `filter`: selecting only objects
  13310.   // containing specific `key:value` pairs.
  13311.   _.where = function(obj, attrs) {
  13312.     return _.filter(obj, _.matcher(attrs));
  13313.   };
  13314.  
  13315.   // Convenience version of a common use case of `find`: getting the first object
  13316.   // containing specific `key:value` pairs.
  13317.   _.findWhere = function(obj, attrs) {
  13318.     return _.find(obj, _.matcher(attrs));
  13319.   };
  13320.  
  13321.   // Return the maximum element (or element-based computation).
  13322.   _.max = function(obj, iteratee, context) {
  13323.     var result = -Infinity, lastComputed = -Infinity,
  13324.         value, computed;
  13325.     if (iteratee == null && obj != null) {
  13326.       obj = isArrayLike(obj) ? obj : _.values(obj);
  13327.       for (var i = 0, length = obj.length; i < length; i++) {
  13328.         value = obj[i];
  13329.         if (value > result) {
  13330.           result = value;
  13331.         }
  13332.       }
  13333.     } else {
  13334.       iteratee = cb(iteratee, context);
  13335.       _.each(obj, function(value, index, list) {
  13336.         computed = iteratee(value, index, list);
  13337.         if (computed > lastComputed || computed === -Infinity && result === -Infinity) {
  13338.           result = value;
  13339.           lastComputed = computed;
  13340.         }
  13341.       });
  13342.     }
  13343.     return result;
  13344.   };
  13345.  
  13346.   // Return the minimum element (or element-based computation).
  13347.   _.min = function(obj, iteratee, context) {
  13348.     var result = Infinity, lastComputed = Infinity,
  13349.         value, computed;
  13350.     if (iteratee == null && obj != null) {
  13351.       obj = isArrayLike(obj) ? obj : _.values(obj);
  13352.       for (var i = 0, length = obj.length; i < length; i++) {
  13353.         value = obj[i];
  13354.         if (value < result) {
  13355.           result = value;
  13356.         }
  13357.       }
  13358.     } else {
  13359.       iteratee = cb(iteratee, context);
  13360.       _.each(obj, function(value, index, list) {
  13361.         computed = iteratee(value, index, list);
  13362.         if (computed < lastComputed || computed === Infinity && result === Infinity) {
  13363.           result = value;
  13364.           lastComputed = computed;
  13365.         }
  13366.       });
  13367.     }
  13368.     return result;
  13369.   };
  13370.  
  13371.   // Shuffle a collection, using the modern version of the
  13372.   // [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle).
  13373.   _.shuffle = function(obj) {
  13374.     var set = isArrayLike(obj) ? obj : _.values(obj);
  13375.     var length = set.length;
  13376.     var shuffled = Array(length);
  13377.     for (var index = 0, rand; index < length; index++) {
  13378.       rand = _.random(0, index);
  13379.       if (rand !== index) shuffled[index] = shuffled[rand];
  13380.       shuffled[rand] = set[index];
  13381.     }
  13382.     return shuffled;
  13383.   };
  13384.  
  13385.   // Sample **n** random values from a collection.
  13386.   // If **n** is not specified, returns a single random element.
  13387.   // The internal `guard` argument allows it to work with `map`.
  13388.   _.sample = function(obj, n, guard) {
  13389.     if (n == null || guard) {
  13390.       if (!isArrayLike(obj)) obj = _.values(obj);
  13391.       return obj[_.random(obj.length - 1)];
  13392.     }
  13393.     return _.shuffle(obj).slice(0, Math.max(0, n));
  13394.   };
  13395.  
  13396.   // Sort the object's values by a criterion produced by an iteratee.
  13397.   _.sortBy = function(obj, iteratee, context) {
  13398.     iteratee = cb(iteratee, context);
  13399.     return _.pluck(_.map(obj, function(value, index, list) {
  13400.       return {
  13401.         value: value,
  13402.         index: index,
  13403.         criteria: iteratee(value, index, list)
  13404.       };
  13405.     }).sort(function(left, right) {
  13406.       var a = left.criteria;
  13407.       var b = right.criteria;
  13408.       if (a !== b) {
  13409.         if (a > b || a === void 0) return 1;
  13410.         if (a < b || b === void 0) return -1;
  13411.       }
  13412.       return left.index - right.index;
  13413.     }), 'value');
  13414.   };
  13415.  
  13416.   // An internal function used for aggregate "group by" operations.
  13417.   var group = function(behavior) {
  13418.     return function(obj, iteratee, context) {
  13419.       var result = {};
  13420.       iteratee = cb(iteratee, context);
  13421.       _.each(obj, function(value, index) {
  13422.         var key = iteratee(value, index, obj);
  13423.         behavior(result, value, key);
  13424.       });
  13425.       return result;
  13426.     };
  13427.   };
  13428.  
  13429.   // Groups the object's values by a criterion. Pass either a string attribute
  13430.   // to group by, or a function that returns the criterion.
  13431.   _.groupBy = group(function(result, value, key) {
  13432.     if (_.has(result, key)) result[key].push(value); else result[key] = [value];
  13433.   });
  13434.  
  13435.   // Indexes the object's values by a criterion, similar to `groupBy`, but for
  13436.   // when you know that your index values will be unique.
  13437.   _.indexBy = group(function(result, value, key) {
  13438.     result[key] = value;
  13439.   });
  13440.  
  13441.   // Counts instances of an object that group by a certain criterion. Pass
  13442.   // either a string attribute to count by, or a function that returns the
  13443.   // criterion.
  13444.   _.countBy = group(function(result, value, key) {
  13445.     if (_.has(result, key)) result[key]++; else result[key] = 1;
  13446.   });
  13447.  
  13448.   // Safely create a real, live array from anything iterable.
  13449.   _.toArray = function(obj) {
  13450.     if (!obj) return [];
  13451.     if (_.isArray(obj)) return slice.call(obj);
  13452.     if (isArrayLike(obj)) return _.map(obj, _.identity);
  13453.     return _.values(obj);
  13454.   };
  13455.  
  13456.   // Return the number of elements in an object.
  13457.   _.size = function(obj) {
  13458.     if (obj == null) return 0;
  13459.     return isArrayLike(obj) ? obj.length : _.keys(obj).length;
  13460.   };
  13461.  
  13462.   // Split a collection into two arrays: one whose elements all satisfy the given
  13463.   // predicate, and one whose elements all do not satisfy the predicate.
  13464.   _.partition = function(obj, predicate, context) {
  13465.     predicate = cb(predicate, context);
  13466.     var pass = [], fail = [];
  13467.     _.each(obj, function(value, key, obj) {
  13468.       (predicate(value, key, obj) ? pass : fail).push(value);
  13469.     });
  13470.     return [pass, fail];
  13471.   };
  13472.  
  13473.   // Array Functions
  13474.   // ---------------
  13475.  
  13476.   // Get the first element of an array. Passing **n** will return the first N
  13477.   // values in the array. Aliased as `head` and `take`. The **guard** check
  13478.   // allows it to work with `_.map`.
  13479.   _.first = _.head = _.take = function(array, n, guard) {
  13480.     if (array == null) return void 0;
  13481.     if (n == null || guard) return array[0];
  13482.     return _.initial(array, array.length - n);
  13483.   };
  13484.  
  13485.   // Returns everything but the last entry of the array. Especially useful on
  13486.   // the arguments object. Passing **n** will return all the values in
  13487.   // the array, excluding the last N.
  13488.   _.initial = function(array, n, guard) {
  13489.     return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n)));
  13490.   };
  13491.  
  13492.   // Get the last element of an array. Passing **n** will return the last N
  13493.   // values in the array.
  13494.   _.last = function(array, n, guard) {
  13495.     if (array == null) return void 0;
  13496.     if (n == null || guard) return array[array.length - 1];
  13497.     return _.rest(array, Math.max(0, array.length - n));
  13498.   };
  13499.  
  13500.   // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.
  13501.   // Especially useful on the arguments object. Passing an **n** will return
  13502.   // the rest N values in the array.
  13503.   _.rest = _.tail = _.drop = function(array, n, guard) {
  13504.     return slice.call(array, n == null || guard ? 1 : n);
  13505.   };
  13506.  
  13507.   // Trim out all falsy values from an array.
  13508.   _.compact = function(array) {
  13509.     return _.filter(array, _.identity);
  13510.   };
  13511.  
  13512.   // Internal implementation of a recursive `flatten` function.
  13513.   var flatten = function(input, shallow, strict, startIndex) {
  13514.     var output = [], idx = 0;
  13515.     for (var i = startIndex || 0, length = getLength(input); i < length; i++) {
  13516.       var value = input[i];
  13517.       if (isArrayLike(value) && (_.isArray(value) || _.isArguments(value))) {
  13518.         //flatten current level of array or arguments object
  13519.         if (!shallow) value = flatten(value, shallow, strict);
  13520.         var j = 0, len = value.length;
  13521.         output.length += len;
  13522.         while (j < len) {
  13523.           output[idx++] = value[j++];
  13524.         }
  13525.       } else if (!strict) {
  13526.         output[idx++] = value;
  13527.       }
  13528.     }
  13529.     return output;
  13530.   };
  13531.  
  13532.   // Flatten out an array, either recursively (by default), or just one level.
  13533.   _.flatten = function(array, shallow) {
  13534.     return flatten(array, shallow, false);
  13535.   };
  13536.  
  13537.   // Return a version of the array that does not contain the specified value(s).
  13538.   _.without = function(array) {
  13539.     return _.difference(array, slice.call(arguments, 1));
  13540.   };
  13541.  
  13542.   // Produce a duplicate-free version of the array. If the array has already
  13543.   // been sorted, you have the option of using a faster algorithm.
  13544.   // Aliased as `unique`.
  13545.   _.uniq = _.unique = function(array, isSorted, iteratee, context) {
  13546.     if (!_.isBoolean(isSorted)) {
  13547.       context = iteratee;
  13548.       iteratee = isSorted;
  13549.       isSorted = false;
  13550.     }
  13551.     if (iteratee != null) iteratee = cb(iteratee, context);
  13552.     var result = [];
  13553.     var seen = [];
  13554.     for (var i = 0, length = getLength(array); i < length; i++) {
  13555.       var value = array[i],
  13556.           computed = iteratee ? iteratee(value, i, array) : value;
  13557.       if (isSorted) {
  13558.         if (!i || seen !== computed) result.push(value);
  13559.         seen = computed;
  13560.       } else if (iteratee) {
  13561.         if (!_.contains(seen, computed)) {
  13562.           seen.push(computed);
  13563.           result.push(value);
  13564.         }
  13565.       } else if (!_.contains(result, value)) {
  13566.         result.push(value);
  13567.       }
  13568.     }
  13569.     return result;
  13570.   };
  13571.  
  13572.   // Produce an array that contains the union: each distinct element from all of
  13573.   // the passed-in arrays.
  13574.   _.union = function() {
  13575.     return _.uniq(flatten(arguments, true, true));
  13576.   };
  13577.  
  13578.   // Produce an array that contains every item shared between all the
  13579.   // passed-in arrays.
  13580.   _.intersection = function(array) {
  13581.     var result = [];
  13582.     var argsLength = arguments.length;
  13583.     for (var i = 0, length = getLength(array); i < length; i++) {
  13584.       var item = array[i];
  13585.       if (_.contains(result, item)) continue;
  13586.       for (var j = 1; j < argsLength; j++) {
  13587.         if (!_.contains(arguments[j], item)) break;
  13588.       }
  13589.       if (j === argsLength) result.push(item);
  13590.     }
  13591.     return result;
  13592.   };
  13593.  
  13594.   // Take the difference between one array and a number of other arrays.
  13595.   // Only the elements present in just the first array will remain.
  13596.   _.difference = function(array) {
  13597.     var rest = flatten(arguments, true, true, 1);
  13598.     return _.filter(array, function(value){
  13599.       return !_.contains(rest, value);
  13600.     });
  13601.   };
  13602.  
  13603.   // Zip together multiple lists into a single array -- elements that share
  13604.   // an index go together.
  13605.   _.zip = function() {
  13606.     return _.unzip(arguments);
  13607.   };
  13608.  
  13609.   // Complement of _.zip. Unzip accepts an array of arrays and groups
  13610.   // each array's elements on shared indices
  13611.   _.unzip = function(array) {
  13612.     var length = array && _.max(array, getLength).length || 0;
  13613.     var result = Array(length);
  13614.  
  13615.     for (var index = 0; index < length; index++) {
  13616.       result[index] = _.pluck(array, index);
  13617.     }
  13618.     return result;
  13619.   };
  13620.  
  13621.   // Converts lists into objects. Pass either a single array of `[key, value]`
  13622.   // pairs, or two parallel arrays of the same length -- one of keys, and one of
  13623.   // the corresponding values.
  13624.   _.object = function(list, values) {
  13625.     var result = {};
  13626.     for (var i = 0, length = getLength(list); i < length; i++) {
  13627.       if (values) {
  13628.         result[list[i]] = values[i];
  13629.       } else {
  13630.         result[list[i][0]] = list[i][1];
  13631.       }
  13632.     }
  13633.     return result;
  13634.   };
  13635.  
  13636.   // Generator function to create the findIndex and findLastIndex functions
  13637.   function createPredicateIndexFinder(dir) {
  13638.     return function(array, predicate, context) {
  13639.       predicate = cb(predicate, context);
  13640.       var length = getLength(array);
  13641.       var index = dir > 0 ? 0 : length - 1;
  13642.       for (; index >= 0 && index < length; index += dir) {
  13643.         if (predicate(array[index], index, array)) return index;
  13644.       }
  13645.       return -1;
  13646.     };
  13647.   }
  13648.  
  13649.   // Returns the first index on an array-like that passes a predicate test
  13650.   _.findIndex = createPredicateIndexFinder(1);
  13651.   _.findLastIndex = createPredicateIndexFinder(-1);
  13652.  
  13653.   // Use a comparator function to figure out the smallest index at which
  13654.   // an object should be inserted so as to maintain order. Uses binary search.
  13655.   _.sortedIndex = function(array, obj, iteratee, context) {
  13656.     iteratee = cb(iteratee, context, 1);
  13657.     var value = iteratee(obj);
  13658.     var low = 0, high = getLength(array);
  13659.     while (low < high) {
  13660.       var mid = Math.floor((low + high) / 2);
  13661.       if (iteratee(array[mid]) < value) low = mid + 1; else high = mid;
  13662.     }
  13663.     return low;
  13664.   };
  13665.  
  13666.   // Generator function to create the indexOf and lastIndexOf functions
  13667.   function createIndexFinder(dir, predicateFind, sortedIndex) {
  13668.     return function(array, item, idx) {
  13669.       var i = 0, length = getLength(array);
  13670.       if (typeof idx == 'number') {
  13671.         if (dir > 0) {
  13672.             i = idx >= 0 ? idx : Math.max(idx + length, i);
  13673.         } else {
  13674.             length = idx >= 0 ? Math.min(idx + 1, length) : idx + length + 1;
  13675.         }
  13676.       } else if (sortedIndex && idx && length) {
  13677.         idx = sortedIndex(array, item);
  13678.         return array[idx] === item ? idx : -1;
  13679.       }
  13680.       if (item !== item) {
  13681.         idx = predicateFind(slice.call(array, i, length), _.isNaN);
  13682.         return idx >= 0 ? idx + i : -1;
  13683.       }
  13684.       for (idx = dir > 0 ? i : length - 1; idx >= 0 && idx < length; idx += dir) {
  13685.         if (array[idx] === item) return idx;
  13686.       }
  13687.       return -1;
  13688.     };
  13689.   }
  13690.  
  13691.   // Return the position of the first occurrence of an item in an array,
  13692.   // or -1 if the item is not included in the array.
  13693.   // If the array is large and already in sort order, pass `true`
  13694.   // for **isSorted** to use binary search.
  13695.   _.indexOf = createIndexFinder(1, _.findIndex, _.sortedIndex);
  13696.   _.lastIndexOf = createIndexFinder(-1, _.findLastIndex);
  13697.  
  13698.   // Generate an integer Array containing an arithmetic progression. A port of
  13699.   // the native Python `range()` function. See
  13700.   // [the Python documentation](http://docs.python.org/library/functions.html#range).
  13701.   _.range = function(start, stop, step) {
  13702.     if (stop == null) {
  13703.       stop = start || 0;
  13704.       start = 0;
  13705.     }
  13706.     step = step || 1;
  13707.  
  13708.     var length = Math.max(Math.ceil((stop - start) / step), 0);
  13709.     var range = Array(length);
  13710.  
  13711.     for (var idx = 0; idx < length; idx++, start += step) {
  13712.       range[idx] = start;
  13713.     }
  13714.  
  13715.     return range;
  13716.   };
  13717.  
  13718.   // Function (ahem) Functions
  13719.   // ------------------
  13720.  
  13721.   // Determines whether to execute a function as a constructor
  13722.   // or a normal function with the provided arguments
  13723.   var executeBound = function(sourceFunc, boundFunc, context, callingContext, args) {
  13724.     if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args);
  13725.     var self = baseCreate(sourceFunc.prototype);
  13726.     var result = sourceFunc.apply(self, args);
  13727.     if (_.isObject(result)) return result;
  13728.     return self;
  13729.   };
  13730.  
  13731.   // Create a function bound to a given object (assigning `this`, and arguments,
  13732.   // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if
  13733.   // available.
  13734.   _.bind = function(func, context) {
  13735.     if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
  13736.     if (!_.isFunction(func)) throw new TypeError('Bind must be called on a function');
  13737.     var args = slice.call(arguments, 2);
  13738.     var bound = function() {
  13739.       return executeBound(func, bound, context, this, args.concat(slice.call(arguments)));
  13740.     };
  13741.     return bound;
  13742.   };
  13743.  
  13744.   // Partially apply a function by creating a version that has had some of its
  13745.   // arguments pre-filled, without changing its dynamic `this` context. _ acts
  13746.   // as a placeholder, allowing any combination of arguments to be pre-filled.
  13747.   _.partial = function(func) {
  13748.     var boundArgs = slice.call(arguments, 1);
  13749.     var bound = function() {
  13750.       var position = 0, length = boundArgs.length;
  13751.       var args = Array(length);
  13752.       for (var i = 0; i < length; i++) {
  13753.         args[i] = boundArgs[i] === _ ? arguments[position++] : boundArgs[i];
  13754.       }
  13755.       while (position < arguments.length) args.push(arguments[position++]);
  13756.       return executeBound(func, bound, this, this, args);
  13757.     };
  13758.     return bound;
  13759.   };
  13760.  
  13761.   // Bind a number of an object's methods to that object. Remaining arguments
  13762.   // are the method names to be bound. Useful for ensuring that all callbacks
  13763.   // defined on an object belong to it.
  13764.   _.bindAll = function(obj) {
  13765.     var i, length = arguments.length, key;
  13766.     if (length <= 1) throw new Error('bindAll must be passed function names');
  13767.     for (i = 1; i < length; i++) {
  13768.       key = arguments[i];
  13769.       obj[key] = _.bind(obj[key], obj);
  13770.     }
  13771.     return obj;
  13772.   };
  13773.  
  13774.   // Memoize an expensive function by storing its results.
  13775.   _.memoize = function(func, hasher) {
  13776.     var memoize = function(key) {
  13777.       var cache = memoize.cache;
  13778.       var address = '' + (hasher ? hasher.apply(this, arguments) : key);
  13779.       if (!_.has(cache, address)) cache[address] = func.apply(this, arguments);
  13780.       return cache[address];
  13781.     };
  13782.     memoize.cache = {};
  13783.     return memoize;
  13784.   };
  13785.  
  13786.   // Delays a function for the given number of milliseconds, and then calls
  13787.   // it with the arguments supplied.
  13788.   _.delay = function(func, wait) {
  13789.     var args = slice.call(arguments, 2);
  13790.     return setTimeout(function(){
  13791.       return func.apply(null, args);
  13792.     }, wait);
  13793.   };
  13794.  
  13795.   // Defers a function, scheduling it to run after the current call stack has
  13796.   // cleared.
  13797.   _.defer = _.partial(_.delay, _, 1);
  13798.  
  13799.   // Returns a function, that, when invoked, will only be triggered at most once
  13800.   // during a given window of time. Normally, the throttled function will run
  13801.   // as much as it can, without ever going more than once per `wait` duration;
  13802.   // but if you'd like to disable the execution on the leading edge, pass
  13803.   // `{leading: false}`. To disable execution on the trailing edge, ditto.
  13804.   _.throttle = function(func, wait, options) {
  13805.     var context, args, result;
  13806.     var timeout = null;
  13807.     var previous = 0;
  13808.     if (!options) options = {};
  13809.     var later = function() {
  13810.       previous = options.leading === false ? 0 : _.now();
  13811.       timeout = null;
  13812.       result = func.apply(context, args);
  13813.       if (!timeout) context = args = null;
  13814.     };
  13815.     return function() {
  13816.       var now = _.now();
  13817.       if (!previous && options.leading === false) previous = now;
  13818.       var remaining = wait - (now - previous);
  13819.       context = this;
  13820.       args = arguments;
  13821.       if (remaining <= 0 || remaining > wait) {
  13822.         if (timeout) {
  13823.           clearTimeout(timeout);
  13824.           timeout = null;
  13825.         }
  13826.         previous = now;
  13827.         result = func.apply(context, args);
  13828.         if (!timeout) context = args = null;
  13829.       } else if (!timeout && options.trailing !== false) {
  13830.         timeout = setTimeout(later, remaining);
  13831.       }
  13832.       return result;
  13833.     };
  13834.   };
  13835.  
  13836.   // Returns a function, that, as long as it continues to be invoked, will not
  13837.   // be triggered. The function will be called after it stops being called for
  13838.   // N milliseconds. If `immediate` is passed, trigger the function on the
  13839.   // leading edge, instead of the trailing.
  13840.   _.debounce = function(func, wait, immediate) {
  13841.     var timeout, args, context, timestamp, result;
  13842.  
  13843.     var later = function() {
  13844.       var last = _.now() - timestamp;
  13845.  
  13846.       if (last < wait && last >= 0) {
  13847.         timeout = setTimeout(later, wait - last);
  13848.       } else {
  13849.         timeout = null;
  13850.         if (!immediate) {
  13851.           result = func.apply(context, args);
  13852.           if (!timeout) context = args = null;
  13853.         }
  13854.       }
  13855.     };
  13856.  
  13857.     return function() {
  13858.       context = this;
  13859.       args = arguments;
  13860.       timestamp = _.now();
  13861.       var callNow = immediate && !timeout;
  13862.       if (!timeout) timeout = setTimeout(later, wait);
  13863.       if (callNow) {
  13864.         result = func.apply(context, args);
  13865.         context = args = null;
  13866.       }
  13867.  
  13868.       return result;
  13869.     };
  13870.   };
  13871.  
  13872.   // Returns the first function passed as an argument to the second,
  13873.   // allowing you to adjust arguments, run code before and after, and
  13874.   // conditionally execute the original function.
  13875.   _.wrap = function(func, wrapper) {
  13876.     return _.partial(wrapper, func);
  13877.   };
  13878.  
  13879.   // Returns a negated version of the passed-in predicate.
  13880.   _.negate = function(predicate) {
  13881.     return function() {
  13882.       return !predicate.apply(this, arguments);
  13883.     };
  13884.   };
  13885.  
  13886.   // Returns a function that is the composition of a list of functions, each
  13887.   // consuming the return value of the function that follows.
  13888.   _.compose = function() {
  13889.     var args = arguments;
  13890.     var start = args.length - 1;
  13891.     return function() {
  13892.       var i = start;
  13893.       var result = args[start].apply(this, arguments);
  13894.       while (i--) result = args[i].call(this, result);
  13895.       return result;
  13896.     };
  13897.   };
  13898.  
  13899.   // Returns a function that will only be executed on and after the Nth call.
  13900.   _.after = function(times, func) {
  13901.     return function() {
  13902.       if (--times < 1) {
  13903.         return func.apply(this, arguments);
  13904.       }
  13905.     };
  13906.   };
  13907.  
  13908.   // Returns a function that will only be executed up to (but not including) the Nth call.
  13909.   _.before = function(times, func) {
  13910.     var memo;
  13911.     return function() {
  13912.       if (--times > 0) {
  13913.         memo = func.apply(this, arguments);
  13914.       }
  13915.       if (times <= 1) func = null;
  13916.       return memo;
  13917.     };
  13918.   };
  13919.  
  13920.   // Returns a function that will be executed at most one time, no matter how
  13921.   // often you call it. Useful for lazy initialization.
  13922.   _.once = _.partial(_.before, 2);
  13923.  
  13924.   // Object Functions
  13925.   // ----------------
  13926.  
  13927.   // Keys in IE < 9 that won't be iterated by `for key in ...` and thus missed.
  13928.   var hasEnumBug = !{toString: null}.propertyIsEnumerable('toString');
  13929.   var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString',
  13930.                       'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];
  13931.  
  13932.   function collectNonEnumProps(obj, keys) {
  13933.     var nonEnumIdx = nonEnumerableProps.length;
  13934.     var constructor = obj.constructor;
  13935.     var proto = (_.isFunction(constructor) && constructor.prototype) || ObjProto;
  13936.  
  13937.     // Constructor is a special case.
  13938.     var prop = 'constructor';
  13939.     if (_.has(obj, prop) && !_.contains(keys, prop)) keys.push(prop);
  13940.  
  13941.     while (nonEnumIdx--) {
  13942.       prop = nonEnumerableProps[nonEnumIdx];
  13943.       if (prop in obj && obj[prop] !== proto[prop] && !_.contains(keys, prop)) {
  13944.         keys.push(prop);
  13945.       }
  13946.     }
  13947.   }
  13948.  
  13949.   // Retrieve the names of an object's own properties.
  13950.   // Delegates to **ECMAScript 5**'s native `Object.keys`
  13951.   _.keys = function(obj) {
  13952.     if (!_.isObject(obj)) return [];
  13953.     if (nativeKeys) return nativeKeys(obj);
  13954.     var keys = [];
  13955.     for (var key in obj) if (_.has(obj, key)) keys.push(key);
  13956.     // Ahem, IE < 9.
  13957.     if (hasEnumBug) collectNonEnumProps(obj, keys);
  13958.     return keys;
  13959.   };
  13960.  
  13961.   // Retrieve all the property names of an object.
  13962.   _.allKeys = function(obj) {
  13963.     if (!_.isObject(obj)) return [];
  13964.     var keys = [];
  13965.     for (var key in obj) keys.push(key);
  13966.     // Ahem, IE < 9.
  13967.     if (hasEnumBug) collectNonEnumProps(obj, keys);
  13968.     return keys;
  13969.   };
  13970.  
  13971.   // Retrieve the values of an object's properties.
  13972.   _.values = function(obj) {
  13973.     var keys = _.keys(obj);
  13974.     var length = keys.length;
  13975.     var values = Array(length);
  13976.     for (var i = 0; i < length; i++) {
  13977.       values[i] = obj[keys[i]];
  13978.     }
  13979.     return values;
  13980.   };
  13981.  
  13982.   // Returns the results of applying the iteratee to each element of the object
  13983.   // In contrast to _.map it returns an object
  13984.   _.mapObject = function(obj, iteratee, context) {
  13985.     iteratee = cb(iteratee, context);
  13986.     var keys =  _.keys(obj),
  13987.           length = keys.length,
  13988.           results = {},
  13989.           currentKey;
  13990.       for (var index = 0; index < length; index++) {
  13991.         currentKey = keys[index];
  13992.         results[currentKey] = iteratee(obj[currentKey], currentKey, obj);
  13993.       }
  13994.       return results;
  13995.   };
  13996.  
  13997.   // Convert an object into a list of `[key, value]` pairs.
  13998.   _.pairs = function(obj) {
  13999.     var keys = _.keys(obj);
  14000.     var length = keys.length;
  14001.     var pairs = Array(length);
  14002.     for (var i = 0; i < length; i++) {
  14003.       pairs[i] = [keys[i], obj[keys[i]]];
  14004.     }
  14005.     return pairs;
  14006.   };
  14007.  
  14008.   // Invert the keys and values of an object. The values must be serializable.
  14009.   _.invert = function(obj) {
  14010.     var result = {};
  14011.     var keys = _.keys(obj);
  14012.     for (var i = 0, length = keys.length; i < length; i++) {
  14013.       result[obj[keys[i]]] = keys[i];
  14014.     }
  14015.     return result;
  14016.   };
  14017.  
  14018.   // Return a sorted list of the function names available on the object.
  14019.   // Aliased as `methods`
  14020.   _.functions = _.methods = function(obj) {
  14021.     var names = [];
  14022.     for (var key in obj) {
  14023.       if (_.isFunction(obj[key])) names.push(key);
  14024.     }
  14025.     return names.sort();
  14026.   };
  14027.  
  14028.   // Extend a given object with all the properties in passed-in object(s).
  14029.   _.extend = createAssigner(_.allKeys);
  14030.  
  14031.   // Assigns a given object with all the own properties in the passed-in object(s)
  14032.   // (https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)
  14033.   _.extendOwn = _.assign = createAssigner(_.keys);
  14034.  
  14035.   // Returns the first key on an object that passes a predicate test
  14036.   _.findKey = function(obj, predicate, context) {
  14037.     predicate = cb(predicate, context);
  14038.     var keys = _.keys(obj), key;
  14039.     for (var i = 0, length = keys.length; i < length; i++) {
  14040.       key = keys[i];
  14041.       if (predicate(obj[key], key, obj)) return key;
  14042.     }
  14043.   };
  14044.  
  14045.   // Return a copy of the object only containing the whitelisted properties.
  14046.   _.pick = function(object, oiteratee, context) {
  14047.     var result = {}, obj = object, iteratee, keys;
  14048.     if (obj == null) return result;
  14049.     if (_.isFunction(oiteratee)) {
  14050.       keys = _.allKeys(obj);
  14051.       iteratee = optimizeCb(oiteratee, context);
  14052.     } else {
  14053.       keys = flatten(arguments, false, false, 1);
  14054.       iteratee = function(value, key, obj) { return key in obj; };
  14055.       obj = Object(obj);
  14056.     }
  14057.     for (var i = 0, length = keys.length; i < length; i++) {
  14058.       var key = keys[i];
  14059.       var value = obj[key];
  14060.       if (iteratee(value, key, obj)) result[key] = value;
  14061.     }
  14062.     return result;
  14063.   };
  14064.  
  14065.    // Return a copy of the object without the blacklisted properties.
  14066.   _.omit = function(obj, iteratee, context) {
  14067.     if (_.isFunction(iteratee)) {
  14068.       iteratee = _.negate(iteratee);
  14069.     } else {
  14070.       var keys = _.map(flatten(arguments, false, false, 1), String);
  14071.       iteratee = function(value, key) {
  14072.         return !_.contains(keys, key);
  14073.       };
  14074.     }
  14075.     return _.pick(obj, iteratee, context);
  14076.   };
  14077.  
  14078.   // Fill in a given object with default properties.
  14079.   _.defaults = createAssigner(_.allKeys, true);
  14080.  
  14081.   // Creates an object that inherits from the given prototype object.
  14082.   // If additional properties are provided then they will be added to the
  14083.   // created object.
  14084.   _.create = function(prototype, props) {
  14085.     var result = baseCreate(prototype);
  14086.     if (props) _.extendOwn(result, props);
  14087.     return result;
  14088.   };
  14089.  
  14090.   // Create a (shallow-cloned) duplicate of an object.
  14091.   _.clone = function(obj) {
  14092.     if (!_.isObject(obj)) return obj;
  14093.     return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
  14094.   };
  14095.  
  14096.   // Invokes interceptor with the obj, and then returns obj.
  14097.   // The primary purpose of this method is to "tap into" a method chain, in
  14098.   // order to perform operations on intermediate results within the chain.
  14099.   _.tap = function(obj, interceptor) {
  14100.     interceptor(obj);
  14101.     return obj;
  14102.   };
  14103.  
  14104.   // Returns whether an object has a given set of `key:value` pairs.
  14105.   _.isMatch = function(object, attrs) {
  14106.     var keys = _.keys(attrs), length = keys.length;
  14107.     if (object == null) return !length;
  14108.     var obj = Object(object);
  14109.     for (var i = 0; i < length; i++) {
  14110.       var key = keys[i];
  14111.       if (attrs[key] !== obj[key] || !(key in obj)) return false;
  14112.     }
  14113.     return true;
  14114.   };
  14115.  
  14116.  
  14117.   // Internal recursive comparison function for `isEqual`.
  14118.   var eq = function(a, b, aStack, bStack) {
  14119.     // Identical objects are equal. `0 === -0`, but they aren't identical.
  14120.     // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).
  14121.     if (a === b) return a !== 0 || 1 / a === 1 / b;
  14122.     // A strict comparison is necessary because `null == undefined`.
  14123.     if (a == null || b == null) return a === b;
  14124.     // Unwrap any wrapped objects.
  14125.     if (a instanceof _) a = a._wrapped;
  14126.     if (b instanceof _) b = b._wrapped;
  14127.     // Compare `[[Class]]` names.
  14128.     var className = toString.call(a);
  14129.     if (className !== toString.call(b)) return false;
  14130.     switch (className) {
  14131.       // Strings, numbers, regular expressions, dates, and booleans are compared by value.
  14132.       case '[object RegExp]':
  14133.       // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')
  14134.       case '[object String]':
  14135.         // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
  14136.         // equivalent to `new String("5")`.
  14137.         return '' + a === '' + b;
  14138.       case '[object Number]':
  14139.         // `NaN`s are equivalent, but non-reflexive.
  14140.         // Object(NaN) is equivalent to NaN
  14141.         if (+a !== +a) return +b !== +b;
  14142.         // An `egal` comparison is performed for other numeric values.
  14143.         return +a === 0 ? 1 / +a === 1 / b : +a === +b;
  14144.       case '[object Date]':
  14145.       case '[object Boolean]':
  14146.         // Coerce dates and booleans to numeric primitive values. Dates are compared by their
  14147.         // millisecond representations. Note that invalid dates with millisecond representations
  14148.         // of `NaN` are not equivalent.
  14149.         return +a === +b;
  14150.     }
  14151.  
  14152.     var areArrays = className === '[object Array]';
  14153.     if (!areArrays) {
  14154.       if (typeof a != 'object' || typeof b != 'object') return false;
  14155.  
  14156.       // Objects with different constructors are not equivalent, but `Object`s or `Array`s
  14157.       // from different frames are.
  14158.       var aCtor = a.constructor, bCtor = b.constructor;
  14159.       if (aCtor !== bCtor && !(_.isFunction(aCtor) && aCtor instanceof aCtor &&
  14160.                                _.isFunction(bCtor) && bCtor instanceof bCtor)
  14161.                           && ('constructor' in a && 'constructor' in b)) {
  14162.         return false;
  14163.       }
  14164.     }
  14165.     // Assume equality for cyclic structures. The algorithm for detecting cyclic
  14166.     // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.
  14167.  
  14168.     // Initializing stack of traversed objects.
  14169.     // It's done here since we only need them for objects and arrays comparison.
  14170.     aStack = aStack || [];
  14171.     bStack = bStack || [];
  14172.     var length = aStack.length;
  14173.     while (length--) {
  14174.       // Linear search. Performance is inversely proportional to the number of
  14175.       // unique nested structures.
  14176.       if (aStack[length] === a) return bStack[length] === b;
  14177.     }
  14178.  
  14179.     // Add the first object to the stack of traversed objects.
  14180.     aStack.push(a);
  14181.     bStack.push(b);
  14182.  
  14183.     // Recursively compare objects and arrays.
  14184.     if (areArrays) {
  14185.       // Compare array lengths to determine if a deep comparison is necessary.
  14186.       length = a.length;
  14187.       if (length !== b.length) return false;
  14188.       // Deep compare the contents, ignoring non-numeric properties.
  14189.       while (length--) {
  14190.         if (!eq(a[length], b[length], aStack, bStack)) return false;
  14191.       }
  14192.     } else {
  14193.       // Deep compare objects.
  14194.       var keys = _.keys(a), key;
  14195.       length = keys.length;
  14196.       // Ensure that both objects contain the same number of properties before comparing deep equality.
  14197.       if (_.keys(b).length !== length) return false;
  14198.       while (length--) {
  14199.         // Deep compare each member
  14200.         key = keys[length];
  14201.         if (!(_.has(b, key) && eq(a[key], b[key], aStack, bStack))) return false;
  14202.       }
  14203.     }
  14204.     // Remove the first object from the stack of traversed objects.
  14205.     aStack.pop();
  14206.     bStack.pop();
  14207.     return true;
  14208.   };
  14209.  
  14210.   // Perform a deep comparison to check if two objects are equal.
  14211.   _.isEqual = function(a, b) {
  14212.     return eq(a, b);
  14213.   };
  14214.  
  14215.   // Is a given array, string, or object empty?
  14216.   // An "empty" object has no enumerable own-properties.
  14217.   _.isEmpty = function(obj) {
  14218.     if (obj == null) return true;
  14219.     if (isArrayLike(obj) && (_.isArray(obj) || _.isString(obj) || _.isArguments(obj))) return obj.length === 0;
  14220.     return _.keys(obj).length === 0;
  14221.   };
  14222.  
  14223.   // Is a given value a DOM element?
  14224.   _.isElement = function(obj) {
  14225.     return !!(obj && obj.nodeType === 1);
  14226.   };
  14227.  
  14228.   // Is a given value an array?
  14229.   // Delegates to ECMA5's native Array.isArray
  14230.   _.isArray = nativeIsArray || function(obj) {
  14231.     return toString.call(obj) === '[object Array]';
  14232.   };
  14233.  
  14234.   // Is a given variable an object?
  14235.   _.isObject = function(obj) {
  14236.     var type = typeof obj;
  14237.     return type === 'function' || type === 'object' && !!obj;
  14238.   };
  14239.  
  14240.   // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp, isError.
  14241.   _.each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp', 'Error'], function(name) {
  14242.     _['is' + name] = function(obj) {
  14243.       return toString.call(obj) === '[object ' + name + ']';
  14244.     };
  14245.   });
  14246.  
  14247.   // Define a fallback version of the method in browsers (ahem, IE < 9), where
  14248.   // there isn't any inspectable "Arguments" type.
  14249.   if (!_.isArguments(arguments)) {
  14250.     _.isArguments = function(obj) {
  14251.       return _.has(obj, 'callee');
  14252.     };
  14253.   }
  14254.  
  14255.   // Optimize `isFunction` if appropriate. Work around some typeof bugs in old v8,
  14256.   // IE 11 (#1621), and in Safari 8 (#1929).
  14257.   if (typeof /./ != 'function' && typeof Int8Array != 'object') {
  14258.     _.isFunction = function(obj) {
  14259.       return typeof obj == 'function' || false;
  14260.     };
  14261.   }
  14262.  
  14263.   // Is a given object a finite number?
  14264.   _.isFinite = function(obj) {
  14265.     return isFinite(obj) && !isNaN(parseFloat(obj));
  14266.   };
  14267.  
  14268.   // Is the given value `NaN`? (NaN is the only number which does not equal itself).
  14269.   _.isNaN = function(obj) {
  14270.     return _.isNumber(obj) && obj !== +obj;
  14271.   };
  14272.  
  14273.   // Is a given value a boolean?
  14274.   _.isBoolean = function(obj) {
  14275.     return obj === true || obj === false || toString.call(obj) === '[object Boolean]';
  14276.   };
  14277.  
  14278.   // Is a given value equal to null?
  14279.   _.isNull = function(obj) {
  14280.     return obj === null;
  14281.   };
  14282.  
  14283.   // Is a given variable undefined?
  14284.   _.isUndefined = function(obj) {
  14285.     return obj === void 0;
  14286.   };
  14287.  
  14288.   // Shortcut function for checking if an object has a given property directly
  14289.   // on itself (in other words, not on a prototype).
  14290.   _.has = function(obj, key) {
  14291.     return obj != null && hasOwnProperty.call(obj, key);
  14292.   };
  14293.  
  14294.   // Utility Functions
  14295.   // -----------------
  14296.  
  14297.   // Run Underscore.js in *noConflict* mode, returning the `_` variable to its
  14298.   // previous owner. Returns a reference to the Underscore object.
  14299.   _.noConflict = function() {
  14300.     root._ = previousUnderscore;
  14301.     return this;
  14302.   };
  14303.  
  14304.   // Keep the identity function around for default iteratees.
  14305.   _.identity = function(value) {
  14306.     return value;
  14307.   };
  14308.  
  14309.   // Predicate-generating functions. Often useful outside of Underscore.
  14310.   _.constant = function(value) {
  14311.     return function() {
  14312.       return value;
  14313.     };
  14314.   };
  14315.  
  14316.   _.noop = function(){};
  14317.  
  14318.   _.property = property;
  14319.  
  14320.   // Generates a function for a given object that returns a given property.
  14321.   _.propertyOf = function(obj) {
  14322.     return obj == null ? function(){} : function(key) {
  14323.       return obj[key];
  14324.     };
  14325.   };
  14326.  
  14327.   // Returns a predicate for checking whether an object has a given set of
  14328.   // `key:value` pairs.
  14329.   _.matcher = _.matches = function(attrs) {
  14330.     attrs = _.extendOwn({}, attrs);
  14331.     return function(obj) {
  14332.       return _.isMatch(obj, attrs);
  14333.     };
  14334.   };
  14335.  
  14336.   // Run a function **n** times.
  14337.   _.times = function(n, iteratee, context) {
  14338.     var accum = Array(Math.max(0, n));
  14339.     iteratee = optimizeCb(iteratee, context, 1);
  14340.     for (var i = 0; i < n; i++) accum[i] = iteratee(i);
  14341.     return accum;
  14342.   };
  14343.  
  14344.   // Return a random integer between min and max (inclusive).
  14345.   _.random = function(min, max) {
  14346.     if (max == null) {
  14347.       max = min;
  14348.       min = 0;
  14349.     }
  14350.     return min + Math.floor(Math.random() * (max - min + 1));
  14351.   };
  14352.  
  14353.   // A (possibly faster) way to get the current timestamp as an integer.
  14354.   _.now = Date.now || function() {
  14355.     return new Date().getTime();
  14356.   };
  14357.  
  14358.    // List of HTML entities for escaping.
  14359.   var escapeMap = {
  14360.     '&': '&amp;',
  14361.     '<': '&lt;',
  14362.     '>': '&gt;',
  14363.     '"': '&quot;',
  14364.     "'": '&#x27;',
  14365.     '`': '&#x60;'
  14366.   };
  14367.   var unescapeMap = _.invert(escapeMap);
  14368.  
  14369.   // Functions for escaping and unescaping strings to/from HTML interpolation.
  14370.   var createEscaper = function(map) {
  14371.     var escaper = function(match) {
  14372.       return map[match];
  14373.     };
  14374.     // Regexes for identifying a key that needs to be escaped
  14375.     var source = '(?:' + _.keys(map).join('|') + ')';
  14376.     var testRegexp = RegExp(source);
  14377.     var replaceRegexp = RegExp(source, 'g');
  14378.     return function(string) {
  14379.       string = string == null ? '' : '' + string;
  14380.       return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;
  14381.     };
  14382.   };
  14383.   _.escape = createEscaper(escapeMap);
  14384.   _.unescape = createEscaper(unescapeMap);
  14385.  
  14386.   // If the value of the named `property` is a function then invoke it with the
  14387.   // `object` as context; otherwise, return it.
  14388.   _.result = function(object, property, fallback) {
  14389.     var value = object == null ? void 0 : object[property];
  14390.     if (value === void 0) {
  14391.       value = fallback;
  14392.     }
  14393.     return _.isFunction(value) ? value.call(object) : value;
  14394.   };
  14395.  
  14396.   // Generate a unique integer id (unique within the entire client session).
  14397.   // Useful for temporary DOM ids.
  14398.   var idCounter = 0;
  14399.   _.uniqueId = function(prefix) {
  14400.     var id = ++idCounter + '';
  14401.     return prefix ? prefix + id : id;
  14402.   };
  14403.  
  14404.   // By default, Underscore uses ERB-style template delimiters, change the
  14405.   // following template settings to use alternative delimiters.
  14406.   _.templateSettings = {
  14407.     evaluate    : /<%([\s\S]+?)%>/g,
  14408.     interpolate : /<%=([\s\S]+?)%>/g,
  14409.     escape      : /<%-([\s\S]+?)%>/g
  14410.   };
  14411.  
  14412.   // When customizing `templateSettings`, if you don't want to define an
  14413.   // interpolation, evaluation or escaping regex, we need one that is
  14414.   // guaranteed not to match.
  14415.   var noMatch = /(.)^/;
  14416.  
  14417.   // Certain characters need to be escaped so that they can be put into a
  14418.   // string literal.
  14419.   var escapes = {
  14420.     "'":      "'",
  14421.     '\\':     '\\',
  14422.     '\r':     'r',
  14423.     '\n':     'n',
  14424.     '\u2028': 'u2028',
  14425.     '\u2029': 'u2029'
  14426.   };
  14427.  
  14428.   var escaper = /\\|'|\r|\n|\u2028|\u2029/g;
  14429.  
  14430.   var escapeChar = function(match) {
  14431.     return '\\' + escapes[match];
  14432.   };
  14433.  
  14434.   // JavaScript micro-templating, similar to John Resig's implementation.
  14435.   // Underscore templating handles arbitrary delimiters, preserves whitespace,
  14436.   // and correctly escapes quotes within interpolated code.
  14437.   // NB: `oldSettings` only exists for backwards compatibility.
  14438.   _.template = function(text, settings, oldSettings) {
  14439.     if (!settings && oldSettings) settings = oldSettings;
  14440.     settings = _.defaults({}, settings, _.templateSettings);
  14441.  
  14442.     // Combine delimiters into one regular expression via alternation.
  14443.     var matcher = RegExp([
  14444.       (settings.escape || noMatch).source,
  14445.       (settings.interpolate || noMatch).source,
  14446.       (settings.evaluate || noMatch).source
  14447.     ].join('|') + '|$', 'g');
  14448.  
  14449.     // Compile the template source, escaping string literals appropriately.
  14450.     var index = 0;
  14451.     var source = "__p+='";
  14452.     text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {
  14453.       source += text.slice(index, offset).replace(escaper, escapeChar);
  14454.       index = offset + match.length;
  14455.  
  14456.       if (escape) {
  14457.         source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'";
  14458.       } else if (interpolate) {
  14459.         source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'";
  14460.       } else if (evaluate) {
  14461.         source += "';\n" + evaluate + "\n__p+='";
  14462.       }
  14463.  
  14464.       // Adobe VMs need the match returned to produce the correct offest.
  14465.       return match;
  14466.     });
  14467.     source += "';\n";
  14468.  
  14469.     // If a variable is not specified, place data values in local scope.
  14470.     if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n';
  14471.  
  14472.     source = "var __t,__p='',__j=Array.prototype.join," +
  14473.       "print=function(){__p+=__j.call(arguments,'');};\n" +
  14474.       source + 'return __p;\n';
  14475.  
  14476.     try {
  14477.       var render = new Function(settings.variable || 'obj', '_', source);
  14478.     } catch (e) {
  14479.       e.source = source;
  14480.       throw e;
  14481.     }
  14482.  
  14483.     var template = function(data) {
  14484.       return render.call(this, data, _);
  14485.     };
  14486.  
  14487.     // Provide the compiled source as a convenience for precompilation.
  14488.     var argument = settings.variable || 'obj';
  14489.     template.source = 'function(' + argument + '){\n' + source + '}';
  14490.  
  14491.     return template;
  14492.   };
  14493.  
  14494.   // Add a "chain" function. Start chaining a wrapped Underscore object.
  14495.   _.chain = function(obj) {
  14496.     var instance = _(obj);
  14497.     instance._chain = true;
  14498.     return instance;
  14499.   };
  14500.  
  14501.   // OOP
  14502.   // ---------------
  14503.   // If Underscore is called as a function, it returns a wrapped object that
  14504.   // can be used OO-style. This wrapper holds altered versions of all the
  14505.   // underscore functions. Wrapped objects may be chained.
  14506.  
  14507.   // Helper function to continue chaining intermediate results.
  14508.   var result = function(instance, obj) {
  14509.     return instance._chain ? _(obj).chain() : obj;
  14510.   };
  14511.  
  14512.   // Add your own custom functions to the Underscore object.
  14513.   _.mixin = function(obj) {
  14514.     _.each(_.functions(obj), function(name) {
  14515.       var func = _[name] = obj[name];
  14516.       _.prototype[name] = function() {
  14517.         var args = [this._wrapped];
  14518.         push.apply(args, arguments);
  14519.         return result(this, func.apply(_, args));
  14520.       };
  14521.     });
  14522.   };
  14523.  
  14524.   // Add all of the Underscore functions to the wrapper object.
  14525.   _.mixin(_);
  14526.  
  14527.   // Add all mutator Array functions to the wrapper.
  14528.   _.each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {
  14529.     var method = ArrayProto[name];
  14530.     _.prototype[name] = function() {
  14531.       var obj = this._wrapped;
  14532.       method.apply(obj, arguments);
  14533.       if ((name === 'shift' || name === 'splice') && obj.length === 0) delete obj[0];
  14534.       return result(this, obj);
  14535.     };
  14536.   });
  14537.  
  14538.   // Add all accessor Array functions to the wrapper.
  14539.   _.each(['concat', 'join', 'slice'], function(name) {
  14540.     var method = ArrayProto[name];
  14541.     _.prototype[name] = function() {
  14542.       return result(this, method.apply(this._wrapped, arguments));
  14543.     };
  14544.   });
  14545.  
  14546.   // Extracts the result from a wrapped and chained object.
  14547.   _.prototype.value = function() {
  14548.     return this._wrapped;
  14549.   };
  14550.  
  14551.   // Provide unwrapping proxy for some methods used in engine operations
  14552.   // such as arithmetic and JSON stringification.
  14553.   _.prototype.valueOf = _.prototype.toJSON = _.prototype.value;
  14554.  
  14555.   _.prototype.toString = function() {
  14556.     return '' + this._wrapped;
  14557.   };
  14558.  
  14559.   // AMD registration happens at the end for compatibility with AMD loaders
  14560.   // that may not enforce next-turn semantics on modules. Even though general
  14561.   // practice for AMD registration is to be anonymous, underscore registers
  14562.   // as a named module because, like jQuery, it is a base library that is
  14563.   // popular enough to be bundled in a third party lib, but not be part of
  14564.   // an AMD load request. Those cases could generate an error when an
  14565.   // anonymous define() is called outside of a loader request.
  14566.   if (true) {
  14567.     !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function() {
  14568.       return _;
  14569.     }.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
  14570. 				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
  14571.   }
  14572. }.call(this));
  14573.  
  14574.  
  14575. /***/ }),
  14576. /* 114 */
  14577. /***/ (function(module, exports, __webpack_require__) {
  14578.  
  14579. "use strict";
  14580. // Copyright Joyent, Inc. and other Node contributors.
  14581. //
  14582. // Permission is hereby granted, free of charge, to any person obtaining a
  14583. // copy of this software and associated documentation files (the
  14584. // "Software"), to deal in the Software without restriction, including
  14585. // without limitation the rights to use, copy, modify, merge, publish,
  14586. // distribute, sublicense, and/or sell copies of the Software, and to permit
  14587. // persons to whom the Software is furnished to do so, subject to the
  14588. // following conditions:
  14589. //
  14590. // The above copyright notice and this permission notice shall be included
  14591. // in all copies or substantial portions of the Software.
  14592. //
  14593. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  14594. // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  14595. // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  14596. // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  14597. // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  14598. // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  14599. // USE OR OTHER DEALINGS IN THE SOFTWARE.
  14600.  
  14601.  
  14602.  
  14603. var punycode = __webpack_require__(102);
  14604. var util = __webpack_require__(115);
  14605.  
  14606. exports.parse = urlParse;
  14607. exports.resolve = urlResolve;
  14608. exports.resolveObject = urlResolveObject;
  14609. exports.format = urlFormat;
  14610.  
  14611. exports.Url = Url;
  14612.  
  14613. function Url() {
  14614.   this.protocol = null;
  14615.   this.slashes = null;
  14616.   this.auth = null;
  14617.   this.host = null;
  14618.   this.port = null;
  14619.   this.hostname = null;
  14620.   this.hash = null;
  14621.   this.search = null;
  14622.   this.query = null;
  14623.   this.pathname = null;
  14624.   this.path = null;
  14625.   this.href = null;
  14626. }
  14627.  
  14628. // Reference: RFC 3986, RFC 1808, RFC 2396
  14629.  
  14630. // define these here so at least they only have to be
  14631. // compiled once on the first module load.
  14632. var protocolPattern = /^([a-z0-9.+-]+:)/i,
  14633.     portPattern = /:[0-9]*$/,
  14634.  
  14635.     // Special case for a simple path URL
  14636.     simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/,
  14637.  
  14638.     // RFC 2396: characters reserved for delimiting URLs.
  14639.     // We actually just auto-escape these.
  14640.     delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t'],
  14641.  
  14642.     // RFC 2396: characters not allowed for various reasons.
  14643.     unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims),
  14644.  
  14645.     // Allowed by RFCs, but cause of XSS attacks.  Always escape these.
  14646.     autoEscape = ['\''].concat(unwise),
  14647.     // Characters that are never ever allowed in a hostname.
  14648.     // Note that any invalid chars are also handled, but these
  14649.     // are the ones that are *expected* to be seen, so we fast-path
  14650.     // them.
  14651.     nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),
  14652.     hostEndingChars = ['/', '?', '#'],
  14653.     hostnameMaxLen = 255,
  14654.     hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,
  14655.     hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,
  14656.     // protocols that can allow "unsafe" and "unwise" chars.
  14657.     unsafeProtocol = {
  14658.       'javascript': true,
  14659.       'javascript:': true
  14660.     },
  14661.     // protocols that never have a hostname.
  14662.     hostlessProtocol = {
  14663.       'javascript': true,
  14664.       'javascript:': true
  14665.     },
  14666.     // protocols that always contain a // bit.
  14667.     slashedProtocol = {
  14668.       'http': true,
  14669.       'https': true,
  14670.       'ftp': true,
  14671.       'gopher': true,
  14672.       'file': true,
  14673.       'http:': true,
  14674.       'https:': true,
  14675.       'ftp:': true,
  14676.       'gopher:': true,
  14677.       'file:': true
  14678.     },
  14679.     querystring = __webpack_require__(105);
  14680.  
  14681. function urlParse(url, parseQueryString, slashesDenoteHost) {
  14682.   if (url && util.isObject(url) && url instanceof Url) return url;
  14683.  
  14684.   var u = new Url;
  14685.   u.parse(url, parseQueryString, slashesDenoteHost);
  14686.   return u;
  14687. }
  14688.  
  14689. Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {
  14690.   if (!util.isString(url)) {
  14691.     throw new TypeError("Parameter 'url' must be a string, not " + typeof url);
  14692.   }
  14693.  
  14694.   // Copy chrome, IE, opera backslash-handling behavior.
  14695.   // Back slashes before the query string get converted to forward slashes
  14696.   // See: https://code.google.com/p/chromium/issues/detail?id=25916
  14697.   var queryIndex = url.indexOf('?'),
  14698.       splitter =
  14699.           (queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#',
  14700.       uSplit = url.split(splitter),
  14701.       slashRegex = /\\/g;
  14702.   uSplit[0] = uSplit[0].replace(slashRegex, '/');
  14703.   url = uSplit.join(splitter);
  14704.  
  14705.   var rest = url;
  14706.  
  14707.   // trim before proceeding.
  14708.   // This is to support parse stuff like "  http://foo.com  \n"
  14709.   rest = rest.trim();
  14710.  
  14711.   if (!slashesDenoteHost && url.split('#').length === 1) {
  14712.     // Try fast path regexp
  14713.     var simplePath = simplePathPattern.exec(rest);
  14714.     if (simplePath) {
  14715.       this.path = rest;
  14716.       this.href = rest;
  14717.       this.pathname = simplePath[1];
  14718.       if (simplePath[2]) {
  14719.         this.search = simplePath[2];
  14720.         if (parseQueryString) {
  14721.           this.query = querystring.parse(this.search.substr(1));
  14722.         } else {
  14723.           this.query = this.search.substr(1);
  14724.         }
  14725.       } else if (parseQueryString) {
  14726.         this.search = '';
  14727.         this.query = {};
  14728.       }
  14729.       return this;
  14730.     }
  14731.   }
  14732.  
  14733.   var proto = protocolPattern.exec(rest);
  14734.   if (proto) {
  14735.     proto = proto[0];
  14736.     var lowerProto = proto.toLowerCase();
  14737.     this.protocol = lowerProto;
  14738.     rest = rest.substr(proto.length);
  14739.   }
  14740.  
  14741.   // figure out if it's got a host
  14742.   // user@server is *always* interpreted as a hostname, and url
  14743.   // resolution will treat //foo/bar as host=foo,path=bar because that's
  14744.   // how the browser resolves relative URLs.
  14745.   if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
  14746.     var slashes = rest.substr(0, 2) === '//';
  14747.     if (slashes && !(proto && hostlessProtocol[proto])) {
  14748.       rest = rest.substr(2);
  14749.       this.slashes = true;
  14750.     }
  14751.   }
  14752.  
  14753.   if (!hostlessProtocol[proto] &&
  14754.       (slashes || (proto && !slashedProtocol[proto]))) {
  14755.  
  14756.     // there's a hostname.
  14757.     // the first instance of /, ?, ;, or # ends the host.
  14758.     //
  14759.     // If there is an @ in the hostname, then non-host chars *are* allowed
  14760.     // to the left of the last @ sign, unless some host-ending character
  14761.     // comes *before* the @-sign.
  14762.     // URLs are obnoxious.
  14763.     //
  14764.     // ex:
  14765.     // http://a@b@c/ => user:a@b host:c
  14766.     // http://a@b?@c => user:a host:c path:/?@c
  14767.  
  14768.     // v0.12 TODO(isaacs): This is not quite how Chrome does things.
  14769.     // Review our test case against browsers more comprehensively.
  14770.  
  14771.     // find the first instance of any hostEndingChars
  14772.     var hostEnd = -1;
  14773.     for (var i = 0; i < hostEndingChars.length; i++) {
  14774.       var hec = rest.indexOf(hostEndingChars[i]);
  14775.       if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
  14776.         hostEnd = hec;
  14777.     }
  14778.  
  14779.     // at this point, either we have an explicit point where the
  14780.     // auth portion cannot go past, or the last @ char is the decider.
  14781.     var auth, atSign;
  14782.     if (hostEnd === -1) {
  14783.       // atSign can be anywhere.
  14784.       atSign = rest.lastIndexOf('@');
  14785.     } else {
  14786.       // atSign must be in auth portion.
  14787.       // http://a@b/c@d => host:b auth:a path:/c@d
  14788.       atSign = rest.lastIndexOf('@', hostEnd);
  14789.     }
  14790.  
  14791.     // Now we have a portion which is definitely the auth.
  14792.     // Pull that off.
  14793.     if (atSign !== -1) {
  14794.       auth = rest.slice(0, atSign);
  14795.       rest = rest.slice(atSign + 1);
  14796.       this.auth = decodeURIComponent(auth);
  14797.     }
  14798.  
  14799.     // the host is the remaining to the left of the first non-host char
  14800.     hostEnd = -1;
  14801.     for (var i = 0; i < nonHostChars.length; i++) {
  14802.       var hec = rest.indexOf(nonHostChars[i]);
  14803.       if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
  14804.         hostEnd = hec;
  14805.     }
  14806.     // if we still have not hit it, then the entire thing is a host.
  14807.     if (hostEnd === -1)
  14808.       hostEnd = rest.length;
  14809.  
  14810.     this.host = rest.slice(0, hostEnd);
  14811.     rest = rest.slice(hostEnd);
  14812.  
  14813.     // pull out port.
  14814.     this.parseHost();
  14815.  
  14816.     // we've indicated that there is a hostname,
  14817.     // so even if it's empty, it has to be present.
  14818.     this.hostname = this.hostname || '';
  14819.  
  14820.     // if hostname begins with [ and ends with ]
  14821.     // assume that it's an IPv6 address.
  14822.     var ipv6Hostname = this.hostname[0] === '[' &&
  14823.         this.hostname[this.hostname.length - 1] === ']';
  14824.  
  14825.     // validate a little.
  14826.     if (!ipv6Hostname) {
  14827.       var hostparts = this.hostname.split(/\./);
  14828.       for (var i = 0, l = hostparts.length; i < l; i++) {
  14829.         var part = hostparts[i];
  14830.         if (!part) continue;
  14831.         if (!part.match(hostnamePartPattern)) {
  14832.           var newpart = '';
  14833.           for (var j = 0, k = part.length; j < k; j++) {
  14834.             if (part.charCodeAt(j) > 127) {
  14835.               // we replace non-ASCII char with a temporary placeholder
  14836.               // we need this to make sure size of hostname is not
  14837.               // broken by replacing non-ASCII by nothing
  14838.               newpart += 'x';
  14839.             } else {
  14840.               newpart += part[j];
  14841.             }
  14842.           }
  14843.           // we test again with ASCII char only
  14844.           if (!newpart.match(hostnamePartPattern)) {
  14845.             var validParts = hostparts.slice(0, i);
  14846.             var notHost = hostparts.slice(i + 1);
  14847.             var bit = part.match(hostnamePartStart);
  14848.             if (bit) {
  14849.               validParts.push(bit[1]);
  14850.               notHost.unshift(bit[2]);
  14851.             }
  14852.             if (notHost.length) {
  14853.               rest = '/' + notHost.join('.') + rest;
  14854.             }
  14855.             this.hostname = validParts.join('.');
  14856.             break;
  14857.           }
  14858.         }
  14859.       }
  14860.     }
  14861.  
  14862.     if (this.hostname.length > hostnameMaxLen) {
  14863.       this.hostname = '';
  14864.     } else {
  14865.       // hostnames are always lower case.
  14866.       this.hostname = this.hostname.toLowerCase();
  14867.     }
  14868.  
  14869.     if (!ipv6Hostname) {
  14870.       // IDNA Support: Returns a punycoded representation of "domain".
  14871.       // It only converts parts of the domain name that
  14872.       // have non-ASCII characters, i.e. it doesn't matter if
  14873.       // you call it with a domain that already is ASCII-only.
  14874.       this.hostname = punycode.toASCII(this.hostname);
  14875.     }
  14876.  
  14877.     var p = this.port ? ':' + this.port : '';
  14878.     var h = this.hostname || '';
  14879.     this.host = h + p;
  14880.     this.href += this.host;
  14881.  
  14882.     // strip [ and ] from the hostname
  14883.     // the host field still retains them, though
  14884.     if (ipv6Hostname) {
  14885.       this.hostname = this.hostname.substr(1, this.hostname.length - 2);
  14886.       if (rest[0] !== '/') {
  14887.         rest = '/' + rest;
  14888.       }
  14889.     }
  14890.   }
  14891.  
  14892.   // now rest is set to the post-host stuff.
  14893.   // chop off any delim chars.
  14894.   if (!unsafeProtocol[lowerProto]) {
  14895.  
  14896.     // First, make 100% sure that any "autoEscape" chars get
  14897.     // escaped, even if encodeURIComponent doesn't think they
  14898.     // need to be.
  14899.     for (var i = 0, l = autoEscape.length; i < l; i++) {
  14900.       var ae = autoEscape[i];
  14901.       if (rest.indexOf(ae) === -1)
  14902.         continue;
  14903.       var esc = encodeURIComponent(ae);
  14904.       if (esc === ae) {
  14905.         esc = escape(ae);
  14906.       }
  14907.       rest = rest.split(ae).join(esc);
  14908.     }
  14909.   }
  14910.  
  14911.  
  14912.   // chop off from the tail first.
  14913.   var hash = rest.indexOf('#');
  14914.   if (hash !== -1) {
  14915.     // got a fragment string.
  14916.     this.hash = rest.substr(hash);
  14917.     rest = rest.slice(0, hash);
  14918.   }
  14919.   var qm = rest.indexOf('?');
  14920.   if (qm !== -1) {
  14921.     this.search = rest.substr(qm);
  14922.     this.query = rest.substr(qm + 1);
  14923.     if (parseQueryString) {
  14924.       this.query = querystring.parse(this.query);
  14925.     }
  14926.     rest = rest.slice(0, qm);
  14927.   } else if (parseQueryString) {
  14928.     // no query string, but parseQueryString still requested
  14929.     this.search = '';
  14930.     this.query = {};
  14931.   }
  14932.   if (rest) this.pathname = rest;
  14933.   if (slashedProtocol[lowerProto] &&
  14934.       this.hostname && !this.pathname) {
  14935.     this.pathname = '/';
  14936.   }
  14937.  
  14938.   //to support http.request
  14939.   if (this.pathname || this.search) {
  14940.     var p = this.pathname || '';
  14941.     var s = this.search || '';
  14942.     this.path = p + s;
  14943.   }
  14944.  
  14945.   // finally, reconstruct the href based on what has been validated.
  14946.   this.href = this.format();
  14947.   return this;
  14948. };
  14949.  
  14950. // format a parsed object into a url string
  14951. function urlFormat(obj) {
  14952.   // ensure it's an object, and not a string url.
  14953.   // If it's an obj, this is a no-op.
  14954.   // this way, you can call url_format() on strings
  14955.   // to clean up potentially wonky urls.
  14956.   if (util.isString(obj)) obj = urlParse(obj);
  14957.   if (!(obj instanceof Url)) return Url.prototype.format.call(obj);
  14958.   return obj.format();
  14959. }
  14960.  
  14961. Url.prototype.format = function() {
  14962.   var auth = this.auth || '';
  14963.   if (auth) {
  14964.     auth = encodeURIComponent(auth);
  14965.     auth = auth.replace(/%3A/i, ':');
  14966.     auth += '@';
  14967.   }
  14968.  
  14969.   var protocol = this.protocol || '',
  14970.       pathname = this.pathname || '',
  14971.       hash = this.hash || '',
  14972.       host = false,
  14973.       query = '';
  14974.  
  14975.   if (this.host) {
  14976.     host = auth + this.host;
  14977.   } else if (this.hostname) {
  14978.     host = auth + (this.hostname.indexOf(':') === -1 ?
  14979.         this.hostname :
  14980.         '[' + this.hostname + ']');
  14981.     if (this.port) {
  14982.       host += ':' + this.port;
  14983.     }
  14984.   }
  14985.  
  14986.   if (this.query &&
  14987.       util.isObject(this.query) &&
  14988.       Object.keys(this.query).length) {
  14989.     query = querystring.stringify(this.query);
  14990.   }
  14991.  
  14992.   var search = this.search || (query && ('?' + query)) || '';
  14993.  
  14994.   if (protocol && protocol.substr(-1) !== ':') protocol += ':';
  14995.  
  14996.   // only the slashedProtocols get the //.  Not mailto:, xmpp:, etc.
  14997.   // unless they had them to begin with.
  14998.   if (this.slashes ||
  14999.       (!protocol || slashedProtocol[protocol]) && host !== false) {
  15000.     host = '//' + (host || '');
  15001.     if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;
  15002.   } else if (!host) {
  15003.     host = '';
  15004.   }
  15005.  
  15006.   if (hash && hash.charAt(0) !== '#') hash = '#' + hash;
  15007.   if (search && search.charAt(0) !== '?') search = '?' + search;
  15008.  
  15009.   pathname = pathname.replace(/[?#]/g, function(match) {
  15010.     return encodeURIComponent(match);
  15011.   });
  15012.   search = search.replace('#', '%23');
  15013.  
  15014.   return protocol + host + pathname + search + hash;
  15015. };
  15016.  
  15017. function urlResolve(source, relative) {
  15018.   return urlParse(source, false, true).resolve(relative);
  15019. }
  15020.  
  15021. Url.prototype.resolve = function(relative) {
  15022.   return this.resolveObject(urlParse(relative, false, true)).format();
  15023. };
  15024.  
  15025. function urlResolveObject(source, relative) {
  15026.   if (!source) return relative;
  15027.   return urlParse(source, false, true).resolveObject(relative);
  15028. }
  15029.  
  15030. Url.prototype.resolveObject = function(relative) {
  15031.   if (util.isString(relative)) {
  15032.     var rel = new Url();
  15033.     rel.parse(relative, false, true);
  15034.     relative = rel;
  15035.   }
  15036.  
  15037.   var result = new Url();
  15038.   var tkeys = Object.keys(this);
  15039.   for (var tk = 0; tk < tkeys.length; tk++) {
  15040.     var tkey = tkeys[tk];
  15041.     result[tkey] = this[tkey];
  15042.   }
  15043.  
  15044.   // hash is always overridden, no matter what.
  15045.   // even href="" will remove it.
  15046.   result.hash = relative.hash;
  15047.  
  15048.   // if the relative url is empty, then there's nothing left to do here.
  15049.   if (relative.href === '') {
  15050.     result.href = result.format();
  15051.     return result;
  15052.   }
  15053.  
  15054.   // hrefs like //foo/bar always cut to the protocol.
  15055.   if (relative.slashes && !relative.protocol) {
  15056.     // take everything except the protocol from relative
  15057.     var rkeys = Object.keys(relative);
  15058.     for (var rk = 0; rk < rkeys.length; rk++) {
  15059.       var rkey = rkeys[rk];
  15060.       if (rkey !== 'protocol')
  15061.         result[rkey] = relative[rkey];
  15062.     }
  15063.  
  15064.     //urlParse appends trailing / to urls like http://www.example.com
  15065.     if (slashedProtocol[result.protocol] &&
  15066.         result.hostname && !result.pathname) {
  15067.       result.path = result.pathname = '/';
  15068.     }
  15069.  
  15070.     result.href = result.format();
  15071.     return result;
  15072.   }
  15073.  
  15074.   if (relative.protocol && relative.protocol !== result.protocol) {
  15075.     // if it's a known url protocol, then changing
  15076.     // the protocol does weird things
  15077.     // first, if it's not file:, then we MUST have a host,
  15078.     // and if there was a path
  15079.     // to begin with, then we MUST have a path.
  15080.     // if it is file:, then the host is dropped,
  15081.     // because that's known to be hostless.
  15082.     // anything else is assumed to be absolute.
  15083.     if (!slashedProtocol[relative.protocol]) {
  15084.       var keys = Object.keys(relative);
  15085.       for (var v = 0; v < keys.length; v++) {
  15086.         var k = keys[v];
  15087.         result[k] = relative[k];
  15088.       }
  15089.       result.href = result.format();
  15090.       return result;
  15091.     }
  15092.  
  15093.     result.protocol = relative.protocol;
  15094.     if (!relative.host && !hostlessProtocol[relative.protocol]) {
  15095.       var relPath = (relative.pathname || '').split('/');
  15096.       while (relPath.length && !(relative.host = relPath.shift()));
  15097.       if (!relative.host) relative.host = '';
  15098.       if (!relative.hostname) relative.hostname = '';
  15099.       if (relPath[0] !== '') relPath.unshift('');
  15100.       if (relPath.length < 2) relPath.unshift('');
  15101.       result.pathname = relPath.join('/');
  15102.     } else {
  15103.       result.pathname = relative.pathname;
  15104.     }
  15105.     result.search = relative.search;
  15106.     result.query = relative.query;
  15107.     result.host = relative.host || '';
  15108.     result.auth = relative.auth;
  15109.     result.hostname = relative.hostname || relative.host;
  15110.     result.port = relative.port;
  15111.     // to support http.request
  15112.     if (result.pathname || result.search) {
  15113.       var p = result.pathname || '';
  15114.       var s = result.search || '';
  15115.       result.path = p + s;
  15116.     }
  15117.     result.slashes = result.slashes || relative.slashes;
  15118.     result.href = result.format();
  15119.     return result;
  15120.   }
  15121.  
  15122.   var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),
  15123.       isRelAbs = (
  15124.           relative.host ||
  15125.           relative.pathname && relative.pathname.charAt(0) === '/'
  15126.       ),
  15127.       mustEndAbs = (isRelAbs || isSourceAbs ||
  15128.                     (result.host && relative.pathname)),
  15129.       removeAllDots = mustEndAbs,
  15130.       srcPath = result.pathname && result.pathname.split('/') || [],
  15131.       relPath = relative.pathname && relative.pathname.split('/') || [],
  15132.       psychotic = result.protocol && !slashedProtocol[result.protocol];
  15133.  
  15134.   // if the url is a non-slashed url, then relative
  15135.   // links like ../.. should be able
  15136.   // to crawl up to the hostname, as well.  This is strange.
  15137.   // result.protocol has already been set by now.
  15138.   // Later on, put the first path part into the host field.
  15139.   if (psychotic) {
  15140.     result.hostname = '';
  15141.     result.port = null;
  15142.     if (result.host) {
  15143.       if (srcPath[0] === '') srcPath[0] = result.host;
  15144.       else srcPath.unshift(result.host);
  15145.     }
  15146.     result.host = '';
  15147.     if (relative.protocol) {
  15148.       relative.hostname = null;
  15149.       relative.port = null;
  15150.       if (relative.host) {
  15151.         if (relPath[0] === '') relPath[0] = relative.host;
  15152.         else relPath.unshift(relative.host);
  15153.       }
  15154.       relative.host = null;
  15155.     }
  15156.     mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');
  15157.   }
  15158.  
  15159.   if (isRelAbs) {
  15160.     // it's absolute.
  15161.     result.host = (relative.host || relative.host === '') ?
  15162.                   relative.host : result.host;
  15163.     result.hostname = (relative.hostname || relative.hostname === '') ?
  15164.                       relative.hostname : result.hostname;
  15165.     result.search = relative.search;
  15166.     result.query = relative.query;
  15167.     srcPath = relPath;
  15168.     // fall through to the dot-handling below.
  15169.   } else if (relPath.length) {
  15170.     // it's relative
  15171.     // throw away the existing file, and take the new path instead.
  15172.     if (!srcPath) srcPath = [];
  15173.     srcPath.pop();
  15174.     srcPath = srcPath.concat(relPath);
  15175.     result.search = relative.search;
  15176.     result.query = relative.query;
  15177.   } else if (!util.isNullOrUndefined(relative.search)) {
  15178.     // just pull out the search.
  15179.     // like href='?foo'.
  15180.     // Put this after the other two cases because it simplifies the booleans
  15181.     if (psychotic) {
  15182.       result.hostname = result.host = srcPath.shift();
  15183.       //occationaly the auth can get stuck only in host
  15184.       //this especially happens in cases like
  15185.       //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
  15186.       var authInHost = result.host && result.host.indexOf('@') > 0 ?
  15187.                        result.host.split('@') : false;
  15188.       if (authInHost) {
  15189.         result.auth = authInHost.shift();
  15190.         result.host = result.hostname = authInHost.shift();
  15191.       }
  15192.     }
  15193.     result.search = relative.search;
  15194.     result.query = relative.query;
  15195.     //to support http.request
  15196.     if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
  15197.       result.path = (result.pathname ? result.pathname : '') +
  15198.                     (result.search ? result.search : '');
  15199.     }
  15200.     result.href = result.format();
  15201.     return result;
  15202.   }
  15203.  
  15204.   if (!srcPath.length) {
  15205.     // no path at all.  easy.
  15206.     // we've already handled the other stuff above.
  15207.     result.pathname = null;
  15208.     //to support http.request
  15209.     if (result.search) {
  15210.       result.path = '/' + result.search;
  15211.     } else {
  15212.       result.path = null;
  15213.     }
  15214.     result.href = result.format();
  15215.     return result;
  15216.   }
  15217.  
  15218.   // if a url ENDs in . or .., then it must get a trailing slash.
  15219.   // however, if it ends in anything else non-slashy,
  15220.   // then it must NOT get a trailing slash.
  15221.   var last = srcPath.slice(-1)[0];
  15222.   var hasTrailingSlash = (
  15223.       (result.host || relative.host || srcPath.length > 1) &&
  15224.       (last === '.' || last === '..') || last === '');
  15225.  
  15226.   // strip single dots, resolve double dots to parent dir
  15227.   // if the path tries to go above the root, `up` ends up > 0
  15228.   var up = 0;
  15229.   for (var i = srcPath.length; i >= 0; i--) {
  15230.     last = srcPath[i];
  15231.     if (last === '.') {
  15232.       srcPath.splice(i, 1);
  15233.     } else if (last === '..') {
  15234.       srcPath.splice(i, 1);
  15235.       up++;
  15236.     } else if (up) {
  15237.       srcPath.splice(i, 1);
  15238.       up--;
  15239.     }
  15240.   }
  15241.  
  15242.   // if the path is allowed to go above the root, restore leading ..s
  15243.   if (!mustEndAbs && !removeAllDots) {
  15244.     for (; up--; up) {
  15245.       srcPath.unshift('..');
  15246.     }
  15247.   }
  15248.  
  15249.   if (mustEndAbs && srcPath[0] !== '' &&
  15250.       (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {
  15251.     srcPath.unshift('');
  15252.   }
  15253.  
  15254.   if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {
  15255.     srcPath.push('');
  15256.   }
  15257.  
  15258.   var isAbsolute = srcPath[0] === '' ||
  15259.       (srcPath[0] && srcPath[0].charAt(0) === '/');
  15260.  
  15261.   // put the host back
  15262.   if (psychotic) {
  15263.     result.hostname = result.host = isAbsolute ? '' :
  15264.                                     srcPath.length ? srcPath.shift() : '';
  15265.     //occationaly the auth can get stuck only in host
  15266.     //this especially happens in cases like
  15267.     //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
  15268.     var authInHost = result.host && result.host.indexOf('@') > 0 ?
  15269.                      result.host.split('@') : false;
  15270.     if (authInHost) {
  15271.       result.auth = authInHost.shift();
  15272.       result.host = result.hostname = authInHost.shift();
  15273.     }
  15274.   }
  15275.  
  15276.   mustEndAbs = mustEndAbs || (result.host && srcPath.length);
  15277.  
  15278.   if (mustEndAbs && !isAbsolute) {
  15279.     srcPath.unshift('');
  15280.   }
  15281.  
  15282.   if (!srcPath.length) {
  15283.     result.pathname = null;
  15284.     result.path = null;
  15285.   } else {
  15286.     result.pathname = srcPath.join('/');
  15287.   }
  15288.  
  15289.   //to support request.http
  15290.   if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
  15291.     result.path = (result.pathname ? result.pathname : '') +
  15292.                   (result.search ? result.search : '');
  15293.   }
  15294.   result.auth = relative.auth || result.auth;
  15295.   result.slashes = result.slashes || relative.slashes;
  15296.   result.href = result.format();
  15297.   return result;
  15298. };
  15299.  
  15300. Url.prototype.parseHost = function() {
  15301.   var host = this.host;
  15302.   var port = portPattern.exec(host);
  15303.   if (port) {
  15304.     port = port[0];
  15305.     if (port !== ':') {
  15306.       this.port = port.substr(1);
  15307.     }
  15308.     host = host.substr(0, host.length - port.length);
  15309.   }
  15310.   if (host) this.hostname = host;
  15311. };
  15312.  
  15313.  
  15314. /***/ }),
  15315. /* 115 */
  15316. /***/ (function(module, exports, __webpack_require__) {
  15317.  
  15318. "use strict";
  15319.  
  15320.  
  15321. module.exports = {
  15322.   isString: function(arg) {
  15323.     return typeof(arg) === 'string';
  15324.   },
  15325.   isObject: function(arg) {
  15326.     return typeof(arg) === 'object' && arg !== null;
  15327.   },
  15328.   isNull: function(arg) {
  15329.     return arg === null;
  15330.   },
  15331.   isNullOrUndefined: function(arg) {
  15332.     return arg == null;
  15333.   }
  15334. };
  15335.  
  15336.  
  15337. /***/ }),
  15338. /* 116 */
  15339. /***/ (function(module, exports) {
  15340.  
  15341. module.exports = function(module) {
  15342. 	if(!module.webpackPolyfill) {
  15343. 		module.deprecate = function() {};
  15344. 		module.paths = [];
  15345. 		// module.parent = undefined by default
  15346. 		if(!module.children) module.children = [];
  15347. 		Object.defineProperty(module, "loaded", {
  15348. 			enumerable: true,
  15349. 			get: function() {
  15350. 				return module.l;
  15351. 			}
  15352. 		});
  15353. 		Object.defineProperty(module, "id", {
  15354. 			enumerable: true,
  15355. 			get: function() {
  15356. 				return module.i;
  15357. 			}
  15358. 		});
  15359. 		module.webpackPolyfill = 1;
  15360. 	}
  15361. 	return module;
  15362. };
  15363.  
  15364.  
  15365. /***/ }),
  15366. /* 117 */
  15367. /***/ (function(module, __webpack_exports__, __webpack_require__) {
  15368.  
  15369. "use strict";
  15370. Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
  15371. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator__ = __webpack_require__(11);
  15372. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator__);
  15373. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_asyncToGenerator__ = __webpack_require__(10);
  15374. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_asyncToGenerator___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_asyncToGenerator__);
  15375. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__utils__ = __webpack_require__(9);
  15376. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__pages_detail__ = __webpack_require__(50);
  15377. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__pages_search__ = __webpack_require__(52);
  15378. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__pages_browse__ = __webpack_require__(49);
  15379. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__pages_home__ = __webpack_require__(51);
  15380.  
  15381.  
  15382.  
  15383.  
  15384.  
  15385. var init = function () {
  15386.   var _ref = __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_asyncToGenerator___default()(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator___default.a.mark(function _callee() {
  15387.     var href;
  15388.     return __WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator___default.a.wrap(function _callee$(_context) {
  15389.       while (1) {
  15390.         switch (_context.prev = _context.next) {
  15391.           case 0:
  15392.             href = window.location.href;
  15393.  
  15394.             if (href.indexOf("package") >= 0) {
  15395.               __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_3__pages_detail__["a" /* default */])()().catch(__WEBPACK_IMPORTED_MODULE_2__utils__["a" /* printError */]);
  15396.             } else if (href.indexOf('search') >= 0) {
  15397.               __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_4__pages_search__["a" /* default */])()().catch(__WEBPACK_IMPORTED_MODULE_2__utils__["a" /* printError */]);
  15398.             } else if (href.indexOf('browse') >= 0) {
  15399.               __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_5__pages_browse__["a" /* default */])()().catch(__WEBPACK_IMPORTED_MODULE_2__utils__["a" /* printError */]);
  15400.             } else {
  15401.               __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_6__pages_home__["a" /* default */])()().catch(__WEBPACK_IMPORTED_MODULE_2__utils__["a" /* printError */]);
  15402.             }
  15403.  
  15404.           case 2:
  15405.           case 'end':
  15406.             return _context.stop();
  15407.         }
  15408.       }
  15409.     }, _callee, this);
  15410.   }));
  15411.  
  15412.   return function init() {
  15413.     return _ref.apply(this, arguments);
  15414.   };
  15415. }();
  15416.  
  15417.  
  15418.  
  15419.  
  15420.  
  15421.  
  15422.  
  15423.  
  15424. __webpack_require__(53);
  15425.  
  15426. init();
  15427.  
  15428. /***/ })
  15429. /******/ ]);