{"version":3,"sources":["../node_modules/buffer/index.js","../node_modules/isarray/index.js","../node_modules/base64-js/index.js","../node_modules/ieee754/index.js"],"names":["global","base64","__webpack_require__","ieee754","isArray","kMaxLength","Buffer","TYPED_ARRAY_SUPPORT","createBuffer","that","length","RangeError","Uint8Array","__proto__","prototype","arg","encodingOrOffset","this","Error","allocUnsafe","from","value","TypeError","ArrayBuffer","array","byteOffset","byteLength","undefined","fromArrayLike","fromArrayBuffer","string","encoding","isEncoding","actual","write","slice","fromString","obj","isBuffer","len","checked","copy","buffer","val","type","data","fromObject","assertSize","size","i","toString","isView","loweredCase","utf8ToBytes","base64ToBytes","toLowerCase","slowToString","start","end","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","b","n","m","bidirectionalIndexOf","dir","isNaN","arrayIndexOf","indexOf","call","lastIndexOf","arr","indexSize","arrLength","valLength","String","read","buf","readUInt16BE","foundIndex","found","j","hexWrite","offset","Number","remaining","strLen","parsed","parseInt","substr","utf8Write","blitBuffer","asciiWrite","str","byteArray","push","charCodeAt","asciiToBytes","latin1Write","base64Write","ucs2Write","units","c","hi","lo","utf16leToBytes","fromByteArray","Math","min","res","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","codePoint","bytesPerSequence","codePoints","fromCharCode","apply","decodeCodePointsArray","exports","SlowBuffer","alloc","INSPECT_MAX_BYTES","foo","subarray","e","typedArraySupport","poolSize","_augment","Symbol","species","Object","defineProperty","configurable","fill","allocUnsafeSlow","_isBuffer","compare","a","x","y","concat","list","pos","swap16","swap32","swap64","arguments","equals","inspect","max","match","join","target","thisStart","thisEnd","thisCopy","targetCopy","includes","isFinite","toJSON","Array","_arr","ret","out","toHex","bytes","checkOffset","ext","checkInt","objectWriteUInt16","littleEndian","objectWriteUInt32","checkIEEE754","writeFloat","noAssert","writeDouble","newBuf","sliceLen","readUIntLE","mul","readUIntBE","readUInt8","readUInt16LE","readUInt32LE","readUInt32BE","readIntLE","pow","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUIntLE","writeUIntBE","writeUInt8","floor","writeUInt16LE","writeUInt16BE","writeUInt32LE","writeUInt32BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","set","code","INVALID_BASE64_RE","Infinity","leadSurrogate","toByteArray","trim","replace","stringtrim","base64clean","src","dst","module","b64","lens","getLens","validLen","placeHoldersLen","tmp","Arr","_byteLength","curByte","revLookup","uint8","extraBytes","parts","len2","encodeChunk","lookup","num","output","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","d","s","NaN","rt","abs","log","LN2"],"mappings":"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","file":"static/js/8.126b3000.chunk.js","sourcesContent":["/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <http://feross.org>\n * @license  MIT\n */\n\n/* eslint-disable no-proto */\n'use strict';\n\nvar base64 = require('base64-js');\n\nvar ieee754 = require('ieee754');\n\nvar isArray = require('isarray');\n\nexports.Buffer = Buffer;\nexports.SlowBuffer = SlowBuffer;\nexports.INSPECT_MAX_BYTES = 50;\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object 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 * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\n\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined ? global.TYPED_ARRAY_SUPPORT : typedArraySupport();\n/*\n * Export kMaxLength after typed array support is determined.\n */\n\nexports.kMaxLength = kMaxLength();\n\nfunction typedArraySupport() {\n  try {\n    var arr = new Uint8Array(1);\n    arr.__proto__ = {\n      __proto__: Uint8Array.prototype,\n      foo: function foo() {\n        return 42;\n      }\n    };\n    return arr.foo() === 42 && // typed array instances can be augmented\n    typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n    arr.subarray(1, 1).byteLength === 0; // ie10 has broken `subarray`\n  } catch (e) {\n    return false;\n  }\n}\n\nfunction kMaxLength() {\n  return Buffer.TYPED_ARRAY_SUPPORT ? 0x7fffffff : 0x3fffffff;\n}\n\nfunction createBuffer(that, length) {\n  if (kMaxLength() < length) {\n    throw new RangeError('Invalid typed array length');\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = new Uint8Array(length);\n    that.__proto__ = Buffer.prototype;\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    if (that === null) {\n      that = new Buffer(length);\n    }\n\n    that.length = length;\n  }\n\n  return that;\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\n\nfunction Buffer(arg, encodingOrOffset, length) {\n  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n    return new Buffer(arg, encodingOrOffset, length);\n  } // Common case.\n\n\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new Error('If encoding is specified then the first argument must be a string');\n    }\n\n    return allocUnsafe(this, arg);\n  }\n\n  return from(this, arg, encodingOrOffset, length);\n}\n\nBuffer.poolSize = 8192; // not used by this implementation\n// TODO: Legacy, not needed anymore. Remove in next major version.\n\nBuffer._augment = function (arr) {\n  arr.__proto__ = Buffer.prototype;\n  return arr;\n};\n\nfunction from(that, value, encodingOrOffset, length) {\n  if (typeof value === 'number') {\n    throw new TypeError('\"value\" argument must not be a number');\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n    return fromArrayBuffer(that, value, encodingOrOffset, length);\n  }\n\n  if (typeof value === 'string') {\n    return fromString(that, value, encodingOrOffset);\n  }\n\n  return fromObject(that, value);\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 **/\n\n\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(null, value, encodingOrOffset, length);\n};\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype;\n  Buffer.__proto__ = Uint8Array;\n\n  if (typeof Symbol !== 'undefined' && Symbol.species && Buffer[Symbol.species] === Buffer) {\n    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n    Object.defineProperty(Buffer, Symbol.species, {\n      value: null,\n      configurable: true\n    });\n  }\n}\n\nfunction assertSize(size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be a number');\n  } else if (size < 0) {\n    throw new RangeError('\"size\" argument must not be negative');\n  }\n}\n\nfunction alloc(that, size, fill, encoding) {\n  assertSize(size);\n\n  if (size <= 0) {\n    return createBuffer(that, size);\n  }\n\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpretted as a start offset.\n    return typeof encoding === 'string' ? createBuffer(that, size).fill(fill, encoding) : createBuffer(that, size).fill(fill);\n  }\n\n  return createBuffer(that, size);\n}\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\n\n\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(null, size, fill, encoding);\n};\n\nfunction allocUnsafe(that, size) {\n  assertSize(size);\n  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0);\n\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < size; ++i) {\n      that[i] = 0;\n    }\n  }\n\n  return that;\n}\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\n\n\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(null, size);\n};\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\n\n\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(null, size);\n};\n\nfunction fromString(that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8';\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('\"encoding\" must be a valid string encoding');\n  }\n\n  var length = byteLength(string, encoding) | 0;\n  that = createBuffer(that, length);\n  var actual = that.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    that = that.slice(0, actual);\n  }\n\n  return that;\n}\n\nfunction fromArrayLike(that, array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0;\n  that = createBuffer(that, length);\n\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255;\n  }\n\n  return that;\n}\n\nfunction fromArrayBuffer(that, array, byteOffset, length) {\n  array.byteLength; // this throws if `array` is not a valid ArrayBuffer\n\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\\'offset\\' is out of bounds');\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\\'length\\' is out of bounds');\n  }\n\n  if (byteOffset === undefined && length === undefined) {\n    array = new Uint8Array(array);\n  } else if (length === undefined) {\n    array = new Uint8Array(array, byteOffset);\n  } else {\n    array = new Uint8Array(array, byteOffset, length);\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = array;\n    that.__proto__ = Buffer.prototype;\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromArrayLike(that, array);\n  }\n\n  return that;\n}\n\nfunction fromObject(that, obj) {\n  if (Buffer.isBuffer(obj)) {\n    var len = checked(obj.length) | 0;\n    that = createBuffer(that, len);\n\n    if (that.length === 0) {\n      return that;\n    }\n\n    obj.copy(that, 0, 0, len);\n    return that;\n  }\n\n  if (obj) {\n    if (typeof ArrayBuffer !== 'undefined' && obj.buffer instanceof ArrayBuffer || 'length' in obj) {\n      if (typeof obj.length !== 'number' || isnan(obj.length)) {\n        return createBuffer(that, 0);\n      }\n\n      return fromArrayLike(that, obj);\n    }\n\n    if (obj.type === 'Buffer' && isArray(obj.data)) {\n      return fromArrayLike(that, obj.data);\n    }\n  }\n\n  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.');\n}\n\nfunction checked(length) {\n  // Note: cannot use `length < kMaxLength()` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' + 'size: 0x' + kMaxLength().toString(16) + ' bytes');\n  }\n\n  return length | 0;\n}\n\nfunction SlowBuffer(length) {\n  if (+length != length) {\n    // eslint-disable-line eqeqeq\n    length = 0;\n  }\n\n  return Buffer.alloc(+length);\n}\n\nBuffer.isBuffer = function isBuffer(b) {\n  return !!(b != null && b._isBuffer);\n};\n\nBuffer.compare = function compare(a, b) {\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers');\n  }\n\n  if (a === b) return 0;\n  var x = a.length;\n  var y = b.length;\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i];\n      y = b[i];\n      break;\n    }\n  }\n\n  if (x < y) return -1;\n  if (y < x) return 1;\n  return 0;\n};\n\nBuffer.isEncoding = function isEncoding(encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true;\n\n    default:\n      return false;\n  }\n};\n\nBuffer.concat = function concat(list, length) {\n  if (!isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers');\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0);\n  }\n\n  var i;\n\n  if (length === undefined) {\n    length = 0;\n\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length;\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length);\n  var pos = 0;\n\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i];\n\n    if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers');\n    }\n\n    buf.copy(buffer, pos);\n    pos += buf.length;\n  }\n\n  return buffer;\n};\n\nfunction byteLength(string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length;\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' && (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n    return string.byteLength;\n  }\n\n  if (typeof string !== 'string') {\n    string = '' + string;\n  }\n\n  var len = string.length;\n  if (len === 0) return 0; // Use a for loop to avoid recursion\n\n  var loweredCase = false;\n\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len;\n\n      case 'utf8':\n      case 'utf-8':\n      case undefined:\n        return utf8ToBytes(string).length;\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2;\n\n      case 'hex':\n        return len >>> 1;\n\n      case 'base64':\n        return base64ToBytes(string).length;\n\n      default:\n        if (loweredCase) return utf8ToBytes(string).length; // assume utf8\n\n        encoding = ('' + encoding).toLowerCase();\n        loweredCase = true;\n    }\n  }\n}\n\nBuffer.byteLength = byteLength;\n\nfunction slowToString(encoding, start, end) {\n  var loweredCase = false; // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\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\n  if (start === undefined || start < 0) {\n    start = 0;\n  } // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n\n\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  } // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n\n\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} // The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\n\n\nBuffer.prototype._isBuffer = true;\n\nfunction swap(b, n, m) {\n  var i = b[n];\n  b[n] = b[m];\n  b[m] = i;\n}\n\nBuffer.prototype.swap16 = function swap16() {\n  var len = this.length;\n\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits');\n  }\n\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1);\n  }\n\n  return this;\n};\n\nBuffer.prototype.swap32 = function swap32() {\n  var len = this.length;\n\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits');\n  }\n\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3);\n    swap(this, i + 1, i + 2);\n  }\n\n  return this;\n};\n\nBuffer.prototype.swap64 = function swap64() {\n  var len = this.length;\n\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits');\n  }\n\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7);\n    swap(this, i + 1, i + 6);\n    swap(this, i + 2, i + 5);\n    swap(this, i + 3, i + 4);\n  }\n\n  return this;\n};\n\nBuffer.prototype.toString = function toString() {\n  var length = this.length | 0;\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.equals = function equals(b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer');\n  if (this === b) return true;\n  return Buffer.compare(this, b) === 0;\n};\n\nBuffer.prototype.inspect = function inspect() {\n  var str = '';\n  var max = exports.INSPECT_MAX_BYTES;\n\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ');\n    if (this.length > max) str += ' ... ';\n  }\n\n  return '<Buffer ' + str + '>';\n};\n\nBuffer.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError('Argument must be a Buffer');\n  }\n\n  if (start === undefined) {\n    start = 0;\n  }\n\n  if (end === undefined) {\n    end = target ? target.length : 0;\n  }\n\n  if (thisStart === undefined) {\n    thisStart = 0;\n  }\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\n  if (thisStart >= thisEnd) {\n    return -1;\n  }\n\n  if (start >= end) {\n    return 1;\n  }\n\n  start >>>= 0;\n  end >>>= 0;\n  thisStart >>>= 0;\n  thisEnd >>>= 0;\n  if (this === target) return 0;\n  var x = thisEnd - thisStart;\n  var y = end - start;\n  var len = Math.min(x, y);\n  var thisCopy = this.slice(thisStart, thisEnd);\n  var targetCopy = target.slice(start, end);\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i];\n      y = targetCopy[i];\n      break;\n    }\n  }\n\n  if (x < y) return -1;\n  if (y < x) return 1;\n  return 0;\n}; // 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\n\n\nfunction bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1; // Normalize byteOffset\n\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\n  byteOffset = +byteOffset; // Coerce to Number.\n\n  if (isNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : buffer.length - 1;\n  } // Normalize byteOffset: negative offsets start from the end of the buffer\n\n\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset;\n\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1;else byteOffset = buffer.length - 1;\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0;else return -1;\n  } // Normalize val\n\n\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding);\n  } // Finally, search either indexOf (if dir is true) or lastIndexOf\n\n\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\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\n    if (Buffer.TYPED_ARRAY_SUPPORT && 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\n    return arrayIndexOf(buffer, [val], byteOffset, encoding, dir);\n  }\n\n  throw new TypeError('val must be string, number or Buffer');\n}\n\nfunction arrayIndexOf(arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1;\n  var arrLength = arr.length;\n  var valLength = val.length;\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase();\n\n    if (encoding === 'ucs2' || encoding === 'ucs-2' || encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1;\n      }\n\n      indexSize = 2;\n      arrLength /= 2;\n      valLength /= 2;\n      byteOffset /= 2;\n    }\n  }\n\n  function read(buf, i) {\n    if (indexSize === 1) {\n      return buf[i];\n    } else {\n      return buf.readUInt16BE(i * indexSize);\n    }\n  }\n\n  var i;\n\n  if (dir) {\n    var foundIndex = -1;\n\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\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true;\n\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false;\n          break;\n        }\n      }\n\n      if (found) return i;\n    }\n  }\n\n  return -1;\n}\n\nBuffer.prototype.includes = function includes(val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1;\n};\n\nBuffer.prototype.indexOf = function indexOf(val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true);\n};\n\nBuffer.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false);\n};\n\nfunction hexWrite(buf, string, offset, length) {\n  offset = Number(offset) || 0;\n  var remaining = buf.length - offset;\n\n  if (!length) {\n    length = remaining;\n  } else {\n    length = Number(length);\n\n    if (length > remaining) {\n      length = remaining;\n    }\n  } // must be an even number of digits\n\n\n  var strLen = string.length;\n  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string');\n\n  if (length > strLen / 2) {\n    length = strLen / 2;\n  }\n\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16);\n    if (isNaN(parsed)) return i;\n    buf[offset + i] = parsed;\n  }\n\n  return i;\n}\n\nfunction utf8Write(buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);\n}\n\nfunction asciiWrite(buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length);\n}\n\nfunction latin1Write(buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length);\n}\n\nfunction base64Write(buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length);\n}\n\nfunction ucs2Write(buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);\n}\n\nBuffer.prototype.write = function write(string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8';\n    length = this.length;\n    offset = 0; // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset;\n    length = this.length;\n    offset = 0; // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0;\n\n    if (isFinite(length)) {\n      length = length | 0;\n      if (encoding === undefined) encoding = 'utf8';\n    } else {\n      encoding = length;\n      length = undefined;\n    } // legacy write(string, encoding, offset, length) - remove in v0.13\n\n  } else {\n    throw new Error('Buffer.write(string, encoding, offset[, length]) is no longer supported');\n  }\n\n  var remaining = this.length - offset;\n  if (length === undefined || length > remaining) length = remaining;\n\n  if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds');\n  }\n\n  if (!encoding) encoding = 'utf8';\n  var loweredCase = false;\n\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length);\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length);\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length);\n\n      case 'latin1':\n      case 'binary':\n        return latin1Write(this, string, offset, length);\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length);\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length);\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding);\n        encoding = ('' + encoding).toLowerCase();\n        loweredCase = true;\n    }\n  }\n};\n\nBuffer.prototype.toJSON = function toJSON() {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  };\n};\n\nfunction base64Slice(buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf);\n  } else {\n    return base64.fromByteArray(buf.slice(start, end));\n  }\n}\n\nfunction utf8Slice(buf, start, end) {\n  end = Math.min(buf.length, end);\n  var res = [];\n  var i = start;\n\n  while (i < end) {\n    var firstByte = buf[i];\n    var codePoint = null;\n    var bytesPerSequence = firstByte > 0xEF ? 4 : firstByte > 0xDF ? 3 : firstByte > 0xBF ? 2 : 1;\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint;\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte;\n          }\n\n          break;\n\n        case 2:\n          secondByte = buf[i + 1];\n\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | secondByte & 0x3F;\n\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint;\n            }\n          }\n\n          break;\n\n        case 3:\n          secondByte = buf[i + 1];\n          thirdByte = buf[i + 2];\n\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | thirdByte & 0x3F;\n\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint;\n            }\n          }\n\n          break;\n\n        case 4:\n          secondByte = buf[i + 1];\n          thirdByte = buf[i + 2];\n          fourthByte = buf[i + 3];\n\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\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint;\n            }\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} // 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\n\n\nvar MAX_ARGUMENTS_LENGTH = 0x1000;\n\nfunction decodeCodePointsArray(codePoints) {\n  var len = codePoints.length;\n\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints); // avoid extra slice()\n  } // Decode in chunks to avoid \"call stack size exceeded\".\n\n\n  var res = '';\n  var i = 0;\n\n  while (i < len) {\n    res += String.fromCharCode.apply(String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH));\n  }\n\n  return res;\n}\n\nfunction asciiSlice(buf, start, end) {\n  var ret = '';\n  end = Math.min(buf.length, end);\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F);\n  }\n\n  return ret;\n}\n\nfunction latin1Slice(buf, start, end) {\n  var ret = '';\n  end = Math.min(buf.length, end);\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i]);\n  }\n\n  return ret;\n}\n\nfunction hexSlice(buf, start, end) {\n  var len = buf.length;\n  if (!start || start < 0) start = 0;\n  if (!end || end < 0 || end > len) end = len;\n  var out = '';\n\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i]);\n  }\n\n  return out;\n}\n\nfunction utf16leSlice(buf, start, end) {\n  var bytes = buf.slice(start, end);\n  var res = '';\n\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);\n  }\n\n  return res;\n}\n\nBuffer.prototype.slice = function slice(start, end) {\n  var len = this.length;\n  start = ~~start;\n  end = end === undefined ? len : ~~end;\n\n  if (start < 0) {\n    start += len;\n    if (start < 0) start = 0;\n  } else if (start > len) {\n    start = len;\n  }\n\n  if (end < 0) {\n    end += len;\n    if (end < 0) end = 0;\n  } else if (end > len) {\n    end = len;\n  }\n\n  if (end < start) end = start;\n  var newBuf;\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = this.subarray(start, end);\n    newBuf.__proto__ = Buffer.prototype;\n  } else {\n    var sliceLen = end - start;\n    newBuf = new Buffer(sliceLen, undefined);\n\n    for (var i = 0; i < sliceLen; ++i) {\n      newBuf[i] = this[i + start];\n    }\n  }\n\n  return newBuf;\n};\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\n\n\nfunction checkOffset(offset, ext, length) {\n  if (offset % 1 !== 0 || offset < 0) throw new RangeError('offset is not uint');\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length');\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE(offset, byteLength, noAssert) {\n  offset = offset | 0;\n  byteLength = byteLength | 0;\n  if (!noAssert) checkOffset(offset, byteLength, this.length);\n  var val = this[offset];\n  var mul = 1;\n  var i = 0;\n\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul;\n  }\n\n  return val;\n};\n\nBuffer.prototype.readUIntBE = function readUIntBE(offset, byteLength, noAssert) {\n  offset = offset | 0;\n  byteLength = byteLength | 0;\n\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length);\n  }\n\n  var val = this[offset + --byteLength];\n  var mul = 1;\n\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul;\n  }\n\n  return val;\n};\n\nBuffer.prototype.readUInt8 = function readUInt8(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length);\n  return this[offset];\n};\n\nBuffer.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length);\n  return this[offset] | this[offset + 1] << 8;\n};\n\nBuffer.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length);\n  return this[offset] << 8 | this[offset + 1];\n};\n\nBuffer.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length);\n  return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 0x1000000;\n};\n\nBuffer.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length);\n  return this[offset] * 0x1000000 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);\n};\n\nBuffer.prototype.readIntLE = function readIntLE(offset, byteLength, noAssert) {\n  offset = offset | 0;\n  byteLength = byteLength | 0;\n  if (!noAssert) checkOffset(offset, byteLength, this.length);\n  var val = this[offset];\n  var mul = 1;\n  var i = 0;\n\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul;\n  }\n\n  mul *= 0x80;\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength);\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  var i = byteLength;\n  var mul = 1;\n  var val = this[offset + --i];\n\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul;\n  }\n\n  mul *= 0x80;\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength);\n  return val;\n};\n\nBuffer.prototype.readInt8 = function readInt8(offset, noAssert) {\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  if (!noAssert) checkOffset(offset, 2, this.length);\n  var val = this[offset] | this[offset + 1] << 8;\n  return val & 0x8000 ? val | 0xFFFF0000 : val;\n};\n\nBuffer.prototype.readInt16BE = function readInt16BE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length);\n  var val = this[offset + 1] | this[offset] << 8;\n  return val & 0x8000 ? val | 0xFFFF0000 : val;\n};\n\nBuffer.prototype.readInt32LE = function readInt32LE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length);\n  return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;\n};\n\nBuffer.prototype.readInt32BE = function readInt32BE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length);\n  return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];\n};\n\nBuffer.prototype.readFloatLE = function readFloatLE(offset, noAssert) {\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  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  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  if (!noAssert) checkOffset(offset, 8, this.length);\n  return ieee754.read(this, offset, false, 52, 8);\n};\n\nfunction checkInt(buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance');\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds');\n  if (offset + ext > buf.length) throw new RangeError('Index out of range');\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  byteLength = byteLength | 0;\n\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1;\n    checkInt(this, value, offset, byteLength, maxBytes, 0);\n  }\n\n  var mul = 1;\n  var i = 0;\n  this[offset] = value & 0xFF;\n\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = value / mul & 0xFF;\n  }\n\n  return offset + byteLength;\n};\n\nBuffer.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  byteLength = byteLength | 0;\n\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1;\n    checkInt(this, value, offset, byteLength, maxBytes, 0);\n  }\n\n  var i = byteLength - 1;\n  var mul = 1;\n  this[offset + i] = value & 0xFF;\n\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = value / mul & 0xFF;\n  }\n\n  return offset + byteLength;\n};\n\nBuffer.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0);\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value);\n  this[offset] = value & 0xff;\n  return offset + 1;\n};\n\nfunction objectWriteUInt16(buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1;\n\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n    buf[offset + i] = (value & 0xff << 8 * (littleEndian ? i : 1 - i)) >>> (littleEndian ? i : 1 - i) * 8;\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value & 0xff;\n    this[offset + 1] = value >>> 8;\n  } else {\n    objectWriteUInt16(this, value, offset, true);\n  }\n\n  return offset + 2;\n};\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value >>> 8;\n    this[offset + 1] = value & 0xff;\n  } else {\n    objectWriteUInt16(this, value, offset, false);\n  }\n\n  return offset + 2;\n};\n\nfunction objectWriteUInt32(buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1;\n\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n    buf[offset + i] = value >>> (littleEndian ? i : 3 - i) * 8 & 0xff;\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = value >>> 24;\n    this[offset + 2] = value >>> 16;\n    this[offset + 1] = value >>> 8;\n    this[offset] = value & 0xff;\n  } else {\n    objectWriteUInt32(this, value, offset, true);\n  }\n\n  return offset + 4;\n};\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value >>> 24;\n    this[offset + 1] = value >>> 16;\n    this[offset + 2] = value >>> 8;\n    this[offset + 3] = value & 0xff;\n  } else {\n    objectWriteUInt32(this, value, offset, false);\n  }\n\n  return offset + 4;\n};\n\nBuffer.prototype.writeIntLE = function writeIntLE(value, offset, byteLength, noAssert) {\n  value = +value;\n  offset = offset | 0;\n\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1);\n    checkInt(this, value, offset, byteLength, limit - 1, -limit);\n  }\n\n  var i = 0;\n  var mul = 1;\n  var sub = 0;\n  this[offset] = value & 0xFF;\n\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1;\n    }\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\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1);\n    checkInt(this, value, offset, byteLength, limit - 1, -limit);\n  }\n\n  var i = byteLength - 1;\n  var mul = 1;\n  var sub = 0;\n  this[offset + i] = value & 0xFF;\n\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1;\n    }\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 (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value);\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\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value & 0xff;\n    this[offset + 1] = value >>> 8;\n  } else {\n    objectWriteUInt16(this, value, offset, true);\n  }\n\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\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value >>> 8;\n    this[offset + 1] = value & 0xff;\n  } else {\n    objectWriteUInt16(this, value, offset, false);\n  }\n\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\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value & 0xff;\n    this[offset + 1] = value >>> 8;\n    this[offset + 2] = value >>> 16;\n    this[offset + 3] = value >>> 24;\n  } else {\n    objectWriteUInt32(this, value, offset, true);\n  }\n\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\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value >>> 24;\n    this[offset + 1] = value >>> 16;\n    this[offset + 2] = value >>> 8;\n    this[offset + 3] = value & 0xff;\n  } else {\n    objectWriteUInt32(this, value, offset, false);\n  }\n\n  return offset + 4;\n};\n\nfunction checkIEEE754(buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range');\n  if (offset < 0) throw new RangeError('Index out of range');\n}\n\nfunction writeFloat(buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38);\n  }\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  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308);\n  }\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}; // copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\n\n\nBuffer.prototype.copy = function copy(target, targetStart, start, end) {\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; // Copy 0 bytes; we're done\n\n  if (end === start) return 0;\n  if (target.length === 0 || this.length === 0) return 0; // Fatal error conditions\n\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds');\n  }\n\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds');\n  if (end < 0) throw new RangeError('sourceEnd out of bounds'); // Are we oob?\n\n  if (end > this.length) end = this.length;\n\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start;\n  }\n\n  var len = end - start;\n  var i;\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start];\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; ++i) {\n      target[i + targetStart] = this[i + start];\n    }\n  } else {\n    Uint8Array.prototype.set.call(target, this.subarray(start, start + len), targetStart);\n  }\n\n  return len;\n}; // Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\n\n\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\n    if (val.length === 1) {\n      var code = val.charCodeAt(0);\n\n      if (code < 256) {\n        val = code;\n      }\n    }\n\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string');\n    }\n\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding);\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255;\n  } // Invalid ranges are not set to a default, so can range check early.\n\n\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  if (!val) val = 0;\n  var i;\n\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val;\n    }\n  } else {\n    var bytes = Buffer.isBuffer(val) ? val : utf8ToBytes(new Buffer(val, encoding).toString());\n    var len = bytes.length;\n\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len];\n    }\n  }\n\n  return this;\n}; // HELPER FUNCTIONS\n// ================\n\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g;\n\nfunction base64clean(str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, ''); // Node converts strings with length < 2 to ''\n\n  if (str.length < 2) return ''; // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n\n  while (str.length % 4 !== 0) {\n    str = str + '=';\n  }\n\n  return str;\n}\n\nfunction stringtrim(str) {\n  if (str.trim) return str.trim();\n  return str.replace(/^\\s+|\\s+$/g, '');\n}\n\nfunction toHex(n) {\n  if (n < 16) return '0' + n.toString(16);\n  return n.toString(16);\n}\n\nfunction utf8ToBytes(string, units) {\n  units = units || Infinity;\n  var codePoint;\n  var length = string.length;\n  var leadSurrogate = null;\n  var bytes = [];\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i); // is surrogate component\n\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        } // valid lead\n\n\n        leadSurrogate = codePoint;\n        continue;\n      } // 2 leads in a row\n\n\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);\n        leadSurrogate = codePoint;\n        continue;\n      } // valid surrogate pair\n\n\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; // encode utf8\n\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(codePoint >> 0x6 | 0xC0, codePoint & 0x3F | 0x80);\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break;\n      bytes.push(codePoint >> 0xC | 0xE0, codePoint >> 0x6 & 0x3F | 0x80, codePoint & 0x3F | 0x80);\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break;\n      bytes.push(codePoint >> 0x12 | 0xF0, codePoint >> 0xC & 0x3F | 0x80, codePoint >> 0x6 & 0x3F | 0x80, codePoint & 0x3F | 0x80);\n    } else {\n      throw new Error('Invalid code point');\n    }\n  }\n\n  return bytes;\n}\n\nfunction asciiToBytes(str) {\n  var byteArray = [];\n\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF);\n  }\n\n  return byteArray;\n}\n\nfunction utf16leToBytes(str, units) {\n  var c, hi, lo;\n  var byteArray = [];\n\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break;\n    c = str.charCodeAt(i);\n    hi = c >> 8;\n    lo = c % 256;\n    byteArray.push(lo);\n    byteArray.push(hi);\n  }\n\n  return byteArray;\n}\n\nfunction base64ToBytes(str) {\n  return base64.toByteArray(base64clean(str));\n}\n\nfunction blitBuffer(src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if (i + offset >= dst.length || i >= src.length) break;\n    dst[i + offset] = src[i];\n  }\n\n  return i;\n}\n\nfunction isnan(val) {\n  return val !== val; // eslint-disable-line no-self-compare\n}","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};","'use strict';\n\nexports.byteLength = byteLength;\nexports.toByteArray = toByteArray;\nexports.fromByteArray = fromByteArray;\nvar lookup = [];\nvar revLookup = [];\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i];\n  revLookup[code.charCodeAt(i)] = i;\n} // Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\n\n\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  } // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n\n\n  var validLen = b64.indexOf('=');\n  if (validLen === -1) validLen = len;\n  var placeHoldersLen = validLen === len ? 0 : 4 - validLen % 4;\n  return [validLen, placeHoldersLen];\n} // base64 is 4/3 + up to two characters of the original data\n\n\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  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));\n  var curByte = 0; // if there are placeholders, only get up to the last complete 4 chars\n\n  var len = placeHoldersLen > 0 ? validLen - 4 : validLen;\n  var i;\n\n  for (i = 0; i < len; i += 4) {\n    tmp = revLookup[b64.charCodeAt(i)] << 18 | revLookup[b64.charCodeAt(i + 1)] << 12 | revLookup[b64.charCodeAt(i + 2)] << 6 | 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 = revLookup[b64.charCodeAt(i)] << 2 | revLookup[b64.charCodeAt(i + 1)] >> 4;\n    arr[curByte++] = tmp & 0xFF;\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp = revLookup[b64.charCodeAt(i)] << 10 | revLookup[b64.charCodeAt(i + 1)] << 4 | 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] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F];\n}\n\nfunction encodeChunk(uint8, start, end) {\n  var tmp;\n  var output = [];\n\n  for (var i = start; i < end; i += 3) {\n    tmp = (uint8[i] << 16 & 0xFF0000) + (uint8[i + 1] << 8 & 0xFF00) + (uint8[i + 2] & 0xFF);\n    output.push(tripletToBase64(tmp));\n  }\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\n  var parts = [];\n  var maxChunkLength = 16383; // must be multiple of 3\n  // go through the array every three bytes, we'll deal with trailing stuff later\n\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  } // pad the end with zeros, but make sure to not forget the extra bytes\n\n\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1];\n    parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 0x3F] + '==');\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1];\n    parts.push(lookup[tmp >> 10] + lookup[tmp >> 4 & 0x3F] + lookup[tmp << 2 & 0x3F] + '=');\n  }\n\n  return parts.join('');\n}","exports.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  i += d;\n  e = s & (1 << -nBits) - 1;\n  s >>= -nBits;\n  nBits += eLen;\n\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\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\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  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\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--;\n      c *= 2;\n    }\n\n    if (e + eBias >= 1) {\n      value += rt / c;\n    } else {\n      value += rt * Math.pow(2, 1 - eBias);\n    }\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\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128;\n};"],"sourceRoot":""}