{"version":3,"file":"static/js/6559_ca8a698e97988d40ae8e.js","mappings":"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","sources":["file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/buffer@6.0.3/node_modules/buffer/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/compressorjs@1.2.1/node_modules/compressorjs/dist/compressor.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/bail@2.0.2/node_modules/bail/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/ccount@2.0.1/node_modules/ccount/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/clsx@2.1.0/node_modules/clsx/dist/clsx.mjs","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/comma-separated-tokens@2.0.3/node_modules/comma-separated-tokens/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/compute-scroll-into-view@3.1.0/node_modules/compute-scroll-into-view/dist/index.js"],"sourcesContent":["'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\n// Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction getLens (b64) {\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n  var validLen = b64.indexOf('=')\n  if (validLen === -1) validLen = len\n\n  var placeHoldersLen = validLen === len\n    ? 0\n    : 4 - (validLen % 4)\n\n  return [validLen, placeHoldersLen]\n}\n\n// base64 is 4/3 + up to two characters of the original data\nfunction byteLength (b64) {\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction _byteLength (b64, validLen, placeHoldersLen) {\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction toByteArray (b64) {\n  var tmp\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\n\n  var curByte = 0\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  var len = placeHoldersLen > 0\n    ? validLen - 4\n    : validLen\n\n  var i\n  for (i = 0; i < len; i += 4) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 18) |\n      (revLookup[b64.charCodeAt(i + 1)] << 12) |\n      (revLookup[b64.charCodeAt(i + 2)] << 6) |\n      revLookup[b64.charCodeAt(i + 3)]\n    arr[curByte++] = (tmp >> 16) & 0xFF\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 2) |\n      (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 10) |\n      (revLookup[b64.charCodeAt(i + 1)] << 4) |\n      (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] +\n    lookup[num >> 12 & 0x3F] +\n    lookup[num >> 6 & 0x3F] +\n    lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp =\n      ((uint8[i] << 16) & 0xFF0000) +\n      ((uint8[i + 1] << 8) & 0xFF00) +\n      (uint8[i + 2] & 0xFF)\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 2] +\n      lookup[(tmp << 4) & 0x3F] +\n      '=='\n    )\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 10] +\n      lookup[(tmp >> 4) & 0x3F] +\n      lookup[(tmp << 2) & 0x3F] +\n      '='\n    )\n  }\n\n  return parts.join('')\n}\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <https://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\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","/*!\n * Compressor.js v1.2.1\n * https://fengyuanchen.github.io/compressorjs\n *\n * Copyright 2018-present Chen Fengyuan\n * Released under the MIT license\n *\n * Date: 2023-02-28T14:09:41.732Z\n */\n\n(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n  typeof define === 'function' && define.amd ? define(factory) :\n  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Compressor = factory());\n})(this, (function () { 'use strict';\n\n  function ownKeys(object, enumerableOnly) {\n    var keys = Object.keys(object);\n    if (Object.getOwnPropertySymbols) {\n      var symbols = Object.getOwnPropertySymbols(object);\n      enumerableOnly && (symbols = symbols.filter(function (sym) {\n        return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n      })), keys.push.apply(keys, symbols);\n    }\n    return keys;\n  }\n  function _objectSpread2(target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = null != arguments[i] ? arguments[i] : {};\n      i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {\n        _defineProperty(target, key, source[key]);\n      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {\n        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n      });\n    }\n    return target;\n  }\n  function _classCallCheck(instance, Constructor) {\n    if (!(instance instanceof Constructor)) {\n      throw new TypeError(\"Cannot call a class as a function\");\n    }\n  }\n  function _defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if (\"value\" in descriptor) descriptor.writable = true;\n      Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);\n    }\n  }\n  function _createClass(Constructor, protoProps, staticProps) {\n    if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) _defineProperties(Constructor, staticProps);\n    Object.defineProperty(Constructor, \"prototype\", {\n      writable: false\n    });\n    return Constructor;\n  }\n  function _defineProperty(obj, key, value) {\n    key = _toPropertyKey(key);\n    if (key in obj) {\n      Object.defineProperty(obj, key, {\n        value: value,\n        enumerable: true,\n        configurable: true,\n        writable: true\n      });\n    } else {\n      obj[key] = value;\n    }\n    return obj;\n  }\n  function _extends() {\n    _extends = Object.assign ? Object.assign.bind() : function (target) {\n      for (var i = 1; i < arguments.length; i++) {\n        var source = arguments[i];\n        for (var key in source) {\n          if (Object.prototype.hasOwnProperty.call(source, key)) {\n            target[key] = source[key];\n          }\n        }\n      }\n      return target;\n    };\n    return _extends.apply(this, arguments);\n  }\n  function _toPrimitive(input, hint) {\n    if (typeof input !== \"object\" || input === null) return input;\n    var prim = input[Symbol.toPrimitive];\n    if (prim !== undefined) {\n      var res = prim.call(input, hint || \"default\");\n      if (typeof res !== \"object\") return res;\n      throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n    }\n    return (hint === \"string\" ? String : Number)(input);\n  }\n  function _toPropertyKey(arg) {\n    var key = _toPrimitive(arg, \"string\");\n    return typeof key === \"symbol\" ? key : String(key);\n  }\n\n  var canvasToBlob = {exports: {}};\n\n  /*\n   * JavaScript Canvas to Blob\n   * https://github.com/blueimp/JavaScript-Canvas-to-Blob\n   *\n   * Copyright 2012, Sebastian Tschan\n   * https://blueimp.net\n   *\n   * Licensed under the MIT license:\n   * https://opensource.org/licenses/MIT\n   *\n   * Based on stackoverflow user Stoive's code snippet:\n   * http://stackoverflow.com/q/4998908\n   */\n  (function (module) {\n  if (typeof window === 'undefined') {\n    return;\n  }\n    (function (window) {\n\n      var CanvasPrototype = window.HTMLCanvasElement && window.HTMLCanvasElement.prototype;\n      var hasBlobConstructor = window.Blob && function () {\n        try {\n          return Boolean(new Blob());\n        } catch (e) {\n          return false;\n        }\n      }();\n      var hasArrayBufferViewSupport = hasBlobConstructor && window.Uint8Array && function () {\n        try {\n          return new Blob([new Uint8Array(100)]).size === 100;\n        } catch (e) {\n          return false;\n        }\n      }();\n      var BlobBuilder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder;\n      var dataURIPattern = /^data:((.*?)(;charset=.*?)?)(;base64)?,/;\n      var dataURLtoBlob = (hasBlobConstructor || BlobBuilder) && window.atob && window.ArrayBuffer && window.Uint8Array && function (dataURI) {\n        var matches, mediaType, isBase64, dataString, byteString, arrayBuffer, intArray, i, bb;\n        // Parse the dataURI components as per RFC 2397\n        matches = dataURI.match(dataURIPattern);\n        if (!matches) {\n          throw new Error('invalid data URI');\n        }\n        // Default to text/plain;charset=US-ASCII\n        mediaType = matches[2] ? matches[1] : 'text/plain' + (matches[3] || ';charset=US-ASCII');\n        isBase64 = !!matches[4];\n        dataString = dataURI.slice(matches[0].length);\n        if (isBase64) {\n          // Convert base64 to raw binary data held in a string:\n          byteString = atob(dataString);\n        } else {\n          // Convert base64/URLEncoded data component to raw binary:\n          byteString = decodeURIComponent(dataString);\n        }\n        // Write the bytes of the string to an ArrayBuffer:\n        arrayBuffer = new ArrayBuffer(byteString.length);\n        intArray = new Uint8Array(arrayBuffer);\n        for (i = 0; i < byteString.length; i += 1) {\n          intArray[i] = byteString.charCodeAt(i);\n        }\n        // Write the ArrayBuffer (or ArrayBufferView) to a blob:\n        if (hasBlobConstructor) {\n          return new Blob([hasArrayBufferViewSupport ? intArray : arrayBuffer], {\n            type: mediaType\n          });\n        }\n        bb = new BlobBuilder();\n        bb.append(arrayBuffer);\n        return bb.getBlob(mediaType);\n      };\n      if (window.HTMLCanvasElement && !CanvasPrototype.toBlob) {\n        if (CanvasPrototype.mozGetAsFile) {\n          CanvasPrototype.toBlob = function (callback, type, quality) {\n            var self = this;\n            setTimeout(function () {\n              if (quality && CanvasPrototype.toDataURL && dataURLtoBlob) {\n                callback(dataURLtoBlob(self.toDataURL(type, quality)));\n              } else {\n                callback(self.mozGetAsFile('blob', type));\n              }\n            });\n          };\n        } else if (CanvasPrototype.toDataURL && dataURLtoBlob) {\n          if (CanvasPrototype.msToBlob) {\n            CanvasPrototype.toBlob = function (callback, type, quality) {\n              var self = this;\n              setTimeout(function () {\n                if ((type && type !== 'image/png' || quality) && CanvasPrototype.toDataURL && dataURLtoBlob) {\n                  callback(dataURLtoBlob(self.toDataURL(type, quality)));\n                } else {\n                  callback(self.msToBlob(type));\n                }\n              });\n            };\n          } else {\n            CanvasPrototype.toBlob = function (callback, type, quality) {\n              var self = this;\n              setTimeout(function () {\n                callback(dataURLtoBlob(self.toDataURL(type, quality)));\n              });\n            };\n          }\n        }\n      }\n      if (module.exports) {\n        module.exports = dataURLtoBlob;\n      } else {\n        window.dataURLtoBlob = dataURLtoBlob;\n      }\n    })(window);\n  })(canvasToBlob);\n  var toBlob = canvasToBlob.exports;\n\n  var isBlob = function isBlob(value) {\n    if (typeof Blob === 'undefined') {\n      return false;\n    }\n    return value instanceof Blob || Object.prototype.toString.call(value) === '[object Blob]';\n  };\n\n  var DEFAULTS = {\n    /**\n     * Indicates if output the original image instead of the compressed one\n     * when the size of the compressed image is greater than the original one's\n     * @type {boolean}\n     */\n    strict: true,\n    /**\n     * Indicates if read the image's Exif Orientation information,\n     * and then rotate or flip the image automatically.\n     * @type {boolean}\n     */\n    checkOrientation: true,\n    /**\n     * Indicates if retain the image's Exif information after compressed.\n     * @type {boolean}\n    */\n    retainExif: false,\n    /**\n     * The max width of the output image.\n     * @type {number}\n     */\n    maxWidth: Infinity,\n    /**\n     * The max height of the output image.\n     * @type {number}\n     */\n    maxHeight: Infinity,\n    /**\n     * The min width of the output image.\n     * @type {number}\n     */\n    minWidth: 0,\n    /**\n     * The min height of the output image.\n     * @type {number}\n     */\n    minHeight: 0,\n    /**\n     * The width of the output image.\n     * If not specified, the natural width of the source image will be used.\n     * @type {number}\n     */\n    width: undefined,\n    /**\n     * The height of the output image.\n     * If not specified, the natural height of the source image will be used.\n     * @type {number}\n     */\n    height: undefined,\n    /**\n     * Sets how the size of the image should be resized to the container\n     * specified by the `width` and `height` options.\n     * @type {string}\n     */\n    resize: 'none',\n    /**\n     * The quality of the output image.\n     * It must be a number between `0` and `1`,\n     * and only available for `image/jpeg` and `image/webp` images.\n     * Check out {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob canvas.toBlob}.\n     * @type {number}\n     */\n    quality: 0.8,\n    /**\n     * The mime type of the output image.\n     * By default, the original mime type of the source image file will be used.\n     * @type {string}\n     */\n    mimeType: 'auto',\n    /**\n     * Files whose file type is included in this list,\n     * and whose file size exceeds the `convertSize` value will be converted to JPEGs.\n     * @type {string｜Array}\n     */\n    convertTypes: ['image/png'],\n    /**\n     * PNG files over this size (5 MB by default) will be converted to JPEGs.\n     * To disable this, just set the value to `Infinity`.\n     * @type {number}\n     */\n    convertSize: 5000000,\n    /**\n     * The hook function to execute before draw the image into the canvas for compression.\n     * @type {Function}\n     * @param {CanvasRenderingContext2D} context - The 2d rendering context of the canvas.\n     * @param {HTMLCanvasElement} canvas - The canvas for compression.\n     * @example\n     * function (context, canvas) {\n     *   context.fillStyle = '#fff';\n     * }\n     */\n    beforeDraw: null,\n    /**\n     * The hook function to execute after drew the image into the canvas for compression.\n     * @type {Function}\n     * @param {CanvasRenderingContext2D} context - The 2d rendering context of the canvas.\n     * @param {HTMLCanvasElement} canvas - The canvas for compression.\n     * @example\n     * function (context, canvas) {\n     *   context.filter = 'grayscale(100%)';\n     * }\n     */\n    drew: null,\n    /**\n     * The hook function to execute when success to compress the image.\n     * @type {Function}\n     * @param {File} file - The compressed image File object.\n     * @example\n     * function (file) {\n     *   console.log(file);\n     * }\n     */\n    success: null,\n    /**\n     * The hook function to execute when fail to compress the image.\n     * @type {Function}\n     * @param {Error} err - An Error object.\n     * @example\n     * function (err) {\n     *   console.log(err.message);\n     * }\n     */\n    error: null\n  };\n\n  var IS_BROWSER = typeof window !== 'undefined' && typeof window.document !== 'undefined';\n  var WINDOW = IS_BROWSER ? window : {};\n\n  /**\n   * Check if the given value is a positive number.\n   * @param {*} value - The value to check.\n   * @returns {boolean} Returns `true` if the given value is a positive number, else `false`.\n   */\n  var isPositiveNumber = function isPositiveNumber(value) {\n    return value > 0 && value < Infinity;\n  };\n  var slice = Array.prototype.slice;\n\n  /**\n   * Convert array-like or iterable object to an array.\n   * @param {*} value - The value to convert.\n   * @returns {Array} Returns a new array.\n   */\n  function toArray(value) {\n    return Array.from ? Array.from(value) : slice.call(value);\n  }\n  var REGEXP_IMAGE_TYPE = /^image\\/.+$/;\n\n  /**\n   * Check if the given value is a mime type of image.\n   * @param {*} value - The value to check.\n   * @returns {boolean} Returns `true` if the given is a mime type of image, else `false`.\n   */\n  function isImageType(value) {\n    return REGEXP_IMAGE_TYPE.test(value);\n  }\n\n  /**\n   * Convert image type to extension.\n   * @param {string} value - The image type to convert.\n   * @returns {boolean} Returns the image extension.\n   */\n  function imageTypeToExtension(value) {\n    var extension = isImageType(value) ? value.substr(6) : '';\n    if (extension === 'jpeg') {\n      extension = 'jpg';\n    }\n    return \".\".concat(extension);\n  }\n  var fromCharCode = String.fromCharCode;\n\n  /**\n   * Get string from char code in data view.\n   * @param {DataView} dataView - The data view for read.\n   * @param {number} start - The start index.\n   * @param {number} length - The read length.\n   * @returns {string} The read result.\n   */\n  function getStringFromCharCode(dataView, start, length) {\n    var str = '';\n    var i;\n    length += start;\n    for (i = start; i < length; i += 1) {\n      str += fromCharCode(dataView.getUint8(i));\n    }\n    return str;\n  }\n  var btoa = WINDOW.btoa;\n\n  /**\n   * Transform array buffer to Data URL.\n   * @param {ArrayBuffer} arrayBuffer - The array buffer to transform.\n   * @param {string} mimeType - The mime type of the Data URL.\n   * @returns {string} The result Data URL.\n   */\n  function arrayBufferToDataURL(arrayBuffer, mimeType) {\n    var chunks = [];\n    var chunkSize = 8192;\n    var uint8 = new Uint8Array(arrayBuffer);\n    while (uint8.length > 0) {\n      // XXX: Babel's `toConsumableArray` helper will throw error in IE or Safari 9\n      // eslint-disable-next-line prefer-spread\n      chunks.push(fromCharCode.apply(null, toArray(uint8.subarray(0, chunkSize))));\n      uint8 = uint8.subarray(chunkSize);\n    }\n    return \"data:\".concat(mimeType, \";base64,\").concat(btoa(chunks.join('')));\n  }\n\n  /**\n   * Get orientation value from given array buffer.\n   * @param {ArrayBuffer} arrayBuffer - The array buffer to read.\n   * @returns {number} The read orientation value.\n   */\n  function resetAndGetOrientation(arrayBuffer) {\n    var dataView = new DataView(arrayBuffer);\n    var orientation;\n\n    // Ignores range error when the image does not have correct Exif information\n    try {\n      var littleEndian;\n      var app1Start;\n      var ifdStart;\n\n      // Only handle JPEG image (start by 0xFFD8)\n      if (dataView.getUint8(0) === 0xFF && dataView.getUint8(1) === 0xD8) {\n        var length = dataView.byteLength;\n        var offset = 2;\n        while (offset + 1 < length) {\n          if (dataView.getUint8(offset) === 0xFF && dataView.getUint8(offset + 1) === 0xE1) {\n            app1Start = offset;\n            break;\n          }\n          offset += 1;\n        }\n      }\n      if (app1Start) {\n        var exifIDCode = app1Start + 4;\n        var tiffOffset = app1Start + 10;\n        if (getStringFromCharCode(dataView, exifIDCode, 4) === 'Exif') {\n          var endianness = dataView.getUint16(tiffOffset);\n          littleEndian = endianness === 0x4949;\n          if (littleEndian || endianness === 0x4D4D /* bigEndian */) {\n            if (dataView.getUint16(tiffOffset + 2, littleEndian) === 0x002A) {\n              var firstIFDOffset = dataView.getUint32(tiffOffset + 4, littleEndian);\n              if (firstIFDOffset >= 0x00000008) {\n                ifdStart = tiffOffset + firstIFDOffset;\n              }\n            }\n          }\n        }\n      }\n      if (ifdStart) {\n        var _length = dataView.getUint16(ifdStart, littleEndian);\n        var _offset;\n        var i;\n        for (i = 0; i < _length; i += 1) {\n          _offset = ifdStart + i * 12 + 2;\n          if (dataView.getUint16(_offset, littleEndian) === 0x0112 /* Orientation */) {\n            // 8 is the offset of the current tag's value\n            _offset += 8;\n\n            // Get the original orientation value\n            orientation = dataView.getUint16(_offset, littleEndian);\n\n            // Override the orientation with its default value\n            dataView.setUint16(_offset, 1, littleEndian);\n            break;\n          }\n        }\n      }\n    } catch (e) {\n      orientation = 1;\n    }\n    return orientation;\n  }\n\n  /**\n   * Parse Exif Orientation value.\n   * @param {number} orientation - The orientation to parse.\n   * @returns {Object} The parsed result.\n   */\n  function parseOrientation(orientation) {\n    var rotate = 0;\n    var scaleX = 1;\n    var scaleY = 1;\n    switch (orientation) {\n      // Flip horizontal\n      case 2:\n        scaleX = -1;\n        break;\n\n      // Rotate left 180°\n      case 3:\n        rotate = -180;\n        break;\n\n      // Flip vertical\n      case 4:\n        scaleY = -1;\n        break;\n\n      // Flip vertical and rotate right 90°\n      case 5:\n        rotate = 90;\n        scaleY = -1;\n        break;\n\n      // Rotate right 90°\n      case 6:\n        rotate = 90;\n        break;\n\n      // Flip horizontal and rotate right 90°\n      case 7:\n        rotate = 90;\n        scaleX = -1;\n        break;\n\n      // Rotate left 90°\n      case 8:\n        rotate = -90;\n        break;\n    }\n    return {\n      rotate: rotate,\n      scaleX: scaleX,\n      scaleY: scaleY\n    };\n  }\n  var REGEXP_DECIMALS = /\\.\\d*(?:0|9){12}\\d*$/;\n\n  /**\n   * Normalize decimal number.\n   * Check out {@link https://0.30000000000000004.com/}\n   * @param {number} value - The value to normalize.\n   * @param {number} [times=100000000000] - The times for normalizing.\n   * @returns {number} Returns the normalized number.\n   */\n  function normalizeDecimalNumber(value) {\n    var times = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 100000000000;\n    return REGEXP_DECIMALS.test(value) ? Math.round(value * times) / times : value;\n  }\n\n  /**\n   * Get the max sizes in a rectangle under the given aspect ratio.\n   * @param {Object} data - The original sizes.\n   * @param {string} [type='contain'] - The adjust type.\n   * @returns {Object} The result sizes.\n   */\n  function getAdjustedSizes(_ref) {\n    var aspectRatio = _ref.aspectRatio,\n      height = _ref.height,\n      width = _ref.width;\n    var type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'none';\n    var isValidWidth = isPositiveNumber(width);\n    var isValidHeight = isPositiveNumber(height);\n    if (isValidWidth && isValidHeight) {\n      var adjustedWidth = height * aspectRatio;\n      if ((type === 'contain' || type === 'none') && adjustedWidth > width || type === 'cover' && adjustedWidth < width) {\n        height = width / aspectRatio;\n      } else {\n        width = height * aspectRatio;\n      }\n    } else if (isValidWidth) {\n      height = width / aspectRatio;\n    } else if (isValidHeight) {\n      width = height * aspectRatio;\n    }\n    return {\n      width: width,\n      height: height\n    };\n  }\n\n  /**\n   * Get Exif information from the given array buffer.\n   * @param {ArrayBuffer} arrayBuffer - The array buffer to read.\n   * @returns {Array} The read Exif information.\n   */\n  function getExif(arrayBuffer) {\n    var array = toArray(new Uint8Array(arrayBuffer));\n    var length = array.length;\n    var segments = [];\n    var start = 0;\n    while (start + 3 < length) {\n      var value = array[start];\n      var next = array[start + 1];\n\n      // SOS (Start of Scan)\n      if (value === 0xFF && next === 0xDA) {\n        break;\n      }\n\n      // SOI (Start of Image)\n      if (value === 0xFF && next === 0xD8) {\n        start += 2;\n      } else {\n        var offset = array[start + 2] * 256 + array[start + 3];\n        var end = start + offset + 2;\n        var segment = array.slice(start, end);\n        segments.push(segment);\n        start = end;\n      }\n    }\n    return segments.reduce(function (exifArray, current) {\n      if (current[0] === 0xFF && current[1] === 0xE1) {\n        return exifArray.concat(current);\n      }\n      return exifArray;\n    }, []);\n  }\n\n  /**\n   * Insert Exif information into the given array buffer.\n   * @param {ArrayBuffer} arrayBuffer - The array buffer to transform.\n   * @param {Array} exifArray - The Exif information to insert.\n   * @returns {ArrayBuffer} The transformed array buffer.\n   */\n  function insertExif(arrayBuffer, exifArray) {\n    var array = toArray(new Uint8Array(arrayBuffer));\n    if (array[2] !== 0xFF || array[3] !== 0xE0) {\n      return arrayBuffer;\n    }\n    var app0Length = array[4] * 256 + array[5];\n    var newArrayBuffer = [0xFF, 0xD8].concat(exifArray, array.slice(4 + app0Length));\n    return new Uint8Array(newArrayBuffer);\n  }\n\n  var ArrayBuffer$1 = WINDOW.ArrayBuffer,\n    FileReader = WINDOW.FileReader;\n  var URL = WINDOW.URL || WINDOW.webkitURL;\n  var REGEXP_EXTENSION = /\\.\\w+$/;\n  var AnotherCompressor = WINDOW.Compressor;\n\n  /**\n   * Creates a new image compressor.\n   * @class\n   */\n  var Compressor = /*#__PURE__*/function () {\n    /**\n     * The constructor of Compressor.\n     * @param {File|Blob} file - The target image file for compressing.\n     * @param {Object} [options] - The options for compressing.\n     */\n    function Compressor(file, options) {\n      _classCallCheck(this, Compressor);\n      this.file = file;\n      this.exif = [];\n      this.image = new Image();\n      this.options = _objectSpread2(_objectSpread2({}, DEFAULTS), options);\n      this.aborted = false;\n      this.result = null;\n      this.init();\n    }\n    _createClass(Compressor, [{\n      key: \"init\",\n      value: function init() {\n        var _this = this;\n        var file = this.file,\n          options = this.options;\n        if (!isBlob(file)) {\n          this.fail(new Error('The first argument must be a File or Blob object.'));\n          return;\n        }\n        var mimeType = file.type;\n        if (!isImageType(mimeType)) {\n          this.fail(new Error('The first argument must be an image File or Blob object.'));\n          return;\n        }\n        if (!URL || !FileReader) {\n          this.fail(new Error('The current browser does not support image compression.'));\n          return;\n        }\n        if (!ArrayBuffer$1) {\n          options.checkOrientation = false;\n          options.retainExif = false;\n        }\n        var isJPEGImage = mimeType === 'image/jpeg';\n        var checkOrientation = isJPEGImage && options.checkOrientation;\n        var retainExif = isJPEGImage && options.retainExif;\n        if (URL && !checkOrientation && !retainExif) {\n          this.load({\n            url: URL.createObjectURL(file)\n          });\n        } else {\n          var reader = new FileReader();\n          this.reader = reader;\n          reader.onload = function (_ref) {\n            var target = _ref.target;\n            var result = target.result;\n            var data = {};\n            var orientation = 1;\n            if (checkOrientation) {\n              // Reset the orientation value to its default value 1\n              // as some iOS browsers will render image with its orientation\n              orientation = resetAndGetOrientation(result);\n              if (orientation > 1) {\n                _extends(data, parseOrientation(orientation));\n              }\n            }\n            if (retainExif) {\n              _this.exif = getExif(result);\n            }\n            if (checkOrientation || retainExif) {\n              if (!URL\n\n              // Generate a new URL with the default orientation value 1.\n              || orientation > 1) {\n                data.url = arrayBufferToDataURL(result, mimeType);\n              } else {\n                data.url = URL.createObjectURL(file);\n              }\n            } else {\n              data.url = result;\n            }\n            _this.load(data);\n          };\n          reader.onabort = function () {\n            _this.fail(new Error('Aborted to read the image with FileReader.'));\n          };\n          reader.onerror = function () {\n            _this.fail(new Error('Failed to read the image with FileReader.'));\n          };\n          reader.onloadend = function () {\n            _this.reader = null;\n          };\n          if (checkOrientation || retainExif) {\n            reader.readAsArrayBuffer(file);\n          } else {\n            reader.readAsDataURL(file);\n          }\n        }\n      }\n    }, {\n      key: \"load\",\n      value: function load(data) {\n        var _this2 = this;\n        var file = this.file,\n          image = this.image;\n        image.onload = function () {\n          _this2.draw(_objectSpread2(_objectSpread2({}, data), {}, {\n            naturalWidth: image.naturalWidth,\n            naturalHeight: image.naturalHeight\n          }));\n        };\n        image.onabort = function () {\n          _this2.fail(new Error('Aborted to load the image.'));\n        };\n        image.onerror = function () {\n          _this2.fail(new Error('Failed to load the image.'));\n        };\n\n        // Match all browsers that use WebKit as the layout engine in iOS devices,\n        // such as Safari for iOS, Chrome for iOS, and in-app browsers.\n        if (WINDOW.navigator && /(?:iPad|iPhone|iPod).*?AppleWebKit/i.test(WINDOW.navigator.userAgent)) {\n          // Fix the `The operation is insecure` error (#57)\n          image.crossOrigin = 'anonymous';\n        }\n        image.alt = file.name;\n        image.src = data.url;\n      }\n    }, {\n      key: \"draw\",\n      value: function draw(_ref2) {\n        var _this3 = this;\n        var naturalWidth = _ref2.naturalWidth,\n          naturalHeight = _ref2.naturalHeight,\n          _ref2$rotate = _ref2.rotate,\n          rotate = _ref2$rotate === void 0 ? 0 : _ref2$rotate,\n          _ref2$scaleX = _ref2.scaleX,\n          scaleX = _ref2$scaleX === void 0 ? 1 : _ref2$scaleX,\n          _ref2$scaleY = _ref2.scaleY,\n          scaleY = _ref2$scaleY === void 0 ? 1 : _ref2$scaleY;\n        var file = this.file,\n          image = this.image,\n          options = this.options;\n        var canvas = document.createElement('canvas');\n        var context = canvas.getContext('2d');\n        var is90DegreesRotated = Math.abs(rotate) % 180 === 90;\n        var resizable = (options.resize === 'contain' || options.resize === 'cover') && isPositiveNumber(options.width) && isPositiveNumber(options.height);\n        var maxWidth = Math.max(options.maxWidth, 0) || Infinity;\n        var maxHeight = Math.max(options.maxHeight, 0) || Infinity;\n        var minWidth = Math.max(options.minWidth, 0) || 0;\n        var minHeight = Math.max(options.minHeight, 0) || 0;\n        var aspectRatio = naturalWidth / naturalHeight;\n        var width = options.width,\n          height = options.height;\n        if (is90DegreesRotated) {\n          var _ref3 = [maxHeight, maxWidth];\n          maxWidth = _ref3[0];\n          maxHeight = _ref3[1];\n          var _ref4 = [minHeight, minWidth];\n          minWidth = _ref4[0];\n          minHeight = _ref4[1];\n          var _ref5 = [height, width];\n          width = _ref5[0];\n          height = _ref5[1];\n        }\n        if (resizable) {\n          aspectRatio = width / height;\n        }\n        var _getAdjustedSizes = getAdjustedSizes({\n          aspectRatio: aspectRatio,\n          width: maxWidth,\n          height: maxHeight\n        }, 'contain');\n        maxWidth = _getAdjustedSizes.width;\n        maxHeight = _getAdjustedSizes.height;\n        var _getAdjustedSizes2 = getAdjustedSizes({\n          aspectRatio: aspectRatio,\n          width: minWidth,\n          height: minHeight\n        }, 'cover');\n        minWidth = _getAdjustedSizes2.width;\n        minHeight = _getAdjustedSizes2.height;\n        if (resizable) {\n          var _getAdjustedSizes3 = getAdjustedSizes({\n            aspectRatio: aspectRatio,\n            width: width,\n            height: height\n          }, options.resize);\n          width = _getAdjustedSizes3.width;\n          height = _getAdjustedSizes3.height;\n        } else {\n          var _getAdjustedSizes4 = getAdjustedSizes({\n            aspectRatio: aspectRatio,\n            width: width,\n            height: height\n          });\n          var _getAdjustedSizes4$wi = _getAdjustedSizes4.width;\n          width = _getAdjustedSizes4$wi === void 0 ? naturalWidth : _getAdjustedSizes4$wi;\n          var _getAdjustedSizes4$he = _getAdjustedSizes4.height;\n          height = _getAdjustedSizes4$he === void 0 ? naturalHeight : _getAdjustedSizes4$he;\n        }\n        width = Math.floor(normalizeDecimalNumber(Math.min(Math.max(width, minWidth), maxWidth)));\n        height = Math.floor(normalizeDecimalNumber(Math.min(Math.max(height, minHeight), maxHeight)));\n        var destX = -width / 2;\n        var destY = -height / 2;\n        var destWidth = width;\n        var destHeight = height;\n        var params = [];\n        if (resizable) {\n          var srcX = 0;\n          var srcY = 0;\n          var srcWidth = naturalWidth;\n          var srcHeight = naturalHeight;\n          var _getAdjustedSizes5 = getAdjustedSizes({\n            aspectRatio: aspectRatio,\n            width: naturalWidth,\n            height: naturalHeight\n          }, {\n            contain: 'cover',\n            cover: 'contain'\n          }[options.resize]);\n          srcWidth = _getAdjustedSizes5.width;\n          srcHeight = _getAdjustedSizes5.height;\n          srcX = (naturalWidth - srcWidth) / 2;\n          srcY = (naturalHeight - srcHeight) / 2;\n          params.push(srcX, srcY, srcWidth, srcHeight);\n        }\n        params.push(destX, destY, destWidth, destHeight);\n        if (is90DegreesRotated) {\n          var _ref6 = [height, width];\n          width = _ref6[0];\n          height = _ref6[1];\n        }\n        canvas.width = width;\n        canvas.height = height;\n        if (!isImageType(options.mimeType)) {\n          options.mimeType = file.type;\n        }\n        var fillStyle = 'transparent';\n\n        // Converts PNG files over the `convertSize` to JPEGs.\n        if (file.size > options.convertSize && options.convertTypes.indexOf(options.mimeType) >= 0) {\n          options.mimeType = 'image/jpeg';\n        }\n        var isJPEGImage = options.mimeType === 'image/jpeg';\n        if (isJPEGImage) {\n          fillStyle = '#fff';\n        }\n\n        // Override the default fill color (#000, black)\n        context.fillStyle = fillStyle;\n        context.fillRect(0, 0, width, height);\n        if (options.beforeDraw) {\n          options.beforeDraw.call(this, context, canvas);\n        }\n        if (this.aborted) {\n          return;\n        }\n        context.save();\n        context.translate(width / 2, height / 2);\n        context.rotate(rotate * Math.PI / 180);\n        context.scale(scaleX, scaleY);\n        context.drawImage.apply(context, [image].concat(params));\n        context.restore();\n        if (options.drew) {\n          options.drew.call(this, context, canvas);\n        }\n        if (this.aborted) {\n          return;\n        }\n        var callback = function callback(blob) {\n          if (!_this3.aborted) {\n            var done = function done(result) {\n              return _this3.done({\n                naturalWidth: naturalWidth,\n                naturalHeight: naturalHeight,\n                result: result\n              });\n            };\n            if (blob && isJPEGImage && options.retainExif && _this3.exif && _this3.exif.length > 0) {\n              var next = function next(arrayBuffer) {\n                return done(toBlob(arrayBufferToDataURL(insertExif(arrayBuffer, _this3.exif), options.mimeType)));\n              };\n              if (blob.arrayBuffer) {\n                blob.arrayBuffer().then(next).catch(function () {\n                  _this3.fail(new Error('Failed to read the compressed image with Blob.arrayBuffer().'));\n                });\n              } else {\n                var reader = new FileReader();\n                _this3.reader = reader;\n                reader.onload = function (_ref7) {\n                  var target = _ref7.target;\n                  next(target.result);\n                };\n                reader.onabort = function () {\n                  _this3.fail(new Error('Aborted to read the compressed image with FileReader.'));\n                };\n                reader.onerror = function () {\n                  _this3.fail(new Error('Failed to read the compressed image with FileReader.'));\n                };\n                reader.onloadend = function () {\n                  _this3.reader = null;\n                };\n                reader.readAsArrayBuffer(blob);\n              }\n            } else {\n              done(blob);\n            }\n          }\n        };\n        if (canvas.toBlob) {\n          canvas.toBlob(callback, options.mimeType, options.quality);\n        } else {\n          callback(toBlob(canvas.toDataURL(options.mimeType, options.quality)));\n        }\n      }\n    }, {\n      key: \"done\",\n      value: function done(_ref8) {\n        var naturalWidth = _ref8.naturalWidth,\n          naturalHeight = _ref8.naturalHeight,\n          result = _ref8.result;\n        var file = this.file,\n          image = this.image,\n          options = this.options;\n        if (URL && image.src.indexOf('blob:') === 0) {\n          URL.revokeObjectURL(image.src);\n        }\n        if (result) {\n          // Returns original file if the result is greater than it and without size related options\n          if (options.strict && !options.retainExif && result.size > file.size && options.mimeType === file.type && !(options.width > naturalWidth || options.height > naturalHeight || options.minWidth > naturalWidth || options.minHeight > naturalHeight || options.maxWidth < naturalWidth || options.maxHeight < naturalHeight)) {\n            result = file;\n          } else {\n            var date = new Date();\n            result.lastModified = date.getTime();\n            result.lastModifiedDate = date;\n            result.name = file.name;\n\n            // Convert the extension to match its type\n            if (result.name && result.type !== file.type) {\n              result.name = result.name.replace(REGEXP_EXTENSION, imageTypeToExtension(result.type));\n            }\n          }\n        } else {\n          // Returns original file if the result is null in some cases.\n          result = file;\n        }\n        this.result = result;\n        if (options.success) {\n          options.success.call(this, result);\n        }\n      }\n    }, {\n      key: \"fail\",\n      value: function fail(err) {\n        var options = this.options;\n        if (options.error) {\n          options.error.call(this, err);\n        } else {\n          throw err;\n        }\n      }\n    }, {\n      key: \"abort\",\n      value: function abort() {\n        if (!this.aborted) {\n          this.aborted = true;\n          if (this.reader) {\n            this.reader.abort();\n          } else if (!this.image.complete) {\n            this.image.onload = null;\n            this.image.onabort();\n          } else {\n            this.fail(new Error('The compression process has been aborted.'));\n          }\n        }\n      }\n\n      /**\n       * Get the no conflict compressor class.\n       * @returns {Compressor} The compressor class.\n       */\n    }], [{\n      key: \"noConflict\",\n      value: function noConflict() {\n        window.Compressor = AnotherCompressor;\n        return Compressor;\n      }\n\n      /**\n       * Change the default options.\n       * @param {Object} options - The new default options.\n       */\n    }, {\n      key: \"setDefaults\",\n      value: function setDefaults(options) {\n        _extends(DEFAULTS, options);\n      }\n    }]);\n    return Compressor;\n  }();\n\n  return Compressor;\n\n}));\n","/**\n * Throw a given error.\n *\n * @param {Error|null|undefined} [error]\n *   Maybe error.\n * @returns {asserts error is null|undefined}\n */\nexport function bail(error) {\n  if (error) {\n    throw error\n  }\n}\n","/**\n * Count how often a character (or substring) is used in a string.\n *\n * @param {string} value\n *   Value to search in.\n * @param {string} character\n *   Character (or substring) to look for.\n * @return {number}\n *   Number of times `character` occurred in `value`.\n */\nexport function ccount(value, character) {\n  const source = String(value)\n\n  if (typeof character !== 'string') {\n    throw new TypeError('Expected character')\n  }\n\n  let count = 0\n  let index = source.indexOf(character)\n\n  while (index !== -1) {\n    count++\n    index = source.indexOf(character, index + character.length)\n  }\n\n  return count\n}\n","function r(e){var t,f,n=\"\";if(\"string\"==typeof e||\"number\"==typeof e)n+=e;else if(\"object\"==typeof e)if(Array.isArray(e)){var o=e.length;for(t=0;t<o;t++)e[t]&&(f=r(e[t]))&&(n&&(n+=\" \"),n+=f)}else for(f in e)e[f]&&(n&&(n+=\" \"),n+=f);return n}export function clsx(){for(var e,t,f=0,n=\"\",o=arguments.length;f<o;f++)(e=arguments[f])&&(t=r(e))&&(n&&(n+=\" \"),n+=t);return n}export default clsx;","/**\n * @typedef Options\n *   Configuration for `stringify`.\n * @property {boolean} [padLeft=true]\n *   Whether to pad a space before a token.\n * @property {boolean} [padRight=false]\n *   Whether to pad a space after a token.\n */\n\n/**\n * @typedef {Options} StringifyOptions\n *   Please use `StringifyOptions` instead.\n */\n\n/**\n * Parse comma-separated tokens to an array.\n *\n * @param {string} value\n *   Comma-separated tokens.\n * @returns {Array<string>}\n *   List of tokens.\n */\nexport function parse(value) {\n  /** @type {Array<string>} */\n  const tokens = []\n  const input = String(value || '')\n  let index = input.indexOf(',')\n  let start = 0\n  /** @type {boolean} */\n  let end = false\n\n  while (!end) {\n    if (index === -1) {\n      index = input.length\n      end = true\n    }\n\n    const token = input.slice(start, index).trim()\n\n    if (token || !end) {\n      tokens.push(token)\n    }\n\n    start = index + 1\n    index = input.indexOf(',', start)\n  }\n\n  return tokens\n}\n\n/**\n * Serialize an array of strings or numbers to comma-separated tokens.\n *\n * @param {Array<string|number>} values\n *   List of tokens.\n * @param {Options} [options]\n *   Configuration for `stringify` (optional).\n * @returns {string}\n *   Comma-separated tokens.\n */\nexport function stringify(values, options) {\n  const settings = options || {}\n\n  // Ensure the last empty entry is seen.\n  const input = values[values.length - 1] === '' ? [...values, ''] : values\n\n  return input\n    .join(\n      (settings.padRight ? ' ' : '') +\n        ',' +\n        (settings.padLeft === false ? '' : ' ')\n    )\n    .trim()\n}\n","const t=t=>\"object\"==typeof t&&null!=t&&1===t.nodeType,e=(t,e)=>(!e||\"hidden\"!==t)&&(\"visible\"!==t&&\"clip\"!==t),n=(t,n)=>{if(t.clientHeight<t.scrollHeight||t.clientWidth<t.scrollWidth){const o=getComputedStyle(t,null);return e(o.overflowY,n)||e(o.overflowX,n)||(t=>{const e=(t=>{if(!t.ownerDocument||!t.ownerDocument.defaultView)return null;try{return t.ownerDocument.defaultView.frameElement}catch(t){return null}})(t);return!!e&&(e.clientHeight<t.scrollHeight||e.clientWidth<t.scrollWidth)})(t)}return!1},o=(t,e,n,o,l,r,i,s)=>r<t&&i>e||r>t&&i<e?0:r<=t&&s<=n||i>=e&&s>=n?r-t-o:i>e&&s<n||r<t&&s>n?i-e+l:0,l=t=>{const e=t.parentElement;return null==e?t.getRootNode().host||null:e},r=(e,r)=>{var i,s,d,h;if(\"undefined\"==typeof document)return[];const{scrollMode:c,block:f,inline:u,boundary:a,skipOverflowHiddenElements:g}=r,p=\"function\"==typeof a?a:t=>t!==a;if(!t(e))throw new TypeError(\"Invalid target\");const m=document.scrollingElement||document.documentElement,w=[];let W=e;for(;t(W)&&p(W);){if(W=l(W),W===m){w.push(W);break}null!=W&&W===document.body&&n(W)&&!n(document.documentElement)||null!=W&&n(W,g)&&w.push(W)}const b=null!=(s=null==(i=window.visualViewport)?void 0:i.width)?s:innerWidth,H=null!=(h=null==(d=window.visualViewport)?void 0:d.height)?h:innerHeight,{scrollX:y,scrollY:M}=window,{height:v,width:E,top:x,right:C,bottom:I,left:R}=e.getBoundingClientRect(),{top:T,right:B,bottom:F,left:V}=(t=>{const e=window.getComputedStyle(t);return{top:parseFloat(e.scrollMarginTop)||0,right:parseFloat(e.scrollMarginRight)||0,bottom:parseFloat(e.scrollMarginBottom)||0,left:parseFloat(e.scrollMarginLeft)||0}})(e);let k=\"start\"===f||\"nearest\"===f?x-T:\"end\"===f?I+F:x+v/2-T+F,D=\"center\"===u?R+E/2-V+B:\"end\"===u?C+B:R-V;const L=[];for(let t=0;t<w.length;t++){const e=w[t],{height:n,width:l,top:r,right:i,bottom:s,left:d}=e.getBoundingClientRect();if(\"if-needed\"===c&&x>=0&&R>=0&&I<=H&&C<=b&&x>=r&&I<=s&&R>=d&&C<=i)return L;const h=getComputedStyle(e),a=parseInt(h.borderLeftWidth,10),g=parseInt(h.borderTopWidth,10),p=parseInt(h.borderRightWidth,10),W=parseInt(h.borderBottomWidth,10);let T=0,B=0;const F=\"offsetWidth\"in e?e.offsetWidth-e.clientWidth-a-p:0,V=\"offsetHeight\"in e?e.offsetHeight-e.clientHeight-g-W:0,S=\"offsetWidth\"in e?0===e.offsetWidth?0:l/e.offsetWidth:0,X=\"offsetHeight\"in e?0===e.offsetHeight?0:n/e.offsetHeight:0;if(m===e)T=\"start\"===f?k:\"end\"===f?k-H:\"nearest\"===f?o(M,M+H,H,g,W,M+k,M+k+v,v):k-H/2,B=\"start\"===u?D:\"center\"===u?D-b/2:\"end\"===u?D-b:o(y,y+b,b,a,p,y+D,y+D+E,E),T=Math.max(0,T+M),B=Math.max(0,B+y);else{T=\"start\"===f?k-r-g:\"end\"===f?k-s+W+V:\"nearest\"===f?o(r,s,n,g,W+V,k,k+v,v):k-(r+n/2)+V/2,B=\"start\"===u?D-d-a:\"center\"===u?D-(d+l/2)+F/2:\"end\"===u?D-i+p+F:o(d,i,l,a,p+F,D,D+E,E);const{scrollLeft:t,scrollTop:h}=e;T=0===X?0:Math.max(0,Math.min(h+T/X,e.scrollHeight-n/X+V)),B=0===S?0:Math.max(0,Math.min(t+B/S,e.scrollWidth-l/S+F)),k+=h-T,D+=t-B}L.push({el:e,top:T,left:B})}return L};export{r as compute};//# sourceMappingURL=index.js.map\n"],"names":["exports","byteLength","b64","lens","getLens","validLen","placeHoldersLen","toByteArray","tmp","i","arr","Arr","_byteLength","curByte","len","revLookup","charCodeAt","fromByteArray","uint8","length","extraBytes","parts","maxChunkLength","len2","push","encodeChunk","lookup","join","Uint8Array","Array","code","Error","indexOf","start","end","num","output","base64","ieee754","customInspectSymbol","Symbol","Buffer","K_MAX_LENGTH","createBuffer","RangeError","buf","Object","setPrototypeOf","prototype","arg","encodingOrOffset","TypeError","allocUnsafe","from","value","string","encoding","isEncoding","actual","write","slice","fromString","ArrayBuffer","isView","arrayView","isInstance","copy","fromArrayBuffer","buffer","byteOffset","fromArrayLike","fromArrayView","SharedArrayBuffer","valueOf","b","obj","isBuffer","checked","undefined","numberIsNaN","type","isArray","data","fromObject","toPrimitive","assertSize","size","array","toString","mustMatch","arguments","loweredCase","utf8ToBytes","base64ToBytes","toLowerCase","slowToString","this","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","n","m","bidirectionalIndexOf","val","dir","arrayIndexOf","call","lastIndexOf","indexSize","arrLength","valLength","String","read","readUInt16BE","foundIndex","found","j","hexWrite","offset","Number","remaining","strLen","parsed","parseInt","substr","utf8Write","blitBuffer","asciiWrite","str","byteArray","asciiToBytes","base64Write","ucs2Write","units","c","hi","lo","utf16leToBytes","Math","min","res","firstByte","codePoint","bytesPerSequence","secondByte","thirdByte","fourthByte","tempCodePoint","codePoints","MAX_ARGUMENTS_LENGTH","fromCharCode","apply","decodeCodePointsArray","TYPED_ARRAY_SUPPORT","proto","foo","e","typedArraySupport","console","error","defineProperty","enumerable","get","poolSize","alloc","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","readBigUInt64BE","readIntLE","pow","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readBigInt64LE","readBigInt64BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUintLE","writeUIntLE","writeUintBE","writeUIntBE","writeUint8","writeUInt8","writeUint16LE","writeUInt16LE","writeUint16BE","writeUInt16BE","writeUint32LE","writeUInt32LE","writeUint32BE","writeUInt32BE","writeBigUInt64LE","writeBigUInt64BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeBigInt64LE","writeBigInt64BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","copyWithin","errors","E","sym","getMessage","Base","constructor","super","writable","configurable","name","stack","message","addNumericalSeparator","range","ERR_OUT_OF_RANGE","checkBounds","ERR_INVALID_ARG_TYPE","floor","ERR_BUFFER_OUT_OF_BOUNDS","input","msg","received","isInteger","abs","INVALID_BASE64_RE","Infinity","leadSurrogate","split","base64clean","src","dst","alphabet","table","i16","fn","BufferBigIntNotDefined","module","ownKeys","object","enumerableOnly","keys","getOwnPropertySymbols","symbols","filter","getOwnPropertyDescriptor","_objectSpread2","source","forEach","key","_defineProperty","getOwnPropertyDescriptors","defineProperties","_classCallCheck","instance","Constructor","_defineProperties","props","descriptor","_toPropertyKey","_createClass","protoProps","staticProps","_extends","assign","bind","hasOwnProperty","_toPrimitive","hint","prim","canvasToBlob","window","CanvasPrototype","HTMLCanvasElement","hasBlobConstructor","Blob","Boolean","hasArrayBufferViewSupport","BlobBuilder","WebKitBlobBuilder","MozBlobBuilder","MSBlobBuilder","dataURIPattern","dataURLtoBlob","atob","dataURI","matches","mediaType","isBase64","dataString","byteString","arrayBuffer","intArray","bb","match","decodeURIComponent","append","getBlob","toBlob","mozGetAsFile","callback","quality","self","setTimeout","toDataURL","msToBlob","isBlob","DEFAULTS","strict","checkOrientation","retainExif","maxWidth","maxHeight","minWidth","minHeight","width","height","resize","mimeType","convertTypes","convertSize","beforeDraw","drew","success","WINDOW","document","isPositiveNumber","toArray","REGEXP_IMAGE_TYPE","isImageType","test","imageTypeToExtension","extension","getStringFromCharCode","dataView","getUint8","btoa","arrayBufferToDataURL","chunks","chunkSize","resetAndGetOrientation","orientation","DataView","app1Start","ifdStart","tiffOffset","endianness","getUint16","firstIFDOffset","getUint32","_offset","_length","setUint16","parseOrientation","rotate","scaleX","scaleY","REGEXP_DECIMALS","normalizeDecimalNumber","times","round","getAdjustedSizes","_ref","aspectRatio","isValidWidth","isValidHeight","adjustedWidth","getExif","segments","next","segment","reduce","exifArray","current","insertExif","app0Length","newArrayBuffer","ArrayBuffer$1","FileReader","URL","webkitURL","REGEXP_EXTENSION","AnotherCompressor","Compressor","file","options","exif","image","Image","aborted","result","init","_this","isJPEGImage","reader","onload","url","createObjectURL","load","onabort","fail","onerror","onloadend","readAsArrayBuffer","readAsDataURL","_this2","draw","naturalWidth","naturalHeight","navigator","userAgent","crossOrigin","alt","_ref2","_this3","_ref2$rotate","_ref2$scaleX","_ref2$scaleY","canvas","createElement","context","getContext","is90DegreesRotated","resizable","_ref3","_ref4","_ref5","_getAdjustedSizes","_getAdjustedSizes2","_getAdjustedSizes3","_getAdjustedSizes4","_getAdjustedSizes4$wi","_getAdjustedSizes4$he","destX","destY","destWidth","destHeight","params","srcX","srcY","srcWidth","srcHeight","_getAdjustedSizes5","contain","cover","_ref6","fillStyle","fillRect","save","translate","PI","scale","drawImage","restore","blob","done","then","catch","_ref7","_ref8","revokeObjectURL","date","Date","lastModified","getTime","lastModifiedDate","err","abort","complete","factory","bail","ccount","character","count","index","r","t","f","o","stringify","values","settings","padRight","padLeft","nodeType","clientHeight","scrollHeight","clientWidth","scrollWidth","getComputedStyle","overflowY","overflowX","ownerDocument","defaultView","frameElement","l","s","parentElement","getRootNode","host","d","h","scrollMode","block","inline","u","boundary","skipOverflowHiddenElements","g","p","scrollingElement","documentElement","w","W","body","visualViewport","innerWidth","H","innerHeight","scrollX","scrollY","M","v","top","right","C","bottom","I","left","R","getBoundingClientRect","T","B","F","V","parseFloat","scrollMarginTop","scrollMarginRight","scrollMarginBottom","scrollMarginLeft","k","D","L","borderLeftWidth","borderTopWidth","borderRightWidth","borderBottomWidth","offsetWidth","offsetHeight","S","X","scrollLeft","scrollTop","el"],"sourceRoot":""}