{"version":3,"file":"hls-p2p-engine.min.js","mappings":"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","sources":["webpack://@cvte/hls-p2p-engine/webpack/runtime/create fake namespace object","webpack://@cvte/hls-p2p-engine/./node_modules/base64-js/index.js","webpack://@cvte/hls-p2p-engine/./node_modules/buffer/index.js","webpack://@cvte/hls-p2p-engine/./node_modules/clone/clone.js","webpack://@cvte/hls-p2p-engine/./node_modules/debug/src/browser.js","webpack://@cvte/hls-p2p-engine/./node_modules/debug/src/common.js","webpack://@cvte/hls-p2p-engine/./node_modules/err-code/index.js","webpack://@cvte/hls-p2p-engine/./node_modules/events/events.js","webpack://@cvte/hls-p2p-engine/./node_modules/fast-fifo/fixed-size.js","webpack://@cvte/hls-p2p-engine/./node_modules/fast-fifo/index.js","webpack://@cvte/hls-p2p-engine/./node_modules/get-browser-rtc/index.js","webpack://@cvte/hls-p2p-engine/./node_modules/ieee754/index.js","webpack://@cvte/hls-p2p-engine/./node_modules/inherits/inherits_browser.js","webpack://@cvte/hls-p2p-engine/./node_modules/ms/index.js","webpack://@cvte/hls-p2p-engine/./node_modules/once/once.js","webpack://@cvte/hls-p2p-engine/./node_modules/queue-microtask/index.js","webpack://@cvte/hls-p2p-engine/./node_modules/queue-tick/queue-microtask.js","webpack://@cvte/hls-p2p-engine/./node_modules/run-parallel/index.js","webpack://@cvte/hls-p2p-engine/./node_modules/safe-buffer/index.js","webpack://@cvte/hls-p2p-engine/./node_modules/sha.js/hash.js","webpack://@cvte/hls-p2p-engine/./node_modules/sha.js/sha1.js","webpack://@cvte/hls-p2p-engine/./node_modules/streamx/index.js","webpack://@cvte/hls-p2p-engine/./node_modules/wrappy/wrappy.js","webpack://@cvte/hls-p2p-engine/webpack/bootstrap","webpack://@cvte/hls-p2p-engine/webpack/runtime/compat get default export","webpack://@cvte/hls-p2p-engine/webpack/runtime/define property getters","webpack://@cvte/hls-p2p-engine/webpack/runtime/global","webpack://@cvte/hls-p2p-engine/webpack/runtime/hasOwnProperty shorthand","webpack://@cvte/hls-p2p-engine/webpack/runtime/make namespace object","webpack://@cvte/hls-p2p-engine/./lib/interface.ts","webpack://@cvte/hls-p2p-engine/./node_modules/uint8-util/util.js","webpack://@cvte/hls-p2p-engine/./node_modules/base64-arraybuffer/dist/base64-arraybuffer.es5.js","webpack://@cvte/hls-p2p-engine/./node_modules/uint8-util/browser.js","webpack://@cvte/hls-p2p-engine/./node_modules/@thaunknown/simple-peer/lite.js","webpack://@cvte/hls-p2p-engine/./node_modules/bittorrent-tracker/lib/common.js","webpack://@cvte/hls-p2p-engine/./node_modules/@thaunknown/simple-websocket/index.js","webpack://@cvte/hls-p2p-engine/./node_modules/bittorrent-tracker/lib/client/tracker.js","webpack://@cvte/hls-p2p-engine/./node_modules/bittorrent-tracker/lib/client/websocket-tracker.js","webpack://@cvte/hls-p2p-engine/./node_modules/bittorrent-tracker/client.js","webpack://@cvte/hls-p2p-engine/./lib/media-peer.ts","webpack://@cvte/hls-p2p-engine/./lib/stringly-typed-event-emitter.ts","webpack://@cvte/hls-p2p-engine/./lib/p2p-manager.ts","webpack://@cvte/hls-p2p-engine/./lib/segments-memory-storage.ts","webpack://@cvte/hls-p2p-engine/./lib/p2pEngine.ts","webpack://@cvte/hls-p2p-engine/./node_modules/hls.js/src/loader/load-stats.ts","webpack://@cvte/hls-p2p-engine/./node_modules/hls.js/src/utils/logger.ts","webpack://@cvte/hls-p2p-engine/./node_modules/hls.js/src/utils/xhr-loader.ts","webpack://@cvte/hls-p2p-engine/./lib/hybrid-fragment-loader.ts","webpack://@cvte/hls-p2p-engine/./lib/index.ts"],"sourcesContent":["var getProto = Object.getPrototypeOf ? (obj) => (Object.getPrototypeOf(obj)) : (obj) => (obj.__proto__);\nvar leafPrototypes;\n// create a fake namespace object\n// mode & 1: value is a module id, require it\n// mode & 2: merge all properties of value into the ns\n// mode & 4: return value when already ns object\n// mode & 16: return value when it's Promise-like\n// mode & 8|1: behave like require\n__webpack_require__.t = function(value, mode) {\n\tif(mode & 1) value = this(value);\n\tif(mode & 8) return value;\n\tif(typeof value === 'object' && value) {\n\t\tif((mode & 4) && value.__esModule) return value;\n\t\tif((mode & 16) && typeof value.then === 'function') return value;\n\t}\n\tvar ns = Object.create(null);\n\t__webpack_require__.r(ns);\n\tvar def = {};\n\tleafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];\n\tfor(var current = mode & 2 && value; typeof current == 'object' && !~leafPrototypes.indexOf(current); current = getProto(current)) {\n\t\tObject.getOwnPropertyNames(current).forEach((key) => (def[key] = () => (value[key])));\n\t}\n\tdef['default'] = () => (value);\n\t__webpack_require__.d(ns, def);\n\treturn ns;\n};","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\n// Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction getLens (b64) {\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n  var validLen = b64.indexOf('=')\n  if (validLen === -1) validLen = len\n\n  var placeHoldersLen = validLen === len\n    ? 0\n    : 4 - (validLen % 4)\n\n  return [validLen, placeHoldersLen]\n}\n\n// base64 is 4/3 + up to two characters of the original data\nfunction byteLength (b64) {\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction _byteLength (b64, validLen, placeHoldersLen) {\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction toByteArray (b64) {\n  var tmp\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\n\n  var curByte = 0\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  var len = placeHoldersLen > 0\n    ? validLen - 4\n    : validLen\n\n  var i\n  for (i = 0; i < len; i += 4) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 18) |\n      (revLookup[b64.charCodeAt(i + 1)] << 12) |\n      (revLookup[b64.charCodeAt(i + 2)] << 6) |\n      revLookup[b64.charCodeAt(i + 3)]\n    arr[curByte++] = (tmp >> 16) & 0xFF\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 2) |\n      (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 10) |\n      (revLookup[b64.charCodeAt(i + 1)] << 4) |\n      (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] +\n    lookup[num >> 12 & 0x3F] +\n    lookup[num >> 6 & 0x3F] +\n    lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp =\n      ((uint8[i] << 16) & 0xFF0000) +\n      ((uint8[i + 1] << 8) & 0xFF00) +\n      (uint8[i + 2] & 0xFF)\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 2] +\n      lookup[(tmp << 4) & 0x3F] +\n      '=='\n    )\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 10] +\n      lookup[(tmp >> 4) & 0x3F] +\n      lookup[(tmp << 2) & 0x3F] +\n      '='\n    )\n  }\n\n  return parts.join('')\n}\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <https://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\nvar K_MAX_LENGTH = 0x7fffffff\nexports.kMaxLength = K_MAX_LENGTH\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Print warning and recommend using `buffer` v4.x which has an Object\n *               implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * We report that the browser does not support typed arrays if the are not subclassable\n * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`\n * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support\n * for __proto__ and has a buggy typed array implementation.\n */\nBuffer.TYPED_ARRAY_SUPPORT = typedArraySupport()\n\nif (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&\n    typeof console.error === 'function') {\n  console.error(\n    'This browser lacks typed array (Uint8Array) support which is required by ' +\n    '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'\n  )\n}\n\nfunction typedArraySupport () {\n  // Can typed array instances can be augmented?\n  try {\n    var arr = new Uint8Array(1)\n    arr.__proto__ = { __proto__: Uint8Array.prototype, foo: function () { return 42 } }\n    return arr.foo() === 42\n  } catch (e) {\n    return false\n  }\n}\n\nObject.defineProperty(Buffer.prototype, 'parent', {\n  enumerable: true,\n  get: function () {\n    if (!Buffer.isBuffer(this)) return undefined\n    return this.buffer\n  }\n})\n\nObject.defineProperty(Buffer.prototype, 'offset', {\n  enumerable: true,\n  get: function () {\n    if (!Buffer.isBuffer(this)) return undefined\n    return this.byteOffset\n  }\n})\n\nfunction createBuffer (length) {\n  if (length > K_MAX_LENGTH) {\n    throw new RangeError('The value \"' + length + '\" is invalid for option \"size\"')\n  }\n  // Return an augmented `Uint8Array` instance\n  var buf = new Uint8Array(length)\n  buf.__proto__ = Buffer.prototype\n  return buf\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new TypeError(\n        'The \"string\" argument must be of type string. Received type number'\n      )\n    }\n    return allocUnsafe(arg)\n  }\n  return from(arg, encodingOrOffset, length)\n}\n\n// Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\nif (typeof Symbol !== 'undefined' && Symbol.species != null &&\n    Buffer[Symbol.species] === Buffer) {\n  Object.defineProperty(Buffer, Symbol.species, {\n    value: null,\n    configurable: true,\n    enumerable: false,\n    writable: false\n  })\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\nfunction from (value, encodingOrOffset, length) {\n  if (typeof value === 'string') {\n    return fromString(value, encodingOrOffset)\n  }\n\n  if (ArrayBuffer.isView(value)) {\n    return fromArrayLike(value)\n  }\n\n  if (value == null) {\n    throw TypeError(\n      'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\n      'or Array-like Object. Received type ' + (typeof value)\n    )\n  }\n\n  if (isInstance(value, ArrayBuffer) ||\n      (value && isInstance(value.buffer, ArrayBuffer))) {\n    return fromArrayBuffer(value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'number') {\n    throw new TypeError(\n      'The \"value\" argument must not be of type number. Received type number'\n    )\n  }\n\n  var valueOf = value.valueOf && value.valueOf()\n  if (valueOf != null && valueOf !== value) {\n    return Buffer.from(valueOf, encodingOrOffset, length)\n  }\n\n  var b = fromObject(value)\n  if (b) return b\n\n  if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&\n      typeof value[Symbol.toPrimitive] === 'function') {\n    return Buffer.from(\n      value[Symbol.toPrimitive]('string'), encodingOrOffset, length\n    )\n  }\n\n  throw new TypeError(\n    'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\n    'or Array-like Object. Received type ' + (typeof value)\n  )\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(value, encodingOrOffset, length)\n}\n\n// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:\n// https://github.com/feross/buffer/pull/148\nBuffer.prototype.__proto__ = Uint8Array.prototype\nBuffer.__proto__ = Uint8Array\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be of type number')\n  } else if (size < 0) {\n    throw new RangeError('The value \"' + size + '\" is invalid for option \"size\"')\n  }\n}\n\nfunction alloc (size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpretted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(size).fill(fill, encoding)\n      : createBuffer(size).fill(fill)\n  }\n  return createBuffer(size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(size, fill, encoding)\n}\n\nfunction allocUnsafe (size) {\n  assertSize(size)\n  return createBuffer(size < 0 ? 0 : checked(size) | 0)\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(size)\n}\n\nfunction fromString (string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('Unknown encoding: ' + encoding)\n  }\n\n  var length = byteLength(string, encoding) | 0\n  var buf = createBuffer(length)\n\n  var actual = buf.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    buf = buf.slice(0, actual)\n  }\n\n  return buf\n}\n\nfunction fromArrayLike (array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0\n  var buf = createBuffer(length)\n  for (var i = 0; i < length; i += 1) {\n    buf[i] = array[i] & 255\n  }\n  return buf\n}\n\nfunction fromArrayBuffer (array, byteOffset, length) {\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\"offset\" is outside of buffer bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\"length\" is outside of buffer bounds')\n  }\n\n  var buf\n  if (byteOffset === undefined && length === undefined) {\n    buf = new Uint8Array(array)\n  } else if (length === undefined) {\n    buf = new Uint8Array(array, byteOffset)\n  } else {\n    buf = new Uint8Array(array, byteOffset, length)\n  }\n\n  // Return an augmented `Uint8Array` instance\n  buf.__proto__ = Buffer.prototype\n  return buf\n}\n\nfunction fromObject (obj) {\n  if (Buffer.isBuffer(obj)) {\n    var len = checked(obj.length) | 0\n    var buf = createBuffer(len)\n\n    if (buf.length === 0) {\n      return buf\n    }\n\n    obj.copy(buf, 0, 0, len)\n    return buf\n  }\n\n  if (obj.length !== undefined) {\n    if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {\n      return createBuffer(0)\n    }\n    return fromArrayLike(obj)\n  }\n\n  if (obj.type === 'Buffer' && Array.isArray(obj.data)) {\n    return fromArrayLike(obj.data)\n  }\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < K_MAX_LENGTH` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= K_MAX_LENGTH) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return b != null && b._isBuffer === true &&\n    b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false\n}\n\nBuffer.compare = function compare (a, b) {\n  if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)\n  if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError(\n      'The \"buf1\", \"buf2\" arguments must be one of type Buffer or Uint8Array'\n    )\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!Array.isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length)\n  var pos = 0\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i]\n    if (isInstance(buf, Uint8Array)) {\n      buf = Buffer.from(buf)\n    }\n    if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    }\n    buf.copy(buffer, pos)\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length\n  }\n  if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    throw new TypeError(\n      'The \"string\" argument must be one of type string, Buffer, or ArrayBuffer. ' +\n      'Received type ' + typeof string\n    )\n  }\n\n  var len = string.length\n  var mustMatch = (arguments.length > 2 && arguments[2] === true)\n  if (!mustMatch && len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) {\n          return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8\n        }\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)\n// to detect a Buffer instance. It's not possible to use `instanceof Buffer`\n// reliably in a browserify context because there could be multiple different\n// copies of the 'buffer' package in use. This method works even for Buffer\n// instances that were created from another copy of the `buffer` package.\n// See: https://github.com/feross/buffer/issues/154\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  var i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  var len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  var len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  var len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.toLocaleString = Buffer.prototype.toString\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = exports.INSPECT_MAX_BYTES\n  str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()\n  if (this.length > max) str += ' ... '\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (isInstance(target, Uint8Array)) {\n    target = Buffer.from(target, target.offset, target.byteLength)\n  }\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError(\n      'The \"target\" argument must be one of type Buffer or Uint8Array. ' +\n      'Received type ' + (typeof target)\n    )\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  var x = thisEnd - thisStart\n  var y = end - start\n  var len = Math.min(x, y)\n\n  var thisCopy = this.slice(thisStart, thisEnd)\n  var targetCopy = target.slice(start, end)\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset // Coerce to Number.\n  if (numberIsNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1\n  var arrLength = arr.length\n  var valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  var i\n  if (dir) {\n    var foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  var strLen = string.length\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (numberIsNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset >>> 0\n    if (isFinite(length)) {\n      length = length >>> 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Write(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF) ? 4\n      : (firstByte > 0xDF) ? 3\n        : (firstByte > 0xBF) ? 2\n          : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256))\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf = this.subarray(start, end)\n  // Return an augmented `Uint8Array` instance\n  newBuf.__proto__ = Buffer.prototype\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  this[offset] = (value >>> 8)\n  this[offset + 1] = (value & 0xff)\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  this[offset + 3] = (value >>> 24)\n  this[offset + 2] = (value >>> 16)\n  this[offset + 1] = (value >>> 8)\n  this[offset] = (value & 0xff)\n  return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  this[offset] = (value >>> 24)\n  this[offset + 1] = (value >>> 16)\n  this[offset + 2] = (value >>> 8)\n  this[offset + 3] = (value & 0xff)\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    var limit = Math.pow(2, (8 * byteLength) - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    var limit = Math.pow(2, (8 * byteLength) - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  this[offset] = (value >>> 8)\n  this[offset + 1] = (value & 0xff)\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\n  this[offset + 2] = (value >>> 16)\n  this[offset + 3] = (value >>> 24)\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  this[offset] = (value >>> 24)\n  this[offset + 1] = (value >>> 16)\n  this[offset + 2] = (value >>> 8)\n  this[offset + 3] = (value & 0xff)\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('Index out of range')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n\n  if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {\n    // Use built-in when available, missing from IE11\n    this.copyWithin(targetStart, start, end)\n  } else if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (var i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, end),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n    if (val.length === 1) {\n      var code = val.charCodeAt(0)\n      if ((encoding === 'utf8' && code < 128) ||\n          encoding === 'latin1') {\n        // Fast path: If `val` fits into a single byte, use that numeric value.\n        val = code\n      }\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  var i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    var bytes = Buffer.isBuffer(val)\n      ? val\n      : Buffer.from(val, encoding)\n    var len = bytes.length\n    if (len === 0) {\n      throw new TypeError('The value \"' + val +\n        '\" is invalid for argument \"value\"')\n    }\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node takes equal signs as end of the Base64 encoding\n  str = str.split('=')[0]\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = str.trim().replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\n// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass\n// the `instanceof` check but they should be treated as of that type.\n// See: https://github.com/feross/buffer/issues/166\nfunction isInstance (obj, type) {\n  return obj instanceof type ||\n    (obj != null && obj.constructor != null && obj.constructor.name != null &&\n      obj.constructor.name === type.name)\n}\nfunction numberIsNaN (obj) {\n  // For IE11 support\n  return obj !== obj // eslint-disable-line no-self-compare\n}\n","var clone = (function() {\n'use strict';\n\nfunction _instanceof(obj, type) {\n  return type != null && obj instanceof type;\n}\n\nvar nativeMap;\ntry {\n  nativeMap = Map;\n} catch(_) {\n  // maybe a reference error because no `Map`. Give it a dummy value that no\n  // value will ever be an instanceof.\n  nativeMap = function() {};\n}\n\nvar nativeSet;\ntry {\n  nativeSet = Set;\n} catch(_) {\n  nativeSet = function() {};\n}\n\nvar nativePromise;\ntry {\n  nativePromise = Promise;\n} catch(_) {\n  nativePromise = function() {};\n}\n\n/**\n * Clones (copies) an Object using deep copying.\n *\n * This function supports circular references by default, but if you are certain\n * there are no circular references in your object, you can save some CPU time\n * by calling clone(obj, false).\n *\n * Caution: if `circular` is false and `parent` contains circular references,\n * your program may enter an infinite loop and crash.\n *\n * @param `parent` - the object to be cloned\n * @param `circular` - set to true if the object to be cloned may contain\n *    circular references. (optional - true by default)\n * @param `depth` - set to a number if the object is only to be cloned to\n *    a particular depth. (optional - defaults to Infinity)\n * @param `prototype` - sets the prototype to be used when cloning an object.\n *    (optional - defaults to parent prototype).\n * @param `includeNonEnumerable` - set to true if the non-enumerable properties\n *    should be cloned as well. Non-enumerable properties on the prototype\n *    chain will be ignored. (optional - false by default)\n*/\nfunction clone(parent, circular, depth, prototype, includeNonEnumerable) {\n  if (typeof circular === 'object') {\n    depth = circular.depth;\n    prototype = circular.prototype;\n    includeNonEnumerable = circular.includeNonEnumerable;\n    circular = circular.circular;\n  }\n  // maintain two arrays for circular references, where corresponding parents\n  // and children have the same index\n  var allParents = [];\n  var allChildren = [];\n\n  var useBuffer = typeof Buffer != 'undefined';\n\n  if (typeof circular == 'undefined')\n    circular = true;\n\n  if (typeof depth == 'undefined')\n    depth = Infinity;\n\n  // recurse this function so we don't reset allParents and allChildren\n  function _clone(parent, depth) {\n    // cloning null always returns null\n    if (parent === null)\n      return null;\n\n    if (depth === 0)\n      return parent;\n\n    var child;\n    var proto;\n    if (typeof parent != 'object') {\n      return parent;\n    }\n\n    if (_instanceof(parent, nativeMap)) {\n      child = new nativeMap();\n    } else if (_instanceof(parent, nativeSet)) {\n      child = new nativeSet();\n    } else if (_instanceof(parent, nativePromise)) {\n      child = new nativePromise(function (resolve, reject) {\n        parent.then(function(value) {\n          resolve(_clone(value, depth - 1));\n        }, function(err) {\n          reject(_clone(err, depth - 1));\n        });\n      });\n    } else if (clone.__isArray(parent)) {\n      child = [];\n    } else if (clone.__isRegExp(parent)) {\n      child = new RegExp(parent.source, __getRegExpFlags(parent));\n      if (parent.lastIndex) child.lastIndex = parent.lastIndex;\n    } else if (clone.__isDate(parent)) {\n      child = new Date(parent.getTime());\n    } else if (useBuffer && Buffer.isBuffer(parent)) {\n      if (Buffer.allocUnsafe) {\n        // Node.js >= 4.5.0\n        child = Buffer.allocUnsafe(parent.length);\n      } else {\n        // Older Node.js versions\n        child = new Buffer(parent.length);\n      }\n      parent.copy(child);\n      return child;\n    } else if (_instanceof(parent, Error)) {\n      child = Object.create(parent);\n    } else {\n      if (typeof prototype == 'undefined') {\n        proto = Object.getPrototypeOf(parent);\n        child = Object.create(proto);\n      }\n      else {\n        child = Object.create(prototype);\n        proto = prototype;\n      }\n    }\n\n    if (circular) {\n      var index = allParents.indexOf(parent);\n\n      if (index != -1) {\n        return allChildren[index];\n      }\n      allParents.push(parent);\n      allChildren.push(child);\n    }\n\n    if (_instanceof(parent, nativeMap)) {\n      parent.forEach(function(value, key) {\n        var keyChild = _clone(key, depth - 1);\n        var valueChild = _clone(value, depth - 1);\n        child.set(keyChild, valueChild);\n      });\n    }\n    if (_instanceof(parent, nativeSet)) {\n      parent.forEach(function(value) {\n        var entryChild = _clone(value, depth - 1);\n        child.add(entryChild);\n      });\n    }\n\n    for (var i in parent) {\n      var attrs;\n      if (proto) {\n        attrs = Object.getOwnPropertyDescriptor(proto, i);\n      }\n\n      if (attrs && attrs.set == null) {\n        continue;\n      }\n      child[i] = _clone(parent[i], depth - 1);\n    }\n\n    if (Object.getOwnPropertySymbols) {\n      var symbols = Object.getOwnPropertySymbols(parent);\n      for (var i = 0; i < symbols.length; i++) {\n        // Don't need to worry about cloning a symbol because it is a primitive,\n        // like a number or string.\n        var symbol = symbols[i];\n        var descriptor = Object.getOwnPropertyDescriptor(parent, symbol);\n        if (descriptor && !descriptor.enumerable && !includeNonEnumerable) {\n          continue;\n        }\n        child[symbol] = _clone(parent[symbol], depth - 1);\n        if (!descriptor.enumerable) {\n          Object.defineProperty(child, symbol, {\n            enumerable: false\n          });\n        }\n      }\n    }\n\n    if (includeNonEnumerable) {\n      var allPropertyNames = Object.getOwnPropertyNames(parent);\n      for (var i = 0; i < allPropertyNames.length; i++) {\n        var propertyName = allPropertyNames[i];\n        var descriptor = Object.getOwnPropertyDescriptor(parent, propertyName);\n        if (descriptor && descriptor.enumerable) {\n          continue;\n        }\n        child[propertyName] = _clone(parent[propertyName], depth - 1);\n        Object.defineProperty(child, propertyName, {\n          enumerable: false\n        });\n      }\n    }\n\n    return child;\n  }\n\n  return _clone(parent, depth);\n}\n\n/**\n * Simple flat clone using prototype, accepts only objects, usefull for property\n * override on FLAT configuration object (no nested props).\n *\n * USE WITH CAUTION! This may not behave as you wish if you do not know how this\n * works.\n */\nclone.clonePrototype = function clonePrototype(parent) {\n  if (parent === null)\n    return null;\n\n  var c = function () {};\n  c.prototype = parent;\n  return new c();\n};\n\n// private utility functions\n\nfunction __objToStr(o) {\n  return Object.prototype.toString.call(o);\n}\nclone.__objToStr = __objToStr;\n\nfunction __isDate(o) {\n  return typeof o === 'object' && __objToStr(o) === '[object Date]';\n}\nclone.__isDate = __isDate;\n\nfunction __isArray(o) {\n  return typeof o === 'object' && __objToStr(o) === '[object Array]';\n}\nclone.__isArray = __isArray;\n\nfunction __isRegExp(o) {\n  return typeof o === 'object' && __objToStr(o) === '[object RegExp]';\n}\nclone.__isRegExp = __isRegExp;\n\nfunction __getRegExpFlags(re) {\n  var flags = '';\n  if (re.global) flags += 'g';\n  if (re.ignoreCase) flags += 'i';\n  if (re.multiline) flags += 'm';\n  return flags;\n}\nclone.__getRegExpFlags = __getRegExpFlags;\n\nreturn clone;\n})();\n\nif (typeof module === 'object' && module.exports) {\n  module.exports = clone;\n}\n","/* eslint-env browser */\n\n/**\n * This is the web browser implementation of `debug()`.\n */\n\nexports.formatArgs = formatArgs;\nexports.save = save;\nexports.load = load;\nexports.useColors = useColors;\nexports.storage = localstorage();\nexports.destroy = (() => {\n\tlet warned = false;\n\n\treturn () => {\n\t\tif (!warned) {\n\t\t\twarned = true;\n\t\t\tconsole.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');\n\t\t}\n\t};\n})();\n\n/**\n * Colors.\n */\n\nexports.colors = [\n\t'#0000CC',\n\t'#0000FF',\n\t'#0033CC',\n\t'#0033FF',\n\t'#0066CC',\n\t'#0066FF',\n\t'#0099CC',\n\t'#0099FF',\n\t'#00CC00',\n\t'#00CC33',\n\t'#00CC66',\n\t'#00CC99',\n\t'#00CCCC',\n\t'#00CCFF',\n\t'#3300CC',\n\t'#3300FF',\n\t'#3333CC',\n\t'#3333FF',\n\t'#3366CC',\n\t'#3366FF',\n\t'#3399CC',\n\t'#3399FF',\n\t'#33CC00',\n\t'#33CC33',\n\t'#33CC66',\n\t'#33CC99',\n\t'#33CCCC',\n\t'#33CCFF',\n\t'#6600CC',\n\t'#6600FF',\n\t'#6633CC',\n\t'#6633FF',\n\t'#66CC00',\n\t'#66CC33',\n\t'#9900CC',\n\t'#9900FF',\n\t'#9933CC',\n\t'#9933FF',\n\t'#99CC00',\n\t'#99CC33',\n\t'#CC0000',\n\t'#CC0033',\n\t'#CC0066',\n\t'#CC0099',\n\t'#CC00CC',\n\t'#CC00FF',\n\t'#CC3300',\n\t'#CC3333',\n\t'#CC3366',\n\t'#CC3399',\n\t'#CC33CC',\n\t'#CC33FF',\n\t'#CC6600',\n\t'#CC6633',\n\t'#CC9900',\n\t'#CC9933',\n\t'#CCCC00',\n\t'#CCCC33',\n\t'#FF0000',\n\t'#FF0033',\n\t'#FF0066',\n\t'#FF0099',\n\t'#FF00CC',\n\t'#FF00FF',\n\t'#FF3300',\n\t'#FF3333',\n\t'#FF3366',\n\t'#FF3399',\n\t'#FF33CC',\n\t'#FF33FF',\n\t'#FF6600',\n\t'#FF6633',\n\t'#FF9900',\n\t'#FF9933',\n\t'#FFCC00',\n\t'#FFCC33'\n];\n\n/**\n * Currently only WebKit-based Web Inspectors, Firefox >= v31,\n * and the Firebug extension (any Firefox version) are known\n * to support \"%c\" CSS customizations.\n *\n * TODO: add a `localStorage` variable to explicitly enable/disable colors\n */\n\n// eslint-disable-next-line complexity\nfunction useColors() {\n\t// NB: In an Electron preload script, document will be defined but not fully\n\t// initialized. Since we know we're in Chrome, we'll just detect this case\n\t// explicitly\n\tif (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {\n\t\treturn true;\n\t}\n\n\t// Internet Explorer and Edge do not support colors.\n\tif (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\\/(\\d+)/)) {\n\t\treturn false;\n\t}\n\n\t// Is webkit? http://stackoverflow.com/a/16459606/376773\n\t// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632\n\treturn (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||\n\t\t// Is firebug? http://stackoverflow.com/a/398120/376773\n\t\t(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||\n\t\t// Is firefox >= v31?\n\t\t// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages\n\t\t(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\\/(\\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||\n\t\t// Double check webkit in userAgent just in case we are in a worker\n\t\t(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\\/(\\d+)/));\n}\n\n/**\n * Colorize log arguments if enabled.\n *\n * @api public\n */\n\nfunction formatArgs(args) {\n\targs[0] = (this.useColors ? '%c' : '') +\n\t\tthis.namespace +\n\t\t(this.useColors ? ' %c' : ' ') +\n\t\targs[0] +\n\t\t(this.useColors ? '%c ' : ' ') +\n\t\t'+' + module.exports.humanize(this.diff);\n\n\tif (!this.useColors) {\n\t\treturn;\n\t}\n\n\tconst c = 'color: ' + this.color;\n\targs.splice(1, 0, c, 'color: inherit');\n\n\t// The final \"%c\" is somewhat tricky, because there could be other\n\t// arguments passed either before or after the %c, so we need to\n\t// figure out the correct index to insert the CSS into\n\tlet index = 0;\n\tlet lastC = 0;\n\targs[0].replace(/%[a-zA-Z%]/g, match => {\n\t\tif (match === '%%') {\n\t\t\treturn;\n\t\t}\n\t\tindex++;\n\t\tif (match === '%c') {\n\t\t\t// We only are interested in the *last* %c\n\t\t\t// (the user may have provided their own)\n\t\t\tlastC = index;\n\t\t}\n\t});\n\n\targs.splice(lastC, 0, c);\n}\n\n/**\n * Invokes `console.debug()` when available.\n * No-op when `console.debug` is not a \"function\".\n * If `console.debug` is not available, falls back\n * to `console.log`.\n *\n * @api public\n */\nexports.log = console.debug || console.log || (() => {});\n\n/**\n * Save `namespaces`.\n *\n * @param {String} namespaces\n * @api private\n */\nfunction save(namespaces) {\n\ttry {\n\t\tif (namespaces) {\n\t\t\texports.storage.setItem('debug', namespaces);\n\t\t} else {\n\t\t\texports.storage.removeItem('debug');\n\t\t}\n\t} catch (error) {\n\t\t// Swallow\n\t\t// XXX (@Qix-) should we be logging these?\n\t}\n}\n\n/**\n * Load `namespaces`.\n *\n * @return {String} returns the previously persisted debug modes\n * @api private\n */\nfunction load() {\n\tlet r;\n\ttry {\n\t\tr = exports.storage.getItem('debug');\n\t} catch (error) {\n\t\t// Swallow\n\t\t// XXX (@Qix-) should we be logging these?\n\t}\n\n\t// If debug isn't set in LS, and we're in Electron, try to load $DEBUG\n\tif (!r && typeof process !== 'undefined' && 'env' in process) {\n\t\tr = process.env.DEBUG;\n\t}\n\n\treturn r;\n}\n\n/**\n * Localstorage attempts to return the localstorage.\n *\n * This is necessary because safari throws\n * when a user disables cookies/localstorage\n * and you attempt to access it.\n *\n * @return {LocalStorage}\n * @api private\n */\n\nfunction localstorage() {\n\ttry {\n\t\t// TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context\n\t\t// The Browser also has localStorage in the global context.\n\t\treturn localStorage;\n\t} catch (error) {\n\t\t// Swallow\n\t\t// XXX (@Qix-) should we be logging these?\n\t}\n}\n\nmodule.exports = require('./common')(exports);\n\nconst {formatters} = module.exports;\n\n/**\n * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.\n */\n\nformatters.j = function (v) {\n\ttry {\n\t\treturn JSON.stringify(v);\n\t} catch (error) {\n\t\treturn '[UnexpectedJSONParseError]: ' + error.message;\n\t}\n};\n","\n/**\n * This is the common logic for both the Node.js and web browser\n * implementations of `debug()`.\n */\n\nfunction setup(env) {\n\tcreateDebug.debug = createDebug;\n\tcreateDebug.default = createDebug;\n\tcreateDebug.coerce = coerce;\n\tcreateDebug.disable = disable;\n\tcreateDebug.enable = enable;\n\tcreateDebug.enabled = enabled;\n\tcreateDebug.humanize = require('ms');\n\tcreateDebug.destroy = destroy;\n\n\tObject.keys(env).forEach(key => {\n\t\tcreateDebug[key] = env[key];\n\t});\n\n\t/**\n\t* The currently active debug mode names, and names to skip.\n\t*/\n\n\tcreateDebug.names = [];\n\tcreateDebug.skips = [];\n\n\t/**\n\t* Map of special \"%n\" handling functions, for the debug \"format\" argument.\n\t*\n\t* Valid key names are a single, lower or upper-case letter, i.e. \"n\" and \"N\".\n\t*/\n\tcreateDebug.formatters = {};\n\n\t/**\n\t* Selects a color for a debug namespace\n\t* @param {String} namespace The namespace string for the debug instance to be colored\n\t* @return {Number|String} An ANSI color code for the given namespace\n\t* @api private\n\t*/\n\tfunction selectColor(namespace) {\n\t\tlet hash = 0;\n\n\t\tfor (let i = 0; i < namespace.length; i++) {\n\t\t\thash = ((hash << 5) - hash) + namespace.charCodeAt(i);\n\t\t\thash |= 0; // Convert to 32bit integer\n\t\t}\n\n\t\treturn createDebug.colors[Math.abs(hash) % createDebug.colors.length];\n\t}\n\tcreateDebug.selectColor = selectColor;\n\n\t/**\n\t* Create a debugger with the given `namespace`.\n\t*\n\t* @param {String} namespace\n\t* @return {Function}\n\t* @api public\n\t*/\n\tfunction createDebug(namespace) {\n\t\tlet prevTime;\n\t\tlet enableOverride = null;\n\t\tlet namespacesCache;\n\t\tlet enabledCache;\n\n\t\tfunction debug(...args) {\n\t\t\t// Disabled?\n\t\t\tif (!debug.enabled) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tconst self = debug;\n\n\t\t\t// Set `diff` timestamp\n\t\t\tconst curr = Number(new Date());\n\t\t\tconst ms = curr - (prevTime || curr);\n\t\t\tself.diff = ms;\n\t\t\tself.prev = prevTime;\n\t\t\tself.curr = curr;\n\t\t\tprevTime = curr;\n\n\t\t\targs[0] = createDebug.coerce(args[0]);\n\n\t\t\tif (typeof args[0] !== 'string') {\n\t\t\t\t// Anything else let's inspect with %O\n\t\t\t\targs.unshift('%O');\n\t\t\t}\n\n\t\t\t// Apply any `formatters` transformations\n\t\t\tlet index = 0;\n\t\t\targs[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {\n\t\t\t\t// If we encounter an escaped % then don't increase the array index\n\t\t\t\tif (match === '%%') {\n\t\t\t\t\treturn '%';\n\t\t\t\t}\n\t\t\t\tindex++;\n\t\t\t\tconst formatter = createDebug.formatters[format];\n\t\t\t\tif (typeof formatter === 'function') {\n\t\t\t\t\tconst val = args[index];\n\t\t\t\t\tmatch = formatter.call(self, val);\n\n\t\t\t\t\t// Now we need to remove `args[index]` since it's inlined in the `format`\n\t\t\t\t\targs.splice(index, 1);\n\t\t\t\t\tindex--;\n\t\t\t\t}\n\t\t\t\treturn match;\n\t\t\t});\n\n\t\t\t// Apply env-specific formatting (colors, etc.)\n\t\t\tcreateDebug.formatArgs.call(self, args);\n\n\t\t\tconst logFn = self.log || createDebug.log;\n\t\t\tlogFn.apply(self, args);\n\t\t}\n\n\t\tdebug.namespace = namespace;\n\t\tdebug.useColors = createDebug.useColors();\n\t\tdebug.color = createDebug.selectColor(namespace);\n\t\tdebug.extend = extend;\n\t\tdebug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release.\n\n\t\tObject.defineProperty(debug, 'enabled', {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: false,\n\t\t\tget: () => {\n\t\t\t\tif (enableOverride !== null) {\n\t\t\t\t\treturn enableOverride;\n\t\t\t\t}\n\t\t\t\tif (namespacesCache !== createDebug.namespaces) {\n\t\t\t\t\tnamespacesCache = createDebug.namespaces;\n\t\t\t\t\tenabledCache = createDebug.enabled(namespace);\n\t\t\t\t}\n\n\t\t\t\treturn enabledCache;\n\t\t\t},\n\t\t\tset: v => {\n\t\t\t\tenableOverride = v;\n\t\t\t}\n\t\t});\n\n\t\t// Env-specific initialization logic for debug instances\n\t\tif (typeof createDebug.init === 'function') {\n\t\t\tcreateDebug.init(debug);\n\t\t}\n\n\t\treturn debug;\n\t}\n\n\tfunction extend(namespace, delimiter) {\n\t\tconst newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);\n\t\tnewDebug.log = this.log;\n\t\treturn newDebug;\n\t}\n\n\t/**\n\t* Enables a debug mode by namespaces. This can include modes\n\t* separated by a colon and wildcards.\n\t*\n\t* @param {String} namespaces\n\t* @api public\n\t*/\n\tfunction enable(namespaces) {\n\t\tcreateDebug.save(namespaces);\n\t\tcreateDebug.namespaces = namespaces;\n\n\t\tcreateDebug.names = [];\n\t\tcreateDebug.skips = [];\n\n\t\tlet i;\n\t\tconst split = (typeof namespaces === 'string' ? namespaces : '').split(/[\\s,]+/);\n\t\tconst len = split.length;\n\n\t\tfor (i = 0; i < len; i++) {\n\t\t\tif (!split[i]) {\n\t\t\t\t// ignore empty strings\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tnamespaces = split[i].replace(/\\*/g, '.*?');\n\n\t\t\tif (namespaces[0] === '-') {\n\t\t\t\tcreateDebug.skips.push(new RegExp('^' + namespaces.slice(1) + '$'));\n\t\t\t} else {\n\t\t\t\tcreateDebug.names.push(new RegExp('^' + namespaces + '$'));\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t* Disable debug output.\n\t*\n\t* @return {String} namespaces\n\t* @api public\n\t*/\n\tfunction disable() {\n\t\tconst namespaces = [\n\t\t\t...createDebug.names.map(toNamespace),\n\t\t\t...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace)\n\t\t].join(',');\n\t\tcreateDebug.enable('');\n\t\treturn namespaces;\n\t}\n\n\t/**\n\t* Returns true if the given mode name is enabled, false otherwise.\n\t*\n\t* @param {String} name\n\t* @return {Boolean}\n\t* @api public\n\t*/\n\tfunction enabled(name) {\n\t\tif (name[name.length - 1] === '*') {\n\t\t\treturn true;\n\t\t}\n\n\t\tlet i;\n\t\tlet len;\n\n\t\tfor (i = 0, len = createDebug.skips.length; i < len; i++) {\n\t\t\tif (createDebug.skips[i].test(name)) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\n\t\tfor (i = 0, len = createDebug.names.length; i < len; i++) {\n\t\t\tif (createDebug.names[i].test(name)) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\n\t\treturn false;\n\t}\n\n\t/**\n\t* Convert regexp to namespace\n\t*\n\t* @param {RegExp} regxep\n\t* @return {String} namespace\n\t* @api private\n\t*/\n\tfunction toNamespace(regexp) {\n\t\treturn regexp.toString()\n\t\t\t.substring(2, regexp.toString().length - 2)\n\t\t\t.replace(/\\.\\*\\?$/, '*');\n\t}\n\n\t/**\n\t* Coerce `val`.\n\t*\n\t* @param {Mixed} val\n\t* @return {Mixed}\n\t* @api private\n\t*/\n\tfunction coerce(val) {\n\t\tif (val instanceof Error) {\n\t\t\treturn val.stack || val.message;\n\t\t}\n\t\treturn val;\n\t}\n\n\t/**\n\t* XXX DO NOT USE. This is a temporary stub function.\n\t* XXX It WILL be removed in the next major release.\n\t*/\n\tfunction destroy() {\n\t\tconsole.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');\n\t}\n\n\tcreateDebug.enable(createDebug.load());\n\n\treturn createDebug;\n}\n\nmodule.exports = setup;\n","'use strict';\n\n/**\n * @typedef {{ [key: string]: any }} Extensions\n * @typedef {Error} Err\n * @property {string} message\n */\n\n/**\n *\n * @param {Error} obj\n * @param {Extensions} props\n * @returns {Error & Extensions}\n */\nfunction assign(obj, props) {\n    for (const key in props) {\n        Object.defineProperty(obj, key, {\n            value: props[key],\n            enumerable: true,\n            configurable: true,\n        });\n    }\n\n    return obj;\n}\n\n/**\n *\n * @param {any} err - An Error\n * @param {string|Extensions} code - A string code or props to set on the error\n * @param {Extensions} [props] - Props to set on the error\n * @returns {Error & Extensions}\n */\nfunction createError(err, code, props) {\n    if (!err || typeof err === 'string') {\n        throw new TypeError('Please pass an Error to err-code');\n    }\n\n    if (!props) {\n        props = {};\n    }\n\n    if (typeof code === 'object') {\n        props = code;\n        code = '';\n    }\n\n    if (code) {\n        props.code = code;\n    }\n\n    try {\n        return assign(err, props);\n    } catch (_) {\n        props.message = err.message;\n        props.stack = err.stack;\n\n        const ErrClass = function () {};\n\n        ErrClass.prototype = Object.create(Object.getPrototypeOf(err));\n\n        // @ts-ignore\n        const output = assign(new ErrClass(), props);\n\n        return output;\n    }\n}\n\nmodule.exports = createError;\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar R = typeof Reflect === 'object' ? Reflect : null\nvar ReflectApply = R && typeof R.apply === 'function'\n  ? R.apply\n  : function ReflectApply(target, receiver, args) {\n    return Function.prototype.apply.call(target, receiver, args);\n  }\n\nvar ReflectOwnKeys\nif (R && typeof R.ownKeys === 'function') {\n  ReflectOwnKeys = R.ownKeys\n} else if (Object.getOwnPropertySymbols) {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target)\n      .concat(Object.getOwnPropertySymbols(target));\n  };\n} else {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target);\n  };\n}\n\nfunction ProcessEmitWarning(warning) {\n  if (console && console.warn) console.warn(warning);\n}\n\nvar NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {\n  return value !== value;\n}\n\nfunction EventEmitter() {\n  EventEmitter.init.call(this);\n}\nmodule.exports = EventEmitter;\nmodule.exports.once = once;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._eventsCount = 0;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nvar defaultMaxListeners = 10;\n\nfunction checkListener(listener) {\n  if (typeof listener !== 'function') {\n    throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n  }\n}\n\nObject.defineProperty(EventEmitter, 'defaultMaxListeners', {\n  enumerable: true,\n  get: function() {\n    return defaultMaxListeners;\n  },\n  set: function(arg) {\n    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {\n      throw new RangeError('The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received ' + arg + '.');\n    }\n    defaultMaxListeners = arg;\n  }\n});\n\nEventEmitter.init = function() {\n\n  if (this._events === undefined ||\n      this._events === Object.getPrototypeOf(this)._events) {\n    this._events = Object.create(null);\n    this._eventsCount = 0;\n  }\n\n  this._maxListeners = this._maxListeners || undefined;\n};\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {\n    throw new RangeError('The value of \"n\" is out of range. It must be a non-negative number. Received ' + n + '.');\n  }\n  this._maxListeners = n;\n  return this;\n};\n\nfunction _getMaxListeners(that) {\n  if (that._maxListeners === undefined)\n    return EventEmitter.defaultMaxListeners;\n  return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n  return _getMaxListeners(this);\n};\n\nEventEmitter.prototype.emit = function emit(type) {\n  var args = [];\n  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);\n  var doError = (type === 'error');\n\n  var events = this._events;\n  if (events !== undefined)\n    doError = (doError && events.error === undefined);\n  else if (!doError)\n    return false;\n\n  // If there is no 'error' event listener then throw.\n  if (doError) {\n    var er;\n    if (args.length > 0)\n      er = args[0];\n    if (er instanceof Error) {\n      // Note: The comments on the `throw` lines are intentional, they show\n      // up in Node's output if this results in an unhandled exception.\n      throw er; // Unhandled 'error' event\n    }\n    // At least give some kind of context to the user\n    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));\n    err.context = er;\n    throw err; // Unhandled 'error' event\n  }\n\n  var handler = events[type];\n\n  if (handler === undefined)\n    return false;\n\n  if (typeof handler === 'function') {\n    ReflectApply(handler, this, args);\n  } else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      ReflectApply(listeners[i], this, args);\n  }\n\n  return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n  var m;\n  var events;\n  var existing;\n\n  checkListener(listener);\n\n  events = target._events;\n  if (events === undefined) {\n    events = target._events = Object.create(null);\n    target._eventsCount = 0;\n  } else {\n    // To avoid recursion in the case that type === \"newListener\"! Before\n    // adding it to the listeners, first emit \"newListener\".\n    if (events.newListener !== undefined) {\n      target.emit('newListener', type,\n                  listener.listener ? listener.listener : listener);\n\n      // Re-assign `events` because a newListener handler could have caused the\n      // this._events to be assigned to a new object\n      events = target._events;\n    }\n    existing = events[type];\n  }\n\n  if (existing === undefined) {\n    // Optimize the case of one listener. Don't need the extra array object.\n    existing = events[type] = listener;\n    ++target._eventsCount;\n  } else {\n    if (typeof existing === 'function') {\n      // Adding the second element, need to change to array.\n      existing = events[type] =\n        prepend ? [listener, existing] : [existing, listener];\n      // If we've already got an array, just append.\n    } else if (prepend) {\n      existing.unshift(listener);\n    } else {\n      existing.push(listener);\n    }\n\n    // Check for listener leak\n    m = _getMaxListeners(target);\n    if (m > 0 && existing.length > m && !existing.warned) {\n      existing.warned = true;\n      // No error code for this since it is a Warning\n      // eslint-disable-next-line no-restricted-syntax\n      var w = new Error('Possible EventEmitter memory leak detected. ' +\n                          existing.length + ' ' + String(type) + ' listeners ' +\n                          'added. Use emitter.setMaxListeners() to ' +\n                          'increase limit');\n      w.name = 'MaxListenersExceededWarning';\n      w.emitter = target;\n      w.type = type;\n      w.count = existing.length;\n      ProcessEmitWarning(w);\n    }\n  }\n\n  return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n  return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener =\n    function prependListener(type, listener) {\n      return _addListener(this, type, listener, true);\n    };\n\nfunction onceWrapper() {\n  if (!this.fired) {\n    this.target.removeListener(this.type, this.wrapFn);\n    this.fired = true;\n    if (arguments.length === 0)\n      return this.listener.call(this.target);\n    return this.listener.apply(this.target, arguments);\n  }\n}\n\nfunction _onceWrap(target, type, listener) {\n  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n  var wrapped = onceWrapper.bind(state);\n  wrapped.listener = listener;\n  state.wrapFn = wrapped;\n  return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n  checkListener(listener);\n  this.on(type, _onceWrap(this, type, listener));\n  return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n    function prependOnceListener(type, listener) {\n      checkListener(listener);\n      this.prependListener(type, _onceWrap(this, type, listener));\n      return this;\n    };\n\n// Emits a 'removeListener' event if and only if the listener was removed.\nEventEmitter.prototype.removeListener =\n    function removeListener(type, listener) {\n      var list, events, position, i, originalListener;\n\n      checkListener(listener);\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      list = events[type];\n      if (list === undefined)\n        return this;\n\n      if (list === listener || list.listener === listener) {\n        if (--this._eventsCount === 0)\n          this._events = Object.create(null);\n        else {\n          delete events[type];\n          if (events.removeListener)\n            this.emit('removeListener', type, list.listener || listener);\n        }\n      } else if (typeof list !== 'function') {\n        position = -1;\n\n        for (i = list.length - 1; i >= 0; i--) {\n          if (list[i] === listener || list[i].listener === listener) {\n            originalListener = list[i].listener;\n            position = i;\n            break;\n          }\n        }\n\n        if (position < 0)\n          return this;\n\n        if (position === 0)\n          list.shift();\n        else {\n          spliceOne(list, position);\n        }\n\n        if (list.length === 1)\n          events[type] = list[0];\n\n        if (events.removeListener !== undefined)\n          this.emit('removeListener', type, originalListener || listener);\n      }\n\n      return this;\n    };\n\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\n\nEventEmitter.prototype.removeAllListeners =\n    function removeAllListeners(type) {\n      var listeners, events, i;\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      // not listening for removeListener, no need to emit\n      if (events.removeListener === undefined) {\n        if (arguments.length === 0) {\n          this._events = Object.create(null);\n          this._eventsCount = 0;\n        } else if (events[type] !== undefined) {\n          if (--this._eventsCount === 0)\n            this._events = Object.create(null);\n          else\n            delete events[type];\n        }\n        return this;\n      }\n\n      // emit removeListener for all listeners on all events\n      if (arguments.length === 0) {\n        var keys = Object.keys(events);\n        var key;\n        for (i = 0; i < keys.length; ++i) {\n          key = keys[i];\n          if (key === 'removeListener') continue;\n          this.removeAllListeners(key);\n        }\n        this.removeAllListeners('removeListener');\n        this._events = Object.create(null);\n        this._eventsCount = 0;\n        return this;\n      }\n\n      listeners = events[type];\n\n      if (typeof listeners === 'function') {\n        this.removeListener(type, listeners);\n      } else if (listeners !== undefined) {\n        // LIFO order\n        for (i = listeners.length - 1; i >= 0; i--) {\n          this.removeListener(type, listeners[i]);\n        }\n      }\n\n      return this;\n    };\n\nfunction _listeners(target, type, unwrap) {\n  var events = target._events;\n\n  if (events === undefined)\n    return [];\n\n  var evlistener = events[type];\n  if (evlistener === undefined)\n    return [];\n\n  if (typeof evlistener === 'function')\n    return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n\n  return unwrap ?\n    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n  return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n  return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  if (typeof emitter.listenerCount === 'function') {\n    return emitter.listenerCount(type);\n  } else {\n    return listenerCount.call(emitter, type);\n  }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n  var events = this._events;\n\n  if (events !== undefined) {\n    var evlistener = events[type];\n\n    if (typeof evlistener === 'function') {\n      return 1;\n    } else if (evlistener !== undefined) {\n      return evlistener.length;\n    }\n  }\n\n  return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];\n};\n\nfunction arrayClone(arr, n) {\n  var copy = new Array(n);\n  for (var i = 0; i < n; ++i)\n    copy[i] = arr[i];\n  return copy;\n}\n\nfunction spliceOne(list, index) {\n  for (; index + 1 < list.length; index++)\n    list[index] = list[index + 1];\n  list.pop();\n}\n\nfunction unwrapListeners(arr) {\n  var ret = new Array(arr.length);\n  for (var i = 0; i < ret.length; ++i) {\n    ret[i] = arr[i].listener || arr[i];\n  }\n  return ret;\n}\n\nfunction once(emitter, name) {\n  return new Promise(function (resolve, reject) {\n    function errorListener(err) {\n      emitter.removeListener(name, resolver);\n      reject(err);\n    }\n\n    function resolver() {\n      if (typeof emitter.removeListener === 'function') {\n        emitter.removeListener('error', errorListener);\n      }\n      resolve([].slice.call(arguments));\n    };\n\n    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });\n    if (name !== 'error') {\n      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });\n    }\n  });\n}\n\nfunction addErrorHandlerIfEventEmitter(emitter, handler, flags) {\n  if (typeof emitter.on === 'function') {\n    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);\n  }\n}\n\nfunction eventTargetAgnosticAddListener(emitter, name, listener, flags) {\n  if (typeof emitter.on === 'function') {\n    if (flags.once) {\n      emitter.once(name, listener);\n    } else {\n      emitter.on(name, listener);\n    }\n  } else if (typeof emitter.addEventListener === 'function') {\n    // EventTarget does not have `error` event semantics like Node\n    // EventEmitters, we do not listen for `error` events here.\n    emitter.addEventListener(name, function wrapListener(arg) {\n      // IE does not have builtin `{ once: true }` support so we\n      // have to do it manually.\n      if (flags.once) {\n        emitter.removeEventListener(name, wrapListener);\n      }\n      listener(arg);\n    });\n  } else {\n    throw new TypeError('The \"emitter\" argument must be of type EventEmitter. Received type ' + typeof emitter);\n  }\n}\n","module.exports = class FixedFIFO {\n  constructor (hwm) {\n    if (!(hwm > 0) || ((hwm - 1) & hwm) !== 0) throw new Error('Max size for a FixedFIFO should be a power of two')\n    this.buffer = new Array(hwm)\n    this.mask = hwm - 1\n    this.top = 0\n    this.btm = 0\n    this.next = null\n  }\n\n  clear () {\n    this.top = this.btm = 0\n    this.next = null\n    this.buffer.fill(undefined)\n  }\n\n  push (data) {\n    if (this.buffer[this.top] !== undefined) return false\n    this.buffer[this.top] = data\n    this.top = (this.top + 1) & this.mask\n    return true\n  }\n\n  shift () {\n    const last = this.buffer[this.btm]\n    if (last === undefined) return undefined\n    this.buffer[this.btm] = undefined\n    this.btm = (this.btm + 1) & this.mask\n    return last\n  }\n\n  peek () {\n    return this.buffer[this.btm]\n  }\n\n  isEmpty () {\n    return this.buffer[this.btm] === undefined\n  }\n}\n","const FixedFIFO = require('./fixed-size')\n\nmodule.exports = class FastFIFO {\n  constructor (hwm) {\n    this.hwm = hwm || 16\n    this.head = new FixedFIFO(this.hwm)\n    this.tail = this.head\n    this.length = 0\n  }\n\n  clear () {\n    this.head = this.tail\n    this.head.clear()\n    this.length = 0\n  }\n\n  push (val) {\n    this.length++\n    if (!this.head.push(val)) {\n      const prev = this.head\n      this.head = prev.next = new FixedFIFO(2 * this.head.buffer.length)\n      this.head.push(val)\n    }\n  }\n\n  shift () {\n    if (this.length !== 0) this.length--\n    const val = this.tail.shift()\n    if (val === undefined && this.tail.next) {\n      const next = this.tail.next\n      this.tail.next = null\n      this.tail = next\n      return this.tail.shift()\n    }\n\n    return val\n  }\n\n  peek () {\n    const val = this.tail.peek()\n    if (val === undefined && this.tail.next) return this.tail.next.peek()\n    return val\n  }\n\n  isEmpty () {\n    return this.length === 0\n  }\n}\n","// originally pulled out of simple-peer\n\nmodule.exports = function getBrowserRTC () {\n  if (typeof globalThis === 'undefined') return null\n  var wrtc = {\n    RTCPeerConnection: globalThis.RTCPeerConnection || globalThis.mozRTCPeerConnection ||\n      globalThis.webkitRTCPeerConnection,\n    RTCSessionDescription: globalThis.RTCSessionDescription ||\n      globalThis.mozRTCSessionDescription || globalThis.webkitRTCSessionDescription,\n    RTCIceCandidate: globalThis.RTCIceCandidate || globalThis.mozRTCIceCandidate ||\n      globalThis.webkitRTCIceCandidate\n  }\n  if (!wrtc.RTCPeerConnection) return null\n  return wrtc\n}\n","/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */\nexports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = ((value * c) - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      ctor.prototype = Object.create(superCtor.prototype, {\n        constructor: {\n          value: ctor,\n          enumerable: false,\n          writable: true,\n          configurable: true\n        }\n      })\n    }\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      var TempCtor = function () {}\n      TempCtor.prototype = superCtor.prototype\n      ctor.prototype = new TempCtor()\n      ctor.prototype.constructor = ctor\n    }\n  }\n}\n","/**\n * Helpers.\n */\n\nvar s = 1000;\nvar m = s * 60;\nvar h = m * 60;\nvar d = h * 24;\nvar w = d * 7;\nvar y = d * 365.25;\n\n/**\n * Parse or format the given `val`.\n *\n * Options:\n *\n *  - `long` verbose formatting [false]\n *\n * @param {String|Number} val\n * @param {Object} [options]\n * @throws {Error} throw an error if val is not a non-empty string or a number\n * @return {String|Number}\n * @api public\n */\n\nmodule.exports = function(val, options) {\n  options = options || {};\n  var type = typeof val;\n  if (type === 'string' && val.length > 0) {\n    return parse(val);\n  } else if (type === 'number' && isFinite(val)) {\n    return options.long ? fmtLong(val) : fmtShort(val);\n  }\n  throw new Error(\n    'val is not a non-empty string or a valid number. val=' +\n      JSON.stringify(val)\n  );\n};\n\n/**\n * Parse the given `str` and return milliseconds.\n *\n * @param {String} str\n * @return {Number}\n * @api private\n */\n\nfunction parse(str) {\n  str = String(str);\n  if (str.length > 100) {\n    return;\n  }\n  var match = /^(-?(?:\\d+)?\\.?\\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(\n    str\n  );\n  if (!match) {\n    return;\n  }\n  var n = parseFloat(match[1]);\n  var type = (match[2] || 'ms').toLowerCase();\n  switch (type) {\n    case 'years':\n    case 'year':\n    case 'yrs':\n    case 'yr':\n    case 'y':\n      return n * y;\n    case 'weeks':\n    case 'week':\n    case 'w':\n      return n * w;\n    case 'days':\n    case 'day':\n    case 'd':\n      return n * d;\n    case 'hours':\n    case 'hour':\n    case 'hrs':\n    case 'hr':\n    case 'h':\n      return n * h;\n    case 'minutes':\n    case 'minute':\n    case 'mins':\n    case 'min':\n    case 'm':\n      return n * m;\n    case 'seconds':\n    case 'second':\n    case 'secs':\n    case 'sec':\n    case 's':\n      return n * s;\n    case 'milliseconds':\n    case 'millisecond':\n    case 'msecs':\n    case 'msec':\n    case 'ms':\n      return n;\n    default:\n      return undefined;\n  }\n}\n\n/**\n * Short format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtShort(ms) {\n  var msAbs = Math.abs(ms);\n  if (msAbs >= d) {\n    return Math.round(ms / d) + 'd';\n  }\n  if (msAbs >= h) {\n    return Math.round(ms / h) + 'h';\n  }\n  if (msAbs >= m) {\n    return Math.round(ms / m) + 'm';\n  }\n  if (msAbs >= s) {\n    return Math.round(ms / s) + 's';\n  }\n  return ms + 'ms';\n}\n\n/**\n * Long format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtLong(ms) {\n  var msAbs = Math.abs(ms);\n  if (msAbs >= d) {\n    return plural(ms, msAbs, d, 'day');\n  }\n  if (msAbs >= h) {\n    return plural(ms, msAbs, h, 'hour');\n  }\n  if (msAbs >= m) {\n    return plural(ms, msAbs, m, 'minute');\n  }\n  if (msAbs >= s) {\n    return plural(ms, msAbs, s, 'second');\n  }\n  return ms + ' ms';\n}\n\n/**\n * Pluralization helper.\n */\n\nfunction plural(ms, msAbs, n, name) {\n  var isPlural = msAbs >= n * 1.5;\n  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');\n}\n","var wrappy = require('wrappy')\nmodule.exports = wrappy(once)\nmodule.exports.strict = wrappy(onceStrict)\n\nonce.proto = once(function () {\n  Object.defineProperty(Function.prototype, 'once', {\n    value: function () {\n      return once(this)\n    },\n    configurable: true\n  })\n\n  Object.defineProperty(Function.prototype, 'onceStrict', {\n    value: function () {\n      return onceStrict(this)\n    },\n    configurable: true\n  })\n})\n\nfunction once (fn) {\n  var f = function () {\n    if (f.called) return f.value\n    f.called = true\n    return f.value = fn.apply(this, arguments)\n  }\n  f.called = false\n  return f\n}\n\nfunction onceStrict (fn) {\n  var f = function () {\n    if (f.called)\n      throw new Error(f.onceError)\n    f.called = true\n    return f.value = fn.apply(this, arguments)\n  }\n  var name = fn.name || 'Function wrapped with `once`'\n  f.onceError = name + \" shouldn't be called more than once\"\n  f.called = false\n  return f\n}\n","/*! queue-microtask. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */\nlet promise\n\nmodule.exports = typeof queueMicrotask === 'function'\n  ? queueMicrotask.bind(typeof window !== 'undefined' ? window : global)\n  // reuse resolved promise, and allocate it lazily\n  : cb => (promise || (promise = Promise.resolve()))\n    .then(cb)\n    .catch(err => setTimeout(() => { throw err }, 0))\n","module.exports = typeof queueMicrotask === 'function' ? queueMicrotask : (fn) => Promise.resolve().then(fn)\n","/*! run-parallel. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */\nmodule.exports = runParallel\n\nconst queueMicrotask = require('queue-microtask')\n\nfunction runParallel (tasks, cb) {\n  let results, pending, keys\n  let isSync = true\n\n  if (Array.isArray(tasks)) {\n    results = []\n    pending = tasks.length\n  } else {\n    keys = Object.keys(tasks)\n    results = {}\n    pending = keys.length\n  }\n\n  function done (err) {\n    function end () {\n      if (cb) cb(err, results)\n      cb = null\n    }\n    if (isSync) queueMicrotask(end)\n    else end()\n  }\n\n  function each (i, err, result) {\n    results[i] = result\n    if (--pending === 0 || err) {\n      done(err)\n    }\n  }\n\n  if (!pending) {\n    // empty\n    done(null)\n  } else if (keys) {\n    // object\n    keys.forEach(function (key) {\n      tasks[key](function (err, result) { each(key, err, result) })\n    })\n  } else {\n    // array\n    tasks.forEach(function (task, i) {\n      task(function (err, result) { each(i, err, result) })\n    })\n  }\n\n  isSync = false\n}\n","/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */\n/* eslint-disable node/no-deprecated-api */\nvar buffer = require('buffer')\nvar Buffer = buffer.Buffer\n\n// alternative to using Object.keys for old browsers\nfunction copyProps (src, dst) {\n  for (var key in src) {\n    dst[key] = src[key]\n  }\n}\nif (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {\n  module.exports = buffer\n} else {\n  // Copy properties from require('buffer')\n  copyProps(buffer, exports)\n  exports.Buffer = SafeBuffer\n}\n\nfunction SafeBuffer (arg, encodingOrOffset, length) {\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.prototype = Object.create(Buffer.prototype)\n\n// Copy static methods from Buffer\ncopyProps(Buffer, SafeBuffer)\n\nSafeBuffer.from = function (arg, encodingOrOffset, length) {\n  if (typeof arg === 'number') {\n    throw new TypeError('Argument must not be a number')\n  }\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.alloc = function (size, fill, encoding) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  var buf = Buffer(size)\n  if (fill !== undefined) {\n    if (typeof encoding === 'string') {\n      buf.fill(fill, encoding)\n    } else {\n      buf.fill(fill)\n    }\n  } else {\n    buf.fill(0)\n  }\n  return buf\n}\n\nSafeBuffer.allocUnsafe = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return Buffer(size)\n}\n\nSafeBuffer.allocUnsafeSlow = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return buffer.SlowBuffer(size)\n}\n","var Buffer = require('safe-buffer').Buffer\n\n// prototype class for hash functions\nfunction Hash (blockSize, finalSize) {\n  this._block = Buffer.alloc(blockSize)\n  this._finalSize = finalSize\n  this._blockSize = blockSize\n  this._len = 0\n}\n\nHash.prototype.update = function (data, enc) {\n  if (typeof data === 'string') {\n    enc = enc || 'utf8'\n    data = Buffer.from(data, enc)\n  }\n\n  var block = this._block\n  var blockSize = this._blockSize\n  var length = data.length\n  var accum = this._len\n\n  for (var offset = 0; offset < length;) {\n    var assigned = accum % blockSize\n    var remainder = Math.min(length - offset, blockSize - assigned)\n\n    for (var i = 0; i < remainder; i++) {\n      block[assigned + i] = data[offset + i]\n    }\n\n    accum += remainder\n    offset += remainder\n\n    if ((accum % blockSize) === 0) {\n      this._update(block)\n    }\n  }\n\n  this._len += length\n  return this\n}\n\nHash.prototype.digest = function (enc) {\n  var rem = this._len % this._blockSize\n\n  this._block[rem] = 0x80\n\n  // zero (rem + 1) trailing bits, where (rem + 1) is the smallest\n  // non-negative solution to the equation (length + 1 + (rem + 1)) === finalSize mod blockSize\n  this._block.fill(0, rem + 1)\n\n  if (rem >= this._finalSize) {\n    this._update(this._block)\n    this._block.fill(0)\n  }\n\n  var bits = this._len * 8\n\n  // uint32\n  if (bits <= 0xffffffff) {\n    this._block.writeUInt32BE(bits, this._blockSize - 4)\n\n  // uint64\n  } else {\n    var lowBits = (bits & 0xffffffff) >>> 0\n    var highBits = (bits - lowBits) / 0x100000000\n\n    this._block.writeUInt32BE(highBits, this._blockSize - 8)\n    this._block.writeUInt32BE(lowBits, this._blockSize - 4)\n  }\n\n  this._update(this._block)\n  var hash = this._hash()\n\n  return enc ? hash.toString(enc) : hash\n}\n\nHash.prototype._update = function () {\n  throw new Error('_update must be implemented by subclass')\n}\n\nmodule.exports = Hash\n","/*\n * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined\n * in FIPS PUB 180-1\n * Version 2.1a Copyright Paul Johnston 2000 - 2002.\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n * Distributed under the BSD License\n * See http://pajhome.org.uk/crypt/md5 for details.\n */\n\nvar inherits = require('inherits')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar K = [\n  0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0\n]\n\nvar W = new Array(80)\n\nfunction Sha1 () {\n  this.init()\n  this._w = W\n\n  Hash.call(this, 64, 56)\n}\n\ninherits(Sha1, Hash)\n\nSha1.prototype.init = function () {\n  this._a = 0x67452301\n  this._b = 0xefcdab89\n  this._c = 0x98badcfe\n  this._d = 0x10325476\n  this._e = 0xc3d2e1f0\n\n  return this\n}\n\nfunction rotl1 (num) {\n  return (num << 1) | (num >>> 31)\n}\n\nfunction rotl5 (num) {\n  return (num << 5) | (num >>> 27)\n}\n\nfunction rotl30 (num) {\n  return (num << 30) | (num >>> 2)\n}\n\nfunction ft (s, b, c, d) {\n  if (s === 0) return (b & c) | ((~b) & d)\n  if (s === 2) return (b & c) | (b & d) | (c & d)\n  return b ^ c ^ d\n}\n\nSha1.prototype._update = function (M) {\n  var W = this._w\n\n  var a = this._a | 0\n  var b = this._b | 0\n  var c = this._c | 0\n  var d = this._d | 0\n  var e = this._e | 0\n\n  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)\n  for (; i < 80; ++i) W[i] = rotl1(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16])\n\n  for (var j = 0; j < 80; ++j) {\n    var s = ~~(j / 20)\n    var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0\n\n    e = d\n    d = c\n    c = rotl30(b)\n    b = a\n    a = t\n  }\n\n  this._a = (a + this._a) | 0\n  this._b = (b + this._b) | 0\n  this._c = (c + this._c) | 0\n  this._d = (d + this._d) | 0\n  this._e = (e + this._e) | 0\n}\n\nSha1.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(20)\n\n  H.writeInt32BE(this._a | 0, 0)\n  H.writeInt32BE(this._b | 0, 4)\n  H.writeInt32BE(this._c | 0, 8)\n  H.writeInt32BE(this._d | 0, 12)\n  H.writeInt32BE(this._e | 0, 16)\n\n  return H\n}\n\nmodule.exports = Sha1\n","const { EventEmitter } = require('events')\nconst STREAM_DESTROYED = new Error('Stream was destroyed')\nconst PREMATURE_CLOSE = new Error('Premature close')\n\nconst queueTick = require('queue-tick')\nconst FIFO = require('fast-fifo')\n\n/* eslint-disable no-multi-spaces */\n\n// 27 bits used total (4 from shared, 13 from read, and 10 from write)\nconst MAX = ((1 << 27) - 1)\n\n// Shared state\nconst OPENING       = 0b0001\nconst PREDESTROYING = 0b0010\nconst DESTROYING    = 0b0100\nconst DESTROYED     = 0b1000\n\nconst NOT_OPENING = MAX ^ OPENING\nconst NOT_PREDESTROYING = MAX ^ PREDESTROYING\n\n// Read state (4 bit offset from shared state)\nconst READ_ACTIVE           = 0b0000000000001 << 4\nconst READ_UPDATING         = 0b0000000000010 << 4\nconst READ_PRIMARY          = 0b0000000000100 << 4\nconst READ_QUEUED           = 0b0000000001000 << 4\nconst READ_RESUMED          = 0b0000000010000 << 4\nconst READ_PIPE_DRAINED     = 0b0000000100000 << 4\nconst READ_ENDING           = 0b0000001000000 << 4\nconst READ_EMIT_DATA        = 0b0000010000000 << 4\nconst READ_EMIT_READABLE    = 0b0000100000000 << 4\nconst READ_EMITTED_READABLE = 0b0001000000000 << 4\nconst READ_DONE             = 0b0010000000000 << 4\nconst READ_NEXT_TICK        = 0b0100000000000 << 4\nconst READ_NEEDS_PUSH       = 0b1000000000000 << 4\n\n// Combined read state\nconst READ_FLOWING = READ_RESUMED | READ_PIPE_DRAINED\nconst READ_ACTIVE_AND_NEEDS_PUSH = READ_ACTIVE | READ_NEEDS_PUSH\nconst READ_PRIMARY_AND_ACTIVE = READ_PRIMARY | READ_ACTIVE\nconst READ_EMIT_READABLE_AND_QUEUED = READ_EMIT_READABLE | READ_QUEUED\n\nconst READ_NOT_ACTIVE             = MAX ^ READ_ACTIVE\nconst READ_NON_PRIMARY            = MAX ^ READ_PRIMARY\nconst READ_NON_PRIMARY_AND_PUSHED = MAX ^ (READ_PRIMARY | READ_NEEDS_PUSH)\nconst READ_PUSHED                 = MAX ^ READ_NEEDS_PUSH\nconst READ_PAUSED                 = MAX ^ READ_RESUMED\nconst READ_NOT_QUEUED             = MAX ^ (READ_QUEUED | READ_EMITTED_READABLE)\nconst READ_NOT_ENDING             = MAX ^ READ_ENDING\nconst READ_PIPE_NOT_DRAINED       = MAX ^ READ_FLOWING\nconst READ_NOT_NEXT_TICK          = MAX ^ READ_NEXT_TICK\nconst READ_NOT_UPDATING           = MAX ^ READ_UPDATING\n\n// Write state (17 bit offset, 4 bit offset from shared state and 13 from read state)\nconst WRITE_ACTIVE     = 0b0000000001 << 17\nconst WRITE_UPDATING   = 0b0000000010 << 17\nconst WRITE_PRIMARY    = 0b0000000100 << 17\nconst WRITE_QUEUED     = 0b0000001000 << 17\nconst WRITE_UNDRAINED  = 0b0000010000 << 17\nconst WRITE_DONE       = 0b0000100000 << 17\nconst WRITE_EMIT_DRAIN = 0b0001000000 << 17\nconst WRITE_NEXT_TICK  = 0b0010000000 << 17\nconst WRITE_WRITING    = 0b0100000000 << 17\nconst WRITE_FINISHING  = 0b1000000000 << 17\n\nconst WRITE_NOT_ACTIVE    = MAX ^ (WRITE_ACTIVE | WRITE_WRITING)\nconst WRITE_NON_PRIMARY   = MAX ^ WRITE_PRIMARY\nconst WRITE_NOT_FINISHING = MAX ^ WRITE_FINISHING\nconst WRITE_DRAINED       = MAX ^ WRITE_UNDRAINED\nconst WRITE_NOT_QUEUED    = MAX ^ WRITE_QUEUED\nconst WRITE_NOT_NEXT_TICK = MAX ^ WRITE_NEXT_TICK\nconst WRITE_NOT_UPDATING  = MAX ^ WRITE_UPDATING\n\n// Combined shared state\nconst ACTIVE = READ_ACTIVE | WRITE_ACTIVE\nconst NOT_ACTIVE = MAX ^ ACTIVE\nconst DONE = READ_DONE | WRITE_DONE\nconst DESTROY_STATUS = DESTROYING | DESTROYED | PREDESTROYING\nconst OPEN_STATUS = DESTROY_STATUS | OPENING\nconst AUTO_DESTROY = DESTROY_STATUS | DONE\nconst NON_PRIMARY = WRITE_NON_PRIMARY & READ_NON_PRIMARY\nconst ACTIVE_OR_TICKING = WRITE_NEXT_TICK | READ_NEXT_TICK\nconst TICKING = ACTIVE_OR_TICKING & NOT_ACTIVE\nconst IS_OPENING = OPEN_STATUS | TICKING\n\n// Combined shared state and read state\nconst READ_PRIMARY_STATUS = OPEN_STATUS | READ_ENDING | READ_DONE\nconst READ_STATUS = OPEN_STATUS | READ_DONE | READ_QUEUED\nconst READ_ENDING_STATUS = OPEN_STATUS | READ_ENDING | READ_QUEUED\nconst READ_READABLE_STATUS = OPEN_STATUS | READ_EMIT_READABLE | READ_QUEUED | READ_EMITTED_READABLE\nconst SHOULD_NOT_READ = OPEN_STATUS | READ_ACTIVE | READ_ENDING | READ_DONE | READ_NEEDS_PUSH\nconst READ_BACKPRESSURE_STATUS = DESTROY_STATUS | READ_ENDING | READ_DONE\nconst READ_UPDATE_SYNC_STATUS = READ_UPDATING | OPEN_STATUS | READ_NEXT_TICK | READ_PRIMARY\n\n// Combined write state\nconst WRITE_PRIMARY_STATUS = OPEN_STATUS | WRITE_FINISHING | WRITE_DONE\nconst WRITE_QUEUED_AND_UNDRAINED = WRITE_QUEUED | WRITE_UNDRAINED\nconst WRITE_QUEUED_AND_ACTIVE = WRITE_QUEUED | WRITE_ACTIVE\nconst WRITE_DRAIN_STATUS = WRITE_QUEUED | WRITE_UNDRAINED | OPEN_STATUS | WRITE_ACTIVE\nconst WRITE_STATUS = OPEN_STATUS | WRITE_ACTIVE | WRITE_QUEUED\nconst WRITE_PRIMARY_AND_ACTIVE = WRITE_PRIMARY | WRITE_ACTIVE\nconst WRITE_ACTIVE_AND_WRITING = WRITE_ACTIVE | WRITE_WRITING\nconst WRITE_FINISHING_STATUS = OPEN_STATUS | WRITE_FINISHING | WRITE_QUEUED_AND_ACTIVE | WRITE_DONE\nconst WRITE_BACKPRESSURE_STATUS = WRITE_UNDRAINED | DESTROY_STATUS | WRITE_FINISHING | WRITE_DONE\nconst WRITE_UPDATE_SYNC_STATUS = WRITE_UPDATING | OPEN_STATUS | WRITE_NEXT_TICK | WRITE_PRIMARY\n\nconst asyncIterator = Symbol.asyncIterator || Symbol('asyncIterator')\n\nclass WritableState {\n  constructor (stream, { highWaterMark = 16384, map = null, mapWritable, byteLength, byteLengthWritable } = {}) {\n    this.stream = stream\n    this.queue = new FIFO()\n    this.highWaterMark = highWaterMark\n    this.buffered = 0\n    this.error = null\n    this.pipeline = null\n    this.drains = null // if we add more seldomly used helpers we might them into a subobject so its a single ptr\n    this.byteLength = byteLengthWritable || byteLength || defaultByteLength\n    this.map = mapWritable || map\n    this.afterWrite = afterWrite.bind(this)\n    this.afterUpdateNextTick = updateWriteNT.bind(this)\n  }\n\n  get ended () {\n    return (this.stream._duplexState & WRITE_DONE) !== 0\n  }\n\n  push (data) {\n    if (this.map !== null) data = this.map(data)\n\n    this.buffered += this.byteLength(data)\n    this.queue.push(data)\n\n    if (this.buffered < this.highWaterMark) {\n      this.stream._duplexState |= WRITE_QUEUED\n      return true\n    }\n\n    this.stream._duplexState |= WRITE_QUEUED_AND_UNDRAINED\n    return false\n  }\n\n  shift () {\n    const data = this.queue.shift()\n\n    this.buffered -= this.byteLength(data)\n    if (this.buffered === 0) this.stream._duplexState &= WRITE_NOT_QUEUED\n\n    return data\n  }\n\n  end (data) {\n    if (typeof data === 'function') this.stream.once('finish', data)\n    else if (data !== undefined && data !== null) this.push(data)\n    this.stream._duplexState = (this.stream._duplexState | WRITE_FINISHING) & WRITE_NON_PRIMARY\n  }\n\n  autoBatch (data, cb) {\n    const buffer = []\n    const stream = this.stream\n\n    buffer.push(data)\n    while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED_AND_ACTIVE) {\n      buffer.push(stream._writableState.shift())\n    }\n\n    if ((stream._duplexState & OPEN_STATUS) !== 0) return cb(null)\n    stream._writev(buffer, cb)\n  }\n\n  update () {\n    const stream = this.stream\n\n    stream._duplexState |= WRITE_UPDATING\n\n    do {\n      while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED) {\n        const data = this.shift()\n        stream._duplexState |= WRITE_ACTIVE_AND_WRITING\n        stream._write(data, this.afterWrite)\n      }\n\n      if ((stream._duplexState & WRITE_PRIMARY_AND_ACTIVE) === 0) this.updateNonPrimary()\n    } while (this.continueUpdate() === true)\n\n    stream._duplexState &= WRITE_NOT_UPDATING\n  }\n\n  updateNonPrimary () {\n    const stream = this.stream\n\n    if ((stream._duplexState & WRITE_FINISHING_STATUS) === WRITE_FINISHING) {\n      stream._duplexState = (stream._duplexState | WRITE_ACTIVE) & WRITE_NOT_FINISHING\n      stream._final(afterFinal.bind(this))\n      return\n    }\n\n    if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) {\n      if ((stream._duplexState & ACTIVE_OR_TICKING) === 0) {\n        stream._duplexState |= ACTIVE\n        stream._destroy(afterDestroy.bind(this))\n      }\n      return\n    }\n\n    if ((stream._duplexState & IS_OPENING) === OPENING) {\n      stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING\n      stream._open(afterOpen.bind(this))\n    }\n  }\n\n  continueUpdate () {\n    if ((this.stream._duplexState & WRITE_NEXT_TICK) === 0) return false\n    this.stream._duplexState &= WRITE_NOT_NEXT_TICK\n    return true\n  }\n\n  updateCallback () {\n    if ((this.stream._duplexState & WRITE_UPDATE_SYNC_STATUS) === WRITE_PRIMARY) this.update()\n    else this.updateNextTick()\n  }\n\n  updateNextTick () {\n    if ((this.stream._duplexState & WRITE_NEXT_TICK) !== 0) return\n    this.stream._duplexState |= WRITE_NEXT_TICK\n    if ((this.stream._duplexState & WRITE_UPDATING) === 0) queueTick(this.afterUpdateNextTick)\n  }\n}\n\nclass ReadableState {\n  constructor (stream, { highWaterMark = 16384, map = null, mapReadable, byteLength, byteLengthReadable } = {}) {\n    this.stream = stream\n    this.queue = new FIFO()\n    this.highWaterMark = highWaterMark\n    this.buffered = 0\n    this.error = null\n    this.pipeline = null\n    this.byteLength = byteLengthReadable || byteLength || defaultByteLength\n    this.map = mapReadable || map\n    this.pipeTo = null\n    this.afterRead = afterRead.bind(this)\n    this.afterUpdateNextTick = updateReadNT.bind(this)\n  }\n\n  get ended () {\n    return (this.stream._duplexState & READ_DONE) !== 0\n  }\n\n  pipe (pipeTo, cb) {\n    if (this.pipeTo !== null) throw new Error('Can only pipe to one destination')\n    if (typeof cb !== 'function') cb = null\n\n    this.stream._duplexState |= READ_PIPE_DRAINED\n    this.pipeTo = pipeTo\n    this.pipeline = new Pipeline(this.stream, pipeTo, cb)\n\n    if (cb) this.stream.on('error', noop) // We already error handle this so supress crashes\n\n    if (isStreamx(pipeTo)) {\n      pipeTo._writableState.pipeline = this.pipeline\n      if (cb) pipeTo.on('error', noop) // We already error handle this so supress crashes\n      pipeTo.on('finish', this.pipeline.finished.bind(this.pipeline)) // TODO: just call finished from pipeTo itself\n    } else {\n      const onerror = this.pipeline.done.bind(this.pipeline, pipeTo)\n      const onclose = this.pipeline.done.bind(this.pipeline, pipeTo, null) // onclose has a weird bool arg\n      pipeTo.on('error', onerror)\n      pipeTo.on('close', onclose)\n      pipeTo.on('finish', this.pipeline.finished.bind(this.pipeline))\n    }\n\n    pipeTo.on('drain', afterDrain.bind(this))\n    this.stream.emit('piping', pipeTo)\n    pipeTo.emit('pipe', this.stream)\n  }\n\n  push (data) {\n    const stream = this.stream\n\n    if (data === null) {\n      this.highWaterMark = 0\n      stream._duplexState = (stream._duplexState | READ_ENDING) & READ_NON_PRIMARY_AND_PUSHED\n      return false\n    }\n\n    if (this.map !== null) data = this.map(data)\n    this.buffered += this.byteLength(data)\n    this.queue.push(data)\n\n    stream._duplexState = (stream._duplexState | READ_QUEUED) & READ_PUSHED\n\n    return this.buffered < this.highWaterMark\n  }\n\n  shift () {\n    const data = this.queue.shift()\n\n    this.buffered -= this.byteLength(data)\n    if (this.buffered === 0) this.stream._duplexState &= READ_NOT_QUEUED\n    return data\n  }\n\n  unshift (data) {\n    const pending = [this.map !== null ? this.map(data) : data]\n    while (this.buffered > 0) pending.push(this.shift())\n\n    for (let i = 0; i < pending.length - 1; i++) {\n      const data = pending[i]\n      this.buffered += this.byteLength(data)\n      this.queue.push(data)\n    }\n\n    this.push(pending[pending.length - 1])\n  }\n\n  read () {\n    const stream = this.stream\n\n    if ((stream._duplexState & READ_STATUS) === READ_QUEUED) {\n      const data = this.shift()\n      if (this.pipeTo !== null && this.pipeTo.write(data) === false) stream._duplexState &= READ_PIPE_NOT_DRAINED\n      if ((stream._duplexState & READ_EMIT_DATA) !== 0) stream.emit('data', data)\n      return data\n    }\n\n    return null\n  }\n\n  drain () {\n    const stream = this.stream\n\n    while ((stream._duplexState & READ_STATUS) === READ_QUEUED && (stream._duplexState & READ_FLOWING) !== 0) {\n      const data = this.shift()\n      if (this.pipeTo !== null && this.pipeTo.write(data) === false) stream._duplexState &= READ_PIPE_NOT_DRAINED\n      if ((stream._duplexState & READ_EMIT_DATA) !== 0) stream.emit('data', data)\n    }\n  }\n\n  update () {\n    const stream = this.stream\n\n    stream._duplexState |= READ_UPDATING\n\n    do {\n      this.drain()\n\n      while (this.buffered < this.highWaterMark && (stream._duplexState & SHOULD_NOT_READ) === 0) {\n        stream._duplexState |= READ_ACTIVE_AND_NEEDS_PUSH\n        stream._read(this.afterRead)\n        this.drain()\n      }\n\n      if ((stream._duplexState & READ_READABLE_STATUS) === READ_EMIT_READABLE_AND_QUEUED) {\n        stream._duplexState |= READ_EMITTED_READABLE\n        stream.emit('readable')\n      }\n\n      if ((stream._duplexState & READ_PRIMARY_AND_ACTIVE) === 0) this.updateNonPrimary()\n    } while (this.continueUpdate() === true)\n\n    stream._duplexState &= READ_NOT_UPDATING\n  }\n\n  updateNonPrimary () {\n    const stream = this.stream\n\n    if ((stream._duplexState & READ_ENDING_STATUS) === READ_ENDING) {\n      stream._duplexState = (stream._duplexState | READ_DONE) & READ_NOT_ENDING\n      stream.emit('end')\n      if ((stream._duplexState & AUTO_DESTROY) === DONE) stream._duplexState |= DESTROYING\n      if (this.pipeTo !== null) this.pipeTo.end()\n    }\n\n    if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) {\n      if ((stream._duplexState & ACTIVE_OR_TICKING) === 0) {\n        stream._duplexState |= ACTIVE\n        stream._destroy(afterDestroy.bind(this))\n      }\n      return\n    }\n\n    if ((stream._duplexState & IS_OPENING) === OPENING) {\n      stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING\n      stream._open(afterOpen.bind(this))\n    }\n  }\n\n  continueUpdate () {\n    if ((this.stream._duplexState & READ_NEXT_TICK) === 0) return false\n    this.stream._duplexState &= READ_NOT_NEXT_TICK\n    return true\n  }\n\n  updateCallback () {\n    if ((this.stream._duplexState & READ_UPDATE_SYNC_STATUS) === READ_PRIMARY) this.update()\n    else this.updateNextTick()\n  }\n\n  updateNextTick () {\n    if ((this.stream._duplexState & READ_NEXT_TICK) !== 0) return\n    this.stream._duplexState |= READ_NEXT_TICK\n    if ((this.stream._duplexState & READ_UPDATING) === 0) queueTick(this.afterUpdateNextTick)\n  }\n}\n\nclass TransformState {\n  constructor (stream) {\n    this.data = null\n    this.afterTransform = afterTransform.bind(stream)\n    this.afterFinal = null\n  }\n}\n\nclass Pipeline {\n  constructor (src, dst, cb) {\n    this.from = src\n    this.to = dst\n    this.afterPipe = cb\n    this.error = null\n    this.pipeToFinished = false\n  }\n\n  finished () {\n    this.pipeToFinished = true\n  }\n\n  done (stream, err) {\n    if (err) this.error = err\n\n    if (stream === this.to) {\n      this.to = null\n\n      if (this.from !== null) {\n        if ((this.from._duplexState & READ_DONE) === 0 || !this.pipeToFinished) {\n          this.from.destroy(this.error || new Error('Writable stream closed prematurely'))\n        }\n        return\n      }\n    }\n\n    if (stream === this.from) {\n      this.from = null\n\n      if (this.to !== null) {\n        if ((stream._duplexState & READ_DONE) === 0) {\n          this.to.destroy(this.error || new Error('Readable stream closed before ending'))\n        }\n        return\n      }\n    }\n\n    if (this.afterPipe !== null) this.afterPipe(this.error)\n    this.to = this.from = this.afterPipe = null\n  }\n}\n\nfunction afterDrain () {\n  this.stream._duplexState |= READ_PIPE_DRAINED\n  this.updateCallback()\n}\n\nfunction afterFinal (err) {\n  const stream = this.stream\n  if (err) stream.destroy(err)\n  if ((stream._duplexState & DESTROY_STATUS) === 0) {\n    stream._duplexState |= WRITE_DONE\n    stream.emit('finish')\n  }\n  if ((stream._duplexState & AUTO_DESTROY) === DONE) {\n    stream._duplexState |= DESTROYING\n  }\n\n  stream._duplexState &= WRITE_NOT_ACTIVE\n\n  // no need to wait the extra tick here, so we short circuit that\n  if ((stream._duplexState & WRITE_UPDATING) === 0) this.update()\n  else this.updateNextTick()\n}\n\nfunction afterDestroy (err) {\n  const stream = this.stream\n\n  if (!err && this.error !== STREAM_DESTROYED) err = this.error\n  if (err) stream.emit('error', err)\n  stream._duplexState |= DESTROYED\n  stream.emit('close')\n\n  const rs = stream._readableState\n  const ws = stream._writableState\n\n  if (rs !== null && rs.pipeline !== null) rs.pipeline.done(stream, err)\n\n  if (ws !== null) {\n    while (ws.drains !== null && ws.drains.length > 0) ws.drains.shift().resolve(false)\n    if (ws.pipeline !== null) ws.pipeline.done(stream, err)\n  }\n}\n\nfunction afterWrite (err) {\n  const stream = this.stream\n\n  if (err) stream.destroy(err)\n  stream._duplexState &= WRITE_NOT_ACTIVE\n\n  if (this.drains !== null) tickDrains(this.drains)\n\n  if ((stream._duplexState & WRITE_DRAIN_STATUS) === WRITE_UNDRAINED) {\n    stream._duplexState &= WRITE_DRAINED\n    if ((stream._duplexState & WRITE_EMIT_DRAIN) === WRITE_EMIT_DRAIN) {\n      stream.emit('drain')\n    }\n  }\n\n  this.updateCallback()\n}\n\nfunction afterRead (err) {\n  if (err) this.stream.destroy(err)\n  this.stream._duplexState &= READ_NOT_ACTIVE\n  this.updateCallback()\n}\n\nfunction updateReadNT () {\n  if ((this.stream._duplexState & READ_UPDATING) === 0) {\n    this.stream._duplexState &= READ_NOT_NEXT_TICK\n    this.update()\n  }\n}\n\nfunction updateWriteNT () {\n  if ((this.stream._duplexState & WRITE_UPDATING) === 0) {\n    this.stream._duplexState &= WRITE_NOT_NEXT_TICK\n    this.update()\n  }\n}\n\nfunction tickDrains (drains) {\n  for (let i = 0; i < drains.length; i++) {\n    // drains.writes are monotonic, so if one is 0 its always the first one\n    if (--drains[i].writes === 0) {\n      drains.shift().resolve(true)\n      i--\n    }\n  }\n}\n\nfunction afterOpen (err) {\n  const stream = this.stream\n\n  if (err) stream.destroy(err)\n\n  if ((stream._duplexState & DESTROYING) === 0) {\n    if ((stream._duplexState & READ_PRIMARY_STATUS) === 0) stream._duplexState |= READ_PRIMARY\n    if ((stream._duplexState & WRITE_PRIMARY_STATUS) === 0) stream._duplexState |= WRITE_PRIMARY\n    stream.emit('open')\n  }\n\n  stream._duplexState &= NOT_ACTIVE\n\n  if (stream._writableState !== null) {\n    stream._writableState.updateCallback()\n  }\n\n  if (stream._readableState !== null) {\n    stream._readableState.updateCallback()\n  }\n}\n\nfunction afterTransform (err, data) {\n  if (data !== undefined && data !== null) this.push(data)\n  this._writableState.afterWrite(err)\n}\n\nfunction newListener (name) {\n  if (this._readableState !== null) {\n    if (name === 'data') {\n      this._duplexState |= (READ_EMIT_DATA | READ_RESUMED)\n      this._readableState.updateNextTick()\n    }\n    if (name === 'readable') {\n      this._duplexState |= READ_EMIT_READABLE\n      this._readableState.updateNextTick()\n    }\n  }\n\n  if (this._writableState !== null) {\n    if (name === 'drain') {\n      this._duplexState |= WRITE_EMIT_DRAIN\n      this._writableState.updateNextTick()\n    }\n  }\n}\n\nclass Stream extends EventEmitter {\n  constructor (opts) {\n    super()\n\n    this._duplexState = 0\n    this._readableState = null\n    this._writableState = null\n\n    if (opts) {\n      if (opts.open) this._open = opts.open\n      if (opts.destroy) this._destroy = opts.destroy\n      if (opts.predestroy) this._predestroy = opts.predestroy\n      if (opts.signal) {\n        opts.signal.addEventListener('abort', abort.bind(this))\n      }\n    }\n\n    this.on('newListener', newListener)\n  }\n\n  _open (cb) {\n    cb(null)\n  }\n\n  _destroy (cb) {\n    cb(null)\n  }\n\n  _predestroy () {\n    // does nothing\n  }\n\n  get readable () {\n    return this._readableState !== null ? true : undefined\n  }\n\n  get writable () {\n    return this._writableState !== null ? true : undefined\n  }\n\n  get destroyed () {\n    return (this._duplexState & DESTROYED) !== 0\n  }\n\n  get destroying () {\n    return (this._duplexState & DESTROY_STATUS) !== 0\n  }\n\n  destroy (err) {\n    if ((this._duplexState & DESTROY_STATUS) === 0) {\n      if (!err) err = STREAM_DESTROYED\n      this._duplexState = (this._duplexState | DESTROYING) & NON_PRIMARY\n\n      if (this._readableState !== null) {\n        this._readableState.highWaterMark = 0\n        this._readableState.error = err\n      }\n      if (this._writableState !== null) {\n        this._writableState.highWaterMark = 0\n        this._writableState.error = err\n      }\n\n      this._duplexState |= PREDESTROYING\n      this._predestroy()\n      this._duplexState &= NOT_PREDESTROYING\n\n      if (this._readableState !== null) this._readableState.updateNextTick()\n      if (this._writableState !== null) this._writableState.updateNextTick()\n    }\n  }\n}\n\nclass Readable extends Stream {\n  constructor (opts) {\n    super(opts)\n\n    this._duplexState |= OPENING | WRITE_DONE\n    this._readableState = new ReadableState(this, opts)\n\n    if (opts) {\n      if (opts.read) this._read = opts.read\n      if (opts.eagerOpen) this._readableState.updateNextTick()\n    }\n  }\n\n  _read (cb) {\n    cb(null)\n  }\n\n  pipe (dest, cb) {\n    this._readableState.updateNextTick()\n    this._readableState.pipe(dest, cb)\n    return dest\n  }\n\n  read () {\n    this._readableState.updateNextTick()\n    return this._readableState.read()\n  }\n\n  push (data) {\n    this._readableState.updateNextTick()\n    return this._readableState.push(data)\n  }\n\n  unshift (data) {\n    this._readableState.updateNextTick()\n    return this._readableState.unshift(data)\n  }\n\n  resume () {\n    this._duplexState |= READ_RESUMED\n    this._readableState.updateNextTick()\n    return this\n  }\n\n  pause () {\n    this._duplexState &= READ_PAUSED\n    return this\n  }\n\n  static _fromAsyncIterator (ite, opts) {\n    let destroy\n\n    const rs = new Readable({\n      ...opts,\n      read (cb) {\n        ite.next().then(push).then(cb.bind(null, null)).catch(cb)\n      },\n      predestroy () {\n        destroy = ite.return()\n      },\n      destroy (cb) {\n        if (!destroy) return cb(null)\n        destroy.then(cb.bind(null, null)).catch(cb)\n      }\n    })\n\n    return rs\n\n    function push (data) {\n      if (data.done) rs.push(null)\n      else rs.push(data.value)\n    }\n  }\n\n  static from (data, opts) {\n    if (isReadStreamx(data)) return data\n    if (data[asyncIterator]) return this._fromAsyncIterator(data[asyncIterator](), opts)\n    if (!Array.isArray(data)) data = data === undefined ? [] : [data]\n\n    let i = 0\n    return new Readable({\n      ...opts,\n      read (cb) {\n        this.push(i === data.length ? null : data[i++])\n        cb(null)\n      }\n    })\n  }\n\n  static isBackpressured (rs) {\n    return (rs._duplexState & READ_BACKPRESSURE_STATUS) !== 0 || rs._readableState.buffered >= rs._readableState.highWaterMark\n  }\n\n  static isPaused (rs) {\n    return (rs._duplexState & READ_RESUMED) === 0\n  }\n\n  [asyncIterator] () {\n    const stream = this\n\n    let error = null\n    let promiseResolve = null\n    let promiseReject = null\n\n    this.on('error', (err) => { error = err })\n    this.on('readable', onreadable)\n    this.on('close', onclose)\n\n    return {\n      [asyncIterator] () {\n        return this\n      },\n      next () {\n        return new Promise(function (resolve, reject) {\n          promiseResolve = resolve\n          promiseReject = reject\n          const data = stream.read()\n          if (data !== null) ondata(data)\n          else if ((stream._duplexState & DESTROYED) !== 0) ondata(null)\n        })\n      },\n      return () {\n        return destroy(null)\n      },\n      throw (err) {\n        return destroy(err)\n      }\n    }\n\n    function onreadable () {\n      if (promiseResolve !== null) ondata(stream.read())\n    }\n\n    function onclose () {\n      if (promiseResolve !== null) ondata(null)\n    }\n\n    function ondata (data) {\n      if (promiseReject === null) return\n      if (error) promiseReject(error)\n      else if (data === null && (stream._duplexState & READ_DONE) === 0) promiseReject(STREAM_DESTROYED)\n      else promiseResolve({ value: data, done: data === null })\n      promiseReject = promiseResolve = null\n    }\n\n    function destroy (err) {\n      stream.destroy(err)\n      return new Promise((resolve, reject) => {\n        if (stream._duplexState & DESTROYED) return resolve({ value: undefined, done: true })\n        stream.once('close', function () {\n          if (err) reject(err)\n          else resolve({ value: undefined, done: true })\n        })\n      })\n    }\n  }\n}\n\nclass Writable extends Stream {\n  constructor (opts) {\n    super(opts)\n\n    this._duplexState |= OPENING | READ_DONE\n    this._writableState = new WritableState(this, opts)\n\n    if (opts) {\n      if (opts.writev) this._writev = opts.writev\n      if (opts.write) this._write = opts.write\n      if (opts.final) this._final = opts.final\n      if (opts.eagerOpen) this._writableState.updateNextTick()\n    }\n  }\n\n  _writev (batch, cb) {\n    cb(null)\n  }\n\n  _write (data, cb) {\n    this._writableState.autoBatch(data, cb)\n  }\n\n  _final (cb) {\n    cb(null)\n  }\n\n  static isBackpressured (ws) {\n    return (ws._duplexState & WRITE_BACKPRESSURE_STATUS) !== 0\n  }\n\n  static drained (ws) {\n    if (ws.destroyed) return Promise.resolve(false)\n    const state = ws._writableState\n    const pending = (isWritev(ws) ? Math.min(1, state.queue.length) : state.queue.length)\n    const writes = pending + ((ws._duplexState & WRITE_WRITING) ? 1 : 0)\n    if (writes === 0) return Promise.resolve(true)\n    if (state.drains === null) state.drains = []\n    return new Promise((resolve) => {\n      state.drains.push({ writes, resolve })\n    })\n  }\n\n  write (data) {\n    this._writableState.updateNextTick()\n    return this._writableState.push(data)\n  }\n\n  end (data) {\n    this._writableState.updateNextTick()\n    this._writableState.end(data)\n    return this\n  }\n}\n\nclass Duplex extends Readable { // and Writable\n  constructor (opts) {\n    super(opts)\n\n    this._duplexState = OPENING\n    this._writableState = new WritableState(this, opts)\n\n    if (opts) {\n      if (opts.writev) this._writev = opts.writev\n      if (opts.write) this._write = opts.write\n      if (opts.final) this._final = opts.final\n    }\n  }\n\n  _writev (batch, cb) {\n    cb(null)\n  }\n\n  _write (data, cb) {\n    this._writableState.autoBatch(data, cb)\n  }\n\n  _final (cb) {\n    cb(null)\n  }\n\n  write (data) {\n    this._writableState.updateNextTick()\n    return this._writableState.push(data)\n  }\n\n  end (data) {\n    this._writableState.updateNextTick()\n    this._writableState.end(data)\n    return this\n  }\n}\n\nclass Transform extends Duplex {\n  constructor (opts) {\n    super(opts)\n    this._transformState = new TransformState(this)\n\n    if (opts) {\n      if (opts.transform) this._transform = opts.transform\n      if (opts.flush) this._flush = opts.flush\n    }\n  }\n\n  _write (data, cb) {\n    if (this._readableState.buffered >= this._readableState.highWaterMark) {\n      this._transformState.data = data\n    } else {\n      this._transform(data, this._transformState.afterTransform)\n    }\n  }\n\n  _read (cb) {\n    if (this._transformState.data !== null) {\n      const data = this._transformState.data\n      this._transformState.data = null\n      cb(null)\n      this._transform(data, this._transformState.afterTransform)\n    } else {\n      cb(null)\n    }\n  }\n\n  destroy (err) {\n    super.destroy(err)\n    if (this._transformState.data !== null) {\n      this._transformState.data = null\n      this._transformState.afterTransform()\n    }\n  }\n\n  _transform (data, cb) {\n    cb(null, data)\n  }\n\n  _flush (cb) {\n    cb(null)\n  }\n\n  _final (cb) {\n    this._transformState.afterFinal = cb\n    this._flush(transformAfterFlush.bind(this))\n  }\n}\n\nclass PassThrough extends Transform {}\n\nfunction transformAfterFlush (err, data) {\n  const cb = this._transformState.afterFinal\n  if (err) return cb(err)\n  if (data !== null && data !== undefined) this.push(data)\n  this.push(null)\n  cb(null)\n}\n\nfunction pipelinePromise (...streams) {\n  return new Promise((resolve, reject) => {\n    return pipeline(...streams, (err) => {\n      if (err) return reject(err)\n      resolve()\n    })\n  })\n}\n\nfunction pipeline (stream, ...streams) {\n  const all = Array.isArray(stream) ? [...stream, ...streams] : [stream, ...streams]\n  const done = (all.length && typeof all[all.length - 1] === 'function') ? all.pop() : null\n\n  if (all.length < 2) throw new Error('Pipeline requires at least 2 streams')\n\n  let src = all[0]\n  let dest = null\n  let error = null\n\n  for (let i = 1; i < all.length; i++) {\n    dest = all[i]\n\n    if (isStreamx(src)) {\n      src.pipe(dest, onerror)\n    } else {\n      errorHandle(src, true, i > 1, onerror)\n      src.pipe(dest)\n    }\n\n    src = dest\n  }\n\n  if (done) {\n    let fin = false\n\n    const autoDestroy = isStreamx(dest) || !!(dest._writableState && dest._writableState.autoDestroy)\n\n    dest.on('error', (err) => {\n      if (error === null) error = err\n    })\n\n    dest.on('finish', () => {\n      fin = true\n      if (!autoDestroy) done(error)\n    })\n\n    if (autoDestroy) {\n      dest.on('close', () => done(error || (fin ? null : PREMATURE_CLOSE)))\n    }\n  }\n\n  return dest\n\n  function errorHandle (s, rd, wr, onerror) {\n    s.on('error', onerror)\n    s.on('close', onclose)\n\n    function onclose () {\n      if (rd && s._readableState && !s._readableState.ended) return onerror(PREMATURE_CLOSE)\n      if (wr && s._writableState && !s._writableState.ended) return onerror(PREMATURE_CLOSE)\n    }\n  }\n\n  function onerror (err) {\n    if (!err || error) return\n    error = err\n\n    for (const s of all) {\n      s.destroy(err)\n    }\n  }\n}\n\nfunction isStream (stream) {\n  return !!stream._readableState || !!stream._writableState\n}\n\nfunction isStreamx (stream) {\n  return typeof stream._duplexState === 'number' && isStream(stream)\n}\n\nfunction getStreamError (stream) {\n  const err = (stream._readableState && stream._readableState.error) || (stream._writableState && stream._writableState.error)\n  return err === STREAM_DESTROYED ? null : err // only explicit errors\n}\n\nfunction isReadStreamx (stream) {\n  return isStreamx(stream) && stream.readable\n}\n\nfunction isTypedArray (data) {\n  return typeof data === 'object' && data !== null && typeof data.byteLength === 'number'\n}\n\nfunction defaultByteLength (data) {\n  return isTypedArray(data) ? data.byteLength : 1024\n}\n\nfunction noop () {}\n\nfunction abort () {\n  this.destroy(new Error('Stream aborted.'))\n}\n\nfunction isWritev (s) {\n  return s._writev !== Writable.prototype._writev && s._writev !== Duplex.prototype._writev\n}\n\nmodule.exports = {\n  pipeline,\n  pipelinePromise,\n  isStream,\n  isStreamx,\n  getStreamError,\n  Stream,\n  Writable,\n  Readable,\n  Duplex,\n  Transform,\n  // Export PassThrough for compatibility with Node.js core's stream module\n  PassThrough\n}\n","// Returns a wrapper function that returns a wrapped callback\n// The wrapper function should do some stuff, and return a\n// presumably different callback function.\n// This makes sure that own properties are retained, so that\n// decorations and such are not lost along the way.\nmodule.exports = wrappy\nfunction wrappy (fn, cb) {\n  if (fn && cb) return wrappy(fn)(cb)\n\n  if (typeof fn !== 'function')\n    throw new TypeError('need wrapper function')\n\n  Object.keys(fn).forEach(function (k) {\n    wrapper[k] = fn[k]\n  })\n\n  return wrapper\n\n  function wrapper() {\n    var args = new Array(arguments.length)\n    for (var i = 0; i < args.length; i++) {\n      args[i] = arguments[i]\n    }\n    var ret = fn.apply(this, args)\n    var cb = args[args.length-1]\n    if (typeof ret === 'function' && ret !== cb) {\n      Object.keys(cb).forEach(function (k) {\n        ret[k] = cb[k]\n      })\n    }\n    return ret\n  }\n}\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","export var Events;\r\n(function (Events) {\r\n    Events[\"SegmentLoaded\"] = \"segment_loaded\";\r\n    Events[\"SegmentError\"] = \"segment_error\";\r\n    Events[\"SegmentAbort\"] = \"segment_abort\";\r\n    Events[\"SegmentDownloaded\"] = \"segment_downloaded\";\r\n    Events[\"PeerConnect\"] = \"peer_connect\";\r\n    Events[\"PeerClose\"] = \"peer_close\";\r\n    Events[\"PieceBytesDownloaded\"] = \"piece_bytes_downloaded\";\r\n    Events[\"PieceBytesUploaded\"] = \"piece_bytes_uploaded\";\r\n})(Events || (Events = {}));\r\n","/* Common package for dealing with hex/string/uint8 conversions (and sha1 hashing)\r\n*\r\n* @author   Jimmy Wärting <jimmy@warting.se> (https://jimmy.warting.se/opensource)\r\n* @license  MIT\r\n*/\r\nexport const alphabet = '0123456789abcdef'\r\nconst encodeLookup = []\r\nconst decodeLookup = []\r\n\r\nfor (let i = 0; i < 256; i++) {\r\n  encodeLookup[i] = alphabet[i >> 4 & 0xf] + alphabet[i & 0xf]\r\n  if (i < 16) {\r\n    if (i < 10) {\r\n      decodeLookup[0x30 + i] = i\r\n    } else {\r\n      decodeLookup[0x61 - 10 + i] = i\r\n    }\r\n  }\r\n}\r\n\r\nexport const arr2hex = data => {\r\n  const length = data.length\r\n  let string = ''\r\n  let i = 0\r\n  while (i < length) {\r\n    string += encodeLookup[data[i++]]\r\n  }\r\n  return string\r\n}\r\n\r\nexport const hex2arr = str => {\r\n  const sizeof = str.length >> 1\r\n  const length = sizeof << 1\r\n  const array = new Uint8Array(sizeof)\r\n  let n = 0\r\n  let i = 0\r\n  while (i < length) {\r\n    array[n++] = decodeLookup[str.charCodeAt(i++)] << 4 | decodeLookup[str.charCodeAt(i++)]\r\n  }\r\n  return array\r\n}\r\n\r\nexport const concat = (chunks, size = 0) => {\r\n  const length = chunks.length || 0\r\n  if (!size) {\r\n    let i = length\r\n    while (i--) size += chunks[i].length\r\n  }\r\n  const b = new Uint8Array(size)\r\n  let offset = size\r\n  let i = length\r\n  while (i--) {\r\n    offset -= chunks[i].length\r\n    b.set(chunks[i], offset)\r\n  }\r\n\r\n  return b\r\n}\r\n\r\nexport const equal = (a, b) => {\r\n  if (a.length !== b.length) return false\r\n  for (let i = a.length; i > -1; i -= 1) {\r\n    if ((a[i] !== b[i])) return false\r\n  }\r\n  return true\r\n}\r\n","/*\n * base64-arraybuffer 1.0.2 <https://github.com/niklasvh/base64-arraybuffer>\n * Copyright (c) 2022 Niklas von Hertzen <https://hertzen.com>\n * Released under MIT License\n */\nvar chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n// Use a lookup table to find the index.\nvar lookup = typeof Uint8Array === 'undefined' ? [] : new Uint8Array(256);\nfor (var i = 0; i < chars.length; i++) {\n    lookup[chars.charCodeAt(i)] = i;\n}\nvar encode = function (arraybuffer) {\n    var bytes = new Uint8Array(arraybuffer), i, len = bytes.length, base64 = '';\n    for (i = 0; i < len; i += 3) {\n        base64 += chars[bytes[i] >> 2];\n        base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)];\n        base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)];\n        base64 += chars[bytes[i + 2] & 63];\n    }\n    if (len % 3 === 2) {\n        base64 = base64.substring(0, base64.length - 1) + '=';\n    }\n    else if (len % 3 === 1) {\n        base64 = base64.substring(0, base64.length - 2) + '==';\n    }\n    return base64;\n};\nvar decode = function (base64) {\n    var bufferLength = base64.length * 0.75, len = base64.length, i, p = 0, encoded1, encoded2, encoded3, encoded4;\n    if (base64[base64.length - 1] === '=') {\n        bufferLength--;\n        if (base64[base64.length - 2] === '=') {\n            bufferLength--;\n        }\n    }\n    var arraybuffer = new ArrayBuffer(bufferLength), bytes = new Uint8Array(arraybuffer);\n    for (i = 0; i < len; i += 4) {\n        encoded1 = lookup[base64.charCodeAt(i)];\n        encoded2 = lookup[base64.charCodeAt(i + 1)];\n        encoded3 = lookup[base64.charCodeAt(i + 2)];\n        encoded4 = lookup[base64.charCodeAt(i + 3)];\n        bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);\n        bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);\n        bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);\n    }\n    return arraybuffer;\n};\n\nexport { decode, encode };\n//# sourceMappingURL=base64-arraybuffer.es5.js.map\n","import { arr2hex, hex2arr, alphabet } from './util.js'\r\nimport { decode, encode } from 'base64-arraybuffer'\r\n\r\nconst decoder = new TextDecoder()\r\n// 50% slower at < 48 chars, but little impact at 4M OPS/s vs 8M OPS/s\r\nexport const arr2text = (data, enc) => {\r\n  if (!enc) return decoder.decode(data)\r\n  const dec = new TextDecoder(enc)\r\n  return dec.decode(data)\r\n}\r\n\r\n// sacrifice ~20% speed for bundle size\r\nconst encoder = new TextEncoder()\r\nexport const text2arr = str => encoder.encode(str)\r\n\r\nexport const arr2base = data => encode(data)\r\n\r\nexport const base2arr = str => new Uint8Array(decode(str))\r\n\r\nexport const bin2hex = str => {\r\n  let res = ''\r\n  let c\r\n  let i = 0\r\n  const len = str.length\r\n\r\n  while (i < len) {\r\n    c = str.charCodeAt(i++)\r\n    res += alphabet[c >> 4] + alphabet[c & 0xF]\r\n  }\r\n\r\n  return res\r\n}\r\n\r\nconst MAX_ARGUMENTS_LENGTH = 0x10000\r\nexport const hex2bin = hex => {\r\n  const points = hex2arr(hex)\r\n  if (points.length <= MAX_ARGUMENTS_LENGTH) return String.fromCharCode(...points)\r\n\r\n  let res = ''\r\n  let i = 0\r\n  while (i < points.length) {\r\n    res += String.fromCharCode(...points.subarray(i, i += MAX_ARGUMENTS_LENGTH))\r\n  }\r\n  return res\r\n}\r\n\r\nconst scope = typeof window !== 'undefined' ? window : self\r\nconst crypto = scope.crypto || scope.msCrypto || {}\r\nconst subtle = crypto.subtle || crypto.webkitSubtle\r\n\r\nconst formatMap = {\r\n  hex: arr2hex,\r\n  base64: arr2base\r\n}\r\n\r\nexport const hash = async (data, format, algo = 'sha-1') => {\r\n  if (!subtle) throw new Error('no web crypto support')\r\n  if (typeof data === 'string') data = text2arr(data)\r\n  const out = new Uint8Array(await subtle.digest(algo, data))\r\n  return format ? formatMap[format](out) : out\r\n}\r\n\r\nexport const randomBytes = size => {\r\n  const view = new Uint8Array(size)\r\n  return crypto.getRandomValues(view)\r\n}\r\n\r\nexport * from './util.js'\r\n","/*! simple-peer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */\r\nimport debug from 'debug'\r\nimport getBrowserRTC from 'get-browser-rtc'\r\nimport { Duplex } from 'streamx'\r\nimport queueMicrotask from 'queue-microtask' // TODO: remove when Node 10 is not supported\r\nimport errCode from 'err-code'\r\nimport { randomBytes, arr2hex, text2arr } from 'uint8-util'\r\n\r\nconst Debug = debug('simple-peer')\r\n\r\nconst MAX_BUFFERED_AMOUNT = 64 * 1024\r\nconst ICECOMPLETE_TIMEOUT = 5 * 1000\r\nconst CHANNEL_CLOSING_TIMEOUT = 5 * 1000\r\n\r\n// HACK: Filter trickle lines when trickle is disabled #354\r\nfunction filterTrickle (sdp) {\r\n  return sdp.replace(/a=ice-options:trickle\\s\\n/g, '')\r\n}\r\n\r\nfunction warn (message) {\r\n  console.warn(message)\r\n}\r\n\r\n/**\r\n * WebRTC peer connection. Same API as node core `net.Socket`, plus a few extra methods.\r\n * Duplex stream.\r\n * @param {Object} opts\r\n */\r\nclass Peer extends Duplex {\r\n  constructor (opts) {\r\n    opts = Object.assign({\r\n      allowHalfOpen: false\r\n    }, opts)\r\n\r\n    super(opts)\r\n\r\n    this.__objectMode = !!opts.objectMode // streamx is objectMode by default, so implement readable's fuctionality\r\n\r\n    this._id = arr2hex(randomBytes(4)).slice(0, 7)\r\n    this._debug('new peer %o', opts)\r\n\r\n    this.channelName = opts.initiator\r\n      ? opts.channelName || arr2hex(randomBytes(20))\r\n      : null\r\n\r\n    this.initiator = opts.initiator || false\r\n    this.channelConfig = opts.channelConfig || Peer.channelConfig\r\n    this.channelNegotiated = this.channelConfig.negotiated\r\n    this.config = Object.assign({}, Peer.config, opts.config)\r\n    this.offerOptions = opts.offerOptions || {}\r\n    this.answerOptions = opts.answerOptions || {}\r\n    this.sdpTransform = opts.sdpTransform || (sdp => sdp)\r\n    this.trickle = opts.trickle !== undefined ? opts.trickle : true\r\n    this.allowHalfTrickle = opts.allowHalfTrickle !== undefined ? opts.allowHalfTrickle : false\r\n    this.iceCompleteTimeout = opts.iceCompleteTimeout || ICECOMPLETE_TIMEOUT\r\n\r\n    this._destroying = false\r\n    this._connected = false\r\n\r\n    this.remoteAddress = undefined\r\n    this.remoteFamily = undefined\r\n    this.remotePort = undefined\r\n    this.localAddress = undefined\r\n    this.localFamily = undefined\r\n    this.localPort = undefined\r\n\r\n    this._wrtc = (opts.wrtc && typeof opts.wrtc === 'object')\r\n      ? opts.wrtc\r\n      : getBrowserRTC()\r\n\r\n    if (!this._wrtc) {\r\n      if (typeof window === 'undefined') {\r\n        throw errCode(new Error('No WebRTC support: Specify `opts.wrtc` option in this environment'), 'ERR_WEBRTC_SUPPORT')\r\n      } else {\r\n        throw errCode(new Error('No WebRTC support: Not a supported browser'), 'ERR_WEBRTC_SUPPORT')\r\n      }\r\n    }\r\n\r\n    this._pcReady = false\r\n    this._channelReady = false\r\n    this._iceComplete = false // ice candidate trickle done (got null candidate)\r\n    this._iceCompleteTimer = null // send an offer/answer anyway after some timeout\r\n    this._channel = null\r\n    this._pendingCandidates = []\r\n\r\n    this._isNegotiating = false // is this peer waiting for negotiation to complete?\r\n    this._firstNegotiation = true\r\n    this._batchedNegotiation = false // batch synchronous negotiations\r\n    this._queuedNegotiation = false // is there a queued negotiation request?\r\n    this._sendersAwaitingStable = []\r\n    this._closingInterval = null\r\n\r\n    this._remoteTracks = []\r\n    this._remoteStreams = []\r\n\r\n    this._chunk = null\r\n    this._cb = null\r\n    this._interval = null\r\n\r\n    try {\r\n      this._pc = new (this._wrtc.RTCPeerConnection)(this.config)\r\n    } catch (err) {\r\n      this.__destroy(errCode(err, 'ERR_PC_CONSTRUCTOR'))\r\n      return\r\n    }\r\n\r\n    // We prefer feature detection whenever possible, but sometimes that's not\r\n    // possible for certain implementations.\r\n    this._isReactNativeWebrtc = typeof this._pc._peerConnectionId === 'number'\r\n\r\n    this._pc.oniceconnectionstatechange = () => {\r\n      this._onIceStateChange()\r\n    }\r\n    this._pc.onicegatheringstatechange = () => {\r\n      this._onIceStateChange()\r\n    }\r\n    this._pc.onconnectionstatechange = () => {\r\n      this._onConnectionStateChange()\r\n    }\r\n    this._pc.onsignalingstatechange = () => {\r\n      this._onSignalingStateChange()\r\n    }\r\n    this._pc.onicecandidate = event => {\r\n      this._onIceCandidate(event)\r\n    }\r\n\r\n    // HACK: Fix for odd Firefox behavior, see: https://github.com/feross/simple-peer/pull/783\r\n    if (typeof this._pc.peerIdentity === 'object') {\r\n      this._pc.peerIdentity.catch(err => {\r\n        this.__destroy(errCode(err, 'ERR_PC_PEER_IDENTITY'))\r\n      })\r\n    }\r\n\r\n    // Other spec events, unused by this implementation:\r\n    // - onconnectionstatechange\r\n    // - onicecandidateerror\r\n    // - onfingerprintfailure\r\n    // - onnegotiationneeded\r\n\r\n    if (this.initiator || this.channelNegotiated) {\r\n      this._setupData({\r\n        channel: this._pc.createDataChannel(this.channelName, this.channelConfig)\r\n      })\r\n    } else {\r\n      this._pc.ondatachannel = event => {\r\n        this._setupData(event)\r\n      }\r\n    }\r\n\r\n    this._debug('initial negotiation')\r\n    this._needsNegotiation()\r\n\r\n    this._onFinishBound = () => {\r\n      this._onFinish()\r\n    }\r\n    this.once('finish', this._onFinishBound)\r\n  }\r\n\r\n  get bufferSize () {\r\n    return (this._channel && this._channel.bufferedAmount) || 0\r\n  }\r\n\r\n  // HACK: it's possible channel.readyState is \"closing\" before peer.destroy() fires\r\n  // https://bugs.chromium.org/p/chromium/issues/detail?id=882743\r\n  get connected () {\r\n    return (this._connected && this._channel.readyState === 'open')\r\n  }\r\n\r\n  address () {\r\n    return { port: this.localPort, family: this.localFamily, address: this.localAddress }\r\n  }\r\n\r\n  signal (data) {\r\n    if (this._destroying) return\r\n    if (this.destroyed) throw errCode(new Error('cannot signal after peer is destroyed'), 'ERR_DESTROYED')\r\n    if (typeof data === 'string') {\r\n      try {\r\n        data = JSON.parse(data)\r\n      } catch (err) {\r\n        data = {}\r\n      }\r\n    }\r\n    this._debug('signal()')\r\n\r\n    if (data.renegotiate && this.initiator) {\r\n      this._debug('got request to renegotiate')\r\n      this._needsNegotiation()\r\n    }\r\n    if (data.transceiverRequest && this.initiator) {\r\n      this._debug('got request for transceiver')\r\n      this.addTransceiver(data.transceiverRequest.kind, data.transceiverRequest.init)\r\n    }\r\n    if (data.candidate) {\r\n      if (this._pc.remoteDescription && this._pc.remoteDescription.type) {\r\n        this._addIceCandidate(data.candidate)\r\n      } else {\r\n        this._pendingCandidates.push(data.candidate)\r\n      }\r\n    }\r\n    if (data.sdp) {\r\n      this._pc.setRemoteDescription(new (this._wrtc.RTCSessionDescription)(data))\r\n        .then(() => {\r\n          if (this.destroyed) return\r\n\r\n          this._pendingCandidates.forEach(candidate => {\r\n            this._addIceCandidate(candidate)\r\n          })\r\n          this._pendingCandidates = []\r\n\r\n          if (this._pc.remoteDescription.type === 'offer') this._createAnswer()\r\n        })\r\n        .catch(err => {\r\n          this.__destroy(errCode(err, 'ERR_SET_REMOTE_DESCRIPTION'))\r\n        })\r\n    }\r\n    if (!data.sdp && !data.candidate && !data.renegotiate && !data.transceiverRequest) {\r\n      this.__destroy(errCode(new Error('signal() called with invalid signal data'), 'ERR_SIGNALING'))\r\n    }\r\n  }\r\n\r\n  _addIceCandidate (candidate) {\r\n    const iceCandidateObj = new this._wrtc.RTCIceCandidate(candidate)\r\n    this._pc.addIceCandidate(iceCandidateObj)\r\n      .catch(err => {\r\n        if (!iceCandidateObj.address || iceCandidateObj.address.endsWith('.local')) {\r\n          warn('Ignoring unsupported ICE candidate.')\r\n        } else {\r\n          this.__destroy(errCode(err, 'ERR_ADD_ICE_CANDIDATE'))\r\n        }\r\n      })\r\n  }\r\n\r\n  /**\r\n   * Send text/binary data to the remote peer.\r\n   * @param {ArrayBufferView|ArrayBuffer|Uint8Array|string|Blob} chunk\r\n   */\r\n  send (chunk) {\r\n    if (this._destroying) return\r\n    if (this.destroyed) throw errCode(new Error('cannot send after peer is destroyed'), 'ERR_DESTROYED')\r\n    this._channel.send(chunk)\r\n  }\r\n\r\n  _needsNegotiation () {\r\n    this._debug('_needsNegotiation')\r\n    if (this._batchedNegotiation) return // batch synchronous renegotiations\r\n    this._batchedNegotiation = true\r\n    queueMicrotask(() => {\r\n      this._batchedNegotiation = false\r\n      if (this.initiator || !this._firstNegotiation) {\r\n        this._debug('starting batched negotiation')\r\n        this.negotiate()\r\n      } else {\r\n        this._debug('non-initiator initial negotiation request discarded')\r\n      }\r\n      this._firstNegotiation = false\r\n    })\r\n  }\r\n\r\n  negotiate () {\r\n    if (this._destroying) return\r\n    if (this.destroyed) throw errCode(new Error('cannot negotiate after peer is destroyed'), 'ERR_DESTROYED')\r\n\r\n    if (this.initiator) {\r\n      if (this._isNegotiating) {\r\n        this._queuedNegotiation = true\r\n        this._debug('already negotiating, queueing')\r\n      } else {\r\n        this._debug('start negotiation')\r\n        setTimeout(() => { // HACK: Chrome crashes if we immediately call createOffer\r\n          this._createOffer()\r\n        }, 0)\r\n      }\r\n    } else {\r\n      if (this._isNegotiating) {\r\n        this._queuedNegotiation = true\r\n        this._debug('already negotiating, queueing')\r\n      } else {\r\n        this._debug('requesting negotiation from initiator')\r\n        this.emit('signal', { // request initiator to renegotiate\r\n          type: 'renegotiate',\r\n          renegotiate: true\r\n        })\r\n      }\r\n    }\r\n    this._isNegotiating = true\r\n  }\r\n\r\n  _final (cb) {\r\n    if (!this._readableState.ended) this.push(null)\r\n    cb(null)\r\n  }\r\n\r\n  __destroy (err) {\r\n    this.end()\r\n    this._destroy(() => {}, err)\r\n  }\r\n\r\n  _destroy (cb, err) {\r\n    if (this.destroyed || this._destroying) return\r\n    this._destroying = true\r\n\r\n    this._debug('destroying (error: %s)', err && (err.message || err))\r\n\r\n    setTimeout(() => { // allow events concurrent with the call to _destroy() to fire (see #692)\r\n      this._connected = false\r\n      this._pcReady = false\r\n      this._channelReady = false\r\n      this._remoteTracks = null\r\n      this._remoteStreams = null\r\n      this._senderMap = null\r\n\r\n      clearInterval(this._closingInterval)\r\n      this._closingInterval = null\r\n\r\n      clearInterval(this._interval)\r\n      this._interval = null\r\n      this._chunk = null\r\n      this._cb = null\r\n\r\n      if (this._onFinishBound) this.removeListener('finish', this._onFinishBound)\r\n      this._onFinishBound = null\r\n\r\n      if (this._channel) {\r\n        try {\r\n          this._channel.close()\r\n        } catch (err) {}\r\n\r\n        // allow events concurrent with destruction to be handled\r\n        this._channel.onmessage = null\r\n        this._channel.onopen = null\r\n        this._channel.onclose = null\r\n        this._channel.onerror = null\r\n      }\r\n      if (this._pc) {\r\n        try {\r\n          this._pc.close()\r\n        } catch (err) {}\r\n\r\n        // allow events concurrent with destruction to be handled\r\n        this._pc.oniceconnectionstatechange = null\r\n        this._pc.onicegatheringstatechange = null\r\n        this._pc.onsignalingstatechange = null\r\n        this._pc.onicecandidate = null\r\n        this._pc.ontrack = null\r\n        this._pc.ondatachannel = null\r\n      }\r\n      this._pc = null\r\n      this._channel = null\r\n      if (err) this.emit('error', err)\r\n      cb()\r\n    }, 0)\r\n  }\r\n\r\n  _setupData (event) {\r\n    if (!event.channel) {\r\n      // In some situations `pc.createDataChannel()` returns `undefined` (in wrtc),\r\n      // which is invalid behavior. Handle it gracefully.\r\n      // See: https://github.com/feross/simple-peer/issues/163\r\n      return this.__destroy(errCode(new Error('Data channel event is missing `channel` property'), 'ERR_DATA_CHANNEL'))\r\n    }\r\n\r\n    this._channel = event.channel\r\n    this._channel.binaryType = 'arraybuffer'\r\n\r\n    if (typeof this._channel.bufferedAmountLowThreshold === 'number') {\r\n      this._channel.bufferedAmountLowThreshold = MAX_BUFFERED_AMOUNT\r\n    }\r\n\r\n    this.channelName = this._channel.label\r\n\r\n    this._channel.onmessage = event => {\r\n      this._onChannelMessage(event)\r\n    }\r\n    this._channel.onbufferedamountlow = () => {\r\n      this._onChannelBufferedAmountLow()\r\n    }\r\n    this._channel.onopen = () => {\r\n      this._onChannelOpen()\r\n    }\r\n    this._channel.onclose = () => {\r\n      this._onChannelClose()\r\n    }\r\n    this._channel.onerror = event => {\r\n      const err = event.error instanceof Error\r\n        ? event.error\r\n        : new Error(`Datachannel error: ${event.message} ${event.filename}:${event.lineno}:${event.colno}`)\r\n      this.__destroy(errCode(err, 'ERR_DATA_CHANNEL'))\r\n    }\r\n\r\n    // HACK: Chrome will sometimes get stuck in readyState \"closing\", let's check for this condition\r\n    // https://bugs.chromium.org/p/chromium/issues/detail?id=882743\r\n    let isClosing = false\r\n    this._closingInterval = setInterval(() => { // No \"onclosing\" event\r\n      if (this._channel && this._channel.readyState === 'closing') {\r\n        if (isClosing) this._onChannelClose() // closing timed out: equivalent to onclose firing\r\n        isClosing = true\r\n      } else {\r\n        isClosing = false\r\n      }\r\n    }, CHANNEL_CLOSING_TIMEOUT)\r\n  }\r\n\r\n  _write (chunk, cb) {\r\n    if (this.destroyed) return cb(errCode(new Error('cannot write after peer is destroyed'), 'ERR_DATA_CHANNEL'))\r\n\r\n    if (this._connected) {\r\n      try {\r\n        this.send(chunk)\r\n      } catch (err) {\r\n        return this.__destroy(errCode(err, 'ERR_DATA_CHANNEL'))\r\n      }\r\n      if (this._channel.bufferedAmount > MAX_BUFFERED_AMOUNT) {\r\n        this._debug('start backpressure: bufferedAmount %d', this._channel.bufferedAmount)\r\n        this._cb = cb\r\n      } else {\r\n        cb(null)\r\n      }\r\n    } else {\r\n      this._debug('write before connect')\r\n      this._chunk = chunk\r\n      this._cb = cb\r\n    }\r\n  }\r\n\r\n  // When stream finishes writing, close socket. Half open connections are not\r\n  // supported.\r\n  _onFinish () {\r\n    if (this.destroyed) return\r\n\r\n    // Wait a bit before destroying so the socket flushes.\r\n    // TODO: is there a more reliable way to accomplish this?\r\n    const destroySoon = () => {\r\n      setTimeout(() => this.__destroy(), 1000)\r\n    }\r\n\r\n    if (this._connected) {\r\n      destroySoon()\r\n    } else {\r\n      this.once('connect', destroySoon)\r\n    }\r\n  }\r\n\r\n  _startIceCompleteTimeout () {\r\n    if (this.destroyed) return\r\n    if (this._iceCompleteTimer) return\r\n    this._debug('started iceComplete timeout')\r\n    this._iceCompleteTimer = setTimeout(() => {\r\n      if (!this._iceComplete) {\r\n        this._iceComplete = true\r\n        this._debug('iceComplete timeout completed')\r\n        this.emit('iceTimeout')\r\n        this.emit('_iceComplete')\r\n      }\r\n    }, this.iceCompleteTimeout)\r\n  }\r\n\r\n  _createOffer () {\r\n    if (this.destroyed) return\r\n\r\n    this._pc.createOffer(this.offerOptions)\r\n      .then(offer => {\r\n        if (this.destroyed) return\r\n        if (!this.trickle && !this.allowHalfTrickle) offer.sdp = filterTrickle(offer.sdp)\r\n        offer.sdp = this.sdpTransform(offer.sdp)\r\n\r\n        const sendOffer = () => {\r\n          if (this.destroyed) return\r\n          const signal = this._pc.localDescription || offer\r\n          this._debug('signal')\r\n          this.emit('signal', {\r\n            type: signal.type,\r\n            sdp: signal.sdp\r\n          })\r\n        }\r\n\r\n        const onSuccess = () => {\r\n          this._debug('createOffer success')\r\n          if (this.destroyed) return\r\n          if (this.trickle || this._iceComplete) sendOffer()\r\n          else this.once('_iceComplete', sendOffer) // wait for candidates\r\n        }\r\n\r\n        const onError = err => {\r\n          this.__destroy(errCode(err, 'ERR_SET_LOCAL_DESCRIPTION'))\r\n        }\r\n\r\n        this._pc.setLocalDescription(offer)\r\n          .then(onSuccess)\r\n          .catch(onError)\r\n      })\r\n      .catch(err => {\r\n        this.__destroy(errCode(err, 'ERR_CREATE_OFFER'))\r\n      })\r\n  }\r\n\r\n  _createAnswer () {\r\n    if (this.destroyed) return\r\n\r\n    this._pc.createAnswer(this.answerOptions)\r\n      .then(answer => {\r\n        if (this.destroyed) return\r\n        if (!this.trickle && !this.allowHalfTrickle) answer.sdp = filterTrickle(answer.sdp)\r\n        answer.sdp = this.sdpTransform(answer.sdp)\r\n\r\n        const sendAnswer = () => {\r\n          if (this.destroyed) return\r\n          const signal = this._pc.localDescription || answer\r\n          this._debug('signal')\r\n          this.emit('signal', {\r\n            type: signal.type,\r\n            sdp: signal.sdp\r\n          })\r\n          if (!this.initiator) this._requestMissingTransceivers?.()\r\n        }\r\n\r\n        const onSuccess = () => {\r\n          if (this.destroyed) return\r\n          if (this.trickle || this._iceComplete) sendAnswer()\r\n          else this.once('_iceComplete', sendAnswer)\r\n        }\r\n\r\n        const onError = err => {\r\n          this.__destroy(errCode(err, 'ERR_SET_LOCAL_DESCRIPTION'))\r\n        }\r\n\r\n        this._pc.setLocalDescription(answer)\r\n          .then(onSuccess)\r\n          .catch(onError)\r\n      })\r\n      .catch(err => {\r\n        this.__destroy(errCode(err, 'ERR_CREATE_ANSWER'))\r\n      })\r\n  }\r\n\r\n  _onConnectionStateChange () {\r\n    if (this.destroyed || this._destroying) return\r\n    if (this._pc.connectionState === 'failed') {\r\n      this.__destroy(errCode(new Error('Connection failed.'), 'ERR_CONNECTION_FAILURE'))\r\n    }\r\n  }\r\n\r\n  _onIceStateChange () {\r\n    if (this.destroyed) return\r\n    const iceConnectionState = this._pc.iceConnectionState\r\n    const iceGatheringState = this._pc.iceGatheringState\r\n\r\n    this._debug(\r\n      'iceStateChange (connection: %s) (gathering: %s)',\r\n      iceConnectionState,\r\n      iceGatheringState\r\n    )\r\n    this.emit('iceStateChange', iceConnectionState, iceGatheringState)\r\n\r\n    if (iceConnectionState === 'connected' || iceConnectionState === 'completed') {\r\n      this._pcReady = true\r\n      this._maybeReady()\r\n    }\r\n    if (iceConnectionState === 'failed') {\r\n      this.__destroy(errCode(new Error('Ice connection failed.'), 'ERR_ICE_CONNECTION_FAILURE'))\r\n    }\r\n    if (iceConnectionState === 'closed') {\r\n      this.__destroy(errCode(new Error('Ice connection closed.'), 'ERR_ICE_CONNECTION_CLOSED'))\r\n    }\r\n  }\r\n\r\n  getStats (cb) {\r\n    // statreports can come with a value array instead of properties\r\n    const flattenValues = report => {\r\n      if (Object.prototype.toString.call(report.values) === '[object Array]') {\r\n        report.values.forEach(value => {\r\n          Object.assign(report, value)\r\n        })\r\n      }\r\n      return report\r\n    }\r\n\r\n    // Promise-based getStats() (standard)\r\n    if (this._pc.getStats.length === 0 || this._isReactNativeWebrtc) {\r\n      this._pc.getStats()\r\n        .then(res => {\r\n          const reports = []\r\n          res.forEach(report => {\r\n            reports.push(flattenValues(report))\r\n          })\r\n          cb(null, reports)\r\n        }, err => cb(err))\r\n\r\n    // Single-parameter callback-based getStats() (non-standard)\r\n    } else if (this._pc.getStats.length > 0) {\r\n      this._pc.getStats(res => {\r\n        // If we destroy connection in `connect` callback this code might happen to run when actual connection is already closed\r\n        if (this.destroyed) return\r\n\r\n        const reports = []\r\n        res.result().forEach(result => {\r\n          const report = {}\r\n          result.names().forEach(name => {\r\n            report[name] = result.stat(name)\r\n          })\r\n          report.id = result.id\r\n          report.type = result.type\r\n          report.timestamp = result.timestamp\r\n          reports.push(flattenValues(report))\r\n        })\r\n        cb(null, reports)\r\n      }, err => cb(err))\r\n\r\n    // Unknown browser, skip getStats() since it's anyone's guess which style of\r\n    // getStats() they implement.\r\n    } else {\r\n      cb(null, [])\r\n    }\r\n  }\r\n\r\n  _maybeReady () {\r\n    this._debug('maybeReady pc %s channel %s', this._pcReady, this._channelReady)\r\n    if (this._connected || this._connecting || !this._pcReady || !this._channelReady) return\r\n\r\n    this._connecting = true\r\n\r\n    // HACK: We can't rely on order here, for details see https://github.com/js-platform/node-webrtc/issues/339\r\n    const findCandidatePair = () => {\r\n      if (this.destroyed || this._destroying) return\r\n\r\n      this.getStats((err, items) => {\r\n        if (this.destroyed || this._destroying) return\r\n\r\n        // Treat getStats error as non-fatal. It's not essential.\r\n        if (err) items = []\r\n\r\n        const remoteCandidates = {}\r\n        const localCandidates = {}\r\n        const candidatePairs = {}\r\n        let foundSelectedCandidatePair = false\r\n\r\n        items.forEach(item => {\r\n          // TODO: Once all browsers support the hyphenated stats report types, remove\r\n          // the non-hypenated ones\r\n          if (item.type === 'remotecandidate' || item.type === 'remote-candidate') {\r\n            remoteCandidates[item.id] = item\r\n          }\r\n          if (item.type === 'localcandidate' || item.type === 'local-candidate') {\r\n            localCandidates[item.id] = item\r\n          }\r\n          if (item.type === 'candidatepair' || item.type === 'candidate-pair') {\r\n            candidatePairs[item.id] = item\r\n          }\r\n        })\r\n\r\n        const setSelectedCandidatePair = selectedCandidatePair => {\r\n          foundSelectedCandidatePair = true\r\n\r\n          let local = localCandidates[selectedCandidatePair.localCandidateId]\r\n\r\n          if (local && (local.ip || local.address)) {\r\n            // Spec\r\n            this.localAddress = local.ip || local.address\r\n            this.localPort = Number(local.port)\r\n          } else if (local && local.ipAddress) {\r\n            // Firefox\r\n            this.localAddress = local.ipAddress\r\n            this.localPort = Number(local.portNumber)\r\n          } else if (typeof selectedCandidatePair.googLocalAddress === 'string') {\r\n            // TODO: remove this once Chrome 58 is released\r\n            local = selectedCandidatePair.googLocalAddress.split(':')\r\n            this.localAddress = local[0]\r\n            this.localPort = Number(local[1])\r\n          }\r\n          if (this.localAddress) {\r\n            this.localFamily = this.localAddress.includes(':') ? 'IPv6' : 'IPv4'\r\n          }\r\n\r\n          let remote = remoteCandidates[selectedCandidatePair.remoteCandidateId]\r\n\r\n          if (remote && (remote.ip || remote.address)) {\r\n            // Spec\r\n            this.remoteAddress = remote.ip || remote.address\r\n            this.remotePort = Number(remote.port)\r\n          } else if (remote && remote.ipAddress) {\r\n            // Firefox\r\n            this.remoteAddress = remote.ipAddress\r\n            this.remotePort = Number(remote.portNumber)\r\n          } else if (typeof selectedCandidatePair.googRemoteAddress === 'string') {\r\n            // TODO: remove this once Chrome 58 is released\r\n            remote = selectedCandidatePair.googRemoteAddress.split(':')\r\n            this.remoteAddress = remote[0]\r\n            this.remotePort = Number(remote[1])\r\n          }\r\n          if (this.remoteAddress) {\r\n            this.remoteFamily = this.remoteAddress.includes(':') ? 'IPv6' : 'IPv4'\r\n          }\r\n\r\n          this._debug(\r\n            'connect local: %s:%s remote: %s:%s',\r\n            this.localAddress,\r\n            this.localPort,\r\n            this.remoteAddress,\r\n            this.remotePort\r\n          )\r\n        }\r\n\r\n        items.forEach(item => {\r\n          // Spec-compliant\r\n          if (item.type === 'transport' && item.selectedCandidatePairId) {\r\n            setSelectedCandidatePair(candidatePairs[item.selectedCandidatePairId])\r\n          }\r\n\r\n          // Old implementations\r\n          if (\r\n            (item.type === 'googCandidatePair' && item.googActiveConnection === 'true') ||\r\n            ((item.type === 'candidatepair' || item.type === 'candidate-pair') && item.selected)\r\n          ) {\r\n            setSelectedCandidatePair(item)\r\n          }\r\n        })\r\n\r\n        // Ignore candidate pair selection in browsers like Safari 11 that do not have any local or remote candidates\r\n        // But wait until at least 1 candidate pair is available\r\n        if (!foundSelectedCandidatePair && (!Object.keys(candidatePairs).length || Object.keys(localCandidates).length)) {\r\n          setTimeout(findCandidatePair, 100)\r\n          return\r\n        } else {\r\n          this._connecting = false\r\n          this._connected = true\r\n        }\r\n\r\n        if (this._chunk) {\r\n          try {\r\n            this.send(this._chunk)\r\n          } catch (err) {\r\n            return this.__destroy(errCode(err, 'ERR_DATA_CHANNEL'))\r\n          }\r\n          this._chunk = null\r\n          this._debug('sent chunk from \"write before connect\"')\r\n\r\n          const cb = this._cb\r\n          this._cb = null\r\n          cb(null)\r\n        }\r\n\r\n        // If `bufferedAmountLowThreshold` and 'onbufferedamountlow' are unsupported,\r\n        // fallback to using setInterval to implement backpressure.\r\n        if (typeof this._channel.bufferedAmountLowThreshold !== 'number') {\r\n          this._interval = setInterval(() => this._onInterval(), 150)\r\n          if (this._interval.unref) this._interval.unref()\r\n        }\r\n\r\n        this._debug('connect')\r\n        this.emit('connect')\r\n      })\r\n    }\r\n    findCandidatePair()\r\n  }\r\n\r\n  _onInterval () {\r\n    if (!this._cb || !this._channel || this._channel.bufferedAmount > MAX_BUFFERED_AMOUNT) {\r\n      return\r\n    }\r\n    this._onChannelBufferedAmountLow()\r\n  }\r\n\r\n  _onSignalingStateChange () {\r\n    if (this.destroyed) return\r\n\r\n    if (this._pc.signalingState === 'stable') {\r\n      this._isNegotiating = false\r\n\r\n      // HACK: Firefox doesn't yet support removing tracks when signalingState !== 'stable'\r\n      this._debug('flushing sender queue', this._sendersAwaitingStable)\r\n      this._sendersAwaitingStable.forEach(sender => {\r\n        this._pc.removeTrack(sender)\r\n        this._queuedNegotiation = true\r\n      })\r\n      this._sendersAwaitingStable = []\r\n\r\n      if (this._queuedNegotiation) {\r\n        this._debug('flushing negotiation queue')\r\n        this._queuedNegotiation = false\r\n        this._needsNegotiation() // negotiate again\r\n      } else {\r\n        this._debug('negotiated')\r\n        this.emit('negotiated')\r\n      }\r\n    }\r\n\r\n    this._debug('signalingStateChange %s', this._pc.signalingState)\r\n    this.emit('signalingStateChange', this._pc.signalingState)\r\n  }\r\n\r\n  _onIceCandidate (event) {\r\n    if (this.destroyed) return\r\n    if (event.candidate && this.trickle) {\r\n      this.emit('signal', {\r\n        type: 'candidate',\r\n        candidate: {\r\n          candidate: event.candidate.candidate,\r\n          sdpMLineIndex: event.candidate.sdpMLineIndex,\r\n          sdpMid: event.candidate.sdpMid\r\n        }\r\n      })\r\n    } else if (!event.candidate && !this._iceComplete) {\r\n      this._iceComplete = true\r\n      this.emit('_iceComplete')\r\n    }\r\n    // as soon as we've received one valid candidate start timeout\r\n    if (event.candidate) {\r\n      this._startIceCompleteTimeout()\r\n    }\r\n  }\r\n\r\n  _onChannelMessage (event) {\r\n    if (this.destroyed) return\r\n    let data = event.data\r\n    if (data instanceof ArrayBuffer) {\r\n      data = new Uint8Array(data)\r\n    } else if (this.__objectMode === false) {\r\n      data = text2arr(data)\r\n    }\r\n    this.push(data)\r\n  }\r\n\r\n  _onChannelBufferedAmountLow () {\r\n    if (this.destroyed || !this._cb) return\r\n    this._debug('ending backpressure: bufferedAmount %d', this._channel.bufferedAmount)\r\n    const cb = this._cb\r\n    this._cb = null\r\n    cb(null)\r\n  }\r\n\r\n  _onChannelOpen () {\r\n    if (this._connected || this.destroyed) return\r\n    this._debug('on channel open')\r\n    this._channelReady = true\r\n    this._maybeReady()\r\n  }\r\n\r\n  _onChannelClose () {\r\n    if (this.destroyed) return\r\n    this._debug('on channel close')\r\n    this.__destroy()\r\n  }\r\n\r\n  _debug () {\r\n    const args = [].slice.call(arguments)\r\n    args[0] = '[' + this._id + '] ' + args[0]\r\n    Debug.apply(null, args)\r\n  }\r\n}\r\n\r\nPeer.WEBRTC_SUPPORT = !!getBrowserRTC()\r\n\r\n/**\r\n * Expose peer and data channel config for overriding all Peer\r\n * instances. Otherwise, just set opts.config or opts.channelConfig\r\n * when constructing a Peer.\r\n */\r\nPeer.config = {\r\n  iceServers: [\r\n    {\r\n      urls: [\r\n        'stun:stun.l.google.com:19302',\r\n        'stun:global.stun.twilio.com:3478'\r\n      ]\r\n    }\r\n  ],\r\n  sdpSemantics: 'unified-plan'\r\n}\r\n\r\nPeer.channelConfig = {}\r\n\r\nexport default Peer\r\n","/**\n * Functions/constants needed by both the client and server.\n */\nimport * as common from './common-node.js'\nexport * from './common-node.js'\n\nexport const DEFAULT_ANNOUNCE_PEERS = 50\nexport const MAX_ANNOUNCE_PEERS = 82\n\n// HACK: Fix for WHATWG URL object not parsing non-standard URL schemes like\n// 'udp:'. Just replace it with 'http:' since we only need a few properties.\n//\n// Note: Only affects Chrome and Firefox. Works fine in Node.js, Safari, and\n// Edge.\n//\n// Note: UDP trackers aren't used in the normal browser build, but they are\n// used in a Chrome App build (i.e. by Brave Browser).\n//\n// Bug reports:\n// - Chrome: https://bugs.chromium.org/p/chromium/issues/detail?id=734880\n// - Firefox: https://bugzilla.mozilla.org/show_bug.cgi?id=1374505\nexport const parseUrl = str => {\n  const url = new URL(str.replace(/^udp:/, 'http:'))\n\n  if (str.match(/^udp:/)) {\n    Object.defineProperties(url, {\n      href: { value: url.href.replace(/^http/, 'udp') },\n      protocol: { value: url.protocol.replace(/^http/, 'udp') },\n      origin: { value: url.origin.replace(/^http/, 'udp') }\n    })\n  }\n\n  return url\n}\n\nexport default {\n  DEFAULT_ANNOUNCE_PEERS,\n  MAX_ANNOUNCE_PEERS,\n  parseUrl,\n  ...common\n}\n","/*! simple-websocket. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */\r\n/* global WebSocket */\r\n\r\nimport Debug from 'debug'\r\nimport queueMicrotask from 'queue-microtask' // TODO: remove when Node 10 is not supported\r\nimport ws from 'ws' // websockets in node - will be empty object in browser\r\nimport { Duplex } from 'streamx'\r\nimport { text2arr, randomBytes, arr2hex } from 'uint8-util'\r\n\r\nconst debug = Debug('simple-websocket')\r\n\r\nconst _WebSocket = typeof ws !== 'function' ? WebSocket : ws\r\n\r\nconst MAX_BUFFERED_AMOUNT = 64 * 1024\r\n\r\n/**\r\n * WebSocket. Same API as node core `net.Socket`. Duplex stream.\r\n * @param {Object} opts\r\n * @param {string=} opts.url websocket server url\r\n * @param {string=} opts.socket raw websocket instance to wrap\r\n */\r\nexport default class Socket extends Duplex {\r\n  constructor (opts = {}) {\r\n    // Support simple usage: `new Socket(url)`\r\n    if (typeof opts === 'string') {\r\n      opts = { url: opts }\r\n    }\r\n\r\n    opts = Object.assign({\r\n      allowHalfOpen: false\r\n    }, opts)\r\n\r\n    super(opts)\r\n\r\n    this.__objectMode = !!opts.objectMode // streamx is objectMode by default, so implement readable's fuctionality\r\n    if (opts.objectMode != null) delete opts.objectMode // causes error with ws...\r\n\r\n    if (opts.url == null && opts.socket == null) {\r\n      throw new Error('Missing required `url` or `socket` option')\r\n    }\r\n    if (opts.url != null && opts.socket != null) {\r\n      throw new Error('Must specify either `url` or `socket` option, not both')\r\n    }\r\n\r\n    this._id = arr2hex(randomBytes(4)).slice(0, 7)\r\n    this._debug('new websocket: %o', opts)\r\n\r\n    this.connected = false\r\n\r\n    this._chunk = null\r\n    this._cb = null\r\n    this._interval = null\r\n\r\n    if (opts.socket) {\r\n      this.url = opts.socket.url\r\n      this._ws = opts.socket\r\n      this.connected = opts.socket.readyState === _WebSocket.OPEN\r\n    } else {\r\n      this.url = opts.url\r\n      try {\r\n        if (typeof ws === 'function') {\r\n          // `ws` package accepts options\r\n          this._ws = new _WebSocket(opts.url, {\r\n            ...opts,\r\n            encoding: undefined // encoding option breaks ws internals\r\n          })\r\n        } else {\r\n          this._ws = new _WebSocket(opts.url)\r\n        }\r\n      } catch (err) {\r\n        queueMicrotask(() => this.destroy(err))\r\n        return\r\n      }\r\n    }\r\n\r\n    this._ws.binaryType = 'arraybuffer'\r\n\r\n    if (opts.socket && this.connected) {\r\n      queueMicrotask(() => this._handleOpen())\r\n    } else {\r\n      this._ws.onopen = () => this._handleOpen()\r\n    }\r\n\r\n    this._ws.onmessage = event => this._handleMessage(event)\r\n    this._ws.onclose = () => this._handleClose()\r\n    this._ws.onerror = err => this._handleError(err)\r\n\r\n    this._handleFinishBound = () => this._handleFinish()\r\n    this.once('finish', this._handleFinishBound)\r\n  }\r\n\r\n  /**\r\n   * Send text/binary data to the WebSocket server.\r\n   * @param {TypedArrayView|ArrayBuffer|Uint8Array|string|Blob|Object} chunk\r\n   */\r\n  send (chunk) {\r\n    this._ws.send(chunk)\r\n  }\r\n\r\n  _final (cb) {\r\n    if (!this._readableState.ended) this.push(null)\r\n    cb(null)\r\n  }\r\n\r\n  _destroy (cb) {\r\n    if (this.destroyed) return\r\n    if (!this._writableState.ended) this.end()\r\n\r\n    this.connected = false\r\n\r\n    clearInterval(this._interval)\r\n    this._interval = null\r\n    this._chunk = null\r\n    this._cb = null\r\n\r\n    if (this._handleFinishBound) {\r\n      this.removeListener('finish', this._handleFinishBound)\r\n    }\r\n    this._handleFinishBound = null\r\n\r\n    if (this._ws) {\r\n      const ws = this._ws\r\n      const onClose = () => {\r\n        ws.onclose = null\r\n      }\r\n      if (ws.readyState === _WebSocket.CLOSED) {\r\n        onClose()\r\n      } else {\r\n        try {\r\n          ws.onclose = onClose\r\n          ws.close()\r\n        } catch (err) {\r\n          onClose()\r\n        }\r\n      }\r\n\r\n      ws.onopen = null\r\n      ws.onmessage = null\r\n      ws.onerror = () => {}\r\n    }\r\n    this._ws = null\r\n\r\n    cb()\r\n  }\r\n\r\n  _write (chunk, cb) {\r\n    if (this.destroyed) return cb(new Error('cannot write after socket is destroyed'))\r\n\r\n    if (this.connected) {\r\n      try {\r\n        this.send(chunk)\r\n      } catch (err) {\r\n        return this.destroy(err)\r\n      }\r\n      if (typeof ws !== 'function' && this._ws.bufferedAmount > MAX_BUFFERED_AMOUNT) {\r\n        this._debug('start backpressure: bufferedAmount %d', this._ws.bufferedAmount)\r\n        this._cb = cb\r\n      } else {\r\n        cb(null)\r\n      }\r\n    } else {\r\n      this._debug('write before connect')\r\n      this._chunk = chunk\r\n      this._cb = cb\r\n    }\r\n  }\r\n\r\n  _handleOpen () {\r\n    if (this.connected || this.destroyed) return\r\n    this.connected = true\r\n\r\n    if (this._chunk) {\r\n      try {\r\n        this.send(this._chunk)\r\n      } catch (err) {\r\n        return this.destroy(err)\r\n      }\r\n      this._chunk = null\r\n      this._debug('sent chunk from \"write before connect\"')\r\n\r\n      const cb = this._cb\r\n      this._cb = null\r\n      cb(null)\r\n    }\r\n\r\n    // Backpressure is not implemented in Node.js. The `ws` module has a buggy\r\n    // `bufferedAmount` property. See: https://github.com/websockets/ws/issues/492\r\n    if (typeof ws !== 'function') {\r\n      this._interval = setInterval(() => this._onInterval(), 150)\r\n      if (this._interval.unref) this._interval.unref()\r\n    }\r\n\r\n    this._debug('connect')\r\n    this.emit('connect')\r\n  }\r\n\r\n  _handleMessage (event) {\r\n    if (this.destroyed) return\r\n    let data = event.data\r\n    if (data instanceof ArrayBuffer) data = new Uint8Array(data)\r\n    if (this.__objectMode === false) data = text2arr(data)\r\n    this.push(data)\r\n  }\r\n\r\n  _handleClose () {\r\n    if (this.destroyed) return\r\n    this._debug('on close')\r\n    this.destroy()\r\n  }\r\n\r\n  _handleError (_) {\r\n    this.destroy(new Error(`Error connecting to ${this.url}`))\r\n  }\r\n\r\n  // When stream finishes writing, close socket. Half open connections are not\r\n  // supported.\r\n  _handleFinish () {\r\n    if (this.destroyed) return\r\n\r\n    // Wait a bit before destroying so the socket flushes.\r\n    // TODO: is there a more reliable way to accomplish this?\r\n    const destroySoon = () => {\r\n      setTimeout(() => this.destroy(), 1000)\r\n    }\r\n\r\n    if (this.connected) {\r\n      destroySoon()\r\n    } else {\r\n      this.once('connect', destroySoon)\r\n    }\r\n  }\r\n\r\n  _onInterval () {\r\n    if (!this._cb || !this._ws || this._ws.bufferedAmount > MAX_BUFFERED_AMOUNT) {\r\n      return\r\n    }\r\n    this._debug('ending backpressure: bufferedAmount %d', this._ws.bufferedAmount)\r\n    const cb = this._cb\r\n    this._cb = null\r\n    cb(null)\r\n  }\r\n\r\n  _debug () {\r\n    const args = [].slice.call(arguments)\r\n    args[0] = '[' + this._id + '] ' + args[0]\r\n    debug.apply(null, args)\r\n  }\r\n}\r\n\r\nSocket.WEBSOCKET_SUPPORT = !!_WebSocket\r\n","import EventEmitter from 'events'\n\nclass Tracker extends EventEmitter {\n  constructor (client, announceUrl) {\n    super()\n\n    this.client = client\n    this.announceUrl = announceUrl\n\n    this.interval = null\n    this.destroyed = false\n  }\n\n  setInterval (intervalMs) {\n    if (intervalMs == null) intervalMs = this.DEFAULT_ANNOUNCE_INTERVAL\n\n    clearInterval(this.interval)\n\n    if (intervalMs) {\n      this.interval = setInterval(() => {\n        this.announce(this.client._defaultAnnounceOpts())\n      }, intervalMs)\n      if (this.interval.unref) this.interval.unref()\n    }\n  }\n}\n\nexport default Tracker\n","import clone from 'clone'\nimport Debug from 'debug'\nimport Peer from '@thaunknown/simple-peer/lite.js'\nimport Socket from '@thaunknown/simple-websocket'\nimport Socks from 'socks'\nimport { arr2text, arr2hex, hex2bin, bin2hex, randomBytes } from 'uint8-util'\n\nimport common from '../common.js'\nimport Tracker from './tracker.js'\n\nconst debug = Debug('bittorrent-tracker:websocket-tracker')\n\n// Use a socket pool, so tracker clients share WebSocket objects for the same server.\n// In practice, WebSockets are pretty slow to establish, so this gives a nice performance\n// boost, and saves browser resources.\nconst socketPool = {}\n\nconst RECONNECT_MINIMUM = 10 * 1000\nconst RECONNECT_MAXIMUM = 60 * 60 * 1000\nconst RECONNECT_VARIANCE = 5 * 60 * 1000\nconst OFFER_TIMEOUT = 50 * 1000\n\nclass WebSocketTracker extends Tracker {\n  constructor (client, announceUrl) {\n    super(client, announceUrl)\n    debug('new websocket tracker %s', announceUrl)\n\n    this.peers = {} // peers (offer id -> peer)\n    this.socket = null\n\n    this.reconnecting = false\n    this.retries = 0\n    this.reconnectTimer = null\n\n    // Simple boolean flag to track whether the socket has received data from\n    // the websocket server since the last time socket.send() was called.\n    this.expectingResponse = false\n\n    this._openSocket()\n  }\n\n  announce (opts) {\n    if (this.destroyed || this.reconnecting) return\n    if (!this.socket.connected) {\n      this.socket.once('connect', () => {\n        this.announce(opts)\n      })\n      return\n    }\n\n    const params = Object.assign({}, opts, {\n      action: 'announce',\n      info_hash: this.client._infoHashBinary,\n      peer_id: this.client._peerIdBinary\n    })\n    if (this._trackerId) params.trackerid = this._trackerId\n\n    if (opts.event === 'stopped' || opts.event === 'completed') {\n      // Don't include offers with 'stopped' or 'completed' event\n      this._send(params)\n    } else {\n      // Limit the number of offers that are generated, since it can be slow\n      const numwant = Math.min(opts.numwant, 5)\n\n      this._generateOffers(numwant, offers => {\n        params.numwant = numwant\n        params.offers = offers\n        this._send(params)\n      })\n    }\n  }\n\n  scrape (opts) {\n    if (this.destroyed || this.reconnecting) return\n    if (!this.socket.connected) {\n      this.socket.once('connect', () => {\n        this.scrape(opts)\n      })\n      return\n    }\n\n    const infoHashes = (Array.isArray(opts.infoHash) && opts.infoHash.length > 0)\n      ? opts.infoHash.map(infoHash => hex2bin(infoHash))\n      : (opts.infoHash && hex2bin(opts.infoHash)) || this.client._infoHashBinary\n    const params = {\n      action: 'scrape',\n      info_hash: infoHashes\n    }\n\n    this._send(params)\n  }\n\n  destroy (cb = noop) {\n    if (this.destroyed) return cb(null)\n\n    this.destroyed = true\n\n    clearInterval(this.interval)\n    clearTimeout(this.reconnectTimer)\n\n    // Destroy peers\n    for (const peerId in this.peers) {\n      const peer = this.peers[peerId]\n      clearTimeout(peer.trackerTimeout)\n      peer.destroy()\n    }\n    this.peers = null\n\n    if (this.socket) {\n      this.socket.removeListener('connect', this._onSocketConnectBound)\n      this.socket.removeListener('data', this._onSocketDataBound)\n      this.socket.removeListener('close', this._onSocketCloseBound)\n      this.socket.removeListener('error', this._onSocketErrorBound)\n      this.socket = null\n    }\n\n    this._onSocketConnectBound = null\n    this._onSocketErrorBound = null\n    this._onSocketDataBound = null\n    this._onSocketCloseBound = null\n\n    if (socketPool[this.announceUrl]) {\n      socketPool[this.announceUrl].consumers -= 1\n    }\n\n    // Other instances are using the socket, so there's nothing left to do here\n    if (socketPool[this.announceUrl].consumers > 0) return cb()\n\n    let socket = socketPool[this.announceUrl]\n    delete socketPool[this.announceUrl]\n    socket.on('error', noop) // ignore all future errors\n    socket.once('close', cb)\n\n    let timeout\n\n    // If there is no data response expected, destroy immediately.\n    if (!this.expectingResponse) return destroyCleanup()\n\n    // Otherwise, wait a short time for potential responses to come in from the\n    // server, then force close the socket.\n    timeout = setTimeout(destroyCleanup, common.DESTROY_TIMEOUT)\n\n    // But, if a response comes from the server before the timeout fires, do cleanup\n    // right away.\n    socket.once('data', destroyCleanup)\n\n    function destroyCleanup () {\n      if (timeout) {\n        clearTimeout(timeout)\n        timeout = null\n      }\n      socket.removeListener('data', destroyCleanup)\n      socket.destroy()\n      socket = null\n    }\n  }\n\n  _openSocket () {\n    this.destroyed = false\n\n    if (!this.peers) this.peers = {}\n\n    this._onSocketConnectBound = () => {\n      this._onSocketConnect()\n    }\n    this._onSocketErrorBound = err => {\n      this._onSocketError(err)\n    }\n    this._onSocketDataBound = data => {\n      this._onSocketData(data)\n    }\n    this._onSocketCloseBound = () => {\n      this._onSocketClose()\n    }\n\n    this.socket = socketPool[this.announceUrl]\n    if (this.socket) {\n      socketPool[this.announceUrl].consumers += 1\n      if (this.socket.connected) {\n        this._onSocketConnectBound()\n      }\n    } else {\n      const parsedUrl = new URL(this.announceUrl)\n      let agent\n      if (this.client._proxyOpts) {\n        agent = parsedUrl.protocol === 'wss:' ? this.client._proxyOpts.httpsAgent : this.client._proxyOpts.httpAgent\n        if (!agent && this.client._proxyOpts.socksProxy) {\n          agent = new Socks.Agent(clone(this.client._proxyOpts.socksProxy), (parsedUrl.protocol === 'wss:'))\n        }\n      }\n      this.socket = socketPool[this.announceUrl] = new Socket({ url: this.announceUrl, agent })\n      this.socket.consumers = 1\n      this.socket.once('connect', this._onSocketConnectBound)\n    }\n\n    this.socket.on('data', this._onSocketDataBound)\n    this.socket.once('close', this._onSocketCloseBound)\n    this.socket.once('error', this._onSocketErrorBound)\n  }\n\n  _onSocketConnect () {\n    if (this.destroyed) return\n\n    if (this.reconnecting) {\n      this.reconnecting = false\n      this.retries = 0\n      this.announce(this.client._defaultAnnounceOpts())\n    }\n  }\n\n  _onSocketData (data) {\n    if (this.destroyed) return\n\n    this.expectingResponse = false\n\n    try {\n      data = JSON.parse(arr2text(data))\n    } catch (err) {\n      this.client.emit('warning', new Error('Invalid tracker response'))\n      return\n    }\n\n    if (data.action === 'announce') {\n      this._onAnnounceResponse(data)\n    } else if (data.action === 'scrape') {\n      this._onScrapeResponse(data)\n    } else {\n      this._onSocketError(new Error(`invalid action in WS response: ${data.action}`))\n    }\n  }\n\n  _onAnnounceResponse (data) {\n    if (data.info_hash !== this.client._infoHashBinary) {\n      debug(\n        'ignoring websocket data from %s for %s (looking for %s: reused socket)',\n        this.announceUrl, bin2hex(data.info_hash), this.client.infoHash\n      )\n      return\n    }\n\n    if (data.peer_id && data.peer_id === this.client._peerIdBinary) {\n      // ignore offers/answers from this client\n      return\n    }\n\n    debug(\n      'received %s from %s for %s',\n      JSON.stringify(data), this.announceUrl, this.client.infoHash\n    )\n\n    const failure = data['failure reason']\n    if (failure) return this.client.emit('warning', new Error(failure))\n\n    const warning = data['warning message']\n    if (warning) this.client.emit('warning', new Error(warning))\n\n    const interval = data.interval || data['min interval']\n    if (interval) this.setInterval(interval * 1000)\n\n    const trackerId = data['tracker id']\n    if (trackerId) {\n      // If absent, do not discard previous trackerId value\n      this._trackerId = trackerId\n    }\n\n    if (data.complete != null) {\n      const response = Object.assign({}, data, {\n        announce: this.announceUrl,\n        infoHash: bin2hex(data.info_hash)\n      })\n      this.client.emit('update', response)\n    }\n\n    let peer\n    if (data.offer && data.peer_id) {\n      debug('creating peer (from remote offer)')\n      peer = this._createPeer()\n      peer.id = bin2hex(data.peer_id)\n      peer.once('signal', answer => {\n        const params = {\n          action: 'announce',\n          info_hash: this.client._infoHashBinary,\n          peer_id: this.client._peerIdBinary,\n          to_peer_id: data.peer_id,\n          answer,\n          offer_id: data.offer_id\n        }\n        if (this._trackerId) params.trackerid = this._trackerId\n        this._send(params)\n      })\n      this.client.emit('peer', peer)\n      peer.signal(data.offer)\n    }\n\n    if (data.answer && data.peer_id) {\n      const offerId = bin2hex(data.offer_id)\n      peer = this.peers[offerId]\n      if (peer) {\n        peer.id = bin2hex(data.peer_id)\n        this.client.emit('peer', peer)\n        peer.signal(data.answer)\n\n        clearTimeout(peer.trackerTimeout)\n        peer.trackerTimeout = null\n        delete this.peers[offerId]\n      } else {\n        debug(`got unexpected answer: ${JSON.stringify(data.answer)}`)\n      }\n    }\n  }\n\n  _onScrapeResponse (data) {\n    data = data.files || {}\n\n    const keys = Object.keys(data)\n    if (keys.length === 0) {\n      this.client.emit('warning', new Error('invalid scrape response'))\n      return\n    }\n\n    keys.forEach(infoHash => {\n      // TODO: optionally handle data.flags.min_request_interval\n      // (separate from announce interval)\n      const response = Object.assign(data[infoHash], {\n        announce: this.announceUrl,\n        infoHash: bin2hex(infoHash)\n      })\n      this.client.emit('scrape', response)\n    })\n  }\n\n  _onSocketClose () {\n    if (this.destroyed) return\n    this.destroy()\n    this._startReconnectTimer()\n  }\n\n  _onSocketError (err) {\n    if (this.destroyed) return\n    this.destroy()\n    // errors will often happen if a tracker is offline, so don't treat it as fatal\n    this.client.emit('warning', err)\n    this._startReconnectTimer()\n  }\n\n  _startReconnectTimer () {\n    const ms = Math.floor(Math.random() * RECONNECT_VARIANCE) + Math.min(Math.pow(2, this.retries) * RECONNECT_MINIMUM, RECONNECT_MAXIMUM)\n\n    this.reconnecting = true\n    clearTimeout(this.reconnectTimer)\n    this.reconnectTimer = setTimeout(() => {\n      this.retries++\n      this._openSocket()\n    }, ms)\n    if (this.reconnectTimer.unref) this.reconnectTimer.unref()\n\n    debug('reconnecting socket in %s ms', ms)\n  }\n\n  _send (params) {\n    if (this.destroyed) return\n    this.expectingResponse = true\n    const message = JSON.stringify(params)\n    debug('send %s', message)\n    this.socket.send(message)\n  }\n\n  _generateOffers (numwant, cb) {\n    const self = this\n    const offers = []\n    debug('generating %s offers', numwant)\n\n    for (let i = 0; i < numwant; ++i) {\n      generateOffer()\n    }\n    checkDone()\n\n    function generateOffer () {\n      const offerId = arr2hex(randomBytes(20))\n      debug('creating peer (from _generateOffers)')\n      const peer = self.peers[offerId] = self._createPeer({ initiator: true })\n      peer.once('signal', offer => {\n        offers.push({\n          offer,\n          offer_id: hex2bin(offerId)\n        })\n        checkDone()\n      })\n      peer.trackerTimeout = setTimeout(() => {\n        debug('tracker timeout: destroying peer')\n        peer.trackerTimeout = null\n        delete self.peers[offerId]\n        peer.destroy()\n      }, OFFER_TIMEOUT)\n      if (peer.trackerTimeout.unref) peer.trackerTimeout.unref()\n    }\n\n    function checkDone () {\n      if (offers.length === numwant) {\n        debug('generated %s offers', numwant)\n        cb(offers)\n      }\n    }\n  }\n\n  _createPeer (opts) {\n    const self = this\n\n    opts = Object.assign({\n      trickle: false,\n      config: self.client._rtcConfig,\n      wrtc: self.client._wrtc\n    }, opts)\n\n    const peer = new Peer(opts)\n\n    peer.once('error', onError)\n    peer.once('connect', onConnect)\n\n    return peer\n\n    // Handle peer 'error' events that are fired *before* the peer is emitted in\n    // a 'peer' event.\n    function onError (err) {\n      self.client.emit('warning', new Error(`Connection error: ${err.message}`))\n      peer.destroy()\n    }\n\n    // Once the peer is emitted in a 'peer' event, then it's the consumer's\n    // responsibility to listen for errors, so the listeners are removed here.\n    function onConnect () {\n      peer.removeListener('error', onError)\n      peer.removeListener('connect', onConnect)\n    }\n  }\n}\n\nWebSocketTracker.prototype.DEFAULT_ANNOUNCE_INTERVAL = 30 * 1000 // 30 seconds\n// Normally this shouldn't be accessed but is occasionally useful\nWebSocketTracker._socketPool = socketPool\n\nfunction noop () {}\n\nexport default WebSocketTracker\n","import Debug from 'debug'\nimport EventEmitter from 'events'\nimport once from 'once'\nimport parallel from 'run-parallel'\nimport Peer from '@thaunknown/simple-peer/lite.js'\nimport queueMicrotask from 'queue-microtask'\nimport { hex2arr, hex2bin, text2arr, arr2hex, arr2text } from 'uint8-util'\n\nimport common from './lib/common.js'\nimport HTTPTracker from './lib/client/http-tracker.js' // empty object in browser\nimport UDPTracker from './lib/client/udp-tracker.js' // empty object in browser\nimport WebSocketTracker from './lib/client/websocket-tracker.js'\n\nconst debug = Debug('bittorrent-tracker:client')\n\n/**\n * BitTorrent tracker client.\n *\n * Find torrent peers, to help a torrent client participate in a torrent swarm.\n *\n * @param {Object} opts                          options object\n * @param {string|Uint8Array} opts.infoHash          torrent info hash\n * @param {string|Uint8Array} opts.peerId            peer id\n * @param {string|Array.<string>} opts.announce  announce\n * @param {number} opts.port                     torrent client listening port\n * @param {function} opts.getAnnounceOpts        callback to provide data to tracker\n * @param {number} opts.rtcConfig                RTCPeerConnection configuration object\n * @param {number} opts.userAgent                User-Agent header for http requests\n * @param {number} opts.wrtc                     custom webrtc impl (useful in node.js)\n * @param {object} opts.proxyOpts                proxy options (useful in node.js)\n */\nclass Client extends EventEmitter {\n  constructor (opts = {}) {\n    super()\n\n    if (!opts.peerId) throw new Error('Option `peerId` is required')\n    if (!opts.infoHash) throw new Error('Option `infoHash` is required')\n    if (!opts.announce) throw new Error('Option `announce` is required')\n    if (!process.browser && !opts.port) throw new Error('Option `port` is required')\n\n    this.peerId = typeof opts.peerId === 'string'\n      ? opts.peerId\n      : arr2hex(opts.peerId)\n    this._peerIdBuffer = hex2arr(this.peerId)\n    this._peerIdBinary = hex2bin(this.peerId)\n\n    this.infoHash = typeof opts.infoHash === 'string'\n      ? opts.infoHash.toLowerCase()\n      : arr2hex(opts.infoHash)\n    this._infoHashBuffer = hex2arr(this.infoHash)\n    this._infoHashBinary = hex2bin(this.infoHash)\n\n    debug('new client %s', this.infoHash)\n\n    this.destroyed = false\n\n    this._port = opts.port\n    this._getAnnounceOpts = opts.getAnnounceOpts\n    this._rtcConfig = opts.rtcConfig\n    this._userAgent = opts.userAgent\n    this._proxyOpts = opts.proxyOpts\n\n    // Support lazy 'wrtc' module initialization\n    // See: https://github.com/webtorrent/webtorrent-hybrid/issues/46\n    this._wrtc = typeof opts.wrtc === 'function' ? opts.wrtc() : opts.wrtc\n\n    let announce = typeof opts.announce === 'string'\n      ? [opts.announce]\n      : opts.announce == null ? [] : opts.announce\n\n    // Remove trailing slash from trackers to catch duplicates\n    announce = announce.map(announceUrl => {\n      if (ArrayBuffer.isView(announceUrl)) announceUrl = arr2text(announceUrl)\n      if (announceUrl[announceUrl.length - 1] === '/') {\n        announceUrl = announceUrl.substring(0, announceUrl.length - 1)\n      }\n      return announceUrl\n    })\n    // remove duplicates by converting to Set and back\n    announce = Array.from(new Set(announce))\n\n    const webrtcSupport = this._wrtc !== false && (!!this._wrtc || Peer.WEBRTC_SUPPORT)\n\n    const nextTickWarn = err => {\n      queueMicrotask(() => {\n        this.emit('warning', err)\n      })\n    }\n\n    this._trackers = announce\n      .map(announceUrl => {\n        let parsedUrl\n        try {\n          parsedUrl = common.parseUrl(announceUrl)\n        } catch (err) {\n          nextTickWarn(new Error(`Invalid tracker URL: ${announceUrl}`))\n          return null\n        }\n\n        const port = parsedUrl.port\n        if (port < 0 || port > 65535) {\n          nextTickWarn(new Error(`Invalid tracker port: ${announceUrl}`))\n          return null\n        }\n\n        const protocol = parsedUrl.protocol\n        if ((protocol === 'http:' || protocol === 'https:') &&\n            typeof HTTPTracker === 'function') {\n          return new HTTPTracker(this, announceUrl)\n        } else if (protocol === 'udp:' && typeof UDPTracker === 'function') {\n          return new UDPTracker(this, announceUrl)\n        } else if ((protocol === 'ws:' || protocol === 'wss:') && webrtcSupport) {\n          // Skip ws:// trackers on https:// sites because they throw SecurityError\n          if (protocol === 'ws:' && typeof window !== 'undefined' &&\n              window.location.protocol === 'https:') {\n            nextTickWarn(new Error(`Unsupported tracker protocol: ${announceUrl}`))\n            return null\n          }\n          return new WebSocketTracker(this, announceUrl)\n        } else {\n          nextTickWarn(new Error(`Unsupported tracker protocol: ${announceUrl}`))\n          return null\n        }\n      })\n      .filter(Boolean)\n  }\n\n  /**\n   * Send a `start` announce to the trackers.\n   * @param {Object} opts\n   * @param {number=} opts.uploaded\n   * @param {number=} opts.downloaded\n   * @param {number=} opts.left (if not set, calculated automatically)\n   */\n  start (opts) {\n    opts = this._defaultAnnounceOpts(opts)\n    opts.event = 'started'\n    debug('send `start` %o', opts)\n    this._announce(opts)\n\n    // start announcing on intervals\n    this._trackers.forEach(tracker => {\n      tracker.setInterval()\n    })\n  }\n\n  /**\n   * Send a `stop` announce to the trackers.\n   * @param {Object} opts\n   * @param {number=} opts.uploaded\n   * @param {number=} opts.downloaded\n   * @param {number=} opts.numwant\n   * @param {number=} opts.left (if not set, calculated automatically)\n   */\n  stop (opts) {\n    opts = this._defaultAnnounceOpts(opts)\n    opts.event = 'stopped'\n    debug('send `stop` %o', opts)\n    this._announce(opts)\n  }\n\n  /**\n   * Send a `complete` announce to the trackers.\n   * @param {Object} opts\n   * @param {number=} opts.uploaded\n   * @param {number=} opts.downloaded\n   * @param {number=} opts.numwant\n   * @param {number=} opts.left (if not set, calculated automatically)\n   */\n  complete (opts) {\n    if (!opts) opts = {}\n    opts = this._defaultAnnounceOpts(opts)\n    opts.event = 'completed'\n    debug('send `complete` %o', opts)\n    this._announce(opts)\n  }\n\n  /**\n   * Send a `update` announce to the trackers.\n   * @param {Object} opts\n   * @param {number=} opts.uploaded\n   * @param {number=} opts.downloaded\n   * @param {number=} opts.numwant\n   * @param {number=} opts.left (if not set, calculated automatically)\n   */\n  update (opts) {\n    opts = this._defaultAnnounceOpts(opts)\n    if (opts.event) delete opts.event\n    debug('send `update` %o', opts)\n    this._announce(opts)\n  }\n\n  _announce (opts) {\n    this._trackers.forEach(tracker => {\n      // tracker should not modify `opts` object, it's passed to all trackers\n      tracker.announce(opts)\n    })\n  }\n\n  /**\n   * Send a scrape request to the trackers.\n   * @param {Object} opts\n   */\n  scrape (opts) {\n    debug('send `scrape`')\n    if (!opts) opts = {}\n    this._trackers.forEach(tracker => {\n      // tracker should not modify `opts` object, it's passed to all trackers\n      tracker.scrape(opts)\n    })\n  }\n\n  setInterval (intervalMs) {\n    debug('setInterval %d', intervalMs)\n    this._trackers.forEach(tracker => {\n      tracker.setInterval(intervalMs)\n    })\n  }\n\n  destroy (cb) {\n    if (this.destroyed) return\n    this.destroyed = true\n    debug('destroy')\n\n    const tasks = this._trackers.map(tracker => cb => {\n      tracker.destroy(cb)\n    })\n\n    parallel(tasks, cb)\n\n    this._trackers = []\n    this._getAnnounceOpts = null\n  }\n\n  _defaultAnnounceOpts (opts = {}) {\n    if (opts.numwant == null) opts.numwant = common.DEFAULT_ANNOUNCE_PEERS\n\n    if (opts.uploaded == null) opts.uploaded = 0\n    if (opts.downloaded == null) opts.downloaded = 0\n\n    if (this._getAnnounceOpts) opts = Object.assign({}, opts, this._getAnnounceOpts())\n\n    return opts\n  }\n}\n\n/**\n * Simple convenience function to scrape a tracker for an info hash without needing to\n * create a Client, pass it a parsed torrent, etc. Support scraping a tracker for multiple\n * torrents at the same time.\n * @params {Object} opts\n * @param  {string|Array.<string>} opts.infoHash\n * @param  {string} opts.announce\n * @param  {function} cb\n */\nClient.scrape = (opts, cb) => {\n  cb = once(cb)\n\n  if (!opts.infoHash) throw new Error('Option `infoHash` is required')\n  if (!opts.announce) throw new Error('Option `announce` is required')\n\n  const clientOpts = Object.assign({}, opts, {\n    infoHash: Array.isArray(opts.infoHash) ? opts.infoHash[0] : opts.infoHash,\n    peerId: text2arr('01234567890123456789'), // dummy value\n    port: 6881 // dummy value\n  })\n\n  const client = new Client(clientOpts)\n  client.once('error', cb)\n  client.once('warning', cb)\n\n  let len = Array.isArray(opts.infoHash) ? opts.infoHash.length : 1\n  const results = {}\n  client.on('scrape', data => {\n    len -= 1\n    results[data.infoHash] = data\n    if (len === 0) {\n      client.destroy()\n      const keys = Object.keys(results)\n      if (keys.length === 1) {\n        cb(null, results[keys[0]])\n      } else {\n        cb(null, results)\n      }\n    }\n  })\n\n  client.scrape({ infoHash: opts.infoHash })\n  return client\n}\n\nexport default Client\n","import Debug from 'debug';\r\nimport { Buffer } from 'buffer';\r\nimport { STEEmitter } from './stringly-typed-event-emitter';\r\nvar MediaPeerCommands;\r\n(function (MediaPeerCommands) {\r\n    MediaPeerCommands[MediaPeerCommands[\"SegmentData\"] = 0] = \"SegmentData\";\r\n    MediaPeerCommands[MediaPeerCommands[\"SegmentAbsent\"] = 1] = \"SegmentAbsent\";\r\n    MediaPeerCommands[MediaPeerCommands[\"SegmentsMap\"] = 2] = \"SegmentsMap\";\r\n    MediaPeerCommands[MediaPeerCommands[\"SegmentsPending\"] = 3] = \"SegmentsPending\";\r\n    MediaPeerCommands[MediaPeerCommands[\"SegmentRequest\"] = 4] = \"SegmentRequest\";\r\n    MediaPeerCommands[MediaPeerCommands[\"CancelSegmentRequest\"] = 5] = \"CancelSegmentRequest\";\r\n})(MediaPeerCommands || (MediaPeerCommands = {}));\r\nclass DownloadingSegment {\r\n    constructor(id, size) {\r\n        this.id = id;\r\n        this.size = size;\r\n        this.bytesDownloaded = 0;\r\n        this.pieces = [];\r\n        this.loading = { start: 0, end: 0, first: 0 };\r\n    }\r\n}\r\nexport class MediaPeer extends STEEmitter {\r\n    constructor(peer, settings) {\r\n        super();\r\n        this.peer = peer;\r\n        this.settings = settings;\r\n        this.remoteAddress = '';\r\n        this.downloadingSegmentId = null;\r\n        this.downloadingSegment = null;\r\n        this.segmentsMap = [];\r\n        this.pendingStatus = [];\r\n        this.lastSegmentsSend_ = '';\r\n        this.debug = Debug('p2pml:media-peer');\r\n        this.timer = null;\r\n        this.onPeerConnect = () => {\r\n            this.debug('peer connect', this.id, this);\r\n            this.remoteAddress = this.peer.remoteAddress;\r\n            this.emit('connect', this);\r\n        };\r\n        this.onPeerClose = () => {\r\n            this.debug('peer close', this.id, this);\r\n            this.terminateSegmentRequest();\r\n            this.emit('close', this);\r\n        };\r\n        this.onPeerError = (error) => {\r\n            this.debug('peer error', this.id, error, this);\r\n        };\r\n        this.receiveSegmentPiece = (data) => {\r\n            if (!this.downloadingSegment) {\r\n                this.debug('peer segment not requested', this.id, this);\r\n                return;\r\n            }\r\n            if (this.downloadingSegment.loading.first === 0) {\r\n                this.downloadingSegment.loading.first = performance.now();\r\n            }\r\n            this.downloadingSegment.bytesDownloaded += data.byteLength;\r\n            this.downloadingSegment.pieces.push(data);\r\n            this.emit('bytes-downloaded', this, this.downloadingSegment.id, data.byteLength);\r\n            const segmentId = this.downloadingSegment.id;\r\n            this.emit('segment-downloaded', this.downloadingSegment);\r\n            if (this.downloadingSegment.bytesDownloaded === this.downloadingSegment.size) {\r\n                const segmentData = new Uint8Array(this.downloadingSegment.size);\r\n                let offset = 0;\r\n                for (const piece of this.downloadingSegment.pieces) {\r\n                    segmentData.set(new Uint8Array(piece), offset);\r\n                    offset += piece.byteLength;\r\n                }\r\n                this.downloadingSegment.loading.end = performance.now();\r\n                this.debug('peer segment download done', this.id, segmentId, this);\r\n                this.terminateSegmentRequest();\r\n                this.emit('segment-loaded', this, segmentId, segmentData.buffer);\r\n            }\r\n            else if (this.downloadingSegment.bytesDownloaded > this.downloadingSegment.size) {\r\n                this.debug('peer segment download bytes mismatch', this.id, segmentId, this);\r\n                this.terminateSegmentRequest();\r\n                this.emit('segment-error', this, segmentId, 'Too many bytes received for segment');\r\n            }\r\n        };\r\n        this.getJsonCommand = (data) => {\r\n            const bytes = new Uint8Array(data);\r\n            if (bytes[0] === 123 && bytes[1] === 34 && bytes[data.byteLength - 1] === 125) {\r\n                try {\r\n                    return JSON.parse(new TextDecoder().decode(data));\r\n                }\r\n                catch (_a) {\r\n                    return null;\r\n                }\r\n            }\r\n            return null;\r\n        };\r\n        this.onPeerData = (data) => {\r\n            const command = this.getJsonCommand(data);\r\n            if (command === null) {\r\n                this.receiveSegmentPiece(data);\r\n                return;\r\n            }\r\n            if (this.downloadingSegment) {\r\n                this.debug('peer segment download is interrupted by a command', this.id, this);\r\n                const segmentId = this.downloadingSegment.id;\r\n                this.terminateSegmentRequest();\r\n                this.emit('segment-error', this, segmentId, 'Segment download is interrupted by a command');\r\n                return;\r\n            }\r\n            this.debug('peer receive command', this.id, command);\r\n            switch (command.c) {\r\n                case MediaPeerCommands.SegmentsMap:\r\n                    this.segmentsMap = command.m.split('|');\r\n                    this.emit('data-updated', { peerId: this.peer.id, segmentsMap: this.segmentsMap });\r\n                    break;\r\n                case MediaPeerCommands.SegmentRequest:\r\n                    this.emit('segment-request', this, command.i);\r\n                    break;\r\n                case MediaPeerCommands.SegmentData:\r\n                    if (this.downloadingSegmentId && this.downloadingSegmentId === command.i) {\r\n                        if (typeof command.s === 'number' && command.s >= 0) {\r\n                            this.downloadingSegment = new DownloadingSegment(command.i, command.s);\r\n                            this.cancelResponseTimeoutTimer();\r\n                            this.runResponseTimeoutTimer();\r\n                        }\r\n                        else {\r\n                            this.debug('invalid segment size', this.id, command.s, this);\r\n                        }\r\n                    }\r\n                    break;\r\n                case MediaPeerCommands.SegmentsPending:\r\n                    try {\r\n                        this.pendingStatus = command.m.split('|');\r\n                    }\r\n                    catch (error) { }\r\n                    break;\r\n                case MediaPeerCommands.SegmentAbsent:\r\n                    if (this.downloadingSegmentId && this.downloadingSegmentId === command.i) {\r\n                        this.terminateSegmentRequest();\r\n                        this.segmentsMap = this.segmentsMap.filter((x) => x !== command.i);\r\n                        this.emit('segment-absent', this, command.i);\r\n                    }\r\n                    break;\r\n                case MediaPeerCommands.CancelSegmentRequest:\r\n                    break;\r\n                default:\r\n                    break;\r\n            }\r\n        };\r\n        this.sendCommand = (command) => {\r\n            this.peer.write(JSON.stringify(command));\r\n        };\r\n        this.destroy = () => {\r\n            this.debug('peer destroy', this.id, this);\r\n            this.terminateSegmentRequest();\r\n            this.peer.destroy();\r\n        };\r\n        this.getDownloadingSegmentId = () => {\r\n            return this.downloadingSegmentId;\r\n        };\r\n        this.checkPendingTimeout = (segmentId) => {\r\n            try {\r\n                if (this.pendingStatus[0] === segmentId) {\r\n                    return Number(this.pendingStatus[1]);\r\n                }\r\n                return 0;\r\n            }\r\n            catch (e) {\r\n                return 0;\r\n            }\r\n        };\r\n        this.getSegmentsMap = () => {\r\n            return this.segmentsMap;\r\n        };\r\n        this.getPendingStatus = () => {\r\n            return this.pendingStatus;\r\n        };\r\n        this.sendSegmentsMap = (segmentsMap) => {\r\n            if (this.lastSegmentsSend_ === segmentsMap)\r\n                return;\r\n            this.lastSegmentsSend_ = segmentsMap;\r\n            this.sendCommand({ c: MediaPeerCommands.SegmentsMap, m: segmentsMap });\r\n        };\r\n        this.sendSegmentsPending = (pendingStatus) => {\r\n            this.sendCommand({ c: MediaPeerCommands.SegmentsPending, m: pendingStatus });\r\n        };\r\n        this.sendSegmentData = (segmentId, data) => {\r\n            this.sendCommand({\r\n                c: MediaPeerCommands.SegmentData,\r\n                i: segmentId,\r\n                s: data.byteLength,\r\n            });\r\n            let bytesLeft = data.byteLength;\r\n            while (bytesLeft > 0) {\r\n                const bytesToSend = bytesLeft >= this.settings.webRtcMaxMessageSize ? this.settings.webRtcMaxMessageSize : bytesLeft;\r\n                const buffer = Buffer.from(data, data.byteLength - bytesLeft, bytesToSend);\r\n                this.peer.write(buffer);\r\n                bytesLeft -= bytesToSend;\r\n            }\r\n            this.emit('bytes-uploaded', this, data.byteLength);\r\n        };\r\n        this.sendSegmentAbsent = (segmentId) => {\r\n            this.sendCommand({ c: MediaPeerCommands.SegmentAbsent, i: segmentId });\r\n        };\r\n        this.requestSegment = (segmentId) => {\r\n            if (!segmentId) {\r\n                throw new Error('segmentId is empty');\r\n            }\r\n            if (this.downloadingSegmentId === segmentId) {\r\n                throw new Error('Target segment is already downloading: ' + segmentId);\r\n            }\r\n            if (this.downloadingSegmentId) {\r\n                throw new Error('A segment is already downloading: ' + this.downloadingSegmentId);\r\n            }\r\n            this.sendCommand({ c: MediaPeerCommands.SegmentRequest, i: segmentId });\r\n            this.downloadingSegmentId = segmentId;\r\n            this.runResponseTimeoutTimer();\r\n        };\r\n        this.cancelSegmentRequest = () => {\r\n            let downloadingSegment;\r\n            if (this.downloadingSegmentId) {\r\n                const segmentId = this.downloadingSegmentId;\r\n                downloadingSegment = this.downloadingSegment ? this.downloadingSegment.pieces : undefined;\r\n                this.terminateSegmentRequest();\r\n                this.sendCommand({ c: MediaPeerCommands.CancelSegmentRequest, i: segmentId });\r\n            }\r\n            return downloadingSegment;\r\n        };\r\n        this.runResponseTimeoutTimer = () => {\r\n            this.timer = setTimeout(() => {\r\n                this.timer = null;\r\n                if (!this.downloadingSegmentId) {\r\n                    return;\r\n                }\r\n                const segmentId = this.downloadingSegmentId;\r\n                this.cancelSegmentRequest();\r\n                this.emit('segment-timeout', this, segmentId);\r\n            }, this.settings.p2pSegmentDownloadTimeout);\r\n        };\r\n        this.cancelResponseTimeoutTimer = () => {\r\n            if (this.timer) {\r\n                clearTimeout(this.timer);\r\n                this.timer = null;\r\n            }\r\n        };\r\n        this.terminateSegmentRequest = () => {\r\n            this.downloadingSegmentId = null;\r\n            this.downloadingSegment = null;\r\n            this.cancelResponseTimeoutTimer();\r\n        };\r\n        this.peer.on('connect', this.onPeerConnect);\r\n        this.peer.on('close', this.onPeerClose);\r\n        this.peer.on('error', this.onPeerError);\r\n        this.peer.on('data', this.onPeerData);\r\n        this.id = peer.id;\r\n    }\r\n    canDownload(segmentId) {\r\n        const canDownload = this.downloadingSegmentId === null && this.segmentsMap.includes(segmentId);\r\n        return canDownload;\r\n    }\r\n}\r\n","import { EventEmitter } from 'events';\r\nexport class STEEmitter extends EventEmitter {\r\n    constructor() {\r\n        super(...arguments);\r\n        this.on = (event, listener) => super.on(event, listener);\r\n        this.emit = (event, ...args) => super.emit(event, ...args);\r\n    }\r\n}\r\n","import Debug from 'debug';\r\nimport { Client } from 'bittorrent-tracker';\r\nimport { EventEmitter } from 'events';\r\nimport { Buffer } from 'buffer';\r\nimport sha1 from 'sha.js/sha1';\r\nimport { MediaPeer } from './media-peer';\r\nconst version = '0.6.2';\r\nconst PEER_PROTOCOL_VERSION = 2;\r\nconst PEER_ID_VERSION_STRING = version.replace(/\\d*./g, (v) => `0${parseInt(v, 10) % 100}`.slice(-2)).slice(0, 4);\r\nconst PEER_ID_VERSION_PREFIX = `-WW${PEER_ID_VERSION_STRING}-`;\r\nclass PeerSegmentRequest {\r\n    constructor(peerId, segment, callbacks) {\r\n        this.peerId = peerId;\r\n        this.segment = segment;\r\n        this.callbacks = callbacks;\r\n    }\r\n}\r\nfunction generatePeerId() {\r\n    const PEER_ID_SYMBOLS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';\r\n    const PEER_ID_LENGTH = 20;\r\n    let peerId = PEER_ID_VERSION_PREFIX;\r\n    for (let i = 0; i < PEER_ID_LENGTH - PEER_ID_VERSION_PREFIX.length; i++) {\r\n        peerId += PEER_ID_SYMBOLS.charAt(Math.floor(Math.random() * PEER_ID_SYMBOLS.length));\r\n    }\r\n    return new TextEncoder().encode(peerId).buffer;\r\n}\r\nexport class P2PMediaManager extends EventEmitter {\r\n    constructor(streamSwarmId, settings, segmentsStorage) {\r\n        super();\r\n        this.streamSwarmId = streamSwarmId;\r\n        this.settings = settings;\r\n        this.segmentsStorage = segmentsStorage;\r\n        this.trackerClient = null;\r\n        this.peers = new Map();\r\n        this.peerCandidates = new Map();\r\n        this.peerSegmentRequests = new Map();\r\n        this.debug = Debug('p2pml:p2p-media-manager');\r\n        this.peersCheckTimes = 0;\r\n        this.getPeers = () => {\r\n            return this.peers;\r\n        };\r\n        this.getPeerId = () => {\r\n            return Buffer.from(this.peerId).toString('hex');\r\n        };\r\n        this.createClient = () => {\r\n            const infoHash = new sha1().update(`${PEER_PROTOCOL_VERSION}${this.streamSwarmId}`).digest();\r\n            const clientOptions = {\r\n                infoHash: Buffer.from(infoHash, 0, 20),\r\n                peerId: Buffer.from(this.peerId, 0, 20),\r\n                announce: this.settings.trackerAnnounce,\r\n                rtcConfig: this.settings.rtcConfig,\r\n                port: 6881,\r\n                getAnnounceOpts: () => {\r\n                    return { numwant: this.settings.peerRequestsPerAnnounce };\r\n                },\r\n            };\r\n            let oldTrackerClient = this.trackerClient;\r\n            this.trackerClient = new Client(clientOptions);\r\n            this.trackerClient.on('error', this.onTrackerError);\r\n            this.trackerClient.on('warning', this.onTrackerWarning);\r\n            this.trackerClient.on('update', this.onTrackerUpdate);\r\n            this.trackerClient.on('peer', this.onTrackerPeer);\r\n            this.trackerClient.start();\r\n            if (oldTrackerClient !== null) {\r\n                oldTrackerClient.destroy();\r\n                oldTrackerClient = null;\r\n            }\r\n        };\r\n        this.onTrackerError = (error) => {\r\n            this.debug('tracker error', error);\r\n        };\r\n        this.onTrackerWarning = (warning) => {\r\n            this.debug('tracker warning', warning);\r\n        };\r\n        this.onTrackerUpdate = (data) => {\r\n            this.debug('tracker update', data);\r\n            this.emit('tracker-update', data);\r\n        };\r\n        this.onTrackerPeer = (trackerPeer) => {\r\n            this.debug('tracker peer', trackerPeer.id, trackerPeer);\r\n            if (this.peers.has(trackerPeer.id)) {\r\n                this.debug('tracker peer already connected', trackerPeer.id, trackerPeer);\r\n                trackerPeer.destroy();\r\n                return;\r\n            }\r\n            const peer = new MediaPeer(trackerPeer, this.settings);\r\n            peer.on('connect', this.onPeerConnect);\r\n            peer.on('close', this.onPeerClose);\r\n            peer.on('data-updated', this.onPeerDataUpdated);\r\n            peer.on('segment-request', this.onSegmentRequest);\r\n            peer.on('segment-loaded', this.onSegmentLoaded);\r\n            peer.on('segment-absent', this.onSegmentAbsent);\r\n            peer.on('segment-error', this.onSegmentError);\r\n            peer.on('segment-timeout', this.onSegmentTimeout);\r\n            peer.on('bytes-downloaded', this.onPieceBytesDownloaded);\r\n            peer.on('bytes-uploaded', this.onPieceBytesUploaded);\r\n            let peerCandidatesById = this.peerCandidates.get(peer.id);\r\n            if (!peerCandidatesById) {\r\n                peerCandidatesById = [];\r\n                this.peerCandidates.set(peer.id, peerCandidatesById);\r\n            }\r\n            peerCandidatesById.push(peer);\r\n        };\r\n        this.checkPendingTimeout = (segment) => {\r\n            const canP2P = this.canDownload(segment);\r\n            if (canP2P)\r\n                return 0;\r\n            const timeoutList = Array.from(this.peers.values())\r\n                .map((peer) => peer.checkPendingTimeout(segment.id))\r\n                .filter((timeout) => timeout > 0);\r\n            const timeout = Math.max(...timeoutList);\r\n            return timeout > 0 ? timeout + 100 : 0;\r\n        };\r\n        this.canDownload = (segment) => {\r\n            if (Array.from(this.peers.keys()).length === 0) {\r\n                if (this.peersCheckTimes > 20) {\r\n                    this.peersCheckTimes = 0;\r\n                    this.debug('没有可用的 Peer, 重新创建 TrackerClient');\r\n                    this.createClient();\r\n                }\r\n                else {\r\n                    this.peersCheckTimes++;\r\n                }\r\n                return false;\r\n            }\r\n            const candidates = [];\r\n            for (const peer of Array.from(this.peers.values())) {\r\n                if (peer.canDownload(segment.id)) {\r\n                    candidates.push(peer);\r\n                }\r\n            }\r\n            if (candidates.length === 0) {\r\n                return false;\r\n            }\r\n            return true;\r\n        };\r\n        this.load = (segment, callbacks) => {\r\n            const candidates = [];\r\n            for (const peer of Array.from(this.peers.values())) {\r\n                if (peer.canDownload(segment.id)) {\r\n                    candidates.push(peer);\r\n                }\r\n            }\r\n            if (candidates.length === 0) {\r\n                callbacks === null || callbacks === void 0 ? void 0 : callbacks.onError(null, { message: 'no_peer_found' });\r\n                return false;\r\n            }\r\n            const peer = candidates[Math.floor(Math.random() * candidates.length)];\r\n            peer.requestSegment(segment.id);\r\n            this.debug('使用 p2p 下载', peer.id, segment.id);\r\n            this.peerSegmentRequests.set(segment.id, new PeerSegmentRequest(peer.id, segment, callbacks));\r\n            return true;\r\n        };\r\n        this.abort = (segment) => {\r\n            let downloadingSegment;\r\n            const peerSegmentRequest = this.peerSegmentRequests.get(segment.id);\r\n            if (peerSegmentRequest) {\r\n                const peer = this.peers.get(peerSegmentRequest.peerId);\r\n                if (peer) {\r\n                    downloadingSegment = peer.cancelSegmentRequest();\r\n                }\r\n                this.peerSegmentRequests.delete(segment.id);\r\n            }\r\n            return downloadingSegment;\r\n        };\r\n        this.isDownloading = (segment) => {\r\n            return this.peerSegmentRequests.has(segment.id);\r\n        };\r\n        this.getActiveDownloadsCount = () => {\r\n            return this.peerSegmentRequests.size;\r\n        };\r\n        this.destroy = (swarmChange = false) => {\r\n            this.streamSwarmId = '';\r\n            if (this.trackerClient) {\r\n                this.trackerClient.stop();\r\n                if (swarmChange) {\r\n                    this.trackerClient.removeAllListeners('error');\r\n                    this.trackerClient.removeAllListeners('warning');\r\n                    this.trackerClient.removeAllListeners('update');\r\n                    this.trackerClient.removeAllListeners('peer');\r\n                }\r\n                else {\r\n                    this.trackerClient.destroy();\r\n                    this.trackerClient = null;\r\n                }\r\n            }\r\n            this.peers.forEach((peer) => peer.destroy());\r\n            this.peers.clear();\r\n            this.peerSegmentRequests.clear();\r\n            for (const peerCandidateById of Array.from(this.peerCandidates.values())) {\r\n                for (const peerCandidate of peerCandidateById) {\r\n                    peerCandidate.destroy();\r\n                }\r\n            }\r\n            this.peerCandidates.clear();\r\n        };\r\n        this.sendSegmentsMapToAll = (segmentsMap) => {\r\n            this.debug('发送本地 storage 分片到对等端', Array.from(this.peers.keys()));\r\n            this.peers.forEach((peer) => peer.sendSegmentsMap(segmentsMap));\r\n        };\r\n        this.sendSegmentsPendingToAll = (segmentsPending, delay) => {\r\n            this.debug('发送本地 pending 分片到对等端', Array.from(this.peers.keys()));\r\n            this.peers.forEach((peer) => peer.sendSegmentsPending(`${segmentsPending}|${delay}`));\r\n        };\r\n        this.sendSegmentsMap = (peerId, segmentsMap) => {\r\n            const peer = this.peers.get(peerId);\r\n            if (peer) {\r\n                peer.sendSegmentsMap(segmentsMap);\r\n            }\r\n        };\r\n        this.onPieceBytesDownloaded = (peer, segmentId, bytes) => {\r\n            var _a, _b;\r\n            this.emit('bytes-downloaded', bytes, peer.id);\r\n            const peerSegmentRequest = this.peerSegmentRequests.get(segmentId);\r\n            if (!peerSegmentRequest) {\r\n                return;\r\n            }\r\n            if ((_a = peerSegmentRequest.callbacks) === null || _a === void 0 ? void 0 : _a.onPiece) {\r\n                (_b = peerSegmentRequest.callbacks) === null || _b === void 0 ? void 0 : _b.onPiece(peer.id, bytes);\r\n            }\r\n        };\r\n        this.onPieceBytesUploaded = (peer, bytes) => {\r\n            this.emit('bytes-uploaded', bytes, peer.id);\r\n        };\r\n        this.onPeerConnect = (peer) => {\r\n            const connectedPeer = this.peers.get(peer.id);\r\n            if (connectedPeer) {\r\n                this.debug('tracker peer already connected (in peer connect)', peer.id, peer);\r\n                peer.destroy();\r\n                return;\r\n            }\r\n            this.debug('添加新 peer 到 peers', peer.id, JSON.stringify(this.peers.keys(), null, 2));\r\n            this.peers.set(peer.id, peer);\r\n            const peerCandidatesById = this.peerCandidates.get(peer.id);\r\n            if (peerCandidatesById) {\r\n                for (const peerCandidate of peerCandidatesById) {\r\n                    if (peerCandidate !== peer) {\r\n                        peerCandidate.destroy();\r\n                    }\r\n                }\r\n                this.peerCandidates.delete(peer.id);\r\n            }\r\n            this.emit('peer-connected', { id: peer.id, remoteAddress: peer.remoteAddress });\r\n        };\r\n        this.onPeerClose = (peer) => {\r\n            var _a, _b;\r\n            if (this.peers.get(peer.id) !== peer) {\r\n                const peerCandidatesById = this.peerCandidates.get(peer.id);\r\n                if (!peerCandidatesById) {\r\n                    return;\r\n                }\r\n                const index = peerCandidatesById.indexOf(peer);\r\n                if (index !== -1) {\r\n                    peerCandidatesById.splice(index, 1);\r\n                }\r\n                if (peerCandidatesById.length === 0) {\r\n                    this.peerCandidates.delete(peer.id);\r\n                }\r\n                return;\r\n            }\r\n            for (const [key, value] of Array.from(this.peerSegmentRequests)) {\r\n                if (value.peerId === peer.id) {\r\n                    if ((_a = value.callbacks) === null || _a === void 0 ? void 0 : _a.onError) {\r\n                        (_b = value.callbacks) === null || _b === void 0 ? void 0 : _b.onError(peer.id, { message: 'peer_closed' });\r\n                    }\r\n                    this.peerSegmentRequests.delete(key);\r\n                }\r\n            }\r\n            this.peers.delete(peer.id);\r\n            this.emit('peer-data-updated');\r\n            this.emit('peer-closed', peer.id);\r\n        };\r\n        this.onPeerDataUpdated = ({ peerId, segmentsMap }) => {\r\n            this.emit('peer-segments-map-updated', { peerId, segmentsMap });\r\n            this.emit('peer-data-updated');\r\n        };\r\n        this.onSegmentRequest = (peer, segmentId) => {\r\n            const segment = this.segmentsStorage.getSegment(segmentId);\r\n            if (segment && segment.data) {\r\n                peer.sendSegmentData(segmentId, segment.data);\r\n            }\r\n            else {\r\n                peer.sendSegmentAbsent(segmentId);\r\n            }\r\n        };\r\n        this.onSegmentLoaded = async (peer, segmentId, data) => {\r\n            var _a, _b;\r\n            const peerSegmentRequest = this.peerSegmentRequests.get(segmentId);\r\n            if (!peerSegmentRequest) {\r\n                return;\r\n            }\r\n            const segment = peerSegmentRequest.segment;\r\n            if ((_a = peerSegmentRequest.callbacks) === null || _a === void 0 ? void 0 : _a.onSuccess) {\r\n                (_b = peerSegmentRequest.callbacks) === null || _b === void 0 ? void 0 : _b.onSuccess(peer.id, data.slice(0));\r\n            }\r\n            this.peerSegmentRequests.delete(segmentId);\r\n            this.emit('segment-loaded', segment, data, peer.id);\r\n        };\r\n        this.onSegmentAbsent = (peer, segmentId) => {\r\n            var _a, _b;\r\n            const peerSegmentRequest = this.peerSegmentRequests.get(segmentId);\r\n            if (peerSegmentRequest) {\r\n                if ((_a = peerSegmentRequest.callbacks) === null || _a === void 0 ? void 0 : _a.onError) {\r\n                    (_b = peerSegmentRequest.callbacks) === null || _b === void 0 ? void 0 : _b.onError(peer.id, { message: 'segment_absent' });\r\n                }\r\n                this.peerSegmentRequests.delete(segmentId);\r\n                this.emit('peer-data-updated');\r\n            }\r\n        };\r\n        this.onSegmentError = (peer, segmentId, description) => {\r\n            var _a, _b;\r\n            const peerSegmentRequest = this.peerSegmentRequests.get(segmentId);\r\n            if (peerSegmentRequest) {\r\n                if ((_a = peerSegmentRequest.callbacks) === null || _a === void 0 ? void 0 : _a.onError) {\r\n                    (_b = peerSegmentRequest.callbacks) === null || _b === void 0 ? void 0 : _b.onError(peer.id, { message: 'segment_error:' + description });\r\n                }\r\n                this.peerSegmentRequests.delete(segmentId);\r\n                this.emit('segment-error', peerSegmentRequest.segment, description, peer.id);\r\n            }\r\n        };\r\n        this.onSegmentTimeout = (peer, segmentId) => {\r\n            var _a, _b;\r\n            const peerSegmentRequest = this.peerSegmentRequests.get(segmentId);\r\n            if (peerSegmentRequest) {\r\n                if ((_a = peerSegmentRequest.callbacks) === null || _a === void 0 ? void 0 : _a.onError) {\r\n                    (_b = peerSegmentRequest.callbacks) === null || _b === void 0 ? void 0 : _b.onError(peer.id, { message: 'segment_timeout' });\r\n                }\r\n                this.peerSegmentRequests.delete(segmentId);\r\n                peer.destroy();\r\n                if (this.peers.delete(peerSegmentRequest.peerId)) {\r\n                    this.emit('peer-data-updated');\r\n                }\r\n            }\r\n        };\r\n        this.peerId = generatePeerId();\r\n        if (this.debug.enabled) {\r\n            this.debug('peer ID', this.getPeerId(), new TextDecoder().decode(this.peerId));\r\n        }\r\n        this.debug('stream swarm ID', this.streamSwarmId);\r\n        this.createClient();\r\n    }\r\n}\r\n","export class SegmentsMemoryStorage {\r\n    constructor(settings) {\r\n        this.settings = settings;\r\n        this.segments = [];\r\n    }\r\n    storeSegment(segment) {\r\n        var _a;\r\n        this.segments.push(segment);\r\n        const limitCount = ((_a = this.settings) === null || _a === void 0 ? void 0 : _a.cachedSegmentsCount) || 30;\r\n        if (this.segments.length > limitCount) {\r\n            this.segments.shift();\r\n        }\r\n    }\r\n    getSegments() {\r\n        return this.segments;\r\n    }\r\n    getSegment(id) {\r\n        return this.segments.find((segment) => segment.id === id);\r\n    }\r\n    destroy() {\r\n        this.segments = [];\r\n    }\r\n}\r\n","import Debug from 'debug';\r\nimport { EventEmitter } from 'events';\r\nimport { Events } from './interface';\r\nimport { P2PMediaManager } from './p2p-manager';\r\nimport { SegmentsMemoryStorage } from './segments-memory-storage';\r\nconst defaultSettings = {\r\n    cachedSegmentsCount: 30,\r\n    p2pSegmentDownloadTimeout: 60000,\r\n    webRtcMaxMessageSize: 64 * 1024 - 1,\r\n    trackerAnnounce: ['wss://live-wt-tracker.test.seewo.com', 'wss://tracker.webtorrent.dev'],\r\n    peerRequestsPerAnnounce: 10,\r\n    rtcConfig: {\r\n        iceServers: [\r\n            {\r\n                urls: [\r\n                    'stun:stun.qq.com:3478',\r\n                    'stun:stun.miwifi.com:3478',\r\n                    'stun:stun.chat.bilibili.com:3478',\r\n                    'stun:stun.syncthing.net:3478',\r\n                    'stun:stun.cloudflare.com:3478',\r\n                    'stun:stun.l.google.com:19302',\r\n                    'stun:global.stun.twilio.com:3478',\r\n                ],\r\n            },\r\n        ],\r\n        sdpSemantics: 'unified-plan',\r\n    },\r\n};\r\nexport class P2PEngine extends EventEmitter {\r\n    constructor(swarmId, settings) {\r\n        super();\r\n        this.debug = Debug('p2pEngine:');\r\n        this.onSegmentLoaded = (segment, data, peerId) => {\r\n            this.storeSegment(segment);\r\n            this.debug('segment loaded', segment.id, segment.url, peerId);\r\n            segment.data = data;\r\n            this.emit(Events.SegmentLoaded, segment, peerId);\r\n        };\r\n        this.onSegmentError = (segment, details, peerId) => {\r\n            this.debug('segment error', segment.id, segment.url, peerId, details);\r\n            this.emit(Events.SegmentError, segment, details, peerId);\r\n        };\r\n        this.onPeerSegmentsMapUpdated = ({ peerId, segmentsMap }) => {\r\n            this.debug('peer segments map updated', peerId, segmentsMap);\r\n        };\r\n        this.onPeerConnect = async (peer) => {\r\n            this.debug('peer connected', peer.id);\r\n            this.emit(Events.PeerConnect, peer);\r\n        };\r\n        this.onPeerClose = (peerId) => {\r\n            this.debug('peer closed', peerId);\r\n            this.emit(Events.PeerClose, peerId);\r\n        };\r\n        this.onTrackerUpdate = async (data) => {\r\n            this.debug('tracker update', data);\r\n            this.broadcastSegmentsMap();\r\n        };\r\n        this.destroy = async () => {\r\n            this.p2pManager.destroy();\r\n            this.segmentsStorage.destroy();\r\n            this.removeAllListeners();\r\n        };\r\n        this.swarmId = swarmId;\r\n        this.settings = Object.assign(Object.assign({}, defaultSettings), settings);\r\n        this.segmentsStorage = this.settings.segmentsStorage === undefined ? new SegmentsMemoryStorage(this.settings) : this.settings.segmentsStorage;\r\n        this.p2pManager = new P2PMediaManager(this.swarmId, this.settings, this.segmentsStorage);\r\n        this.p2pManager.on('segment-loaded', this.onSegmentLoaded);\r\n        this.p2pManager.on('segment-error', this.onSegmentError);\r\n        this.p2pManager.on('peer-connected', this.onPeerConnect);\r\n        this.p2pManager.on('peer-closed', this.onPeerClose);\r\n        this.p2pManager.on('tracker-update', this.onTrackerUpdate);\r\n        this.p2pManager.on('peer-segments-map-updated', this.onPeerSegmentsMapUpdated);\r\n    }\r\n    getPeerId() {\r\n        return this.p2pManager.getPeerId();\r\n    }\r\n    getPeers() {\r\n        return this.p2pManager.getPeers();\r\n    }\r\n    getSettings() {\r\n        return this.settings;\r\n    }\r\n    storeSegment(segment) {\r\n        this.segmentsStorage.storeSegment(segment);\r\n        this.broadcastSegmentsMap();\r\n    }\r\n    broadcastSegmentsMap() {\r\n        const storageSegments = this.segmentsStorage.getSegments();\r\n        const segmentsMap = storageSegments.map((x) => x.id).join('|');\r\n        this.p2pManager.sendSegmentsMapToAll(segmentsMap);\r\n    }\r\n}\r\nP2PEngine.isSupported = () => {\r\n    return window.RTCPeerConnection.prototype.createDataChannel !== undefined;\r\n};\r\n","export class LoadStats {\r\n    constructor() {\r\n        this.aborted = false;\r\n        this.loaded = 0;\r\n        this.retry = 0;\r\n        this.total = 0;\r\n        this.chunkCount = 0;\r\n        this.bwEstimate = 0;\r\n        this.loading = { start: 0, first: 0, end: 0 };\r\n        this.parsing = { start: 0, end: 0 };\r\n        this.buffering = { start: 0, first: 0, end: 0 };\r\n    }\r\n}\r\n","const noop = function () { };\r\nconst fakeLogger = {\r\n    trace: noop,\r\n    debug: noop,\r\n    log: noop,\r\n    warn: noop,\r\n    info: noop,\r\n    error: noop,\r\n};\r\nlet exportedLogger = fakeLogger;\r\nfunction consolePrintFn(type) {\r\n    const func = self.console[type];\r\n    if (func) {\r\n        return func.bind(self.console, `[${type}] >`);\r\n    }\r\n    return noop;\r\n}\r\nfunction exportLoggerFunctions(debugConfig, ...functions) {\r\n    functions.forEach(function (type) {\r\n        exportedLogger[type] = debugConfig[type]\r\n            ? debugConfig[type].bind(debugConfig)\r\n            : consolePrintFn(type);\r\n    });\r\n}\r\nexport function enableLogs(debugConfig, id) {\r\n    if ((self.console && debugConfig === true) ||\r\n        typeof debugConfig === 'object') {\r\n        exportLoggerFunctions(debugConfig, 'debug', 'log', 'info', 'warn', 'error');\r\n        try {\r\n            exportedLogger.log(`Debug logs enabled for \"${id}\"`);\r\n        }\r\n        catch (e) {\r\n            exportedLogger = fakeLogger;\r\n        }\r\n    }\r\n    else {\r\n        exportedLogger = fakeLogger;\r\n    }\r\n}\r\nexport const logger = exportedLogger;\r\n","import { logger } from '../utils/logger';\r\nimport { LoadStats } from '../loader/load-stats';\r\nconst AGE_HEADER_LINE_REGEX = /^age:\\s*[\\d.]+\\s*$/m;\r\nclass XhrLoader {\r\n    constructor(config) {\r\n        this.config = null;\r\n        this.callbacks = null;\r\n        this.loader = null;\r\n        this.xhrSetup = config ? config.xhrSetup : null;\r\n        this.stats = new LoadStats();\r\n        this.retryDelay = 0;\r\n    }\r\n    destroy() {\r\n        this.callbacks = null;\r\n        this.abortInternal();\r\n        this.loader = null;\r\n        this.config = null;\r\n    }\r\n    abortInternal() {\r\n        const loader = this.loader;\r\n        self.clearTimeout(this.requestTimeout);\r\n        self.clearTimeout(this.retryTimeout);\r\n        if (loader) {\r\n            loader.onreadystatechange = null;\r\n            loader.onprogress = null;\r\n            if (loader.readyState !== 4) {\r\n                this.stats.aborted = true;\r\n                loader.abort();\r\n            }\r\n        }\r\n    }\r\n    abort() {\r\n        var _a;\r\n        this.abortInternal();\r\n        if ((_a = this.callbacks) === null || _a === void 0 ? void 0 : _a.onAbort) {\r\n            this.callbacks.onAbort(this.stats, this.context, this.loader);\r\n        }\r\n    }\r\n    load(context, config, callbacks) {\r\n        if (this.stats.loading.start) {\r\n            throw new Error('Loader can only be used once.');\r\n        }\r\n        this.stats.loading.start = self.performance.now();\r\n        this.context = context;\r\n        this.config = config;\r\n        this.callbacks = callbacks;\r\n        this.retryDelay = config.retryDelay;\r\n        this.loadInternal();\r\n    }\r\n    loadInternal() {\r\n        const { config, context } = this;\r\n        if (!config) {\r\n            return;\r\n        }\r\n        const xhr = (this.loader = new self.XMLHttpRequest());\r\n        const stats = this.stats;\r\n        stats.loading.first = 0;\r\n        stats.loaded = 0;\r\n        const xhrSetup = this.xhrSetup;\r\n        try {\r\n            if (xhrSetup) {\r\n                try {\r\n                    xhrSetup(xhr, context.url);\r\n                }\r\n                catch (e) {\r\n                    xhr.open('GET', context.url, true);\r\n                    xhrSetup(xhr, context.url);\r\n                }\r\n            }\r\n            if (!xhr.readyState) {\r\n                xhr.open('GET', context.url, true);\r\n            }\r\n            const headers = this.context.headers;\r\n            if (headers) {\r\n                for (const header in headers) {\r\n                    xhr.setRequestHeader(header, headers[header]);\r\n                }\r\n            }\r\n        }\r\n        catch (e) {\r\n            this.callbacks.onError({ code: xhr.status, text: e.message }, context, xhr);\r\n            return;\r\n        }\r\n        if (context.rangeEnd) {\r\n            xhr.setRequestHeader('Range', 'bytes=' + context.rangeStart + '-' + (context.rangeEnd - 1));\r\n        }\r\n        xhr.onreadystatechange = this.readystatechange.bind(this);\r\n        xhr.onprogress = this.loadprogress.bind(this);\r\n        xhr.responseType = context.responseType;\r\n        self.clearTimeout(this.requestTimeout);\r\n        this.requestTimeout = self.setTimeout(this.loadtimeout.bind(this), config.timeout);\r\n        xhr.send();\r\n    }\r\n    readystatechange() {\r\n        const { context, loader: xhr, stats } = this;\r\n        if (!context || !xhr) {\r\n            return;\r\n        }\r\n        const readyState = xhr.readyState;\r\n        const config = this.config;\r\n        if (stats.aborted) {\r\n            return;\r\n        }\r\n        if (readyState >= 2) {\r\n            self.clearTimeout(this.requestTimeout);\r\n            if (stats.loading.first === 0) {\r\n                stats.loading.first = Math.max(self.performance.now(), stats.loading.start);\r\n            }\r\n            if (readyState === 4) {\r\n                xhr.onreadystatechange = null;\r\n                xhr.onprogress = null;\r\n                const status = xhr.status;\r\n                const isArrayBuffer = xhr.responseType === 'arraybuffer';\r\n                if (status >= 200 &&\r\n                    status < 300 &&\r\n                    ((isArrayBuffer && xhr.response) || xhr.responseText !== null)) {\r\n                    stats.loading.end = Math.max(self.performance.now(), stats.loading.first);\r\n                    let data;\r\n                    let len;\r\n                    if (isArrayBuffer) {\r\n                        data = xhr.response;\r\n                        len = data.byteLength;\r\n                    }\r\n                    else {\r\n                        data = xhr.responseText;\r\n                        len = data.length;\r\n                    }\r\n                    stats.loaded = stats.total = len;\r\n                    if (!this.callbacks) {\r\n                        return;\r\n                    }\r\n                    const onProgress = this.callbacks.onProgress;\r\n                    if (onProgress) {\r\n                        onProgress(stats, context, data, xhr);\r\n                    }\r\n                    if (!this.callbacks) {\r\n                        return;\r\n                    }\r\n                    const response = {\r\n                        url: xhr.responseURL,\r\n                        data: data,\r\n                    };\r\n                    this.callbacks.onSuccess(response, stats, context, xhr);\r\n                }\r\n                else {\r\n                    if (stats.retry >= config.maxRetry ||\r\n                        (status >= 400 && status < 499)) {\r\n                        logger.error(`${status} while loading ${context.url}`);\r\n                        this.callbacks.onError({ code: status, text: xhr.statusText }, context, xhr);\r\n                    }\r\n                    else {\r\n                        logger.warn(`${status} while loading ${context.url}, retrying in ${this.retryDelay}...`);\r\n                        this.abortInternal();\r\n                        this.loader = null;\r\n                        self.clearTimeout(this.retryTimeout);\r\n                        this.retryTimeout = self.setTimeout(this.loadInternal.bind(this), this.retryDelay);\r\n                        this.retryDelay = Math.min(2 * this.retryDelay, config.maxRetryDelay);\r\n                        stats.retry++;\r\n                    }\r\n                }\r\n            }\r\n            else {\r\n                self.clearTimeout(this.requestTimeout);\r\n                this.requestTimeout = self.setTimeout(this.loadtimeout.bind(this), config.timeout);\r\n            }\r\n        }\r\n    }\r\n    loadtimeout() {\r\n        logger.warn(`timeout while loading ${this.context.url}`);\r\n        const callbacks = this.callbacks;\r\n        if (callbacks) {\r\n            this.abortInternal();\r\n            callbacks.onTimeout(this.stats, this.context, this.loader);\r\n        }\r\n    }\r\n    loadprogress(event) {\r\n        const stats = this.stats;\r\n        stats.loaded = event.loaded;\r\n        if (event.lengthComputable) {\r\n            stats.total = event.total;\r\n        }\r\n    }\r\n    getCacheAge() {\r\n        let result = null;\r\n        if (this.loader &&\r\n            AGE_HEADER_LINE_REGEX.test(this.loader.getAllResponseHeaders())) {\r\n            const ageHeader = this.loader.getResponseHeader('age');\r\n            result = ageHeader ? parseFloat(ageHeader) : null;\r\n        }\r\n        return result;\r\n    }\r\n}\r\nexport default XhrLoader;\r\n","import Debug from 'debug';\r\nimport { LoadStats } from 'hls.js/src/loader/load-stats';\r\nimport XhrLoader from 'hls.js/src/utils/xhr-loader';\r\nimport { Events } from './interface';\r\nfunction createSegment(context, data = undefined) {\r\n    var _a;\r\n    const streamId = context === null || context === void 0 ? void 0 : context.url.replace(/\\?.*/g, '').split('/').pop();\r\n    const segment = {\r\n        id: `${(_a = context === null || context === void 0 ? void 0 : context.frag) === null || _a === void 0 ? void 0 : _a.baseurl}+${streamId}`,\r\n        url: context === null || context === void 0 ? void 0 : context.url,\r\n        streamId,\r\n        range: undefined,\r\n        data: data === null || data === void 0 ? void 0 : data.slice(0),\r\n    };\r\n    return segment;\r\n}\r\nclass P2PFragmentLoader {\r\n    constructor(engine) {\r\n        this.debug = Debug('p2pml:p2p-fragment-loader');\r\n        this.callbacks = null;\r\n        this.config = null;\r\n        this.stats = new LoadStats();\r\n        this.engine = engine;\r\n    }\r\n    destroy() {\r\n        this.context = null;\r\n        this.stats = new LoadStats();\r\n    }\r\n    abort() {\r\n        var _a;\r\n        this.abortInternal();\r\n        if ((_a = this.callbacks) === null || _a === void 0 ? void 0 : _a.onAbort) {\r\n            this.callbacks.onAbort(this.stats, this.context, null);\r\n        }\r\n    }\r\n    abortInternal() {\r\n        self.clearTimeout(this.requestTimeout);\r\n        this.stats.aborted = true;\r\n        const p2pManager = this.engine.p2pManager;\r\n        const segment = createSegment(this.context);\r\n        p2pManager.abort(segment);\r\n    }\r\n    load(context, config, callbacks) {\r\n        if (this.stats.loading.start) {\r\n            throw new Error('Loader can only be used once.');\r\n        }\r\n        this.stats.loading.start = self.performance.now();\r\n        this.context = context;\r\n        this.config = config;\r\n        this.callbacks = callbacks;\r\n        return this.loadInternal();\r\n    }\r\n    loadInternal() {\r\n        var _a, _b;\r\n        const { config, context } = this;\r\n        if (!config || !context) {\r\n            return;\r\n        }\r\n        const stats = this.stats;\r\n        stats.loading.first = 0;\r\n        stats.loaded = 0;\r\n        stats.aborted = false;\r\n        if (context.rangeStart) {\r\n            this.debug('p2p 暂时不支持 range 请求', context.rangeStart, context.rangeEnd);\r\n            (_a = this.callbacks) === null || _a === void 0 ? void 0 : _a.onError({ code: 0, text: 'p2p 暂时不支持 range 请求' }, context, null);\r\n            return;\r\n        }\r\n        const fragDuration = ((_b = context === null || context === void 0 ? void 0 : context.frag) === null || _b === void 0 ? void 0 : _b.duration) * 1000 || 3 * 1000;\r\n        const p2pSegmentDownloadTimeout = this.engine.getSettings().p2pSegmentDownloadTimeout || 3 * 1000;\r\n        const minTimeout = Math.min(fragDuration, p2pSegmentDownloadTimeout) / 2;\r\n        self.clearTimeout(this.requestTimeout);\r\n        this.requestTimeout = self.setTimeout(() => {\r\n            var _a;\r\n            this.abortInternal();\r\n            if ((_a = this.callbacks) === null || _a === void 0 ? void 0 : _a.onTimeout) {\r\n                this.callbacks.onTimeout(stats, context, null);\r\n            }\r\n        }, minTimeout);\r\n        const p2pManager = this.engine.p2pManager;\r\n        const segment = createSegment(this.context);\r\n        const p2pCallbacks = {\r\n            onSuccess: (peerId, data) => {\r\n                var _a, _b;\r\n                self.clearTimeout(this.requestTimeout);\r\n                this.stats.loading.end = Math.max(self.performance.now(), this.stats.loading.first);\r\n                this.stats.total = this.stats.loaded = data.byteLength;\r\n                const onProgress = (_a = this.callbacks) === null || _a === void 0 ? void 0 : _a.onProgress;\r\n                if (onProgress) {\r\n                    onProgress(this.stats, this.context, data, null);\r\n                }\r\n                this.debug('p2p 下载分片成功', segment.id, this.stats);\r\n                const response = {\r\n                    url: segment.url || '',\r\n                    data: data,\r\n                    code: 200,\r\n                };\r\n                (_b = this.callbacks) === null || _b === void 0 ? void 0 : _b.onSuccess(response, this.stats, this.context, null);\r\n            },\r\n            onError: (peerId, error) => {\r\n                var _a;\r\n                self.clearTimeout(this.requestTimeout);\r\n                this.debug('p2p 下载分片失败', segment.id, peerId, error);\r\n                (_a = this.callbacks) === null || _a === void 0 ? void 0 : _a.onError(error, this.context, null);\r\n            },\r\n            onPiece: (peerId, pieceData) => {\r\n                if (this.stats.loading.first === 0) {\r\n                    this.stats.loading.first = Math.max(self.performance.now(), this.stats.loading.start);\r\n                }\r\n            },\r\n        };\r\n        p2pManager.load(segment, p2pCallbacks);\r\n    }\r\n    getCacheAge() {\r\n        return null;\r\n    }\r\n}\r\nexport class HybridFragmentLoader {\r\n    constructor(hlsConfig, engine) {\r\n        this.debug = Debug('p2pml:p2p-hybrid-loader');\r\n        this.hlsConfig = null;\r\n        this.xhrLoader = null;\r\n        this.callbacks = null;\r\n        this.hlsConfig = hlsConfig;\r\n        this.engine = engine;\r\n        this.stats = new LoadStats();\r\n    }\r\n    async load(context, config, callbacks) {\r\n        let keepP2PTimeout = 0;\r\n        if (HybridFragmentLoader.CacheStatus.latestUseP2P) {\r\n            this.debug('上次使用了 p2p，等待 100ms');\r\n            keepP2PTimeout = 100;\r\n        }\r\n        setTimeout(() => {\r\n            this.pendingLoad(context, config, callbacks);\r\n        }, keepP2PTimeout);\r\n    }\r\n    pendingLoad(context, config, callbacks) {\r\n        var _a;\r\n        const segment = createSegment(context);\r\n        const pendingTimeout = this.engine.p2pManager.checkPendingTimeout(segment);\r\n        const timeout = Math.min((((_a = context === null || context === void 0 ? void 0 : context.frag) === null || _a === void 0 ? void 0 : _a.duration) * 1000) / 2, pendingTimeout || 0);\r\n        this.debug('等待 pending 下载的超时时间', timeout);\r\n        setTimeout(() => {\r\n            const canP2P = this.engine.p2pManager.canDownload(segment);\r\n            if (canP2P) {\r\n                HybridFragmentLoader.CacheStatus.latestUseP2P = true;\r\n                this.p2pLoad(context, config, callbacks);\r\n            }\r\n            else {\r\n                HybridFragmentLoader.CacheStatus.latestUseP2P = false;\r\n                this.xhrLoad(context, config, callbacks);\r\n            }\r\n        }, timeout);\r\n    }\r\n    xhrLoad(context, config, callbacks) {\r\n        this.xhrLoader = new XhrLoader(this.hlsConfig);\r\n        this.callbacks = {\r\n            onSuccess: callbacks.onSuccess,\r\n            onError: callbacks.onError,\r\n            onTimeout: callbacks.onTimeout,\r\n            onAbort: callbacks.onAbort,\r\n            onProgress: (stats, context, data, networkDetails) => {\r\n                this.stats = stats;\r\n                const segment = createSegment(context, data);\r\n                this.engine.storeSegmentAndDelay(segment, { http: stats.loading.end - stats.loading.start });\r\n                this.engine.emit(Events.SegmentLoaded, segment, null);\r\n                callbacks.onProgress(stats, context, data, networkDetails);\r\n            },\r\n        };\r\n        const segment = createSegment(context);\r\n        this.engine.p2pManager.sendSegmentsPendingToAll(segment.id, this.engine.lastPendingDelay.http);\r\n        this.debug('使用 xhr 下载', segment.id);\r\n        this.xhrLoader.load(context, config, this.callbacks);\r\n    }\r\n    p2pLoad(context, config, callbacks) {\r\n        this.p2pLoader = new P2PFragmentLoader(this.engine);\r\n        this.callbacks = {\r\n            onSuccess: callbacks.onSuccess,\r\n            onError: () => {\r\n                this.xhrLoad(context, config, callbacks);\r\n            },\r\n            onTimeout: () => {\r\n                this.xhrLoad(context, config, callbacks);\r\n            },\r\n            onAbort: callbacks.onAbort,\r\n            onProgress: (stats, context, data, networkDetails) => {\r\n                this.stats = stats;\r\n                const segment = createSegment(context, data);\r\n                this.engine.storeSegmentAndDelay(segment, { p2p: stats.loading.end - stats.loading.start });\r\n                callbacks === null || callbacks === void 0 ? void 0 : callbacks.onProgress(stats, context, data, networkDetails);\r\n            },\r\n        };\r\n        const segment = createSegment(context);\r\n        this.engine.p2pManager.sendSegmentsPendingToAll(segment.id, this.engine.lastPendingDelay.p2p);\r\n        this.p2pLoader.load(context, config, this.callbacks);\r\n    }\r\n    abort() {\r\n        var _a, _b;\r\n        (_a = this.xhrLoader) === null || _a === void 0 ? void 0 : _a.abort();\r\n        (_b = this.p2pLoader) === null || _b === void 0 ? void 0 : _b.abort();\r\n    }\r\n    destroy() {\r\n        var _a, _b;\r\n        this.callbacks = null;\r\n        (_a = this.xhrLoader) === null || _a === void 0 ? void 0 : _a.destroy();\r\n        (_b = this.p2pLoader) === null || _b === void 0 ? void 0 : _b.destroy();\r\n    }\r\n    getCacheAge() {\r\n        var _a;\r\n        return (_a = this.xhrLoader) === null || _a === void 0 ? void 0 : _a.getCacheAge();\r\n    }\r\n}\r\nHybridFragmentLoader.CacheStatus = { latestUseP2P: false };\r\n","import { P2PEngine } from './p2pEngine';\r\nimport { HybridFragmentLoader } from './hybrid-fragment-loader';\r\nexport class HlsEngine extends P2PEngine {\r\n    constructor(swarmId, settings) {\r\n        super(swarmId, settings);\r\n        this.lastPendingDelay = { http: 0, p2p: 0 };\r\n    }\r\n    createLoaderClass() {\r\n        const engine = this;\r\n        return class LoaderClass extends HybridFragmentLoader {\r\n            constructor(hlsConfig) {\r\n                super(hlsConfig, engine);\r\n            }\r\n        };\r\n    }\r\n    storeSegmentAndDelay(segment, lastPendingDelay) {\r\n        super.storeSegment(segment);\r\n        this.lastPendingDelay = Object.assign(this.lastPendingDelay, lastPendingDelay);\r\n    }\r\n}\r\nHlsEngine.version = __VERSION__;\r\nwindow.HlsP2PEngine = HlsEngine;\r\n"],"names":["leafPrototypes","getProto","exports","byteLength","b64","lens","getLens","validLen","placeHoldersLen","toByteArray","tmp","i","arr","Arr","_byteLength","curByte","len","revLookup","charCodeAt","fromByteArray","uint8","length","extraBytes","parts","maxChunkLength","len2","push","encodeChunk","lookup","join","Uint8Array","Array","code","Error","indexOf","start","end","num","output","base64","ieee754","Buffer","SlowBuffer","alloc","INSPECT_MAX_BYTES","K_MAX_LENGTH","createBuffer","RangeError","buf","__proto__","prototype","arg","encodingOrOffset","TypeError","allocUnsafe","from","value","string","encoding","isEncoding","actual","write","slice","fromString","ArrayBuffer","isView","fromArrayLike","isInstance","buffer","array","byteOffset","undefined","fromArrayBuffer","valueOf","b","obj","isBuffer","checked","copy","numberIsNaN","type","isArray","data","fromObject","Symbol","toPrimitive","assertSize","size","toString","mustMatch","arguments","loweredCase","utf8ToBytes","base64ToBytes","toLowerCase","slowToString","this","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","n","m","bidirectionalIndexOf","val","dir","arrayIndexOf","call","lastIndexOf","indexSize","arrLength","valLength","String","read","readUInt16BE","foundIndex","found","j","hexWrite","offset","Number","remaining","strLen","parsed","parseInt","substr","utf8Write","blitBuffer","asciiWrite","str","byteArray","asciiToBytes","latin1Write","base64Write","ucs2Write","units","c","hi","lo","utf16leToBytes","Math","min","res","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","codePoint","bytesPerSequence","codePoints","MAX_ARGUMENTS_LENGTH","fromCharCode","apply","decodeCodePointsArray","kMaxLength","TYPED_ARRAY_SUPPORT","foo","e","typedArraySupport","console","error","Object","defineProperty","enumerable","get","species","configurable","writable","poolSize","fill","allocUnsafeSlow","_isBuffer","compare","a","x","y","concat","list","pos","swap16","swap32","swap64","toLocaleString","equals","inspect","max","replace","trim","target","thisStart","thisEnd","thisCopy","targetCopy","includes","isFinite","toJSON","_arr","ret","out","toHex","bytes","checkOffset","ext","checkInt","checkIEEE754","writeFloat","littleEndian","noAssert","writeDouble","newBuf","subarray","readUIntLE","mul","readUIntBE","readUInt8","readUInt16LE","readUInt32LE","readUInt32BE","readIntLE","pow","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUIntLE","writeUIntBE","writeUInt8","writeUInt16LE","writeUInt16BE","writeUInt32LE","writeUInt32BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","copyWithin","set","INVALID_BASE64_RE","Infinity","leadSurrogate","split","base64clean","src","dst","constructor","name","clone","_instanceof","nativeMap","nativeSet","nativePromise","Map","_","Set","Promise","parent","circular","depth","includeNonEnumerable","allParents","allChildren","useBuffer","_clone","child","proto","resolve","reject","then","err","__isArray","__isRegExp","RegExp","source","__getRegExpFlags","lastIndex","__isDate","Date","getTime","create","getPrototypeOf","index","forEach","key","keyChild","valueChild","entryChild","add","attrs","getOwnPropertyDescriptor","getOwnPropertySymbols","symbols","symbol","descriptor","allPropertyNames","getOwnPropertyNames","propertyName","__objToStr","o","re","flags","global","ignoreCase","multiline","clonePrototype","module","formatArgs","args","useColors","namespace","humanize","diff","color","splice","lastC","match","save","namespaces","storage","setItem","removeItem","load","r","getItem","env","DEBUG","window","process","__nwjs","navigator","userAgent","document","documentElement","style","WebkitAppearance","firebug","exception","table","$1","localStorage","localstorage","destroy","warned","warn","colors","log","debug","formatters","v","JSON","stringify","message","createDebug","prevTime","namespacesCache","enabledCache","enableOverride","enabled","self","curr","ms","prev","coerce","unshift","format","formatter","selectColor","extend","init","delimiter","newDebug","toNamespace","regexp","substring","default","stack","disable","names","map","skips","enable","test","keys","hash","abs","assign","props","ErrClass","ReflectOwnKeys","R","Reflect","ReflectApply","receiver","Function","ownKeys","NumberIsNaN","isNaN","EventEmitter","once","emitter","errorListener","removeListener","resolver","eventTargetAgnosticAddListener","handler","on","addErrorHandlerIfEventEmitter","_events","_eventsCount","_maxListeners","defaultMaxListeners","checkListener","listener","_getMaxListeners","that","_addListener","prepend","events","existing","warning","newListener","emit","w","count","onceWrapper","fired","wrapFn","_onceWrap","state","wrapped","bind","_listeners","unwrap","evlistener","unwrapListeners","arrayClone","listenerCount","addEventListener","wrapListener","removeEventListener","setMaxListeners","getMaxListeners","doError","er","context","listeners","addListener","prependListener","prependOnceListener","position","originalListener","shift","pop","spliceOne","off","removeAllListeners","rawListeners","eventNames","hwm","mask","top","btm","next","clear","last","peek","isEmpty","FixedFIFO","head","tail","globalThis","wrtc","RTCPeerConnection","mozRTCPeerConnection","webkitRTCPeerConnection","RTCSessionDescription","mozRTCSessionDescription","webkitRTCSessionDescription","RTCIceCandidate","mozRTCIceCandidate","webkitRTCIceCandidate","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","d","s","NaN","rt","floor","LN2","ctor","superCtor","super_","TempCtor","h","plural","msAbs","isPlural","round","options","exec","parseFloat","parse","long","fmtLong","fmtShort","wrappy","fn","f","called","onceStrict","onceError","strict","promise","queueMicrotask","g","cb","catch","setTimeout","tasks","results","pending","isSync","done","each","result","task","copyProps","SafeBuffer","Hash","blockSize","finalSize","_block","_finalSize","_blockSize","_len","update","enc","block","accum","assigned","remainder","_update","digest","rem","bits","lowBits","highBits","_hash","inherits","K","W","Sha1","_w","rotl5","rotl30","ft","_a","_b","_c","_d","_e","M","t","H","STREAM_DESTROYED","PREMATURE_CLOSE","queueTick","FIFO","MAX","NOT_OPENING","READ_PRIMARY","READ_QUEUED","READ_RESUMED","READ_ENDING","READ_EMIT_DATA","READ_EMIT_READABLE","READ_EMITTED_READABLE","READ_DONE","READ_NEXT_TICK","READ_PIPE_NOT_DRAINED","READ_NOT_NEXT_TICK","WRITE_ACTIVE","WRITE_UPDATING","WRITE_PRIMARY","WRITE_QUEUED","WRITE_UNDRAINED","WRITE_DONE","WRITE_EMIT_DRAIN","WRITE_NEXT_TICK","WRITE_WRITING","WRITE_FINISHING","WRITE_NOT_ACTIVE","WRITE_NON_PRIMARY","WRITE_NOT_NEXT_TICK","ACTIVE","READ_ACTIVE","NOT_ACTIVE","DONE","DESTROY_STATUS","DESTROYING","OPEN_STATUS","AUTO_DESTROY","ACTIVE_OR_TICKING","IS_OPENING","WRITE_QUEUED_AND_ACTIVE","WRITE_STATUS","asyncIterator","WritableState","stream","highWaterMark","mapWritable","byteLengthWritable","queue","buffered","pipeline","drains","defaultByteLength","afterWrite","afterUpdateNextTick","updateWriteNT","ended","_duplexState","autoBatch","_writableState","_writev","_write","updateNonPrimary","continueUpdate","_final","afterFinal","_open","afterOpen","_destroy","afterDestroy","updateCallback","updateNextTick","ReadableState","mapReadable","byteLengthReadable","pipeTo","afterRead","updateReadNT","pipe","Pipeline","noop","isStreamx","finished","onerror","onclose","afterDrain","drain","_read","READ_UPDATING","TransformState","afterTransform","to","afterPipe","pipeToFinished","rs","_readableState","ws","writes","tickDrains","Stream","opts","super","open","predestroy","_predestroy","signal","abort","readable","destroyed","destroying","Readable","OPENING","eagerOpen","dest","resume","pause","_fromAsyncIterator","ite","return","isBackpressured","isPaused","promiseResolve","promiseReject","ondata","throw","Writable","writev","final","batch","drained","Duplex","Transform","_transformState","transform","_transform","flush","_flush","transformAfterFlush","streams","all","errorHandle","fin","autoDestroy","rd","wr","isStream","isTypedArray","pipelinePromise","getStreamError","PassThrough","k","wrapper","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","getter","__esModule","mode","ns","def","current","definition","prop","hasOwnProperty","toStringTag","Events","alphabet","encodeLookup","decodeLookup","arr2hex","hex2arr","sizeof","chars","decoder","TextDecoder","arr2text","decode","encoder","TextEncoder","text2arr","encode","bin2hex","hex2bin","hex","points","scope","crypto","msCrypto","randomBytes","subtle","webkitSubtle","view","getRandomValues","Debug","MAX_BUFFERED_AMOUNT","filterTrickle","sdp","Peer","allowHalfOpen","__objectMode","objectMode","_id","_debug","channelName","initiator","channelConfig","channelNegotiated","negotiated","config","offerOptions","answerOptions","sdpTransform","trickle","allowHalfTrickle","iceCompleteTimeout","_destroying","_connected","remoteAddress","remoteFamily","remotePort","localAddress","localFamily","localPort","_wrtc","_pcReady","_channelReady","_iceComplete","_iceCompleteTimer","_channel","_pendingCandidates","_isNegotiating","_firstNegotiation","_batchedNegotiation","_queuedNegotiation","_sendersAwaitingStable","_closingInterval","_remoteTracks","_remoteStreams","_chunk","_cb","_interval","_pc","__destroy","_isReactNativeWebrtc","_peerConnectionId","oniceconnectionstatechange","_onIceStateChange","onicegatheringstatechange","onconnectionstatechange","_onConnectionStateChange","onsignalingstatechange","_onSignalingStateChange","onicecandidate","event","_onIceCandidate","peerIdentity","_setupData","channel","createDataChannel","ondatachannel","_needsNegotiation","_onFinishBound","_onFinish","bufferSize","bufferedAmount","connected","readyState","address","port","family","renegotiate","transceiverRequest","addTransceiver","kind","candidate","remoteDescription","_addIceCandidate","setRemoteDescription","_createAnswer","iceCandidateObj","addIceCandidate","endsWith","send","chunk","negotiate","_createOffer","_senderMap","clearInterval","close","onmessage","onopen","ontrack","binaryType","bufferedAmountLowThreshold","label","_onChannelMessage","onbufferedamountlow","_onChannelBufferedAmountLow","_onChannelOpen","_onChannelClose","filename","lineno","colno","isClosing","setInterval","destroySoon","_startIceCompleteTimeout","createOffer","offer","sendOffer","localDescription","setLocalDescription","createAnswer","answer","sendAnswer","_requestMissingTransceivers","connectionState","iceConnectionState","iceGatheringState","_maybeReady","getStats","flattenValues","report","values","reports","stat","id","timestamp","_connecting","findCandidatePair","items","remoteCandidates","localCandidates","candidatePairs","foundSelectedCandidatePair","item","setSelectedCandidatePair","selectedCandidatePair","local","localCandidateId","ip","ipAddress","portNumber","googLocalAddress","remote","remoteCandidateId","googRemoteAddress","selectedCandidatePairId","googActiveConnection","selected","_onInterval","unref","signalingState","sender","removeTrack","sdpMLineIndex","sdpMid","WEBRTC_SUPPORT","iceServers","urls","sdpSemantics","DEFAULT_ANNOUNCE_PEERS","MAX_ANNOUNCE_PEERS","parseUrl","url","URL","defineProperties","href","protocol","origin","_WebSocket","WebSocket","Socket","socket","_ws","OPEN","_handleOpen","_handleMessage","_handleClose","_handleError","_handleFinishBound","_handleFinish","onClose","CLOSED","WEBSOCKET_SUPPORT","client","announceUrl","interval","intervalMs","DEFAULT_ANNOUNCE_INTERVAL","announce","_defaultAnnounceOpts","socketPool","WebSocketTracker","peers","reconnecting","retries","reconnectTimer","expectingResponse","_openSocket","params","action","info_hash","_infoHashBinary","peer_id","_peerIdBinary","_trackerId","trackerid","_send","numwant","_generateOffers","offers","scrape","infoHash","clearTimeout","peerId","peer","trackerTimeout","_onSocketConnectBound","_onSocketDataBound","_onSocketCloseBound","_onSocketErrorBound","consumers","timeout","destroyCleanup","common","DESTROY_TIMEOUT","_onSocketConnect","_onSocketError","_onSocketData","_onSocketClose","parsedUrl","agent","_proxyOpts","httpsAgent","httpAgent","socksProxy","_onAnnounceResponse","_onScrapeResponse","failure","trackerId","complete","response","_createPeer","to_peer_id","offer_id","offerId","files","_startReconnectTimer","random","generateOffer","checkDone","_rtcConfig","onError","onConnect","_socketPool","browser","_peerIdBuffer","_infoHashBuffer","_port","_getAnnounceOpts","getAnnounceOpts","rtcConfig","_userAgent","proxyOpts","webrtcSupport","nextTickWarn","_trackers","location","filter","Boolean","_announce","tracker","stop","uploaded","downloaded","clientOpts","MediaPeerCommands","STEEmitter","DownloadingSegment","bytesDownloaded","pieces","loading","first","MediaPeer","settings","downloadingSegmentId","downloadingSegment","segmentsMap","pendingStatus","lastSegmentsSend_","timer","onPeerConnect","onPeerClose","terminateSegmentRequest","onPeerError","receiveSegmentPiece","performance","now","segmentId","segmentData","piece","getJsonCommand","onPeerData","command","SegmentsMap","SegmentRequest","SegmentData","cancelResponseTimeoutTimer","runResponseTimeoutTimer","SegmentsPending","SegmentAbsent","CancelSegmentRequest","sendCommand","getDownloadingSegmentId","checkPendingTimeout","getSegmentsMap","getPendingStatus","sendSegmentsMap","sendSegmentsPending","sendSegmentData","bytesLeft","bytesToSend","webRtcMaxMessageSize","sendSegmentAbsent","requestSegment","cancelSegmentRequest","p2pSegmentDownloadTimeout","canDownload","PEER_ID_VERSION_PREFIX","PeerSegmentRequest","segment","callbacks","P2PMediaManager","streamSwarmId","segmentsStorage","trackerClient","peerCandidates","peerSegmentRequests","peersCheckTimes","getPeers","getPeerId","createClient","clientOptions","trackerAnnounce","peerRequestsPerAnnounce","oldTrackerClient","onTrackerError","onTrackerWarning","onTrackerUpdate","onTrackerPeer","trackerPeer","has","onPeerDataUpdated","onSegmentRequest","onSegmentLoaded","onSegmentAbsent","onSegmentError","onSegmentTimeout","onPieceBytesDownloaded","onPieceBytesUploaded","peerCandidatesById","timeoutList","candidates","peerSegmentRequest","delete","isDownloading","getActiveDownloadsCount","swarmChange","peerCandidateById","peerCandidate","sendSegmentsMapToAll","sendSegmentsPendingToAll","segmentsPending","delay","onPiece","getSegment","async","onSuccess","description","PEER_ID_SYMBOLS","charAt","generatePeerId","SegmentsMemoryStorage","segments","storeSegment","limitCount","cachedSegmentsCount","getSegments","find","defaultSettings","P2PEngine","swarmId","SegmentLoaded","details","SegmentError","onPeerSegmentsMapUpdated","PeerConnect","PeerClose","broadcastSegmentsMap","p2pManager","getSettings","isSupported","LoadStats","aborted","loaded","retry","total","chunkCount","bwEstimate","parsing","buffering","fakeLogger","trace","info","exportedLogger","logger","AGE_HEADER_LINE_REGEX","loader","xhrSetup","stats","retryDelay","abortInternal","requestTimeout","retryTimeout","onreadystatechange","onprogress","onAbort","loadInternal","xhr","XMLHttpRequest","headers","header","setRequestHeader","status","text","rangeEnd","rangeStart","readystatechange","loadprogress","responseType","loadtimeout","isArrayBuffer","responseText","onProgress","responseURL","maxRetry","statusText","maxRetryDelay","onTimeout","lengthComputable","getCacheAge","getAllResponseHeaders","ageHeader","getResponseHeader","createSegment","streamId","frag","baseurl","range","P2PFragmentLoader","engine","fragDuration","duration","minTimeout","p2pCallbacks","pieceData","HybridFragmentLoader","hlsConfig","xhrLoader","keepP2PTimeout","CacheStatus","latestUseP2P","pendingLoad","pendingTimeout","p2pLoad","xhrLoad","networkDetails","storeSegmentAndDelay","http","lastPendingDelay","p2pLoader","p2p","HlsEngine","createLoaderClass","version","HlsP2PEngine"],"sourceRoot":""}