g(x,c))a[d]=x,a[n]=c,d=n;else break a}}return b}\nfunction g(a,b){var c=a.sortIndex-b.sortIndex;return 0!==c?c:a.id-b.id}if(\"object\"===typeof performance&&\"function\"===typeof performance.now){var l=performance;exports.unstable_now=function(){return l.now()}}else{var p=Date,q=p.now();exports.unstable_now=function(){return p.now()-q}}var r=[],t=[],u=1,v=null,y=3,z=!1,A=!1,B=!1,D=\"function\"===typeof setTimeout?setTimeout:null,E=\"function\"===typeof clearTimeout?clearTimeout:null,F=\"undefined\"!==typeof setImmediate?setImmediate:null;\n\"undefined\"!==typeof navigator&&void 0!==navigator.scheduling&&void 0!==navigator.scheduling.isInputPending&&navigator.scheduling.isInputPending.bind(navigator.scheduling);function G(a){for(var b=h(t);null!==b;){if(null===b.callback)k(t);else if(b.startTime<=a)k(t),b.sortIndex=b.expirationTime,f(r,b);else break;b=h(t)}}function H(a){B=!1;G(a);if(!A)if(null!==h(r))A=!0,I(J);else{var b=h(t);null!==b&&K(H,b.startTime-a)}}\nfunction J(a,b){A=!1;B&&(B=!1,E(L),L=-1);z=!0;var c=y;try{G(b);for(v=h(r);null!==v&&(!(v.expirationTime>b)||a&&!M());){var d=v.callback;if(\"function\"===typeof d){v.callback=null;y=v.priorityLevel;var e=d(v.expirationTime<=b);b=exports.unstable_now();\"function\"===typeof e?v.callback=e:v===h(r)&&k(r);G(b)}else k(r);v=h(r)}if(null!==v)var w=!0;else{var m=h(t);null!==m&&K(H,m.startTime-b);w=!1}return w}finally{v=null,y=c,z=!1}}var N=!1,O=null,L=-1,P=5,Q=-1;\nfunction M(){return exports.unstable_now()-Qa||125d?(a.sortIndex=c,f(t,a),null===h(r)&&a===h(t)&&(B?(E(L),L=-1):B=!0,K(H,c-d))):(a.sortIndex=e,f(r,a),A||z||(A=!0,I(J)));return a};\nexports.unstable_shouldYield=M;exports.unstable_wrapCallback=function(a){var b=y;return function(){var c=y;y=b;try{return a.apply(this,arguments)}finally{y=c}}};\n","'use strict';\n\nvar m = require('react-dom');\nif (process.env.NODE_ENV === 'production') {\n exports.createRoot = m.createRoot;\n exports.hydrateRoot = m.hydrateRoot;\n} else {\n var i = m.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;\n exports.createRoot = function(c, o) {\n i.usingClientEntryPoint = true;\n try {\n return m.createRoot(c, o);\n } finally {\n i.usingClientEntryPoint = false;\n }\n };\n exports.hydrateRoot = function(c, h, o) {\n i.usingClientEntryPoint = true;\n try {\n return m.hydrateRoot(c, h, o);\n } finally {\n i.usingClientEntryPoint = false;\n }\n };\n}\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n module.exports = require('./cjs/react-jsx-runtime.production.min.js');\n} else {\n module.exports = require('./cjs/react-jsx-runtime.development.js');\n}\n","/* eslint-disable */ \n\n/**\n The MIT License\n\nCopyright (c) EventSource GitHub organisation\n\nPermission is hereby granted, free of charge, to any person obtaining\na copy of this software and associated documentation files (the\n\"Software\"), to deal in the Software without restriction, including\nwithout limitation the rights to use, copy, modify, merge, publish,\ndistribute, sublicense, and/or sell copies of the Software, and to\npermit persons to whom the Software is furnished to do so, subject to\nthe following conditions:\n\nThe above copyright notice and this permission notice shall be\nincluded in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\nEXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\nMERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\nNONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE\nLIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\nOF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\nWITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n*/\n\n/** ****/ (function (modules) { // webpackBootstrap\n/** ****/ \t// The module cache\n/** ****/ \tconst installedModules = {};\n/** ****/\n/** ****/ \t// The require function\n/** ****/ \tfunction __webpack_require__(moduleId) {\n/** ****/\n/** ****/ \t\t// Check if module is in cache\n/** ****/ \t\tif (installedModules[moduleId]) {\n/** ****/ \t\t\treturn installedModules[moduleId].exports;\n/** ****/ \t\t}\n/** ****/ \t\t// Create a new module (and put it into the cache)\n/** ****/ \t\tconst module = installedModules[moduleId] = {\n/** ****/ \t\t\ti: moduleId,\n/** ****/ \t\t\tl: false,\n/** ****/ \t\t\texports: {}\n/** ****/ \t\t};\n/** ****/\n/** ****/ \t\t// Execute the module function\n/** ****/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/** ****/\n/** ****/ \t\t// Flag the module as loaded\n/** ****/ \t\tmodule.l = true;\n/** ****/\n/** ****/ \t\t// Return the exports of the module\n/** ****/ \t\treturn module.exports;\n/** ****/ \t}\n/** ****/\n/** ****/\n/** ****/ \t// expose the modules object (__webpack_modules__)\n/** ****/ \t__webpack_require__.m = modules;\n/** ****/\n/** ****/ \t// expose the module cache\n/** ****/ \t__webpack_require__.c = installedModules;\n/** ****/\n/** ****/ \t// define getter function for harmony exports\n/** ****/ \t__webpack_require__.d = function (exports, name, getter) {\n/** ****/ \t\tif (!__webpack_require__.o(exports, name)) {\n/** ****/ \t\t\tObject.defineProperty(exports, name, {\n/** ****/ \t\t\t\tconfigurable: false,\n/** ****/ \t\t\t\tenumerable: true,\n/** ****/ \t\t\t\tget: getter\n/** ****/ \t\t\t});\n/** ****/ \t\t}\n/** ****/ \t};\n/** ****/\n/** ****/ \t// getDefaultExport function for compatibility with non-harmony modules\n/** ****/ \t__webpack_require__.n = function (module) {\n/** ****/ \t\tconst getter = module && module.__esModule ?\n/** ****/ \t\t\tfunction getDefault() {\n return module.default;\n} :\n/** ****/ \t\t\tfunction getModuleExports() {\n return module;\n};\n/** ****/ \t\t__webpack_require__.d(getter, 'a', getter);\n/** ****/ \t\treturn getter;\n/** ****/ \t};\n/** ****/\n/** ****/ \t// Object.prototype.hasOwnProperty.call\n/** ****/ \t__webpack_require__.o = function (object, property) {\n return Object.prototype.hasOwnProperty.call(object, property);\n};\n/** ****/\n/** ****/ \t// __webpack_public_path__\n/** ****/ \t__webpack_require__.p = \"\";\n/** ****/\n/** ****/ \t// Load entry module and return exports\n/** ****/ \treturn __webpack_require__(__webpack_require__.s = 21);\n/** ****/ })\n/** **********************************************************************/\n/** ****/ ([\n/* 0 */\n/** */ (function (module, exports) {\n\tlet g;\n\n\t// This works in non-strict mode\n\tg = (function () {\n\t\treturn this;\n\t})();\n\n\ttry {\n\t\t// This works if eval is allowed (see CSP)\n\t\tg = g || Function(\"return this\")() || (1, eval)(\"this\");\n\t} catch (e) {\n\t\t// This works if the window reference is available\n\t\tif (typeof window === \"object\") {\n g = window;\n}\n\t}\n\n\t// g can still be undefined, but nothing to do about it...\n\t// We return undefined, instead of nothing here, so it's\n\t// easier to handle this case. if(!global) { ...}\n\n\tmodule.exports = g;\n\t/** */ }),\n\t/* 1 */\n\t/** */ (function (module, exports) {\n\t// shim for using process in browser\n\tconst process = module.exports = {};\n\n\t// cached from whatever global is present so that test runners that stub it\n\t// don't break things. But we need to wrap it in a try catch in case it is\n\t// wrapped in strict mode code which doesn't define any globals. It's inside a\n\t// function because try/catches deoptimize in certain engines.\n\n\tlet cachedSetTimeout;\n\tlet cachedClearTimeout;\n\n\tfunction defaultSetTimout() {\n\t\tthrow new Error('setTimeout has not been defined');\n\t}\n\tfunction defaultClearTimeout() {\n\t\tthrow new Error('clearTimeout has not been defined');\n\t}\n\t(function () {\n\t\ttry {\n\t\t\tif (typeof setTimeout === 'function') {\n\t\t\t\tcachedSetTimeout = setTimeout;\n\t\t\t} else {\n\t\t\t\tcachedSetTimeout = defaultSetTimout;\n\t\t\t}\n\t\t} catch (e) {\n\t\t\tcachedSetTimeout = defaultSetTimout;\n\t\t}\n\t\ttry {\n\t\t\tif (typeof clearTimeout === 'function') {\n\t\t\t\tcachedClearTimeout = clearTimeout;\n\t\t\t} else {\n\t\t\t\tcachedClearTimeout = defaultClearTimeout;\n\t\t\t}\n\t\t} catch (e) {\n\t\t\tcachedClearTimeout = defaultClearTimeout;\n\t\t}\n\t}());\n\tfunction runTimeout(fun) {\n\t\tif (cachedSetTimeout === setTimeout) {\n\t\t\t// normal enviroments in sane situations\n\t\t\treturn setTimeout(fun, 0);\n\t\t}\n\t\t// if setTimeout wasn't available but was latter defined\n\t\tif ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n\t\t\tcachedSetTimeout = setTimeout;\n\t\t\treturn setTimeout(fun, 0);\n\t\t}\n\t\ttry {\n\t\t\t// when when somebody has screwed with setTimeout but no I.E. maddness\n\t\t\treturn cachedSetTimeout(fun, 0);\n\t\t} catch (e) {\n\t\t\ttry {\n\t\t\t\t// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n\t\t\t\treturn cachedSetTimeout.call(null, fun, 0);\n\t\t\t} catch (e) {\n\t\t\t\t// 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\n\t\t\t\treturn cachedSetTimeout.call(this, fun, 0);\n\t\t\t}\n\t\t}\n\t}\n\tfunction runClearTimeout(marker) {\n\t\tif (cachedClearTimeout === clearTimeout) {\n\t\t\t// normal enviroments in sane situations\n\t\t\treturn clearTimeout(marker);\n\t\t}\n\t\t// if clearTimeout wasn't available but was latter defined\n\t\tif ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n\t\t\tcachedClearTimeout = clearTimeout;\n\t\t\treturn clearTimeout(marker);\n\t\t}\n\t\ttry {\n\t\t\t// when when somebody has screwed with setTimeout but no I.E. maddness\n\t\t\treturn cachedClearTimeout(marker);\n\t\t} catch (e) {\n\t\t\ttry {\n\t\t\t\t// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n\t\t\t\treturn cachedClearTimeout.call(null, marker);\n\t\t\t} catch (e) {\n\t\t\t\t// 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.\n\t\t\t\t// Some versions of I.E. have different rules for clearTimeout vs setTimeout\n\t\t\t\treturn cachedClearTimeout.call(this, marker);\n\t\t\t}\n\t\t}\n\t}\n\tlet queue = [];\n\tlet draining = false;\n\tlet currentQueue;\n\tlet queueIndex = -1;\n\n\tfunction cleanUpNextTick() {\n\t\tif (!draining || !currentQueue) {\n\t\t\treturn;\n\t\t}\n\t\tdraining = false;\n\t\tif (currentQueue.length) {\n\t\t\tqueue = currentQueue.concat(queue);\n\t\t} else {\n\t\t\tqueueIndex = -1;\n\t\t}\n\t\tif (queue.length) {\n\t\t\tdrainQueue();\n\t\t}\n\t}\n\n\tfunction drainQueue() {\n\t\tif (draining) {\n\t\t\treturn;\n\t\t}\n\t\tconst timeout = runTimeout(cleanUpNextTick);\n\t\tdraining = true;\n\n\t\tlet len = queue.length;\n\t\twhile (len) {\n\t\t\tcurrentQueue = queue;\n\t\t\tqueue = [];\n\t\t\twhile (++queueIndex < len) {\n\t\t\t\tif (currentQueue) {\n\t\t\t\t\tcurrentQueue[queueIndex].run();\n\t\t\t\t}\n\t\t\t}\n\t\t\tqueueIndex = -1;\n\t\t\tlen = queue.length;\n\t\t}\n\t\tcurrentQueue = null;\n\t\tdraining = false;\n\t\trunClearTimeout(timeout);\n\t}\n\n\tprocess.nextTick = function (fun) {\n\t\tconst args = new Array(arguments.length - 1);\n\t\tif (arguments.length > 1) {\n\t\t\tfor (let i = 1; i < arguments.length; i++) {\n\t\t\t\targs[i - 1] = arguments[i];\n\t\t\t}\n\t\t}\n\t\tqueue.push(new Item(fun, args));\n\t\tif (queue.length === 1 && !draining) {\n\t\t\trunTimeout(drainQueue);\n\t\t}\n\t};\n\n\t// v8 likes predictible objects\n\tfunction Item(fun, array) {\n\t\tthis.fun = fun;\n\t\tthis.array = array;\n\t}\n\tItem.prototype.run = function () {\n\t\tthis.fun.apply(null, this.array);\n\t};\n\tprocess.title = 'browser';\n\tprocess.browser = true;\n\tprocess.env = {};\n\tprocess.argv = [];\n\tprocess.version = ''; // empty string to avoid regexp issues\n\tprocess.versions = {};\n\n\tfunction noop() {}\n\n\tprocess.on = noop;\n\tprocess.addListener = noop;\n\tprocess.once = noop;\n\tprocess.off = noop;\n\tprocess.removeListener = noop;\n\tprocess.removeAllListeners = noop;\n\tprocess.emit = noop;\n\tprocess.prependListener = noop;\n\tprocess.prependOnceListener = noop;\n\n\tprocess.listeners = function (name) {\n return [];\n};\n\n\tprocess.binding = function (name) {\n\t\tthrow new Error('process.binding is not supported');\n\t};\n\n\tprocess.cwd = function () {\n return '/';\n};\n\tprocess.chdir = function (dir) {\n\t\tthrow new Error('process.chdir is not supported');\n\t};\n\tprocess.umask = function () {\n return 0;\n};\n\t/** */ }),\n\t/* 2 */\n\t/** */ (function (module, exports, __webpack_require__) {\n\t\"use strict\";\n\t/* WEBPACK VAR INJECTION */(function (global) { /* !\n\t * The buffer module from node.js, for the browser.\n\t *\n\t * @author Feross Aboukhadijeh \n\t * @license MIT\n\t */\n\t/* eslint-disable no-proto */\n\n\n\tconst base64 = __webpack_require__(23);\n\tconst ieee754 = __webpack_require__(24);\n\tconst isArray = __webpack_require__(25);\n\n\texports.Buffer = Buffer;\n\texports.SlowBuffer = SlowBuffer;\n\texports.INSPECT_MAX_BYTES = 50;\n\n\t/**\n\t * If `Buffer.TYPED_ARRAY_SUPPORT`:\n\t * === true Use Uint8Array implementation (fastest)\n\t * === false Use Object implementation (most compatible, even IE6)\n\t *\n\t * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n\t * Opera 11.6+, iOS 4.2+.\n\t *\n\t * Due to various browser bugs, sometimes the Object implementation will be used even\n\t * when the browser supports typed arrays.\n\t *\n\t * Note:\n\t *\n\t * - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n\t * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n\t *\n\t * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n\t *\n\t * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n\t * incorrect length in some situations.\n\n\t * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n\t * get the Object implementation, which is slower but behaves correctly.\n\t */\n\tBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n\t ? global.TYPED_ARRAY_SUPPORT\n\t : typedArraySupport();\n\n\t/*\n\t * Export kMaxLength after typed array support is determined.\n\t */\n\texports.kMaxLength = kMaxLength();\n\n\tfunction typedArraySupport() {\n\t try {\n\t\tconst arr = new Uint8Array(1);\n\t\tarr.__proto__ = {__proto__: Uint8Array.prototype, foo() {\n return 42;\n}};\n\t\treturn arr.foo() === 42 && // typed array instances can be augmented\n\t\t\ttypeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n\t\t\tarr.subarray(1, 1).byteLength === 0; // ie10 has broken `subarray`\n\t } catch (e) {\n\t\treturn false;\n\t }\n\t}\n\n\tfunction kMaxLength() {\n\t return Buffer.TYPED_ARRAY_SUPPORT\n\t\t? 0x7fffffff\n\t\t: 0x3fffffff;\n\t}\n\n\tfunction createBuffer(that, length) {\n\t if (kMaxLength() < length) {\n\t\tthrow new RangeError('Invalid typed array length');\n\t }\n\t if (Buffer.TYPED_ARRAY_SUPPORT) {\n\t\t// Return an augmented `Uint8Array` instance, for best performance\n\t\tthat = new Uint8Array(length);\n\t\tthat.__proto__ = Buffer.prototype;\n\t } else {\n\t\t// Fallback: Return an object instance of the Buffer class\n\t\tif (that === null) {\n\t\t that = new Buffer(length);\n\t\t}\n\t\tthat.length = length;\n\t }\n\n\t return that;\n\t}\n\n\t/**\n\t * The Buffer constructor returns instances of `Uint8Array` that have their\n\t * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n\t * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n\t * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n\t * returns a single octet.\n\t *\n\t * The `Uint8Array` prototype remains unmodified.\n\t */\n\n\tfunction Buffer(arg, encodingOrOffset, length) {\n\t if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n\t\treturn new Buffer(arg, encodingOrOffset, length);\n\t }\n\n\t // Common case.\n\t if (typeof arg === 'number') {\n\t\tif (typeof encodingOrOffset === 'string') {\n\t\t throw new Error(\n\t\t\t'If encoding is specified then the first argument must be a string'\n\t\t );\n\t\t}\n\t\treturn allocUnsafe(this, arg);\n\t }\n\t return from(this, arg, encodingOrOffset, length);\n\t}\n\n\tBuffer.poolSize = 8192; // not used by this implementation\n\n\t// TODO: Legacy, not needed anymore. Remove in next major version.\n\tBuffer._augment = function (arr) {\n\t arr.__proto__ = Buffer.prototype;\n\t return arr;\n\t};\n\n\tfunction from(that, value, encodingOrOffset, length) {\n\t if (typeof value === 'number') {\n\t\tthrow new TypeError('\"value\" argument must not be a number');\n\t }\n\n\t if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n\t\treturn fromArrayBuffer(that, value, encodingOrOffset, length);\n\t }\n\n\t if (typeof value === 'string') {\n\t\treturn fromString(that, value, encodingOrOffset);\n\t }\n\n\t return fromObject(that, value);\n\t}\n\n\t/**\n\t * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n\t * if value is a number.\n\t * Buffer.from(str[, encoding])\n\t * Buffer.from(array)\n\t * Buffer.from(buffer)\n\t * Buffer.from(arrayBuffer[, byteOffset[, length]])\n\t **/\n\tBuffer.from = function (value, encodingOrOffset, length) {\n\t return from(null, value, encodingOrOffset, length);\n\t};\n\n\tif (Buffer.TYPED_ARRAY_SUPPORT) {\n\t Buffer.prototype.__proto__ = Uint8Array.prototype;\n\t Buffer.__proto__ = Uint8Array;\n\t if (typeof Symbol !== 'undefined' && Symbol.species &&\n\t\t Buffer[Symbol.species] === Buffer) {\n\t\t// Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n\t\tObject.defineProperty(Buffer, Symbol.species, {\n\t\t value: null,\n\t\t configurable: true\n\t\t});\n\t }\n\t}\n\n\tfunction assertSize(size) {\n\t if (typeof size !== 'number') {\n\t\tthrow new TypeError('\"size\" argument must be a number');\n\t } else if (size < 0) {\n\t\tthrow new RangeError('\"size\" argument must not be negative');\n\t }\n\t}\n\n\tfunction alloc(that, size, fill, encoding) {\n\t assertSize(size);\n\t if (size <= 0) {\n\t\treturn createBuffer(that, size);\n\t }\n\t if (fill !== undefined) {\n\t\t// Only pay attention to encoding if it's a string. This\n\t\t// prevents accidentally sending in a number that would\n\t\t// be interpretted as a start offset.\n\t\treturn typeof encoding === 'string'\n\t\t ? createBuffer(that, size).fill(fill, encoding)\n\t\t : createBuffer(that, size).fill(fill);\n\t }\n\t return createBuffer(that, size);\n\t}\n\n\t/**\n\t * Creates a new filled Buffer instance.\n\t * alloc(size[, fill[, encoding]])\n\t **/\n\tBuffer.alloc = function (size, fill, encoding) {\n\t return alloc(null, size, fill, encoding);\n\t};\n\n\tfunction allocUnsafe(that, size) {\n\t assertSize(size);\n\t that = createBuffer(that, size < 0 ? 0 : checked(size) | 0);\n\t if (!Buffer.TYPED_ARRAY_SUPPORT) {\n\t\tfor (let i = 0; i < size; ++i) {\n\t\t that[i] = 0;\n\t\t}\n\t }\n\t return that;\n\t}\n\n\t/**\n\t * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n\t * */\n\tBuffer.allocUnsafe = function (size) {\n\t return allocUnsafe(null, size);\n\t};\n\t/**\n\t * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n\t */\n\tBuffer.allocUnsafeSlow = function (size) {\n\t return allocUnsafe(null, size);\n\t};\n\n\tfunction fromString(that, string, encoding) {\n\t if (typeof encoding !== 'string' || encoding === '') {\n\t\tencoding = 'utf8';\n\t }\n\n\t if (!Buffer.isEncoding(encoding)) {\n\t\tthrow new TypeError('\"encoding\" must be a valid string encoding');\n\t }\n\n\t const length = byteLength(string, encoding) | 0;\n\t that = createBuffer(that, length);\n\n\t const actual = that.write(string, encoding);\n\n\t if (actual !== length) {\n\t\t// Writing a hex string, for example, that contains invalid characters will\n\t\t// cause everything after the first invalid character to be ignored. (e.g.\n\t\t// 'abxxcd' will be treated as 'ab')\n\t\tthat = that.slice(0, actual);\n\t }\n\n\t return that;\n\t}\n\n\tfunction fromArrayLike(that, array) {\n\t const length = array.length < 0 ? 0 : checked(array.length) | 0;\n\t that = createBuffer(that, length);\n\t for (let i = 0; i < length; i += 1) {\n\t\tthat[i] = array[i] & 255;\n\t }\n\t return that;\n\t}\n\n\tfunction fromArrayBuffer(that, array, byteOffset, length) {\n\t array.byteLength; // this throws if `array` is not a valid ArrayBuffer\n\n\t if (byteOffset < 0 || array.byteLength < byteOffset) {\n\t\tthrow new RangeError('\\'offset\\' is out of bounds');\n\t }\n\n\t if (array.byteLength < byteOffset + (length || 0)) {\n\t\tthrow new RangeError('\\'length\\' is out of bounds');\n\t }\n\n\t if (byteOffset === undefined && length === undefined) {\n\t\tarray = new Uint8Array(array);\n\t } else if (length === undefined) {\n\t\tarray = new Uint8Array(array, byteOffset);\n\t } else {\n\t\tarray = new Uint8Array(array, byteOffset, length);\n\t }\n\n\t if (Buffer.TYPED_ARRAY_SUPPORT) {\n\t\t// Return an augmented `Uint8Array` instance, for best performance\n\t\tthat = array;\n\t\tthat.__proto__ = Buffer.prototype;\n\t } else {\n\t\t// Fallback: Return an object instance of the Buffer class\n\t\tthat = fromArrayLike(that, array);\n\t }\n\t return that;\n\t}\n\n\tfunction fromObject(that, obj) {\n\t if (Buffer.isBuffer(obj)) {\n\t\tconst len = checked(obj.length) | 0;\n\t\tthat = createBuffer(that, len);\n\n\t\tif (that.length === 0) {\n\t\t return that;\n\t\t}\n\n\t\tobj.copy(that, 0, 0, len);\n\t\treturn that;\n\t }\n\n\t if (obj) {\n\t\tif ((typeof ArrayBuffer !== 'undefined' &&\n\t\t\tobj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n\t\t if (typeof obj.length !== 'number' || isnan(obj.length)) {\n\t\t\treturn createBuffer(that, 0);\n\t\t }\n\t\t return fromArrayLike(that, obj);\n\t\t}\n\n\t\tif (obj.type === 'Buffer' && isArray(obj.data)) {\n\t\t return fromArrayLike(that, obj.data);\n\t\t}\n\t }\n\n\t throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.');\n\t}\n\n\tfunction checked(length) {\n\t // Note: cannot use `length < kMaxLength()` here because that fails when\n\t // length is NaN (which is otherwise coerced to zero.)\n\t if (length >= kMaxLength()) {\n\t\tthrow new RangeError('Attempt to allocate Buffer larger than maximum ' +\n\t\t\t\t\t\t\t 'size: 0x' + kMaxLength().toString(16) + ' bytes');\n\t }\n\t return length | 0;\n\t}\n\n\tfunction SlowBuffer(length) {\n\t if (+length != length) { // eslint-disable-line eqeqeq\n\t\tlength = 0;\n\t }\n\t return Buffer.alloc(+length);\n\t}\n\n\tBuffer.isBuffer = function isBuffer(b) {\n\t return !!(b != null && b._isBuffer);\n\t};\n\n\tBuffer.compare = function compare(a, b) {\n\t if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n\t\tthrow new TypeError('Arguments must be Buffers');\n\t }\n\n\t if (a === b) {\n return 0;\n}\n\n\t let x = a.length;\n\t let y = b.length;\n\n\t for (let i = 0, len = Math.min(x, y); i < len; ++i) {\n\t\tif (a[i] !== b[i]) {\n\t\t x = a[i];\n\t\t y = b[i];\n\t\t break;\n\t\t}\n\t }\n\n\t if (x < y) {\n return -1;\n}\n\t if (y < x) {\n return 1;\n}\n\t return 0;\n\t};\n\n\tBuffer.isEncoding = function isEncoding(encoding) {\n\t switch (String(encoding).toLowerCase()) {\n\t\tcase 'hex':\n\t\tcase 'utf8':\n\t\tcase 'utf-8':\n\t\tcase 'ascii':\n\t\tcase 'latin1':\n\t\tcase 'binary':\n\t\tcase 'base64':\n\t\tcase 'ucs2':\n\t\tcase 'ucs-2':\n\t\tcase 'utf16le':\n\t\tcase 'utf-16le':\n\t\t return true;\n\t\tdefault:\n\t\t return false;\n\t }\n\t};\n\n\tBuffer.concat = function concat(list, length) {\n\t if (!isArray(list)) {\n\t\tthrow new TypeError('\"list\" argument must be an Array of Buffers');\n\t }\n\n\t if (list.length === 0) {\n\t\treturn Buffer.alloc(0);\n\t }\n\n\t let i;\n\t if (length === undefined) {\n\t\tlength = 0;\n\t\tfor (i = 0; i < list.length; ++i) {\n\t\t length += list[i].length;\n\t\t}\n\t }\n\n\t const buffer = Buffer.allocUnsafe(length);\n\t let pos = 0;\n\t for (i = 0; i < list.length; ++i) {\n\t\tconst buf = list[i];\n\t\tif (!Buffer.isBuffer(buf)) {\n\t\t throw new TypeError('\"list\" argument must be an Array of Buffers');\n\t\t}\n\t\tbuf.copy(buffer, pos);\n\t\tpos += buf.length;\n\t }\n\t return buffer;\n\t};\n\n\tfunction byteLength(string, encoding) {\n\t if (Buffer.isBuffer(string)) {\n\t\treturn string.length;\n\t }\n\t if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n\t\t (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n\t\treturn string.byteLength;\n\t }\n\t if (typeof string !== 'string') {\n\t\tstring = '' + string;\n\t }\n\n\t const len = string.length;\n\t if (len === 0) {\n return 0;\n}\n\n\t // Use a for loop to avoid recursion\n\t let loweredCase = false;\n\t for (;;) {\n\t\tswitch (encoding) {\n\t\t case 'ascii':\n\t\t case 'latin1':\n\t\t case 'binary':\n\t\t\treturn len;\n\t\t case 'utf8':\n\t\t case 'utf-8':\n\t\t case undefined:\n\t\t\treturn utf8ToBytes(string).length;\n\t\t case 'ucs2':\n\t\t case 'ucs-2':\n\t\t case 'utf16le':\n\t\t case 'utf-16le':\n\t\t\treturn len * 2;\n\t\t case 'hex':\n\t\t\treturn len >>> 1;\n\t\t case 'base64':\n\t\t\treturn base64ToBytes(string).length;\n\t\t default:\n\t\t\tif (loweredCase) {\n return utf8ToBytes(string).length;\n} // assume utf8\n\t\t\tencoding = ('' + encoding).toLowerCase();\n\t\t\tloweredCase = true;\n\t\t}\n\t }\n\t}\n\tBuffer.byteLength = byteLength;\n\n\tfunction slowToString(encoding, start, end) {\n\t let loweredCase = false;\n\n\t // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n\t // property of a typed array.\n\n\t // This behaves neither like String nor Uint8Array in that we set start/end\n\t // to their upper/lower bounds if the value passed is out of range.\n\t // undefined is handled specially as per ECMA-262 6th Edition,\n\t // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n\t if (start === undefined || start < 0) {\n\t\tstart = 0;\n\t }\n\t // Return early if start > this.length. Done here to prevent potential uint32\n\t // coercion fail below.\n\t if (start > this.length) {\n\t\treturn '';\n\t }\n\n\t if (end === undefined || end > this.length) {\n\t\tend = this.length;\n\t }\n\n\t if (end <= 0) {\n\t\treturn '';\n\t }\n\n\t // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n\t end >>>= 0;\n\t start >>>= 0;\n\n\t if (end <= start) {\n\t\treturn '';\n\t }\n\n\t if (!encoding) {\n encoding = 'utf8';\n}\n\n\t while (true) {\n\t\tswitch (encoding) {\n\t\t case 'hex':\n\t\t\treturn hexSlice(this, start, end);\n\n\t\t case 'utf8':\n\t\t case 'utf-8':\n\t\t\treturn utf8Slice(this, start, end);\n\n\t\t case 'ascii':\n\t\t\treturn asciiSlice(this, start, end);\n\n\t\t case 'latin1':\n\t\t case 'binary':\n\t\t\treturn latin1Slice(this, start, end);\n\n\t\t case 'base64':\n\t\t\treturn base64Slice(this, start, end);\n\n\t\t case 'ucs2':\n\t\t case 'ucs-2':\n\t\t case 'utf16le':\n\t\t case 'utf-16le':\n\t\t\treturn utf16leSlice(this, start, end);\n\n\t\t default:\n\t\t\tif (loweredCase) {\n throw new TypeError('Unknown encoding: ' + encoding);\n}\n\t\t\tencoding = (encoding + '').toLowerCase();\n\t\t\tloweredCase = true;\n\t\t}\n\t }\n\t}\n\n\t// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n\t// Buffer instances.\n\tBuffer.prototype._isBuffer = true;\n\n\tfunction swap(b, n, m) {\n\t const i = b[n];\n\t b[n] = b[m];\n\t b[m] = i;\n\t}\n\n\tBuffer.prototype.swap16 = function swap16() {\n\t const len = this.length;\n\t if (len % 2 !== 0) {\n\t\tthrow new RangeError('Buffer size must be a multiple of 16-bits');\n\t }\n\t for (let i = 0; i < len; i += 2) {\n\t\tswap(this, i, i + 1);\n\t }\n\t return this;\n\t};\n\n\tBuffer.prototype.swap32 = function swap32() {\n\t const len = this.length;\n\t if (len % 4 !== 0) {\n\t\tthrow new RangeError('Buffer size must be a multiple of 32-bits');\n\t }\n\t for (let i = 0; i < len; i += 4) {\n\t\tswap(this, i, i + 3);\n\t\tswap(this, i + 1, i + 2);\n\t }\n\t return this;\n\t};\n\n\tBuffer.prototype.swap64 = function swap64() {\n\t const len = this.length;\n\t if (len % 8 !== 0) {\n\t\tthrow new RangeError('Buffer size must be a multiple of 64-bits');\n\t }\n\t for (let i = 0; i < len; i += 8) {\n\t\tswap(this, i, i + 7);\n\t\tswap(this, i + 1, i + 6);\n\t\tswap(this, i + 2, i + 5);\n\t\tswap(this, i + 3, i + 4);\n\t }\n\t return this;\n\t};\n\n\tBuffer.prototype.toString = function toString() {\n\t const length = this.length | 0;\n\t if (length === 0) {\n return '';\n}\n\t if (arguments.length === 0) {\n return utf8Slice(this, 0, length);\n}\n\t return slowToString.apply(this, arguments);\n\t};\n\n\tBuffer.prototype.equals = function equals(b) {\n\t if (!Buffer.isBuffer(b)) {\n throw new TypeError('Argument must be a Buffer');\n}\n\t if (this === b) {\n return true;\n}\n\t return Buffer.compare(this, b) === 0;\n\t};\n\n\tBuffer.prototype.inspect = function inspect() {\n\t let str = '';\n\t const max = exports.INSPECT_MAX_BYTES;\n\t if (this.length > 0) {\n\t\tstr = this.toString('hex', 0, max).match(/.{2}/g).join(' ');\n\t\tif (this.length > max) {\n str += ' ... ';\n}\n\t }\n\t return '';\n\t};\n\n\tBuffer.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {\n\t if (!Buffer.isBuffer(target)) {\n\t\tthrow new TypeError('Argument must be a Buffer');\n\t }\n\n\t if (start === undefined) {\n\t\tstart = 0;\n\t }\n\t if (end === undefined) {\n\t\tend = target ? target.length : 0;\n\t }\n\t if (thisStart === undefined) {\n\t\tthisStart = 0;\n\t }\n\t if (thisEnd === undefined) {\n\t\tthisEnd = this.length;\n\t }\n\n\t if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n\t\tthrow new RangeError('out of range index');\n\t }\n\n\t if (thisStart >= thisEnd && start >= end) {\n\t\treturn 0;\n\t }\n\t if (thisStart >= thisEnd) {\n\t\treturn -1;\n\t }\n\t if (start >= end) {\n\t\treturn 1;\n\t }\n\n\t start >>>= 0;\n\t end >>>= 0;\n\t thisStart >>>= 0;\n\t thisEnd >>>= 0;\n\n\t if (this === target) {\n return 0;\n}\n\n\t let x = thisEnd - thisStart;\n\t let y = end - start;\n\t const len = Math.min(x, y);\n\n\t const thisCopy = this.slice(thisStart, thisEnd);\n\t const targetCopy = target.slice(start, end);\n\n\t for (let i = 0; i < len; ++i) {\n\t\tif (thisCopy[i] !== targetCopy[i]) {\n\t\t x = thisCopy[i];\n\t\t y = targetCopy[i];\n\t\t break;\n\t\t}\n\t }\n\n\t if (x < y) {\n return -1;\n}\n\t if (y < x) {\n return 1;\n}\n\t return 0;\n\t};\n\n\t// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n\t// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n\t//\n\t// Arguments:\n\t// - buffer - a Buffer to search\n\t// - val - a string, Buffer, or number\n\t// - byteOffset - an index into `buffer`; will be clamped to an int32\n\t// - encoding - an optional encoding, relevant is val is a string\n\t// - dir - true for indexOf, false for lastIndexOf\n\tfunction bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {\n\t // Empty buffer means no match\n\t if (buffer.length === 0) {\n return -1;\n}\n\n\t // Normalize byteOffset\n\t if (typeof byteOffset === 'string') {\n\t\tencoding = byteOffset;\n\t\tbyteOffset = 0;\n\t } else if (byteOffset > 0x7fffffff) {\n\t\tbyteOffset = 0x7fffffff;\n\t } else if (byteOffset < -0x80000000) {\n\t\tbyteOffset = -0x80000000;\n\t }\n\t byteOffset = +byteOffset; // Coerce to Number.\n\t if (isNaN(byteOffset)) {\n\t\t// byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n\t\tbyteOffset = dir ? 0 : (buffer.length - 1);\n\t }\n\n\t // Normalize byteOffset: negative offsets start from the end of the buffer\n\t if (byteOffset < 0) {\n byteOffset = buffer.length + byteOffset;\n}\n\t if (byteOffset >= buffer.length) {\n\t\tif (dir) {\n return -1;\n}\n\t\tbyteOffset = buffer.length - 1;\n\t } else if (byteOffset < 0) {\n\t\tif (dir) {\n byteOffset = 0;\n} else {\n return -1;\n}\n\t }\n\n\t // Normalize val\n\t if (typeof val === 'string') {\n\t\tval = Buffer.from(val, encoding);\n\t }\n\n\t // Finally, search either indexOf (if dir is true) or lastIndexOf\n\t if (Buffer.isBuffer(val)) {\n\t\t// Special case: looking for empty string/buffer always fails\n\t\tif (val.length === 0) {\n\t\t return -1;\n\t\t}\n\t\treturn arrayIndexOf(buffer, val, byteOffset, encoding, dir);\n\t } else if (typeof val === 'number') {\n\t\tval &= 0xFF; // Search for a byte value [0-255]\n\t\tif (Buffer.TYPED_ARRAY_SUPPORT &&\n\t\t\ttypeof Uint8Array.prototype.indexOf === 'function') {\n\t\t if (dir) {\n\t\t\treturn Uint8Array.prototype.indexOf.call(buffer, val, byteOffset);\n\t\t }\n\t\t\treturn Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);\n\t\t}\n\t\treturn arrayIndexOf(buffer, [val], byteOffset, encoding, dir);\n\t }\n\n\t throw new TypeError('val must be string, number or Buffer');\n\t}\n\n\tfunction arrayIndexOf(arr, val, byteOffset, encoding, dir) {\n\t let indexSize = 1;\n\t let arrLength = arr.length;\n\t let valLength = val.length;\n\n\t if (encoding !== undefined) {\n\t\tencoding = String(encoding).toLowerCase();\n\t\tif (encoding === 'ucs2' || encoding === 'ucs-2' ||\n\t\t\tencoding === 'utf16le' || encoding === 'utf-16le') {\n\t\t if (arr.length < 2 || val.length < 2) {\n\t\t\treturn -1;\n\t\t }\n\t\t indexSize = 2;\n\t\t arrLength /= 2;\n\t\t valLength /= 2;\n\t\t byteOffset /= 2;\n\t\t}\n\t }\n\n\t function read(buf, i) {\n\t\tif (indexSize === 1) {\n\t\t return buf[i];\n\t\t}\n\t\t return buf.readUInt16BE(i * indexSize);\n\t }\n\n\t let i;\n\t if (dir) {\n\t\tlet foundIndex = -1;\n\t\tfor (i = byteOffset; i < arrLength; i++) {\n\t\t if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n\t\t\tif (foundIndex === -1) {\n foundIndex = i;\n}\n\t\t\tif (i - foundIndex + 1 === valLength) {\n return foundIndex * indexSize;\n}\n\t\t } else {\n\t\t\tif (foundIndex !== -1) {\n i -= i - foundIndex;\n}\n\t\t\tfoundIndex = -1;\n\t\t }\n\t\t}\n\t } else {\n\t\tif (byteOffset + valLength > arrLength) {\n byteOffset = arrLength - valLength;\n}\n\t\tfor (i = byteOffset; i >= 0; i--) {\n\t\t let found = true;\n\t\t for (let j = 0; j < valLength; j++) {\n\t\t\tif (read(arr, i + j) !== read(val, j)) {\n\t\t\t found = false;\n\t\t\t break;\n\t\t\t}\n\t\t }\n\t\t if (found) {\n return i;\n}\n\t\t}\n\t }\n\n\t return -1;\n\t}\n\n\tBuffer.prototype.includes = function includes(val, byteOffset, encoding) {\n\t return this.indexOf(val, byteOffset, encoding) !== -1;\n\t};\n\n\tBuffer.prototype.indexOf = function indexOf(val, byteOffset, encoding) {\n\t return bidirectionalIndexOf(this, val, byteOffset, encoding, true);\n\t};\n\n\tBuffer.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {\n\t return bidirectionalIndexOf(this, val, byteOffset, encoding, false);\n\t};\n\n\tfunction hexWrite(buf, string, offset, length) {\n\t offset = Number(offset) || 0;\n\t const remaining = buf.length - offset;\n\t if (!length) {\n\t\tlength = remaining;\n\t } else {\n\t\tlength = Number(length);\n\t\tif (length > remaining) {\n\t\t length = remaining;\n\t\t}\n\t }\n\n\t // must be an even number of digits\n\t const strLen = string.length;\n\t if (strLen % 2 !== 0) {\n throw new TypeError('Invalid hex string');\n}\n\n\t if (length > strLen / 2) {\n\t\tlength = strLen / 2;\n\t }\n\t for (var i = 0; i < length; ++i) {\n\t\tconst parsed = parseInt(string.substr(i * 2, 2), 16);\n\t\tif (isNaN(parsed)) {\n return i;\n}\n\t\tbuf[offset + i] = parsed;\n\t }\n\t return i;\n\t}\n\n\tfunction utf8Write(buf, string, offset, length) {\n\t return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);\n\t}\n\n\tfunction asciiWrite(buf, string, offset, length) {\n\t return blitBuffer(asciiToBytes(string), buf, offset, length);\n\t}\n\n\tfunction latin1Write(buf, string, offset, length) {\n\t return asciiWrite(buf, string, offset, length);\n\t}\n\n\tfunction base64Write(buf, string, offset, length) {\n\t return blitBuffer(base64ToBytes(string), buf, offset, length);\n\t}\n\n\tfunction ucs2Write(buf, string, offset, length) {\n\t return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);\n\t}\n\n\tBuffer.prototype.write = function write(string, offset, length, encoding) {\n\t // Buffer#write(string)\n\t if (offset === undefined) {\n\t\tencoding = 'utf8';\n\t\tlength = this.length;\n\t\toffset = 0;\n\t // Buffer#write(string, encoding)\n\t } else if (length === undefined && typeof offset === 'string') {\n\t\tencoding = offset;\n\t\tlength = this.length;\n\t\toffset = 0;\n\t // Buffer#write(string, offset[, length][, encoding])\n\t } else if (isFinite(offset)) {\n\t\toffset |= 0;\n\t\tif (isFinite(length)) {\n\t\t length |= 0;\n\t\t if (encoding === undefined) {\n encoding = 'utf8';\n}\n\t\t} else {\n\t\t encoding = length;\n\t\t length = undefined;\n\t\t}\n\t // legacy write(string, encoding, offset, length) - remove in v0.13\n\t } else {\n\t\tthrow new Error(\n\t\t 'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n\t\t);\n\t }\n\n\t const remaining = this.length - offset;\n\t if (length === undefined || length > remaining) {\n length = remaining;\n}\n\n\t if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n\t\tthrow new RangeError('Attempt to write outside buffer bounds');\n\t }\n\n\t if (!encoding) {\n encoding = 'utf8';\n}\n\n\t let loweredCase = false;\n\t for (;;) {\n\t\tswitch (encoding) {\n\t\t case 'hex':\n\t\t\treturn hexWrite(this, string, offset, length);\n\n\t\t case 'utf8':\n\t\t case 'utf-8':\n\t\t\treturn utf8Write(this, string, offset, length);\n\n\t\t case 'ascii':\n\t\t\treturn asciiWrite(this, string, offset, length);\n\n\t\t case 'latin1':\n\t\t case 'binary':\n\t\t\treturn latin1Write(this, string, offset, length);\n\n\t\t case 'base64':\n\t\t\t// Warning: maxLength not taken into account in base64Write\n\t\t\treturn base64Write(this, string, offset, length);\n\n\t\t case 'ucs2':\n\t\t case 'ucs-2':\n\t\t case 'utf16le':\n\t\t case 'utf-16le':\n\t\t\treturn ucs2Write(this, string, offset, length);\n\n\t\t default:\n\t\t\tif (loweredCase) {\n throw new TypeError('Unknown encoding: ' + encoding);\n}\n\t\t\tencoding = ('' + encoding).toLowerCase();\n\t\t\tloweredCase = true;\n\t\t}\n\t }\n\t};\n\n\tBuffer.prototype.toJSON = function toJSON() {\n\t return {\n\t\ttype: 'Buffer',\n\t\tdata: Array.prototype.slice.call(this._arr || this, 0)\n\t };\n\t};\n\n\tfunction base64Slice(buf, start, end) {\n\t if (start === 0 && end === buf.length) {\n\t\treturn base64.fromByteArray(buf);\n\t }\n\t\treturn base64.fromByteArray(buf.slice(start, end));\n\t}\n\n\tfunction utf8Slice(buf, start, end) {\n\t end = Math.min(buf.length, end);\n\t const res = [];\n\n\t let i = start;\n\t while (i < end) {\n\t\tconst firstByte = buf[i];\n\t\tlet codePoint = null;\n\t\tlet bytesPerSequence = (firstByte > 0xEF) ? 4\n\t\t : (firstByte > 0xDF) ? 3\n\t\t : (firstByte > 0xBF) ? 2\n\t\t : 1;\n\n\t\tif (i + bytesPerSequence <= end) {\n\t\t var secondByte, thirdByte, fourthByte, tempCodePoint;\n\n\t\t switch (bytesPerSequence) {\n\t\t\tcase 1:\n\t\t\t if (firstByte < 0x80) {\n\t\t\t\tcodePoint = firstByte;\n\t\t\t }\n\t\t\t break;\n\t\t\tcase 2:\n\t\t\t secondByte = buf[i + 1];\n\t\t\t if ((secondByte & 0xC0) === 0x80) {\n\t\t\t\ttempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F);\n\t\t\t\tif (tempCodePoint > 0x7F) {\n\t\t\t\t codePoint = tempCodePoint;\n\t\t\t\t}\n\t\t\t }\n\t\t\t break;\n\t\t\tcase 3:\n\t\t\t secondByte = buf[i + 1];\n\t\t\t thirdByte = buf[i + 2];\n\t\t\t if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n\t\t\t\ttempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F);\n\t\t\t\tif (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n\t\t\t\t codePoint = tempCodePoint;\n\t\t\t\t}\n\t\t\t }\n\t\t\t break;\n\t\t\tcase 4:\n\t\t\t secondByte = buf[i + 1];\n\t\t\t thirdByte = buf[i + 2];\n\t\t\t fourthByte = buf[i + 3];\n\t\t\t if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n\t\t\t\ttempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F);\n\t\t\t\tif (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n\t\t\t\t codePoint = tempCodePoint;\n\t\t\t\t}\n\t\t\t }\n\t\t }\n\t\t}\n\n\t\tif (codePoint === null) {\n\t\t // we did not generate a valid codePoint so insert a\n\t\t // replacement char (U+FFFD) and advance only 1 byte\n\t\t codePoint = 0xFFFD;\n\t\t bytesPerSequence = 1;\n\t\t} else if (codePoint > 0xFFFF) {\n\t\t // encode to utf16 (surrogate pair dance)\n\t\t codePoint -= 0x10000;\n\t\t res.push(codePoint >>> 10 & 0x3FF | 0xD800);\n\t\t codePoint = 0xDC00 | codePoint & 0x3FF;\n\t\t}\n\n\t\tres.push(codePoint);\n\t\ti += bytesPerSequence;\n\t }\n\n\t return decodeCodePointsArray(res);\n\t}\n\n\t// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n\t// the lowest limit is Chrome, with 0x10000 args.\n\t// We go 1 magnitude less, for safety\n\tconst MAX_ARGUMENTS_LENGTH = 0x1000;\n\n\tfunction decodeCodePointsArray(codePoints) {\n\t const len = codePoints.length;\n\t if (len <= MAX_ARGUMENTS_LENGTH) {\n\t\treturn String.fromCharCode.apply(String, codePoints); // avoid extra slice()\n\t }\n\n\t // Decode in chunks to avoid \"call stack size exceeded\".\n\t let res = '';\n\t let i = 0;\n\t while (i < len) {\n\t\tres += String.fromCharCode.apply(\n\t\t String,\n\t\t codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n\t\t);\n\t }\n\t return res;\n\t}\n\n\tfunction asciiSlice(buf, start, end) {\n\t let ret = '';\n\t end = Math.min(buf.length, end);\n\n\t for (let i = start; i < end; ++i) {\n\t\tret += String.fromCharCode(buf[i] & 0x7F);\n\t }\n\t return ret;\n\t}\n\n\tfunction latin1Slice(buf, start, end) {\n\t let ret = '';\n\t end = Math.min(buf.length, end);\n\n\t for (let i = start; i < end; ++i) {\n\t\tret += String.fromCharCode(buf[i]);\n\t }\n\t return ret;\n\t}\n\n\tfunction hexSlice(buf, start, end) {\n\t const len = buf.length;\n\n\t if (!start || start < 0) {\n start = 0;\n}\n\t if (!end || end < 0 || end > len) {\n end = len;\n}\n\n\t let out = '';\n\t for (let i = start; i < end; ++i) {\n\t\tout += toHex(buf[i]);\n\t }\n\t return out;\n\t}\n\n\tfunction utf16leSlice(buf, start, end) {\n\t const bytes = buf.slice(start, end);\n\t let res = '';\n\t for (let i = 0; i < bytes.length; i += 2) {\n\t\tres += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);\n\t }\n\t return res;\n\t}\n\n\tBuffer.prototype.slice = function slice(start, end) {\n\t const len = this.length;\n\t start = ~~start;\n\t end = end === undefined ? len : ~~end;\n\n\t if (start < 0) {\n\t\tstart += len;\n\t\tif (start < 0) {\n start = 0;\n}\n\t } else if (start > len) {\n\t\tstart = len;\n\t }\n\n\t if (end < 0) {\n\t\tend += len;\n\t\tif (end < 0) {\n end = 0;\n}\n\t } else if (end > len) {\n\t\tend = len;\n\t }\n\n\t if (end < start) {\n end = start;\n}\n\n\t let newBuf;\n\t if (Buffer.TYPED_ARRAY_SUPPORT) {\n\t\tnewBuf = this.subarray(start, end);\n\t\tnewBuf.__proto__ = Buffer.prototype;\n\t } else {\n\t\tconst sliceLen = end - start;\n\t\tnewBuf = new Buffer(sliceLen, undefined);\n\t\tfor (let i = 0; i < sliceLen; ++i) {\n\t\t newBuf[i] = this[i + start];\n\t\t}\n\t }\n\n\t return newBuf;\n\t};\n\n\t/*\n\t * Need to make sure that buffer isn't trying to write out of bounds.\n\t */\n\tfunction checkOffset(offset, ext, length) {\n\t if ((offset % 1) !== 0 || offset < 0) {\n throw new RangeError('offset is not uint');\n}\n\t if (offset + ext > length) {\n throw new RangeError('Trying to access beyond buffer length');\n}\n\t}\n\n\tBuffer.prototype.readUIntLE = function readUIntLE(offset, byteLength, noAssert) {\n\t offset |= 0;\n\t byteLength |= 0;\n\t if (!noAssert) {\n checkOffset(offset, byteLength, this.length);\n}\n\n\t let val = this[offset];\n\t let mul = 1;\n\t let i = 0;\n\t while (++i < byteLength && (mul *= 0x100)) {\n\t\tval += this[offset + i] * mul;\n\t }\n\n\t return val;\n\t};\n\n\tBuffer.prototype.readUIntBE = function readUIntBE(offset, byteLength, noAssert) {\n\t offset |= 0;\n\t byteLength |= 0;\n\t if (!noAssert) {\n\t\tcheckOffset(offset, byteLength, this.length);\n\t }\n\n\t let val = this[offset + --byteLength];\n\t let mul = 1;\n\t while (byteLength > 0 && (mul *= 0x100)) {\n\t\tval += this[offset + --byteLength] * mul;\n\t }\n\n\t return val;\n\t};\n\n\tBuffer.prototype.readUInt8 = function readUInt8(offset, noAssert) {\n\t if (!noAssert) {\n checkOffset(offset, 1, this.length);\n}\n\t return this[offset];\n\t};\n\n\tBuffer.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {\n\t if (!noAssert) {\n checkOffset(offset, 2, this.length);\n}\n\t return this[offset] | (this[offset + 1] << 8);\n\t};\n\n\tBuffer.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {\n\t if (!noAssert) {\n checkOffset(offset, 2, this.length);\n}\n\t return (this[offset] << 8) | this[offset + 1];\n\t};\n\n\tBuffer.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {\n\t if (!noAssert) {\n checkOffset(offset, 4, this.length);\n}\n\n\t return ((this[offset]) |\n\t\t (this[offset + 1] << 8) |\n\t\t (this[offset + 2] << 16)) +\n\t\t (this[offset + 3] * 0x1000000);\n\t};\n\n\tBuffer.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {\n\t if (!noAssert) {\n checkOffset(offset, 4, this.length);\n}\n\n\t return (this[offset] * 0x1000000) +\n\t\t((this[offset + 1] << 16) |\n\t\t(this[offset + 2] << 8) |\n\t\tthis[offset + 3]);\n\t};\n\n\tBuffer.prototype.readIntLE = function readIntLE(offset, byteLength, noAssert) {\n\t offset |= 0;\n\t byteLength |= 0;\n\t if (!noAssert) {\n checkOffset(offset, byteLength, this.length);\n}\n\n\t let val = this[offset];\n\t let mul = 1;\n\t let i = 0;\n\t while (++i < byteLength && (mul *= 0x100)) {\n\t\tval += this[offset + i] * mul;\n\t }\n\t mul *= 0x80;\n\n\t if (val >= mul) {\n val -= Math.pow(2, 8 * byteLength);\n}\n\n\t return val;\n\t};\n\n\tBuffer.prototype.readIntBE = function readIntBE(offset, byteLength, noAssert) {\n\t offset |= 0;\n\t byteLength |= 0;\n\t if (!noAssert) {\n checkOffset(offset, byteLength, this.length);\n}\n\n\t let i = byteLength;\n\t let mul = 1;\n\t let val = this[offset + --i];\n\t while (i > 0 && (mul *= 0x100)) {\n\t\tval += this[offset + --i] * mul;\n\t }\n\t mul *= 0x80;\n\n\t if (val >= mul) {\n val -= Math.pow(2, 8 * byteLength);\n}\n\n\t return val;\n\t};\n\n\tBuffer.prototype.readInt8 = function readInt8(offset, noAssert) {\n\t if (!noAssert) {\n checkOffset(offset, 1, this.length);\n}\n\t if (!(this[offset] & 0x80)) {\n return (this[offset]);\n}\n\t return ((0xff - this[offset] + 1) * -1);\n\t};\n\n\tBuffer.prototype.readInt16LE = function readInt16LE(offset, noAssert) {\n\t if (!noAssert) {\n checkOffset(offset, 2, this.length);\n}\n\t const val = this[offset] | (this[offset + 1] << 8);\n\t return (val & 0x8000) ? val | 0xFFFF0000 : val;\n\t};\n\n\tBuffer.prototype.readInt16BE = function readInt16BE(offset, noAssert) {\n\t if (!noAssert) {\n checkOffset(offset, 2, this.length);\n}\n\t const val = this[offset + 1] | (this[offset] << 8);\n\t return (val & 0x8000) ? val | 0xFFFF0000 : val;\n\t};\n\n\tBuffer.prototype.readInt32LE = function readInt32LE(offset, noAssert) {\n\t if (!noAssert) {\n checkOffset(offset, 4, this.length);\n}\n\n\t return (this[offset]) |\n\t\t(this[offset + 1] << 8) |\n\t\t(this[offset + 2] << 16) |\n\t\t(this[offset + 3] << 24);\n\t};\n\n\tBuffer.prototype.readInt32BE = function readInt32BE(offset, noAssert) {\n\t if (!noAssert) {\n checkOffset(offset, 4, this.length);\n}\n\n\t return (this[offset] << 24) |\n\t\t(this[offset + 1] << 16) |\n\t\t(this[offset + 2] << 8) |\n\t\t(this[offset + 3]);\n\t};\n\n\tBuffer.prototype.readFloatLE = function readFloatLE(offset, noAssert) {\n\t if (!noAssert) {\n checkOffset(offset, 4, this.length);\n}\n\t return ieee754.read(this, offset, true, 23, 4);\n\t};\n\n\tBuffer.prototype.readFloatBE = function readFloatBE(offset, noAssert) {\n\t if (!noAssert) {\n checkOffset(offset, 4, this.length);\n}\n\t return ieee754.read(this, offset, false, 23, 4);\n\t};\n\n\tBuffer.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {\n\t if (!noAssert) {\n checkOffset(offset, 8, this.length);\n}\n\t return ieee754.read(this, offset, true, 52, 8);\n\t};\n\n\tBuffer.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {\n\t if (!noAssert) {\n checkOffset(offset, 8, this.length);\n}\n\t return ieee754.read(this, offset, false, 52, 8);\n\t};\n\n\tfunction checkInt(buf, value, offset, ext, max, min) {\n\t if (!Buffer.isBuffer(buf)) {\n throw new TypeError('\"buffer\" argument must be a Buffer instance');\n}\n\t if (value > max || value < min) {\n throw new RangeError('\"value\" argument is out of bounds');\n}\n\t if (offset + ext > buf.length) {\n throw new RangeError('Index out of range');\n}\n\t}\n\n\tBuffer.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength, noAssert) {\n\t value = +value;\n\t offset |= 0;\n\t byteLength |= 0;\n\t if (!noAssert) {\n\t\tconst maxBytes = Math.pow(2, 8 * byteLength) - 1;\n\t\tcheckInt(this, value, offset, byteLength, maxBytes, 0);\n\t }\n\n\t let mul = 1;\n\t let i = 0;\n\t this[offset] = value & 0xFF;\n\t while (++i < byteLength && (mul *= 0x100)) {\n\t\tthis[offset + i] = (value / mul) & 0xFF;\n\t }\n\n\t return offset + byteLength;\n\t};\n\n\tBuffer.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength, noAssert) {\n\t value = +value;\n\t offset |= 0;\n\t byteLength |= 0;\n\t if (!noAssert) {\n\t\tconst maxBytes = Math.pow(2, 8 * byteLength) - 1;\n\t\tcheckInt(this, value, offset, byteLength, maxBytes, 0);\n\t }\n\n\t let i = byteLength - 1;\n\t let mul = 1;\n\t this[offset + i] = value & 0xFF;\n\t while (--i >= 0 && (mul *= 0x100)) {\n\t\tthis[offset + i] = (value / mul) & 0xFF;\n\t }\n\n\t return offset + byteLength;\n\t};\n\n\tBuffer.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {\n\t value = +value;\n\t offset |= 0;\n\t if (!noAssert) {\n checkInt(this, value, offset, 1, 0xff, 0);\n}\n\t if (!Buffer.TYPED_ARRAY_SUPPORT) {\n value = Math.floor(value);\n}\n\t this[offset] = (value & 0xff);\n\t return offset + 1;\n\t};\n\n\tfunction objectWriteUInt16(buf, value, offset, littleEndian) {\n\t if (value < 0) {\n value = 0xffff + value + 1;\n}\n\t for (let i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n\t\tbuf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n\t\t (littleEndian ? i : 1 - i) * 8;\n\t }\n\t}\n\n\tBuffer.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {\n\t value = +value;\n\t offset |= 0;\n\t if (!noAssert) {\n checkInt(this, value, offset, 2, 0xffff, 0);\n}\n\t if (Buffer.TYPED_ARRAY_SUPPORT) {\n\t\tthis[offset] = (value & 0xff);\n\t\tthis[offset + 1] = (value >>> 8);\n\t } else {\n\t\tobjectWriteUInt16(this, value, offset, true);\n\t }\n\t return offset + 2;\n\t};\n\n\tBuffer.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {\n\t value = +value;\n\t offset |= 0;\n\t if (!noAssert) {\n checkInt(this, value, offset, 2, 0xffff, 0);\n}\n\t if (Buffer.TYPED_ARRAY_SUPPORT) {\n\t\tthis[offset] = (value >>> 8);\n\t\tthis[offset + 1] = (value & 0xff);\n\t } else {\n\t\tobjectWriteUInt16(this, value, offset, false);\n\t }\n\t return offset + 2;\n\t};\n\n\tfunction objectWriteUInt32(buf, value, offset, littleEndian) {\n\t if (value < 0) {\n value = 0xffffffff + value + 1;\n}\n\t for (let i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n\t\tbuf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff;\n\t }\n\t}\n\n\tBuffer.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {\n\t value = +value;\n\t offset |= 0;\n\t if (!noAssert) {\n checkInt(this, value, offset, 4, 0xffffffff, 0);\n}\n\t if (Buffer.TYPED_ARRAY_SUPPORT) {\n\t\tthis[offset + 3] = (value >>> 24);\n\t\tthis[offset + 2] = (value >>> 16);\n\t\tthis[offset + 1] = (value >>> 8);\n\t\tthis[offset] = (value & 0xff);\n\t } else {\n\t\tobjectWriteUInt32(this, value, offset, true);\n\t }\n\t return offset + 4;\n\t};\n\n\tBuffer.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {\n\t value = +value;\n\t offset |= 0;\n\t if (!noAssert) {\n checkInt(this, value, offset, 4, 0xffffffff, 0);\n}\n\t if (Buffer.TYPED_ARRAY_SUPPORT) {\n\t\tthis[offset] = (value >>> 24);\n\t\tthis[offset + 1] = (value >>> 16);\n\t\tthis[offset + 2] = (value >>> 8);\n\t\tthis[offset + 3] = (value & 0xff);\n\t } else {\n\t\tobjectWriteUInt32(this, value, offset, false);\n\t }\n\t return offset + 4;\n\t};\n\n\tBuffer.prototype.writeIntLE = function writeIntLE(value, offset, byteLength, noAssert) {\n\t value = +value;\n\t offset |= 0;\n\t if (!noAssert) {\n\t\tconst limit = Math.pow(2, 8 * byteLength - 1);\n\n\t\tcheckInt(this, value, offset, byteLength, limit - 1, -limit);\n\t }\n\n\t let i = 0;\n\t let mul = 1;\n\t let sub = 0;\n\t this[offset] = value & 0xFF;\n\t while (++i < byteLength && (mul *= 0x100)) {\n\t\tif (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n\t\t sub = 1;\n\t\t}\n\t\tthis[offset + i] = ((value / mul) >> 0) - sub & 0xFF;\n\t }\n\n\t return offset + byteLength;\n\t};\n\n\tBuffer.prototype.writeIntBE = function writeIntBE(value, offset, byteLength, noAssert) {\n\t value = +value;\n\t offset |= 0;\n\t if (!noAssert) {\n\t\tconst limit = Math.pow(2, 8 * byteLength - 1);\n\n\t\tcheckInt(this, value, offset, byteLength, limit - 1, -limit);\n\t }\n\n\t let i = byteLength - 1;\n\t let mul = 1;\n\t let sub = 0;\n\t this[offset + i] = value & 0xFF;\n\t while (--i >= 0 && (mul *= 0x100)) {\n\t\tif (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n\t\t sub = 1;\n\t\t}\n\t\tthis[offset + i] = ((value / mul) >> 0) - sub & 0xFF;\n\t }\n\n\t return offset + byteLength;\n\t};\n\n\tBuffer.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {\n\t value = +value;\n\t offset |= 0;\n\t if (!noAssert) {\n checkInt(this, value, offset, 1, 0x7f, -0x80);\n}\n\t if (!Buffer.TYPED_ARRAY_SUPPORT) {\n value = Math.floor(value);\n}\n\t if (value < 0) {\n value = 0xff + value + 1;\n}\n\t this[offset] = (value & 0xff);\n\t return offset + 1;\n\t};\n\n\tBuffer.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {\n\t value = +value;\n\t offset |= 0;\n\t if (!noAssert) {\n checkInt(this, value, offset, 2, 0x7fff, -0x8000);\n}\n\t if (Buffer.TYPED_ARRAY_SUPPORT) {\n\t\tthis[offset] = (value & 0xff);\n\t\tthis[offset + 1] = (value >>> 8);\n\t } else {\n\t\tobjectWriteUInt16(this, value, offset, true);\n\t }\n\t return offset + 2;\n\t};\n\n\tBuffer.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {\n\t value = +value;\n\t offset |= 0;\n\t if (!noAssert) {\n checkInt(this, value, offset, 2, 0x7fff, -0x8000);\n}\n\t if (Buffer.TYPED_ARRAY_SUPPORT) {\n\t\tthis[offset] = (value >>> 8);\n\t\tthis[offset + 1] = (value & 0xff);\n\t } else {\n\t\tobjectWriteUInt16(this, value, offset, false);\n\t }\n\t return offset + 2;\n\t};\n\n\tBuffer.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {\n\t value = +value;\n\t offset |= 0;\n\t if (!noAssert) {\n checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);\n}\n\t if (Buffer.TYPED_ARRAY_SUPPORT) {\n\t\tthis[offset] = (value & 0xff);\n\t\tthis[offset + 1] = (value >>> 8);\n\t\tthis[offset + 2] = (value >>> 16);\n\t\tthis[offset + 3] = (value >>> 24);\n\t } else {\n\t\tobjectWriteUInt32(this, value, offset, true);\n\t }\n\t return offset + 4;\n\t};\n\n\tBuffer.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {\n\t value = +value;\n\t offset |= 0;\n\t if (!noAssert) {\n checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);\n}\n\t if (value < 0) {\n value = 0xffffffff + value + 1;\n}\n\t if (Buffer.TYPED_ARRAY_SUPPORT) {\n\t\tthis[offset] = (value >>> 24);\n\t\tthis[offset + 1] = (value >>> 16);\n\t\tthis[offset + 2] = (value >>> 8);\n\t\tthis[offset + 3] = (value & 0xff);\n\t } else {\n\t\tobjectWriteUInt32(this, value, offset, false);\n\t }\n\t return offset + 4;\n\t};\n\n\tfunction checkIEEE754(buf, value, offset, ext, max, min) {\n\t if (offset + ext > buf.length) {\n throw new RangeError('Index out of range');\n}\n\t if (offset < 0) {\n throw new RangeError('Index out of range');\n}\n\t}\n\n\tfunction writeFloat(buf, value, offset, littleEndian, noAssert) {\n\t if (!noAssert) {\n\t\tcheckIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38);\n\t }\n\t ieee754.write(buf, value, offset, littleEndian, 23, 4);\n\t return offset + 4;\n\t}\n\n\tBuffer.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {\n\t return writeFloat(this, value, offset, true, noAssert);\n\t};\n\n\tBuffer.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {\n\t return writeFloat(this, value, offset, false, noAssert);\n\t};\n\n\tfunction writeDouble(buf, value, offset, littleEndian, noAssert) {\n\t if (!noAssert) {\n\t\tcheckIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308);\n\t }\n\t ieee754.write(buf, value, offset, littleEndian, 52, 8);\n\t return offset + 8;\n\t}\n\n\tBuffer.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {\n\t return writeDouble(this, value, offset, true, noAssert);\n\t};\n\n\tBuffer.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {\n\t return writeDouble(this, value, offset, false, noAssert);\n\t};\n\n\t// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\n\tBuffer.prototype.copy = function copy(target, targetStart, start, end) {\n\t if (!start) {\n start = 0;\n}\n\t if (!end && end !== 0) {\n end = this.length;\n}\n\t if (targetStart >= target.length) {\n targetStart = target.length;\n}\n\t if (!targetStart) {\n targetStart = 0;\n}\n\t if (end > 0 && end < start) {\n end = start;\n}\n\n\t // Copy 0 bytes; we're done\n\t if (end === start) {\n return 0;\n}\n\t if (target.length === 0 || this.length === 0) {\n return 0;\n}\n\n\t // Fatal error conditions\n\t if (targetStart < 0) {\n\t\tthrow new RangeError('targetStart out of bounds');\n\t }\n\t if (start < 0 || start >= this.length) {\n throw new RangeError('sourceStart out of bounds');\n}\n\t if (end < 0) {\n throw new RangeError('sourceEnd out of bounds');\n}\n\n\t // Are we oob?\n\t if (end > this.length) {\n end = this.length;\n}\n\t if (target.length - targetStart < end - start) {\n\t\tend = target.length - targetStart + start;\n\t }\n\n\t const len = end - start;\n\t let i;\n\n\t if (this === target && start < targetStart && targetStart < end) {\n\t\t// descending copy from end\n\t\tfor (i = len - 1; i >= 0; --i) {\n\t\t target[i + targetStart] = this[i + start];\n\t\t}\n\t } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n\t\t// ascending copy from start\n\t\tfor (i = 0; i < len; ++i) {\n\t\t target[i + targetStart] = this[i + start];\n\t\t}\n\t } else {\n\t\tUint8Array.prototype.set.call(\n\t\t target,\n\t\t this.subarray(start, start + len),\n\t\t targetStart\n\t\t);\n\t }\n\n\t return len;\n\t};\n\n\t// Usage:\n\t// buffer.fill(number[, offset[, end]])\n\t// buffer.fill(buffer[, offset[, end]])\n\t// buffer.fill(string[, offset[, end]][, encoding])\n\tBuffer.prototype.fill = function fill(val, start, end, encoding) {\n\t // Handle string cases:\n\t if (typeof val === 'string') {\n\t\tif (typeof start === 'string') {\n\t\t encoding = start;\n\t\t start = 0;\n\t\t end = this.length;\n\t\t} else if (typeof end === 'string') {\n\t\t encoding = end;\n\t\t end = this.length;\n\t\t}\n\t\tif (val.length === 1) {\n\t\t const code = val.charCodeAt(0);\n\t\t if (code < 256) {\n\t\t\tval = code;\n\t\t }\n\t\t}\n\t\tif (encoding !== undefined && typeof encoding !== 'string') {\n\t\t throw new TypeError('encoding must be a string');\n\t\t}\n\t\tif (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n\t\t throw new TypeError('Unknown encoding: ' + encoding);\n\t\t}\n\t } else if (typeof val === 'number') {\n\t\tval &= 255;\n\t }\n\n\t // Invalid ranges are not set to a default, so can range check early.\n\t if (start < 0 || this.length < start || this.length < end) {\n\t\tthrow new RangeError('Out of range index');\n\t }\n\n\t if (end <= start) {\n\t\treturn this;\n\t }\n\n\t start >>>= 0;\n\t end = end === undefined ? this.length : end >>> 0;\n\n\t if (!val) {\n val = 0;\n}\n\n\t let i;\n\t if (typeof val === 'number') {\n\t\tfor (i = start; i < end; ++i) {\n\t\t this[i] = val;\n\t\t}\n\t } else {\n\t\tconst bytes = Buffer.isBuffer(val)\n\t\t ? val\n\t\t : utf8ToBytes(new Buffer(val, encoding).toString());\n\t\tconst len = bytes.length;\n\t\tfor (i = 0; i < end - start; ++i) {\n\t\t this[i + start] = bytes[i % len];\n\t\t}\n\t }\n\n\t return this;\n\t};\n\n\t// HELPER FUNCTIONS\n\t// ================\n\n\tconst INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g;\n\n\tfunction base64clean(str) {\n\t // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n\t str = stringtrim(str).replace(INVALID_BASE64_RE, '');\n\t // Node converts strings with length < 2 to ''\n\t if (str.length < 2) {\n return '';\n}\n\t // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n\t while (str.length % 4 !== 0) {\n\t\tstr += '=';\n\t }\n\t return str;\n\t}\n\n\tfunction stringtrim(str) {\n\t if (str.trim) {\n return str.trim();\n}\n\t return str.replace(/^\\s+|\\s+$/g, '');\n\t}\n\n\tfunction toHex(n) {\n\t if (n < 16) {\n return '0' + n.toString(16);\n}\n\t return n.toString(16);\n\t}\n\n\tfunction utf8ToBytes(string, units) {\n\t units = units || Infinity;\n\t let codePoint;\n\t const length = string.length;\n\t let leadSurrogate = null;\n\t const bytes = [];\n\n\t for (let i = 0; i < length; ++i) {\n\t\tcodePoint = string.charCodeAt(i);\n\n\t\t// is surrogate component\n\t\tif (codePoint > 0xD7FF && codePoint < 0xE000) {\n\t\t // last char was a lead\n\t\t if (!leadSurrogate) {\n\t\t\t// no lead yet\n\t\t\tif (codePoint > 0xDBFF) {\n\t\t\t // unexpected trail\n\t\t\t if ((units -= 3) > -1) {\n bytes.push(0xEF, 0xBF, 0xBD);\n}\n\t\t\t continue;\n\t\t\t} else if (i + 1 === length) {\n\t\t\t // unpaired lead\n\t\t\t if ((units -= 3) > -1) {\n bytes.push(0xEF, 0xBF, 0xBD);\n}\n\t\t\t continue;\n\t\t\t}\n\n\t\t\t// valid lead\n\t\t\tleadSurrogate = codePoint;\n\n\t\t\tcontinue;\n\t\t }\n\n\t\t // 2 leads in a row\n\t\t if (codePoint < 0xDC00) {\n\t\t\tif ((units -= 3) > -1) {\n bytes.push(0xEF, 0xBF, 0xBD);\n}\n\t\t\tleadSurrogate = codePoint;\n\t\t\tcontinue;\n\t\t }\n\n\t\t // valid surrogate pair\n\t\t codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000;\n\t\t} else if (leadSurrogate) {\n\t\t // valid bmp char, but last char was a lead\n\t\t if ((units -= 3) > -1) {\n bytes.push(0xEF, 0xBF, 0xBD);\n}\n\t\t}\n\n\t\tleadSurrogate = null;\n\n\t\t// encode utf8\n\t\tif (codePoint < 0x80) {\n\t\t if ((units -= 1) < 0) {\n break;\n}\n\t\t bytes.push(codePoint);\n\t\t} else if (codePoint < 0x800) {\n\t\t if ((units -= 2) < 0) {\n break;\n}\n\t\t bytes.push(\n\t\t\tcodePoint >> 0x6 | 0xC0,\n\t\t\tcodePoint & 0x3F | 0x80\n\t\t );\n\t\t} else if (codePoint < 0x10000) {\n\t\t if ((units -= 3) < 0) {\n break;\n}\n\t\t bytes.push(\n\t\t\tcodePoint >> 0xC | 0xE0,\n\t\t\tcodePoint >> 0x6 & 0x3F | 0x80,\n\t\t\tcodePoint & 0x3F | 0x80\n\t\t );\n\t\t} else if (codePoint < 0x110000) {\n\t\t if ((units -= 4) < 0) {\n break;\n}\n\t\t bytes.push(\n\t\t\tcodePoint >> 0x12 | 0xF0,\n\t\t\tcodePoint >> 0xC & 0x3F | 0x80,\n\t\t\tcodePoint >> 0x6 & 0x3F | 0x80,\n\t\t\tcodePoint & 0x3F | 0x80\n\t\t );\n\t\t} else {\n\t\t throw new Error('Invalid code point');\n\t\t}\n\t }\n\n\t return bytes;\n\t}\n\n\tfunction asciiToBytes(str) {\n\t const byteArray = [];\n\t for (let i = 0; i < str.length; ++i) {\n\t\t// Node's code seems to be doing this and not & 0x7F..\n\t\tbyteArray.push(str.charCodeAt(i) & 0xFF);\n\t }\n\t return byteArray;\n\t}\n\n\tfunction utf16leToBytes(str, units) {\n\t let c, hi, lo;\n\t const byteArray = [];\n\t for (let i = 0; i < str.length; ++i) {\n\t\tif ((units -= 2) < 0) {\n break;\n}\n\n\t\tc = str.charCodeAt(i);\n\t\thi = c >> 8;\n\t\tlo = c % 256;\n\t\tbyteArray.push(lo);\n\t\tbyteArray.push(hi);\n\t }\n\n\t return byteArray;\n\t}\n\n\tfunction base64ToBytes(str) {\n\t return base64.toByteArray(base64clean(str));\n\t}\n\n\tfunction blitBuffer(src, dst, offset, length) {\n\t for (var i = 0; i < length; ++i) {\n\t\tif ((i + offset >= dst.length) || (i >= src.length)) {\n break;\n}\n\t\tdst[i + offset] = src[i];\n\t }\n\t return i;\n\t}\n\n\tfunction isnan(val) {\n\t return val !== val; // eslint-disable-line no-self-compare\n\t}\n\t/* WEBPACK VAR INJECTION */ }.call(exports, __webpack_require__(0)));\n\t/** */ }),\n\t/* 3 */\n\t/** */ (function (module, exports, __webpack_require__) {\n\t\"use strict\";\n\t// Copyright Joyent, Inc. and other Node contributors.\n\t//\n\t// Permission is hereby granted, free of charge, to any person obtaining a\n\t// copy of this software and associated documentation files (the\n\t// \"Software\"), to deal in the Software without restriction, including\n\t// without limitation the rights to use, copy, modify, merge, publish,\n\t// distribute, sublicense, and/or sell copies of the Software, and to permit\n\t// persons to whom the Software is furnished to do so, subject to the\n\t// following conditions:\n\t//\n\t// The above copyright notice and this permission notice shall be included\n\t// in all copies or substantial portions of the Software.\n\t//\n\t// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n\t// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n\t// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n\t// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n\t// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n\t// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n\t// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n\t// a duplex stream is just a stream that is both readable and writable.\n\t// Since JS doesn't have multiple prototypal inheritance, this class\n\t// prototypally inherits from Readable, and then parasitically from\n\t// Writable.\n\n\n\t/* */\n\n\tconst pna = __webpack_require__(6);\n\t/* */\n\n\t/* */\n\tconst objectKeys = Object.keys || function (obj) {\n\t const keys = [];\n\t for (const key in obj) {\n\t\tkeys.push(key);\n\t } return keys;\n\t};\n\t/* */\n\n\tmodule.exports = Duplex;\n\n\t/* */\n\tconst util = __webpack_require__(4);\n\tutil.inherits = __webpack_require__(5);\n\t/* */\n\n\tconst Readable = __webpack_require__(15);\n\tconst Writable = __webpack_require__(18);\n\n\tutil.inherits(Duplex, Readable);\n\n\t{\n\t // avoid scope creep, the keys array can then be collected\n\t const keys = objectKeys(Writable.prototype);\n\t for (let v = 0; v < keys.length; v++) {\n\t\tconst method = keys[v];\n\t\tif (!Duplex.prototype[method]) {\n Duplex.prototype[method] = Writable.prototype[method];\n}\n\t }\n\t}\n\n\tfunction Duplex(options) {\n\t if (!(this instanceof Duplex)) {\n return new Duplex(options);\n}\n\n\t Readable.call(this, options);\n\t Writable.call(this, options);\n\n\t if (options && options.readable === false) {\n this.readable = false;\n}\n\n\t if (options && options.writable === false) {\n this.writable = false;\n}\n\n\t this.allowHalfOpen = true;\n\t if (options && options.allowHalfOpen === false) {\n this.allowHalfOpen = false;\n}\n\n\t this.once('end', onend);\n\t}\n\n\tObject.defineProperty(Duplex.prototype, 'writableHighWaterMark', {\n\t // making it explicit this property is not enumerable\n\t // because otherwise some prototype manipulation in\n\t // userland will fail\n\t enumerable: false,\n\t get() {\n\t\treturn this._writableState.highWaterMark;\n\t }\n\t});\n\n\t// the no-half-open enforcer\n\tfunction onend() {\n\t // if we allow half-open state, or if the writable side ended,\n\t // then we're ok.\n\t if (this.allowHalfOpen || this._writableState.ended) {\n return;\n}\n\n\t // no more data can be written.\n\t // But allow more writes to happen in this tick.\n\t pna.nextTick(onEndNT, this);\n\t}\n\n\tfunction onEndNT(self) {\n\t self.end();\n\t}\n\n\tObject.defineProperty(Duplex.prototype, 'destroyed', {\n\t get() {\n\t\tif (this._readableState === undefined || this._writableState === undefined) {\n\t\t return false;\n\t\t}\n\t\treturn this._readableState.destroyed && this._writableState.destroyed;\n\t },\n\t set(value) {\n\t\t// we ignore the value if the stream\n\t\t// has not been initialized yet\n\t\tif (this._readableState === undefined || this._writableState === undefined) {\n\t\t return;\n\t\t}\n\n\t\t// backward compatibility, the user is explicitly\n\t\t// managing destroyed\n\t\tthis._readableState.destroyed = value;\n\t\tthis._writableState.destroyed = value;\n\t }\n\t});\n\n\tDuplex.prototype._destroy = function (err, cb) {\n\t this.push(null);\n\t this.end();\n\n\t pna.nextTick(cb, err);\n\t};\n\t/** */ }),\n\t/* 4 */\n\t/** */ (function (module, exports, __webpack_require__) {\n\t/* WEBPACK VAR INJECTION */(function (Buffer) { // Copyright Joyent, Inc. and other Node contributors.\n\t//\n\t// Permission is hereby granted, free of charge, to any person obtaining a\n\t// copy of this software and associated documentation files (the\n\t// \"Software\"), to deal in the Software without restriction, including\n\t// without limitation the rights to use, copy, modify, merge, publish,\n\t// distribute, sublicense, and/or sell copies of the Software, and to permit\n\t// persons to whom the Software is furnished to do so, subject to the\n\t// following conditions:\n\t//\n\t// The above copyright notice and this permission notice shall be included\n\t// in all copies or substantial portions of the Software.\n\t//\n\t// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n\t// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n\t// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n\t// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n\t// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n\t// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n\t// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n\t// NOTE: These type checking functions intentionally don't use `instanceof`\n\t// because it is fragile and can be easily faked with `Object.create()`.\n\n\tfunction isArray(arg) {\n\t if (Array.isArray) {\n\t\treturn Array.isArray(arg);\n\t }\n\t return objectToString(arg) === '[object Array]';\n\t}\n\texports.isArray = isArray;\n\n\tfunction isBoolean(arg) {\n\t return typeof arg === 'boolean';\n\t}\n\texports.isBoolean = isBoolean;\n\n\tfunction isNull(arg) {\n\t return arg === null;\n\t}\n\texports.isNull = isNull;\n\n\tfunction isNullOrUndefined(arg) {\n\t return arg == null;\n\t}\n\texports.isNullOrUndefined = isNullOrUndefined;\n\n\tfunction isNumber(arg) {\n\t return typeof arg === 'number';\n\t}\n\texports.isNumber = isNumber;\n\n\tfunction isString(arg) {\n\t return typeof arg === 'string';\n\t}\n\texports.isString = isString;\n\n\tfunction isSymbol(arg) {\n\t return typeof arg === 'symbol';\n\t}\n\texports.isSymbol = isSymbol;\n\n\tfunction isUndefined(arg) {\n\t return arg === void 0;\n\t}\n\texports.isUndefined = isUndefined;\n\n\tfunction isRegExp(re) {\n\t return objectToString(re) === '[object RegExp]';\n\t}\n\texports.isRegExp = isRegExp;\n\n\tfunction isObject(arg) {\n\t return typeof arg === 'object' && arg !== null;\n\t}\n\texports.isObject = isObject;\n\n\tfunction isDate(d) {\n\t return objectToString(d) === '[object Date]';\n\t}\n\texports.isDate = isDate;\n\n\tfunction isError(e) {\n\t return (objectToString(e) === '[object Error]' || e instanceof Error);\n\t}\n\texports.isError = isError;\n\n\tfunction isFunction(arg) {\n\t return typeof arg === 'function';\n\t}\n\texports.isFunction = isFunction;\n\n\tfunction isPrimitive(arg) {\n\t return arg === null ||\n\t\t\t typeof arg === 'boolean' ||\n\t\t\t typeof arg === 'number' ||\n\t\t\t typeof arg === 'string' ||\n\t\t\t typeof arg === 'symbol' || // ES6 symbol\n\t\t\t typeof arg === 'undefined';\n\t}\n\texports.isPrimitive = isPrimitive;\n\n\texports.isBuffer = Buffer.isBuffer;\n\n\tfunction objectToString(o) {\n\t return Object.prototype.toString.call(o);\n\t}\n\t/* WEBPACK VAR INJECTION */ }.call(exports, __webpack_require__(2).Buffer));\n\t/** */ }),\n\t/* 5 */\n\t/** */ (function (module, exports) {\n\tif (typeof Object.create === 'function') {\n\t // implementation from standard node.js 'util' module\n\t module.exports = function inherits(ctor, superCtor) {\n\t\tctor.super_ = superCtor;\n\t\tctor.prototype = Object.create(superCtor.prototype, {\n\t\t constructor: {\n\t\t\tvalue: ctor,\n\t\t\tenumerable: false,\n\t\t\twritable: true,\n\t\t\tconfigurable: true\n\t\t }\n\t\t});\n\t };\n\t} else {\n\t // old school shim for old browsers\n\t module.exports = function inherits(ctor, superCtor) {\n\t\tctor.super_ = superCtor;\n\t\tconst TempCtor = function () {};\n\t\tTempCtor.prototype = superCtor.prototype;\n\t\tctor.prototype = new TempCtor();\n\t\tctor.prototype.constructor = ctor;\n\t };\n\t}\n\t/** */ }),\n\t/* 6 */\n\t/** */ (function (module, exports, __webpack_require__) {\n\t\"use strict\";\n\t/* WEBPACK VAR INJECTION */(function (process) {\n\tif (!process.version ||\n\t\tprocess.version.indexOf('v0.') === 0 ||\n\t\tprocess.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {\n\t module.exports = { nextTick };\n\t} else {\n\t module.exports = process;\n\t}\n\n\tfunction nextTick(fn, arg1, arg2, arg3) {\n\t if (typeof fn !== 'function') {\n\t\tthrow new TypeError('\"callback\" argument must be a function');\n\t }\n\t const len = arguments.length;\n\t let args, i;\n\t switch (len) {\n\t case 0:\n\t case 1:\n\t\treturn process.nextTick(fn);\n\t case 2:\n\t\treturn process.nextTick(() => {\n\t\t fn.call(null, arg1);\n\t\t});\n\t case 3:\n\t\treturn process.nextTick(() => {\n\t\t fn.call(null, arg1, arg2);\n\t\t});\n\t case 4:\n\t\treturn process.nextTick(() => {\n\t\t fn.call(null, arg1, arg2, arg3);\n\t\t});\n\t default:\n\t\targs = new Array(len - 1);\n\t\ti = 0;\n\t\twhile (i < args.length) {\n\t\t args[i++] = arguments[i];\n\t\t}\n\t\treturn process.nextTick(() => {\n\t\t fn.apply(null, args);\n\t\t});\n\t }\n\t}\n\t/* WEBPACK VAR INJECTION */ }.call(exports, __webpack_require__(1)));\n\t/** */ }),\n\t/* 7 */\n\t/** */ (function (module, exports, __webpack_require__) {\n\t\"use strict\";\n\t// Copyright Joyent, Inc. and other Node contributors.\n\t//\n\t// Permission is hereby granted, free of charge, to any person obtaining a\n\t// copy of this software and associated documentation files (the\n\t// \"Software\"), to deal in the Software without restriction, including\n\t// without limitation the rights to use, copy, modify, merge, publish,\n\t// distribute, sublicense, and/or sell copies of the Software, and to permit\n\t// persons to whom the Software is furnished to do so, subject to the\n\t// following conditions:\n\t//\n\t// The above copyright notice and this permission notice shall be included\n\t// in all copies or substantial portions of the Software.\n\t//\n\t// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n\t// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n\t// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n\t// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n\t// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n\t// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n\t// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n\n\tconst punycode = __webpack_require__(30);\n\tconst util = __webpack_require__(32);\n\n\texports.parse = urlParse;\n\texports.resolve = urlResolve;\n\texports.resolveObject = urlResolveObject;\n\texports.format = urlFormat;\n\n\texports.Url = Url;\n\n\tfunction Url() {\n\t this.protocol = null;\n\t this.slashes = null;\n\t this.auth = null;\n\t this.host = null;\n\t this.port = null;\n\t this.hostname = null;\n\t this.hash = null;\n\t this.search = null;\n\t this.query = null;\n\t this.pathname = null;\n\t this.path = null;\n\t this.href = null;\n\t}\n\n\t// Reference: RFC 3986, RFC 1808, RFC 2396\n\n\t// define these here so at least they only have to be\n\t// compiled once on the first module load.\n\tconst protocolPattern = /^([a-z0-9.+-]+:)/i,\n\t\tportPattern = /:[0-9]*$/,\n\n\t\t// Special case for a simple path URL\n\t\tsimplePathPattern = /^(\\/\\/?(?!\\/)[^\\?\\s]*)(\\?[^\\s]*)?$/,\n\n\t\t// RFC 2396: characters reserved for delimiting URLs.\n\t\t// We actually just auto-escape these.\n\t\tdelims = ['<', '>', '\"', '`', ' ', '\\r', '\\n', '\\t'],\n\n\t\t// RFC 2396: characters not allowed for various reasons.\n\t\tunwise = ['{', '}', '|', '\\\\', '^', '`'].concat(delims),\n\n\t\t// Allowed by RFCs, but cause of XSS attacks. Always escape these.\n\t\tautoEscape = ['\\''].concat(unwise),\n\t\t// Characters that are never ever allowed in a hostname.\n\t\t// Note that any invalid chars are also handled, but these\n\t\t// are the ones that are *expected* to be seen, so we fast-path\n\t\t// them.\n\t\tnonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),\n\t\thostEndingChars = ['/', '?', '#'],\n\t\thostnameMaxLen = 255,\n\t\thostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,\n\t\thostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,\n\t\t// protocols that can allow \"unsafe\" and \"unwise\" chars.\n\t\tunsafeProtocol = {\n\t\t 'javascript': true,\n\t\t 'javascript:': true\n\t\t},\n\t\t// protocols that never have a hostname.\n\t\thostlessProtocol = {\n\t\t 'javascript': true,\n\t\t 'javascript:': true\n\t\t},\n\t\t// protocols that always contain a // bit.\n\t\tslashedProtocol = {\n\t\t 'http': true,\n\t\t 'https': true,\n\t\t 'ftp': true,\n\t\t 'gopher': true,\n\t\t 'file': true,\n\t\t 'http:': true,\n\t\t 'https:': true,\n\t\t 'ftp:': true,\n\t\t 'gopher:': true,\n\t\t 'file:': true\n\t\t},\n\t\tquerystring = __webpack_require__(33);\n\n\tfunction urlParse(url, parseQueryString, slashesDenoteHost) {\n\t if (url && util.isObject(url) && url instanceof Url) {\n return url;\n}\n\n\t const u = new Url;\n\t u.parse(url, parseQueryString, slashesDenoteHost);\n\t return u;\n\t}\n\n\tUrl.prototype.parse = function (url, parseQueryString, slashesDenoteHost) {\n\t if (!util.isString(url)) {\n\t\tthrow new TypeError(\"Parameter 'url' must be a string, not \" + typeof url);\n\t }\n\n\t // Copy chrome, IE, opera backslash-handling behavior.\n\t // Back slashes before the query string get converted to forward slashes\n\t // See: https://code.google.com/p/chromium/issues/detail?id=25916\n\t const queryIndex = url.indexOf('?'),\n\t\t splitter =\n\t\t\t (queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#',\n\t\t uSplit = url.split(splitter),\n\t\t slashRegex = /\\\\/g;\n\t uSplit[0] = uSplit[0].replace(slashRegex, '/');\n\t url = uSplit.join(splitter);\n\n\t let rest = url;\n\n\t // trim before proceeding.\n\t // This is to support parse stuff like \" http://foo.com \\n\"\n\t rest = rest.trim();\n\n\t if (!slashesDenoteHost && url.split('#').length === 1) {\n\t\t// Try fast path regexp\n\t\tconst simplePath = simplePathPattern.exec(rest);\n\t\tif (simplePath) {\n\t\t this.path = rest;\n\t\t this.href = rest;\n\t\t this.pathname = simplePath[1];\n\t\t if (simplePath[2]) {\n\t\t\tthis.search = simplePath[2];\n\t\t\tif (parseQueryString) {\n\t\t\t this.query = querystring.parse(this.search.substr(1));\n\t\t\t} else {\n\t\t\t this.query = this.search.substr(1);\n\t\t\t}\n\t\t } else if (parseQueryString) {\n\t\t\tthis.search = '';\n\t\t\tthis.query = {};\n\t\t }\n\t\t return this;\n\t\t}\n\t }\n\n\t let proto = protocolPattern.exec(rest);\n\t if (proto) {\n\t\tproto = proto[0];\n\t\tvar lowerProto = proto.toLowerCase();\n\t\tthis.protocol = lowerProto;\n\t\trest = rest.substr(proto.length);\n\t }\n\n\t // figure out if it's got a host\n\t // user@server is *always* interpreted as a hostname, and url\n\t // resolution will treat //foo/bar as host=foo,path=bar because that's\n\t // how the browser resolves relative URLs.\n\t if (slashesDenoteHost || proto || rest.match(/^\\/\\/[^@\\/]+@[^@\\/]+/)) {\n\t\tvar slashes = rest.substr(0, 2) === '//';\n\t\tif (slashes && !(proto && hostlessProtocol[proto])) {\n\t\t rest = rest.substr(2);\n\t\t this.slashes = true;\n\t\t}\n\t }\n\n\t if (!hostlessProtocol[proto] &&\n\t\t (slashes || (proto && !slashedProtocol[proto]))) {\n\t\t// there's a hostname.\n\t\t// the first instance of /, ?, ;, or # ends the host.\n\t\t//\n\t\t// If there is an @ in the hostname, then non-host chars *are* allowed\n\t\t// to the left of the last @ sign, unless some host-ending character\n\t\t// comes *before* the @-sign.\n\t\t// URLs are obnoxious.\n\t\t//\n\t\t// ex:\n\t\t// http://a@b@c/ => user:a@b host:c\n\t\t// http://a@b?@c => user:a host:c path:/?@c\n\n\t\t// v0.12 TODO(isaacs): This is not quite how Chrome does things.\n\t\t// Review our test case against browsers more comprehensively.\n\n\t\t// find the first instance of any hostEndingChars\n\t\tlet hostEnd = -1;\n\t\tfor (var i = 0; i < hostEndingChars.length; i++) {\n\t\t var hec = rest.indexOf(hostEndingChars[i]);\n\t\t if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {\n hostEnd = hec;\n}\n\t\t}\n\n\t\t// at this point, either we have an explicit point where the\n\t\t// auth portion cannot go past, or the last @ char is the decider.\n\t\tlet auth, atSign;\n\t\tif (hostEnd === -1) {\n\t\t // atSign can be anywhere.\n\t\t atSign = rest.lastIndexOf('@');\n\t\t} else {\n\t\t // atSign must be in auth portion.\n\t\t // http://a@b/c@d => host:b auth:a path:/c@d\n\t\t atSign = rest.lastIndexOf('@', hostEnd);\n\t\t}\n\n\t\t// Now we have a portion which is definitely the auth.\n\t\t// Pull that off.\n\t\tif (atSign !== -1) {\n\t\t auth = rest.slice(0, atSign);\n\t\t rest = rest.slice(atSign + 1);\n\t\t this.auth = decodeURIComponent(auth);\n\t\t}\n\n\t\t// the host is the remaining to the left of the first non-host char\n\t\thostEnd = -1;\n\t\tfor (var i = 0; i < nonHostChars.length; i++) {\n\t\t var hec = rest.indexOf(nonHostChars[i]);\n\t\t if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {\n hostEnd = hec;\n}\n\t\t}\n\t\t// if we still have not hit it, then the entire thing is a host.\n\t\tif (hostEnd === -1) {\n hostEnd = rest.length;\n}\n\n\t\tthis.host = rest.slice(0, hostEnd);\n\t\trest = rest.slice(hostEnd);\n\n\t\t// pull out port.\n\t\tthis.parseHost();\n\n\t\t// we've indicated that there is a hostname,\n\t\t// so even if it's empty, it has to be present.\n\t\tthis.hostname = this.hostname || '';\n\n\t\t// if hostname begins with [ and ends with ]\n\t\t// assume that it's an IPv6 address.\n\t\tconst ipv6Hostname = this.hostname[0] === '[' &&\n\t\t\tthis.hostname[this.hostname.length - 1] === ']';\n\n\t\t// validate a little.\n\t\tif (!ipv6Hostname) {\n\t\t const hostparts = this.hostname.split(/\\./);\n\t\t for (var i = 0, l = hostparts.length; i < l; i++) {\n\t\t\tconst part = hostparts[i];\n\t\t\tif (!part) {\n continue;\n}\n\t\t\tif (!part.match(hostnamePartPattern)) {\n\t\t\t let newpart = '';\n\t\t\t for (let j = 0, k = part.length; j < k; j++) {\n\t\t\t\tif (part.charCodeAt(j) > 127) {\n\t\t\t\t // we replace non-ASCII char with a temporary placeholder\n\t\t\t\t // we need this to make sure size of hostname is not\n\t\t\t\t // broken by replacing non-ASCII by nothing\n\t\t\t\t newpart += 'x';\n\t\t\t\t} else {\n\t\t\t\t newpart += part[j];\n\t\t\t\t}\n\t\t\t }\n\t\t\t // we test again with ASCII char only\n\t\t\t if (!newpart.match(hostnamePartPattern)) {\n\t\t\t\tconst validParts = hostparts.slice(0, i);\n\t\t\t\tconst notHost = hostparts.slice(i + 1);\n\t\t\t\tconst bit = part.match(hostnamePartStart);\n\t\t\t\tif (bit) {\n\t\t\t\t validParts.push(bit[1]);\n\t\t\t\t notHost.unshift(bit[2]);\n\t\t\t\t}\n\t\t\t\tif (notHost.length) {\n\t\t\t\t rest = '/' + notHost.join('.') + rest;\n\t\t\t\t}\n\t\t\t\tthis.hostname = validParts.join('.');\n\t\t\t\tbreak;\n\t\t\t }\n\t\t\t}\n\t\t }\n\t\t}\n\n\t\tif (this.hostname.length > hostnameMaxLen) {\n\t\t this.hostname = '';\n\t\t} else {\n\t\t // hostnames are always lower case.\n\t\t this.hostname = this.hostname.toLowerCase();\n\t\t}\n\n\t\tif (!ipv6Hostname) {\n\t\t // IDNA Support: Returns a punycoded representation of \"domain\".\n\t\t // It only converts parts of the domain name that\n\t\t // have non-ASCII characters, i.e. it doesn't matter if\n\t\t // you call it with a domain that already is ASCII-only.\n\t\t this.hostname = punycode.toASCII(this.hostname);\n\t\t}\n\n\t\tvar p = this.port ? ':' + this.port : '';\n\t\tconst h = this.hostname || '';\n\t\tthis.host = h + p;\n\t\tthis.href += this.host;\n\n\t\t// strip [ and ] from the hostname\n\t\t// the host field still retains them, though\n\t\tif (ipv6Hostname) {\n\t\t this.hostname = this.hostname.substr(1, this.hostname.length - 2);\n\t\t if (rest[0] !== '/') {\n\t\t\trest = '/' + rest;\n\t\t }\n\t\t}\n\t }\n\n\t // now rest is set to the post-host stuff.\n\t // chop off any delim chars.\n\t if (!unsafeProtocol[lowerProto]) {\n\t\t// First, make 100% sure that any \"autoEscape\" chars get\n\t\t// escaped, even if encodeURIComponent doesn't think they\n\t\t// need to be.\n\t\tfor (var i = 0, l = autoEscape.length; i < l; i++) {\n\t\t const ae = autoEscape[i];\n\t\t if (rest.indexOf(ae) === -1) {\n continue;\n}\n\t\t let esc = encodeURIComponent(ae);\n\t\t if (esc === ae) {\n\t\t\tesc = escape(ae);\n\t\t }\n\t\t rest = rest.split(ae).join(esc);\n\t\t}\n\t }\n\n\n\t // chop off from the tail first.\n\t const hash = rest.indexOf('#');\n\t if (hash !== -1) {\n\t\t// got a fragment string.\n\t\tthis.hash = rest.substr(hash);\n\t\trest = rest.slice(0, hash);\n\t }\n\t const qm = rest.indexOf('?');\n\t if (qm !== -1) {\n\t\tthis.search = rest.substr(qm);\n\t\tthis.query = rest.substr(qm + 1);\n\t\tif (parseQueryString) {\n\t\t this.query = querystring.parse(this.query);\n\t\t}\n\t\trest = rest.slice(0, qm);\n\t } else if (parseQueryString) {\n\t\t// no query string, but parseQueryString still requested\n\t\tthis.search = '';\n\t\tthis.query = {};\n\t }\n\t if (rest) {\n this.pathname = rest;\n}\n\t if (slashedProtocol[lowerProto] &&\n\t\t this.hostname && !this.pathname) {\n\t\tthis.pathname = '/';\n\t }\n\n\t // to support http.request\n\t if (this.pathname || this.search) {\n\t\tvar p = this.pathname || '';\n\t\tconst s = this.search || '';\n\t\tthis.path = p + s;\n\t }\n\n\t // finally, reconstruct the href based on what has been validated.\n\t this.href = this.format();\n\t return this;\n\t};\n\n\t// format a parsed object into a url string\n\tfunction urlFormat(obj) {\n\t // ensure it's an object, and not a string url.\n\t // If it's an obj, this is a no-op.\n\t // this way, you can call url_format() on strings\n\t // to clean up potentially wonky urls.\n\t if (util.isString(obj)) {\n obj = urlParse(obj);\n}\n\t if (!(obj instanceof Url)) {\n return Url.prototype.format.call(obj);\n}\n\t return obj.format();\n\t}\n\n\tUrl.prototype.format = function () {\n\t let auth = this.auth || '';\n\t if (auth) {\n\t\tauth = encodeURIComponent(auth);\n\t\tauth = auth.replace(/%3A/i, ':');\n\t\tauth += '@';\n\t }\n\n\t let protocol = this.protocol || '',\n\t\t pathname = this.pathname || '',\n\t\t hash = this.hash || '',\n\t\t host = false,\n\t\t query = '';\n\n\t if (this.host) {\n\t\thost = auth + this.host;\n\t } else if (this.hostname) {\n\t\thost = auth + (this.hostname.indexOf(':') === -1 ?\n\t\t\tthis.hostname :\n\t\t\t'[' + this.hostname + ']');\n\t\tif (this.port) {\n\t\t host += ':' + this.port;\n\t\t}\n\t }\n\n\t if (this.query &&\n\t\t util.isObject(this.query) &&\n\t\t Object.keys(this.query).length) {\n\t\tquery = querystring.stringify(this.query);\n\t }\n\n\t let search = this.search || (query && ('?' + query)) || '';\n\n\t if (protocol && protocol.substr(-1) !== ':') {\n protocol += ':';\n}\n\n\t // only the slashedProtocols get the //. Not mailto:, xmpp:, etc.\n\t // unless they had them to begin with.\n\t if (this.slashes ||\n\t\t (!protocol || slashedProtocol[protocol]) && host !== false) {\n\t\thost = '//' + (host || '');\n\t\tif (pathname && pathname.charAt(0) !== '/') {\n pathname = '/' + pathname;\n}\n\t } else if (!host) {\n\t\thost = '';\n\t }\n\n\t if (hash && hash.charAt(0) !== '#') {\n hash = '#' + hash;\n}\n\t if (search && search.charAt(0) !== '?') {\n search = '?' + search;\n}\n\n\t pathname = pathname.replace(/[?#]/g, (match) => {\n\t\treturn encodeURIComponent(match);\n\t });\n\t search = search.replace('#', '%23');\n\n\t return protocol + host + pathname + search + hash;\n\t};\n\n\tfunction urlResolve(source, relative) {\n\t return urlParse(source, false, true).resolve(relative);\n\t}\n\n\tUrl.prototype.resolve = function (relative) {\n\t return this.resolveObject(urlParse(relative, false, true)).format();\n\t};\n\n\tfunction urlResolveObject(source, relative) {\n\t if (!source) {\n return relative;\n}\n\t return urlParse(source, false, true).resolveObject(relative);\n\t}\n\n\tUrl.prototype.resolveObject = function (relative) {\n\t if (util.isString(relative)) {\n\t\tconst rel = new Url();\n\t\trel.parse(relative, false, true);\n\t\trelative = rel;\n\t }\n\n\t const result = new Url();\n\t const tkeys = Object.keys(this);\n\t for (let tk = 0; tk < tkeys.length; tk++) {\n\t\tconst tkey = tkeys[tk];\n\t\tresult[tkey] = this[tkey];\n\t }\n\n\t // hash is always overridden, no matter what.\n\t // even href=\"\" will remove it.\n\t result.hash = relative.hash;\n\n\t // if the relative url is empty, then there's nothing left to do here.\n\t if (relative.href === '') {\n\t\tresult.href = result.format();\n\t\treturn result;\n\t }\n\n\t // hrefs like //foo/bar always cut to the protocol.\n\t if (relative.slashes && !relative.protocol) {\n\t\t// take everything except the protocol from relative\n\t\tconst rkeys = Object.keys(relative);\n\t\tfor (let rk = 0; rk < rkeys.length; rk++) {\n\t\t const rkey = rkeys[rk];\n\t\t if (rkey !== 'protocol') {\n result[rkey] = relative[rkey];\n}\n\t\t}\n\n\t\t// urlParse appends trailing / to urls like http://www.example.com\n\t\tif (slashedProtocol[result.protocol] &&\n\t\t\tresult.hostname && !result.pathname) {\n\t\t result.path = result.pathname = '/';\n\t\t}\n\n\t\tresult.href = result.format();\n\t\treturn result;\n\t }\n\n\t if (relative.protocol && relative.protocol !== result.protocol) {\n\t\t// if it's a known url protocol, then changing\n\t\t// the protocol does weird things\n\t\t// first, if it's not file:, then we MUST have a host,\n\t\t// and if there was a path\n\t\t// to begin with, then we MUST have a path.\n\t\t// if it is file:, then the host is dropped,\n\t\t// because that's known to be hostless.\n\t\t// anything else is assumed to be absolute.\n\t\tif (!slashedProtocol[relative.protocol]) {\n\t\t const keys = Object.keys(relative);\n\t\t for (let v = 0; v < keys.length; v++) {\n\t\t\tconst k = keys[v];\n\t\t\tresult[k] = relative[k];\n\t\t }\n\t\t result.href = result.format();\n\t\t return result;\n\t\t}\n\n\t\tresult.protocol = relative.protocol;\n\t\tif (!relative.host && !hostlessProtocol[relative.protocol]) {\n\t\t var relPath = (relative.pathname || '').split('/');\n\t\t while (relPath.length && !(relative.host = relPath.shift())) { }\n\t\t if (!relative.host) {\n relative.host = '';\n}\n\t\t if (!relative.hostname) {\n relative.hostname = '';\n}\n\t\t if (relPath[0] !== '') {\n relPath.unshift('');\n}\n\t\t if (relPath.length < 2) {\n relPath.unshift('');\n}\n\t\t result.pathname = relPath.join('/');\n\t\t} else {\n\t\t result.pathname = relative.pathname;\n\t\t}\n\t\tresult.search = relative.search;\n\t\tresult.query = relative.query;\n\t\tresult.host = relative.host || '';\n\t\tresult.auth = relative.auth;\n\t\tresult.hostname = relative.hostname || relative.host;\n\t\tresult.port = relative.port;\n\t\t// to support http.request\n\t\tif (result.pathname || result.search) {\n\t\t const p = result.pathname || '';\n\t\t const s = result.search || '';\n\t\t result.path = p + s;\n\t\t}\n\t\tresult.slashes = result.slashes || relative.slashes;\n\t\tresult.href = result.format();\n\t\treturn result;\n\t }\n\n\t var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),\n\t\t isRelAbs = (\n\t\t\t relative.host ||\n\t\t\t relative.pathname && relative.pathname.charAt(0) === '/'\n\t\t ),\n\t\t mustEndAbs = (isRelAbs || isSourceAbs ||\n\t\t\t\t\t\t(result.host && relative.pathname)),\n\t\t removeAllDots = mustEndAbs,\n\t\t srcPath = result.pathname && result.pathname.split('/') || [],\n\t\t relPath = relative.pathname && relative.pathname.split('/') || [],\n\t\t psychotic = result.protocol && !slashedProtocol[result.protocol];\n\n\t // if the url is a non-slashed url, then relative\n\t // links like ../.. should be able\n\t // to crawl up to the hostname, as well. This is strange.\n\t // result.protocol has already been set by now.\n\t // Later on, put the first path part into the host field.\n\t if (psychotic) {\n\t\tresult.hostname = '';\n\t\tresult.port = null;\n\t\tif (result.host) {\n\t\t if (srcPath[0] === '') {\n srcPath[0] = result.host;\n} else {\n srcPath.unshift(result.host);\n}\n\t\t}\n\t\tresult.host = '';\n\t\tif (relative.protocol) {\n\t\t relative.hostname = null;\n\t\t relative.port = null;\n\t\t if (relative.host) {\n\t\t\tif (relPath[0] === '') {\n relPath[0] = relative.host;\n} else {\n relPath.unshift(relative.host);\n}\n\t\t }\n\t\t relative.host = null;\n\t\t}\n\t\tmustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');\n\t }\n\n\t if (isRelAbs) {\n\t\t// it's absolute.\n\t\tresult.host = (relative.host || relative.host === '') ?\n\t\t\t\t\t relative.host : result.host;\n\t\tresult.hostname = (relative.hostname || relative.hostname === '') ?\n\t\t\t\t\t\t relative.hostname : result.hostname;\n\t\tresult.search = relative.search;\n\t\tresult.query = relative.query;\n\t\tsrcPath = relPath;\n\t\t// fall through to the dot-handling below.\n\t } else if (relPath.length) {\n\t\t// it's relative\n\t\t// throw away the existing file, and take the new path instead.\n\t\tif (!srcPath) {\n srcPath = [];\n}\n\t\tsrcPath.pop();\n\t\tsrcPath = srcPath.concat(relPath);\n\t\tresult.search = relative.search;\n\t\tresult.query = relative.query;\n\t } else if (!util.isNullOrUndefined(relative.search)) {\n\t\t// just pull out the search.\n\t\t// like href='?foo'.\n\t\t// Put this after the other two cases because it simplifies the booleans\n\t\tif (psychotic) {\n\t\t result.hostname = result.host = srcPath.shift();\n\t\t // occationaly the auth can get stuck only in host\n\t\t // this especially happens in cases like\n\t\t // url.resolveObject('mailto:local1@domain1', 'local2@domain2')\n\t\t var authInHost = result.host && result.host.indexOf('@') > 0 ?\n\t\t\t\t\t\t result.host.split('@') : false;\n\t\t if (authInHost) {\n\t\t\tresult.auth = authInHost.shift();\n\t\t\tresult.host = result.hostname = authInHost.shift();\n\t\t }\n\t\t}\n\t\tresult.search = relative.search;\n\t\tresult.query = relative.query;\n\t\t// to support http.request\n\t\tif (!util.isNull(result.pathname) || !util.isNull(result.search)) {\n\t\t result.path = (result.pathname ? result.pathname : '') +\n\t\t\t\t\t\t(result.search ? result.search : '');\n\t\t}\n\t\tresult.href = result.format();\n\t\treturn result;\n\t }\n\n\t if (!srcPath.length) {\n\t\t// no path at all. easy.\n\t\t// we've already handled the other stuff above.\n\t\tresult.pathname = null;\n\t\t// to support http.request\n\t\tif (result.search) {\n\t\t result.path = '/' + result.search;\n\t\t} else {\n\t\t result.path = null;\n\t\t}\n\t\tresult.href = result.format();\n\t\treturn result;\n\t }\n\n\t // if a url ENDs in . or .., then it must get a trailing slash.\n\t // however, if it ends in anything else non-slashy,\n\t // then it must NOT get a trailing slash.\n\t let last = srcPath.slice(-1)[0];\n\t const hasTrailingSlash = (\n\t\t (result.host || relative.host || srcPath.length > 1) &&\n\t\t (last === '.' || last === '..') || last === '');\n\n\t // strip single dots, resolve double dots to parent dir\n\t // if the path tries to go above the root, `up` ends up > 0\n\t let up = 0;\n\t for (let i = srcPath.length; i >= 0; i--) {\n\t\tlast = srcPath[i];\n\t\tif (last === '.') {\n\t\t srcPath.splice(i, 1);\n\t\t} else if (last === '..') {\n\t\t srcPath.splice(i, 1);\n\t\t up++;\n\t\t} else if (up) {\n\t\t srcPath.splice(i, 1);\n\t\t up--;\n\t\t}\n\t }\n\n\t // if the path is allowed to go above the root, restore leading ..s\n\t if (!mustEndAbs && !removeAllDots) {\n\t\tfor (; up--; up) {\n\t\t srcPath.unshift('..');\n\t\t}\n\t }\n\n\t if (mustEndAbs && srcPath[0] !== '' &&\n\t\t (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {\n\t\tsrcPath.unshift('');\n\t }\n\n\t if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {\n\t\tsrcPath.push('');\n\t }\n\n\t const isAbsolute = srcPath[0] === '' ||\n\t\t (srcPath[0] && srcPath[0].charAt(0) === '/');\n\n\t // put the host back\n\t if (psychotic) {\n\t\tresult.hostname = result.host = isAbsolute ? '' :\n\t\t\t\t\t\t\t\t\t\tsrcPath.length ? srcPath.shift() : '';\n\t\t// occationaly the auth can get stuck only in host\n\t\t// this especially happens in cases like\n\t\t// url.resolveObject('mailto:local1@domain1', 'local2@domain2')\n\t\tvar authInHost = result.host && result.host.indexOf('@') > 0 ?\n\t\t\t\t\t\t result.host.split('@') : false;\n\t\tif (authInHost) {\n\t\t result.auth = authInHost.shift();\n\t\t result.host = result.hostname = authInHost.shift();\n\t\t}\n\t }\n\n\t mustEndAbs = mustEndAbs || (result.host && srcPath.length);\n\n\t if (mustEndAbs && !isAbsolute) {\n\t\tsrcPath.unshift('');\n\t }\n\n\t if (!srcPath.length) {\n\t\tresult.pathname = null;\n\t\tresult.path = null;\n\t } else {\n\t\tresult.pathname = srcPath.join('/');\n\t }\n\n\t // to support request.http\n\t if (!util.isNull(result.pathname) || !util.isNull(result.search)) {\n\t\tresult.path = (result.pathname ? result.pathname : '') +\n\t\t\t\t\t (result.search ? result.search : '');\n\t }\n\t result.auth = relative.auth || result.auth;\n\t result.slashes = result.slashes || relative.slashes;\n\t result.href = result.format();\n\t return result;\n\t};\n\n\tUrl.prototype.parseHost = function () {\n\t let host = this.host;\n\t let port = portPattern.exec(host);\n\t if (port) {\n\t\tport = port[0];\n\t\tif (port !== ':') {\n\t\t this.port = port.substr(1);\n\t\t}\n\t\thost = host.substr(0, host.length - port.length);\n\t }\n\t if (host) {\n this.hostname = host;\n}\n\t};\n\t/** */ }),\n\t/* 8 */\n\t/** */ (function (module, exports) {\n\t// Copyright Joyent, Inc. and other Node contributors.\n\t//\n\t// Permission is hereby granted, free of charge, to any person obtaining a\n\t// copy of this software and associated documentation files (the\n\t// \"Software\"), to deal in the Software without restriction, including\n\t// without limitation the rights to use, copy, modify, merge, publish,\n\t// distribute, sublicense, and/or sell copies of the Software, and to permit\n\t// persons to whom the Software is furnished to do so, subject to the\n\t// following conditions:\n\t//\n\t// The above copyright notice and this permission notice shall be included\n\t// in all copies or substantial portions of the Software.\n\t//\n\t// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n\t// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n\t// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n\t// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n\t// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n\t// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n\t// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n\tfunction EventEmitter() {\n\t this._events = this._events || {};\n\t this._maxListeners = this._maxListeners || undefined;\n\t}\n\tmodule.exports = EventEmitter;\n\n\t// Backwards-compat with node 0.10.x\n\tEventEmitter.EventEmitter = EventEmitter;\n\n\tEventEmitter.prototype._events = undefined;\n\tEventEmitter.prototype._maxListeners = undefined;\n\n\t// By default EventEmitters will print a warning if more than 10 listeners are\n\t// added to it. This is a useful default which helps finding memory leaks.\n\tEventEmitter.defaultMaxListeners = 10;\n\n\t// Obviously not all Emitters should be limited to 10. This function allows\n\t// that to be increased. Set to zero for unlimited.\n\tEventEmitter.prototype.setMaxListeners = function (n) {\n\t if (!isNumber(n) || n < 0 || isNaN(n)) {\n throw TypeError('n must be a positive number');\n}\n\t this._maxListeners = n;\n\t return this;\n\t};\n\n\tEventEmitter.prototype.emit = function (type) {\n\t let er, handler, len, args, i, listeners;\n\n\t if (!this._events) {\n this._events = {};\n}\n\n\t // If there is no 'error' event listener then throw.\n\t if (type === 'error') {\n\t\tif (!this._events.error ||\n\t\t\t(isObject(this._events.error) && !this._events.error.length)) {\n\t\t er = arguments[1];\n\t\t if (er instanceof Error) {\n\t\t\tthrow er; // Unhandled 'error' event\n\t\t } else {\n\t\t\t// At least give some kind of context to the user\n\t\t\tconst err = new Error('Uncaught, unspecified \"error\" event. (' + er + ')');\n\t\t\terr.context = er;\n\t\t\tthrow err;\n\t\t }\n\t\t}\n\t }\n\n\t handler = this._events[type];\n\n\t if (isUndefined(handler)) {\n return false;\n}\n\n\t if (isFunction(handler)) {\n\t\tswitch (arguments.length) {\n\t\t // fast cases\n\t\t case 1:\n\t\t\thandler.call(this);\n\t\t\tbreak;\n\t\t case 2:\n\t\t\thandler.call(this, arguments[1]);\n\t\t\tbreak;\n\t\t case 3:\n\t\t\thandler.call(this, arguments[1], arguments[2]);\n\t\t\tbreak;\n\t\t // slower\n\t\t default:\n\t\t\targs = Array.prototype.slice.call(arguments, 1);\n\t\t\thandler.apply(this, args);\n\t\t}\n\t } else if (isObject(handler)) {\n\t\targs = Array.prototype.slice.call(arguments, 1);\n\t\tlisteners = handler.slice();\n\t\tlen = listeners.length;\n\t\tfor (i = 0; i < len; i++) {\n listeners[i].apply(this, args);\n}\n\t }\n\n\t return true;\n\t};\n\n\tEventEmitter.prototype.addListener = function (type, listener) {\n\t let m;\n\n\t if (!isFunction(listener)) {\n throw TypeError('listener must be a function');\n}\n\n\t if (!this._events) {\n this._events = {};\n}\n\n\t // To avoid recursion in the case that type === \"newListener\"! Before\n\t // adding it to the listeners, first emit \"newListener\".\n\t if (this._events.newListener) {\n this.emit('newListener', type,\n\t\t\t\t isFunction(listener.listener) ?\n\t\t\t\t listener.listener : listener);\n}\n\n\t if (!this._events[type])\n\t\t// Optimize the case of one listener. Don't need the extra array object.\n\t\t{\n this._events[type] = listener;\n} else if (isObject(this._events[type]))\n\t\t// If we've already got an array, just append.\n\t\t{\n this._events[type].push(listener);\n} else\n\t\t// Adding the second element, need to change to array.\n\t\t{\n this._events[type] = [this._events[type], listener];\n}\n\n\t // Check for listener leak\n\t if (isObject(this._events[type]) && !this._events[type].warned) {\n\t\tif (!isUndefined(this._maxListeners)) {\n\t\t m = this._maxListeners;\n\t\t} else {\n\t\t m = EventEmitter.defaultMaxListeners;\n\t\t}\n\n\t\tif (m && m > 0 && this._events[type].length > m) {\n\t\t this._events[type].warned = true;\n\t\t console.error('(node) warning: possible EventEmitter memory ' +\n\t\t\t\t\t\t'leak detected. %d listeners added. ' +\n\t\t\t\t\t\t'Use emitter.setMaxListeners() to increase limit.',\n\t\t\t\t\t\tthis._events[type].length);\n\t\t if (typeof console.trace === 'function') {\n\t\t\t// not supported in IE 10\n\t\t\tconsole.trace();\n\t\t }\n\t\t}\n\t }\n\n\t return this;\n\t};\n\n\tEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\n\tEventEmitter.prototype.once = function (type, listener) {\n\t if (!isFunction(listener)) {\n throw TypeError('listener must be a function');\n}\n\n\t let fired = false;\n\n\t function g() {\n\t\tthis.removeListener(type, g);\n\n\t\tif (!fired) {\n\t\t fired = true;\n\t\t listener.apply(this, arguments);\n\t\t}\n\t }\n\n\t g.listener = listener;\n\t this.on(type, g);\n\n\t return this;\n\t};\n\n\t// emits a 'removeListener' event iff the listener was removed\n\tEventEmitter.prototype.removeListener = function (type, listener) {\n\t let list, position, length, i;\n\n\t if (!isFunction(listener)) {\n throw TypeError('listener must be a function');\n}\n\n\t if (!this._events || !this._events[type]) {\n return this;\n}\n\n\t list = this._events[type];\n\t length = list.length;\n\t position = -1;\n\n\t if (list === listener ||\n\t\t (isFunction(list.listener) && list.listener === listener)) {\n\t\tdelete this._events[type];\n\t\tif (this._events.removeListener) {\n this.emit('removeListener', type, listener);\n}\n\t } else if (isObject(list)) {\n\t\tfor (i = length; i-- > 0;) {\n\t\t if (list[i] === listener ||\n\t\t\t (list[i].listener && list[i].listener === listener)) {\n\t\t\tposition = i;\n\t\t\tbreak;\n\t\t }\n\t\t}\n\n\t\tif (position < 0) {\n return this;\n}\n\n\t\tif (list.length === 1) {\n\t\t list.length = 0;\n\t\t delete this._events[type];\n\t\t} else {\n\t\t list.splice(position, 1);\n\t\t}\n\n\t\tif (this._events.removeListener) {\n this.emit('removeListener', type, listener);\n}\n\t }\n\n\t return this;\n\t};\n\n\tEventEmitter.prototype.removeAllListeners = function (type) {\n\t let key, listeners;\n\n\t if (!this._events) {\n return this;\n}\n\n\t // not listening for removeListener, no need to emit\n\t if (!this._events.removeListener) {\n\t\tif (arguments.length === 0) {\n this._events = {};\n} else if (this._events[type]) {\n delete this._events[type];\n}\n\t\treturn this;\n\t }\n\n\t // emit removeListener for all listeners on all events\n\t if (arguments.length === 0) {\n\t\tfor (key in this._events) {\n\t\t if (key === 'removeListener') {\n continue;\n}\n\t\t this.removeAllListeners(key);\n\t\t}\n\t\tthis.removeAllListeners('removeListener');\n\t\tthis._events = {};\n\t\treturn this;\n\t }\n\n\t listeners = this._events[type];\n\n\t if (isFunction(listeners)) {\n\t\tthis.removeListener(type, listeners);\n\t } else if (listeners) {\n\t\t// LIFO order\n\t\twhile (listeners.length) {\n this.removeListener(type, listeners[listeners.length - 1]);\n}\n\t }\n\t delete this._events[type];\n\n\t return this;\n\t};\n\n\tEventEmitter.prototype.listeners = function (type) {\n\t let ret;\n\t if (!this._events || !this._events[type]) {\n ret = [];\n} else if (isFunction(this._events[type])) {\n ret = [this._events[type]];\n} else {\n ret = this._events[type].slice();\n}\n\t return ret;\n\t};\n\n\tEventEmitter.prototype.listenerCount = function (type) {\n\t if (this._events) {\n\t\tconst evlistener = this._events[type];\n\n\t\tif (isFunction(evlistener)) {\n return 1;\n} else if (evlistener) {\n return evlistener.length;\n}\n\t }\n\t return 0;\n\t};\n\n\tEventEmitter.listenerCount = function (emitter, type) {\n\t return emitter.listenerCount(type);\n\t};\n\n\tfunction isFunction(arg) {\n\t return typeof arg === 'function';\n\t}\n\n\tfunction isNumber(arg) {\n\t return typeof arg === 'number';\n\t}\n\n\tfunction isObject(arg) {\n\t return typeof arg === 'object' && arg !== null;\n\t}\n\n\tfunction isUndefined(arg) {\n\t return arg === void 0;\n\t}\n\t/** */ }),\n\t/* 9 */\n\t/** */ (function (module, exports, __webpack_require__) {\n\t/* eslint-disable node/no-deprecated-api */\n\tconst buffer = __webpack_require__(2);\n\tconst Buffer = buffer.Buffer;\n\n\t// alternative to using Object.keys for old browsers\n\tfunction copyProps(src, dst) {\n\t for (const key in src) {\n\t\tdst[key] = src[key];\n\t }\n\t}\n\tif (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {\n\t module.exports = buffer;\n\t} else {\n\t // Copy properties from require('buffer')\n\t copyProps(buffer, exports);\n\t exports.Buffer = SafeBuffer;\n\t}\n\n\tfunction SafeBuffer(arg, encodingOrOffset, length) {\n\t return Buffer(arg, encodingOrOffset, length);\n\t}\n\n\t// Copy static methods from Buffer\n\tcopyProps(Buffer, SafeBuffer);\n\n\tSafeBuffer.from = function (arg, encodingOrOffset, length) {\n\t if (typeof arg === 'number') {\n\t\tthrow new TypeError('Argument must not be a number');\n\t }\n\t return Buffer(arg, encodingOrOffset, length);\n\t};\n\n\tSafeBuffer.alloc = function (size, fill, encoding) {\n\t if (typeof size !== 'number') {\n\t\tthrow new TypeError('Argument must be a number');\n\t }\n\t const buf = Buffer(size);\n\t if (fill !== undefined) {\n\t\tif (typeof encoding === 'string') {\n\t\t buf.fill(fill, encoding);\n\t\t} else {\n\t\t buf.fill(fill);\n\t\t}\n\t } else {\n\t\tbuf.fill(0);\n\t }\n\t return buf;\n\t};\n\n\tSafeBuffer.allocUnsafe = function (size) {\n\t if (typeof size !== 'number') {\n\t\tthrow new TypeError('Argument must be a number');\n\t }\n\t return Buffer(size);\n\t};\n\n\tSafeBuffer.allocUnsafeSlow = function (size) {\n\t if (typeof size !== 'number') {\n\t\tthrow new TypeError('Argument must be a number');\n\t }\n\t return buffer.SlowBuffer(size);\n\t};\n\t/** */ }),\n\t/* 10 */\n\t/** */ (function (module, exports, __webpack_require__) {\n\t/* WEBPACK VAR INJECTION */(function (global) {\n const ClientRequest = __webpack_require__(37);\n\tconst response = __webpack_require__(13);\n\tconst extend = __webpack_require__(48);\n\tconst statusCodes = __webpack_require__(49);\n\tconst url = __webpack_require__(7);\n\n\tconst http = exports;\n\n\thttp.request = function (opts, cb) {\n\t\tif (typeof opts === 'string') {\n opts = url.parse(opts);\n} else {\n opts = extend(opts);\n}\n\n\t\t// Normally, the page is loaded from http or https, so not specifying a protocol\n\t\t// will result in a (valid) protocol-relative url. However, this won't work if\n\t\t// the protocol is something else, like 'file:'\n\t\tconst defaultProtocol = global.location.protocol.search(/^https?:$/) === -1 ? 'http:' : '';\n\n\t\tconst protocol = opts.protocol || defaultProtocol;\n\t\tlet host = opts.hostname || opts.host;\n\t\tconst port = opts.port;\n\t\tconst path = opts.path || '/';\n\n\t\t// Necessary for IPv6 addresses\n\t\tif (host && host.indexOf(':') !== -1) {\n host = '[' + host + ']';\n}\n\n\t\t// This may be a relative url. The browser should always be able to interpret it correctly.\n\t\topts.url = (host ? (protocol + '//' + host) : '') + (port ? ':' + port : '') + path;\n\t\topts.method = (opts.method || 'GET').toUpperCase();\n\t\topts.headers = opts.headers || {};\n\n\t\t// Also valid opts.auth, opts.mode\n\n\t\tconst req = new ClientRequest(opts);\n\t\tif (cb) {\n req.on('response', cb);\n}\n\t\treturn req;\n\t};\n\n\thttp.get = function get(opts, cb) {\n\t\tconst req = http.request(opts, cb);\n\t\treq.end();\n\t\treturn req;\n\t};\n\n\thttp.ClientRequest = ClientRequest;\n\thttp.IncomingMessage = response.IncomingMessage;\n\n\thttp.Agent = function () {};\n\thttp.Agent.defaultMaxSockets = 4;\n\n\thttp.globalAgent = new http.Agent();\n\n\thttp.STATUS_CODES = statusCodes;\n\n\thttp.METHODS = [\n\t\t'CHECKOUT',\n\t\t'CONNECT',\n\t\t'COPY',\n\t\t'DELETE',\n\t\t'GET',\n\t\t'HEAD',\n\t\t'LOCK',\n\t\t'M-SEARCH',\n\t\t'MERGE',\n\t\t'MKACTIVITY',\n\t\t'MKCOL',\n\t\t'MOVE',\n\t\t'NOTIFY',\n\t\t'OPTIONS',\n\t\t'PATCH',\n\t\t'POST',\n\t\t'PROPFIND',\n\t\t'PROPPATCH',\n\t\t'PURGE',\n\t\t'PUT',\n\t\t'REPORT',\n\t\t'SEARCH',\n\t\t'SUBSCRIBE',\n\t\t'TRACE',\n\t\t'UNLOCK',\n\t\t'UNSUBSCRIBE'\n\t];\n\t/* WEBPACK VAR INJECTION */ }.call(exports, __webpack_require__(0)));\n\t/** */ }),\n\t/* 11 */\n\t/** */ (function (module, exports, __webpack_require__) {\n\t/* WEBPACK VAR INJECTION */(function (global) {\n exports.fetch = isFunction(global.fetch) && isFunction(global.ReadableStream);\n\n\texports.writableStream = isFunction(global.WritableStream);\n\n\texports.abortController = isFunction(global.AbortController);\n\n\texports.blobConstructor = false;\n\ttry {\n\t\tnew Blob([new ArrayBuffer(1)]);\n\t\texports.blobConstructor = true;\n\t} catch (e) {}\n\n\t// The xhr request to example.com may violate some restrictive CSP configurations,\n\t// so if we're running in a browser that supports `fetch`, avoid calling getXHR()\n\t// and assume support for certain features below.\n\tlet xhr;\n\tfunction getXHR() {\n\t\t// Cache the xhr value\n\t\tif (xhr !== undefined) {\n return xhr;\n}\n\n\t\tif (global.XMLHttpRequest) {\n\t\t\txhr = new global.XMLHttpRequest();\n\t\t\t// If XDomainRequest is available (ie only, where xhr might not work\n\t\t\t// cross domain), use the page location. Otherwise use example.com\n\t\t\t// Note: this doesn't actually make an http request.\n\t\t\ttry {\n\t\t\t\txhr.open('GET', global.XDomainRequest ? '/' : 'https://example.com');\n\t\t\t} catch (e) {\n\t\t\t\txhr = null;\n\t\t\t}\n\t\t} else {\n\t\t\t// Service workers don't have XHR\n\t\t\txhr = null;\n\t\t}\n\t\treturn xhr;\n\t}\n\n\tfunction checkTypeSupport(type) {\n\t\tconst xhr = getXHR();\n\t\tif (!xhr) {\n return false;\n}\n\t\ttry {\n\t\t\txhr.responseType = type;\n\t\t\treturn xhr.responseType === type;\n\t\t} catch (e) {}\n\t\treturn false;\n\t}\n\n\t// For some strange reason, Safari 7.0 reports typeof global.ArrayBuffer === 'object'.\n\t// Safari 7.1 appears to have fixed this bug.\n\tconst haveArrayBuffer = typeof global.ArrayBuffer !== 'undefined';\n\tconst haveSlice = haveArrayBuffer && isFunction(global.ArrayBuffer.prototype.slice);\n\n\t// If fetch is supported, then arraybuffer will be supported too. Skip calling\n\t// checkTypeSupport(), since that calls getXHR().\n\texports.arraybuffer = exports.fetch || (haveArrayBuffer && checkTypeSupport('arraybuffer'));\n\n\t// These next two tests unavoidably show warnings in Chrome. Since fetch will always\n\t// be used if it's available, just return false for these to avoid the warnings.\n\texports.msstream = !exports.fetch && haveSlice && checkTypeSupport('ms-stream');\n\texports.mozchunkedarraybuffer = !exports.fetch && haveArrayBuffer &&\n\t\tcheckTypeSupport('moz-chunked-arraybuffer');\n\n\t// If fetch is supported, then overrideMimeType will be supported too. Skip calling\n\t// getXHR().\n\texports.overrideMimeType = exports.fetch || (getXHR() ? isFunction(getXHR().overrideMimeType) : false);\n\n\texports.vbArray = isFunction(global.VBArray);\n\n\tfunction isFunction(value) {\n\t\treturn typeof value === 'function';\n\t}\n\n\txhr = null; // Help gc\n\t/* WEBPACK VAR INJECTION */ }.call(exports, __webpack_require__(0)));\n\t/** */ }),\n\t/* 12 */\n\t/** */ (function (module, exports) {\n\tif (typeof Object.create === 'function') {\n\t // implementation from standard node.js 'util' module\n\t module.exports = function inherits(ctor, superCtor) {\n\t\tctor.super_ = superCtor;\n\t\tctor.prototype = Object.create(superCtor.prototype, {\n\t\t constructor: {\n\t\t\tvalue: ctor,\n\t\t\tenumerable: false,\n\t\t\twritable: true,\n\t\t\tconfigurable: true\n\t\t }\n\t\t});\n\t };\n\t} else {\n\t // old school shim for old browsers\n\t module.exports = function inherits(ctor, superCtor) {\n\t\tctor.super_ = superCtor;\n\t\tconst TempCtor = function () {};\n\t\tTempCtor.prototype = superCtor.prototype;\n\t\tctor.prototype = new TempCtor();\n\t\tctor.prototype.constructor = ctor;\n\t };\n\t}\n\t/** */ }),\n\t/* 13 */\n\t/** */ (function (module, exports, __webpack_require__) {\n\t/* WEBPACK VAR INJECTION */(function (process, Buffer, global) {\n const capability = __webpack_require__(11);\n\tconst inherits = __webpack_require__(12);\n\tconst stream = __webpack_require__(14);\n\n\tconst rStates = exports.readyStates = {\n\t\tUNSENT: 0,\n\t\tOPENED: 1,\n\t\tHEADERS_RECEIVED: 2,\n\t\tLOADING: 3,\n\t\tDONE: 4\n\t};\n\n\tconst IncomingMessage = exports.IncomingMessage = function (xhr, response, mode, fetchTimer) {\n\t\tconst self = this;\n\t\tstream.Readable.call(self);\n\n\t\tself._mode = mode;\n\t\tself.headers = {};\n\t\tself.rawHeaders = [];\n\t\tself.trailers = {};\n\t\tself.rawTrailers = [];\n\n\t\t// Fake the 'close' event, but only once 'end' fires\n\t\tself.on('end', () => {\n\t\t\t// The nextTick is necessary to prevent the 'request' module from causing an infinite loop\n\t\t\tprocess.nextTick(() => {\n\t\t\t\tself.emit('close');\n\t\t\t});\n\t\t});\n\n\t\tif (mode === 'fetch') {\n\t\t\tself._fetchResponse = response;\n\n\t\t\tself.url = response.url;\n\t\t\tself.statusCode = response.status;\n\t\t\tself.statusMessage = response.statusText;\n\n\t\t\tresponse.headers.forEach((header, key) => {\n\t\t\t\tself.headers[key.toLowerCase()] = header;\n\t\t\t\tself.rawHeaders.push(key, header);\n\t\t\t});\n\n\t\t\tif (capability.writableStream) {\n\t\t\t\tconst writable = new WritableStream({\n\t\t\t\t\twrite(chunk) {\n\t\t\t\t\t\treturn new Promise(((resolve, reject) => {\n\t\t\t\t\t\t\tif (self._destroyed) {\n\t\t\t\t\t\t\t\treject();\n\t\t\t\t\t\t\t} else if (self.push(new Buffer(chunk))) {\n\t\t\t\t\t\t\t\tresolve();\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tself._resumeFetch = resolve;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}));\n\t\t\t\t\t},\n\t\t\t\t\tclose() {\n\t\t\t\t\t\tglobal.clearTimeout(fetchTimer);\n\t\t\t\t\t\tif (!self._destroyed) {\n self.push(null);\n}\n\t\t\t\t\t},\n\t\t\t\t\tabort(err) {\n\t\t\t\t\t\tif (!self._destroyed) {\n self.emit('error', err);\n}\n\t\t\t\t\t}\n\t\t\t\t});\n\n\t\t\t\ttry {\n\t\t\t\t\tresponse.body.pipeTo(writable).catch((err) => {\n\t\t\t\t\t\tglobal.clearTimeout(fetchTimer);\n\t\t\t\t\t\tif (!self._destroyed) {\n self.emit('error', err);\n}\n\t\t\t\t\t});\n\t\t\t\t\treturn;\n\t\t\t\t} catch (e) {} // pipeTo method isn't defined. Can't find a better way to feature test this\n\t\t\t}\n\t\t\t// fallback for when writableStream or pipeTo aren't available\n\t\t\tconst reader = response.body.getReader();\n\t\t\tfunction read() {\n\t\t\t\treader.read().then((result) => {\n\t\t\t\t\tif (self._destroyed) {\n return;\n}\n\t\t\t\t\tif (result.done) {\n\t\t\t\t\t\tglobal.clearTimeout(fetchTimer);\n\t\t\t\t\t\tself.push(null);\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tself.push(new Buffer(result.value));\n\t\t\t\t\tread();\n\t\t\t\t}).catch((err) => {\n\t\t\t\t\tglobal.clearTimeout(fetchTimer);\n\t\t\t\t\tif (!self._destroyed) {\n self.emit('error', err);\n}\n\t\t\t\t});\n\t\t\t}\n\t\t\tread();\n\t\t} else {\n\t\t\tself._xhr = xhr;\n\t\t\tself._pos = 0;\n\n\t\t\tself.url = xhr.responseURL;\n\t\t\tself.statusCode = xhr.status;\n\t\t\tself.statusMessage = xhr.statusText;\n\t\t\tconst headers = xhr.getAllResponseHeaders().split(/\\r?\\n/);\n\t\t\theaders.forEach((header) => {\n\t\t\t\tconst matches = header.match(/^([^:]+):\\s*(.*)/);\n\t\t\t\tif (matches) {\n\t\t\t\t\tconst key = matches[1].toLowerCase();\n\t\t\t\t\tif (key === 'set-cookie') {\n\t\t\t\t\t\tif (self.headers[key] === undefined) {\n\t\t\t\t\t\t\tself.headers[key] = [];\n\t\t\t\t\t\t}\n\t\t\t\t\t\tself.headers[key].push(matches[2]);\n\t\t\t\t\t} else if (self.headers[key] !== undefined) {\n\t\t\t\t\t\tself.headers[key] += ', ' + matches[2];\n\t\t\t\t\t} else {\n\t\t\t\t\t\tself.headers[key] = matches[2];\n\t\t\t\t\t}\n\t\t\t\t\tself.rawHeaders.push(matches[1], matches[2]);\n\t\t\t\t}\n\t\t\t});\n\n\t\t\tself._charset = 'x-user-defined';\n\t\t\tif (!capability.overrideMimeType) {\n\t\t\t\tconst mimeType = self.rawHeaders['mime-type'];\n\t\t\t\tif (mimeType) {\n\t\t\t\t\tconst charsetMatch = mimeType.match(/;\\s*charset=([^;])(;|$)/);\n\t\t\t\t\tif (charsetMatch) {\n\t\t\t\t\t\tself._charset = charsetMatch[1].toLowerCase();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif (!self._charset) {\n self._charset = 'utf-8';\n} // best guess\n\t\t\t}\n\t\t}\n\t};\n\n\tinherits(IncomingMessage, stream.Readable);\n\n\tIncomingMessage.prototype._read = function () {\n\t\tconst self = this;\n\n\t\tconst resolve = self._resumeFetch;\n\t\tif (resolve) {\n\t\t\tself._resumeFetch = null;\n\t\t\tresolve();\n\t\t}\n\t};\n\n\tIncomingMessage.prototype._onXHRProgress = function () {\n\t\tconst self = this;\n\n\t\tconst xhr = self._xhr;\n\n\t\tlet response = null;\n\t\tswitch (self._mode) {\n\t\t\tcase 'text:vbarray': // For IE9\n\t\t\t\tif (xhr.readyState !== rStates.DONE) {\n break;\n}\n\t\t\t\ttry {\n\t\t\t\t\t// This fails in IE8\n\t\t\t\t\tresponse = new global.VBArray(xhr.responseBody).toArray();\n\t\t\t\t} catch (e) {}\n\t\t\t\tif (response !== null) {\n\t\t\t\t\tself.push(new Buffer(response));\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\t// Falls through in IE8\n\t\t\tcase 'text':\n\t\t\t\ttry { // This will fail when readyState = 3 in IE9. Switch mode and wait for readyState = 4\n\t\t\t\t\tresponse = xhr.responseText;\n\t\t\t\t} catch (e) {\n\t\t\t\t\tself._mode = 'text:vbarray';\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\tif (response.length > self._pos) {\n\t\t\t\t\tconst newData = response.substr(self._pos);\n\t\t\t\t\tif (self._charset === 'x-user-defined') {\n\t\t\t\t\t\tconst buffer = new Buffer(newData.length);\n\t\t\t\t\t\tfor (let i = 0; i < newData.length; i++) {\n buffer[i] = newData.charCodeAt(i) & 0xff;\n}\n\n\t\t\t\t\t\tself.push(buffer);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tself.push(newData, self._charset);\n\t\t\t\t\t}\n\t\t\t\t\tself._pos = response.length;\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tcase 'arraybuffer':\n\t\t\t\tif (xhr.readyState !== rStates.DONE || !xhr.response) {\n break;\n}\n\t\t\t\tresponse = xhr.response;\n\t\t\t\tself.push(new Buffer(new Uint8Array(response)));\n\t\t\t\tbreak;\n\t\t\tcase 'moz-chunked-arraybuffer': // take whole\n\t\t\t\tresponse = xhr.response;\n\t\t\t\tif (xhr.readyState !== rStates.LOADING || !response) {\n break;\n}\n\t\t\t\tself.push(new Buffer(new Uint8Array(response)));\n\t\t\t\tbreak;\n\t\t\tcase 'ms-stream':\n\t\t\t\tresponse = xhr.response;\n\t\t\t\tif (xhr.readyState !== rStates.LOADING) {\n break;\n}\n\t\t\t\tvar reader = new global.MSStreamReader();\n\t\t\t\treader.onprogress = function () {\n\t\t\t\t\tif (reader.result.byteLength > self._pos) {\n\t\t\t\t\t\tself.push(new Buffer(new Uint8Array(reader.result.slice(self._pos))));\n\t\t\t\t\t\tself._pos = reader.result.byteLength;\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\t\treader.onload = function () {\n\t\t\t\t\tself.push(null);\n\t\t\t\t};\n\t\t\t\t// reader.onerror = ??? // TODO: this\n\t\t\t\treader.readAsArrayBuffer(response);\n\t\t\t\tbreak;\n\t\t}\n\n\t\t// The ms-stream case handles end separately in reader.onload()\n\t\tif (self._xhr.readyState === rStates.DONE && self._mode !== 'ms-stream') {\n\t\t\tself.push(null);\n\t\t}\n\t};\n\t/* WEBPACK VAR INJECTION */ }.call(exports, __webpack_require__(1), __webpack_require__(2).Buffer, __webpack_require__(0)));\n\t/** */ }),\n\t/* 14 */\n\t/** */ (function (module, exports, __webpack_require__) {\n\texports = module.exports = __webpack_require__(15);\n\texports.Stream = exports;\n\texports.Readable = exports;\n\texports.Writable = __webpack_require__(18);\n\texports.Duplex = __webpack_require__(3);\n\texports.Transform = __webpack_require__(20);\n\texports.PassThrough = __webpack_require__(46);\n\t/** */ }),\n\t/* 15 */\n\t/** */ (function (module, exports, __webpack_require__) {\n\t\"use strict\";\n\t/* WEBPACK VAR INJECTION */(function (global, process) { // Copyright Joyent, Inc. and other Node contributors.\n\t//\n\t// Permission is hereby granted, free of charge, to any person obtaining a\n\t// copy of this software and associated documentation files (the\n\t// \"Software\"), to deal in the Software without restriction, including\n\t// without limitation the rights to use, copy, modify, merge, publish,\n\t// distribute, sublicense, and/or sell copies of the Software, and to permit\n\t// persons to whom the Software is furnished to do so, subject to the\n\t// following conditions:\n\t//\n\t// The above copyright notice and this permission notice shall be included\n\t// in all copies or substantial portions of the Software.\n\t//\n\t// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n\t// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n\t// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n\t// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n\t// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n\t// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n\t// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n\n\t/* */\n\n\tconst pna = __webpack_require__(6);\n\t/* */\n\n\tmodule.exports = Readable;\n\n\t/* */\n\tconst isArray = __webpack_require__(38);\n\t/* */\n\n\t/* */\n\tlet Duplex;\n\t/* */\n\n\tReadable.ReadableState = ReadableState;\n\n\t/* */\n\tconst EE = __webpack_require__(8).EventEmitter;\n\n\tconst EElistenerCount = function (emitter, type) {\n\t return emitter.listeners(type).length;\n\t};\n\t/* */\n\n\t/* */\n\tconst Stream = __webpack_require__(16);\n\t/* */\n\n\t/* */\n\n\tconst Buffer = __webpack_require__(9).Buffer;\n\tconst OurUint8Array = global.Uint8Array || function () {};\n\tfunction _uint8ArrayToBuffer(chunk) {\n\t return Buffer.from(chunk);\n\t}\n\tfunction _isUint8Array(obj) {\n\t return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n\t}\n\n\t/* */\n\n\t/* */\n\tconst util = __webpack_require__(4);\n\tutil.inherits = __webpack_require__(5);\n\t/* */\n\n\t/* */\n\tconst debugUtil = __webpack_require__(39);\n\tlet debug = void 0;\n\tif (debugUtil && debugUtil.debuglog) {\n\t debug = debugUtil.debuglog('stream');\n\t} else {\n\t debug = function () {};\n\t}\n\t/* */\n\n\tconst BufferList = __webpack_require__(40);\n\tconst destroyImpl = __webpack_require__(17);\n\tlet StringDecoder;\n\n\tutil.inherits(Readable, Stream);\n\n\tconst kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];\n\n\tfunction prependListener(emitter, event, fn) {\n\t // Sadly this is not cacheable as some libraries bundle their own\n\t // event emitter implementation with them.\n\t if (typeof emitter.prependListener === 'function') {\n return emitter.prependListener(event, fn);\n}\n\n\t // This is a hack to make sure that our error handler is attached before any\n\t // userland ones. NEVER DO THIS. This is here only because this code needs\n\t // to continue to work with older versions of Node.js that do not include\n\t // the prependListener() method. The goal is to eventually remove this hack.\n\t if (!emitter._events || !emitter._events[event]) {\n emitter.on(event, fn);\n} else if (isArray(emitter._events[event])) {\n emitter._events[event].unshift(fn);\n} else {\n emitter._events[event] = [fn, emitter._events[event]];\n}\n\t}\n\n\tfunction ReadableState(options, stream) {\n\t Duplex = Duplex || __webpack_require__(3);\n\n\t options = options || {};\n\n\t // Duplex streams are both readable and writable, but share\n\t // the same options object.\n\t // However, some cases require setting options to different\n\t // values for the readable and the writable sides of the duplex stream.\n\t // These options can be provided separately as readableXXX and writableXXX.\n\t const isDuplex = stream instanceof Duplex;\n\n\t // object stream flag. Used to make read(n) ignore n and to\n\t // make all the buffer merging and length checks go away\n\t this.objectMode = !!options.objectMode;\n\n\t if (isDuplex) {\n this.objectMode = this.objectMode || !!options.readableObjectMode;\n}\n\n\t // the point at which it stops calling _read() to fill the buffer\n\t // Note: 0 is a valid value, means \"don't call _read preemptively ever\"\n\t const hwm = options.highWaterMark;\n\t const readableHwm = options.readableHighWaterMark;\n\t const defaultHwm = this.objectMode ? 16 : 16 * 1024;\n\n\t if (hwm || hwm === 0) {\n this.highWaterMark = hwm;\n} else if (isDuplex && (readableHwm || readableHwm === 0)) {\n this.highWaterMark = readableHwm;\n} else {\n this.highWaterMark = defaultHwm;\n}\n\n\t // cast to ints.\n\t this.highWaterMark = Math.floor(this.highWaterMark);\n\n\t // A linked list is used to store data chunks instead of an array because the\n\t // linked list can remove elements from the beginning faster than\n\t // array.shift()\n\t this.buffer = new BufferList();\n\t this.length = 0;\n\t this.pipes = null;\n\t this.pipesCount = 0;\n\t this.flowing = null;\n\t this.ended = false;\n\t this.endEmitted = false;\n\t this.reading = false;\n\n\t // a flag to be able to tell if the event 'readable'/'data' is emitted\n\t // immediately, or on a later tick. We set this to true at first, because\n\t // any actions that shouldn't happen until \"later\" should generally also\n\t // not happen before the first read call.\n\t this.sync = true;\n\n\t // whenever we return null, then we set a flag to say\n\t // that we're awaiting a 'readable' event emission.\n\t this.needReadable = false;\n\t this.emittedReadable = false;\n\t this.readableListening = false;\n\t this.resumeScheduled = false;\n\n\t // has it been destroyed\n\t this.destroyed = false;\n\n\t // Crypto is kind of old and crusty. Historically, its default string\n\t // encoding is 'binary' so we have to make this configurable.\n\t // Everything else in the universe uses 'utf8', though.\n\t this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n\t // the number of writers that are awaiting a drain event in .pipe()s\n\t this.awaitDrain = 0;\n\n\t // if true, a maybeReadMore has been scheduled\n\t this.readingMore = false;\n\n\t this.decoder = null;\n\t this.encoding = null;\n\t if (options.encoding) {\n\t\tif (!StringDecoder) {\n StringDecoder = __webpack_require__(19).StringDecoder;\n}\n\t\tthis.decoder = new StringDecoder(options.encoding);\n\t\tthis.encoding = options.encoding;\n\t }\n\t}\n\n\tfunction Readable(options) {\n\t Duplex = Duplex || __webpack_require__(3);\n\n\t if (!(this instanceof Readable)) {\n return new Readable(options);\n}\n\n\t this._readableState = new ReadableState(options, this);\n\n\t // legacy\n\t this.readable = true;\n\n\t if (options) {\n\t\tif (typeof options.read === 'function') {\n this._read = options.read;\n}\n\n\t\tif (typeof options.destroy === 'function') {\n this._destroy = options.destroy;\n}\n\t }\n\n\t Stream.call(this);\n\t}\n\n\tObject.defineProperty(Readable.prototype, 'destroyed', {\n\t get() {\n\t\tif (this._readableState === undefined) {\n\t\t return false;\n\t\t}\n\t\treturn this._readableState.destroyed;\n\t },\n\t set(value) {\n\t\t// we ignore the value if the stream\n\t\t// has not been initialized yet\n\t\tif (!this._readableState) {\n\t\t return;\n\t\t}\n\n\t\t// backward compatibility, the user is explicitly\n\t\t// managing destroyed\n\t\tthis._readableState.destroyed = value;\n\t }\n\t});\n\n\tReadable.prototype.destroy = destroyImpl.destroy;\n\tReadable.prototype._undestroy = destroyImpl.undestroy;\n\tReadable.prototype._destroy = function (err, cb) {\n\t this.push(null);\n\t cb(err);\n\t};\n\n\t// Manually shove something into the read() buffer.\n\t// This returns true if the highWaterMark has not been hit yet,\n\t// similar to how Writable.write() returns true if you should\n\t// write() some more.\n\tReadable.prototype.push = function (chunk, encoding) {\n\t const state = this._readableState;\n\t let skipChunkCheck;\n\n\t if (!state.objectMode) {\n\t\tif (typeof chunk === 'string') {\n\t\t encoding = encoding || state.defaultEncoding;\n\t\t if (encoding !== state.encoding) {\n\t\t\tchunk = Buffer.from(chunk, encoding);\n\t\t\tencoding = '';\n\t\t }\n\t\t skipChunkCheck = true;\n\t\t}\n\t } else {\n\t\tskipChunkCheck = true;\n\t }\n\n\t return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);\n\t};\n\n\t// Unshift should *always* be something directly out of read()\n\tReadable.prototype.unshift = function (chunk) {\n\t return readableAddChunk(this, chunk, null, true, false);\n\t};\n\n\tfunction readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {\n\t const state = stream._readableState;\n\t if (chunk === null) {\n\t\tstate.reading = false;\n\t\tonEofChunk(stream, state);\n\t } else {\n\t\tlet er;\n\t\tif (!skipChunkCheck) {\n er = chunkInvalid(state, chunk);\n}\n\t\tif (er) {\n\t\t stream.emit('error', er);\n\t\t} else if (state.objectMode || chunk && chunk.length > 0) {\n\t\t if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {\n\t\t\tchunk = _uint8ArrayToBuffer(chunk);\n\t\t }\n\n\t\t if (addToFront) {\n\t\t\tif (state.endEmitted) {\n stream.emit('error', new Error('stream.unshift() after end event'));\n} else {\n addChunk(stream, state, chunk, true);\n}\n\t\t } else if (state.ended) {\n\t\t\tstream.emit('error', new Error('stream.push() after EOF'));\n\t\t } else {\n\t\t\tstate.reading = false;\n\t\t\tif (state.decoder && !encoding) {\n\t\t\t chunk = state.decoder.write(chunk);\n\t\t\t if (state.objectMode || chunk.length !== 0) {\n addChunk(stream, state, chunk, false);\n} else {\n maybeReadMore(stream, state);\n}\n\t\t\t} else {\n\t\t\t addChunk(stream, state, chunk, false);\n\t\t\t}\n\t\t }\n\t\t} else if (!addToFront) {\n\t\t state.reading = false;\n\t\t}\n\t }\n\n\t return needMoreData(state);\n\t}\n\n\tfunction addChunk(stream, state, chunk, addToFront) {\n\t if (state.flowing && state.length === 0 && !state.sync) {\n\t\tstream.emit('data', chunk);\n\t\tstream.read(0);\n\t } else {\n\t\t// update the buffer info.\n\t\tstate.length += state.objectMode ? 1 : chunk.length;\n\t\tif (addToFront) {\n state.buffer.unshift(chunk);\n} else {\n state.buffer.push(chunk);\n}\n\n\t\tif (state.needReadable) {\n emitReadable(stream);\n}\n\t }\n\t maybeReadMore(stream, state);\n\t}\n\n\tfunction chunkInvalid(state, chunk) {\n\t let er;\n\t if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n\t\ter = new TypeError('Invalid non-string/buffer chunk');\n\t }\n\t return er;\n\t}\n\n\t// if it's past the high water mark, we can push in some more.\n\t// Also, if we have no data yet, we can stand some\n\t// more bytes. This is to work around cases where hwm=0,\n\t// such as the repl. Also, if the push() triggered a\n\t// readable event, and the user called read(largeNumber) such that\n\t// needReadable was set, then we ought to push more, so that another\n\t// 'readable' event will be triggered.\n\tfunction needMoreData(state) {\n\t return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);\n\t}\n\n\tReadable.prototype.isPaused = function () {\n\t return this._readableState.flowing === false;\n\t};\n\n\t// backwards compatibility.\n\tReadable.prototype.setEncoding = function (enc) {\n\t if (!StringDecoder) {\n StringDecoder = __webpack_require__(19).StringDecoder;\n}\n\t this._readableState.decoder = new StringDecoder(enc);\n\t this._readableState.encoding = enc;\n\t return this;\n\t};\n\n\t// Don't raise the hwm > 8MB\n\tconst MAX_HWM = 0x800000;\n\tfunction computeNewHighWaterMark(n) {\n\t if (n >= MAX_HWM) {\n\t\tn = MAX_HWM;\n\t } else {\n\t\t// Get the next highest power of 2 to prevent increasing hwm excessively in\n\t\t// tiny amounts\n\t\tn--;\n\t\tn |= n >>> 1;\n\t\tn |= n >>> 2;\n\t\tn |= n >>> 4;\n\t\tn |= n >>> 8;\n\t\tn |= n >>> 16;\n\t\tn++;\n\t }\n\t return n;\n\t}\n\n\t// This function is designed to be inlinable, so please take care when making\n\t// changes to the function body.\n\tfunction howMuchToRead(n, state) {\n\t if (n <= 0 || state.length === 0 && state.ended) {\n return 0;\n}\n\t if (state.objectMode) {\n return 1;\n}\n\t if (n !== n) {\n\t\t// Only flow one buffer at a time\n\t\tif (state.flowing && state.length) {\n return state.buffer.head.data.length;\n} return state.length;\n\t }\n\t // If we're asking for more than the current hwm, then raise the hwm.\n\t if (n > state.highWaterMark) {\n state.highWaterMark = computeNewHighWaterMark(n);\n}\n\t if (n <= state.length) {\n return n;\n}\n\t // Don't have enough\n\t if (!state.ended) {\n\t\tstate.needReadable = true;\n\t\treturn 0;\n\t }\n\t return state.length;\n\t}\n\n\t// you can override either this method, or the async _read(n) below.\n\tReadable.prototype.read = function (n) {\n\t debug('read', n);\n\t n = parseInt(n, 10);\n\t const state = this._readableState;\n\t const nOrig = n;\n\n\t if (n !== 0) {\n state.emittedReadable = false;\n}\n\n\t // if we're doing read(0) to trigger a readable event, but we\n\t // already have a bunch of data in the buffer, then just trigger\n\t // the 'readable' event and move on.\n\t if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {\n\t\tdebug('read: emitReadable', state.length, state.ended);\n\t\tif (state.length === 0 && state.ended) {\n endReadable(this);\n} else {\n emitReadable(this);\n}\n\t\treturn null;\n\t }\n\n\t n = howMuchToRead(n, state);\n\n\t // if we've ended, and we're now clear, then finish it up.\n\t if (n === 0 && state.ended) {\n\t\tif (state.length === 0) {\n endReadable(this);\n}\n\t\treturn null;\n\t }\n\n\t // All the actual chunk generation logic needs to be\n\t // *below* the call to _read. The reason is that in certain\n\t // synthetic stream cases, such as passthrough streams, _read\n\t // may be a completely synchronous operation which may change\n\t // the state of the read buffer, providing enough data when\n\t // before there was *not* enough.\n\t //\n\t // So, the steps are:\n\t // 1. Figure out what the state of things will be after we do\n\t // a read from the buffer.\n\t //\n\t // 2. If that resulting state will trigger a _read, then call _read.\n\t // Note that this may be asynchronous, or synchronous. Yes, it is\n\t // deeply ugly to write APIs this way, but that still doesn't mean\n\t // that the Readable class should behave improperly, as streams are\n\t // designed to be sync/async agnostic.\n\t // Take note if the _read call is sync or async (ie, if the read call\n\t // has returned yet), so that we know whether or not it's safe to emit\n\t // 'readable' etc.\n\t //\n\t // 3. Actually pull the requested chunks out of the buffer and return.\n\n\t // if we need a readable event, then we need to do some reading.\n\t let doRead = state.needReadable;\n\t debug('need readable', doRead);\n\n\t // if we currently have less than the highWaterMark, then also read some\n\t if (state.length === 0 || state.length - n < state.highWaterMark) {\n\t\tdoRead = true;\n\t\tdebug('length less than watermark', doRead);\n\t }\n\n\t // however, if we've ended, then there's no point, and if we're already\n\t // reading, then it's unnecessary.\n\t if (state.ended || state.reading) {\n\t\tdoRead = false;\n\t\tdebug('reading or ended', doRead);\n\t } else if (doRead) {\n\t\tdebug('do read');\n\t\tstate.reading = true;\n\t\tstate.sync = true;\n\t\t// if the length is currently zero, then we *need* a readable event.\n\t\tif (state.length === 0) {\n state.needReadable = true;\n}\n\t\t// call internal read method\n\t\tthis._read(state.highWaterMark);\n\t\tstate.sync = false;\n\t\t// If _read pushed data synchronously, then `reading` will be false,\n\t\t// and we need to re-evaluate how much data we can return to the user.\n\t\tif (!state.reading) {\n n = howMuchToRead(nOrig, state);\n}\n\t }\n\n\t let ret;\n\t if (n > 0) {\n ret = fromList(n, state);\n} else {\n ret = null;\n}\n\n\t if (ret === null) {\n\t\tstate.needReadable = true;\n\t\tn = 0;\n\t } else {\n\t\tstate.length -= n;\n\t }\n\n\t if (state.length === 0) {\n\t\t// If we have nothing in the buffer, then we want to know\n\t\t// as soon as we *do* get something into the buffer.\n\t\tif (!state.ended) {\n state.needReadable = true;\n}\n\n\t\t// If we tried to read() past the EOF, then emit end on the next tick.\n\t\tif (nOrig !== n && state.ended) {\n endReadable(this);\n}\n\t }\n\n\t if (ret !== null) {\n this.emit('data', ret);\n}\n\n\t return ret;\n\t};\n\n\tfunction onEofChunk(stream, state) {\n\t if (state.ended) {\n return;\n}\n\t if (state.decoder) {\n\t\tconst chunk = state.decoder.end();\n\t\tif (chunk && chunk.length) {\n\t\t state.buffer.push(chunk);\n\t\t state.length += state.objectMode ? 1 : chunk.length;\n\t\t}\n\t }\n\t state.ended = true;\n\n\t // emit 'readable' now to make sure it gets picked up.\n\t emitReadable(stream);\n\t}\n\n\t// Don't emit readable right away in sync mode, because this can trigger\n\t// another read() call => stack overflow. This way, it might trigger\n\t// a nextTick recursion warning, but that's not so bad.\n\tfunction emitReadable(stream) {\n\t const state = stream._readableState;\n\t state.needReadable = false;\n\t if (!state.emittedReadable) {\n\t\tdebug('emitReadable', state.flowing);\n\t\tstate.emittedReadable = true;\n\t\tif (state.sync) {\n pna.nextTick(emitReadable_, stream);\n} else {\n emitReadable_(stream);\n}\n\t }\n\t}\n\n\tfunction emitReadable_(stream) {\n\t debug('emit readable');\n\t stream.emit('readable');\n\t flow(stream);\n\t}\n\n\t// at this point, the user has presumably seen the 'readable' event,\n\t// and called read() to consume some data. that may have triggered\n\t// in turn another _read(n) call, in which case reading = true if\n\t// it's in progress.\n\t// However, if we're not ended, or reading, and the length < hwm,\n\t// then go ahead and try to read some more preemptively.\n\tfunction maybeReadMore(stream, state) {\n\t if (!state.readingMore) {\n\t\tstate.readingMore = true;\n\t\tpna.nextTick(maybeReadMore_, stream, state);\n\t }\n\t}\n\n\tfunction maybeReadMore_(stream, state) {\n\t let len = state.length;\n\t while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {\n\t\tdebug('maybeReadMore read 0');\n\t\tstream.read(0);\n\t\tif (len === state.length)\n\t\t // didn't get any data, stop spinning.\n\t\t {\n break;\n} else {\n len = state.length;\n}\n\t }\n\t state.readingMore = false;\n\t}\n\n\t// abstract method. to be overridden in specific implementation classes.\n\t// call cb(er, data) where data is <= n in length.\n\t// for virtual (non-string, non-buffer) streams, \"length\" is somewhat\n\t// arbitrary, and perhaps not very meaningful.\n\tReadable.prototype._read = function (n) {\n\t this.emit('error', new Error('_read() is not implemented'));\n\t};\n\n\tReadable.prototype.pipe = function (dest, pipeOpts) {\n\t const src = this;\n\t const state = this._readableState;\n\n\t switch (state.pipesCount) {\n\t\tcase 0:\n\t\t state.pipes = dest;\n\t\t break;\n\t\tcase 1:\n\t\t state.pipes = [state.pipes, dest];\n\t\t break;\n\t\tdefault:\n\t\t state.pipes.push(dest);\n\t\t break;\n\t }\n\t state.pipesCount += 1;\n\t debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);\n\n\t const doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;\n\n\t const endFn = doEnd ? onend : unpipe;\n\t if (state.endEmitted) {\n pna.nextTick(endFn);\n} else {\n src.once('end', endFn);\n}\n\n\t dest.on('unpipe', onunpipe);\n\t function onunpipe(readable, unpipeInfo) {\n\t\tdebug('onunpipe');\n\t\tif (readable === src) {\n\t\t if (unpipeInfo && unpipeInfo.hasUnpiped === false) {\n\t\t\tunpipeInfo.hasUnpiped = true;\n\t\t\tcleanup();\n\t\t }\n\t\t}\n\t }\n\n\t function onend() {\n\t\tdebug('onend');\n\t\tdest.end();\n\t }\n\n\t // when the dest drains, it reduces the awaitDrain counter\n\t // on the source. This would be more elegant with a .once()\n\t // handler in flow(), but adding and removing repeatedly is\n\t // too slow.\n\t const ondrain = pipeOnDrain(src);\n\t dest.on('drain', ondrain);\n\n\t let cleanedUp = false;\n\t function cleanup() {\n\t\tdebug('cleanup');\n\t\t// cleanup event handlers once the pipe is broken\n\t\tdest.removeListener('close', onclose);\n\t\tdest.removeListener('finish', onfinish);\n\t\tdest.removeListener('drain', ondrain);\n\t\tdest.removeListener('error', onerror);\n\t\tdest.removeListener('unpipe', onunpipe);\n\t\tsrc.removeListener('end', onend);\n\t\tsrc.removeListener('end', unpipe);\n\t\tsrc.removeListener('data', ondata);\n\n\t\tcleanedUp = true;\n\n\t\t// if the reader is waiting for a drain event from this\n\t\t// specific writer, then it would cause it to never start\n\t\t// flowing again.\n\t\t// So, if this is awaiting a drain, then we just call it now.\n\t\t// If we don't know, then assume that we are waiting for one.\n\t\tif (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) {\n ondrain();\n}\n\t }\n\n\t // If the user pushes more data while we're writing to dest then we'll end up\n\t // in ondata again. However, we only want to increase awaitDrain once because\n\t // dest will only emit one 'drain' event for the multiple writes.\n\t // => Introduce a guard on increasing awaitDrain.\n\t let increasedAwaitDrain = false;\n\t src.on('data', ondata);\n\t function ondata(chunk) {\n\t\tdebug('ondata');\n\t\tincreasedAwaitDrain = false;\n\t\tconst ret = dest.write(chunk);\n\t\tif (ret === false && !increasedAwaitDrain) {\n\t\t // If the user unpiped during `dest.write()`, it is possible\n\t\t // to get stuck in a permanently paused state if that write\n\t\t // also returned false.\n\t\t // => Check whether `dest` is still a piping destination.\n\t\t if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {\n\t\t\tdebug('false write response, pause', src._readableState.awaitDrain);\n\t\t\tsrc._readableState.awaitDrain++;\n\t\t\tincreasedAwaitDrain = true;\n\t\t }\n\t\t src.pause();\n\t\t}\n\t }\n\n\t // if the dest has an error, then stop piping into it.\n\t // however, don't suppress the throwing behavior for this.\n\t function onerror(er) {\n\t\tdebug('onerror', er);\n\t\tunpipe();\n\t\tdest.removeListener('error', onerror);\n\t\tif (EElistenerCount(dest, 'error') === 0) {\n dest.emit('error', er);\n}\n\t }\n\n\t // Make sure our error handler is attached before userland ones.\n\t prependListener(dest, 'error', onerror);\n\n\t // Both close and finish should trigger unpipe, but only once.\n\t function onclose() {\n\t\tdest.removeListener('finish', onfinish);\n\t\tunpipe();\n\t }\n\t dest.once('close', onclose);\n\t function onfinish() {\n\t\tdebug('onfinish');\n\t\tdest.removeListener('close', onclose);\n\t\tunpipe();\n\t }\n\t dest.once('finish', onfinish);\n\n\t function unpipe() {\n\t\tdebug('unpipe');\n\t\tsrc.unpipe(dest);\n\t }\n\n\t // tell the dest that it's being piped to\n\t dest.emit('pipe', src);\n\n\t // start the flow if it hasn't been started already.\n\t if (!state.flowing) {\n\t\tdebug('pipe resume');\n\t\tsrc.resume();\n\t }\n\n\t return dest;\n\t};\n\n\tfunction pipeOnDrain(src) {\n\t return function () {\n\t\tconst state = src._readableState;\n\t\tdebug('pipeOnDrain', state.awaitDrain);\n\t\tif (state.awaitDrain) {\n state.awaitDrain--;\n}\n\t\tif (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {\n\t\t state.flowing = true;\n\t\t flow(src);\n\t\t}\n\t };\n\t}\n\n\tReadable.prototype.unpipe = function (dest) {\n\t const state = this._readableState;\n\t const unpipeInfo = { hasUnpiped: false };\n\n\t // if we're not piping anywhere, then do nothing.\n\t if (state.pipesCount === 0) {\n return this;\n}\n\n\t // just one destination. most common case.\n\t if (state.pipesCount === 1) {\n\t\t// passed in one, but it's not the right one.\n\t\tif (dest && dest !== state.pipes) {\n return this;\n}\n\n\t\tif (!dest) {\n dest = state.pipes;\n}\n\n\t\t// got a match.\n\t\tstate.pipes = null;\n\t\tstate.pipesCount = 0;\n\t\tstate.flowing = false;\n\t\tif (dest) {\n dest.emit('unpipe', this, unpipeInfo);\n}\n\t\treturn this;\n\t }\n\n\t // slow case. multiple pipe destinations.\n\n\t if (!dest) {\n\t\t// remove all.\n\t\tconst dests = state.pipes;\n\t\tconst len = state.pipesCount;\n\t\tstate.pipes = null;\n\t\tstate.pipesCount = 0;\n\t\tstate.flowing = false;\n\n\t\tfor (let i = 0; i < len; i++) {\n\t\t dests[i].emit('unpipe', this, unpipeInfo);\n\t\t} return this;\n\t }\n\n\t // try to find the right one.\n\t const index = indexOf(state.pipes, dest);\n\t if (index === -1) {\n return this;\n}\n\n\t state.pipes.splice(index, 1);\n\t state.pipesCount -= 1;\n\t if (state.pipesCount === 1) {\n state.pipes = state.pipes[0];\n}\n\n\t dest.emit('unpipe', this, unpipeInfo);\n\n\t return this;\n\t};\n\n\t// set up data events if they are asked for\n\t// Ensure readable listeners eventually get something\n\tReadable.prototype.on = function (ev, fn) {\n\t const res = Stream.prototype.on.call(this, ev, fn);\n\n\t if (ev === 'data') {\n\t\t// Start flowing on next tick if stream isn't explicitly paused\n\t\tif (this._readableState.flowing !== false) {\n this.resume();\n}\n\t } else if (ev === 'readable') {\n\t\tconst state = this._readableState;\n\t\tif (!state.endEmitted && !state.readableListening) {\n\t\t state.readableListening = state.needReadable = true;\n\t\t state.emittedReadable = false;\n\t\t if (!state.reading) {\n\t\t\tpna.nextTick(nReadingNextTick, this);\n\t\t } else if (state.length) {\n\t\t\temitReadable(this);\n\t\t }\n\t\t}\n\t }\n\n\t return res;\n\t};\n\tReadable.prototype.addListener = Readable.prototype.on;\n\n\tfunction nReadingNextTick(self) {\n\t debug('readable nexttick read 0');\n\t self.read(0);\n\t}\n\n\t// pause() and resume() are remnants of the legacy readable stream API\n\t// If the user uses them, then switch into old mode.\n\tReadable.prototype.resume = function () {\n\t const state = this._readableState;\n\t if (!state.flowing) {\n\t\tdebug('resume');\n\t\tstate.flowing = true;\n\t\tresume(this, state);\n\t }\n\t return this;\n\t};\n\n\tfunction resume(stream, state) {\n\t if (!state.resumeScheduled) {\n\t\tstate.resumeScheduled = true;\n\t\tpna.nextTick(resume_, stream, state);\n\t }\n\t}\n\n\tfunction resume_(stream, state) {\n\t if (!state.reading) {\n\t\tdebug('resume read 0');\n\t\tstream.read(0);\n\t }\n\n\t state.resumeScheduled = false;\n\t state.awaitDrain = 0;\n\t stream.emit('resume');\n\t flow(stream);\n\t if (state.flowing && !state.reading) {\n stream.read(0);\n}\n\t}\n\n\tReadable.prototype.pause = function () {\n\t debug('call pause flowing=%j', this._readableState.flowing);\n\t if (this._readableState.flowing !== false) {\n\t\tdebug('pause');\n\t\tthis._readableState.flowing = false;\n\t\tthis.emit('pause');\n\t }\n\t return this;\n\t};\n\n\tfunction flow(stream) {\n\t const state = stream._readableState;\n\t debug('flow', state.flowing);\n\t while (state.flowing && stream.read() !== null) {}\n\t}\n\n\t// wrap an old-style stream as the async data source.\n\t// This is *not* part of the readable stream interface.\n\t// It is an ugly unfortunate mess of history.\n\tReadable.prototype.wrap = function (stream) {\n\t const _this = this;\n\n\t const state = this._readableState;\n\t let paused = false;\n\n\t stream.on('end', () => {\n\t\tdebug('wrapped end');\n\t\tif (state.decoder && !state.ended) {\n\t\t const chunk = state.decoder.end();\n\t\t if (chunk && chunk.length) {\n _this.push(chunk);\n}\n\t\t}\n\n\t\t_this.push(null);\n\t });\n\n\t stream.on('data', (chunk) => {\n\t\tdebug('wrapped data');\n\t\tif (state.decoder) {\n chunk = state.decoder.write(chunk);\n}\n\n\t\t// don't skip over falsy values in objectMode\n\t\tif (state.objectMode && (chunk === null || chunk === undefined)) {\n return;\n} else if (!state.objectMode && (!chunk || !chunk.length)) {\n return;\n}\n\n\t\tconst ret = _this.push(chunk);\n\t\tif (!ret) {\n\t\t paused = true;\n\t\t stream.pause();\n\t\t}\n\t });\n\n\t // proxy all the other methods.\n\t // important when wrapping filters and duplexes.\n\t for (const i in stream) {\n\t\tif (this[i] === undefined && typeof stream[i] === 'function') {\n\t\t this[i] = (function (method) {\n\t\t\treturn function () {\n\t\t\t return stream[method].apply(stream, arguments);\n\t\t\t};\n\t\t }(i));\n\t\t}\n\t }\n\n\t // proxy certain important events.\n\t for (let n = 0; n < kProxyEvents.length; n++) {\n\t\tstream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));\n\t }\n\n\t // when we try to consume some more bytes, simply unpause the\n\t // underlying stream.\n\t this._read = function (n) {\n\t\tdebug('wrapped _read', n);\n\t\tif (paused) {\n\t\t paused = false;\n\t\t stream.resume();\n\t\t}\n\t };\n\n\t return this;\n\t};\n\n\tObject.defineProperty(Readable.prototype, 'readableHighWaterMark', {\n\t // making it explicit this property is not enumerable\n\t // because otherwise some prototype manipulation in\n\t // userland will fail\n\t enumerable: false,\n\t get() {\n\t\treturn this._readableState.highWaterMark;\n\t }\n\t});\n\n\t// exposed for testing purposes only.\n\tReadable._fromList = fromList;\n\n\t// Pluck off n bytes from an array of buffers.\n\t// Length is the combined lengths of all the buffers in the list.\n\t// This function is designed to be inlinable, so please take care when making\n\t// changes to the function body.\n\tfunction fromList(n, state) {\n\t // nothing buffered\n\t if (state.length === 0) {\n return null;\n}\n\n\t let ret;\n\t if (state.objectMode) {\n ret = state.buffer.shift();\n} else if (!n || n >= state.length) {\n\t\t// read it all, truncate the list\n\t\tif (state.decoder) {\n ret = state.buffer.join('');\n} else if (state.buffer.length === 1) {\n ret = state.buffer.head.data;\n} else {\n ret = state.buffer.concat(state.length);\n}\n\t\tstate.buffer.clear();\n\t } else {\n\t\t// read part of list\n\t\tret = fromListPartial(n, state.buffer, state.decoder);\n\t }\n\n\t return ret;\n\t}\n\n\t// Extracts only enough buffered data to satisfy the amount requested.\n\t// This function is designed to be inlinable, so please take care when making\n\t// changes to the function body.\n\tfunction fromListPartial(n, list, hasStrings) {\n\t let ret;\n\t if (n < list.head.data.length) {\n\t\t// slice is the same for buffers and strings\n\t\tret = list.head.data.slice(0, n);\n\t\tlist.head.data = list.head.data.slice(n);\n\t } else if (n === list.head.data.length) {\n\t\t// first chunk is a perfect match\n\t\tret = list.shift();\n\t } else {\n\t\t// result spans more than one buffer\n\t\tret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);\n\t }\n\t return ret;\n\t}\n\n\t// Copies a specified amount of characters from the list of buffered data\n\t// chunks.\n\t// This function is designed to be inlinable, so please take care when making\n\t// changes to the function body.\n\tfunction copyFromBufferString(n, list) {\n\t let p = list.head;\n\t let c = 1;\n\t let ret = p.data;\n\t n -= ret.length;\n\t while (p = p.next) {\n\t\tconst str = p.data;\n\t\tconst nb = n > str.length ? str.length : n;\n\t\tif (nb === str.length) {\n ret += str;\n} else {\n ret += str.slice(0, n);\n}\n\t\tn -= nb;\n\t\tif (n === 0) {\n\t\t if (nb === str.length) {\n\t\t\t++c;\n\t\t\tif (p.next) {\n list.head = p.next;\n} else {\n list.head = list.tail = null;\n}\n\t\t } else {\n\t\t\tlist.head = p;\n\t\t\tp.data = str.slice(nb);\n\t\t }\n\t\t break;\n\t\t}\n\t\t++c;\n\t }\n\t list.length -= c;\n\t return ret;\n\t}\n\n\t// Copies a specified amount of bytes from the list of buffered data chunks.\n\t// This function is designed to be inlinable, so please take care when making\n\t// changes to the function body.\n\tfunction copyFromBuffer(n, list) {\n\t const ret = Buffer.allocUnsafe(n);\n\t let p = list.head;\n\t let c = 1;\n\t p.data.copy(ret);\n\t n -= p.data.length;\n\t while (p = p.next) {\n\t\tconst buf = p.data;\n\t\tconst nb = n > buf.length ? buf.length : n;\n\t\tbuf.copy(ret, ret.length - n, 0, nb);\n\t\tn -= nb;\n\t\tif (n === 0) {\n\t\t if (nb === buf.length) {\n\t\t\t++c;\n\t\t\tif (p.next) {\n list.head = p.next;\n} else {\n list.head = list.tail = null;\n}\n\t\t } else {\n\t\t\tlist.head = p;\n\t\t\tp.data = buf.slice(nb);\n\t\t }\n\t\t break;\n\t\t}\n\t\t++c;\n\t }\n\t list.length -= c;\n\t return ret;\n\t}\n\n\tfunction endReadable(stream) {\n\t const state = stream._readableState;\n\n\t // If we get here before consuming all the bytes, then that is a\n\t // bug in node. Should never happen.\n\t if (state.length > 0) {\n throw new Error('\"endReadable()\" called on non-empty stream');\n}\n\n\t if (!state.endEmitted) {\n\t\tstate.ended = true;\n\t\tpna.nextTick(endReadableNT, state, stream);\n\t }\n\t}\n\n\tfunction endReadableNT(state, stream) {\n\t // Check that we didn't get one last unshift.\n\t if (!state.endEmitted && state.length === 0) {\n\t\tstate.endEmitted = true;\n\t\tstream.readable = false;\n\t\tstream.emit('end');\n\t }\n\t}\n\n\tfunction indexOf(xs, x) {\n\t for (let i = 0, l = xs.length; i < l; i++) {\n\t\tif (xs[i] === x) {\n return i;\n}\n\t }\n\t return -1;\n\t}\n\t/* WEBPACK VAR INJECTION */ }.call(exports, __webpack_require__(0), __webpack_require__(1)));\n\t/** */ }),\n\t/* 16 */\n\t/** */ (function (module, exports, __webpack_require__) {\n\tmodule.exports = __webpack_require__(8).EventEmitter;\n\t/** */ }),\n\t/* 17 */\n\t/** */ (function (module, exports, __webpack_require__) {\n\t\"use strict\";\n\n\n\t/* */\n\n\tconst pna = __webpack_require__(6);\n\t/* */\n\n\t// undocumented cb() API, needed for core, not for public API\n\tfunction destroy(err, cb) {\n\t const _this = this;\n\n\t const readableDestroyed = this._readableState && this._readableState.destroyed;\n\t const writableDestroyed = this._writableState && this._writableState.destroyed;\n\n\t if (readableDestroyed || writableDestroyed) {\n\t\tif (cb) {\n\t\t cb(err);\n\t\t} else if (err && (!this._writableState || !this._writableState.errorEmitted)) {\n\t\t pna.nextTick(emitErrorNT, this, err);\n\t\t}\n\t\treturn this;\n\t }\n\n\t // we set destroyed to true before firing error callbacks in order\n\t // to make it re-entrance safe in case destroy() is called within callbacks\n\n\t if (this._readableState) {\n\t\tthis._readableState.destroyed = true;\n\t }\n\n\t // if this is a duplex stream mark the writable part as destroyed as well\n\t if (this._writableState) {\n\t\tthis._writableState.destroyed = true;\n\t }\n\n\t this._destroy(err || null, (err) => {\n\t\tif (!cb && err) {\n\t\t pna.nextTick(emitErrorNT, _this, err);\n\t\t if (_this._writableState) {\n\t\t\t_this._writableState.errorEmitted = true;\n\t\t }\n\t\t} else if (cb) {\n\t\t cb(err);\n\t\t}\n\t });\n\n\t return this;\n\t}\n\n\tfunction undestroy() {\n\t if (this._readableState) {\n\t\tthis._readableState.destroyed = false;\n\t\tthis._readableState.reading = false;\n\t\tthis._readableState.ended = false;\n\t\tthis._readableState.endEmitted = false;\n\t }\n\n\t if (this._writableState) {\n\t\tthis._writableState.destroyed = false;\n\t\tthis._writableState.ended = false;\n\t\tthis._writableState.ending = false;\n\t\tthis._writableState.finished = false;\n\t\tthis._writableState.errorEmitted = false;\n\t }\n\t}\n\n\tfunction emitErrorNT(self, err) {\n\t self.emit('error', err);\n\t}\n\n\tmodule.exports = {\n\t destroy,\n\t undestroy\n\t};\n\t/** */ }),\n\t/* 18 */\n\t/** */ (function (module, exports, __webpack_require__) {\n\t\"use strict\";\n\t/* WEBPACK VAR INJECTION */(function (process, setImmediate, global) { // Copyright Joyent, Inc. and other Node contributors.\n\t//\n\t// Permission is hereby granted, free of charge, to any person obtaining a\n\t// copy of this software and associated documentation files (the\n\t// \"Software\"), to deal in the Software without restriction, including\n\t// without limitation the rights to use, copy, modify, merge, publish,\n\t// distribute, sublicense, and/or sell copies of the Software, and to permit\n\t// persons to whom the Software is furnished to do so, subject to the\n\t// following conditions:\n\t//\n\t// The above copyright notice and this permission notice shall be included\n\t// in all copies or substantial portions of the Software.\n\t//\n\t// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n\t// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n\t// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n\t// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n\t// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n\t// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n\t// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n\t// A bit simpler than readable streams.\n\t// Implement an async ._write(chunk, encoding, cb), and it'll handle all\n\t// the drain event emission and buffering.\n\n\n\t/* */\n\n\tconst pna = __webpack_require__(6);\n\t/* */\n\n\tmodule.exports = Writable;\n\n\t/* */\n\tfunction WriteReq(chunk, encoding, cb) {\n\t this.chunk = chunk;\n\t this.encoding = encoding;\n\t this.callback = cb;\n\t this.next = null;\n\t}\n\n\t// It seems a linked list but it is not\n\t// there will be only 2 of these for each stream\n\tfunction CorkedRequest(state) {\n\t const _this = this;\n\n\t this.next = null;\n\t this.entry = null;\n\t this.finish = function () {\n\t\tonCorkedFinish(_this, state);\n\t };\n\t}\n\t/* */\n\n\t/* */\n\tconst asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;\n\t/* */\n\n\t/* */\n\tlet Duplex;\n\t/* */\n\n\tWritable.WritableState = WritableState;\n\n\t/* */\n\tconst util = __webpack_require__(4);\n\tutil.inherits = __webpack_require__(5);\n\t/* */\n\n\t/* */\n\tconst internalUtil = {\n\t deprecate: __webpack_require__(44)\n\t};\n\t/* */\n\n\t/* */\n\tconst Stream = __webpack_require__(16);\n\t/* */\n\n\t/* */\n\n\tconst Buffer = __webpack_require__(9).Buffer;\n\tconst OurUint8Array = global.Uint8Array || function () {};\n\tfunction _uint8ArrayToBuffer(chunk) {\n\t return Buffer.from(chunk);\n\t}\n\tfunction _isUint8Array(obj) {\n\t return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n\t}\n\n\t/* */\n\n\tconst destroyImpl = __webpack_require__(17);\n\n\tutil.inherits(Writable, Stream);\n\n\tfunction nop() {}\n\n\tfunction WritableState(options, stream) {\n\t Duplex = Duplex || __webpack_require__(3);\n\n\t options = options || {};\n\n\t // Duplex streams are both readable and writable, but share\n\t // the same options object.\n\t // However, some cases require setting options to different\n\t // values for the readable and the writable sides of the duplex stream.\n\t // These options can be provided separately as readableXXX and writableXXX.\n\t const isDuplex = stream instanceof Duplex;\n\n\t // object stream flag to indicate whether or not this stream\n\t // contains buffers or objects.\n\t this.objectMode = !!options.objectMode;\n\n\t if (isDuplex) {\n this.objectMode = this.objectMode || !!options.writableObjectMode;\n}\n\n\t // the point at which write() starts returning false\n\t // Note: 0 is a valid value, means that we always return false if\n\t // the entire buffer is not flushed immediately on write()\n\t const hwm = options.highWaterMark;\n\t const writableHwm = options.writableHighWaterMark;\n\t const defaultHwm = this.objectMode ? 16 : 16 * 1024;\n\n\t if (hwm || hwm === 0) {\n this.highWaterMark = hwm;\n} else if (isDuplex && (writableHwm || writableHwm === 0)) {\n this.highWaterMark = writableHwm;\n} else {\n this.highWaterMark = defaultHwm;\n}\n\n\t // cast to ints.\n\t this.highWaterMark = Math.floor(this.highWaterMark);\n\n\t // if _final has been called\n\t this.finalCalled = false;\n\n\t // drain event flag.\n\t this.needDrain = false;\n\t // at the start of calling end()\n\t this.ending = false;\n\t // when end() has been called, and returned\n\t this.ended = false;\n\t // when 'finish' is emitted\n\t this.finished = false;\n\n\t // has it been destroyed\n\t this.destroyed = false;\n\n\t // should we decode strings into buffers before passing to _write?\n\t // this is here so that some node-core streams can optimize string\n\t // handling at a lower level.\n\t const noDecode = options.decodeStrings === false;\n\t this.decodeStrings = !noDecode;\n\n\t // Crypto is kind of old and crusty. Historically, its default string\n\t // encoding is 'binary' so we have to make this configurable.\n\t // Everything else in the universe uses 'utf8', though.\n\t this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n\t // not an actual buffer we keep track of, but a measurement\n\t // of how much we're waiting to get pushed to some underlying\n\t // socket or file.\n\t this.length = 0;\n\n\t // a flag to see when we're in the middle of a write.\n\t this.writing = false;\n\n\t // when true all writes will be buffered until .uncork() call\n\t this.corked = 0;\n\n\t // a flag to be able to tell if the onwrite cb is called immediately,\n\t // or on a later tick. We set this to true at first, because any\n\t // actions that shouldn't happen until \"later\" should generally also\n\t // not happen before the first write call.\n\t this.sync = true;\n\n\t // a flag to know if we're processing previously buffered items, which\n\t // may call the _write() callback in the same tick, so that we don't\n\t // end up in an overlapped onwrite situation.\n\t this.bufferProcessing = false;\n\n\t // the callback that's passed to _write(chunk,cb)\n\t this.onwrite = function (er) {\n\t\tonwrite(stream, er);\n\t };\n\n\t // the callback that the user supplies to write(chunk,encoding,cb)\n\t this.writecb = null;\n\n\t // the amount that is being written when _write is called.\n\t this.writelen = 0;\n\n\t this.bufferedRequest = null;\n\t this.lastBufferedRequest = null;\n\n\t // number of pending user-supplied write callbacks\n\t // this must be 0 before 'finish' can be emitted\n\t this.pendingcb = 0;\n\n\t // emit prefinish if the only thing we're waiting for is _write cbs\n\t // This is relevant for synchronous Transform streams\n\t this.prefinished = false;\n\n\t // True if the error was already emitted and should not be thrown again\n\t this.errorEmitted = false;\n\n\t // count buffered requests\n\t this.bufferedRequestCount = 0;\n\n\t // allocate the first CorkedRequest, there is always\n\t // one allocated and free to use, and we maintain at most two\n\t this.corkedRequestsFree = new CorkedRequest(this);\n\t}\n\n\tWritableState.prototype.getBuffer = function getBuffer() {\n\t let current = this.bufferedRequest;\n\t const out = [];\n\t while (current) {\n\t\tout.push(current);\n\t\tcurrent = current.next;\n\t }\n\t return out;\n\t};\n\n\t(function () {\n\t try {\n\t\tObject.defineProperty(WritableState.prototype, 'buffer', {\n\t\t get: internalUtil.deprecate(function () {\n\t\t\treturn this.getBuffer();\n\t\t }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')\n\t\t});\n\t } catch (_) {}\n\t})();\n\n\t// Test _writableState for inheritance to account for Duplex streams,\n\t// whose prototype chain only points to Readable.\n\tlet realHasInstance;\n\tif (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {\n\t realHasInstance = Function.prototype[Symbol.hasInstance];\n\t Object.defineProperty(Writable, Symbol.hasInstance, {\n\t\tvalue(object) {\n\t\t if (realHasInstance.call(this, object)) {\n return true;\n}\n\t\t if (this !== Writable) {\n return false;\n}\n\n\t\t return object && object._writableState instanceof WritableState;\n\t\t}\n\t });\n\t} else {\n\t realHasInstance = function (object) {\n\t\treturn object instanceof this;\n\t };\n\t}\n\n\tfunction Writable(options) {\n\t Duplex = Duplex || __webpack_require__(3);\n\n\t // Writable ctor is applied to Duplexes, too.\n\t // `realHasInstance` is necessary because using plain `instanceof`\n\t // would return false, as no `_writableState` property is attached.\n\n\t // Trying to use the custom `instanceof` for Writable here will also break the\n\t // Node.js LazyTransform implementation, which has a non-trivial getter for\n\t // `_writableState` that would lead to infinite recursion.\n\t if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {\n\t\treturn new Writable(options);\n\t }\n\n\t this._writableState = new WritableState(options, this);\n\n\t // legacy.\n\t this.writable = true;\n\n\t if (options) {\n\t\tif (typeof options.write === 'function') {\n this._write = options.write;\n}\n\n\t\tif (typeof options.writev === 'function') {\n this._writev = options.writev;\n}\n\n\t\tif (typeof options.destroy === 'function') {\n this._destroy = options.destroy;\n}\n\n\t\tif (typeof options.final === 'function') {\n this._final = options.final;\n}\n\t }\n\n\t Stream.call(this);\n\t}\n\n\t// Otherwise people can pipe Writable streams, which is just wrong.\n\tWritable.prototype.pipe = function () {\n\t this.emit('error', new Error('Cannot pipe, not readable'));\n\t};\n\n\tfunction writeAfterEnd(stream, cb) {\n\t const er = new Error('write after end');\n\t // TODO: defer error events consistently everywhere, not just the cb\n\t stream.emit('error', er);\n\t pna.nextTick(cb, er);\n\t}\n\n\t// Checks that a user-supplied chunk is valid, especially for the particular\n\t// mode the stream is in. Currently this means that `null` is never accepted\n\t// and undefined/non-string values are only allowed in object mode.\n\tfunction validChunk(stream, state, chunk, cb) {\n\t let valid = true;\n\t let er = false;\n\n\t if (chunk === null) {\n\t\ter = new TypeError('May not write null values to stream');\n\t } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n\t\ter = new TypeError('Invalid non-string/buffer chunk');\n\t }\n\t if (er) {\n\t\tstream.emit('error', er);\n\t\tpna.nextTick(cb, er);\n\t\tvalid = false;\n\t }\n\t return valid;\n\t}\n\n\tWritable.prototype.write = function (chunk, encoding, cb) {\n\t const state = this._writableState;\n\t let ret = false;\n\t const isBuf = !state.objectMode && _isUint8Array(chunk);\n\n\t if (isBuf && !Buffer.isBuffer(chunk)) {\n\t\tchunk = _uint8ArrayToBuffer(chunk);\n\t }\n\n\t if (typeof encoding === 'function') {\n\t\tcb = encoding;\n\t\tencoding = null;\n\t }\n\n\t if (isBuf) {\n encoding = 'buffer';\n} else if (!encoding) {\n encoding = state.defaultEncoding;\n}\n\n\t if (typeof cb !== 'function') {\n cb = nop;\n}\n\n\t if (state.ended) {\n writeAfterEnd(this, cb);\n} else if (isBuf || validChunk(this, state, chunk, cb)) {\n\t\tstate.pendingcb++;\n\t\tret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);\n\t }\n\n\t return ret;\n\t};\n\n\tWritable.prototype.cork = function () {\n\t const state = this._writableState;\n\n\t state.corked++;\n\t};\n\n\tWritable.prototype.uncork = function () {\n\t const state = this._writableState;\n\n\t if (state.corked) {\n\t\tstate.corked--;\n\n\t\tif (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) {\n clearBuffer(this, state);\n}\n\t }\n\t};\n\n\tWritable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n\t // node::ParseEncoding() requires lower case.\n\t if (typeof encoding === 'string') {\n encoding = encoding.toLowerCase();\n}\n\t if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) {\n throw new TypeError('Unknown encoding: ' + encoding);\n}\n\t this._writableState.defaultEncoding = encoding;\n\t return this;\n\t};\n\n\tfunction decodeChunk(state, chunk, encoding) {\n\t if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\n\t\tchunk = Buffer.from(chunk, encoding);\n\t }\n\t return chunk;\n\t}\n\n\tObject.defineProperty(Writable.prototype, 'writableHighWaterMark', {\n\t // making it explicit this property is not enumerable\n\t // because otherwise some prototype manipulation in\n\t // userland will fail\n\t enumerable: false,\n\t get() {\n\t\treturn this._writableState.highWaterMark;\n\t }\n\t});\n\n\t// if we're already writing something, then just put this\n\t// in the queue, and wait our turn. Otherwise, call _write\n\t// If we return false, then we need a drain event, so set that flag.\n\tfunction writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {\n\t if (!isBuf) {\n\t\tconst newChunk = decodeChunk(state, chunk, encoding);\n\t\tif (chunk !== newChunk) {\n\t\t isBuf = true;\n\t\t encoding = 'buffer';\n\t\t chunk = newChunk;\n\t\t}\n\t }\n\t const len = state.objectMode ? 1 : chunk.length;\n\n\t state.length += len;\n\n\t const ret = state.length < state.highWaterMark;\n\t // we must ensure that previous needDrain will not be reset to false.\n\t if (!ret) {\n state.needDrain = true;\n}\n\n\t if (state.writing || state.corked) {\n\t\tconst last = state.lastBufferedRequest;\n\t\tstate.lastBufferedRequest = {\n\t\t chunk,\n\t\t encoding,\n\t\t isBuf,\n\t\t callback: cb,\n\t\t next: null\n\t\t};\n\t\tif (last) {\n\t\t last.next = state.lastBufferedRequest;\n\t\t} else {\n\t\t state.bufferedRequest = state.lastBufferedRequest;\n\t\t}\n\t\tstate.bufferedRequestCount += 1;\n\t } else {\n\t\tdoWrite(stream, state, false, len, chunk, encoding, cb);\n\t }\n\n\t return ret;\n\t}\n\n\tfunction doWrite(stream, state, writev, len, chunk, encoding, cb) {\n\t state.writelen = len;\n\t state.writecb = cb;\n\t state.writing = true;\n\t state.sync = true;\n\t if (writev) {\n stream._writev(chunk, state.onwrite);\n} else {\n stream._write(chunk, encoding, state.onwrite);\n}\n\t state.sync = false;\n\t}\n\n\tfunction onwriteError(stream, state, sync, er, cb) {\n\t --state.pendingcb;\n\n\t if (sync) {\n\t\t// defer the callback if we are being called synchronously\n\t\t// to avoid piling up things on the stack\n\t\tpna.nextTick(cb, er);\n\t\t// this can emit finish, and it will always happen\n\t\t// after error\n\t\tpna.nextTick(finishMaybe, stream, state);\n\t\tstream._writableState.errorEmitted = true;\n\t\tstream.emit('error', er);\n\t } else {\n\t\t// the caller expect this to happen before if\n\t\t// it is async\n\t\tcb(er);\n\t\tstream._writableState.errorEmitted = true;\n\t\tstream.emit('error', er);\n\t\t// this can emit finish, but finish must\n\t\t// always follow error\n\t\tfinishMaybe(stream, state);\n\t }\n\t}\n\n\tfunction onwriteStateUpdate(state) {\n\t state.writing = false;\n\t state.writecb = null;\n\t state.length -= state.writelen;\n\t state.writelen = 0;\n\t}\n\n\tfunction onwrite(stream, er) {\n\t const state = stream._writableState;\n\t const sync = state.sync;\n\t const cb = state.writecb;\n\n\t onwriteStateUpdate(state);\n\n\t if (er) {\n onwriteError(stream, state, sync, er, cb);\n} else {\n\t\t// Check if we're actually ready to finish, but don't emit yet\n\t\tconst finished = needFinish(state);\n\n\t\tif (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n\t\t clearBuffer(stream, state);\n\t\t}\n\n\t\tif (sync) {\n\t\t /* */\n\t\t asyncWrite(afterWrite, stream, state, finished, cb);\n\t\t /* */\n\t\t} else {\n\t\t afterWrite(stream, state, finished, cb);\n\t\t}\n\t }\n\t}\n\n\tfunction afterWrite(stream, state, finished, cb) {\n\t if (!finished) {\n onwriteDrain(stream, state);\n}\n\t state.pendingcb--;\n\t cb();\n\t finishMaybe(stream, state);\n\t}\n\n\t// Must force callback to be called on nextTick, so that we don't\n\t// emit 'drain' before the write() consumer gets the 'false' return\n\t// value, and has a chance to attach a 'drain' listener.\n\tfunction onwriteDrain(stream, state) {\n\t if (state.length === 0 && state.needDrain) {\n\t\tstate.needDrain = false;\n\t\tstream.emit('drain');\n\t }\n\t}\n\n\t// if there's something in the buffer waiting, then process it\n\tfunction clearBuffer(stream, state) {\n\t state.bufferProcessing = true;\n\t let entry = state.bufferedRequest;\n\n\t if (stream._writev && entry && entry.next) {\n\t\t// Fast case, write everything using _writev()\n\t\tconst l = state.bufferedRequestCount;\n\t\tconst buffer = new Array(l);\n\t\tconst holder = state.corkedRequestsFree;\n\t\tholder.entry = entry;\n\n\t\tlet count = 0;\n\t\tlet allBuffers = true;\n\t\twhile (entry) {\n\t\t buffer[count] = entry;\n\t\t if (!entry.isBuf) {\n allBuffers = false;\n}\n\t\t entry = entry.next;\n\t\t count += 1;\n\t\t}\n\t\tbuffer.allBuffers = allBuffers;\n\n\t\tdoWrite(stream, state, true, state.length, buffer, '', holder.finish);\n\n\t\t// doWrite is almost always async, defer these to save a bit of time\n\t\t// as the hot path ends with doWrite\n\t\tstate.pendingcb++;\n\t\tstate.lastBufferedRequest = null;\n\t\tif (holder.next) {\n\t\t state.corkedRequestsFree = holder.next;\n\t\t holder.next = null;\n\t\t} else {\n\t\t state.corkedRequestsFree = new CorkedRequest(state);\n\t\t}\n\t\tstate.bufferedRequestCount = 0;\n\t } else {\n\t\t// Slow case, write chunks one-by-one\n\t\twhile (entry) {\n\t\t const chunk = entry.chunk;\n\t\t const encoding = entry.encoding;\n\t\t const cb = entry.callback;\n\t\t const len = state.objectMode ? 1 : chunk.length;\n\n\t\t doWrite(stream, state, false, len, chunk, encoding, cb);\n\t\t entry = entry.next;\n\t\t state.bufferedRequestCount--;\n\t\t // if we didn't call the onwrite immediately, then\n\t\t // it means that we need to wait until it does.\n\t\t // also, that means that the chunk and cb are currently\n\t\t // being processed, so move the buffer counter past them.\n\t\t if (state.writing) {\n\t\t\tbreak;\n\t\t }\n\t\t}\n\n\t\tif (entry === null) {\n state.lastBufferedRequest = null;\n}\n\t }\n\n\t state.bufferedRequest = entry;\n\t state.bufferProcessing = false;\n\t}\n\n\tWritable.prototype._write = function (chunk, encoding, cb) {\n\t cb(new Error('_write() is not implemented'));\n\t};\n\n\tWritable.prototype._writev = null;\n\n\tWritable.prototype.end = function (chunk, encoding, cb) {\n\t const state = this._writableState;\n\n\t if (typeof chunk === 'function') {\n\t\tcb = chunk;\n\t\tchunk = null;\n\t\tencoding = null;\n\t } else if (typeof encoding === 'function') {\n\t\tcb = encoding;\n\t\tencoding = null;\n\t }\n\n\t if (chunk !== null && chunk !== undefined) {\n this.write(chunk, encoding);\n}\n\n\t // .end() fully uncorks\n\t if (state.corked) {\n\t\tstate.corked = 1;\n\t\tthis.uncork();\n\t }\n\n\t // ignore unnecessary end() calls.\n\t if (!state.ending && !state.finished) {\n endWritable(this, state, cb);\n}\n\t};\n\n\tfunction needFinish(state) {\n\t return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n\t}\n\tfunction callFinal(stream, state) {\n\t stream._final((err) => {\n\t\tstate.pendingcb--;\n\t\tif (err) {\n\t\t stream.emit('error', err);\n\t\t}\n\t\tstate.prefinished = true;\n\t\tstream.emit('prefinish');\n\t\tfinishMaybe(stream, state);\n\t });\n\t}\n\tfunction prefinish(stream, state) {\n\t if (!state.prefinished && !state.finalCalled) {\n\t\tif (typeof stream._final === 'function') {\n\t\t state.pendingcb++;\n\t\t state.finalCalled = true;\n\t\t pna.nextTick(callFinal, stream, state);\n\t\t} else {\n\t\t state.prefinished = true;\n\t\t stream.emit('prefinish');\n\t\t}\n\t }\n\t}\n\n\tfunction finishMaybe(stream, state) {\n\t const need = needFinish(state);\n\t if (need) {\n\t\tprefinish(stream, state);\n\t\tif (state.pendingcb === 0) {\n\t\t state.finished = true;\n\t\t stream.emit('finish');\n\t\t}\n\t }\n\t return need;\n\t}\n\n\tfunction endWritable(stream, state, cb) {\n\t state.ending = true;\n\t finishMaybe(stream, state);\n\t if (cb) {\n\t\tif (state.finished) {\n pna.nextTick(cb);\n} else {\n stream.once('finish', cb);\n}\n\t }\n\t state.ended = true;\n\t stream.writable = false;\n\t}\n\n\tfunction onCorkedFinish(corkReq, state, err) {\n\t let entry = corkReq.entry;\n\t corkReq.entry = null;\n\t while (entry) {\n\t\tconst cb = entry.callback;\n\t\tstate.pendingcb--;\n\t\tcb(err);\n\t\tentry = entry.next;\n\t }\n\t if (state.corkedRequestsFree) {\n\t\tstate.corkedRequestsFree.next = corkReq;\n\t } else {\n\t\tstate.corkedRequestsFree = corkReq;\n\t }\n\t}\n\n\tObject.defineProperty(Writable.prototype, 'destroyed', {\n\t get() {\n\t\tif (this._writableState === undefined) {\n\t\t return false;\n\t\t}\n\t\treturn this._writableState.destroyed;\n\t },\n\t set(value) {\n\t\t// we ignore the value if the stream\n\t\t// has not been initialized yet\n\t\tif (!this._writableState) {\n\t\t return;\n\t\t}\n\n\t\t// backward compatibility, the user is explicitly\n\t\t// managing destroyed\n\t\tthis._writableState.destroyed = value;\n\t }\n\t});\n\n\tWritable.prototype.destroy = destroyImpl.destroy;\n\tWritable.prototype._undestroy = destroyImpl.undestroy;\n\tWritable.prototype._destroy = function (err, cb) {\n\t this.end();\n\t cb(err);\n\t};\n\t/* WEBPACK VAR INJECTION */ }.call(exports, __webpack_require__(1), __webpack_require__(42).setImmediate, __webpack_require__(0)));\n\t/** */ }),\n\t/* 19 */\n\t/** */ (function (module, exports, __webpack_require__) {\n\t\"use strict\";\n\t// Copyright Joyent, Inc. and other Node contributors.\n\t//\n\t// Permission is hereby granted, free of charge, to any person obtaining a\n\t// copy of this software and associated documentation files (the\n\t// \"Software\"), to deal in the Software without restriction, including\n\t// without limitation the rights to use, copy, modify, merge, publish,\n\t// distribute, sublicense, and/or sell copies of the Software, and to permit\n\t// persons to whom the Software is furnished to do so, subject to the\n\t// following conditions:\n\t//\n\t// The above copyright notice and this permission notice shall be included\n\t// in all copies or substantial portions of the Software.\n\t//\n\t// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n\t// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n\t// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n\t// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n\t// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n\t// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n\t// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n\n\t/* */\n\n\tconst Buffer = __webpack_require__(45).Buffer;\n\t/* */\n\n\tconst isEncoding = Buffer.isEncoding || function (encoding) {\n\t encoding = '' + encoding;\n\t switch (encoding && encoding.toLowerCase()) {\n\t\tcase 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':\n\t\t return true;\n\t\tdefault:\n\t\t return false;\n\t }\n\t};\n\n\tfunction _normalizeEncoding(enc) {\n\t if (!enc) {\n return 'utf8';\n}\n\t let retried;\n\t while (true) {\n\t\tswitch (enc) {\n\t\t case 'utf8':\n\t\t case 'utf-8':\n\t\t\treturn 'utf8';\n\t\t case 'ucs2':\n\t\t case 'ucs-2':\n\t\t case 'utf16le':\n\t\t case 'utf-16le':\n\t\t\treturn 'utf16le';\n\t\t case 'latin1':\n\t\t case 'binary':\n\t\t\treturn 'latin1';\n\t\t case 'base64':\n\t\t case 'ascii':\n\t\t case 'hex':\n\t\t\treturn enc;\n\t\t default:\n\t\t\tif (retried) {\n return;\n} // undefined\n\t\t\tenc = ('' + enc).toLowerCase();\n\t\t\tretried = true;\n\t\t}\n\t }\n\t}\n\n\t// Do not cache `Buffer.isEncoding` when checking encoding names as some\n\t// modules monkey-patch it to support additional encodings\n\tfunction normalizeEncoding(enc) {\n\t const nenc = _normalizeEncoding(enc);\n\t if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) {\n throw new Error('Unknown encoding: ' + enc);\n}\n\t return nenc || enc;\n\t}\n\n\t// StringDecoder provides an interface for efficiently splitting a series of\n\t// buffers into a series of JS strings without breaking apart multi-byte\n\t// characters.\n\texports.StringDecoder = StringDecoder;\n\tfunction StringDecoder(encoding) {\n\t this.encoding = normalizeEncoding(encoding);\n\t let nb;\n\t switch (this.encoding) {\n\t\tcase 'utf16le':\n\t\t this.text = utf16Text;\n\t\t this.end = utf16End;\n\t\t nb = 4;\n\t\t break;\n\t\tcase 'utf8':\n\t\t this.fillLast = utf8FillLast;\n\t\t nb = 4;\n\t\t break;\n\t\tcase 'base64':\n\t\t this.text = base64Text;\n\t\t this.end = base64End;\n\t\t nb = 3;\n\t\t break;\n\t\tdefault:\n\t\t this.write = simpleWrite;\n\t\t this.end = simpleEnd;\n\t\t return;\n\t }\n\t this.lastNeed = 0;\n\t this.lastTotal = 0;\n\t this.lastChar = Buffer.allocUnsafe(nb);\n\t}\n\n\tStringDecoder.prototype.write = function (buf) {\n\t if (buf.length === 0) {\n return '';\n}\n\t let r;\n\t let i;\n\t if (this.lastNeed) {\n\t\tr = this.fillLast(buf);\n\t\tif (r === undefined) {\n return '';\n}\n\t\ti = this.lastNeed;\n\t\tthis.lastNeed = 0;\n\t } else {\n\t\ti = 0;\n\t }\n\t if (i < buf.length) {\n return r ? r + this.text(buf, i) : this.text(buf, i);\n}\n\t return r || '';\n\t};\n\n\tStringDecoder.prototype.end = utf8End;\n\n\t// Returns only complete characters in a Buffer\n\tStringDecoder.prototype.text = utf8Text;\n\n\t// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer\n\tStringDecoder.prototype.fillLast = function (buf) {\n\t if (this.lastNeed <= buf.length) {\n\t\tbuf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);\n\t\treturn this.lastChar.toString(this.encoding, 0, this.lastTotal);\n\t }\n\t buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);\n\t this.lastNeed -= buf.length;\n\t};\n\n\t// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a\n\t// continuation byte. If an invalid byte is detected, -2 is returned.\n\tfunction utf8CheckByte(byte) {\n\t if (byte <= 0x7F) {\n return 0;\n} else if (byte >> 5 === 0x06) {\n return 2;\n} else if (byte >> 4 === 0x0E) {\n return 3;\n} else if (byte >> 3 === 0x1E) {\n return 4;\n}\n\t return byte >> 6 === 0x02 ? -1 : -2;\n\t}\n\n\t// Checks at most 3 bytes at the end of a Buffer in order to detect an\n\t// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)\n\t// needed to complete the UTF-8 character (if applicable) are returned.\n\tfunction utf8CheckIncomplete(self, buf, i) {\n\t let j = buf.length - 1;\n\t if (j < i) {\n return 0;\n}\n\t let nb = utf8CheckByte(buf[j]);\n\t if (nb >= 0) {\n\t\tif (nb > 0) {\n self.lastNeed = nb - 1;\n}\n\t\treturn nb;\n\t }\n\t if (--j < i || nb === -2) {\n return 0;\n}\n\t nb = utf8CheckByte(buf[j]);\n\t if (nb >= 0) {\n\t\tif (nb > 0) {\n self.lastNeed = nb - 2;\n}\n\t\treturn nb;\n\t }\n\t if (--j < i || nb === -2) {\n return 0;\n}\n\t nb = utf8CheckByte(buf[j]);\n\t if (nb >= 0) {\n\t\tif (nb > 0) {\n\t\t if (nb === 2) {\n nb = 0;\n} else {\n self.lastNeed = nb - 3;\n}\n\t\t}\n\t\treturn nb;\n\t }\n\t return 0;\n\t}\n\n\t// Validates as many continuation bytes for a multi-byte UTF-8 character as\n\t// needed or are available. If we see a non-continuation byte where we expect\n\t// one, we \"replace\" the validated continuation bytes we've seen so far with\n\t// a single UTF-8 replacement character ('\\ufffd'), to match v8's UTF-8 decoding\n\t// behavior. The continuation byte check is included three times in the case\n\t// where all of the continuation bytes for a character exist in the same buffer.\n\t// It is also done this way as a slight performance increase instead of using a\n\t// loop.\n\tfunction utf8CheckExtraBytes(self, buf, p) {\n\t if ((buf[0] & 0xC0) !== 0x80) {\n\t\tself.lastNeed = 0;\n\t\treturn '\\ufffd';\n\t }\n\t if (self.lastNeed > 1 && buf.length > 1) {\n\t\tif ((buf[1] & 0xC0) !== 0x80) {\n\t\t self.lastNeed = 1;\n\t\t return '\\ufffd';\n\t\t}\n\t\tif (self.lastNeed > 2 && buf.length > 2) {\n\t\t if ((buf[2] & 0xC0) !== 0x80) {\n\t\t\tself.lastNeed = 2;\n\t\t\treturn '\\ufffd';\n\t\t }\n\t\t}\n\t }\n\t}\n\n\t// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.\n\tfunction utf8FillLast(buf) {\n\t const p = this.lastTotal - this.lastNeed;\n\t const r = utf8CheckExtraBytes(this, buf, p);\n\t if (r !== undefined) {\n return r;\n}\n\t if (this.lastNeed <= buf.length) {\n\t\tbuf.copy(this.lastChar, p, 0, this.lastNeed);\n\t\treturn this.lastChar.toString(this.encoding, 0, this.lastTotal);\n\t }\n\t buf.copy(this.lastChar, p, 0, buf.length);\n\t this.lastNeed -= buf.length;\n\t}\n\n\t// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a\n\t// partial character, the character's bytes are buffered until the required\n\t// number of bytes are available.\n\tfunction utf8Text(buf, i) {\n\t const total = utf8CheckIncomplete(this, buf, i);\n\t if (!this.lastNeed) {\n return buf.toString('utf8', i);\n}\n\t this.lastTotal = total;\n\t const end = buf.length - (total - this.lastNeed);\n\t buf.copy(this.lastChar, 0, end);\n\t return buf.toString('utf8', i, end);\n\t}\n\n\t// For UTF-8, a replacement character is added when ending on a partial\n\t// character.\n\tfunction utf8End(buf) {\n\t const r = buf && buf.length ? this.write(buf) : '';\n\t if (this.lastNeed) {\n return r + '\\ufffd';\n}\n\t return r;\n\t}\n\n\t// UTF-16LE typically needs two bytes per character, but even if we have an even\n\t// number of bytes available, we need to check if we end on a leading/high\n\t// surrogate. In that case, we need to wait for the next two bytes in order to\n\t// decode the last character properly.\n\tfunction utf16Text(buf, i) {\n\t if ((buf.length - i) % 2 === 0) {\n\t\tconst r = buf.toString('utf16le', i);\n\t\tif (r) {\n\t\t const c = r.charCodeAt(r.length - 1);\n\t\t if (c >= 0xD800 && c <= 0xDBFF) {\n\t\t\tthis.lastNeed = 2;\n\t\t\tthis.lastTotal = 4;\n\t\t\tthis.lastChar[0] = buf[buf.length - 2];\n\t\t\tthis.lastChar[1] = buf[buf.length - 1];\n\t\t\treturn r.slice(0, -1);\n\t\t }\n\t\t}\n\t\treturn r;\n\t }\n\t this.lastNeed = 1;\n\t this.lastTotal = 2;\n\t this.lastChar[0] = buf[buf.length - 1];\n\t return buf.toString('utf16le', i, buf.length - 1);\n\t}\n\n\t// For UTF-16LE we do not explicitly append special replacement characters if we\n\t// end on a partial character, we simply let v8 handle that.\n\tfunction utf16End(buf) {\n\t const r = buf && buf.length ? this.write(buf) : '';\n\t if (this.lastNeed) {\n\t\tconst end = this.lastTotal - this.lastNeed;\n\t\treturn r + this.lastChar.toString('utf16le', 0, end);\n\t }\n\t return r;\n\t}\n\n\tfunction base64Text(buf, i) {\n\t const n = (buf.length - i) % 3;\n\t if (n === 0) {\n return buf.toString('base64', i);\n}\n\t this.lastNeed = 3 - n;\n\t this.lastTotal = 3;\n\t if (n === 1) {\n\t\tthis.lastChar[0] = buf[buf.length - 1];\n\t } else {\n\t\tthis.lastChar[0] = buf[buf.length - 2];\n\t\tthis.lastChar[1] = buf[buf.length - 1];\n\t }\n\t return buf.toString('base64', i, buf.length - n);\n\t}\n\n\tfunction base64End(buf) {\n\t const r = buf && buf.length ? this.write(buf) : '';\n\t if (this.lastNeed) {\n return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);\n}\n\t return r;\n\t}\n\n\t// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)\n\tfunction simpleWrite(buf) {\n\t return buf.toString(this.encoding);\n\t}\n\n\tfunction simpleEnd(buf) {\n\t return buf && buf.length ? this.write(buf) : '';\n\t}\n\t/** */ }),\n\t/* 20 */\n\t/** */ (function (module, exports, __webpack_require__) {\n\t\"use strict\";\n\t// Copyright Joyent, Inc. and other Node contributors.\n\t//\n\t// Permission is hereby granted, free of charge, to any person obtaining a\n\t// copy of this software and associated documentation files (the\n\t// \"Software\"), to deal in the Software without restriction, including\n\t// without limitation the rights to use, copy, modify, merge, publish,\n\t// distribute, sublicense, and/or sell copies of the Software, and to permit\n\t// persons to whom the Software is furnished to do so, subject to the\n\t// following conditions:\n\t//\n\t// The above copyright notice and this permission notice shall be included\n\t// in all copies or substantial portions of the Software.\n\t//\n\t// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n\t// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n\t// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n\t// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n\t// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n\t// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n\t// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n\t// a transform stream is a readable/writable stream where you do\n\t// something with the data. Sometimes it's called a \"filter\",\n\t// but that's not a great name for it, since that implies a thing where\n\t// some bits pass through, and others are simply ignored. (That would\n\t// be a valid example of a transform, of course.)\n\t//\n\t// While the output is causally related to the input, it's not a\n\t// necessarily symmetric or synchronous transformation. For example,\n\t// a zlib stream might take multiple plain-text writes(), and then\n\t// emit a single compressed chunk some time in the future.\n\t//\n\t// Here's how this works:\n\t//\n\t// The Transform stream has all the aspects of the readable and writable\n\t// stream classes. When you write(chunk), that calls _write(chunk,cb)\n\t// internally, and returns false if there's a lot of pending writes\n\t// buffered up. When you call read(), that calls _read(n) until\n\t// there's enough pending readable data buffered up.\n\t//\n\t// In a transform stream, the written data is placed in a buffer. When\n\t// _read(n) is called, it transforms the queued up data, calling the\n\t// buffered _write cb's as it consumes chunks. If consuming a single\n\t// written chunk would result in multiple output chunks, then the first\n\t// outputted bit calls the readcb, and subsequent chunks just go into\n\t// the read buffer, and will cause it to emit 'readable' if necessary.\n\t//\n\t// This way, back-pressure is actually determined by the reading side,\n\t// since _read has to be called to start processing a new chunk. However,\n\t// a pathological inflate type of transform can cause excessive buffering\n\t// here. For example, imagine a stream where every byte of input is\n\t// interpreted as an integer from 0-255, and then results in that many\n\t// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in\n\t// 1kb of data being output. In this case, you could write a very small\n\t// amount of input, and end up with a very large amount of output. In\n\t// such a pathological inflating mechanism, there'd be no way to tell\n\t// the system to stop doing the transform. A single 4MB write could\n\t// cause the system to run out of memory.\n\t//\n\t// However, even in such a pathological case, only a single written chunk\n\t// would be consumed, and then the rest would wait (un-transformed) until\n\t// the results of the previous transformed chunk were consumed.\n\n\n\tmodule.exports = Transform;\n\n\tconst Duplex = __webpack_require__(3);\n\n\t/* */\n\tconst util = __webpack_require__(4);\n\tutil.inherits = __webpack_require__(5);\n\t/* */\n\n\tutil.inherits(Transform, Duplex);\n\n\tfunction afterTransform(er, data) {\n\t const ts = this._transformState;\n\t ts.transforming = false;\n\n\t const cb = ts.writecb;\n\n\t if (!cb) {\n\t\treturn this.emit('error', new Error('write callback called multiple times'));\n\t }\n\n\t ts.writechunk = null;\n\t ts.writecb = null;\n\n\t if (data != null) // single equals check for both `null` and `undefined`\n\t\t{\n this.push(data);\n}\n\n\t cb(er);\n\n\t const rs = this._readableState;\n\t rs.reading = false;\n\t if (rs.needReadable || rs.length < rs.highWaterMark) {\n\t\tthis._read(rs.highWaterMark);\n\t }\n\t}\n\n\tfunction Transform(options) {\n\t if (!(this instanceof Transform)) {\n return new Transform(options);\n}\n\n\t Duplex.call(this, options);\n\n\t this._transformState = {\n\t\tafterTransform: afterTransform.bind(this),\n\t\tneedTransform: false,\n\t\ttransforming: false,\n\t\twritecb: null,\n\t\twritechunk: null,\n\t\twriteencoding: null\n\t };\n\n\t // start out asking for a readable event once data is transformed.\n\t this._readableState.needReadable = true;\n\n\t // we have implemented the _read method, and done the other things\n\t // that Readable wants before the first _read call, so unset the\n\t // sync guard flag.\n\t this._readableState.sync = false;\n\n\t if (options) {\n\t\tif (typeof options.transform === 'function') {\n this._transform = options.transform;\n}\n\n\t\tif (typeof options.flush === 'function') {\n this._flush = options.flush;\n}\n\t }\n\n\t // When the writable side finishes, then flush out anything remaining.\n\t this.on('prefinish', prefinish);\n\t}\n\n\tfunction prefinish() {\n\t const _this = this;\n\n\t if (typeof this._flush === 'function') {\n\t\tthis._flush((er, data) => {\n\t\t done(_this, er, data);\n\t\t});\n\t } else {\n\t\tdone(this, null, null);\n\t }\n\t}\n\n\tTransform.prototype.push = function (chunk, encoding) {\n\t this._transformState.needTransform = false;\n\t return Duplex.prototype.push.call(this, chunk, encoding);\n\t};\n\n\t// This is the part where you do stuff!\n\t// override this function in implementation classes.\n\t// 'chunk' is an input chunk.\n\t//\n\t// Call `push(newChunk)` to pass along transformed output\n\t// to the readable side. You may call 'push' zero or more times.\n\t//\n\t// Call `cb(err)` when you are done with this chunk. If you pass\n\t// an error, then that'll put the hurt on the whole operation. If you\n\t// never call cb(), then you'll never get another chunk.\n\tTransform.prototype._transform = function (chunk, encoding, cb) {\n\t throw new Error('_transform() is not implemented');\n\t};\n\n\tTransform.prototype._write = function (chunk, encoding, cb) {\n\t const ts = this._transformState;\n\t ts.writecb = cb;\n\t ts.writechunk = chunk;\n\t ts.writeencoding = encoding;\n\t if (!ts.transforming) {\n\t\tconst rs = this._readableState;\n\t\tif (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) {\n this._read(rs.highWaterMark);\n}\n\t }\n\t};\n\n\t// Doesn't matter what the args are here.\n\t// _transform does all the work.\n\t// That we got here means that the readable side wants more data.\n\tTransform.prototype._read = function (n) {\n\t const ts = this._transformState;\n\n\t if (ts.writechunk !== null && ts.writecb && !ts.transforming) {\n\t\tts.transforming = true;\n\t\tthis._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\n\t } else {\n\t\t// mark that we need a transform, so that any data that comes in\n\t\t// will get processed, now that we've asked for it.\n\t\tts.needTransform = true;\n\t }\n\t};\n\n\tTransform.prototype._destroy = function (err, cb) {\n\t const _this2 = this;\n\n\t Duplex.prototype._destroy.call(this, err, (err2) => {\n\t\tcb(err2);\n\t\t_this2.emit('close');\n\t });\n\t};\n\n\tfunction done(stream, er, data) {\n\t if (er) {\n return stream.emit('error', er);\n}\n\n\t if (data != null) // single equals check for both `null` and `undefined`\n\t\t{\n stream.push(data);\n}\n\n\t // if there's nothing in the write buffer, then that means\n\t // that nothing more will ever be provided\n\t if (stream._writableState.length) {\n throw new Error('Calling transform done when ws.length != 0');\n}\n\n\t if (stream._transformState.transforming) {\n throw new Error('Calling transform done when still transforming');\n}\n\n\t return stream.push(null);\n\t}\n\t/** */ }),\n\t/* 21 */\n\t/** */ (function (module, exports, __webpack_require__) {\n\tconst EventSource = __webpack_require__(22);\n\n\tif (typeof window === 'object') {\n\t window.EventSourcePolyfill = EventSource;\n\t if (!window.EventSource) {\n window.EventSource = EventSource;\n}\n\t module.exports = window.EventSource;\n\t} else {\n\t module.exports = EventSource;\n\t}\n\t/** */ }),\n\t/* 22 */\n\t/** */ (function (module, exports, __webpack_require__) {\n\t/* WEBPACK VAR INJECTION */(function (process, Buffer) {\n const original = __webpack_require__(26);\n\tconst parse = __webpack_require__(7).parse;\n\tconst events = __webpack_require__(8);\n\tconst https = __webpack_require__(36);\n\tconst http = __webpack_require__(10);\n\tconst util = __webpack_require__(50);\n\n\tconst httpsOptions = [\n\t 'pfx', 'key', 'passphrase', 'cert', 'ca', 'ciphers',\n\t 'rejectUnauthorized', 'secureProtocol', 'servername'\n\t];\n\n\tconst bom = [239, 187, 191];\n\tconst colon = 58;\n\tconst space = 32;\n\tconst lineFeed = 10;\n\tconst carriageReturn = 13;\n\n\tfunction hasBom(buf) {\n\t return bom.every((charCode, index) => {\n\t\treturn buf[index] === charCode;\n\t });\n\t}\n\n\t/**\n\t * Creates a new EventSource object\n\t *\n\t * @param {String} url the URL to which to connect\n\t * @param {Object} [eventSourceInitDict] extra init params. See README for details.\n\t * @api public\n\t **/\n\tfunction EventSource(url, eventSourceInitDict) {\n\t let readyState = EventSource.CONNECTING;\n\t Object.defineProperty(this, 'readyState', {\n\t\tget() {\n\t\t return readyState;\n\t\t}\n\t });\n\n\t Object.defineProperty(this, 'url', {\n\t\tget() {\n\t\t return url;\n\t\t}\n\t });\n\n\t const self = this;\n\t self.reconnectInterval = 1000;\n\n\t function onConnectionClosed() {\n\t\tif (readyState === EventSource.CLOSED) {\n return;\n}\n\t\treadyState = EventSource.CONNECTING;\n\t\t_emit('error', new Event('error'));\n\n\t\t// The url may have been changed by a temporary\n\t\t// redirect. If that's the case, revert it now.\n\t\tif (reconnectUrl) {\n\t\t url = reconnectUrl;\n\t\t reconnectUrl = null;\n\t\t}\n\t\tsetTimeout(() => {\n\t\t if (readyState !== EventSource.CONNECTING) {\n\t\t\treturn;\n\t\t }\n\t\t connect();\n\t\t}, self.reconnectInterval);\n\t }\n\n\t let req;\n\t let lastEventId = '';\n\t if (eventSourceInitDict && eventSourceInitDict.headers && eventSourceInitDict.headers['Last-Event-ID']) {\n\t\tlastEventId = eventSourceInitDict.headers['Last-Event-ID'];\n\t\tdelete eventSourceInitDict.headers['Last-Event-ID'];\n\t }\n\n\t let discardTrailingNewline = false;\n\t let data = '';\n\t let eventName = '';\n\n\t var reconnectUrl = null;\n\n\t function connect() {\n\t\tconst options = parse(url);\n\t\tlet isSecure = options.protocol === 'https:';\n\t\toptions.headers = { 'Cache-Control': 'no-cache', 'Accept': 'text/event-stream' };\n\t\tif (lastEventId) {\n options.headers['Last-Event-ID'] = lastEventId;\n}\n\t\tif (eventSourceInitDict && eventSourceInitDict.headers) {\n\t\t for (const i in eventSourceInitDict.headers) {\n\t\t\tconst header = eventSourceInitDict.headers[i];\n\t\t\tif (header) {\n\t\t\t options.headers[i] = header;\n\t\t\t}\n\t\t }\n\t\t}\n\n\t\t// Legacy: this should be specified as `eventSourceInitDict.https.rejectUnauthorized`,\n\t\t// but for now exists as a backwards-compatibility layer\n\t\toptions.rejectUnauthorized = !(eventSourceInitDict && !eventSourceInitDict.rejectUnauthorized);\n\n\t\t// If specify http proxy, make the request to sent to the proxy server,\n\t\t// and include the original url in path and Host headers\n\t\tconst useProxy = eventSourceInitDict && eventSourceInitDict.proxy;\n\t\tif (useProxy) {\n\t\t const proxy = parse(eventSourceInitDict.proxy);\n\t\t isSecure = proxy.protocol === 'https:';\n\n\t\t options.protocol = isSecure ? 'https:' : 'http:';\n\t\t options.path = url;\n\t\t options.headers.Host = options.host;\n\t\t options.hostname = proxy.hostname;\n\t\t options.host = proxy.host;\n\t\t options.port = proxy.port;\n\t\t}\n\n\t\t// If https options are specified, merge them into the request options\n\t\tif (eventSourceInitDict && eventSourceInitDict.https) {\n\t\t for (const optName in eventSourceInitDict.https) {\n\t\t\tif (httpsOptions.indexOf(optName) === -1) {\n\t\t\t continue;\n\t\t\t}\n\n\t\t\tconst option = eventSourceInitDict.https[optName];\n\t\t\tif (option !== undefined) {\n\t\t\t options[optName] = option;\n\t\t\t}\n\t\t }\n\t\t}\n\n\t\t// Pass this on to the XHR\n\t\tif (eventSourceInitDict && eventSourceInitDict.withCredentials !== undefined) {\n\t\t options.withCredentials = eventSourceInitDict.withCredentials;\n\t\t}\n\n\t\treq = (isSecure ? https : http).request(options, (res) => {\n\t\t // Handle HTTP errors\n\t\t if (res.statusCode === 500 || res.statusCode === 502 || res.statusCode === 503 || res.statusCode === 504) {\n\t\t\t_emit('error', new Event('error', {status: res.statusCode}));\n\t\t\tonConnectionClosed();\n\t\t\treturn;\n\t\t }\n\n\t\t // Handle HTTP redirects\n\t\t if (res.statusCode === 301 || res.statusCode === 307) {\n\t\t\tif (!res.headers.location) {\n\t\t\t // Server sent redirect response without Location header.\n\t\t\t _emit('error', new Event('error', {status: res.statusCode}));\n\t\t\t return;\n\t\t\t}\n\t\t\tif (res.statusCode === 307) {\n reconnectUrl = url;\n}\n\t\t\turl = res.headers.location;\n\t\t\tprocess.nextTick(connect);\n\t\t\treturn;\n\t\t }\n\n\t\t if (res.statusCode !== 200) {\n\t\t\t_emit('error', new Event('error', {status: res.statusCode}));\n\t\t\treturn self.close();\n\t\t }\n\n\t\t readyState = EventSource.OPEN;\n\t\t res.on('close', () => {\n\t\t\tres.removeAllListeners('close');\n\t\t\tres.removeAllListeners('end');\n\t\t\tonConnectionClosed();\n\t\t });\n\n\t\t res.on('end', () => {\n\t\t\tres.removeAllListeners('close');\n\t\t\tres.removeAllListeners('end');\n\t\t\tonConnectionClosed();\n\t\t });\n\t\t _emit('open', new Event('open'));\n\n\t\t // text/event-stream parser adapted from webkit's\n\t\t // Source/WebCore/page/EventSource.cpp\n\t\t let isFirst = true;\n\t\t let buf;\n\t\t res.on('data', (chunk) => {\n\t\t\tbuf = buf ? Buffer.concat([buf, chunk]) : chunk;\n\t\t\tif (isFirst && hasBom(buf)) {\n\t\t\t buf = buf.slice(bom.length);\n\t\t\t}\n\n\t\t\tisFirst = false;\n\t\t\tlet pos = 0;\n\t\t\tconst length = buf.length;\n\n\t\t\twhile (pos < length) {\n\t\t\t if (discardTrailingNewline) {\n\t\t\t\tif (buf[pos] === lineFeed) {\n\t\t\t\t ++pos;\n\t\t\t\t}\n\t\t\t\tdiscardTrailingNewline = false;\n\t\t\t }\n\n\t\t\t let lineLength = -1;\n\t\t\t let fieldLength = -1;\n\t\t\t var c;\n\n\t\t\t for (let i = pos; lineLength < 0 && i < length; ++i) {\n\t\t\t\tc = buf[i];\n\t\t\t\tif (c === colon) {\n\t\t\t\t if (fieldLength < 0) {\n\t\t\t\t\tfieldLength = i - pos;\n\t\t\t\t }\n\t\t\t\t} else if (c === carriageReturn) {\n\t\t\t\t discardTrailingNewline = true;\n\t\t\t\t lineLength = i - pos;\n\t\t\t\t} else if (c === lineFeed) {\n\t\t\t\t lineLength = i - pos;\n\t\t\t\t}\n\t\t\t }\n\n\t\t\t if (lineLength < 0) {\n\t\t\t\tbreak;\n\t\t\t }\n\n\t\t\t parseEventStreamLine(buf, pos, fieldLength, lineLength);\n\n\t\t\t pos += lineLength + 1;\n\t\t\t}\n\n\t\t\tif (pos === length) {\n\t\t\t buf = void 0;\n\t\t\t} else if (pos > 0) {\n\t\t\t buf = buf.slice(pos);\n\t\t\t}\n\t\t });\n\t\t});\n\n\t\treq.on('error', onConnectionClosed);\n\t\tif (req.setNoDelay) {\n req.setNoDelay(true);\n}\n\t\treq.end();\n\t }\n\n\t connect();\n\n\t function _emit() {\n\t\tif (self.listeners(arguments[0]).length > 0) {\n\t\t self.emit.apply(self, arguments);\n\t\t}\n\t }\n\n\t this._close = function () {\n\t\tif (readyState === EventSource.CLOSED) {\n return;\n}\n\t\treadyState = EventSource.CLOSED;\n\t\tif (req.abort) {\n req.abort();\n}\n\t\tif (req.xhr && req.xhr.abort) {\n req.xhr.abort();\n}\n\t };\n\n\t function parseEventStreamLine(buf, pos, fieldLength, lineLength) {\n\t\tif (lineLength === 0) {\n\t\t if (data.length > 0) {\n\t\t\tconst type = eventName || 'message';\n\t\t\t_emit(type, new MessageEvent(type, {\n\t\t\t data: data.slice(0, -1), // remove trailing newline\n\t\t\t lastEventId,\n\t\t\t origin: original(url)\n\t\t\t}));\n\t\t\tdata = '';\n\t\t }\n\t\t eventName = void 0;\n\t\t} else if (fieldLength > 0) {\n\t\t const noValue = fieldLength < 0;\n\t\t let step = 0;\n\t\t const field = buf.slice(pos, pos + (noValue ? lineLength : fieldLength)).toString();\n\n\t\t if (noValue) {\n\t\t\tstep = lineLength;\n\t\t } else if (buf[pos + fieldLength + 1] !== space) {\n\t\t\tstep = fieldLength + 1;\n\t\t } else {\n\t\t\tstep = fieldLength + 2;\n\t\t }\n\t\t pos += step;\n\n\t\t const valueLength = lineLength - step;\n\t\t const value = buf.slice(pos, pos + valueLength).toString();\n\n\t\t if (field === 'data') {\n\t\t\tdata += value + '\\n';\n\t\t } else if (field === 'event') {\n\t\t\teventName = value;\n\t\t } else if (field === 'id') {\n\t\t\tlastEventId = value;\n\t\t } else if (field === 'retry') {\n\t\t\tconst retry = parseInt(value, 10);\n\t\t\tif (!Number.isNaN(retry)) {\n\t\t\t self.reconnectInterval = retry;\n\t\t\t}\n\t\t }\n\t\t}\n\t }\n\t}\n\n\tmodule.exports = EventSource;\n\n\tutil.inherits(EventSource, events.EventEmitter);\n\tEventSource.prototype.constructor = EventSource; // make stacktraces readable\n\n\t['open', 'error', 'message'].forEach((method) => {\n\t Object.defineProperty(EventSource.prototype, 'on' + method, {\n\t\t/**\n\t\t * Returns the current listener\n\t\t *\n\t\t * @return {Mixed} the set function or undefined\n\t\t * @api private\n\t\t */\n\t\tget: function get() {\n\t\t const listener = this.listeners(method)[0];\n\t\t return listener ? (listener._listener ? listener._listener : listener) : undefined;\n\t\t},\n\n\t\t/**\n\t\t * Start listening for events\n\t\t *\n\t\t * @param {Function} listener the listener\n\t\t * @return {Mixed} the set function or undefined\n\t\t * @api private\n\t\t */\n\t\tset: function set(listener) {\n\t\t this.removeAllListeners(method);\n\t\t this.addEventListener(method, listener);\n\t\t}\n\t });\n\t});\n\n\t/**\n\t * Ready states\n\t */\n\tObject.defineProperty(EventSource, 'CONNECTING', {enumerable: true, value: 0});\n\tObject.defineProperty(EventSource, 'OPEN', {enumerable: true, value: 1});\n\tObject.defineProperty(EventSource, 'CLOSED', {enumerable: true, value: 2});\n\n\tEventSource.prototype.CONNECTING = 0;\n\tEventSource.prototype.OPEN = 1;\n\tEventSource.prototype.CLOSED = 2;\n\n\t/**\n\t * Closes the connection, if one is made, and sets the readyState attribute to 2 (closed)\n\t *\n\t * @see https://developer.mozilla.org/en-US/docs/Web/API/EventSource/close\n\t * @api public\n\t */\n\tEventSource.prototype.close = function () {\n\t this._close();\n\t};\n\n\t/**\n\t * Emulates the W3C Browser based WebSocket interface using addEventListener.\n\t *\n\t * @param {String} type A string representing the event type to listen out for\n\t * @param {Function} listener callback\n\t * @see https://developer.mozilla.org/en/DOM/element.addEventListener\n\t * @see http://dev.w3.org/html5/websockets/#the-websocket-interface\n\t * @api public\n\t */\n\tEventSource.prototype.addEventListener = function addEventListener(type, listener) {\n\t if (typeof listener === 'function') {\n\t\t// store a reference so we can return the original function again\n\t\tlistener._listener = listener;\n\t\tthis.on(type, listener);\n\t }\n\t};\n\n\t/**\n\t * Emulates the W3C Browser based WebSocket interface using removeEventListener.\n\t *\n\t * @param {String} type A string representing the event type to remove\n\t * @param {Function} listener callback\n\t * @see https://developer.mozilla.org/en/DOM/element.removeEventListener\n\t * @see http://dev.w3.org/html5/websockets/#the-websocket-interface\n\t * @api public\n\t */\n\tEventSource.prototype.removeEventListener = function removeEventListener(type, listener) {\n\t if (typeof listener === 'function') {\n\t\tlistener._listener = undefined;\n\t\tthis.removeListener(type, listener);\n\t }\n\t};\n\n\t/**\n\t * W3C Event\n\t *\n\t * @see http://www.w3.org/TR/DOM-Level-3-Events/#interface-Event\n\t * @api private\n\t */\n\tfunction Event(type, optionalProperties) {\n\t Object.defineProperty(this, 'type', { writable: false, value: type, enumerable: true });\n\t if (optionalProperties) {\n\t\tfor (const f in optionalProperties) {\n\t\t if (optionalProperties.hasOwnProperty(f)) {\n\t\t\tObject.defineProperty(this, f, { writable: false, value: optionalProperties[f], enumerable: true });\n\t\t }\n\t\t}\n\t }\n\t}\n\n\t/**\n\t * W3C MessageEvent\n\t *\n\t * @see http://www.w3.org/TR/webmessaging/#event-definitions\n\t * @api private\n\t */\n\tfunction MessageEvent(type, eventInitDict) {\n\t Object.defineProperty(this, 'type', { writable: false, value: type, enumerable: true });\n\t for (const f in eventInitDict) {\n\t\tif (eventInitDict.hasOwnProperty(f)) {\n\t\t Object.defineProperty(this, f, { writable: false, value: eventInitDict[f], enumerable: true });\n\t\t}\n\t }\n\t}\n\t/* WEBPACK VAR INJECTION */ }.call(exports, __webpack_require__(1), __webpack_require__(2).Buffer));\n\t/** */ }),\n\t/* 23 */\n\t/** */ (function (module, exports, __webpack_require__) {\n\t\"use strict\";\n\n\n\texports.byteLength = byteLength;\n\texports.toByteArray = toByteArray;\n\texports.fromByteArray = fromByteArray;\n\n\tconst lookup = [];\n\tconst revLookup = [];\n\tconst Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;\n\n\tconst code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n\tfor (let i = 0, len = code.length; i < len; ++i) {\n\t lookup[i] = code[i];\n\t revLookup[code.charCodeAt(i)] = i;\n\t}\n\n\t// Support decoding URL-safe base64 strings, as Node.js does.\n\t// See: https://en.wikipedia.org/wiki/Base64#URL_applications\n\trevLookup['-'.charCodeAt(0)] = 62;\n\trevLookup['_'.charCodeAt(0)] = 63;\n\n\tfunction getLens(b64) {\n\t const len = b64.length;\n\n\t if (len % 4 > 0) {\n\t\tthrow new Error('Invalid string. Length must be a multiple of 4');\n\t }\n\n\t // Trim off extra bytes after placeholder bytes are found\n\t // See: https://github.com/beatgammit/base64-js/issues/42\n\t let validLen = b64.indexOf('=');\n\t if (validLen === -1) {\n validLen = len;\n}\n\n\t const placeHoldersLen = validLen === len\n\t\t? 0\n\t\t: 4 - (validLen % 4);\n\n\t return [validLen, placeHoldersLen];\n\t}\n\n\t// base64 is 4/3 + up to two characters of the original data\n\tfunction byteLength(b64) {\n\t const lens = getLens(b64);\n\t const validLen = lens[0];\n\t const placeHoldersLen = lens[1];\n\t return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen;\n\t}\n\n\tfunction _byteLength(b64, validLen, placeHoldersLen) {\n\t return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen;\n\t}\n\n\tfunction toByteArray(b64) {\n\t let tmp;\n\t const lens = getLens(b64);\n\t const validLen = lens[0];\n\t const placeHoldersLen = lens[1];\n\n\t const arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));\n\n\t let curByte = 0;\n\n\t // if there are placeholders, only get up to the last complete 4 chars\n\t const len = placeHoldersLen > 0\n\t\t? validLen - 4\n\t\t: validLen;\n\n\t for (var i = 0; i < len; i += 4) {\n\t\ttmp =\n\t\t (revLookup[b64.charCodeAt(i)] << 18) |\n\t\t (revLookup[b64.charCodeAt(i + 1)] << 12) |\n\t\t (revLookup[b64.charCodeAt(i + 2)] << 6) |\n\t\t revLookup[b64.charCodeAt(i + 3)];\n\t\tarr[curByte++] = (tmp >> 16) & 0xFF;\n\t\tarr[curByte++] = (tmp >> 8) & 0xFF;\n\t\tarr[curByte++] = tmp & 0xFF;\n\t }\n\n\t if (placeHoldersLen === 2) {\n\t\ttmp =\n\t\t (revLookup[b64.charCodeAt(i)] << 2) |\n\t\t (revLookup[b64.charCodeAt(i + 1)] >> 4);\n\t\tarr[curByte++] = tmp & 0xFF;\n\t }\n\n\t if (placeHoldersLen === 1) {\n\t\ttmp =\n\t\t (revLookup[b64.charCodeAt(i)] << 10) |\n\t\t (revLookup[b64.charCodeAt(i + 1)] << 4) |\n\t\t (revLookup[b64.charCodeAt(i + 2)] >> 2);\n\t\tarr[curByte++] = (tmp >> 8) & 0xFF;\n\t\tarr[curByte++] = tmp & 0xFF;\n\t }\n\n\t return arr;\n\t}\n\n\tfunction tripletToBase64(num) {\n\t return lookup[num >> 18 & 0x3F] +\n\t\tlookup[num >> 12 & 0x3F] +\n\t\tlookup[num >> 6 & 0x3F] +\n\t\tlookup[num & 0x3F];\n\t}\n\n\tfunction encodeChunk(uint8, start, end) {\n\t let tmp;\n\t const output = [];\n\t for (let i = start; i < end; i += 3) {\n\t\ttmp =\n\t\t ((uint8[i] << 16) & 0xFF0000) +\n\t\t ((uint8[i + 1] << 8) & 0xFF00) +\n\t\t (uint8[i + 2] & 0xFF);\n\t\toutput.push(tripletToBase64(tmp));\n\t }\n\t return output.join('');\n\t}\n\n\tfunction fromByteArray(uint8) {\n\t let tmp;\n\t const len = uint8.length;\n\t const extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes\n\t const parts = [];\n\t const maxChunkLength = 16383; // must be multiple of 3\n\n\t // go through the array every three bytes, we'll deal with trailing stuff later\n\t for (let i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n\t\tparts.push(encodeChunk(\n\t\t uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)\n\t\t));\n\t }\n\n\t // pad the end with zeros, but make sure to not forget the extra bytes\n\t if (extraBytes === 1) {\n\t\ttmp = uint8[len - 1];\n\t\tparts.push(\n\t\t lookup[tmp >> 2] +\n\t\t lookup[(tmp << 4) & 0x3F] +\n\t\t '=='\n\t\t);\n\t } else if (extraBytes === 2) {\n\t\ttmp = (uint8[len - 2] << 8) + uint8[len - 1];\n\t\tparts.push(\n\t\t lookup[tmp >> 10] +\n\t\t lookup[(tmp >> 4) & 0x3F] +\n\t\t lookup[(tmp << 2) & 0x3F] +\n\t\t '='\n\t\t);\n\t }\n\n\t return parts.join('');\n\t}\n\t/** */ }),\n\t/* 24 */\n\t/** */ (function (module, exports) {\n\texports.read = function (buffer, offset, isLE, mLen, nBytes) {\n\t let e, m;\n\t const eLen = (nBytes * 8) - mLen - 1;\n\t const eMax = (1 << eLen) - 1;\n\t const eBias = eMax >> 1;\n\t let nBits = -7;\n\t let i = isLE ? (nBytes - 1) : 0;\n\t const d = isLE ? -1 : 1;\n\t let s = buffer[offset + i];\n\n\t i += d;\n\n\t e = s & ((1 << (-nBits)) - 1);\n\t s >>= (-nBits);\n\t nBits += eLen;\n\t for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n\t m = e & ((1 << (-nBits)) - 1);\n\t e >>= (-nBits);\n\t nBits += mLen;\n\t for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n\t if (e === 0) {\n\t\te = 1 - eBias;\n\t } else if (e === eMax) {\n\t\treturn m ? NaN : ((s ? -1 : 1) * Infinity);\n\t } else {\n\t\tm += Math.pow(2, mLen);\n\t\te -= eBias;\n\t }\n\t return (s ? -1 : 1) * m * Math.pow(2, e - mLen);\n\t};\n\n\texports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n\t let e, m, c;\n\t let eLen = (nBytes * 8) - mLen - 1;\n\t const eMax = (1 << eLen) - 1;\n\t const eBias = eMax >> 1;\n\t const rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0);\n\t let i = isLE ? 0 : (nBytes - 1);\n\t const d = isLE ? 1 : -1;\n\t const s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;\n\n\t value = Math.abs(value);\n\n\t if (isNaN(value) || value === Infinity) {\n\t\tm = isNaN(value) ? 1 : 0;\n\t\te = eMax;\n\t } else {\n\t\te = Math.floor(Math.log(value) / Math.LN2);\n\t\tif (value * (c = Math.pow(2, -e)) < 1) {\n\t\t e--;\n\t\t c *= 2;\n\t\t}\n\t\tif (e + eBias >= 1) {\n\t\t value += rt / c;\n\t\t} else {\n\t\t value += rt * Math.pow(2, 1 - eBias);\n\t\t}\n\t\tif (value * c >= 2) {\n\t\t e++;\n\t\t c /= 2;\n\t\t}\n\n\t\tif (e + eBias >= eMax) {\n\t\t m = 0;\n\t\t e = eMax;\n\t\t} else if (e + eBias >= 1) {\n\t\t m = ((value * c) - 1) * Math.pow(2, mLen);\n\t\t e += eBias;\n\t\t} else {\n\t\t m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);\n\t\t e = 0;\n\t\t}\n\t }\n\n\t for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n\t e = (e << mLen) | m;\n\t eLen += mLen;\n\t for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n\t buffer[offset + i - d] |= s * 128;\n\t};\n\t/** */ }),\n\t/* 25 */\n\t/** */ (function (module, exports) {\n\tconst toString = {}.toString;\n\n\tmodule.exports = Array.isArray || function (arr) {\n\t return toString.call(arr) == '[object Array]';\n\t};\n\t/** */ }),\n\t/* 26 */\n\t/** */ (function (module, exports, __webpack_require__) {\n\t\"use strict\";\n\n\n\tconst parse = __webpack_require__(27);\n\n\t/**\n\t * Transform an URL to a valid origin value.\n\t *\n\t * @param {String|Object} url URL to transform to it's origin.\n\t * @returns {String} The origin.\n\t * @api public\n\t */\n\tfunction origin(url) {\n\t if (typeof url === 'string') {\n url = parse(url);\n}\n\n\t //\n\t // 6.2. ASCII Serialization of an Origin\n\t // http://tools.ietf.org/html/rfc6454#section-6.2\n\t //\n\t if (!url.protocol || !url.hostname) {\n return 'null';\n}\n\n\t //\n\t // 4. Origin of a URI\n\t // http://tools.ietf.org/html/rfc6454#section-4\n\t //\n\t // States that url.scheme, host should be converted to lower case. This also\n\t // makes it easier to match origins as everything is just lower case.\n\t //\n\t return (url.protocol + '//' + url.host).toLowerCase();\n\t}\n\n\t/**\n\t * Check if the origins are the same.\n\t *\n\t * @param {String} a URL or origin of a.\n\t * @param {String} b URL or origin of b.\n\t * @returns {Boolean}\n\t * @api public\n\t */\n\torigin.same = function same(a, b) {\n\t return origin(a) === origin(b);\n\t};\n\n\t//\n\t// Expose the origin\n\t//\n\tmodule.exports = origin;\n\t/** */ }),\n\t/* 27 */\n\t/** */ (function (module, exports, __webpack_require__) {\n\t\"use strict\";\n\t/* WEBPACK VAR INJECTION */(function (global) {\n\tconst required = __webpack_require__(28),\n\t qs = __webpack_require__(29),\n\t protocolre = /^([a-z][a-z0-9.+-]*:)?(\\/\\/)?([\\S\\s]*)/i,\n\t slashes = /^[A-Za-z][A-Za-z0-9+-.]*:\\/\\//;\n\n\t/**\n\t * These are the parse rules for the URL parser, it informs the parser\n\t * about:\n\t *\n\t * 0. The char it Needs to parse, if it's a string it should be done using\n\t * indexOf, RegExp using exec and NaN means set as current value.\n\t * 1. The property we should set when parsing this value.\n\t * 2. Indication if it's backwards or forward parsing, when set as number it's\n\t * the value of extra chars that should be split off.\n\t * 3. Inherit from location if non existing in the parser.\n\t * 4. `toLowerCase` the resulting value.\n\t */\n\tconst rules = [\n\t ['#', 'hash'], // Extract from the back.\n\t ['?', 'query'], // Extract from the back.\n\t function sanitize(address) { // Sanitize what is left of the address\n\t\treturn address.replace('\\\\', '/');\n\t },\n\t ['/', 'pathname'], // Extract from the back.\n\t ['@', 'auth', 1], // Extract from the front.\n\t [NaN, 'host', undefined, 1, 1], // Set left over value.\n\t [/:(\\d+)$/, 'port', undefined, 1], // RegExp the back.\n\t [NaN, 'hostname', undefined, 1, 1] // Set left over.\n\t];\n\n\t/**\n\t * These properties should not be copied or inherited from. This is only needed\n\t * for all non blob URL's as a blob URL does not include a hash, only the\n\t * origin.\n\t *\n\t * @type {Object}\n\t * @private\n\t */\n\tconst ignore = { hash: 1, query: 1 };\n\n\t/**\n\t * The location object differs when your code is loaded through a normal page,\n\t * Worker or through a worker using a blob. And with the blobble begins the\n\t * trouble as the location object will contain the URL of the blob, not the\n\t * location of the page where our code is loaded in. The actual origin is\n\t * encoded in the `pathname` so we can thankfully generate a good \"default\"\n\t * location from it so we can generate proper relative URL's again.\n\t *\n\t * @param {Object|String} loc Optional default location object.\n\t * @returns {Object} lolcation object.\n\t * @public\n\t */\n\tfunction lolcation(loc) {\n\t const location = global && global.location || {};\n\t loc = loc || location;\n\n\t let finaldestination = {},\n\t\t type = typeof loc,\n\t\t key;\n\n\t if (loc.protocol === 'blob:') {\n\t\tfinaldestination = new Url(unescape(loc.pathname), {});\n\t } else if (type === 'string') {\n\t\tfinaldestination = new Url(loc, {});\n\t\tfor (key in ignore) {\n delete finaldestination[key];\n}\n\t } else if (type === 'object') {\n\t\tfor (key in loc) {\n\t\t if (key in ignore) {\n continue;\n}\n\t\t finaldestination[key] = loc[key];\n\t\t}\n\n\t\tif (finaldestination.slashes === undefined) {\n\t\t finaldestination.slashes = slashes.test(loc.href);\n\t\t}\n\t }\n\n\t return finaldestination;\n\t}\n\n\t/**\n\t * @typedef ProtocolExtract\n\t * @type Object\n\t * @property {String} protocol Protocol matched in the URL, in lowercase.\n\t * @property {Boolean} slashes `true` if protocol is followed by \"//\", else `false`.\n\t * @property {String} rest Rest of the URL that is not part of the protocol.\n\t */\n\n\t/**\n\t * Extract protocol information from a URL with/without double slash (\"//\").\n\t *\n\t * @param {String} address URL we want to extract from.\n\t * @return {ProtocolExtract} Extracted information.\n\t * @private\n\t */\n\tfunction extractProtocol(address) {\n\t const match = protocolre.exec(address);\n\n\t return {\n\t\tprotocol: match[1] ? match[1].toLowerCase() : '',\n\t\tslashes: !!match[2],\n\t\trest: match[3]\n\t };\n\t}\n\n\t/**\n\t * Resolve a relative URL pathname against a base URL pathname.\n\t *\n\t * @param {String} relative Pathname of the relative URL.\n\t * @param {String} base Pathname of the base URL.\n\t * @return {String} Resolved pathname.\n\t * @private\n\t */\n\tfunction resolve(relative, base) {\n\t let path = (base || '/').split('/').slice(0, -1).concat(relative.split('/')),\n\t\t i = path.length,\n\t\t last = path[i - 1],\n\t\t unshift = false,\n\t\t up = 0;\n\n\t while (i--) {\n\t\tif (path[i] === '.') {\n\t\t path.splice(i, 1);\n\t\t} else if (path[i] === '..') {\n\t\t path.splice(i, 1);\n\t\t up++;\n\t\t} else if (up) {\n\t\t if (i === 0) {\n unshift = true;\n}\n\t\t path.splice(i, 1);\n\t\t up--;\n\t\t}\n\t }\n\n\t if (unshift) {\n path.unshift('');\n}\n\t if (last === '.' || last === '..') {\n path.push('');\n}\n\n\t return path.join('/');\n\t}\n\n\t/**\n\t * The actual URL instance. Instead of returning an object we've opted-in to\n\t * create an actual constructor as it's much more memory efficient and\n\t * faster and it pleases my OCD.\n\t *\n\t * It is worth noting that we should not use `URL` as class name to prevent\n\t * clashes with the global URL instance that got introduced in browsers.\n\t *\n\t * @constructor\n\t * @param {String} address URL we want to parse.\n\t * @param {Object|String} location Location defaults for relative paths.\n\t * @param {Boolean|Function} parser Parser for the query string.\n\t * @private\n\t */\n\tfunction Url(address, location, parser) {\n\t if (!(this instanceof Url)) {\n\t\treturn new Url(address, location, parser);\n\t }\n\n\t let relative, extracted, parse, instruction, index, key,\n\t\t instructions = rules.slice(),\n\t\t type = typeof location,\n\t\t url = this,\n\t\t i = 0;\n\n\t //\n\t // The following if statements allows this module two have compatibility with\n\t // 2 different API:\n\t //\n\t // 1. Node.js's `url.parse` api which accepts a URL, boolean as arguments\n\t // where the boolean indicates that the query string should also be parsed.\n\t //\n\t // 2. The `URL` interface of the browser which accepts a URL, object as\n\t // arguments. The supplied object will be used as default values / fall-back\n\t // for relative paths.\n\t //\n\t if (type !== 'object' && type !== 'string') {\n\t\tparser = location;\n\t\tlocation = null;\n\t }\n\n\t if (parser && typeof parser !== 'function') {\n parser = qs.parse;\n}\n\n\t location = lolcation(location);\n\n\t //\n\t // Extract protocol information before running the instructions.\n\t //\n\t extracted = extractProtocol(address || '');\n\t relative = !extracted.protocol && !extracted.slashes;\n\t url.slashes = extracted.slashes || relative && location.slashes;\n\t url.protocol = extracted.protocol || location.protocol || '';\n\t address = extracted.rest;\n\n\t //\n\t // When the authority component is absent the URL starts with a path\n\t // component.\n\t //\n\t if (!extracted.slashes) {\n instructions[3] = [/(.*)/, 'pathname'];\n}\n\n\t for (; i < instructions.length; i++) {\n\t\tinstruction = instructions[i];\n\n\t\tif (typeof instruction === 'function') {\n\t\t address = instruction(address);\n\t\t continue;\n\t\t}\n\n\t\tparse = instruction[0];\n\t\tkey = instruction[1];\n\n\t\tif (parse !== parse) {\n\t\t url[key] = address;\n\t\t} else if (typeof parse === 'string') {\n\t\t if (~(index = address.indexOf(parse))) {\n\t\t\tif (typeof instruction[2] === 'number') {\n\t\t\t url[key] = address.slice(0, index);\n\t\t\t address = address.slice(index + instruction[2]);\n\t\t\t} else {\n\t\t\t url[key] = address.slice(index);\n\t\t\t address = address.slice(0, index);\n\t\t\t}\n\t\t }\n\t\t} else if ((index = parse.exec(address))) {\n\t\t url[key] = index[1];\n\t\t address = address.slice(0, index.index);\n\t\t}\n\n\t\turl[key] = url[key] || (\n\t\t relative && instruction[3] ? location[key] || '' : ''\n\t\t);\n\n\t\t//\n\t\t// Hostname, host and protocol should be lowercased so they can be used to\n\t\t// create a proper `origin`.\n\t\t//\n\t\tif (instruction[4]) {\n url[key] = url[key].toLowerCase();\n}\n\t }\n\n\t //\n\t // Also parse the supplied query string in to an object. If we're supplied\n\t // with a custom parser as function use that instead of the default build-in\n\t // parser.\n\t //\n\t if (parser) {\n url.query = parser(url.query);\n}\n\n\t //\n\t // If the URL is relative, resolve the pathname against the base URL.\n\t //\n\t if (\n\t\t relative\n\t\t&& location.slashes\n\t\t&& url.pathname.charAt(0) !== '/'\n\t\t&& (url.pathname !== '' || location.pathname !== '')\n\t ) {\n\t\turl.pathname = resolve(url.pathname, location.pathname);\n\t }\n\n\t //\n\t // We should not add port numbers if they are already the default port number\n\t // for a given protocol. As the host also contains the port number we're going\n\t // override it with the hostname which contains no port number.\n\t //\n\t if (!required(url.port, url.protocol)) {\n\t\turl.host = url.hostname;\n\t\turl.port = '';\n\t }\n\n\t //\n\t // Parse down the `auth` for the username and password.\n\t //\n\t url.username = url.password = '';\n\t if (url.auth) {\n\t\tinstruction = url.auth.split(':');\n\t\turl.username = instruction[0] || '';\n\t\turl.password = instruction[1] || '';\n\t }\n\n\t url.origin = url.protocol && url.host && url.protocol !== 'file:'\n\t\t? url.protocol + '//' + url.host\n\t\t: 'null';\n\n\t //\n\t // The href is just the compiled result.\n\t //\n\t url.href = url.toString();\n\t}\n\n\t/**\n\t * This is convenience method for changing properties in the URL instance to\n\t * insure that they all propagate correctly.\n\t *\n\t * @param {String} part Property we need to adjust.\n\t * @param {Mixed} value The newly assigned value.\n\t * @param {Boolean|Function} fn When setting the query, it will be the function\n\t * used to parse the query.\n\t * When setting the protocol, double slash will be\n\t * removed from the final url if it is true.\n\t * @returns {URL} URL instance for chaining.\n\t * @public\n\t */\n\tfunction set(part, value, fn) {\n\t const url = this;\n\n\t switch (part) {\n\t\tcase 'query':\n\t\t if (typeof value === 'string' && value.length) {\n\t\t\tvalue = (fn || qs.parse)(value);\n\t\t }\n\n\t\t url[part] = value;\n\t\t break;\n\n\t\tcase 'port':\n\t\t url[part] = value;\n\n\t\t if (!required(value, url.protocol)) {\n\t\t\turl.host = url.hostname;\n\t\t\turl[part] = '';\n\t\t } else if (value) {\n\t\t\turl.host = url.hostname + ':' + value;\n\t\t }\n\n\t\t break;\n\n\t\tcase 'hostname':\n\t\t url[part] = value;\n\n\t\t if (url.port) {\n value += ':' + url.port;\n}\n\t\t url.host = value;\n\t\t break;\n\n\t\tcase 'host':\n\t\t url[part] = value;\n\n\t\t if (/:\\d+$/.test(value)) {\n\t\t\tvalue = value.split(':');\n\t\t\turl.port = value.pop();\n\t\t\turl.hostname = value.join(':');\n\t\t } else {\n\t\t\turl.hostname = value;\n\t\t\turl.port = '';\n\t\t }\n\n\t\t break;\n\n\t\tcase 'protocol':\n\t\t url.protocol = value.toLowerCase();\n\t\t url.slashes = !fn;\n\t\t break;\n\n\t\tcase 'pathname':\n\t\tcase 'hash':\n\t\t if (value) {\n\t\t\tconst char = part === 'pathname' ? '/' : '#';\n\t\t\turl[part] = value.charAt(0) !== char ? char + value : value;\n\t\t } else {\n\t\t\turl[part] = value;\n\t\t }\n\t\t break;\n\n\t\tdefault:\n\t\t url[part] = value;\n\t }\n\n\t for (let i = 0; i < rules.length; i++) {\n\t\tconst ins = rules[i];\n\n\t\tif (ins[4]) {\n url[ins[1]] = url[ins[1]].toLowerCase();\n}\n\t }\n\n\t url.origin = url.protocol && url.host && url.protocol !== 'file:'\n\t\t? url.protocol + '//' + url.host\n\t\t: 'null';\n\n\t url.href = url.toString();\n\n\t return url;\n\t}\n\n\t/**\n\t * Transform the properties back in to a valid and full URL string.\n\t *\n\t * @param {Function} stringify Optional query stringify function.\n\t * @returns {String} Compiled version of the URL.\n\t * @public\n\t */\n\tfunction toString(stringify) {\n\t if (!stringify || typeof stringify !== 'function') {\n stringify = qs.stringify;\n}\n\n\t let query,\n\t\t url = this,\n\t\t protocol = url.protocol;\n\n\t if (protocol && protocol.charAt(protocol.length - 1) !== ':') {\n protocol += ':';\n}\n\n\t let result = protocol + (url.slashes ? '//' : '');\n\n\t if (url.username) {\n\t\tresult += url.username;\n\t\tif (url.password) {\n result += ':' + url.password;\n}\n\t\tresult += '@';\n\t }\n\n\t result += url.host + url.pathname;\n\n\t query = typeof url.query === 'object' ? stringify(url.query) : url.query;\n\t if (query) {\n result += query.charAt(0) !== '?' ? '?' + query : query;\n}\n\n\t if (url.hash) {\n result += url.hash;\n}\n\n\t return result;\n\t}\n\n\tUrl.prototype = { set, toString };\n\n\t//\n\t// Expose the URL parser and some additional properties that might be useful for\n\t// others or testing.\n\t//\n\tUrl.extractProtocol = extractProtocol;\n\tUrl.location = lolcation;\n\tUrl.qs = qs;\n\n\tmodule.exports = Url;\n\t/* WEBPACK VAR INJECTION */ }.call(exports, __webpack_require__(0)));\n\t/** */ }),\n\t/* 28 */\n\t/** */ (function (module, exports, __webpack_require__) {\n\t\"use strict\";\n\n\n\t/**\n\t * Check if we're required to add a port number.\n\t *\n\t * @see https://url.spec.whatwg.org/#default-port\n\t * @param {Number|String} port Port number we need to check\n\t * @param {String} protocol Protocol we need to check against.\n\t * @returns {Boolean} Is it a default port for the given protocol\n\t * @api private\n\t */\n\tmodule.exports = function required(port, protocol) {\n\t protocol = protocol.split(':')[0];\n\t port = +port;\n\n\t if (!port) {\n return false;\n}\n\n\t switch (protocol) {\n\t\tcase 'http':\n\t\tcase 'ws':\n\t\treturn port !== 80;\n\n\t\tcase 'https':\n\t\tcase 'wss':\n\t\treturn port !== 443;\n\n\t\tcase 'ftp':\n\t\treturn port !== 21;\n\n\t\tcase 'gopher':\n\t\treturn port !== 70;\n\n\t\tcase 'file':\n\t\treturn false;\n\t }\n\n\t return port !== 0;\n\t};\n\t/** */ }),\n\t/* 29 */\n\t/** */ (function (module, exports, __webpack_require__) {\n\t\"use strict\";\n\n\n\tconst has = Object.prototype.hasOwnProperty;\n\n\t/**\n\t * Decode a URI encoded string.\n\t *\n\t * @param {String} input The URI encoded string.\n\t * @returns {String} The decoded string.\n\t * @api private\n\t */\n\tfunction decode(input) {\n\t return decodeURIComponent(input.replace(/\\+/g, ' '));\n\t}\n\n\t/**\n\t * Simple query string parser.\n\t *\n\t * @param {String} query The query string that needs to be parsed.\n\t * @returns {Object}\n\t * @api public\n\t */\n\tfunction querystring(query) {\n\t let parser = /([^=?&]+)=?([^&]*)/g,\n\t\t result = {},\n\t\t part;\n\n\t while (part = parser.exec(query)) {\n\t\tconst key = decode(part[1]),\n\t\t value = decode(part[2]);\n\n\t\t//\n\t\t// Prevent overriding of existing properties. This ensures that build-in\n\t\t// methods like `toString` or __proto__ are not overriden by malicious\n\t\t// querystrings.\n\t\t//\n\t\tif (key in result) {\n continue;\n}\n\t\tresult[key] = value;\n\t }\n\n\t return result;\n\t}\n\n\t/**\n\t * Transform a query string to an object.\n\t *\n\t * @param {Object} obj Object that should be transformed.\n\t * @param {String} prefix Optional prefix.\n\t * @returns {String}\n\t * @api public\n\t */\n\tfunction querystringify(obj, prefix) {\n\t prefix = prefix || '';\n\n\t const pairs = [];\n\n\t //\n\t // Optionally prefix with a '?' if needed\n\t //\n\t if (typeof prefix !== 'string') {\n prefix = '?';\n}\n\n\t for (const key in obj) {\n\t\tif (has.call(obj, key)) {\n\t\t pairs.push(encodeURIComponent(key) + '=' + encodeURIComponent(obj[key]));\n\t\t}\n\t }\n\n\t return pairs.length ? prefix + pairs.join('&') : '';\n\t}\n\n\t//\n\t// Expose the module.\n\t//\n\texports.stringify = querystringify;\n\texports.parse = querystring;\n\t/** */ }),\n\t/* 30 */\n\t/** */ (function (module, exports, __webpack_require__) {\n\t/* WEBPACK VAR INJECTION */(function (module, global) {\n let __WEBPACK_AMD_DEFINE_RESULT__;/* ! https://mths.be/punycode v1.4.1 by @mathias */\n\t(function (root) {\n\t\t/** Detect free variables */\n\t\tconst freeExports = typeof exports == 'object' && exports &&\n\t\t\t!exports.nodeType && exports;\n\t\tconst freeModule = typeof module == 'object' && module &&\n\t\t\t!module.nodeType && module;\n\t\tconst freeGlobal = typeof global == 'object' && global;\n\t\tif (\n\t\t\tfreeGlobal.global === freeGlobal ||\n\t\t\tfreeGlobal.window === freeGlobal ||\n\t\t\tfreeGlobal.self === freeGlobal\n\t\t) {\n\t\t\troot = freeGlobal;\n\t\t}\n\n\t\t/**\n\t\t * The `punycode` object.\n\t\t * @name punycode\n\t\t * @type Object\n\t\t */\n\t\tlet punycode,\n\n\t\t/** Highest positive signed 32-bit float value */\n\t\tmaxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1\n\n\t\t/** Bootstring parameters */\n\t\tbase = 36,\n\t\ttMin = 1,\n\t\ttMax = 26,\n\t\tskew = 38,\n\t\tdamp = 700,\n\t\tinitialBias = 72,\n\t\tinitialN = 128, // 0x80\n\t\tdelimiter = '-', // '\\x2D'\n\n\t\t/** Regular expressions */\n\t\tregexPunycode = /^xn--/,\n\t\tregexNonASCII = /[^\\x20-\\x7E]/, // unprintable ASCII chars + non-ASCII chars\n\t\tregexSeparators = /[\\x2E\\u3002\\uFF0E\\uFF61]/g, // RFC 3490 separators\n\n\t\t/** Error messages */\n\t\terrors = {\n\t\t\t'overflow': 'Overflow: input needs wider integers to process',\n\t\t\t'not-basic': 'Illegal input >= 0x80 (not a basic code point)',\n\t\t\t'invalid-input': 'Invalid input'\n\t\t},\n\n\t\t/** Convenience shortcuts */\n\t\tbaseMinusTMin = base - tMin,\n\t\tfloor = Math.floor,\n\t\tstringFromCharCode = String.fromCharCode,\n\n\t\t/** Temporary variable */\n\t\tkey;\n\n\t\t/* --------------------------------------------------------------------------*/\n\n\t\t/**\n\t\t * A generic error utility function.\n\t\t * @private\n\t\t * @param {String} type The error type.\n\t\t * @returns {Error} Throws a `RangeError` with the applicable error message.\n\t\t */\n\t\tfunction error(type) {\n\t\t\tthrow new RangeError(errors[type]);\n\t\t}\n\n\t\t/**\n\t\t * A generic `Array#map` utility function.\n\t\t * @private\n\t\t * @param {Array} array The array to iterate over.\n\t\t * @param {Function} callback The function that gets called for every array\n\t\t * item.\n\t\t * @returns {Array} A new array of values returned by the callback function.\n\t\t */\n\t\tfunction map(array, fn) {\n\t\t\tlet length = array.length;\n\t\t\tconst result = [];\n\t\t\twhile (length--) {\n\t\t\t\tresult[length] = fn(array[length]);\n\t\t\t}\n\t\t\treturn result;\n\t\t}\n\n\t\t/**\n\t\t * A simple `Array#map`-like wrapper to work with domain name strings or email\n\t\t * addresses.\n\t\t * @private\n\t\t * @param {String} domain The domain name or email address.\n\t\t * @param {Function} callback The function that gets called for every\n\t\t * character.\n\t\t * @returns {Array} A new string of characters returned by the callback\n\t\t * function.\n\t\t */\n\t\tfunction mapDomain(string, fn) {\n\t\t\tconst parts = string.split('@');\n\t\t\tlet result = '';\n\t\t\tif (parts.length > 1) {\n\t\t\t\t// In email addresses, only the domain name should be punycoded. Leave\n\t\t\t\t// the local part (i.e. everything up to `@`) intact.\n\t\t\t\tresult = parts[0] + '@';\n\t\t\t\tstring = parts[1];\n\t\t\t}\n\t\t\t// Avoid `split(regex)` for IE8 compatibility. See #17.\n\t\t\tstring = string.replace(regexSeparators, '\\x2E');\n\t\t\tconst labels = string.split('.');\n\t\t\tconst encoded = map(labels, fn).join('.');\n\t\t\treturn result + encoded;\n\t\t}\n\n\t\t/**\n\t\t * Creates an array containing the numeric code points of each Unicode\n\t\t * character in the string. While JavaScript uses UCS-2 internally,\n\t\t * this function will convert a pair of surrogate halves (each of which\n\t\t * UCS-2 exposes as separate characters) into a single code point,\n\t\t * matching UTF-16.\n\t\t * @see `punycode.ucs2.encode`\n\t\t * @see \n\t\t * @memberOf punycode.ucs2\n\t\t * @name decode\n\t\t * @param {String} string The Unicode input string (UCS-2).\n\t\t * @returns {Array} The new array of code points.\n\t\t */\n\t\tfunction ucs2decode(string) {\n\t\t\tlet output = [],\n\t\t\t\tcounter = 0,\n\t\t\t\tlength = string.length,\n\t\t\t\tvalue,\n\t\t\t\textra;\n\t\t\twhile (counter < length) {\n\t\t\t\tvalue = string.charCodeAt(counter++);\n\t\t\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t\t\t// high surrogate, and there is a next character\n\t\t\t\t\textra = string.charCodeAt(counter++);\n\t\t\t\t\tif ((extra & 0xFC00) == 0xDC00) { // low surrogate\n\t\t\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t\t\t} else {\n\t\t\t\t\t\t// unmatched surrogate; only append this code unit, in case the next\n\t\t\t\t\t\t// code unit is the high surrogate of a surrogate pair\n\t\t\t\t\t\toutput.push(value);\n\t\t\t\t\t\tcounter--;\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\toutput.push(value);\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn output;\n\t\t}\n\n\t\t/**\n\t\t * Creates a string based on an array of numeric code points.\n\t\t * @see `punycode.ucs2.decode`\n\t\t * @memberOf punycode.ucs2\n\t\t * @name encode\n\t\t * @param {Array} codePoints The array of numeric code points.\n\t\t * @returns {String} The new Unicode string (UCS-2).\n\t\t */\n\t\tfunction ucs2encode(array) {\n\t\t\treturn map(array, (value) => {\n\t\t\t\tlet output = '';\n\t\t\t\tif (value > 0xFFFF) {\n\t\t\t\t\tvalue -= 0x10000;\n\t\t\t\t\toutput += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);\n\t\t\t\t\tvalue = 0xDC00 | value & 0x3FF;\n\t\t\t\t}\n\t\t\t\toutput += stringFromCharCode(value);\n\t\t\t\treturn output;\n\t\t\t}).join('');\n\t\t}\n\n\t\t/**\n\t\t * Converts a basic code point into a digit/integer.\n\t\t * @see `digitToBasic()`\n\t\t * @private\n\t\t * @param {Number} codePoint The basic numeric code point value.\n\t\t * @returns {Number} The numeric value of a basic code point (for use in\n\t\t * representing integers) in the range `0` to `base - 1`, or `base` if\n\t\t * the code point does not represent a value.\n\t\t */\n\t\tfunction basicToDigit(codePoint) {\n\t\t\tif (codePoint - 48 < 10) {\n\t\t\t\treturn codePoint - 22;\n\t\t\t}\n\t\t\tif (codePoint - 65 < 26) {\n\t\t\t\treturn codePoint - 65;\n\t\t\t}\n\t\t\tif (codePoint - 97 < 26) {\n\t\t\t\treturn codePoint - 97;\n\t\t\t}\n\t\t\treturn base;\n\t\t}\n\n\t\t/**\n\t\t * Converts a digit/integer into a basic code point.\n\t\t * @see `basicToDigit()`\n\t\t * @private\n\t\t * @param {Number} digit The numeric value of a basic code point.\n\t\t * @returns {Number} The basic code point whose value (when used for\n\t\t * representing integers) is `digit`, which needs to be in the range\n\t\t * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is\n\t\t * used; else, the lowercase form is used. The behavior is undefined\n\t\t * if `flag` is non-zero and `digit` has no uppercase form.\n\t\t */\n\t\tfunction digitToBasic(digit, flag) {\n\t\t\t// 0..25 map to ASCII a..z or A..Z\n\t\t\t// 26..35 map to ASCII 0..9\n\t\t\treturn digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);\n\t\t}\n\n\t\t/**\n\t\t * Bias adaptation function as per section 3.4 of RFC 3492.\n\t\t * https://tools.ietf.org/html/rfc3492#section-3.4\n\t\t * @private\n\t\t */\n\t\tfunction adapt(delta, numPoints, firstTime) {\n\t\t\tlet k = 0;\n\t\t\tdelta = firstTime ? floor(delta / damp) : delta >> 1;\n\t\t\tdelta += floor(delta / numPoints);\n\t\t\tfor (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {\n\t\t\t\tdelta = floor(delta / baseMinusTMin);\n\t\t\t}\n\t\t\treturn floor(k + (baseMinusTMin + 1) * delta / (delta + skew));\n\t\t}\n\n\t\t/**\n\t\t * Converts a Punycode string of ASCII-only symbols to a string of Unicode\n\t\t * symbols.\n\t\t * @memberOf punycode\n\t\t * @param {String} input The Punycode string of ASCII-only symbols.\n\t\t * @returns {String} The resulting string of Unicode symbols.\n\t\t */\n\t\tfunction decode(input) {\n\t\t\t// Don't use UCS-2\n\t\t\tlet output = [],\n\t\t\t\tinputLength = input.length,\n\t\t\t\tout,\n\t\t\t\ti = 0,\n\t\t\t\tn = initialN,\n\t\t\t\tbias = initialBias,\n\t\t\t\tbasic,\n\t\t\t\tj,\n\t\t\t\tindex,\n\t\t\t\toldi,\n\t\t\t\tw,\n\t\t\t\tk,\n\t\t\t\tdigit,\n\t\t\t\tt,\n\t\t\t\t/** Cached calculation results */\n\t\t\t\tbaseMinusT;\n\n\t\t\t// Handle the basic code points: let `basic` be the number of input code\n\t\t\t// points before the last delimiter, or `0` if there is none, then copy\n\t\t\t// the first basic code points to the output.\n\n\t\t\tbasic = input.lastIndexOf(delimiter);\n\t\t\tif (basic < 0) {\n\t\t\t\tbasic = 0;\n\t\t\t}\n\n\t\t\tfor (j = 0; j < basic; ++j) {\n\t\t\t\t// if it's not a basic code point\n\t\t\t\tif (input.charCodeAt(j) >= 0x80) {\n\t\t\t\t\terror('not-basic');\n\t\t\t\t}\n\t\t\t\toutput.push(input.charCodeAt(j));\n\t\t\t}\n\n\t\t\t// Main decoding loop: start just after the last delimiter if any basic code\n\t\t\t// points were copied; start at the beginning otherwise.\n\n\t\t\tfor (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {\n\t\t\t\t// `index` is the index of the next character to be consumed.\n\t\t\t\t// Decode a generalized variable-length integer into `delta`,\n\t\t\t\t// which gets added to `i`. The overflow checking is easier\n\t\t\t\t// if we increase `i` as we go, then subtract off its starting\n\t\t\t\t// value at the end to obtain `delta`.\n\t\t\t\tfor (oldi = i, w = 1, k = base; /* no condition */; k += base) {\n\t\t\t\t\tif (index >= inputLength) {\n\t\t\t\t\t\terror('invalid-input');\n\t\t\t\t\t}\n\n\t\t\t\t\tdigit = basicToDigit(input.charCodeAt(index++));\n\n\t\t\t\t\tif (digit >= base || digit > floor((maxInt - i) / w)) {\n\t\t\t\t\t\terror('overflow');\n\t\t\t\t\t}\n\n\t\t\t\t\ti += digit * w;\n\t\t\t\t\tt = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\n\t\t\t\t\tif (digit < t) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\n\t\t\t\t\tbaseMinusT = base - t;\n\t\t\t\t\tif (w > floor(maxInt / baseMinusT)) {\n\t\t\t\t\t\terror('overflow');\n\t\t\t\t\t}\n\n\t\t\t\t\tw *= baseMinusT;\n\t\t\t\t}\n\n\t\t\t\tout = output.length + 1;\n\t\t\t\tbias = adapt(i - oldi, out, oldi == 0);\n\n\t\t\t\t// `i` was supposed to wrap around from `out` to `0`,\n\t\t\t\t// incrementing `n` each time, so we'll fix that now:\n\t\t\t\tif (floor(i / out) > maxInt - n) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\tn += floor(i / out);\n\t\t\t\ti %= out;\n\n\t\t\t\t// Insert `n` at position `i` of the output\n\t\t\t\toutput.splice(i++, 0, n);\n\t\t\t}\n\n\t\t\treturn ucs2encode(output);\n\t\t}\n\n\t\t/**\n\t\t * Converts a string of Unicode symbols (e.g. a domain name label) to a\n\t\t * Punycode string of ASCII-only symbols.\n\t\t * @memberOf punycode\n\t\t * @param {String} input The string of Unicode symbols.\n\t\t * @returns {String} The resulting Punycode string of ASCII-only symbols.\n\t\t */\n\t\tfunction encode(input) {\n\t\t\tlet n,\n\t\t\t\tdelta,\n\t\t\t\thandledCPCount,\n\t\t\t\tbasicLength,\n\t\t\t\tbias,\n\t\t\t\tj,\n\t\t\t\tm,\n\t\t\t\tq,\n\t\t\t\tk,\n\t\t\t\tt,\n\t\t\t\tcurrentValue,\n\t\t\t\toutput = [],\n\t\t\t\t/** `inputLength` will hold the number of code points in `input`. */\n\t\t\t\tinputLength,\n\t\t\t\t/** Cached calculation results */\n\t\t\t\thandledCPCountPlusOne,\n\t\t\t\tbaseMinusT,\n\t\t\t\tqMinusT;\n\n\t\t\t// Convert the input in UCS-2 to Unicode\n\t\t\tinput = ucs2decode(input);\n\n\t\t\t// Cache the length\n\t\t\tinputLength = input.length;\n\n\t\t\t// Initialize the state\n\t\t\tn = initialN;\n\t\t\tdelta = 0;\n\t\t\tbias = initialBias;\n\n\t\t\t// Handle the basic code points\n\t\t\tfor (j = 0; j < inputLength; ++j) {\n\t\t\t\tcurrentValue = input[j];\n\t\t\t\tif (currentValue < 0x80) {\n\t\t\t\t\toutput.push(stringFromCharCode(currentValue));\n\t\t\t\t}\n\t\t\t}\n\n\t\t\thandledCPCount = basicLength = output.length;\n\n\t\t\t// `handledCPCount` is the number of code points that have been handled;\n\t\t\t// `basicLength` is the number of basic code points.\n\n\t\t\t// Finish the basic string - if it is not empty - with a delimiter\n\t\t\tif (basicLength) {\n\t\t\t\toutput.push(delimiter);\n\t\t\t}\n\n\t\t\t// Main encoding loop:\n\t\t\twhile (handledCPCount < inputLength) {\n\t\t\t\t// All non-basic code points < n have been handled already. Find the next\n\t\t\t\t// larger one:\n\t\t\t\tfor (m = maxInt, j = 0; j < inputLength; ++j) {\n\t\t\t\t\tcurrentValue = input[j];\n\t\t\t\t\tif (currentValue >= n && currentValue < m) {\n\t\t\t\t\t\tm = currentValue;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Increase `delta` enough to advance the decoder's state to ,\n\t\t\t\t// but guard against overflow\n\t\t\t\thandledCPCountPlusOne = handledCPCount + 1;\n\t\t\t\tif (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\tdelta += (m - n) * handledCPCountPlusOne;\n\t\t\t\tn = m;\n\n\t\t\t\tfor (j = 0; j < inputLength; ++j) {\n\t\t\t\t\tcurrentValue = input[j];\n\n\t\t\t\t\tif (currentValue < n && ++delta > maxInt) {\n\t\t\t\t\t\terror('overflow');\n\t\t\t\t\t}\n\n\t\t\t\t\tif (currentValue == n) {\n\t\t\t\t\t\t// Represent delta as a generalized variable-length integer\n\t\t\t\t\t\tfor (q = delta, k = base; /* no condition */; k += base) {\n\t\t\t\t\t\t\tt = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\t\t\t\t\t\t\tif (q < t) {\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tqMinusT = q - t;\n\t\t\t\t\t\t\tbaseMinusT = base - t;\n\t\t\t\t\t\t\toutput.push(\n\t\t\t\t\t\t\t\tstringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\tq = floor(qMinusT / baseMinusT);\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\toutput.push(stringFromCharCode(digitToBasic(q, 0)));\n\t\t\t\t\t\tbias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);\n\t\t\t\t\t\tdelta = 0;\n\t\t\t\t\t\t++handledCPCount;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t++delta;\n\t\t\t\t++n;\n\t\t\t}\n\t\t\treturn output.join('');\n\t\t}\n\n\t\t/**\n\t\t * Converts a Punycode string representing a domain name or an email address\n\t\t * to Unicode. Only the Punycoded parts of the input will be converted, i.e.\n\t\t * it doesn't matter if you call it on a string that has already been\n\t\t * converted to Unicode.\n\t\t * @memberOf punycode\n\t\t * @param {String} input The Punycoded domain name or email address to\n\t\t * convert to Unicode.\n\t\t * @returns {String} The Unicode representation of the given Punycode\n\t\t * string.\n\t\t */\n\t\tfunction toUnicode(input) {\n\t\t\treturn mapDomain(input, (string) => {\n\t\t\t\treturn regexPunycode.test(string)\n\t\t\t\t\t? decode(string.slice(4).toLowerCase())\n\t\t\t\t\t: string;\n\t\t\t});\n\t\t}\n\n\t\t/**\n\t\t * Converts a Unicode string representing a domain name or an email address to\n\t\t * Punycode. Only the non-ASCII parts of the domain name will be converted,\n\t\t * i.e. it doesn't matter if you call it with a domain that's already in\n\t\t * ASCII.\n\t\t * @memberOf punycode\n\t\t * @param {String} input The domain name or email address to convert, as a\n\t\t * Unicode string.\n\t\t * @returns {String} The Punycode representation of the given domain name or\n\t\t * email address.\n\t\t */\n\t\tfunction toASCII(input) {\n\t\t\treturn mapDomain(input, (string) => {\n\t\t\t\treturn regexNonASCII.test(string)\n\t\t\t\t\t? 'xn--' + encode(string)\n\t\t\t\t\t: string;\n\t\t\t});\n\t\t}\n\n\t\t/* --------------------------------------------------------------------------*/\n\n\t\t/** Define the public API */\n\t\tpunycode = {\n\t\t\t/**\n\t\t\t * A string representing the current Punycode.js version number.\n\t\t\t * @memberOf punycode\n\t\t\t * @type String\n\t\t\t */\n\t\t\t'version': '1.4.1',\n\t\t\t/**\n\t\t\t * An object of methods to convert from JavaScript's internal character\n\t\t\t * representation (UCS-2) to Unicode code points, and back.\n\t\t\t * @see \n\t\t\t * @memberOf punycode\n\t\t\t * @type Object\n\t\t\t */\n\t\t\t'ucs2': {\n\t\t\t\t'decode': ucs2decode,\n\t\t\t\t'encode': ucs2encode\n\t\t\t},\n\t\t\tdecode,\n\t\t\tencode,\n\t\t\ttoASCII,\n\t\t\ttoUnicode\n\t\t};\n\n\t\t/** Expose `punycode` */\n\t\t// Some AMD build optimizers, like r.js, check for specific condition patterns\n\t\t// like the following:\n\t\tif (\n\t\t\ttrue\n\t\t) {\n\t\t\t!(__WEBPACK_AMD_DEFINE_RESULT__ = (function () {\n\t\t\t\treturn punycode;\n\t\t\t}).call(exports, __webpack_require__, exports, module),\n\t\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t\t} else if (freeExports && freeModule) {\n\t\t\tif (module.exports == freeExports) {\n\t\t\t\t// in Node.js, io.js, or RingoJS v0.8.0+\n\t\t\t\tfreeModule.exports = punycode;\n\t\t\t} else {\n\t\t\t\t// in Narwhal or RingoJS v0.7.0-\n\t\t\t\tfor (key in punycode) {\n\t\t\t\t\tpunycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\t// in Rhino or a web browser\n\t\t\troot.punycode = punycode;\n\t\t}\n\t}(this));\n\t/* WEBPACK VAR INJECTION */ }.call(exports, __webpack_require__(31)(module), __webpack_require__(0)));\n\t/** */ }),\n\t/* 31 */\n\t/** */ (function (module, exports) {\n\tmodule.exports = function (module) {\n\t\tif (!module.webpackPolyfill) {\n\t\t\tmodule.deprecate = function () {};\n\t\t\tmodule.paths = [];\n\t\t\t// module.parent = undefined by default\n\t\t\tif (!module.children) {\n module.children = [];\n}\n\t\t\tObject.defineProperty(module, \"loaded\", {\n\t\t\t\tenumerable: true,\n\t\t\t\tget() {\n\t\t\t\t\treturn module.l;\n\t\t\t\t}\n\t\t\t});\n\t\t\tObject.defineProperty(module, \"id\", {\n\t\t\t\tenumerable: true,\n\t\t\t\tget() {\n\t\t\t\t\treturn module.i;\n\t\t\t\t}\n\t\t\t});\n\t\t\tmodule.webpackPolyfill = 1;\n\t\t}\n\t\treturn module;\n\t};\n\t/** */ }),\n\t/* 32 */\n\t/** */ (function (module, exports, __webpack_require__) {\n\t\"use strict\";\n\n\n\tmodule.exports = {\n\t isString(arg) {\n\t\treturn typeof (arg) === 'string';\n\t },\n\t isObject(arg) {\n\t\treturn typeof (arg) === 'object' && arg !== null;\n\t },\n\t isNull(arg) {\n\t\treturn arg === null;\n\t },\n\t isNullOrUndefined(arg) {\n\t\treturn arg == null;\n\t }\n\t};\n\t/** */ }),\n\t/* 33 */\n\t/** */ (function (module, exports, __webpack_require__) {\n\t\"use strict\";\n\n\n\texports.decode = exports.parse = __webpack_require__(34);\n\texports.encode = exports.stringify = __webpack_require__(35);\n\t/** */ }),\n\t/* 34 */\n\t/** */ (function (module, exports, __webpack_require__) {\n\t\"use strict\";\n\t// Copyright Joyent, Inc. and other Node contributors.\n\t//\n\t// Permission is hereby granted, free of charge, to any person obtaining a\n\t// copy of this software and associated documentation files (the\n\t// \"Software\"), to deal in the Software without restriction, including\n\t// without limitation the rights to use, copy, modify, merge, publish,\n\t// distribute, sublicense, and/or sell copies of the Software, and to permit\n\t// persons to whom the Software is furnished to do so, subject to the\n\t// following conditions:\n\t//\n\t// The above copyright notice and this permission notice shall be included\n\t// in all copies or substantial portions of the Software.\n\t//\n\t// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n\t// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n\t// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n\t// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n\t// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n\t// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n\t// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n\n\t// If obj.hasOwnProperty has been overridden, then calling\n\t// obj.hasOwnProperty(prop) will break.\n\t// See: https://github.com/joyent/node/issues/1707\n\tfunction hasOwnProperty(obj, prop) {\n\t return Object.prototype.hasOwnProperty.call(obj, prop);\n\t}\n\n\tmodule.exports = function (qs, sep, eq, options) {\n\t sep = sep || '&';\n\t eq = eq || '=';\n\t const obj = {};\n\n\t if (typeof qs !== 'string' || qs.length === 0) {\n\t\treturn obj;\n\t }\n\n\t const regexp = /\\+/g;\n\t qs = qs.split(sep);\n\n\t let maxKeys = 1000;\n\t if (options && typeof options.maxKeys === 'number') {\n\t\tmaxKeys = options.maxKeys;\n\t }\n\n\t let len = qs.length;\n\t // maxKeys <= 0 means that we should not limit keys count\n\t if (maxKeys > 0 && len > maxKeys) {\n\t\tlen = maxKeys;\n\t }\n\n\t for (let i = 0; i < len; ++i) {\n\t\tvar x = qs[i].replace(regexp, '%20'),\n\t\t\tidx = x.indexOf(eq),\n\t\t\tkstr, vstr, k, v;\n\n\t\tif (idx >= 0) {\n\t\t kstr = x.substr(0, idx);\n\t\t vstr = x.substr(idx + 1);\n\t\t} else {\n\t\t kstr = x;\n\t\t vstr = '';\n\t\t}\n\n\t\tk = decodeURIComponent(kstr);\n\t\tv = decodeURIComponent(vstr);\n\n\t\tif (!hasOwnProperty(obj, k)) {\n\t\t obj[k] = v;\n\t\t} else if (isArray(obj[k])) {\n\t\t obj[k].push(v);\n\t\t} else {\n\t\t obj[k] = [obj[k], v];\n\t\t}\n\t }\n\n\t return obj;\n\t};\n\n\tvar isArray = Array.isArray || function (xs) {\n\t return Object.prototype.toString.call(xs) === '[object Array]';\n\t};\n\t/** */ }),\n\t/* 35 */\n\t/** */ (function (module, exports, __webpack_require__) {\n\t\"use strict\";\n\t// Copyright Joyent, Inc. and other Node contributors.\n\t//\n\t// Permission is hereby granted, free of charge, to any person obtaining a\n\t// copy of this software and associated documentation files (the\n\t// \"Software\"), to deal in the Software without restriction, including\n\t// without limitation the rights to use, copy, modify, merge, publish,\n\t// distribute, sublicense, and/or sell copies of the Software, and to permit\n\t// persons to whom the Software is furnished to do so, subject to the\n\t// following conditions:\n\t//\n\t// The above copyright notice and this permission notice shall be included\n\t// in all copies or substantial portions of the Software.\n\t//\n\t// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n\t// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n\t// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n\t// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n\t// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n\t// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n\t// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n\n\tconst stringifyPrimitive = function (v) {\n\t switch (typeof v) {\n\t\tcase 'string':\n\t\t return v;\n\n\t\tcase 'boolean':\n\t\t return v ? 'true' : 'false';\n\n\t\tcase 'number':\n\t\t return isFinite(v) ? v : '';\n\n\t\tdefault:\n\t\t return '';\n\t }\n\t};\n\n\tmodule.exports = function (obj, sep, eq, name) {\n\t sep = sep || '&';\n\t eq = eq || '=';\n\t if (obj === null) {\n\t\tobj = undefined;\n\t }\n\n\t if (typeof obj === 'object') {\n\t\treturn map(objectKeys(obj), (k) => {\n\t\t const ks = encodeURIComponent(stringifyPrimitive(k)) + eq;\n\t\t if (isArray(obj[k])) {\n\t\t\treturn map(obj[k], (v) => {\n\t\t\t return ks + encodeURIComponent(stringifyPrimitive(v));\n\t\t\t}).join(sep);\n\t\t }\n\t\t\treturn ks + encodeURIComponent(stringifyPrimitive(obj[k]));\n\t\t}).join(sep);\n\t }\n\n\t if (!name) {\n return '';\n}\n\t return encodeURIComponent(stringifyPrimitive(name)) + eq +\n\t\t\t encodeURIComponent(stringifyPrimitive(obj));\n\t};\n\n\tvar isArray = Array.isArray || function (xs) {\n\t return Object.prototype.toString.call(xs) === '[object Array]';\n\t};\n\n\tfunction map(xs, f) {\n\t if (xs.map) {\n return xs.map(f);\n}\n\t const res = [];\n\t for (let i = 0; i < xs.length; i++) {\n\t\tres.push(f(xs[i], i));\n\t }\n\t return res;\n\t}\n\n\tvar objectKeys = Object.keys || function (obj) {\n\t const res = [];\n\t for (const key in obj) {\n\t\tif (Object.prototype.hasOwnProperty.call(obj, key)) {\n res.push(key);\n}\n\t }\n\t return res;\n\t};\n\t/** */ }),\n\t/* 36 */\n\t/** */ (function (module, exports, __webpack_require__) {\n\tconst http = __webpack_require__(10);\n\tconst url = __webpack_require__(7);\n\n\tconst https = module.exports;\n\n\tfor (const key in http) {\n\t if (http.hasOwnProperty(key)) {\n https[key] = http[key];\n}\n\t}\n\n\thttps.request = function (params, cb) {\n\t params = validateParams(params);\n\t return http.request.call(this, params, cb);\n\t};\n\n\thttps.get = function (params, cb) {\n\t params = validateParams(params);\n\t return http.get.call(this, params, cb);\n\t};\n\n\tfunction validateParams(params) {\n\t if (typeof params === 'string') {\n\t\tparams = url.parse(params);\n\t }\n\t if (!params.protocol) {\n\t\tparams.protocol = 'https:';\n\t }\n\t if (params.protocol !== 'https:') {\n\t\tthrow new Error('Protocol \"' + params.protocol + '\" not supported. Expected \"https:\"');\n\t }\n\t return params;\n\t}\n\t/** */ }),\n\t/* 37 */\n\t/** */ (function (module, exports, __webpack_require__) {\n\t/* WEBPACK VAR INJECTION */(function (Buffer, global, process) {\n const capability = __webpack_require__(11);\n\tconst inherits = __webpack_require__(12);\n\tconst response = __webpack_require__(13);\n\tconst stream = __webpack_require__(14);\n\tconst toArrayBuffer = __webpack_require__(47);\n\n\tconst IncomingMessage = response.IncomingMessage;\n\tconst rStates = response.readyStates;\n\n\tfunction decideMode(preferBinary, useFetch) {\n\t\tif (capability.fetch && useFetch) {\n\t\t\treturn 'fetch';\n\t\t} else if (capability.mozchunkedarraybuffer) {\n\t\t\treturn 'moz-chunked-arraybuffer';\n\t\t} else if (capability.msstream) {\n\t\t\treturn 'ms-stream';\n\t\t} else if (capability.arraybuffer && preferBinary) {\n\t\t\treturn 'arraybuffer';\n\t\t} else if (capability.vbArray && preferBinary) {\n\t\t\treturn 'text:vbarray';\n\t\t}\n\t\t\treturn 'text';\n\t}\n\n\tconst ClientRequest = module.exports = function (opts) {\n\t\tconst self = this;\n\t\tstream.Writable.call(self);\n\n\t\tself._opts = opts;\n\t\tself._body = [];\n\t\tself._headers = {};\n\t\tif (opts.auth) {\n self.setHeader('Authorization', 'Basic ' + new Buffer(opts.auth).toString('base64'));\n}\n\t\tObject.keys(opts.headers).forEach((name) => {\n\t\t\tself.setHeader(name, opts.headers[name]);\n\t\t});\n\n\t\tlet preferBinary;\n\t\tlet useFetch = true;\n\t\tif (opts.mode === 'disable-fetch' || ('requestTimeout' in opts && !capability.abortController)) {\n\t\t\t// If the use of XHR should be preferred. Not typically needed.\n\t\t\tuseFetch = false;\n\t\t\tpreferBinary = true;\n\t\t} else if (opts.mode === 'prefer-streaming') {\n\t\t\t// If streaming is a high priority but binary compatibility and\n\t\t\t// the accuracy of the 'content-type' header aren't\n\t\t\tpreferBinary = false;\n\t\t} else if (opts.mode === 'allow-wrong-content-type') {\n\t\t\t// If streaming is more important than preserving the 'content-type' header\n\t\t\tpreferBinary = !capability.overrideMimeType;\n\t\t} else if (!opts.mode || opts.mode === 'default' || opts.mode === 'prefer-fast') {\n\t\t\t// Use binary if text streaming may corrupt data or the content-type header, or for speed\n\t\t\tpreferBinary = true;\n\t\t} else {\n\t\t\tthrow new Error('Invalid value for opts.mode');\n\t\t}\n\t\tself._mode = decideMode(preferBinary, useFetch);\n\t\tself._fetchTimer = null;\n\n\t\tself.on('finish', () => {\n\t\t\tself._onFinish();\n\t\t});\n\t};\n\n\tinherits(ClientRequest, stream.Writable);\n\n\tClientRequest.prototype.setHeader = function (name, value) {\n\t\tconst self = this;\n\t\tconst lowerName = name.toLowerCase();\n\t\t// This check is not necessary, but it prevents warnings from browsers about setting unsafe\n\t\t// headers. To be honest I'm not entirely sure hiding these warnings is a good thing, but\n\t\t// http-browserify did it, so I will too.\n\t\tif (unsafeHeaders.indexOf(lowerName) !== -1) {\n return;\n}\n\n\t\tself._headers[lowerName] = {\n\t\t\tname,\n\t\t\tvalue\n\t\t};\n\t};\n\n\tClientRequest.prototype.getHeader = function (name) {\n\t\tconst header = this._headers[name.toLowerCase()];\n\t\tif (header) {\n return header.value;\n}\n\t\treturn null;\n\t};\n\n\tClientRequest.prototype.removeHeader = function (name) {\n\t\tconst self = this;\n\t\tdelete self._headers[name.toLowerCase()];\n\t};\n\n\tClientRequest.prototype._onFinish = function () {\n\t\tconst self = this;\n\n\t\tif (self._destroyed) {\n return;\n}\n\t\tconst opts = self._opts;\n\n\t\tconst headersObj = self._headers;\n\t\tlet body = null;\n\t\tif (opts.method !== 'GET' && opts.method !== 'HEAD') {\n\t\t\tif (capability.arraybuffer) {\n\t\t\t\tbody = toArrayBuffer(Buffer.concat(self._body));\n\t\t\t} else if (capability.blobConstructor) {\n\t\t\t\tbody = new global.Blob(self._body.map((buffer) => {\n\t\t\t\t\treturn toArrayBuffer(buffer);\n\t\t\t\t}), {\n\t\t\t\t\ttype: (headersObj['content-type'] || {}).value || ''\n\t\t\t\t});\n\t\t\t} else {\n\t\t\t\t// get utf8 string\n\t\t\t\tbody = Buffer.concat(self._body).toString();\n\t\t\t}\n\t\t}\n\n\t\t// create flattened list of headers\n\t\tconst headersList = [];\n\t\tObject.keys(headersObj).forEach((keyName) => {\n\t\t\tconst name = headersObj[keyName].name;\n\t\t\tconst value = headersObj[keyName].value;\n\t\t\tif (Array.isArray(value)) {\n\t\t\t\tvalue.forEach((v) => {\n\t\t\t\t\theadersList.push([name, v]);\n\t\t\t\t});\n\t\t\t} else {\n\t\t\t\theadersList.push([name, value]);\n\t\t\t}\n\t\t});\n\n\t\tif (self._mode === 'fetch') {\n\t\t\tlet signal = null;\n\t\t\tconst fetchTimer = null;\n\t\t\tif (capability.abortController) {\n\t\t\t\tconst controller = new AbortController();\n\t\t\t\tsignal = controller.signal;\n\t\t\t\tself._fetchAbortController = controller;\n\n\t\t\t\tif ('requestTimeout' in opts && opts.requestTimeout !== 0) {\n\t\t\t\t\tself._fetchTimer = global.setTimeout(() => {\n\t\t\t\t\t\tself.emit('requestTimeout');\n\t\t\t\t\t\tif (self._fetchAbortController) {\n self._fetchAbortController.abort();\n}\n\t\t\t\t\t}, opts.requestTimeout);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tglobal.fetch(self._opts.url, {\n\t\t\t\tmethod: self._opts.method,\n\t\t\t\theaders: headersList,\n\t\t\t\tbody: body || undefined,\n\t\t\t\tmode: 'cors',\n\t\t\t\tcredentials: opts.withCredentials ? 'include' : 'same-origin',\n\t\t\t\tsignal\n\t\t\t}).then((response) => {\n\t\t\t\tself._fetchResponse = response;\n\t\t\t\tself._connect();\n\t\t\t}, (reason) => {\n\t\t\t\tglobal.clearTimeout(self._fetchTimer);\n\t\t\t\tif (!self._destroyed) {\n self.emit('error', reason);\n}\n\t\t\t});\n\t\t} else {\n\t\t\tconst xhr = self._xhr = new global.XMLHttpRequest();\n\t\t\ttry {\n\t\t\t\txhr.open(self._opts.method, self._opts.url, true);\n\t\t\t} catch (err) {\n\t\t\t\tprocess.nextTick(() => {\n\t\t\t\t\tself.emit('error', err);\n\t\t\t\t});\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Can't set responseType on really old browsers\n\t\t\tif ('responseType' in xhr) {\n xhr.responseType = self._mode.split(':')[0];\n}\n\n\t\t\tif ('withCredentials' in xhr) {\n xhr.withCredentials = !!opts.withCredentials;\n}\n\n\t\t\tif (self._mode === 'text' && 'overrideMimeType' in xhr) {\n xhr.overrideMimeType('text/plain; charset=x-user-defined');\n}\n\n\t\t\tif ('requestTimeout' in opts) {\n\t\t\t\txhr.timeout = opts.requestTimeout;\n\t\t\t\txhr.ontimeout = function () {\n\t\t\t\t\tself.emit('requestTimeout');\n\t\t\t\t};\n\t\t\t}\n\n\t\t\theadersList.forEach((header) => {\n\t\t\t\txhr.setRequestHeader(header[0], header[1]);\n\t\t\t});\n\n\t\t\tself._response = null;\n\t\t\txhr.onreadystatechange = function () {\n\t\t\t\tswitch (xhr.readyState) {\n\t\t\t\t\tcase rStates.LOADING:\n\t\t\t\t\tcase rStates.DONE:\n\t\t\t\t\t\tself._onXHRProgress();\n\t\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t};\n\t\t\t// Necessary for streaming in Firefox, since xhr.response is ONLY defined\n\t\t\t// in onprogress, not in onreadystatechange with xhr.readyState = 3\n\t\t\tif (self._mode === 'moz-chunked-arraybuffer') {\n\t\t\t\txhr.onprogress = function () {\n\t\t\t\t\tself._onXHRProgress();\n\t\t\t\t};\n\t\t\t}\n\n\t\t\txhr.onerror = function () {\n\t\t\t\tif (self._destroyed) {\n return;\n}\n\t\t\t\tself.emit('error', new Error('XHR error'));\n\t\t\t};\n\n\t\t\ttry {\n\t\t\t\txhr.send(body);\n\t\t\t} catch (err) {\n\t\t\t\tprocess.nextTick(() => {\n\t\t\t\t\tself.emit('error', err);\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t};\n\n\t/**\n\t * Checks if xhr.status is readable and non-zero, indicating no error.\n\t * Even though the spec says it should be available in readyState 3,\n\t * accessing it throws an exception in IE8\n\t */\n\tfunction statusValid(xhr) {\n\t\ttry {\n\t\t\tconst status = xhr.status;\n\t\t\treturn (status !== null && status !== 0);\n\t\t} catch (e) {\n\t\t\treturn false;\n\t\t}\n\t}\n\n\tClientRequest.prototype._onXHRProgress = function () {\n\t\tconst self = this;\n\n\t\tif (!statusValid(self._xhr) || self._destroyed) {\n return;\n}\n\n\t\tif (!self._response) {\n self._connect();\n}\n\n\t\tself._response._onXHRProgress();\n\t};\n\n\tClientRequest.prototype._connect = function () {\n\t\tconst self = this;\n\n\t\tif (self._destroyed) {\n return;\n}\n\n\t\tself._response = new IncomingMessage(self._xhr, self._fetchResponse, self._mode, self._fetchTimer);\n\t\tself._response.on('error', (err) => {\n\t\t\tself.emit('error', err);\n\t\t});\n\n\t\tself.emit('response', self._response);\n\t};\n\n\tClientRequest.prototype._write = function (chunk, encoding, cb) {\n\t\tconst self = this;\n\n\t\tself._body.push(chunk);\n\t\tcb();\n\t};\n\n\tClientRequest.prototype.abort = ClientRequest.prototype.destroy = function () {\n\t\tconst self = this;\n\t\tself._destroyed = true;\n\t\tglobal.clearTimeout(self._fetchTimer);\n\t\tif (self._response) {\n self._response._destroyed = true;\n}\n\t\tif (self._xhr) {\n self._xhr.abort();\n} else if (self._fetchAbortController) {\n self._fetchAbortController.abort();\n}\n\t};\n\n\tClientRequest.prototype.end = function (data, encoding, cb) {\n\t\tconst self = this;\n\t\tif (typeof data === 'function') {\n\t\t\tcb = data;\n\t\t\tdata = undefined;\n\t\t}\n\n\t\tstream.Writable.prototype.end.call(self, data, encoding, cb);\n\t};\n\n\tClientRequest.prototype.flushHeaders = function () {};\n\tClientRequest.prototype.setTimeout = function () {};\n\tClientRequest.prototype.setNoDelay = function () {};\n\tClientRequest.prototype.setSocketKeepAlive = function () {};\n\n\t// Taken from http://www.w3.org/TR/XMLHttpRequest/#the-setrequestheader%28%29-method\n\tvar unsafeHeaders = [\n\t\t'accept-charset',\n\t\t'accept-encoding',\n\t\t'access-control-request-headers',\n\t\t'access-control-request-method',\n\t\t'connection',\n\t\t'content-length',\n\t\t'cookie',\n\t\t'cookie2',\n\t\t'date',\n\t\t'dnt',\n\t\t'expect',\n\t\t'host',\n\t\t'keep-alive',\n\t\t'origin',\n\t\t'referer',\n\t\t'te',\n\t\t'trailer',\n\t\t'transfer-encoding',\n\t\t'upgrade',\n\t\t'via'\n\t];\n\t/* WEBPACK VAR INJECTION */ }.call(exports, __webpack_require__(2).Buffer, __webpack_require__(0), __webpack_require__(1)));\n\t/** */ }),\n\t/* 38 */\n\t/** */ (function (module, exports) {\n\tconst toString = {}.toString;\n\n\tmodule.exports = Array.isArray || function (arr) {\n\t return toString.call(arr) == '[object Array]';\n\t};\n\t/** */ }),\n\t/* 39 */\n\t/** */ (function (module, exports) {\n\n\t/* (ignored) */\n\n\t/** */ }),\n\t/* 40 */\n\t/** */ (function (module, exports, __webpack_require__) {\n\t\"use strict\";\n\n\n\tfunction _classCallCheck(instance, Constructor) {\n if (!(instance instanceof Constructor)) {\n throw new TypeError(\"Cannot call a class as a function\");\n}\n}\n\n\tconst Buffer = __webpack_require__(9).Buffer;\n\tconst util = __webpack_require__(41);\n\n\tfunction copyBuffer(src, target, offset) {\n\t src.copy(target, offset);\n\t}\n\n\tmodule.exports = (function () {\n\t function BufferList() {\n\t\t_classCallCheck(this, BufferList);\n\n\t\tthis.head = null;\n\t\tthis.tail = null;\n\t\tthis.length = 0;\n\t }\n\n\t BufferList.prototype.push = function push(v) {\n\t\tconst entry = { data: v, next: null };\n\t\tif (this.length > 0) {\n this.tail.next = entry;\n} else {\n this.head = entry;\n}\n\t\tthis.tail = entry;\n\t\t++this.length;\n\t };\n\n\t BufferList.prototype.unshift = function unshift(v) {\n\t\tconst entry = { data: v, next: this.head };\n\t\tif (this.length === 0) {\n this.tail = entry;\n}\n\t\tthis.head = entry;\n\t\t++this.length;\n\t };\n\n\t BufferList.prototype.shift = function shift() {\n\t\tif (this.length === 0) {\n return;\n}\n\t\tconst ret = this.head.data;\n\t\tif (this.length === 1) {\n this.head = this.tail = null;\n} else {\n this.head = this.head.next;\n}\n\t\t--this.length;\n\t\treturn ret;\n\t };\n\n\t BufferList.prototype.clear = function clear() {\n\t\tthis.head = this.tail = null;\n\t\tthis.length = 0;\n\t };\n\n\t BufferList.prototype.join = function join(s) {\n\t\tif (this.length === 0) {\n return '';\n}\n\t\tlet p = this.head;\n\t\tlet ret = '' + p.data;\n\t\twhile (p = p.next) {\n\t\t ret += s + p.data;\n\t\t} return ret;\n\t };\n\n\t BufferList.prototype.concat = function concat(n) {\n\t\tif (this.length === 0) {\n return Buffer.alloc(0);\n}\n\t\tif (this.length === 1) {\n return this.head.data;\n}\n\t\tconst ret = Buffer.allocUnsafe(n >>> 0);\n\t\tlet p = this.head;\n\t\tlet i = 0;\n\t\twhile (p) {\n\t\t copyBuffer(p.data, ret, i);\n\t\t i += p.data.length;\n\t\t p = p.next;\n\t\t}\n\t\treturn ret;\n\t };\n\n\t return BufferList;\n\t}());\n\n\tif (util && util.inspect && util.inspect.custom) {\n\t module.exports.prototype[util.inspect.custom] = function () {\n\t\tconst obj = util.inspect({ length: this.length });\n\t\treturn this.constructor.name + ' ' + obj;\n\t };\n\t}\n\t/** */ }),\n\t/* 41 */\n\t/** */ (function (module, exports) {\n\n\t/* (ignored) */\n\n\t/** */ }),\n\t/* 42 */\n\t/** */ (function (module, exports, __webpack_require__) {\n\t/* WEBPACK VAR INJECTION */(function (global) {\n const scope = (typeof global !== \"undefined\" && global) ||\n\t\t\t\t(typeof self !== \"undefined\" && self) ||\n\t\t\t\twindow;\n\tconst apply = Function.prototype.apply;\n\n\t// DOM APIs, for completeness\n\n\texports.setTimeout = function () {\n\t return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout);\n\t};\n\texports.setInterval = function () {\n\t return new Timeout(apply.call(setInterval, scope, arguments), clearInterval);\n\t};\n\texports.clearTimeout =\n\texports.clearInterval = function (timeout) {\n\t if (timeout) {\n\t\ttimeout.close();\n\t }\n\t};\n\n\tfunction Timeout(id, clearFn) {\n\t this._id = id;\n\t this._clearFn = clearFn;\n\t}\n\tTimeout.prototype.unref = Timeout.prototype.ref = function () {};\n\tTimeout.prototype.close = function () {\n\t this._clearFn.call(scope, this._id);\n\t};\n\n\t// Does not start the time, just sets up the members needed.\n\texports.enroll = function (item, msecs) {\n\t clearTimeout(item._idleTimeoutId);\n\t item._idleTimeout = msecs;\n\t};\n\n\texports.unenroll = function (item) {\n\t clearTimeout(item._idleTimeoutId);\n\t item._idleTimeout = -1;\n\t};\n\n\texports._unrefActive = exports.active = function (item) {\n\t clearTimeout(item._idleTimeoutId);\n\n\t const msecs = item._idleTimeout;\n\t if (msecs >= 0) {\n\t\titem._idleTimeoutId = setTimeout(() => {\n\t\t if (item._onTimeout) {\n item._onTimeout();\n}\n\t\t}, msecs);\n\t }\n\t};\n\n\t// setimmediate attaches itself to the global object\n\t__webpack_require__(43);\n\t// On some exotic environments, it's not clear which object `setimmediate` was\n\t// able to install onto. Search each possibility in the same order as the\n\t// `setimmediate` library.\n\texports.setImmediate = (typeof self !== \"undefined\" && self.setImmediate) ||\n\t\t\t\t\t\t (typeof global !== \"undefined\" && global.setImmediate) ||\n\t\t\t\t\t\t (this && this.setImmediate);\n\texports.clearImmediate = (typeof self !== \"undefined\" && self.clearImmediate) ||\n\t\t\t\t\t\t\t (typeof global !== \"undefined\" && global.clearImmediate) ||\n\t\t\t\t\t\t\t (this && this.clearImmediate);\n\t/* WEBPACK VAR INJECTION */ }.call(exports, __webpack_require__(0)));\n\t/** */ }),\n\t/* 43 */\n\t/** */ (function (module, exports, __webpack_require__) {\n\t/* WEBPACK VAR INJECTION */(function (global, process) {\n (function (global, undefined) {\n\t\t\"use strict\";\n\n\t\tif (global.setImmediate) {\n\t\t\treturn;\n\t\t}\n\n\t\tlet nextHandle = 1; // Spec says greater than zero\n\t\tconst tasksByHandle = {};\n\t\tlet currentlyRunningATask = false;\n\t\tconst doc = global.document;\n\t\tlet registerImmediate;\n\n\t\tfunction setImmediate(callback) {\n\t\t // Callback can either be a function or a string\n\t\t if (typeof callback !== \"function\") {\n\t\t\tcallback = new Function(\"\" + callback);\n\t\t }\n\t\t // Copy function arguments\n\t\t const args = new Array(arguments.length - 1);\n\t\t for (let i = 0; i < args.length; i++) {\n\t\t\t args[i] = arguments[i + 1];\n\t\t }\n\t\t // Store and register the task\n\t\t const task = { callback, args };\n\t\t tasksByHandle[nextHandle] = task;\n\t\t registerImmediate(nextHandle);\n\t\t return nextHandle++;\n\t\t}\n\n\t\tfunction clearImmediate(handle) {\n\t\t\tdelete tasksByHandle[handle];\n\t\t}\n\n\t\tfunction run(task) {\n\t\t\tconst callback = task.callback;\n\t\t\tconst args = task.args;\n\t\t\tswitch (args.length) {\n\t\t\tcase 0:\n\t\t\t\tcallback();\n\t\t\t\tbreak;\n\t\t\tcase 1:\n\t\t\t\tcallback(args[0]);\n\t\t\t\tbreak;\n\t\t\tcase 2:\n\t\t\t\tcallback(args[0], args[1]);\n\t\t\t\tbreak;\n\t\t\tcase 3:\n\t\t\t\tcallback(args[0], args[1], args[2]);\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tcallback.apply(undefined, args);\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\tfunction runIfPresent(handle) {\n\t\t\t// From the spec: \"Wait until any invocations of this algorithm started before this one have completed.\"\n\t\t\t// So if we're currently running a task, we'll need to delay this invocation.\n\t\t\tif (currentlyRunningATask) {\n\t\t\t\t// Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a\n\t\t\t\t// \"too much recursion\" error.\n\t\t\t\tsetTimeout(runIfPresent, 0, handle);\n\t\t\t} else {\n\t\t\t\tconst task = tasksByHandle[handle];\n\t\t\t\tif (task) {\n\t\t\t\t\tcurrentlyRunningATask = true;\n\t\t\t\t\ttry {\n\t\t\t\t\t\trun(task);\n\t\t\t\t\t} finally {\n\t\t\t\t\t\tclearImmediate(handle);\n\t\t\t\t\t\tcurrentlyRunningATask = false;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tfunction installNextTickImplementation() {\n\t\t\tregisterImmediate = function (handle) {\n\t\t\t\tprocess.nextTick(() => {\n runIfPresent(handle);\n});\n\t\t\t};\n\t\t}\n\n\t\tfunction canUsePostMessage() {\n\t\t\t// The test against `importScripts` prevents this implementation from being installed inside a web worker,\n\t\t\t// where `global.postMessage` means something completely different and can't be used for this purpose.\n\t\t\tif (global.postMessage && !global.importScripts) {\n\t\t\t\tlet postMessageIsAsynchronous = true;\n\t\t\t\tconst oldOnMessage = global.onmessage;\n\t\t\t\tglobal.onmessage = function () {\n\t\t\t\t\tpostMessageIsAsynchronous = false;\n\t\t\t\t};\n\t\t\t\tglobal.postMessage(\"\", \"*\");\n\t\t\t\tglobal.onmessage = oldOnMessage;\n\t\t\t\treturn postMessageIsAsynchronous;\n\t\t\t}\n\t\t}\n\n\t\tfunction installPostMessageImplementation() {\n\t\t\t// Installs an event handler on `global` for the `message` event: see\n\t\t\t// * https://developer.mozilla.org/en/DOM/window.postMessage\n\t\t\t// * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages\n\n\t\t\tconst messagePrefix = \"setImmediate$\" + Math.random() + \"$\";\n\t\t\tconst onGlobalMessage = function (event) {\n\t\t\t\tif (event.source === global &&\n\t\t\t\t\ttypeof event.data === \"string\" &&\n\t\t\t\t\tevent.data.indexOf(messagePrefix) === 0) {\n\t\t\t\t\trunIfPresent(+event.data.slice(messagePrefix.length));\n\t\t\t\t}\n\t\t\t};\n\n\t\t\tif (global.addEventListener) {\n\t\t\t\tglobal.addEventListener(\"message\", onGlobalMessage, false);\n\t\t\t} else {\n\t\t\t\tglobal.attachEvent(\"onmessage\", onGlobalMessage);\n\t\t\t}\n\n\t\t\tregisterImmediate = function (handle) {\n\t\t\t\tglobal.postMessage(messagePrefix + handle, \"*\");\n\t\t\t};\n\t\t}\n\n\t\tfunction installMessageChannelImplementation() {\n\t\t\tconst channel = new MessageChannel();\n\t\t\tchannel.port1.onmessage = function (event) {\n\t\t\t\tconst handle = event.data;\n\t\t\t\trunIfPresent(handle);\n\t\t\t};\n\n\t\t\tregisterImmediate = function (handle) {\n\t\t\t\tchannel.port2.postMessage(handle);\n\t\t\t};\n\t\t}\n\n\t\tfunction installReadyStateChangeImplementation() {\n\t\t\tconst html = doc.documentElement;\n\t\t\tregisterImmediate = function (handle) {\n\t\t\t\t// Create a