{"version":3,"sources":["webpack://@ekliptor/prompt-cash/./node_modules/base64-js/index.js","webpack://@ekliptor/prompt-cash/./node_modules/bignumber.js/bignumber.js","webpack://@ekliptor/prompt-cash/./node_modules/buffer/index.js","webpack://@ekliptor/prompt-cash/./node_modules/debug/src/browser.js","webpack://@ekliptor/prompt-cash/./node_modules/debug/src/common.js","webpack://@ekliptor/prompt-cash/./node_modules/ieee754/index.js","webpack://@ekliptor/prompt-cash/./node_modules/ms/index.js","webpack://@ekliptor/prompt-cash/./node_modules/process/browser.js","webpack://@ekliptor/prompt-cash/webpack/bootstrap","webpack://@ekliptor/prompt-cash/./src/utils/WebHelpers.ts","webpack://@ekliptor/prompt-cash/./src/ui/AppMessage.ts","webpack://@ekliptor/prompt-cash/./src/utils/misc.ts","webpack://@ekliptor/prompt-cash/./src/AbstractPage.ts","webpack://@ekliptor/prompt-cash/external \"payjs\"","webpack://@ekliptor/prompt-cash/./src/bitcoin-cash/chain-utils.ts","webpack://@ekliptor/prompt-cash/./src/bitcoin-cash/BchdRest.ts","webpack://@ekliptor/prompt-cash/./src/utils/Log.ts","webpack://@ekliptor/prompt-cash/./src/bitcoin-cash/BitcoinCash.ts","webpack://@ekliptor/prompt-cash/./src/bitcoin-cash/ChainTools.ts","webpack://@ekliptor/prompt-cash/./src/bitcoin-cash/PromptRest.ts","webpack://@ekliptor/prompt-cash/./src/Merchant.ts","webpack://@ekliptor/prompt-cash/external \"ProgressBar\"","webpack://@ekliptor/prompt-cash/./src/structs/PaymentResponse.ts","webpack://@ekliptor/prompt-cash/./src/Pay.ts","webpack://@ekliptor/prompt-cash/./src/structs/TransferResponse.ts","webpack://@ekliptor/prompt-cash/./src/Transfer.ts","webpack://@ekliptor/prompt-cash/./src/Bridge.ts","webpack://@ekliptor/prompt-cash/./src/Localizer.ts","webpack://@ekliptor/prompt-cash/./index.ts","webpack://@ekliptor/prompt-cash/./src/JqueryApp.ts"],"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","globalObject","BigNumber","isNumeric","mathceil","Math","ceil","mathfloor","floor","bignumberError","tooManyDigits","BASE","LOG_BASE","MAX_SAFE_INTEGER","POWS_TEN","SQRT_BASE","MAX","bitFloor","n","coeffToString","a","s","z","j","r","slice","compare","x","y","b","xc","c","yc","k","e","l","intCheck","min","max","name","String","isOdd","toExponential","str","charAt","toFixedPoint","zs","clone","configObject","div","convertBase","parseNumeric","pow2_53","random53bitInt","basePrefix","dotAfter","dotBefore","isInfinityOrNaN","whitespaceOrPlus","P","prototype","constructor","toString","valueOf","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","v","alphabet","caseChanged","isNum","this","_isBigNumber","test","replace","search","substring","round","DEBUG","toUpperCase","toLowerCase","format","rm","id","c0","ne","maxOrMin","args","method","m","call","normalise","pop","sd","d","ni","rd","pows10","out","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","set","obj","p","hasOwnProperty","crypto","getRandomValues","randomBytes","EXPONENTIAL_AT","RANGE","isBigNumber","maximum","arguments","lt","minimum","gt","random","dp","rand","Uint32Array","copy","splice","sum","plus","decimal","toBaseOut","baseIn","baseOut","arrL","reverse","sign","callerIsToString","pow","concat","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","isFinite","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","split","g1","g2","intPart","fractionPart","isNeg","intDigits","substr","RegExp","toFraction","md","d0","d1","d2","exp","n0","n1","toNumber","toPrecision","toJSON","base64","ieee754","customInspectSymbol","Symbol","Buffer","SlowBuffer","alloc","INSPECT_MAX_BYTES","K_MAX_LENGTH","createBuffer","RangeError","buf","Object","setPrototypeOf","arg","encodingOrOffset","TypeError","allocUnsafe","from","value","string","encoding","isEncoding","actual","write","fromString","ArrayBuffer","isView","arrayView","isInstance","fromArrayBuffer","buffer","byteOffset","fromArrayLike","fromArrayView","SharedArrayBuffer","isBuffer","checked","undefined","numberIsNaN","type","isArray","data","fromObject","toPrimitive","assertSize","size","array","mustMatch","loweredCase","utf8ToBytes","base64ToBytes","slowToString","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","bidirectionalIndexOf","val","dir","arrayIndexOf","lastIndexOf","indexSize","arrLength","valLength","read","readUInt16BE","foundIndex","found","hexWrite","offset","Number","remaining","strLen","parsed","parseInt","utf8Write","blitBuffer","asciiWrite","byteArray","asciiToBytes","base64Write","ucs2Write","units","hi","lo","utf16leToBytes","res","firstByte","codePoint","bytesPerSequence","secondByte","thirdByte","fourthByte","tempCodePoint","codePoints","MAX_ARGUMENTS_LENGTH","fromCharCode","apply","decodeCodePointsArray","kMaxLength","TYPED_ARRAY_SUPPORT","proto","foo","typedArraySupport","console","error","defineProperty","enumerable","get","poolSize","fill","allocUnsafeSlow","_isBuffer","list","pos","swap16","swap32","swap64","toLocaleString","equals","inspect","trim","target","thisStart","thisEnd","thisCopy","targetCopy","includes","_arr","ret","hexSliceLookupTable","bytes","checkOffset","ext","checkInt","wrtBigUInt64LE","checkIntBI","BigInt","wrtBigUInt64BE","checkIEEE754","writeFloat","littleEndian","noAssert","writeDouble","newBuf","subarray","readUintLE","readUIntLE","mul","readUintBE","readUIntBE","readUint8","readUInt8","readUint16LE","readUInt16LE","readUint16BE","readUint32LE","readUInt32LE","readUint32BE","readUInt32BE","readBigUInt64LE","defineBigIntMethod","validateNumber","first","last","boundsError","readBigUInt64BE","readIntLE","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readBigInt64LE","readBigInt64BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUintLE","writeUIntLE","writeUintBE","writeUIntBE","writeUint8","writeUInt8","writeUint16LE","writeUInt16LE","writeUint16BE","writeUInt16BE","writeUint32LE","writeUInt32LE","writeUint32BE","writeUInt32BE","writeBigUInt64LE","writeBigUInt64BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeBigInt64LE","writeBigInt64BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","copyWithin","errors","E","sym","getMessage","Base","super","writable","configurable","stack","message","addNumericalSeparator","range","ERR_OUT_OF_RANGE","checkBounds","ERR_INVALID_ARG_TYPE","ERR_BUFFER_OUT_OF_BOUNDS","input","msg","received","INVALID_BASE64_RE","Infinity","leadSurrogate","base64clean","src","dst","table","i16","fn","BufferBigIntNotDefined","formatArgs","useColors","namespace","module","humanize","diff","color","index","lastC","match","save","namespaces","storage","setItem","removeItem","load","getItem","process","env","window","__nwjs","navigator","userAgent","document","documentElement","style","WebkitAppearance","firebug","exception","$1","localStorage","localstorage","destroy","warned","warn","colors","log","debug","formatters","JSON","stringify","createDebug","prevTime","enableOverride","enabled","self","curr","Date","ms","prev","coerce","unshift","formatter","selectColor","extend","init","delimiter","newDebug","toNamespace","regexp","default","disable","names","map","skips","enable","keys","forEach","key","hash","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","rt","LN2","h","plural","msAbs","isPlural","options","exec","parseFloat","parse","long","fmtShort","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","defaultClearTimeout","runTimeout","fun","setTimeout","clearTimeout","currentQueue","queue","draining","queueIndex","cleanUpNextTick","drainQueue","timeout","run","marker","runClearTimeout","Item","noop","nextTick","title","browser","argv","version","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","umask","__webpack_module_cache__","__webpack_require__","moduleId","__webpack_modules__","$","cssSelectors","setConfig","getConfig","getBrowserLang","language","getCookie","c_name","ARRcookies","cookie","decodeURI","setCookie","expireDays","date","getTime","cookieLifeDays","toUTCString","cookiePath","cookieHost","removeCookie","fromBase64","atob","toBase64","btoa","translate","text","variables","safeHtml","placeHolder","translation","tr","textPiece","escapeOutput","reg","convertNewlines","escapeRegex","isAppleIOS","MSStream","getAllCssSelectors","cached","originRegex","location","origin","styleSheets","sheet","href","rules","u","selectorText","imports","err","isExistingCssSelector","selector","selectors","addParamToUrl","urlStr","overwrite","queryParam","getApi","path","callback","dataType","url","fixRelativeUrl","textStatus","jqXHR","postApi","post","postJson","that","ajax","contentType","accepts","json","success","errorThrown","preloadImages","urls","image","createElement","alt","fullUrl","siteUrl","canDismiss","AppMessage","counter","display","append","toHtml","animate","scrollTop","locales","close","setJquery","setLocales","toDisplayTimeHHMMSS","secondsTotal","forceHours","hours","minutes","seconds","timeStr","app","webHelpers","getWebHelpers","payjs","fromSatoshis","sats","base64ToHex","upperCase","raw","result","hex","hexToBase64","reverseBytes","apiUrl","getTokenMeta","meta","tokenIdHex","tokenIdBase64","token_id","getAddressUnspentOutputs","address","includeSlpMeta","includeMempool","Promise","resolve","reject","include_mempool","include_token_metadata","then","catch","txt","getBchAddressUnspentOutputs","bchOutputs","outputs","filter","o","slp_token","sort","getSlpAddressUnspentOutputs","utxo","slpOutputs","is_mint_baton","batonOutputs","token_metadata","BchdRest","getAddressBalance","tokenID","readBchBalanceFromUtxo","readSlpTokenBalanceFromUtxo","submitTransaction","txHex","transaction","skip_slp_validity_check","txid","tx","curSats","amount","tokenMeta","type1","decimals","readTokenMetadata","fetch","body","logger","trace","verbose","info","NS_BASE","myPrivateKey","bchd","privateKey","hdPrivateKey","bitcore","deriveChild","getPrivateKey","getBchAddress","toAddress","getSlpAddress","bchaddrjs","getDerivedAddress","xpub","pubKey","hdPath","publicKey","getDerivedKey","xpriv","getBchBalance","getSlpBalance","slpAddress","importAddress","privateKeyHex","extractPrivateKey","wif","toWIF","signTransaction","to","cashAddress","signTransactionWithUtxo","txn","bchUtxo","bchdToBitcoreUtxo","rec","bchAddress","bch","change","signSlpTransaction","tokenAmount","slpUtxo","slpTotal","reduce","_","slpTo","slpMsg","addOutput","satoshis","script","cashAddr","getAddressUtxos","addressStr","bchdOutputs","curOut","outpoint","pubkey_script","bitcoreOut","txId","outputIndex","findUtxoForTransaction","minSats","apiBasePath","createAddress","params","cash_address","slp_address","headers","bitcoinCash","chainTools","PromptRest","apiBase","ChainTools","initPage","addEventListeners","balance","prop","event","toggleExpandButtonIcon","find","closeExpandButton","fadeToggle","fadeOut","hdPublicKey","xpubkey","confirm","confirmWalletBackup","currentXpub","top","preventDefault","withdrawFromWallet","checkbox","confirmSignatures","confirmSlpTokens","frame","attr","fadeIn","getTr","token","dataset","parentElement","pathUrlShortener","icon","hasClass","removeClass","addClass","button","form","$form","addressCount","withdrawnAmount","derivedHdKey","BitcoinCash","availableAmountBch","neededAmountRemaining","toWithdraw","receivers","withdrawalSuccess","updating","withdrawalFailed","AbstractPage","ProgressBar","fromJson","assign","PaymentResponse","generateMockPayment","status","tx_id","progressBarTimerID","remainingPaymentTimeSec","confirmationBarTimerID","lastConfirmationCount","confirmationExpectation","receivedAmount","checkLocalPaymentTimerID","askBackendTimerID","fullyPaid","confirming","retryCount","payment","successPayImage","successPayImageFinal","startPaymentTimer","addPaymentFormEvents","paymentFormEl","click","inputEl","parent","select","execCommand","timeRemainingSec","startTimeSec","now","checkPaymentStatusLocally","bind","checkMs","setTimedOut","bar","strokeWidth","easing","duration","trailColor","trailWidth","svgStyle","position","left","padding","margin","transform","getRemainingTimePercent","setInterval","clearInterval","setText","timeTotalSec","getRemainingConfirmationsPercent","confirmations_required","confirmations","rangeStep","blockTime","repeat","fullPage","showPaymentConfirming","scheduleLocalPaymentStatusCheck","showPaymentReceived","slp_token_id","address_slp","requestTokenID","previousAmount","askBackendForPayment","timeoutMs","pathPay","paid_amount_crypto","remaining_amount_crypto","numDecimals","qr_url","payment_link","maxRetryCount","scheduleAskBackendForPayment","amount_crypto","successImage","addSuccessImageProperties","showFinalPaidImage","replaceWith","sendPaidFrameMessage","targetOrigin","ref","postMessage","successImageFinal","returnUrl","maxWidth","maxHeight","width","className","TransferResponse","checkLocalTransferTimerID","confirmed","transfer","startTransferTimer","checkTransferStatusLocally","askBackendForTransfer","scheduleLocalTransferStatusCheck","pathTransfer","bridge","maxAmount","baseUrl","Localizer","DEFAULT_LANG","loadTranslations","langUrl","loadTranslationsFromObject","exportTranslationFunctionToWindow","getAll","setLang","lang","reload","jqApp","promptCfg","host","WebHelpers","localizer","pageType","getPageType","merchant","Merchant","pay","Pay","Transfer","Bridge","setupBoostrapFramework","tooltip","TEXT_FIELDS","jQuery","promptCash"],"mappings":"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","file":"bundle.js","sourcesContent":["'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\n// Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction getLens (b64) {\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n  var validLen = b64.indexOf('=')\n  if (validLen === -1) validLen = len\n\n  var placeHoldersLen = validLen === len\n    ? 0\n    : 4 - (validLen % 4)\n\n  return [validLen, placeHoldersLen]\n}\n\n// base64 is 4/3 + up to two characters of the original data\nfunction byteLength (b64) {\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction _byteLength (b64, validLen, placeHoldersLen) {\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction toByteArray (b64) {\n  var tmp\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\n\n  var curByte = 0\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  var len = placeHoldersLen > 0\n    ? validLen - 4\n    : validLen\n\n  var i\n  for (i = 0; i < len; i += 4) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 18) |\n      (revLookup[b64.charCodeAt(i + 1)] << 12) |\n      (revLookup[b64.charCodeAt(i + 2)] << 6) |\n      revLookup[b64.charCodeAt(i + 3)]\n    arr[curByte++] = (tmp >> 16) & 0xFF\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 2) |\n      (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 10) |\n      (revLookup[b64.charCodeAt(i + 1)] << 4) |\n      (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] +\n    lookup[num >> 12 & 0x3F] +\n    lookup[num >> 6 & 0x3F] +\n    lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp =\n      ((uint8[i] << 16) & 0xFF0000) +\n      ((uint8[i + 1] << 8) & 0xFF00) +\n      (uint8[i + 2] & 0xFF)\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 2] +\n      lookup[(tmp << 4) & 0x3F] +\n      '=='\n    )\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 10] +\n      lookup[(tmp >> 4) & 0x3F] +\n      lookup[(tmp << 2) & 0x3F] +\n      '='\n    )\n  }\n\n  return parts.join('')\n}\n",";(function (globalObject) {\r\n  'use strict';\r\n\r\n/*\r\n *      bignumber.js v9.0.1\r\n *      A JavaScript library for arbitrary-precision arithmetic.\r\n *      https://github.com/MikeMcl/bignumber.js\r\n *      Copyright (c) 2020 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\n  var BigNumber,\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\n  function 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\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) {\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              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 ? 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) {\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    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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  BigNumber = clone();\r\n  BigNumber['default'] = BigNumber.BigNumber = BigNumber;\r\n\r\n  // AMD.\r\n  if (typeof define == 'function' && define.amd) {\r\n    define(function () { return BigNumber; });\r\n\r\n  // Node.js and other environments that support module.exports.\r\n  } else if (typeof module != 'undefined' && module.exports) {\r\n    module.exports = BigNumber;\r\n\r\n  // Browser.\r\n  } else {\r\n    if (!globalObject) {\r\n      globalObject = typeof self != 'undefined' && self ? self : window;\r\n    }\r\n\r\n    globalObject.BigNumber = BigNumber;\r\n  }\r\n})(this);\r\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <https://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nconst base64 = require('base64-js')\nconst ieee754 = require('ieee754')\nconst customInspectSymbol =\n  (typeof Symbol === 'function' && typeof Symbol['for'] === 'function') // eslint-disable-line dot-notation\n    ? Symbol['for']('nodejs.util.inspect.custom') // eslint-disable-line dot-notation\n    : null\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\nconst K_MAX_LENGTH = 0x7fffffff\nexports.kMaxLength = K_MAX_LENGTH\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Print warning and recommend using `buffer` v4.x which has an Object\n *               implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * We report that the browser does not support typed arrays if the are not subclassable\n * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`\n * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support\n * for __proto__ and has a buggy typed array implementation.\n */\nBuffer.TYPED_ARRAY_SUPPORT = typedArraySupport()\n\nif (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&\n    typeof console.error === 'function') {\n  console.error(\n    'This browser lacks typed array (Uint8Array) support which is required by ' +\n    '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'\n  )\n}\n\nfunction typedArraySupport () {\n  // Can typed array instances can be augmented?\n  try {\n    const arr = new Uint8Array(1)\n    const proto = { foo: function () { return 42 } }\n    Object.setPrototypeOf(proto, Uint8Array.prototype)\n    Object.setPrototypeOf(arr, proto)\n    return arr.foo() === 42\n  } catch (e) {\n    return false\n  }\n}\n\nObject.defineProperty(Buffer.prototype, 'parent', {\n  enumerable: true,\n  get: function () {\n    if (!Buffer.isBuffer(this)) return undefined\n    return this.buffer\n  }\n})\n\nObject.defineProperty(Buffer.prototype, 'offset', {\n  enumerable: true,\n  get: function () {\n    if (!Buffer.isBuffer(this)) return undefined\n    return this.byteOffset\n  }\n})\n\nfunction createBuffer (length) {\n  if (length > K_MAX_LENGTH) {\n    throw new RangeError('The value \"' + length + '\" is invalid for option \"size\"')\n  }\n  // Return an augmented `Uint8Array` instance\n  const buf = new Uint8Array(length)\n  Object.setPrototypeOf(buf, Buffer.prototype)\n  return buf\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new TypeError(\n        'The \"string\" argument must be of type string. Received type number'\n      )\n    }\n    return allocUnsafe(arg)\n  }\n  return from(arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\nfunction from (value, encodingOrOffset, length) {\n  if (typeof value === 'string') {\n    return fromString(value, encodingOrOffset)\n  }\n\n  if (ArrayBuffer.isView(value)) {\n    return fromArrayView(value)\n  }\n\n  if (value == null) {\n    throw new TypeError(\n      'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\n      'or Array-like Object. Received type ' + (typeof value)\n    )\n  }\n\n  if (isInstance(value, ArrayBuffer) ||\n      (value && isInstance(value.buffer, ArrayBuffer))) {\n    return fromArrayBuffer(value, encodingOrOffset, length)\n  }\n\n  if (typeof SharedArrayBuffer !== 'undefined' &&\n      (isInstance(value, SharedArrayBuffer) ||\n      (value && isInstance(value.buffer, SharedArrayBuffer)))) {\n    return fromArrayBuffer(value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'number') {\n    throw new TypeError(\n      'The \"value\" argument must not be of type number. Received type number'\n    )\n  }\n\n  const valueOf = value.valueOf && value.valueOf()\n  if (valueOf != null && valueOf !== value) {\n    return Buffer.from(valueOf, encodingOrOffset, length)\n  }\n\n  const b = fromObject(value)\n  if (b) return b\n\n  if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&\n      typeof value[Symbol.toPrimitive] === 'function') {\n    return Buffer.from(value[Symbol.toPrimitive]('string'), encodingOrOffset, length)\n  }\n\n  throw new TypeError(\n    'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\n    'or Array-like Object. Received type ' + (typeof value)\n  )\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(value, encodingOrOffset, length)\n}\n\n// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:\n// https://github.com/feross/buffer/pull/148\nObject.setPrototypeOf(Buffer.prototype, Uint8Array.prototype)\nObject.setPrototypeOf(Buffer, Uint8Array)\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be of type number')\n  } else if (size < 0) {\n    throw new RangeError('The value \"' + size + '\" is invalid for option \"size\"')\n  }\n}\n\nfunction alloc (size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpreted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(size).fill(fill, encoding)\n      : createBuffer(size).fill(fill)\n  }\n  return createBuffer(size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(size, fill, encoding)\n}\n\nfunction allocUnsafe (size) {\n  assertSize(size)\n  return createBuffer(size < 0 ? 0 : checked(size) | 0)\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(size)\n}\n\nfunction fromString (string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('Unknown encoding: ' + encoding)\n  }\n\n  const length = byteLength(string, encoding) | 0\n  let buf = createBuffer(length)\n\n  const actual = buf.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    buf = buf.slice(0, actual)\n  }\n\n  return buf\n}\n\nfunction fromArrayLike (array) {\n  const length = array.length < 0 ? 0 : checked(array.length) | 0\n  const buf = createBuffer(length)\n  for (let i = 0; i < length; i += 1) {\n    buf[i] = array[i] & 255\n  }\n  return buf\n}\n\nfunction fromArrayView (arrayView) {\n  if (isInstance(arrayView, Uint8Array)) {\n    const copy = new Uint8Array(arrayView)\n    return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength)\n  }\n  return fromArrayLike(arrayView)\n}\n\nfunction fromArrayBuffer (array, byteOffset, length) {\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\"offset\" is outside of buffer bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\"length\" is outside of buffer bounds')\n  }\n\n  let buf\n  if (byteOffset === undefined && length === undefined) {\n    buf = new Uint8Array(array)\n  } else if (length === undefined) {\n    buf = new Uint8Array(array, byteOffset)\n  } else {\n    buf = new Uint8Array(array, byteOffset, length)\n  }\n\n  // Return an augmented `Uint8Array` instance\n  Object.setPrototypeOf(buf, Buffer.prototype)\n\n  return buf\n}\n\nfunction fromObject (obj) {\n  if (Buffer.isBuffer(obj)) {\n    const len = checked(obj.length) | 0\n    const buf = createBuffer(len)\n\n    if (buf.length === 0) {\n      return buf\n    }\n\n    obj.copy(buf, 0, 0, len)\n    return buf\n  }\n\n  if (obj.length !== undefined) {\n    if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {\n      return createBuffer(0)\n    }\n    return fromArrayLike(obj)\n  }\n\n  if (obj.type === 'Buffer' && Array.isArray(obj.data)) {\n    return fromArrayLike(obj.data)\n  }\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < K_MAX_LENGTH` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= K_MAX_LENGTH) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return b != null && b._isBuffer === true &&\n    b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false\n}\n\nBuffer.compare = function compare (a, b) {\n  if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)\n  if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError(\n      'The \"buf1\", \"buf2\" arguments must be one of type Buffer or Uint8Array'\n    )\n  }\n\n  if (a === b) return 0\n\n  let x = a.length\n  let y = b.length\n\n  for (let i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!Array.isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  let i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  const buffer = Buffer.allocUnsafe(length)\n  let pos = 0\n  for (i = 0; i < list.length; ++i) {\n    let buf = list[i]\n    if (isInstance(buf, Uint8Array)) {\n      if (pos + buf.length > buffer.length) {\n        if (!Buffer.isBuffer(buf)) buf = Buffer.from(buf)\n        buf.copy(buffer, pos)\n      } else {\n        Uint8Array.prototype.set.call(\n          buffer,\n          buf,\n          pos\n        )\n      }\n    } else if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    } else {\n      buf.copy(buffer, pos)\n    }\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length\n  }\n  if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    throw new TypeError(\n      'The \"string\" argument must be one of type string, Buffer, or ArrayBuffer. ' +\n      'Received type ' + typeof string\n    )\n  }\n\n  const len = string.length\n  const mustMatch = (arguments.length > 2 && arguments[2] === true)\n  if (!mustMatch && len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  let loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) {\n          return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8\n        }\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  let loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coercion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)\n// to detect a Buffer instance. It's not possible to use `instanceof Buffer`\n// reliably in a browserify context because there could be multiple different\n// copies of the 'buffer' package in use. This method works even for Buffer\n// instances that were created from another copy of the `buffer` package.\n// See: https://github.com/feross/buffer/issues/154\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  const i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  const len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (let i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  const len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (let i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  const len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (let i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  const length = this.length\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.toLocaleString = Buffer.prototype.toString\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  let str = ''\n  const max = exports.INSPECT_MAX_BYTES\n  str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()\n  if (this.length > max) str += ' ... '\n  return '<Buffer ' + str + '>'\n}\nif (customInspectSymbol) {\n  Buffer.prototype[customInspectSymbol] = Buffer.prototype.inspect\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (isInstance(target, Uint8Array)) {\n    target = Buffer.from(target, target.offset, target.byteLength)\n  }\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError(\n      'The \"target\" argument must be one of type Buffer or Uint8Array. ' +\n      'Received type ' + (typeof target)\n    )\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  let x = thisEnd - thisStart\n  let y = end - start\n  const len = Math.min(x, y)\n\n  const thisCopy = this.slice(thisStart, thisEnd)\n  const targetCopy = target.slice(start, end)\n\n  for (let i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset // Coerce to Number.\n  if (numberIsNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [val], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  let indexSize = 1\n  let arrLength = arr.length\n  let valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  let i\n  if (dir) {\n    let foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      let found = true\n      for (let j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  const remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  const strLen = string.length\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  let i\n  for (i = 0; i < length; ++i) {\n    const parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (numberIsNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset >>> 0\n    if (isFinite(length)) {\n      length = length >>> 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  const remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  let loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return asciiWrite(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  const res = []\n\n  let i = start\n  while (i < end) {\n    const firstByte = buf[i]\n    let codePoint = null\n    let bytesPerSequence = (firstByte > 0xEF)\n      ? 4\n      : (firstByte > 0xDF)\n          ? 3\n          : (firstByte > 0xBF)\n              ? 2\n              : 1\n\n    if (i + bytesPerSequence <= end) {\n      let secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nconst MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  const len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  let res = ''\n  let i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  let ret = ''\n  end = Math.min(buf.length, end)\n\n  for (let i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  let ret = ''\n  end = Math.min(buf.length, end)\n\n  for (let i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  const len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  let out = ''\n  for (let i = start; i < end; ++i) {\n    out += hexSliceLookupTable[buf[i]]\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  const bytes = buf.slice(start, end)\n  let res = ''\n  // If bytes.length is odd, the last 8 bits must be ignored (same as node.js)\n  for (let i = 0; i < bytes.length - 1; i += 2) {\n    res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256))\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  const len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  const newBuf = this.subarray(start, end)\n  // Return an augmented `Uint8Array` instance\n  Object.setPrototypeOf(newBuf, Buffer.prototype)\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUintLE =\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  let val = this[offset]\n  let mul = 1\n  let i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUintBE =\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  let val = this[offset + --byteLength]\n  let mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUint8 =\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUint16LE =\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUint16BE =\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUint32LE =\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUint32BE =\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE (offset) {\n  offset = offset >>> 0\n  validateNumber(offset, 'offset')\n  const first = this[offset]\n  const last = this[offset + 7]\n  if (first === undefined || last === undefined) {\n    boundsError(offset, this.length - 8)\n  }\n\n  const lo = first +\n    this[++offset] * 2 ** 8 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 24\n\n  const hi = this[++offset] +\n    this[++offset] * 2 ** 8 +\n    this[++offset] * 2 ** 16 +\n    last * 2 ** 24\n\n  return BigInt(lo) + (BigInt(hi) << BigInt(32))\n})\n\nBuffer.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE (offset) {\n  offset = offset >>> 0\n  validateNumber(offset, 'offset')\n  const first = this[offset]\n  const last = this[offset + 7]\n  if (first === undefined || last === undefined) {\n    boundsError(offset, this.length - 8)\n  }\n\n  const hi = first * 2 ** 24 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 8 +\n    this[++offset]\n\n  const lo = this[++offset] * 2 ** 24 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 8 +\n    last\n\n  return (BigInt(hi) << BigInt(32)) + BigInt(lo)\n})\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  let val = this[offset]\n  let mul = 1\n  let i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  let i = byteLength\n  let mul = 1\n  let val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  const val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  const val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE (offset) {\n  offset = offset >>> 0\n  validateNumber(offset, 'offset')\n  const first = this[offset]\n  const last = this[offset + 7]\n  if (first === undefined || last === undefined) {\n    boundsError(offset, this.length - 8)\n  }\n\n  const val = this[offset + 4] +\n    this[offset + 5] * 2 ** 8 +\n    this[offset + 6] * 2 ** 16 +\n    (last << 24) // Overflow\n\n  return (BigInt(val) << BigInt(32)) +\n    BigInt(first +\n    this[++offset] * 2 ** 8 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 24)\n})\n\nBuffer.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE (offset) {\n  offset = offset >>> 0\n  validateNumber(offset, 'offset')\n  const first = this[offset]\n  const last = this[offset + 7]\n  if (first === undefined || last === undefined) {\n    boundsError(offset, this.length - 8)\n  }\n\n  const val = (first << 24) + // Overflow\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 8 +\n    this[++offset]\n\n  return (BigInt(val) << BigInt(32)) +\n    BigInt(this[++offset] * 2 ** 24 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 8 +\n    last)\n})\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUintLE =\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) {\n    const maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  let mul = 1\n  let i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUintBE =\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) {\n    const maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  let i = byteLength - 1\n  let mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUint8 =\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeUint16LE =\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\n  return offset + 2\n}\n\nBuffer.prototype.writeUint16BE =\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  this[offset] = (value >>> 8)\n  this[offset + 1] = (value & 0xff)\n  return offset + 2\n}\n\nBuffer.prototype.writeUint32LE =\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  this[offset + 3] = (value >>> 24)\n  this[offset + 2] = (value >>> 16)\n  this[offset + 1] = (value >>> 8)\n  this[offset] = (value & 0xff)\n  return offset + 4\n}\n\nBuffer.prototype.writeUint32BE =\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  this[offset] = (value >>> 24)\n  this[offset + 1] = (value >>> 16)\n  this[offset + 2] = (value >>> 8)\n  this[offset + 3] = (value & 0xff)\n  return offset + 4\n}\n\nfunction wrtBigUInt64LE (buf, value, offset, min, max) {\n  checkIntBI(value, min, max, buf, offset, 7)\n\n  let lo = Number(value & BigInt(0xffffffff))\n  buf[offset++] = lo\n  lo = lo >> 8\n  buf[offset++] = lo\n  lo = lo >> 8\n  buf[offset++] = lo\n  lo = lo >> 8\n  buf[offset++] = lo\n  let hi = Number(value >> BigInt(32) & BigInt(0xffffffff))\n  buf[offset++] = hi\n  hi = hi >> 8\n  buf[offset++] = hi\n  hi = hi >> 8\n  buf[offset++] = hi\n  hi = hi >> 8\n  buf[offset++] = hi\n  return offset\n}\n\nfunction wrtBigUInt64BE (buf, value, offset, min, max) {\n  checkIntBI(value, min, max, buf, offset, 7)\n\n  let lo = Number(value & BigInt(0xffffffff))\n  buf[offset + 7] = lo\n  lo = lo >> 8\n  buf[offset + 6] = lo\n  lo = lo >> 8\n  buf[offset + 5] = lo\n  lo = lo >> 8\n  buf[offset + 4] = lo\n  let hi = Number(value >> BigInt(32) & BigInt(0xffffffff))\n  buf[offset + 3] = hi\n  hi = hi >> 8\n  buf[offset + 2] = hi\n  hi = hi >> 8\n  buf[offset + 1] = hi\n  hi = hi >> 8\n  buf[offset] = hi\n  return offset + 8\n}\n\nBuffer.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE (value, offset = 0) {\n  return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt('0xffffffffffffffff'))\n})\n\nBuffer.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE (value, offset = 0) {\n  return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt('0xffffffffffffffff'))\n})\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    const limit = Math.pow(2, (8 * byteLength) - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  let i = 0\n  let mul = 1\n  let sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    const limit = Math.pow(2, (8 * byteLength) - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  let i = byteLength - 1\n  let mul = 1\n  let sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  this[offset] = (value >>> 8)\n  this[offset + 1] = (value & 0xff)\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\n  this[offset + 2] = (value >>> 16)\n  this[offset + 3] = (value >>> 24)\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  this[offset] = (value >>> 24)\n  this[offset + 1] = (value >>> 16)\n  this[offset + 2] = (value >>> 8)\n  this[offset + 3] = (value & 0xff)\n  return offset + 4\n}\n\nBuffer.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE (value, offset = 0) {\n  return wrtBigUInt64LE(this, value, offset, -BigInt('0x8000000000000000'), BigInt('0x7fffffffffffffff'))\n})\n\nBuffer.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE (value, offset = 0) {\n  return wrtBigUInt64BE(this, value, offset, -BigInt('0x8000000000000000'), BigInt('0x7fffffffffffffff'))\n})\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('Index out of range')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  const len = end - start\n\n  if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {\n    // Use built-in when available, missing from IE11\n    this.copyWithin(targetStart, start, end)\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, end),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n    if (val.length === 1) {\n      const code = val.charCodeAt(0)\n      if ((encoding === 'utf8' && code < 128) ||\n          encoding === 'latin1') {\n        // Fast path: If `val` fits into a single byte, use that numeric value.\n        val = code\n      }\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  } else if (typeof val === 'boolean') {\n    val = Number(val)\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  let i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    const bytes = Buffer.isBuffer(val)\n      ? val\n      : Buffer.from(val, encoding)\n    const len = bytes.length\n    if (len === 0) {\n      throw new TypeError('The value \"' + val +\n        '\" is invalid for argument \"value\"')\n    }\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// CUSTOM ERRORS\n// =============\n\n// Simplified versions from Node, changed for Buffer-only usage\nconst errors = {}\nfunction E (sym, getMessage, Base) {\n  errors[sym] = class NodeError extends Base {\n    constructor () {\n      super()\n\n      Object.defineProperty(this, 'message', {\n        value: getMessage.apply(this, arguments),\n        writable: true,\n        configurable: true\n      })\n\n      // Add the error code to the name to include it in the stack trace.\n      this.name = `${this.name} [${sym}]`\n      // Access the stack to generate the error message including the error code\n      // from the name.\n      this.stack // eslint-disable-line no-unused-expressions\n      // Reset the name to the actual name.\n      delete this.name\n    }\n\n    get code () {\n      return sym\n    }\n\n    set code (value) {\n      Object.defineProperty(this, 'code', {\n        configurable: true,\n        enumerable: true,\n        value,\n        writable: true\n      })\n    }\n\n    toString () {\n      return `${this.name} [${sym}]: ${this.message}`\n    }\n  }\n}\n\nE('ERR_BUFFER_OUT_OF_BOUNDS',\n  function (name) {\n    if (name) {\n      return `${name} is outside of buffer bounds`\n    }\n\n    return 'Attempt to access memory outside buffer bounds'\n  }, RangeError)\nE('ERR_INVALID_ARG_TYPE',\n  function (name, actual) {\n    return `The \"${name}\" argument must be of type number. Received type ${typeof actual}`\n  }, TypeError)\nE('ERR_OUT_OF_RANGE',\n  function (str, range, input) {\n    let msg = `The value of \"${str}\" is out of range.`\n    let received = input\n    if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {\n      received = addNumericalSeparator(String(input))\n    } else if (typeof input === 'bigint') {\n      received = String(input)\n      if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) {\n        received = addNumericalSeparator(received)\n      }\n      received += 'n'\n    }\n    msg += ` It must be ${range}. Received ${received}`\n    return msg\n  }, RangeError)\n\nfunction addNumericalSeparator (val) {\n  let res = ''\n  let i = val.length\n  const start = val[0] === '-' ? 1 : 0\n  for (; i >= start + 4; i -= 3) {\n    res = `_${val.slice(i - 3, i)}${res}`\n  }\n  return `${val.slice(0, i)}${res}`\n}\n\n// CHECK FUNCTIONS\n// ===============\n\nfunction checkBounds (buf, offset, byteLength) {\n  validateNumber(offset, 'offset')\n  if (buf[offset] === undefined || buf[offset + byteLength] === undefined) {\n    boundsError(offset, buf.length - (byteLength + 1))\n  }\n}\n\nfunction checkIntBI (value, min, max, buf, offset, byteLength) {\n  if (value > max || value < min) {\n    const n = typeof min === 'bigint' ? 'n' : ''\n    let range\n    if (byteLength > 3) {\n      if (min === 0 || min === BigInt(0)) {\n        range = `>= 0${n} and < 2${n} ** ${(byteLength + 1) * 8}${n}`\n      } else {\n        range = `>= -(2${n} ** ${(byteLength + 1) * 8 - 1}${n}) and < 2 ** ` +\n                `${(byteLength + 1) * 8 - 1}${n}`\n      }\n    } else {\n      range = `>= ${min}${n} and <= ${max}${n}`\n    }\n    throw new errors.ERR_OUT_OF_RANGE('value', range, value)\n  }\n  checkBounds(buf, offset, byteLength)\n}\n\nfunction validateNumber (value, name) {\n  if (typeof value !== 'number') {\n    throw new errors.ERR_INVALID_ARG_TYPE(name, 'number', value)\n  }\n}\n\nfunction boundsError (value, length, type) {\n  if (Math.floor(value) !== value) {\n    validateNumber(value, type)\n    throw new errors.ERR_OUT_OF_RANGE(type || 'offset', 'an integer', value)\n  }\n\n  if (length < 0) {\n    throw new errors.ERR_BUFFER_OUT_OF_BOUNDS()\n  }\n\n  throw new errors.ERR_OUT_OF_RANGE(type || 'offset',\n                                    `>= ${type ? 1 : 0} and <= ${length}`,\n                                    value)\n}\n\n// HELPER FUNCTIONS\n// ================\n\nconst INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node takes equal signs as end of the Base64 encoding\n  str = str.split('=')[0]\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = str.trim().replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  let codePoint\n  const length = string.length\n  let leadSurrogate = null\n  const bytes = []\n\n  for (let i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  const byteArray = []\n  for (let i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  let c, hi, lo\n  const byteArray = []\n  for (let i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  let i\n  for (i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\n// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass\n// the `instanceof` check but they should be treated as of that type.\n// See: https://github.com/feross/buffer/issues/166\nfunction isInstance (obj, type) {\n  return obj instanceof type ||\n    (obj != null && obj.constructor != null && obj.constructor.name != null &&\n      obj.constructor.name === type.name)\n}\nfunction numberIsNaN (obj) {\n  // For IE11 support\n  return obj !== obj // eslint-disable-line no-self-compare\n}\n\n// Create lookup table for `toString('hex')`\n// See: https://github.com/feross/buffer/issues/219\nconst hexSliceLookupTable = (function () {\n  const alphabet = '0123456789abcdef'\n  const table = new Array(256)\n  for (let i = 0; i < 16; ++i) {\n    const i16 = i * 16\n    for (let j = 0; j < 16; ++j) {\n      table[i16 + j] = alphabet[i] + alphabet[j]\n    }\n  }\n  return table\n})()\n\n// Return not function with Error if BigInt not supported\nfunction defineBigIntMethod (fn) {\n  return typeof BigInt === 'undefined' ? BufferBigIntNotDefined : fn\n}\n\nfunction BufferBigIntNotDefined () {\n  throw new Error('BigInt not supported')\n}\n","/* eslint-env browser */\n\n/**\n * This is the web browser implementation of `debug()`.\n */\n\nexports.formatArgs = formatArgs;\nexports.save = save;\nexports.load = load;\nexports.useColors = useColors;\nexports.storage = localstorage();\nexports.destroy = (() => {\n\tlet warned = false;\n\n\treturn () => {\n\t\tif (!warned) {\n\t\t\twarned = true;\n\t\t\tconsole.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');\n\t\t}\n\t};\n})();\n\n/**\n * Colors.\n */\n\nexports.colors = [\n\t'#0000CC',\n\t'#0000FF',\n\t'#0033CC',\n\t'#0033FF',\n\t'#0066CC',\n\t'#0066FF',\n\t'#0099CC',\n\t'#0099FF',\n\t'#00CC00',\n\t'#00CC33',\n\t'#00CC66',\n\t'#00CC99',\n\t'#00CCCC',\n\t'#00CCFF',\n\t'#3300CC',\n\t'#3300FF',\n\t'#3333CC',\n\t'#3333FF',\n\t'#3366CC',\n\t'#3366FF',\n\t'#3399CC',\n\t'#3399FF',\n\t'#33CC00',\n\t'#33CC33',\n\t'#33CC66',\n\t'#33CC99',\n\t'#33CCCC',\n\t'#33CCFF',\n\t'#6600CC',\n\t'#6600FF',\n\t'#6633CC',\n\t'#6633FF',\n\t'#66CC00',\n\t'#66CC33',\n\t'#9900CC',\n\t'#9900FF',\n\t'#9933CC',\n\t'#9933FF',\n\t'#99CC00',\n\t'#99CC33',\n\t'#CC0000',\n\t'#CC0033',\n\t'#CC0066',\n\t'#CC0099',\n\t'#CC00CC',\n\t'#CC00FF',\n\t'#CC3300',\n\t'#CC3333',\n\t'#CC3366',\n\t'#CC3399',\n\t'#CC33CC',\n\t'#CC33FF',\n\t'#CC6600',\n\t'#CC6633',\n\t'#CC9900',\n\t'#CC9933',\n\t'#CCCC00',\n\t'#CCCC33',\n\t'#FF0000',\n\t'#FF0033',\n\t'#FF0066',\n\t'#FF0099',\n\t'#FF00CC',\n\t'#FF00FF',\n\t'#FF3300',\n\t'#FF3333',\n\t'#FF3366',\n\t'#FF3399',\n\t'#FF33CC',\n\t'#FF33FF',\n\t'#FF6600',\n\t'#FF6633',\n\t'#FF9900',\n\t'#FF9933',\n\t'#FFCC00',\n\t'#FFCC33'\n];\n\n/**\n * Currently only WebKit-based Web Inspectors, Firefox >= v31,\n * and the Firebug extension (any Firefox version) are known\n * to support \"%c\" CSS customizations.\n *\n * TODO: add a `localStorage` variable to explicitly enable/disable colors\n */\n\n// eslint-disable-next-line complexity\nfunction useColors() {\n\t// NB: In an Electron preload script, document will be defined but not fully\n\t// initialized. Since we know we're in Chrome, we'll just detect this case\n\t// explicitly\n\tif (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {\n\t\treturn true;\n\t}\n\n\t// Internet Explorer and Edge do not support colors.\n\tif (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\\/(\\d+)/)) {\n\t\treturn false;\n\t}\n\n\t// Is webkit? http://stackoverflow.com/a/16459606/376773\n\t// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632\n\treturn (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||\n\t\t// Is firebug? http://stackoverflow.com/a/398120/376773\n\t\t(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||\n\t\t// Is firefox >= v31?\n\t\t// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages\n\t\t(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\\/(\\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||\n\t\t// Double check webkit in userAgent just in case we are in a worker\n\t\t(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\\/(\\d+)/));\n}\n\n/**\n * Colorize log arguments if enabled.\n *\n * @api public\n */\n\nfunction formatArgs(args) {\n\targs[0] = (this.useColors ? '%c' : '') +\n\t\tthis.namespace +\n\t\t(this.useColors ? ' %c' : ' ') +\n\t\targs[0] +\n\t\t(this.useColors ? '%c ' : ' ') +\n\t\t'+' + module.exports.humanize(this.diff);\n\n\tif (!this.useColors) {\n\t\treturn;\n\t}\n\n\tconst c = 'color: ' + this.color;\n\targs.splice(1, 0, c, 'color: inherit');\n\n\t// The final \"%c\" is somewhat tricky, because there could be other\n\t// arguments passed either before or after the %c, so we need to\n\t// figure out the correct index to insert the CSS into\n\tlet index = 0;\n\tlet lastC = 0;\n\targs[0].replace(/%[a-zA-Z%]/g, match => {\n\t\tif (match === '%%') {\n\t\t\treturn;\n\t\t}\n\t\tindex++;\n\t\tif (match === '%c') {\n\t\t\t// We only are interested in the *last* %c\n\t\t\t// (the user may have provided their own)\n\t\t\tlastC = index;\n\t\t}\n\t});\n\n\targs.splice(lastC, 0, c);\n}\n\n/**\n * Invokes `console.debug()` when available.\n * No-op when `console.debug` is not a \"function\".\n * If `console.debug` is not available, falls back\n * to `console.log`.\n *\n * @api public\n */\nexports.log = console.debug || console.log || (() => {});\n\n/**\n * Save `namespaces`.\n *\n * @param {String} namespaces\n * @api private\n */\nfunction save(namespaces) {\n\ttry {\n\t\tif (namespaces) {\n\t\t\texports.storage.setItem('debug', namespaces);\n\t\t} else {\n\t\t\texports.storage.removeItem('debug');\n\t\t}\n\t} catch (error) {\n\t\t// Swallow\n\t\t// XXX (@Qix-) should we be logging these?\n\t}\n}\n\n/**\n * Load `namespaces`.\n *\n * @return {String} returns the previously persisted debug modes\n * @api private\n */\nfunction load() {\n\tlet r;\n\ttry {\n\t\tr = exports.storage.getItem('debug');\n\t} catch (error) {\n\t\t// Swallow\n\t\t// XXX (@Qix-) should we be logging these?\n\t}\n\n\t// If debug isn't set in LS, and we're in Electron, try to load $DEBUG\n\tif (!r && typeof process !== 'undefined' && 'env' in process) {\n\t\tr = process.env.DEBUG;\n\t}\n\n\treturn r;\n}\n\n/**\n * Localstorage attempts to return the localstorage.\n *\n * This is necessary because safari throws\n * when a user disables cookies/localstorage\n * and you attempt to access it.\n *\n * @return {LocalStorage}\n * @api private\n */\n\nfunction localstorage() {\n\ttry {\n\t\t// TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context\n\t\t// The Browser also has localStorage in the global context.\n\t\treturn localStorage;\n\t} catch (error) {\n\t\t// Swallow\n\t\t// XXX (@Qix-) should we be logging these?\n\t}\n}\n\nmodule.exports = require('./common')(exports);\n\nconst {formatters} = module.exports;\n\n/**\n * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.\n */\n\nformatters.j = function (v) {\n\ttry {\n\t\treturn JSON.stringify(v);\n\t} catch (error) {\n\t\treturn '[UnexpectedJSONParseError]: ' + error.message;\n\t}\n};\n","\n/**\n * This is the common logic for both the Node.js and web browser\n * implementations of `debug()`.\n */\n\nfunction setup(env) {\n\tcreateDebug.debug = createDebug;\n\tcreateDebug.default = createDebug;\n\tcreateDebug.coerce = coerce;\n\tcreateDebug.disable = disable;\n\tcreateDebug.enable = enable;\n\tcreateDebug.enabled = enabled;\n\tcreateDebug.humanize = require('ms');\n\tcreateDebug.destroy = destroy;\n\n\tObject.keys(env).forEach(key => {\n\t\tcreateDebug[key] = env[key];\n\t});\n\n\t/**\n\t* The currently active debug mode names, and names to skip.\n\t*/\n\n\tcreateDebug.names = [];\n\tcreateDebug.skips = [];\n\n\t/**\n\t* Map of special \"%n\" handling functions, for the debug \"format\" argument.\n\t*\n\t* Valid key names are a single, lower or upper-case letter, i.e. \"n\" and \"N\".\n\t*/\n\tcreateDebug.formatters = {};\n\n\t/**\n\t* Selects a color for a debug namespace\n\t* @param {String} namespace The namespace string for the for the debug instance to be colored\n\t* @return {Number|String} An ANSI color code for the given namespace\n\t* @api private\n\t*/\n\tfunction selectColor(namespace) {\n\t\tlet hash = 0;\n\n\t\tfor (let i = 0; i < namespace.length; i++) {\n\t\t\thash = ((hash << 5) - hash) + namespace.charCodeAt(i);\n\t\t\thash |= 0; // Convert to 32bit integer\n\t\t}\n\n\t\treturn createDebug.colors[Math.abs(hash) % createDebug.colors.length];\n\t}\n\tcreateDebug.selectColor = selectColor;\n\n\t/**\n\t* Create a debugger with the given `namespace`.\n\t*\n\t* @param {String} namespace\n\t* @return {Function}\n\t* @api public\n\t*/\n\tfunction createDebug(namespace) {\n\t\tlet prevTime;\n\t\tlet enableOverride = null;\n\n\t\tfunction debug(...args) {\n\t\t\t// Disabled?\n\t\t\tif (!debug.enabled) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tconst self = debug;\n\n\t\t\t// Set `diff` timestamp\n\t\t\tconst curr = Number(new Date());\n\t\t\tconst ms = curr - (prevTime || curr);\n\t\t\tself.diff = ms;\n\t\t\tself.prev = prevTime;\n\t\t\tself.curr = curr;\n\t\t\tprevTime = curr;\n\n\t\t\targs[0] = createDebug.coerce(args[0]);\n\n\t\t\tif (typeof args[0] !== 'string') {\n\t\t\t\t// Anything else let's inspect with %O\n\t\t\t\targs.unshift('%O');\n\t\t\t}\n\n\t\t\t// Apply any `formatters` transformations\n\t\t\tlet index = 0;\n\t\t\targs[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {\n\t\t\t\t// If we encounter an escaped % then don't increase the array index\n\t\t\t\tif (match === '%%') {\n\t\t\t\t\treturn '%';\n\t\t\t\t}\n\t\t\t\tindex++;\n\t\t\t\tconst formatter = createDebug.formatters[format];\n\t\t\t\tif (typeof formatter === 'function') {\n\t\t\t\t\tconst val = args[index];\n\t\t\t\t\tmatch = formatter.call(self, val);\n\n\t\t\t\t\t// Now we need to remove `args[index]` since it's inlined in the `format`\n\t\t\t\t\targs.splice(index, 1);\n\t\t\t\t\tindex--;\n\t\t\t\t}\n\t\t\t\treturn match;\n\t\t\t});\n\n\t\t\t// Apply env-specific formatting (colors, etc.)\n\t\t\tcreateDebug.formatArgs.call(self, args);\n\n\t\t\tconst logFn = self.log || createDebug.log;\n\t\t\tlogFn.apply(self, args);\n\t\t}\n\n\t\tdebug.namespace = namespace;\n\t\tdebug.useColors = createDebug.useColors();\n\t\tdebug.color = createDebug.selectColor(namespace);\n\t\tdebug.extend = extend;\n\t\tdebug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release.\n\n\t\tObject.defineProperty(debug, 'enabled', {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: false,\n\t\t\tget: () => enableOverride === null ? createDebug.enabled(namespace) : enableOverride,\n\t\t\tset: v => {\n\t\t\t\tenableOverride = v;\n\t\t\t}\n\t\t});\n\n\t\t// Env-specific initialization logic for debug instances\n\t\tif (typeof createDebug.init === 'function') {\n\t\t\tcreateDebug.init(debug);\n\t\t}\n\n\t\treturn debug;\n\t}\n\n\tfunction extend(namespace, delimiter) {\n\t\tconst newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);\n\t\tnewDebug.log = this.log;\n\t\treturn newDebug;\n\t}\n\n\t/**\n\t* Enables a debug mode by namespaces. This can include modes\n\t* separated by a colon and wildcards.\n\t*\n\t* @param {String} namespaces\n\t* @api public\n\t*/\n\tfunction enable(namespaces) {\n\t\tcreateDebug.save(namespaces);\n\n\t\tcreateDebug.names = [];\n\t\tcreateDebug.skips = [];\n\n\t\tlet i;\n\t\tconst split = (typeof namespaces === 'string' ? namespaces : '').split(/[\\s,]+/);\n\t\tconst len = split.length;\n\n\t\tfor (i = 0; i < len; i++) {\n\t\t\tif (!split[i]) {\n\t\t\t\t// ignore empty strings\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tnamespaces = split[i].replace(/\\*/g, '.*?');\n\n\t\t\tif (namespaces[0] === '-') {\n\t\t\t\tcreateDebug.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));\n\t\t\t} else {\n\t\t\t\tcreateDebug.names.push(new RegExp('^' + namespaces + '$'));\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t* Disable debug output.\n\t*\n\t* @return {String} namespaces\n\t* @api public\n\t*/\n\tfunction disable() {\n\t\tconst namespaces = [\n\t\t\t...createDebug.names.map(toNamespace),\n\t\t\t...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace)\n\t\t].join(',');\n\t\tcreateDebug.enable('');\n\t\treturn namespaces;\n\t}\n\n\t/**\n\t* Returns true if the given mode name is enabled, false otherwise.\n\t*\n\t* @param {String} name\n\t* @return {Boolean}\n\t* @api public\n\t*/\n\tfunction enabled(name) {\n\t\tif (name[name.length - 1] === '*') {\n\t\t\treturn true;\n\t\t}\n\n\t\tlet i;\n\t\tlet len;\n\n\t\tfor (i = 0, len = createDebug.skips.length; i < len; i++) {\n\t\t\tif (createDebug.skips[i].test(name)) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\n\t\tfor (i = 0, len = createDebug.names.length; i < len; i++) {\n\t\t\tif (createDebug.names[i].test(name)) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\n\t\treturn false;\n\t}\n\n\t/**\n\t* Convert regexp to namespace\n\t*\n\t* @param {RegExp} regxep\n\t* @return {String} namespace\n\t* @api private\n\t*/\n\tfunction toNamespace(regexp) {\n\t\treturn regexp.toString()\n\t\t\t.substring(2, regexp.toString().length - 2)\n\t\t\t.replace(/\\.\\*\\?$/, '*');\n\t}\n\n\t/**\n\t* Coerce `val`.\n\t*\n\t* @param {Mixed} val\n\t* @return {Mixed}\n\t* @api private\n\t*/\n\tfunction coerce(val) {\n\t\tif (val instanceof Error) {\n\t\t\treturn val.stack || val.message;\n\t\t}\n\t\treturn val;\n\t}\n\n\t/**\n\t* XXX DO NOT USE. This is a temporary stub function.\n\t* XXX It WILL be removed in the next major release.\n\t*/\n\tfunction destroy() {\n\t\tconsole.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');\n\t}\n\n\tcreateDebug.enable(createDebug.load());\n\n\treturn createDebug;\n}\n\nmodule.exports = setup;\n","/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */\nexports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = ((value * c) - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","/**\n * Helpers.\n */\n\nvar s = 1000;\nvar m = s * 60;\nvar h = m * 60;\nvar d = h * 24;\nvar w = d * 7;\nvar y = d * 365.25;\n\n/**\n * Parse or format the given `val`.\n *\n * Options:\n *\n *  - `long` verbose formatting [false]\n *\n * @param {String|Number} val\n * @param {Object} [options]\n * @throws {Error} throw an error if val is not a non-empty string or a number\n * @return {String|Number}\n * @api public\n */\n\nmodule.exports = function(val, options) {\n  options = options || {};\n  var type = typeof val;\n  if (type === 'string' && val.length > 0) {\n    return parse(val);\n  } else if (type === 'number' && isFinite(val)) {\n    return options.long ? fmtLong(val) : fmtShort(val);\n  }\n  throw new Error(\n    'val is not a non-empty string or a valid number. val=' +\n      JSON.stringify(val)\n  );\n};\n\n/**\n * Parse the given `str` and return milliseconds.\n *\n * @param {String} str\n * @return {Number}\n * @api private\n */\n\nfunction parse(str) {\n  str = String(str);\n  if (str.length > 100) {\n    return;\n  }\n  var match = /^(-?(?:\\d+)?\\.?\\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(\n    str\n  );\n  if (!match) {\n    return;\n  }\n  var n = parseFloat(match[1]);\n  var type = (match[2] || 'ms').toLowerCase();\n  switch (type) {\n    case 'years':\n    case 'year':\n    case 'yrs':\n    case 'yr':\n    case 'y':\n      return n * y;\n    case 'weeks':\n    case 'week':\n    case 'w':\n      return n * w;\n    case 'days':\n    case 'day':\n    case 'd':\n      return n * d;\n    case 'hours':\n    case 'hour':\n    case 'hrs':\n    case 'hr':\n    case 'h':\n      return n * h;\n    case 'minutes':\n    case 'minute':\n    case 'mins':\n    case 'min':\n    case 'm':\n      return n * m;\n    case 'seconds':\n    case 'second':\n    case 'secs':\n    case 'sec':\n    case 's':\n      return n * s;\n    case 'milliseconds':\n    case 'millisecond':\n    case 'msecs':\n    case 'msec':\n    case 'ms':\n      return n;\n    default:\n      return undefined;\n  }\n}\n\n/**\n * Short format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtShort(ms) {\n  var msAbs = Math.abs(ms);\n  if (msAbs >= d) {\n    return Math.round(ms / d) + 'd';\n  }\n  if (msAbs >= h) {\n    return Math.round(ms / h) + 'h';\n  }\n  if (msAbs >= m) {\n    return Math.round(ms / m) + 'm';\n  }\n  if (msAbs >= s) {\n    return Math.round(ms / s) + 's';\n  }\n  return ms + 'ms';\n}\n\n/**\n * Long format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtLong(ms) {\n  var msAbs = Math.abs(ms);\n  if (msAbs >= d) {\n    return plural(ms, msAbs, d, 'day');\n  }\n  if (msAbs >= h) {\n    return plural(ms, msAbs, h, 'hour');\n  }\n  if (msAbs >= m) {\n    return plural(ms, msAbs, m, 'minute');\n  }\n  if (msAbs >= s) {\n    return plural(ms, msAbs, s, 'second');\n  }\n  return ms + ' ms';\n}\n\n/**\n * Pluralization helper.\n */\n\nfunction plural(ms, msAbs, n, name) {\n  var isPlural = msAbs >= n * 1.5;\n  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');\n}\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tif(__webpack_module_cache__[moduleId]) {\n\t\treturn __webpack_module_cache__[moduleId].exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","import {BrowserWindow} from \"../types\";\n\nexport interface WebHelpersConfig {\n    cookieLifeDays: number;\n    cookiePath: string;\n    cookieHost: string;\n    siteUrl: string;\n}\n\nexport class WebHelpers {\n    public readonly window: BrowserWindow;\n    public readonly $: JQueryStatic;\n\n    protected config: WebHelpersConfig;\n    protected cssSelectors: string[] = [];\n\n    constructor(window: BrowserWindow, $: JQueryStatic, config: WebHelpersConfig) {\n        this.window = window;\n        this.$ = $;\n        this.config = config;\n    }\n\n    public setConfig(config: WebHelpersConfig) {\n        this.config = config;\n    }\n\n    public getConfig(): WebHelpersConfig {\n        return this.config;\n    }\n\n    public getBrowserLang() {\n        return this.window.navigator.language.substr(0, 2).toLowerCase();\n    }\n\n    public getCookie(c_name: string) {\n        let i, x, y;\n        let ARRcookies = this.window.document.cookie.split(\";\");\n        for (i = 0; i < ARRcookies.length; i++)\n        {\n            x = ARRcookies[i].substr(0, ARRcookies[i].indexOf(\"=\"));\n            y = ARRcookies[i].substr(ARRcookies[i].indexOf(\"=\") + 1);\n            x = x.replace(/^\\s+|\\s+$/g,\"\");\n            if (x == c_name)\n                return decodeURI(y);\n        }\n        return null;\n    }\n\n    public setCookie(name: string, value: any, expireDays: number) {\n        let date = new Date();\n        date = new Date(date.getTime()+1000*60*60*24* (expireDays ? expireDays : this.config.cookieLifeDays));\n        //document.cookie = name + \"=\" + value + \"; expires=\" + date.toGMTString() + \"; path=\" + pageData.cookiePath + \"; domain=.\" + location.host;\n        // we must add \"domain\" key if server adds it or else there will be 2 different cookies\n        this.window.document.cookie = name + \"=\" + value + \"; expires=\" + date.toUTCString() + \"; path=\" + this.config.cookiePath + \"; domain=\" + this.config.cookieHost;\n    }\n\n    public removeCookie(name: string) {\n        //document.cookie = name + \"=; expires=Thu, 02 Jan 1970 00:00:00 UTC; path=\" + pageData.cookiePath + \"; domain=.\" + location.host;\n        this.window.document.cookie = name + \"=; expires=Thu, 02 Jan 1970 00:00:00 UTC; path=\" + this.config.cookiePath;\n    }\n\n    public fromBase64(data: string) {\n        if (typeof this.window.atob !== \"function\") {\n            this.window.console.error(\"Base64 decoding is not supported in your browser\");\n            return \"\";\n        }\n        return this.window.atob(data);\n    }\n\n    public toBase64(data: string) {\n        if (typeof this.window.btoa !== \"function\") {\n            this.window.console.error(\"Base64 encoding is not supported in your browser\");\n            return \"\";\n        }\n        return this.window.btoa(data);\n    }\n\n    /**\n     * Populate a html template\n     * @param text {String}: The html template (or just normal text with variables)\n     * @param variables {Object}: the key-value pairs with variables names and their content to be set in text\n     * @param safeHtml {boolean, default false}: don't escape html characters if set to true\n     * @returns {String} the translated html\n     */\n    public translate(text: string, variables: any, safeHtml: boolean = false) {\n        if (typeof text !== \"string\") {\n            try {\n                // @ts-ignore\n                text = text.toString();\n            }\n            catch (e) {\n                this.log(\"Text to translate is not a string\");\n                return text;\n            }\n        }\n        let start = 0, end = 0;\n        while ((start = text.indexOf(\"{\", start)) !== -1)\n        {\n            if (start > 0 && text.charAt(start-1) === \"\\\\\") { // escaped javascript code beginning\n                start++;\n                continue;\n            }\n            end = text.indexOf(\"}\", start);\n            if (end === -1) {\n                this.log(\"Can not find end position while translating HTML\");\n                break;\n            }\n            let placeHolder = text.substring(start+1, end);\n            let translation = null;\n            if (placeHolder.substring(0, 3) === \"tr:\") {\n                let key = placeHolder.substring(3);\n                //translation = this.tr(key.toUpperCase());\n                translation = this.tr(key);\n            }\n            else if (typeof variables === \"object\") {\n                let textPiece = variables[placeHolder];\n                if (typeof textPiece !== \"undefined\") {\n                    if (typeof safeHtml === \"boolean\" && safeHtml)\n                        translation = textPiece;\n                    else\n                        translation = this.escapeOutput(textPiece);\n                }\n            }\n            if (translation !== null) {\n                let reg = new RegExp(\"\\\\{\" + placeHolder + \"\\\\}\", \"g\");\n                text = text.replace(reg, translation);\n            }\n            else if (placeHolder.match(\"^[A-Za-z0-9_]+$\") !== null) {\n                this.log(\"No translation found for place holder: \" + placeHolder);\n                let reg = new RegExp(\"\\\\{\" + placeHolder + \"\\\\}\", \"g\");\n                text = text.replace(reg, \"MISSING: \" + this.escapeOutput(placeHolder));\n            }\n            else\n                start += placeHolder.length;\n        }\n        text = text.replace(/\\\\\\\\\\\\{/, \"{\");\n        return text;\n    }\n\n    public escapeOutput(text: string, convertNewlines: boolean = true) {\n        if (typeof text !== \"string\")\n            return text;\n        text = text.replace(/&/g, \"&amp;\").replace(/</g, \"&lt;\").replace(/>/g, \"&gt;\").replace(/\"/g, \"&quot;\").replace(/'/g, \"&#039;\");\n        if (typeof convertNewlines === \"undefined\" || convertNewlines === true)\n            text = text.replace(/\\r?\\n/g, \"<br>\");\n        return text;\n    }\n\n    public escapeRegex(str: string) {\n        return str.replace(/[\\-\\[\\]\\/\\{\\}\\(\\)\\*\\+\\?\\.\\\\\\^\\$\\|]/g, \"\\\\$&\");\n    }\n\n    public tr(key: string) {\n        //if (typeof language[key] === \"undefined\")\n        //return \"MISSING: \" + key;\n        //return language[key];\n        //return i18next.t(key) // will just print the key if it doesn't exist and debug is disabled\n        return key; // we don't have client-side translation support on this WP plugin yet. just return the key // TODO do we need this if we make our plugin use more ajax?\n    }\n\n    public log(args) {\n        if (//typeof pageData.debugLog !== \"boolean\" || pageData.debugLog === false || // TODO add in CashTipprConfig\n            typeof this.window.console !== \"object\" || typeof this.window.console.log !== \"function\")\n            return;\n        this.window.console.log(arguments);\n    }\n\n    public isAppleIOS() {\n        // https://stackoverflow.com/questions/9038625/detect-if-device-is-ios\n        return /iPad|iPhone|iPod/.test(this.window.navigator.userAgent) && !(this.window as any).MSStream;\n    }\n\n    public getAllCssSelectors(cached = true): string[] {\n        if (cached === true && this.cssSelectors.length !== 0)\n            return this.cssSelectors;\n\n        this.cssSelectors = [];\n        try {\n            const originRegex = new RegExp(\"^\" + this.escapeRegex(this.window.document.location.origin), \"i\");\n            for (let i = 0; i < this.window.document.styleSheets.length; i++)\n            {\n                const sheet: any = this.window.document.styleSheets[i];\n                if (sheet.href && originRegex.test(sheet.href) === false)\n                    continue; // can't access it\n                if (sheet.rules) {\n                    for (let u = 0; u < sheet.rules.length; u++)\n                    {\n                        if (sheet.rules[u].selectorText)\n                            this.cssSelectors.push(sheet.rules[u].selectorText);\n                    }\n                }\n                if (sheet.imports) {\n                    for (let x = 0; x < sheet.imports.length; x++)\n                    {\n                        for (let u = 0; u < sheet.imports[x].rules.length; u++)\n                        {\n                            if (sheet.imports[x].rules[u].selectorText)\n                                this.cssSelectors.push(sheet.imports[x].rules[u].selectorText);\n                        }\n                    }\n                }\n            }\n        }\n        catch (err) {\n            this.window.console.error(\"Error getting CSS selectors\", err);\n        }\n        return this.cssSelectors;\n    }\n\n    public isExistingCssSelector(selector: string): boolean {\n        const selectors = this.getAllCssSelectors();\n        for (let i = 0; i < selectors.length; i++)\n        {\n            if (selectors[i] === selector) // css props case insensitive, class names in HTML case sensitive\n                return true;\n        }\n        return false;\n    }\n\n    // ################################################################\n    // ###################### PRIVATE FUNCTIONS #######################\n\n    public addParamToUrl(urlStr: string, key: string, value: string = \"\", overwrite: boolean = false) {\n        if (!value)\n            value = \"1\";\n        let start = urlStr.indexOf('?');\n        if (start !== -1 && urlStr.indexOf(key + '=') !== -1) {\n            if (!overwrite)\n                return urlStr // param already exists\n            let search = this.escapeRegex(key + '=');\n            urlStr = urlStr.replace(new RegExp(search + '[^&]*(&|$)'), ''); // remove it and add it to the end of the url\n            urlStr = urlStr.replace(/(\\?|&)$/, '');\n        }\n        let queryParam = urlStr.indexOf('?') !== -1 ? '&' : '?';\n        return urlStr + queryParam + key + '=' + value;\n    }\n\n    public getApi(path: string, data?: any, callback?: (data: any, textStatus: string, jqXHR: JQueryXHR) => any, dataType?: string) {\n        if (typeof data === \"function\") {\n            callback = data;\n            data = null;\n        }\n        else if (data === undefined)\n            data = null;\n        let url = this.fixRelativeUrl(path);\n        return this.$.get(url, data, (data, textStatus, jqXHR) => {\n            callback(data, textStatus, jqXHR);\n        }, dataType);\n    }\n\n    public postApi(path: string, data?: any, callback?: (data: any, textStatus: string, jqXHR: JQueryXHR) => any, dataType?: string) {\n        let url = this.fixRelativeUrl(path);\n        return this.$.post(url, data, (data, textStatus, jqXHR) => {\n            callback(data, textStatus, jqXHR);\n        }, dataType);\n    }\n\n    public postJson(path: string, data?: any, callback?: (data: any, textStatus: string, jqXHR: JQueryXHR) => any, dataType?: string) {\n        let url = this.fixRelativeUrl(path);\n        const that = this;\n        return this.$.ajax(url, {\n            url: url,\n            //data: JSON.stringify(data),\n            contentType: \"application/json\",\n            accepts: {\n                json: \"application/json\",\n            },\n            method: \"POST\",\n            dataType: \"json\",\n            //xhrFields: {\n            //withCredentials: true\n            //},\n            success(data: any, textStatus: string, jqXHR: JQueryXHR): any {\n                callback(data, textStatus, jqXHR);\n            },\n            error(jqXHR: JQueryXHR, textStatus: string, errorThrown: string): any {\n                that.log([\"Error posting JSON \" + textStatus, errorThrown]);\n                callback(null, textStatus, jqXHR);\n            },\n        });\n    }\n\n    public preloadImages(...urls: string[]) {\n        // jQuery version: https://css-tricks.com/snippets/jquery/image-preloader/\n        // CSS version: https://web.dev/preload-responsive-images/#preload-overview\n        for (let i = 0; i < urls.length; i++)\n        {\n            let image = window.document.createElement(\"img\"); // or new Image()\n            image.alt = \"preload-\" + i;\n            image.src = urls[i];\n        }\n    }\n\n    // ################################################################\n    // ###################### PRIVATE FUNCTIONS #######################\n\n    protected fixRelativeUrl(url: string): string {\n        if (url.toLowerCase().indexOf(\"http\") === 0)\n            return url; // already a full url\n        let fullUrl = this.config.siteUrl;\n        if (url.length !== 0 && url[0] === \"/\" && fullUrl[fullUrl.length-1] === \"/\")\n            fullUrl = fullUrl.substr(0, fullUrl.length-1); // avoid duplicate //\n        fullUrl += url;\n        return fullUrl;\n    }\n}\n","\n// modelled after Bootstrap alerts\n\nexport type AppMessageType = \"primary\" | \"secondary\" | \"success\" | \"danger\" | \"warning\" | \"info\" | \"light\" | \"dark\";\n\nexport interface AppMsgLocales {\n    close: string;\n}\n\nexport class AppMessage {\n    protected static $: JQueryStatic = (window as any).$;\n    protected static locales: AppMsgLocales = {close: \"Close\"};\n\n    public readonly text: string;\n    public readonly type: AppMessageType;\n    public readonly canDismiss: boolean;\n    public readonly id: number;\n\n    protected static counter = 0;\n\n    constructor(text: string, type: AppMessageType, canDismiss: boolean = true) {\n        this.text = text;\n        this.type = type;\n        this.canDismiss = canDismiss;\n        this.id = ++AppMessage.counter;\n    }\n\n    public display(): void {\n        AppMessage.$(\"#app-messages\").append(this.toHtml());\n        AppMessage.$('html, body').animate({scrollTop: 0}, 260);\n    }\n\n    public toHtml(): string {\n        if (this.canDismiss === false) {\n            return `<div class=\"alert alert-${this.type}\" role=\"alert\">${this.text}</div>`;\n        }\n        return `<div class=\"alert alert-${this.type} alert-dismissible fade show\" role=\"alert\">${this.text}\n            <button type=\"button\" class=\"close\" data-dismiss=\"alert\" aria-label=\"${AppMessage.locales.close}\">\n                <span aria-hidden=\"true\">&times;</span>\n            </button>\n        </div>`;\n    }\n\n    public static setJquery($: JQueryStatic): void {\n        AppMessage.$ = $;\n    }\n\n    public static setLocales(locales: AppMsgLocales) {\n        AppMessage.locales = locales;\n    }\n\n    // ################################################################\n    // ###################### PRIVATE FUNCTIONS #######################\n\n}\n","export type DateInterval = \"year\" | \"quarter\" | \"month\" | \"week\" | \"day\" | \"hour\" | \"minute\" | \"second\";\n\nexport function fixUrlTrailingSlash(url: string): string {\n    url = url.trim();\n    if (url.length === 0 || url[url.length-1] === \"/\")\n        return url;\n    return url + \"/\";\n}\n\n/**\n * Adds the given units of interval to the date.\n * It returns a copy of the date, so the given date is not modified.\n * @param date\n * @param interval\n * @param units\n */\nexport function dateAdd(date: Date, interval: DateInterval, units: number): Date {\n    let ret = new Date(date); //don't change original date\n    switch (interval.toLowerCase()) {\n        case 'year'   :  ret.setFullYear(ret.getFullYear() + units);  \tbreak;\n        case 'quarter':  ret.setMonth(ret.getMonth() + 3*units);  \t\tbreak;\n        case 'month'  :  ret.setMonth(ret.getMonth() + units);  \t\t    break;\n        case 'week'   :  ret.setDate(ret.getDate() + 7*units);  \t\t        break;\n        case 'day'    :  ret.setDate(ret.getDate() + units);  \t\t\t        break;\n        case 'hour'   :  ret.setTime(ret.getTime() + units*3600000);  \t        break;\n        case 'minute' :  ret.setTime(ret.getTime() + units*60000);  \t        break;\n        case 'second' :  ret.setTime(ret.getTime() + units*1000);  \t\t        break;\n        default       :  ret = undefined;  break;\n    }\n    return ret;\n}\n\nexport function assertUnreachableCode(x: never): never {\n    throw new Error(\"Unexpected object: \" + x);\n}\n\nexport function toDisplayTimeHHMMSS(secondsTotal: number, forceHours: boolean = false): string {\n    const hours = Math.floor(secondsTotal / 3600);\n    const minutes = Math.floor((secondsTotal - (hours * 3600)) / 60);\n    const seconds = secondsTotal - (hours * 3600) - (minutes * 60);\n\n    let timeStr = \"\";\n    if (hours !== 0 || forceHours === true) {\n        if (hours < 10)\n            timeStr += \"0\";\n        timeStr += hours + \":\";\n    }\n    if (minutes < 10)\n        timeStr += \"0\";\n    timeStr += minutes + \":\";\n    if (seconds < 10)\n        timeStr += \"0\";\n    timeStr += seconds;\n    return timeStr;\n}\n","import {JqueryApp} from \"./JqueryApp\";\nimport {WebHelpers} from \"./utils/WebHelpers\";\n\n\nexport class AbstractPage {\n    protected app: JqueryApp;\n    protected webHelpers: WebHelpers;\n\n    constructor(app: JqueryApp) {\n        this.app = app;\n        this.webHelpers = this.app.getWebHelpers();\n    }\n\n    // ################################################################\n    // ###################### PRIVATE FUNCTIONS #######################\n}\n","const __WEBPACK_NAMESPACE_OBJECT__ = payjs;","\nexport function toSatoshis(bch: number): number {\n    return Math.floor(bch * 100000000);\n}\n\nexport function fromSatoshis(sats: number): number {\n    return sats / 100000000.0;\n}\n\nexport function base64ToHex(base64: string, upperCase: boolean = false): string {\n    const raw = atob(base64);\n    let result = '';\n    for (let i = 0; i < raw.length; i++) {\n        const hex = raw.charCodeAt(i).toString(16);\n        result += (hex.length === 2 ? hex : '0' + hex);\n    }\n    return upperCase === true ? result.toUpperCase() : result;\n}\n\nexport function hexToBase64(hex: string): string {\n    return btoa(\n        String.fromCharCode(\n            ...hex\n                .match(/.{2}/g)\n                .map(c => parseInt(c, 16))\n        )\n    );\n}\n\nexport function reverseBytes(buffer: string): string {\n    let bytes = buffer.match(/[a-fA-F0-9]{2}/g);\n    if (bytes === null)\n        throw new Error(\"Can not reverse bytes of invalid buffer: \" + buffer);\n    return bytes.reverse().join('');\n}\n","import {hexToBase64, base64ToHex, reverseBytes, fromSatoshis} from \"./chain-utils\";\n\nexport const DUST_LIMIT = 546;\nexport const MIN_FEE = 1000; // BCHD doesn't broadcast TX that are below this\n\nexport interface BchdRestOutput {\n    outpoint: {\n        hash: string; // bas64 string\n        index: number;\n    },\n    pubkey_script: string; // bas64 string\n    value: string; // integer as string = sats\n    is_coinbase: boolean;\n    block_height: number;\n    slp_token?: {\n        token_id: string; // bas64 string\n        amount: string; // integer as string\n        is_mint_baton: boolean;\n        address: string;\n        decimals: number;\n        slp_action: string; // NON_SLP\n        token_type: number\n    }\n}\nexport interface BchdTokenMetadata {\n    token_id: string; // bas64 string\n    token_type: number;\n    type1?: SlpTokenMeta;\n    nft1_group?: SlpTokenMeta;\n    nft1_child?: SlpChildTokenMeta;\n}\nexport interface SlpTokenMeta {\n    token_ticker: string; // bas64 string\n    token_name: string; // bas64 string\n    token_document_url: string; // bas64 string\n    token_document_hash: string; // bas64 string\n    decimals: number;\n    mint_baton_txid: string; // bas64 string\n    mint_baton_vout: number;\n}\nexport interface SlpChildTokenMeta {\n    token_ticker: string; // bas64 string\n    token_name: string; // bas64 string\n    token_document_url: string; // bas64 string\n    token_document_hash: string; // bas64 string\n    group_id: string; // bas64 string\n}\nexport interface BchdRestUtxo {\n    outputs: BchdRestOutput[];\n    token_metadata?: BchdTokenMetadata[]; // included if include_token_metadata === true\n}\n\nexport interface BchUtxo {\n    bchOutputs: BchdRestOutput[];\n}\n\n/**\n * A UTXO where outputs are seperated into 3 sets for BCH, SLP and SLP baton.\n * Always use this UTXO when sending SLP tokens to prevent\n * accidentally burning tokens.\n */\nexport interface SlpUtxo extends BchUtxo {\n    slpOutputs: BchdRestOutput[];\n    batonOutputs: BchdRestOutput[]; // minting baton UTXO\n    token_metadata?: BchdTokenMetadata; // the metadata for this token\n}\n\n/**\n * A REST client for the BCHD REST API available at:\n * https://bchd.ny1.simpleledger.io/\n */\nexport class BchdRest {\n    protected apiUrl: string = \"https://bchd.ny1.simpleledger.io/v1/\";\n\n    constructor(apiUrl: string = \"\") {\n        if (apiUrl.length !== 0) {\n            this.apiUrl = apiUrl;\n            if (/\\/v1\\//.test(this.apiUrl) !== true)\n                throw new Error(\"Invalid BCHD REST API URL: \" + this.apiUrl);\n        }\n    }\n\n    /**\n     * Return token meta data for a specific token from an array of meta data.\n     * Returns null if there is no meta data with the given token ID.\n     * @param meta\n     * @param tokenIdHex\n     */\n    public static getTokenMeta(meta: BchdTokenMetadata[], tokenIdHex: string): BchdTokenMetadata {\n        if (meta == null)\n            return null;\n        const tokenIdBase64 = hexToBase64(tokenIdHex);\n        for (let i = 0; i < meta.length; i++)\n        {\n            if (meta[i].token_id === tokenIdBase64)\n                return meta[i];\n        }\n        return null;\n    }\n\n    /**\n     * Return the UTXO of an address.\n     * Use getSlpAddressUnspentOutputs() to separate the UTXO into SLP outputs to avoid burning tokens.\n     * @param address the CashAddr or SLP address\n     * @param includeSlpMeta\n     * @param includeMempool\n     */\n    public async getAddressUnspentOutputs(address: string, includeSlpMeta: boolean = false, includeMempool: boolean = false) {\n        return new Promise<BchdRestUtxo>((resolve, reject) => {\n            const url = this.apiUrl + \"GetAddressUnspentOutputs\";\n            let data = {\n                address: address,\n                include_mempool: includeMempool,\n                include_token_metadata: includeSlpMeta\n            }\n            this.postApi(url, data).then((res: BchdRestUtxo) => {\n                resolve(res);\n            }).catch((err) => {\n                reject({txt: \"Invalid response when getting UTXO\", err: err, address: address});\n            });\n        })\n    }\n\n    /**\n     * Return the UTXO of a BCH address.\n     * This function is SLP-aware, meaning it will filter any UTXOs that have SLP tokens associated with them\n     * to prevent them from being burned accidentally.\n     * @param address\n     * @param includeMempool\n     */\n    public async getBchAddressUnspentOutputs(address: string, includeMempool: boolean = false): Promise<BchUtxo> {\n        let utxo = await this.getAddressUnspentOutputs(address, true, includeMempool);\n        return {\n            // sort BCHD outputs ascending (smallest first)\n            bchOutputs: utxo.outputs.filter(o => !o.slp_token || !o.slp_token.token_id).sort((a, b) => parseInt(a.value) - parseInt(b.value)),\n        }\n    }\n\n    /**\n     * Return the UTXO for an address\n     * @param address an address as CashAddr or SLP address\n     * @param tokenIdHex\n     * @param includeMempool\n     */\n    public async getSlpAddressUnspentOutputs(address: string, tokenIdHex: string, includeMempool: boolean = false): Promise<SlpUtxo> {\n        let utxo = await this.getAddressUnspentOutputs(address, true, includeMempool);\n        const tokenIdBase64 = hexToBase64(tokenIdHex);\n        return {\n            // sort BCHD outputs ascending (smallest first)\n            bchOutputs: utxo.outputs.filter(o => !o.slp_token || !o.slp_token.token_id).sort((a, b) => parseInt(a.value) - parseInt(b.value)),\n            slpOutputs: utxo.outputs.filter(o => o.slp_token && o.slp_token.token_id === tokenIdBase64 && o.slp_token.is_mint_baton === false),\n            batonOutputs: utxo.outputs.filter(o => o.slp_token && o.slp_token.token_id === tokenIdBase64 && o.slp_token.is_mint_baton === true),\n            token_metadata: BchdRest.getTokenMeta(utxo.token_metadata, tokenIdHex),\n        }\n    }\n\n    /**\n     * Get the (unconfirmed) BCHD balance of the address.\n     * If you specify a token ID it returns the balance of that token.\n     * @param address\n     * @param tokenID\n     * @param includeMempool\n     */\n    public async getAddressBalance(address: string, tokenID: string = \"\", includeMempool: boolean = false): Promise<number> {\n        let utxo = await this.getAddressUnspentOutputs(address, tokenID.length !== 0, includeMempool);\n        if (utxo.outputs === undefined) // returns empty object for unused addresses\n            return 0.0;\n        if (tokenID == \"\")\n            return this.readBchBalanceFromUtxo(utxo.outputs);\n        return this.readSlpTokenBalanceFromUtxo(utxo, tokenID);\n    }\n\n    /**\n     * Submit a transaction\n     * @param txHex The transaction as hex string (as returned in bitcore.Transaction.toString() )\n     * @return the transaction ID as hex\n     */\n    public async submitTransaction(txHex: string): Promise<string> {\n        return new Promise<string>((resolve, reject) => {\n            const url = this.apiUrl + \"SubmitTransaction\";\n            let data = {\n                transaction: hexToBase64(txHex),\n                skip_slp_validity_check: false,\n                /*\n                required_slp_burns: [\n                    {\n                        outpoint: {\n                            hash: \"string\",\n                            index: 0\n                        },\n                        token_id: \"string\",\n                        token_type: 0,\n                        amount: \"string\",\n                        mint_baton_vout: 0\n                    }\n                ]*/\n            }\n            this.postApi(url, data).then((res) => {\n                if (!res.hash) {\n                    reject({txt: \"Submitted TX doesn't contain TX Hash\", res: res, tx: txHex});\n                    return;\n                }\n                const txid = reverseBytes(base64ToHex(res.hash));\n                resolve(txid);\n            }).catch((err) => {\n                reject({txt: \"Invalid response when submitting TX\", err: err, tx: txHex});\n            });\n        });\n    }\n\n    // ################################################################\n    // ###################### PRIVATE FUNCTIONS #######################\n\n    protected readBchBalanceFromUtxo(outputs: BchdRestOutput[]): number {\n        let sats = 0.0;\n        outputs.forEach((output) => {\n            const curSats = parseInt(output.value);\n            if (curSats > DUST_LIMIT)\n                sats += curSats;\n        });\n        return fromSatoshis(sats);\n    }\n\n    protected readSlpTokenBalanceFromUtxo(utxo: BchdRestUtxo, tokenID: string): number {\n        let amount = 0.0;\n        const tokenMeta = BchdRest.getTokenMeta(utxo.token_metadata, tokenID);\n        utxo.outputs.forEach((output) => {\n            if (!output.slp_token)\n                return;\n            let curTokenID = base64ToHex(output.slp_token.token_id);\n            if (curTokenID !== tokenID)\n                return;\n            amount += parseInt(output.slp_token.amount);\n        });\n        if (tokenMeta && tokenMeta.type1 && tokenMeta.type1.decimals > 0)\n            amount /= Math.pow(10, tokenMeta.type1.decimals);\n        return amount;\n    }\n\n    /**\n     * Returns the metadata for the requesed tokenID in parameter.\n     * @param meta\n     * @param tokenID\n     * @return the SLP token metadata or null if not found\n     * @protected\n     */\n    protected readTokenMetadata(meta: BchdTokenMetadata[], tokenID: string): BchdTokenMetadata {\n        for (let i = 0; i < meta.length; i++)\n        {\n            let curTokenID = base64ToHex(meta[i].token_id);\n            if (tokenID !== curTokenID)\n                continue;\n            return meta[i];\n        }\n        return null;\n    }\n\n    /**\n     * Post JSON\n     * @param url\n     * @param data\n     * @return the JSON response as JS object\n     */\n    protected async postApi(url: string, data?: any): Promise<any> {\n        try {\n            let res = await window.fetch(url, {\n                method: \"post\",\n                body: JSON.stringify(data),\n            });\n            let json = await res.json();\n            return json;\n        }\n        catch (err) {\n            console.error(\"Error posting BCHD JSON\", err);\n            throw err;\n        }\n    }\n}\n","import * as debug from \"debug\";\n//import * as supportsColor from \"supports-color\"; // only for NodeJS to enable more colors\n\n// to enable write on console: localStorage.debug = 'prompt:*'\nconst NS_BASE = 'prompt';\n// TODO create namespaces per app name? we can't read app dir on filesystem and we want to avoid missing logs due to include order (from another lib using this class)\n\n/*\nconst COLORS = {\n    trace: 'lightblue',\n    info: 'blue',\n    warn: 'pink',\n    error: 'red'\n};\n*/\n\nclass Log {\n    // https://www.npmjs.com/package/debug#formatters\n    constructor() {\n    }\n\n    public trace(formatter: any, ...args: any[]): void {\n    }\n\n    public verbose(formatter: any, ...args: any[]): void {\n    }\n\n    public info(formatter: any, ...args: any[]): void {\n    }\n\n    public warn(formatter: any, ...args: any[]): void {\n    }\n\n    public error(formatter: any, ...args: any[]): void {\n    }\n\n    // ################################################################\n    // ###################### PRIVATE FUNCTIONS #######################\n}\n\nconst logger = new Log();\n/*\nObject.keys(COLORS).forEach((logLevel) => {\n    console.log(logLevel, COLORS[logLevel])\n    //debug.colors = COLORS[logLevel];\n});\ndebug.colors = COLORS;\n*/\nlogger.trace = debug(NS_BASE + \":trace\" );\nlogger.verbose = debug(NS_BASE + \":verbose\" );\nlogger.info = debug(NS_BASE + \":info\" );\nlogger.warn = debug(NS_BASE + \":warn\" );\nlogger.error = debug(NS_BASE + \":error\" );\n\nexport {logger}\n","import {bitcore, bchaddrjs, bignumber, slpmdm as mdm} from \"@ekliptor/payjs\";\nimport {BchdRest, DUST_LIMIT, BchdRestOutput, BchdRestUtxo, MIN_FEE, BchUtxo} from \"./BchdRest\";\nimport * as utils from \"./chain-utils\";\nimport {logger} from \"../utils/Log\";\nimport {BigNumber} from \"bignumber.js\";\nimport {toSatoshis} from \"./chain-utils\";\nimport {PromptRest} from \"./PromptRest\"; // TODO use types from payjs\n\n//export const MIN_FEE = 1000; // BCHD doesn't broadcast TX that are below this\n\nexport interface BitcoinCashAddress {\n    address: string; // the address starting with \"bitcoincash:\"\n    privateKey: string;\n    wif: string;\n}\n\nexport interface BchRecipient {\n    bchAddress: string;\n    amount: number; // in BCH (not satoshis). not BigNumber because bitcore.addOutput() doesn't accept it\n}\nexport interface SlpTokenRecipient {\n    slpAddress: string;\n    tokenAmount: BigNumber;\n}\n\nexport class BitcoinCash {\n    protected privateKey: bitcore.PrivateKey = null;\n    protected hdPrivateKey: bitcore.HDPrivateKey = null;\n    protected bchd: PromptRest;\n\n    constructor(myPrivateKey: string | bitcore.PrivateKey | bitcore.HDPrivateKey = \"\", bchd: PromptRest) {\n        if (typeof myPrivateKey === \"string\")\n            this.privateKey = new bitcore.PrivateKey(myPrivateKey ? myPrivateKey : undefined);\n        else if (myPrivateKey instanceof bitcore.PrivateKey || myPrivateKey.deriveChild === undefined)\n            this.privateKey = myPrivateKey as bitcore.PrivateKey;\n        else {\n            this.hdPrivateKey = myPrivateKey;\n            //this.privateKey = myPrivateKey.deriveChild(\"m/0/0\");\n        }\n        this.bchd = bchd;\n    }\n\n    public getPrivateKey() {\n        return this.privateKey;\n    }\n\n    public getBchAddress(privateKey: bitcore.PrivateKey = null): string {\n        if (privateKey === null)\n            privateKey = this.getPrivateKey();\n        const ownAddress = privateKey.toAddress().toString();\n        return ownAddress;\n    }\n\n    /**\n     * Set a another address than the default address of this Private Key.\n     * Useful with BIP44 addresses.\n     * @param address\n     */\n    /*\n    public setBchAddress(address: string): void {\n        this.bchdAddress = address;\n    }*/\n\n    public getSlpAddress(): string {\n        return bchaddrjs.toSlpAddress(this.getBchAddress());\n    }\n\n    public getDerivedAddress(xpub: string, index: number): bitcore.Address {\n        const pubKey = new bitcore.HDPublicKey(xpub);\n        const hdPath = \"m/0/\" + index;\n        let derivedAddress = new bitcore.Address(pubKey.deriveChild(hdPath, false).publicKey, bitcore.Networks.mainnet);\n        return derivedAddress;\n    }\n\n    public static getDerivedKey(xpriv: string, index: number): bitcore.HDPrivateKey {\n        const derivedHdKey = new bitcore.HDPrivateKey(xpriv);\n        const hdPath = \"m/0/\" + index;\n        return derivedHdKey.deriveChild(hdPath, false);\n    }\n\n    public async getBchBalance(): Promise<number> {\n        return this.bchd.getAddressBalance(this.getBchAddress());\n    }\n\n    public async getSlpBalance(tokenID: string): Promise<number> {\n        const slpAddress = this.getSlpAddress();\n        return this.bchd.getAddressBalance(slpAddress, tokenID);\n    }\n\n    /**\n     * Import an address from private key or WIF.\n     * @param privateKeyHex\n     * @return BitcoinCashAddress\n     */\n    public importAddress(privateKeyHex: string): BitcoinCashAddress {\n        const key = this.extractPrivateKey(privateKeyHex);\n        let privateKey = new bitcore.PrivateKey(key);\n        return {\n            address: privateKey.toAddress().toString(),\n            privateKey: privateKey.toString(),\n            wif: privateKey.toWIF()\n        }\n    }\n\n    public async signTransaction(to: BchRecipient[], privateKey: bitcore.PrivateKey = null): Promise<bitcore.Transaction> {\n        if (privateKey === null)\n            privateKey = this.privateKey;\n        const cashAddress = this.getBchAddress(privateKey);\n        const utxo = await this.bchd.getBchAddressUnspentOutputs(cashAddress, true);\n        return this.signTransactionWithUtxo(to, privateKey, cashAddress, utxo);\n    }\n\n    public async signTransactionWithUtxo(to: BchRecipient[], privateKey: bitcore.PrivateKey = null, cashAddress: string, utxo: BchUtxo): Promise<bitcore.Transaction> {\n        if (privateKey === null)\n            privateKey = this.privateKey;\n        if (utxo.bchOutputs.length === 0)\n            throw new Error(`Address ${cashAddress} has no BCH-only UTXO balance.`);\n\n        // build the transaction\n        let txn = new bitcore.Transaction();\n\n        // add BCH to inputs\n        const bchUtxo = this.bchdToBitcoreUtxo(utxo.bchOutputs, cashAddress);\n        txn.from([...bchUtxo]);\n\n        let script = bitcore.Script.empty();\n        // @ts-ignore // Opcode is not part of typings\n        //script.add(bitcore.Opcode.OP_RETURN);\n        //txn.addOutput(new bitcore.Transaction.Output({script: script, satoshis: 0}));\n\n        // add BCH recipients as outputs\n        to.forEach((rec) => {\n            //txn.to() // should work identically, see Transaction.prototype.to\n            if (rec.bchAddress === cashAddress) {\n                throw new Error(\"Receiver address can not be identical to change address: \" + rec.bchAddress);\n            }\n            const sats = toSatoshis(rec.amount);\n            //const script = bitcore.Script.fromAddress(rec.bchAddress);\n            //txn.addOutput(new bitcore.Transaction.Output({satoshis: sats, script: script }));\n            txn.to(rec.bchAddress, sats);\n        });\n\n        // change to sender\n        txn.change(cashAddress)/*.feePerKb(MIN_FEE)*/; // bet bitcore handle fees automatically\n\n        // sign the transaction\n        txn = txn.sign(privateKey);\n        logger.info(\"Signed TX with ID %s\", txn.id);\n        logger.info(txn);\n        logger.info(txn.toString())\n        //logger.verbose(txn.toString()); // full TX as hex\n\n        return txn;\n    }\n\n    public async signSlpTransaction(tokenIdHex: string, to: SlpTokenRecipient[]): Promise<bitcore.Transaction> {\n        // similar to https://github.com/simpleledgerinc/cpp_slp_graph_search/blob/master/regtest-bchn/test/helpers/rpcwallet.ts#L305\n        // TODO is there a max number of recipients? max TX size... bitcore should already take care of that\n        const slpAddress = this.getSlpAddress();\n        const cashAddress = this.getBchAddress();\n        // we have to include the mempool or else when signing many TX over a short time we get \"output already spent\" error\n        const utxo = await this.bchd.getSlpAddressUnspentOutputs(slpAddress, tokenIdHex, true);\n        if (utxo.bchOutputs.length === 0)\n            throw new Error(`Address ${cashAddress} has no BCH-only UTXO balance to pay for SLP TX fees.`);\n        else if (utxo.token_metadata === null)\n            throw new Error(`No token meta data found for token ID ${tokenIdHex}`);\n\n        // convert token amount to token \"satoshis\" (shift decimals)\n        const decimals = utxo.token_metadata.type1.decimals;\n        to.forEach((rec) => {\n            rec.tokenAmount = rec.tokenAmount.multipliedBy(10**decimals, 10);\n        });\n\n        // build the transaction\n        let txn = new bitcore.Transaction();\n\n        // add BCH to inputs to pay TX fees\n        const bchUtxo = this.bchdToBitcoreUtxo(utxo.bchOutputs, cashAddress);\n        const slpUtxo = this.bchdToBitcoreUtxo(utxo.slpOutputs);\n        txn.from([...slpUtxo, ...bchUtxo]);\n\n        // add slp change back to our wallet\n        const slpTotal = utxo.slpOutputs.reduce((p, c, _) => p.plus(c.slp_token!.amount), new BigNumber(0));\n        //console.log(\"SLP TOTAL\", slpTotal)\n        const slpTo = to.reduce((p, c, _) => p.plus(c.tokenAmount), new BigNumber(0));\n        to.unshift({ slpAddress: slpAddress, tokenAmount: slpTotal.minus(slpTo) }); // first address is our SLP change\n        //console.log(\"SLP return\", slpTotal.minus(slpTo))\n\n        // add slp mint op_return\n        // @ts-ignore\n        const slpMsg = mdm.TokenType1.send(tokenIdHex, to.map((v, i, _) => v.tokenAmount));\n        txn.addOutput(new bitcore.Transaction.Output({satoshis: 0, script: slpMsg }));\n\n        // add dust outputs for token receiver and minting baton\n        to.forEach((rec, i) => {\n            const cashAddr = bchaddrjs.toCashAddress(rec.slpAddress);\n            txn.to(cashAddr, DUST_LIMIT);\n        });\n\n        // change to sender\n        txn.change(cashAddress);\n\n        // sign the transaction\n        txn = txn.sign(this.privateKey);\n        logger.info(\"Signed TX with ID %s\", txn.id);\n        logger.info(txn);\n        logger.info(txn.toString())\n        //logger.verbose(txn.toString()); // full TX as hex\n\n        return txn;\n    }\n\n    public async getAddressUtxos(addressStr: string, includeSlpMeta: boolean = false): Promise<bitcore.Transaction.UnspentOutput[]> {\n        let utxos: bitcore.Transaction.UnspentOutput[] = [];\n        let res = await this.bchd.getAddressUnspentOutputs(addressStr, includeSlpMeta);\n        utxos = this.bchdToBitcoreUtxo(res.outputs, addressStr);\n        return utxos;\n    }\n\n    public bchdToBitcoreUtxo(bchdOutputs: BchdRestOutput[], addressStr?: string): bitcore.Transaction.UnspentOutput[] {\n        let outputs: bitcore.Transaction.UnspentOutput[] = [];\n        for (let i = 0; i < bchdOutputs.length; i++)\n        {\n            let curOut = bchdOutputs[i];\n            if (!curOut.outpoint)\n                continue;\n            const amount = typeof curOut.value === \"number\" ? curOut.value : parseFloat(curOut.value); // BCHD REST returns strings\n            const script = Buffer.from(curOut.pubkey_script as string, \"base64\");\n            const txid = Buffer.from(curOut.outpoint.hash as string, \"base64\");\n            let bitcoreOut = bitcore.Transaction.UnspentOutput.fromObject({\n                //txId: \"115e8f72f39fad874cfab0deed11a80f24f967a84079fb56ddf53ea02e308986\",\n                txId: utils.reverseBytes(txid.toString(\"hex\")),\n                outputIndex: curOut.outpoint.index,\n                address: addressStr ? new bitcore.Address(addressStr) : undefined,\n                //script: new bitcore.Script(\"76a91447862fe165e6121af80d5dde1ecb478ed170565b88ac\"),\n                script: new bitcore.Script(script.toString(\"hex\")),\n                //script: this.getScriptPubKey(addressStr),\n                satoshis: amount, // balance\n            });\n            outputs.push(bitcoreOut);\n        }\n        return outputs;\n    }\n\n    public findUtxoForTransaction(outputs: bitcore.Transaction.UnspentOutput[], minSats: number): bitcore.Transaction.UnspentOutput | null {\n        for (let i = 0; i < outputs.length; i++)\n        {\n            if (outputs[i].satoshis >= minSats)\n                return outputs[i];\n        }\n        return null;\n    }\n\n    // ################################################################\n    // ###################### PRIVATE FUNCTIONS #######################\n\n    protected extractPrivateKey(privateKeyHex: string): string {\n        // ElectronCash shows keys as: address key - extract the 2nd part (key)\n        // example simpleledger:qq... L1...\n        const pos = privateKeyHex.indexOf(\" \");\n        if (pos === -1)\n            return privateKeyHex;\n        return privateKeyHex.substr(pos+1).trim();\n    }\n}\n","import {WebHelpers} from \"../utils/WebHelpers\";\n\nexport interface ChainAddress {\n    cashAddress: string; // the address starting with \"bitcoincash:\"\n    slpAddress: string;\n}\n\nexport class ChainTools {\n    protected apiBasePath: string;\n    protected webHelpers: WebHelpers;\n\n    constructor(apiBasePath: string, webHelpers: WebHelpers) {\n        this.apiBasePath = apiBasePath;\n        this.webHelpers = webHelpers;\n    }\n\n    public createAddress(xpub: string, index: number): Promise<ChainAddress> {\n        return new Promise<ChainAddress>((resolve, reject) => {\n            const url = this.apiBasePath + \"/create-address\";\n            let params = {\n                xpub: xpub, // jQuery escapes if needed\n                index: index\n            }\n            this.webHelpers.getApi(url, params, (data) => {\n                if (data.data === undefined) {\n                    reject({text: \"invalid address response\", res: data});\n                    return;\n                }\n\n                resolve({\n                    cashAddress: data.data.cash_address,\n                    slpAddress: data.data.slp_address,\n                });\n            });\n        })\n    }\n\n    // ################################################################\n    // ###################### PRIVATE FUNCTIONS #######################\n}\n","import {hexToBase64, base64ToHex, reverseBytes, fromSatoshis} from \"./chain-utils\";\n\nexport const DUST_LIMIT = 546;\nexport const MIN_FEE = 1000; // BCHD doesn't broadcast TX that are below this\n\nexport interface BchdRestOutput {\n    outpoint: {\n        hash: string; // bas64 string\n        index: number;\n    },\n    pubkey_script: string; // bas64 string\n    value: string; // integer as string = sats\n    is_coinbase: boolean;\n    block_height: number;\n    slp_token?: {\n        token_id: string; // bas64 string\n        amount: string; // integer as string\n        is_mint_baton: boolean;\n        address: string;\n        decimals: number;\n        slp_action: string; // NON_SLP\n        token_type: number\n    }\n}\nexport interface BchdTokenMetadata {\n    token_id: string; // bas64 string\n    token_type: number;\n    type1?: SlpTokenMeta;\n    nft1_group?: SlpTokenMeta;\n    nft1_child?: SlpChildTokenMeta;\n}\nexport interface SlpTokenMeta {\n    token_ticker: string; // bas64 string\n    token_name: string; // bas64 string\n    token_document_url: string; // bas64 string\n    token_document_hash: string; // bas64 string\n    decimals: number;\n    mint_baton_txid: string; // bas64 string\n    mint_baton_vout: number;\n}\nexport interface SlpChildTokenMeta {\n    token_ticker: string; // bas64 string\n    token_name: string; // bas64 string\n    token_document_url: string; // bas64 string\n    token_document_hash: string; // bas64 string\n    group_id: string; // bas64 string\n}\nexport interface BchdRestUtxo {\n    outputs: BchdRestOutput[];\n    //token_metadata?: BchdTokenMetadata[]; // included if include_token_metadata === true\n}\n\nexport interface BchUtxo {\n    bchOutputs: BchdRestOutput[];\n}\n\n/**\n * A UTXO where outputs are seperated into 3 sets for BCH, SLP and SLP baton.\n * Always use this UTXO when sending SLP tokens to prevent\n * accidentally burning tokens.\n */\nexport interface SlpUtxo extends BchUtxo {\n    slpOutputs: BchdRestOutput[];\n    batonOutputs: BchdRestOutput[]; // minting baton UTXO\n    token_metadata?: BchdTokenMetadata; // the metadata for this token\n}\n\nexport class PromptRest {\n    protected apiUrl: string = \"\";\n\n    constructor(apiUrl: string = \"\") {\n        if (apiUrl.length !== 0) {\n            this.apiUrl = apiUrl;\n        }\n    }\n\n\n    /**\n     * Return the UTXO of an address.\n     * Use getSlpAddressUnspentOutputs() to separate the UTXO into SLP outputs to avoid burning tokens.\n     * @param address the CashAddr or SLP address\n     * @param includeSlpMeta\n     * @param includeMempool\n     */\n    public async getAddressUnspentOutputs(address: string, includeSlpMeta: boolean = false, includeMempool: boolean = false) {\n        return new Promise<BchdRestUtxo>((resolve, reject) => {\n            let url = this.apiUrl + \"?method=GetAddressUnspentOutputs\";\n            let data = {\n                address: address,\n                include_mempool: includeMempool,\n                include_token_metadata: includeSlpMeta\n            }\n            this.postApi(url, data).then((res: BchdRestUtxo) => {\n                resolve(res);\n            }).catch((err) => {\n                reject({txt: \"Invalid response when getting UTXO\", err: err, address: address});\n            });\n        })\n    }\n\n    /**\n     * Return the UTXO of a BCH address.\n     * This function is SLP-aware, meaning it will filter any UTXOs that have SLP tokens associated with them\n     * to prevent them from being burned accidentally.\n     * @param address\n     * @param includeMempool\n     */\n    public async getBchAddressUnspentOutputs(address: string, includeMempool: boolean = false): Promise<BchUtxo> {\n        let utxo = await this.getAddressUnspentOutputs(address, true, includeMempool);\n        return {\n            // sort BCHD outputs ascending (smallest first)\n            bchOutputs: utxo.outputs.filter(o => !o.slp_token || !o.slp_token.token_id).sort((a, b) => parseInt(a.value) - parseInt(b.value)),\n        }\n    }\n\n    /**\n     * Return the UTXO for an address\n     * @param address an address as CashAddr or SLP address\n     * @param tokenIdHex\n     * @param includeMempool\n     */\n    public async getSlpAddressUnspentOutputs(address: string, tokenIdHex: string, includeMempool: boolean = false): Promise<SlpUtxo> {\n        throw \"Not Implemented\";\n        return null;\n    }\n\n    /**\n     * Get the (unconfirmed) BCHD balance of the address.\n     * If you specify a token ID it returns the balance of that token.\n     * @param address\n     * @param tokenID\n     * @param includeMempool\n     */\n    public async getAddressBalance(address: string, tokenID: string = \"\", includeMempool: boolean = false): Promise<number> {\n        let utxo = await this.getAddressUnspentOutputs(address, tokenID.length !== 0, includeMempool);\n        if (utxo.outputs === undefined) // returns empty object for unused addresses\n            return 0.0;\n        if (tokenID == \"\")\n            return this.readBchBalanceFromUtxo(utxo.outputs);\n        return 0.0;\n    }\n\n    /**\n     * Submit a transaction\n     * @param txHex The transaction as hex string (as returned in bitcore.Transaction.toString() )\n     * @return the transaction ID as hex\n     */\n    public async submitTransaction(txHex: string): Promise<string> {\n\n        return new Promise<string>((resolve, reject)=>{\n            reject(\"Not Implemented\");\n        })\n    }\n\n    // ################################################################\n    // ###################### PRIVATE FUNCTIONS #######################\n\n    protected readBchBalanceFromUtxo(outputs: BchdRestOutput[]): number {\n        let sats = 0.0;\n        outputs.forEach((output) => {\n            const curSats = parseInt(output.value);\n            if (curSats > DUST_LIMIT)\n                sats += curSats;\n        });\n        return fromSatoshis(sats);\n    }\n\n\n    /**\n     * Post JSON\n     * @param url\n     * @param data\n     * @return the JSON response as JS object\n     */\n    protected async postApi(url: string, data?: any): Promise<any> {\n        try {\n            let res = await window.fetch(url, {\n                method: \"post\",\n                headers: {\n                    'Content-Type': 'application/json'\n                },\n                body: JSON.stringify(data),\n            });\n            let json = await res.json();\n            return json;\n        }\n        catch (err) {\n            console.error(\"Error posting BCHD JSON\", err);\n            throw err;\n        }\n    }\n}\n","import {AbstractPage} from \"./AbstractPage\";\nimport {JqueryApp} from \"./JqueryApp\";\nimport {bitcore} from \"@ekliptor/payjs\";\n//import {BchdRest, DUST_LIMIT} from \"./bitcoin-cash/BchdRest\";\nimport {BchRecipient, BitcoinCash} from \"./bitcoin-cash/BitcoinCash\"\nimport {BigNumber} from \"bignumber.js\";\nimport {AppMessage} from \"./ui/AppMessage\";\nimport {logger} from \"./utils/Log\";\nimport {ChainTools} from \"./bitcoin-cash/ChainTools\";\nimport {fromSatoshis} from \"./bitcoin-cash/chain-utils\";\nimport {PromptRest} from \"./bitcoin-cash/PromptRest\";\n\n\nexport class Merchant extends AbstractPage {\n    protected bchd: PromptRest;\n    protected bitcoinCash: BitcoinCash = null;\n    protected chainTools: ChainTools = null;\n\n    constructor(app: JqueryApp) {\n        super(app);\n        //this.bchd = new PromptRest(this.app.getConfig().bchdRestAddress);\n        this.bchd = new PromptRest(this.app.getConfig().apiBase + \"/node-api\")\n        this.chainTools = new ChainTools(this.app.getConfig().apiBase, this.app.getWebHelpers());\n\n        this.app.$(() => { // jQuery 3.0 \"document.ready\"\n            this.initPage();\n            this.addEventListeners();\n        });\n    }\n\n    // ################################################################\n    // ###################### PRIVATE FUNCTIONS #######################\n\n    protected initPage() {\n        if (this.app.getConfig().balance <= 0.0)\n            this.app.$(\"#withdraw-btn\").prop(\"disabled\", true);\n    }\n\n    protected addEventListeners() {\n        // =========== Account page ===========\n        // ====================================\n        this.app.$(\"#create-wallet-btn\").on(\"click\", async (event) => {\n            this.toggleExpandButtonIcon(this.app.$(event.target).find(\".toggleIcon\").eq(0));\n            this.closeExpandButton(this.app.$(\"#import-xpub-btn\"));\n            this.app.$(\".create-xpub\").fadeToggle(\"slow\");\n            this.app.$(\".import-xpub\").fadeOut(\"slow\");\n\n            let hdPrivateKey = new bitcore.HDPrivateKey();\n            let hdPublicKey = hdPrivateKey.hdPublicKey;\n            this.app.$(\"#xpub-new\").val(hdPublicKey.xpubkey.toString());\n            // @ts-ignore\n            //this.app.$(\"#wif-new\").val(hdPrivateKey.privateKey.toWIF()); // we can't derive keys from WIF\n            this.app.$(\"#wif-new\").val(hdPrivateKey.toString());\n\n            //let address = new bitcore.Address(hdPublicKey.publicKey, bitcore.Networks.livenet); // we don't scan for this address, use index 0\n            //let derivedAddress = new bitcore.Address(hdPublicKey.derive(0).publicKey, bitcore.Networks.livenet); // use API call just to ensure we use same address\n            const address = await this.chainTools.createAddress(hdPublicKey.xpubkey.toString(), 0);\n            this.app.$(\"#address-new\").val(address.cashAddress);\n        });\n        this.app.$(\"#import-xpub-btn\").on(\"click\", (event) => {\n            this.toggleExpandButtonIcon(this.app.$(event.target).find(\".toggleIcon\").eq(0));\n            this.closeExpandButton(this.app.$(\"#create-wallet-btn\"));\n            this.app.$(\".import-xpub\").fadeToggle(\"slow\");\n            this.app.$(\".create-xpub\").fadeOut(\"slow\");\n        });\n        this.app.$(\"#use-xpub-btn\").on(\"click\", (event) => {\n            if (window.confirm(this.app.getConfig().tr.confirmWalletBackup) !== true)\n                return;\n            const currentXpub = this.app.$(\"#xpub-new\").val();\n            this.app.$(\"#xpub\").val(currentXpub);\n        });\n\n        this.app.$(\"#withdraw-btn\").on(\"click\", (event) => {\n            this.app.$(\"#withdraw-section\").fadeToggle(\"slow\");\n            this.app.$('html, body').animate({\n                scrollTop: this.app.$(\"#withdrawal-form\").offset().top - 100\n            }, 1200);\n        });\n        this.app.$(\"#withdrawal-form\").on(\"submit\", (event) => {\n            event.preventDefault(); // we submit using ajax\n            this.withdrawFromWallet(event.target);\n        });\n\n        this.app.$(\"#enforceSignatures\").on(\"change\", (event) => {\n            const checkbox = this.app.$(event.target);\n            if (checkbox.prop(\"checked\") !== true)\n                return;\n            if (window.confirm(this.app.getConfig().tr.confirmSignatures) !== true)\n                checkbox.prop(\"checked\", false);\n        });\n\n        this.app.$(\"#enableSlpTokens\").on(\"change\", (event) => {\n            const checkbox = this.app.$(event.target);\n            if (checkbox.prop(\"checked\") !== true)\n                return;\n            if (window.confirm(this.app.getConfig().tr.confirmSlpTokens) !== true)\n                checkbox.prop(\"checked\", false);\n        });\n\n        this.app.$(\"#show-frame-demo\").on(\"click\", (event) => {\n            this.app.$(event.target).fadeOut(\"slow\");\n            const frame = this.app.$(\"#prompt-frame\");\n            frame.attr(\"src\", frame.attr(\"data-src\"));\n            frame.fadeIn(\"slow\");\n        });\n\n        this.app.$(\".deleteUrlBtn\").on(\"click\", (event) => {\n            if (confirm(this.app.getTr().get(\"reallyRemoveUrl\"))) {\n                let token = event.target.dataset.token\n                if (token === undefined)\n                    token = event.target.parentElement.dataset.token\n                window.location.replace(this.app.getConfig().pathUrlShortener + \"?op=remove&token=\" + token);\n            }\n        });\n\n        this.app.$(\".editUrlBtn\").on(\"click\", (event) => {\n            let token = event.target.dataset.token\n            if (token === undefined)\n                token = event.target.parentElement.dataset.token\n            window.location.replace(this.app.getConfig().pathUrlShortener + \"?token=\" + token);\n        });\n    }\n\n    protected toggleExpandButtonIcon(icon: JQuery<HTMLElement>) {\n        if (icon.hasClass(\"fa-arrow-up\") === true) {\n            icon.removeClass(\"fa-arrow-up\").addClass(\"fa-arrow-down\");\n        }\n        else\n            icon.removeClass(\"fa-arrow-down\").addClass(\"fa-arrow-up\");\n    }\n\n    protected closeExpandButton(button: JQuery<HTMLElement>) {\n        const icon = button.find(\".toggleIcon\").eq(0);\n        icon.removeClass(\"fa-arrow-up\").addClass(\"fa-arrow-down\");\n    }\n\n    protected async withdrawFromWallet(form :HTMLElement) {\n        const $form = this.app.$(form);\n        const config = this.app.getConfig();\n        let privateKey = $form.find(\"#wallet-wif\").val() as string;\n        const bchAddress = $form.find(\"#withdrawal-address\").val() as string;\n        let amount = parseFloat($form.find(\"#withdrawal-amount\").val() as string);\n        //const xpub = this.app.$(\"#xpub\").val() as string;\n        try {\n            //amount -= fromSatoshis(DUST_LIMIT)*5; // already subtracted on server. Why needed again?\n            if (amount <= 0.0)\n                throw new Error(\"Withdrawal balance must be positive.\");\n            this.app.$(\"#withdraw-progress\").fadeIn(\"slow\");\n\n            const addressCount = parseInt(this.app.$(\"#address-count\").text() as string);\n            let withdrawnAmount = 0.0;\n            for (let i = 0; i < addressCount; i++)\n            {\n                let derivedHdKey = BitcoinCash.getDerivedKey(privateKey, i);\n                this.bitcoinCash = new BitcoinCash(derivedHdKey, this.bchd);\n                const xpub = derivedHdKey.hdPublicKey.xpubkey.toString();\n                const address = await this.chainTools.createAddress(xpub, i);\n                //this.bitcoinCash.setBchAddress(address.cashAddress);\n\n                // get UTXO and withdraw everything from it\n                const utxo = await this.bchd.getBchAddressUnspentOutputs(address.cashAddress, true);\n                if (utxo.bchOutputs.length === 0)\n                    continue;\n                let availableAmountBch = 0.0;\n                utxo.bchOutputs.forEach((out) => {\n                    availableAmountBch += fromSatoshis(parseInt(out.value));\n                });\n                const neededAmountRemaining = amount - withdrawnAmount;\n                const toWithdraw = Math.min(neededAmountRemaining, availableAmountBch);\n                withdrawnAmount += toWithdraw;\n\n                const receivers: BchRecipient[] = [{bchAddress: bchAddress, amount: toWithdraw}];\n                // @ts-ignore\n                const transaction = await this.bitcoinCash.signTransactionWithUtxo(receivers, derivedHdKey.privateKey, address, utxo);\n                logger.verbose(transaction)\n                let txid = await this.bchd.submitTransaction(transaction.toString());\n                logger.info(\"Submitted TX with TXID %s\", txid); // or transaction.id\n                if (withdrawnAmount >= amount)\n                    break;\n            }\n\n            // show success message and update balance\n            const msg = new AppMessage(config.tr.withdrawalSuccess, \"success\");\n            msg.display();\n            this.app.$(\"#withdraw-progress\").fadeOut(\"slow\");\n            this.app.$(\"#balance\").text(config.tr.updating); // TODO API call to compute new BCH balance and USD value\n        }\n        catch (err) {\n            const msg = new AppMessage(config.tr.withdrawalFailed, \"danger\");\n            msg.display();\n            console.error(\"error starting withdrawal\", err)\n        }\n    }\n}\n","const __WEBPACK_NAMESPACE_OBJECT__ = ProgressBar;","\nexport type PaymentStatus = \"PENDING\" | \"CONFIRMING\" | \"PAID\" | \"CANCELLED\" | \"EXPIRED\" | \"HOLD\" | \"REFUNDED\";\n\nexport class PaymentResponse {\n    public readonly id: number;\n    public readonly tx_id: string; // the value the merchant supplied\n    public readonly token: string;\n    // TODO add more props\n    public readonly status: PaymentStatus;\n    public readonly paid_amount_crypto: number;\n    public readonly remaining_amount_crypto: number;\n    public readonly qr_url: string;\n    public readonly payment_link: string;\n    public readonly confirmations: number;\n    public readonly confirmations_required: number;\n\n    constructor() {\n    }\n\n    public static fromJson(json: any): PaymentResponse {\n        return Object.assign(new PaymentResponse(), json); // copy properties\n    }\n\n    public static generateMockPayment(txId: string, status: PaymentStatus = \"PAID\") {\n        const last = txId.lastIndexOf(\"-\");\n        if (last !== -1)\n            txId = txId.substr(0, last);\n        return Object.assign(new PaymentResponse(), {\n            id: 5,\n            tx_id: txId,\n            status: status,\n        });\n    }\n\n    // ################################################################\n    // ###################### PRIVATE FUNCTIONS #######################\n\n}\n","import {AbstractPage} from \"./AbstractPage\";\nimport {JqueryApp} from \"./JqueryApp\";\nimport * as ProgressBar from \"progressbar.js\"\nimport * as misc from \"./utils/misc\";\nimport {logger} from \"./utils/Log\";\n//import {BchdRest} from \"./bitcoin-cash/BchdRest\";\nimport {PaymentResponse} from \"./structs/PaymentResponse\";\nimport {PromptRest} from \"./bitcoin-cash/PromptRest\";\n\n\nexport class Pay extends AbstractPage {\n    protected progressBarTimerID: number = 0;\n    protected remainingPaymentTimeSec: number = 0;\n    protected confirmationBarTimerID: number = 0;\n    protected lastConfirmationCount: number = 0;\n    protected confirmationExpectation: number = 0;\n\n    protected receivedAmount: number = 0.0;\n    //protected checkServerPaymentTimerID: number = 0; // timer calling web server // TODO needed?\n    protected checkLocalPaymentTimerID: number = 0;\n    protected askBackendTimerID: number = 0;\n    protected fullyPaid: boolean = false;\n    protected confirming: boolean = false;\n    protected retryCount: number = 0;\n    protected payment: PaymentResponse = null; // the latest payment status from API\n    protected bchd: PromptRest;\n\n    constructor(app: JqueryApp) {\n        super(app);\n\n        const config = this.app.getConfig();\n        //this.bchd = new PromptRest(this.app.getConfig().bchdRestAddress);\n        this.bchd = new PromptRest(this.app.getConfig().apiBase + \"/node-api\")\n\n        this.app.$(window).on(\"load\", ($) => {\n            //this.addButtonLinkClass();\n            if (this.app.$(\".pay-preloader\").length > 0) {\n                this.app.$(\".pay-preloader\").fadeOut(\"slow\");\n            }\n            this.webHelpers.preloadImages(config.payment.successPayImage, config.payment.successPayImageFinal);\n        });\n        this.app.$(() => { // jQuery 3.0 \"document.ready\"\n            this.addEventListeners();\n            this.startPaymentTimer();\n            //const msg = new AppMessage(\"fooo msg test\", \"danger\");\n            //msg.display()\n\n            /*\n            setTimeout(() => {\n                this.sendPaidFrameMessage(); // TODO debug code to show frame immediately as paid\n            }, 500);*/\n        });\n    }\n\n    // ################################################################\n    // ###################### PRIVATE FUNCTIONS #######################\n\n    protected addEventListeners() {\n        if (this.app.$(\"#pay-qrcode-form\").length !== 0)\n            this.addPaymentFormEvents(this.app.$(\"#pay-qrcode-form\").eq(0)); // the form after the order has been placed\n    }\n\n    protected addPaymentFormEvents(paymentFormEl: JQuery) {\n        //const txid = paymentFormEl.find(\"#slp-txid-db\").val();\n\n        this.app.$(\".pay-copy-field\").click((event) => {\n            event.preventDefault();\n            const inputEl = this.app.$(event.target).parent().parent().find(\"input[type='text']\");\n            //let text = inputEl.val();\n            inputEl.select();\n            try {\n                window.document.execCommand(\"copy\");\n            }\n            catch (err) { // try-catch shouldn't be needed except for some really old browsers\n            }\n            inputEl.select(); // ensure it's selected again for iOS devices to copy it manually. not working, remove?\n        });\n        this.app.$(\"#pay-qrcode-form input[type='text']\").click((event) => {\n            this.app.$(event.target).select();\n        });\n        if (this.webHelpers.isAppleIOS() === true) // copy to clipboard button doesn't work there\n            this.app.$(\"#pay-qrcode-form .slp-copy-field\").addClass(\"hidden\");\n    }\n\n    protected startPaymentTimer() {\n        this.remainingPaymentTimeSec = this.app.getConfig().payment.timeRemainingSec;\n        const startTimeSec = Math.floor(Date.now() / 1000); // ensure we keep track of real time cause setTimeout() gets delayed in background\n        setTimeout(this.checkPaymentStatusLocally.bind(this, true), this.app.getConfig().payment.checkMs);\n        if (this.remainingPaymentTimeSec <= 0) {\n            this.setTimedOut();\n            return;\n        }\n\n        const bar = new ProgressBar.Circle(\"#payment-timeout-bar\", {\n            strokeWidth: 6,\n            easing: 'easeInOut',\n            duration: 1400,\n            color: '#1ab394',\n            trailColor: '#eee',\n            trailWidth: 1,\n            svgStyle: null,\n            text: {\n                value: misc.toDisplayTimeHHMMSS(this.remainingPaymentTimeSec),\n                style: {\n                    position: 'absolute',\n                    left: '50%',\n                    top: '60%',\n                    padding: 0,\n                    margin: 0,\n                    // You can specify styles which will be browser prefixed\n                    transform: {\n                        prefix: true,\n                        value: 'translate(-50%, -50%)'\n                    }\n                }\n            }\n        });\n        bar.animate(this.getRemainingTimePercent());  // Number from 0.0 to 1.0\n\n        this.progressBarTimerID = window.setInterval(() => {\n            //this.remainingPaymentTimeSec--;\n            this.remainingPaymentTimeSec = this.app.getConfig().payment.timeRemainingSec - (Math.floor(Date.now() / 1000) - startTimeSec);\n            if (this.remainingPaymentTimeSec < 0)\n                this.remainingPaymentTimeSec = 0;\n            const remaining = this.getRemainingTimePercent();\n            if (remaining <= 0.0) {\n                clearInterval(this.progressBarTimerID);\n                this.progressBarTimerID = 0;\n                this.setTimedOut();\n                return;\n            }\n            bar.animate(remaining, {\n                duration: 800\n            });\n            bar.setText(misc.toDisplayTimeHHMMSS(this.remainingPaymentTimeSec));\n        }, 1000);\n    }\n\n    protected getRemainingTimePercent() {\n        const config = this.app.getConfig();\n        let remaining = this.remainingPaymentTimeSec / config.payment.timeTotalSec;\n        if (remaining < 0.0)\n            remaining = 0.0;\n        else if (remaining > 1.0)\n            remaining = 1.0;\n        return remaining;\n    }\n\n    protected getRemainingConfirmationsPercent() {\n        const config = this.app.getConfig();\n        const refreshTime = 1000;\n        if (!this.payment)\n            return 0.0;\n        if (this.payment.confirmations_required == 0)\n            return 1.0;\n        if (this.lastConfirmationCount != this.payment.confirmations) {\n            this.lastConfirmationCount = this.payment.confirmations;\n            this.confirmationExpectation = 0;\n        }\n        let remaining = 1.0 - (this.payment.confirmations_required - this.payment.confirmations) / this.payment.confirmations_required;\n        let range = (1.0 / this.payment.confirmations_required) * 0.90; // auto fill on timer up to 90% of the pending range\n        let rangeStep = (config.payment.blockTime ? 1/(config.payment.blockTime/refreshTime) : 0.01); // percentage of the range to step per tick\n        this.confirmationExpectation += range * rangeStep;\n        if (this.confirmationExpectation > range) {\n            this.confirmationExpectation = range\n        }\n        remaining += this.confirmationExpectation;\n        if (remaining < 0.0)\n            remaining = 0.0;\n        else if (remaining > 1.0)\n            remaining = 1.0;\n        return remaining;\n    }\n\n    protected setTimedOut() {\n        if (this.fullyPaid === true)\n            return;\n        const config = this.app.getConfig();\n        if (config.payment.status == \"CONFIRMING\")\n            return;\n        logger.info(\"Payment has timed out\");\n        // TODO ask for email (if not provided already)\n        this.app.$(\"#pay-pending\").fadeOut(\"slow\");\n        this.app.$(\"#pay-expired\").fadeIn(\"slow\");\n    }\n\n    protected checkPaymentStatusLocally(repeat = true) {\n        //this.askBackendForPayment(); // <<<< for testing only\n\n        // check if the frame has been removed & stop querying\n        const config = this.app.getConfig();\n        if (config.fullPage === false) {\n            // iframe code stops running if we call $.remove()\n            //const $wnd = this.app.$(window);\n            //if ($wnd.is(\":visible\") === false || $wnd.height() === 0) {\n                //console.log([\"Stopped querying for balance because payment controls have been removed\", $wnd.is(\":visible\"), $wnd.height()]);\n            /*\n            if (window.top !== window.self) {\n                console.log([\"Stopped querying for balance because payment controls have been removed\"]);\n                return;\n            }*/\n        }\n        if (config.payment.status == \"CONFIRMING\") {\n            this.showPaymentConfirming(); // should already be done\n            this.scheduleLocalPaymentStatusCheck(repeat, 5*this.app.getConfig().payment.checkMs);\n            return;\n        }\n        if (config.payment.status == \"PAID\") {\n            this.showPaymentReceived(); // should already be done\n            this.webHelpers.log(\"Skipped querying for balance changes because fully paid\");\n            return;\n        }\n\n        //const tokenID = config.tokenID;\n        const tokenID = config.payment.slp_token_id;\n        const address = config.payment.address_slp ? config.payment.address_slp : config.payment.address;\n        const isSlpPayment = address.indexOf(\"simpleledger\") === 0; // starts with slp prefix\n\n        let requestTokenID = isSlpPayment === true ? tokenID : \"\";\n        clearTimeout(this.checkLocalPaymentTimerID);\n\n        this.bchd.getAddressBalance(address, requestTokenID, true).then((balance) => {\n            const previousAmount = this.receivedAmount;\n            this.receivedAmount = balance;\n            if (this.receivedAmount !== previousAmount) { // trigger a server-side re-check on balance change\n                this.webHelpers.log(\"Noticed balance change. Asking Web Server...\");\n                /*\n                clearTimeout(this.checkServerPaymentTimerID);\n                this.checkServerPaymentTimerID = this.slpPayments.window.setTimeout(() => {\n                    if (this.fullyPaid === false)\n                        this.checkPaymentStatus(repeat, true, true); // will set it to fully paid\n                }, this.slpPayments.getConfig().checkPaymentLocalIntervalSec * 1000);\n                 */\n                this.askBackendForPayment(); // query server to confirm\n            }\n            else if (repeat === false)\n                return;\n            this.scheduleLocalPaymentStatusCheck(repeat, this.app.getConfig().payment.checkMs);\n        }).catch((err) => {\n            this.webHelpers.log(err);\n            // give it some more time before retry (internet connection might be down)\n            this.scheduleLocalPaymentStatusCheck(repeat, 5*this.app.getConfig().payment.checkMs);\n        });\n    }\n\n    protected scheduleLocalPaymentStatusCheck(repeat: boolean, timeoutMs: number) {\n        clearTimeout(this.checkLocalPaymentTimerID); // ensure we don't run multiple timers\n        this.checkLocalPaymentTimerID = window.setTimeout(() => {\n            this.checkPaymentStatusLocally(repeat);\n        }, timeoutMs);\n    }\n\n    protected askBackendForPayment() {\n        if (this.askBackendTimerID !== 0 ) {\n            clearTimeout(this.askBackendTimerID);\n            this.askBackendTimerID = 0;\n        }\n        const url = /*window.location.protocol + window.location.host + */this.app.getConfig().pathPay + \"/check\";\n        let params = {\n            tx_id: this.app.getConfig().payment.id, // jQuery escapes if needed\n        }\n        this.webHelpers.getApi(url, params, (data) => {\n            if (!data.payment) {\n                logger.error(\"Invalid response on payment check %o\", data);\n                return;\n            }\n            this.payment = PaymentResponse.fromJson(data.payment);\n            logger.verbose(\"payment update\", this.payment);\n            if (this.payment.status === \"CONFIRMING\") {\n                //this.app.$(\"#pay-token-amount-remaining\").text(this.payment.paid_amount_crypto);\n                this.showPaymentConfirming();\n            }\n            else if (this.payment.status === \"PAID\")\n                this.showPaymentReceived(); // otherwise we keep querying BCHD\n            else if (this.payment.paid_amount_crypto > 0.0) {\n                this.app.$(\"#pay-token-amount-remaining\").text(this.payment.remaining_amount_crypto.toFixed(this.app.getConfig().numDecimals));\n                this.app.$(\"#pay-remaining-txt\").fadeIn(\"slow\");\n\n                // update QR Code\n                // update payment amount in URI and QR code\n                this.app.$(\"#pay-qr-code-image\").attr(\"src\", this.payment.qr_url);\n                this.app.$(\"#pay-address\").val(this.payment.payment_link);\n                this.app.$(\"#pay-wallet\").attr(\"href\", this.payment.payment_link);\n            }\n            else if (this.retryCount < this.app.getConfig().payment.maxRetryCount) {\n                this.retryCount++;\n                logger.verbose(\"retry asking backend %d/%d times\", this.retryCount, this.app.getConfig().payment.maxRetryCount);\n                this.scheduleAskBackendForPayment();\n            }\n        });\n    }\n\n    protected scheduleAskBackendForPayment() {\n        if (this.askBackendTimerID !== 0)\n            return; // timer already running\n        this.askBackendTimerID = window.setTimeout(() => {\n            this.askBackendForPayment();\n        }, this.app.getConfig().payment.checkMs);\n    }\n\n    protected showPaymentConfirming(){\n        if (this.confirming === true)\n            return; // already updated\n        this.confirming = true;\n\n        const config = this.app.getConfig();\n\n        this.app.$(\"#block-explorer-link\").fadeIn(\"slow\");\n        this.app.$(\"#pay-token-amount-remaining\").text(config.payment.amount_crypto);\n\n        config.payment.status = \"CONFIRMING\";\n        //clearTimeout(this.checkServerPaymentTimerID);\n        //clearTimeout(this.checkLocalPaymentTimerID);\n        /*let successImage = window.document.createElement(\"img\");\n        successImage.src = config.payment.successPayImage;\n        successImage.alt = config.payment.paidTxt;\n        successImage.id = \"pay-success-image-animated\";\n        this.addSuccessImageProperties(successImage);\n        setTimeout(() => {\n            this.showFinalPaidImage();\n        }, 1300);*/\n\n        const tr = this.app.getTr();\n\n        // update confirmation count\n        this.app.$(\"#pay-payment-status\").text(tr.get(\"confirming\"));\n\n        this.app.$(\"#pay-payment-pending, #pay-payment-options, #pay-pay-instructions\").fadeOut(\"slow\");\n        this.app.$(\"#pay-qr-code-image, #pay-qrcode-form, #pay-manual-payment, #pay-wallet, #payment-timeout-bar\").fadeOut(\"slow\");\n        //this.app.$(\"#pay-qr-code\").fadeOut(\"slow\");\n        //this.app.$(\"#pay-qr-code\").replaceWith(successImage);\n\n        const bar = new ProgressBar.Line(\"#payment-confirmation-bar\", {\n            strokeWidth: 6,\n            easing: 'easeInOut',\n            duration: 1400,\n            color: '#1ab394',\n            trailColor: '#eee',\n            trailWidth: 1,\n            svgStyle: null,\n            text: {\n                value: \"\",\n                style: {\n                    position: 'absolute',\n                    left: '50%',\n                    top: '60%',\n                    color: '#343a40',\n                    padding: 0,\n                    margin: 0,\n                    // You can specify styles which will be browser prefixed\n                    transform: {\n                        prefix: true,\n                        value: 'translate(-50%, -50%)'\n                    }\n                }\n            }\n        });\n        bar.animate(this.getRemainingConfirmationsPercent());  // Number from 0.0 to 1.0\n\n        this.confirmationBarTimerID = window.setInterval(() => {\n            // update confirmation count. Don't always API this or we have MULTIPLE request piling up in case of slow server\n            this.scheduleAskBackendForPayment();\n\n            if (config.payment.status == \"PAID\") {\n                this.showPaymentReceived(); // should already be done\n                this.webHelpers.log(\"Skipped querying for balance changes because fully paid\");\n                return;\n            }\n\n            const remaining = this.getRemainingConfirmationsPercent();\n\n            bar.animate(remaining, {\n                duration: 800\n            });\n            if (this.payment)\n                bar.setText(tr.get(\"confirmingShort\") + tr.get(\"colon\") + \" \" + this.payment.confirmations + \"/\" + this.payment.confirmations_required);\n            else\n                bar.setText(\"\");\n\n            if (remaining >= 1.0) {\n                clearInterval(this.confirmationBarTimerID);\n                this.confirmationBarTimerID = 0;\n                return;\n            }\n        }, 1000);\n    }\n\n    protected showPaymentReceived() {\n        if (this.fullyPaid === true)\n            return; // already updated\n        this.fullyPaid = true;\n        // TODO does partial payment work?\n\n        const config = this.app.getConfig();\n        const tr = this.app.getTr();\n\n        config.payment.status = \"PAID\";\n        //clearTimeout(this.checkServerPaymentTimerID);\n        clearTimeout(this.checkLocalPaymentTimerID);\n        let successImage = window.document.createElement(\"img\");\n        successImage.src = config.payment.successPayImage;\n        successImage.alt = tr.get(\"paid\");\n        successImage.id = \"pay-success-image-animated\";\n        this.addSuccessImageProperties(successImage);\n        setTimeout(() => {\n            this.showFinalPaidImage();\n        }, 1300);\n\n        this.app.$(\"#pay-payment-status\").text(tr.get(\"paid\"));\n        this.app.$(\"#pay-payment-pending, #pay-payment-options, #pay-pay-instructions\").fadeOut(\"slow\");\n        this.app.$(\"#pay-qr-code\").replaceWith(successImage);\n\n        this.sendPaidFrameMessage();\n    }\n\n    protected sendPaidFrameMessage() {\n        const config = this.app.getConfig();\n        if (this.payment === null) {\n            console.warn(\"Generating mock payment. This shouldn't happen in production!\");\n            this.payment = PaymentResponse.generateMockPayment(config.payment.id);\n        }\n\n        if (config.fullPage === true) {\n            console.debug(\"Skipped sending 'paid' message in fullPage mode\");\n            return;\n        }\n        if (window.parent === window.self) {\n            console.debug(\"Skipped sending 'paid' message without parent\");\n            return; // should be same as fullPage === true\n        }\n        let targetOrigin = config.ref || \"*\"; // send to all windows as fallback only\n        //console.debug(\"Sending 'paid' message to origin: %s\", targetOrigin);\n        window.parent.postMessage({\n            'func': 'onPromptPaid',\n            'data': this.payment,\n        }, targetOrigin);\n    }\n\n    protected showFinalPaidImage() {\n        const config = this.app.getConfig();\n        //let successImageFinal: HTMLImageElement = Object.assign(this.slpPayments.window.document.createElement(\"img\"), successImage); // doesn't copy attributes of native elements\n        let successImageFinal = window.document.createElement(\"img\");\n        successImageFinal.src = config.payment.successPayImageFinal;\n        //successImageFinal.alt = this.slpPayments.getConfig().paidTxt;\n        successImageFinal.id = \"pay-success-image\";\n        this.addSuccessImageProperties(successImageFinal);\n        this.app.$(\"#pay-success-image-animated, #pay-qr-code\").replaceWith(successImageFinal);\n\n        // redirect customer back to store\n        logger.verbose(\"Returning customer to URL: %s\", config.payment.returnUrl);\n        if (!config.payment.returnUrl || config.payment.returnUrl.toLowerCase().indexOf(\"http\") !== 0)\n            return;\n        window.location.replace(config.payment.returnUrl);\n    }\n\n    protected addSuccessImageProperties(image: HTMLImageElement) {\n        image.style.maxWidth = \"300px\";\n        image.style.maxHeight = \"300px\";\n        image.style.width = \"100%\";\n        image.style.display = \"block\";\n        image.className = \"pay-center\";\n    }\n}\n","\nexport type TransferStatus = \"PENDING\" | \"COMPLETED\" | \"FAILED\";\n\nexport class TransferResponse {\n    public readonly id: number;\n    public readonly status: TransferStatus;\n\n    constructor() {\n    }\n\n    public static fromJson(json: any): TransferResponse {\n        return Object.assign(new TransferResponse(), json); // copy properties\n    }\n\n    /*public static generateMockPayment(txId: string, status: PaymentStatus = \"PAID\") {\n        const last = txId.lastIndexOf(\"-\");\n        if (last !== -1)\n            txId = txId.substr(0, last);\n        return Object.assign(new PaymentResponse(), {\n            id: 5,\n            tx_id: txId,\n            status: status,\n        });\n    }*/\n\n    // ################################################################\n    // ###################### PRIVATE FUNCTIONS #######################\n\n}\n","import {AbstractPage} from \"./AbstractPage\";\nimport {JqueryApp} from \"./JqueryApp\";\nimport * as ProgressBar from \"progressbar.js\"\nimport * as misc from \"./utils/misc\";\nimport {logger} from \"./utils/Log\";\n//import {BchdRest} from \"./bitcoin-cash/BchdRest\";\nimport {TransferResponse} from \"./structs/TransferResponse\";\n\n\nexport class Transfer extends AbstractPage {\n    protected checkLocalTransferTimerID: number = 0\n    protected confirmed: boolean = false;\n    protected transfer: TransferResponse = null; // the latest payment status from API\n\n    constructor(app: JqueryApp) {\n        super(app);\n\n        const config = this.app.getConfig();\n\n        this.app.$(window).on(\"load\", ($) => {\n            //this.addButtonLinkClass();\n            /*if (this.app.$(\".pay-preloader\").length > 0) {\n                this.app.$(\".pay-preloader\").fadeOut(\"slow\");\n            }*/\n            this.webHelpers.preloadImages(config.transfer.successPayImage, config.transfer.successPayImageFinal);\n        });\n        this.app.$(() => { // jQuery 3.0 \"document.ready\"\n            this.addEventListeners();\n            this.startTransferTimer();\n            //const msg = new AppMessage(\"fooo msg test\", \"danger\");\n            //msg.display()\n\n            /*\n            setTimeout(() => {\n                this.sendPaidFrameMessage(); // TODO debug code to show frame immediately as paid\n            }, 500);*/\n        });\n    }\n\n    // ################################################################\n    // ###################### PRIVATE FUNCTIONS #######################\n\n    protected addEventListeners() {\n\n    }\n\n    protected startTransferTimer() {\n        setTimeout(this.checkTransferStatusLocally.bind(this, true), this.app.getConfig().transfer.checkMs);\n    }\n\n    protected checkTransferStatusLocally(repeat = true) {\n        this.askBackendForTransfer();\n\n        // check if the frame has been removed & stop querying\n        const config = this.app.getConfig();\n\n        this.scheduleLocalTransferStatusCheck(repeat, 5*this.app.getConfig().transfer.checkMs);\n\n    }\n\n    protected scheduleLocalTransferStatusCheck(repeat: boolean, timeoutMs: number) {\n        clearTimeout(this.checkLocalTransferTimerID); // ensure we don't run multiple timers\n        this.checkLocalTransferTimerID = window.setTimeout(() => {\n            this.checkTransferStatusLocally(repeat);\n        }, timeoutMs);\n    }\n\n    protected askBackendForTransfer() {\n        const url = /*window.location.protocol + window.location.host + */this.app.getConfig().pathTransfer + \"/check\";\n        let params = {\n            token: this.app.getConfig().transfer.token, // jQuery escapes if needed\n            tx_id: this.app.getConfig().transfer.tx_id, // jQuery escapes if needed\n        }\n        this.webHelpers.getApi(url, params, (data) => {\n            if (!data.transfer) {\n                // thats fien transfer not yet started\n                //logger.error(\"Invalid response on transfer check %o\", data);\n                return;\n            }\n            this.transfer = TransferResponse.fromJson(data.transfer);\n            logger.verbose(\"transfer update\", this.transfer);\n\n            const config = this.app.getConfig();\n            const tr = this.app.getTr();\n\n            // update confirmation count\n            this.app.$(\"#transfer-status\").text(this.transfer.status == \"COMPLETED\" ? tr.get(\"transferCompleted\") : tr.get(\"transferPending\"));\n\n            if(this.transfer.status == \"COMPLETED\") {\n                clearTimeout(this.checkLocalTransferTimerID); // ensure we don't run multiple timers\n\n\n                let successImage = window.document.createElement(\"img\");\n                successImage.src = config.transfer.successPayImage;\n                successImage.alt = tr.get(\"paid\");\n                successImage.id = \"pay-success-image-animated\";\n                this.addSuccessImageProperties(successImage);\n                setTimeout(() => {\n                    this.showFinalPaidImage();\n                }, 1300);\n\n                this.app.$(\"#pay-payment-status\").text(tr.get(\"paid\"));\n                this.app.$(\"#pay-payment-pending, #pay-payment-options, #pay-pay-instructions\").fadeOut(\"slow\");\n                this.app.$(\"#pay-qr-code\").replaceWith(successImage);\n\n            }\n\n        });\n    }\n\n    protected showFinalPaidImage() {\n        const config = this.app.getConfig();\n        //let successImageFinal: HTMLImageElement = Object.assign(this.slpPayments.window.document.createElement(\"img\"), successImage); // doesn't copy attributes of native elements\n        let successImageFinal = window.document.createElement(\"img\");\n        successImageFinal.src = config.transfer.successPayImageFinal;\n        //successImageFinal.alt = this.slpPayments.getConfig().paidTxt;\n        successImageFinal.id = \"pay-success-image\";\n        this.addSuccessImageProperties(successImageFinal);\n        this.app.$(\"#pay-success-image-animated, #pay-qr-code\").replaceWith(successImageFinal);\n\n        logger.verbose(\"Exchange done\");\n\n        // config.payment is undefined\n        /*\n        logger.verbose(\"Returning customer to URL: %s\", config.payment.returnUrl);\n        if (!config.payment.returnUrl || config.payment.returnUrl.toLowerCase().indexOf(\"http\") !== 0)\n            return;\n        window.location.replace(config.payment.returnUrl);\n         */\n    }\n\n    protected addSuccessImageProperties(image: HTMLImageElement) {\n        image.style.maxWidth = \"300px\";\n        image.style.maxHeight = \"300px\";\n        image.style.width = \"100%\";\n        image.style.display = \"block\";\n        image.className = \"pay-center\";\n    }\n\n}\n","import {AbstractPage} from \"./AbstractPage\";\n//import {BchdRest} from \"./bitcoin-cash/BchdRest\";\nimport {BitcoinCash} from \"./bitcoin-cash/BitcoinCash\";\nimport {ChainTools} from \"./bitcoin-cash/ChainTools\";\nimport {JqueryApp} from \"./JqueryApp\";\nimport {PromptRest} from \"./bitcoin-cash/PromptRest\";\n\nexport class Bridge extends AbstractPage {\n    protected bchd: PromptRest;\n    protected bitcoinCash: BitcoinCash = null;\n    protected chainTools: ChainTools = null;\n\n    constructor(app: JqueryApp) {\n        super(app);\n        //this.bchd = new PromptRest(this.app.getConfig().bchdRestAddress);\n        this.bchd = new PromptRest(this.app.getConfig().apiBase + \"/node-api\")\n        this.chainTools = new ChainTools(this.app.getConfig().apiBase, this.app.getWebHelpers());\n\n        this.app.$(() => { // jQuery 3.0 \"document.ready\"\n            this.initPage();\n            this.addEventListeners();\n        });\n    }\n\n    // ################################################################\n    // ###################### PRIVATE FUNCTIONS #######################\n\n    protected initPage() {\n\n    }\n\n    protected addEventListeners() {\n        this.app.$(\".btnSelectMaxBridgeAmount\").on(\"click\", (event) => {\n            this.app.$(\"#amount\").val(this.app.getConfig().bridge.maxAmount.toFixed(3)); // TODO max amount per SLP token\n        });\n    }\n}\n","import {WebHelpers} from \"./utils/WebHelpers\";\n\n\nexport interface LanguageData {\n    [key: string]: string; // can be string or sub-object with strings (rare)\n}\n\nexport class Localizer {\n    public static readonly DEFAULT_LANG = \"en\";\n\n    protected webHelpers: WebHelpers;\n    protected baseUrl: string = \"/pub/locales/\"; // + {lang}.json\n    protected language: string;\n    protected data: LanguageData = null;\n\n    /**\n     * Create the translation class.\n     * @param language the language to load (en, de, es, ...)\n     * @param baseUrl the server  to serve the {lang}.json file\n     */\n    constructor(webHelpers: WebHelpers, language: string, baseUrl: string = \"\") {\n        this.webHelpers = webHelpers;\n        this.language = language || Localizer.DEFAULT_LANG;\n        if (baseUrl.length !== 0)\n            this.baseUrl = baseUrl;\n    }\n\n    /**\n     * Load the translation JSON file from server.\n     */\n    public async loadTranslations(): Promise<void> {\n        const langUrl = `${this.baseUrl}${this.language}.json`;\n        try {\n            let res = await fetch(langUrl);\n            this.data = await res.json();\n            console.log(this.data)\n        }\n        catch (err) {\n            console.error(\"Error loading translation from %s\", langUrl, err);\n        }\n    }\n\n    public loadTranslationsFromObject(key: string): void {\n        if (typeof window[key] !== \"object\") {\n            console.error(\"window.%s object to load translations doesn't exist\", key);\n            return;\n        }\n        this.data = window[key];\n    }\n\n    /**\n     * Adds the tr() function to the global window object (under the specified key as function name).\n     * @param key\n     */\n    public exportTranslationFunctionToWindow(key: string = \"tr\"): void {\n        if (window[key] !== undefined) {\n            console.error(\"There already exists another translation function under the same key: %s\", key);\n            return;\n        }\n\n        window[key] = this.get.bind(this);\n    }\n\n    /**\n     * Get translation for a specific key.\n     * @param key\n     */\n    public get(key: string): string {\n        return this.data[key];\n    }\n\n    public getAll(): LanguageData {\n        return this.data;\n    }\n\n    public setLang(lang: string): void {\n        this.language = lang;\n        this.webHelpers.setCookie(\"lang\", lang, this.webHelpers.getConfig().cookieLifeDays);\n        document.location.reload();\n    }\n\n    // ################################################################\n    // ###################### PRIVATE FUNCTIONS #######################\n\n}\n","import {JqueryApp} from \"./src/JqueryApp\";\n\nlet jqApp = new JqueryApp(jQuery);\n// export it so that the API is accessible to other libraries\n// this is optional\n(window as any).promptCash = jqApp;\n","import {store} from \"./utils/Store\";\nimport {WebHelpers} from \"./utils/WebHelpers\";\nimport {AppMessage, AppMessageType} from \"./ui/AppMessage\";\nimport * as misc from \"./utils/misc\";\nimport {Merchant} from \"./Merchant\";\nimport {Pay} from \"./Pay\";\nimport {Transfer} from \"./Transfer\";\nimport {Bridge} from \"./Bridge\";\nimport {logger} from \"./utils/Log\";\nimport {PaymentStatus} from \"./structs/PaymentResponse\";\nimport {Localizer} from \"./Localizer\";\n\nexport interface AppConfig {\n    // PAY page\n    bchdRestAddress: string;\n    pathPay: string;\n    pathTransfer: string;\n    pathUrlShortener: string;\n    apiBase: string;\n    ref: string; // referer\n    numDecimals: number;\n\n    // on Pay (payment) page\n    fullPage: boolean; // true = full page payment, false = iframe\n    payment: {\n        timeTotalSec: number;\n        timeRemainingSec: number;\n        maxRetryCount: number;\n        id: string;\n        status: PaymentStatus;\n        address: string;\n        address_slp: string;\n        slp_token_id: string;\n        // paidAmountCrypto: number;\n        amount_crypto: number; // total amount\n        // remainingAmountCrypto: number;\n        checkMs: number;\n        blockTime: number;\n        returnUrl: string; // URL to send the customer back to. may be empty\n\n        successPayImage: string; // image url, animated\n        successPayImageFinal: string; // image url\n    }\n\n    transfer: {\n        token: string;\n        tx_id: string;\n        checkMs: number;\n\n        successPayImage: string;\n        successPayImageFinal: string;\n    }\n\n    bridge: { // only defined before payment is made (1st page)\n        maxAmount: number;\n    }\n\n    // Account page\n    balance: number; // balance in merchant wallet\n\n    // localizations\n    tr: {\n        // TODO can be removed in favor of new Localizer.ts\n        close: string;\n        confirmSignatures: string;\n        confirmSlpTokens: string;\n        confirmWalletBackup: string;\n        withdrawalFailed: string;\n        withdrawalSuccess: string;\n        updating: string;\n    }\n\n    cookieLifeDays: number;\n    cookiePath: string;\n    cookieHost: string;\n    siteUrl: string;\n}\n\nexport type PageType = \"landing\" | \"merchant\" | \"pay\" | \"transfer\" | \"bridge\";\n\nexport class JqueryApp {\n    protected static readonly TEXT_FIELDS = [\"wp-address\", \"private-key\", \"token-id\", \"reward-amount\",\n        \"wc-api-key\", \"wc-api-secret\"];\n\n    public readonly $: JQueryStatic;\n    protected readonly config: AppConfig;\n    protected readonly webHelpers: WebHelpers;\n    protected readonly localizer: Localizer;\n    protected readonly merchant: Merchant;\n    protected readonly pay: Pay;\n    protected readonly transfer: Transfer;\n    protected readonly bridge: Bridge;\n\n    protected readonly pageType: PageType;\n\n    constructor($: JQueryStatic) {\n        this.$ = $;\n        this.config = (window as any).promptCfg || {};\n        if (!this.config.cookieHost)\n            this.config.cookieHost = window.location.host;\n\n        this.webHelpers = new WebHelpers(window as any, this.$, this.config);\n        const lang = this.webHelpers.getCookie(\"lng\");\n        this.localizer = new Localizer(this.webHelpers, lang, `${document.location.origin}/pub/locales/`);\n        this.localizer.loadTranslationsFromObject(\"promptTr\");\n        this.localizer.exportTranslationFunctionToWindow();\n\n        AppMessage.setJquery(this.$);\n        AppMessage.setLocales(this.config.tr);\n\n        // create the class and bind events based on the page we are on\n        this.pageType = this.getPageType();\n        logger.info(\"%s page loading\", this.pageType);\n        switch (this.pageType)\n        {\n            case \"merchant\":\n                this.merchant = new Merchant(this);\n                break;\n            case \"landing\":\n                break;\n            case \"pay\":\n                this.pay = new Pay(this);\n                break;\n            case \"transfer\":\n                this.transfer = new Transfer(this);\n                break;\n            case \"bridge\":\n                this.bridge = new Bridge(this);\n                break;\n            default:\n                misc.assertUnreachableCode(this.pageType);\n        }\n        this.$(() => {\n            this.setupBoostrapFramework();\n        });\n    }\n\n    public getConfig() {\n        return this.config;\n    }\n\n    public getWebHelpers() {\n        return this.webHelpers;\n    }\n\n    public getTr() {\n        return this.localizer;\n    }\n\n    // ################################################################\n    // ###################### PRIVATE FUNCTIONS #######################\n\n    protected getPageType(): PageType {\n        // must be checked before landing-area\n        if (this.$(\"body\").hasClass(\"page-pay\") === true)\n            return \"pay\";\n        else if (this.$(\"body\").hasClass(\"page-transfer\") === true)\n            return \"transfer\";\n        else if (this.$(\"body\").hasClass(\"page-bridge\") === true)\n            return \"bridge\";\n        else if (this.$(\"body\").hasClass(\"landing-area\") === true)\n            return \"landing\";\n        else if (this.$(\"body\").hasClass(\"merchant-area\") === true)\n            return \"merchant\";\n        throw new Error(\"Unknown page type on body: \" + this.$(\"body\").attr(\"class\"));\n    }\n\n    protected setupBoostrapFramework() {\n        const $ = this.$('[data-toggle=\"tooltip\"]') as any;\n        $.tooltip();\n    }\n}\n"],"sourceRoot":""}