{"version":3,"file":"static/js/vendor~820c4f04.16f25bd6.js","mappings":"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","sources":["../node_modules/brorand/index.js","../node_modules/buffer-reverse/index.js","../node_modules/buffer/index.js"],"sourcesContent":["var r;\n\nmodule.exports = function rand(len) {\n  if (!r)\n    r = new Rand(null);\n\n  return r.generate(len);\n};\n\nfunction Rand(rand) {\n  this.rand = rand;\n}\nmodule.exports.Rand = Rand;\n\nRand.prototype.generate = function generate(len) {\n  return this._rand(len);\n};\n\n// Emulate crypto API using randy\nRand.prototype._rand = function _rand(n) {\n  if (this.rand.getBytes)\n    return this.rand.getBytes(n);\n\n  var res = new Uint8Array(n);\n  for (var i = 0; i < res.length; i++)\n    res[i] = this.rand.getByte();\n  return res;\n};\n\nif (typeof self === 'object') {\n  if (self.crypto && self.crypto.getRandomValues) {\n    // Modern browsers\n    Rand.prototype._rand = function _rand(n) {\n      var arr = new Uint8Array(n);\n      self.crypto.getRandomValues(arr);\n      return arr;\n    };\n  } else if (self.msCrypto && self.msCrypto.getRandomValues) {\n    // IE\n    Rand.prototype._rand = function _rand(n) {\n      var arr = new Uint8Array(n);\n      self.msCrypto.getRandomValues(arr);\n      return arr;\n    };\n\n  // Safari's WebWorkers do not have `crypto`\n  } else if (typeof window === 'object') {\n    // Old junk\n    Rand.prototype._rand = function() {\n      throw new Error('Not implemented yet');\n    };\n  }\n} else {\n  // Node.js or Web worker with no crypto support\n  try {\n    var crypto = require('crypto');\n    if (typeof crypto.randomBytes !== 'function')\n      throw new Error('Not supported');\n\n    Rand.prototype._rand = function _rand(n) {\n      return crypto.randomBytes(n);\n    };\n  } catch (e) {\n  }\n}\n","module.exports = function reverse (src) {\n  var buffer = new Buffer(src.length)\n\n  for (var i = 0, j = src.length - 1; i <= j; ++i, --j) {\n    buffer[i] = src[j]\n    buffer[j] = src[i]\n  }\n\n  return buffer\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"],"names":["r","Rand","rand","this","module","exports","len","generate","prototype","_rand","n","getBytes","res","Uint8Array","i","length","getByte","self","crypto","getRandomValues","arr","msCrypto","window","Error","require","randomBytes","e","src","buffer","Buffer","j","_classCallCheck","_createClass","_assertThisInitialized","_inherits","_createSuper","base64","ieee754","customInspectSymbol","Symbol","SlowBuffer","alloc","INSPECT_MAX_BYTES","K_MAX_LENGTH","createBuffer","RangeError","buf","Object","setPrototypeOf","arg","encodingOrOffset","TypeError","allocUnsafe","from","value","string","encoding","isEncoding","byteLength","actual","write","slice","fromString","ArrayBuffer","isView","arrayView","isInstance","copy","fromArrayBuffer","byteOffset","fromArrayLike","fromArrayView","SharedArrayBuffer","valueOf","b","obj","isBuffer","checked","undefined","numberIsNaN","type","Array","isArray","data","fromObject","toPrimitive","assertSize","size","array","toString","mustMatch","arguments","loweredCase","utf8ToBytes","base64ToBytes","toLowerCase","slowToString","start","end","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","m","bidirectionalIndexOf","val","dir","arrayIndexOf","indexOf","call","lastIndexOf","indexSize","arrLength","valLength","String","read","readUInt16BE","foundIndex","found","hexWrite","offset","Number","remaining","strLen","parsed","parseInt","substr","utf8Write","blitBuffer","asciiWrite","str","byteArray","push","charCodeAt","asciiToBytes","base64Write","ucs2Write","units","c","hi","lo","utf16leToBytes","fromByteArray","Math","min","firstByte","codePoint","bytesPerSequence","secondByte","thirdByte","fourthByte","tempCodePoint","codePoints","MAX_ARGUMENTS_LENGTH","fromCharCode","apply","decodeCodePointsArray","kMaxLength","TYPED_ARRAY_SUPPORT","proto","foo","typedArraySupport","console","error","defineProperty","enumerable","get","poolSize","fill","allocUnsafeSlow","_isBuffer","compare","a","x","y","concat","list","pos","set","swap16","swap32","swap64","toLocaleString","equals","inspect","max","replace","trim","target","thisStart","thisEnd","thisCopy","targetCopy","includes","isFinite","toJSON","_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","pow","readBigUInt64BE","readIntLE","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","code","errors","E","sym","getMessage","Base","_Base","NodeError","_super","_this","writable","configurable","name","stack","key","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","toByteArray","split","base64clean","dst","constructor","alphabet","table","i16","fn","BufferBigIntNotDefined"],"sourceRoot":""}