{"version":3,"file":"vendors-640e94a9.xxxxxxxx.bundle.js","mappings":"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","sources":["webpack://iadviser/./node_modules/base64-js/index.js","webpack://iadviser/./node_modules/broadcast-channel/dist/es/util.js","webpack://iadviser/./node_modules/broadcast-channel/dist/es/methods/native.js","webpack://iadviser/./node_modules/broadcast-channel/dist/es/options.js","webpack://iadviser/./node_modules/broadcast-channel/dist/es/methods/indexed-db.js","webpack://iadviser/./node_modules/broadcast-channel/dist/es/methods/localstorage.js","webpack://iadviser/./node_modules/broadcast-channel/dist/es/methods/simulate.js","webpack://iadviser/./node_modules/broadcast-channel/dist/es/method-chooser.js","webpack://iadviser/./node_modules/broadcast-channel/dist/es/broadcast-channel.js","webpack://iadviser/./node_modules/buffer/index.js","webpack://iadviser/./node_modules/bignumber.js/bignumber.mjs"],"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 * returns true if the given object is a promise\n */\nexport function isPromise(obj) {\n  if (obj && typeof obj.then === 'function') {\n    return true;\n  } else {\n    return false;\n  }\n}\nexport function sleep(time) {\n  if (!time) time = 0;\n  return new Promise(function (res) {\n    return setTimeout(res, time);\n  });\n}\nexport function randomInt(min, max) {\n  return Math.floor(Math.random() * (max - min + 1) + min);\n}\n/**\n * https://stackoverflow.com/a/8084248\n */\n\nexport function randomToken() {\n  return Math.random().toString(36).substring(2);\n}\nvar lastMs = 0;\nvar additional = 0;\n/**\n * returns the current time in micro-seconds,\n * WARNING: This is a pseudo-function\n * Performance.now is not reliable in webworkers, so we just make sure to never return the same time.\n * This is enough in browsers, and this function will not be used in nodejs.\n * The main reason for this hack is to ensure that BroadcastChannel behaves equal to production when it is used in fast-running unit tests.\n */\n\nexport function microSeconds() {\n  var ms = new Date().getTime();\n\n  if (ms === lastMs) {\n    additional++;\n    return ms * 1000 + additional;\n  } else {\n    lastMs = ms;\n    additional = 0;\n    return ms * 1000;\n  }\n}\n/**\n * copied from the 'detect-node' npm module\n * We cannot use the module directly because it causes problems with rollup\n * @link https://github.com/iliakan/detect-node/blob/master/index.js\n */\n\nexport var isNode = Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]';","import { microSeconds as micro, isNode } from '../util';\nexport var microSeconds = micro;\nexport var type = 'native';\nexport function create(channelName) {\n  var state = {\n    messagesCallback: null,\n    bc: new BroadcastChannel(channelName),\n    subFns: [] // subscriberFunctions\n\n  };\n\n  state.bc.onmessage = function (msg) {\n    if (state.messagesCallback) {\n      state.messagesCallback(msg.data);\n    }\n  };\n\n  return state;\n}\nexport function close(channelState) {\n  channelState.bc.close();\n  channelState.subFns = [];\n}\nexport function postMessage(channelState, messageJson) {\n  try {\n    channelState.bc.postMessage(messageJson, false);\n    return Promise.resolve();\n  } catch (err) {\n    return Promise.reject(err);\n  }\n}\nexport function onMessage(channelState, fn) {\n  channelState.messagesCallback = fn;\n}\nexport function canBeUsed() {\n  /**\n   * in the electron-renderer, isNode will be true even if we are in browser-context\n   * so we also check if window is undefined\n   */\n  if (isNode && typeof window === 'undefined') return false;\n\n  if (typeof BroadcastChannel === 'function') {\n    if (BroadcastChannel._pubkey) {\n      throw new Error('BroadcastChannel: Do not overwrite window.BroadcastChannel with this module, this is not a polyfill');\n    }\n\n    return true;\n  } else return false;\n}\nexport function averageResponseTime() {\n  return 150;\n}\nexport default {\n  create: create,\n  close: close,\n  onMessage: onMessage,\n  postMessage: postMessage,\n  canBeUsed: canBeUsed,\n  type: type,\n  averageResponseTime: averageResponseTime,\n  microSeconds: microSeconds\n};","export function fillOptionsWithDefaults() {\n  var originalOptions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n  var options = JSON.parse(JSON.stringify(originalOptions)); // main\n\n  if (typeof options.webWorkerSupport === 'undefined') options.webWorkerSupport = true; // indexed-db\n\n  if (!options.idb) options.idb = {}; //  after this time the messages get deleted\n\n  if (!options.idb.ttl) options.idb.ttl = 1000 * 45;\n  if (!options.idb.fallbackInterval) options.idb.fallbackInterval = 150; //  handles abrupt db onclose events.\n\n  if (originalOptions.idb && typeof originalOptions.idb.onclose === 'function') options.idb.onclose = originalOptions.idb.onclose; // localstorage\n\n  if (!options.localstorage) options.localstorage = {};\n  if (!options.localstorage.removeTimeout) options.localstorage.removeTimeout = 1000 * 60; // custom methods\n\n  if (originalOptions.methods) options.methods = originalOptions.methods; // node\n\n  if (!options.node) options.node = {};\n  if (!options.node.ttl) options.node.ttl = 1000 * 60 * 2; // 2 minutes;\n\n  if (typeof options.node.useFastPath === 'undefined') options.node.useFastPath = true;\n  return options;\n}","/**\n * this method uses indexeddb to store the messages\n * There is currently no observerAPI for idb\n * @link https://github.com/w3c/IndexedDB/issues/51\n */\nimport { sleep, randomInt, randomToken, microSeconds as micro, isNode } from '../util.js';\nexport var microSeconds = micro;\nimport { ObliviousSet } from 'oblivious-set';\nimport { fillOptionsWithDefaults } from '../options';\nvar DB_PREFIX = 'pubkey.broadcast-channel-0-';\nvar OBJECT_STORE_ID = 'messages';\nexport var type = 'idb';\nexport function getIdb() {\n  if (typeof indexedDB !== 'undefined') return indexedDB;\n\n  if (typeof window !== 'undefined') {\n    if (typeof window.mozIndexedDB !== 'undefined') return window.mozIndexedDB;\n    if (typeof window.webkitIndexedDB !== 'undefined') return window.webkitIndexedDB;\n    if (typeof window.msIndexedDB !== 'undefined') return window.msIndexedDB;\n  }\n\n  return false;\n}\nexport function createDatabase(channelName) {\n  var IndexedDB = getIdb(); // create table\n\n  var dbName = DB_PREFIX + channelName;\n  var openRequest = IndexedDB.open(dbName, 1);\n\n  openRequest.onupgradeneeded = function (ev) {\n    var db = ev.target.result;\n    db.createObjectStore(OBJECT_STORE_ID, {\n      keyPath: 'id',\n      autoIncrement: true\n    });\n  };\n\n  var dbPromise = new Promise(function (res, rej) {\n    openRequest.onerror = function (ev) {\n      return rej(ev);\n    };\n\n    openRequest.onsuccess = function () {\n      res(openRequest.result);\n    };\n  });\n  return dbPromise;\n}\n/**\n * writes the new message to the database\n * so other readers can find it\n */\n\nexport function writeMessage(db, readerUuid, messageJson) {\n  var time = new Date().getTime();\n  var writeObject = {\n    uuid: readerUuid,\n    time: time,\n    data: messageJson\n  };\n  var transaction = db.transaction([OBJECT_STORE_ID], 'readwrite');\n  return new Promise(function (res, rej) {\n    transaction.oncomplete = function () {\n      return res();\n    };\n\n    transaction.onerror = function (ev) {\n      return rej(ev);\n    };\n\n    var objectStore = transaction.objectStore(OBJECT_STORE_ID);\n    objectStore.add(writeObject);\n  });\n}\nexport function getAllMessages(db) {\n  var objectStore = db.transaction(OBJECT_STORE_ID).objectStore(OBJECT_STORE_ID);\n  var ret = [];\n  return new Promise(function (res) {\n    objectStore.openCursor().onsuccess = function (ev) {\n      var cursor = ev.target.result;\n\n      if (cursor) {\n        ret.push(cursor.value); //alert(\"Name for SSN \" + cursor.key + \" is \" + cursor.value.name);\n\n        cursor[\"continue\"]();\n      } else {\n        res(ret);\n      }\n    };\n  });\n}\nexport function getMessagesHigherThan(db, lastCursorId) {\n  var objectStore = db.transaction(OBJECT_STORE_ID).objectStore(OBJECT_STORE_ID);\n  var ret = [];\n\n  function openCursor() {\n    // Occasionally Safari will fail on IDBKeyRange.bound, this\n    // catches that error, having it open the cursor to the first\n    // item. When it gets data it will advance to the desired key.\n    try {\n      var keyRangeValue = IDBKeyRange.bound(lastCursorId + 1, Infinity);\n      return objectStore.openCursor(keyRangeValue);\n    } catch (e) {\n      return objectStore.openCursor();\n    }\n  }\n\n  return new Promise(function (res) {\n    openCursor().onsuccess = function (ev) {\n      var cursor = ev.target.result;\n\n      if (cursor) {\n        if (cursor.value.id < lastCursorId + 1) {\n          cursor[\"continue\"](lastCursorId + 1);\n        } else {\n          ret.push(cursor.value);\n          cursor[\"continue\"]();\n        }\n      } else {\n        res(ret);\n      }\n    };\n  });\n}\nexport function removeMessageById(db, id) {\n  var request = db.transaction([OBJECT_STORE_ID], 'readwrite').objectStore(OBJECT_STORE_ID)[\"delete\"](id);\n  return new Promise(function (res) {\n    request.onsuccess = function () {\n      return res();\n    };\n  });\n}\nexport function getOldMessages(db, ttl) {\n  var olderThen = new Date().getTime() - ttl;\n  var objectStore = db.transaction(OBJECT_STORE_ID).objectStore(OBJECT_STORE_ID);\n  var ret = [];\n  return new Promise(function (res) {\n    objectStore.openCursor().onsuccess = function (ev) {\n      var cursor = ev.target.result;\n\n      if (cursor) {\n        var msgObk = cursor.value;\n\n        if (msgObk.time < olderThen) {\n          ret.push(msgObk); //alert(\"Name for SSN \" + cursor.key + \" is \" + cursor.value.name);\n\n          cursor[\"continue\"]();\n        } else {\n          // no more old messages,\n          res(ret);\n          return;\n        }\n      } else {\n        res(ret);\n      }\n    };\n  });\n}\nexport function cleanOldMessages(db, ttl) {\n  return getOldMessages(db, ttl).then(function (tooOld) {\n    return Promise.all(tooOld.map(function (msgObj) {\n      return removeMessageById(db, msgObj.id);\n    }));\n  });\n}\nexport function create(channelName, options) {\n  options = fillOptionsWithDefaults(options);\n  return createDatabase(channelName).then(function (db) {\n    var state = {\n      closed: false,\n      lastCursorId: 0,\n      channelName: channelName,\n      options: options,\n      uuid: randomToken(),\n\n      /**\n       * emittedMessagesIds\n       * contains all messages that have been emitted before\n       * @type {ObliviousSet}\n       */\n      eMIs: new ObliviousSet(options.idb.ttl * 2),\n      // ensures we do not read messages in parrallel\n      writeBlockPromise: Promise.resolve(),\n      messagesCallback: null,\n      readQueuePromises: [],\n      db: db\n    };\n    /**\n     * Handle abrupt closes that do not originate from db.close().\n     * This could happen, for example, if the underlying storage is\n     * removed or if the user clears the database in the browser's\n     * history preferences.\n     */\n\n    db.onclose = function () {\n      state.closed = true;\n      if (options.idb.onclose) options.idb.onclose();\n    };\n    /**\n     * if service-workers are used,\n     * we have no 'storage'-event if they post a message,\n     * therefore we also have to set an interval\n     */\n\n\n    _readLoop(state);\n\n    return state;\n  });\n}\n\nfunction _readLoop(state) {\n  if (state.closed) return;\n  readNewMessages(state).then(function () {\n    return sleep(state.options.idb.fallbackInterval);\n  }).then(function () {\n    return _readLoop(state);\n  });\n}\n\nfunction _filterMessage(msgObj, state) {\n  if (msgObj.uuid === state.uuid) return false; // send by own\n\n  if (state.eMIs.has(msgObj.id)) return false; // already emitted\n\n  if (msgObj.data.time < state.messagesCallbackTime) return false; // older then onMessageCallback\n\n  return true;\n}\n/**\n * reads all new messages from the database and emits them\n */\n\n\nfunction readNewMessages(state) {\n  // channel already closed\n  if (state.closed) return Promise.resolve(); // if no one is listening, we do not need to scan for new messages\n\n  if (!state.messagesCallback) return Promise.resolve();\n  return getMessagesHigherThan(state.db, state.lastCursorId).then(function (newerMessages) {\n    var useMessages = newerMessages\n    /**\n     * there is a bug in iOS where the msgObj can be undefined some times\n     * so we filter them out\n     * @link https://github.com/pubkey/broadcast-channel/issues/19\n     */\n    .filter(function (msgObj) {\n      return !!msgObj;\n    }).map(function (msgObj) {\n      if (msgObj.id > state.lastCursorId) {\n        state.lastCursorId = msgObj.id;\n      }\n\n      return msgObj;\n    }).filter(function (msgObj) {\n      return _filterMessage(msgObj, state);\n    }).sort(function (msgObjA, msgObjB) {\n      return msgObjA.time - msgObjB.time;\n    }); // sort by time\n\n    useMessages.forEach(function (msgObj) {\n      if (state.messagesCallback) {\n        state.eMIs.add(msgObj.id);\n        state.messagesCallback(msgObj.data);\n      }\n    });\n    return Promise.resolve();\n  });\n}\n\nexport function close(channelState) {\n  channelState.closed = true;\n  channelState.db.close();\n}\nexport function postMessage(channelState, messageJson) {\n  channelState.writeBlockPromise = channelState.writeBlockPromise.then(function () {\n    return writeMessage(channelState.db, channelState.uuid, messageJson);\n  }).then(function () {\n    if (randomInt(0, 10) === 0) {\n      /* await (do not await) */\n      cleanOldMessages(channelState.db, channelState.options.idb.ttl);\n    }\n  });\n  return channelState.writeBlockPromise;\n}\nexport function onMessage(channelState, fn, time) {\n  channelState.messagesCallbackTime = time;\n  channelState.messagesCallback = fn;\n  readNewMessages(channelState);\n}\nexport function canBeUsed() {\n  if (isNode) return false;\n  var idb = getIdb();\n  if (!idb) return false;\n  return true;\n}\nexport function averageResponseTime(options) {\n  return options.idb.fallbackInterval * 2;\n}\nexport default {\n  create: create,\n  close: close,\n  onMessage: onMessage,\n  postMessage: postMessage,\n  canBeUsed: canBeUsed,\n  type: type,\n  averageResponseTime: averageResponseTime,\n  microSeconds: microSeconds\n};","/**\n * A localStorage-only method which uses localstorage and its 'storage'-event\n * This does not work inside of webworkers because they have no access to locastorage\n * This is basically implemented to support IE9 or your grandmothers toaster.\n * @link https://caniuse.com/#feat=namevalue-storage\n * @link https://caniuse.com/#feat=indexeddb\n */\nimport { ObliviousSet } from 'oblivious-set';\nimport { fillOptionsWithDefaults } from '../options';\nimport { sleep, randomToken, microSeconds as micro, isNode } from '../util';\nexport var microSeconds = micro;\nvar KEY_PREFIX = 'pubkey.broadcastChannel-';\nexport var type = 'localstorage';\n/**\n * copied from crosstab\n * @link https://github.com/tejacques/crosstab/blob/master/src/crosstab.js#L32\n */\n\nexport function getLocalStorage() {\n  var localStorage;\n  if (typeof window === 'undefined') return null;\n\n  try {\n    localStorage = window.localStorage;\n    localStorage = window['ie8-eventlistener/storage'] || window.localStorage;\n  } catch (e) {// New versions of Firefox throw a Security exception\n    // if cookies are disabled. See\n    // https://bugzilla.mozilla.org/show_bug.cgi?id=1028153\n  }\n\n  return localStorage;\n}\nexport function storageKey(channelName) {\n  return KEY_PREFIX + channelName;\n}\n/**\n* writes the new message to the storage\n* and fires the storage-event so other readers can find it\n*/\n\nexport function postMessage(channelState, messageJson) {\n  return new Promise(function (res) {\n    sleep().then(function () {\n      var key = storageKey(channelState.channelName);\n      var writeObj = {\n        token: randomToken(),\n        time: new Date().getTime(),\n        data: messageJson,\n        uuid: channelState.uuid\n      };\n      var value = JSON.stringify(writeObj);\n      getLocalStorage().setItem(key, value);\n      /**\n       * StorageEvent does not fire the 'storage' event\n       * in the window that changes the state of the local storage.\n       * So we fire it manually\n       */\n\n      var ev = document.createEvent('Event');\n      ev.initEvent('storage', true, true);\n      ev.key = key;\n      ev.newValue = value;\n      window.dispatchEvent(ev);\n      res();\n    });\n  });\n}\nexport function addStorageEventListener(channelName, fn) {\n  var key = storageKey(channelName);\n\n  var listener = function listener(ev) {\n    if (ev.key === key) {\n      fn(JSON.parse(ev.newValue));\n    }\n  };\n\n  window.addEventListener('storage', listener);\n  return listener;\n}\nexport function removeStorageEventListener(listener) {\n  window.removeEventListener('storage', listener);\n}\nexport function create(channelName, options) {\n  options = fillOptionsWithDefaults(options);\n\n  if (!canBeUsed()) {\n    throw new Error('BroadcastChannel: localstorage cannot be used');\n  }\n\n  var uuid = randomToken();\n  /**\n   * eMIs\n   * contains all messages that have been emitted before\n   * @type {ObliviousSet}\n   */\n\n  var eMIs = new ObliviousSet(options.localstorage.removeTimeout);\n  var state = {\n    channelName: channelName,\n    uuid: uuid,\n    eMIs: eMIs // emittedMessagesIds\n\n  };\n  state.listener = addStorageEventListener(channelName, function (msgObj) {\n    if (!state.messagesCallback) return; // no listener\n\n    if (msgObj.uuid === uuid) return; // own message\n\n    if (!msgObj.token || eMIs.has(msgObj.token)) return; // already emitted\n\n    if (msgObj.data.time && msgObj.data.time < state.messagesCallbackTime) return; // too old\n\n    eMIs.add(msgObj.token);\n    state.messagesCallback(msgObj.data);\n  });\n  return state;\n}\nexport function close(channelState) {\n  removeStorageEventListener(channelState.listener);\n}\nexport function onMessage(channelState, fn, time) {\n  channelState.messagesCallbackTime = time;\n  channelState.messagesCallback = fn;\n}\nexport function canBeUsed() {\n  if (isNode) return false;\n  var ls = getLocalStorage();\n  if (!ls) return false;\n\n  try {\n    var key = '__broadcastchannel_check';\n    ls.setItem(key, 'works');\n    ls.removeItem(key);\n  } catch (e) {\n    // Safari 10 in private mode will not allow write access to local\n    // storage and fail with a QuotaExceededError. See\n    // https://developer.mozilla.org/en-US/docs/Web/API/Web_Storage_API#Private_Browsing_Incognito_modes\n    return false;\n  }\n\n  return true;\n}\nexport function averageResponseTime() {\n  var defaultTime = 120;\n  var userAgent = navigator.userAgent.toLowerCase();\n\n  if (userAgent.includes('safari') && !userAgent.includes('chrome')) {\n    // safari is much slower so this time is higher\n    return defaultTime * 2;\n  }\n\n  return defaultTime;\n}\nexport default {\n  create: create,\n  close: close,\n  onMessage: onMessage,\n  postMessage: postMessage,\n  canBeUsed: canBeUsed,\n  type: type,\n  averageResponseTime: averageResponseTime,\n  microSeconds: microSeconds\n};","import { microSeconds as micro } from '../util';\nexport var microSeconds = micro;\nexport var type = 'simulate';\nvar SIMULATE_CHANNELS = new Set();\nexport function create(channelName) {\n  var state = {\n    name: channelName,\n    messagesCallback: null\n  };\n  SIMULATE_CHANNELS.add(state);\n  return state;\n}\nexport function close(channelState) {\n  SIMULATE_CHANNELS[\"delete\"](channelState);\n}\nexport function postMessage(channelState, messageJson) {\n  return new Promise(function (res) {\n    return setTimeout(function () {\n      var channelArray = Array.from(SIMULATE_CHANNELS);\n      channelArray.filter(function (channel) {\n        return channel.name === channelState.name;\n      }).filter(function (channel) {\n        return channel !== channelState;\n      }).filter(function (channel) {\n        return !!channel.messagesCallback;\n      }).forEach(function (channel) {\n        return channel.messagesCallback(messageJson);\n      });\n      res();\n    }, 5);\n  });\n}\nexport function onMessage(channelState, fn) {\n  channelState.messagesCallback = fn;\n}\nexport function canBeUsed() {\n  return true;\n}\nexport function averageResponseTime() {\n  return 5;\n}\nexport default {\n  create: create,\n  close: close,\n  onMessage: onMessage,\n  postMessage: postMessage,\n  canBeUsed: canBeUsed,\n  type: type,\n  averageResponseTime: averageResponseTime,\n  microSeconds: microSeconds\n};","import NativeMethod from './methods/native.js';\nimport IndexeDbMethod from './methods/indexed-db.js';\nimport LocalstorageMethod from './methods/localstorage.js';\nimport SimulateMethod from './methods/simulate.js';\nimport { isNode } from './util'; // order is important\n\nvar METHODS = [NativeMethod, // fastest\nIndexeDbMethod, LocalstorageMethod];\n/**\n * The NodeMethod is loaded lazy\n * so it will not get bundled in browser-builds\n */\n\nif (isNode) {\n  /**\n   * we use the non-transpiled code for nodejs\n   * because it runs faster\n   */\n  var NodeMethod = require('../../src/methods/' + // use this hack so that browserify and others\n  // do not import the node-method by default\n  // when bundling.\n  'node.js');\n  /**\n   * this will be false for webpackbuilds\n   * which will shim the node-method with an empty object {}\n   */\n\n\n  if (typeof NodeMethod.canBeUsed === 'function') {\n    METHODS.push(NodeMethod);\n  }\n}\n\nexport function chooseMethod(options) {\n  var chooseMethods = [].concat(options.methods, METHODS).filter(Boolean); // directly chosen\n\n  if (options.type) {\n    if (options.type === 'simulate') {\n      // only use simulate-method if directly chosen\n      return SimulateMethod;\n    }\n\n    var ret = chooseMethods.find(function (m) {\n      return m.type === options.type;\n    });\n    if (!ret) throw new Error('method-type ' + options.type + ' not found');else return ret;\n  }\n  /**\n   * if no webworker support is needed,\n   * remove idb from the list so that localstorage is been chosen\n   */\n\n\n  if (!options.webWorkerSupport && !isNode) {\n    chooseMethods = chooseMethods.filter(function (m) {\n      return m.type !== 'idb';\n    });\n  }\n\n  var useMethod = chooseMethods.find(function (method) {\n    return method.canBeUsed();\n  });\n  if (!useMethod) throw new Error('No useable methode found:' + JSON.stringify(METHODS.map(function (m) {\n    return m.type;\n  })));else return useMethod;\n}","import { isPromise } from './util.js';\nimport { chooseMethod } from './method-chooser.js';\nimport { fillOptionsWithDefaults } from './options.js';\nexport var BroadcastChannel = function BroadcastChannel(name, options) {\n  this.name = name;\n\n  if (ENFORCED_OPTIONS) {\n    options = ENFORCED_OPTIONS;\n  }\n\n  this.options = fillOptionsWithDefaults(options);\n  this.method = chooseMethod(this.options); // isListening\n\n  this._iL = false;\n  /**\n   * _onMessageListener\n   * setting onmessage twice,\n   * will overwrite the first listener\n   */\n\n  this._onML = null;\n  /**\n   * _addEventListeners\n   */\n\n  this._addEL = {\n    message: [],\n    internal: []\n  };\n  /**\n   * Unsend message promises\n   * where the sending is still in progress\n   * @type {Set<Promise>}\n   */\n\n  this._uMP = new Set();\n  /**\n   * _beforeClose\n   * array of promises that will be awaited\n   * before the channel is closed\n   */\n\n  this._befC = [];\n  /**\n   * _preparePromise\n   */\n\n  this._prepP = null;\n\n  _prepareChannel(this);\n}; // STATICS\n\n/**\n * used to identify if someone overwrites\n * window.BroadcastChannel with this\n * See methods/native.js\n */\n\nBroadcastChannel._pubkey = true;\n/**\n * clears the tmp-folder if is node\n * @return {Promise<boolean>} true if has run, false if not node\n */\n\nexport function clearNodeFolder(options) {\n  options = fillOptionsWithDefaults(options);\n  var method = chooseMethod(options);\n\n  if (method.type === 'node') {\n    return method.clearNodeFolder().then(function () {\n      return true;\n    });\n  } else {\n    return Promise.resolve(false);\n  }\n}\n/**\n * if set, this method is enforced,\n * no mather what the options are\n */\n\nvar ENFORCED_OPTIONS;\nexport function enforceOptions(options) {\n  ENFORCED_OPTIONS = options;\n} // PROTOTYPE\n\nBroadcastChannel.prototype = {\n  postMessage: function postMessage(msg) {\n    if (this.closed) {\n      throw new Error('BroadcastChannel.postMessage(): ' + 'Cannot post message after channel has closed');\n    }\n\n    return _post(this, 'message', msg);\n  },\n  postInternal: function postInternal(msg) {\n    return _post(this, 'internal', msg);\n  },\n\n  set onmessage(fn) {\n    var time = this.method.microSeconds();\n    var listenObj = {\n      time: time,\n      fn: fn\n    };\n\n    _removeListenerObject(this, 'message', this._onML);\n\n    if (fn && typeof fn === 'function') {\n      this._onML = listenObj;\n\n      _addListenerObject(this, 'message', listenObj);\n    } else {\n      this._onML = null;\n    }\n  },\n\n  addEventListener: function addEventListener(type, fn) {\n    var time = this.method.microSeconds();\n    var listenObj = {\n      time: time,\n      fn: fn\n    };\n\n    _addListenerObject(this, type, listenObj);\n  },\n  removeEventListener: function removeEventListener(type, fn) {\n    var obj = this._addEL[type].find(function (obj) {\n      return obj.fn === fn;\n    });\n\n    _removeListenerObject(this, type, obj);\n  },\n  close: function close() {\n    var _this = this;\n\n    if (this.closed) {\n      return;\n    }\n\n    this.closed = true;\n    var awaitPrepare = this._prepP ? this._prepP : Promise.resolve();\n    this._onML = null;\n    this._addEL.message = [];\n    return awaitPrepare // wait until all current sending are processed\n    .then(function () {\n      return Promise.all(Array.from(_this._uMP));\n    }) // run before-close hooks\n    .then(function () {\n      return Promise.all(_this._befC.map(function (fn) {\n        return fn();\n      }));\n    }) // close the channel\n    .then(function () {\n      return _this.method.close(_this._state);\n    });\n  },\n\n  get type() {\n    return this.method.type;\n  },\n\n  get isClosed() {\n    return this.closed;\n  }\n\n};\n/**\n * Post a message over the channel\n * @returns {Promise} that resolved when the message sending is done\n */\n\nfunction _post(broadcastChannel, type, msg) {\n  var time = broadcastChannel.method.microSeconds();\n  var msgObj = {\n    time: time,\n    type: type,\n    data: msg\n  };\n  var awaitPrepare = broadcastChannel._prepP ? broadcastChannel._prepP : Promise.resolve();\n  return awaitPrepare.then(function () {\n    var sendPromise = broadcastChannel.method.postMessage(broadcastChannel._state, msgObj); // add/remove to unsend messages list\n\n    broadcastChannel._uMP.add(sendPromise);\n\n    sendPromise[\"catch\"]().then(function () {\n      return broadcastChannel._uMP[\"delete\"](sendPromise);\n    });\n    return sendPromise;\n  });\n}\n\nfunction _prepareChannel(channel) {\n  var maybePromise = channel.method.create(channel.name, channel.options);\n\n  if (isPromise(maybePromise)) {\n    channel._prepP = maybePromise;\n    maybePromise.then(function (s) {\n      // used in tests to simulate slow runtime\n\n      /*if (channel.options.prepareDelay) {\n           await new Promise(res => setTimeout(res, this.options.prepareDelay));\n      }*/\n      channel._state = s;\n    });\n  } else {\n    channel._state = maybePromise;\n  }\n}\n\nfunction _hasMessageListeners(channel) {\n  if (channel._addEL.message.length > 0) return true;\n  if (channel._addEL.internal.length > 0) return true;\n  return false;\n}\n\nfunction _addListenerObject(channel, type, obj) {\n  channel._addEL[type].push(obj);\n\n  _startListening(channel);\n}\n\nfunction _removeListenerObject(channel, type, obj) {\n  channel._addEL[type] = channel._addEL[type].filter(function (o) {\n    return o !== obj;\n  });\n\n  _stopListening(channel);\n}\n\nfunction _startListening(channel) {\n  if (!channel._iL && _hasMessageListeners(channel)) {\n    // someone is listening, start subscribing\n    var listenerFn = function listenerFn(msgObj) {\n      channel._addEL[msgObj.type].forEach(function (obj) {\n        if (msgObj.time >= obj.time) {\n          obj.fn(msgObj.data);\n        }\n      });\n    };\n\n    var time = channel.method.microSeconds();\n\n    if (channel._prepP) {\n      channel._prepP.then(function () {\n        channel._iL = true;\n        channel.method.onMessage(channel._state, listenerFn, time);\n      });\n    } else {\n      channel._iL = true;\n      channel.method.onMessage(channel._state, listenerFn, time);\n    }\n  }\n}\n\nfunction _stopListening(channel) {\n  if (channel._iL && !_hasMessageListeners(channel)) {\n    // noone is listening, stop subscribing\n    channel._iL = false;\n    var time = channel.method.microSeconds();\n    channel.method.onMessage(channel._state, null, time);\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","/*\r\n *      bignumber.js v9.3.1\r\n *      A JavaScript library for arbitrary-precision arithmetic.\r\n *      https://github.com/MikeMcl/bignumber.js\r\n *      Copyright (c) 2025 Michael Mclaughlin <M8ch88l@gmail.com>\r\n *      MIT Licensed.\r\n *\r\n *      BigNumber.prototype methods     |  BigNumber methods\r\n *                                      |\r\n *      absoluteValue            abs    |  clone\r\n *      comparedTo                      |  config               set\r\n *      decimalPlaces            dp     |      DECIMAL_PLACES\r\n *      dividedBy                div    |      ROUNDING_MODE\r\n *      dividedToIntegerBy       idiv   |      EXPONENTIAL_AT\r\n *      exponentiatedBy          pow    |      RANGE\r\n *      integerValue                    |      CRYPTO\r\n *      isEqualTo                eq     |      MODULO_MODE\r\n *      isFinite                        |      POW_PRECISION\r\n *      isGreaterThan            gt     |      FORMAT\r\n *      isGreaterThanOrEqualTo   gte    |      ALPHABET\r\n *      isInteger                       |  isBigNumber\r\n *      isLessThan               lt     |  maximum              max\r\n *      isLessThanOrEqualTo      lte    |  minimum              min\r\n *      isNaN                           |  random\r\n *      isNegative                      |  sum\r\n *      isPositive                      |\r\n *      isZero                          |\r\n *      minus                           |\r\n *      modulo                   mod    |\r\n *      multipliedBy             times  |\r\n *      negated                         |\r\n *      plus                            |\r\n *      precision                sd     |\r\n *      shiftedBy                       |\r\n *      squareRoot               sqrt   |\r\n *      toExponential                   |\r\n *      toFixed                         |\r\n *      toFormat                        |\r\n *      toFraction                      |\r\n *      toJSON                          |\r\n *      toNumber                        |\r\n *      toPrecision                     |\r\n *      toString                        |\r\n *      valueOf                         |\r\n *\r\n */\r\n\r\n\r\nvar\r\n  isNumeric = /^-?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?$/i,\r\n  mathceil = Math.ceil,\r\n  mathfloor = Math.floor,\r\n\r\n  bignumberError = '[BigNumber Error] ',\r\n  tooManyDigits = bignumberError + 'Number primitive has more than 15 significant digits: ',\r\n\r\n  BASE = 1e14,\r\n  LOG_BASE = 14,\r\n  MAX_SAFE_INTEGER = 0x1fffffffffffff,         // 2^53 - 1\r\n  // MAX_INT32 = 0x7fffffff,                   // 2^31 - 1\r\n  POWS_TEN = [1, 10, 100, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13],\r\n  SQRT_BASE = 1e7,\r\n\r\n  // EDITABLE\r\n  // The limit on the value of DECIMAL_PLACES, TO_EXP_NEG, TO_EXP_POS, MIN_EXP, MAX_EXP, and\r\n  // the arguments to toExponential, toFixed, toFormat, and toPrecision.\r\n  MAX = 1E9;                                   // 0 to MAX_INT32\r\n\r\n\r\n/*\r\n * Create and return a BigNumber constructor.\r\n */\r\nfunction clone(configObject) {\r\n  var div, convertBase, parseNumeric,\r\n    P = BigNumber.prototype = { constructor: BigNumber, toString: null, valueOf: null },\r\n    ONE = new BigNumber(1),\r\n\r\n\r\n    //----------------------------- EDITABLE CONFIG DEFAULTS -------------------------------\r\n\r\n\r\n    // The default values below must be integers within the inclusive ranges stated.\r\n    // The values can also be changed at run-time using BigNumber.set.\r\n\r\n    // The maximum number of decimal places for operations involving division.\r\n    DECIMAL_PLACES = 20,                     // 0 to MAX\r\n\r\n    // The rounding mode used when rounding to the above decimal places, and when using\r\n    // toExponential, toFixed, toFormat and toPrecision, and round (default value).\r\n    // UP         0 Away from zero.\r\n    // DOWN       1 Towards zero.\r\n    // CEIL       2 Towards +Infinity.\r\n    // FLOOR      3 Towards -Infinity.\r\n    // HALF_UP    4 Towards nearest neighbour. If equidistant, up.\r\n    // HALF_DOWN  5 Towards nearest neighbour. If equidistant, down.\r\n    // HALF_EVEN  6 Towards nearest neighbour. If equidistant, towards even neighbour.\r\n    // HALF_CEIL  7 Towards nearest neighbour. If equidistant, towards +Infinity.\r\n    // HALF_FLOOR 8 Towards nearest neighbour. If equidistant, towards -Infinity.\r\n    ROUNDING_MODE = 4,                       // 0 to 8\r\n\r\n    // EXPONENTIAL_AT : [TO_EXP_NEG , TO_EXP_POS]\r\n\r\n    // The exponent value at and beneath which toString returns exponential notation.\r\n    // Number type: -7\r\n    TO_EXP_NEG = -7,                         // 0 to -MAX\r\n\r\n    // The exponent value at and above which toString returns exponential notation.\r\n    // Number type: 21\r\n    TO_EXP_POS = 21,                         // 0 to MAX\r\n\r\n    // RANGE : [MIN_EXP, MAX_EXP]\r\n\r\n    // The minimum exponent value, beneath which underflow to zero occurs.\r\n    // Number type: -324  (5e-324)\r\n    MIN_EXP = -1e7,                          // -1 to -MAX\r\n\r\n    // The maximum exponent value, above which overflow to Infinity occurs.\r\n    // Number type:  308  (1.7976931348623157e+308)\r\n    // For MAX_EXP > 1e7, e.g. new BigNumber('1e100000000').plus(1) may be slow.\r\n    MAX_EXP = 1e7,                           // 1 to MAX\r\n\r\n    // Whether to use cryptographically-secure random number generation, if available.\r\n    CRYPTO = false,                          // true or false\r\n\r\n    // The modulo mode used when calculating the modulus: a mod n.\r\n    // The quotient (q = a / n) is calculated according to the corresponding rounding mode.\r\n    // The remainder (r) is calculated as: r = a - n * q.\r\n    //\r\n    // UP        0 The remainder is positive if the dividend is negative, else is negative.\r\n    // DOWN      1 The remainder has the same sign as the dividend.\r\n    //             This modulo mode is commonly known as 'truncated division' and is\r\n    //             equivalent to (a % n) in JavaScript.\r\n    // FLOOR     3 The remainder has the same sign as the divisor (Python %).\r\n    // HALF_EVEN 6 This modulo mode implements the IEEE 754 remainder function.\r\n    // EUCLID    9 Euclidian division. q = sign(n) * floor(a / abs(n)).\r\n    //             The remainder is always positive.\r\n    //\r\n    // The truncated division, floored division, Euclidian division and IEEE 754 remainder\r\n    // modes are commonly used for the modulus operation.\r\n    // Although the other rounding modes can also be used, they may not give useful results.\r\n    MODULO_MODE = 1,                         // 0 to 9\r\n\r\n    // The maximum number of significant digits of the result of the exponentiatedBy operation.\r\n    // If POW_PRECISION is 0, there will be unlimited significant digits.\r\n    POW_PRECISION = 0,                       // 0 to MAX\r\n\r\n    // The format specification used by the BigNumber.prototype.toFormat method.\r\n    FORMAT = {\r\n      prefix: '',\r\n      groupSize: 3,\r\n      secondaryGroupSize: 0,\r\n      groupSeparator: ',',\r\n      decimalSeparator: '.',\r\n      fractionGroupSize: 0,\r\n      fractionGroupSeparator: '\\xA0',        // non-breaking space\r\n      suffix: ''\r\n    },\r\n\r\n    // The alphabet used for base conversion. It must be at least 2 characters long, with no '+',\r\n    // '-', '.', whitespace, or repeated character.\r\n    // '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_'\r\n    ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz',\r\n    alphabetHasNormalDecimalDigits = true;\r\n\r\n\r\n  //------------------------------------------------------------------------------------------\r\n\r\n\r\n  // CONSTRUCTOR\r\n\r\n\r\n  /*\r\n   * The BigNumber constructor and exported function.\r\n   * Create and return a new instance of a BigNumber object.\r\n   *\r\n   * v {number|string|BigNumber} A numeric value.\r\n   * [b] {number} The base of v. Integer, 2 to ALPHABET.length inclusive.\r\n   */\r\n  function BigNumber(v, b) {\r\n    var alphabet, c, caseChanged, e, i, isNum, len, str,\r\n      x = this;\r\n\r\n    // Enable constructor call without `new`.\r\n    if (!(x instanceof BigNumber)) return new BigNumber(v, b);\r\n\r\n    if (b == null) {\r\n\r\n      if (v && v._isBigNumber === true) {\r\n        x.s = v.s;\r\n\r\n        if (!v.c || v.e > MAX_EXP) {\r\n          x.c = x.e = null;\r\n        } else if (v.e < MIN_EXP) {\r\n          x.c = [x.e = 0];\r\n        } else {\r\n          x.e = v.e;\r\n          x.c = v.c.slice();\r\n        }\r\n\r\n        return;\r\n      }\r\n\r\n      if ((isNum = typeof v == 'number') && v * 0 == 0) {\r\n\r\n        // Use `1 / n` to handle minus zero also.\r\n        x.s = 1 / v < 0 ? (v = -v, -1) : 1;\r\n\r\n        // Fast path for integers, where n < 2147483648 (2**31).\r\n        if (v === ~~v) {\r\n          for (e = 0, i = v; i >= 10; i /= 10, e++);\r\n\r\n          if (e > MAX_EXP) {\r\n            x.c = x.e = null;\r\n          } else {\r\n            x.e = e;\r\n            x.c = [v];\r\n          }\r\n\r\n          return;\r\n        }\r\n\r\n        str = String(v);\r\n      } else {\r\n\r\n        if (!isNumeric.test(str = String(v))) return parseNumeric(x, str, isNum);\r\n\r\n        x.s = str.charCodeAt(0) == 45 ? (str = str.slice(1), -1) : 1;\r\n      }\r\n\r\n      // Decimal point?\r\n      if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');\r\n\r\n      // Exponential form?\r\n      if ((i = str.search(/e/i)) > 0) {\r\n\r\n        // Determine exponent.\r\n        if (e < 0) e = i;\r\n        e += +str.slice(i + 1);\r\n        str = str.substring(0, i);\r\n      } else if (e < 0) {\r\n\r\n        // Integer.\r\n        e = str.length;\r\n      }\r\n\r\n    } else {\r\n\r\n      // '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}'\r\n      intCheck(b, 2, ALPHABET.length, 'Base');\r\n\r\n      // Allow exponential notation to be used with base 10 argument, while\r\n      // also rounding to DECIMAL_PLACES as with other bases.\r\n      if (b == 10 && alphabetHasNormalDecimalDigits) {\r\n        x = new BigNumber(v);\r\n        return round(x, DECIMAL_PLACES + x.e + 1, ROUNDING_MODE);\r\n      }\r\n\r\n      str = String(v);\r\n\r\n      if (isNum = typeof v == 'number') {\r\n\r\n        // Avoid potential interpretation of Infinity and NaN as base 44+ values.\r\n        if (v * 0 != 0) return parseNumeric(x, str, isNum, b);\r\n\r\n        x.s = 1 / v < 0 ? (str = str.slice(1), -1) : 1;\r\n\r\n        // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'\r\n        if (BigNumber.DEBUG && str.replace(/^0\\.0*|\\./, '').length > 15) {\r\n          throw Error\r\n           (tooManyDigits + v);\r\n        }\r\n      } else {\r\n        x.s = str.charCodeAt(0) === 45 ? (str = str.slice(1), -1) : 1;\r\n      }\r\n\r\n      alphabet = ALPHABET.slice(0, b);\r\n      e = i = 0;\r\n\r\n      // Check that str is a valid base b number.\r\n      // Don't use RegExp, so alphabet can contain special characters.\r\n      for (len = str.length; i < len; i++) {\r\n        if (alphabet.indexOf(c = str.charAt(i)) < 0) {\r\n          if (c == '.') {\r\n\r\n            // If '.' is not the first character and it has not be found before.\r\n            if (i > e) {\r\n              e = len;\r\n              continue;\r\n            }\r\n          } else if (!caseChanged) {\r\n\r\n            // Allow e.g. hexadecimal 'FF' as well as 'ff'.\r\n            if (str == str.toUpperCase() && (str = str.toLowerCase()) ||\r\n                str == str.toLowerCase() && (str = str.toUpperCase())) {\r\n              caseChanged = true;\r\n              i = -1;\r\n              e = 0;\r\n              continue;\r\n            }\r\n          }\r\n\r\n          return parseNumeric(x, String(v), isNum, b);\r\n        }\r\n      }\r\n\r\n      // Prevent later check for length on converted number.\r\n      isNum = false;\r\n      str = convertBase(str, b, 10, x.s);\r\n\r\n      // Decimal point?\r\n      if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');\r\n      else e = str.length;\r\n    }\r\n\r\n    // Determine leading zeros.\r\n    for (i = 0; str.charCodeAt(i) === 48; i++);\r\n\r\n    // Determine trailing zeros.\r\n    for (len = str.length; str.charCodeAt(--len) === 48;);\r\n\r\n    if (str = str.slice(i, ++len)) {\r\n      len -= i;\r\n\r\n      // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'\r\n      if (isNum && BigNumber.DEBUG &&\r\n        len > 15 && (v > MAX_SAFE_INTEGER || v !== mathfloor(v))) {\r\n          throw Error\r\n           (tooManyDigits + (x.s * v));\r\n      }\r\n\r\n       // Overflow?\r\n      if ((e = e - i - 1) > MAX_EXP) {\r\n\r\n        // Infinity.\r\n        x.c = x.e = null;\r\n\r\n      // Underflow?\r\n      } else if (e < MIN_EXP) {\r\n\r\n        // Zero.\r\n        x.c = [x.e = 0];\r\n      } else {\r\n        x.e = e;\r\n        x.c = [];\r\n\r\n        // Transform base\r\n\r\n        // e is the base 10 exponent.\r\n        // i is where to slice str to get the first element of the coefficient array.\r\n        i = (e + 1) % LOG_BASE;\r\n        if (e < 0) i += LOG_BASE;  // i < 1\r\n\r\n        if (i < len) {\r\n          if (i) x.c.push(+str.slice(0, i));\r\n\r\n          for (len -= LOG_BASE; i < len;) {\r\n            x.c.push(+str.slice(i, i += LOG_BASE));\r\n          }\r\n\r\n          i = LOG_BASE - (str = str.slice(i)).length;\r\n        } else {\r\n          i -= len;\r\n        }\r\n\r\n        for (; i--; str += '0');\r\n        x.c.push(+str);\r\n      }\r\n    } else {\r\n\r\n      // Zero.\r\n      x.c = [x.e = 0];\r\n    }\r\n  }\r\n\r\n\r\n  // CONSTRUCTOR PROPERTIES\r\n\r\n\r\n  BigNumber.clone = clone;\r\n\r\n  BigNumber.ROUND_UP = 0;\r\n  BigNumber.ROUND_DOWN = 1;\r\n  BigNumber.ROUND_CEIL = 2;\r\n  BigNumber.ROUND_FLOOR = 3;\r\n  BigNumber.ROUND_HALF_UP = 4;\r\n  BigNumber.ROUND_HALF_DOWN = 5;\r\n  BigNumber.ROUND_HALF_EVEN = 6;\r\n  BigNumber.ROUND_HALF_CEIL = 7;\r\n  BigNumber.ROUND_HALF_FLOOR = 8;\r\n  BigNumber.EUCLID = 9;\r\n\r\n\r\n  /*\r\n   * Configure infrequently-changing library-wide settings.\r\n   *\r\n   * Accept an object with the following optional properties (if the value of a property is\r\n   * a number, it must be an integer within the inclusive range stated):\r\n   *\r\n   *   DECIMAL_PLACES   {number}           0 to MAX\r\n   *   ROUNDING_MODE    {number}           0 to 8\r\n   *   EXPONENTIAL_AT   {number|number[]}  -MAX to MAX  or  [-MAX to 0, 0 to MAX]\r\n   *   RANGE            {number|number[]}  -MAX to MAX (not zero)  or  [-MAX to -1, 1 to MAX]\r\n   *   CRYPTO           {boolean}          true or false\r\n   *   MODULO_MODE      {number}           0 to 9\r\n   *   POW_PRECISION       {number}           0 to MAX\r\n   *   ALPHABET         {string}           A string of two or more unique characters which does\r\n   *                                       not contain '.'.\r\n   *   FORMAT           {object}           An object with some of the following properties:\r\n   *     prefix                 {string}\r\n   *     groupSize              {number}\r\n   *     secondaryGroupSize     {number}\r\n   *     groupSeparator         {string}\r\n   *     decimalSeparator       {string}\r\n   *     fractionGroupSize      {number}\r\n   *     fractionGroupSeparator {string}\r\n   *     suffix                 {string}\r\n   *\r\n   * (The values assigned to the above FORMAT object properties are not checked for validity.)\r\n   *\r\n   * E.g.\r\n   * BigNumber.config({ DECIMAL_PLACES : 20, ROUNDING_MODE : 4 })\r\n   *\r\n   * Ignore properties/parameters set to null or undefined, except for ALPHABET.\r\n   *\r\n   * Return an object with the properties current values.\r\n   */\r\n  BigNumber.config = BigNumber.set = function (obj) {\r\n    var p, v;\r\n\r\n    if (obj != null) {\r\n\r\n      if (typeof obj == 'object') {\r\n\r\n        // DECIMAL_PLACES {number} Integer, 0 to MAX inclusive.\r\n        // '[BigNumber Error] DECIMAL_PLACES {not a primitive number|not an integer|out of range}: {v}'\r\n        if (obj.hasOwnProperty(p = 'DECIMAL_PLACES')) {\r\n          v = obj[p];\r\n          intCheck(v, 0, MAX, p);\r\n          DECIMAL_PLACES = v;\r\n        }\r\n\r\n        // ROUNDING_MODE {number} Integer, 0 to 8 inclusive.\r\n        // '[BigNumber Error] ROUNDING_MODE {not a primitive number|not an integer|out of range}: {v}'\r\n        if (obj.hasOwnProperty(p = 'ROUNDING_MODE')) {\r\n          v = obj[p];\r\n          intCheck(v, 0, 8, p);\r\n          ROUNDING_MODE = v;\r\n        }\r\n\r\n        // EXPONENTIAL_AT {number|number[]}\r\n        // Integer, -MAX to MAX inclusive or\r\n        // [integer -MAX to 0 inclusive, 0 to MAX inclusive].\r\n        // '[BigNumber Error] EXPONENTIAL_AT {not a primitive number|not an integer|out of range}: {v}'\r\n        if (obj.hasOwnProperty(p = 'EXPONENTIAL_AT')) {\r\n          v = obj[p];\r\n          if (v && v.pop) {\r\n            intCheck(v[0], -MAX, 0, p);\r\n            intCheck(v[1], 0, MAX, p);\r\n            TO_EXP_NEG = v[0];\r\n            TO_EXP_POS = v[1];\r\n          } else {\r\n            intCheck(v, -MAX, MAX, p);\r\n            TO_EXP_NEG = -(TO_EXP_POS = v < 0 ? -v : v);\r\n          }\r\n        }\r\n\r\n        // RANGE {number|number[]} Non-zero integer, -MAX to MAX inclusive or\r\n        // [integer -MAX to -1 inclusive, integer 1 to MAX inclusive].\r\n        // '[BigNumber Error] RANGE {not a primitive number|not an integer|out of range|cannot be zero}: {v}'\r\n        if (obj.hasOwnProperty(p = 'RANGE')) {\r\n          v = obj[p];\r\n          if (v && v.pop) {\r\n            intCheck(v[0], -MAX, -1, p);\r\n            intCheck(v[1], 1, MAX, p);\r\n            MIN_EXP = v[0];\r\n            MAX_EXP = v[1];\r\n          } else {\r\n            intCheck(v, -MAX, MAX, p);\r\n            if (v) {\r\n              MIN_EXP = -(MAX_EXP = v < 0 ? -v : v);\r\n            } else {\r\n              throw Error\r\n               (bignumberError + p + ' cannot be zero: ' + v);\r\n            }\r\n          }\r\n        }\r\n\r\n        // CRYPTO {boolean} true or false.\r\n        // '[BigNumber Error] CRYPTO not true or false: {v}'\r\n        // '[BigNumber Error] crypto unavailable'\r\n        if (obj.hasOwnProperty(p = 'CRYPTO')) {\r\n          v = obj[p];\r\n          if (v === !!v) {\r\n            if (v) {\r\n              if (typeof crypto != 'undefined' && crypto &&\r\n               (crypto.getRandomValues || crypto.randomBytes)) {\r\n                CRYPTO = v;\r\n              } else {\r\n                CRYPTO = !v;\r\n                throw Error\r\n                 (bignumberError + 'crypto unavailable');\r\n              }\r\n            } else {\r\n              CRYPTO = v;\r\n            }\r\n          } else {\r\n            throw Error\r\n             (bignumberError + p + ' not true or false: ' + v);\r\n          }\r\n        }\r\n\r\n        // MODULO_MODE {number} Integer, 0 to 9 inclusive.\r\n        // '[BigNumber Error] MODULO_MODE {not a primitive number|not an integer|out of range}: {v}'\r\n        if (obj.hasOwnProperty(p = 'MODULO_MODE')) {\r\n          v = obj[p];\r\n          intCheck(v, 0, 9, p);\r\n          MODULO_MODE = v;\r\n        }\r\n\r\n        // POW_PRECISION {number} Integer, 0 to MAX inclusive.\r\n        // '[BigNumber Error] POW_PRECISION {not a primitive number|not an integer|out of range}: {v}'\r\n        if (obj.hasOwnProperty(p = 'POW_PRECISION')) {\r\n          v = obj[p];\r\n          intCheck(v, 0, MAX, p);\r\n          POW_PRECISION = v;\r\n        }\r\n\r\n        // FORMAT {object}\r\n        // '[BigNumber Error] FORMAT not an object: {v}'\r\n        if (obj.hasOwnProperty(p = 'FORMAT')) {\r\n          v = obj[p];\r\n          if (typeof v == 'object') FORMAT = v;\r\n          else throw Error\r\n           (bignumberError + p + ' not an object: ' + v);\r\n        }\r\n\r\n        // ALPHABET {string}\r\n        // '[BigNumber Error] ALPHABET invalid: {v}'\r\n        if (obj.hasOwnProperty(p = 'ALPHABET')) {\r\n          v = obj[p];\r\n\r\n          // Disallow if less than two characters,\r\n          // or if it contains '+', '-', '.', whitespace, or a repeated character.\r\n          if (typeof v == 'string' && !/^.?$|[+\\-.\\s]|(.).*\\1/.test(v)) {\r\n            alphabetHasNormalDecimalDigits = v.slice(0, 10) == '0123456789';\r\n            ALPHABET = v;\r\n          } else {\r\n            throw Error\r\n             (bignumberError + p + ' invalid: ' + v);\r\n          }\r\n        }\r\n\r\n      } else {\r\n\r\n        // '[BigNumber Error] Object expected: {v}'\r\n        throw Error\r\n         (bignumberError + 'Object expected: ' + obj);\r\n      }\r\n    }\r\n\r\n    return {\r\n      DECIMAL_PLACES: DECIMAL_PLACES,\r\n      ROUNDING_MODE: ROUNDING_MODE,\r\n      EXPONENTIAL_AT: [TO_EXP_NEG, TO_EXP_POS],\r\n      RANGE: [MIN_EXP, MAX_EXP],\r\n      CRYPTO: CRYPTO,\r\n      MODULO_MODE: MODULO_MODE,\r\n      POW_PRECISION: POW_PRECISION,\r\n      FORMAT: FORMAT,\r\n      ALPHABET: ALPHABET\r\n    };\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if v is a BigNumber instance, otherwise return false.\r\n   *\r\n   * If BigNumber.DEBUG is true, throw if a BigNumber instance is not well-formed.\r\n   *\r\n   * v {any}\r\n   *\r\n   * '[BigNumber Error] Invalid BigNumber: {v}'\r\n   */\r\n  BigNumber.isBigNumber = function (v) {\r\n    if (!v || v._isBigNumber !== true) return false;\r\n    if (!BigNumber.DEBUG) return true;\r\n\r\n    var i, n,\r\n      c = v.c,\r\n      e = v.e,\r\n      s = v.s;\r\n\r\n    out: if ({}.toString.call(c) == '[object Array]') {\r\n\r\n      if ((s === 1 || s === -1) && e >= -MAX && e <= MAX && e === mathfloor(e)) {\r\n\r\n        // If the first element is zero, the BigNumber value must be zero.\r\n        if (c[0] === 0) {\r\n          if (e === 0 && c.length === 1) return true;\r\n          break out;\r\n        }\r\n\r\n        // Calculate number of digits that c[0] should have, based on the exponent.\r\n        i = (e + 1) % LOG_BASE;\r\n        if (i < 1) i += LOG_BASE;\r\n\r\n        // Calculate number of digits of c[0].\r\n        //if (Math.ceil(Math.log(c[0] + 1) / Math.LN10) == i) {\r\n        if (String(c[0]).length == i) {\r\n\r\n          for (i = 0; i < c.length; i++) {\r\n            n = c[i];\r\n            if (n < 0 || n >= BASE || n !== mathfloor(n)) break out;\r\n          }\r\n\r\n          // Last element cannot be zero, unless it is the only element.\r\n          if (n !== 0) return true;\r\n        }\r\n      }\r\n\r\n    // Infinity/NaN\r\n    } else if (c === null && e === null && (s === null || s === 1 || s === -1)) {\r\n      return true;\r\n    }\r\n\r\n    throw Error\r\n      (bignumberError + 'Invalid BigNumber: ' + v);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new BigNumber whose value is the maximum of the arguments.\r\n   *\r\n   * arguments {number|string|BigNumber}\r\n   */\r\n  BigNumber.maximum = BigNumber.max = function () {\r\n    return maxOrMin(arguments, -1);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new BigNumber whose value is the minimum of the arguments.\r\n   *\r\n   * arguments {number|string|BigNumber}\r\n   */\r\n  BigNumber.minimum = BigNumber.min = function () {\r\n    return maxOrMin(arguments, 1);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new BigNumber with a random value equal to or greater than 0 and less than 1,\r\n   * and with dp, or DECIMAL_PLACES if dp is omitted, decimal places (or less if trailing\r\n   * zeros are produced).\r\n   *\r\n   * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n   *\r\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp}'\r\n   * '[BigNumber Error] crypto unavailable'\r\n   */\r\n  BigNumber.random = (function () {\r\n    var pow2_53 = 0x20000000000000;\r\n\r\n    // Return a 53 bit integer n, where 0 <= n < 9007199254740992.\r\n    // Check if Math.random() produces more than 32 bits of randomness.\r\n    // If it does, assume at least 53 bits are produced, otherwise assume at least 30 bits.\r\n    // 0x40000000 is 2^30, 0x800000 is 2^23, 0x1fffff is 2^21 - 1.\r\n    var random53bitInt = (Math.random() * pow2_53) & 0x1fffff\r\n     ? function () { return mathfloor(Math.random() * pow2_53); }\r\n     : function () { return ((Math.random() * 0x40000000 | 0) * 0x800000) +\r\n       (Math.random() * 0x800000 | 0); };\r\n\r\n    return function (dp) {\r\n      var a, b, e, k, v,\r\n        i = 0,\r\n        c = [],\r\n        rand = new BigNumber(ONE);\r\n\r\n      if (dp == null) dp = DECIMAL_PLACES;\r\n      else intCheck(dp, 0, MAX);\r\n\r\n      k = mathceil(dp / LOG_BASE);\r\n\r\n      if (CRYPTO) {\r\n\r\n        // Browsers supporting crypto.getRandomValues.\r\n        if (crypto.getRandomValues) {\r\n\r\n          a = crypto.getRandomValues(new Uint32Array(k *= 2));\r\n\r\n          for (; i < k;) {\r\n\r\n            // 53 bits:\r\n            // ((Math.pow(2, 32) - 1) * Math.pow(2, 21)).toString(2)\r\n            // 11111 11111111 11111111 11111111 11100000 00000000 00000000\r\n            // ((Math.pow(2, 32) - 1) >>> 11).toString(2)\r\n            //                                     11111 11111111 11111111\r\n            // 0x20000 is 2^21.\r\n            v = a[i] * 0x20000 + (a[i + 1] >>> 11);\r\n\r\n            // Rejection sampling:\r\n            // 0 <= v < 9007199254740992\r\n            // Probability that v >= 9e15, is\r\n            // 7199254740992 / 9007199254740992 ~= 0.0008, i.e. 1 in 1251\r\n            if (v >= 9e15) {\r\n              b = crypto.getRandomValues(new Uint32Array(2));\r\n              a[i] = b[0];\r\n              a[i + 1] = b[1];\r\n            } else {\r\n\r\n              // 0 <= v <= 8999999999999999\r\n              // 0 <= (v % 1e14) <= 99999999999999\r\n              c.push(v % 1e14);\r\n              i += 2;\r\n            }\r\n          }\r\n          i = k / 2;\r\n\r\n        // Node.js supporting crypto.randomBytes.\r\n        } else if (crypto.randomBytes) {\r\n\r\n          // buffer\r\n          a = crypto.randomBytes(k *= 7);\r\n\r\n          for (; i < k;) {\r\n\r\n            // 0x1000000000000 is 2^48, 0x10000000000 is 2^40\r\n            // 0x100000000 is 2^32, 0x1000000 is 2^24\r\n            // 11111 11111111 11111111 11111111 11111111 11111111 11111111\r\n            // 0 <= v < 9007199254740992\r\n            v = ((a[i] & 31) * 0x1000000000000) + (a[i + 1] * 0x10000000000) +\r\n               (a[i + 2] * 0x100000000) + (a[i + 3] * 0x1000000) +\r\n               (a[i + 4] << 16) + (a[i + 5] << 8) + a[i + 6];\r\n\r\n            if (v >= 9e15) {\r\n              crypto.randomBytes(7).copy(a, i);\r\n            } else {\r\n\r\n              // 0 <= (v % 1e14) <= 99999999999999\r\n              c.push(v % 1e14);\r\n              i += 7;\r\n            }\r\n          }\r\n          i = k / 7;\r\n        } else {\r\n          CRYPTO = false;\r\n          throw Error\r\n           (bignumberError + 'crypto unavailable');\r\n        }\r\n      }\r\n\r\n      // Use Math.random.\r\n      if (!CRYPTO) {\r\n\r\n        for (; i < k;) {\r\n          v = random53bitInt();\r\n          if (v < 9e15) c[i++] = v % 1e14;\r\n        }\r\n      }\r\n\r\n      k = c[--i];\r\n      dp %= LOG_BASE;\r\n\r\n      // Convert trailing digits to zeros according to dp.\r\n      if (k && dp) {\r\n        v = POWS_TEN[LOG_BASE - dp];\r\n        c[i] = mathfloor(k / v) * v;\r\n      }\r\n\r\n      // Remove trailing elements which are zero.\r\n      for (; c[i] === 0; c.pop(), i--);\r\n\r\n      // Zero?\r\n      if (i < 0) {\r\n        c = [e = 0];\r\n      } else {\r\n\r\n        // Remove leading elements which are zero and adjust exponent accordingly.\r\n        for (e = -1 ; c[0] === 0; c.splice(0, 1), e -= LOG_BASE);\r\n\r\n        // Count the digits of the first element of c to determine leading zeros, and...\r\n        for (i = 1, v = c[0]; v >= 10; v /= 10, i++);\r\n\r\n        // adjust the exponent accordingly.\r\n        if (i < LOG_BASE) e -= LOG_BASE - i;\r\n      }\r\n\r\n      rand.e = e;\r\n      rand.c = c;\r\n      return rand;\r\n    };\r\n  })();\r\n\r\n\r\n   /*\r\n   * Return a BigNumber whose value is the sum of the arguments.\r\n   *\r\n   * arguments {number|string|BigNumber}\r\n   */\r\n  BigNumber.sum = function () {\r\n    var i = 1,\r\n      args = arguments,\r\n      sum = new BigNumber(args[0]);\r\n    for (; i < args.length;) sum = sum.plus(args[i++]);\r\n    return sum;\r\n  };\r\n\r\n\r\n  // PRIVATE FUNCTIONS\r\n\r\n\r\n  // Called by BigNumber and BigNumber.prototype.toString.\r\n  convertBase = (function () {\r\n    var decimal = '0123456789';\r\n\r\n    /*\r\n     * Convert string of baseIn to an array of numbers of baseOut.\r\n     * Eg. toBaseOut('255', 10, 16) returns [15, 15].\r\n     * Eg. toBaseOut('ff', 16, 10) returns [2, 5, 5].\r\n     */\r\n    function toBaseOut(str, baseIn, baseOut, alphabet) {\r\n      var j,\r\n        arr = [0],\r\n        arrL,\r\n        i = 0,\r\n        len = str.length;\r\n\r\n      for (; i < len;) {\r\n        for (arrL = arr.length; arrL--; arr[arrL] *= baseIn);\r\n\r\n        arr[0] += alphabet.indexOf(str.charAt(i++));\r\n\r\n        for (j = 0; j < arr.length; j++) {\r\n\r\n          if (arr[j] > baseOut - 1) {\r\n            if (arr[j + 1] == null) arr[j + 1] = 0;\r\n            arr[j + 1] += arr[j] / baseOut | 0;\r\n            arr[j] %= baseOut;\r\n          }\r\n        }\r\n      }\r\n\r\n      return arr.reverse();\r\n    }\r\n\r\n    // Convert a numeric string of baseIn to a numeric string of baseOut.\r\n    // If the caller is toString, we are converting from base 10 to baseOut.\r\n    // If the caller is BigNumber, we are converting from baseIn to base 10.\r\n    return function (str, baseIn, baseOut, sign, callerIsToString) {\r\n      var alphabet, d, e, k, r, x, xc, y,\r\n        i = str.indexOf('.'),\r\n        dp = DECIMAL_PLACES,\r\n        rm = ROUNDING_MODE;\r\n\r\n      // Non-integer.\r\n      if (i >= 0) {\r\n        k = POW_PRECISION;\r\n\r\n        // Unlimited precision.\r\n        POW_PRECISION = 0;\r\n        str = str.replace('.', '');\r\n        y = new BigNumber(baseIn);\r\n        x = y.pow(str.length - i);\r\n        POW_PRECISION = k;\r\n\r\n        // Convert str as if an integer, then restore the fraction part by dividing the\r\n        // result by its base raised to a power.\r\n\r\n        y.c = toBaseOut(toFixedPoint(coeffToString(x.c), x.e, '0'),\r\n         10, baseOut, decimal);\r\n        y.e = y.c.length;\r\n      }\r\n\r\n      // Convert the number as integer.\r\n\r\n      xc = toBaseOut(str, baseIn, baseOut, callerIsToString\r\n       ? (alphabet = ALPHABET, decimal)\r\n       : (alphabet = decimal, ALPHABET));\r\n\r\n      // xc now represents str as an integer and converted to baseOut. e is the exponent.\r\n      e = k = xc.length;\r\n\r\n      // Remove trailing zeros.\r\n      for (; xc[--k] == 0; xc.pop());\r\n\r\n      // Zero?\r\n      if (!xc[0]) return alphabet.charAt(0);\r\n\r\n      // Does str represent an integer? If so, no need for the division.\r\n      if (i < 0) {\r\n        --e;\r\n      } else {\r\n        x.c = xc;\r\n        x.e = e;\r\n\r\n        // The sign is needed for correct rounding.\r\n        x.s = sign;\r\n        x = div(x, y, dp, rm, baseOut);\r\n        xc = x.c;\r\n        r = x.r;\r\n        e = x.e;\r\n      }\r\n\r\n      // xc now represents str converted to baseOut.\r\n\r\n      // The index of the rounding digit.\r\n      d = e + dp + 1;\r\n\r\n      // The rounding digit: the digit to the right of the digit that may be rounded up.\r\n      i = xc[d];\r\n\r\n      // Look at the rounding digits and mode to determine whether to round up.\r\n\r\n      k = baseOut / 2;\r\n      r = r || d < 0 || xc[d + 1] != null;\r\n\r\n      r = rm < 4 ? (i != null || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\r\n            : i > k || i == k &&(rm == 4 || r || rm == 6 && xc[d - 1] & 1 ||\r\n             rm == (x.s < 0 ? 8 : 7));\r\n\r\n      // If the index of the rounding digit is not greater than zero, or xc represents\r\n      // zero, then the result of the base conversion is zero or, if rounding up, a value\r\n      // such as 0.00001.\r\n      if (d < 1 || !xc[0]) {\r\n\r\n        // 1^-dp or 0\r\n        str = r ? toFixedPoint(alphabet.charAt(1), -dp, alphabet.charAt(0)) : alphabet.charAt(0);\r\n      } else {\r\n\r\n        // Truncate xc to the required number of decimal places.\r\n        xc.length = d;\r\n\r\n        // Round up?\r\n        if (r) {\r\n\r\n          // Rounding up may mean the previous digit has to be rounded up and so on.\r\n          for (--baseOut; ++xc[--d] > baseOut;) {\r\n            xc[d] = 0;\r\n\r\n            if (!d) {\r\n              ++e;\r\n              xc = [1].concat(xc);\r\n            }\r\n          }\r\n        }\r\n\r\n        // Determine trailing zeros.\r\n        for (k = xc.length; !xc[--k];);\r\n\r\n        // E.g. [4, 11, 15] becomes 4bf.\r\n        for (i = 0, str = ''; i <= k; str += alphabet.charAt(xc[i++]));\r\n\r\n        // Add leading zeros, decimal point and trailing zeros as required.\r\n        str = toFixedPoint(str, e, alphabet.charAt(0));\r\n      }\r\n\r\n      // The caller will add the sign.\r\n      return str;\r\n    };\r\n  })();\r\n\r\n\r\n  // Perform division in the specified base. Called by div and convertBase.\r\n  div = (function () {\r\n\r\n    // Assume non-zero x and k.\r\n    function multiply(x, k, base) {\r\n      var m, temp, xlo, xhi,\r\n        carry = 0,\r\n        i = x.length,\r\n        klo = k % SQRT_BASE,\r\n        khi = k / SQRT_BASE | 0;\r\n\r\n      for (x = x.slice(); i--;) {\r\n        xlo = x[i] % SQRT_BASE;\r\n        xhi = x[i] / SQRT_BASE | 0;\r\n        m = khi * xlo + xhi * klo;\r\n        temp = klo * xlo + ((m % SQRT_BASE) * SQRT_BASE) + carry;\r\n        carry = (temp / base | 0) + (m / SQRT_BASE | 0) + khi * xhi;\r\n        x[i] = temp % base;\r\n      }\r\n\r\n      if (carry) x = [carry].concat(x);\r\n\r\n      return x;\r\n    }\r\n\r\n    function compare(a, b, aL, bL) {\r\n      var i, cmp;\r\n\r\n      if (aL != bL) {\r\n        cmp = aL > bL ? 1 : -1;\r\n      } else {\r\n\r\n        for (i = cmp = 0; i < aL; i++) {\r\n\r\n          if (a[i] != b[i]) {\r\n            cmp = a[i] > b[i] ? 1 : -1;\r\n            break;\r\n          }\r\n        }\r\n      }\r\n\r\n      return cmp;\r\n    }\r\n\r\n    function subtract(a, b, aL, base) {\r\n      var i = 0;\r\n\r\n      // Subtract b from a.\r\n      for (; aL--;) {\r\n        a[aL] -= i;\r\n        i = a[aL] < b[aL] ? 1 : 0;\r\n        a[aL] = i * base + a[aL] - b[aL];\r\n      }\r\n\r\n      // Remove leading zeros.\r\n      for (; !a[0] && a.length > 1; a.splice(0, 1));\r\n    }\r\n\r\n    // x: dividend, y: divisor.\r\n    return function (x, y, dp, rm, base) {\r\n      var cmp, e, i, more, n, prod, prodL, q, qc, rem, remL, rem0, xi, xL, yc0,\r\n        yL, yz,\r\n        s = x.s == y.s ? 1 : -1,\r\n        xc = x.c,\r\n        yc = y.c;\r\n\r\n      // Either NaN, Infinity or 0?\r\n      if (!xc || !xc[0] || !yc || !yc[0]) {\r\n\r\n        return new BigNumber(\r\n\r\n         // Return NaN if either NaN, or both Infinity or 0.\r\n         !x.s || !y.s || (xc ? yc && xc[0] == yc[0] : !yc) ? NaN :\r\n\r\n          // Return ±0 if x is ±0 or y is ±Infinity, or return ±Infinity as y is ±0.\r\n          xc && xc[0] == 0 || !yc ? s * 0 : s / 0\r\n       );\r\n      }\r\n\r\n      q = new BigNumber(s);\r\n      qc = q.c = [];\r\n      e = x.e - y.e;\r\n      s = dp + e + 1;\r\n\r\n      if (!base) {\r\n        base = BASE;\r\n        e = bitFloor(x.e / LOG_BASE) - bitFloor(y.e / LOG_BASE);\r\n        s = s / LOG_BASE | 0;\r\n      }\r\n\r\n      // Result exponent may be one less then the current value of e.\r\n      // The coefficients of the BigNumbers from convertBase may have trailing zeros.\r\n      for (i = 0; yc[i] == (xc[i] || 0); i++);\r\n\r\n      if (yc[i] > (xc[i] || 0)) e--;\r\n\r\n      if (s < 0) {\r\n        qc.push(1);\r\n        more = true;\r\n      } else {\r\n        xL = xc.length;\r\n        yL = yc.length;\r\n        i = 0;\r\n        s += 2;\r\n\r\n        // Normalise xc and yc so highest order digit of yc is >= base / 2.\r\n\r\n        n = mathfloor(base / (yc[0] + 1));\r\n\r\n        // Not necessary, but to handle odd bases where yc[0] == (base / 2) - 1.\r\n        // if (n > 1 || n++ == 1 && yc[0] < base / 2) {\r\n        if (n > 1) {\r\n          yc = multiply(yc, n, base);\r\n          xc = multiply(xc, n, base);\r\n          yL = yc.length;\r\n          xL = xc.length;\r\n        }\r\n\r\n        xi = yL;\r\n        rem = xc.slice(0, yL);\r\n        remL = rem.length;\r\n\r\n        // Add zeros to make remainder as long as divisor.\r\n        for (; remL < yL; rem[remL++] = 0);\r\n        yz = yc.slice();\r\n        yz = [0].concat(yz);\r\n        yc0 = yc[0];\r\n        if (yc[1] >= base / 2) yc0++;\r\n        // Not necessary, but to prevent trial digit n > base, when using base 3.\r\n        // else if (base == 3 && yc0 == 1) yc0 = 1 + 1e-15;\r\n\r\n        do {\r\n          n = 0;\r\n\r\n          // Compare divisor and remainder.\r\n          cmp = compare(yc, rem, yL, remL);\r\n\r\n          // If divisor < remainder.\r\n          if (cmp < 0) {\r\n\r\n            // Calculate trial digit, n.\r\n\r\n            rem0 = rem[0];\r\n            if (yL != remL) rem0 = rem0 * base + (rem[1] || 0);\r\n\r\n            // n is how many times the divisor goes into the current remainder.\r\n            n = mathfloor(rem0 / yc0);\r\n\r\n            //  Algorithm:\r\n            //  product = divisor multiplied by trial digit (n).\r\n            //  Compare product and remainder.\r\n            //  If product is greater than remainder:\r\n            //    Subtract divisor from product, decrement trial digit.\r\n            //  Subtract product from remainder.\r\n            //  If product was less than remainder at the last compare:\r\n            //    Compare new remainder and divisor.\r\n            //    If remainder is greater than divisor:\r\n            //      Subtract divisor from remainder, increment trial digit.\r\n\r\n            if (n > 1) {\r\n\r\n              // n may be > base only when base is 3.\r\n              if (n >= base) n = base - 1;\r\n\r\n              // product = divisor * trial digit.\r\n              prod = multiply(yc, n, base);\r\n              prodL = prod.length;\r\n              remL = rem.length;\r\n\r\n              // Compare product and remainder.\r\n              // If product > remainder then trial digit n too high.\r\n              // n is 1 too high about 5% of the time, and is not known to have\r\n              // ever been more than 1 too high.\r\n              while (compare(prod, rem, prodL, remL) == 1) {\r\n                n--;\r\n\r\n                // Subtract divisor from product.\r\n                subtract(prod, yL < prodL ? yz : yc, prodL, base);\r\n                prodL = prod.length;\r\n                cmp = 1;\r\n              }\r\n            } else {\r\n\r\n              // n is 0 or 1, cmp is -1.\r\n              // If n is 0, there is no need to compare yc and rem again below,\r\n              // so change cmp to 1 to avoid it.\r\n              // If n is 1, leave cmp as -1, so yc and rem are compared again.\r\n              if (n == 0) {\r\n\r\n                // divisor < remainder, so n must be at least 1.\r\n                cmp = n = 1;\r\n              }\r\n\r\n              // product = divisor\r\n              prod = yc.slice();\r\n              prodL = prod.length;\r\n            }\r\n\r\n            if (prodL < remL) prod = [0].concat(prod);\r\n\r\n            // Subtract product from remainder.\r\n            subtract(rem, prod, remL, base);\r\n            remL = rem.length;\r\n\r\n             // If product was < remainder.\r\n            if (cmp == -1) {\r\n\r\n              // Compare divisor and new remainder.\r\n              // If divisor < new remainder, subtract divisor from remainder.\r\n              // Trial digit n too low.\r\n              // n is 1 too low about 5% of the time, and very rarely 2 too low.\r\n              while (compare(yc, rem, yL, remL) < 1) {\r\n                n++;\r\n\r\n                // Subtract divisor from remainder.\r\n                subtract(rem, yL < remL ? yz : yc, remL, base);\r\n                remL = rem.length;\r\n              }\r\n            }\r\n          } else if (cmp === 0) {\r\n            n++;\r\n            rem = [0];\r\n          } // else cmp === 1 and n will be 0\r\n\r\n          // Add the next digit, n, to the result array.\r\n          qc[i++] = n;\r\n\r\n          // Update the remainder.\r\n          if (rem[0]) {\r\n            rem[remL++] = xc[xi] || 0;\r\n          } else {\r\n            rem = [xc[xi]];\r\n            remL = 1;\r\n          }\r\n        } while ((xi++ < xL || rem[0] != null) && s--);\r\n\r\n        more = rem[0] != null;\r\n\r\n        // Leading zero?\r\n        if (!qc[0]) qc.splice(0, 1);\r\n      }\r\n\r\n      if (base == BASE) {\r\n\r\n        // To calculate q.e, first get the number of digits of qc[0].\r\n        for (i = 1, s = qc[0]; s >= 10; s /= 10, i++);\r\n\r\n        round(q, dp + (q.e = i + e * LOG_BASE - 1) + 1, rm, more);\r\n\r\n      // Caller is convertBase.\r\n      } else {\r\n        q.e = e;\r\n        q.r = +more;\r\n      }\r\n\r\n      return q;\r\n    };\r\n  })();\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of BigNumber n in fixed-point or exponential\r\n   * notation rounded to the specified decimal places or significant digits.\r\n   *\r\n   * n: a BigNumber.\r\n   * i: the index of the last digit required (i.e. the digit that may be rounded up).\r\n   * rm: the rounding mode.\r\n   * id: 1 (toExponential) or 2 (toPrecision).\r\n   */\r\n  function format(n, i, rm, id) {\r\n    var c0, e, ne, len, str;\r\n\r\n    if (rm == null) rm = ROUNDING_MODE;\r\n    else intCheck(rm, 0, 8);\r\n\r\n    if (!n.c) return n.toString();\r\n\r\n    c0 = n.c[0];\r\n    ne = n.e;\r\n\r\n    if (i == null) {\r\n      str = coeffToString(n.c);\r\n      str = id == 1 || id == 2 && (ne <= TO_EXP_NEG || ne >= TO_EXP_POS)\r\n       ? toExponential(str, ne)\r\n       : toFixedPoint(str, ne, '0');\r\n    } else {\r\n      n = round(new BigNumber(n), i, rm);\r\n\r\n      // n.e may have changed if the value was rounded up.\r\n      e = n.e;\r\n\r\n      str = coeffToString(n.c);\r\n      len = str.length;\r\n\r\n      // toPrecision returns exponential notation if the number of significant digits\r\n      // specified is less than the number of digits necessary to represent the integer\r\n      // part of the value in fixed-point notation.\r\n\r\n      // Exponential notation.\r\n      if (id == 1 || id == 2 && (i <= e || e <= TO_EXP_NEG)) {\r\n\r\n        // Append zeros?\r\n        for (; len < i; str += '0', len++);\r\n        str = toExponential(str, e);\r\n\r\n      // Fixed-point notation.\r\n      } else {\r\n        i -= ne + (id === 2 && e > ne);\r\n        str = toFixedPoint(str, e, '0');\r\n\r\n        // Append zeros?\r\n        if (e + 1 > len) {\r\n          if (--i > 0) for (str += '.'; i--; str += '0');\r\n        } else {\r\n          i += e - len;\r\n          if (i > 0) {\r\n            if (e + 1 == len) str += '.';\r\n            for (; i--; str += '0');\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    return n.s < 0 && c0 ? '-' + str : str;\r\n  }\r\n\r\n\r\n  // Handle BigNumber.max and BigNumber.min.\r\n  // If any number is NaN, return NaN.\r\n  function maxOrMin(args, n) {\r\n    var k, y,\r\n      i = 1,\r\n      x = new BigNumber(args[0]);\r\n\r\n    for (; i < args.length; i++) {\r\n      y = new BigNumber(args[i]);\r\n      if (!y.s || (k = compare(x, y)) === n || k === 0 && x.s === n) {\r\n        x = y;\r\n      }\r\n    }\r\n\r\n    return x;\r\n  }\r\n\r\n\r\n  /*\r\n   * Strip trailing zeros, calculate base 10 exponent and check against MIN_EXP and MAX_EXP.\r\n   * Called by minus, plus and times.\r\n   */\r\n  function normalise(n, c, e) {\r\n    var i = 1,\r\n      j = c.length;\r\n\r\n     // Remove trailing zeros.\r\n    for (; !c[--j]; c.pop());\r\n\r\n    // Calculate the base 10 exponent. First get the number of digits of c[0].\r\n    for (j = c[0]; j >= 10; j /= 10, i++);\r\n\r\n    // Overflow?\r\n    if ((e = i + e * LOG_BASE - 1) > MAX_EXP) {\r\n\r\n      // Infinity.\r\n      n.c = n.e = null;\r\n\r\n    // Underflow?\r\n    } else if (e < MIN_EXP) {\r\n\r\n      // Zero.\r\n      n.c = [n.e = 0];\r\n    } else {\r\n      n.e = e;\r\n      n.c = c;\r\n    }\r\n\r\n    return n;\r\n  }\r\n\r\n\r\n  // Handle values that fail the validity test in BigNumber.\r\n  parseNumeric = (function () {\r\n    var basePrefix = /^(-?)0([xbo])(?=\\w[\\w.]*$)/i,\r\n      dotAfter = /^([^.]+)\\.$/,\r\n      dotBefore = /^\\.([^.]+)$/,\r\n      isInfinityOrNaN = /^-?(Infinity|NaN)$/,\r\n      whitespaceOrPlus = /^\\s*\\+(?=[\\w.])|^\\s+|\\s+$/g;\r\n\r\n    return function (x, str, isNum, b) {\r\n      var base,\r\n        s = isNum ? str : str.replace(whitespaceOrPlus, '');\r\n\r\n      // No exception on ±Infinity or NaN.\r\n      if (isInfinityOrNaN.test(s)) {\r\n        x.s = isNaN(s) ? null : s < 0 ? -1 : 1;\r\n      } else {\r\n        if (!isNum) {\r\n\r\n          // basePrefix = /^(-?)0([xbo])(?=\\w[\\w.]*$)/i\r\n          s = s.replace(basePrefix, function (m, p1, p2) {\r\n            base = (p2 = p2.toLowerCase()) == 'x' ? 16 : p2 == 'b' ? 2 : 8;\r\n            return !b || b == base ? p1 : m;\r\n          });\r\n\r\n          if (b) {\r\n            base = b;\r\n\r\n            // E.g. '1.' to '1', '.1' to '0.1'\r\n            s = s.replace(dotAfter, '$1').replace(dotBefore, '0.$1');\r\n          }\r\n\r\n          if (str != s) return new BigNumber(s, base);\r\n        }\r\n\r\n        // '[BigNumber Error] Not a number: {n}'\r\n        // '[BigNumber Error] Not a base {b} number: {n}'\r\n        if (BigNumber.DEBUG) {\r\n          throw Error\r\n            (bignumberError + 'Not a' + (b ? ' base ' + b : '') + ' number: ' + str);\r\n        }\r\n\r\n        // NaN\r\n        x.s = null;\r\n      }\r\n\r\n      x.c = x.e = null;\r\n    }\r\n  })();\r\n\r\n\r\n  /*\r\n   * Round x to sd significant digits using rounding mode rm. Check for over/under-flow.\r\n   * If r is truthy, it is known that there are more digits after the rounding digit.\r\n   */\r\n  function round(x, sd, rm, r) {\r\n    var d, i, j, k, n, ni, rd,\r\n      xc = x.c,\r\n      pows10 = POWS_TEN;\r\n\r\n    // if x is not Infinity or NaN...\r\n    if (xc) {\r\n\r\n      // rd is the rounding digit, i.e. the digit after the digit that may be rounded up.\r\n      // n is a base 1e14 number, the value of the element of array x.c containing rd.\r\n      // ni is the index of n within x.c.\r\n      // d is the number of digits of n.\r\n      // i is the index of rd within n including leading zeros.\r\n      // j is the actual index of rd within n (if < 0, rd is a leading zero).\r\n      out: {\r\n\r\n        // Get the number of digits of the first element of xc.\r\n        for (d = 1, k = xc[0]; k >= 10; k /= 10, d++);\r\n        i = sd - d;\r\n\r\n        // If the rounding digit is in the first element of xc...\r\n        if (i < 0) {\r\n          i += LOG_BASE;\r\n          j = sd;\r\n          n = xc[ni = 0];\r\n\r\n          // Get the rounding digit at index j of n.\r\n          rd = mathfloor(n / pows10[d - j - 1] % 10);\r\n        } else {\r\n          ni = mathceil((i + 1) / LOG_BASE);\r\n\r\n          if (ni >= xc.length) {\r\n\r\n            if (r) {\r\n\r\n              // Needed by sqrt.\r\n              for (; xc.length <= ni; xc.push(0));\r\n              n = rd = 0;\r\n              d = 1;\r\n              i %= LOG_BASE;\r\n              j = i - LOG_BASE + 1;\r\n            } else {\r\n              break out;\r\n            }\r\n          } else {\r\n            n = k = xc[ni];\r\n\r\n            // Get the number of digits of n.\r\n            for (d = 1; k >= 10; k /= 10, d++);\r\n\r\n            // Get the index of rd within n.\r\n            i %= LOG_BASE;\r\n\r\n            // Get the index of rd within n, adjusted for leading zeros.\r\n            // The number of leading zeros of n is given by LOG_BASE - d.\r\n            j = i - LOG_BASE + d;\r\n\r\n            // Get the rounding digit at index j of n.\r\n            rd = j < 0 ? 0 : mathfloor(n / pows10[d - j - 1] % 10);\r\n          }\r\n        }\r\n\r\n        r = r || sd < 0 ||\r\n\r\n        // Are there any non-zero digits after the rounding digit?\r\n        // The expression  n % pows10[d - j - 1]  returns all digits of n to the right\r\n        // of the digit at j, e.g. if n is 908714 and j is 2, the expression gives 714.\r\n         xc[ni + 1] != null || (j < 0 ? n : n % pows10[d - j - 1]);\r\n\r\n        r = rm < 4\r\n         ? (rd || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\r\n         : rd > 5 || rd == 5 && (rm == 4 || r || rm == 6 &&\r\n\r\n          // Check whether the digit to the left of the rounding digit is odd.\r\n          ((i > 0 ? j > 0 ? n / pows10[d - j] : 0 : xc[ni - 1]) % 10) & 1 ||\r\n           rm == (x.s < 0 ? 8 : 7));\r\n\r\n        if (sd < 1 || !xc[0]) {\r\n          xc.length = 0;\r\n\r\n          if (r) {\r\n\r\n            // Convert sd to decimal places.\r\n            sd -= x.e + 1;\r\n\r\n            // 1, 0.1, 0.01, 0.001, 0.0001 etc.\r\n            xc[0] = pows10[(LOG_BASE - sd % LOG_BASE) % LOG_BASE];\r\n            x.e = -sd || 0;\r\n          } else {\r\n\r\n            // Zero.\r\n            xc[0] = x.e = 0;\r\n          }\r\n\r\n          return x;\r\n        }\r\n\r\n        // Remove excess digits.\r\n        if (i == 0) {\r\n          xc.length = ni;\r\n          k = 1;\r\n          ni--;\r\n        } else {\r\n          xc.length = ni + 1;\r\n          k = pows10[LOG_BASE - i];\r\n\r\n          // E.g. 56700 becomes 56000 if 7 is the rounding digit.\r\n          // j > 0 means i > number of leading zeros of n.\r\n          xc[ni] = j > 0 ? mathfloor(n / pows10[d - j] % pows10[j]) * k : 0;\r\n        }\r\n\r\n        // Round up?\r\n        if (r) {\r\n\r\n          for (; ;) {\r\n\r\n            // If the digit to be rounded up is in the first element of xc...\r\n            if (ni == 0) {\r\n\r\n              // i will be the length of xc[0] before k is added.\r\n              for (i = 1, j = xc[0]; j >= 10; j /= 10, i++);\r\n              j = xc[0] += k;\r\n              for (k = 1; j >= 10; j /= 10, k++);\r\n\r\n              // if i != k the length has increased.\r\n              if (i != k) {\r\n                x.e++;\r\n                if (xc[0] == BASE) xc[0] = 1;\r\n              }\r\n\r\n              break;\r\n            } else {\r\n              xc[ni] += k;\r\n              if (xc[ni] != BASE) break;\r\n              xc[ni--] = 0;\r\n              k = 1;\r\n            }\r\n          }\r\n        }\r\n\r\n        // Remove trailing zeros.\r\n        for (i = xc.length; xc[--i] === 0; xc.pop());\r\n      }\r\n\r\n      // Overflow? Infinity.\r\n      if (x.e > MAX_EXP) {\r\n        x.c = x.e = null;\r\n\r\n      // Underflow? Zero.\r\n      } else if (x.e < MIN_EXP) {\r\n        x.c = [x.e = 0];\r\n      }\r\n    }\r\n\r\n    return x;\r\n  }\r\n\r\n\r\n  function valueOf(n) {\r\n    var str,\r\n      e = n.e;\r\n\r\n    if (e === null) return n.toString();\r\n\r\n    str = coeffToString(n.c);\r\n\r\n    str = e <= TO_EXP_NEG || e >= TO_EXP_POS\r\n      ? toExponential(str, e)\r\n      : toFixedPoint(str, e, '0');\r\n\r\n    return n.s < 0 ? '-' + str : str;\r\n  }\r\n\r\n\r\n  // PROTOTYPE/INSTANCE METHODS\r\n\r\n\r\n  /*\r\n   * Return a new BigNumber whose value is the absolute value of this BigNumber.\r\n   */\r\n  P.absoluteValue = P.abs = function () {\r\n    var x = new BigNumber(this);\r\n    if (x.s < 0) x.s = 1;\r\n    return x;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return\r\n   *   1 if the value of this BigNumber is greater than the value of BigNumber(y, b),\r\n   *   -1 if the value of this BigNumber is less than the value of BigNumber(y, b),\r\n   *   0 if they have the same value,\r\n   *   or null if the value of either is NaN.\r\n   */\r\n  P.comparedTo = function (y, b) {\r\n    return compare(this, new BigNumber(y, b));\r\n  };\r\n\r\n\r\n  /*\r\n   * If dp is undefined or null or true or false, return the number of decimal places of the\r\n   * value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN.\r\n   *\r\n   * Otherwise, if dp is a number, return a new BigNumber whose value is the value of this\r\n   * BigNumber rounded to a maximum of dp decimal places using rounding mode rm, or\r\n   * ROUNDING_MODE if rm is omitted.\r\n   *\r\n   * [dp] {number} Decimal places: integer, 0 to MAX inclusive.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n   */\r\n  P.decimalPlaces = P.dp = function (dp, rm) {\r\n    var c, n, v,\r\n      x = this;\r\n\r\n    if (dp != null) {\r\n      intCheck(dp, 0, MAX);\r\n      if (rm == null) rm = ROUNDING_MODE;\r\n      else intCheck(rm, 0, 8);\r\n\r\n      return round(new BigNumber(x), dp + x.e + 1, rm);\r\n    }\r\n\r\n    if (!(c = x.c)) return null;\r\n    n = ((v = c.length - 1) - bitFloor(this.e / LOG_BASE)) * LOG_BASE;\r\n\r\n    // Subtract the number of trailing zeros of the last number.\r\n    if (v = c[v]) for (; v % 10 == 0; v /= 10, n--);\r\n    if (n < 0) n = 0;\r\n\r\n    return n;\r\n  };\r\n\r\n\r\n  /*\r\n   *  n / 0 = I\r\n   *  n / N = N\r\n   *  n / I = 0\r\n   *  0 / n = 0\r\n   *  0 / 0 = N\r\n   *  0 / N = N\r\n   *  0 / I = 0\r\n   *  N / n = N\r\n   *  N / 0 = N\r\n   *  N / N = N\r\n   *  N / I = N\r\n   *  I / n = I\r\n   *  I / 0 = I\r\n   *  I / N = N\r\n   *  I / I = N\r\n   *\r\n   * Return a new BigNumber whose value is the value of this BigNumber divided by the value of\r\n   * BigNumber(y, b), rounded according to DECIMAL_PLACES and ROUNDING_MODE.\r\n   */\r\n  P.dividedBy = P.div = function (y, b) {\r\n    return div(this, new BigNumber(y, b), DECIMAL_PLACES, ROUNDING_MODE);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new BigNumber whose value is the integer part of dividing the value of this\r\n   * BigNumber by the value of BigNumber(y, b).\r\n   */\r\n  P.dividedToIntegerBy = P.idiv = function (y, b) {\r\n    return div(this, new BigNumber(y, b), 0, 1);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a BigNumber whose value is the value of this BigNumber exponentiated by n.\r\n   *\r\n   * If m is present, return the result modulo m.\r\n   * If n is negative round according to DECIMAL_PLACES and ROUNDING_MODE.\r\n   * If POW_PRECISION is non-zero and m is not present, round to POW_PRECISION using ROUNDING_MODE.\r\n   *\r\n   * The modular power operation works efficiently when x, n, and m are integers, otherwise it\r\n   * is equivalent to calculating x.exponentiatedBy(n).modulo(m) with a POW_PRECISION of 0.\r\n   *\r\n   * n {number|string|BigNumber} The exponent. An integer.\r\n   * [m] {number|string|BigNumber} The modulus.\r\n   *\r\n   * '[BigNumber Error] Exponent not an integer: {n}'\r\n   */\r\n  P.exponentiatedBy = P.pow = function (n, m) {\r\n    var half, isModExp, i, k, more, nIsBig, nIsNeg, nIsOdd, y,\r\n      x = this;\r\n\r\n    n = new BigNumber(n);\r\n\r\n    // Allow NaN and ±Infinity, but not other non-integers.\r\n    if (n.c && !n.isInteger()) {\r\n      throw Error\r\n        (bignumberError + 'Exponent not an integer: ' + valueOf(n));\r\n    }\r\n\r\n    if (m != null) m = new BigNumber(m);\r\n\r\n    // Exponent of MAX_SAFE_INTEGER is 15.\r\n    nIsBig = n.e > 14;\r\n\r\n    // If x is NaN, ±Infinity, ±0 or ±1, or n is ±Infinity, NaN or ±0.\r\n    if (!x.c || !x.c[0] || x.c[0] == 1 && !x.e && x.c.length == 1 || !n.c || !n.c[0]) {\r\n\r\n      // The sign of the result of pow when x is negative depends on the evenness of n.\r\n      // If +n overflows to ±Infinity, the evenness of n would be not be known.\r\n      y = new BigNumber(Math.pow(+valueOf(x), nIsBig ? n.s * (2 - isOdd(n)) : +valueOf(n)));\r\n      return m ? y.mod(m) : y;\r\n    }\r\n\r\n    nIsNeg = n.s < 0;\r\n\r\n    if (m) {\r\n\r\n      // x % m returns NaN if abs(m) is zero, or m is NaN.\r\n      if (m.c ? !m.c[0] : !m.s) return new BigNumber(NaN);\r\n\r\n      isModExp = !nIsNeg && x.isInteger() && m.isInteger();\r\n\r\n      if (isModExp) x = x.mod(m);\r\n\r\n    // Overflow to ±Infinity: >=2**1e10 or >=1.0000024**1e15.\r\n    // Underflow to ±0: <=0.79**1e10 or <=0.9999975**1e15.\r\n    } else if (n.e > 9 && (x.e > 0 || x.e < -1 || (x.e == 0\r\n      // [1, 240000000]\r\n      ? x.c[0] > 1 || nIsBig && x.c[1] >= 24e7\r\n      // [80000000000000]  [99999750000000]\r\n      : x.c[0] < 8e13 || nIsBig && x.c[0] <= 9999975e7))) {\r\n\r\n      // If x is negative and n is odd, k = -0, else k = 0.\r\n      k = x.s < 0 && isOdd(n) ? -0 : 0;\r\n\r\n      // If x >= 1, k = ±Infinity.\r\n      if (x.e > -1) k = 1 / k;\r\n\r\n      // If n is negative return ±0, else return ±Infinity.\r\n      return new BigNumber(nIsNeg ? 1 / k : k);\r\n\r\n    } else if (POW_PRECISION) {\r\n\r\n      // Truncating each coefficient array to a length of k after each multiplication\r\n      // equates to truncating significant digits to POW_PRECISION + [28, 41],\r\n      // i.e. there will be a minimum of 28 guard digits retained.\r\n      k = mathceil(POW_PRECISION / LOG_BASE + 2);\r\n    }\r\n\r\n    if (nIsBig) {\r\n      half = new BigNumber(0.5);\r\n      if (nIsNeg) n.s = 1;\r\n      nIsOdd = isOdd(n);\r\n    } else {\r\n      i = Math.abs(+valueOf(n));\r\n      nIsOdd = i % 2;\r\n    }\r\n\r\n    y = new BigNumber(ONE);\r\n\r\n    // Performs 54 loop iterations for n of 9007199254740991.\r\n    for (; ;) {\r\n\r\n      if (nIsOdd) {\r\n        y = y.times(x);\r\n        if (!y.c) break;\r\n\r\n        if (k) {\r\n          if (y.c.length > k) y.c.length = k;\r\n        } else if (isModExp) {\r\n          y = y.mod(m);    //y = y.minus(div(y, m, 0, MODULO_MODE).times(m));\r\n        }\r\n      }\r\n\r\n      if (i) {\r\n        i = mathfloor(i / 2);\r\n        if (i === 0) break;\r\n        nIsOdd = i % 2;\r\n      } else {\r\n        n = n.times(half);\r\n        round(n, n.e + 1, 1);\r\n\r\n        if (n.e > 14) {\r\n          nIsOdd = isOdd(n);\r\n        } else {\r\n          i = +valueOf(n);\r\n          if (i === 0) break;\r\n          nIsOdd = i % 2;\r\n        }\r\n      }\r\n\r\n      x = x.times(x);\r\n\r\n      if (k) {\r\n        if (x.c && x.c.length > k) x.c.length = k;\r\n      } else if (isModExp) {\r\n        x = x.mod(m);    //x = x.minus(div(x, m, 0, MODULO_MODE).times(m));\r\n      }\r\n    }\r\n\r\n    if (isModExp) return y;\r\n    if (nIsNeg) y = ONE.div(y);\r\n\r\n    return m ? y.mod(m) : k ? round(y, POW_PRECISION, ROUNDING_MODE, more) : y;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new BigNumber whose value is the value of this BigNumber rounded to an integer\r\n   * using rounding mode rm, or ROUNDING_MODE if rm is omitted.\r\n   *\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {rm}'\r\n   */\r\n  P.integerValue = function (rm) {\r\n    var n = new BigNumber(this);\r\n    if (rm == null) rm = ROUNDING_MODE;\r\n    else intCheck(rm, 0, 8);\r\n    return round(n, n.e + 1, rm);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this BigNumber is equal to the value of BigNumber(y, b),\r\n   * otherwise return false.\r\n   */\r\n  P.isEqualTo = P.eq = function (y, b) {\r\n    return compare(this, new BigNumber(y, b)) === 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this BigNumber is a finite number, otherwise return false.\r\n   */\r\n  P.isFinite = function () {\r\n    return !!this.c;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this BigNumber is greater than the value of BigNumber(y, b),\r\n   * otherwise return false.\r\n   */\r\n  P.isGreaterThan = P.gt = function (y, b) {\r\n    return compare(this, new BigNumber(y, b)) > 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this BigNumber is greater than or equal to the value of\r\n   * BigNumber(y, b), otherwise return false.\r\n   */\r\n  P.isGreaterThanOrEqualTo = P.gte = function (y, b) {\r\n    return (b = compare(this, new BigNumber(y, b))) === 1 || b === 0;\r\n\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this BigNumber is an integer, otherwise return false.\r\n   */\r\n  P.isInteger = function () {\r\n    return !!this.c && bitFloor(this.e / LOG_BASE) > this.c.length - 2;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this BigNumber is less than the value of BigNumber(y, b),\r\n   * otherwise return false.\r\n   */\r\n  P.isLessThan = P.lt = function (y, b) {\r\n    return compare(this, new BigNumber(y, b)) < 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this BigNumber is less than or equal to the value of\r\n   * BigNumber(y, b), otherwise return false.\r\n   */\r\n  P.isLessThanOrEqualTo = P.lte = function (y, b) {\r\n    return (b = compare(this, new BigNumber(y, b))) === -1 || b === 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this BigNumber is NaN, otherwise return false.\r\n   */\r\n  P.isNaN = function () {\r\n    return !this.s;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this BigNumber is negative, otherwise return false.\r\n   */\r\n  P.isNegative = function () {\r\n    return this.s < 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this BigNumber is positive, otherwise return false.\r\n   */\r\n  P.isPositive = function () {\r\n    return this.s > 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this BigNumber is 0 or -0, otherwise return false.\r\n   */\r\n  P.isZero = function () {\r\n    return !!this.c && this.c[0] == 0;\r\n  };\r\n\r\n\r\n  /*\r\n   *  n - 0 = n\r\n   *  n - N = N\r\n   *  n - I = -I\r\n   *  0 - n = -n\r\n   *  0 - 0 = 0\r\n   *  0 - N = N\r\n   *  0 - I = -I\r\n   *  N - n = N\r\n   *  N - 0 = N\r\n   *  N - N = N\r\n   *  N - I = N\r\n   *  I - n = I\r\n   *  I - 0 = I\r\n   *  I - N = N\r\n   *  I - I = N\r\n   *\r\n   * Return a new BigNumber whose value is the value of this BigNumber minus the value of\r\n   * BigNumber(y, b).\r\n   */\r\n  P.minus = function (y, b) {\r\n    var i, j, t, xLTy,\r\n      x = this,\r\n      a = x.s;\r\n\r\n    y = new BigNumber(y, b);\r\n    b = y.s;\r\n\r\n    // Either NaN?\r\n    if (!a || !b) return new BigNumber(NaN);\r\n\r\n    // Signs differ?\r\n    if (a != b) {\r\n      y.s = -b;\r\n      return x.plus(y);\r\n    }\r\n\r\n    var xe = x.e / LOG_BASE,\r\n      ye = y.e / LOG_BASE,\r\n      xc = x.c,\r\n      yc = y.c;\r\n\r\n    if (!xe || !ye) {\r\n\r\n      // Either Infinity?\r\n      if (!xc || !yc) return xc ? (y.s = -b, y) : new BigNumber(yc ? x : NaN);\r\n\r\n      // Either zero?\r\n      if (!xc[0] || !yc[0]) {\r\n\r\n        // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.\r\n        return yc[0] ? (y.s = -b, y) : new BigNumber(xc[0] ? x :\r\n\r\n         // IEEE 754 (2008) 6.3: n - n = -0 when rounding to -Infinity\r\n         ROUNDING_MODE == 3 ? -0 : 0);\r\n      }\r\n    }\r\n\r\n    xe = bitFloor(xe);\r\n    ye = bitFloor(ye);\r\n    xc = xc.slice();\r\n\r\n    // Determine which is the bigger number.\r\n    if (a = xe - ye) {\r\n\r\n      if (xLTy = a < 0) {\r\n        a = -a;\r\n        t = xc;\r\n      } else {\r\n        ye = xe;\r\n        t = yc;\r\n      }\r\n\r\n      t.reverse();\r\n\r\n      // Prepend zeros to equalise exponents.\r\n      for (b = a; b--; t.push(0));\r\n      t.reverse();\r\n    } else {\r\n\r\n      // Exponents equal. Check digit by digit.\r\n      j = (xLTy = (a = xc.length) < (b = yc.length)) ? a : b;\r\n\r\n      for (a = b = 0; b < j; b++) {\r\n\r\n        if (xc[b] != yc[b]) {\r\n          xLTy = xc[b] < yc[b];\r\n          break;\r\n        }\r\n      }\r\n    }\r\n\r\n    // x < y? Point xc to the array of the bigger number.\r\n    if (xLTy) {\r\n      t = xc;\r\n      xc = yc;\r\n      yc = t;\r\n      y.s = -y.s;\r\n    }\r\n\r\n    b = (j = yc.length) - (i = xc.length);\r\n\r\n    // Append zeros to xc if shorter.\r\n    // No need to add zeros to yc if shorter as subtract only needs to start at yc.length.\r\n    if (b > 0) for (; b--; xc[i++] = 0);\r\n    b = BASE - 1;\r\n\r\n    // Subtract yc from xc.\r\n    for (; j > a;) {\r\n\r\n      if (xc[--j] < yc[j]) {\r\n        for (i = j; i && !xc[--i]; xc[i] = b);\r\n        --xc[i];\r\n        xc[j] += BASE;\r\n      }\r\n\r\n      xc[j] -= yc[j];\r\n    }\r\n\r\n    // Remove leading zeros and adjust exponent accordingly.\r\n    for (; xc[0] == 0; xc.splice(0, 1), --ye);\r\n\r\n    // Zero?\r\n    if (!xc[0]) {\r\n\r\n      // Following IEEE 754 (2008) 6.3,\r\n      // n - n = +0  but  n - n = -0  when rounding towards -Infinity.\r\n      y.s = ROUNDING_MODE == 3 ? -1 : 1;\r\n      y.c = [y.e = 0];\r\n      return y;\r\n    }\r\n\r\n    // No need to check for Infinity as +x - +y != Infinity && -x - -y != Infinity\r\n    // for finite x and y.\r\n    return normalise(y, xc, ye);\r\n  };\r\n\r\n\r\n  /*\r\n   *   n % 0 =  N\r\n   *   n % N =  N\r\n   *   n % I =  n\r\n   *   0 % n =  0\r\n   *  -0 % n = -0\r\n   *   0 % 0 =  N\r\n   *   0 % N =  N\r\n   *   0 % I =  0\r\n   *   N % n =  N\r\n   *   N % 0 =  N\r\n   *   N % N =  N\r\n   *   N % I =  N\r\n   *   I % n =  N\r\n   *   I % 0 =  N\r\n   *   I % N =  N\r\n   *   I % I =  N\r\n   *\r\n   * Return a new BigNumber whose value is the value of this BigNumber modulo the value of\r\n   * BigNumber(y, b). The result depends on the value of MODULO_MODE.\r\n   */\r\n  P.modulo = P.mod = function (y, b) {\r\n    var q, s,\r\n      x = this;\r\n\r\n    y = new BigNumber(y, b);\r\n\r\n    // Return NaN if x is Infinity or NaN, or y is NaN or zero.\r\n    if (!x.c || !y.s || y.c && !y.c[0]) {\r\n      return new BigNumber(NaN);\r\n\r\n    // Return x if y is Infinity or x is zero.\r\n    } else if (!y.c || x.c && !x.c[0]) {\r\n      return new BigNumber(x);\r\n    }\r\n\r\n    if (MODULO_MODE == 9) {\r\n\r\n      // Euclidian division: q = sign(y) * floor(x / abs(y))\r\n      // r = x - qy    where  0 <= r < abs(y)\r\n      s = y.s;\r\n      y.s = 1;\r\n      q = div(x, y, 0, 3);\r\n      y.s = s;\r\n      q.s *= s;\r\n    } else {\r\n      q = div(x, y, 0, MODULO_MODE);\r\n    }\r\n\r\n    y = x.minus(q.times(y));\r\n\r\n    // To match JavaScript %, ensure sign of zero is sign of dividend.\r\n    if (!y.c[0] && MODULO_MODE == 1) y.s = x.s;\r\n\r\n    return y;\r\n  };\r\n\r\n\r\n  /*\r\n   *  n * 0 = 0\r\n   *  n * N = N\r\n   *  n * I = I\r\n   *  0 * n = 0\r\n   *  0 * 0 = 0\r\n   *  0 * N = N\r\n   *  0 * I = N\r\n   *  N * n = N\r\n   *  N * 0 = N\r\n   *  N * N = N\r\n   *  N * I = N\r\n   *  I * n = I\r\n   *  I * 0 = N\r\n   *  I * N = N\r\n   *  I * I = I\r\n   *\r\n   * Return a new BigNumber whose value is the value of this BigNumber multiplied by the value\r\n   * of BigNumber(y, b).\r\n   */\r\n  P.multipliedBy = P.times = function (y, b) {\r\n    var c, e, i, j, k, m, xcL, xlo, xhi, ycL, ylo, yhi, zc,\r\n      base, sqrtBase,\r\n      x = this,\r\n      xc = x.c,\r\n      yc = (y = new BigNumber(y, b)).c;\r\n\r\n    // Either NaN, ±Infinity or ±0?\r\n    if (!xc || !yc || !xc[0] || !yc[0]) {\r\n\r\n      // Return NaN if either is NaN, or one is 0 and the other is Infinity.\r\n      if (!x.s || !y.s || xc && !xc[0] && !yc || yc && !yc[0] && !xc) {\r\n        y.c = y.e = y.s = null;\r\n      } else {\r\n        y.s *= x.s;\r\n\r\n        // Return ±Infinity if either is ±Infinity.\r\n        if (!xc || !yc) {\r\n          y.c = y.e = null;\r\n\r\n        // Return ±0 if either is ±0.\r\n        } else {\r\n          y.c = [0];\r\n          y.e = 0;\r\n        }\r\n      }\r\n\r\n      return y;\r\n    }\r\n\r\n    e = bitFloor(x.e / LOG_BASE) + bitFloor(y.e / LOG_BASE);\r\n    y.s *= x.s;\r\n    xcL = xc.length;\r\n    ycL = yc.length;\r\n\r\n    // Ensure xc points to longer array and xcL to its length.\r\n    if (xcL < ycL) {\r\n      zc = xc;\r\n      xc = yc;\r\n      yc = zc;\r\n      i = xcL;\r\n      xcL = ycL;\r\n      ycL = i;\r\n    }\r\n\r\n    // Initialise the result array with zeros.\r\n    for (i = xcL + ycL, zc = []; i--; zc.push(0));\r\n\r\n    base = BASE;\r\n    sqrtBase = SQRT_BASE;\r\n\r\n    for (i = ycL; --i >= 0;) {\r\n      c = 0;\r\n      ylo = yc[i] % sqrtBase;\r\n      yhi = yc[i] / sqrtBase | 0;\r\n\r\n      for (k = xcL, j = i + k; j > i;) {\r\n        xlo = xc[--k] % sqrtBase;\r\n        xhi = xc[k] / sqrtBase | 0;\r\n        m = yhi * xlo + xhi * ylo;\r\n        xlo = ylo * xlo + ((m % sqrtBase) * sqrtBase) + zc[j] + c;\r\n        c = (xlo / base | 0) + (m / sqrtBase | 0) + yhi * xhi;\r\n        zc[j--] = xlo % base;\r\n      }\r\n\r\n      zc[j] = c;\r\n    }\r\n\r\n    if (c) {\r\n      ++e;\r\n    } else {\r\n      zc.splice(0, 1);\r\n    }\r\n\r\n    return normalise(y, zc, e);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new BigNumber whose value is the value of this BigNumber negated,\r\n   * i.e. multiplied by -1.\r\n   */\r\n  P.negated = function () {\r\n    var x = new BigNumber(this);\r\n    x.s = -x.s || null;\r\n    return x;\r\n  };\r\n\r\n\r\n  /*\r\n   *  n + 0 = n\r\n   *  n + N = N\r\n   *  n + I = I\r\n   *  0 + n = n\r\n   *  0 + 0 = 0\r\n   *  0 + N = N\r\n   *  0 + I = I\r\n   *  N + n = N\r\n   *  N + 0 = N\r\n   *  N + N = N\r\n   *  N + I = N\r\n   *  I + n = I\r\n   *  I + 0 = I\r\n   *  I + N = N\r\n   *  I + I = I\r\n   *\r\n   * Return a new BigNumber whose value is the value of this BigNumber plus the value of\r\n   * BigNumber(y, b).\r\n   */\r\n  P.plus = function (y, b) {\r\n    var t,\r\n      x = this,\r\n      a = x.s;\r\n\r\n    y = new BigNumber(y, b);\r\n    b = y.s;\r\n\r\n    // Either NaN?\r\n    if (!a || !b) return new BigNumber(NaN);\r\n\r\n    // Signs differ?\r\n     if (a != b) {\r\n      y.s = -b;\r\n      return x.minus(y);\r\n    }\r\n\r\n    var xe = x.e / LOG_BASE,\r\n      ye = y.e / LOG_BASE,\r\n      xc = x.c,\r\n      yc = y.c;\r\n\r\n    if (!xe || !ye) {\r\n\r\n      // Return ±Infinity if either ±Infinity.\r\n      if (!xc || !yc) return new BigNumber(a / 0);\r\n\r\n      // Either zero?\r\n      // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.\r\n      if (!xc[0] || !yc[0]) return yc[0] ? y : new BigNumber(xc[0] ? x : a * 0);\r\n    }\r\n\r\n    xe = bitFloor(xe);\r\n    ye = bitFloor(ye);\r\n    xc = xc.slice();\r\n\r\n    // Prepend zeros to equalise exponents. Faster to use reverse then do unshifts.\r\n    if (a = xe - ye) {\r\n      if (a > 0) {\r\n        ye = xe;\r\n        t = yc;\r\n      } else {\r\n        a = -a;\r\n        t = xc;\r\n      }\r\n\r\n      t.reverse();\r\n      for (; a--; t.push(0));\r\n      t.reverse();\r\n    }\r\n\r\n    a = xc.length;\r\n    b = yc.length;\r\n\r\n    // Point xc to the longer array, and b to the shorter length.\r\n    if (a - b < 0) {\r\n      t = yc;\r\n      yc = xc;\r\n      xc = t;\r\n      b = a;\r\n    }\r\n\r\n    // Only start adding at yc.length - 1 as the further digits of xc can be ignored.\r\n    for (a = 0; b;) {\r\n      a = (xc[--b] = xc[b] + yc[b] + a) / BASE | 0;\r\n      xc[b] = BASE === xc[b] ? 0 : xc[b] % BASE;\r\n    }\r\n\r\n    if (a) {\r\n      xc = [a].concat(xc);\r\n      ++ye;\r\n    }\r\n\r\n    // No need to check for zero, as +x + +y != 0 && -x + -y != 0\r\n    // ye = MAX_EXP + 1 possible\r\n    return normalise(y, xc, ye);\r\n  };\r\n\r\n\r\n  /*\r\n   * If sd is undefined or null or true or false, return the number of significant digits of\r\n   * the value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN.\r\n   * If sd is true include integer-part trailing zeros in the count.\r\n   *\r\n   * Otherwise, if sd is a number, return a new BigNumber whose value is the value of this\r\n   * BigNumber rounded to a maximum of sd significant digits using rounding mode rm, or\r\n   * ROUNDING_MODE if rm is omitted.\r\n   *\r\n   * sd {number|boolean} number: significant digits: integer, 1 to MAX inclusive.\r\n   *                     boolean: whether to count integer-part trailing zeros: true or false.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}'\r\n   */\r\n  P.precision = P.sd = function (sd, rm) {\r\n    var c, n, v,\r\n      x = this;\r\n\r\n    if (sd != null && sd !== !!sd) {\r\n      intCheck(sd, 1, MAX);\r\n      if (rm == null) rm = ROUNDING_MODE;\r\n      else intCheck(rm, 0, 8);\r\n\r\n      return round(new BigNumber(x), sd, rm);\r\n    }\r\n\r\n    if (!(c = x.c)) return null;\r\n    v = c.length - 1;\r\n    n = v * LOG_BASE + 1;\r\n\r\n    if (v = c[v]) {\r\n\r\n      // Subtract the number of trailing zeros of the last element.\r\n      for (; v % 10 == 0; v /= 10, n--);\r\n\r\n      // Add the number of digits of the first element.\r\n      for (v = c[0]; v >= 10; v /= 10, n++);\r\n    }\r\n\r\n    if (sd && x.e + 1 > n) n = x.e + 1;\r\n\r\n    return n;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new BigNumber whose value is the value of this BigNumber shifted by k places\r\n   * (powers of 10). Shift to the right if n > 0, and to the left if n < 0.\r\n   *\r\n   * k {number} Integer, -MAX_SAFE_INTEGER to MAX_SAFE_INTEGER inclusive.\r\n   *\r\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {k}'\r\n   */\r\n  P.shiftedBy = function (k) {\r\n    intCheck(k, -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER);\r\n    return this.times('1e' + k);\r\n  };\r\n\r\n\r\n  /*\r\n   *  sqrt(-n) =  N\r\n   *  sqrt(N) =  N\r\n   *  sqrt(-I) =  N\r\n   *  sqrt(I) =  I\r\n   *  sqrt(0) =  0\r\n   *  sqrt(-0) = -0\r\n   *\r\n   * Return a new BigNumber whose value is the square root of the value of this BigNumber,\r\n   * rounded according to DECIMAL_PLACES and ROUNDING_MODE.\r\n   */\r\n  P.squareRoot = P.sqrt = function () {\r\n    var m, n, r, rep, t,\r\n      x = this,\r\n      c = x.c,\r\n      s = x.s,\r\n      e = x.e,\r\n      dp = DECIMAL_PLACES + 4,\r\n      half = new BigNumber('0.5');\r\n\r\n    // Negative/NaN/Infinity/zero?\r\n    if (s !== 1 || !c || !c[0]) {\r\n      return new BigNumber(!s || s < 0 && (!c || c[0]) ? NaN : c ? x : 1 / 0);\r\n    }\r\n\r\n    // Initial estimate.\r\n    s = Math.sqrt(+valueOf(x));\r\n\r\n    // Math.sqrt underflow/overflow?\r\n    // Pass x to Math.sqrt as integer, then adjust the exponent of the result.\r\n    if (s == 0 || s == 1 / 0) {\r\n      n = coeffToString(c);\r\n      if ((n.length + e) % 2 == 0) n += '0';\r\n      s = Math.sqrt(+n);\r\n      e = bitFloor((e + 1) / 2) - (e < 0 || e % 2);\r\n\r\n      if (s == 1 / 0) {\r\n        n = '5e' + e;\r\n      } else {\r\n        n = s.toExponential();\r\n        n = n.slice(0, n.indexOf('e') + 1) + e;\r\n      }\r\n\r\n      r = new BigNumber(n);\r\n    } else {\r\n      r = new BigNumber(s + '');\r\n    }\r\n\r\n    // Check for zero.\r\n    // r could be zero if MIN_EXP is changed after the this value was created.\r\n    // This would cause a division by zero (x/t) and hence Infinity below, which would cause\r\n    // coeffToString to throw.\r\n    if (r.c[0]) {\r\n      e = r.e;\r\n      s = e + dp;\r\n      if (s < 3) s = 0;\r\n\r\n      // Newton-Raphson iteration.\r\n      for (; ;) {\r\n        t = r;\r\n        r = half.times(t.plus(div(x, t, dp, 1)));\r\n\r\n        if (coeffToString(t.c).slice(0, s) === (n = coeffToString(r.c)).slice(0, s)) {\r\n\r\n          // The exponent of r may here be one less than the final result exponent,\r\n          // e.g 0.0009999 (e-4) --> 0.001 (e-3), so adjust s so the rounding digits\r\n          // are indexed correctly.\r\n          if (r.e < e) --s;\r\n          n = n.slice(s - 3, s + 1);\r\n\r\n          // The 4th rounding digit may be in error by -1 so if the 4 rounding digits\r\n          // are 9999 or 4999 (i.e. approaching a rounding boundary) continue the\r\n          // iteration.\r\n          if (n == '9999' || !rep && n == '4999') {\r\n\r\n            // On the first iteration only, check to see if rounding up gives the\r\n            // exact result as the nines may infinitely repeat.\r\n            if (!rep) {\r\n              round(t, t.e + DECIMAL_PLACES + 2, 0);\r\n\r\n              if (t.times(t).eq(x)) {\r\n                r = t;\r\n                break;\r\n              }\r\n            }\r\n\r\n            dp += 4;\r\n            s += 4;\r\n            rep = 1;\r\n          } else {\r\n\r\n            // If rounding digits are null, 0{0,4} or 50{0,3}, check for exact\r\n            // result. If not, then there are further digits and m will be truthy.\r\n            if (!+n || !+n.slice(1) && n.charAt(0) == '5') {\r\n\r\n              // Truncate to the first rounding digit.\r\n              round(r, r.e + DECIMAL_PLACES + 2, 1);\r\n              m = !r.times(r).eq(x);\r\n            }\r\n\r\n            break;\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    return round(r, r.e + DECIMAL_PLACES + 1, ROUNDING_MODE, m);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of this BigNumber in exponential notation and\r\n   * rounded using ROUNDING_MODE to dp fixed decimal places.\r\n   *\r\n   * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n   */\r\n  P.toExponential = function (dp, rm) {\r\n    if (dp != null) {\r\n      intCheck(dp, 0, MAX);\r\n      dp++;\r\n    }\r\n    return format(this, dp, rm, 1);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of this BigNumber in fixed-point notation rounding\r\n   * to dp fixed decimal places using rounding mode rm, or ROUNDING_MODE if rm is omitted.\r\n   *\r\n   * Note: as with JavaScript's number type, (-0).toFixed(0) is '0',\r\n   * but e.g. (-0.00001).toFixed(0) is '-0'.\r\n   *\r\n   * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n   */\r\n  P.toFixed = function (dp, rm) {\r\n    if (dp != null) {\r\n      intCheck(dp, 0, MAX);\r\n      dp = dp + this.e + 1;\r\n    }\r\n    return format(this, dp, rm);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of this BigNumber in fixed-point notation rounded\r\n   * using rm or ROUNDING_MODE to dp decimal places, and formatted according to the properties\r\n   * of the format or FORMAT object (see BigNumber.set).\r\n   *\r\n   * The formatting object may contain some or all of the properties shown below.\r\n   *\r\n   * FORMAT = {\r\n   *   prefix: '',\r\n   *   groupSize: 3,\r\n   *   secondaryGroupSize: 0,\r\n   *   groupSeparator: ',',\r\n   *   decimalSeparator: '.',\r\n   *   fractionGroupSize: 0,\r\n   *   fractionGroupSeparator: '\\xA0',      // non-breaking space\r\n   *   suffix: ''\r\n   * };\r\n   *\r\n   * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   * [format] {object} Formatting options. See FORMAT pbject above.\r\n   *\r\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n   * '[BigNumber Error] Argument not an object: {format}'\r\n   */\r\n  P.toFormat = function (dp, rm, format) {\r\n    var str,\r\n      x = this;\r\n\r\n    if (format == null) {\r\n      if (dp != null && rm && typeof rm == 'object') {\r\n        format = rm;\r\n        rm = null;\r\n      } else if (dp && typeof dp == 'object') {\r\n        format = dp;\r\n        dp = rm = null;\r\n      } else {\r\n        format = FORMAT;\r\n      }\r\n    } else if (typeof format != 'object') {\r\n      throw Error\r\n        (bignumberError + 'Argument not an object: ' + format);\r\n    }\r\n\r\n    str = x.toFixed(dp, rm);\r\n\r\n    if (x.c) {\r\n      var i,\r\n        arr = str.split('.'),\r\n        g1 = +format.groupSize,\r\n        g2 = +format.secondaryGroupSize,\r\n        groupSeparator = format.groupSeparator || '',\r\n        intPart = arr[0],\r\n        fractionPart = arr[1],\r\n        isNeg = x.s < 0,\r\n        intDigits = isNeg ? intPart.slice(1) : intPart,\r\n        len = intDigits.length;\r\n\r\n      if (g2) {\r\n        i = g1;\r\n        g1 = g2;\r\n        g2 = i;\r\n        len -= i;\r\n      }\r\n\r\n      if (g1 > 0 && len > 0) {\r\n        i = len % g1 || g1;\r\n        intPart = intDigits.substr(0, i);\r\n        for (; i < len; i += g1) intPart += groupSeparator + intDigits.substr(i, g1);\r\n        if (g2 > 0) intPart += groupSeparator + intDigits.slice(i);\r\n        if (isNeg) intPart = '-' + intPart;\r\n      }\r\n\r\n      str = fractionPart\r\n       ? intPart + (format.decimalSeparator || '') + ((g2 = +format.fractionGroupSize)\r\n        ? fractionPart.replace(new RegExp('\\\\d{' + g2 + '}\\\\B', 'g'),\r\n         '$&' + (format.fractionGroupSeparator || ''))\r\n        : fractionPart)\r\n       : intPart;\r\n    }\r\n\r\n    return (format.prefix || '') + str + (format.suffix || '');\r\n  };\r\n\r\n\r\n  /*\r\n   * Return an array of two BigNumbers representing the value of this BigNumber as a simple\r\n   * fraction with an integer numerator and an integer denominator.\r\n   * The denominator will be a positive non-zero value less than or equal to the specified\r\n   * maximum denominator. If a maximum denominator is not specified, the denominator will be\r\n   * the lowest value necessary to represent the number exactly.\r\n   *\r\n   * [md] {number|string|BigNumber} Integer >= 1, or Infinity. The maximum denominator.\r\n   *\r\n   * '[BigNumber Error] Argument {not an integer|out of range} : {md}'\r\n   */\r\n  P.toFraction = function (md) {\r\n    var d, d0, d1, d2, e, exp, n, n0, n1, q, r, s,\r\n      x = this,\r\n      xc = x.c;\r\n\r\n    if (md != null) {\r\n      n = new BigNumber(md);\r\n\r\n      // Throw if md is less than one or is not an integer, unless it is Infinity.\r\n      if (!n.isInteger() && (n.c || n.s !== 1) || n.lt(ONE)) {\r\n        throw Error\r\n          (bignumberError + 'Argument ' +\r\n            (n.isInteger() ? 'out of range: ' : 'not an integer: ') + valueOf(n));\r\n      }\r\n    }\r\n\r\n    if (!xc) return new BigNumber(x);\r\n\r\n    d = new BigNumber(ONE);\r\n    n1 = d0 = new BigNumber(ONE);\r\n    d1 = n0 = new BigNumber(ONE);\r\n    s = coeffToString(xc);\r\n\r\n    // Determine initial denominator.\r\n    // d is a power of 10 and the minimum max denominator that specifies the value exactly.\r\n    e = d.e = s.length - x.e - 1;\r\n    d.c[0] = POWS_TEN[(exp = e % LOG_BASE) < 0 ? LOG_BASE + exp : exp];\r\n    md = !md || n.comparedTo(d) > 0 ? (e > 0 ? d : n1) : n;\r\n\r\n    exp = MAX_EXP;\r\n    MAX_EXP = 1 / 0;\r\n    n = new BigNumber(s);\r\n\r\n    // n0 = d1 = 0\r\n    n0.c[0] = 0;\r\n\r\n    for (; ;)  {\r\n      q = div(n, d, 0, 1);\r\n      d2 = d0.plus(q.times(d1));\r\n      if (d2.comparedTo(md) == 1) break;\r\n      d0 = d1;\r\n      d1 = d2;\r\n      n1 = n0.plus(q.times(d2 = n1));\r\n      n0 = d2;\r\n      d = n.minus(q.times(d2 = d));\r\n      n = d2;\r\n    }\r\n\r\n    d2 = div(md.minus(d0), d1, 0, 1);\r\n    n0 = n0.plus(d2.times(n1));\r\n    d0 = d0.plus(d2.times(d1));\r\n    n0.s = n1.s = x.s;\r\n    e = e * 2;\r\n\r\n    // Determine which fraction is closer to x, n0/d0 or n1/d1\r\n    r = div(n1, d1, e, ROUNDING_MODE).minus(x).abs().comparedTo(\r\n        div(n0, d0, e, ROUNDING_MODE).minus(x).abs()) < 1 ? [n1, d1] : [n0, d0];\r\n\r\n    MAX_EXP = exp;\r\n\r\n    return r;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return the value of this BigNumber converted to a number primitive.\r\n   */\r\n  P.toNumber = function () {\r\n    return +valueOf(this);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of this BigNumber rounded to sd significant digits\r\n   * using rounding mode rm or ROUNDING_MODE. If sd is less than the number of digits\r\n   * necessary to represent the integer part of the value in fixed-point notation, then use\r\n   * exponential notation.\r\n   *\r\n   * [sd] {number} Significant digits. Integer, 1 to MAX inclusive.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}'\r\n   */\r\n  P.toPrecision = function (sd, rm) {\r\n    if (sd != null) intCheck(sd, 1, MAX);\r\n    return format(this, sd, rm, 2);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of this BigNumber in base b, or base 10 if b is\r\n   * omitted. If a base is specified, including base 10, round according to DECIMAL_PLACES and\r\n   * ROUNDING_MODE. If a base is not specified, and this BigNumber has a positive exponent\r\n   * that is equal to or greater than TO_EXP_POS, or a negative exponent equal to or less than\r\n   * TO_EXP_NEG, return exponential notation.\r\n   *\r\n   * [b] {number} Integer, 2 to ALPHABET.length inclusive.\r\n   *\r\n   * '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}'\r\n   */\r\n  P.toString = function (b) {\r\n    var str,\r\n      n = this,\r\n      s = n.s,\r\n      e = n.e;\r\n\r\n    // Infinity or NaN?\r\n    if (e === null) {\r\n      if (s) {\r\n        str = 'Infinity';\r\n        if (s < 0) str = '-' + str;\r\n      } else {\r\n        str = 'NaN';\r\n      }\r\n    } else {\r\n      if (b == null) {\r\n        str = e <= TO_EXP_NEG || e >= TO_EXP_POS\r\n         ? toExponential(coeffToString(n.c), e)\r\n         : toFixedPoint(coeffToString(n.c), e, '0');\r\n      } else if (b === 10 && alphabetHasNormalDecimalDigits) {\r\n        n = round(new BigNumber(n), DECIMAL_PLACES + e + 1, ROUNDING_MODE);\r\n        str = toFixedPoint(coeffToString(n.c), n.e, '0');\r\n      } else {\r\n        intCheck(b, 2, ALPHABET.length, 'Base');\r\n        str = convertBase(toFixedPoint(coeffToString(n.c), e, '0'), 10, b, s, true);\r\n      }\r\n\r\n      if (s < 0 && n.c[0]) str = '-' + str;\r\n    }\r\n\r\n    return str;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return as toString, but do not accept a base argument, and include the minus sign for\r\n   * negative zero.\r\n   */\r\n  P.valueOf = P.toJSON = function () {\r\n    return valueOf(this);\r\n  };\r\n\r\n\r\n  P._isBigNumber = true;\r\n\r\n  P[Symbol.toStringTag] = 'BigNumber';\r\n\r\n  // Node.js v10.12.0+\r\n  P[Symbol.for('nodejs.util.inspect.custom')] = P.valueOf;\r\n\r\n  if (configObject != null) BigNumber.set(configObject);\r\n\r\n  return BigNumber;\r\n}\r\n\r\n\r\n// PRIVATE HELPER FUNCTIONS\r\n\r\n// These functions don't need access to variables,\r\n// e.g. DECIMAL_PLACES, in the scope of the `clone` function above.\r\n\r\n\r\nfunction bitFloor(n) {\r\n  var i = n | 0;\r\n  return n > 0 || n === i ? i : i - 1;\r\n}\r\n\r\n\r\n// Return a coefficient array as a string of base 10 digits.\r\nfunction coeffToString(a) {\r\n  var s, z,\r\n    i = 1,\r\n    j = a.length,\r\n    r = a[0] + '';\r\n\r\n  for (; i < j;) {\r\n    s = a[i++] + '';\r\n    z = LOG_BASE - s.length;\r\n    for (; z--; s = '0' + s);\r\n    r += s;\r\n  }\r\n\r\n  // Determine trailing zeros.\r\n  for (j = r.length; r.charCodeAt(--j) === 48;);\r\n\r\n  return r.slice(0, j + 1 || 1);\r\n}\r\n\r\n\r\n// Compare the value of BigNumbers x and y.\r\nfunction compare(x, y) {\r\n  var a, b,\r\n    xc = x.c,\r\n    yc = y.c,\r\n    i = x.s,\r\n    j = y.s,\r\n    k = x.e,\r\n    l = y.e;\r\n\r\n  // Either NaN?\r\n  if (!i || !j) return null;\r\n\r\n  a = xc && !xc[0];\r\n  b = yc && !yc[0];\r\n\r\n  // Either zero?\r\n  if (a || b) return a ? b ? 0 : -j : i;\r\n\r\n  // Signs differ?\r\n  if (i != j) return i;\r\n\r\n  a = i < 0;\r\n  b = k == l;\r\n\r\n  // Either Infinity?\r\n  if (!xc || !yc) return b ? 0 : !xc ^ a ? 1 : -1;\r\n\r\n  // Compare exponents.\r\n  if (!b) return k > l ^ a ? 1 : -1;\r\n\r\n  j = (k = xc.length) < (l = yc.length) ? k : l;\r\n\r\n  // Compare digit by digit.\r\n  for (i = 0; i < j; i++) if (xc[i] != yc[i]) return xc[i] > yc[i] ^ a ? 1 : -1;\r\n\r\n  // Compare lengths.\r\n  return k == l ? 0 : k > l ^ a ? 1 : -1;\r\n}\r\n\r\n\r\n/*\r\n * Check that n is a primitive number, an integer, and in range, otherwise throw.\r\n */\r\nfunction intCheck(n, min, max, name) {\r\n  if (n < min || n > max || n !== mathfloor(n)) {\r\n    throw Error\r\n     (bignumberError + (name || 'Argument') + (typeof n == 'number'\r\n       ? n < min || n > max ? ' out of range: ' : ' not an integer: '\r\n       : ' not a primitive number: ') + String(n));\r\n  }\r\n}\r\n\r\n\r\n// Assumes finite n.\r\nfunction isOdd(n) {\r\n  var k = n.c.length - 1;\r\n  return bitFloor(n.e / LOG_BASE) == k && n.c[k] % 2 != 0;\r\n}\r\n\r\n\r\nfunction toExponential(str, e) {\r\n  return (str.length > 1 ? str.charAt(0) + '.' + str.slice(1) : str) +\r\n   (e < 0 ? 'e' : 'e+') + e;\r\n}\r\n\r\n\r\nfunction toFixedPoint(str, e, z) {\r\n  var len, zs;\r\n\r\n  // Negative exponent?\r\n  if (e < 0) {\r\n\r\n    // Prepend zeros.\r\n    for (zs = z + '.'; ++e; zs += z);\r\n    str = zs + str;\r\n\r\n  // Positive exponent\r\n  } else {\r\n    len = str.length;\r\n\r\n    // Append zeros.\r\n    if (++e > len) {\r\n      for (zs = z, e -= len; --e; zs += z);\r\n      str += zs;\r\n    } else if (e < len) {\r\n      str = str.slice(0, e) + '.' + str.slice(e);\r\n    }\r\n  }\r\n\r\n  return str;\r\n}\r\n\r\n\r\n// EXPORT\r\n\r\n\r\nexport var BigNumber = clone();\r\n\r\nexport default BigNumber;\r\n"],"names":["exports","toByteArray","b64","tmp","i","lens","len","length","Error","validLen","indexOf","getLens","placeHoldersLen","arr","Arr","_byteLength","curByte","revLookup","charCodeAt","fromByteArray","uint8","extraBytes","parts","maxChunkLength","len2","push","encodeChunk","lookup","join","Uint8Array","Array","code","tripletToBase64","num","start","end","output","sleep","time","Promise","res","setTimeout","randomToken","Math","random","toString","substring","lastMs","additional","microSeconds","ms","Date","getTime","isNode","Object","prototype","call","process","methods_native","create","channelName","state","messagesCallback","bc","BroadcastChannel","subFns","onmessage","msg","data","close","channelState","onMessage","fn","postMessage","messageJson","resolve","err","reject","canBeUsed","window","_pubkey","type","averageResponseTime","fillOptionsWithDefaults","originalOptions","arguments","undefined","options","JSON","parse","stringify","webWorkerSupport","idb","ttl","fallbackInterval","onclose","localstorage","removeTimeout","methods","node","useFastPath","OBJECT_STORE_ID","getIdb","indexedDB","mozIndexedDB","webkitIndexedDB","msIndexedDB","_readLoop","closed","readNewMessages","then","db","lastCursorId","objectStore","transaction","ret","keyRangeValue","IDBKeyRange","bound","Infinity","openCursor","e","onsuccess","ev","cursor","target","result","value","id","newerMessages","useMessages","filter","msgObj","map","uuid","eMIs","has","messagesCallbackTime","_filterMessage","sort","msgObjA","msgObjB","forEach","add","indexed_db","dbName","openRequest","open","onupgradeneeded","createObjectStore","keyPath","autoIncrement","rej","onerror","createDatabase","es","p4","writeBlockPromise","readQueuePromises","readerUuid","writeObject","oncomplete","writeMessage","floor","olderThen","msgObk","getOldMessages","tooOld","all","request","removeMessageById","getLocalStorage","localStorage","storageKey","localstorage_canBeUsed","ls","key","setItem","removeItem","listener","newValue","token","addEventListener","addStorageEventListener","removeEventListener","writeObj","document","createEvent","initEvent","dispatchEvent","userAgent","navigator","toLowerCase","includes","defaultTime","simulate_microSeconds","SIMULATE_CHANNELS","Set","simulate","name","from","channel","METHODS","NodeMethod","__webpack_require__","broadcast_channel_BroadcastChannel","maybePromise","obj","this","method","chooseMethods","concat","Boolean","find","m","useMethod","chooseMethod","_iL","_onML","_addEL","message","internal","_uMP","_befC","_prepP","s","_state","_post","broadcastChannel","sendPromise","_hasMessageListeners","_addListenerObject","listenerFn","_startListening","_removeListenerObject","o","_stopListening","postInternal","listenObj","_this","awaitPrepare","isClosed","base64","ieee754","customInspectSymbol","Symbol","hp","Buffer","IS","K_MAX_LENGTH","createBuffer","RangeError","buf","setPrototypeOf","arg","encodingOrOffset","TypeError","allocUnsafe","string","encoding","isEncoding","byteLength","actual","write","slice","fromString","ArrayBuffer","isView","arrayView","isInstance","copy","fromArrayBuffer","buffer","byteOffset","fromArrayLike","fromArrayView","SharedArrayBuffer","valueOf","b","isBuffer","checked","numberIsNaN","isArray","fromObject","toPrimitive","assertSize","size","array","mustMatch","loweredCase","utf8ToBytes","base64ToBytes","slowToString","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","n","bidirectionalIndexOf","val","dir","arrayIndexOf","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","min","firstByte","codePoint","bytesPerSequence","secondByte","thirdByte","fourthByte","tempCodePoint","codePoints","MAX_ARGUMENTS_LENGTH","fromCharCode","apply","decodeCodePointsArray","TYPED_ARRAY_SUPPORT","proto","foo","typedArraySupport","console","error","defineProperty","enumerable","get","poolSize","alloc","fill","allocUnsafeSlow","_isBuffer","compare","a","x","y","list","pos","set","swap16","swap32","swap64","toLocaleString","equals","inspect","max","replace","trim","thisStart","thisEnd","thisCopy","targetCopy","isFinite","toJSON","_arr","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","stack","addNumericalSeparator","range","ERR_OUT_OF_RANGE","checkBounds","ERR_INVALID_ARG_TYPE","ERR_BUFFER_OUT_OF_BOUNDS","input","received","isInteger","abs","INVALID_BASE64_RE","leadSurrogate","split","base64clean","src","dst","alphabet","table","i16","BufferBigIntNotDefined","isNumeric","mathceil","ceil","mathfloor","bignumberError","tooManyDigits","BASE","LOG_BASE","MAX_SAFE_INTEGER","POWS_TEN","SQRT_BASE","MAX","bitFloor","coeffToString","z","r","xc","yc","k","l","intCheck","isOdd","toExponential","charAt","toFixedPoint","zs","BigNumber","clone","configObject","div","convertBase","parseNumeric","pow2_53","random53bitInt","basePrefix","dotAfter","dotBefore","isInfinityOrNaN","whitespaceOrPlus","P","ONE","DECIMAL_PLACES","ROUNDING_MODE","TO_EXP_NEG","TO_EXP_POS","MIN_EXP","MAX_EXP","CRYPTO","MODULO_MODE","POW_PRECISION","FORMAT","prefix","groupSize","secondaryGroupSize","groupSeparator","decimalSeparator","fractionGroupSize","fractionGroupSeparator","suffix","ALPHABET","alphabetHasNormalDecimalDigits","v","caseChanged","isNum","_isBigNumber","test","search","round","DEBUG","toUpperCase","format","rm","c0","ne","maxOrMin","args","normalise","pop","sd","d","ni","rd","pows10","ROUND_UP","ROUND_DOWN","ROUND_CEIL","ROUND_FLOOR","ROUND_HALF_UP","ROUND_HALF_DOWN","ROUND_HALF_EVEN","ROUND_HALF_CEIL","ROUND_HALF_FLOOR","EUCLID","config","p","hasOwnProperty","crypto","getRandomValues","randomBytes","EXPONENTIAL_AT","RANGE","isBigNumber","maximum","minimum","dp","rand","Uint32Array","splice","sum","plus","decimal","toBaseOut","baseIn","baseOut","arrL","reverse","sign","callerIsToString","multiply","base","temp","xlo","xhi","carry","klo","khi","aL","bL","cmp","subtract","more","prod","prodL","q","qc","rem","remL","rem0","xi","xL","yc0","yL","yz","NaN","isNaN","p1","p2","absoluteValue","comparedTo","decimalPlaces","dividedBy","dividedToIntegerBy","idiv","exponentiatedBy","half","isModExp","nIsBig","nIsNeg","nIsOdd","mod","times","integerValue","isEqualTo","eq","isGreaterThan","gt","isGreaterThanOrEqualTo","gte","isLessThan","lt","isLessThanOrEqualTo","lte","isNegative","isPositive","isZero","minus","t","xLTy","xe","ye","modulo","multipliedBy","xcL","ycL","ylo","yhi","zc","sqrtBase","negated","precision","shiftedBy","squareRoot","sqrt","rep","toFixed","toFormat","g1","g2","intPart","fractionPart","isNeg","intDigits","RegExp","toFraction","md","d0","d1","d2","exp","n0","n1","toNumber","toPrecision","toStringTag","for","__webpack_exports__","A"],"sourceRoot":""}