{"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\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar 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\nvar 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    var arr = new Uint8Array(1)\n    var 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  var 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  var valueOf = value.valueOf && value.valueOf()\n  if (valueOf != null && valueOf !== value) {\n    return Buffer.from(valueOf, encodingOrOffset, length)\n  }\n\n  var 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(\n      value[Symbol.toPrimitive]('string'), encodingOrOffset, length\n    )\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  var length = byteLength(string, encoding) | 0\n  var buf = createBuffer(length)\n\n  var 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  var length = array.length < 0 ? 0 : checked(array.length) | 0\n  var buf = createBuffer(length)\n  for (var 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    var 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  var 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    var len = checked(obj.length) | 0\n    var 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  var x = a.length\n  var y = b.length\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    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  var 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  var buffer = Buffer.allocUnsafe(length)\n  var pos = 0\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i]\n    if (isInstance(buf, Uint8Array)) {\n      if (pos + buf.length > buffer.length) {\n        Buffer.from(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  var len = string.length\n  var mustMatch = (arguments.length > 2 && arguments[2] === true)\n  if (!mustMatch && len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var 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  var 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  var i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  var len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  var len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  var len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  var 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  var str = ''\n  var 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  var x = thisEnd - thisStart\n  var y = end - start\n  var len = Math.min(x, y)\n\n  var thisCopy = this.slice(thisStart, thisEnd)\n  var targetCopy = target.slice(start, end)\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\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  var indexSize = 1\n  var arrLength = arr.length\n  var 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  var i\n  if (dir) {\n    var 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      var found = true\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  var strLen = string.length\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; ++i) {\n    var 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  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var 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  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF)\n      ? 4\n      : (firstByte > 0xDF)\n          ? 3\n          : (firstByte > 0xBF)\n              ? 2\n              : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          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\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var 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  var res = ''\n  var 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  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; ++i) {\n    out += hexSliceLookupTable[buf[i]]\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  // If bytes.length is odd, the last 8 bits must be ignored (same as node.js)\n  for (var 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  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var 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  var val = this[offset]\n  var mul = 1\n  var 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  var val = this[offset + --byteLength]\n  var 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.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var 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  var i = byteLength\n  var mul = 1\n  var 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  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  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.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    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  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    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  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\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    var limit = Math.pow(2, (8 * byteLength) - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = 0\n  this[offset] = value & 0xFF\n  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    var limit = Math.pow(2, (8 * byteLength) - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = 0\n  this[offset + i] = value & 0xFF\n  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\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  var 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      var 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  var i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    var bytes = Buffer.isBuffer(val)\n      ? val\n      : Buffer.from(val, encoding)\n    var 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// HELPER FUNCTIONS\n// ================\n\nvar 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  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\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  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var 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  for (var i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  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\nvar hexSliceLookupTable = (function () {\n  var alphabet = '0123456789abcdef'\n  var table = new Array(256)\n  for (var i = 0; i < 16; ++i) {\n    var i16 = i * 16\n    for (var j = 0; j < 16; ++j) {\n      table[i16 + j] = alphabet[i] + alphabet[j]\n    }\n  }\n  return table\n})()\n","/*\r\n *      bignumber.js v9.1.1\r\n *      A JavaScript library for arbitrary-precision arithmetic.\r\n *      https://github.com/MikeMcl/bignumber.js\r\n *      Copyright (c) 2022 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, P.lt);\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, P.gt);\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;\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  function maxOrMin(args, method) {\r\n    var n,\r\n      i = 1,\r\n      m = new BigNumber(args[0]);\r\n\r\n    for (; i < args.length; i++) {\r\n      n = new BigNumber(args[i]);\r\n\r\n      // If any number is NaN, return NaN.\r\n      if (!n.s) {\r\n        m = n;\r\n        break;\r\n      } else if (method.call(m, n)) {\r\n        m = n;\r\n      }\r\n    }\r\n\r\n    return m;\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 = n / pows10[d - j - 1] % 10 | 0;\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 : n / pows10[d - j - 1] % 10 | 0;\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) t = xc, xc = yc, yc = t, y.s = -y.s;\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) zc = xc, xc = yc, yc = zc, i = xcL, xcL = ycL, ycL = i;\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) t = yc, yc = xc, xc = t, b = a;\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) i = g1, g1 = g2, g2 = i, len -= i;\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","byteLength","b64","lens","getLens","validLen","placeHoldersLen","toByteArray","tmp","i","arr","Arr","_byteLength","curByte","len","revLookup","charCodeAt","fromByteArray","uint8","length","extraBytes","parts","maxChunkLength","len2","push","encodeChunk","lookup","join","Uint8Array","Array","code","Error","indexOf","start","end","num","output","sleep","time","Promise","res","setTimeout","randomToken","Math","random","toString","substring","lastMs","additional","microSeconds","ms","Date","getTime","isNode","Object","prototype","call","process","create","channelName","state","messagesCallback","bc","BroadcastChannel","subFns","onmessage","msg","data","close","channelState","onMessage","fn","postMessage","messageJson","resolve","err","reject","canBeUsed","window","_pubkey","type","averageResponseTime","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","dbName","openRequest","open","onupgradeneeded","createObjectStore","keyPath","autoIncrement","rej","onerror","createDatabase","writeBlockPromise","readQueuePromises","readerUuid","writeObject","oncomplete","writeMessage","floor","olderThen","msgObk","getOldMessages","tooOld","all","request","removeMessageById","KEY_PREFIX","getLocalStorage","localStorage","storageKey","ls","key","setItem","removeItem","listener","newValue","token","addEventListener","addStorageEventListener","removeEventListener","writeObj","document","createEvent","initEvent","dispatchEvent","userAgent","navigator","toLowerCase","includes","defaultTime","SIMULATE_CHANNELS","Set","name","from","channel","METHODS","NodeMethod","maybePromise","obj","this","method","chooseMethods","concat","Boolean","find","m","useMethod","_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","Buffer","K_MAX_LENGTH","createBuffer","RangeError","buf","setPrototypeOf","arg","encodingOrOffset","TypeError","allocUnsafe","string","encoding","isEncoding","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","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","codePoint","bytesPerSequence","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","checkIEEE754","writeFloat","littleEndian","noAssert","writeDouble","newBuf","subarray","readUintLE","readUIntLE","mul","readUintBE","readUIntBE","readUint8","readUInt8","readUint16LE","readUInt16LE","readUint16BE","readUint32LE","readUInt32LE","readUint32BE","readUInt32BE","readIntLE","pow","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUintLE","writeUIntLE","writeUintBE","writeUIntBE","writeUint8","writeUInt8","writeUint16LE","writeUInt16LE","writeUint16BE","writeUInt16BE","writeUint32LE","writeUInt32LE","writeUint32BE","writeUInt32BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","copyWithin","INVALID_BASE64_RE","leadSurrogate","split","base64clean","src","dst","constructor","alphabet","table","i16","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","lt","minimum","gt","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","abs","comparedTo","decimalPlaces","dividedBy","dividedToIntegerBy","idiv","exponentiatedBy","half","isModExp","nIsBig","nIsNeg","nIsOdd","isInteger","mod","times","integerValue","isEqualTo","eq","isGreaterThan","isGreaterThanOrEqualTo","gte","isLessThan","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"],"sourceRoot":""}