{"version":3,"file":"adb-monkey.js","mappings":"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","sources":["webpack://@warren-bank/adb-monkey/./node_modules/@warren-bank/url/es6-node/jsURL.js","webpack://@warren-bank/adb-monkey/./node_modules/base64-js/index.js","webpack://@warren-bank/adb-monkey/./node_modules/blob-to-buffer/index.js","webpack://@warren-bank/adb-monkey/./node_modules/buffer/index.js","webpack://@warren-bank/adb-monkey/./node_modules/events/events.js","webpack://@warren-bank/adb-monkey/./node_modules/ieee754/index.js","webpack://@warren-bank/adb-monkey/./node_modules/net-websocket-polyfill/index.js","webpack://@warren-bank/adb-monkey/./node_modules/net-websocket-polyfill/src/connect.js","webpack://@warren-bank/adb-monkey/./node_modules/net-websocket-polyfill/src/events.js","webpack://@warren-bank/adb-monkey/./node_modules/net-websocket-polyfill/src/index.js","webpack://@warren-bank/adb-monkey/./node_modules/net-websocket-polyfill/src/utils.js","webpack://@warren-bank/adb-monkey/../src/monkey.js","webpack://@warren-bank/adb-monkey/../src/monkey/api.js","webpack://@warren-bank/adb-monkey/../src/monkey/client.js","webpack://@warren-bank/adb-monkey/../src/monkey/command.js","webpack://@warren-bank/adb-monkey/../src/monkey/connection.js","webpack://@warren-bank/adb-monkey/../src/monkey/multi.js","webpack://@warren-bank/adb-monkey/../src/monkey/parser.js","webpack://@warren-bank/adb-monkey/../src/monkey/queue.js","webpack://@warren-bank/adb-monkey/../src/monkey/reply.js","webpack://@warren-bank/adb-monkey/webpack/bootstrap","webpack://@warren-bank/adb-monkey/webpack/runtime/node module decorator","webpack://@warren-bank/adb-monkey/./src/globals.js"],"sourcesContent":["const regexs = {\r\n  url:  new RegExp('^([^/:]+:)?(?://(?:([^/:@]+):?([^/:@]+)?@)?([^:/\\\\?#]+)(?::(\\\\d+))?)?(/[^\\\\?#]*|[^\\\\?#]+)?(\\\\?[^#]*)?(#.*)?$'),\r\n  host: /^([^:]+)(?::(\\d+))?$/\r\n}\r\n\r\nclass URL {\r\n  #_searchParams = ''\r\n\r\n  constructor(url, base) {\r\n    if (base)\r\n      url = URL.resolve(url, base) || ''\r\n\r\n    this.href = url\r\n  }\r\n\r\n  static resolve(url, base) {\r\n    const srcURL = new URL(base)\r\n    const dstURL = new URL(url)\r\n\r\n    const fields = ['protocol', 'username', 'password', 'hostname', 'port', 'pathname', 'search', 'hash']\r\n\r\n    // copy missing fields in order, and stop when the 1st populated field is encountered.\r\n    // when the 1st populated field is pathname, do the equivalent to: path.join(base_pathname, url_pathname)\r\n    for (let i=0; i < fields.length; i++) {\r\n      let field = fields[i]\r\n\r\n      if ((field === 'pathname') && dstURL[field] && srcURL[field] && (dstURL[field][0] !== '/'))\r\n        dstURL[field] = srcURL[field].replace(/[^\\/]*$/, '') + dstURL[field]\r\n      if (dstURL[field])\r\n        break\r\n      if (srcURL[field])\r\n        dstURL[field] = srcURL[field]\r\n    }\r\n\r\n    return dstURL.toString()\r\n  }\r\n\r\n  toString() {\r\n    return `${this.protocol}${this.host ? `//${this.username ? (this.password ? `${this.username}:${this.password}@` : `${this.username}@`) : ''}${this.host}` : ''}${this.pathname}${this.search}${this.hash}`\r\n  }\r\n\r\n  toJSON() {\r\n    return this.toString()\r\n  }\r\n\r\n  get href() {\r\n    return this.toString()\r\n  }\r\n\r\n  set href(url) {\r\n    const matches = regexs.url.exec(url)\r\n    if (!matches) throw new Error(\"Failed to construct 'URL': Invalid URL\")\r\n\r\n    this.protocol     = matches[1] || ''\r\n    this.username     = matches[2] || ''\r\n    this.password     = matches[3] || ''\r\n    this.hostname     = matches[4] || ''\r\n    this.port         = matches[5] || ''\r\n    this.pathname     = matches[6] || ''\r\n    this.search       = matches[7] || ''\r\n    this.hash         = matches[8] || ''\r\n  }\r\n\r\n  get host() {\r\n    return this.port ? `${this.hostname}:${this.port}` : this.hostname\r\n  }\r\n\r\n  set host(host) {\r\n    const matches = regexs.host.exec(host)\r\n    if (!matches) throw new Error(\"Failed to update 'URL': Invalid host\")\r\n\r\n    this.hostname     = matches[1] || ''\r\n    this.port         = matches[2] || ''\r\n  }\r\n\r\n  // read-only\r\n  get origin() {\r\n    return `${this.protocol}//${this.host}`\r\n  }\r\n\r\n  get search() {\r\n    return this.#_searchParams.toString()\r\n  }\r\n\r\n  set search(search) {\r\n    this.#_searchParams = new URLSearchParams(search)\r\n  }\r\n\r\n  // read-only\r\n  get searchParams() {\r\n    return this.#_searchParams\r\n  }\r\n\r\n  // ===================\r\n  // additional methods:\r\n  // ===================\r\n\r\n  parse(parseQueryString = false) {\r\n    return {\r\n      slashes:  true,\r\n      href:     this.href,\r\n      protocol: this.protocol,\r\n      username: this.username,\r\n      password: this.password,\r\n      auth:     `${this.username ? (this.password ? `${this.username}:${this.password}` : `${this.username}`) : ''}`,\r\n      hostname: this.hostname,\r\n      port:     this.port,\r\n      host:     this.host,\r\n      pathname: this.pathname,\r\n      search:   this.search,\r\n      path:     `${this.pathname}${this.search}`,\r\n      query:    (parseQueryString ? this.searchParams.parse() : this.searchParams.toString(/* exclude_question_mark= */ true)),\r\n      hash:     this.hash\r\n    }\r\n  }\r\n}\r\n\r\nclass URLSearchParams {\r\n  #_map    = {}\r\n  #_sorted = false\r\n\r\n  constructor(search) {\r\n    this.#_map = {}\r\n\r\n    if (search && (search[0] === '?'))\r\n      search = search.substring(1)\r\n\r\n    if (search) {\r\n      const pairs = search.split('&')\r\n      pairs.forEach(pair => {\r\n        const index = pair.indexOf('=')\r\n\r\n        if (index > 0) {\r\n          const key = pair.substring(0, index)\r\n          const val = (index + 1 < pair.length) ? pair.substring(index + 1) : ''\r\n\r\n          if (!this.#_map[key])\r\n            this.#_map[key] = []\r\n\r\n          this.#_map[key].push(val)\r\n        }\r\n      })\r\n    }\r\n  }\r\n\r\n  has(key) {\r\n    return !!this.#_map[key]\r\n  }\r\n\r\n  get(key) {\r\n    return this.#_map[key] ? this.#_map[key][0] : null\r\n  }\r\n\r\n  getAll(key) {\r\n    return this.#_map[key] ? [...this.#_map[key]] : []\r\n  }\r\n\r\n  set(key, val) {\r\n    this.#_map[key] = [val]\r\n  }\r\n\r\n  append(key, val) {\r\n    if (!this.#_map[key])\r\n      this.#_map[key] = []\r\n\r\n    this.#_map[key].push(val)\r\n  }\r\n\r\n  delete(key, val) {\r\n    if (!this.#_map[key]) return\r\n\r\n    if (val) {\r\n      const index = this.#_map[key].indexOf(val)\r\n      if (index >= 0) {\r\n        this.#_map[key].splice(index, 1)\r\n\r\n        if (!this.#_map[key].length)\r\n          delete this.#_map[key]\r\n      }\r\n    }\r\n    else {\r\n      delete this.#_map[key]\r\n    }\r\n  }\r\n\r\n  sort(sorted = true) {\r\n    this.#_sorted = !!sorted\r\n  }\r\n\r\n  keys() {\r\n    const keys = Object.keys(this.#_map)\r\n    if (this.#_sorted) keys.sort()\r\n    return keys\r\n  }\r\n\r\n  values() {\r\n    const values = []\r\n    for (const key in this.#_map) {\r\n      values.push(...this.#_map[key])\r\n    }\r\n    if (this.#_sorted) values.sort()\r\n    return values\r\n  }\r\n\r\n  entries() {\r\n    const denormalized = []\r\n    const keys = this.keys()\r\n    keys.forEach(key => {\r\n      const vals = this.#_sorted\r\n        ? [...this.#_map[key]].sort()\r\n        : this.#_map[key]\r\n      vals.forEach(val => {\r\n        denormalized.push([key, val])\r\n      })\r\n    })\r\n    return denormalized\r\n  }\r\n\r\n  forEach(callback, thisArg) {\r\n    const denormalized = this.entries()\r\n    denormalized.forEach(([key, val]) => {\r\n      callback.apply(thisArg, [val, key, this])\r\n    })\r\n  }\r\n\r\n  toString(exclude_question_mark = false) {\r\n    let search = ''\r\n    const denormalized = this.entries()\r\n    denormalized.forEach(([key, val]) => {\r\n      let prefix = search ? '&' : exclude_question_mark ? '' : '?'\r\n      search += `${prefix}${key}=${val}`\r\n    })\r\n    return search\r\n  }\r\n\r\n  toJSON() {\r\n    return this.toString()\r\n  }\r\n\r\n  // ===================\r\n  // additional methods:\r\n  // ===================\r\n\r\n  parse() {\r\n    const map_clone = {}\r\n    for (const key in this.#_map) {\r\n      map_clone[key] = [...this.#_map[key]]\r\n    }\r\n    return map_clone\r\n  }\r\n}\r\n\r\nconst parse = (url, parseQueryString = false) => {\r\n  return (new URL(url)).parse(parseQueryString)\r\n}\r\n\r\nconst resolve = (base, url) => URL.resolve(url, base)\r\n\r\ntry {\r\n  if (module instanceof Object)\r\n    module.exports = {URL, URLSearchParams, parse, resolve}\r\n}\r\ncatch(e) {}\r\n\r\ntry {\r\n  if (window instanceof Object)\r\n    window.jsURL = {URL, URLSearchParams, parse, resolve}\r\n}\r\ncatch(e) {}\r\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","/*! blob-to-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */\n/* global Blob, FileReader */\n\nmodule.exports = function blobToBuffer (blob, cb) {\n  if (typeof Blob === 'undefined' || !(blob instanceof Blob)) {\n    throw new Error('first argument must be a Blob')\n  }\n  if (typeof cb !== 'function') {\n    throw new Error('second argument must be a function')\n  }\n\n  const reader = new FileReader()\n\n  function onLoadEnd (e) {\n    reader.removeEventListener('loadend', onLoadEnd, false)\n    if (e.error) cb(e.error)\n    else cb(null, Buffer.from(reader.result))\n  }\n\n  reader.addEventListener('loadend', onLoadEnd, false)\n  reader.readAsArrayBuffer(blob)\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\nconst base64 = require('base64-js')\nconst ieee754 = require('ieee754')\nconst customInspectSymbol =\n  (typeof Symbol === 'function' && typeof Symbol['for'] === 'function') // eslint-disable-line dot-notation\n    ? Symbol['for']('nodejs.util.inspect.custom') // eslint-disable-line dot-notation\n    : null\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\nconst 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    const arr = new Uint8Array(1)\n    const proto = { foo: function () { return 42 } }\n    Object.setPrototypeOf(proto, Uint8Array.prototype)\n    Object.setPrototypeOf(arr, proto)\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  const buf = new Uint8Array(length)\n  Object.setPrototypeOf(buf, 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\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 fromArrayView(value)\n  }\n\n  if (value == null) {\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  if (isInstance(value, ArrayBuffer) ||\n      (value && isInstance(value.buffer, ArrayBuffer))) {\n    return fromArrayBuffer(value, encodingOrOffset, length)\n  }\n\n  if (typeof SharedArrayBuffer !== 'undefined' &&\n      (isInstance(value, SharedArrayBuffer) ||\n      (value && isInstance(value.buffer, SharedArrayBuffer)))) {\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  const valueOf = value.valueOf && value.valueOf()\n  if (valueOf != null && valueOf !== value) {\n    return Buffer.from(valueOf, encodingOrOffset, length)\n  }\n\n  const 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(value[Symbol.toPrimitive]('string'), encodingOrOffset, length)\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\nObject.setPrototypeOf(Buffer.prototype, Uint8Array.prototype)\nObject.setPrototypeOf(Buffer, 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 interpreted 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  const length = byteLength(string, encoding) | 0\n  let buf = createBuffer(length)\n\n  const 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  const length = array.length < 0 ? 0 : checked(array.length) | 0\n  const buf = createBuffer(length)\n  for (let i = 0; i < length; i += 1) {\n    buf[i] = array[i] & 255\n  }\n  return buf\n}\n\nfunction fromArrayView (arrayView) {\n  if (isInstance(arrayView, Uint8Array)) {\n    const copy = new Uint8Array(arrayView)\n    return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength)\n  }\n  return fromArrayLike(arrayView)\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  let 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  Object.setPrototypeOf(buf, Buffer.prototype)\n\n  return buf\n}\n\nfunction fromObject (obj) {\n  if (Buffer.isBuffer(obj)) {\n    const len = checked(obj.length) | 0\n    const 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  let x = a.length\n  let y = b.length\n\n  for (let 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  let 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  const buffer = Buffer.allocUnsafe(length)\n  let pos = 0\n  for (i = 0; i < list.length; ++i) {\n    let buf = list[i]\n    if (isInstance(buf, Uint8Array)) {\n      if (pos + buf.length > buffer.length) {\n        if (!Buffer.isBuffer(buf)) buf = Buffer.from(buf)\n        buf.copy(buffer, pos)\n      } else {\n        Uint8Array.prototype.set.call(\n          buffer,\n          buf,\n          pos\n        )\n      }\n    } else if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    } else {\n      buf.copy(buffer, pos)\n    }\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  const len = string.length\n  const mustMatch = (arguments.length > 2 && arguments[2] === true)\n  if (!mustMatch && len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  let 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  let 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 coercion 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  const i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  const len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (let i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  const len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (let 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  const len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (let 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  const 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  let str = ''\n  const 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}\nif (customInspectSymbol) {\n  Buffer.prototype[customInspectSymbol] = Buffer.prototype.inspect\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  let x = thisEnd - thisStart\n  let y = end - start\n  const len = Math.min(x, y)\n\n  const thisCopy = this.slice(thisStart, thisEnd)\n  const targetCopy = target.slice(start, end)\n\n  for (let 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  let indexSize = 1\n  let arrLength = arr.length\n  let 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  let i\n  if (dir) {\n    let 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      let found = true\n      for (let 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  const 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  const strLen = string.length\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  let i\n  for (i = 0; i < length; ++i) {\n    const 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 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  const 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  let 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      case 'latin1':\n      case 'binary':\n        return asciiWrite(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  const res = []\n\n  let i = start\n  while (i < end) {\n    const firstByte = buf[i]\n    let codePoint = null\n    let bytesPerSequence = (firstByte > 0xEF)\n      ? 4\n      : (firstByte > 0xDF)\n          ? 3\n          : (firstByte > 0xBF)\n              ? 2\n              : 1\n\n    if (i + bytesPerSequence <= end) {\n      let 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\nconst MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  const 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  let res = ''\n  let 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  let ret = ''\n  end = Math.min(buf.length, end)\n\n  for (let i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  let ret = ''\n  end = Math.min(buf.length, end)\n\n  for (let i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  const len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  let out = ''\n  for (let i = start; i < end; ++i) {\n    out += hexSliceLookupTable[buf[i]]\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  const bytes = buf.slice(start, end)\n  let res = ''\n  // If bytes.length is odd, the last 8 bits must be ignored (same as node.js)\n  for (let i = 0; i < bytes.length - 1; 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  const 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  const newBuf = this.subarray(start, end)\n  // Return an augmented `Uint8Array` instance\n  Object.setPrototypeOf(newBuf, Buffer.prototype)\n\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 =\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  let val = this[offset]\n  let mul = 1\n  let i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUintBE =\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  let val = this[offset + --byteLength]\n  let mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUint8 =\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 =\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 =\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 =\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 =\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.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE (offset) {\n  offset = offset >>> 0\n  validateNumber(offset, 'offset')\n  const first = this[offset]\n  const last = this[offset + 7]\n  if (first === undefined || last === undefined) {\n    boundsError(offset, this.length - 8)\n  }\n\n  const lo = first +\n    this[++offset] * 2 ** 8 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 24\n\n  const hi = this[++offset] +\n    this[++offset] * 2 ** 8 +\n    this[++offset] * 2 ** 16 +\n    last * 2 ** 24\n\n  return BigInt(lo) + (BigInt(hi) << BigInt(32))\n})\n\nBuffer.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE (offset) {\n  offset = offset >>> 0\n  validateNumber(offset, 'offset')\n  const first = this[offset]\n  const last = this[offset + 7]\n  if (first === undefined || last === undefined) {\n    boundsError(offset, this.length - 8)\n  }\n\n  const hi = first * 2 ** 24 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 8 +\n    this[++offset]\n\n  const lo = this[++offset] * 2 ** 24 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 8 +\n    last\n\n  return (BigInt(hi) << BigInt(32)) + BigInt(lo)\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  let val = this[offset]\n  let mul = 1\n  let 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  let i = byteLength\n  let mul = 1\n  let 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  const 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  const 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.readBigInt64LE = defineBigIntMethod(function readBigInt64LE (offset) {\n  offset = offset >>> 0\n  validateNumber(offset, 'offset')\n  const first = this[offset]\n  const last = this[offset + 7]\n  if (first === undefined || last === undefined) {\n    boundsError(offset, this.length - 8)\n  }\n\n  const val = this[offset + 4] +\n    this[offset + 5] * 2 ** 8 +\n    this[offset + 6] * 2 ** 16 +\n    (last << 24) // Overflow\n\n  return (BigInt(val) << BigInt(32)) +\n    BigInt(first +\n    this[++offset] * 2 ** 8 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 24)\n})\n\nBuffer.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE (offset) {\n  offset = offset >>> 0\n  validateNumber(offset, 'offset')\n  const first = this[offset]\n  const last = this[offset + 7]\n  if (first === undefined || last === undefined) {\n    boundsError(offset, this.length - 8)\n  }\n\n  const val = (first << 24) + // Overflow\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 8 +\n    this[++offset]\n\n  return (BigInt(val) << BigInt(32)) +\n    BigInt(this[++offset] * 2 ** 24 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 8 +\n    last)\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 =\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) {\n    const maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  let mul = 1\n  let 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 =\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) {\n    const maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  let i = byteLength - 1\n  let 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 =\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 =\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 =\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 =\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 =\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\nfunction wrtBigUInt64LE (buf, value, offset, min, max) {\n  checkIntBI(value, min, max, buf, offset, 7)\n\n  let lo = Number(value & BigInt(0xffffffff))\n  buf[offset++] = lo\n  lo = lo >> 8\n  buf[offset++] = lo\n  lo = lo >> 8\n  buf[offset++] = lo\n  lo = lo >> 8\n  buf[offset++] = lo\n  let hi = Number(value >> BigInt(32) & BigInt(0xffffffff))\n  buf[offset++] = hi\n  hi = hi >> 8\n  buf[offset++] = hi\n  hi = hi >> 8\n  buf[offset++] = hi\n  hi = hi >> 8\n  buf[offset++] = hi\n  return offset\n}\n\nfunction wrtBigUInt64BE (buf, value, offset, min, max) {\n  checkIntBI(value, min, max, buf, offset, 7)\n\n  let lo = Number(value & BigInt(0xffffffff))\n  buf[offset + 7] = lo\n  lo = lo >> 8\n  buf[offset + 6] = lo\n  lo = lo >> 8\n  buf[offset + 5] = lo\n  lo = lo >> 8\n  buf[offset + 4] = lo\n  let hi = Number(value >> BigInt(32) & BigInt(0xffffffff))\n  buf[offset + 3] = hi\n  hi = hi >> 8\n  buf[offset + 2] = hi\n  hi = hi >> 8\n  buf[offset + 1] = hi\n  hi = hi >> 8\n  buf[offset] = hi\n  return offset + 8\n}\n\nBuffer.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE (value, offset = 0) {\n  return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt('0xffffffffffffffff'))\n})\n\nBuffer.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE (value, offset = 0) {\n  return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt('0xffffffffffffffff'))\n})\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    const limit = Math.pow(2, (8 * byteLength) - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  let i = 0\n  let mul = 1\n  let 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    const limit = Math.pow(2, (8 * byteLength) - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  let i = byteLength - 1\n  let mul = 1\n  let 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\nBuffer.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE (value, offset = 0) {\n  return wrtBigUInt64LE(this, value, offset, -BigInt('0x8000000000000000'), BigInt('0x7fffffffffffffff'))\n})\n\nBuffer.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE (value, offset = 0) {\n  return wrtBigUInt64BE(this, value, offset, -BigInt('0x8000000000000000'), BigInt('0x7fffffffffffffff'))\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  const 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 {\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      const 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  } else if (typeof val === 'boolean') {\n    val = Number(val)\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  let i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    const bytes = Buffer.isBuffer(val)\n      ? val\n      : Buffer.from(val, encoding)\n    const 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// CUSTOM ERRORS\n// =============\n\n// Simplified versions from Node, changed for Buffer-only usage\nconst errors = {}\nfunction E (sym, getMessage, Base) {\n  errors[sym] = class NodeError extends Base {\n    constructor () {\n      super()\n\n      Object.defineProperty(this, 'message', {\n        value: getMessage.apply(this, arguments),\n        writable: true,\n        configurable: true\n      })\n\n      // Add the error code to the name to include it in the stack trace.\n      this.name = `${this.name} [${sym}]`\n      // Access the stack to generate the error message including the error code\n      // from the name.\n      this.stack // eslint-disable-line no-unused-expressions\n      // Reset the name to the actual name.\n      delete this.name\n    }\n\n    get code () {\n      return sym\n    }\n\n    set code (value) {\n      Object.defineProperty(this, 'code', {\n        configurable: true,\n        enumerable: true,\n        value,\n        writable: true\n      })\n    }\n\n    toString () {\n      return `${this.name} [${sym}]: ${this.message}`\n    }\n  }\n}\n\nE('ERR_BUFFER_OUT_OF_BOUNDS',\n  function (name) {\n    if (name) {\n      return `${name} is outside of buffer bounds`\n    }\n\n    return 'Attempt to access memory outside buffer bounds'\n  }, RangeError)\nE('ERR_INVALID_ARG_TYPE',\n  function (name, actual) {\n    return `The \"${name}\" argument must be of type number. Received type ${typeof actual}`\n  }, TypeError)\nE('ERR_OUT_OF_RANGE',\n  function (str, range, input) {\n    let msg = `The value of \"${str}\" is out of range.`\n    let received = input\n    if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {\n      received = addNumericalSeparator(String(input))\n    } else if (typeof input === 'bigint') {\n      received = String(input)\n      if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) {\n        received = addNumericalSeparator(received)\n      }\n      received += 'n'\n    }\n    msg += ` It must be ${range}. Received ${received}`\n    return msg\n  }, RangeError)\n\nfunction addNumericalSeparator (val) {\n  let res = ''\n  let i = val.length\n  const start = val[0] === '-' ? 1 : 0\n  for (; i >= start + 4; i -= 3) {\n    res = `_${val.slice(i - 3, i)}${res}`\n  }\n  return `${val.slice(0, i)}${res}`\n}\n\n// CHECK FUNCTIONS\n// ===============\n\nfunction checkBounds (buf, offset, byteLength) {\n  validateNumber(offset, 'offset')\n  if (buf[offset] === undefined || buf[offset + byteLength] === undefined) {\n    boundsError(offset, buf.length - (byteLength + 1))\n  }\n}\n\nfunction checkIntBI (value, min, max, buf, offset, byteLength) {\n  if (value > max || value < min) {\n    const n = typeof min === 'bigint' ? 'n' : ''\n    let range\n    if (byteLength > 3) {\n      if (min === 0 || min === BigInt(0)) {\n        range = `>= 0${n} and < 2${n} ** ${(byteLength + 1) * 8}${n}`\n      } else {\n        range = `>= -(2${n} ** ${(byteLength + 1) * 8 - 1}${n}) and < 2 ** ` +\n                `${(byteLength + 1) * 8 - 1}${n}`\n      }\n    } else {\n      range = `>= ${min}${n} and <= ${max}${n}`\n    }\n    throw new errors.ERR_OUT_OF_RANGE('value', range, value)\n  }\n  checkBounds(buf, offset, byteLength)\n}\n\nfunction validateNumber (value, name) {\n  if (typeof value !== 'number') {\n    throw new errors.ERR_INVALID_ARG_TYPE(name, 'number', value)\n  }\n}\n\nfunction boundsError (value, length, type) {\n  if (Math.floor(value) !== value) {\n    validateNumber(value, type)\n    throw new errors.ERR_OUT_OF_RANGE(type || 'offset', 'an integer', value)\n  }\n\n  if (length < 0) {\n    throw new errors.ERR_BUFFER_OUT_OF_BOUNDS()\n  }\n\n  throw new errors.ERR_OUT_OF_RANGE(type || 'offset',\n                                    `>= ${type ? 1 : 0} and <= ${length}`,\n                                    value)\n}\n\n// HELPER FUNCTIONS\n// ================\n\nconst 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 utf8ToBytes (string, units) {\n  units = units || Infinity\n  let codePoint\n  const length = string.length\n  let leadSurrogate = null\n  const bytes = []\n\n  for (let 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  const byteArray = []\n  for (let 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  let c, hi, lo\n  const byteArray = []\n  for (let 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  let i\n  for (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\n// Create lookup table for `toString('hex')`\n// See: https://github.com/feross/buffer/issues/219\nconst hexSliceLookupTable = (function () {\n  const alphabet = '0123456789abcdef'\n  const table = new Array(256)\n  for (let i = 0; i < 16; ++i) {\n    const i16 = i * 16\n    for (let j = 0; j < 16; ++j) {\n      table[i16 + j] = alphabet[i] + alphabet[j]\n    }\n  }\n  return table\n})()\n\n// Return not function with Error if BigInt not supported\nfunction defineBigIntMethod (fn) {\n  return typeof BigInt === 'undefined' ? BufferBigIntNotDefined : fn\n}\n\nfunction BufferBigIntNotDefined () {\n  throw new Error('BigInt not supported')\n}\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","/*! 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","const net = require('./src')\n\nmodule.exports = net","var configureEvents = require(\"./events.js\")\n\nmodule.exports = async (args) => {\n  var connectListener\n\n    if (typeof args[0] == \"string\") {\n      self.url = new URL(args[0])\n      if (typeof args[1] == \"function\") {\n        connectListener = args[1]\n      } \n    }\n    else if (typeof args[0] == \"object\") {\n      self.url = new URL('ws://' + args[0].host)\n      self.url.port = args[0].port\n    }\n    else if (typeof args[0] == \"number\") {\n      self.url = new URL('ws://localhost')\n      self.url.port = args[0]\n      if (typeof args[1] == \"string\") {\n        self.url.hostname = args[1]\n        if (typeof args[2] == \"function\") {\n          connectListener = args[2]\n        }\n      }\n    }\n    \n    if (connectListener) {\n      self.on('connect', connectListener)\n    }\n    self.socket = new WebSocket(self.url.href)\n    configureEvents(self)\n    return self\n}","/* Handles websocket events ---> socket events for \napplications that need it */\n\nconst toBuffer = require('blob-to-buffer')\n\nmodule.exports = function(instance) {\n  instance.socket.onclose = (event) => {\n    if (event.code == 1006) {\n      instance.emit('close', { hadError: true })\n    }\n    else {\n      instance.emit('close', { hadError: false})\n    }\n  }\n  instance.socket.onerror = (event) => {\n    instance.emit('error', event.message)\n  }\n  instance.socket.onmessage = (event) => {\n    /* Data format depends on what proxy is used\n    so we'll try to support as many as we can */\n\n    if (instance.encoding == \"binary\") {\n      if (event.data instanceof Blob) {\n        toBuffer(event.data, (err, buf) => { \n          if (err) throw err\n        \n          instance.emit(\"data\", buf)\n        })\n      } else if (typeof event.data == \"string\") {\n        return Buffer.from(event.data)\n      }\n    } else if (instance.encoding == \"utf8\") {\n      if (event.data instanceof Blob) {\n        var reader = new FileReader()\n        reader.onload = () => {\n          instance.emit('data', reader.result)\n        }\n        reader.readAsText(event.data)\n      } else if (typeof event.data == \"string\") {\n        instance.emit('data', event.data) \n      }\n    }\n  }\n  instance.socket.onopen = (event) => {\n    instance.emit(\"connect\") /* Nothing else */\n    instance.emit(\"ready\")\n  }\n}","var events = require('events')\nvar url = require('url');\n\nvar socketUtils = require('./utils.js')\nvar connectSocket = require('./connect.js')\n\nclass socket extends events.EventEmitter {\n  constructor(options) {\n    super()\n  }\n  connect() {\n    self = this //we can access this from inside connectSocket\n    connectSocket(arguments)\n  }\n\n  write(data, encoding, callback) {\n    /* We can take a string, Buffer, or Uint8Array\n    and we need to make it into a string, Blob,\n    or ArrayBuffer */\n    \n    if (typeof data == \"string\")\n      this.socket.send(data)\n    else {\n      this.socket.send(new Blob([data])) \n    }\n\n      /*\n    this.socket.send(new Blob([data])) */\n\n    if (typeof callback == \"function\") {\n      callback()\n    }\n  }\n  setEncoding(encoding) {\n    if (encoding == \"utf8\")\n        this.encoding = encoding\n    else\n        this.encoding = \"binary\"\n  }\n  get connecting() {\n    return (this.socket.readyState == this.socket.CONNECTING)\n  }\n  destroy(exception = null) {\n    this.socket.close(1000, \"destroy called\")\n    this.emit('error', exception)\n    return this\n  }\n  get remotePort() {\n    return this.url.port\n  }\n\n  get bufferSize() {\n    socketUtils.bufferSize(this)\n  }\n  get destroyed() {\n    socketUtils.destroyed(this)\n  }\n  address() {\n\n  }\n  get remoteAddress() {\n\n  }\n}\n\nmodule.exports.Socket = socket\n","var utils = {}\n\nutils.address = function(instance) {\n    return instance.socket.bufferedSize\n}\nutils.destroyed = function(instance) {\n    return (instance.socket.readyState == instance.socket.CLOSED)\n}\nutils.bufferSize = function(instance) {\n    return instance.socket.bufferedSize\n}\n\nmodule.exports = utils","const Client = require('./monkey/client');\r\nconst Connection = require('./monkey/connection');\r\n\r\nclass Monkey {\r\n\r\n  static connect(options) {\r\n    return new Connection().connect(options);\r\n  }\r\n\r\n  static connectStream(stream) {\r\n    return new Client().connect(stream);\r\n  }\r\n}\r\n\r\nMonkey.Connection = Connection;\r\nMonkey.Client = Client;\r\n\r\nmodule.exports = Monkey;\r\n","const {EventEmitter} = require('events');\r\n\r\nclass Api extends EventEmitter {\r\n  constructor(options) {\r\n    super(options)\r\n  }\r\n\r\n  send() {\r\n    throw new Error(\"send is not implemented\");\r\n  }\r\n\r\n  keyDown(keyCode, callback) {\r\n    this.send(`key down ${keyCode}`, callback);\r\n    return this;\r\n  }\r\n\r\n  keyUp(keyCode, callback) {\r\n    this.send(`key up ${keyCode}`, callback);\r\n    return this;\r\n  }\r\n\r\n  touchDown(x, y, callback) {\r\n    this.send(`touch down ${x} ${y}`, callback);\r\n    return this;\r\n  }\r\n\r\n  touchUp(x, y, callback) {\r\n    this.send(`touch up ${x} ${y}`, callback);\r\n    return this;\r\n  }\r\n\r\n  touchMove(x, y, callback) {\r\n    this.send(`touch move ${x} ${y}`, callback);\r\n    return this;\r\n  }\r\n\r\n  trackball(dx, dy, callback) {\r\n    this.send(`trackball ${dx} ${dy}`, callback);\r\n    return this;\r\n  }\r\n\r\n  flipOpen(callback) {\r\n    this.send(\"flip open\", callback);\r\n    return this;\r\n  }\r\n\r\n  flipClose(callback) {\r\n    this.send(\"flip close\", callback);\r\n    return this;\r\n  }\r\n\r\n  wake(callback) {\r\n    this.send(\"wake\", callback);\r\n    return this;\r\n  }\r\n\r\n  tap(x, y, callback) {\r\n    this.send(`tap ${x} ${y}`, callback);\r\n    return this;\r\n  }\r\n\r\n  press(keyCode, callback) {\r\n    this.send(`press ${keyCode}`, callback);\r\n    return this;\r\n  }\r\n\r\n  type(str, callback) {\r\n    // Escape double quotes.\r\n    str = str.replace(/\"/g, '\\\\\"');\r\n    if (str.indexOf(' ') === -1) {\r\n      this.send(`type ${str}`, callback);\r\n    } else {\r\n      this.send(`type \\\"${str}\\\"`, callback);\r\n    }\r\n    return this;\r\n  }\r\n\r\n  list(callback) {\r\n    this.send(\"listvar\", (err, vars) => {\r\n      if (err) { return this(callback(err)); }\r\n      if (err) {\r\n        return callback(err);\r\n      } else {\r\n        return callback(null, vars.split(/\\s+/g));\r\n      }\r\n    });\r\n    return this;\r\n  }\r\n\r\n  get(name, callback) {\r\n    this.send(`getvar ${name}`, callback);\r\n    return this;\r\n  }\r\n\r\n  quit(callback) {\r\n    this.send(\"quit\", callback);\r\n    return this;\r\n  }\r\n\r\n  done(callback) {\r\n    this.send(\"done\", callback);\r\n    return this;\r\n  }\r\n\r\n  sleep(ms, callback) {\r\n    this.send(`sleep ${ms}`, callback);\r\n    return this;\r\n  }\r\n\r\n  getAmCurrentAction(callback) {\r\n    this.get('am.current.action', callback);\r\n    return this;\r\n  }\r\n\r\n  getAmCurrentCategories(callback) {\r\n    this.get('am.current.categories', callback);\r\n    return this;\r\n  }\r\n\r\n  getAmCurrentCompClass(callback) {\r\n    this.get('am.current.comp.class', callback);\r\n    return this;\r\n  }\r\n\r\n  getAmCurrentCompPackage(callback) {\r\n    this.get('am.current.comp.package', callback);\r\n    return this;\r\n  }\r\n\r\n  getAmCurrentData(callback) {\r\n    this.get('am.current.data', callback);\r\n    return this;\r\n  }\r\n\r\n  getAmCurrentPackage(callback) {\r\n    this.get('am.current.package', callback);\r\n    return this;\r\n  }\r\n\r\n  getBuildBoard(callback) {\r\n    this.get('build.board', callback);\r\n    return this;\r\n  }\r\n\r\n  getBuildBrand(callback) {\r\n    this.get('build.brand', callback);\r\n    return this;\r\n  }\r\n\r\n  getBuildCpuAbi(callback) {\r\n    this.get('build.cpu_abi', callback);\r\n    return this;\r\n  }\r\n\r\n  getBuildDevice(callback) {\r\n    this.get('build.device', callback);\r\n    return this;\r\n  }\r\n\r\n  getBuildDisplay(callback) {\r\n    this.get('build.display', callback);\r\n    return this;\r\n  }\r\n\r\n  getBuildFingerprint(callback) {\r\n    this.get('build.fingerprint', callback);\r\n    return this;\r\n  }\r\n\r\n  getBuildHost(callback) {\r\n    this.get('build.host', callback);\r\n    return this;\r\n  }\r\n\r\n  getBuildId(callback) {\r\n    this.get('build.id', callback);\r\n    return this;\r\n  }\r\n\r\n  getBuildManufacturer(callback) {\r\n    this.get('build.manufacturer', callback);\r\n    return this;\r\n  }\r\n\r\n  getBuildModel(callback) {\r\n    this.get('build.model', callback);\r\n    return this;\r\n  }\r\n\r\n  getBuildProduct(callback) {\r\n    this.get('build.product', callback);\r\n    return this;\r\n  }\r\n\r\n  getBuildTags(callback) {\r\n    this.get('build.tags', callback);\r\n    return this;\r\n  }\r\n\r\n  getBuildType(callback) {\r\n    this.get('build.type', callback);\r\n    return this;\r\n  }\r\n\r\n  getBuildUser(callback) {\r\n    this.get('build.user', callback);\r\n    return this;\r\n  }\r\n\r\n  getBuildVersionCodename(callback) {\r\n    this.get('build.version.codename', callback);\r\n    return this;\r\n  }\r\n\r\n  getBuildVersionIncremental(callback) {\r\n    this.get('build.version.incremental', callback);\r\n    return this;\r\n  }\r\n\r\n  getBuildVersionRelease(callback) {\r\n    this.get('build.version.release', callback);\r\n    return this;\r\n  }\r\n\r\n  getBuildVersionSdk(callback) {\r\n    this.get('build.version.sdk', callback);\r\n    return this;\r\n  }\r\n\r\n  getClockMillis(callback) {\r\n    this.get('clock.millis', callback);\r\n    return this;\r\n  }\r\n\r\n  getClockRealtime(callback) {\r\n    this.get('clock.realtime', callback);\r\n    return this;\r\n  }\r\n\r\n  getClockUptime(callback) {\r\n    this.get('clock.uptime', callback);\r\n    return this;\r\n  }\r\n\r\n  getDisplayDensity(callback) {\r\n    this.get('display.density', callback);\r\n    return this;\r\n  }\r\n\r\n  getDisplayHeight(callback) {\r\n    this.get('display.height', callback);\r\n    return this;\r\n  }\r\n\r\n  getDisplayWidth(callback) {\r\n    this.get('display.width', callback);\r\n    return this;\r\n  }\r\n}\r\n\r\nmodule.exports = Api;\r\n","const Api = require('./api');\r\nconst Command = require('./command');\r\nconst Reply = require('./reply');\r\nconst Queue = require('./queue');\r\nconst Multi = require('./multi');\r\nconst Parser = require('./parser');\r\n\r\nclass Client extends Api {\r\n  constructor() {\r\n    super()\r\n    this.commandQueue = new Queue;\r\n    this.parser = new Parser;\r\n    this.stream = null;\r\n  }\r\n\r\n  _hook() {\r\n    this.stream.on('data', data => {\r\n      return this.parser.parse(data);\r\n    });\r\n    this.stream.on('error', err => {\r\n      return this.emit('error', err);\r\n    });\r\n    this.stream.on('end', () => {\r\n      return this.emit('end');\r\n    });\r\n    this.stream.on('finish', () => {\r\n      return this.emit('finish');\r\n    });\r\n    this.parser.on('reply', reply => {\r\n      return this._consume(reply);\r\n    });\r\n    this.parser.on('error', err => {\r\n      return this.emit('error', err);\r\n    });\r\n  }\r\n\r\n  _consume(reply) {\r\n    let command;\r\n    if (command = this.commandQueue.dequeue()) {\r\n      if (reply.isError()) {\r\n        command.callback(reply.toError(), null, command.command);\r\n      } else {\r\n        command.callback(null, reply.value, command.command);\r\n      }\r\n    } else {\r\n      throw new Error(\"Command queue depleted, but replies still coming in\");\r\n    }\r\n  }\r\n\r\n  connect(stream) {\r\n    this.stream = stream;\r\n    this._hook();\r\n    return this;\r\n  }\r\n\r\n  end() {\r\n    this.stream.end();\r\n    return this;\r\n  }\r\n\r\n  send(commands, callback) {\r\n    if (Array.isArray(commands)) {\r\n      for (var command of Array.from(commands)) {\r\n        this.commandQueue.enqueue(new Command(command, callback));\r\n      }\r\n      this.stream.write(`${commands.join('\\n')}\\n`);\r\n    } else {\r\n      this.commandQueue.enqueue(new Command(commands, callback));\r\n      this.stream.write(`${commands}\\n`);\r\n    }\r\n    return this;\r\n  }\r\n\r\n  multi() {\r\n    return new Multi(this);\r\n  }\r\n}\r\n\r\nmodule.exports = Client;\r\n","class Command {\r\n  constructor(command, callback) {\r\n    this.command = command;\r\n    this.callback = callback;\r\n    this.next = null;\r\n  }\r\n}\r\n\r\nmodule.exports = Command;\r\n","const Net = require('net');\r\n\r\nconst Client = require('./client');\r\n\r\nclass Connection extends Client {\r\n  constructor() {\r\n    super()\r\n  }\r\n\r\n  connect(options) {\r\n    const stream = Net.connect(options);\r\n    stream.setNoDelay(true);\r\n    return super.connect(stream);\r\n  }\r\n\r\n  _hook() {\r\n    this.stream.on('connect', () => {\r\n      return this.emit('connect');\r\n    });\r\n    this.stream.on('close', hadError => {\r\n      return this.emit('close', hadError);\r\n    });\r\n    return super._hook();\r\n  }\r\n}\r\n\r\nmodule.exports = Connection;\r\n","const Api = require('./api');\r\nconst Command = require('./command');\r\n\r\nclass Multi extends Api {\r\n  constructor(monkey) {\r\n    super()\r\n    this.monkey = monkey;\r\n    this.commands = [];\r\n    this.replies = [];\r\n    this.errors = [];\r\n    this.counter = 0;\r\n    this.sent = false;\r\n    this.callback = null;\r\n    this.collector = (err, result, cmd) => {\r\n      if (err) { this.errors.push(`${cmd}: ${err.message}`); }\r\n      this.replies.push(result);\r\n      this.counter -= 1;\r\n      return this._maybeFinish();\r\n    };\r\n  }\r\n\r\n  _maybeFinish() {\r\n    if (this.counter === 0) {\r\n      if (this.errors.length) {\r\n        setImmediate(() => {\r\n          return this.callback(new Error(this.errors.join(', ')));\r\n        });\r\n      } else {\r\n        setImmediate(() => {\r\n          return this.callback(null, this.replies);\r\n        });\r\n      }\r\n    }\r\n  }\r\n\r\n  _forbidReuse() {\r\n    if (this.sent) {\r\n      throw new Error(\"Reuse not supported\");\r\n    }\r\n  }\r\n\r\n  send(command) {\r\n    this._forbidReuse();\r\n    this.commands.push(new Command(command, this.collector));\r\n  }\r\n\r\n  execute(callback) {\r\n    this._forbidReuse();\r\n    this.counter = this.commands.length;\r\n    this.sent = true;\r\n    this.callback = callback;\r\n    if (this.counter === 0) {\r\n      return;\r\n    }\r\n    const parts = [];\r\n    for (var command of Array.from(this.commands)) {\r\n      this.monkey.commandQueue.enqueue(command);\r\n      parts.push(command.command);\r\n    }\r\n    parts.push('');\r\n    this.commands = [];\r\n    this.monkey.stream.write(parts.join('\\n'));\r\n  }\r\n}\r\n\r\nmodule.exports = Multi;\r\n","const {EventEmitter} = require('events');\r\n\r\nconst Reply = require('./reply');\r\n\r\nclass Parser extends EventEmitter {\r\n  constructor(options) {\r\n    super(options)\r\n    this.column = 0;\r\n    this.buffer = Buffer.from('');\r\n  }\r\n\r\n  parse(chunk) {\r\n    this.buffer = Buffer.concat([this.buffer, chunk]);\r\n    while (this.column < this.buffer.length) {\r\n      if (this.buffer[this.column] === 0x0a) {\r\n        this._parseLine(this.buffer.slice(0, this.column));\r\n        this.buffer = this.buffer.slice(this.column + 1);\r\n        this.column = 0;\r\n      }\r\n      this.column += 1;\r\n    }\r\n    if (this.buffer.length) {\r\n      this.emit('wait');\r\n    } else {\r\n      this.emit('drain');\r\n    }\r\n  }\r\n\r\n  _parseLine(line) {\r\n    switch (line[0]) {\r\n      case 0x4f: // 'O'\r\n        if (line.length === 2) { // 'OK'\r\n          this.emit('reply', new Reply(Reply.OK, null));\r\n        } else { // 'OK:'\r\n          this.emit('reply', new Reply(Reply.OK, line.toString('ascii', 3)));\r\n        }\r\n        break;\r\n      case 0x45: // 'E'\r\n        if (line.length === 5) { // 'ERROR'\r\n          this.emit('reply', new Reply(Reply.ERROR, null));\r\n        } else { // 'ERROR:'\r\n          this.emit('reply', new Reply(Reply.ERROR, line.toString('ascii', 6)));\r\n        }\r\n        break;\r\n      default:\r\n        this._complain(line);\r\n    }\r\n  }\r\n\r\n  _complain(line) {\r\n    this.emit('error', new SyntaxError(`Unparseable line '${line}'`));\r\n  }\r\n}\r\n\r\nmodule.exports = Parser;\r\n","class Queue {\r\n  constructor() {\r\n    this.head = null;\r\n    this.tail = null;\r\n  }\r\n\r\n  enqueue(item) {\r\n    if (this.tail) {\r\n      this.tail.next = item;\r\n    } else {\r\n      this.head = item;\r\n    }\r\n    this.tail = item;\r\n  }\r\n\r\n  dequeue() {\r\n    const item = this.head;\r\n    if (item) {\r\n      if (item === this.tail) {\r\n        this.tail = null;\r\n      }\r\n      this.head = item.next;\r\n      item.next = null;\r\n    }\r\n    return item;\r\n  }\r\n}\r\n\r\nmodule.exports = Queue;\r\n","class Reply {\r\n  static initClass() {\r\n    this.ERROR = 'ERROR';\r\n    this.OK = 'OK';\r\n  }\r\n\r\n  constructor(type, value) {\r\n    this.type = type;\r\n    this.value = value;\r\n  }\r\n\r\n  isError() {\r\n    return this.type === Reply.ERROR;\r\n  }\r\n\r\n  toError() {\r\n    if (!this.isError()) {\r\n      throw new Error('toError() cannot be called for non-errors');\r\n    }\r\n    return new Error(this.value);\r\n  }\r\n}\r\nReply.initClass();\r\n\r\nmodule.exports = Reply;\r\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\tid: moduleId,\n\t\tloaded: false,\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// Flag the module as loaded\n\tmodule.loaded = true;\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","__webpack_require__.nmd = (module) => {\n\tmodule.paths = [];\n\tif (!module.children) module.children = [];\n\treturn module;\n};","const Net = require('net')\r\n\r\nNet.Socket.prototype.encoding   = 'binary'\r\nNet.Socket.prototype.setNoDelay = function(){}\r\n\r\nNet.connect = function(options) {\r\n  const socket = new Net.Socket()\r\n  socket.connect(...options)\r\n  return socket\r\n}\r\n\r\nwindow.Buffer = require('buffer/').Buffer\r\nwindow.Monkey = require('../../src/monkey.js')\r\n"],"names":["regexs","url","RegExp","host","URL","constructor","base","resolve","this","href","srcURL","dstURL","fields","i","length","field","replace","toString","protocol","username","password","pathname","search","hash","toJSON","matches","exec","Error","hostname","port","origin","URLSearchParams","searchParams","parse","parseQueryString","arguments","undefined","slashes","auth","path","query","substring","split","forEach","pair","index","indexOf","key","val","push","has","get","getAll","set","append","delete","splice","sort","sorted","keys","Object","values","entries","denormalized","callback","thisArg","_ref","apply","exclude_question_mark","_ref2","map_clone","module","exports","e","window","jsURL","byteLength","b64","lens","getLens","validLen","placeHoldersLen","toByteArray","tmp","arr","Arr","_byteLength","curByte","len","revLookup","charCodeAt","fromByteArray","uint8","extraBytes","parts","maxChunkLength","len2","encodeChunk","lookup","join","Uint8Array","Array","code","start","end","num","output","blob","cb","Blob","reader","FileReader","addEventListener","onLoadEnd","removeEventListener","error","Buffer","from","result","readAsArrayBuffer","base64","require","ieee754","customInspectSymbol","Symbol","K_MAX_LENGTH","createBuffer","RangeError","buf","setPrototypeOf","prototype","arg","encodingOrOffset","TypeError","allocUnsafe","value","string","encoding","isEncoding","actual","write","slice","fromString","ArrayBuffer","isView","arrayView","isInstance","copy","fromArrayBuffer","buffer","byteOffset","fromArrayLike","fromArrayView","SharedArrayBuffer","valueOf","b","obj","isBuffer","checked","numberIsNaN","type","isArray","data","fromObject","toPrimitive","assertSize","size","array","mustMatch","loweredCase","utf8ToBytes","base64ToBytes","toLowerCase","slowToString","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","n","m","bidirectionalIndexOf","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","base64Write","ucs2Write","units","c","hi","lo","utf16leToBytes","Math","min","res","firstByte","codePoint","bytesPerSequence","secondByte","thirdByte","fourthByte","tempCodePoint","codePoints","MAX_ARGUMENTS_LENGTH","fromCharCode","decodeCodePointsArray","TYPED_ARRAY_SUPPORT","proto","foo","typedArraySupport","console","defineProperty","enumerable","poolSize","alloc","fill","allocUnsafeSlow","_isBuffer","compare","a","x","y","concat","list","pos","swap16","swap32","swap64","toLocaleString","equals","inspect","max","trim","target","thisStart","thisEnd","thisCopy","targetCopy","includes","isFinite","_arr","ret","out","hexSliceLookupTable","bytes","checkOffset","ext","checkInt","wrtBigUInt64LE","checkIntBI","BigInt","wrtBigUInt64BE","checkIEEE754","writeFloat","littleEndian","noAssert","writeDouble","newBuf","subarray","readUintLE","readUIntLE","mul","readUintBE","readUIntBE","readUint8","readUInt8","readUint16LE","readUInt16LE","readUint16BE","readUint32LE","readUInt32LE","readUint32BE","readUInt32BE","readBigUInt64LE","defineBigIntMethod","validateNumber","first","last","boundsError","readBigUInt64BE","readIntLE","pow","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readBigInt64LE","readBigInt64BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUintLE","writeUIntLE","writeUintBE","writeUIntBE","writeUint8","writeUInt8","writeUint16LE","writeUInt16LE","writeUint16BE","writeUInt16BE","writeUint32LE","writeUInt32LE","writeUint32BE","writeUInt32BE","writeBigUInt64LE","writeBigUInt64BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeBigInt64LE","writeBigInt64BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","copyWithin","errors","E","sym","getMessage","Base","super","writable","configurable","name","stack","message","addNumericalSeparator","range","ERR_OUT_OF_RANGE","checkBounds","ERR_INVALID_ARG_TYPE","floor","ERR_BUFFER_OUT_OF_BOUNDS","input","msg","received","isInteger","abs","INVALID_BASE64_RE","Infinity","leadSurrogate","base64clean","src","dst","alphabet","table","i16","fn","BufferBigIntNotDefined","ReflectOwnKeys","R","Reflect","ReflectApply","receiver","args","Function","ownKeys","getOwnPropertySymbols","getOwnPropertyNames","NumberIsNaN","isNaN","EventEmitter","init","once","emitter","Promise","reject","errorListener","err","removeListener","resolver","eventTargetAgnosticAddListener","handler","flags","on","addErrorHandlerIfEventEmitter","_events","_eventsCount","_maxListeners","defaultMaxListeners","checkListener","listener","_getMaxListeners","that","_addListener","prepend","events","existing","warning","create","newListener","emit","unshift","warned","w","count","warn","onceWrapper","fired","wrapFn","_onceWrap","state","wrapped","bind","_listeners","unwrap","evlistener","unwrapListeners","arrayClone","listenerCount","wrapListener","getPrototypeOf","setMaxListeners","getMaxListeners","doError","er","context","listeners","addListener","prependListener","prependOnceListener","position","originalListener","shift","pop","spliceOne","off","removeAllListeners","rawListeners","eventNames","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","d","s","NaN","rt","log","LN2","net","configureEvents","async","connectListener","self","socket","WebSocket","toBuffer","instance","onclose","event","hadError","onerror","onmessage","onload","readAsText","onopen","socketUtils","connectSocket","options","connect","send","setEncoding","connecting","readyState","CONNECTING","destroy","exception","close","remotePort","bufferSize","destroyed","address","remoteAddress","Socket","utils","bufferedSize","CLOSED","Client","Connection","Monkey","connectStream","stream","keyDown","keyCode","keyUp","touchDown","touchUp","touchMove","trackball","dx","dy","flipOpen","flipClose","wake","tap","press","vars","quit","done","sleep","ms","getAmCurrentAction","getAmCurrentCategories","getAmCurrentCompClass","getAmCurrentCompPackage","getAmCurrentData","getAmCurrentPackage","getBuildBoard","getBuildBrand","getBuildCpuAbi","getBuildDevice","getBuildDisplay","getBuildFingerprint","getBuildHost","getBuildId","getBuildManufacturer","getBuildModel","getBuildProduct","getBuildTags","getBuildType","getBuildUser","getBuildVersionCodename","getBuildVersionIncremental","getBuildVersionRelease","getBuildVersionSdk","getClockMillis","getClockRealtime","getClockUptime","getDisplayDensity","getDisplayHeight","getDisplayWidth","Api","Command","Queue","Multi","Parser","commandQueue","parser","_hook","reply","_consume","command","dequeue","isError","toError","commands","enqueue","multi","next","Net","setNoDelay","monkey","replies","counter","sent","collector","cmd","_maybeFinish","setImmediate","_forbidReuse","execute","Reply","column","chunk","_parseLine","line","OK","ERROR","_complain","SyntaxError","head","tail","item","initClass","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","id","loaded","__webpack_modules__","nmd","paths","children"],"sourceRoot":""}